Fundamentals of Embedded C Programming and Efficiency

Embedded C programming offers fine-grained control over hardware, optimizing resource use for efficient system design.

### Introduction to Embedded C Programming: Key Concepts and Practices
* 📚 In this series of videos, we will delve into the fundamentals of embedded C programming, highlighting its **differences from standard C** and focusing on **key aspects crucial for embedded systems**.
* ⚙ Our journey begins with a recap of C programming, emphasizing the **importance of writing efficient code tailored for embedded systems**, which often operate under **strict resource constraints**.
* 🛠 C has been around for about 50 years, originally developed alongside the Unix operating system, and is valued for its **close relationship with hardware**, allowing programmers to have **fine-grained control over system resources** like memory and processing power.
* 💾 Efficiency in C programming is crucial, especially in embedded systems where **memory and processing capabilities are limited**; understanding specific definitions of efficiency will be essential as we progress.
* 🖥 Embedded C is particularly effective for developing **operating systems**, **high-performance applications**, and **network applications**, and it remains popular in game development due to its **performance advantages**.
* 🔍 We will explore various data types, including integers and characters, and the significance of using **precise data types** in embedded systems to **conserve memory and enhance performance**.
* 🔄 Control structures such as conditionals and loops will be examined, illustrating how they help **manage program flow and decision-making** in embedded applications.
* 📏 Lastly, we will cover functions and modular programming, which promote **code reusability and maintainability**, and discuss memory management, particularly the importance of understanding the **stack and heap** in the context of **long-running embedded systems**.

[Music] [Music] Hello everyone. We'll now continue on our journey into embedded C programming, and what we are going to look at in this set of videos is some of the basics of embedded C, to some extent how it differs from regular C, what are the things that we primarily care about. To some extent, this is also a very quick recap of what is there in regular C, but for the most part, the assumption is that you already are familiar with C programming as such. So, we're going to start off with the concept of writing efficient C code for embedded systems, right? And in particular, there are a few things that we need to understand over here. We'll be starting with a recap of what C programming actually is, then look at the topic of efficiency in a little bit more detail, and what it means to actually design systems that are efficient in the context of embedded systems. Okay, so first things first, we have already sort of discussed this briefly, but C as a programming language, why does it even exist, and why is it a

useful language to know right now. Why does it exist? Of course, it's been around for a very long time, uh, about 50 years or so at this point. And when it was introduced, it was primarily brought in as a language that allowed people to write operating systems. In other words, the development of C went hand in hand with the development of the Unix operating system, and that shows in a number of the sort of basic primitives that are available in the language and the kind of problems it is best at solving. Now, why? And if we keep this background in mind, it becomes a bit easier to understand what is special about C. In particular, it is close to the hardware. What that means is that if you look at a piece of C code, it is usually possible for a reasonably experienced programmer to be pretty much able to say, Okay, that this particular C code is going to translate into these Assembly Language instructions. And for the most part, you'll probably be right. You'll have at least like, you know, a

good overlap with what actually gets generated by the compiler. It is possible to create more complicated data structures and so on, but that's not what we are talking about. We are talking about the basic parts of the language itself. What that in turn means is that since you are so close to the hardware, it gives you very fine-grained control over the system resources. What are system resources? The most basic resource available to any computing system is, of course, computing power, the number of clock cycles available for doing useful work. But apart from that, it is the amount of memory that's available in the system, the storage, the I/O, the input-output, network bandwidth, various other kinds of features like that, which also have to be sort of controlled and given to the programs that need to use it in different ways. Now, while allowing you this level of control, C also provides the capability for structured programming. There is a concept of functions, there are loops and other kinds of iterative keywords and execution constructs, and there are ways of taking different types of data and putting them together.

to create more complex data structures or data types. So, this allows a higher level of abstraction. So, all this is to sort of explain why C, as a programming language, hits a nice balance between being close to the hardware, giving you direct access to what a computer is capable of doing, while at the same time providing a level of abstraction that makes it reasonably easy to construct fairly efficient programs. Now, that word efficient is something that I keep using, but there are some very specific definitions of efficiency that we will need to sort of look into as we move further. Please keep that in mind; it is one of those terms which is broadly misused because people say things are efficient just when they mean that it's maybe well-written code or it's not particularly wasteful, but it is usually possible to almost quantify that in many contexts, and that is something that we will try to do as we move forward. Now, as I mentioned, where does the C language get used? One of the main areas where it really shines is in the

