C Programming from Basic to Advanced: A Practical Guide

Why Learn C Programming in 2026?

• Closest to the hardware: Direct memory access, bit-level control and predictable timing are exactly what microcontrollers demand.
• Everywhere in embedded systems: Firmware for STM32, ARM Cortex-M, AVR, PIC and 8051 chips is overwhelmingly written in C.
• Powers core software: Operating system kernels, device drivers, RTOS kernels and language runtimes such as CPython are built in C.
• Small and fast: A well-written C program can run on a chip with only a few kilobytes of memory.
• A gateway language: Once pointers and memory make sense, C++, Rust and even Python internals become easier to understand.
• A hiring signal: Embedded, firmware, automotive and IoT job descriptions routinely list C as a core skill.

C Programming from Basic to Advanced: Roadmap at a Glance

• Stage 1 (Basics): Syntax, variables, data types, operators, input and output. You can write and run small programs.
• Stage 2 (Logic building): Decisions, loops, functions, recursion. You can break a problem into steps.
• Stage 3 (Memory fundamentals): Arrays, strings, pointers. You understand how data lives in memory.
• Stage 4 (Intermediate C): Structures, unions, enums, dynamic memory, file handling, the preprocessor. You can build multi-file programs.
• Stage 5 (Advanced C): Bit manipulation, function pointers, volatile, memory-mapped registers, data structures, debugging. You can read and write firmware-grade code.

Stage 1: C Basics (The Foundation)

Structure of a C Program

Every C program follows the same skeleton. Learn it once and you will recognise it everywhere.

#include 

int main(void)
{
    printf("Hello, embedded world!\n");
    return 0;
}

• #include brings in the standard input/output library so printf works.
• main() is the entry point. On a bare-metal microcontroller, a start-up file runs first and then calls main().
• return 0; tells the operating system the program finished successfully.
• Statements end with a semicolon, and blocks sit inside curly braces.

Compile and Run Your First Program

gcc -std=c11 -Wall -Wextra hello.c -o hello
./hello

-Wall -Wextra switch on helpful warnings. Treat every warning as a bug waiting to happen.

Most embedded projects use C99 or C11, and C23 is the latest published ISO standard.

Variables and Data Types

A variable is a named location in memory. Give it a type, a name and a starting value, for example int count = 10;

Core types: char (1 byte), int (commonly 2 or 4 bytes), float (usually 4 bytes) and double (usually 8 bytes).

Modifiers such as signed, unsigned, short and long change the range and size.

Embedded tip: The size of int depends on the platform. It is often 16 bits on small 8-bit and 16-bit microcontrollers and 32 bits on ARM Cortex-M. When size matters, use the fixed-width types from .

#include 

uint8_t  sensor_id   = 7;     // exactly 8 bits, unsigned
int16_t  temperature = -25;   // exactly 16 bits, signed
uint32_t timer_ticks = 0;     // exactly 32 bits, unsigned

Constants and Type Conversion

Use const for typed, read-only values and #define for compile-time values such as array sizes and register addresses.

Mixed expressions convert types automatically, and that can surprise you: 5 / 2 gives 2 because both operands are integers.

Use an explicit cast when you need precision.

int total = 7, count = 2;
float average = (float)total / count;   // 3.5, not 3

Operators in C

• Arithmetic: + - * / %
• Relational: == != > < >= <=
• Logical: && || !
• Bitwise: & | ^ ~ << >> (the backbone of register programming)
• Assignment: = += -= *= /=, plus ++ and --
• Ternary: condition ? a : b for compact decisions

Common mistake: Writing if (x = 5) instead of if (x == 5). The first assigns, the second compares.

Input and Output

printf() prints formatted output and scanf() reads formatted input.

Common format specifiers: %d (int), %u (unsigned), %f (float), %c (char), %s (string) and %x (hex).

Pass the address of the variable to scanf, for example &age.

int age;
printf("Enter your age: ");
scanf("%d", &age);
printf("You are %d years old.\n", age);

Embedded note: Many microcontrollers have no console, so output usually goes through UART. printf is either redirected to the UART or replaced with lightweight custom print functions.

Stage 2: Control Flow, Functions and Logic Building

Decision Making

Use if, else if and else for conditions, and switch when choosing between many integer or character values.

End every case with break unless you deliberately want fall-through.

