Understanding Bit Manipulation in Embedded Systems Programming

Embedded systems rely heavily on bit manipulation for efficient hardware control and operations.

### Understanding Bit Manipulation and Pointers in Embedded Programming
* 💻 Bit manipulation is crucial in embedded systems as it **directly interacts with hardware**, allowing **control over individual bits** within registers and memory locations.
* 🔧 The process of manipulating bits includes **setting, clearing, and toggling bits** using bit masks and logical operations such as **OR, AND, and XOR**.
* 📝 For instance, to set a specific bit in an 8-bit register, one creates a **bit mask** by left shifting the value one to the **desired bit position** and uses the **OR operation** to update the register.
* ⚙ ️ Conversely, clearing a bit requires an **inverted bit mask** and the **AND operation** to ensure the targeted bit is **set to zero** while other bits remain **unchanged**.
* 🔍 Checking the status of a bit can be done using a **bit mask with the AND operation** to isolate the desired bit, allowing the programmer to **determine if it is set or not**.
* 🔒 Atomic operations are essential to avoid race conditions during bit manipulation, ensuring that **read-modify-write sequences occur without interruption**, which is particularly supported in ARM Cortex processors through a feature called **bit banding**.
* 📍 Pointers in embedded programming store **addresses of variables**, enabling **direct access to memory and peripherals**, and must be handled carefully to avoid issues like **dangling or uninitialized pointers**.
* 🛠 Best practices for using pointers include **proper initialization**, **validity checks**, and **memory management** to prevent common pitfalls and ensure robust embedded software development.

[Music] [Music] So far, we have been talking about how memory gets allocated and the different factors that we need to keep in mind while looking at how to manage memory. But a very important part of what we do in a lot of embedded programming is what's called bit manipulation, right? This is important from the point of view of the fact that embedded systems are often directly controlling different kinds of hardware. And there is also a concept of something called an atomic operation that we need to keep in mind when we are actually trying to modify bits in various locations, either in memory or in IO peripherals. So, why do we need to manipulate bits, right? Bit manipulation is something which in a regular course in C you might come across at some point but is not going to be one of the main focus areas. It's not a terribly important thing, right? Yes, you are mostly dealing with numbers, but you are probably thinking in terms of integers or floating-point numbers, and directly manipulating the bits in memory is not a

very common occurrence in regular C code. Embedded systems, on the other hand, rely on this extreme excessively okay uh, and part of the reason for that is we are directly trying to control hardware units, and literally a single bit uh, either in a register inside a CPU or mapped onto the peripheral uh, memory of a CPU can actually act as a switch or a control signal that can enable or disable different kinds of logic right now. That's fine. It basically what we are trying to say in other words is that embedded systems need to directly be a B to set or clear different single individual wires right. The problem is that inside a CPU, I'm usually dealing with words that are either 8 bits or 16 bits or 32 bits. They are fixed by the design of the CPU and don't make it particularly easy to either set or clear individual bits inside that 16-bit chunk okay. So what usually happens is very often we end up having what are called status registers for example where multiple different bits are grouped together and you need to read through

the data sheet and find out, okay, you know, if this bit is set, it means something. If this other bit is set, it means something else. If a third bit is set, it means something else. If I modify one of the bits over here, it will turn on some feature over there. If I modify another bit, it will turn on or turn off some other feature somewhere else, right? So, we group them together in some way that is convenient for us, but the point is that actually manipulating individual bits is there, then not very trivial or easy. There are standard sort of template codes that we use in order to actually do this, and we're going to look at a few examples of that, right? The simplest and most straightforward example is, let's say that we have an 8-bit word out here, right? So, B7 to B0 is an 8-bit word. It has B7, B6, up to B0, and this is stored, let's say, somewhere inside a memory location of some embedded system, or it could actually even be directly inside a register.

inside the CPU, or it could also correspond to a register or a memory location, which is actually a sort of pseudo memory location. It actually corresponds to an input-output port, something which is actually connected to a set of wires outside. How that gets implemented is actually part of how digital logic implements the interfacing between a CPU and the outside world. It's not something we can go into detail in this course, but is relatively straightforward and easy to understand once you understand the fundamentals of how the digital logic works, and is well worth understanding even if you are primarily looking at it from the software point of view. Okay, so we'll not get into the details of how it's implemented. What matters is it is possible that this 8-bit register actually corresponds to a memory location or a memory address, which is not a physical memory location, but actually corresponds to some external port or a peripheral that we want to modify. Anyway, the point is initially let's assume that this value 11 1 0 1 011 is the binary value stored in this

