[MUSIC] This lecture we'll talk about the structure of an embedded system. The hardware structure specifically, look at the different components. A very generic view and we'll talk about some of them. The main component, the microcontroller we'll talk more about in the next lecture. So, here's my high level generic view of what an embedded system looks like. So if you look at an embedded system, it's got to take data from the outside world and then it's gotta output data to the outside world. So it has, first for the receiving data from the outside world, it has a set of sensors. So these sensors they receive information from the outside in many different ways because there are lots of different types of sensors. The most basic type of sensor would be a button, push button, something like that. And that's receiving data that somebody types in. You know, zero, one is binary. Then there's also, for instance, you could receive sound information like the microphone in front of me, or actually connected to here. And that receives audio information. There's also video, like the camera in front of me, or just a regular light sensor that receives video information. There's all kinds of sensors. Touch screens, right? You can receive touch information through a touch screen. So, there's a lot off different sensors that an embedded system can receive input from. So that input comes in to a set of sensors and it's gonna go into the core of the system and in the end, once the system has decided, process that information, decide what to do with that information, it needs to cause some results. An effect to happen in the outside world. So that's done through the actuators at the other side, the actuators, they cause events to happen in the world. So those might be something like an LED, a light, like there's a light flashing in front of me. That LED is an output actuator. And it goes off and on to indicate probably that it's recording, okay? But there are other actuators too, like for instance, the camera in front of me. It's got motors inside that control the lens to control the focus. So those motors, those are actuators. Those are outputs of the system. So the system will drive those motors and those will be considered actuators and make them. Pull the lens in and out and things like this. So, lots of different types of actuators. Speakers are actuators, they output sound. Lights are actuators, they output light. The screen is an actuator, it also outputs light but in a more interesting, I don't know if you call it interesting, but in a more detailed format. More complex format a light, so a screen is an output. So there are lots of different actuators. So if you look at the embedded system, it's in between there, right? It receives data from the sensors, it does something with the data, and then it outputs to the actuators to make something happen in the real world as a result of the data that it received. So the interface components of the sensors and the actuators. Now in the middle of the system, the center of the whole thing is that microcontroller in the center. Now, the microcontroller we will talk about in the next lecture in more detail, and actually a lot of this class is specializational focus on microcontrollers and how to program them, but there are other components that are commonly inside the core of an embedded system as well, and you see two of them right there. IP and FPGA, we'll talk about those in a little bit right now. So, IP stands for intellectual property, or IP Core people call them, and intellectual property core is basically a predesigned component, typically a premanufactured component so an integrated circuit, a chip that performs one function. When I say one function, maybe a set of functions, but all related to one particular task. So it's a chip that is not general purpose programmable. It's a core that just performs some small set of functions that are all related. So these things can be very useful. They're cheap in high volume. So what that means is, high volume means manufacturing volume. So if you have some very common task that's performed by a lot of systems, like say you got a cellphone, right? And then that cell phone, let's say, it's very common to perform some type of audio filtering task, okay? So all of our cell phones have to do this audio filtering, right, let's say. So you might make one of these IP cores, which performs filtering, and then it would be high volume, because there are many millions of cell phones that are for sale, and so you manufacture many of them. So there's a lot of work to designing one of them and it costs a lot if you want to just fabricate one. But when you're fabricating a high volume, it's very cheap. So these IP cores can be very valuable when you have high volume production. So they're useful for common tasks, that's the best thing. In order to make sure you get high volume. You basically wanna have, you wanna use them for very common tasks. Tasks that happen over and over because there's a lot of need. So if it's just a one-off if this is a design, some kind of function that's only done in this one system, then you would almost certainly not make an IP core and make a special purpose chip just for that. You wouldn't do that, but if it's some common task that's done a lot. So, for instance, network controllers, right? That's in a lot of systems. Basically every Internet linked device has some sort of network controller in it. So that type of thing you might implement as an IP core, a dedicated piece of hardware which just does IP control operations. Audio, video codecs right, so I'm coding audio and video, and compressing it, decompressing it. These are operations that perform by lots and lots of IOT devices, so this type of device, this type of function you might put into an IP core. Now these IP cores, we're not designing them in this class, that's outside of the scope of the class, but when you're making an IOT System, you definitely might want to buy one of these. So you'll look at a library, an online library, of IP cores, find some vendor, Texas Instruments, say, they sell a lot of chips that do different things, and you find the one that does exactly what you want. You say, well I'm doing MPEG encoding let me find the TIM peg encoding chip, and you find, you'll probably find 50 of them, and you pick the one that you want, and that's the core that you use. So that's how we use these things. We're buying them off the shelf, we're not actually gonna be designing IP cores, because that's too complex. And they have to interact with a microcontroller. So remember that the microcontroller is the center of all the action right? So, it's connected to the IP cores and it tells them when to do what they need to do. Right, so if an IP core is for encoding video, the microcontroller will say encode now, right, encode this data now. And when I say it will say that, it means, I mean through the signals, so the wires It will send the appropriate sequence of input signals to trigger it to record. And then the results may be the core sets a signal high when it's completed. And that goes back to the microcontroller. The microcontroller knows okay the coding is done, let me move on right. So there's this conversation between the micro controller and the IP core that goes on. And so you have to wire it appropriately and we'll only touch on that. Now another component that you often find in IOT devices, embedded devices in general, are Field Programmable Gate Arrays. Now, we will not be using Field Programmable Gate Arrays in this class because their complexity is basically outside of the scope of the class, but what they are, they're an interesting thing and you should know what they are. They're hardware. They're integrated circuits, they're chips. Not programmable chips, they're regular chips. Not programmable in the conventional sense, okay? These things can be reconfigured, essentially rewired to perform different tasks. So, let's say you need something to do audio filtering. So, you might configure the FPGA to perform filtering. So it's a hardware device that will perform filtering because it's been wired to do that. But then you can rewire it, reconfigure the device, to rewire it so that it performs mpeg coding instead or something like that. So you can rewire this thing, reconfigure it, so that it can perform different tasks. Now it's not programmable in the sense of a general purpose processor, you don't write code for it. And as a result it's actually a lot faster than a general purpose processor right. You can get that same flexibility with a general purpose processor. You could run one program, or another program, you could do that with a processor but you would do it with the FPGA if possible because it's a lot faster. It will execute a lot faster. Because the software conversion step we won't talk here that is skipped if you directly in hardware using FPGA so FPGAs have that advantage. And no fabrication is needed. So when you make an IP core and you fabricate it as a chip. You have to fabricate it. You have to manufacture chips and that's expensive. So it only makes sense in high volume with FPGAs you don't have to fabricate you just reconfigure it through programming, just connect it by USB to a computer and you can rewire the thing. So that's much more convenient and cheaper, so if you have a one off design you would implement in an FPGA over some kind of an IP core. Thank you. >> [MUSIC]
