Embedded C From Scratch

#include <stdio.h>

int main(void)
{
    int led_state = 0;      // 0 means OFF, 1 means ON
    int blink_count = 5;    // number of times to blink

    led_state = 1;          // LED ON
    printf("LED state = %d\n", led_state);

    led_state = 0;          // LED OFF
    printf("Blink count = %d\n", blink_count);

    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    char letter = 'A';          // usually 1 byte
    int count = 100;            // size depends on platform
    float voltage = 3.3f;       // decimal number
    uint8_t gpio_pin = 5;       // exactly 8 bits, 0 to 255
    uint32_t reg = 0x40021000;  // exactly 32 bits

    printf("letter=%c count=%d voltage=%.2f pin=%u reg=0x%08X\n",
           letter, count, voltage, gpio_pin, reg);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int adc = 750;
    int threshold = 600;

    if (adc > threshold && adc < 1024)
    {
        printf("ADC is valid and above threshold\n");
    }

    int doubled = adc * 2;
    int remainder = adc % 10;

    printf("doubled=%d remainder=%d\n", doubled, remainder);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t pin = 5;
    uint32_t tick = 123456;
    float voltage = 3.294f;

    printf("Pin: %u\n", pin);
    printf("Tick: %lu\n", (unsigned long)tick);
    printf("Voltage: %.2f V\n", voltage);

    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint16_t adc = 2048;
    float voltage;

    voltage = ((float)adc / 4095.0f) * 3.3f;
    printf("Voltage = %.3f V\n", voltage);

    uint16_t big = 300;
    uint8_t small = (uint8_t)big; // 300 becomes 44 because uint8_t max is 255
    printf("small = %u\n", small);

    return 0;
}

#include <stdio.h>

int global_error = 0; // global scope, lifetime is entire program

void counter_function(void)
{
    static int count = 0; // exists for entire program but visible only here
    count++;
    printf("count=%d\n", count);
}

int main(void)
{
    int local_value = 10; // local to main
    counter_function();
    counter_function();
    counter_function();
    printf("local=%d global_error=%d\n", local_value, global_error);
    return 0;
}

// file1.c
#include <stdio.h>

int system_error = 0;        // real definition
static int private_count = 0; // visible only inside file1.c

void increment_private(void)
{
    private_count++;
    printf("private_count=%d\n", private_count);
}

// file2.c
extern int system_error; // declaration: variable exists in another file

void set_error(void)
{
    system_error = 1;
}

#include <stdio.h>
#include <stdint.h>

const uint16_t adc_threshold = 3000;
const char device_name[] = "STM32_NODE_01";

int main(void)
{
    uint16_t adc = 3100;

    if (adc > adc_threshold)
    {
        printf("%s: threshold crossed\n", device_name);
    }

    return 0;
}

#include <stdint.h>
#include <stdio.h>

volatile uint8_t button_pressed = 0;

void EXTI_Button_IRQHandler(void) // imagine this is an interrupt
{
    button_pressed = 1;
}

int main(void)
{
    while (button_pressed == 0)
    {
        // wait until interrupt changes button_pressed
    }

    printf("Button pressed\n");
    return 0;
}

#include <stdio.h>

int main(void)
{
    int temperature = 75;

    if (temperature > 80)
    {
        printf("Fan ON\n");
    }
    else
    {
        printf("Fan OFF\n");
    }

    return 0;
}

#include <stdio.h>

int main(void)
{
    char command = 'B';

    switch (command)
    {
        case 'L':
            printf("LED ON\n");
            break;
        case 'O':
            printf("LED OFF\n");
            break;
        case 'B':
            printf("LED BLINK\n");
            break;
        default:
            printf("Unknown command\n");
            break;
    }

    return 0;
}

#include <stdio.h>

int main(void)
{
    for (int i = 0; i < 5; i++)
    {
        printf("Blink %d\n", i + 1);
    }

    return 0;
}

#include <stdio.h>

int main(void)
{
    int sensor_ready = 0;
    int attempts = 0;

    while (sensor_ready == 0 && attempts < 3)
    {
        printf("Checking sensor...\n");
        attempts++;

        if (attempts == 2)
        {
            sensor_ready = 1;
        }
    }

    printf("Done\n");
    return 0;
}

#include <stdio.h>

int main(void)
{
    int retries = 0;
    int success = 0;

    do
    {
        printf("Trying communication...\n");
        retries++;
        if (retries == 2)
        {
            success = 1;
        }
    } while (success == 0 && retries < 3);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int values[] = {10, 20, 30, 40, 50};
    int target = 30;

    for (int i = 0; i < 5; i++)
    {
        if (values[i] == target)
        {
            printf("Found at index %d\n", i);
            break;
        }
    }

    return 0;
}

#include <stdio.h>

int main(void)
{
    int adc_values[] = {100, -1, 250, -1, 500};

    for (int i = 0; i < 5; i++)
    {
        if (adc_values[i] < 0)
        {
            continue; // invalid reading, skip it
        }
        printf("Valid ADC: %d\n", adc_values[i]);
    }

    return 0;
}

#include <stdio.h>

