Semaphores, Mutexes & Message Queues

#include "FreeRTOS.h"
#include "semphr.h"

/* Binary semaphore: signal between ISR and task */
/* ISR "gives" (signals); task "takes" (waits) */
static SemaphoreHandle_t g_can_rx_sem;
static StaticSemaphore_t g_can_rx_sem_buf;

void Init(void) {
    g_can_rx_sem = xSemaphoreCreateBinaryStatic(&g_can_rx_sem_buf);
}

/* ISR: give semaphore (non-blocking, from ISR context) */
void CAN0_RX_ISR(void) {
    BaseType_t higher_prio_woken = pdFALSE;
    xSemaphoreGiveFromISR(g_can_rx_sem, &higher_prio_woken);
    portYIELD_FROM_ISR(higher_prio_woken);  /* yield if higher-prio task unblocked */
}

/* Task: wait for semaphore (blocks until ISR signals) */
void Task_ProcessCan(void *p) {
    (void)p;
    for (;;) {
        if (xSemaphoreTake(g_can_rx_sem, pdMS_TO_TICKS(10u)) == pdTRUE) {
            process_can_message();  /* process the received frame */
        }
        /* else: timeout — handle missing message */
    }
}

/* Counting semaphore: track available resources or event count */
static SemaphoreHandle_t g_free_buf_count;

void Pool_Init(void) {
    /* 8 free buffers initially */
    g_free_buf_count = xSemaphoreCreateCounting(8u, 8u);
}
uint8_t *Pool_Alloc(void) {
    if (xSemaphoreTake(g_free_buf_count, 0u) == pdTRUE) {
        return get_next_free_buffer();
    }
    return NULL;  /* no buffers available */
}
void Pool_Free(uint8_t *buf) {
    return_buffer(buf);
    xSemaphoreGive(g_free_buf_count);  /* increment count */
}

#include "FreeRTOS.h"
#include "semphr.h"

/* Mutex: protects shared resource; prevents priority inversion via inheritance */
static SemaphoreHandle_t g_spi_mutex;
static StaticSemaphore_t g_spi_mutex_buf;

void Spi_Init(void) {
    g_spi_mutex = xSemaphoreCreateMutexStatic(&g_spi_mutex_buf);
}

/* Both tasks share SPI bus; mutex ensures one at a time */
Std_ReturnType Spi_Transfer(const uint8_t *tx, uint8_t *rx, uint8_t len)
{
    if (xSemaphoreTake(g_spi_mutex, pdMS_TO_TICKS(50u)) != pdTRUE) {
        return E_NOT_OK;  /* timeout: SPI bus busy */
    }

    /* Critical section: exclusive SPI access */
    Std_ReturnType ret = Spi_DoTransfer_Internal(tx, rx, len);

    xSemaphoreGive(g_spi_mutex);  /* ALWAYS release, even if transfer failed */
    return ret;
}

/* NEVER take a mutex from ISR context — use binary semaphore instead */
/* NEVER take mutex from ISR: causes priority inversion + potential deadlock */

/* Key difference: mutex vs semaphore
   Mutex: ownership (only the taker can release); priority inheritance
   Semaphore: no ownership (any task/ISR can give); no priority inheritance */

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

typedef struct {
    uint16_t id;
    uint8_t  dlc;
    uint8_t  data[8];
} CanFrame_t;

#define CAN_QUEUE_DEPTH  16u
static QueueHandle_t g_can_rx_queue;
static StaticQueue_t g_can_rx_queue_buf;
static uint8_t       g_can_rx_queue_storage[CAN_QUEUE_DEPTH * sizeof(CanFrame_t)];

void CanQueue_Init(void) {
    g_can_rx_queue = xQueueCreateStatic(
        CAN_QUEUE_DEPTH, sizeof(CanFrame_t),
        g_can_rx_queue_storage, &g_can_rx_queue_buf);
}

/* ISR: enqueue received frame */
void CAN0_RX_ISR(void) {
    CanFrame_t frame;
    frame.id  = CAN0_RXID_REG & 0x7FFu;
    frame.dlc = (uint8_t)(CAN0_RXCTRL_REG & 0x0Fu);
    read_can_data(frame.data, frame.dlc);

    BaseType_t hp_woken = pdFALSE;
    if (xQueueSendFromISR(g_can_rx_queue, &frame, &hp_woken) != pdTRUE) {
        /* Queue full: increment overflow counter */
        g_can_rx_overflow++;
    }
    portYIELD_FROM_ISR(hp_woken);
}

/* Task: dequeue and process */
void Task_CanProcess(void *p) {
    CanFrame_t frame;
    for (;;) {
        if (xQueueReceive(g_can_rx_queue, &frame, portMAX_DELAY) == pdTRUE) {
            App_ProcessCanFrame(&frame);
        }
    }
}