8-bit register, and what I want to do is to change the value of B3 from 0 to 1, yeah, and I want to do this completely using C. Now, what we do in that case is I first need to get the old value which was there in this 8-bit register, right? I am then going to set this bit to one and store the new data back into the register, okay? How does that look in a language like C? I first need to create something called a bit mask, right? So, this concept of a bit mask is very important. It's something that will keep coming out repeatedly when we are doing this bit manipulation in this context. The bit mask basically says it is the number one left shifted, so this less than less than is a left shift operation, right, by the bit position where bit position in this case would be three because I want to set the bit three. If I set bit position to zero, it would basically be one left shift by zero, which would basically result in a one over here. It

wouldn't shift at all. One left shifted by one would come here. One left shifted by two would come here, and so on, right? So, one left shifted by three in this case will have three zeros after the one. Okay, now what I do is I first take the old value of data. I read it, right? So, anything which is on the right-hand side of this equals uh sign, it means I have to first read this value, possibly into some temporary storage register. Then I take this bit mask one left shift by 3, and I apply this operation, which is the or operation, the logical or operation. What does or operation do? One or with one is one, one or with one is one, zero or with zero is zero, but here zero or with one, right? Corresponding to this becomes one, all the others remain the same. One or with one, zero or with zero, one or with one, one or with one. Okay, so uh sorry, let me just rephrase that last part. What we are doing here is we first read in the value of data. We get this

8-bit number 11 1 0 1 011. We have got it into some internal register, let's say, and now I take my bit mask, which is this value of all zeros and uh one 0 0. Okay, now if I take a bit twice or of the operations, what I get is one or with zero, the result comes out as one. This one is ored with the second zero. This zero is ored with the third zero. So, one or with 0 gives me 1. 0 or with 0 gives me 0er. That's what comes into this place. But in this location B3 alone, zero is ored with one, and what comes out is a one over here. So, I'm starting out with this. I or it with this, and I get this as the result. This is an example of bit manipulation where we are setting an individual bit inside a particular value. Okay, what are the other things that we can do? We can clear a bit, right? So, clearing a bit, let's take the example.

of bit four. Okay, let's say that I want to clear it. That is, I wanted to change from 1 to zero while all the other bits remain exactly the same as before. None of them should change, okay? How do I make sure that a bit does not change in value? Well, the easy way to do it would be to say, if it was a one, I need it to remain as a one. If it was a zero, I need it to remain as a zero, okay? So, what we do is we sort of create an inverted bit mask, right? Where I say that I'll first take my one left shifted to the position where I want to make the change, right? So, left shift by four in this case, and then I negate it, or I take the complement of whatever I have got here. Wherever I have zeros, I replace them with ones, and wherever I have ones, I replace them with zeros. So, I end up getting this sequence of bits. Now, let's see what happens if I do this. I take B 0, and I and it. I do a

logical and operation. I and it with the one so one and Ed with one will give me a one. The second one anded with one will also give me a one. This zero anded with a one will give me a zero. It does not change the value. Okay, what does change is that when there was a one over here, it will force it to a zero. Now you might be wondering, okay, why did I have to do all of this, right? Couldn't I have just ored it or done something else? Not quite, because you want to make sure that all of these, the one places where the bit mask is one, are left unchanged, whereas this one is forced to zero. The only way to force the output of an and gate to zero is that your second input actually has to be zero out there, right? So we force whatever the value of B4 was, whether it was zero or whether it was one, it gets forced to zero at the end. That's what we mean by clearing a bit, even if it was zero to

