Serial Email Signature Routing Made Easy

Serial email signature routing

[Music] hi there my name is alexander rousell and we're starting today with the first week of the serial buses hackaday u course we're going to be learning about i squared c in this the first part we're going to be covering both the hardware and protocol layers of i squared c in this first lesson we're going to go through things quite thoroughly the prerequisites as we posted were some understanding of programming microcontrollers experience with arduino is good basic understanding of circuit elements but as long as you have sort of a general idea of how chips work and if you have any experience programming you should be okay my email address is there on screen am rousal at frozenelectronics.ca uh so welcome to week one super excited to be teaching this course this is gonna be a lot of fun so the goal of this course is to familiarize you with i squared c and one wire uh in two separate parts which are two very popular serial buses from microcontroller communication we're going to be starting with i squared c at the hardware and protocol level and next week will be i squared c at the software level we'll be taking a look at software examples in c c plus plus with an msp430 microcontroller there is an easter egg in this presentation yes the first person to find it and send it to my email address which was on the first slide will get a 10 tindy gift certificate which is really cool this only applies to the first running of this course which is the week of september 2nd to the 9th if you're watching this right after it's come out and you're the first one to find the easter egg and email to me then you will get that 10 tindy gift certificate which is really cool a big thanks to tindy for helping support this course so a little bit about me i'm a canadian hacker i specialize in designing and prototyping building testing debugging embedded systems embedded is what i do it's what i am good at and what i love doing i have a lot of years of experience with i squared cn1 wire i squared c in particular i've done a lot of work with i'm a writer and contributor on the side for hackaday.io the tindy blog supply frame hardware blog and also other websites over the years i've done a lot of writing and contributing to various websites um i spend way too much time drooling over expensive logic analyzers eventually i'd like to get that uh tektronix mso is it the mso5 or the 8 series where you can have 64 logic channels at once in real time it's just they're so cool so let's jump into it what is i squared c well i2c or i squared c short for inter integrated circuit bus is a specification for an electrical connection which transmits serial data between any integrated circuits uh it can be any arbitrary data at all with any arbitrary length of data and it's usually between a microprocessor microcontroller and various peripherals and sensors although that's not a rule it can be between two microcontrollers or it could even be in some cases between two different sensors data is sent in a packetized format meaning that each chunk of data is sent in a specific order and with a delineator of the start and the end of the packet which we'll get into where did it come from this is a really good question it was developed by phillips who are now owned by nxp they started developing it in the late 70s and early 80s originally called cbus for use in creating simple control system with their family of integrated circuits it was supposed to be very simple to implement if you're a chip designer and you want to add a serial bus to your chip the idea was that it was going to take up less room on an integrated circuit than competing serial buses like uart or there's many other choices at the time it was supposed to be very easy and specifically designed for communication between different portions of a circuit it's not really intended for communications between two different boards or over long distances it's really um ideal for communicating from one part of a circuit board to another or between various chips by the early 90s i squared c had become quite popular and there was a lot of other manufacturers that had started creating circuits compatible with the i squared c specification if you wanted to create them you had to pay a license fee to phillips to use the i squared z logo and implement the standard using their official names like sda and scl a lot of companies avoided this by calling it two wire or twi atmel in particular you might know on the app mega chips for a long time it was called twi that was to avoid paying these licensing fees to phillips in 2006 phillips which had then been bought by nxp made it a semi-open standard so you no longer require a license fee to be paid to implement i squared c on a chip or to use the official names and all the you know stuff from the specification you still do require license fee if you want to reserve an address in the i squared c address space so if you're making a new chip that is unique from other types of chips and you want a whole brand new address for it you do have to pay a fee for that and i'm just an aside here we won't be covering sm bus much at all but just so you know that intel in 1995 they made an addition to the i squared c standard called sm bus for use in personal computers the differences are that it's much more stringent when it comes to timing and and keeping things um free of interference as much as possible on a pc motherboard there can be a lot of high-speed switching going on you've got at that time isa and pci now you've got pci express you've got ethernet there's all sorts of stuff going on they wanted a simple bus to communicate between the processor and temperature sensors and basic eproms that sort of thing but they wanted it to be a bit more stringent so that it could withstand the conditions on a motherboard and be standardized specifically for use on motherboards but we won't be covering sm bus it's not that different from i squared c most chips that support i squared c will support sm bus so we come to the why well we talked about how it's simple to implement but there are a lot of alternatives to i squared c uh now we've got a whole ton of serial buses that are commonly available on microcontrollers can which is often used in automotive uh stuff you get about a megahertz spi which we'll be covering in part two of this course uh potentially up to 100 megahertz so a lot more speed a lot more data throughput usb you can even step up to that 480 megahertz for usb 2.0 now we've got usb 3.1 gen 2 at 10 gigabits per second so you can stuff a lot of data over a serial bus uart which was competitive at the time when it was developed you can get you know easily up to 10 megabyte nowadays one wire ethernet bluetooth there's lots of different options but none of these really at the time because spi wasn't really implemented then none of these address the ease of use and the low cost of implementation as well as the low external cost a lot of these for example usb ethernet bluetooth you often need an external piece of hardware to the microcontroller for usb and ethernet you have what's called a phi which is essentially it contains the drivers and the low level logic for that serial standard those chips add cost to your bomb and if you're doing short range communications between chips it's not worth spending the money on that sort of thing when you can have a very simple fi integrated into the chip and all you need externally are a couple of resistors as we'll see so what makes i squared c a good choice well as i said the ease of use and cost doesn't require external transceivers and it's integrated into almost all microcontrollers there's lots of software libraries that are freely available to use either full software implementations of i squared c or library specific to the chip that will take advantage of the hardware i squared c that's built into it the only external components that you need are a couple of resistors less than a cent in your bond cost and if you're buying resistors by you know huge reels of 10 000 at a time often way less than even that it's a simple protocol you can learn very quickly by taking a course like this so let's dive into i squared c at the hardware level there's only three things that are actually connected to the bus we have a controller a device which is currently in control of the bus it controls the clock line and therefore controls the speed at which data is sent and received you have peripherals a device which cannot control the bus directly has to be told to control the bus by the controller it's typically a sensor something that only responds to commands but doesn't actually control the bus directly and then we have that pair of pull-up resistors which keep both of the s both of the i squared c lines in their high idle state i just want to go over a very brief aside here the i squared c specification and in the industry for many many years they've been using terms that are now recognized to be problematic uh i squared c specification uses the term master for controller and slave for peripherals in this course and on hackaday.i o and many other places we're just going to use controller and peripheral partially in response to the fact that they're problematic but also to demonstrate how easy and seamless the change is and that it's not a big deal so hopefully no one will be upset by that if you are times move on and these are the terms we're going to be using in this course so if you need to refer to the specification just remember which one pertains to which and just replace the words it's that simple so the two lines that are key to i squared c as i mentioned are called sda and scl scl serial clock used to synchronize each bit because i squared t is a synchronous protocol it has to have a clock that lines up with each data bit to clock it in and sda serial data which is driven low or release high to send the actual bits of data that are being communicated back and forth this is a very quick look at what an average trace looks like from an i squared c bus you don't need to worry about the decoded logic i just want you to see that the top trace has just a clock line it's just going up and down up and down up and down and the bottom trace is going up and down and it represents the actual bits that are being sent top trace scl bottom trace sda how are they built now this is where the prerequisite of having a basic understanding of circuit symbols is good but we'll go over this in detail so on the bus we have the two pull-up resistors these whenever nothing is happening on the bus they return the bus to its state of idle which is vcc it could be 3.3 volts it could be 5 volts it could be 1.8 volts it doesn't matter as long as it's agreed upon between the chips and all the chips will work with that voltage level most commonly you'll see 3.3 and 5 volts we have a buffer which is connected to each line internally inside the chip this is how it samples what's actually happening on the bus this is how it listens to what's going on and then we have fets which are transistors which can turn on and off these are called open drain or open collector because they are connected directly to ground and to the line itself when you turn them on they essentially become a short circuit and because we've got a high resistance to vcc it pulls it to ground now this is a really key point with i squared c the only thing a device can do is pull the bus to ground it can't drive the bus high it relies on the external pull-ups for that this has some trade-offs but it makes some things very simple such as bus arbitration which we'll get into later uh we also have uh there's just some boxes to show on the left-hand side we have a controller on the right-hand side we have a peripheral you'll notice that the peripheral only has effect on the data line it doesn't have a fet on the clock line that's because as i mentioned the controller controls the clock line and therefore it sort of is in control of how quickly data is sent and when things happen on the bus there's also equivalent capacitance on the bus now we're going to just touch on this briefly if you know your ohm's law and you've dealt with capacitors at all you'll know that equivalent capacitance on things like serial buses is a bad thing capacitors resist change in voltage but changes in voltage is how we are signaling and communicating so we don't want capacitance so things that are important to remember as i said the bus can only be pulled to ground they rely on the external resistors to pull them back up to their idle state the value of the pull-up resistors can affect the maximum transmission speed especially in systems that have many devices attached to the bus because we can only pull the ground yeah as i said this has some benefits that make bus arbitration and acknowledge sequences much easier so this is why pull-ups matter remember our rc circuit basics the length of time it takes to charge a capacitor is directly proportional to the size of the resistor times the size of the capacitor in ohms and ferrets if we have too much resistance or too much capacitance it can make the charge time so long that the voltage is unable to get back to the idle state making communication intermittent or in many cases completely impossible so let's take a quick look at what this looks like in practice with some exaggerated examples that help illustrate what can go wrong so we're going to be looking at some circuit simulation software don't worry about all the different symbols you see we'll go over the important ones so this is our first example where our bus has too much resistance we've used pull-up resistors of one mega ohm which is a lot of resistance and the equivalent capacitance on the bus is quite high as well at one nano farad over on the left hand side we have a voltage source which is our bus at 5 volts and over on the right hand side we have that fet that we saw inside the devices earlier and that's going to be turning on and off to simulate the data or clock line being sent so in this case with one mega ohm of resistance and one nano farad of capacitance there's the resistor there's the capacitor we get this this is a very typical signature you'll see on an oscilloscope we call it shark finning because it looks like a shark's fin we're starting up at five volts but when we turn the transistor on we get all the way down to zero volts but then we only get back up to just over three volts you can see the charge time has that very characteristic curve to it we want to avoid this because this will make will have to slow down communication make those pulses further and further apart so the bus has time to return to its idle state obviously we don't want that so the solution is to increase the resistance or sorry decrease the amount of resistance pardon me or decrease the amount of capacitance sometimes we can't decrease the amount of capacitance so the easiest thing to do is to lower the resistor so this is an example where it's just right we have our sort of average value of 4.7 k very common pull up resistor size for i squared c now we've got our nice clean 5 volts when we let go of the line it snaps back up to 5 volts very quickly we've got nice clean transitions this will work great so speaking about speed we have various speed options on the i squared c bus we've got the standard speed of 100 kilohertz later on there was a 400 kilohertz mode that was introduced called fast mode later a fast mode plus 1 megahertz high speed mode 3.4 megahertz and then there's a new addition to the standard called ultra fast mode uh that runs at five megahertz and it uses a traditional push-pull type of serial bus so it doesn't use pull-up resistors it's a completely different thing it's not very common at all yet so we won't really be touching on it most of the time you're going to see 100 or 400 kilohertz most microcontrollers do support fast mode plus in high speed mode but most chips typically support 400 kilohertz or fast mode plus one megahertz as their top speed r squared c is not really the best if you need to move huge amounts of data really fast it's really meant for communicating small amounts of data to in between various chips on a circuit board as i said yeah it uses a traditional push-pull architecture like spi hasn't found mainstream usage yet so here's a typical i square c bus we've got a microcontroller that has sdn scl lines connected to some pull-up resistors which are then connected to a bunch of different things on the bus we've got all sorts of options when it comes to i squared c temperature sensors accelerometers we've got eeproms barometric pressure sensors so we can connect as many devices as we want in parallel they're all connected to the same sd8 scl and the only limit on this as we talked about earlier is the amount of capacitance each one of these devices that we add to the bus will increase the amount of capacitance and eventually we'll hit a limit you might have to lower the amount of resistance in the pull-up resistors or you might run into a hard limit but it's fairly uncommon most buses only have a few devices on them and you don't need to worry about it so it's time to look at i squared c at the protocol level timing is everything like with any synchronous protocol everything is timed against a clock i squared c packets are formed from events that happen on the bus like any packetized serial format every packet starts and ends with a specific event in the case of i squared c these are called start and stop conditions they're quite simple how can a peripheral tell a start or stop condition apart from just data well here's the hard and fast rule the only time the data line sda can change when the clock line is high is during start or stop conditions so if the clock line is high and the deadline transitions it is either a start or a stop condition there's no other situation in which that happens so during regular transmissions the controller peripheral must wait until the clock line is low before changing the data line if you're just sending a regular byte of data you have to make sure the clock line is low before you change the data line otherwise you'll be sending a start or a stop condition let's look at what these actually look like here's our start condition marks the beginning of an i squared c transaction the bus starts idle so both sda and scl are pulled high by the pull-up resistors to 5 volts or whatever it may be the data line goes low first followed shortly by the clock line the reason that it's a start condition again is because we see the data line goes low first it changes while the clock line is still high this is what it looks like on the bus over at the left hand side you can see clock is on top and data is on the bottom the data line transitions low while the clock line is still high then some amount of time later the clock line goes low and that signals a start condition so now we're ready to start sending data well what's a stop condition it's essentially the inverse it's a mirror image it marks the end of an i squared c transaction so it's an exact mirror image the bus must be active both sda and scl are in their low state so zero volts the clock goes high first followed by data afterwards of course the clock has to go high first to signal a stop condition because the only way we can signal these conditions is by changing the data line while the clock line is high this is what it looks like on the bus we start with both lines low clock line goes high and sometime later the data line goes high this signals a stop condition now the bus is free to be used by other controllers if there are any um or sometimes this will signal to the chip to start executing whatever command we just gave it there's also a variation of the start condition called a repeated start this is when we send another start condition instead of a stop condition this leads into bus arbitration it's a repeated start and it's when we want to immediately start a new transaction without letting go of the bus and potentially having another chip step in and start communicating this is really important if for example you've just written a value to a chip it's done something and you want to read the result out because it's time sensitive you can't wait you know however long it's going to take for another chip to do some sort of communication so you can do a repeated start it's also commonly used when you're when you finish writing data and now you want to read data back from a peripheral for example we might send the register of the data we want to read then we'd send a repeated start and then read the data out instead of doing a stop condition and then another start condition this leads us into bus arbitration this is one of the lesser known parts of i squared c and it's not something you see terribly commonly unless you have more than one controller on a bus i squared c does support this but it's not something you'll see commonly usually you have a single microcontroller and multiple peripherals but i squared c is capable of either so why can't it just start reading and writing data to a peripheral because there might be another controller on the bus whenever any communications protocol has more than one controller they must have a way to talk to each other and decide who gets to talk when because we can't all talk at the same time or else the bus turns into a mess because i squared c devices can only pull the bus to ground arbitration actually becomes automatic it's something that you don't need to program in to your software because it's taken care of by the hardware here's an example one controller sends a start condition at the exact same time as another controller unlikely but it might happen they both then start to send data on the bus every time the controller changes the state of the bus sets it to a one or a zero it then needs to look at the bus and check that it's actually in the state that it was set to so for example if you're trying to send a one you need to release the bus line and the pull-up resistors will pull it back up to five volts but if you've done that and you look at the bus and the bus is still low that must mean another controller is talking so we need to stop sending data and wait until we see a stop condition it's non-destructive as well because we haven't stepped on what the other controller is sending we released the bus but nothing happened so it didn't change what the other controller was sending and the controller that won arbitration doesn't even know what happened it never even knew another controller was trying to talk which is one of the great things about i squared c bus arbitration here's a very simplified diagram often bus arbitration would happen on the very first bit or two but i've sort of extended this out to show what happens two controllers are sending data at the same time one of them goes to send a one at the same time the other one is sending a zero and the losing controller looks and sees uh oh i wanted there to be a one here but there's a zero that must mean that another controller is talking so i need to stop sending data and wait until i see a stop condition before talking again so this leads us into again the two roles we can have on the bus one device is sending data and the other device is listening these roles can change during the course of a transaction the controller is not always the one talking peripheral's not always the one listening because of course we can read data from a peripheral or we can write data to a peripheral no matter who is talking or listening though as we mentioned earlier the controller is in control of the clock line therefore the speed of the transaction and transitioning between them is simply done by letting go of the sda line if you want the other side to talk you tell them you know you signal command then you let go and you let them take over controlling the sda line but during that time the controller is still sending clock pulses so now that we've mastered starts off by arbitration we'll look at how it's actually sent every bit is accompanied by a clock pulse a transition from low to high on the clock line indicates that whatever is currently on the data line is the bit that we're trying to send it makes it's basically saying this bit is valid right now so read what's on the line and that's the bit that we're trying to send after the clock line goes low the device currently sending the data changes the data line to the state of the next bit so again we have to wait until the clock line goes low to change the data line otherwise it would be interpreted as a start or stop condition data is always sent one byte at a time bit by bit and bytes are always eight bits long now this doesn't mean that we can't send 16 or 32 or 64-bit values we just have to always send them in multiples of eight this is because i squared c was developed in the 80s when everything was 8-bit but because it's an arbitrary length format we can send however much data we want so if we actually decode what's going on every transaction is initiated by the controller sending a start condition peripherals can't control the bus once they're requested to do so the controller must send an address with every transaction and that address identifies the exact peripheral it wants to communicate with if we've got five or six devices on the box we have to have a way to tell them apart and they have to know which device is being talked to by the controller or else they're all going to start responding so that's why we have addresses and at the end of every byte they also acknowledge what's just happened there's what's called the acknowledge bit it actually looks like a ninth bit being sent but it's uh whatever device is currently receiving data so whoever's listening at the time they send the acknowledge bit to say whatever you've just sent me is valid and i understand it so we'll look at the acknowledge or not acknowledge as it may be in a bit more depth when a controller starts a transaction and sends an address out to one of these devices the peripheral if there's a peripheral there that has that address it will respond to that address with the acknowledge bit this is done by the controller briefly letting go of the data line and if you let go of the data line and there was no device there it would return to its idle state so if there is a device there it holds the data line low while the controller sends another clock pulse and this is how it says hey i'm here i'm acknowledging the address if it doesn't match any peripheral or the data set is incorrect and not acknowledge is sent this is actually the default state because the bus is pulled high by resistors if no one does anything to send an acknowledge bit the default is not acknowledged um yeah the natural state is being pulled high so let's actually look at how this all sort of goes together we have at the beginning like we established we have a start so we start with the star condition in this trace again the clock line is on top the data line is on the bottom then while the clock line is low we set up the first bit you can see it goes high there then the first time that the clock line on the top goes from low to high that's a clocking in the first bit which is in this case a one then the peripheral or whoever is talking at this point waits for the clock line to go low and then it sets the data line low it might look like that's happening at the same time there on that very first clock pulse but if you zoom in really close there's actually a delay between the clock line going low and then the state of the data line changing and then the rest of the bits are all zeros including the acknowledge bit at the end there so each bit is set as what we just pointed out and then after the falling edge the next bit is set up so on the byte below is hexadecimal 80 or one with seven zeros in binary uh don't worry about the actual d code below we'll get to that later but at the end as we said we send eight bits as you can see you can count them there's eight clock pulses and then there's that ninth bit below it there you can see in pink it says ack because the bus remained low during that last clock pulse that means whatever device was listening to this data acknowledged it and said yes this is valid so let's take a closer look at how addressing happens that's actually what we just looked at there was an address being sent addresses are 7-bit values they're unique to each type of device and ice philips and nxp have tried to sort of keep all similar devices using similar addresses so temperature sensors might have a specific address that they typically use ebroms have a different address barometric pressure sensors have a different address and because there's seven bit values that leaves an extra bit on the end to make an eight bit value this bit is actually um how we determine what's happening if it's a reader or right so yeah we reserve those addresses by paying a fee to nxp if you were a chip designer creating a new peripheral you'd have to pay a fee for one of these addresses as i said the address is also how the peripheral knows if this upcoming transaction is going to be a read or a write the seven bit address is followed by an eighth bit which is low if the following transaction is a right or high if it's a read this is referred to as the read write bit now because we're adding a bit to the end effectively what we're doing is we're taking that seven bit address we're shifting it to the left by one place and then we're adding that zero or one on the end to tell the peripheral either we're writing data to the peripheral or we're trying to read data from it so here's some examples the sht21 temperature and humidity sensor which is actually the sensor we'll be using in our examples in part two week two the address is 40 hexadecimal and the seven bit uh it's sort of native uh address but if we actually want to talk to it we have to shift it to the left by one so it becomes an 80 if we want to write to the device because that last bit is a zero or if we want to read something from it we add a 1 and it becomes 81. so if you sort of know your basic binary and hexadecimal if you shift everything over to the left by one then it changes the value and we basically we do a logical or i won't get into the details we'll get into that in the software implementation but we change the last bit to tell it what we want to do now here's a stumbling block is that a lot of data sheets will use either of these forms some companies will always display things as the 7-bit address and then they'll specify if you need to add the reader right bit others will show the right address like for example the data sheet might show hexadecimal 80 as the address so you have to read carefully and ask are they giving me the 8-bit address or the 7-bit address most of the time the data sheets make it clear just don't assume that it's one or the other so we'll take another look here that same transaction we looked at earlier the software the logic analyzer that i had hooked up to this the software has actually decoded this for us so that byte 0x80 and hexadecimal is actually a right to address 40. so you can see at the bottom there it's decoded it to address right 40. the read write bit is a zero and then we have an acknowledge at the end so even though the byte being sent is hexadecimal 80 the logic analyzer is showing us that this is a write to 7-bit address 40. i know it's a little bit confusing to have these eight and seven-bit addresses floating around but you get used to it very quickly when you're working with these devices at the end we pull the act bit low meaning the device has responded to this address and it's ready for the transaction which in this case would be a write so if we take a summary of everything we've looked at so far the controller starts any transaction with a start condition and then sends the address with the last bit high or low depending on whether it's a read or a write the device either acknowledges it by pulling the data line low during the ack bit or if there's no device there the default state is for the lines to be in the high state and therefore it would be not acknowledged which is one of the nice things about having pull up resistors and having the idle state being high if nothing responds then it's very easy to tell that because the line will be high controller will then continue depending on the status of that acknowledged bit it'll either keep going or if it got a not acknowledged it'll handle that error so let's actually look at some examples for writing and reading data only the controller is able to change the state of the clock line so it's always controlling the timing this is very key and can be sort of confusing when you're reading data from a peripheral you need to provide the clot pulses to it it doesn't control the clock line so when the controller is the one putting data on the bus it is simultaneously setting both the clock and data lines but when the controller is reading data it just sends out clock pulses and whatever it sees coming back on the data line is the data that's being sent back from the peripheral when the controller is writing the peripheral is the one that's sending an acknowledge because in that case the peripheral is the one listening whichever device is listening is the one that sends the acknowledge of course that makes sense whatever devices is listening is the one that needs to say hey yes i heard what you said and then vice versa when the controller is reading it sends acknowledge or not acknowledge bits so it sends out clock pulses gets data back at the end of every byte the peripheral is expecting the controller to send and acknowledge saying yes i want to read more bytes from you or not acknowledged saying i'm either done reading bytes from you or there is something wrong with what you sent um uh yeah they'll send a knack when they're finished reading data peripherals will send a knack if there's been some sort of error so let's look at a practical example a microcontroller is connected to an eprom via an i squared c bus which is what we've been looking at it wants to read 10 bytes from address 1 0 f4 inside the eeprom if you know anything about how memory is organized it's just a whole bunch of 8-bit bytes in this case each one has a unique address so we want to read whatever 10 bytes start at 1 0 f4 don't confuse the address inside the eeprom uh like the memory address we want to read from don't confuse that with the device address which is always seven bits or eight bits the eeprom's i squared c device address is 50 which is actually one of the standard addresses for eproms that's the seven bit value so the transaction will take place in two parts because we want to read so if we want to read something we first have to write to the peripheral to tell it what we want to do microcontroller will send a start condition with the right address which is a zero that's hexadecimal five zero shifted to the left by one bit and then the last bit is set to a zero because this is the write and then after it sends that address the device address of a0 it then sends the memory address that it wants to read from in this case 1 0 f4 then it will send a repeated start because we don't want another controller on the bus potentially butting in right after we've told the memory we want to read from this address if we were to send a stop it's possible that another controller might connect to that same device and change what address is being looked at we want to make sure that doesn't happen so we send a repeated start followed by the read address which is just the right address but the last bit is a one so in this case it's a one in hexadecimal the controller will then send clock pulses and the eeprom will send a bit for every clock pulse that the controller generates at the end of each byte the controller will send an ack until the final byte when it will send a knack and in this case we want to read 10 bytes so it'll send an acknowledge and it'll count up until it gets to the 10th byte then it'll set and not acknowledge let's actually take a look at this in pulse view so this is actually the software that i used to probe this exact example transaction i set up a microcontroller and an eeprom and i actually did exactly what we just discussed in that last slide so if we zoom in here over on the left you can see the bottom traces data top traces clock we have a start condition both lines are high data line goes low then the clock line goes low the software has decoded that for us and shows us that's start then we send the first byte which is an address and it's a write to address 50. so as you can see it's actually 1 0 1 0 which is a a0 as we determine is the 8-bit address if we're writing and we get an acknowledge back because during this ninth clock pulse right around here the controller would let go of the bus and then the peripheral will hold the bus low while this final clock pulse is sent out then it will release it again as soon as it sees the falling edge of that clock pulse and that's when the bus goes high there for a moment then the next two bytes that we write are the address that we want to read data from inside the eprom so as you can see one zero f4 is what's actually being written then because now we want to switch to reading data we have to send a repeated start condition we could as i said in theory we could send a stop condition followed by another start condition but then we're risking another controller potentially taking control of the bus from us which is something we want to avoid so we send another start condition again it's the exact same as the usual start we start with both lines high the data line goes low first then the clock line then we're sending an address read from address 50. so again we have a1 as the address you can see it actually separates out the read write bit for us in this software which is really nice so this is actually byte a1 but the software has decoded it for us into a read from address 50 we get an acknowledge because we know the eprom is at that address then we start reading bytes from it we read the first byte and then at the end of that byte you know during this section now as soon as we as soon as um the device acknowledges that read address the controller then lets go of the data line and now the peripheral is controlling the data line the controller keeps sending out clock pulses and that's how the peripheral synchronizes this but from then on out the peripheral is controlling the data line so it sends out the first byte which in this case happens to be hexadecimal 48 then at the end it lets go of the data line and the controller then sends the acknowledged pulse because now the controller is the one listening so it lets go the controller keeps the data line low through that ninth clock pulse and that's an acknowledge and that's us saying we want to read another byte it keeps doing this one two three four five six seven eight nine times then we get to the final byte this final byte same thing happens we read it out but at the end the controller just lets the line return to its idle state it sends another clock pulse and the device now you know it's not acknowledged so the device stops sending data and we're done with this transaction so we send a stop condition which again we start with both lines low we set the clock line high then we set the data line high and that's the stop condition as you can see it's been decoded as for us it's decoded it for us there as a p for the stop condition so that's a full transaction reading 10 bytes from an eeprom when you look at it piece by piece it's actually quite a simple protocol as you can see we write an address depending on the type of device it'll change what we're actually writing to the device but we write whatever we want we send a repeated start or sometimes a stop and then another start and then we read from that same address and it sends us whatever data in this case it's data from an eeprom it could be temperature sensor data it could be barometric pressure data it could be anything and when you have multiple devices on the bus all you have to do is change what address that you're reading and writing from and you're talking to a completely different device again i want to point out that the clock pulses here as you can see are very regular if we actually zoom in and we use the cursors to take a measurement from this end of one clock pulse to this end of the next one you can see we're running at about 100 kilohertz 102.5 kilohertz so this is running at uh the lowest i squared c speed but that's perfectly fine uh you know it's not super fast we end up reading 10 bytes in oh you know about just over a millisecond 1.3 milliseconds it might be too slow for some applications so you can either increase the speed if the device supports it or you might need to choose a different serial bus this is just an example so whenever you're working with i squared c having a logic analyzer and having software like this makes it really easy to visualize what's going on on the bus and it makes it really easy to make changes uh and you can see the changes that you've made being reflected in whatever is being sampled on the bus by the logic analyzer so let's go back over to the slides and finish up our presentation all right so we took a look at pulseview now let's sort of summarize everything that we've gone over i squared c transactions are made up of sequences of events on the bus start condition is how we start everything followed by the address of the device that we want to talk to and it's a read or write bit depending on what kind of transaction it is then we send the data to be read or written depending on what direction it is there's an acknowledge or not acknowledge for each byte sent by whichever side is currently listening at the end we have a stop condition or a repeated start in some cases bus arbitration is automatic and non-destructive because of the fact that we use pull-up resistors that takes care of bus arbitration for us essentially as long as every device always looks at the bus after it's changed it to make sure that it's in the state that it expects it to be and if it's not in the state that it expects it to be it has to stop and wait for a stop condition to appear on the bus before it can try communicating again most of the time if you're not doing serious embedded device work where you have multiple controllers on the same bus and tons of peripherals you're very rarely going to have to deal with bus arbitration in the majority of systems it's going to be a single microcontroller talking to a variety of sensors or memories or something but again it's good to understand how it works and this same benefit from pull-up resistors as apparent in the acknowledge not acknowledge by default and not acknowledge will always be sent the chip actually has to intervene pull the bus low to say that it is acknowledging which is important because that makes it sort of by default error proof if something goes wrong you're always going to get a not acknowledged back you don't have to worry about accidentally getting something on the bus that you don't expect because the idle state is forced by those pull-up resistors which can't do anything but pull the bus high there's no active device that pulls it high which is really interesting so either device can be talking or listening as we said either side might be sending data but the controller is always in control the clock line so as we just saw in pulseview even when we were reading bytes from the eeprom the controller was actually the one still generating those clock pulses and then it was just allowing the peripheral to change the state of the data line and then at the end of each byte it would send an acknowledge saying yes we want more data from you only the controller can start and end transactions again the peripherals can't do anything unless they see a start and then their valid address on the bus followed by whatever happens and then a stop condition or repeated start in some cases that's it for this presentation i went over things you know tried to squeeze it into an hour here a little under an hour uh the first question and answer session is going to be tomorrow night thursday and it's going to cover any questions you have we're going to be doing a live session so if you have any questions go back through the presentation write down any questions you have or anything you missed and i'll be more than happy to answer any questions you have if you want we can take a look again at that example transaction we can look at it in more in depth if you have any questions later after this course is complete you can always email me at the email address at the first slide i can't promise that i'm going to be able to give everyone a full you know detailed answer but i'll always be able to point you in the right direction and speaking of which there's a book that if you're interested in learning more about the i squared c bus we're going to look at it again next week there's a bus called mastering the i squared c bus by an amazing electronics engineer named vincent hempe if you're interested in buying that book it's available online it's no longer in print so it's a little bit pricey but it is the textbook on i squared c uh so i highly recommend that and next week we'll be going into software examples so uh hopefully if you want to follow along with those examples you'll have your msp430 launch pad we're going to be going over some example msp430 code looking at how you actually use an i squared c peripheral to send a i squared c block inside a microcontroller to communicate with peripherals and actually do something with it which is the whole point of learning i squared c i'm going to put a link to these slides so you can download them on the project page for this course so if you want to go back through the slides and take a closer look at anything you're more than welcome to do that the same thing will be true with the software it'll be posted into a get lab repository where anyone can take a look at the code and we'll be going over that in detail next week so thank you so much for watching