[Music] [Music] All right, so let's look at the different kinds of microcontroller families, and what I mean over here is there are many different vendors who sell microcontrollers. We need to be aware of the different options that are available to us so that we can make an informed decision on which one to finally go with. What I'm going to do over here is present a very high-level overview of the different kinds of capabilities of some of the better-known ones. It is by no means exhaustive, right? And if a particular microcontroller is left out of this, that does not mean I think it is unimportant. It just means that I just picked a few specific representative examples out here, right? There might be some microcontroller that you have come across or have used or can see used in a different context, which is, of course, you know, potentially also a very useful and important microcontroller. What I'm trying to do over here is to give a flavor for why they exist in the first place and what

are the ways in which we can sort of compare and understand their capabilities. The first thing we need to understand, of course, is what do we mean by a microcontroller family, right? And to understand that, there is this term called the instruction set that we need to think about, right? Once again, going back to the program course on programming in C, how does a processor actually understand or execute instructions, right? And there we saw that there was this core part of the processor which can do three kinds of things. One is it can perform arithmetic and logic operations, or it can load or store data from an external memory into its local storage, which we usually call registers. And the third is it can perform something called control flow. That is, it can perform these operations, whether they are logical, arithmetic, or memory-related operations, in sequence, one after the other. But that sequence can also be changed at runtime by doing something called a branch or a jump instruction, right? So those are the core instructions that actually affect how the processor itself works and the set of instructions that a particular

processor is capable of understanding constitute what is called its ISA or instruction set architecture. Right, so the ISA is the specific set of instructions used by a given processor. Right now, in principle, all ISAs are equivalent almost. What I mean by that is there can be certain restrictions based on how much memory a particular ISA can access and so on, which might put limits on whether you can actually perform exactly the same kind of computations on one ISA as on another. But removing once we take that out of the picture, in principle at least computationally, they are all equivalent. Having said that, many ISAs have certain kinds of instructions that are heavily tuned for certain types of operations. In particular, there are specific ISAs that have very well-tuned Loop instructions, things which can actually sort of possibly decrement a counter, check whether it is zero, and perform a branch all in a single instruction. That's very effective for implementing things like for Loops. Okay, and on top of that, there are a few other aspects of computer architecture.

that come into play things like, you know, is it a risk machine? A reduced instruction set computer? Is it stack-based? Is it accumulator-based? And each of these kinds of architectures needs different kinds of optimizations. Now, for the most part, we are not really interested in most of those, right? What we care about is, okay, if there is a specific functionality that is provided by an ISA that is useful for our application, we need to be able to understand it and use it appropriately. So, with that in mind, what I'm going to do very briefly over here is just talk about a few of the more popular families of microcontrollers. One of them is called the AVR Series, right? It is essentially from the company Atmel, which was later acquired by Microchip. And it's been around since 1996 or so, nearly 30 years at this point. Flash-based. The good thing about being flash-based is that, you know, you can actually upgrade the firmware or change the firmware without having to actually have a complicated programmer, and especially

In the context of you know what the state of the art was in 1996, this was an interesting improvement, right? And it started out as what's called an 8-bit processor. An 8-bit processor versus a 16-bit processor versus a 32-bit processor. This is again something that we touched upon during the C programming. Primarily, it sort of relates to how big of an address space you can address, right? It also affects how big the numbers are that you can store inside your registers, right? And the 8-bit, once again, whether it's 8-bit, 32-bit, and so on, could refer to multiple things. Commonly, one of the things that it refers to is the registers that are actually present inside the system, right? You might have an 8-bit register but also have something like a 16-bit accumulator for performing certain kinds of computations and so on. The point is, at a rough cut, what you can say is if you see that something is an 8-bit processor, it is typically going to have access to a

limited amount of memory and is also primarily used for not very computationally intensive applications because even multiplying two large integers is going to require a lot of back and forth from memory in order to do it on a system like this. Now, that's why where it started from, but that's not where it ended. You also have like, you know, variants of this that are capable of addressing a significant, reasonable amount of memory and also of performing a decent amount of computation. And, of course, the most popular and well-known of these is the Arduino, right? It has effectively been credited with the so-called democratization of MCU coding, right? What that means is that it brought it to the point where MCU microcontrollers were accessible to everyone, right? There were cheap microcontrollers before the Arduino, and people did use them, but even to just get to the point where you are able to write a program and get it running on a microcontroller required a significant amount of, you know, dedication in the sense that you needed to be willing to

