🌱 STM32 - 14. Lập trình Thanh ghi STM32 - Ngoại vi UART (Pooling)

byNguyễn Văn Nghĩa -
2

🌱 STM32 - 14. Lập trình Thanh ghi STM32 - Ngoại vi UART (Pooling)

    Post này sẽ tập trung vào quá trình khởi tạo, truyền, nhận qua ngoại vi USART của vi điều khiển STM32. Dù bạn lập trình thanh ghi hay thư viện thì cũng đều tuân thủ theo Workflow cơ bản này. (Mình sẽ chủ yếu nói đến quá trình truyền/nhận theo kiểu Polling).

STM32F401 NUCLEO Board

Hình 1: Board STM32F401 NUCLEO với các chân GPIO

    Để thực hành với USART, các bạn cần nắm được các kiến thức cơ bản và các thanh ghi của nó:

👉 Khởi tạo USART

    Việc khởi tạo USART, chúng ta sẽ khởi tạo 2 đặc điểm quan trọng nhất của USART là khung truyền (bao gồm độ dài khung truyền, số bit Stop) và tốc độ Baudrate.

  1. Cấu hình bit M trong thanh ghi USART_CR1 để xác định độ dài khung truyền là 8 bits hay 9 bits (Word Length).
  2. Cấu hình số bit Stop bằng bit STOP trong thanh ghi USART_CR2.
  3. Tính toán Baudrate và cấu hình bằng thanh ghi USART_BRR.
  4. Cho phép quá trình truyền dữ liệu bằng bit TE trên thanh ghi USART_CR1.
  5. Cho phép quá trình nhận dữ liệu bằng bit RE trên thanh ghi USART_CR1.
  6. Cho phép ngoại vi USART bằng bit UE trên thanh ghi USART_CR1.

    Các bước 4, 5 có thể chọn 1 trong 2 nếu USART của chúng ta chỉ cho phép truyền hoặc nhận.

    ➤ Định nghĩa các thanh ghi cần thiết (UART, Clock, GPIO)

  1. // Base address definitions
  2. #define RCC_BASE        0x40023800
  3. #define GPIOA_BASE      0x40020000
  4. #define USART2_BASE     0x40004400
  6. // RCC register definitions
  7. #define RCC_CR          (*(volatile uint32_t *)(RCC_BASE + 0x00))
  8. #define RCC_CFGR        (*(volatile uint32_t *)(RCC_BASE + 0x08))
  9. #define RCC_AHB1ENR     (*(volatile uint32_t *)(RCC_BASE + 0x30))
  10. #define RCC_APB1ENR     (*(volatile uint32_t *)(RCC_BASE + 0x40))
  12. // GPIOA register definitions
  13. #define GPIOA_MODER     (*(volatile uint32_t *)(GPIOA_BASE + 0x00))
  14. #define GPIOA_OTYPER    (*(volatile uint32_t *)(GPIOA_BASE + 0x04))
  15. #define GPIOA_OSPEEDR   (*(volatile uint32_t *)(GPIOA_BASE + 0x08))
  16. #define GPIOA_PUPDR     (*(volatile uint32_t *)(GPIOA_BASE + 0x0C))
  17. #define GPIOA_AFRL      (*(volatile uint32_t *)(GPIOA_BASE + 0x20))
  19. // USART2 register definitions
  20. #define USART2_SR       (*(volatile uint32_t *)(USART2_BASE + 0x00))
  21. #define USART2_DR       (*(volatile uint32_t *)(USART2_BASE + 0x04))
  22. #define USART2_BRR      (*(volatile uint32_t *)(USART2_BASE + 0x08))
  23. #define USART2_CR1      (*(volatile uint32_t *)(USART2_BASE + 0x0C))
  24. #define USART2_CR2      (*(volatile uint32_t *)(USART2_BASE + 0x10))
  25. #define USART2_CR3      (*(volatile uint32_t *)(USART2_BASE + 0x14))
  27. // RCC bit definitions
  28. #define RCC_CR_HSION    (1 << 0)
  29. #define RCC_CR_HSIRDY   (1 << 1)
  30. #define RCC_CFGR_SW_HSI (0 << 0)
  31. #define RCC_CFGR_HPRE_DIV1  (0 << 4)
  32. #define RCC_CFGR_PPRE1_DIV2 (4 << 10)
  33. #define RCC_AHB1ENR_GPIOAEN (1 << 0)
  34. #define RCC_APB1ENR_USART2EN (1 << 17)
  36. // GPIO bit definitions
  37. #define GPIO_MODER_AF   2
  38. #define GPIO_OSPEEDR_HIGH 3
  39. #define GPIO_PUPDR_NONE 0
  40. #define GPIO_AF7_USART2 7
  42. // USART_CR1 bit definitions
  43. #define USART_CR1_UE    (1 << 13)
  44. #define USART_CR1_TE    (1 << 3)
  45. #define USART_CR1_RE    (1 << 2)
  47. // USART_CR2 bit definitions
  48. #define USART_CR2_STOP_1BIT (0 << 12) // 1 stop bit
  50. // USART_SR bit definitions
  51. #define USART_SR_TXE    (1 << 7)
  52. #define USART_SR_TC     (1 << 6)
  53. #define USART_SR_RXNE   (1 << 5)
  54. #define USART_SR_ORE    (1 << 3) // Overrun Error
  55. #define USART_SR_FE     (1 << 1) // Framing Error
  56. #define USART_SR_PE     (1 << 0) // Parity Error

    ➤ Khởi tạo các module dependency cần thiết - Clock, GPIO

  1. // Clock configuration function
  2. void SystemClock_Config(void)
  3. {
  4.     RCC_CR |= RCC_CR_HSION;
  5.     while (!(RCC_CR & RCC_CR_HSIRDY));
  6.     RCC_CFGR &= ~(RCC_CFGR_SW_HSI);
  7.     RCC_CFGR |= RCC_CFGR_HPRE_DIV1;
  8.     RCC_CFGR |= RCC_CFGR_PPRE1_DIV2; // PCLK1 = 12 MHz
  9. }
  11. // GPIO configuration for USART2 (PA2-TX, PA3-RX)
  12. void GPIO_Init(void)
  13. {
  14.     RCC_AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
  16.     // Set PA2 (TX) and PA3 (RX) to Alternate Function
  17.     GPIOA_MODER &= ~(3 << (2 * 2));
  18.     GPIOA_MODER |= (GPIO_MODER_AF << (2 * 2));
  19.     GPIOA_MODER &= ~(3 << (3 * 2));
  20.     GPIOA_MODER |= (GPIO_MODER_AF << (3 * 2));
  22.     // High speed
  23.     GPIOA_OSPEEDR &= ~(3 << (2 * 2));
  24.     GPIOA_OSPEEDR |= (GPIO_OSPEEDR_HIGH << (2 * 2));
  25.     GPIOA_OSPEEDR &= ~(3 << (3 * 2));
  26.     GPIOA_OSPEEDR |= (GPIO_OSPEEDR_HIGH << (3 * 2));
  28.     // No pull-up/pull-down
  29.     GPIOA_PUPDR &= ~(3 << (2 * 2));
  30.     GPIOA_PUPDR &= ~(3 << (3 * 2));
  32.     // AF7 for USART2
  33.     GPIOA_AFRL &= ~(0xF << (2 * 4));
  34.     GPIOA_AFRL |= (GPIO_AF7_USART2 << (2 * 4));
  35.     GPIOA_AFRL &= ~(0xF << (3 * 4));
  36.     GPIOA_AFRL |= (GPIO_AF7_USART2 << (3 * 4));
  37. }

    ➤ Khởi tạo module UART với Baudrate 9600

  1. // USART2 initialization function
  2. void USART2_Init(void)
  3. {
  4.     RCC_APB1ENR |= RCC_APB1ENR_USART2EN;
  6.     // Configure Baudrate = 9600
  7.     USART2_BRR = (78 << 4) | 2; // 0x04E2
  9.     // Configure CR1: 8 bits, no parity, enable TX/RX
  10.     USART2_CR1 = 0;
  11.     USART2_CR1 |= USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
  13.     // Configure CR2: 1 stop bit
  14.     USART2_CR2 = 0;
  15.     USART2_CR2 |= USART_CR2_STOP_1BIT;
  17.     // Configure CR3: No hardware flow control
  18.     USART2_CR3 = 0;
  19. }