start with it would end up being Z at the end. Okay, now we could go further and say I will toggle a bit. What does toggling mean? If it was a zero, I wanted to convert to a one, but if it was a one, I wanted to convert to a zero. Okay, now how do I do that? The same story, we create a bit mask. Uh, sorry, this should actually be corrected. This bit mask is not quite right. It should be a one in uh, location number. Okay, location here. Yeah, this is what the bit mask should look like, right? There's a one and then two zeros after that. All right, so once we have that, I can now do an XR operation, an exclusive or. How does XR work? A one XOR with a zero gives me the same one itself. A zero XOR with a zero gives me back zero. But if I had a zero over here and I XOR it with one, I'll get a one. But if B5 had the value one and I XOR it with one, one XOR'd

with one will give me a zero, okay. So, all of this obviously assumes that you are familiar with the basics of Boolean logic, right, which you should be at this point. But obviously, it is not doing anything very complicated. This is not some, uh, you know, sophisticated application of the laws of Boolean logic. It is just a very simple sign kind of computation where I use or in order to set a value to one. I use and in order to force a value to zero when I want to. I use xor to switch the value. If it was a zero, make it one. If it was a one, make it zero, right? So, all of these can be used to directly manipulate individual bits in a system. Now, one other thing that is very useful and does not actually involve changing the value of a bit is just to check if a particular bit is set or not, right? What does that mean? Let's say that I have managed to read this back from some kind of a status register, but I don't really care about the values of bits 1, 0, 4, 7, 2, and so on. I

only care about bit six. I want to know whether it was set or not. How do I check that? Similar to how we did with the first case, right? We create a bit mask, right? Once again, this thing should be, yeah, the bit mask should have a one at the position that we are interested in checking. And what we do is we now have a bit mask which looks like this: 01 and all zeros. I want to use this bit mask to get rid of every bit other than the one that I'm interested in. So, what should I do? I AND it with the data that I'm trying to compare against. Okay, that guarantees that anything corresponding to these zeros gets pushed to zero. But if there was a one in bit position number six, that would survive into my final result. But if it was zero, it would remain a zero. So, what do I do? I basically check. I take the data, I AND it with my bit mask, and check if the result is zero. If it's zero, it meant that the bit in position number six was actually

zero. If it's not zero, it means that the result I got is this 0, one something. I don't care what the result is; all that I care is that it's not zero, okay? So, in this way, I can also check a particular bit and find out whether it has been set or not. Examples of where this gets used in practice: one of them is, for example, to turn LEDs on or off, right? So, for example, I could have something where I say I have a particular memory location, and this use of the word volatile is something that we will, you know, be using quite a lot in embedded systems. It basically says I can use a pointer in order to directly update a particular memory location, and by using this thing, this particular notation, which is star odr or equal to, that is star odr is equal to star odr or with one less than less than LED pin, it allows us to set the bit corresponding to the LED. The other one is and equal to, which allows us to clear the bit, so I can turn

an individual LED on or off by directly manipulating a particular bit within a given register. Similarly, I could use it to check whether a particular button has been pressed. I read from a register that has 32 bits. I pull out one of those bits by doing this ANDing with the one less than less than button pin and check whether the result is true or not, that is, it's zero or not. If it's non-zero, I return the value one, and if it is zero, I return the value zero. Okay, now one thing that you might notice over here is that there is a possibility of something called a race condition, right? It's not an obvious thing to keep in mind unless you are already familiar with the concept of, you know, multi-processing or things where there are multiple writers to a particular pin or a particular value. Now, basically, what I'm trying to say over here is, let's say that I have a register with which I'm reading in some value data, right? At this point in time, there is some instruction that

reads the value from data and puts it into some temporary register inside the CPU. Then there is something else which actually creates this bitmask ORS. It updates that register, and then there would be a store operation which actually rotates back into the location where it was. The point is there are a finite number of clock cycles between the time that I read the data and that I'm writing the new value back out. Okay, during this time, it is possible, especially when you are interfacing with the outside world where other things could be connected to the pins that you are looking at, that something else has actually changed the value of data. The bit that you thought was not set has actually been set to some other value, right? Especially, let's say that if you're trying to toggle it, for example, you might find that you were toggling it under the assumption that it was zero, but it turns out that it had actually changed to one in the meantime. There could be scenarios where something of that sort could happen, which it depends entirely on what kind of hardware you

