So, [COUGH] after the start condition is sent, then you gotta send the address.
So every slave on this bus has an address, a known address.
And the addresses are seven bits long.
There's also another variance to this protocol where addresses can be
ten bits long, but right now let's say seven bits long.
So you got this seven bit long address that's associated with every slave and
every slave knows their own address.
So the master, when it's sending data to a particular slave,
starting a transaction with a particular slave.
It has to send that seven bit long address on the wires, one clock cycle at a time.
On an SDA line, say the address is 0000001.
So it puts that sequence on the SDA line.
One clock cycle at a time, one SCL.
So the first SCL clock, you'll have a zero.
Next one, you'll have a zero, and so on.
It puts them on one at a time.
And then, in addition to the address,
there's one more bit that is a direction, okay?
So all together, the address and direction make up a byte,
that's eight bits all together.
So seven bit address plus a one bit direction.
And the direction is, it's just a single bit, zero or one.
It indicates whether this is a read transaction or a write transaction.
So what happens is, at the point when the address and
the data direction are being sent, the slaves are all listening for the address.
They receive the address bits one at a time.
Then once they receive all seven,
they compare those address bits to their own address.
And if it's a match, then they continue to interact on this transaction.
And if it's not a match, then all the rest of the slaves are aware it's not a match.
They just go to sleep and forget about this transaction and wait until it's over.
Okay, so once you've sent the address and
the direction, then there's a data byte or a set of data bytes that can be sent.
Now, if this is a right transaction,
then you send as many data bytes as you wanna write.
You wanna write ten bytes, you send ten data bytes.
If this is a read transaction, then what happens is the slave has to send bytes
back, as many bytes as are needed to be read.
So there's a sequence of data bytes that happen, and
data bytes keep getting transferred until finally, there's a stop condition.
The message says okay, communication over.
And it sets a stop condition, sends that on the data line, the SDA line.
And the slave recognizes that, and then stops the transmission.