int init_sensor(void)
{
    int clock_ok = 1;
    int gpio_ok = 0;

    if (!clock_ok)
    {
        goto error;
    }

    if (!gpio_ok)
    {
        goto error;
    }

    return 0; // success

error:
    printf("Sensor init failed\n");
    return -1;
}

int main(void)
{
    init_sensor();
    return 0;
}

#include <stdio.h>

void led_on(void); // declaration/prototype

int main(void)
{
    led_on();
    return 0;
}

void led_on(void) // definition
{
    printf("LED ON\n");
}

#include <stdio.h>

void blink_led(int times)
{
    for (int i = 0; i < times; i++)
    {
        printf("LED ON\n");
        printf("LED OFF\n");
    }
}

int main(void)
{
    blink_led(3);
    return 0;
}

#include <stdio.h>

void set_led(int pin, int state)
{
    printf("Pin %d = %s\n", pin, state ? "ON" : "OFF");
}

int main(void)
{
    set_led(5, 1);
    set_led(5, 0);
    set_led(13, 1);
    return 0;
}

#include <stdio.h>

int read_temperature(void)
{
    return 32; // fake sensor value
}

int init_uart(void)
{
    return 0; // success
}

int main(void)
{
    int status = init_uart();
    int temp = read_temperature();

    printf("status=%d temp=%d\n", status, temp);
    return 0;
}

#include <stdio.h>

void change_value(int x)
{
    x = 99;
}

int main(void)
{
    int a = 10;
    change_value(a);
    printf("a=%d\n", a); // still 10
    return 0;
}

#include <stdio.h>

void clear_buffer(int buffer[], int size)
{
    for (int i = 0; i < size; i++)
    {
        buffer[i] = 0;
    }
}

int main(void)
{
    int data[5] = {1, 2, 3, 4, 5};
    clear_buffer(data, 5);

    for (int i = 0; i < 5; i++)
    {
        printf("%d ", data[i]);
    }
    return 0;
}

#include <stdio.h>

int factorial(int n)
{
    if (n <= 1)
    {
        return 1;
    }
    return n * factorial(n - 1);
}

int main(void)
{
    printf("5! = %d\n", factorial(5));
    return 0;
}

#include <stdio.h>

int main(void)
{
    int adc_samples[5] = {100, 200, 300, 400, 500};
    int sum = 0;

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

    printf("Average = %d\n", sum / 5);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int keypad[4][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
        {0, 0, 0}
    };

    printf("Key at row 1 col 2 = %d\n", keypad[1][2]); // 6
    return 0;
}

#include <stdio.h>

int main(void)
{
    char raw[3] = {'A', 'B', 'C'};
    char str[4] = {'A', 'B', 'C', ''};

    printf("String = %s\n", str);
    printf("Raw chars = %c %c %c\n", raw[0], raw[1], raw[2]);
    return 0;
}

#include <stdio.h>

int main(void)
{
    char command[] = "blink";

    if (command[0] == 'b')
    {
        printf("Command starts with b\n");
    }

    printf("Command = %s\n", command);
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    char cmd[] = "LED_ON";

    if (strcmp(cmd, "LED_ON") == 0)
    {
        printf("Turn LED ON\n");
    }

    printf("Length = %zu\n", strlen(cmd));
    return 0;
}

#include <stdio.h>

int my_strlen(const char *s)
{
    int count = 0;
    while (s[count] != '')
    {
        count++;
    }
    return count;
}

int my_strcmp(const char *a, const char *b)
{
    int i = 0;
    while (a[i] != '' && b[i] != '')
    {
        if (a[i] != b[i])
        {
            return a[i] - b[i];
        }
        i++;
    }
    return a[i] - b[i];
}

int main(void)
{
    printf("len=%d\n", my_strlen("UART"));
    printf("cmp=%d\n", my_strcmp("ON", "OFF"));
    return 0;
}

#include <stdio.h>

int main(void)
{
    int value = 42;

    printf("value=%d\n", value);
    printf("address=%p\n", (void *)&value);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int number = 55;
    int *ptr = &number;

    printf("number=%d\n", number);
    printf("ptr stores address=%p\n", (void *)ptr);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int led = 0;
    int *p = &led;

    *p = 1; // change led through pointer
    printf("led=%d\n", led);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int arr[3] = {10, 20, 30};
    int *p = arr;

    printf("%d\n", *p);       // 10
    printf("%d\n", *(p + 1)); // 20
    printf("%d\n", *(p + 2)); // 30

    return 0;
}

#include <stdio.h>

int main(void)
{
    int arr[4] = {1, 2, 3, 4};
    int *p = arr;

    printf("arr[2]=%d\n", arr[2]);
    printf("*(p+2)=%d\n", *(p + 2));
    printf("sizeof arr=%zu\n", sizeof(arr));
    printf("sizeof p=%zu\n", sizeof(p));

    return 0;
}

#include <stdio.h>

void change_pointer(int **pp)
{
    static int new_value = 99;
    *pp = &new_value;
}

int main(void)
{
    int a = 10;
    int *p = &a;

    change_pointer(&p);
    printf("*p=%d\n", *p);
    return 0;
}

#include <stdio.h>