sit down, understand a lot about the electronics behind it, put it on a breadboard, figure out how to program it, lots of things like that, whereas the uino literally said, Hey, know, plug it into a USB port, here's the IDE for programming it. Even the language is a simplified version of C, so go ahead, just write your code and see what happens, right? It has been used in a number of other areas, consumer electronics variables. It is especially popular in the context of art and educational programming. So, the AVR Series, in other words, is one family of microcontrollers that you know has been used in many of these contexts. The PIC is another very old and popular series of microcontrollers, right? It's almost as old as me, which probably tells you that I'm old at this point. It was started by the company Microchip Technology in 1976. As you can see, this is one that almost entirely had the EEPROM, the electrically erasable PROM. And in fact, you might see pictures of these where you actually have this sort of a glass window that is

visible out here, and literally, this glass window was not just there for show. That was the window through which UV rays would be sort of shown down on the microcontroller in order to reset it and erase it for the next round of programming. Once again, a very popular architecture. There are newer variants, which are 32-bit architectures, which are based on the myips ISA. So, as you can see, right, this actually technically is not just one ISA. It is the PIC ISA for the older versions and also has a different ISA for newer ones. Its ISA, the instruction set, is actually very well suited to the use of lookup tables, which constitute a very interesting way of programming, especially in embedded systems, right? It is very popular with hobbyists, but, or rather, was very popular with hobbyists, possibly still is, but to a large extent has been displaced by the Arduino in terms of just the ease of use, right? Because typically, you need somewhat complicated debugging equipment to understand, well, possibly now it has been improved, but at least in the early 2000s.

this was the kind of equipment that you needed in order to debug code on a pick system. So, moving on, the MSP 430 series from Texas Instruments has again been around since 1992, been quite a while. So, as you can see, most of these families have been around for at least like three decades at this point, right? Two to three decades at this point. One of the focus areas of the MSP Series has been ultra-low power applications, right? And it's kind of interesting what they look at is providing a mechanism where you literally have 0.1 microamps of current draw if all that you are interested in is just keeping the contents of memory safe, right? Normally, what happens is when you switch off the system, the contents of memory just leak away completely to zero. What this is saying is you can put it into a low power standby mode where the memory is retained, where it consumes only around 0.1 microamps, 100 nanoamps of current. There is also another mode of 7 microamps or so where it can actually

work with a real-time clock at a very slow speed right now. Interestingly, a single coin cell, the kind that is shown over here, has like a few mamp hours of capacity, a few milliamp hours. Doesn't sound like a lot. It's probably around 100 mamp hours or so. Your phone battery is probably on the region of around like maybe 3 to 4,000 or maybe a bit more, right? A single coin cell is probably somewhere in the region of around 100 milliamp hours. The point is, with that 100 milliamp hours, something like this can possibly even exist in that state without losing the contents of its memory for something on the order of years. Now, in practice, of course, other things happen, such as the fact that there will be some internal leakage, which will cause the current to actually drain away a bit faster. But these coin cells are also designed with very good internal resistance characteristics, which means that they don't easily leak, right? So, this was one area where especially the ultra-low power applications is a place where the MSP

series is quite well known, and you know known to do well. They have their Launchpad kits targeted especially at university programs, and they have a very easy-to-use USB-powered debug system where you can literally just have a small device, plug it into a USB port, you can program it, you can debug it, lots of support in terms of what can be done with that. Nowadays, of course, many of you have probably heard of this series called the ESP, right? It used to be the ES 8266, and now the ESP32 series. This is a Shanghai-based company. They have, again, best known for coming out with extremely low-cost and very high levels of integration on the devices that they sell. You can actually get one of these Node MCU units probably for around 3 to 400 rupees, right? On top of that, they also typically integrate quite a few peripherals, including things like Bluetooth and Wi-Fi, which means that you can literally take one of these devices and create an internet-connected device at one shot, right, by just connecting a

few other sensors and actuators to it if you want. Yeah, they use a different type, something called the extensa ISA, which was a proprietary ISA currently owned by the company Cadence, right? And they are best known for having these ultra-low-cost boards. So, the question basically comes, okay, which one of these microcontroller families should we use, and which one are we going to use in this course? And well, it's a highly competitive market, right? If you look at it, even though I said, for example, the MSP has like extremely low standby power, the ESP has like very good connectivity options. You'll go back, and you can probably find some member of each of the other families that has similar kinds of behaviors, right? So, it's not an easy thing to differentiate between them. One aspect which is actually very important in choosing this is infrastructure, and what I mean by that is the fact that, for example, the Arduino IDE is so popular, means that there are a large number of people who have access to it. It means that there is a good

