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 --- stm32f091/consts.h | 2 ++ stm32f091/esp8266.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++ stm32f091/esp8266.h | 10 ++++++++++ stm32f091/setup.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ stm32f091/setup.h | 2 ++ 5 files changed, 113 insertions(+) (limited to 'stm32f091') 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 7a1316483ff8962f581d686f4e812c7ec5a2b6cc Mon Sep 17 00:00:00 2001 From: lonkaars Date: Tue, 25 Oct 2022 18:08:28 +0200 Subject: finish merge --- stm32f091/esp8266.c | 2 +- stm32f091/main.c | 9 --------- stm32f091/setup.c | 13 +++++++++++-- 3 files changed, 12 insertions(+), 12 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 6a9f254..341f052 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -34,7 +34,7 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){ } // 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_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); } diff --git a/stm32f091/main.c b/stm32f091/main.c index 7cb0718..ed0dacd 100644 --- a/stm32f091/main.c +++ b/stm32f091/main.c @@ -5,18 +5,9 @@ #include "main.h" #include "setup.h" #include "sensor.h" -#include "backlog.h" int main() { ws_io_setup(); - HAL_GPIO_Init(GPIOA, &(GPIO_InitTypeDef) { - .Pin = GPIO_PIN_5, - .Mode = GPIO_MODE_OUTPUT_PP, - .Pull = GPIO_NOPULL - }); - - ws_backlog_alloc(24 * 60); - xTaskCreate(ws_sensor_read_task, "sensor", 128, NULL, 1, NULL); vTaskStartScheduler(); } diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 318de5a..63efd37 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -7,6 +7,7 @@ #include "esp8266.h" #include "setup.h" +#include "backlog.h" I2C_HandleTypeDef hi2c1 = { .Instance = I2C1, @@ -57,7 +58,7 @@ DMA_HandleTypeDef hdma_usart1_rx = { .Init.Priority = DMA_PRIORITY_LOW, }; -DMA_HandleTypeDef hdma_usart1_tx { +DMA_HandleTypeDef hdma_usart1_tx = { .Instance = DMA1_Channel2, .Init.Direction = DMA_MEMORY_TO_PERIPH, .Init.PeriphInc = DMA_PINC_DISABLE, @@ -83,6 +84,14 @@ void ws_io_setup() { ws_io_usart1_setup(); ws_io_usart2_setup(); ws_io_dma_setup(); + + HAL_GPIO_Init(GPIOA, &(GPIO_InitTypeDef) { + .Pin = GPIO_PIN_5, + .Mode = GPIO_MODE_OUTPUT_PP, + .Pull = GPIO_NOPULL + }); + + ws_backlog_alloc(24 * 60); } static void ws_io_clock_setup() { @@ -123,7 +132,7 @@ 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_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); } -- cgit v1.2.3 From 97800dd398440f50dc48911ad27897c98193c056 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Tue, 25 Oct 2022 18:22:05 +0200 Subject: dummy function in server.h implemented --- stm32f091/server.c | 56 ++++++++---------------------------------------------- stm32f091/server.h | 12 ------------ 2 files changed, 8 insertions(+), 60 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/server.c b/stm32f091/server.c index 4840527..de6ea50 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -3,55 +3,15 @@ #include #include -#include "setup.h" #include "server.h" -#include "esp8266.h" -void ws_server_demo() { - uint8_t ok[]= "ok\r\n"; - uint8_t hier[]= "hier\r\n"; - //disconnect();//connect();// +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) ?) - ws_esp8266_StartEsp(); - HAL_UART_Transmit(&huart2, hier,sizeof(hier),1000); - ws_esp8266_close(); - HAL_UART_Transmit(&huart2, hier,sizeof(hier),1000); - ws_esp8266_serveruit(); - HAL_UART_Transmit(&huart2, hier,sizeof(hier),1000); - ws_esp8266_mux(); - HAL_UART_Transmit(&huart2, hier,sizeof(hier),1000); - ws_esp8266_mode(); - HAL_UART_Transmit(&huart2, hier,sizeof(hier),1000); - - ws_esp8266_serveraan(); - HAL_UART_Transmit(&huart2, ok,sizeof(ok),1000); - uint8_t receive[24]={0}; - uint8_t sendToQTData[]="gelukt"; - uint8_t test[]="test"; - //int ret; - //ATsendCommand(sendToQTData); - while (1) - { - - if(receive[0]=='\0') - { - HAL_UART_Receive_IT(&huart1, receive, 24); - } - else - { - HAL_UART_Transmit(&huart2, test,strlen((char*)test),1000); - HAL_Delay(5000); - - // if(receivingMsg(receive, 24)==1) - // { - // ret=1; - ws_esp8266_ATsendCommand(sendToQTData); - ws_esp8266_close(); - memset(receive,0,24); - //} - } - - - - } + return; } diff --git a/stm32f091/server.h b/stm32f091/server.h index e134079..6041ef6 100644 --- a/stm32f091/server.h +++ b/stm32f091/server.h @@ -3,11 +3,6 @@ #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 * @@ -20,10 +15,3 @@ */ 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 - -- cgit v1.2.3 From e2ae9e96ba05baa389ebc49a65a941bada87e3aa Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 15:51:18 +0200 Subject: dma write working --- stm32f091/esp8266.c | 12 +++++------- stm32f091/esp8266.h | 3 ++- stm32f091/main.c | 6 +++++- stm32f091/makefile | 1 + stm32f091/setup.c | 1 - stm32f091/test.c | 25 +++++++++++++++++++++++++ stm32f091/test.h | 4 ++++ 7 files changed, 42 insertions(+), 10 deletions(-) create mode 100644 stm32f091/test.c create mode 100644 stm32f091/test.h (limited to 'stm32f091') diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 341f052..98c4e10 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -14,6 +14,7 @@ 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) { @@ -51,14 +52,11 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t 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 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 ws_esp8266_ATsendCommand(uint8_t* data){ char dataChar[20]; diff --git a/stm32f091/esp8266.h b/stm32f091/esp8266.h index 9df02cb..d18c214 100644 --- a/stm32f091/esp8266.h +++ b/stm32f091/esp8266.h @@ -6,11 +6,12 @@ extern char g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; -void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *, uint16_t); +// 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 USART1_IRQHandler(void); void ws_esp8266_ATsendCommand(uint8_t* data); int ws_esp8266_checkOK(uint8_t *receiveData,int length); diff --git a/stm32f091/main.c b/stm32f091/main.c index ed0dacd..f5fe563 100644 --- a/stm32f091/main.c +++ b/stm32f091/main.c @@ -6,8 +6,12 @@ #include "setup.h" #include "sensor.h" +#include "test.h" + int main() { ws_io_setup(); - xTaskCreate(ws_sensor_read_task, "sensor", 128, NULL, 1, NULL); + // 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); vTaskStartScheduler(); } diff --git a/stm32f091/makefile b/stm32f091/makefile index 20424c3..bf20f00 100644 --- a/stm32f091/makefile +++ b/stm32f091/makefile @@ -90,6 +90,7 @@ $(TARGET).elf: $(OBJS) flash: $(TARGET).bin st-flash write $(TARGET).bin 0x08000000 + st-flash reset compile_commands: clean compiledb make -n diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 63efd37..39cff07 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -132,7 +132,6 @@ static void ws_io_usart1_setup() { if (HAL_UART_Init(&huart1) != HAL_OK) return ws_setup_error_handler(); - 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); } diff --git a/stm32f091/test.c b/stm32f091/test.c new file mode 100644 index 0000000..4d1b936 --- /dev/null +++ b/stm32f091/test.c @@ -0,0 +1,25 @@ +#include +#include +#include + +#include "setup.h" + +uint8_t tx_buffer[] = "AT\r\n"; + +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() { + while (1) { + HAL_UART_Transmit_DMA(&huart1, tx_buffer, sizeof(tx_buffer)); + __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); + + HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); + vTaskDelay(portTICK_PERIOD_MS * 1000 * 1); + } +} diff --git a/stm32f091/test.h b/stm32f091/test.h new file mode 100644 index 0000000..6c312d9 --- /dev/null +++ b/stm32f091/test.h @@ -0,0 +1,4 @@ +#pragma once + +void ws_test_read_task(); +void ws_test_write_task(); -- 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') 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 a74368cb7eebb99b14060c9198dfa277a18c2234 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 19:17:51 +0200 Subject: optimize makefile --- stm32f091/makefile | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/makefile b/stm32f091/makefile index bf20f00..dd03761 100644 --- a/stm32f091/makefile +++ b/stm32f091/makefile @@ -4,6 +4,7 @@ OC = arm-none-eabi-objcopy RM = rm -f TARGET = main +HOST=$(strip $(shell uname -o)) include ../shared/shared.mk @@ -13,7 +14,6 @@ SHARED_FLAGS += -Wall SHARED_FLAGS += -Wextra # SHARED_FLAGS += -Wno-register SHARED_FLAGS += -Wa,--defsym,CALL_ARM_SYSTEM_INIT=1 -# SHARED_FLAGS += -I/usr/arm-none-eabi/include/ SHARED_FLAGS += -I./lib/STM32-base-STM32Cube/HAL/STM32F0xx/inc SHARED_FLAGS += -I./lib/STM32-base-STM32Cube/HAL/STM32F0xx/inc/Legacy SHARED_FLAGS += -I./lib/STM32-base-STM32Cube/CMSIS/ARM/inc @@ -22,7 +22,10 @@ SHARED_FLAGS += -I./lib/STM32-base/startup SHARED_FLAGS += -I./lib/FreeRTOS-Kernel/include SHARED_FLAGS += -I./lib/FreeRTOS-Kernel/portable/GCC/ARM_CM0/ SHARED_FLAGS += -I. -SHARED_FLAGS += -O1 +ifeq ($(HOST),GNU/Linux) +SHARED_FLAGS += -I/usr/arm-none-eabi/include/ +endif +# SHARED_FLAGS += -O1 SHARED_FLAGS += -ffunction-sections SHARED_FLAGS += -fdata-sections SHARED_FLAGS += -Wl,--gc-sections @@ -89,8 +92,7 @@ $(TARGET).elf: $(OBJS) $(LD) $(LFLAGS) $^ -o $@ flash: $(TARGET).bin - st-flash write $(TARGET).bin 0x08000000 - st-flash reset + st-flash --reset write $(TARGET).bin 0x08000000 compile_commands: clean compiledb make -n -- 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') 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 02f7c39773db3daa5e0885035c79a1e10e8af0df Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 19:31:19 +0200 Subject: clean up test code --- stm32f091/setup.c | 23 +++++++++-------------- stm32f091/stm32f0xx_hal_conf.h | 2 -- 2 files changed, 9 insertions(+), 16 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 98ef8cd..2110e03 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -22,16 +22,14 @@ I2C_HandleTypeDef hi2c1 = { }; UART_HandleTypeDef huart1 = { - .Instance = USART1, - .Init.BaudRate = 115200, - .Init.WordLength = UART_WORDLENGTH_8B, - .Init.StopBits = UART_STOPBITS_1, - .Init.Parity = UART_PARITY_NONE, - .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, + .Instance = USART1, + .Init.BaudRate = 115200, + .Init.WordLength = UART_WORDLENGTH_8B, + .Init.StopBits = UART_STOPBITS_1, + .Init.Parity = UART_PARITY_NONE, + .Init.Mode = UART_MODE_TX_RX, + .Init.HwFlowCtl = UART_HWCONTROL_NONE, + .Init.OverSampling = UART_OVERSAMPLING_16, }; UART_HandleTypeDef huart2 = { @@ -133,11 +131,8 @@ 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() { @@ -196,7 +191,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { __HAL_LINKDMA(huart, hdmatx, hdma_usart1_tx); // USART1 interrupt Init - HAL_NVIC_SetPriority(USART1_IRQn, 5, 0); + HAL_NVIC_SetPriority(USART1_IRQn, 0, 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 45f9fab..fc27221 100644 --- a/stm32f091/stm32f0xx_hal_conf.h +++ b/stm32f091/stm32f0xx_hal_conf.h @@ -19,8 +19,6 @@ #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 -- cgit v1.2.3 From 754dc7371651bd1b7fa74ee1aab9f297329a0f15 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 19:32:59 +0200 Subject: add disclaimer for broken dma functionality --- stm32f091/readme.md | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'stm32f091') diff --git a/stm32f091/readme.md b/stm32f091/readme.md index 97492d5..d2758b5 100644 --- a/stm32f091/readme.md +++ b/stm32f091/readme.md @@ -4,4 +4,8 @@ - make sure to initialize the git submodules - all warnings from source files in the lib/ subfolder are hidden - copy wifi.def.h to wifi.h and edit the network credentials +- the initialization code is broken in some way which means that a soft reset + is required for the uart dma to work, either (a) press the reset button on + the development board after plugging in, or (b) run `st-flash reset` after + plugging in. -- cgit v1.2.3 From 4dbb57fe63d3c59893d1a670fecdde7ea20c9a4a Mon Sep 17 00:00:00 2001 From: lonkaars Date: Wed, 26 Oct 2022 19:34:52 +0200 Subject: call server req incoming from transfer complete handler --- stm32f091/esp8266.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 5d1847b..4daba34 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -7,6 +7,7 @@ #include "esp8266.h" #include "setup.h" #include "consts.h" +#include "server.h" #include "util.h" uint8_t g_ws_esp8266_dma_rx_buffer[WS_DMA_RX_BUFFER_SIZE]; @@ -17,9 +18,8 @@ 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); + ws_server_req_incoming(g_ws_esp8266_dma_rx_buffer, WS_DMA_RX_BUFFER_SIZE); - 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); } -- 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') 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') 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 dd1d0cf34a44f70793dcb52fd9ef90d9274b55d1 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Thu, 27 Oct 2022 17:42:54 +0200 Subject: move esp setup to setup.c --- stm32f091/esp8266.c | 205 +++++++-------------------------------------------- stm32f091/esp8266.h | 23 +++--- stm32f091/main.c | 5 +- stm32f091/server.c | 4 +- stm32f091/setup.c | 10 +++ stm32f091/test.c | 18 ----- stm32f091/test.h | 3 - stm32f091/wifi.def.h | 2 + 8 files changed, 54 insertions(+), 216 deletions(-) delete mode 100644 stm32f091/test.c delete mode 100644 stm32f091/test.h (limited to 'stm32f091') diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index c98528e..d45954e 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -10,6 +10,12 @@ #include "server.h" #include "util.h" +// macro for concise sending of multiple commands +#define ws_esp8266_send_seq(cmd) { \ + uint8_t _cmd[] = cmd; \ + ws_server_send(_cmd, sizeof(_cmd)); \ +} + 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]; @@ -53,6 +59,28 @@ void ws_esp8266_start_receive() { __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"); +} + +void ws_esp8266_ap_client_mode() { + ws_esp8266_send_seq("AT+CWMODE=1\r\n"); +} + +void ws_esp8266_start_tcp_server() { + ws_esp8266_send_seq("AT+CIPSERVER=0\r\n"); + ws_esp8266_send_seq("AT+CIPMUX=1\r\n"); + ws_esp8266_send_seq("AT+CIPSERVER=1," WS_SERVER_PORT "\r\n"); +} + +void ws_esp8266_set_mac() { + ws_esp8266_send_seq("AT+CIPSTAMAC=\"" WS_ESP8266_WLAN_MAC "\"\r\n"); +} + +void ws_esp8266_set_ip() { + ws_esp8266_send_seq("AT+CIPSTA=\"" WS_ESP8266_WLAN_IP "\"\r\n"); +} + // TODO: refactor code from here to EOF void ws_esp8266_ATsendCommand(uint8_t* data){ char dataChar[20]; @@ -68,183 +96,6 @@ void ws_esp8266_ATsendCommand(uint8_t* data){ HAL_UART_Transmit(&huart2, data, strlen((char*)data),1000); HAL_Delay(5000); } -int ws_esp8266_checkOK(uint8_t *receiveData,int length){ - char *ret=""; - // char *ret1=""; - HAL_UART_Transmit(&huart2, receiveData,length,1000); - ret = strstr((char*)receiveData,"OK"); - // ret = strstr((char*)receiveData,"change"); - // memset(receiveData,0,30); - if((ret[0]='O') && (ret[1]=='K')){ - //HAL_UART_Transmit(&huart2, (uint8_t*)ret, sizeof(ret), 100); - return 1; - - } -// else if((ret1[0]='c') && (ret1[1]=='h')){ -// //HAL_UART_Transmit(&huart2, (uint8_t*)ret, sizeof(ret), 100); -// return 1; -// -// } - else{ - return 0; - } - -} -int ws_esp8266_receivingMsg(uint8_t *receiveData,int length){ - char *ret=""; - 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; - - } - else{ - return 0; - } - -} -int ws_esp8266_unlink(uint8_t *receiveData,int length){ - char *ret=""; - HAL_UART_Transmit(&huart2, receiveData,length,1000); - ret = strstr((char*)receiveData,"UNLINK"); - // memset(receiveData,0,30); - if((ret[0]='U') && (ret[1]=='N')){ - //HAL_UART_Transmit(&huart2, (uint8_t*)ret, sizeof(ret), 100); - return 1; - - } - else{ - return 0; - } - -} - -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(&huart1, Tx_AT,strlen((char*)Tx_AT), 100); - HAL_UART_Receive(&huart1, Rx_buffer, 10, 100); - - - HAL_UART_Transmit(&huart2, Rx_buffer,10,100); - HAL_Delay(5000); - //memset(Rx_buffer,0,sizeof(Rx_buffer)); - } - -} -void ws_esp8266_disconnect(){ - int ret; - uint8_t Tx_disconnect[]="AT+CWQAP\r\n";uint8_t buffer[17]={0}; - while(ret!=1){ - - 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){ - ret=1; - } - - } - - HAL_Delay(5000); -} -void ws_esp8266_mode(){ - int ret; - uint8_t buffer1[20]={0}; uint8_t Tx_mode[]="AT+CWMODE=1\r\n"; - - while(ret!=1){ - - 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){ - ret=1; - - } - - } - - HAL_Delay(1000); -} -void ws_esp8266_connect(){ - uint8_t Tx_network[]="AT+CWJAP=\"" WS_ESP8266_WLAN_SSID "\",\"" WS_ESP8266_WLAN_PASSWD "\"\r\n"; - - - HAL_UART_Transmit(&huart1, Tx_network,strlen((char*)Tx_network),1000); - HAL_Delay(10000); -// HAL_UART_Transmit(&huart1, Tx_network,sizeof(Tx_network),1000); -// HAL_Delay(10000); - - - - - -} -void ws_esp8266_serveraan(){ - int ret; - uint8_t buffer1[30]={0}; uint8_t Tx_server[]="AT+CIPSERVER=1," WS_SERVER_PORT "\r\n"; - - while(ret!=1){ - - 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){ - ret=1; - - } - - } - - HAL_Delay(1000); -} -void ws_esp8266_serveruit(){ - //int ret; - //uint8_t buffer1[27]={0}; - uint8_t Tx_server[]="AT+CIPSERVER=0\r\n"; -// -// while(ret!=1){ - - 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){ -// ret=1; -// -// } -// -// } - - HAL_Delay(1000); -} -void ws_esp8266_mux(){ - int ret; - uint8_t buffer2[20]={0}; uint8_t Tx_mux[]="AT+CIPMUX=1\r\n"; - - while(ret!=1){ - - 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){ - ret=1; - - } - - } - - HAL_Delay(5000); -} void ws_esp8266_close(){ uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; diff --git a/stm32f091/esp8266.h b/stm32f091/esp8266.h index 64910fd..66ccfba 100644 --- a/stm32f091/esp8266.h +++ b/stm32f091/esp8266.h @@ -25,18 +25,17 @@ 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(); -// 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); -int ws_esp8266_unlink(uint8_t *receiveData,int length); -void ws_esp8266_StartEsp(); -void ws_esp8266_disconnect(); -void ws_esp8266_mode(); +/** @brief connect to access point using wifi.h credentials */ void ws_esp8266_connect(); -void ws_esp8266_serveraan(); -void ws_esp8266_serveruit(); -void ws_esp8266_mux(); -void ws_esp8266_close(); +/** @brief set esp to access point client mode (connect to AP, not become one) */ +void ws_esp8266_ap_client_mode(); +/** @brief initialize and configure the tcp server */ +void ws_esp8266_start_tcp_server(); + +/** @brief set mac address of the esp client */ +void ws_esp8266_set_mac(); +/** @brief set static ip address of the esp client */ +void ws_esp8266_set_ip(); diff --git a/stm32f091/main.c b/stm32f091/main.c index 80eb5a7..67c0a8d 100644 --- a/stm32f091/main.c +++ b/stm32f091/main.c @@ -6,11 +6,8 @@ #include "setup.h" #include "sensor.h" -#include "test.h" - int main() { ws_io_setup(); - // xTaskCreate(ws_sensor_read_task, "sensor", 64, NULL, 1, NULL); - xTaskCreate(ws_test_write_task, "test", 16, NULL, 2, NULL); + xTaskCreate(ws_sensor_read_task, "sensor", 64, NULL, 1, NULL); vTaskStartScheduler(); } diff --git a/stm32f091/server.c b/stm32f091/server.c index a06727c..1b677c2 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -77,8 +77,8 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { break; } case WS_SERVER_LM_IDLE: { - if (next_few_bytes_are("+IPD")) { - i += 3; // skip I, P, and D + if (next_few_bytes_are("+IPD,")) { + i += 4; // skip I, P, D, and comma g_ws_server_parser.mode = WS_SERVER_LM_IPD_LISTENING; } break; diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 9ed4174..2175ab3 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -91,6 +91,16 @@ void ws_io_setup() { }); ws_backlog_alloc(24 * 60); + +#ifdef WS_ESP8266_WLAN_MAC + ws_esp8266_set_mac(); +#endif +#ifdef WS_ESP8266_WLAN_IP + ws_esp8266_set_ip(); +#endif + ws_esp8266_ap_client_mode(); + ws_esp8266_connect(); + ws_esp8266_start_tcp_server(); } static void ws_io_clock_setup() { diff --git a/stm32f091/test.c b/stm32f091/test.c deleted file mode 100644 index ae48ef7..0000000 --- a/stm32f091/test.c +++ /dev/null @@ -1,18 +0,0 @@ -#include -#include -#include - -#include "server.h" -#include "setup.h" - -void ws_test_write_task() { - 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_server_send(cmd1, sizeof(cmd1)); - ws_server_send(cmd2, sizeof(cmd2)); - ws_server_send(cmd3, sizeof(cmd3)); - vTaskDelay(portTICK_PERIOD_MS * 1000 * 1); - } -} diff --git a/stm32f091/test.h b/stm32f091/test.h deleted file mode 100644 index dffa516..0000000 --- a/stm32f091/test.h +++ /dev/null @@ -1,3 +0,0 @@ -#pragma once - -void ws_test_write_task(); diff --git a/stm32f091/wifi.def.h b/stm32f091/wifi.def.h index f0748d2..61e1706 100644 --- a/stm32f091/wifi.def.h +++ b/stm32f091/wifi.def.h @@ -2,4 +2,6 @@ #define WS_ESP8266_WLAN_SSID "Test" #define WS_ESP8266_WLAN_PASSWD "12345678" +// #define WS_ESP8266_WLAN_MAC "f2:9b:89:47:c4:f3" +// #define WS_ESP8266_WLAN_IP "192.168.2.69" -- cgit v1.2.3 From 89e652af2506f7cf7854ce2e6f5b9b97423d1d40 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Thu, 27 Oct 2022 18:33:43 +0200 Subject: fix dumb typo's and added comments to faulty code --- shared/protocol.c | 5 ++++- stm32f091/server.c | 6 +++--- stm32f091/setup.c | 2 ++ 3 files changed, 9 insertions(+), 4 deletions(-) (limited to 'stm32f091') diff --git a/shared/protocol.c b/shared/protocol.c index c6e5ddd..ca0edc4 100644 --- a/shared/protocol.c +++ b/shared/protocol.c @@ -99,7 +99,10 @@ 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++) - state->target->argv[i] = malloc(sizeof(char) * (state->args_len[i] + 1)); + state->target->argv[i] = malloc(sizeof(char) * (state->args_len[i] + 1)); // segfaults on 2nd run? + // state->target->argv stays empty according to debugger + // goes to HardFault_Handler on 2nd iteration + // this might be the stm running out of heap memory though i'm not sure state->target->argc = state->arg_len; diff --git a/stm32f091/server.c b/stm32f091/server.c index 1b677c2..7e44774 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -16,7 +16,7 @@ static ws_s_server_parser g_ws_server_parser = { .current_channel = 0, .channel_data_length = 0, .channel_data_counter = 0, - .channel_listen_mode = WS_SERVER_CL_DATA_LENGTH, + .channel_listen_mode = WS_SERVER_CL_CHANNEL_ID, }; static ws_s_protocol_req_parser_state* g_ws_protocol_parsers[WS_SERVER_MAX_CHANNELS] = {0}; @@ -101,8 +101,8 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { 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 + g_ws_server_parser.channel_data_length *= 10; + g_ws_server_parser.channel_data_length += byte - '0'; // ascii to int break; } case WS_SERVER_CL_DATA_READ: { diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 2175ab3..5b6c6a4 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -90,7 +90,9 @@ void ws_io_setup() { .Pull = GPIO_NOPULL }); + // TODO: remove debug size ws_backlog_alloc(24 * 60); + // ws_backlog_alloc(10); #ifdef WS_ESP8266_WLAN_MAC ws_esp8266_set_mac(); -- cgit v1.2.3 From 1cac46e7701ef2783aea13d55261582f4d91f2fa Mon Sep 17 00:00:00 2001 From: lonkaars Date: Fri, 28 Oct 2022 09:57:50 +0200 Subject: working janky protocol! --- shared/protocol.c | 14 ++++++++++---- shared/protocol.h | 3 ++- shared/util.c | 7 +++++++ shared/util.h | 2 ++ stm32f091/esp8266.c | 27 -------------------------- stm32f091/protocol.c | 8 ++++++-- stm32f091/server.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++------ stm32f091/server.h | 13 +++++++++++-- stm32f091/setup.c | 3 ++- 9 files changed, 88 insertions(+), 43 deletions(-) create mode 100644 shared/util.c (limited to 'stm32f091') diff --git a/shared/protocol.c b/shared/protocol.c index ca0edc4..fcc84a4 100644 --- a/shared/protocol.c +++ b/shared/protocol.c @@ -3,6 +3,7 @@ #include #include "protocol.h" +#include "util.h" #define WS_CMD_MAP(parsed_cmd, name, code) \ if (strlen(parsed_cmd->argv[0]) == strlen(name) && strncmp(parsed_cmd->argv[0], name, strlen(name)) == 0) return code; @@ -99,10 +100,7 @@ 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++) - state->target->argv[i] = malloc(sizeof(char) * (state->args_len[i] + 1)); // segfaults on 2nd run? - // state->target->argv stays empty according to debugger - // goes to HardFault_Handler on 2nd iteration - // this might be the stm running out of heap memory though i'm not sure + state->target->argv[i] = malloc(sizeof(char) * (state->args_len[i] + 1)); state->target->argc = state->arg_len; @@ -138,3 +136,11 @@ void ws_protocol_req_cmd_free(ws_s_protocol_parsed_req_cmd* cmd) { free(cmd); return; } + +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) + return size; +} \ No newline at end of file diff --git a/shared/protocol.h b/shared/protocol.h index fbe29d6..5bcb114 100644 --- a/shared/protocol.h +++ b/shared/protocol.h @@ -5,7 +5,7 @@ #include "bin.h" -#define WS_PROTOCOL_CMD_MAX_ARGUMENTS (1) +#define WS_PROTOCOL_CMD_MAX_ARGUMENTS (2) #define WS_PROTOCOL_CMD_BUFFER_LEN (40) #define WS_PROTOCOL_CMD_AMOUNT (1) @@ -148,3 +148,4 @@ static ws_protocol_res_handler_t* g_ws_protocol_res_handlers[WS_PROTOCOL_CMD_AMO [WS_PROTOCOL_CMD_LAST_RECORDS] = &ws_protocol_res_last_records, }; +unsigned short ws_protocol_get_header_size(ws_s_protocol_res* response); \ No newline at end of file diff --git a/shared/util.c b/shared/util.c new file mode 100644 index 0000000..ea972b0 --- /dev/null +++ b/shared/util.c @@ -0,0 +1,7 @@ +#include "util.h" + +unsigned int ws_log16(unsigned int x) { + unsigned int l = 0; + while (x >>= 4) ++l; // bitshift right by 4 until x == 0 + return l; +} \ No newline at end of file diff --git a/shared/util.h b/shared/util.h index f39ff34..94a3dfe 100644 --- a/shared/util.h +++ b/shared/util.h @@ -2,3 +2,5 @@ #define WS_MIN(a, b) (((a) < (b)) ? (a) : (b)) #define WS_MAX(a, b) (((a) > (b)) ? (a) : (b)) + +unsigned int ws_log16(unsigned int x); diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index d45954e..db134a0 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -80,30 +80,3 @@ void ws_esp8266_set_mac() { void ws_esp8266_set_ip() { ws_esp8266_send_seq("AT+CIPSTA=\"" WS_ESP8266_WLAN_IP "\"\r\n"); } - -// TODO: refactor code from here to EOF -void ws_esp8266_ATsendCommand(uint8_t* data){ - char dataChar[20]; - uint8_t Tx_send[]="AT+CIPSEND=0,"; - - itoa(strlen((char*)data),dataChar,10); - strcat((char*)Tx_send,dataChar); - strcat((char*)Tx_send,"\r\n"); - HAL_UART_Transmit(&huart1, Tx_send, strlen((char*)Tx_send),1000); - HAL_Delay(2000); - HAL_UART_Transmit(&huart1, data, strlen((char*)data),1000); - HAL_Delay(1000); - HAL_UART_Transmit(&huart2, data, strlen((char*)data),1000); - HAL_Delay(5000); -} -void ws_esp8266_close(){ - - uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; - - - HAL_UART_Transmit(&huart1, Tx_close,strlen((char*)Tx_close), 100); - - HAL_Delay(3000); - -} - diff --git a/stm32f091/protocol.c b/stm32f091/protocol.c index 589ee5d..3a8d78b 100644 --- a/stm32f091/protocol.c +++ b/stm32f091/protocol.c @@ -3,6 +3,8 @@ #include "../shared/protocol.h" #include "backlog.h" #include "util.h" +#include "server.h" +#include "esp8266.h" 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; @@ -16,6 +18,7 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s response->csh = true; response->msg = ws_bin_s_alloc(0); 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 { ws_protocol_send_data(response_header, strlen(response_header)); char line[response_line_size + 1]; // +1 for null terminator -> sprintf @@ -24,10 +27,11 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s 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("\r\n", 2); // test } } void ws_protocol_send_data(const char* data, unsigned int length) { - //TODO: implement on esp data channels - HAL_UART_Transmit(&huart2, (uint8_t*) data, length, HAL_MAX_DELAY); + 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 7e44774..d4f7e20 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -9,7 +9,7 @@ #include "setup.h" #include "consts.h" -static ws_s_server_parser g_ws_server_parser = { +ws_s_server_parser g_ws_server_parser = { .last_response = WS_SERVER_RC_NONE, .mode = WS_SERVER_LM_IDLE, @@ -20,7 +20,7 @@ static 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; void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore) { if (ignore) return; @@ -80,6 +80,9 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { if (next_few_bytes_are("+IPD,")) { i += 4; // skip I, P, D, and comma g_ws_server_parser.mode = WS_SERVER_LM_IPD_LISTENING; + } else if (byte == '>') { + g_ws_server_parser.mode = WS_SERVER_LM_CIPSEND_LISTENING; + ws_server_buffer_send_finish(); } break; } @@ -114,6 +117,7 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { 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); + g_ws_server_parser.mode = WS_SERVER_LM_IDLE; } break; } @@ -121,6 +125,14 @@ 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")) { + i += 6; + // g_ws_server_parser.mode = WS_SERVER_LM_IDLE; + ws_server_req_respond_end(0); + } + break; + } default: {} } } @@ -132,9 +144,39 @@ void ws_server_send(uint8_t* data, size_t 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_send[]="AT+CIPSEND=0,LEN:"; - uint8_t Tx_close[]="AT+CIPCLOSE=0\r\n"; - return; +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 +} + +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); +#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); + g_ws_esp8266_dma_tx_buffer_index = 0; + while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); +} + +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); + g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; + ws_esp8266_send((uint8_t*) cmd, len); + while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); +} + +void ws_server_req_respond_end(unsigned int channel) { + char* cmd = NULL; + size_t len = asiprintf(&cmd, "AT+CIPCLOSE=%d\r\n", channel); + g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; + ws_esp8266_send((uint8_t*) cmd, len); + while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); } diff --git a/stm32f091/server.h b/stm32f091/server.h index 44882e4..128b579 100644 --- a/stm32f091/server.h +++ b/stm32f091/server.h @@ -9,6 +9,7 @@ typedef enum { 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_SERVER_LM_CIPSEND_LISTENING, /** @brief AT+CIPSEND sent, now reading data */ } ws_e_server_listen_mode; typedef enum { @@ -34,6 +35,9 @@ typedef struct { bool channel_data_ignore; } ws_s_server_parser; +/** @brief global server parser struct */ +extern ws_s_server_parser g_ws_server_parser; + /** * @brief +IPD incoming request handler * @@ -46,8 +50,10 @@ typedef struct { */ 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 AT response header for incoming request on specific channel */ +void ws_server_req_respond_start(unsigned int channel, size_t size); +/** @brief send AT tcp close on specific channel */ +void ws_server_req_respond_end(unsigned int channel); /** @brief send data to esp, waiting until server returns to idle mode */ void ws_server_send(uint8_t* data, size_t size); @@ -74,3 +80,6 @@ void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore); * @param ignore ignore mode */ void ws_server_req_finish(unsigned int channel, bool ignore); + +void ws_server_buffer_send_append(uint8_t* data, size_t size); +void ws_server_buffer_send_finish(); diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 5b6c6a4..1971809 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -8,6 +8,7 @@ #include "esp8266.h" #include "setup.h" #include "backlog.h" +#include "server.h" I2C_HandleTypeDef hi2c1 = { .Instance = I2C1, @@ -101,7 +102,7 @@ void ws_io_setup() { ws_esp8266_set_ip(); #endif ws_esp8266_ap_client_mode(); - ws_esp8266_connect(); + do ws_esp8266_connect(); while (g_ws_server_parser.last_response == WS_SERVER_RC_ERR); ws_esp8266_start_tcp_server(); } -- 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') 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') 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') 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 From ee6d749c0fc2b4cd45e3cf8295aae892e0680c6c Mon Sep 17 00:00:00 2001 From: lonkaars Date: Fri, 28 Oct 2022 15:18:26 +0200 Subject: update todo --- stm32f091/todo.md | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/todo.md b/stm32f091/todo.md index 767d745..77c37e6 100644 --- a/stm32f091/todo.md +++ b/stm32f091/todo.md @@ -1,10 +1,28 @@ -- handle errors from `AT+CIPSEND`, these look like this: - ``` - > AT0,CONNECT +# things that have to get fixed before monday - > +IPD,0,15:last-records 5<0a> - < AT+CIPSEND=0,125 - > AT+CIPSEND=0,125 +- [ ] more documentation in header files (for both client and stm code) +- [ ] design/architecture document +- [ ] more tests in the test document +- [ ] handle errors from `AT+CIPSEND`, these look like this: + ``` + > AT0,CONNECT - > ERROR - ``` + > +IPD,0,15:last-records 5<0a> + < AT+CIPSEND=0,125 + > AT+CIPSEND=0,125 + + > ERROR + ``` + +## `// TODO:`'s + +- [ ] `sensor.c:24: return (uint8_t) temp_c; //TODO: convert with range -> util.h` +- [ ] `sensor.c:36: return (uint8_t) humidity; //TODO: convert with range -> util.h` +- [ ] `sensor.c:51: return (uint8_t) val; // TODO: convert with range` +- [ ] `server.c:47:// TODO: next_few_bytes_are assumes that the complete search string is in the` +- [ ] `server.c:146: // TODO: buffer overrun protection` +- [ ] `server.c:152:// TODO: refactor this` +- [ ] `server.c:165:// TODO: refactor this` +- [ ] `server.c:174:// TODO: refactor this` +- [ ] `setup.c:95: // TODO: remove debug size` +- [ ] `setup.c:187: .Pin = GPIO_PIN_8|GPIO_PIN_9, //TODO: use #defines in setup.h` -- cgit v1.2.3 From c429e17061d392ea4b3f73ebcc9101db8e491d8f Mon Sep 17 00:00:00 2001 From: lonkaars Date: Fri, 28 Oct 2022 16:56:23 +0200 Subject: another off-by-one error fixed --- stm32f091/server.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/server.c b/stm32f091/server.c index 6225eae..46d18f0 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -46,7 +46,7 @@ void ws_server_req_finish(unsigned int channel, bool ignore) { // 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) +#define next_few_bytes_are(code) (((i + sizeof(code) - 2) < 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 ws_dbg_set_usart2_tty_color(1); @@ -80,7 +80,7 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { if (next_few_bytes_are("+IPD,")) { i += 4; // skip I, P, D, and comma g_ws_server_parser.mode = WS_SERVER_LM_IPD_LISTENING; - } else if (byte == '>') { + } else if (next_few_bytes_are("> ")) { g_ws_server_parser.mode = WS_SERVER_LM_CIPSEND_LISTENING; ws_server_buffer_send_finish(); } -- cgit v1.2.3 From 7b4dbb553a4d22e88bafc38163d1b2f951c40fde Mon Sep 17 00:00:00 2001 From: lonkaars Date: Sat, 29 Oct 2022 12:26:46 +0200 Subject: add bunch of unneccesary debug stuff, fix some stuff and expect espressif esp firmware --- stm32f091/esp8266.c | 2 +- stm32f091/server.c | 92 ++++++++++++++++++++++++++++++++--------------------- stm32f091/setup.c | 6 ++-- stm32f091/util.h | 31 +++++++++++++++++- 4 files changed, 89 insertions(+), 42 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index b896567..159b55d 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -58,7 +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 - ws_dbg_set_usart2_tty_color(2); + ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_TX); HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, strlen((char*) g_ws_esp8266_dma_tx_buffer), 100); #endif diff --git a/stm32f091/server.c b/stm32f091/server.c index 46d18f0..e0c97dc 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -49,7 +49,7 @@ void ws_server_req_finish(unsigned int channel, bool ignore) { #define next_few_bytes_are(code) (((i + sizeof(code) - 2) < 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 - ws_dbg_set_usart2_tty_color(1); + ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_RX); HAL_UART_Transmit(&huart2, data, size, 100); #endif @@ -64,12 +64,19 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { case WS_SERVER_LM_STATUS_CODE: { bool code_got = false; if (next_few_bytes_are("OK")) { + i += 1; code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_OK; - } else if (next_few_bytes_are("ERROR") || next_few_bytes_are("FAIL")) { + } else if (next_few_bytes_are("ERROR")) { + i += 4; + code_got = true; + g_ws_server_parser.last_response = WS_SERVER_RC_ERR; + } else if (next_few_bytes_are("FAIL")) { + i += 3; code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_ERR; } else if (next_few_bytes_are("busy p...")) { + i += 8; code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_BUSY; } @@ -80,49 +87,49 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { if (next_few_bytes_are("+IPD,")) { i += 4; // skip I, P, D, and comma g_ws_server_parser.mode = WS_SERVER_LM_IPD_LISTENING; - } else if (next_few_bytes_are("> ")) { + } else if (next_few_bytes_are(">")) { // ">" on official espressif firmware, "> " on ai-thinker firmware g_ws_server_parser.mode = WS_SERVER_LM_CIPSEND_LISTENING; ws_server_buffer_send_finish(); } break; } case WS_SERVER_LM_IPD_LISTENING: { - 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 + 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; } - 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.channel_data_length *= 10; - g_ws_server_parser.channel_data_length += byte - '0'; // ascii to int + 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; } - 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); - g_ws_server_parser.mode = WS_SERVER_LM_IDLE; - } - break; + g_ws_server_parser.channel_data_length *= 10; + g_ws_server_parser.channel_data_length += 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); + g_ws_server_parser.mode = WS_SERVER_LM_IDLE; } - default: {} + break; } + default: {} + } break; } case WS_SERVER_LM_CIPSEND_LISTENING: { @@ -151,15 +158,26 @@ void ws_server_buffer_send_append(uint8_t* data, size_t size) { // TODO: refactor this void ws_server_buffer_send_finish() { + /* const int chunk_size = 16; // esp is garbage + + for (unsigned int chunk = 0; chunk <= (g_ws_esp8266_dma_tx_buffer_size / chunk_size); chunk++) { + HAL_UART_Transmit_DMA(&huart1, &g_ws_esp8266_dma_tx_buffer[chunk_size * chunk], WS_MIN(chunk_size, g_ws_esp8266_dma_tx_buffer_size % chunk_size)); + __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); + while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); + } */ #ifdef WS_DBG_PRINT_ESP_OVER_USART2 - ws_dbg_set_usart2_tty_color(2); + ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_TX); 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, g_ws_esp8266_dma_tx_buffer_size); - __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); + HAL_UART_Transmit(&huart1, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); + // for (unsigned j = 0; j < 10000; j++) asm("nop"); // esp garbage + // for (unsigned int i = 0; i < g_ws_esp8266_dma_tx_buffer_size; i++) { + // // send as slow as possible because the esp is garbage + // for (unsigned j = 0; j < 1000; j++) asm("nop"); // did i mention the esp is garbage + // HAL_UART_Transmit(&huart1, &g_ws_esp8266_dma_tx_buffer[i], 1, 100); + // } g_ws_esp8266_dma_tx_buffer_size = 0; - while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); } // TODO: refactor this diff --git a/stm32f091/setup.c b/stm32f091/setup.c index 1591649..ef00a29 100644 --- a/stm32f091/setup.c +++ b/stm32f091/setup.c @@ -97,18 +97,18 @@ void ws_io_setup() { // ws_backlog_alloc(10); #ifdef WS_DBG_PRINT_ESP_OVER_USART2 - ws_dbg_set_usart2_tty_color(7); + ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_DBGMSG); const char restart_str[] = "\r\n--- stm restart ---\r\n"; - HAL_UART_Transmit(&huart2, restart_str, strlen(restart_str), 100); + HAL_UART_Transmit(&huart2, (uint8_t*) restart_str, strlen(restart_str), 100); #endif + ws_esp8266_ap_client_mode(); #ifdef WS_ESP8266_WLAN_MAC ws_esp8266_set_mac(); #endif #ifdef WS_ESP8266_WLAN_IP ws_esp8266_set_ip(); #endif - ws_esp8266_ap_client_mode(); do ws_esp8266_connect(); while (g_ws_server_parser.last_response == WS_SERVER_RC_ERR); ws_esp8266_start_tcp_server(); } diff --git a/stm32f091/util.h b/stm32f091/util.h index 9f5c1ec..dde3677 100644 --- a/stm32f091/util.h +++ b/stm32f091/util.h @@ -8,6 +8,35 @@ #include "setup.h" #include "../shared/util.h" +#define WS_DBG_TTY_COLOR_BLK 0x0 +#define WS_DBG_TTY_COLOR_RED 0x1 +#define WS_DBG_TTY_COLOR_GRN 0x2 +#define WS_DBG_TTY_COLOR_YLW 0x3 +#define WS_DBG_TTY_COLOR_BLU 0x4 +#define WS_DBG_TTY_COLOR_VLT 0x5 +#define WS_DBG_TTY_COLOR_CYN 0x6 +#define WS_DBG_TTY_COLOR_WHI 0x7 +#define WS_DBG_TTY_COLOR_BR_BLK 0x8 +#define WS_DBG_TTY_COLOR_BR_RED 0x9 +#define WS_DBG_TTY_COLOR_BR_GRN 0xa +#define WS_DBG_TTY_COLOR_BR_YLW 0xb +#define WS_DBG_TTY_COLOR_BR_BLU 0xc +#define WS_DBG_TTY_COLOR_BR_VLT 0xd +#define WS_DBG_TTY_COLOR_BR_CYN 0xe +#define WS_DBG_TTY_COLOR_BR_WHI 0xf + +// serial debug color scheme +#define WS_DBG_TTY_COLOR_DBGMSG WS_DBG_TTY_COLOR_BR_BLK +#define WS_DBG_TTY_COLOR_TX WS_DBG_TTY_COLOR_GRN +#define WS_DBG_TTY_COLOR_RX WS_DBG_TTY_COLOR_RED + +// unused +// #define WS_DBG_TTY_COLOR_CMD_ECHO WS_DBG_TTY_COLOR_BLK +// #define WS_DBG_TTY_COLOR_STATUS_CODE WS_DBG_TTY_COLOR_YLW +// #define WS_DBG_TTY_COLOR_IDLE WS_DBG_TTY_COLOR_VLT +// #define WS_DBG_TTY_COLOR_IPD_LISTENING WS_DBG_TTY_COLOR_GRN +// #define WS_DBG_TTY_COLOR_CIPSEND_LISTENING WS_DBG_TTY_COLOR_RED + #define ws_usb_printf(fmt, ...) { \ char temp[255]; \ snprintf(temp, 255, fmt, ##__VA_ARGS__); \ @@ -15,6 +44,6 @@ } #define ws_dbg_set_usart2_tty_color(color) { \ - uint8_t sgr[] = { 0x1b, 0x5b, 0x33, 0x30 + color, 0x6d }; \ + uint8_t sgr[] = { 0x1b, 0x5b, 0x33 + (color > 7 ? 6 : 0), 0x30 + (color & 0b111), 0x6d }; \ HAL_UART_Transmit(&huart2, sgr, sizeof(sgr), 100); \ } -- cgit v1.2.3 From f536fb4f92eda7ba5e80230a023b144d373dd86b Mon Sep 17 00:00:00 2001 From: lonkaars Date: Sat, 29 Oct 2022 13:19:24 +0200 Subject: garbage delay - esp still too slow!? --- stm32f091/server.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/server.c b/stm32f091/server.c index e0c97dc..cc47251 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -167,16 +167,18 @@ void ws_server_buffer_send_finish() { } */ #ifdef WS_DBG_PRINT_ESP_OVER_USART2 ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_TX); - HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); #endif - HAL_UART_Transmit(&huart1, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); - // for (unsigned j = 0; j < 10000; j++) asm("nop"); // esp garbage - // for (unsigned int i = 0; i < g_ws_esp8266_dma_tx_buffer_size; i++) { - // // send as slow as possible because the esp is garbage - // for (unsigned j = 0; j < 1000; j++) asm("nop"); // did i mention the esp is garbage - // HAL_UART_Transmit(&huart1, &g_ws_esp8266_dma_tx_buffer[i], 1, 100); - // } + // HAL_UART_Transmit(&huart1, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); + for (unsigned j = 0; j < 1000000; j++) asm("nop"); // esp garbage + for (unsigned int i = 0; i < g_ws_esp8266_dma_tx_buffer_size; i++) { + // send as slow as possible because the esp is garbage + for (unsigned j = 0; j < 10000; j++) asm("nop"); // did i mention the esp is garbage + HAL_UART_Transmit(&huart1, &g_ws_esp8266_dma_tx_buffer[i], 1, 100); +#ifdef WS_DBG_PRINT_ESP_OVER_USART2 + HAL_UART_Transmit(&huart2, &g_ws_esp8266_dma_tx_buffer[i], 1, 100); +#endif + } g_ws_esp8266_dma_tx_buffer_size = 0; } -- cgit v1.2.3 From 9947b4aa803b0430e38be3bd6f7179b45b201213 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Sat, 29 Oct 2022 17:15:56 +0200 Subject: send data in chunks for reliability --- stm32f091/esp8266.c | 6 +-- stm32f091/protocol.c | 4 +- stm32f091/server.c | 108 +++++++++++++++++++++++++++++++-------------------- stm32f091/server.h | 24 +++++++++--- stm32f091/todo.md | 2 +- stm32f091/util.h | 2 + 6 files changed, 92 insertions(+), 54 deletions(-) (limited to 'stm32f091') diff --git a/stm32f091/esp8266.c b/stm32f091/esp8266.c index 159b55d..74ec347 100644 --- a/stm32f091/esp8266.c +++ b/stm32f091/esp8266.c @@ -75,9 +75,9 @@ void ws_esp8266_ap_client_mode() { } void ws_esp8266_start_tcp_server() { - ws_esp8266_send_seq("AT+CIPSERVER=0\r\n"); - ws_esp8266_send_seq("AT+CIPMUX=1\r\n"); - ws_esp8266_send_seq("AT+CIPSERVER=1," WS_SERVER_PORT "\r\n"); + ws_esp8266_send_seq("AT+CIPSERVER=0\r\n"); // stop tcp server (if running) + ws_esp8266_send_seq("AT+CIPMUX=1\r\n"); // enable multiplexing (allow multiple connections) + ws_esp8266_send_seq("AT+CIPSERVER=1," WS_SERVER_PORT "\r\n"); // start tcp server } void ws_esp8266_set_mac() { diff --git a/stm32f091/protocol.c b/stm32f091/protocol.c index 4d605fc..ca46b3b 100644 --- a/stm32f091/protocol.c +++ b/stm32f091/protocol.c @@ -21,7 +21,6 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s 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)); @@ -29,9 +28,8 @@ void ws_protocol_res_last_records(ws_s_protocol_parsed_req_cmd* parsed_cmd, ws_s 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_len); // remove string terminator + ws_protocol_send_data(line, response_line_len); } - // ws_protocol_send_data("\r\n", 2); // test } } diff --git a/stm32f091/server.c b/stm32f091/server.c index cc47251..0e8cadf 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -18,10 +18,14 @@ ws_s_server_parser g_ws_server_parser = { .channel_data_length = 0, .channel_data_counter = 0, .channel_listen_mode = WS_SERVER_CL_CHANNEL_ID, + + .rc = { 0 }, }; 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_size = 0; +static unsigned int g_ws_esp8266_dma_tx_buffer_head = 0; +static unsigned int g_ws_esp8266_dma_tx_buffer_tail = 0; +static unsigned int g_ws_esp8266_dma_tx_buffer_cs = 0; // chunk size void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore) { if (ignore) return; @@ -44,6 +48,13 @@ void ws_server_req_finish(unsigned int channel, bool ignore) { } } +static bool ws_server_is_response(char data, uint8_t* counter, const char* cmd, unsigned short cmd_len) { + if (data == cmd[*counter]) *counter += 1; + else *counter = 0; + if (*counter == cmd_len) return true; + return false; +} + // 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) - 2) < size) && (strncmp((char*)&data[i], code, sizeof(code) - 1) == 0)) @@ -63,20 +74,16 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { } case WS_SERVER_LM_STATUS_CODE: { bool code_got = false; - if (next_few_bytes_are("OK")) { - i += 1; + if (ws_server_is_response(byte, &g_ws_server_parser.rc.s_ok, "OK", 2)) { code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_OK; - } else if (next_few_bytes_are("ERROR")) { - i += 4; + } else if (ws_server_is_response(byte, &g_ws_server_parser.rc.s_error, "ERROR", 5)) { code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_ERR; - } else if (next_few_bytes_are("FAIL")) { - i += 3; + } else if (ws_server_is_response(byte, &g_ws_server_parser.rc.s_fail, "FAIL", 4)) { code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_ERR; - } else if (next_few_bytes_are("busy p...")) { - i += 8; + } else if (ws_server_is_response(byte, &g_ws_server_parser.rc.s_busy, "busy p...", 9)) { code_got = true; g_ws_server_parser.last_response = WS_SERVER_RC_BUSY; } @@ -84,12 +91,12 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { break; } case WS_SERVER_LM_IDLE: { - if (next_few_bytes_are("+IPD,")) { - i += 4; // skip I, P, D, and comma + if (ws_server_is_response(byte, &g_ws_server_parser.rc.i_ipd, "+IPD,", 5)) { g_ws_server_parser.mode = WS_SERVER_LM_IPD_LISTENING; - } else if (next_few_bytes_are(">")) { // ">" on official espressif firmware, "> " on ai-thinker firmware + } else if (ws_server_is_response(byte, &g_ws_server_parser.rc.i_prompt, ">", 1)) { + // ^^^ this is ">" on official espressif firmware, "> " on ai-thinker firmware g_ws_server_parser.mode = WS_SERVER_LM_CIPSEND_LISTENING; - ws_server_buffer_send_finish(); + ws_server_buffer_send_chunk(); } break; } @@ -125,6 +132,7 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { 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); g_ws_server_parser.mode = WS_SERVER_LM_IDLE; + ws_server_buffer_request_chunk_send(); } break; } @@ -133,8 +141,8 @@ 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") || next_few_bytes_are("ERROR")) { - ws_server_req_respond_end(0); + if (ws_server_is_response(byte, &g_ws_server_parser.rc.l_send_ok, "SEND OK", 7) || ws_server_is_response(byte, &g_ws_server_parser.rc.l_error, "ERROR", 5)) { + ws_server_buffer_request_chunk_send(); } break; } @@ -143,6 +151,13 @@ void ws_server_req_incoming(uint8_t* data, size_t size) { } } +/** @brief get amount of bytes in g_ws_esp8266_dma_tx_buffer until \n */ +static unsigned int ws_server_next_line_length() { + for (unsigned int i = g_ws_esp8266_dma_tx_buffer_tail; i <= g_ws_esp8266_dma_tx_buffer_head; i++) + if (g_ws_esp8266_dma_tx_buffer[i] == '\n') return i - g_ws_esp8266_dma_tx_buffer_tail + 1; + return g_ws_esp8266_dma_tx_buffer_head - g_ws_esp8266_dma_tx_buffer_tail; +} + 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); @@ -152,43 +167,52 @@ 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_size], (char*) data, size); // append string - g_ws_esp8266_dma_tx_buffer_size += size; // shift head + strncpy((char*) &g_ws_esp8266_dma_tx_buffer[g_ws_esp8266_dma_tx_buffer_head], (char*) data, size); // append string + g_ws_esp8266_dma_tx_buffer_head += size; // shift head } -// TODO: refactor this -void ws_server_buffer_send_finish() { - /* const int chunk_size = 16; // esp is garbage - - for (unsigned int chunk = 0; chunk <= (g_ws_esp8266_dma_tx_buffer_size / chunk_size); chunk++) { - HAL_UART_Transmit_DMA(&huart1, &g_ws_esp8266_dma_tx_buffer[chunk_size * chunk], WS_MIN(chunk_size, g_ws_esp8266_dma_tx_buffer_size % chunk_size)); - __HAL_UART_ENABLE_IT(&huart1, UART_IT_TXE); - while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); - } */ +void ws_server_buffer_request_chunk_send() { + g_ws_esp8266_dma_tx_buffer_cs = ws_server_next_line_length(); + + char* cmd = NULL; + size_t len; + + if (g_ws_esp8266_dma_tx_buffer_cs > 0) { + len = asiprintf(&cmd, "AT+CIPSEND=%d,%d\r\n", g_ws_server_parser.current_channel, g_ws_esp8266_dma_tx_buffer_cs); + } else { + len = asiprintf(&cmd, "AT+CIPCLOSE=%d\r\n", g_ws_server_parser.current_channel); + } + + g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; + #ifdef WS_DBG_PRINT_ESP_OVER_USART2 ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_TX); + HAL_UART_Transmit(&huart2, (uint8_t*) cmd, len, 100); #endif + HAL_UART_Transmit(&huart1, (uint8_t*) cmd, len, 100); +} - // HAL_UART_Transmit(&huart1, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_size, 100); - for (unsigned j = 0; j < 1000000; j++) asm("nop"); // esp garbage - for (unsigned int i = 0; i < g_ws_esp8266_dma_tx_buffer_size; i++) { - // send as slow as possible because the esp is garbage - for (unsigned j = 0; j < 10000; j++) asm("nop"); // did i mention the esp is garbage - HAL_UART_Transmit(&huart1, &g_ws_esp8266_dma_tx_buffer[i], 1, 100); +void ws_server_buffer_send_chunk() { #ifdef WS_DBG_PRINT_ESP_OVER_USART2 - HAL_UART_Transmit(&huart2, &g_ws_esp8266_dma_tx_buffer[i], 1, 100); + ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_TX); + HAL_UART_Transmit(&huart2, &g_ws_esp8266_dma_tx_buffer[g_ws_esp8266_dma_tx_buffer_tail], g_ws_esp8266_dma_tx_buffer_cs, 100); #endif + HAL_UART_Transmit(&huart1, &g_ws_esp8266_dma_tx_buffer[g_ws_esp8266_dma_tx_buffer_tail], g_ws_esp8266_dma_tx_buffer_cs, 100); + g_ws_esp8266_dma_tx_buffer_tail += g_ws_esp8266_dma_tx_buffer_cs; + + if (g_ws_esp8266_dma_tx_buffer_head == g_ws_esp8266_dma_tx_buffer_tail) { + g_ws_esp8266_dma_tx_buffer_head = g_ws_esp8266_dma_tx_buffer_tail = 0; } - g_ws_esp8266_dma_tx_buffer_size = 0; -} -// 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); - g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; - ws_esp8266_send((uint8_t*) cmd, len); - while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); +// #ifdef WS_DBG_PRINT_ESP_OVER_USART2 +// ws_dbg_set_usart2_tty_color(WS_DBG_TTY_COLOR_TX); +// HAL_UART_Transmit(&huart2, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_head, 100); +// #endif +// +// HAL_UART_Transmit(&huart1, g_ws_esp8266_dma_tx_buffer, g_ws_esp8266_dma_tx_buffer_head, 100); +// g_ws_esp8266_dma_tx_buffer_head = 0; +// +// HAL_UART_Transmit(&huart1, (uint8_t*) "+++", 3, 100); } // TODO: refactor this diff --git a/stm32f091/server.h b/stm32f091/server.h index 128b579..07c49d9 100644 --- a/stm32f091/server.h +++ b/stm32f091/server.h @@ -25,6 +25,17 @@ typedef enum { WS_SERVER_RC_OK, } ws_e_server_response_code; +typedef struct { + uint8_t s_ok; /** @brief status code OK */ + uint8_t s_error; /** @brief status code OK */ + uint8_t s_fail; /** @brief status code OK */ + uint8_t s_busy; /** @brief status code OK */ + uint8_t i_ipd; /** @brief idle +IPD, */ + uint8_t i_prompt; /** @brief idle > */ + uint8_t l_send_ok; /** @brief ipd listen SEND OK */ + uint8_t l_error; /** @brief ipd listen ERROR */ +} ws_s_server_parser_response_counter; + typedef struct { ws_e_server_listen_mode mode; ws_e_server_response_code last_response; @@ -33,6 +44,7 @@ typedef struct { unsigned int channel_data_counter; ws_e_channel_listen_mode channel_listen_mode; bool channel_data_ignore; + ws_s_server_parser_response_counter rc; } ws_s_server_parser; /** @brief global server parser struct */ @@ -50,10 +62,10 @@ extern ws_s_server_parser g_ws_server_parser; */ void ws_server_req_incoming(uint8_t* data, size_t size); -/** @brief send AT response header for incoming request on specific channel */ -void ws_server_req_respond_start(unsigned int channel, size_t size); -/** @brief send AT tcp close on specific channel */ -void ws_server_req_respond_end(unsigned int channel); +// /** @brief send AT response header for incoming request on specific channel */ +// void ws_server_req_respond_start(unsigned int channel); +// /** @brief send AT tcp close on specific channel */ +// void ws_server_req_respond_end(unsigned int channel); /** @brief send data to esp, waiting until server returns to idle mode */ void ws_server_send(uint8_t* data, size_t size); @@ -82,4 +94,6 @@ void ws_server_req_parse_byte(unsigned int channel, uint8_t byte, bool ignore); void ws_server_req_finish(unsigned int channel, bool ignore); void ws_server_buffer_send_append(uint8_t* data, size_t size); -void ws_server_buffer_send_finish(); + +void ws_server_buffer_request_chunk_send(); +void ws_server_buffer_send_chunk(); diff --git a/stm32f091/todo.md b/stm32f091/todo.md index 77c37e6..1d42bf8 100644 --- a/stm32f091/todo.md +++ b/stm32f091/todo.md @@ -2,7 +2,7 @@ - [ ] more documentation in header files (for both client and stm code) - [ ] design/architecture document -- [ ] more tests in the test document +- [x] more tests in the test document - [ ] handle errors from `AT+CIPSEND`, these look like this: ``` > AT0,CONNECT diff --git a/stm32f091/util.h b/stm32f091/util.h index dde3677..11bee6f 100644 --- a/stm32f091/util.h +++ b/stm32f091/util.h @@ -30,6 +30,8 @@ #define WS_DBG_TTY_COLOR_TX WS_DBG_TTY_COLOR_GRN #define WS_DBG_TTY_COLOR_RX WS_DBG_TTY_COLOR_RED +#define debugger asm("nop") + // unused // #define WS_DBG_TTY_COLOR_CMD_ECHO WS_DBG_TTY_COLOR_BLK // #define WS_DBG_TTY_COLOR_STATUS_CODE WS_DBG_TTY_COLOR_YLW -- cgit v1.2.3 From aae57dc32a843351fb2e17721afcd841bedec0a6 Mon Sep 17 00:00:00 2001 From: lonkaars Date: Sat, 29 Oct 2022 18:01:44 +0200 Subject: fix memory leak --- stm32f091/server.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'stm32f091') diff --git a/stm32f091/server.c b/stm32f091/server.c index 0e8cadf..112d23a 100644 --- a/stm32f091/server.c +++ b/stm32f091/server.c @@ -182,6 +182,7 @@ void ws_server_buffer_request_chunk_send() { } else { len = asiprintf(&cmd, "AT+CIPCLOSE=%d\r\n", g_ws_server_parser.current_channel); } + free(cmd); g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; @@ -222,4 +223,5 @@ void ws_server_req_respond_end(unsigned int channel) { g_ws_server_parser.mode = WS_SERVER_LM_CMD_ECHO; ws_esp8266_send((uint8_t*) cmd, len); while (!__HAL_DMA_GET_FLAG(&hdma_usart1_tx, DMA_FLAG_TC2)); + free(cmd); } -- cgit v1.2.3