**Introducere** Comunicația serială UART (Universal Asynchronous Receiver/Transmitter) rămâne unul dintre cele mai importante protocoale în embedded și sisteme industriale. Chiar dacă aplicațiile moderne folosesc Ethernet, USB, CAN sau PCIe, UART este încă indispensabil pentru debug, bootloadere, configurare de senzori, interfațare cu modemuri (LTE/5G), module GNSS și, foarte des, pentru logging în producție. În continuare construim, pas cu pas, un **driver UART în C**, **portabil** și **ușor de adaptat** diferitelor MC... **Arhitectura generală a unui driver UART** Un driver UART trebuie să acopere mai multe responsabilități: - Inițializarea perifericului cu parametri: baudrate, paritate, număr de biți, stop bits. - Transmiterea datelor (polling, buffer sau DMA). - Recepția datelor (cu buffer circular și ISR). - Gestionarea erorilor (framing, overrun, parity). - API clar pentru aplicație (send, receive, configure). Pentru portabilitate, se recomandă separarea în: 1. **Interfața publică (API)** – expusă aplicației. 2. **Implementarea dependentă de hardware (HAL)** – care știe să configureze și să acceseze registrele. 3. **Strat de abstracție** pentru a putea schimba între hardware real, simulare POSIX sau test pe PC. ... **Implementarea API-ului UART** Vom defini o interfață generală: ```c #ifndef UART_H #define UART_H #include #include #include typedef enum { UART_OK = 0, UART_ERROR = -1, UART_BUSY = -2, UART_TIMEOUT = -3 } uart_status_t; typedef struct { uint32_t baudrate; uint8_t databits; // 7, 8 uint8_t stopbits; // 1, 2 char parity; // 'N', 'E', 'O' } uart_config_t; // Funcții publice uart_status_t uart_init(int port, const uart_config_t *cfg); uart_status_t uart_write(int port, const uint8_t *data, size_t len); int uart_read(int port, uint8_t *data, size_t len, uint32_t timeout_ms); void uart_irq_handler(int port); // apelată din ISR #endif ``` Această interfață poate fi implementată atât pe un microcontroler (HAL propriu), cât și pe Linux (cu `termios`). ... **Buffer circular (Ring Buffer) pentru RX/TX** Pentru a evita pierderea datelor la recepție, driverul folosește un **buffer circular**. Implementare simplă: ```c #define UART_BUFFER_SIZE 256 typedef struct { uint8_t data[UART_BUFFER_SIZE]; volatile size_t head; volatile size_t tail; } ring_buffer_t; static inline void rb_init(ring_buffer_t *rb) { rb->head = rb->tail = 0; } static inline bool rb_is_empty(const ring_buffer_t *rb) { return rb->head == rb->tail; } static inline bool rb_is_full(const ring_buffer_t *rb) { return ((rb->head + 1) % UART_BUFFER_SIZE) == rb->tail; } static inline void rb_push(ring_buffer_t *rb, uint8_t c) { if (!rb_is_full(rb)) { rb->data[rb->head] = c; rb->head = (rb->head + 1) % UART_BUFFER_SIZE; } } static inline uint8_t rb_pop(ring_buffer_t *rb) { uint8_t c = 0; if (!rb_is_empty(rb)) { c = rb->data[rb->tail]; rb->tail = (rb->tail + 1) % UART_BUFFER_SIZE; } return c; } ``` ... **Tratarea întreruperilor UART (ISR)** Într-un microcontroler tipic (ARM Cortex-M, AVR etc.), UART generează întreruperi la: - RXNE (RX not empty) – există date de citit. - TXE (TX empty) – registrul e gol și poate primi alt octet. Handler tipic: ```c void USART1_IRQHandler(void) { if (USART1->SR & (1 << 5)) { // RXNE uint8_t c = USART1->DR; rb_push(&rx_buffer, c); } if (USART1->SR & (1 << 7)) { // TXE if (!rb_is_empty(&tx_buffer)) { USART1->DR = rb_pop(&tx_buffer); } else { // Nimic de trimis – dezactivează TXE interrupt USART1->CR1 &= ~(1 << 7); } } } ``` ... **Suport opțional DMA** La viteze mari (921600 baud sau mai mult), se recomandă folosirea DMA. Transmiterea se face setând un buffer, iar hardware-ul mută octeții automat. Driverul trebuie doar să notifice aplicația când transferul s-a încheiat. ... **Exemplu de backend POSIX (Linux)** Pentru testare pe PC putem folosi `termios`: ```c #include #include #include #include int uart_fd; int uart_open(const char *device, int baudrate) { uart_fd = open(device, O_RDWR | O_NOCTTY | O_SYNC); struct termios tty; memset(&tty, 0, sizeof tty); tcgetattr(uart_fd, &tty); cfsetospeed(&tty, baudrate); cfsetispeed(&tty, baudrate); tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8; tty.c_iflag = 0; tty.c_oflag = 0; tty.c_lflag = 0; tcsetattr(uart_fd, TCSANOW, &tty); return uart_fd; } ``` Astfel putem testa driverul și pe desktop, fără hardware embedded. ... **Extensii: RS-485 și half-duplex** Multe sisteme industriale folosesc UART cu transceiver RS-485, care este half-duplex și necesită controlul pinului DE/RE. Driverul poate oferi hook-uri pentru a activa TX înainte de transmitere și a reveni la RX după. ... **Testare și validare** Un driver UART trebuie testat în: - Loopback (TX conectat la RX). - Stres test cu mesaje mari. - Test cu erori de framing simulate. - Test de performanță (baudrate maxim stabil). ... **Concluzie** Am construit un driver UART în C cu un **API clar**, **buffer circular**, **ISR hooks**, **posibilitate de DMA** și **control RS-485**, plus un **backend POSIX** pentru testare pe desktop. Separarea pe straturi permite portarea rapidă între platforme, iar atenția la detalii (flow control, timeouts, erori) conferă robustețe în producție. Cu această bază, puteți integra ușor protocoale de nivel superior (cadrare, CRC, comenzi), puteți scala la debite mari cu DMA și puteți menține aceeași interfață publică atât în embedded cât și în simulare.