What are the best ways to write Embedded C code for microcontrollers?

Embedded C is a popular programming language for microcontrollers, which are small and low-power devices that control hardware functions in many applications. Microcontrollers are often used in control engineering, which is the discipline of designing and implementing systems that can monitor and regulate physical processes. Writing Embedded C code for microcontrollers requires some specific skills and techniques to optimize performance, reliability, and maintainability. In this article, you will learn some of the best ways to write Embedded C code for microcontrollers, such as choosing the right data types, using modular and readable code, avoiding common pitfalls, and testing and debugging your code.

1 Data types

One of the first things to consider when writing Embedded C code for microcontrollers is the data types you use. Data types determine how much memory and processing power your variables and constants consume, which can affect the speed and efficiency of your code. You should always use the smallest data type that can fit your data range and avoid unnecessary type conversions. For example, if you need to store an integer between 0 and 255, you can use an unsigned char instead of an int, which saves 2 bytes of memory. You should also use fixed-width data types, such as uint8_t or int16_t, which are defined in the <stdint.h> header file, to ensure portability and consistency across different microcontrollers.

Add your perspective

TalChaim Sigron

Senior Embedded Software Engineer at Apple - ex 81
Report contribution
On many systems you should pay close attention and make sure you access your data in an aligned way while not wasting too much on padding, using structs and unions can make it challenging at times.

Like
Laurent Kersten

Senior Embedded Software Architect.
Report contribution
In my experience, sticking to the smallest data can make the code less efficient (i.e. slower). Especially when MCU word size is smaller than selected data type (8 bits integers on 32 bits MCU for instance). <stdint.h> contains fast integer type that can be used to overcome this. Those are garanteed to be no smaller than the selected size (but can be larger if it make code more efficient).

Like

2 Modular and readable code

Another important aspect of writing Embedded C code for microcontrollers is to make your code modular and readable. Modular code means that you divide your code into smaller and independent functions that perform specific tasks, and then call them from your main program or other functions. This makes your code easier to understand, reuse, and modify, as well as reducing the chances of errors and bugs. Readable code means that you use clear and consistent naming conventions, indentation, spacing, and comments to make your code self-explanatory and easy to follow. You should also use macros and constants instead of hard-coded values, and avoid using global variables and magic numbers, which can make your code confusing and prone to errors.

Add your perspective

TalChaim Sigron

Senior Embedded Software Engineer at Apple - ex 81
Report contribution
When designing any software it’s important to understand the product requirements, plan ahead, and write generic and extendable code. In an Embedded system you might be forced to sacrifice some of those principles for performance or memory. The critical aspect is to make these decisions consciously, document them, and, as part of the development process, regularly reassess whether they still align with the project's goals. Furthermore, it's crucial to strike a balance between optimization and maintainability. This approach ensures that the embedded software not only meets its functional requirements but also maintains a level of quality in terms of reliability, security, and correctness.

Like
Laurent Kersten

Senior Embedded Software Architect.
Report contribution
Code reuse is usually achieved by isolating HW dependent code in a few module and provide a generic interface (for instance read/write ...). The HW independent code should ideally, only relies on those interface. Hard coded value is usually a bad idea use typed constant (i.e const uint32_t my_constant = 100U). Global variables should be avoided. If this really cannot be avoided, then it is best to provide get/set function to access it where code for shared access, synchronization could be added if needed without touching the rest of the SW.

Like

3 Common pitfalls

Writing Embedded C code for microcontrollers also involves avoiding some common pitfalls that can cause problems or unexpected behavior in your code. For instance, floating-point arithmetic should be avoided as it is not supported by all microcontrollers and is slow and inaccurate compared to integer arithmetic. Alternatively, fixed-point arithmetic, which is the use of integers to represent fractions, can be used instead. Dynamic memory allocation should also be avoided as it can cause memory fragmentation, memory leaks, or memory exhaustion, which can crash a program or make it unpredictable. Static memory allocation, which is the use of fixed-size arrays or structures to allocate memory at compile time, should be used instead. Additionally, interrupts should be used with caution as they can block other interrupts or delay a main program if used incorrectly. Volatile variables should be used to communicate between an interrupt service routine (ISR) and a main program to prevent compiler optimizations that can cause errors.

Add your perspective

Laurent Kersten

Senior Embedded Software Architect.
Report contribution
To avoid unexpected behavior, I would suggest two things. First running code through static analysis and enabling "pedantic warning" on compiler. Although this can generate a lot of background noise, this can also help to avoid dangerous construct, undefined (or at least not obvious) behavior (such as mixing signed/ unsigned arithmetic for example). I would also suggest to stick a few data type (at least for variables involves in some computation) to avoid risky type conversion (out of range value), and if possible stick to unsigned arithmetic (to avoid not so obvious behaviors related to sign extension).

Like

4 Testing and debugging

Testing and debugging are essential steps for writing Embedded C code for microcontrollers, as they can help you find and fix errors and bugs in your code. You should always test and debug your code before and after deploying it to your microcontroller, to make sure that it works as expected and meets your requirements. There are various tools and techniques you can use for this purpose, such as simulators, debuggers, oscilloscopes, and logic analyzers. Simulators are software applications that emulate the behavior of your microcontroller and allow you to run and debug your code without using the actual hardware. Debuggers are tools that can connect to your microcontroller and help you monitor and control the execution of your code. Oscilloscopes and logic analyzers measure electrical signals generated by your microcontroller and its peripherals, so they can be used for testing the functionality of these components. Ultimately, testing and debugging will help you inform and reassure stakeholders, as well as provide valuable insights for improving the quality of your code.

Add your perspective

5 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

Add your perspective

What are the best ways to write Embedded C code for microcontrollers?

1

2

3

4

5

1 Data types

2 Modular and readable code

3 Common pitfalls

4 Testing and debugging

5 Here’s what else to consider

Control Engineering

Rate this article

Thanks for your feedback

More articles on Control Engineering

More relevant reading