volatile và atomic

/* Vấn đề duy nhất mà volatile giải quyết trọn vẹn:
   trình biên dịch không biết ISR tồn tại. */

static volatile uint8_t co_du_lieu = 0u;

void USART1_IRQHandler(void)
{
    (void)USART1->DR;
    co_du_lieu = 1u;
}

int main(void)
{
    while (co_du_lieu == 0u) { }      /* đọc lại RAM mỗi vòng */

    xu_ly();

    return 0;
}

volatile uint32_t g_dem = 0u;

void TIM2_IRQHandler(void)
{
    TIM2->SR = ~(1u << 0);
    ++g_dem;              /* ISR tang */
}

void main_giam(void)
{
    --g_dem;              /* main giam */
}

/* Ca hai deu la ba lenh. Neu ngat chen vao giua ba lenh cua main:

     main: ldr  r3, [r0]      @ doc 100
     --- NGAT: g_dem thanh 101 ---
     main: subs r3, r3, #1    @ tinh 100 - 1 = 99
     main: str  r3, [r0]      @ ghi 99

   Ket qua 99 thay vi 100. Lan tang cua ISR bi MAT. */

volatile uint64_t g_moc;      /* 64 bit, doc bang hai lenh */

typedef struct { uint16_t x, y; } Diem;

volatile Diem g_vi_tri;       /* hai truong, phai nhat quan */

/* Ca hai truong hop deu can vung toi han, xem Bai 49.4.
   volatile chi bao dam moi lenh duoc sinh ra, khong bao dam
   chung chay lien mach. */

uint32_t ket_qua;              /* bien THUONG */
volatile uint32_t co_xong;     /* volatile */

void tinh_toan(void)
{
    ket_qua = tinh_gi_do();    /* lenh thuong */
    co_xong = 1u;              /* lenh volatile */
}

/* Chuan C KHONG cam trinh bien dich chuyen lenh gan ket_qua
   xuong SAU lenh gan co_xong.

   Neu no lam vay, va ISR doc co_xong roi doc ket_qua ngay,
   thi ISR thay co_xong bang 1 nhung ket_qua chua duoc ghi. */

/* Cach chua 1: cho ket_qua cung volatile */
volatile uint32_t ket_qua;

/* Cach chua 2: rao can trinh bien dich giua hai lenh */
ket_qua = tinh_gi_do();
__asm volatile ("" ::: "memory");
co_xong = 1u;

#include <signal.h>

volatile sig_atomic_t co_du_lieu = 0;

void USART1_IRQHandler(void)
{
    (void)USART1->DR;
    co_du_lieu = 1;        /* ghi nguyen tu, bao dam boi chuan */
}

int main(void)
{
    while (co_du_lieu == 0) { }

    co_du_lieu = 0;
    xu_ly();

    return 0;
}

/* Van can volatile: sig_atomic_t bao dam TINH NGUYEN TU,
   khong bao dam trinh bien dich doc lai tu RAM.
   Hai thu khac nhau, va can ca hai. */

#include <stdatomic.h>

static atomic_uint g_dem = 0u;

void TIM2_IRQHandler(void)
{
    TIM2->SR = ~(1u << 0);

    atomic_fetch_add(&g_dem, 1u);      /* tang NGUYEN TU */
}

uint32_t doc_dem(void)
{
    return atomic_load(&g_dem);
}

/* Tren Cortex-M3 tro len, trinh bien dich sinh ra vong lap
   LDREX va STREX. Tren Cortex-M0 khong co hai lenh do,
   nen no goi mot ham thu vien tu tat ngat. */

/* Rao can TRINH BIEN DICH: khong sinh lenh nao */
#define RAO_CAN_BIEN_DICH()   __asm volatile ("" ::: "memory")

/* Rao can BO NHO cua ARM, sinh lenh that: */
__DMB();      /* Data Memory Barrier: moi truy cap bo nho truoc no
                 phai xong truoc khi truy cap sau no bat dau */

__DSB();      /* Data Synchronization Barrier: manh hon, cho MOI
                 lenh truoc do hoan tat, ke ca ghi vao ngoai vi */

__ISB();      /* Instruction Synchronization Barrier: xoa duong ong
                 lenh, buoc doc lai lenh tu bo nho */

/* 1. Ghi du lieu roi cho DMA doc */
bo_dem[0] = 0x12u;
bo_dem[1] = 0x34u;

__DMB();                            /* bao dam hai lenh ghi da toi RAM */

DMA1_Stream0->CR |= 1u;             /* gio moi bat DMA */

/* 2. Xoa co ngat roi tra ve khoi ISR */
EXTI->PR = (1u << 0);

__DSB();                            /* bao dam lenh ghi da toi ngoai vi */

/* 3. Doi bang vector roi bat ngat */
SCB->VTOR = 0x08008000u;

__DSB();
__ISB();                            /* xoa duong ong, doc lai lenh */

__enable_irq();

/* 4. Bat MPU roi truy cap vung vua cau hinh */
MPU->CTRL = 1u;

__DSB();
__ISB();

/* KHONG co rao can: trinh bien dich co the chuyen tinh_toan()
   ra ngoai cap lenh bat tat chan, va ban do ra 4 chu ky. */
GPIOA->BSRR = (1u << 7);
uint32_t v = tinh_toan();
GPIOA->BSRR = (1u << (7 + 16));

/* CO rao can: dam bao tinh_toan chay giua hai canh. */
GPIOA->BSRR = (1u << 7);
RAO_CAN_BIEN_DICH();

uint32_t v = tinh_toan();

RAO_CAN_BIEN_DICH();
GPIOA->BSRR = (1u << (7 + 16));

#include <stdint.h>
#include <signal.h>

/* Co don gian: volatile la du */
static volatile sig_atomic_t co_tick = 0;

/* Bo dem vong: CA HAI chi so VA mang deu volatile */
#define N 256u
static volatile uint8_t  ring[N];
static volatile uint16_t ring_ghi = 0u;
static volatile uint16_t ring_doc = 0u;

/* Bo dem ca hai ben cung sua: can atomic */
static atomic_uint g_tong_byte = 0u;

/* Bien chi ISR dung: KHONG volatile */
static uint16_t isr_dem_noi_bo = 0u;

/* Bien chi main dung: KHONG volatile */
static uint32_t main_bo_dem_tam[64];

void USART1_IRQHandler(void)
{
    uint32_t sr = USART1->SR;

    if (sr & (1u << 5)) {
        uint8_t  b  = (uint8_t)USART1->DR;
        uint16_t ke = (uint16_t)((ring_ghi + 1u) & (N - 1u));

        if (ke != ring_doc) {
            ring[ring_ghi] = b;      /* ghi du lieu TRUOC */
            ring_ghi       = ke;     /* roi cong bo */

            atomic_fetch_add(&g_tong_byte, 1u);
        }
    }

    ++isr_dem_noi_bo;                /* chi ISR dung, khong can volatile */
}