Zephyr RTOS Introduction

  FreeRTOS vs Zephyr Scope
  ──────────────────────────────────────────
  FreeRTOS:
  ┌───────────────┐
  │  Task Sched.  │  You add everything else:
  │  Queues       │  HAL, drivers, TCP/IP,
  │  Semaphores   │  BLE, USB, filesystem...
  │  Timers       │
  └───────────────┘

  Zephyr:
  ┌───────────────────────────────────────┐
  │  Kernel + Scheduler                   │
  │  Devicetree + Kconfig                 │
  │  GPIO, I2C, SPI, UART drivers         │
  │  TCP/IP, BLE, USB, CAN               │
  │  Logging, Shell, Filesystem           │
  │  600+ board support packages          │
  └───────────────────────────────────────┘

cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(traffic_light_zephyr)

target_sources(app PRIVATE src/main.c)

  Zephyr Build Pipeline
  ──────────────────────────────────────────
  Board .dts          prj.conf
  + your .overlay     (Kconfig)
       │                  │
       ▼                  ▼
  ┌──────────┐     ┌──────────────┐
  │  dtc     │     │  Kconfig     │
  │ compiler │     │  processor   │
  └────┬─────┘     └──────┬───────┘
       │                  │
       ▼                  ▼
  devicetree_        .config
  generated.h       (final config)
       │                  │
       └────────┬─────────┘
                ▼
         ┌────────────┐
         │  CMake +   │
         │  Compiler  │◄── src/main.c
         └─────┬──────┘
               ▼
          zephyr.elf ──► west flash

/* Get a node identifier from an alias */
#define LED_RED_NODE    DT_ALIAS(led_red)
#define BTN_PED_NODE    DT_ALIAS(btn_ped)

/* Get the GPIO spec (controller + pin + flags) from a node */
static const struct gpio_dt_spec led_red = GPIO_DT_SPEC_GET(LED_RED_NODE, gpios);
static const struct gpio_dt_spec btn_ped = GPIO_DT_SPEC_GET(BTN_PED_NODE, gpios);

# Kernel features
CONFIG_GPIO=y
CONFIG_SERIAL=y
CONFIG_PRINTK=y

# Thread and scheduling
CONFIG_NUM_PREEMPT_PRIORITIES=16
CONFIG_MAIN_STACK_SIZE=1024

# GPIO interrupt support
CONFIG_GPIO_STM32=y

# Debug output
CONFIG_CONSOLE=y
CONFIG_UART_CONSOLE=y

# Timestamp in printk
CONFIG_LOG=y
CONFIG_LOG_DEFAULT_LEVEL=3

/* Thread entry function */
void light_cycle_entry(void *p1, void *p2, void *p3) {
    ARG_UNUSED(p1); ARG_UNUSED(p2); ARG_UNUSED(p3);

    while (1) {
        /* Thread logic here */
        k_msleep(1000);
    }
}

/* Define a thread statically (stack allocated at compile time) */
K_THREAD_DEFINE(light_cycle_tid,       /* Thread ID variable name */
                1024,                   /* Stack size in bytes */
                light_cycle_entry,      /* Entry function */
                NULL, NULL, NULL,       /* Three parameters (p1, p2, p3) */
                5,                      /* Priority */
                0,                      /* Options (0 = preemptible) */
                0);                     /* Delay before start (0 = immediate) */

#define STACK_SIZE 1024
K_THREAD_STACK_DEFINE(my_stack, STACK_SIZE);
static struct k_thread my_thread_data;

k_tid_t tid = k_thread_create(&my_thread_data, my_stack, STACK_SIZE,
                               my_entry_fn, NULL, NULL, NULL,
                               5,           /* Priority */
                               0,           /* Options */
                               K_NO_WAIT);  /* Start immediately */

/* Define a semaphore (initial count 0, max count 1 = binary) */
K_SEM_DEFINE(ped_sem, 0, 1);

/* In the button callback or ISR */
k_sem_give(&ped_sem);

/* In the pedestrian thread */
k_sem_take(&ped_sem, K_FOREVER);  /* Block until given */

K_MUTEX_DEFINE(led_mutex);

k_mutex_lock(&led_mutex, K_FOREVER);
/* Critical section: access shared resource */
k_mutex_unlock(&led_mutex);

K_MSGQ_DEFINE(cmd_queue, sizeof(uint8_t), 10, 4);

uint8_t cmd = 0x01;
k_msgq_put(&cmd_queue, &cmd, K_NO_WAIT);

uint8_t received;
k_msgq_get(&cmd_queue, &received, K_FOREVER);

#include <zephyr/drivers/gpio.h>

/* Get the GPIO spec from devicetree */
static const struct gpio_dt_spec led_red = GPIO_DT_SPEC_GET(DT_ALIAS(led_red), gpios);

/* In your init function */
if (!gpio_is_ready_dt(&led_red)) {
    printk("Error: LED GPIO not ready\n");
    return;
}
gpio_pin_configure_dt(&led_red, GPIO_OUTPUT_INACTIVE);

/* Turn on the LED */
gpio_pin_set_dt(&led_red, 1);