amount of support available for such systems. It makes it easy to code right, and the more popular a system is, the more popular it becomes, right? More people know about it, more people get attracted to the system. It just popularity begs popularity, and it grows that way. So, which one of these four are we going to use? Well, none of them. We are actually going with the ARM processor. Okay, so what is ARM? And in some sense, ARM is what you would sometimes call the 800-kilo gorilla sitting in the room over here, right? In raw numbers, in terms of the number of processors that have been shipped and are actually used in practice, it completely dwarfs anything else that is there. So, what is ARM, right? A little bit of the history of it. It started off as a company called Acorn Risk Machine. So, this was in the early '80s. BBC, the British Broadcasting Corporation, actually had been given the mandate to popularize computers among the British public. And one of the things that they did was they actually came out with a set of with

some microcontroller microcomputer specifications right. There was something called the BBC micro and another similar thing called the Eon electron. Eon was a company that basically was able, you know, they had a full-blown system. It looked like a large portable keyboard and it did not have a display. You needed to connect it to a TV in order to actually see the output, but it was a fairly powerful processing system. Now, they used a Motorola chip at the time, but as the company grew and adapted, they found that, you know, designing their own chip kind of made sense. They started out as this thing called the Aon risk machine. Risk, by the way, was a specific philosophy or an approach to how to design computer processors, which came out in the early 80s, right, based on research from the University of California, Berkeley, and Stanford University. And, uh, it had some very significant changes in what could be done with regard to, or rather, how you could build fast processors at the time. So, it was an interesting idea. Well,

implemented at some point. They changed the name away from ACON and went to Advanced Risk Machine, which eventually just became ARM, right? So, ARM at this point, you don't usually hear it referred to as Advanced Risk Machine; it just basically stands for ARM by itself now. The raw numbers, right? The fact that probably something like, you know, 20 to 30, or I mean, at this point, I think you probably have more than a thousand ARM processors have been deployed, have been produced for each human being that exists on the Earth, right? It's probably close to that number at this point. And the reason for this is because ARM processors get used in all kinds of places where you wouldn't even expect a processor to be, including things like USB cables or USB power adapters, right? Just the cable over there has some kind of negotiation to decide at what speed it can communicate, and that's handled by putting a processor in there with its own embedded firmware, right? Why did this happen? Because ARM took a very

interesting IP-based model towards their sales. They don't actually manufacture chips of their own. What they do instead is they design the processors and they sell licenses. So, they do not. Arm by itself does not build a chip. What they do is they design the chip to the great level of detail to the point where it can actually be confidently expected to run on Silicon, but then only sell that design to other companies who are then responsible for actually integrating it onto silicon and then producing the chips. Now, what exactly does gate level, register transfer level, and so on mean are things that you would probably have. You may have come across in the digital systems course, and at some point, if you go deeper into digital design, you'll come across these Concepts in a lot more detail. For now, it doesn't really matter. What is important is that these are being sold as intellectual property or IP and not exactly chips by themselves. And what has happened is Arm, therefore, has sold licenses to Apple, and their chips are therefore used in every

single iPhone and every single uh uh and all the new M M series MacBooks uh or the iMac and so on to Qualcomm, which means that a very, very large number of smartphones today, therefore, use Arm processors automatically. Nvidia, right, uh, although Nvidia makes uh Graphics processing units, they also integrate tightly with Arm in a number of contexts. There are companies like Amper whose job is to build high-performance Arm-based computing systems. All of them basically take the basic core or the architecture definition in some sense and build their own chips around it. There are different variants like I said. Arm typically doesn't have a 8-bit or 16-bit variant. You either have 32-bit, which was very popular, and there are still a very large number of uh 32-bit uh Arm processors. In fact, in this course, we will be using one of these for most of our designs. And there are 64-bit variants that are typically used more in the context of microprocessor-type applications where you need a larger memory access and possibly more

