So, Aloha is about as simple as the random access protocols get.
And it's simple and it's really, really easy.
But the problem is that it doesn't really have any sensing going on at all.
So, each of the transmitters, each of the stations, the WiFi stations, are doing
everything blindly. That, that would be like going to a stop
sign and putting a blindfold on and then just randomly deciding when to go, and
when not to go. So, clearly that's not a desirable thing
to do. We will admit, though, that having a car
collision is a lot worse that having a simple, really small data collision that
can just be resent. But still the idea is that, you know, you
really need to quote unquote look both ways before you go into the intersection.
Just like, you really should be sensing to see if anybody else is currently
transmitting so that you don't interfere with them, and then you would expect that
they would do the same as you. So, we need to add sensing into the mix,
really it's the key idea here. And what we mean by carrier sensing is
that you're going to refrain from transmitting if you hear someone.
So, carrier sensing is the term here. And you have to observe a full wait and
listen period before sending. And this is, now we're describing what
called Carrier Sensing Multiple Access or CSMA.
Notice again, now this is the next multiple access method, it's just not a
controlled access method, it's a random access method.
So, we had, we had FDMA, TDMA, CDMA and now we have CSMA not CDMA.
But under carrier sensing we have to refrain from transmitting if you hear
someone and you had to observe a full wait and listen period before you will
send anything. So, here's the idea.
Suppose we have two stations, A and B, okay?
Now, A starts his wait and listen period, right?
And then he has to wait, it's just a prescribed amount of time, it's fixed,
it's just a fixed period. And then, B starts his after A has
already started his. So, A finishes first because they both
have the same wait and listen period. And then A starts to transmit, because it
gets through the period and he doesn't hear anybody else.
Okay? If he had heard someone else, then he
would have had to wait. But then A starts transmitting, and
immediately then B senses that A has just started transmitting and says up, you're
busy, I can't transmit now. And so I have to end.
Whereas B's wait-and-listen period would have ended over here, he didn't get
through the whole thing. So, B won't start to transmit.
And there's the way that we do it. Then A sends his data.
And then some time later, B decides that he wants to send his data.
So, he goes through another wait-and-listen period.
And then he also sends his data, through the network.
But we can draw an analogy here to typical conversations.
Right? So, the idea would be that if you're in a
group of people. Right?
It's common courtesy to wait until someone is done talking before you start
speaking yourself. And you don't immediately start talking
as soon as they stop, you have to wait just, you know, a second or two to make
sure what have they done for you to continue.
And that's just a a typical courtesy [UNKNOWN] conversation, so that's well,
we have going at here. Whereas under an aloha scheme, if you
were, everybody would just randomly being saying random things at different times
and responding to each other and that's very strange, would be a very strange and
rude way of going about. So, this is the more common courtesy,
which leads to better throughput as we will see.
So, now the question is, how do you know that your data actually got there?
So, you have to know if you have to retransmit or not?
And the way that this done is by sending what's called an Acknowledgement frame.
So, when your data gets to the source, right.
If you're a device and you send to the axis point, right.
And you send some frame. If the frame gets there, everything okay.
Then the access point will send back to you, and you will send an
acknowledgement. So, and that's sent upon again, proper
receipt, just to let you know that everything went okay.
And if there's no acknowledgement, you assume that a collision happened and then
you have to retransmit at some point later.
So, let's consider another example here. And now we have five stations, okay.
So, now suppose B is transmitting to D, so B is sending something to D first.
B goes through it's wait and listen period, and he sends some data, okay.
Now, B's transmission gets there because there's no one else interfering with him.
But B doesn't necessarily know that. So, then D a little while later, remember
D also would have to go through a wait and listen period before he transmits
himself because D, even though it's an access point is still a station, so you
have to wait. Then he sends this acknowledgement frame
back to B. And that acknowledgement frame also
doesn't have any collisions or anything. And it could happen that the
acknowledgement frame does collide. Then, after that acknowledgement ends,
both A and C need to send something. So, they both go through a wait and
listen period, and now here's what happens.
Okay. A and C both decide that they want to
send. And they both go through the wait and
listen period. So, they send, and they start sending at
the same exact time. Okay.
And then what happens is, they both sent at the same time.
So, they're both colliding. But they didn't know that they were
trying to send because they just started speaking at the same time.
It'd be like in a conversation. After someone's done, you've probably had
that happen before where then two people will start to speak at the same time.
And then what happens is you have a collision and there is no acknowledgement
that comes back. So, now the question is, what do you do
when you don't get an acknowledgement? So, what happens when there's no
acknowledgement frame back? Well, you need to back off and send
again. And we're going to talk about what back
off means right now.