/* Turn off the LED */
gpio_pin_set_dt(&led_red, 0);

static const struct gpio_dt_spec btn_ped = GPIO_DT_SPEC_GET(DT_ALIAS(btn_ped), gpios);
static struct gpio_callback btn_ped_cb_data;

/* Callback fires in ISR context */
void btn_ped_callback(const struct device *dev, struct gpio_callback *cb, uint32_t pins) {
    k_sem_give(&ped_sem);
}

/* Configuration */
gpio_pin_configure_dt(&btn_ped, GPIO_INPUT);
gpio_pin_interrupt_configure_dt(&btn_ped, GPIO_INT_EDGE_TO_ACTIVE);
gpio_init_callback(&btn_ped_cb_data, btn_ped_callback, BIT(btn_ped.pin));
gpio_add_callback(btn_ped.port, &btn_ped_cb_data);

# GPIO and serial
CONFIG_GPIO=y
CONFIG_SERIAL=y
CONFIG_PRINTK=y
CONFIG_CONSOLE=y
CONFIG_UART_CONSOLE=y

# Thread configuration
CONFIG_NUM_PREEMPT_PRIORITIES=16
CONFIG_MAIN_STACK_SIZE=1024

# Logging with timestamps
CONFIG_LOG=y
CONFIG_LOG_DEFAULT_LEVEL=3

# Stack monitoring (for debugging)
CONFIG_THREAD_STACK_INFO=y
CONFIG_THREAD_MONITOR=y

cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(traffic_light_zephyr)

target_sources(app PRIVATE src/main.c)

#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/printk.h>

/* ---------- Devicetree node references ---------- */
#define LED_RED_NODE    DT_ALIAS(led_red)
#define LED_YELLOW_NODE DT_ALIAS(led_yellow)
#define LED_GREEN_NODE  DT_ALIAS(led_green)
#define BTN_PED_NODE    DT_ALIAS(btn_ped)
#define BTN_EMRG_NODE   DT_ALIAS(btn_emrg)

/* GPIO specs from devicetree */
static const struct gpio_dt_spec led_red    = GPIO_DT_SPEC_GET(LED_RED_NODE, gpios);
static const struct gpio_dt_spec led_yellow = GPIO_DT_SPEC_GET(LED_YELLOW_NODE, gpios);
static const struct gpio_dt_spec led_green  = GPIO_DT_SPEC_GET(LED_GREEN_NODE, gpios);
static const struct gpio_dt_spec btn_ped    = GPIO_DT_SPEC_GET(BTN_PED_NODE, gpios);
static const struct gpio_dt_spec btn_emrg   = GPIO_DT_SPEC_GET(BTN_EMRG_NODE, gpios);

/* ---------- Synchronization ---------- */
K_SEM_DEFINE(ped_sem, 0, 1);
K_SEM_DEFINE(emrg_sem, 0, 1);

/* ---------- Thread IDs (for suspend/resume) ---------- */
extern const k_tid_t light_cycle_tid;
extern const k_tid_t pedestrian_tid;

/* ---------- LED helper ---------- */
static void set_leds(int red, int yellow, int green) {
    gpio_pin_set_dt(&led_red, red);
    gpio_pin_set_dt(&led_yellow, yellow);
    gpio_pin_set_dt(&led_green, green);
}

/* ---------- Timestamped logging ---------- */
static void log_state(const char *source, const char *message) {
    int64_t ms = k_uptime_get();
    printk("[%06ld ms] %s: %s\n", (long)ms, source, message);
}

/* ---------- GPIO interrupt callbacks ---------- */
static struct gpio_callback btn_ped_cb_data;
static struct gpio_callback btn_emrg_cb_data;

static void btn_ped_callback(const struct device *dev,
                              struct gpio_callback *cb,
                              uint32_t pins) {
    ARG_UNUSED(dev);
    ARG_UNUSED(cb);
    ARG_UNUSED(pins);
    k_sem_give(&ped_sem);
}

static void btn_emrg_callback(const struct device *dev,
                                struct gpio_callback *cb,
                                uint32_t pins) {
    ARG_UNUSED(dev);
    ARG_UNUSED(cb);
    ARG_UNUSED(pins);
    k_sem_give(&emrg_sem);
}