creation of operating systems. Like I told you, it was originally written in the context of the Unix environment and Linux. The Linux kernel, the actual kernel of the operating system, is also written in the C language, right? And there is a reason for that, which is precisely the fact that it gives you fine-grain control over resources, and at the same time, it translates very straightforwardly from the C code that you write into Assembly Language code that runs on your processor. Now, another place where C actually shines is in high-performance code. This includes scientific computation or memory-intensive applications, similarly for databases, mostly things that are really pushing the hardware that you have to the limits of what it is capable of doing. And another area happens to be network applications. Once again, these need to strike a balance between the simplicity of the code that you write and the speed that you can get for actually transferring data. Another interesting place where C does get used quite a lot is in game development. Of course, there are reasons in game development to go for higher-level

abstractions like C++ or other kinds of object-oriented languages, but just the raw performance that you get by writing code in C makes it still a very popular language for developing games. So, what we're going to do is just very quickly have a recap of some of the basic concepts in the C language. Please keep in mind that this is by no means a replacement for actually going through a regular course in programming in C. Well, not exactly a course. What you need more than actually attending a course is practice. You need to actually write code, right? So, please keep that in mind. The entire course on embedded programming is going to assume that you already know sufficient C to be able to do something useful, but it's not going to teach you enough of the basics of C. And at the end of the day, the only way that you learn any programming language is through practice. You cannot just read a book and learn a language. You need to practice actually writing code in that language. It's similar to human languages. Just reading a book will

only get you so far until you start actually speaking in the language to other people who actually use the language on a regular basis. All right, so coming back to C, the first thing that we need to keep in mind is that there is a concept of data types, right? And these are used for storing and manipulating data. The most common data type in C, or the very likely the first one that you are likely to encounter, is probably the int or the integer data type, right? And depending on the type of processor that you have, that integer data type is very likely to be a 32-bit number, right? And then, of course, there is the char or the character, which is usually an 8-bit data type, right? And on top of that, there are a few more sort of slightly advanced data types like floating-point numbers, double-precision floating-point numbers, and shorts, where a short is basically a smaller version of an integer which uses less space. Now, all of these are common in any C programming. Now, the sizes are usually implementation-dependent. The standard for C only defines sort of minimum sizes.

that are used in order to implement each of these, but there is a range of different values or number of bits that you can use for the size of an INT or various other data types. Now, implementation-dependent may be okay in the context of something like a general-purpose C program, which you're trying to run on top of an operating system and make it portable, but in the context of embedded systems, that's not really very helpful because over there you usually want very fine-grained control over how many bits are being used by the system. And there is a header file in C referred to as STD int or standard integer.h, which actually allows us to use many other data types. In particular, it defines things like int8_t, uint8_t, which is an unsigned 8-bit integer, int16_t, which is a signed 16-bit integer, signed meaning that it uses the two's complement representation to store numbers, and so on. So, in embedded systems, as we will see as we progress through this course, you usually

don't want to waste space. Right, the amount of space that's available to you for storage and for computation is very tightly restricted, which means that for the most part, you are interested in using exactly the right number of bits for any computation that you need to perform. So, this is a sort of quick recap of the basic data types that are there in C. There are more complex data types that you can create, the most common being the struct, right? It's the keyword struct, which allows you to encapsulate multiple different data, which could be of different types. You could have an integer, a character, possibly even a string, all of them as fields of a single data type. Now, fundamentally, it is not absolutely necessary to use structs, as with pretty much any other part of this language, right? Part of the reason why these kind of keywords and these kind of constructs in the language become useful is because they help you to make your code more readable, understandable, and maintainable. And this is yet another thread that we will be, you know, sort of

stressing upon multiple times as we go through this course because just writing code alone in order to solve a problem is usually not sufficient. You want to write it in such a way that somebody else can understand what you have written. Well, that somebody else could be you 6 months from now. So, please keep that in mind that you know you 6 months from now. You are not going to remember your thought processes when you wrote code today, which means that choosing the right kind of data types, choosing the right kind of structures can make a big difference to how easy your code is to read and maintain. As you move now, there are also enumerated data types and unions, which are once again slightly more complicated structures that you can create in C, and they have their uses. In fact, enumerated data types in particular do find use quite a lot in embedded systems because they can be used either to sort of construct state machine-based systems or also to enumerate the different kinds of inputs, outputs, bits, and so on that you might have somewhere as part of an overall.