are creating, but it can lead to problems if you're not careful with it. So, this requires what is called an atomic operation. An atomic operation allows you to do something called a read, followed by modify, and write. That is, I read the value of data, I modify it, and I write it back as one unitary operation, which does not allow any other changes to data in between. Okay, now it's not possible to do this directly in software. You need some kind of support from the hardware to guarantee that nothing can change the data in between your reading, modifying, and writing, right? So, there is hardware support required on the CPU side, but this is a common enough requirement in many scenarios that most CPUs provide some way by which you can do these kinds of atomic operations. It turns out that in the context of the ARM Cortex processor, which we will sort of be relying on for most of this course, there is something specific called bit banding, right? What bit banding does is it basically allows us to take one single address in the

original memory, and it gives us 32 addresses in the bit-banded memory corresponding to one address out here, one address in the original memory. Usually, corresponds to a 32-bit word. What we say here is every one of the bits inside that word now has a unique address associated with it. Now, obviously, it's not possible to do this for all the memory that you have available to you. So, what some processors do is they take a specific 1 Megabyte area of memory and say that within this 1 Megabyte area, every address, every bit of location has a unique address associated with it, right? Which, for example, allows you to do things like this, which is that I can probably define a macro which allows me to take the position of an individual bit, take the address that I'm trying to write into. So, in other words, if I have a particular address, a memory location, and a bit within that memory location that I want to set, it will allow me to do one particular write operation directly into that write, and I

can directly update an individual bit inside a 32-bit value. This is something which is specific to ARM Cortex processors. It's one of the things which they added simply because it is useful enough in practice that it actually makes certain kinds of code simpler to do, and it also guarantees that this is going to be an atomic operation, right? So, direct bit manipulation can be done that way. You can literally do the set pin, for example, would become as simple as just writing into pin number five of an address, or clearing would basically say just set the value of a pin to zero, and you're done. You don't need to create a bit mask, you don't need to sort of make sure you don't modify the other bits of the system, and so on. It just does exactly what is required of you. So, the advantages of bit banding, obviously, it's atomic. It helps with certain kinds of real-time operations, right? It avoids race conditions. Race conditions are things where two possible pieces of hardware might be trying to modify the same thing at the same time.

uh it also helps a lot with code clarity. It helps to make your code readable and easier to understand. So, to summarize, bit manipulation is an essential part of most programs written for embedded systems. It helps when we are trying to interact with peripheral devices, right? Especially when we are trying to control different kinds of hardware. Maybe we are trying to enable a particular hardware, or we want to receive inputs from hardware. We want to check if a particular bit has been set to one or not. There are standard templates, in other words, the code format that you use, the idea of bit masks, and using it to modify a single bit within a multi-bit register are fairly standardized. The one possible difference is the bit-banding operations in ARM processors, which actually make life even easier but are restricted to those processors and, you know, can be used only in that context. But this whole idea of bit manipulation is something that becomes very important in a lot of embedded programming that we'll be looking at as we move forward. All right, so far we have been

looking at different uses of memory and the kinds of memory manipulation techniques, allocation, and so on that we would look at. Uh, let's now look at the use of pointers in embedded programming and some of the best practices that are recommended in terms of how we use pointers. So, what is a pointer in C? It's a variable that stores the address of another variable. This definition is something that you should really internalize completely. Try to understand it very clearly, right? The pointer is literally just a variable that stores the address of another variable, right? That's pretty much all there is to it. It points to a location in memory, and it allows you indirect access to a variable. Okay, uh, and the point to keep in mind is that variables in C are just locations to store data. Anything that is nontrivial, well, dval is probably not the right word to use, but of a size that is greater than and something that can fit directly inside a register necessarily has to go into memory, which means that it occupies a certain location in memory.

which in turn means that it has an address associated with it. The only things that do not have addresses are things that are directly in the registers of the CPU. Okay, and even technically, they do have an address, which is which register they are in, but that's not part of the address space of the system. Now, the point about the use of pointers comes in to the fact that I can now directly use the address of a variable in memory to directly manipulate it without even knowing the name of the variable or knowing anything else about it. Indirect access to a variable becomes possible. Now, summarizing the syntax, right, we are already familiar with this. You can declare a pointer to an integer by just basically saying int star PTR. I can take, once I have declared inar PTR, the compiler knows that PTR is used to hold pointers to integers. And if my variable X had previously been declared as an INT, I can get its address and put it into PDR, and the compiler would know that it needs to find out that X is a

