So when we went into the lab or at

So when we went into the lab or at least the online lab what we saw
was that there's a trade-off between bit rate and bit error rate.
So in other words, what we did is we tried decreasing the bit time.
And what happens when we decrease the bit time is that the bit rate, which
is just inversely proportional to the bit time,
so it has this hyperbolic relationship, the bit rate goes up.
And of course, that's a good thing, because what we'd like to be able to do
is send information as quickly as possible.
So that implies, then, that we would like the bit time
to be as short as possible, so that the bit rate is as high as possible.
But then what we saw though is that there's
a problem with trying to push the bit time too small.
What we saw was that the bit error rate will also increase.
And the bit error rate is a bad thing, because that means,
essentially, we're making mistakes and we'd
like to make as few mistakes as possible.
So we'll make as few wrong decoding decisions as possible.
And so that means that there's a trade-off, because, on the one hand,
we want the bit time to be small, so that we have a high bit rate.
On the other hand, we don't want it to be too small, because what will happen
is the bit error rate will go up.
And so in many cases, what we do is we set some maximum threshold
on the bit error rate.
And then that would then imply some kind of bit time, which
will then imply certain bit rate.
And so what we'd like to be able to do is
try to understand why there is this increase in the bit error rate
as the bit time goes down.
And hopefully, if we understand that, what we can do
is do something about that.
So let's take a look at this in a very simple situation, where we just
have a single bit.
So in these graphs here, I show you the response
to a single bit, shown in blue, the input waveform, for different bit times.
And then the response of the channel is shown in black, as seen here.
And so for just the single bit for a very long bit time what we observe
is that the response starts to go up when the bit goes up,
finally reaches a value very, very close to its final value,
and then, once the bit ends, we go back down to zero.
As the bit time gets shorter and shorter, it starts to go up.
And then you can see in these two cases here,
it hasn't really reached a value very, very
close to that final value, like it did in these top two cases here.
And so you can see here in this case here it went up only, let's say,
about 80% of the way.
Here, maybe about 60% of the way before it had to start going down.
And so when the bit time gets even shorter
than that, what happens, as you see in these bottom two cases,
is that it starts to go up and almost immediately
it has to start going back down, because the bit is over.
And so you remember what happens when we start
to try to do the decoding, what we normally do is we set a threshold.
And in order for us to decode a one-bit, the response
has to go above that threshold.
And in order to decode a zero-bit, it has to go below that threshold.
And you can see in these two cases, certainly in this case here,
you can see that it has not had enough time to get above that threshold value.
So let's take a look at this, then, in a more complicated situation with a more
realistic bit stream, and see what happens with that.
So here I show you the input bit stream for different bit times.
And the response will be shown in black.
And then the threshold at which we make a decision
whether a one-bit or zero-bit is shown in red over here.
So you can see here, when I have a relatively slow bit time,
and I'm going to sub-sample toward the end of the bit.
You can see that for these slow bit times, indeed, for this one bit here,
it does have enough time to get at least above the threshold.
So if I sampled at the correct location here, what we would get
is we would get a correct decoding.
So in this case here, we would get correct decoding for all of these bits.
And you can see what happens then, as we start decreasing the bit time.
As you start decreasing that bit time, it becomes less time
for the response shown in black to get up and cross that red threshold.
And so we can see here, well, it did have enough time for this bit
time of four samples per bit, it did have enough time
to go up, and then cross the threshold before it
had to start coming down in response to the zero-bit over here.
And so for here, we can see that there are generally no errors introduced.
But then if we further decrease the bit time, what we see is that, in this case
here, they are errors that start to introduce.
In particular, if we look here in this first bit here,
we see that it's supposed to be a one-bit.
And so hopefully, the black curve should go above the red curve,
but it doesn't have enough time to do that.
However, on the other hand, there are many cases
where it does seem to do that.
For example, for all these bits here, it does seem to get high enough
and to get low enough.
But there are so

ผลลัพธ์ (ไทย) 1:

ดังนั้นเมื่อเราไป เข้าห้องแล็บ หรือในห้องปฏิบัติการออนไลน์อย่างน้อยสิ่งที่เราเห็นไม่มีปิดระหว่างอัตราบิตและอัตราผิดพลาดบิตดังนั้นในคำอื่น ๆ สิ่งที่เราทำคือ เราพยายามลดเวลาบิตและเกิดอะไรขึ้นเมื่อเราลดเวลาบิตคือที่อัตราบิต ซึ่งเป็นสัดส่วนเพียง inversely เวลาบิตจึงมีความสัมพันธ์นี้ไฮเพอร์โบลิ อัตราบิตขึ้นไปและแน่นอน ซึ่งเป็นสิ่งที่ดี เพราะสิ่งที่เราต้องการจะทำจะส่งข้อมูลอย่างรวดเร็วดังนั้น ที่หมายถึง จากนั้น เราต้องเวลาบิตจะสั้นที่สุด เพื่อให้อัตราบิตสูงที่สุดแต่แล้ว สิ่งที่เราเห็นก็คือ มีมีปัญหากับการพยายามดันเวลาบิตขนาดเล็กเกินไปสิ่งที่เราเห็นได้ว่า อัตราผิดพลาดบิตจะเพิ่มขึ้นและอัตราผิดพลาดบิตเป็นสิ่งไม่ดี เพราะว่าเรากำลังทำผิด และเราจะเป็นหลักชอบทำผิดพลาดน้อยที่สุดดังนั้น เราจะทำให้ตัดสินใจถอดรหัสไม่ถูกต้องน้อยที่สุดและดังนั้น นั่นหมายถึง ว่า มีการปิด เนื่องจาก มือเราต้องการเวลาบิตมีขนาดเล็ก เพื่อให้เรามีอัตราบิตสูงบนมืออื่น ๆ เราไม่ต้องการให้เล็กเกินไป เนื่องจากจะเกิดอะไรขึ้นอัตราผิดพลาดบิตจะขึ้นไปได้ดังนั้นในหลายกรณี สิ่งที่เราทำคือ เราตั้งค่าขีดจำกัดบางอย่างสูงอัตราผิดพลาดบิตแล้ว ที่จะบ่งบอกถึงชนิดของเวลาบิต บางที่จากนั้นจะแสดงถึงอัตราบิตบางอย่างและสิ่งที่เราต้องการจะทำเป็นพยายามที่จะเข้าใจเหตุผลที่มีการเพิ่มขึ้นของอัตราผิดพลาดบิตเป็นบิต เวลาไปลงหวังว่า ถ้าเราเข้าใจว่า เราสามารถทำจะทำอะไรที่ดังนั้นลองมาดูที่นี้ในสถานการณ์ที่ง่ายมาก ที่เราเพิ่งมีนิดเดียวดังนั้น ในกราฟเหล่านี้ ฉันแสดงการตอบสนองการบิตเดียว แสดงเป็นสีน้ำเงิน รูปคลื่นสัญญาณ เวลาบิตที่แตกต่างกันแล้ว การตอบสนองของช่องจะแสดงในสีดำ เห็นนี่และเพื่อให้เพียงบิตเดียวสำหรับความยาวบิตเวลาสิ่งที่เราสังเกตเป็นการตอบสนองเริ่มขึ้นไปเมื่อบิตจน ถึงค่ามาก อยู่ใกล้กับค่าสุดท้ายเมื่อบิตสิ้นสุดลง เราไปและกลับลงไปที่ศูนย์เป็นเวลาบิตได้รับการสั้นลง และสั้นลง มันเริ่มต้นขึ้นไปแล้ว คุณสามารถดูในสองกรณีที่นี่จริง ๆ มันยังไม่ถึงค่ามาก มากใกล้ค่าสุดท้าย คุณได้ในด้านบนสองกรณีนี่และเพื่อให้คุณสามารถดูที่นี่ ในกรณีนี้นี่มันก็ขึ้นเท่านั้น กล่าว คือประมาณ 80% ของทางการนี่ อาจจะประมาณ 60% ของวิธีการก่อนที่จะมีการเริ่มต้นลงไปและเมื่อเวลาบิตเร็วกว่านั้นกว่า สิ่งที่เกิดขึ้น คุณดูในกรณีเหล่านี้สองล่างคือ ว่า มันเริ่มขึ้น และเกือบจะในทันทีมันมีการเริ่มต้นกลับไปลง เนื่องจากบิตผ่านและเพื่อ ให้คุณจดจำสิ่งที่เกิดขึ้นเมื่อเราเริ่มพยายามที่จะทำการถอดรหัส สิ่งที่เราทำปกติได้เราตั้งเกณฑ์การและเพื่อที่เราจะถอดรหัสแบบหนึ่งบิต การตอบสนองขึ้นไปที่สูงกว่าเกณฑ์ที่และการถอดรหัสศูนย์บิต มีไปต่ำกว่าเกณฑ์ที่และคุณสามารถดูในสองกรณี แน่นอนในกรณีนี้นี่คุณสามารถดูว่า มันไม่มีเวลาพอที่จะได้รับข้างต้นค่าขีดจำกัดดังนั้นลองมาดู ที่นี้ จาก นั้น ในสถานการณ์ที่ซับซ้อนมากขึ้นด้วยมากขึ้นกระแสข้อมูลบิตจริง และดูสิ่งที่เกิดกับที่ดังนั้นที่นี่ฉันแสดงคุณกระแสข้อมูลบิตป้อนข้อมูลบิตต่าง ๆ ครั้งและการตอบสนองที่จะแสดงในสีดำแล้วเกณฑ์ในการตัดสินใจเราว่าหนึ่งบิตหรือบิตศูนย์เป็นสีแดงมากกว่าที่นี่เพื่อให้คุณสามารถดูที่นี่ มีเวลาค่อนข้างช้าบิตและจะย่อยตัวอย่างจุดสิ้นสุดของบิตคุณสามารถดูที่ครั้งนี้บิตช้า แน่นอน นี้หนึ่งบิตที่นี่มันมีเวลาพอที่จะได้รับน้อยเหนือขีดจำกัดดังนั้น ถ้าฉันเก็บตัวอย่างในตำแหน่งที่ถูกต้อง อะไรเราจะได้รับคือ เราจะได้รับการถอดรหัสที่ถูกต้องดังนั้น ในกรณีนี้นี่ เราจะได้รับถูกต้องถอดรหัสของบิตเหล่านี้ทั้งหมดและคุณสามารถดูสิ่งที่เกิดขึ้นแล้ว เราเริ่มลดเวลาบิตเมื่อคุณเริ่มลดเวลาบิต มันกลายเป็นเวลาน้อยกว่าสำหรับการตอบสนองแสดงในสีดำจะได้รับค่า และเกณฑ์ที่แดงและเพื่อให้ เราสามารถดูที่นี่ ดี ไม่มีเวลาเพียงพอสำหรับบิตนี้เวลาของตัวอย่างที่สี่ต่อบิต ไม่มีเวลาเพียงพอไปขึ้น และข้ามเขตแดนก่อนมีการเริ่มต้นลงมาที่ศูนย์บิตมากกว่าที่นี่และสำหรับที่นี่ เราสามารถเห็นว่า มีโดยทั่วไป แนะนำข้อผิดพลาดแต่แล้ว ถ้าเราลดเวลาบิตเพิ่มเติม สิ่งที่เราเห็นนั้น ในกรณีนี้ที่นี่ พวกเขามีข้อผิดพลาดที่แนะนำโดยเฉพาะอย่างยิ่ง ถ้าเราดูในนี้ก่อน บิตที่นี่เราเห็นว่า มันควรจะเป็นหนึ่งบิตเพื่อหวังว่า เส้นโค้งสีดำควรไปเหนือเส้นโค้งสีแดงแต่ไม่มีเวลาพอที่จะทำได้อย่างไรก็ตาม ในทางกลับกัน มีหลายกรณีที่มันดูเหมือนจะทำได้เช่น สำหรับทั้งหมดเหล่านี้บิตที่นี่ มันดูเหมือนจะสูงพอและ จะได้รับต่ำพอแต่ไม่มีให้