system that you are designing. Union data types are kind of interesting. They basically allow you to have two different views of the same set of bits in memory, and there are specific cases where they are useful, although for the most part, structs and enums are probably going to be more common in terms of what we regularly use. Now, the data types, once you have data, you need to be able to do something with it, and there are a few important structures or programming constructs that we use regularly while writing code. First of all, we have conditional execution, denoted by the if and else keywords. What we have over there is this is a very common use case. It basically allows us to choose between multiple different options. If some condition is satisfied, do something; else, do something else, right? And for example, in an embedded system, it could be something like if the water level sensor is showing that the water level has reached a certain height, then we need to turn off the motor; else, we keep the motor running, right? Or if it has reached

a low point. We turn on the motor, so those are simple things. But of course, you know exactly the same thing holds in a regular C program as well, right? So you could also chain these if-else conditions. So you could have if the first condition, else if another condition, else if another condition, and so on. Now, that's perfectly fine and valid and a, you know, a reasonable way of writing more complicated kinds of structure, complicated kinds of code. One of the examples would be, let's say that you are in charge of assigning grades to students based on their marks. You might have a condition which looks like if the Mark is greater than 90, then give them a top grade in S. Else if it is greater than 80, then they get an A. Else if it is greater than 70, then they get a B, and so on, right? Now, these nested or chained IFL statements in some cases can also be replaced with what's called a switch-case statement, which basically says I'm going to switch my operation based on the different values that I

might obtain, and by choosing different specific cases or conditions, we can have a very compact way of representing different kinds of code. So, keep in mind that pretty much anything that can be done with switch-case can also be done with if-else, except that this is a more compact and cleaner way to express many different kinds of code. Now, those are the conditionals. On top of that, we also have something called iteration or repetitive execution of the same code, right? And we have a few different options over here, the most common being, of course, the for loop, right? And a for loop, what it does is it basically says that a certain piece of code, which you then specify as the body of the for loop, needs to be run a specific predetermined number of times. Usually predetermined, it is possible for for loops to have a variable number of iterations or something which changes and can be only determined at runtime, but for loops are usually used for the case where we know exactly how many times it is expected to run. While loops are a bit more flexible.

what they allow you to do is write a simple condition which says, as long as that condition is true, execute whatever is inside the body of the loop, and modifying that condition or changing the parameters of the condition can happen anywhere inside the loop. So, you can always execute a for Loop using a while loop, and in the context of C, it is also possible to write a while loop using a for Loop, although that's not a common scenario. For Loops structurally are meant to be for things which are just repeating the same thing a fixed number of times or some known number of times, whereas while Loops are very generic; they could even, you know, keep iterating based on whether an input has been received or not. So, those are the most common forms of looping behavior that we have, and one thing which actually turns out to be relatively common in embedded systems especially is the concept of something called an infinite Loop, where we basically just keep on spinning, checking on some particular value. It would usually be written as something like while one or so, which basically

means while one is never going to become false, and you are going to keep on repeating that Loop. But the fact is that somewhere inside that Loop, we are going to check some condition, and if the condition is satisfied, we will break out of the loop. So, break and continue are things that allow us to change the flow of control of these kinds of Loops. So, all of this allows us to do something called control flow, which is changing the next instruction or next statement that is going to be executed as part of the program, and that is one of the most important parts in terms of the power of programming languages. And it allows us to create what are called structured programs that we can easily understand and reason about. Now, so far, so good. You can actually do quite a lot of programming just by knowing data types and the basic conditionals and for loops and Loops. But one of the really powerful portions of the C programming language comes when we start looking at functions, and functions are basically a form of reusable code, right? You take a

piece of code that you find that you are going to execute regularly multiple times, and possibly you assign certain parameters to it, which we call function arguments. Things that can be used in order to change the behavior of the function. On top of that, a function can also have a return type, meaning that it can be used in order to compute something based on the parameters and then return a value. The most common examples would be something like, you know, maybe the square root of a number or a factorial of a number or a sine or cosine of a number, right? All the mathematical functions that we think of are usually implemented using equivalents in a language like C, which is why the name function, of course, comes because it is very closely related to the concept of a mathematical function. It takes certain inputs and transforms them into outputs. Now, functions in C can do a lot more than that, in particular by enabling the ability to update a value somewhere in memory through a pointer. We are not really restricted to just having a single return.

value now. This enhances the flexibility of functions. It also makes them a little harder to reason about, so you need to use this with a little bit of care, as we will see in multiple occasions. Anything to do with pointers, you need to handle with care, right? They're extremely powerful, but you have to be careful what you do with them. Okay, so all of this, the main thing that the concept of a function is enabling for you, is what's called modular design, right? It allows you to break your code into a set of modules, separate functions. It improves the readability and maintainability of your code, and by effective use of various language features like header files, includes, function prototyping, and libraries, and so on, it's possible to get very well-structured code that can also be reused systematically as required. Now, functions bring in the concept of variables that are used inside the function, and in particular, the concept of scope of a variable. And here, we need to understand specifically there is something called a stack and a