👉 Cấu hình truyền USART - TX

  1. Kiểm tra xem thanh ghi data có trống hay không bằng cờ TXE, nếu cờ TXE = 1 thì có thể ghi dữ liệu vào thanh ghi data để gửi đi.
  2. Ghi dữ liệu vào thanh ghi data USART_DR.
  3. Đợi đến khi data truyền xong bằng cờ TC (TC = 1).

Hình 1: Quy trình truyền dữ liệu UART (TX)

    ➤ Code truyền dữ liệu qua USART (Hàm truyền 1 byte và 1 chuỗi - Polling)

  1. // Function to transmit a character with error checking
  2. void USART2_TransmitChar(uint8_t data)
  3. {
  4.     while (!(USART2_SR & USART_SR_TXE));
  5.     USART2_DR = data;
  6.     while (!(USART2_SR & USART_SR_TC));
  7. }
  9. // Function to transmit a string
  10. void USART2_TransmitString(const char *str)
  11. {
  12.     while (*str) {
  13.         USART2_TransmitChar(*str++);
  14.     }
  15. }

👉 Cấu hình nhận USART - RX

  1. Đợi đến khi nhận dữ liệu xong bằng cờ RXNE, khi nhận xong thì cờ RXNE = 1.
  2. Đọc dữ liệu từ thanh ghi data USART_DR.