Computing. So, within um, there is a series of processor architectures that are called the Cortex Series, right? Which are variants of the 32-bit architecture. A is called the Application Series, and you have probably seen things like, you know, some Samsung phone has an A53 Cortex core or something like that, right? And what that basically means is it is an ARM core in the A series. It is most likely going to be a 64-bit variant because the A series are more focused on full-blown operating systems and running on laptops or phones and so on, right? And they are meant for applications, so they have access to large amounts of memory. They can perform computations fairly fast. They will usually have floating-point computation support and so on. Then you have R, which is the real-time, which is less common. You are unlikely to encounter it on a regular basis because these are used more in real-time embedded applications, especially things like, you know, the failsafe applications, traction control, braking systems, and so on, where you have hard real-time constraints on how fast a

system needs to respond now. What is it about the processor that makes all of this possible? They have very tightly coupled memory, fault tolerance, possibly error correction, things that are designed just for the purpose of making sure that things cannot go wrong. What happens in that case is for having all of these features, you usually have to sacrifice some silicon area, which would otherwise have been applied to making it run faster or to have more peripheral interfaces. That's the tradeoff as far as the R series is concerned. And finally, you have the M series, which sort of stands for microcontroller series. Many of them have little or no memory management capabilities, right, and are mostly meant to be used in standalone mode. Now, having said that, there are certain kinds of operating systems that can run on this and possibly some variants of the M series that could run an operating system as well, right, but are primarily targeted at low-power embedded applications. In some sense, this part is going to be the focus of this course, right? This is where we are going to be

spending most of our time. So, what are the features of the ARM Cortex-M? It's most licensed as synthesizable Verilog code. Verilog is a language used for actually describing circuits at the level of the direct gates that are used in order to build them up, right? But it is customizable, which means that people can add extra features to it before they finally put it onto silicon. It has many useful features from the point of view of a microcontroller. It can handle a large number of interrupts. It has a so-called Harvard architecture, which I'm not really going to get into detail on this. It's a nice feature to have. The bottom line, as far as we are concerned, is the instructions and data can effectively be thought of as being in different areas of memory, right? And what that means is that in the same clock cycle, you can access an instruction as well as fetch data, right? Which is useful to sort of improve the efficiency with which you're performing computations. It has limited pipelining capabilities for those of you.

who have read anything about microprocessor architectures, you would know that pipelining is something that's used in order to get really high performance, high clock speeds. But that's not the main goal over here. Many of the M Series have limited math support. They may not even support floating-point computations, only integer arithmetic, right? But typically, they also have very good low-power modes and the ability to switch between different modes of operation. Now, the ISA that is used by the ARM V7 or the variants thereof is ISA of the Cortex M, is based on something called the ARM V7 architecture. But as far as this course is concerned, we are not really going to be looking into the Assembly Language at all, except perhaps to show a few examples of what Assembly Language looks like or what might get generated by the compiler or how we might be able to do a specific task directly by going down to the instruction level, right? Those will be relatively rare. Almost all the coding that we'll be doing in this course will be in C or

C++ once again. If you are not familiar with C++, it doesn't matter. We are primarily going to be looking at C, and C++ will only be treated as a sort of minor extension. The whatever parts of C++ we need will be things that we'll be touching upon in this course itself. In particular, you don't need to thoroughly understand all the aspects of C++ in order to understand what we what we'll be doing in this course. So quickly looking at, you know, the capabilities of processing capability of what a microprocessor can do, right? A microprocessor in general, one of the things that we would like is to have a high processing speed, right? Generally speaking, there are no fixed lower limits on how slowly you can operate a processor. You can probably go down to kilohertz or even Hertz if necessary, just apply a clock at a very low frequency, and yes, the system will still work in principle, right? Except that there might be some scenarios where perhaps data leaks out, but usually not even that's not going to

happen in most modern processes. Now, having said that, there are certain things like the MSP 430 that are specifically designed for low power. They have a very low leakage design, and there are also other things that are capable of fairly high speed, and that becomes useful for things like real-time control response. Okay, now microprocessor and another feature of microprocessors would be things like, can I get a 32-bit versus a 64-bit architecture? And this primarily relates to how much memory I can access, right? And the fact that I have larger registers means that I can perform math computations a bit more easily. The flip side is it usually also means that it consumes more power because there are more bits inside the processor that are switching at any given point in time. And the alternative is to have 8 or 16-bit microcontrollers. The problem is they have very limited computational capability and also very limited access to memory and storage. The good part is they can be small and consume relatively lower amounts of power, right? So all of