particular uh variable stored somewhere in memory. It has an address. Take that address and store it into PTR. Once I have done that, I can actually do things like Star PTR equal 42. And what that means is it would then go look up that location in memory corresponding to the address in PTR and change its value to 42. Which means that the next time I try using the variable X, I would get the value 42 because that's what I have indirectly updated out there. Now, where do we use this? Pretty much for any kinds of arrays and array manipulation, dynamic memory allocation. The whole idea of malok revolves around the idea that it gives you a chunk of memory. But how does it do that? It just gives you a pointer to the beginning of that memory. And then it's up to you how you use it, right? There are certain kinds of data structures like linked lists, trees, and so on that rely on the use of pointers for implementing them. But those are not things that we regularly run.

into in embedded programming, at least, so we'll not be looking into those, uh, much for now. With this context, the idea of a memory map, which I have already mentioned a few times before, is something that I want to emphasize and has to be made very clear. It is something which you will be coming across a lot in the embedded systems course, right? What a Memory map means is this: on a 32-bit architecture, meaning that the registers inside your CPU are capable of holding 32 bits, right? Every pointer is going to be a 32-bit number. So, if I assume that my pointers are 32 bits wide, what that in turn means is that it's capable of representing up to 2 to the power of 32 different addresses, which is roughly around 4 into 10 to the power of 9, okay? Now, the normal convention is that one address corresponds to one byte, although we usually have word addressable, so one address would be used in order to load in four bytes, but then we usually increment the address by four. So, the convention in most systems is

that one address corresponds to one byte. Now, 4 into 10 power 9 is 4 GB, right? But the actual memory in most systems, especially embedded systems, could be significantly less. Let's consider a relatively large embedded system, even something like a Raspberry Pi, right, which would typically have something like 512 megabytes of memory. Okay, what that means is I have a physical memory, right, which corresponds to some number of addresses out here, but the remaining 4 into 10^9 minus 5 into 10 Power 8, right, the 3.5 into 10 power uh 9 addresses that we have are basically unused. Okay, now some of you may have used Raspberry Pis with more than 4GB of memory, for example, those usually use uh ARM processor that is not 32 bits or has some kind of extensions that allow it to work Beyond 32 bits for the address alone, right? So, in order to address anything beyond 4GB, technically 2GB, you need to uh have some kind of address extensions that allow you to use

wider addresses something beyond the 32-bit range. Okay for embedded systems, that's rare, especially in the ARM Cortex series. We pretty much just have 32-bit registers, 32-bit addresses. What that means is if I have a certain amount of physical memory, there is also a large amount of address space that is unused. Okay, and as indicated over here, basically what it means is let's say that I try to read or write from this location in memory. There is no physical memory there, and if I'm lucky, I will just get back a null response. In practice, most likely the operating system will catch that as an error and maybe give you something like a segmentation fault, saying that you tried to access something which does not exist or is completely outside the memory range of the system. It should actually trigger some kind of an access violation or an exception in the system. But the interesting thing is why should I waste those addresses, right? Maybe I can have something where I have a small piece of digital logic which is attached to my computer.

to the same address bus that is used to communicate with memory. What this does is it basically looks for addresses in this range, and if it finds that your CPU is trying to create an address in this range, it will basically wake up this peripheral. Wake up is a colloquial way of putting it; that's not exactly what's happening. It's enabling it, and this peripheral is then responsible for answering any request that comes in there. So, for example, if I try to read from this address, this peripheral can decide what data to give back. If I try to write to this address, this peripheral will get data and can then decide what to do with it. This is a very powerful idea. What it allows us to do is create digital logic for each of these so-called peripherals. It could be a keyboard, it could be a mouse, it could be an LED, it could be a video screen, a touchscreen, right? Anything pretty much that we use in order to interact or that a computer, CPU needs to interact.

with in the outside world can be given addresses, and if those addresses are used in order to write to, then the data goes into that peripheral. If I try reading from it, the data comes out of that peripheral and into the CPU. Okay, so all of this is implemented using digital Logic. The CPU cannot distinguish whether a response to a read request came from memory or from a peripheral. That is by Design. The CPU actually does not know the difference, right? And as far as code is concerned, all it means is I can now use pointers to either point to physical locations in memory or to one of these peripherals that I have created and given some addresses to. Who decides the addresses? The person building the computer or designing the system, right? So, if you are building your own embedded system, there will be some way by which you can actually get some degree of control over the addresses that are assigned for these different parts. As an example, let's say that I have some address out here. It probably corresponds to this area of physical memory. And if I declare this int pointer