Hình 2: Quy trình nhận dữ liệu UART (RX)

    ➤ Code nhận dữ liệu qua USART (Hàm nhận 1 byte - Polling)

  1. // Function to receive a character with error checking
  2. uint8_t USART2_ReceiveChar(void)
  3. {
  4.     while (!(USART2_SR & USART_SR_RXNE))
  5.     {
  6.         // Check for errors
  7.         if (USART2_SR & (USART_SR_ORE | USART_SR_FE | USART_SR_PE))
  8.         {
  9.             // Error handling: Read DR to clear error flags
  10.             (void)USART2_DR;
  11.             return 0xFF; // Return error value
  12.         }
  13.     }
  14.     return (uint8_t)USART2_DR;
  15. }

👉 Ví dụ code minh họa Workflow

    Dưới đây là full đoạn code bare-metal minh họa Workflow khởi tạo, truyền và nhận dữ liệu qua USART2 trên STM32F401:

  1. #include <stdint.h> // Add header for standard data types
  3. // Base address definitions
  4. #define RCC_BASE        0x40023800
  5. #define GPIOA_BASE      0x40020000
  6. #define USART2_BASE     0x40004400
  8. // RCC register definitions
  9. #define RCC_CR          (*(volatile uint32_t *)(RCC_BASE + 0x00))
  10. #define RCC_CFGR        (*(volatile uint32_t *)(RCC_BASE + 0x08))
  11. #define RCC_AHB1ENR     (*(volatile uint32_t *)(RCC_BASE + 0x30))
  12. #define RCC_APB1ENR     (*(volatile uint32_t *)(RCC_BASE + 0x40))
  14. // GPIOA register definitions
  15. #define GPIOA_MODER     (*(volatile uint32_t *)(GPIOA_BASE + 0x00))
  16. #define GPIOA_OTYPER    (*(volatile uint32_t *)(GPIOA_BASE + 0x04))
  17. #define GPIOA_OSPEEDR   (*(volatile uint32_t *)(GPIOA_BASE + 0x08))
  18. #define GPIOA_PUPDR     (*(volatile uint32_t *)(GPIOA_BASE + 0x0C))
  19. #define GPIOA_AFRL      (*(volatile uint32_t *)(GPIOA_BASE + 0x20))
  21. // USART2 register definitions
  22. #define USART2_SR       (*(volatile uint32_t *)(USART2_BASE + 0x00))
  23. #define USART2_DR       (*(volatile uint32_t *)(USART2_BASE + 0x04))
  24. #define USART2_BRR      (*(volatile uint32_t *)(USART2_BASE + 0x08))
  25. #define USART2_CR1      (*(volatile uint32_t *)(USART2_BASE + 0x0C))
  26. #define USART2_CR2      (*(volatile uint32_t *)(USART2_BASE + 0x10))
  27. #define USART2_CR3      (*(volatile uint32_t *)(USART2_BASE + 0x14))
  29. // RCC bit definitions
  30. #define RCC_CR_HSION    (1 << 0)
  31. #define RCC_CR_HSIRDY   (1 << 1)
  32. #define RCC_CFGR_SW_HSI (0 << 0)
  33. #define RCC_CFGR_HPRE_DIV1  (0 << 4)
  34. #define RCC_CFGR_PPRE1_DIV2 (4 << 10)
  35. #define RCC_AHB1ENR_GPIOAEN (1 << 0)
  36. #define RCC_APB1ENR_USART2EN (1 << 17)
  38. // GPIO bit definitions
  39. #define GPIO_MODER_AF   2
  40. #define GPIO_OSPEEDR_HIGH 3
  41. #define GPIO_PUPDR_NONE 0
  42. #define GPIO_AF7_USART2 7
  44. // USART_CR1 bit definitions
  45. #define USART_CR1_UE    (1 << 13)
  46. #define USART_CR1_TE    (1 << 3)
  47. #define USART_CR1_RE    (1 << 2)
  49. // USART_CR2 bit definitions
  50. #define USART_CR2_STOP_1BIT (0 << 12) // 1 stop bit
  52. // USART_SR bit definitions
  53. #define USART_SR_TXE    (1 << 7)
  54. #define USART_SR_TC     (1 << 6)
  55. #define USART_SR_RXNE   (1 << 5)
  56. #define USART_SR_ORE    (1 << 3) // Overrun Error
  57. #define USART_SR_FE     (1 << 1) // Framing Error
  58. #define USART_SR_PE     (1 << 0) // Parity Error
  60. // Simple delay function (using loop)
  61. void Delay(uint32_t count) {
  62.     while (count--) {
  63.         __asm("nop"); // NOP instruction to create delay
  64.     }
  65. }
  67. // Clock configuration function
  68. void SystemClock_Config(void) {
  69.     RCC_CR |= RCC_CR_HSION;
  70.     while (!(RCC_CR & RCC_CR_HSIRDY));
  71.     RCC_CFGR &= ~(RCC_CFGR_SW_HSI);
  72.     RCC_CFGR |= RCC_CFGR_HPRE_DIV1;
  73.     RCC_CFGR |= RCC_CFGR_PPRE1_DIV2; // PCLK1 = 12 MHz
  74. }
  76. // GPIO configuration for USART2 (PA2-TX, PA3-RX)
  77. void GPIO_Init(void) {
  78.     RCC_AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
  80.     // Set PA2 (TX) and PA3 (RX) to Alternate Function
  81.     GPIOA_MODER &= ~(3 << (2 * 2));
  82.     GPIOA_MODER |= (GPIO_MODER_AF << (2 * 2));
  83.     GPIOA_MODER &= ~(3 << (3 * 2));
  84.     GPIOA_MODER |= (GPIO_MODER_AF << (3 * 2));
  86.     // High speed
  87.     GPIOA_OSPEEDR &= ~(3 << (2 * 2));
  88.     GPIOA_OSPEEDR |= (GPIO_OSPEEDR_HIGH << (2 * 2));
  89.     GPIOA_OSPEEDR &= ~(3 << (3 * 2));
  90.     GPIOA_OSPEEDR |= (GPIO_OSPEEDR_HIGH << (3 * 2));
  92.     // No pull-up/pull-down
  93.     GPIOA_PUPDR &= ~(3 << (2 * 2));
  94.     GPIOA_PUPDR &= ~(3 << (3 * 2));
  96.     // AF7 for USART2
  97.     GPIOA_AFRL &= ~(0xF << (2 * 4));
  98.     GPIOA_AFRL |= (GPIO_AF7_USART2 << (2 * 4));
  99.     GPIOA_AFRL &= ~(0xF << (3 * 4));
  100.     GPIOA_AFRL |= (GPIO_AF7_USART2 << (3 * 4));
  101. }
  103. // USART2 initialization function
  104. void USART2_Init(void)
  105. {
  106.     RCC_APB1ENR |= RCC_APB1ENR_USART2EN;
  108.     // Configure Baudrate = 9600
  109.     USART2_BRR = (78 << 4) | 2; // 0x04E2
  111.     // Configure CR1: 8 bits, no parity, enable TX/RX
  112.     USART2_CR1 = 0;
  113.     USART2_CR1 |= USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
  115.     // Configure CR2: 1 stop bit
  116.     USART2_CR2 = 0;
  117.     USART2_CR2 |= USART_CR2_STOP_1BIT;
  119.     // Configure CR3: No hardware flow control
  120.     USART2_CR3 = 0;
  121. }
  123. // Function to transmit a character with error checking
  124. void USART2_TransmitChar(uint8_t data) {
  125.     while (!(USART2_SR & USART_SR_TXE));
  126.     USART2_DR = data;
  127.     while (!(USART2_SR & USART_SR_TC));
  128. }
  130. // Function to transmit a string
  131. void USART2_TransmitString(const char *str) {
  132.     while (*str) {
  133.         USART2_TransmitChar(*str++);
  134.     }
  135. }
  137. // Function to receive a character with error checking
  138. uint8_t USART2_ReceiveChar(void)
  139. {
  140.     while (!(USART2_SR & USART_SR_RXNE))
  141.     {
  142.         // Check for errors
  143.         if (USART2_SR & (USART_SR_ORE | USART_SR_FE | USART_SR_PE))
  144.         {
  145.             // Error handling: Read DR to clear error flags
  146.             (void)USART2_DR;
  147.             return 0xFF; // Return error value
  148.         }
  149.     }
  150.     return (uint8_t)USART2_DR;
  151. }
  153. int main(void) {
  154.     SystemClock_Config();
  155.     GPIO_Init();
  156.     USART2_Init();
  158.     // Transmit "Hello" string with delay
  159.     USART2_TransmitString("Hello\r\n");
  160.     Delay(1000000); // Wait about 1 second
  162.     while (1) {
  163.         uint8_t received = USART2_ReceiveChar();
  164.         if (received != 0xFF) { // Not an error
  165.             USART2_TransmitChar(received); // Echo
  166.         }
  167.     }
  168. }

    Ok, bài này đến đây thôi, bài sau mình sẽ lấy một ví dụ về các hàm truyền nhận để các bạn hiểu rõ hơn về USART.

>>>>>> Follow ngay <<<<<<<

Để nhận được những bài học miễn phí mới nhất nhé 😊
Chúc các bạn học tập tốt 😊

Tags:
Nguyễn Văn Nghĩa

Mình là một người thích học hỏi và chia sẻ các kiến thức về Nhúng IOT.

2 Nhận xét

  1. Unknownlúc 20:17 12 tháng 10, 2021

    Anh lm thêm về SPI, I2C vs CAN đi anh, cảm ơn anh nhiều ạ.

    Trả lờiXóa
    Trả lời
    1. Nguyễn Văn Nghĩalúc 20:18 12 tháng 10, 2021

      Ok em có thời gian anh sẽ làm thêm về những giao thức khác :D

      Xóa
Mới hơn Cũ hơn
//