Tip:
Highlight text to annotate it
X
Okay, viewers. In this segment, we'll talk about modulation, or how to represent bits
of signals. Okay, so here is the set up. You must know this set up quite well, by
now. We have our computer on the left sending bits to a computer on the right,
across a link. But of course, across the link, we can't send bits, literally. We
send analog signals. So we need to work out some way to represent these bits with
signals. I've said that many times. You must be wondering how exactly we do it.
That's called modulation. And that's the topic of this lecture. Let's dive right
in. Here is a simple modulation scheme. It's the one you that you would think of
first I think if you were just trying to come up with one on your own. We will
simply use a high voltage to represent a one, and a low voltage to represent a
zero. This is a modulation scheme called NRZ,
for Non-Return to Zero The name's for archaic reasons. Don't worry about it. We
can work through an example. You see I have a sequence of bits here. And I'm
going to draw the wave from underneath. So, for zero, we go, we have a low voltage
down here. Nice. Then I'm going to go up to a high voltage for a one, down to a
zero, up, one, one, one, one, zero, one, zero, zero, zero, zero, zero, one, zero.
Whoops, looks like I've got a little bit of noise on there. Must, must be a just a
way away from what it would look. Let me clean it up so you can see it a little
more. There it is. That's one kind of simple modulation. Now there are many
other schemes which are variations on this, which, which can be used in
practice. For instance, we could use more than two levels, two, two signal levels,
to represent bits. If I just look at the, if we group the bits that we sent. two
bits at a time, we could send more different levels. If I go over those bits
I think the sequence was zero, two, three, three, one, from the bits before. If I use
four signal levels it would look something like this. This would be zero, or this
will be well level one, two, three, and four to represent a zero through three.
So I'll start low and I will go up two levels then I will go to the top level,
top level and down to the not quite the lowest level. There we are, that would be
using four levels. The schemes which you used in practice are very much driven by
engineering considerations for how you get this to work. I'm going to talk about one
of those considerations, which is called clock recovery. So for clock recovery,
here's an example of the problem. Imagine that we have this NRZ signal here. Here it
is, a one. And then a zero, a zero, a zero, a zero,
lots of 0's big long run of 0's. If you are the receiver, you see this signal, but
you don't see the bits of course. Your job is to work out what the bits are. So it's
clearly a one and then how many 0's is it? After awhile it gets very difficult for
the receiver to accurately work out the transition points between one zero and the
next. We could imagine that you'd have a very accurate clock. But that turns out to
be expensive. Instead, what you would really like, are frequent transitions in
the signal itself. So that you could help work out the timing of the signal at the
receiver. Now there are several different ways that you might go about this. in your
text you can look at, there is an example of something they called Manchester
coding. That is a coding where there is a transition built into every signal, either
a zero or a one. They all include a transition, a white
form which has a transition. Another approach is something called scrambling.
you could exclusive all your data with a pseudo random signal. Which makes it
highly likely that you'll get transitions. You can look at these designs for fun.
Instead, what I'm going to do is tell you just about one form of modulation that's
used to help with clock recovery. And that's called 4B/5B. Now the idea here is
that we're going to map every four data bits into five code bits, which are then
sent as a signal. And we'll do this in a way where we won't have long runs of 0's
So here are some examples taken from the table. Here's an input of four bits, 0000.
And if we want to send those four data bits, we're instead going to send the five
code bits, 1111 zero. At the receiver, we'll map back from code
bits to data bits, so we'll know what we were talking about. There are sixteen
entries here in the table, they're not shown, they're omitted, but, you know,
just to save space. But you could imagine there's a whole table full. And if we
follow this mapping, you'll find that there are at most three 0's you can get in
a row. So we won't have long runs of 0's anymore. Great. Of course, if you are a,
if you have been thinking ahead, you realize that you can have fairly long runs
of 1's. We haven't done anything to prevent long runs of 1's. So to prevent
that being a problem, we can use a kind of coding where we invert the signal level on
a one, and keep it at the same voltage level for a zero.
This form of encoding is called NRZI where the I is, stands for invert. We invert on
one. And it's also shown in your text. I'll
give you an example. And here, in our example, I've reproduced the table 4B/5B
for a reference, or just some of it. You can see the message bits I want to send.
They start with 1111. Okay, let's look that up in our table. You can see over
here on the left. That should go to 11101. I'll write that in, 11101. Next we have
four 0's. That goes to 1111 and zero. One, one, one, one, zero.
And finally we have zero, zero, zero, one. Which in our table goes to zero, one,
zero, zero, one, zero, one, zero, zero, one.
So those are the bits we actually want to send using an NRZI signal. How do I send
that signal? Since the signal inverts on a one and stays the same as a zero.
I'll show that transition in the middle of a bit time here. So if I just arbitrarily
start at the bottom for a one, then the one will contain an inversion. And then
for the next bit there's a one it's another inversion of the signal I want.
one an inversion. Zero I stay the same. one invert. Invert.
Keep on inverting. Stay the same for zero, zero, invert on the one, zero, zero, zero,
invert on the one. And that is the wave formula that I would
send. I would then be able to see the transitions get enough transitions at the
receive. to find the bit boundaries and you know then go back from my code words
to my data bits and evrything would have been good, i would have sent bits of
information across the link. Oh here is my example for you just cleaned up a little
bit Better. Now, what I told you about, so far, turns out to be what's called
baseband modulation, how you would literally send a signal over a wire.
That's great. You can do that. When we talk about wireless or fiber, though. We
want to send information, not by putting a signal directly in the medium, but by
encoding it on a carrier signal, which is operating at a higher frequency. The
reason for this is that only higher frequencies get a pass roll through the
media or we might want to divide up the medium in terms of frequency bands to
permit multiple people to use it. So we need to work out how to send information
on higher frequencies. it might sound a little tricky, modulating a carrier. It's
not so bad, lets see. Here we can work through an example. So first of all, let
me show, this is just the carrier. The carrier is just a signal which is
oscillating here at some desired frequency. This could be around 2.4
gigahertz for eight or to eleven for instance. Now to modulate it, we can
change it in several ways. We can change the amplitude. That's how far up and down
it is. Maybe I should draw here the amplitude is how far up and down it is.
The frequency is how fast it wiggles. We can have it wiggle Quickly or a little bit
more slowly. And the phase is where it is in it's cycle. We could change the phase
from up down to maybe down up. Would be studying, would be different phases. Let's
see an example. So here is passband modulation. An example of it. At the
beginning I showed you the bassband modulation signal. It's just our old NRZ
signal. I'm tracing over it, just so you can see, but it just goes from zeroes to
ones, and back as it encodes bits. Now, our first passband modulation is going to
modulate the amplitude of the carrier. So you can see here, the carrier is not shown
directly, just the modulation is, and you can imagine there's a carrier going up a
nd down just as before. But its amplitude is being changed. Its amplitude is zero
for some of the initial bits here. And then its amplitude is one when its
oscillating up and down with that amplitude, that magnitude. Alternatively,
here is another kind of Number two a different kind of passbend modulating
frequency shift key you can see now that i oscillate rapidly for a wile this is a one
and i oscillate more slowly for a zero and finally we have phase shift keying. This
signal looks a little more difficult to see. But in essence I'm using a waveform
which starts by going up and then down. Though this would occur more rapidly.
There would be many cycles in each bit time. That will represent a one and the
signal that starts by going down and then later up, so it's had a phase with the
other signal. Will represent a zero. With these schemes, I can now represent
information on carrier signals, which were frequencies of our choice. Real wireless
modulation schemes are considerably more complex than I've shown you in, in these
examples. In fact, you know, you can take a whole communications course to
understand some of this by in, in detail. Nonetheless, what we've covered gives you
the basics of how we send information, bits of information with signals over or
across either wired or wireless links. We'll move on next to error recovery.