/* ---------- Hardware initialization ---------- */
static int hw_init(void) {
    int ret;

    /* Verify all GPIO devices are ready */
    if (!gpio_is_ready_dt(&led_red) ||
        !gpio_is_ready_dt(&led_yellow) ||
        !gpio_is_ready_dt(&led_green) ||
        !gpio_is_ready_dt(&btn_ped) ||
        !gpio_is_ready_dt(&btn_emrg)) {
        printk("Error: GPIO device not ready\n");
        return -1;
    }

    /* Configure LED outputs */
    gpio_pin_configure_dt(&led_red, GPIO_OUTPUT_INACTIVE);
    gpio_pin_configure_dt(&led_yellow, GPIO_OUTPUT_INACTIVE);
    gpio_pin_configure_dt(&led_green, GPIO_OUTPUT_INACTIVE);

    /* Configure button inputs with interrupts */
    gpio_pin_configure_dt(&btn_ped, GPIO_INPUT);
    gpio_pin_configure_dt(&btn_emrg, GPIO_INPUT);

    /* Set up interrupts on falling edge (button press, active low) */
    ret = gpio_pin_interrupt_configure_dt(&btn_ped, GPIO_INT_EDGE_TO_ACTIVE);
    if (ret < 0) {
        printk("Error: failed to configure pedestrian button interrupt\n");
        return ret;
    }

    ret = gpio_pin_interrupt_configure_dt(&btn_emrg, GPIO_INT_EDGE_TO_ACTIVE);
    if (ret < 0) {
        printk("Error: failed to configure emergency button interrupt\n");
        return ret;
    }

    /* Register callbacks */
    gpio_init_callback(&btn_ped_cb_data, btn_ped_callback, BIT(btn_ped.pin));
    gpio_add_callback(btn_ped.port, &btn_ped_cb_data);

    gpio_init_callback(&btn_emrg_cb_data, btn_emrg_callback, BIT(btn_emrg.pin));
    gpio_add_callback(btn_emrg.port, &btn_emrg_cb_data);

    return 0;
}

/* ---------- Light Cycle Thread (Priority 5, lowest) ---------- */
static void light_cycle_entry(void *p1, void *p2, void *p3) {
    ARG_UNUSED(p1); ARG_UNUSED(p2); ARG_UNUSED(p3);

    for (;;) {
        /* Red phase: 3 seconds */
        set_leds(1, 0, 0);
        log_state("LightCycle", "RED on");
        k_msleep(3000);

        /* Yellow phase: 1 second */
        set_leds(0, 1, 0);
        log_state("LightCycle", "YELLOW on");
        k_msleep(1000);

        /* Green phase: 3 seconds */
        set_leds(0, 0, 1);
        log_state("LightCycle", "GREEN on");
        k_msleep(3000);

        /* Yellow before red */
        set_leds(0, 1, 0);
        log_state("LightCycle", "YELLOW on");
        k_msleep(1000);
    }
}

/* ---------- Pedestrian Thread (Priority 4, medium) ---------- */
static void pedestrian_entry(void *p1, void *p2, void *p3) {
    ARG_UNUSED(p1); ARG_UNUSED(p2); ARG_UNUSED(p3);

    for (;;) {
        /* Block until button press semaphore is given */
        k_sem_take(&ped_sem, K_FOREVER);

        log_state("Pedestrian", "Button pressed, requesting walk signal");

        /* Suspend the light cycle thread */
        k_thread_suspend(light_cycle_tid);

        /* Flash green 5 times to warn drivers */
        for (int i = 0; i < 5; i++) {
            set_leds(0, 0, 1);
            k_msleep(150);
            set_leds(0, 0, 0);
            k_msleep(150);
        }

        /* Red for vehicles, pedestrian crosses */
        set_leds(1, 0, 0);
        log_state("Pedestrian", "WALK signal active (red for vehicles)");
        k_msleep(5000);

        log_state("Pedestrian", "Walk complete, resuming normal cycle");

        /* Resume normal cycle */
        k_thread_resume(light_cycle_tid);
    }
}

/* ---------- Emergency Thread (Priority 2, highest) ---------- */
static void emergency_entry(void *p1, void *p2, void *p3) {
    ARG_UNUSED(p1); ARG_UNUSED(p2); ARG_UNUSED(p3);

    for (;;) {
        /* Block until emergency button press */
        k_sem_take(&emrg_sem, K_FOREVER);

        log_state("Emergency", "Override activated, flashing red");

        /* Suspend both lower-priority threads */
        k_thread_suspend(light_cycle_tid);
        k_thread_suspend(pedestrian_tid);

        /* Flash red for 10 seconds */
        for (int i = 0; i < 20; i++) {
            set_leds(1, 0, 0);
            k_msleep(250);
            set_leds(0, 0, 0);
            k_msleep(250);
        }

        log_state("Emergency", "Override complete, resuming normal operation");

        /* Resume threads */
        k_thread_resume(pedestrian_tid);
        k_thread_resume(light_cycle_tid);
    }
}

/* ---------- Static thread definitions ---------- */
K_THREAD_DEFINE(light_cycle_tid,  1024, light_cycle_entry,
                NULL, NULL, NULL, 5, 0, 0);

K_THREAD_DEFINE(pedestrian_tid,   1024, pedestrian_entry,
                NULL, NULL, NULL, 4, 0, 0);

K_THREAD_DEFINE(emergency_tid,    1024, emergency_entry,
                NULL, NULL, NULL, 2, 0, 0);

/* ---------- Main (runs once at boot) ---------- */
int main(void) {
    printk("Zephyr Traffic Light Controller starting...\n");

    if (hw_init() < 0) {
        printk("Hardware init failed. Halting.\n");
        return -1;
    }

    printk("Hardware initialized. Threads running.\n");

    /* Threads are already started by K_THREAD_DEFINE.
       main() can return; the kernel keeps running. */
    return 0;
}