Always add a default case. It is your safety net for unexpected values.

switch (command) {
    case 1:  led_on();  break;
    case 2:  led_off(); break;
    default: error_handler(); break;
}

Loops

for suits a known number of repetitions, while checks the condition first, and do-while always runs at least once.

break exits a loop early and continue skips to the next iteration.

Embedded tip: Most firmware lives inside an endless while (1) loop, often called the super-loop.

for (int i = 1; i <= 5; i++) {
    printf("%d x 2 = %d\n", i, i * 2);
}

Functions

A function is a reusable block with a return type, a name, parameters and a body.

Declare a function (write its prototype) before you call it.

Arguments are passed by value, so the function works on a copy. To change the original, pass its address (you will see this in Stage 3).

Keep each function focused on one job. Small functions are easier to test and debug.

int add(int a, int b);          // prototype

int main(void)
{
    printf("Sum = %d\n", add(4, 6));
    return 0;
}

int add(int a, int b)
{
    return a + b;
}

Recursion

A recursive function calls itself on a smaller version of the problem and needs a base case that stops the calls.

Classic examples: factorial, Fibonacci and tree traversal.

Embedded caution: Every call uses stack memory. On small microcontrollers recursion is usually avoided, and coding standards such as MISRA C restrict it.

Stage 3: Arrays, Strings and Pointers

Arrays

An array stores several values of the same type in consecutive memory locations.

Indexing starts at 0. C does not check bounds, so reading or writing past the end is undefined behaviour.

In firmware, const lookup tables (sine waves, CRC tables) can live in flash, which saves RAM and computation time.

int readings[5] = {12, 18, 25, 30, 22};
int sum = 0;

for (int i = 0; i < 5; i++) {
    sum += readings[i];
}

Strings

A string is a char array that ends with the null character '\0'.

Always reserve one extra byte for it. The word Embedded needs 9 bytes, not 8.

The header gives you strlen, strcmp, strcpy and strcat. Prefer bounded functions such as snprintf to avoid buffer overflows.

char name[] = "Embedded";    // 8 letters + '\0' = 9 bytes

Pointers

Pointers are the topic that makes C feel hard at first. Don’t worry, almost everyone struggles here, and the idea becomes simple with the right picture.

A pointer is a variable that stores the memory address of another variable.

Think of a variable as a house and a pointer as its postal address. The address is not the house, but it tells you exactly where to find it.

Two operators do the work: & gives the address of a variable, and * follows an address to reach the value.

int value = 42;
int *ptr = &value;

printf("Value   : %d\n", *ptr);        // prints 42
printf("Address : %p\n", (void *)ptr);

*ptr = 100;                            // value is now 100

• Pointer arithmetic: ptr + 1 moves forward by sizeof(*ptr) bytes, not by one byte.
• Arrays and pointers: arr[i] and *(arr + i) mean the same thing.
• Pass by reference: Passing a pointer lets a function change the caller’s variable.

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

// usage: swap(&x, &y);

Pointer Mistakes That Cause Most Bugs

• Wild pointer: Using a pointer that was never initialised. Start with int *p = NULL;
• NULL dereference: Reading through a NULL pointer. Check before you use it.
• Dangling pointer: Pointing to memory that was freed or has gone out of scope.
• Buffer overflow: Writing beyond the end of an array through a pointer.

Stage 4: Intermediate C for Real Programs

Structures, Unions and Enums

A struct groups related data of different types under one name.

A union lets several members share the same memory, so its size equals its largest member.

An enum gives names to integer constants, which makes code self-explanatory.

Embedded tip: Structs map neatly onto sensor packets and peripheral register blocks. Padding and alignment can change a struct’s size, so verify it with sizeof.

typedef enum { LED_OFF, LED_ON, LED_BLINK } LedState_t;

typedef struct {
    uint8_t    id;
    int16_t    temperature;
    uint32_t   timestamp;
    LedState_t led;
} SensorNode_t;

SensorNode_t node = { .id = 1, .temperature = 27, .timestamp = 1000, .led = LED_ON };

Dynamic Memory Allocation

malloc, calloc, realloc and free (from ) manage heap memory at run time.

Every successful malloc needs a matching free. Forgetting it causes a memory leak.

Always check the returned pointer for NULL before using it.