heap, and these are basically areas of memory, right? And we all, this was discussed in the C programming course, and it's probably worthwhile to go back and recap it because it turns out to be quite important in the context of embedded systems. The stack, in particular, is a specific area of memory that is given to each function call, and it is one of the things that enables the use of recursion, right? The important thing is each function has its own stack area, which means that it creates its own local variables, things that only that function knows about, and nobody else anywhere in the program has anything to do with those particular values. But it also allows you to pass data back and forth between the caller function and the callee function. So, the callee is the one that's being called, and the caller is the one that's doing the calling of a function, right? A function call basically means that we invoke a function or jump to the start of that function after having set all the parameters we want to evaluate it for, and after the function has been

called and evaluated. It returns right. It may either return a value, or it may just return without a value, but having set some other parameters in other places. So, all of this is enabled by the stack, but there is also a chunk of other memory that is called the Heap that is used for general-purpose storage, right? Things that do not belong necessarily to any single function. They could be the global variables that are used by the entire program, or they might be what are called Static variables used inside a given function, but which need to be kept permanent even after the function exists, or they might correspond to what's called dynamic memory allocation, where we just ask for a certain amount of memory, and it is given to us in order to use as we like. Now, careful management of this scope plays a vital role in the implementation of embedded systems in particular because embedded systems tend to have long-running code, meaning that very often you have something which once it starts just keeps running, possibly for days or months or even years on end, right? And all that it's doing is waiting.

for some inputs and responding to it, so when you have something of that sort, you cannot really afford to just create variables or use memory as you like because after some time you will run out of memory and the system is probably going to crash. So, you have to be careful with how you allocate and manage the memory, and this is something that we will be talking a lot more about as we move forward. Now, given the context of memory, the one sort of scary dragon that is present in any discussion of C is the pointer, right? And we will have a lot more to say about them as we move forward. The important thing is, of course, to understand that pointers ultimately just come down to a way of addressing something that is there in the storage of your system, right? The simpler that you create your mental model of what a pointer is, it probably becomes easier to appreciate that they are not that complex, provided that you literally think of them in terms of just literally their name. They are pointers; they point to a certain location in memory. How you

use them is then up to you. We will be using quite a lot of these as we go through this course, so and we will talk a lot more about how they are used in the context of embedded systems as well. So with all of this in mind, all of everything that I spoke about up to now was just general-purpose C programming. So what is embedded C? Embedded C is largely C itself, and why it is useful is because, as we have already seen, the C language compiles into instructions that are very close to the hardware, which in turn means that by using it in the right context, we can directly manipulate hardware capabilities. It also, the fact that we are able to have fairly good control over the kind of instructions that get generated, means that in a scenario where we have constrained resources, we have a limited amount of memory, a language like C could be very useful because it helps us to control how big our program becomes. So these are requirements for the highly optimized kind of operations that we need in embedded systems now.

where do we use these? It could be consumer electronics, TV, kitchen camera, things of that sort. It could be Automotive, where things like real-time and safety start playing a bigger role. Or it could be medical, where safety as well as security and privacy of the data start to become very important. And most importantly, embedded systems tend to be systems that have very tight constraints. It could be that the entire thing needs to run off a battery, which means that there is a constraint on the amount of energy or power that's available to the system. It could be the size. You do not want a camera that's the size of a suitcase; you want something that can fit in your hand, right? You do not want a phone that needs a trolley to lug it around; you want something that can fit into your pocket, right? And of course, at the end of the day, you also care about the cost, right? So all of these are constraints on the development of a system. You cannot just have a big desktop or a tower kind of machine which sits under your desk and

yes has a very powerful graphics card and capabilities, and you know, lots of RAM and storage, which allow you to do whatever you want, but becomes useless because you can't carry it around and use it when you need to. So, those kinds of things are the constraints that embedded systems are working under, and embedded C helps us with sort of planning for those and meeting those constraints. There are a lot of similarities and differences between C and embedded C. On this side, you can see that there's, you know, this is a program that's written in the regular C language, and you can imagine that, you know, there's a printf statement out here, which basically says enter some data, presumably that comes out on some kind of a screen that you can see, and then there is an fgets function which gets data from a standard input. Now, if you think about it, what does that mean for a person writing a C program? You call a function, you get a result, right? But how does it actually get implemented? That is where the embedded C starts playing a role.