and then write this value. It will actually write the value 4 to somewhere into this physical memory. On the other hand, if I say take the address zero, which looks like it's a low address, it probably corresponds to something in the region of peripheral 3. If I try writing a value there, it goes to this peripheral 3, and that will basically see a one on one of the wires connected to it, and it has to decide what to do with it. One of the simpler things it could do might be turn on an LED, or maybe turn on a fan, or activate a relay, or something else of that sort could be used. So, these are extremely common scenarios in embedded systems. We usually have peripherals that are mapped to an address or an address range. An example of that could be you have a sensor register, right, which is basically given an address, as I said. This choice of address could be by the system designer, and once the person has decided that, all I need to do is read from that location, and it will take

whatever came out of that peripheral and put it into this variable that I'm calling sensor data. Out here, I can then use it for my computation and just, you know, I don't even need to know that this actually came from an external source. The key thing over there is this volatile word that we used while declaring the pointer, right? You would notice that this has been declared as a volatile uint8_t star, right? What does that mean? Volatile explicitly marks a pointer and says, Do not optimize or cache. Cache means to store the value that is actually coming from that particular pointer. When I declare a pointer to be volatile, it says that every time I try reading from it, I need to actually put the address out on the bus, see what data comes back from the peripheral, and give that. Do not try to optimize this and say, 'Hey, this data is already sitting in the cache here. Go ahead and take it.' Okay, so that volatile keyword is important. The compiler will not silently remove it because if you think about it, if I wrote a code like

this right toggle LED. If you actually look at this code, it's a void return type. It does not return a value. It only takes one input, which is a 32-bit unsigned integer. If this was a regular C program, I would probably say, Hey, wait a minute. This is a function which takes one input, does not return a value, it's doing something out here. But as far as I can tell, that you know doesn't really have any impact because it's storing some value into a memory location. Why can't I just optimize this and say, You know, I don't even need to have this code? But that would completely defeat the purpose of the memory map of the hardware peripheral, which is why the volatile keyword. Once we have it when we declare a register like this, tells the compiler, Do not optimize anything containing this. Make sure that there is an actual load or store instruction that gets generated and will actually get executed when we try and access this. So pointers are used in embedded systems in many contexts. The most obvious and common one is going to be for

interfacing with peripheral devices. Right examples would be something like, you know, reading from an analog to digital converter and so on, things that we'll be seeing more of later, but also perhaps for creating, you know, buffers that are used for communicating with things like UARTs or the SPI communication peripherals and so on. Okay, and potentially also for higher speed peripherals like video memory, network buffers, and so on. There are many issues that come up in the context of the safety of using pointers, right? We have things called dangling pointers. We have something called dangling pointers. A dangling pointer will just hold a value. It is, keep in mind that a pointer just holds a value. It is not checked for validity, and it might end up pointing to a location that has been freed or gone out of scope. Okay, you could also have uninitialized pointers. These are sometimes called wild pointers, and the main problem there is that we are trying to use something before allocation. We have not yet allocated the memory for it, but we are trying to use it null.

pointers and random pointers are possible. You can end up with, you know, issues of that sort. So, pretty much coming to the end, we have, uh, so what are the kinds of best practices that we can use in the context of pointers, right? Remember to explicitly initialize the compiler. Very often, it doesn't do things like that automatically for you, right? Uh, anytime that you use a pointer, check the validity. Make sure it is not null because if you try to dereference or star of a PTR where PTR is equal to zero, you are basically trying to access, well, location number zero, right? Now, you could say maybe that's actually a valid location, but you know, please don't write code like that. The general assumption is that the address zero is not supposed to be used again. Best practices: whenever you use malloc, make sure it is combined with a free to, you know, release the memory once it is done. You can also let the compiler know that modifications through a pointer are not expected by using const qualifiers, right? And needless to say, using pointer arithmetic, right, is

