ESP32 में फीफो UART बफर की विशेषताएं

ESP32 में तीन UART हैं। जिनमें से प्रत्येक रिसीवर की FIFO बफर और ट्रांसमीटर की FIFO बफर को 1024 बाइट्स (ईएसपी 32 तकनीकी संदर्भ मैनुअल 3.5) की साझा मेमोरी में रखता है:

हालांकि, जब मैंने UART2 ट्रांसमीटर बफर के FIFO आकार को 128 से 256 बाइट्स तक बढ़ाने की कोशिश की, तो मुझे एक अप्रत्याशित प्रभाव मिला - प्रेषित डेटा ने UART0 रिसीवर के फीफो बफर को खराब कर दिया, जो कि प्रलेखन के अनुसार नहीं होना चाहिए।

दुर्भाग्य से प्रलेखन (ESP32 तकनीकी संदर्भ मैनुअल 3.5) में फीफो बफर रजिस्टरों का कोई विवरण नहीं है। हालाँकि, esp-idf हेडर फ़ाइलों में (uart_struct.h में) पाए गए:

1) ट्रांसमीटर बफर के फीफो स्थिति रजिस्टर (आधार पते के सापेक्ष ऑफसेट 0x5c):

union { struct { uint32_t status:24; uint32_t reserved24: 8; }; uint32_t val; } mem_tx_status; 

2) रिसीवर बफर के FIFO स्थिति रजिस्टर (आधार पते 0x60 के सापेक्ष ऑफसेट):

  union { struct { uint32_t status: 24; uint32_t reserved24: 8; }; struct { uint32_t reserved0: 2; uint32_t rd_addr: 11; /*This register stores the rx mem read address.*/ uint32_t wr_addr: 11; /*This register stores the rx mem write address.*/ uint32_t reserved: 8; }; uint32_t val; } mem_rx_status; 

यह मानते हुए कि mem_tx_status mem_rx_status बिट्स के उद्देश्य से मेल खाता है, हम FIFO बफ़र्स के पते प्राप्त करने के लिए निम्नलिखित कोड लिखते हैं:

 #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include <driver/uart.h> void print_uart_st(uart_dev_t *u,int num) { printf("UART%d:\n",num); printf("rx_st=0x%X\n",(unsigned int)u->mem_rx_status.val); printf("rx_rd=0x%X\n",(unsigned int)u->mem_rx_status.rd_addr); printf("rx_wr=0x%X\n",(unsigned int)u->mem_rx_status.wr_addr); uint32_t tx_s = u->mem_tx_status.val; printf("tx_st=0x%X\n",tx_s); printf("tx_rd=0x%X\n",(tx_s>>2)&2047); printf("tx_wr=0x%X\n",(tx_s>>13)&2047); } uart_config_t uart_config = { .baud_rate = 115200, .data_bits = UART_DATA_8_BITS, .parity = UART_PARITY_DISABLE, .stop_bits = UART_STOP_BITS_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE }; void UARTtest(void * param) { uart_param_config(UART_NUM_1,&uart_config); uart_param_config(UART_NUM_2,&uart_config); uart_driver_install(UART_NUM_1, 256, 0, 0, NULL, 0); uart_driver_install(UART_NUM_2, 256, 0, 0, NULL, 0); uart_set_pin(UART_NUM_1, UART_PIN_NO_CHANGE, GPIO_NUM_16, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); uart_set_pin(UART_NUM_2, UART_PIN_NO_CHANGE, GPIO_NUM_16, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); vTaskDelay(1000/portTICK_PERIOD_MS); while (1) { print_uart_st(&UART0,0); print_uart_st(&UART1,1); print_uart_st(&UART2,2); vTaskDelay(2000/portTICK_PERIOD_MS); char s[256]; uart_write_bytes(UART_NUM_1, s, 1); uart_write_bytes(UART_NUM_2, s, 2); if(gets(s)!=NULL) { printf("recived=%s\n",s); } } } void app_main(void) { xTaskCreate(UARTtest, "UARTtest", 4096, NULL, 5, NULL); } 

शुरू करने के बाद, हम प्राप्त करते हैं:

UART0:
rx_st = 0x300600
rx_rd = 0x180
rx_wr = 0x180
tx_st = 0xCE058
tx_rd = 0x16
tx_wr = 0x67
UART1:
rx_st = 0x400800
rx_rd = 0x200
rx_wr = 0x200
tx_st = 0x100200
tx_rd = 0x80
tx_wr = 0x80
UART2:
rx_st = 0x500A00
rx_rd = 0x280
rx_wr = 0x280
tx_st = 0x200400
tx_rd = 0x100
tx_wr = 0x100

आउटपुट UART0 के माध्यम से किया जाता है, इसलिए tx_wr और tx_rd 0. से भिन्न होते हैं। प्राप्त परिणामों के अनुसार, FIFO बफ़र्स UART0,1,2 के बीच मेमोरी आवंटन निम्नानुसार है:

इसके अलावा, FIFO बफ़र्स की स्थिति रजिस्टरों में 11 बिट्स की थोड़ी क्षमता होती है, जिसका अर्थ है कि FIFO बफर = 2Kb के लिए आवंटित मेमोरी का आकार संभव है। UART0.mem_conf.tx_size = 15 सेट करते समय (मेमोरी 128 बाइट्स लंबे टुकड़ों में आवंटित की जाती है), 1920 बाइट्स आवंटित किए जाएंगे, और रजिस्टर tx_wr ट्रांसमिशन के दौरान 1919 में गिना जाएगा और 0 से गिनती करना जारी रखेगा। हालाँकि, स्मृति को केवल ml संबोधित किया जाता है। 10 बिट्स यानी FIFO बफर = 1 केबी के लिए आवंटित वास्तविक कुल मेमोरी।

कुल:

1. फीफो UART के लिए ESP32 को आवंटित साझा मेमोरी का आवंटन तकनीकी संदर्भ मैनुअल 3.5 से मेल नहीं खाता है;
   
2. साझा की गई मेमोरी FIFO UART = 1Kb की मात्रा।