similar kind of thing could be something where I actually define something called a sensor data register in embedded C. As you will see, that turns out to be something which, you know, a hexadecimal number in this case, which, as we will see later, is actually a pointer, a memory address. And the fact that I'm declaring it as an INT Star, right, meaning it's a pointer to an integer, uh, pointer to an unsigned 8-bit integer in this case, allows me to then directly sort of, you know, write data into that value. And it will take whatever is there in the sensor data register and write it into that. And as we'll see later, that actually does something which is the equivalent of a put C or a fputs, which literally takes some data, sends it out to a peripheral, and that peripheral has the hardware logic which knows how to display it or do something with it. It could be something as simple as turning on a button, right? Or in this case, actually what we are doing is we are reading from the sensor data register, not writing to it, so it will be able

to take a bite right from some memory location and store it into this variable that we call sensor data. It is very similar, in other words, to what this F get T function is doing, except that this is directly doing it at the level of hardware, and it makes it very clear to you exactly what is being done. So, in some sense, these are just two examples of what code would look like. Both are C, both are valid C code. One of them is targeted more at an embedded system, the other is targeted at a general-purpose C programming environment. So, to summarize this portion, right, C is often used as a starting point for embedded programming. It's close to the hardware, and it's easy to appreciate the importance of memory and resources when you use a language like C. Now, a lot of what we will be doing will be manipulating memory. It's, in some sense, a slight misuse of the concept of an address, which allows us to directly talk to the input and output hardware, right? We'll see how that works a little bit later on, but we'll not get into too

much detail of how the hardware part of it works. Okay, so the kind of structures in C that are important for an embedded engineer to know. Of course, you need to know what data types are, what kind of control logic, conditionals, loops, and so on are available, the idea of functions, modular programming, reusability, and of course memory and how to manage it. That is something we will be talking about a lot more as we proceed through the course.

Basics of Embedded C

IIT Madras - BS in Electronic Systems

Embedded C programming focuses on writing efficient code for embedded systems, with a strong emphasis on its differences from regular C.

The language's close relationship with hardware allows for fine-grained control over system resources, while also providing structured programming capabilities for higher-level abstraction.

C has been instrumental in operating system development, particularly Unix, and its efficiency is a key concept that will be explored further in the context of embedded systems.

The Role of C in Operating Systems and High-Performance Applications

The C language is crucial for operating systems like Unix and Linux, providing fine-grain control over resources and straightforward translation to Assembly Language.

C is also popular for high-performance code in scientific computation, memory-intensive applications, network applications, and game development due to its raw performance.

The language offers various data types, with the standard integer header file providing additional options for fine-grained control, which is essential in embedded systems.

C has tightly restricted storage and computation space, making it crucial to use the right number of bits.

The struct keyword allows for encapsulating multiple data types, improving code readability and maintainability.

Other data types like enums and unions offer more complex structures, with enums being useful in embedded systems and unions providing different views of the same memory bits.

Control structures in programming include conditional statements like if-else and switch-case, which help in making decisions based on different conditions.

Iteration is achieved through loops, with for loops used for a predetermined number of iterations and while loops offering more flexibility.

Infinite loops are common in embedded systems, where the code continuously checks for a particular value.

Functions in C programming provide reusable code, allowing for modular design and improved code readability.

They can take parameters, have a return type, and use pointers to update values in memory, enhancing their flexibility.

The effective use of functions, along with features like header files and libraries, enables well-structured and systematic code reuse.

Understanding Memory Management in Embedded Systems

The stack is a memory area allocated for each function call, enabling recursion and local variable creation.

The heap, on the other hand, is used for general-purpose storage, including global and static variables, as well as dynamic memory allocation.

Careful memory management is crucial in embedded systems with long-running code, as improper allocation can lead to memory exhaustion and system crashes.

Embedded C is a variant of C programming, designed to directly manipulate hardware and optimize resource-constrained operations.

It is commonly used in consumer electronics, automotive systems, and medical devices, all of which have tight constraints on power, size, and cost.

The language's ability to control instruction generation makes it ideal for meeting the specific requirements of embedded systems.

Defining a Sensor Data Register in Embedded C

The sensor data register is defined as a hexadecimal number, acting as a pointer to an unsigned 8-bit integer.

This allows for direct data manipulation, either writing to or reading from the register.

The use of C for embedded programming is emphasized, as it provides close interaction with hardware and memory management, which are crucial for manipulating input and output devices.