From ed1c1efa7aee67d36a37212c13998318f02c4350 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 19 Oct 2022 22:12:31 +0200 Subject: moved constants around --- stm32f091/consts.h | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 stm32f091/consts.h (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h new file mode 100644 index 0000000..e0d92bb --- /dev/null +++ b/stm32f091/consts.h @@ -0,0 +1,19 @@ +#pragma once + +#include "wifi.h" + +#define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 +#define WS_PINOUT_I2C_SDA_PORT GPIOB +#define WS_PINOUT_I2C_SCL_PIN GPIO_PIN_8 +#define WS_PINOUT_I2C_SCL_PORT GPIOB + +#define WS_PINOUT_USART1_RX_PIN GPIO_PIN_10 +#define WS_PINOUT_USART1_RX_PORT GPIOA +#define WS_PINOUT_USART1_TX_PIN GPIO_PIN_9 +#define WS_PINOUT_USART1_TX_PORT GPIOA + +#define WS_PINOUT_USART2_RX_PIN GPIO_PIN_3 +#define WS_PINOUT_USART2_RX_PORT GPIOA +#define WS_PINOUT_USART2_TX_PIN GPIO_PIN_2 +#define WS_PINOUT_USART2_TX_PORT GPIOA + -- cgit v1.2.3 From 183ed1e4c58f0c788db0b56886aad2dc258e9ddb Mon Sep 17 00:00:00 2001 From: lonkaars Date: Mon, 24 Oct 2022 18:12:11 +0200 Subject: server port in consts.h + function signature for incoming esp data --- stm32f091/consts.h | 2 ++ stm32f091/esp8266.c | 30 +++++++++++++++--------------- stm32f091/server.h | 29 ++++++++++++++++++++++++++--- 3 files changed, 43 insertions(+), 18 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h index e0d92bb..349ff21 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -2,6 +2,8 @@ #include "wifi.h" +#define WS_SERVER_PORT "80" + #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB #define WS_PINOUT_I2C_SCL_PIN GPIO_PIN_8 diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 9fccf70..4fdf7e6 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -48,6 +48,7 @@ int ws_esp8266_receivingMsg(uint8_t *receiveData,int length){ HAL_UART_Transmit(&huart2, receiveData,length,1000); ret = strstr((char*)receiveData,"+IPD"); // memset(receiveData,0,30); + if((ret[0]='+') && (ret[1]=='I')){ //HAL_UART_Transmit(&huart2, (uint8_t*)ret, sizeof(ret), 100); return 1; @@ -75,13 +76,12 @@ int ws_esp8266_unlink(uint8_t *receiveData,int length){ } void ws_esp8266_StartEsp(){ - uint8_t Tx_AT[]="AT\r\n"; uint8_t Rx_buffer[10]={0}; for(int i=0;i<3;i++){ // HAL_UART_Transmit(&huart2, hier,sizeof(hier),100); - HAL_UART_Transmit_IT(&huart1, Tx_AT,strlen((char*)Tx_AT)); - HAL_UART_Receive_IT(&huart1, Rx_buffer, 10); + HAL_UART_Transmit(&huart1, Tx_AT,strlen((char*)Tx_AT), 100); + HAL_UART_Receive(&huart1, Rx_buffer, 10, 100); HAL_UART_Transmit(&huart2, Rx_buffer,10,100); @@ -95,8 +95,8 @@ void ws_esp8266_disconnect(){ uint8_t Tx_disconnect[]="AT+CWQAP\r\n";uint8_t buffer[17]={0}; while(ret!=1){ - HAL_UART_Transmit_IT(&huart1, Tx_disconnect,strlen((char*)Tx_disconnect)); - HAL_UART_Receive_IT(&huart1, buffer, 17); + HAL_UART_Transmit(&huart1, Tx_disconnect,strlen((char*)Tx_disconnect), 100); + HAL_UART_Receive(&huart1, buffer, 17, 100); HAL_Delay(2000); if(ws_esp8266_checkOK(buffer,17)==1){ @@ -113,8 +113,8 @@ void ws_esp8266_mode(){ while(ret!=1){ - HAL_UART_Transmit_IT(&huart1, Tx_mode,strlen((char*)Tx_mode)); - HAL_UART_Receive_IT(&huart1, buffer1, 20); + HAL_UART_Transmit(&huart1, Tx_mode,strlen((char*)Tx_mode), 100); + HAL_UART_Receive(&huart1, buffer1, 20, 100); HAL_Delay(1000); if(ws_esp8266_checkOK(buffer1,20)==1){ @@ -142,12 +142,12 @@ void ws_esp8266_connect(){ } void ws_esp8266_serveraan(){ int ret; - uint8_t buffer1[30]={0}; uint8_t Tx_server[]="AT+CIPSERVER=1,80\r\n"; + uint8_t buffer1[30]={0}; uint8_t Tx_server[]="AT+CIPSERVER=1," WS_SERVER_PORT "\r\n"; while(ret!=1){ - HAL_UART_Transmit_IT(&huart1, Tx_server,strlen((char*)Tx_server)); - HAL_UART_Receive_IT(&huart1, buffer1, 30); + HAL_UART_Transmit(&huart1, Tx_server,strlen((char*)Tx_server), 100); + HAL_UART_Receive(&huart1, buffer1, 30, 100); HAL_Delay(2000); if(ws_esp8266_checkOK(buffer1,30)==1){ @@ -166,8 +166,8 @@ void ws_esp8266_serveruit(){ // // while(ret!=1){ - HAL_UART_Transmit_IT(&huart1, Tx_server,strlen((char*)Tx_server)); -// HAL_UART_Receive_IT(&huart1, buffer1, 27); + HAL_UART_Transmit(&huart1, Tx_server,strlen((char*)Tx_server), 100); +// HAL_UART_Receive(&huart1, buffer1, 27, 100); HAL_Delay(3000); // if(unlink(buffer1,27)==1){ @@ -185,8 +185,8 @@ void ws_esp8266_mux(){ while(ret!=1){ - HAL_UART_Transmit_IT(&huart1, Tx_mux,strlen((char*)Tx_mux)); - HAL_UART_Receive_IT(&huart1, buffer2, 20); + HAL_UART_Transmit(&huart1, Tx_mux,strlen((char*)Tx_mux), 100); + HAL_UART_Receive(&huart1, buffer2, 20, 100); HAL_Delay(2000); if(ws_esp8266_checkOK(buffer2,20)==1){ @@ -203,7 +203,7 @@ void ws_esp8266_close(){ uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; - HAL_UART_Transmit_IT(&huart1, Tx_close,strlen((char*)Tx_close)); + HAL_UART_Transmit(&huart1, Tx_close,strlen((char*)Tx_close), 100); HAL_Delay(3000); diff --git a/stm32f091/server.h b/stm32f091/server.h index 6a3501d..e134079 100644 --- a/stm32f091/server.h +++ b/stm32f091/server.h @@ -1,6 +1,29 @@ #pragma once -void ws_server_demo(); +#include +#include + +// void ws_server_demo(); +// +// /** FreeRTOS task that listens for incoming requests from the esp */ +// void ws_server_listen_task(); + +/** + * @brief +IPD incoming request handler + * + * this function takes chunks of data from the esp8266 and parses +IPD + * commands. when a valid +IPD command is detected, it gets forwarded to + * ws_protocol_parse_req_byte. + * + * @param data pointer to data array + * @param size amount of bytes allowed to be read from `data` + */ +void ws_server_req_incoming(uint8_t* data, size_t size); + +// TODO: server req incoming implementation +// +// example +IPD command: +// +IPD,0,15:last-records 5\n +// +// TODO: protocol req response parser -/** FreeRTOS task that listens for incoming requests from the esp */ -void ws_server_listen_task(); -- cgit v1.2.3 From 931b357fee219f7d69e3b2e1c5c275413de6010b Mon Sep 17 00:00:00 2001 From: "U-DESKTOP-LF2PDOO\\niels" Date: Tue, 25 Oct 2022 17:42:12 +0200 Subject: initial merge of CubeIDE code for dma idle read --- .gitignore | 1 + stm32f091/consts.h | 2 ++ stm32f091/esp8266.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++ stm32f091/esp8266.h | 10 ++++++++++ stm32f091/setup.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ stm32f091/setup.h | 2 ++ 6 files changed, 114 insertions(+) (limited to 'stm32f091/consts.h') diff --git a/.gitignore b/.gitignore index 18c2616..90d7960 100644 --- a/.gitignore +++ b/.gitignore @@ -18,4 +18,5 @@ shared/main .qmake.stash .vscode/.cortex-debug.registers.state.json copyright +temp/ diff --git a/stm32f091/consts.h b/stm32f091/consts.h index 349ff21..1d8648d 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -4,6 +4,8 @@ #define WS_SERVER_PORT "80" +#define WS_DMA_RX_BUFFER_SIZE 50 + #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB #define WS_PINOUT_I2C_SCL_PIN GPIO_PIN_8 diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 4fdf7e6..6a9f254 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -2,11 +2,64 @@ #include #include #include +#include #include "esp8266.h" #include "setup.h" #include "consts.h" +char g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; +char MainBuf[WS_DMA_RX_BUFFER_SIZE]; // TODO: remove +int isOK = 0; // TODO: remove +uint16_t g_ws_esp8266_dma_old_pos = 0; +uint16_t g_ws_esp8266_dma_new_pos = 0; + +// when rx receives data handle the message. this function is in stm32. this name needs to stay the same or else it wont work. +void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){ + if(huart->Instance == USART1) { + g_ws_esp8266_dma_old_pos = g_ws_esp8266_dma_new_pos; // Update the last position before copying new data + + if(g_ws_esp8266_dma_old_pos+Size > WS_DMA_RX_BUFFER_SIZE) { // if the current position + new data is greater than the main buffer + uint16_t dataToCopy = WS_DMA_RX_BUFFER_SIZE-g_ws_esp8266_dma_old_pos; // find remaining space left + memcpy ((uint8_t*)MainBuf+g_ws_esp8266_dma_old_pos,g_ws_esp8266_dma_rx_buffer,dataToCopy); // copy data in the remaining space + + g_ws_esp8266_dma_old_pos = 0; // point to the start of the buffer + memcpy ((uint8_t*)MainBuf,(uint8_t*)g_ws_esp8266_dma_rx_buffer+dataToCopy,(Size-dataToCopy)); // copy the remaing data + g_ws_esp8266_dma_new_pos = (Size-dataToCopy); // update position + } + // if data is less than new data + else { + memcpy ((uint8_t*)MainBuf+g_ws_esp8266_dma_old_pos,g_ws_esp8266_dma_rx_buffer,Size); + g_ws_esp8266_dma_new_pos = Size+g_ws_esp8266_dma_old_pos; + } + // start DMA again + // memset(g_ws_esp8266_dma_rx_buffer,'\0',g_ws_esp8266_dma_rx_buffer_Size); // clear rx_buff + HAL_UARTEx_ReceiveToIdle_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); + __HAL_DMA_DISABLE_IT(&hdma_usart1_rx,DMA_IT_HT); + } + + // check for OK messagge + for(int i=0;i +extern char g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; + +void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *, uint16_t); +/** @brief This function handles DMA1 channel 2 to 3 and DMA2 channel 1 to 2 interrupts. */ +void DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler(void); +/** @brief This function handles DMA1 channel 1 interrupt. */ +void DMA1_Ch1_IRQHandler(void); + void ws_esp8266_ATsendCommand(uint8_t* data); int ws_esp8266_checkOK(uint8_t *receiveData,int length); int ws_esp8266_receivingMsg(uint8_t *receiveData,int length); diff --git a/stm32f091/setup.c b/stm32f091/setup.c index fec2b7c..318de5a 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -5,6 +5,7 @@ #include #include +#include "esp8266.h" #include "setup.h" I2C_HandleTypeDef hi2c1 = { @@ -45,10 +46,33 @@ UART_HandleTypeDef huart2 = { .AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT, }; +DMA_HandleTypeDef hdma_usart1_rx = { + .Instance = DMA1_Channel1, + .Init.Direction = DMA_PERIPH_TO_MEMORY, + .Init.PeriphInc = DMA_PINC_DISABLE, + .Init.MemInc = DMA_MINC_ENABLE, + .Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE, + .Init.MemDataAlignment = DMA_MDATAALIGN_BYTE, + .Init.Mode = DMA_NORMAL, + .Init.Priority = DMA_PRIORITY_LOW, +}; + +DMA_HandleTypeDef hdma_usart1_tx { + .Instance = DMA1_Channel2, + .Init.Direction = DMA_MEMORY_TO_PERIPH, + .Init.PeriphInc = DMA_PINC_DISABLE, + .Init.MemInc = DMA_MINC_ENABLE, + .Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE, + .Init.MemDataAlignment = DMA_MDATAALIGN_BYTE, + .Init.Mode = DMA_NORMAL, + .Init.Priority = DMA_PRIORITY_LOW, +}; + static void ws_io_clock_setup(); static void ws_io_i2c_setup(); static void ws_io_usart1_setup(); static void ws_io_usart2_setup(); +static void ws_io_dma_setup(); static void ws_setup_error_handler(); void ws_io_setup() { @@ -58,6 +82,7 @@ void ws_io_setup() { ws_io_i2c_setup(); ws_io_usart1_setup(); ws_io_usart2_setup(); + ws_io_dma_setup(); } static void ws_io_clock_setup() { @@ -97,6 +122,9 @@ static void ws_io_i2c_setup() { static void ws_io_usart1_setup() { if (HAL_UART_Init(&huart1) != HAL_OK) return ws_setup_error_handler(); + + HAL_UARTEx_ReceiveToIdle_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); + __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); } static void ws_io_usart2_setup() { @@ -104,6 +132,16 @@ static void ws_io_usart2_setup() { return ws_setup_error_handler(); } +static void ws_io_dma_setup() { + __HAL_RCC_DMA1_CLK_ENABLE(); + + // interrupt priorities + HAL_NVIC_SetPriority(DMA1_Ch1_IRQn, 3, 0); + HAL_NVIC_EnableIRQ(DMA1_Ch1_IRQn); + HAL_NVIC_SetPriority(DMA1_Ch2_3_DMA2_Ch1_2_IRQn, 3, 0); + HAL_NVIC_EnableIRQ(DMA1_Ch2_3_DMA2_Ch1_2_IRQn); +} + void HAL_MspInit() { __HAL_RCC_SYSCFG_CLK_ENABLE(); __HAL_RCC_PWR_CLK_ENABLE(); @@ -136,6 +174,14 @@ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { .Alternate = GPIO_AF1_USART1, }); + // DMA setup + if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK) return ws_setup_error_handler(); + __HAL_DMA1_REMAP(HAL_DMA1_CH1_USART1_RX); + __HAL_LINKDMA(huart, hdmarx, hdma_usart1_rx); + if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK) return ws_setup_error_handler(); + __HAL_DMA1_REMAP(HAL_DMA1_CH2_USART1_TX); + __HAL_LINKDMA(huart, hdmatx, hdma_usart1_tx); + // USART1 interrupt Init HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); diff --git a/stm32f091/setup.h b/stm32f091/setup.h index 04fa177..d459635 100644 --- a/stm32f091/setup.h +++ b/stm32f091/setup.h @@ -9,6 +9,8 @@ extern I2C_HandleTypeDef hi2c1; extern UART_HandleTypeDef huart1; extern UART_HandleTypeDef huart2; +extern DMA_HandleTypeDef hdma_usart1_rx; +extern DMA_HandleTypeDef hdma_usart1_tx; void ws_io_setup(); -- cgit v1.2.3 From d945680142d5b16d8809ea200833edd97caec2f8 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 16:20:39 +0200 Subject: esp send with dma in seperate function --- stm32f091/consts.h | 1 + stm32f091/esp8266.c | 57 ++++++++++++----------------------------------------- stm32f091/esp8266.h | 19 ++++++++++++++---- stm32f091/test.c | 8 ++++---- 4 files changed, 33 insertions(+), 52 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h index 1d8648d..cf7d34f 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -5,6 +5,7 @@ #define WS_SERVER_PORT "80" #define WS_DMA_RX_BUFFER_SIZE 50 +#define WS_DMA_TX_BUFFER_SIZE 50 #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 98c4e10..24860a1 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -7,57 +7,26 @@ #include "esp8266.h" #include "setup.h" #include "consts.h" +#include "util.h" -char g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; -char MainBuf[WS_DMA_RX_BUFFER_SIZE]; // TODO: remove -int isOK = 0; // TODO: remove -uint16_t g_ws_esp8266_dma_old_pos = 0; -uint16_t g_ws_esp8266_dma_new_pos = 0; - -/* -// when rx receives data handle the message. this function is in stm32. this name needs to stay the same or else it wont work. -void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){ - if(huart->Instance == USART1) { - g_ws_esp8266_dma_old_pos = g_ws_esp8266_dma_new_pos; // Update the last position before copying new data - - if(g_ws_esp8266_dma_old_pos+Size > WS_DMA_RX_BUFFER_SIZE) { // if the current position + new data is greater than the main buffer - uint16_t dataToCopy = WS_DMA_RX_BUFFER_SIZE-g_ws_esp8266_dma_old_pos; // find remaining space left - memcpy ((uint8_t*)MainBuf+g_ws_esp8266_dma_old_pos,g_ws_esp8266_dma_rx_buffer,dataToCopy); // copy data in the remaining space - - g_ws_esp8266_dma_old_pos = 0; // point to the start of the buffer - memcpy ((uint8_t*)MainBuf,(uint8_t*)g_ws_esp8266_dma_rx_buffer+dataToCopy,(Size-dataToCopy)); // copy the remaing data - g_ws_esp8266_dma_new_pos = (Size-dataToCopy); // update position - } - // if data is less than new data - else { - memcpy ((uint8_t*)MainBuf+g_ws_esp8266_dma_old_pos,g_ws_esp8266_dma_rx_buffer,Size); - g_ws_esp8266_dma_new_pos = Size+g_ws_esp8266_dma_old_pos; - } - // start DMA again - // memset(g_ws_esp8266_dma_rx_buffer,'\0',g_ws_esp8266_dma_rx_buffer_Size); // clear rx_buff - HAL_UART_Receive_DMA(&huart1, (uint8_t*) g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); - __HAL_DMA_DISABLE_IT(&hdma_usart1_rx,DMA_IT_HT); - } +uint8_t g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; +uint8_t g_ws_esp8266_dma_tx_buffer[WS_DMA_TX_BUFFER_SIZE]; - // check for OK messagge - for(int i=0;i #include -extern char g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; +/** @brief null-terminated rx buffer string */ +extern uint8_t g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; +/** @brief null-terminated tx buffer string */ +extern uint8_t g_ws_esp8266_dma_tx_buffer[WS_DMA_TX_BUFFER_SIZE]; -// void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *, uint16_t); -/** @brief This function handles DMA1 channel 2 to 3 and DMA2 channel 1 to 2 interrupts. */ +/** @brief DMA1 channel 2-3 & DMA2 channel 1-2 interrupt handler */ void DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler(void); -/** @brief This function handles DMA1 channel 1 interrupt. */ +/** @brief DMA1 channel 1 interrupt handler */ void DMA1_Ch1_IRQHandler(void); +/** @brief USART1 interrupt handler */ void USART1_IRQHandler(void); +/** @brief send response to incoming request on specific channel */ +void ws_esp8266_res_send(unsigned int channel, uint8_t* data, size_t size); + +/** @brief send data to esp over uart with dma */ +void ws_esp8266_send(uint8_t* data, size_t size); + +// TODO: remove/update/document/refactor these functions void ws_esp8266_ATsendCommand(uint8_t* data); int ws_esp8266_checkOK(uint8_t *receiveData,int length); int ws_esp8266_receivingMsg(uint8_t *receiveData,int length); diff --git a/stm32f091/test.c b/stm32f091/test.c index 4d1b936..0960d0f 100644 --- a/stm32f091/test.c +++ b/stm32f091/test.c @@ -2,9 +2,9 @@ #include #include +#include "esp8266.h" #include "setup.h" - -uint8_t tx_buffer[] = "AT\r\n"; +#include "util.h" void ws_test_read_task() { uint8_t* buf; // TODO: not working @@ -15,9 +15,9 @@ void ws_test_read_task() { } void ws_test_write_task() { + uint8_t data[] = "AT\r\n"; while (1) { - HAL_UART_Transmit_DMA(&huart1, tx_buffer, sizeof(tx_buffer)); - __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); + ws_esp8266_send(data, sizeof(data)); HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); vTaskDelay(portTICK_PERIOD_MS * 1000 * 1); -- cgit v1.2.3 From d48374c0f38cb01d726958b49bda5c1b6e91ab91 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 19:18:26 +0200 Subject: WIP working dma receive to buffer --- stm32f091/consts.h | 2 +- stm32f091/esp8266.c | 8 ++++++++ stm32f091/esp8266.h | 10 +++++++--- stm32f091/main.c | 3 +-- stm32f091/setup.c | 11 ++++++++--- stm32f091/stm32f0xx_hal_conf.h | 2 ++ stm32f091/test.c | 13 +------------ stm32f091/test.h | 1 - 8 files changed, 28 insertions(+), 22 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h index cf7d34f..5f9d7a1 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -4,7 +4,7 @@ #define WS_SERVER_PORT "80" -#define WS_DMA_RX_BUFFER_SIZE 50 +#define WS_DMA_RX_BUFFER_SIZE 10 #define WS_DMA_TX_BUFFER_SIZE 50 #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 24860a1..5d1847b 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -16,6 +16,14 @@ void DMA1_Ch1_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_usart1_rx); } void DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_usart1_tx); } void USART1_IRQHandler(void) { HAL_UART_IRQHandler(&huart1); } +void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { + HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); + + HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE, 100); + HAL_UART_Receive_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); + __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); +} + void ws_esp8266_send(uint8_t* data, size_t size) { size_t limited_size = WS_MIN(size, WS_DMA_TX_BUFFER_SIZE - 1); memcpy(g_ws_esp8266_dma_tx_buffer, data, limited_size); diff --git a/stm32f091/esp8266.h b/stm32f091/esp8266.h index 8038679..0832e95 100644 --- a/stm32f091/esp8266.h +++ b/stm32f091/esp8266.h @@ -1,11 +1,12 @@ #pragma once -#include "consts.h" - +#include #include #include -/** @brief null-terminated rx buffer string */ +#include "consts.h" + +/** @brief DMA rx buffer */ extern uint8_t g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; /** @brief null-terminated tx buffer string */ extern uint8_t g_ws_esp8266_dma_tx_buffer[WS_DMA_TX_BUFFER_SIZE]; @@ -17,6 +18,9 @@ void DMA1_Ch1_IRQHandler(void); /** @brief USART1 interrupt handler */ void USART1_IRQHandler(void); +/** @brief receive chunk complete */ +void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart); + /** @brief send response to incoming request on specific channel */ void ws_esp8266_res_send(unsigned int channel, uint8_t* data, size_t size); diff --git a/stm32f091/main.c b/stm32f091/main.c index f5fe563..80eb5a7 100644 --- a/stm32f091/main.c +++ b/stm32f091/main.c @@ -11,7 +11,6 @@ int main() { ws_io_setup(); // xTaskCreate(ws_sensor_read_task, "sensor", 64, NULL, 1, NULL); - xTaskCreate(ws_test_write_task, "testw", 16, NULL, 2, NULL); - xTaskCreate(ws_test_read_task, "testr", 16, NULL, 2, NULL); + xTaskCreate(ws_test_write_task, "test", 16, NULL, 2, NULL); vTaskStartScheduler(); } diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 39cff07..98ef8cd 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -30,8 +30,8 @@ UART_HandleTypeDef huart1 = { .Init.Mode = UART_MODE_TX_RX, .Init.HwFlowCtl = UART_HWCONTROL_NONE, .Init.OverSampling = UART_OVERSAMPLING_16, - .Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE, - .AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT, +// .Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE, +// .AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT, }; UART_HandleTypeDef huart2 = { @@ -81,6 +81,7 @@ void ws_io_setup() { ws_io_clock_setup(); ws_io_i2c_setup(); + ws_io_dma_setup(); ws_io_usart1_setup(); ws_io_usart2_setup(); ws_io_dma_setup(); @@ -132,7 +133,11 @@ static void ws_io_usart1_setup() { if (HAL_UART_Init(&huart1) != HAL_OK) return ws_setup_error_handler(); + // HAL_UARTEx_ReceiveToIdle_DMA(&huart2, RX_DMA_buffer, RX_DMA_BUFFER_SIZE); + HAL_UART_Receive_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); + // __HAL_DMA_ENABLE_IT(&hdma_usart1_rx, DMA_IT_TC); + // __HAL_UART_ENABLE_IT(&huart1, UART_IT_TC); } static void ws_io_usart2_setup() { @@ -191,7 +196,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { __HAL_LINKDMA(huart, hdmatx, hdma_usart1_tx); // USART1 interrupt Init - HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); + HAL_NVIC_SetPriority(USART1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); } else if (huart->Instance == USART2) { __HAL_RCC_USART2_CLK_ENABLE(); diff --git a/stm32f091/stm32f0xx_hal_conf.h b/stm32f091/stm32f0xx_hal_conf.h index fc27221..45f9fab 100644 --- a/stm32f091/stm32f0xx_hal_conf.h +++ b/stm32f091/stm32f0xx_hal_conf.h @@ -19,6 +19,8 @@ #define DATA_CACHE_ENABLE 0U #define USE_SPI_CRC 0U +#define USE_HAL_UART_REGISTER_CALLBACKS 1 + #define HAL_RCC_MODULE_ENABLED #define HAL_MODULE_ENABLED #define HAL_I2C_MODULE_ENABLED diff --git a/stm32f091/test.c b/stm32f091/test.c index 0960d0f..e25b071 100644 --- a/stm32f091/test.c +++ b/stm32f091/test.c @@ -3,23 +3,12 @@ #include #include "esp8266.h" -#include "setup.h" -#include "util.h" - -void ws_test_read_task() { - uint8_t* buf; // TODO: not working - while (1) { - HAL_UART_Receive_DMA(&huart1, buf, 1); - HAL_UART_Transmit(&huart2, buf, 1, 100); - } -} void ws_test_write_task() { uint8_t data[] = "AT\r\n"; while (1) { ws_esp8266_send(data, sizeof(data)); - HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); - vTaskDelay(portTICK_PERIOD_MS * 1000 * 1); + vTaskDelay(portTICK_PERIOD_MS * 100 * 1); } } diff --git a/stm32f091/test.h b/stm32f091/test.h index 6c312d9..dffa516 100644 --- a/stm32f091/test.h +++ b/stm32f091/test.h @@ -1,4 +1,3 @@ #pragma once -void ws_test_read_task(); void ws_test_write_task(); -- cgit v1.2.3 From 94e31069df88c3d5e50b4160705c2b7aa27e152b Mon Sep 17 00:00:00 2001 From: lonkaars Date: Thu, 27 Oct 2022 15:37:35 +0200 Subject: WIP server parser --- stm32f091/consts.h | 6 +++-- stm32f091/esp8266.c | 27 ++++++++++++++++--- stm32f091/esp8266.h | 6 ++--- stm32f091/server.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++++----- stm32f091/server.h | 27 +++++++++++++++++++ stm32f091/setup.c | 5 +++- stm32f091/test.c | 15 +++++++---- 7 files changed, 139 insertions(+), 21 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h index 5f9d7a1..b3bc2e2 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -4,8 +4,8 @@ #define WS_SERVER_PORT "80" -#define WS_DMA_RX_BUFFER_SIZE 10 -#define WS_DMA_TX_BUFFER_SIZE 50 +#define WS_DMA_RX_BUFFER_SIZE 100 +#define WS_DMA_TX_BUFFER_SIZE 100 #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB @@ -22,3 +22,5 @@ #define WS_PINOUT_USART2_TX_PIN GPIO_PIN_2 #define WS_PINOUT_USART2_TX_PORT GPIOA +// print esp communication over usb serial (green for tx, red for rx) +#define WS_DBG_PRINT_ESP_OVER_USART2 diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 4daba34..c98528e 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -15,13 +15,22 @@ uint8_t g_ws_esp8266_dma_tx_buffer[WS_DMA_TX_BUFFER_SIZE]; void DMA1_Ch1_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_usart1_rx); } void DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_usart1_tx); } -void USART1_IRQHandler(void) { HAL_UART_IRQHandler(&huart1); } +void USART1_IRQHandler(void) { + if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE)) { + __HAL_UART_CLEAR_IDLEFLAG(&huart1); + HAL_UART_RxCpltCallback(&huart1); + HAL_UART_DMAStop(&huart1); + ws_esp8266_start_receive(); + } + HAL_UART_IRQHandler(&huart1); +} void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { - ws_server_req_incoming(g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); + size_t len = strlen((char*) g_ws_esp8266_dma_rx_buffer); + if (len > 0) ws_server_req_incoming(g_ws_esp8266_dma_rx_buffer, len); - HAL_UART_Receive_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); - __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); + memset(g_ws_esp8266_dma_rx_buffer, 0, WS_DMA_RX_BUFFER_SIZE); + ws_esp8266_start_receive(); } void ws_esp8266_send(uint8_t* data, size_t size) { @@ -29,10 +38,20 @@ void ws_esp8266_send(uint8_t* data, size_t size) { memcpy(g_ws_esp8266_dma_tx_buffer, data, limited_size); g_ws_esp8266_dma_tx_buffer[limited_size] = 0x00; +#ifdef WS_DBG_PRINT_ESP_OVER_USART2 + uint8_t green[] = { 0x1b, 0x5b, 0x33, 0x32, 0x6d }; + HAL_UART_Transmit(&huart2, green, sizeof(green), 100); + HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, strlen((char*) g_ws_esp8266_dma_tx_buffer), 100); +#endif + HAL_UART_Transmit_DMA(&huart1, g_ws_esp8266_dma_tx_buffer, strlen((char*) g_ws_esp8266_dma_tx_buffer)); __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); } +void ws_esp8266_start_receive() { + HAL_UART_Receive_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); + __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); +} // TODO: refactor code from here to EOF void ws_esp8266_ATsendCommand(uint8_t* data){ diff --git a/stm32f091/esp8266.h b/stm32f091/esp8266.h index 0832e95..64910fd 100644 --- a/stm32f091/esp8266.h +++ b/stm32f091/esp8266.h @@ -3,6 +3,7 @@ #include #include #include +#include #include "consts.h" @@ -21,12 +22,11 @@ void USART1_IRQHandler(void); /** @brief receive chunk complete */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart); -/** @brief send response to incoming request on specific channel */ -void ws_esp8266_res_send(unsigned int channel, uint8_t* data, size_t size); - /** @brief send data to esp over uart with dma */ void ws_esp8266_send(uint8_t* data, size_t size); +void ws_esp8266_start_receive(); + // TODO: remove/update/document/refactor these functions void ws_esp8266_ATsendCommand(uint8_t* data); int ws_esp8266_checkOK(uint8_t *receiveData,int length); diff --git a/stm32f091/server.c b/stm32f091/server.c index de6ea50..aa2ff8b 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -3,15 +3,77 @@ #include #include +#include "esp8266.h" #include "server.h" +#include "setup.h" +#include "consts.h" +static ws_s_server_parser g_ws_server_parser = { + .counter = 0, + .last_response = WS_SERVER_RC_NONE, + .mode = WS_SERVER_LM_IDLE, +}; + +// TODO: next_few_bytes_are assumes that the complete search string is in the +// buffer, so won't work for buffer cutoffs +#define next_few_bytes_are(code) (i + sizeof(code) - 1 < size && strncmp((char*)&data[i], code, sizeof(code) - 1) == 0) void ws_server_req_incoming(uint8_t* data, size_t size) { - // TODO: server req incoming implementation - // - // example +IPD command: - // +IPD,0,15:last-records 5\n - // - // TODO: protocol req response parser -> (ws_esp8622_at_send(data, channel) ?) +#ifdef WS_DBG_PRINT_ESP_OVER_USART2 + uint8_t red[] = { 0x1b, 0x5b, 0x33, 0x31, 0x6d }; + HAL_UART_Transmit(&huart2, red, sizeof(red), 100); + HAL_UART_Transmit(&huart2, data, size, 100); +#endif + + for (unsigned int i = 0; i < size; i++) { + uint8_t byte = data[i]; + + switch (g_ws_server_parser.mode) { + case WS_SERVER_LM_CMD_ECHO: { + if (byte == '\n') g_ws_server_parser.mode = WS_SERVER_LM_STATUS_CODE; + break; + } + case WS_SERVER_LM_STATUS_CODE: { + bool code_got = false; + if (next_few_bytes_are("OK")) { + code_got = true; + g_ws_server_parser.last_response = WS_SERVER_RC_OK; + } else if (next_few_bytes_are("ERROR")) { + code_got = true; + g_ws_server_parser.last_response = WS_SERVER_RC_ERR; + } else if (next_few_bytes_are("busy p...")) { + code_got = true; + g_ws_server_parser.last_response = WS_SERVER_RC_BUSY; + } + if (code_got) g_ws_server_parser.mode = WS_SERVER_LM_IDLE; + break; + } + case WS_SERVER_LM_IDLE: { + if (next_few_bytes_are("+IPD")) { + i += 3; // skip I, P, and D + g_ws_server_parser.mode = WS_SERVER_LM_IPD_LISTENING; + } + break; + } + case WS_SERVER_LM_IPD_LISTENING: { + // +IPD,0,15:last-records 5\n + break; + } + default: {} + } + } return; } + +void ws_server_send(uint8_t* data, size_t size) { + g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; + ws_esp8266_send(data, size); + while (g_ws_server_parser.mode != WS_SERVER_LM_IDLE) {}; +} + +void ws_server_req_respond(unsigned int channel, uint8_t* data, size_t size) { + uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; + uint8_t Tx_send[]="AT+CIPSEND=0,LEN:"; + return; +} + diff --git a/stm32f091/server.h b/stm32f091/server.h index 6041ef6..c5698c0 100644 --- a/stm32f091/server.h +++ b/stm32f091/server.h @@ -2,6 +2,27 @@ #include #include +#include + +typedef enum { + WS_SERVER_LM_CMD_ECHO, /** @brief listen for echo of sent command */ + WS_SERVER_LM_STATUS_CODE, /** @brief listen for busy, ERROR or OK */ + WS_SERVER_LM_IDLE, /** @brief listen for incoming +IPD commands */ + WS_SERVER_LM_IPD_LISTENING, /** @brief +IPD received, now reading data */ +} ws_e_server_listen_mode; + +typedef enum { + WS_SERVER_RC_NONE = -1, + WS_SERVER_RC_BUSY, + WS_SERVER_RC_ERR, + WS_SERVER_RC_OK, +} ws_e_server_response_code; + +typedef struct { + int counter; + ws_e_server_listen_mode mode; + ws_e_server_response_code last_response; +} ws_s_server_parser; /** * @brief +IPD incoming request handler @@ -15,3 +36,9 @@ */ void ws_server_req_incoming(uint8_t* data, size_t size); +/** @brief send response to incoming request on specific channel */ +void ws_server_req_respond(unsigned int channel, uint8_t* data, size_t size); + +/** @brief send data to esp, waiting until server returns to idle mode */ +void ws_server_send(uint8_t* data, size_t size); + diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 2110e03..9ed4174 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -133,12 +133,15 @@ static void ws_io_usart1_setup() { HAL_UART_Receive_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); + + __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE); // enable receive intterupts + __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); // enable idle line detection } static void ws_io_usart2_setup() { if (HAL_UART_Init(&huart2) != HAL_OK) return ws_setup_error_handler(); -} +} static void ws_io_dma_setup() { __HAL_RCC_DMA1_CLK_ENABLE(); diff --git a/stm32f091/test.c b/stm32f091/test.c index e25b071..c5e43da 100644 --- a/stm32f091/test.c +++ b/stm32f091/test.c @@ -2,13 +2,18 @@ #include #include -#include "esp8266.h" +#include "server.h" +#include "setup.h" void ws_test_write_task() { - uint8_t data[] = "AT\r\n"; + // uint8_t data[] = "AT+CIPMUX=1+CWMODE=1+CWJAP=\"" WS_ESP8266_WLAN_SSID "\",\"" WS_ESP8266_WLAN_PASSWD "\"\r\n"; + uint8_t cmd1[] = "AT+CIPMUX=1\r\n"; + uint8_t cmd2[] = "AT+CWMODE=1\r\n"; + uint8_t cmd3[] = "AT+CWJAP=\"" WS_ESP8266_WLAN_SSID "\",\"" WS_ESP8266_WLAN_PASSWD "\"\r\n"; while (1) { - ws_esp8266_send(data, sizeof(data)); - - vTaskDelay(portTICK_PERIOD_MS * 100 * 1); + ws_server_send(cmd1, sizeof(cmd1)); + ws_server_send(cmd2, sizeof(cmd2)); + ws_server_send(cmd3, sizeof(cmd3)); + vTaskDelay(portTICK_PERIOD_MS * 1000 * 1); } } -- cgit v1.2.3 From 12704850c9f4cf7410ecf85116da9d23fc2ce6d6 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Thu, 27 Oct 2022 16:50:01 +0200 Subject: server to protocol code --- stm32f091/consts.h | 1 + stm32f091/server.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++++----- stm32f091/server.h | 34 ++++++++++++++++++++++++- stm32f091/test.c | 1 - 4 files changed, 101 insertions(+), 8 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h index b3bc2e2..0a8acec 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -3,6 +3,7 @@ #include "wifi.h" #define WS_SERVER_PORT "80" +#define WS_SERVER_MAX_CHANNELS 2 #define WS_DMA_RX_BUFFER_SIZE 100 #define WS_DMA_TX_BUFFER_SIZE 100 diff --git a/stm32f091/server.c b/stm32f091/server.c index aa2ff8b..a06727c 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -3,17 +3,46 @@ #include #include +#include "../shared/protocol.h" #include "esp8266.h" #include "server.h" #include "setup.h" #include "consts.h" static ws_s_server_parser g_ws_server_parser = { - .counter = 0, .last_response = WS_SERVER_RC_NONE, .mode = WS_SERVER_LM_IDLE, + + .current_channel = 0, + .channel_data_length = 0, + .channel_data_counter = 0, + .channel_listen_mode = WS_SERVER_CL_DATA_LENGTH, }; +static ws_s_protocol_req_parser_state* g_ws_protocol_parsers[WS_SERVER_MAX_CHANNELS] = {0}; + + +void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore) { + if (ignore) return; + if (channel >= WS_SERVER_MAX_CHANNELS) return; + + if (g_ws_protocol_parsers[channel] == NULL) { + g_ws_protocol_parsers[channel] = ws_protocol_req_parser_alloc(); + } + + ws_protocol_parse_req_byte(g_ws_protocol_parsers[channel], byte); +} + +void ws_server_req_finish(unsigned int channel, bool ignore) { + if (ignore) return; + if (channel >= WS_SERVER_MAX_CHANNELS) return; + + if (g_ws_protocol_parsers[channel] != NULL) { + ws_protocol_req_parser_free(g_ws_protocol_parsers[channel]); + g_ws_protocol_parsers[channel] = NULL; + } +} + // TODO: next_few_bytes_are assumes that the complete search string is in the // buffer, so won't work for buffer cutoffs #define next_few_bytes_are(code) (i + sizeof(code) - 1 < size && strncmp((char*)&data[i], code, sizeof(code) - 1) == 0) @@ -37,7 +66,7 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { if (next_few_bytes_are("OK")) { code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_OK; - } else if (next_few_bytes_are("ERROR")) { + } else if (next_few_bytes_are("ERROR") || next_few_bytes_are("FAIL")) { code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_ERR; } else if (next_few_bytes_are("busy p...")) { @@ -55,14 +84,46 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { break; } case WS_SERVER_LM_IPD_LISTENING: { - // +IPD,0,15:last-records 5\n + switch (g_ws_server_parser.channel_listen_mode) { + case WS_SERVER_CL_CHANNEL_ID: { + if (byte == ',') { + g_ws_server_parser.channel_listen_mode = WS_SERVER_CL_DATA_LENGTH; + break; + } + g_ws_server_parser.current_channel *= 10; + g_ws_server_parser.current_channel += byte - '0'; // ascii to int + break; + } + case WS_SERVER_CL_DATA_LENGTH: { + if (byte == ':') { + g_ws_server_parser.channel_listen_mode = WS_SERVER_CL_DATA_READ; + if (g_ws_server_parser.channel_data_length > WS_PROTOCOL_CMD_BUFFER_LEN) + g_ws_server_parser.channel_data_ignore = true; + break; + } + g_ws_server_parser.current_channel *= 10; + g_ws_server_parser.current_channel += byte - '0'; // ascii to int + break; + } + case WS_SERVER_CL_DATA_READ: { + ws_server_req_parse_byte(g_ws_server_parser.current_channel, byte, g_ws_server_parser.channel_data_ignore); + g_ws_server_parser.channel_data_counter++; + if (g_ws_server_parser.channel_data_counter == g_ws_server_parser.channel_data_length) { + g_ws_server_parser.current_channel = 0; + g_ws_server_parser.channel_data_counter = 0; + g_ws_server_parser.channel_data_length = 0; + g_ws_server_parser.channel_listen_mode = WS_SERVER_CL_CHANNEL_ID; + ws_server_req_finish(g_ws_server_parser.current_channel, g_ws_server_parser.channel_data_ignore); + } + break; + } + default: {} + } break; } default: {} } } - - return; } void ws_server_send(uint8_t* data, size_t size) { @@ -72,8 +133,8 @@ void ws_server_send(uint8_t* data, size_t size) { } void ws_server_req_respond(unsigned int channel, uint8_t* data, size_t size) { - uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; uint8_t Tx_send[]="AT+CIPSEND=0,LEN:"; + uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; return; } diff --git a/stm32f091/server.h b/stm32f091/server.h index c5698c0..44882e4 100644 --- a/stm32f091/server.h +++ b/stm32f091/server.h @@ -11,6 +11,12 @@ typedef enum { WS_SERVER_LM_IPD_LISTENING, /** @brief +IPD received, now reading data */ } ws_e_server_listen_mode; +typedef enum { + WS_SERVER_CL_CHANNEL_ID, /** @brief listen channel id */ + WS_SERVER_CL_DATA_LENGTH, /** @brief listen for data byte length */ + WS_SERVER_CL_DATA_READ, /** @brief listen for data and pipe to ws_protocol_parse_req_byte */ +} ws_e_channel_listen_mode; + typedef enum { WS_SERVER_RC_NONE = -1, WS_SERVER_RC_BUSY, @@ -19,9 +25,13 @@ typedef enum { } ws_e_server_response_code; typedef struct { - int counter; ws_e_server_listen_mode mode; ws_e_server_response_code last_response; + unsigned int current_channel; + unsigned int channel_data_length; + unsigned int channel_data_counter; + ws_e_channel_listen_mode channel_listen_mode; + bool channel_data_ignore; } ws_s_server_parser; /** @@ -42,3 +52,25 @@ void ws_server_req_respond(unsigned int channel, uint8_t* data, size_t size); /** @brief send data to esp, waiting until server returns to idle mode */ void ws_server_send(uint8_t* data, size_t size); +/** + * @brief parse byte from channel + * + * automatically creates parser struct and passes data onto protocol parser + * functions + * + * @param channel request channel + * @param byte data byte + * @param ignore ignore mode + */ +void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore); + +/** + * @brief close connection + * + * deallocates any parser struct that were automatically created in + * ws_server_req_parse_byte + * + * @param channel request channel + * @param ignore ignore mode + */ +void ws_server_req_finish(unsigned int channel, bool ignore); diff --git a/stm32f091/test.c b/stm32f091/test.c index c5e43da..ae48ef7 100644 --- a/stm32f091/test.c +++ b/stm32f091/test.c @@ -6,7 +6,6 @@ #include "setup.h" void ws_test_write_task() { - // uint8_t data[] = "AT+CIPMUX=1+CWMODE=1+CWJAP=\"" WS_ESP8266_WLAN_SSID "\",\"" WS_ESP8266_WLAN_PASSWD "\"\r\n"; uint8_t cmd1[] = "AT+CIPMUX=1\r\n"; uint8_t cmd2[] = "AT+CWMODE=1\r\n"; uint8_t cmd3[] = "AT+CWJAP=\"" WS_ESP8266_WLAN_SSID "\",\"" WS_ESP8266_WLAN_PASSWD "\"\r\n"; -- cgit v1.2.3 From f37af779bb836faa7571b7d47036f36f71319aca Mon Sep 17 00:00:00 2001 From: lonkaars Date: Fri, 28 Oct 2022 11:29:09 +0200 Subject: use circular dma buffer for rx --- stm32f091/consts.h | 4 ++-- stm32f091/esp8266.c | 36 ++++++++++++++++++++++-------------- stm32f091/esp8266.h | 7 ++----- stm32f091/server.c | 3 +-- stm32f091/setup.c | 2 +- 5 files changed, 28 insertions(+), 24 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/stm32f091/consts.h b/stm32f091/consts.h index 0a8acec..3d2ef5a 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -3,10 +3,10 @@ #include "wifi.h" #define WS_SERVER_PORT "80" -#define WS_SERVER_MAX_CHANNELS 2 +#define WS_SERVER_MAX_CHANNELS 4 #define WS_DMA_RX_BUFFER_SIZE 100 -#define WS_DMA_TX_BUFFER_SIZE 100 +#define WS_DMA_TX_BUFFER_SIZE 1024 #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index db134a0..754b45b 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -17,6 +17,8 @@ } uint8_t g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; +unsigned int g_ws_esp8266_dma_rx_head = 0; +unsigned int g_ws_esp8266_dma_rx_tail = 0; uint8_t g_ws_esp8266_dma_tx_buffer[WS_DMA_TX_BUFFER_SIZE]; void DMA1_Ch1_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_usart1_rx); } @@ -24,19 +26,30 @@ void DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_usart1_tx void USART1_IRQHandler(void) { if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE)) { __HAL_UART_CLEAR_IDLEFLAG(&huart1); - HAL_UART_RxCpltCallback(&huart1); - HAL_UART_DMAStop(&huart1); - ws_esp8266_start_receive(); + // https://stackoverflow.com/questions/71039052/hal-uartex-rxeventcallback-circular-dma-what-address-is-the-data + g_ws_esp8266_dma_rx_head = huart1.RxXferSize - huart1.hdmarx->Instance->CNDTR; + + ws_esp8266_incoming_data_chunk(); } HAL_UART_IRQHandler(&huart1); } -void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { - size_t len = strlen((char*) g_ws_esp8266_dma_rx_buffer); - if (len > 0) ws_server_req_incoming(g_ws_esp8266_dma_rx_buffer, len); - - memset(g_ws_esp8266_dma_rx_buffer, 0, WS_DMA_RX_BUFFER_SIZE); - ws_esp8266_start_receive(); +void ws_esp8266_incoming_data_chunk() { + if (g_ws_esp8266_dma_rx_head == g_ws_esp8266_dma_rx_tail) return; // no new data + if (g_ws_esp8266_dma_rx_head > g_ws_esp8266_dma_rx_tail) { + // read from tail until head + ws_server_req_incoming(&g_ws_esp8266_dma_rx_buffer[g_ws_esp8266_dma_rx_tail], + g_ws_esp8266_dma_rx_head - g_ws_esp8266_dma_rx_tail); + } else /* if (g_ws_esp8266_dma_rx_head < g_ws_esp8266_dma_rx_tail) */ { + // read from tail until end of buffer + ws_server_req_incoming(&g_ws_esp8266_dma_rx_buffer[g_ws_esp8266_dma_rx_tail], + WS_DMA_RX_BUFFER_SIZE - g_ws_esp8266_dma_rx_tail); + // read from buffer begin until head + ws_server_req_incoming(&g_ws_esp8266_dma_rx_buffer[0], // yes i know this looks dumb + g_ws_esp8266_dma_rx_head); + } + // finish read by shifting tail forward + g_ws_esp8266_dma_rx_tail = g_ws_esp8266_dma_rx_head; } void ws_esp8266_send(uint8_t* data, size_t size) { @@ -54,11 +67,6 @@ void ws_esp8266_send(uint8_t* data, size_t size) { __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); } -void ws_esp8266_start_receive() { - HAL_UART_Receive_DMA(&huart1, g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); - __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); -} - void ws_esp8266_connect() { ws_esp8266_send_seq("AT+CWJAP=\"" WS_ESP8266_WLAN_SSID "\",\"" WS_ESP8266_WLAN_PASSWD "\"\r\n"); } diff --git a/stm32f091/esp8266.h b/stm32f091/esp8266.h index 66ccfba..94a7356 100644 --- a/stm32f091/esp8266.h +++ b/stm32f091/esp8266.h @@ -19,14 +19,11 @@ void DMA1_Ch1_IRQHandler(void); /** @brief USART1 interrupt handler */ void USART1_IRQHandler(void); -/** @brief receive chunk complete */ -void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart); - /** @brief send data to esp over uart with dma */ void ws_esp8266_send(uint8_t* data, size_t size); -/** @brief start dma receive and reset half-transfer interrupt flag */ -void ws_esp8266_start_receive(); +/** @brief line idle, handle new data on dma buffer */ +void ws_esp8266_incoming_data_chunk(); /** @brief connect to access point using wifi.h credentials */ void ws_esp8266_connect(); diff --git a/stm32f091/server.c b/stm32f091/server.c index d4f7e20..8001380 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -127,9 +127,8 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { } case WS_SERVER_LM_CIPSEND_LISTENING: { if (next_few_bytes_are("SEND OK")) { - i += 6; - // g_ws_server_parser.mode = WS_SERVER_LM_IDLE; ws_server_req_respond_end(0); + // g_ws_server_parser.mode = WS_SERVER_LM_IDLE; } break; } diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 1971809..3bf331f 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -53,7 +53,7 @@ DMA_HandleTypeDef hdma_usart1_rx = { .Init.MemInc = DMA_MINC_ENABLE, .Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE, .Init.MemDataAlignment = DMA_MDATAALIGN_BYTE, - .Init.Mode = DMA_NORMAL, + .Init.Mode = DMA_CIRCULAR, .Init.Priority = DMA_PRIORITY_LOW, }; -- cgit v1.2.3 From 4cd465332087e4ab12709f28fae55df10e1a1154 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Fri, 28 Oct 2022 12:14:50 +0200 Subject: add todo.md, fixed segfault in protocol.c, and fix response sending --- shared/protocol.c | 5 +++-- stm32f091/consts.h | 2 +- stm32f091/protocol.c | 13 +++++++------ stm32f091/server.c | 18 ++++++++++-------- stm32f091/todo.md | 10 ++++++++++ 5 files changed, 31 insertions(+), 17 deletions(-) create mode 100644 stm32f091/todo.md (limited to 'stm32f091/consts.h') diff --git a/shared/protocol.c b/shared/protocol.c index fcc84a4..e17a728 100644 --- a/shared/protocol.c +++ b/shared/protocol.c @@ -99,10 +99,11 @@ ws_s_protocol_req_parser_state* ws_protocol_req_parser_alloc() { void ws_protocol_req_cmd_init(ws_s_protocol_req_parser_state* state) { state->target = malloc(sizeof(ws_s_protocol_parsed_req_cmd) + sizeof(char*) * state->arg_len); - for (unsigned int i = 0; i < state->arg_len; i++) + unsigned int args = WS_MIN(state->arg_len, WS_PROTOCOL_CMD_MAX_ARGUMENTS); + for (unsigned int i = 0; i < args; i++) state->target->argv[i] = malloc(sizeof(char) * (state->args_len[i] + 1)); - state->target->argc = state->arg_len; + state->target->argc = args; unsigned int head = 0; for (unsigned int i = 0; i < state->arg_len; i++) { diff --git a/stm32f091/consts.h b/stm32f091/consts.h index 3d2ef5a..955ceea 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -6,7 +6,7 @@ #define WS_SERVER_MAX_CHANNELS 4 #define WS_DMA_RX_BUFFER_SIZE 100 -#define WS_DMA_TX_BUFFER_SIZE 1024 +#define WS_DMA_TX_BUFFER_SIZE 100 #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB diff --git a/stm32f091/protocol.c b/stm32f091/protocol.c index 3a8d78b..21e6527 100644 --- a/stm32f091/protocol.c +++ b/stm32f091/protocol.c @@ -13,19 +13,21 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s if (!send) { response->success = WS_PROTOCOL_CMD_RETURN_OK; - if (sscanf(parsed_cmd->argv[1], "%u", &record_amount) < 1) response->success = WS_PROTOCOL_CMD_RETURN_ERROR; - record_amount = WS_MIN(record_amount, ws_backlog_get_record_count()); response->csh = true; response->msg = ws_bin_s_alloc(0); - response->msg->bytes = strlen(response_header) + response_line_size * record_amount; + response->msg->bytes = 0; + record_amount = WS_MIN(record_amount, ws_backlog_get_record_count()); + if (sscanf(parsed_cmd->argv[1], "%u", &record_amount) < 1) response->success = WS_PROTOCOL_CMD_RETURN_ERROR; + else response->msg->bytes = strlen(response_header) + response_line_size * record_amount; ws_server_req_respond_start(0, response->msg->bytes + ws_protocol_get_header_size(response)); } else { + if (response->success == WS_PROTOCOL_CMD_RETURN_ERROR) return; ws_protocol_send_data(response_header, strlen(response_header)); - char line[response_line_size + 1]; // +1 for null terminator -> sprintf + char line[response_line_size]; for (unsigned int i = 0; i < record_amount; i++) { ws_s_backlog_record* record = ws_backlog_get_last_record(i); sprintf(line, "%04x,%02x,%02x,%02x\n", record->id, record->sens_temperature, record->sens_humidity, record->sens_atm_pressure); - ws_protocol_send_data(line, response_line_size); + ws_protocol_send_data(line, response_line_size - 1); // remove string terminator } ws_protocol_send_data("\r\n", 2); // test } @@ -33,5 +35,4 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s void ws_protocol_send_data(const char* data, unsigned int length) { ws_server_buffer_send_append((uint8_t*) data, length); - // HAL_UART_Transmit(&huart1, (uint8_t*) data, length, HAL_MAX_DELAY); } diff --git a/stm32f091/server.c b/stm32f091/server.c index 8001380..1419da8 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -20,7 +20,7 @@ ws_s_server_parser g_ws_server_parser = { }; static ws_s_protocol_req_parser_state* g_ws_protocol_parsers[WS_SERVER_MAX_CHANNELS] = {0}; -static unsigned int g_ws_esp8266_dma_tx_buffer_index = 0; +static unsigned int g_ws_esp8266_dma_tx_buffer_size = 0; void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore) { if (ignore) return; @@ -126,7 +126,7 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { break; } case WS_SERVER_LM_CIPSEND_LISTENING: { - if (next_few_bytes_are("SEND OK")) { + if (next_few_bytes_are("SEND OK") || next_few_bytes_are("ERROR")) { ws_server_req_respond_end(0); // g_ws_server_parser.mode = WS_SERVER_LM_IDLE; } @@ -146,23 +146,25 @@ void ws_server_send(uint8_t* data, size_t size) { void ws_server_buffer_send_append(uint8_t* data, size_t size) { // TODO: buffer overrun protection // while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); // make sure buffer isn't used - strncpy((char*) &g_ws_esp8266_dma_tx_buffer[g_ws_esp8266_dma_tx_buffer_index], (char*) data, size); // append string - g_ws_esp8266_dma_tx_buffer_index += size; // shift head + strncpy((char*) &g_ws_esp8266_dma_tx_buffer[g_ws_esp8266_dma_tx_buffer_size], (char*) data, size); // append string + g_ws_esp8266_dma_tx_buffer_size += size; // shift head } +// TODO: refactor this void ws_server_buffer_send_finish() { #ifdef WS_DBG_PRINT_ESP_OVER_USART2 uint8_t green[] = { 0x1b, 0x5b, 0x33, 0x32, 0x6d }; HAL_UART_Transmit(&huart2, green, sizeof(green), 100); - HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, strlen((char*) g_ws_esp8266_dma_tx_buffer), 100); + HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); #endif - HAL_UART_Transmit_DMA(&huart1, g_ws_esp8266_dma_tx_buffer, strlen((char*) g_ws_esp8266_dma_tx_buffer)); + HAL_UART_Transmit_DMA(&huart1, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size); __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); - g_ws_esp8266_dma_tx_buffer_index = 0; + g_ws_esp8266_dma_tx_buffer_size = 0; while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); } +// TODO: refactor this void ws_server_req_respond_start(unsigned int channel, size_t size) { char* cmd = NULL; size_t len = asiprintf(&cmd, "AT+CIPSEND=%d,%d\r\n", channel, size); @@ -171,6 +173,7 @@ void ws_server_req_respond_start(unsigned int channel, size_t size) { while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); } +// TODO: refactor this void ws_server_req_respond_end(unsigned int channel) { char* cmd = NULL; size_t len = asiprintf(&cmd, "AT+CIPCLOSE=%d\r\n", channel); @@ -178,4 +181,3 @@ void ws_server_req_respond_end(unsigned int channel) { ws_esp8266_send((uint8_t*) cmd, len); while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); } - diff --git a/stm32f091/todo.md b/stm32f091/todo.md new file mode 100644 index 0000000..767d745 --- /dev/null +++ b/stm32f091/todo.md @@ -0,0 +1,10 @@ +- handle errors from `AT+CIPSEND`, these look like this: + ``` + > AT0,CONNECT + + > +IPD,0,15:last-records 5<0a> + < AT+CIPSEND=0,125 + > AT+CIPSEND=0,125 + + > ERROR + ``` -- cgit v1.2.3 From babb6dc29a5c4af60292ffad5216317d13e2a685 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Fri, 28 Oct 2022 14:31:56 +0200 Subject: fix off-by-one error and create macro for switching serial debug print color --- shared/protocol.c | 2 +- stm32f091/consts.h | 2 +- stm32f091/esp8266.c | 3 +-- stm32f091/protocol.c | 14 ++++++++------ stm32f091/server.c | 8 +++----- stm32f091/setup.c | 7 +++++++ stm32f091/util.h | 4 ++++ 7 files changed, 25 insertions(+), 15 deletions(-) (limited to 'stm32f091/consts.h') diff --git a/shared/protocol.c b/shared/protocol.c index e17a728..8887070 100644 --- a/shared/protocol.c +++ b/shared/protocol.c @@ -142,6 +142,6 @@ unsigned short ws_protocol_get_header_size(ws_s_protocol_res* response) { unsigned short size = 2; // comma and trailing newline if (response->success == WS_PROTOCOL_CMD_RETURN_OK) size += 2; // ok if (response->success == WS_PROTOCOL_CMD_RETURN_ERROR) size += 5; // error - size += ws_log16(response->msg->bytes); // amount of characters for message size (hex) + size += ws_log16(response->msg->bytes) + 1; // amount of characters for message size (hex) return size; } \ No newline at end of file diff --git a/stm32f091/consts.h b/stm32f091/consts.h index 955ceea..3d2ef5a 100644 --- a/stm32f091/consts.h +++ b/stm32f091/consts.h @@ -6,7 +6,7 @@ #define WS_SERVER_MAX_CHANNELS 4 #define WS_DMA_RX_BUFFER_SIZE 100 -#define WS_DMA_TX_BUFFER_SIZE 100 +#define WS_DMA_TX_BUFFER_SIZE 1024 #define WS_PINOUT_I2C_SDA_PIN GPIO_PIN_9 #define WS_PINOUT_I2C_SDA_PORT GPIOB diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 754b45b..b896567 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -58,8 +58,7 @@ void ws_esp8266_send(uint8_t* data, size_t size) { g_ws_esp8266_dma_tx_buffer[limited_size] = 0x00; #ifdef WS_DBG_PRINT_ESP_OVER_USART2 - uint8_t green[] = { 0x1b, 0x5b, 0x33, 0x32, 0x6d }; - HAL_UART_Transmit(&huart2, green, sizeof(green), 100); + ws_dbg_set_usart2_tty_color(2); HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, strlen((char*) g_ws_esp8266_dma_tx_buffer), 100); #endif diff --git a/stm32f091/protocol.c b/stm32f091/protocol.c index 21e6527..4d605fc 100644 --- a/stm32f091/protocol.c +++ b/stm32f091/protocol.c @@ -9,27 +9,29 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s_protocol_res* response, bool send) { static unsigned int record_amount = 0; const char* response_header = "id,temperature,humidity,atmospheric_pressure\n"; - const size_t response_line_size = sizeof("xxxx,xx,xx,xx\n"); + const unsigned int response_line_len = strlen("xxxx,xx,xx,xx\n"); if (!send) { response->success = WS_PROTOCOL_CMD_RETURN_OK; response->csh = true; response->msg = ws_bin_s_alloc(0); response->msg->bytes = 0; - record_amount = WS_MIN(record_amount, ws_backlog_get_record_count()); if (sscanf(parsed_cmd->argv[1], "%u", &record_amount) < 1) response->success = WS_PROTOCOL_CMD_RETURN_ERROR; - else response->msg->bytes = strlen(response_header) + response_line_size * record_amount; + else { + record_amount = WS_MIN(record_amount, ws_backlog_get_record_count()); + response->msg->bytes = strlen(response_header) + response_line_len * record_amount; + } ws_server_req_respond_start(0, response->msg->bytes + ws_protocol_get_header_size(response)); } else { if (response->success == WS_PROTOCOL_CMD_RETURN_ERROR) return; ws_protocol_send_data(response_header, strlen(response_header)); - char line[response_line_size]; + char line[response_line_len + 1]; // + 1 for string terminator for (unsigned int i = 0; i < record_amount; i++) { ws_s_backlog_record* record = ws_backlog_get_last_record(i); sprintf(line, "%04x,%02x,%02x,%02x\n", record->id, record->sens_temperature, record->sens_humidity, record->sens_atm_pressure); - ws_protocol_send_data(line, response_line_size - 1); // remove string terminator + ws_protocol_send_data(line, response_line_len); // remove string terminator } - ws_protocol_send_data("\r\n", 2); // test + // ws_protocol_send_data("\r\n", 2); // test } } diff --git a/stm32f091/server.c b/stm32f091/server.c index 1419da8..6225eae 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -8,6 +8,7 @@ #include "server.h" #include "setup.h" #include "consts.h" +#include "util.h" ws_s_server_parser g_ws_server_parser = { .last_response = WS_SERVER_RC_NONE, @@ -48,8 +49,7 @@ void ws_server_req_finish(unsigned int channel, bool ignore) { #define next_few_bytes_are(code) (i + sizeof(code) - 1 < size && strncmp((char*)&data[i], code, sizeof(code) - 1) == 0) void ws_server_req_incoming(uint8_t* data, size_t size) { #ifdef WS_DBG_PRINT_ESP_OVER_USART2 - uint8_t red[] = { 0x1b, 0x5b, 0x33, 0x31, 0x6d }; - HAL_UART_Transmit(&huart2, red, sizeof(red), 100); + ws_dbg_set_usart2_tty_color(1); HAL_UART_Transmit(&huart2, data, size, 100); #endif @@ -128,7 +128,6 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { case WS_SERVER_LM_CIPSEND_LISTENING: { if (next_few_bytes_are("SEND OK") || next_few_bytes_are("ERROR")) { ws_server_req_respond_end(0); - // g_ws_server_parser.mode = WS_SERVER_LM_IDLE; } break; } @@ -153,8 +152,7 @@ void ws_server_buffer_send_append(uint8_t* data, size_t size) { // TODO: refactor this void ws_server_buffer_send_finish() { #ifdef WS_DBG_PRINT_ESP_OVER_USART2 - uint8_t green[] = { 0x1b, 0x5b, 0x33, 0x32, 0x6d }; - HAL_UART_Transmit(&huart2, green, sizeof(green), 100); + ws_dbg_set_usart2_tty_color(2); HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); #endif diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 3bf331f..1591649 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -9,6 +9,7 @@ #include "setup.h" #include "backlog.h" #include "server.h" +#include "util.h" I2C_HandleTypeDef hi2c1 = { .Instance = I2C1, @@ -95,6 +96,12 @@ void ws_io_setup() { ws_backlog_alloc(24 * 60); // ws_backlog_alloc(10); +#ifdef WS_DBG_PRINT_ESP_OVER_USART2 + ws_dbg_set_usart2_tty_color(7); + const char restart_str[] = "\r\n--- stm restart ---\r\n"; + HAL_UART_Transmit(&huart2, restart_str, strlen(restart_str), 100); +#endif + #ifdef WS_ESP8266_WLAN_MAC ws_esp8266_set_mac(); #endif diff --git a/stm32f091/util.h b/stm32f091/util.h index 92f093f..9f5c1ec 100644 --- a/stm32f091/util.h +++ b/stm32f091/util.h @@ -14,3 +14,7 @@ HAL_UART_Transmit(&huart2, (uint8_t*) temp, sizeof(char) * strlen(temp), HAL_MAX_DELAY); \ } +#define ws_dbg_set_usart2_tty_color(color) { \ + uint8_t sgr[] = { 0x1b, 0x5b, 0x33, 0x30 + color, 0x6d }; \ + HAL_UART_Transmit(&huart2, sgr, sizeof(sgr), 100); \ +} -- cgit v1.2.3