something that is possible, sometimes even encouraged, in the context of C, but should be used with extreme caution. You really need to know exactly what it is that you are doing in these contexts. So, to summarize, a memory map is an essential part of embedded programming, right? Pointers can be used to manipulate peripheral devices directly. They are immensely powerful; they are also immensely dangerous. So, you can do good things as well as run into trouble when you use them. There are many pitfalls and traps that you could run into when you try to use such systems, and careful use of best practices is absolutely essential to avoid problems of this sort, right? There are tools, right? Once again, this is something that I keep stressing multiple times. The focus of this course is not to teach you all possible tools, right? At best, we'll be mentioning a few of them in passing, but when you are actually working to develop code for a specific microcontroller, it's a good idea to learn all the tools that come with that microcontroller and that can be used.

over there in order to improve the performance or the quality of the code that you have right. Very often, compilers also come with memory sanitization tools and so on, which will allow you to detect and avoid such errors as early as possible. So, learning how to use those tools is something that, as a sort of practicing embedded software engineer, you definitely should be doing.

Bit Manipulation

IIT Madras - BS in Electronic Systems

The Importance of Bit Manipulation in Embedded Systems

Bit manipulation is crucial in embedded programming as it directly controls hardware, with individual bits acting as switches or control signals.

CPUs typically deal with fixed word sizes, making it challenging to set or clear individual bits, leading to the use of status registers.

The process of modifying bits involves creating a bit mask, which is a key concept in bit manipulation.

Bit Manipulation: Setting, Clearing, and Toggling Bits

Bit manipulation involves using bitwise operations to modify individual bits in a value.

To set a bit, a left shift and logical OR operation are used, while clearing a bit requires an inverted bit mask and logical AND operation.

Toggling a bit is achieved through an exclusive OR (XOR) operation with a bit mask.

Boolean logic is used to manipulate individual bits in a system, with simple operations like OR, AND, and XOR.

A bit mask can be created to check if a particular bit is set, using AND to isolate the bit of interest.

This technique is commonly used in embedded systems to control LEDs and check button presses, but can lead to race conditions in multi-processing situations.

Atomic Operations and Bit Banding in ARM Cortex Processors

Atomic operations are crucial for ensuring that data is read, modified, and written back without interruption, requiring hardware support from the CPU.

ARM Cortex processors utilize bit banding, which assigns unique addresses to individual bits within a 32-bit word, allowing for direct and atomic bit manipulation.

This technique simplifies code for tasks like setting or clearing a pin, while also helping to avoid race conditions in real-time operations.

The Importance of Bit Manipulation and Pointers in Embedded Programming

Bit manipulation is crucial for interacting with peripheral devices and controlling hardware in embedded systems.

Standard templates and bit masks are commonly used for modifying bits within multi-bit registers, with ARM processors offering bit-banding operations for added convenience.

Pointers in C store the address of variables, allowing for indirect access and manipulation of data in memory, and are essential for array manipulation, dynamic memory allocation, and implementing data structures like linked lists and trees.

Understanding Memory Mapping in Embedded Systems

Memory mapping is crucial in embedded systems, particularly in a 32-bit architecture, where each pointer represents up to 4 billion addresses.

Despite the theoretical address space, most systems have significantly less physical memory, leaving a large portion of addresses unused.

This unused address space can be leveraged to enable peripherals, allowing them to respond to requests from the CPU and facilitating interaction with various devices.

Addressing Peripherals in Embedded Systems

In embedded systems, peripherals are assigned addresses, allowing the CPU to read from and write to them without distinction from memory.

The system designer has control over these address assignments, enabling the use of pointers to access both memory and peripherals.

The volatile keyword is crucial in pointer declarations, preventing optimization and ensuring that each access to the peripheral's address results in a fresh read from or write to the hardware.

Interfacing with Peripheral Devices and Pointer Safety

Pointers are crucial for interfacing with peripheral devices and creating communication buffers, but they come with safety issues like dangling, uninitialized, and random pointers.

Best practices for using pointers include explicit initialization, checking for validity, pairing malloc with free, using const qualifiers, and exercising caution with pointer arithmetic.

Learning to use tools provided by the microcontroller and compilers for memory sanitization can help detect and avoid pointer-related errors.