void led_on(void)  { printf("LED ON\n"); }
void led_off(void) { printf("LED OFF\n"); }

int main(void)
{
    void (*action)(void);

    action = led_on;
    action();

    action = led_off;
    action();

    return 0;
}

#include <stdio.h>

void print_int(void *data)
{
    int *p = (int *)data;
    printf("value=%d\n", *p);
}

int main(void)
{
    int x = 123;
    print_int(&x);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 10;
    int b = 20;

    const int *p1 = &a; // cannot change *p1, can change p1
    p1 = &b;

    int * const p2 = &a; // can change *p2, cannot change p2
    *p2 = 99;

    printf("a=%d b=%d *p1=%d\n", a, b, *p1);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

struct SensorData
{
    uint16_t adc_value;
    float voltage;
    uint8_t error;
};

int main(void)
{
    struct SensorData sensor = {2048, 1.65f, 0};
    printf("adc=%u voltage=%.2f error=%u\n",
           sensor.adc_value, sensor.voltage, sensor.error);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

struct GpioPin
{
    char port;
    uint8_t pin;
};

struct Led
{
    struct GpioPin gpio;
    uint8_t active_high;
};

int main(void)
{
    struct Led led = {{'A', 5}, 1};
    printf("LED on port %c pin %u\n", led.gpio.port, led.gpio.pin);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

struct Led
{
    char port;
    uint8_t pin;
};

int main(void)
{
    struct Led leds[3] = {{'A', 5}, {'B', 3}, {'C', 7}};

    for (int i = 0; i < 3; i++)
    {
        printf("LED %d: port %c pin %u\n", i, leds[i].port, leds[i].pin);
    }
    return 0;
}

#include <stdio.h>
#include <stdint.h>

struct Motor
{
    uint8_t speed;
    uint8_t direction;
};

void motor_set_speed(struct Motor *m, uint8_t speed)
{
    m->speed = speed;
}

int main(void)
{
    struct Motor motor = {0, 1};
    motor_set_speed(&motor, 80);
    printf("speed=%u\n", motor.speed);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

typedef struct
{
    uint8_t speed;
    uint8_t direction;
} Motor_t;

int main(void)
{
    Motor_t motor = {100, 1};
    printf("speed=%u\n", motor.speed);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

union Data
{
    uint32_t word;
    uint8_t bytes[4];
};

int main(void)
{
    union Data d;
    d.word = 0x12345678;

    printf("word=0x%08X\n", d.word);
    printf("byte0=0x%02X\n", d.bytes[0]);
    return 0;
}

#include <stdio.h>

typedef enum
{
    STATE_IDLE,
    STATE_RUN,
    STATE_ERROR
} SystemState_t;

int main(void)
{
    SystemState_t state = STATE_RUN;

    if (state == STATE_RUN)
    {
        printf("System running\n");
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int global_value; // bss/data area

void function(void)
{
    int local_value = 10; // stack
    int *heap_value = malloc(sizeof(int)); // heap

    if (heap_value != NULL)
    {
        *heap_value = 20;
        printf("local=%d heap=%d\n", local_value, *heap_value);
        free(heap_value);
    }
}

int main(void)
{
    function();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *arr = malloc(5 * sizeof(int));

    if (arr == NULL)
    {
        printf("Allocation failed\n");
        return 1;
    }

    for (int i = 0; i < 5; i++)
    {
        arr[i] = i * 10;
    }

    free(arr);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *flags = calloc(8, sizeof(int));

    if (flags == NULL)
    {
        return 1;
    }

    for (int i = 0; i < 8; i++)
    {
        printf("%d ", flags[i]); // all zero
    }

    free(flags);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *arr = malloc(3 * sizeof(int));
    if (arr == NULL) return 1;

    int *temp = realloc(arr, 6 * sizeof(int));
    if (temp == NULL)
    {
        free(arr);
        return 1;
    }

    arr = temp;
    free(arr);
    return 0;
}

#include <stdlib.h>

int main(void)
{
    int *p = malloc(sizeof(int));
    if (p == NULL) return 1;

    *p = 42;
    free(p);
    p = NULL; // safer after free

    return 0;
}

#include <stdlib.h>

void bad_function(void)
{
    int *data = malloc(100 * sizeof(int));
    if (data == NULL) return;

    // forgot free(data); -> leak
}

void good_function(void)
{
    int *data = malloc(100 * sizeof(int));
    if (data == NULL) return;

    free(data);
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t value = 0b00100000; // bit 5 set
    printf("value=%u hex=0x%02X\n", value, value);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t reg = 0b00101000;
    uint8_t mask = (1 << 3);

    if (reg & mask)
    {
        printf("Bit 3 is set\n");
    }
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t reg = 0b00000000;
    reg = reg | (1 << 5); // set bit 5
    printf("reg=0x%02X\n", reg);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t reg = 0b00010000;
    reg ^= (1 << 4); // toggle bit 4 off
    reg ^= (1 << 4); // toggle bit 4 on again
    printf("reg=0x%02X\n", reg);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t reg = 0xFF;
    uint8_t mask = (1 << 3);

    reg = reg & (uint8_t)(~mask); // clear bit 3
    printf("reg=0x%02X\n", reg);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint32_t bit0 = (1UL << 0);
    uint32_t bit5 = (1UL << 5);

    printf("bit0=0x%08lX bit5=0x%08lX\n",
           (unsigned long)bit0, (unsigned long)bit5);
    return 0;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t reg = 0b10110000;
    uint8_t upper_nibble = reg >> 4;

    printf("upper=%u\n", upper_nibble);
    return 0;
}

#include <stdint.h>

#define LED_PIN     5U
#define LED_MASK    (1UL << LED_PIN)

int main(void)
{
    uint32_t reg = 0;
    reg |= LED_MASK;   // set LED pin bit
    reg &= ~LED_MASK;  // clear LED pin bit
    return 0;
}

#include <stdint.h>

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

int main(void)
{
    uint32_t control = 0;
    control |= BIT(0); // enable peripheral
    control |= BIT(3); // enable interrupt
    return 0;
}

#include <stdint.h>

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

int main(void)
{
    uint32_t control = 0xFFFFFFFF;
    control &= ~BIT(3); // clear bit 3
    return 0;
}

#include <stdint.h>

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

int main(void)
{
    uint32_t output = 0;
    output ^= BIT(5); // LED changes state
    output ^= BIT(5); // LED changes back
    return 0;
}

#include <stdio.h>
#include <stdint.h>

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

int main(void)
{
    uint32_t status = BIT(2);

    if (status & BIT(2))
    {
        printf("Data ready\n");
    }
    return 0;
}

#include <stdint.h>
#include <stdio.h>

typedef struct
{
    uint8_t id;
    uint16_t adc;
    uint32_t timestamp;
} Packet_t;

int main(void)
{
    Packet_t p = {1, 2048, 1000};
    printf("id=%u adc=%u time=%lu\n", p.id, p.adc, (unsigned long)p.timestamp);
    return 0;
}

#include <stdint.h>
#include <stdio.h>

volatile uint8_t button_pressed = 0;

void EXTI_Button_IRQHandler(void) // imagine this is an interrupt
{
    button_pressed = 1;
}

int main(void)
{
    while (button_pressed == 0)
    {
        // wait until interrupt changes button_pressed
    }

    printf("Button pressed\n");
    return 0;
}

#include <stdio.h>
#include <stdint.h>

const uint16_t adc_threshold = 3000;
const char device_name[] = "STM32_NODE_01";

int main(void)
{
    uint16_t adc = 3100;

    if (adc > adc_threshold)
    {
        printf("%s: threshold crossed\n", device_name);
    }

    return 0;
}

#include <stdint.h>

#define GPIOA_ODR_ADDR  (0x48000014UL)
#define GPIOA_ODR       (*(volatile uint32_t *)GPIOA_ODR_ADDR)
#define LED_PIN         5U

int main(void)
{
    GPIOA_ODR |= (1UL << LED_PIN);  // set pin high
    GPIOA_ODR &= ~(1UL << LED_PIN); // set pin low
    return 0;
}

#include <stdint.h>

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

volatile uint32_t RCC_AHB2ENR;
volatile uint32_t GPIOA_MODER;
volatile uint32_t GPIOA_ODR;

void gpioa_pin5_output_init(void)
{
    RCC_AHB2ENR |= BIT(0);        // enable GPIOA clock
    GPIOA_MODER &= ~(3UL << 10);  // clear mode bits for pin 5
    GPIOA_MODER |=  (1UL << 10);  // set pin 5 as output
}

void gpioa_pin5_on(void)
{
    GPIOA_ODR |= BIT(5);
}

#include <stdint.h>

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

volatile uint32_t GPIO_ODR;
volatile uint32_t GPIO_IDR;

void led_on(void)     { GPIO_ODR |= BIT(5); }
void led_off(void)    { GPIO_ODR &= ~BIT(5); }
void led_toggle(void) { GPIO_ODR ^= BIT(5); }

uint8_t button_read(void)
{
    return (GPIO_IDR & BIT(13)) ? 1U : 0U;
}

#include <stdint.h>

#define BIT(n)          (1UL << (n))
#define LED_PIN         5U
#define LED_MASK        BIT(LED_PIN)
#define SET_BITS(r, m)  ((r) |= (m))
#define CLR_BITS(r, m)  ((r) &= ~(m))

int main(void)
{
    uint32_t reg = 0;
    SET_BITS(reg, LED_MASK);
    CLR_BITS(reg, LED_MASK);
    return 0;
}

// led.h
#ifndef LED_H
#define LED_H

#include <stdint.h>

void led_init(void);
void led_write(uint8_t state);

#endif

// led.c
#include "led.h"

void led_init(void)
{
    // configure pin
}

void led_write(uint8_t state)
{
    // write pin
}

// uart.c
#include <stdint.h>

static void uart_config_baudrate(uint32_t baud)
{
    // private helper
}

void uart_init(uint32_t baud)
{
    uart_config_baudrate(baud);
}

#include <stdint.h>

volatile uint8_t tick_flag = 0;

void TIM2_IRQHandler(void)
{
    // clear timer interrupt flag here in real STM32 code
    tick_flag = 1;
}

int main(void)
{
    while (1)
    {
        if (tick_flag)
        {
            tick_flag = 0;
            // periodic task
        }
    }
}

#include <stdint.h>

#define RX_BUF_SIZE 64

volatile uint8_t rx_buf[RX_BUF_SIZE];
volatile uint8_t rx_head = 0;

void UART_RX_IRQHandler(uint8_t byte)
{
    uint8_t next = (rx_head + 1U) % RX_BUF_SIZE;
    rx_buf[rx_head] = byte;
    rx_head = next;
}

// Polling style
while ((STATUS_REG & RX_READY_MASK) == 0)
{
    // wait
}
byte = DATA_REG;

// Interrupt style
void UART_IRQHandler(void)
{
    byte = DATA_REG;
    rx_ready = 1;
}

#include <stdint.h>

volatile uint8_t tx_done = 0;

void wait_tx_done(void)
{
    while (tx_done == 0)
    {
        // CPU stuck here until flag changes
    }
}

#include <stdint.h>

void delay_loop(volatile uint32_t count)
{
    while (count--)
    {
        // simple crude delay
    }
}

int main(void)
{
    while (1)
    {
        // led_toggle();
        delay_loop(1000000);
    }
}

#include <stdio.h>

#define LED_PIN 5
#define MAX_RETRY 3

int main(void)
{
    printf("LED pin=%d retries=%d\n", LED_PIN, MAX_RETRY);
    return 0;
}

#include <stdint.h>

#define BIT(n)              (1UL << (n))
#define SET_BIT(reg, bit)   ((reg) |= BIT(bit))
#define CLEAR_BIT(reg, bit) ((reg) &= ~BIT(bit))

int main(void)
{
    uint32_t reg = 0;
    SET_BIT(reg, 5);
    CLEAR_BIT(reg, 5);
    return 0;
}

// sensor.h
#ifndef SENSOR_H
#define SENSOR_H

#include <stdint.h>

void sensor_init(void);
uint16_t sensor_read(void);

#endif // SENSOR_H

#include <stdio.h>

#define DEBUG 1

int main(void)
{
#if DEBUG
    printf("Debug mode enabled\n");
#endif

    return 0;
}

#include <stdio.h>

#define ENABLE_LOGS

int main(void)
{
#ifdef ENABLE_LOGS
    printf("Logs enabled\n");
#endif
    return 0;
}

#include <stdio.h>

#ifndef BAUD_RATE
#define BAUD_RATE 115200
#endif

int main(void)
{
    printf("Baud=%d\n", BAUD_RATE);
    return 0;
}

// button.h
#ifndef BUTTON_H
#define BUTTON_H
#include <stdint.h>
uint8_t button_read(void);
#endif

// button.c
#include "button.h"
uint8_t button_read(void)
{
    return 0;
}

// main.c
#include "button.h"
int main(void)
{
    return button_read();
}

gcc -c main.c -o main.o
gcc -c led.c -o led.o
gcc main.o led.o -o app

gcc -c uart.c -o uart.o
nm uart.o

arm-none-eabi-gcc startup.o main.o led.o \
  -T linker.ld -o firmware.elf

CC=gcc
CFLAGS=-Wall -Wextra
OBJS=main.o led.o

app: $(OBJS)
	$(CC) $(OBJS) -o app

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) app

gcc -c led.c -o led.o
ar rcs libdrivers.a led.o
gcc main.o -L. -ldrivers -o app

#include <stdint.h>

typedef struct
{
    volatile uint32_t SR;
    volatile uint32_t DR;
    volatile uint32_t BRR;
    volatile uint32_t CR1;
} UART_Reg_t;

void uart_send_byte(UART_Reg_t *uart, uint8_t byte)
{
    while ((uart->SR & (1UL << 7)) == 0)
    {
        // wait until TX empty
    }
    uart->DR = byte;
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t SR;
    volatile uint32_t DR;
} SPI_Reg_t;

uint8_t spi_transfer(SPI_Reg_t *spi, uint8_t data)
{
    while ((spi->SR & (1UL << 1)) == 0) {}
    spi->DR = data;

    while ((spi->SR & (1UL << 0)) == 0) {}
    return (uint8_t)spi->DR;
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t CR1;
    volatile uint32_t CR2;
    volatile uint32_t SR1;
    volatile uint32_t SR2;
    volatile uint32_t DR;
} I2C_Reg_t;

#define I2C_CR1_START   (1UL << 8)
#define I2C_CR1_STOP    (1UL << 9)
#define I2C_SR1_SB      (1UL << 0)   /* start bit sent          */
#define I2C_SR1_ADDR    (1UL << 1)   /* address acked           */
#define I2C_SR1_TXE     (1UL << 7)   /* data register empty     */
#define I2C_SR1_BTF     (1UL << 2)   /* byte transfer finished  */

static void i2c_wait_flag(I2C_Reg_t *i2c, uint32_t flag)
{
    while ((i2c->SR1 & flag) == 0U) { /* wait, add a timeout in production */ }
}

/* Writes one byte to a register on an I2C device, e.g. an IMU or EEPROM. */
int i2c_write_register(I2C_Reg_t *i2c, uint8_t dev_addr, uint8_t reg_addr, uint8_t value)
{
    i2c->CR1 |= I2C_CR1_START;
    i2c_wait_flag(i2c, I2C_SR1_SB);              /* start condition sent      */

    i2c->DR = (uint8_t)(dev_addr << 1) | 0U;     /* 7-bit address, write bit  */
    i2c_wait_flag(i2c, I2C_SR1_ADDR);
    (void)i2c->SR2;                              /* SR2 read clears ADDR flag */

    i2c->DR = reg_addr;
    i2c_wait_flag(i2c, I2C_SR1_TXE);

    i2c->DR = value;
    i2c_wait_flag(i2c, I2C_SR1_BTF);              /* value has left the shift register */

    i2c->CR1 |= I2C_CR1_STOP;
    return 0;
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t PSC;
    volatile uint32_t ARR;
    volatile uint32_t CNT;
    volatile uint32_t CR1;
} TIM_Reg_t;

void timer_start_1khz(TIM_Reg_t *tim, uint32_t timer_clk_hz)
{
    tim->PSC = (timer_clk_hz / 1000000UL) - 1UL; // 1 MHz timer tick
    tim->ARR = 1000UL - 1UL;                     // 1 ms update
    tim->CNT = 0;
    tim->CR1 |= 1UL;
}

#include <stdint.h>

uint32_t adc_to_millivolts(uint16_t adc, uint32_t vref_mv)
{
    return ((uint32_t)adc * vref_mv) / 4095UL;
}

int main(void)
{
    uint32_t mv = adc_to_millivolts(2048, 3300);
    (void)mv;
    return 0;
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t ARR;
    volatile uint32_t CCR1;
} PWM_Timer_t;

void pwm_set_percent(PWM_Timer_t *tim, uint8_t percent)
{
    if (percent > 100) percent = 100;
    tim->CCR1 = ((tim->ARR + 1UL) * percent) / 100UL;
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t KR;   /* key register: unlocks / feeds / starts   */
    volatile uint32_t PR;   /* prescaler                                */
    volatile uint32_t RLR;  /* reload value (down-counter target)       */
    volatile uint32_t SR;   /* status: shows if PR/RLR writes finished  */
} IWDG_Reg_t;

#define IWDG_KEY_ENABLE_WRITE 0x5555U
#define IWDG_KEY_RELOAD       0xAAAAU
#define IWDG_KEY_START        0xCCCCU

/* ~1 second timeout: 32 kHz LSI / prescaler 64 = 500 Hz, reload 500 counts. */
void watchdog_init(IWDG_Reg_t *iwdg)
{
    iwdg->KR  = IWDG_KEY_ENABLE_WRITE;   /* unlock PR/RLR for writing */
    iwdg->PR  = 4U;                      /* prescaler /64             */
    iwdg->RLR = 500U;                    /* counts down from 500      */
    while (iwdg->SR != 0U) { /* wait until PR/RLR updates are applied */ }
    iwdg->KR  = IWDG_KEY_START;          /* start the watchdog        */
}

void watchdog_kick(IWDG_Reg_t *iwdg)
{
    iwdg->KR = IWDG_KEY_RELOAD;          /* reload the down-counter   */
}

int main(void)
{
    IWDG_Reg_t * const iwdg = (IWDG_Reg_t *)0x40003000U;
    watchdog_init(iwdg);

    while (1)
    {
        /* main application work: read sensors, service comms, etc. */
        watchdog_kick(iwdg);
    }
}

#include <stdint.h>

typedef void (*AppEntry_t)(void);

void jump_to_application(uint32_t app_address)
{
    uint32_t reset_handler_address = *(uint32_t *)(app_address + 4U);
    AppEntry_t app_entry = (AppEntry_t)reset_handler_address;
    app_entry();
}

#include <stdint.h>

typedef enum
{
    STATUS_OK = 0,
    STATUS_TIMEOUT = -1,
    STATUS_INVALID_ARG = -2,
    STATUS_HW_ERROR = -3
} Status_t;

Status_t sensor_read(uint16_t *value)
{
    if (value == 0)
    {
        return STATUS_INVALID_ARG;
    }

    *value = 1234;
    return STATUS_OK;
}

#include <stdint.h>

#define ADC_MAX_COUNTS 4095UL
#define VREF_MV        3300UL

uint32_t adc_counts_to_mv(uint16_t counts)
{
    return ((uint32_t)counts * VREF_MV) / ADC_MAX_COUNTS;
}

#include <stdint.h>

const uint32_t table[3] = {1, 2, 3}; // rodata/Flash
uint32_t initialized = 5;            // data
uint32_t zero_value;                 // bss

void function(void)
{
    uint32_t local = 10;             // stack
    (void)local;
}

void bad_function(void)
{
    int huge_array[10000]; // dangerous on small MCU stack
    huge_array[0] = 1;
}

void better_function(void)
{
    static int buffer[10000]; // not stack, but uses global RAM
    buffer[0] = 1;
}

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint32_t value = 0x12345678;
    uint8_t *bytes = (uint8_t *)&value;

    printf("byte0=0x%02X\n", bytes[0]);
    return 0;
}

#include <stdint.h>

int main(void)
{
    uint8_t buffer[8];
    // Dangerous on some MCUs if address is not 4-byte aligned:
    // uint32_t *p = (uint32_t *)&buffer[1];
    // *p = 0x12345678;

    return 0;
}

#include <stdio.h>
#include <stdint.h>

typedef struct
{
    uint8_t a;
    uint32_t b;
    uint8_t c;
} Example_t;

int main(void)
{
    printf("sizeof Example_t = %zu\n", sizeof(Example_t));
    return 0;
}

#include <stdio.h>

int main(void)
{
    int arr[3] = {1, 2, 3};
    // printf("%d\n", arr[5]); // undefined behavior

    int x;
    // printf("%d\n", x); // undefined behavior: uninitialized

    return 0;
}

#include <stdint.h>

volatile uint32_t flag;

void wait_flag(void)
{
    while (flag == 0)
    {
        // compiler must re-read flag every time because volatile
    }
}

#include <stdint.h>

volatile const uint32_t STATUS_REG = 0; // conceptual read-only changing register
volatile uint32_t CONTROL_REG = 0;      // writable hardware register

int main(void)
{
    uint32_t status = STATUS_REG;
    CONTROL_REG |= (1UL << 0);
    (void)status;
    return 0;
}

// Example interview task: set, clear, toggle, read bit
#define BIT(n) (1UL << (n))
#define SET_BIT(reg, n)    ((reg) |= BIT(n))
#define CLEAR_BIT(reg, n)  ((reg) &= ~BIT(n))
#define TOGGLE_BIT(reg, n) ((reg) ^= BIT(n))
#define READ_BIT(reg, n)   (((reg) & BIT(n)) != 0U)

/* STM32WB55 register example using CMSIS device definitions; no HAL. */
#include "stm32wb55xx.h"

void led_init(void)
{
    RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
    (void)RCC->AHB2ENR;
    GPIOA->MODER = (GPIOA->MODER & ~GPIO_MODER_MODE5_Msk)
                 | (1UL << GPIO_MODER_MODE5_Pos);
}

void led_on(void)  { GPIOA->BSRR = GPIO_BSRR_BS5; }
void led_off(void) { GPIOA->BSRR = GPIO_BSRR_BR5; }

#include <stdint.h>

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

volatile uint32_t GPIO_IDR;

uint8_t button_is_pressed(void)
{
    // Example: active-low button on pin 13
    return (GPIO_IDR & BIT(13)) ? 0U : 1U;
}

#include <stdint.h>
#include <string.h>

typedef struct
{
    volatile uint32_t SR;
    volatile uint32_t DR;
} USART_Reg_t;

#define USART_SR_TXE (1UL << 7)

static void uart_send_byte(USART_Reg_t *u, uint8_t byte)
{
    while ((u->SR & USART_SR_TXE) == 0U) { /* wait for TX empty */ }
    u->DR = byte;
}

void uart_send_string(USART_Reg_t *u, const char *s)
{
    while (*s != '\0')          /* stop at the null terminator, not a space */
    {
        uart_send_byte(u, (uint8_t)*s);
        s++;
    }
}

/* Simple command dispatcher for a line already received over UART. */
void process_command(const char *cmd)
{
    if (strcmp(cmd, "ON") == 0)
    {
        /* led_on(); */
    }
    else if (strcmp(cmd, "OFF") == 0)
    {
        /* led_off(); */
    }
    else if (strncmp(cmd, "BLINK", 5) == 0)
    {
        /* led_blink(5); */
    }
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t IMR;   /* interrupt mask register           */
    volatile uint32_t RTSR;  /* rising-trigger selection           */
    volatile uint32_t FTSR;  /* falling-trigger selection          */
    volatile uint32_t PR;    /* pending register (write 1 to clear)*/
} EXTI_Reg_t;

#define BUTTON_LINE (1UL << 13)   /* EXTI13, e.g. the user button on many boards */

volatile uint8_t button_event = 0;

void exti_button_init(EXTI_Reg_t *exti)
{
    exti->IMR  |= BUTTON_LINE;   /* unmask the line so it can interrupt */
    exti->FTSR |= BUTTON_LINE;   /* trigger on falling edge (press)     */
    /* NVIC_EnableIRQ(EXTI15_10_IRQn); done separately, MCU-specific     */
}

/* Testable helper. The real vector-table ISR must be void name(void). */
void exti_button_service(EXTI_Reg_t *exti)
{
    if ((exti->PR & BUTTON_LINE) != 0U)
    {
        exti->PR = BUTTON_LINE;   /* writing 1 clears this pending bit */
        button_event = 1;
    }
}

int main(void)
{
    while (1)
    {
        if (button_event)
        {
            button_event = 0;
            /* handle the press here, outside the ISR */
        }
    }
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t CR1;
    volatile uint32_t DIER;  /* DMA/interrupt enable register */
    volatile uint32_t SR;    /* status: bit0 = update flag     */
    volatile uint32_t PSC;
    volatile uint32_t ARR;
} TIM_Reg_t;

#define TIM_CR1_CEN   (1UL << 0)  /* counter enable   */
#define TIM_DIER_UIE  (1UL << 0)  /* update interrupt enable */
#define TIM_SR_UIF    (1UL << 0)  /* update interrupt flag   */

volatile uint32_t ms_ticks = 0;

/* Assumes a 16 MHz timer input clock; produces a 1 ms update event. */
void timer_1ms_init(TIM_Reg_t *tim)
{
    tim->PSC   = 16000U - 1U;   /* 16 MHz / 16000 = 1 kHz counting rate */
    tim->ARR   = 1U - 1U;       /* overflow every 1 count = every 1 ms  */
    tim->DIER |= TIM_DIER_UIE;
    tim->CR1  |= TIM_CR1_CEN;
    /* NVIC_EnableIRQ(TIMx_IRQn); done separately, MCU-specific */
}

/* Testable helper; the real TIMx_IRQHandler is void name(void). */
void timer_update_service(TIM_Reg_t *tim)
{
    if ((tim->SR & TIM_SR_UIF) != 0U)
    {
        tim->SR &= ~TIM_SR_UIF;   /* clear the update flag */
        ms_ticks++;
    }
}

#include <stdint.h>

#define BIT(n) (1UL << (n))
#define DC_PIN 8U   /* data/command select pin */
#define CS_PIN 9U   /* chip select pin         */

volatile uint32_t GPIO_BSRR;   /* set/reset register, see Chapter t91/main.c */
extern uint8_t spi_transfer(void *spi, uint8_t data); /* from Chapter 92 */

static void gpio_write(uint32_t pin, uint8_t level)
{
    GPIO_BSRR = level ? BIT(pin) : BIT(pin + 16U);
}

void lcd_write_command(void *spi, uint8_t cmd)
{
    gpio_write(DC_PIN, 0U);         /* DC low = this byte is a command */
    gpio_write(CS_PIN, 0U);         /* select the display              */
    (void)spi_transfer(spi, cmd);
    gpio_write(CS_PIN, 1U);         /* deselect                        */
}

void lcd_write_data(void *spi, uint8_t data)
{
    gpio_write(DC_PIN, 1U);         /* DC high = this byte is pixel data */
    gpio_write(CS_PIN, 0U);
    (void)spi_transfer(spi, data);
    gpio_write(CS_PIN, 1U);
}

#include <stdint.h>

uint32_t adc_to_mv_12bit(uint16_t raw)
{
    return ((uint32_t)raw * 3300UL) / 4095UL;
}

#include <stdint.h>

typedef struct
{
    volatile uint32_t CCR;    /* channel config: direction, circular, IRQs */
    volatile uint32_t CNDTR;  /* number of data items to transfer          */
    volatile uint32_t CPAR;   /* peripheral address (e.g. ADC data reg)    */
    volatile uint32_t CMAR;   /* memory address (your buffer)              */
} DMA_Channel_t;

#define DMA_CCR_EN        (1UL << 0)
#define DMA_CCR_CIRC      (1UL << 5)  /* circular mode: wraps automatically */
#define DMA_CCR_MINC      (1UL << 7)  /* increment memory address each item */
#define DMA_CCR_MSIZE_16B (1UL << 10)

#define ADC_BUF_LEN 128
static volatile uint16_t adc_buffer[ADC_BUF_LEN];

void adc_dma_start(DMA_Channel_t *dma, uint32_t adc_data_reg_addr)
{
    dma->CPAR   = adc_data_reg_addr;
    dma->CMAR   = (uint32_t)adc_buffer;
    dma->CNDTR  = ADC_BUF_LEN;
    dma->CCR    = DMA_CCR_MSIZE_16B | DMA_CCR_MINC | DMA_CCR_CIRC;
    dma->CCR   |= DMA_CCR_EN;
}

void enter_sleep_until_interrupt(void)
{
    // configure wake-up source first
    // execute CPU instruction such as WFI on ARM Cortex-M
    // __WFI();
}

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

static QueueHandle_t sensor_queue;

void sensor_task(void *arg)
{
    uint16_t reading;
    for (;;)
    {
        reading = read_adc_channel(0);           /* your driver function */
        xQueueSend(sensor_queue, &reading, 0);    /* non-blocking send    */
        vTaskDelay(pdMS_TO_TICKS(100));           /* sleep, don't spin    */
    }
}

void comm_task(void *arg)
{
    uint16_t reading;
    for (;;)
    {
        if (xQueueReceive(sensor_queue, &reading, portMAX_DELAY) == pdPASS)
        {
            uart_send_string(USART2, "reading ready");   /* transmit it */
        }
    }
}

int main(void)
{
    sensor_queue = xQueueCreate(8, sizeof(uint16_t));
    xTaskCreate(sensor_task, "sensor", 128, NULL, 2, NULL);
    xTaskCreate(comm_task,   "comm",   128, NULL, 1, NULL);
    vTaskStartScheduler();   /* never returns */
    for (;;) { }
}

// Project architecture idea
// main.c       -> app loop and initialization
// led.c/h      -> LED driver
// button.c/h   -> button driver
// uart.c/h     -> UART driver
// command.c/h  -> command parser
// app.c/h      -> application state machine