these are some of the capabilities that we would like to see in a microprocessor. Now talking specifically about power consumption, the operating power of a microcontroller or a microprocessor is primarily determined by the frequency at which it's operating, but also the capabilities in the sense that if there are, if the processor is larger and occupies more area or has more gates, presumably there are more moving parts, not literally moving parts because inside the electronics things aren't really moving, but what I mean is more gates that are switching from 0 to 1 and 1 to 0. All those switching activities consume energy, right? So ideally we want to operate at the lowest possible operating frequency, but also that means less computation is possible. The other thing that we would like from the point of view of power consumption is can I put my microprocessor to sleep, right? Can it sleep for long durations and how quickly can it wake up after that and respond to something? And you know, you very often have targets of months or years on button cell batteries for getting that.

you need to have standby currents in the sub-microamp range. The MSP 430 series, as I already mentioned, is particularly good at this, but it's not the only one. There are others also that have very low power capabilities or low power modes that can run for very long durations with simple coin cells. Another aspect that we would be interested in as far as microprocessors are concerned is: can a microprocessor handle multiple tasks simultaneously? This generally requires more memory, and it also means that it can handle multiple peripherals and control all in a single chip, right? The Cortex M series is again good from that point of view. It can handle a relatively large number of interrupts, and it's a 32-bit processor, which means that the amount of memory that it can handle and also switching between the control of such things is also well-built. It can be handled well within these processors. So, all of these were features of a microprocessor. Why are we interested in it? Because we want to sort of see how

should I choose a given microprocessor or a given microcontroller for the task at hand? Right one other non-technical or semi-technical aspect to it is the ecosystem, as I mentioned already, right. Traditional coding and debugging requires some kind of an IDE, the integrated development environment. There's a lot of non-trivial terminology associated with it, right, different kinds of runtime configurations, the build configurations, the compilation process, the debugger, the standalone modes. There is a lot of terminology which can be very off-putting to someone who doesn't want to get deep into this kind of technical aspect. What Arduino did was abstract all of that out to the point where you don't need to worry about it. You just plug it into USB, write a program, and put it onto the Arduino, and it works, right. And that actually made a big difference. Now, that was also copied by a lot of, or rather the idea at least, was adopted by multiple others, including something called Embed, which was a set of libraries for ARM processors. The ESP32 has their own IDEs that provide a

lot of such facilities and so on, right, uh, but having said all of that, the knowledge of how to do detailed debugging enables a lot more detailed control over what you can do with a processor and how to control exactly what it's going, how it's going to behave, right. So why are we talking about all of this? We want to answer the question, how should I choose the microcontroller to work with, right? And traditionally, at least, people would probably say, if you want some kind of a device with a lot of connectivity, Wi-Fi, Bluetooth, and so on, probably ESP32 is the way to go. If you're interested in, you know, some kind of educational coding or hobby or art-related work, Arduino has a better ecosystem, more libraries that support this kind of, uh, usage. Pi has a traditional, you know, stronghold in the area of Industrial Automation, MSP430 for low power, and ARM in general for, you know, scalable high performance, pretty much a catch-all kind of scenario, right. Now here's the problem, most of these processors have some kind of overlapping

features. So, even though I say MSP 430 is particularly low power, there are probably scenarios where I could get a similar kind of behavior using one of the other processors as well, right? Similarly, ESP32 has connectivity. Well, there are variants of ARM that have Bluetooth and Wi-Fi also built into them, right? So, it's no longer cut and dry saying that, Hey, this is how you choose, right? So, what is important, and hopefully will be possible for you by the end of this course, is you understand the capabilities of processors. You should be able to look at a processor, understand what it can do, and then, based on what you require for your application, do you really need Bluetooth or Wi-Fi for your application? If not, then choose one which doesn't have that because it will consume less power, will probably last longer on battery, right? Maybe you are not talking about a battery-operated application, but you want something which can perform computations fast. Maybe some kind of a more powerful ARM processor is the way to go, right? So, those are the

kinds of decisions that you need to be able to make based on the application that you are actually seeing. Ultimately, like I said, the ecosystem plays an important role, especially visible in the context of something like Arduino. Right? What we will be doing is looking at a couple of different ways by which we can write code for an ARM series of processors. And, you know, there is enough support for it that you can build on top of that and actually use this in a larger scale.

Microcontollers Famillies

Microcontollers Famillies

Scripts