// inside a function that returns int
int *data = malloc(5 * sizeof(*data));
if (data == NULL) {
    return -1;                 // allocation failed
}
data[0] = 10;
free(data);
data = NULL;                   // avoids a dangling pointer

Typical errors: memory leaks, double free and use after free.

Embedded caution: Many firmware projects avoid heap allocation after start-up because of fragmentation and unpredictable timing. Static allocation and memory pools are the usual alternatives.

File Handling

Use fopen, fclose, fprintf, fscanf, fgets, fread and fwrite to work with files.

Common modes: r (read), w (write), a (append), with b added for binary files.

Always check that fopen succeeded, and always close the file.

FILE *fp = fopen("log.txt", "w");
if (fp == NULL) {
    perror("File open failed");
    return 1;
}
fprintf(fp, "Temperature: %d C\n", 27);
fclose(fp);

File handling also appears in embedded designs that log data to SD cards using libraries such as FatFs.

Scope and Storage Classes

Local variables live inside a function and disappear when it returns. Global variables live for the whole run, but too many of them make code hard to debug.

static inside a function keeps the value between calls. static at file level hides the name from other files.

extern declares a variable that is defined in another file.

Preprocessor, Headers and Multi-File Projects

#define creates constants and macros, and #include pulls in headers.

Conditional compilation (#ifdef, #ifndef) switches code on or off for different boards and builds.

Put declarations in .h files and definitions in .c files, and guard every header against double inclusion.

Macro trap: #define SQUARE(x) x * x turns SQUARE(2 + 3) into 2 + 3 * 2 + 3, which is 11 instead of 25. Wrap the parameters and the whole expression in parentheses, or use a static inline function.

#ifndef SENSOR_H
#define SENSOR_H

int sensor_read(void);

#endif

Stage 5: Advanced C Programming

Bit Manipulation

Setting, clearing, toggling and testing individual bits is how you control GPIO pins, timers and other peripherals.

Use unsigned types for bitwise work to avoid sign-related surprises.

#define BIT(n)  (1U << (n))

uint32_t reg = 0;

reg |=  BIT(3);          // set bit 3
reg &= ~BIT(3);          // clear bit 3
reg ^=  BIT(3);          // toggle bit 3
if (reg & BIT(3)) {      // test bit 3
    /* bit 3 is set */
}

Function Pointers

A function pointer stores the address of a function, so you can pass behaviour around like data.

You will find them in callbacks, state machines, driver tables and interrupt vector tables.

void on_button_press(void)
{
    /* handle the event */
}

void (*callback)(void) = on_button_press;
callback();                  // calls on_button_press

Advanced Pointer Concepts

• Pointer to pointer: int **pp stores the address of another pointer. It is used for dynamic 2D arrays and for functions that must change a pointer itself.
• Constant pointers: const int *p means the data is read-only, while int *const p means the pointer cannot be reassigned. Read the declaration from right to left.
• Void pointer: void * holds any address, which is why malloc returns it. Convert it to a typed pointer before dereferencing.
• Arrow operator: -> accesses struct members through a pointer.

int x = 10;
int *p = &x;
int **pp = &p;
**pp = 20;                      // x is now 20

SensorNode_t *np = &node;       // node from the Stage 4 example
np->temperature = 30;

volatile, const and Memory-Mapped Registers

volatile tells the compiler that a value can change outside the normal program flow (a hardware register, or a variable modified inside an interrupt), so it must not optimise those reads and writes away.

const marks data as read-only. A read-only status register is often declared const volatile.

In memory-mapped I/O, each peripheral register sits at a fixed address and is accessed through a pointer.

// The address is illustrative. Check your device's reference manual.
#define GPIOA_ODR  (*(volatile uint32_t *)0x48000014U)

GPIOA_ODR |= (1U << 5);      // drive pin 5 high

Classic bug: A flag shared with an interrupt handler but missing volatile often works with optimisation off and fails with optimisation on.

Data Structures in C

Linked lists, stacks, queues, trees and hash tables are all built from structs and pointers.

A favourite in embedded work is the ring (circular) buffer, used for UART receive data and sensor streams.

One slot stays unused so the code can tell a full buffer from an empty one.

#define BUF_SIZE 8

typedef struct {
    uint8_t data[BUF_SIZE];
    uint8_t head;
    uint8_t tail;
} RingBuffer_t;

int rb_put(RingBuffer_t *rb, uint8_t byte)
{
    uint8_t next = (rb->head + 1) % BUF_SIZE;
    if (next == rb->tail) {
        return -1;               // buffer full
    }
    rb->data[rb->head] = byte;
    rb->head = next;
    return 0;
}

int rb_get(RingBuffer_t *rb, uint8_t *byte)
{
    if (rb->head == rb->tail) {
        return -1;               // buffer empty
    }
    *byte = rb->data[rb->tail];
    rb->tail = (rb->tail + 1) % BUF_SIZE;
    return 0;
}

Program Memory Layout

• Text: The compiled code (stored in flash on a microcontroller).
• Data: Initialised global and static variables.
• BSS: Uninitialised globals and statics, zeroed at start-up.
• Heap: Memory handed out by malloc.
• Stack: Local variables and function-call frames.

Knowing this layout helps you read a linker map file and see where your RAM is going.

Debugging and Defensive Coding

• Compile with warnings turned up (-Wall -Wextra) and fix every one of them.
• Use a debugger such as GDB, or an on-chip debugger with breakpoints and watch windows on real hardware.
• Run static analysis tools, and follow a coding standard such as MISRA C when safety matters.
• Avoid undefined behaviour: signed overflow, uninitialised reads, out-of-bounds access and dangling pointers.

Embedded C vs Standard C: What Changes on a Microcontroller

The syntax stays the same. The environment does not.

• No operating system: Code often runs bare-metal, so you manage start-up, clocks and peripherals yourself.
• Tiny memory: Kilobytes of RAM and flash mean every variable, buffer and stack frame counts.
• Direct hardware access: You read and write peripheral registers instead of calling operating system functions.
• Interrupts: Hardware events trigger interrupt service routines (ISRs), so shared variables need volatile and careful design.
• Timing matters: Deadlines and response times are part of correctness, not just performance.
• Cross-compilation: You build on a PC with a cross-compiler such as arm-none-eabi-gcc and flash the result onto the chip.
• Trimmed libraries: printf, malloc and file I/O are often limited, replaced or avoided.

C Project Ladder: Practise at Every Level

• Beginner: Calculator, temperature converter, number guessing game.
• Basic to intermediate: Prime number checker, string utility functions, student record manager using structs and files.
• Intermediate: Dynamic array (a mini vector), linked-list contact book, simple command parser.
• Advanced: Bit-manipulation toolkit, ring-buffer logger, traffic-light state machine.
• On hardware: LED blink, button with debouncing, UART echo, sensor data logger on a microcontroller.

Starter tools: GCC or Clang with VS Code, GDB for debugging, and an IDE such as STM32CubeIDE or Keil for microcontroller work.

Common C Programming Mistakes and How to Avoid Them

• Missing & in scanf: Pass the address of the variable (not needed for strings).
• Off-by-one errors: Loop with i < size, not i <= size.
• Missing ‘\0’: Reserve space for the string terminator.
• Uninitialised variables: Give every variable a starting value.
• Comparing floats with ==: Compare against a small tolerance instead.
• Assuming int is 32 bits: Use types when size matters.
• Memory leaks: Pair every malloc with a free.
• Unparenthesised macros: Wrap parameters and the whole expression in parentheses.

What to Learn After C

• C++ for object-oriented embedded and application code.
• RTOS concepts with FreeRTOS: Tasks, queues and semaphores.
• Communication protocols: UART, SPI, I2C, CAN and MQTT.
• Embedded Linux and system programming: Processes, threads and inter-process communication.
• Data structures and algorithms in C, plus unit testing for firmware.

Final Thoughts on C Programming from Basic to Advanced

Mastering C is not about memorising syntax. It is about building a clear mental picture of how your code, memory and hardware fit together. Move stage by stage, type out every example yourself, break things on purpose and then fix them. That habit is what turns a beginner into an engineer.

Your next steps:

• Finish one small project from the ladder above this week.
• Revisit pointers until * and & feel natural.
• Move to a microcontroller board and make an LED, a button and a UART talk to each other.

Ready to run your C code on real microcontrollers? Explore the embedded systems and IoT training programs at the Indian Institute of Embedded Systems (IIES) in Bangalore and turn these concepts into working hardware projects.