1. What Is a Variable?

A variable is a named location in memory that holds a value of a particular type. When you write uint8_t temperature = 25; the compiler reserves one byte of SRAM, remembers that the name temperature refers to it, and arranges for the value 25 to be stored there. Everything about variable declaration in embedded C follows from six properties that every variable has:

2. Rules for Naming Variables (Identifiers)

Good variable declaration in embedded C starts with a good name. The name of a variable is an identifier. C has firm rules, and embedded teams add conventions on top of them.

Naming conventions used in firmware

3. Declaration Versus Definition

Variable declaration in embedded C involves two different actions, and these two words are often confused, yet the difference is essential as soon as a project has more than one .c file.

The classic multi-file structure puts the definition in one .c file and the declaration in a header that every other file includes. The compiler then checks that all files agree on the type, and the linker connects them to the single storage location:

4. Initialization: Giving a Variable Its First Value

Every variable declaration in embedded C should also say what the first value is. Initialization means giving a variable a value at the moment it is defined. It is different from assignment, which changes the value later. For example int x = 10; initializes; x = 20; assigns.

5. Uninitialized Variables and Garbage Values

A variable declaration in embedded C that omits the initial value has consequences. A local variable that you define without an initial value is not set to zero. Its storage is part of the stack, which still contains whatever earlier function calls left behind. Reading it yields an indeterminate value, commonly called a garbage value, and in C reading it is undefined behaviour.

The output is not reproducible: it depends on what ran before, on compiler flags and on the platform. On a microcontroller the stack is not cleared at reset, so garbage values come from earlier code or from random power-up contents of SRAM. Bugs caused by them are among the hardest to find because they may appear only occasionally.

6. Global and Static Variables Are Automatically Zero

The C standard guarantees that objects with static storage duration (globals and variables declared static) are initialized to zero if you give no initializer: integers become 0, floats 0.0 and pointers NULL. Local (automatic) variables get no such treatment.

7. How the Startup Code Initializes Variables on the STM32F407

To understand variable declaration in embedded C fully you must know what happens before main(). When the Cortex-M4 comes out of reset it does not jump straight to main(). It first runs Reset_Handler from the start-up file (startup_stm32f407xx.s), which prepares the variables:

This is why the order of the diagram matters: a global with an initial value costs both flash (the initial copy) and SRAM (the working copy), while a zero-initialized global costs SRAM only. Lesson 4.3 and Module 11 explore these sections in detail.

8. Constants and Initialization Rules for Global Variables

For variables with static storage duration the initializer must be a constant expression, known at compile time, because the value is placed into the program image. For local variables the initializer can be any expression, evaluated each time the block is entered.

Note that const only promises that your code will not modify the variable; the initialization rules above still apply. You will meet const in depth in Module 13.

9. Common Mistakes With Variable Declaration and Initialization

10. Best Practices for Variable Declaration in Embedded C

• Initialize every variable where you define it; declare it as late as possible, in the smallest scope.
• One variable per declaration; use fixed-width types.
• Put extern declarations in headers and definitions in exactly one .c file; include the header in the defining file so the compiler checks consistency.
• Use descriptive names with units; follow one prefix convention for globals and statics.
• Never rely on garbage; do not rely on zero either if the code might be reused without the standard start-up file: initialize explicitly when it matters.
• Prefer fewer globals: each one is shared state that any function (and any interrupt) can change.
• Enable -Wall -Wextra -Wshadow -Wuninitialized and treat warnings as errors in firmware builds.
• Group related variables into a struct and initialize with designated initializers.

Key Takeaways — Lesson 4.1

• A variable has a name, type, value, address, scope and lifetime.
• Identifiers use letters, digits and underscores, cannot start with a digit and are case-sensitive; use descriptive names with units.
• A declaration announces a name and type (extern int x;); a definition allocates memory (int x;) and must exist exactly once.
• Initialize at definition: int x = 10;. Partial array initializers zero the remaining elements.
• Uninitialized locals contain garbage; reading them is undefined behaviour.
• Globals and statics are zero by default because the start-up code clears .bss; initialized globals are copied from flash to .data.
• Initializers for globals must be constant expressions.
• Good variable declaration in embedded C: initialize everything, minimise scope, one definition, many declarations.

Frequently Asked Questions