[MUSIC] So we'll talk now about Arduino libraries, the different libraries that come with Arduinos. Arduino is a board, it's a type of board, it's a piece of hardware. But it's also this software in the form of these libraries that come with the board. And the libraries actually very important to the useability of an Arduino. Part of the reason why people really like Arduino is because these libraries help you use the Arduino. Help you use the hardware right. Because these micro controls have been in existence for a very long time. But, only with Arduino and things like it coming along with libraries that are really easy to use. Have regular people. I say regular people. People who don't know much about hardware been able to use this hardware and build IOT devices easily. So there are lots of so we talked about sensors actuators and things that you connect to Arduinos, or to any micro controller. And these devices, these sensors, these actuators and other devices that we haven't much talked about, that you connect in the system you connect to the microcontroller. Some of them are simple. Like the sensors and actuators that we've looked at. The resistive sensors and the voltage controlling sensors, and so on. You can just use pulse with modulation or analog read, analog write, digital read, digital write. You can use those functions to actually control these devices and observe these devices. But there are a lot of other devices that are significantly more complicated than that. That you also want to be able to connect to your Arduino and your microcontroller in general and you want to be able to use. So, for these type of devices, it's hard for your average person to write code that directly controls these devices. They can be very complicated. Now, some of these devices that we want to control. They are actually inside the micro controller itself. So the Arduino Uno anyway has a microcontroller, an ATMega328, and this ATMega328 has a lot of different devices on it. So it runs code but it has other devices on it that we would like to use. So, for instance, memories. It has memories and maybe we want to write things to memory and read things from memory. Communication interfaces. We'll talk about these. But maybe an I2C bus. Actually we've talked about [COUGH] some of these already. I2C or SPI, different bus communication interfaces. Maybe we want the microcontroller to talk to another microcontroller through one of these communication interfaces, something like that. Pulse width modulation logic. We've talked about this, right. There are lots of things, timers, lots of different components on there on the chip. That we wanna have access to as programmers and we wanna use for different things. So some of these things are complicated so what happens is, rather than you having to read the the data sheet on exactly how to control the pulse with modulation logic Or the I2C control logic and things like this. Rather than you having to do all that, instead what they do is they provide you with these libraries. And these libraries, they have relatively simple functions that are predefined. And you call the function, and it does whatever it's supposed to do without you having to understand all the details of what's going on inside the library. And so these libraries are immensely helpful in using lots of interesting things with your Arduino with any microcontroller. So the Arduino provides several libraries. Also there are third-party libraries too. Now libraries are also available for external hardware. So not only are these libraries useful in helping you use the hardware that's on the chip. Like a timer built in to the chip, a memory built in to the chip. But it helps you use other hardware, other chips, other parts that are external to the Arduino that you connect to the Arduino. And this is in the form of shields, which we'll talk about in the next module. But those also have a set of libraries that allow you to use them, cause otherwise it's fairly complicated to use them. So libraries make things much easier for you as a programmer. So what we'll talk about first, we'll talk about the EEPROM. This is actually a memory. It stands for Electronically Erasable Programmable Read-Only Memory. So the picture at the bottom, that picture is a picture of an EEPROM. That is not the EEPROM we're using. The EEPROM that we're using is memory that's already embedded into the ATMega328 processor. So you wouldn't see it as a separate chip. It's just a little piece of the chip we see on the Arduino, the main processor. It has some EEPROM memory. Now there's very little of it available, only 1k so 1024 bytes available on our ATMega processor. This memory is non-volatile memory so non-volatile means. It holds its data without power. So that's like a disk. A disk is non-volatile memory, or a flash, so flash is also a non-volatile memory, right? You can write something, you lose power. When you turn on power again, it still has the same memory. So in fact, EEPROM technology is similar to flash. But it's more flexible in the sense that you can write a single byte at a time. Now with flash, you can't actually write a byte at a time. Memory is grouped into blocks. You might now know this, you might not be aware of this, but it's grouped into blocks. So if you want to write to one byte, you've gotta write to the whole block. Which maybe you don't even need to write to the whole block. You just want to change one byte, but you've gotta overwrite the whole block again. So this wastes time and things like this but that's the way it's organized. EEPROM's more flexible. It's byte right writable so you can do one byte at a time. And it supports many more right cycle so what that means is, flash and EEPROM both they don't last forever. Flash, Flash maybe it'll last tens of thousands of write cycles. So, what that means is if you've got Flash, and you've got a particular address in the Flash, you write to that address 10,000 times. After that maybe 10,000, 20,000, 30,000 times, that address will wear out. So, eventually that address won't work anymore. And, the chip will just, the memory will just fail. So the flashes have a limited lifetime. And EEPROM is better than flash. So maybe a flash might be tens of thousands of write cycles, EEPROM would be a lot more than that, maybe a hundred thousand, something like that. Now this isn't as good as disk, disk has a lot more than that. But EEPROM is better in that sense, better than flash. But there isn't much available. So EEPROM takes up a lot of area on the chip so there's only space on our part for a 1024 bytes or 1k bytes. But it's useful for certain things so your program might want might store some more variables in there, in this EEPROM the same way you might use a flash. Although, see the flash on our ATMega What happens is that Flash is used for the program itself. So the code itself is sitting on the Flash, plus the boot-loader. But the EEPROM is a place where you might store settings, or variables, or something like that, that you want to save time and time again. Even after you unplug your Iduino, plug it back in. You want that data to be saved in there. Same way you might use files in a regular disk, a regular file system. You could put little pieces of data inside this EEPROM. Of course these are tiny files cuz they're only 10-24. But you can store some kind of data that you wanna be persistent in this EEPROM. So it can be useful. So you need to read it and you need to write it. So how do you do that? So they provide library functions to access the EEPROM and it's pretty straightforward actually. You access one address at a time. And each address is one byte, so we call byte addressable, meaning every address has one byte in it. So the way you read an address is you call this function called EEPROM.read. It's in the EEPROM library. It's called read. And you pass it an argument, which is an address, which is just a number. And that number, that function returns the contents of that address, so all the addresses are numbered. Since there are only 1024 locations in the memory, there are 1024 addresses, they're numbered 0 through 1023. So that address argument can be any value from 0 to 1023, and EEPROM.read will return the contents of that address, the byte. It'll return a one byte value. EEPROM.write does what it sounds like. It takes two arguments, an address and some data some byte size piece of data. So that data's one byte, and a write set byte into that address. And that's it. And the address has to be between zero and 1023 because that's as big as the EEPROM is. Thank you. [MUSIC]
