From 01784b6a8089543d41fe877f25f088cbfd357ddd Mon Sep 17 00:00:00 2001 From: RedHawk Date: Wed, 31 May 2023 18:47:06 +0300 Subject: [PATCH] esp_socket: [#57] Added driver for esp. * With small example code in master. * esp_connect currently blocks the execution. * Debug messages in socket don't follow the standart. (It is .c file, while debug messages are done in c++) * LpcUart will work only with UART1, due to the PIN_FUNC. --- source/shoh/src/peripherals/LpcDebugUart.cpp | 16 +- source/shoh/src/peripherals/LpcDebugUart.h | 4 +- source/shoh/src/peripherals/LpcUart.cpp | 4 + .../peripherals/networking/esp8266_socket.c | 808 ++++++++++++++++++ .../peripherals/networking/esp8266_socket.h | 21 + .../peripherals/networking/serial_port.cpp | 56 ++ .../src/peripherals/networking/serial_port.h | 30 + source/shoh/src/threads/master/Master.cpp | 6 + 8 files changed, 935 insertions(+), 10 deletions(-) create mode 100644 source/shoh/src/peripherals/networking/esp8266_socket.c create mode 100644 source/shoh/src/peripherals/networking/esp8266_socket.h create mode 100644 source/shoh/src/peripherals/networking/serial_port.cpp create mode 100644 source/shoh/src/peripherals/networking/serial_port.h diff --git a/source/shoh/src/peripherals/LpcDebugUart.cpp b/source/shoh/src/peripherals/LpcDebugUart.cpp index f47c8a8..a3473eb 100644 --- a/source/shoh/src/peripherals/LpcDebugUart.cpp +++ b/source/shoh/src/peripherals/LpcDebugUart.cpp @@ -116,14 +116,14 @@ void LpcDebugUart::set_on_receive(void(*cb)(void)) int LpcDebugUart::free() { - std::lock_guard lock(write_mutex); + std::lock_guard lock(write_debug_mutex); return UART_RB_SIZE - RingBuffer_GetCount(&txring); } int LpcDebugUart::peek() { - std::lock_guard lock(read_mutex); + std::lock_guard lock(read_debug_mutex); return RingBuffer_GetCount(&rxring); } @@ -135,7 +135,7 @@ int LpcDebugUart::read(char &c) int LpcDebugUart::read(char *buffer, int len) { - std::lock_guard lock(read_mutex); + std::lock_guard lock(read_debug_mutex); if(RingBuffer_GetCount(&rxring) <= 0) { notify_rx = xTaskGetCurrentTaskHandle(); @@ -151,7 +151,7 @@ int LpcDebugUart::read(char *buffer, int len) int LpcDebugUart::read(char *buffer, int len, TickType_t total_timeout, TickType_t ic_timeout) { - std::lock_guard lock(read_mutex); + std::lock_guard lock(read_debug_mutex); // we can't read more than ring buffer size at a time if(len > UART_RB_SIZE) len = UART_RB_SIZE; @@ -181,7 +181,7 @@ int LpcDebugUart::write(const char *s) int LpcDebugUart::write(const char *buffer, int len) { - std::lock_guard lock(write_mutex); + std::lock_guard lock(write_debug_mutex); int pos = 0; notify_tx = xTaskGetCurrentTaskHandle(); @@ -214,15 +214,15 @@ bool LpcDebugUart::rxbreak() void LpcDebugUart::speed(int bps) { - std::lock_guard lockw(write_mutex); - std::lock_guard lockr(read_mutex); + std::lock_guard lockw(write_debug_mutex); + std::lock_guard lockr(read_debug_mutex); Chip_UART0_SetBaud(uart, bps); } bool LpcDebugUart::txempty() { - std::lock_guard lock(write_mutex); + std::lock_guard lock(write_debug_mutex); return (RingBuffer_GetCount(&txring) == 0); } diff --git a/source/shoh/src/peripherals/LpcDebugUart.h b/source/shoh/src/peripherals/LpcDebugUart.h index 16c05e8..d9abc9f 100644 --- a/source/shoh/src/peripherals/LpcDebugUart.h +++ b/source/shoh/src/peripherals/LpcDebugUart.h @@ -56,8 +56,8 @@ private: TaskHandle_t notify_rx; TaskHandle_t notify_tx; void (*on_receive)(void); // callback for received data notifications - Fmutex read_mutex; - Fmutex write_mutex; + Fmutex read_debug_mutex; + Fmutex write_debug_mutex; }; #endif /* LPCUART_H_ */ diff --git a/source/shoh/src/peripherals/LpcUart.cpp b/source/shoh/src/peripherals/LpcUart.cpp index 7cbc985..a144bc9 100644 --- a/source/shoh/src/peripherals/LpcUart.cpp +++ b/source/shoh/src/peripherals/LpcUart.cpp @@ -8,6 +8,8 @@ #include #include #include "LpcUart.h" +#include "FreeRTOS.h" +#include "task.h" /* shoh: Important differences * We don't have movable pins -> not needed. @@ -126,6 +128,8 @@ LpcUart::LpcUart(const LpcUartConfig &cfg) { uart = cfg.pUART; // set the actual value after validity checking + //Not that straightforward. + //But will work for uart1, kind of... if(cfg.tx.port >= 0) { Chip_IOCON_PinMuxSet(LPC_IOCON, cfg.tx.port, cfg.tx.pin, (IOCON_FUNC4 | IOCON_MODE_INACT | IOCON_DIGMODE_EN)); } diff --git a/source/shoh/src/peripherals/networking/esp8266_socket.c b/source/shoh/src/peripherals/networking/esp8266_socket.c new file mode 100644 index 0000000..138d723 --- /dev/null +++ b/source/shoh/src/peripherals/networking/esp8266_socket.c @@ -0,0 +1,808 @@ +/* ======================================== + * + * Copyright YOUR COMPANY, THE YEAR + * All Rights Reserved + * UNPUBLISHED, LICENSED SOFTWARE. + * + * CONFIDENTIAL AND PROPRIETARY INFORMATION + * WHICH IS THE PROPERTY OF your company. + * + * ======================================== +*/ +#include +#include +#include +#include +#include + +#include "ring_buffer.h" + +#include "esp8266_socket.h" + +#include "serial_port.h" + +#include "FreeRTOS.h" +#include "task.h" + +typedef int EspSocket_t; + +static inline uint32_t get_ticks(void) { + return xTaskGetTickCount(); +} + +#define I_DONT_USE(x) (void) x +#define DEBUGP( ... ) printf( __VA_ARGS__ ) + +// macro for changing state. Correct operation requires that ctx is a pointer to state machine instance (see state template) +#define TRAN(st) ctx->next_state = st + +typedef enum eventTypes { eEnter, eExit, eTick, eReceive, eConnect, eDisconnect, eSend } EventType; + +typedef struct event_ { + EventType ev; // event type (= what happened) + // we could add additional data +} event; + +static const event evEnter = { eEnter }; +static const event evExit = { eExit }; + + +typedef struct smi_ smi; + +typedef void (*smf)(smi *, const event *); // prototype of state handler function pointer + +#define EVQ_SIZE 32 + +#define SMI_BUFSIZE 80 +#define RC_NOT_AVAILABLE -1 +#define RC_OK 0 +#define RC_ERROR 1 + +struct smi_ { + smf state; // current state (function pointer) + smf next_state; // next state (function pointer) + RINGBUFF_T EspEventQ; + event evq_buf[EVQ_SIZE]; + int timer; + int count; + int pos; + char buffer[SMI_BUFSIZE]; + char ssid[32]; // SSID + char pwd[32]; // password + char sa_data[32]; // ip address + char sa_port[14]; // port number (string) +}; + +static void stInit(smi *ctx, const event *e); +static void stEchoOff(smi *ctx, const event *e); +static void stStationModeCheck(smi *ctx, const event *e); +static void stStationModeSet(smi *ctx, const event *e); +static void stConnectAP(smi *ctx, const event *e); +static void stReady(smi *ctx, const event *e); +static void stConnectTCP(smi *ctx, const event *e); +static void stConnected(smi *ctx, const event *e); +static void stCloseTCP(smi *ctx, const event *e); +static void stPassthrough(smi *ctx, const event *e); +static void stPassthroughOK(smi *ctx, const event *e); +static void stAT(smi *ctx, const event *e); +static void stCommandMode(smi *ctx, const event *e); +static int cur_state(); + +static void EspSocketRun(smi *ctx); + + + +smi EspSocketInstance; + +static void port2str(int i, char *str) +{ + int m = 100000; + i %= m; // limit integer size to max 5 digits. + while(i / m == 0) m/=10; + while(m > 0) { + *str++ = '0' + i / m; + i %= m; + m /= 10; + } + *str='\0'; +} + +void smi_init(smi *ctx) +{ + serial_init(ctx); + memset(ctx, 0, sizeof(smi)); + ctx->state = stInit; + ctx->next_state = stInit; + RingBuffer_Init(&ctx->EspEventQ, ctx->evq_buf, sizeof(event), EVQ_SIZE); + + ctx->state(ctx, &evEnter); // enter initial state +} + + +int esp_socket(const char *ssid, const char *password) +{ + smi_init(&EspSocketInstance); + + + strncpy(EspSocketInstance.ssid, ssid, 32); + strncpy(EspSocketInstance.pwd, password, 32); + + + while(EspSocketInstance.state != stReady) { + //printf("[socket]: Current state %d\r\n", cur_state()); + // run esp task and run ticks + EspSocketRun(&EspSocketInstance); + } + + return 0; +} + +int cur_state() +{ + int st = -1; + if (EspSocketInstance.state == stInit ) + st = 0; + else if (EspSocketInstance.state == stEchoOff ) + st = 1; + else if (EspSocketInstance.state == stStationModeCheck ) + st = 2; + else if (EspSocketInstance.state == stStationModeSet ) + st = 3; + else if (EspSocketInstance.state == stConnectAP ) + st = 4; + else if (EspSocketInstance.state == stReady ) + st = 5; + else if (EspSocketInstance.state == stConnectTCP ) + st = 6; + else if (EspSocketInstance.state == stConnected ) + st = 7; + else if (EspSocketInstance.state == stCloseTCP ) + st = 8; + else if (EspSocketInstance.state == stPassthrough ) + st = 9; + else if (EspSocketInstance.state == stPassthroughOK ) + st = 10; + else if (EspSocketInstance.state == stAT ) + st = 11; + else if (EspSocketInstance.state == stCommandMode ) + st = 12; + return st; +} + +int esp_connect(int sockfd, const char *addr, int port) +{ + I_DONT_USE(sockfd); + + strncpy(EspSocketInstance.sa_data,addr,sizeof(EspSocketInstance.sa_data)-1); + EspSocketInstance.sa_data[sizeof(EspSocketInstance.sa_data)-1] = '\0'; + port2str(port, EspSocketInstance.sa_port); + + const event e = { eConnect }; + + RingBuffer_Insert(&EspSocketInstance.EspEventQ,&e); + + int rc = 0; + + while(EspSocketInstance.state != stConnected) { + // run esp task and run ticks + EspSocketRun(&EspSocketInstance); + } + + return rc; +} + +int esp_read(int sockfd, void *data, int length) +{ + I_DONT_USE(sockfd); + int count = 0; + + if(EspSocketInstance.state == stConnected) { +#if 0 + DEBUGP("[rd=%d]\r\n", length); + // read data + while(count < length && serial_get_char(&EspSocketInstance, data)) { + //char c = *((unsigned char *)data); + //DEBUGP("[%02X %c]\r\n", c , isprint(c) ? c : '.'); + ++count; + ++data; + } +#else + count = serial_read_buf(&EspSocketInstance, data, length); +#endif + } + + return count; +} + +int esp_write(int sockfd, const void *data, int length) +{ + I_DONT_USE(sockfd); + + if(EspSocketInstance.state == stConnected) { + // write data + serial_write_buf(&EspSocketInstance, data, length); + } + + return length; +} + +int esp_close(int sockfd) +{ + return esp_shutdown(sockfd, -1); +} + +int esp_shutdown(int sockfd, int how) +{ + I_DONT_USE(sockfd); + I_DONT_USE(how); + const event e = { eDisconnect }; + + RingBuffer_Insert(&EspSocketInstance.EspEventQ,&e); + while(EspSocketInstance.state != stReady) { + // run esp task and run ticks + EspSocketRun(&EspSocketInstance); + } + + return 0; +} + +int esp_peek(int sockfd) +{ + int cnt = 0; + if(EspSocketInstance.state == stConnected) { + cnt = serial_peek(&EspSocketInstance); + } + return cnt; +} + + +#if 0 +/* this is state template */ +void stStateTemplate(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + break; + case eExit: + break; + case eTick: + break; + case eReceive: + break; + default: + break; + } +} +#endif + +void init_counters(smi *ctx) { + ctx->count = 0; + ctx->pos = 0; + ctx->timer = 0; +} + +/* Read and store characters upto specified length. + * Returns true when specified amount of characters have been accumulated. */ +void sm_flush(smi *ctx) +{ + //DEBUGP("flush: %d\n", (int)xSerialRxWaiting(ctx->ComPort)); + while(serial_get_char(ctx, ctx->buffer)); +} + + +/* Read and store characters upto specified length. + * Returns true when specified amount of characters have been accumulated. */ +bool sm_read_buffer(smi *ctx, int count) +{ + while(ctx->pos < (SMI_BUFSIZE - 1) && ctx->pos < count && serial_get_char(ctx, ctx->buffer + ctx->pos)) { + //putchar(ctx->buffer[ctx->pos]); // debugging + ++ctx->pos; + } + return (ctx->pos >= count); +} + + +/* Read an integer. + * Consumes characters until a non-nondigit is received. The nondigit is also consumed. */ +bool sm_read_int(smi *ctx, int *value) +{ + bool result = false; + while(ctx->pos < (SMI_BUFSIZE - 1) && serial_get_char(ctx, ctx->buffer + ctx->pos)) { + if(!isdigit((int)ctx->buffer[ctx->pos])) { + ctx->buffer[ctx->pos] = '\0'; + *value = atoi(ctx->buffer); + result = true; + break; + } + else { + ++ctx->pos; + } + } + return result; +} + + + +/* Read and store data until one of the specified strings is received. + * The matched string is also included in the data .*/ +int sm_read_until(smi *ctx, const char **p) +{ + int result = RC_NOT_AVAILABLE; + while(result < 0 && ctx->pos < (SMI_BUFSIZE - 1) && serial_get_char(ctx, ctx->buffer + ctx->pos)) { + ++ctx->pos; + ctx->buffer[ctx->pos] = '\0'; + for(int i = 0; result < 0 && p[i] != NULL; ++i) { + if(strstr(ctx->buffer, p[i]) != NULL) { + result = i; + } + } + } + return result; + +} + +/* read and store data until result is received */ +int sm_read_result(smi *ctx) +{ + static const char *result_list[] = { "OK\r\n", "ERROR\r\n", NULL }; + return sm_read_until(ctx, result_list); +} + +/* read and consume characters until specified string occurs */ +bool sm_wait_for(smi *ctx, const char *p) +{ + bool result = false; + int len = strlen(p); + + while(sm_read_buffer(ctx, len)) { + ctx->buffer[ctx->pos] = '\0'; + if(strstr(ctx->buffer, p) != NULL) { + result = true; + break; + } + else { + memmove(ctx->buffer, ctx->buffer + 1, ctx->pos); + --ctx->pos; + } + } + return result; +} + +static void stInit(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stInit\r\n"); + sm_flush(ctx); + init_counters(ctx); + serial_write_str(ctx, "AT\r\n"); + break; + case eExit: + break; + case eTick: + ++ctx->timer; + //if(ctx->timer == 2) DEBUGP("[%s]\r\n", ctx->buffer); + if(ctx->timer >= 5) { + ctx->timer = 0; + ++ctx->count; + if(ctx->count < 2) { + serial_write_str(ctx, "AT\r\n"); + } + else { + DEBUGP("Error: Module not responding\r\n"); + TRAN(stAT); + } + } + break; + case eReceive: + if(sm_wait_for(ctx, "OK\r\n")) { + TRAN(stEchoOff); + } + break; + default: + break; + } +} + +static void stAT(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stAT\r\n"); + init_counters(ctx); + break; + case eExit: + break; + case eTick: + ++ctx->timer; + if(ctx->timer == 5) serial_write_str(ctx, "+++"); + if(ctx->timer == 15) TRAN(stInit); + break; + case eReceive: + break; + default: + break; + } +} + +static void stEchoOff(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stEchoOff\r\n"); + sm_flush(ctx); + init_counters(ctx); + serial_write_str(ctx, "ATE0\r\n"); + break; + case eExit: + break; + case eTick: + ++ctx->timer; + if(ctx->timer >= 10) { + ++ctx->count; + if(ctx->count < 3) { + serial_write_str(ctx, "ATE0\r\n"); + } + else { + DEBUGP("Error: setting local echo off failed\r\n"); + TRAN(stInit); + } + } + break; + case eReceive: + if(sm_wait_for(ctx, "OK\r\n")) { + TRAN(stStationModeCheck); + } + break; + default: + break; + } +} + + +static void stStationModeCheck(smi *ctx, const event *e) +{ + int rc = -1; + switch(e->ev) { + case eEnter: + DEBUGP("stStationModeCheck\r\n"); + init_counters(ctx); + serial_write_str(ctx, "AT+CWMODE_CUR?\r\n"); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + rc = sm_read_result(ctx); + if(rc == RC_OK) { + //DEBUGP("%d: %s", rc, ctx->buffer); + if(strstr(ctx->buffer, "+CWMODE_CUR:1\r\n") != NULL) { + TRAN(stConnectAP); + } + else { + TRAN(stStationModeSet); + } + } + else if(rc == RC_ERROR) { + } + break; + default: + break; + } +} + + +static void stStationModeSet(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stStationModeSet\r\n"); + init_counters(ctx); + serial_write_str(ctx, "AT+CWMODE_CUR=1\r\n"); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + if(sm_wait_for(ctx, "OK\r\n")) { + TRAN(stStationModeCheck); + } + break; + default: + break; + } +} + +static void connect_ssid(smi *ctx) +{ + serial_write_str(ctx, "AT+CWJAP_CUR=\""); + serial_write_str(ctx, ctx->ssid); + serial_write_str(ctx, "\",\""); + serial_write_str(ctx, ctx->pwd); + serial_write_str(ctx, "\"\r\n"); +} + +static void stConnectAP(smi *ctx, const event *e) +{ + int rc; + switch(e->ev) { + case eEnter: + DEBUGP("stConnectAP\r\n"); + init_counters(ctx); + break; + case eExit: + break; + case eTick: + // may take upto 7 seconds. do we need a timeout? + ++ctx->timer; + if(ctx->timer == 1) { + connect_ssid(ctx); + } + if(ctx->timer >= 70) { + ctx->timer = 0; + } + break; + case eReceive: + rc = sm_read_result(ctx); + if(rc == RC_OK) { + //DEBUGP("%d: %s", rc, ctx->buffer); + TRAN(stReady); + } + else if(rc == RC_ERROR) { + // failed: what to do now? + } + break; + default: + break; + } +} + + +static void stReady(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stReady\r\n"); + init_counters(ctx); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + break; + case eConnect: + TRAN(stConnectTCP); + break; + default: + break; + } + +} + + + +static void connect_tcp(smi *ctx) +{ + serial_write_str(ctx, "AT+CIPSTART=\"TCP\",\""); + serial_write_str(ctx, ctx->sa_data); + serial_write_str(ctx, "\","); + serial_write_str(ctx, ctx->sa_port); + serial_write_str(ctx, "\r\n"); +} + +static void stConnectTCP(smi *ctx, const event *e) +{ + int rc; + switch(e->ev) { + case eEnter: + DEBUGP("stConnectTCP\r\n"); + init_counters(ctx); + connect_tcp(ctx); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + rc = sm_read_result(ctx); + if(rc == RC_OK) { + //DEBUGP("%d: %s", rc, ctx->buffer); + if(strstr(ctx->buffer, "CONNECT\r\n") != NULL) { + TRAN(stPassthrough); + } + else { + // what else can we get with OK?? + } + } + else if(rc == RC_ERROR) { + // failed: what to do now? + DEBUGP("Connect failed\r\n"); + connect_tcp(ctx); + } + break; + default: + break; + } +} + + +static void stPassthrough(smi *ctx, const event *e) +{ + int rc; + switch(e->ev) { + case eEnter: + DEBUGP("stPassthrough\r\n"); + init_counters(ctx); + serial_write_str(ctx, "AT+CIPMODE=1\r\n"); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + rc = sm_read_result(ctx); + if(rc == RC_OK) { + TRAN(stPassthroughOK); + } + else if(rc == RC_ERROR) { + // failed: what to do now? + } + break; + default: + break; + } + +} + +static void stPassthroughOK(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stPassthroughOK\r\n"); + init_counters(ctx); + serial_write_str(ctx, "AT+CIPSEND\r\n"); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + if(sm_wait_for(ctx, ">")) { + TRAN(stConnected); + } + break; + default: + break; + } + +} + + +static void stConnected(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stConnected\r\n"); + init_counters(ctx); + break; + case eExit: + break; + case eTick: + break; + case eReceive: + break; + case eDisconnect: + TRAN(stCommandMode); + break; + default: + break; + } + +} + + +static void stCommandMode(smi *ctx, const event *e) +{ + switch(e->ev) { + case eEnter: + DEBUGP("stCommandMode\r\n"); + init_counters(ctx); + break; + case eExit: + break; + case eTick: + ++ctx->timer; + if(ctx->timer == 10) serial_write_str(ctx, "+++"); + if(ctx->timer == 25) TRAN(stCloseTCP); + break; + case eReceive: + break; + default: + break; + } +} + + +static void stCloseTCP(smi *ctx, const event *e) +{ + int rc = -1; + switch(e->ev) { + case eEnter: + DEBUGP("stCloseTCP\r\n"); + init_counters(ctx); + serial_write_str(ctx, "AT+CIPMODE=0\r\n");; + break; + case eReceive: + rc = sm_read_result(ctx); + if(rc == RC_OK) { + if(strstr(ctx->buffer, "CLOSED") != NULL) { + TRAN(stReady); + } + else { + init_counters(ctx); + serial_write_str(ctx, "AT+CIPCLOSE\r\n");; + } + } + else if(rc == RC_ERROR) { + } + break; + case eExit: + break; + case eTick: + ++ctx->timer; + if(ctx->timer == 25) TRAN(stCommandMode); + break; + default: + break; + } +} + + + +static void dispatch_event(smi *ctx, const event *e) +{ + ctx->state(ctx, e); // dispatch event to current state + if(ctx->state != ctx->next_state) { // check if state was changed + ctx->state(ctx, &evExit); // exit old state (cleanup) + ctx->state = ctx->next_state; // change state + ctx->state(ctx, &evEnter); // enter new state + } +} + + + +/** + * Receive events from queue and dispatch them to state machine + */ +static void EspSocketRun(smi *ctx) +{ + event e; + + static uint32_t old = 0 ; + uint32_t now = 0 ; + + now = get_ticks()/100; + if(now != old) { + const event tick = { eTick }; + old = now; + // send ESP tick + RingBuffer_Insert(&ctx->EspEventQ, &tick); + } + + if(serial_peek(ctx)) { + const event rcv = { eReceive }; + RingBuffer_Insert(&ctx->EspEventQ, &rcv); + } + + // read queue + while (RingBuffer_Pop(&ctx->EspEventQ,&e)) { + dispatch_event(ctx, &e); // dispatch event to current state + } +} + + + +/* [] END OF FILE */ diff --git a/source/shoh/src/peripherals/networking/esp8266_socket.h b/source/shoh/src/peripherals/networking/esp8266_socket.h new file mode 100644 index 0000000..9a379b4 --- /dev/null +++ b/source/shoh/src/peripherals/networking/esp8266_socket.h @@ -0,0 +1,21 @@ +#ifndef ESP8266_H_ +#define ESP8266_H_ + +#ifdef __cplusplus +extern "C" { +#endif + + +int esp_socket(const char *ssid, const char *password) ; +int esp_connect(int sockfd, const char *addr, int port); +int esp_read(int sockfd, void *data, int length); +int esp_write(int sockfd, const void *data, int length); +int esp_close(int sockfd); +int esp_shutdown(int sockfd, int how); +int esp_peek(int sockfd); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/source/shoh/src/peripherals/networking/serial_port.cpp b/source/shoh/src/peripherals/networking/serial_port.cpp new file mode 100644 index 0000000..562d772 --- /dev/null +++ b/source/shoh/src/peripherals/networking/serial_port.cpp @@ -0,0 +1,56 @@ +/* + * serial_port.cpp + * + * Created on: 25.8.2021 + * Author: keijo + */ +#include "LpcUart.h" +#include "serial_port.h" + +#ifdef __cplusplus +extern "C" { +#endif + +static LpcUart *EspUart; + +void serial_init(void *ctx) +{ + if(EspUart == nullptr) { + LpcPinMap none = {-1, -1}; // unused pin has negative values in it + LpcPinMap txpin_esp = { 0, 14 }; // transmit pin + LpcPinMap rxpin_esp = { 0, 13 }; // receive pin + LpcUartConfig cfg = { LPC_USART1, 115200, UARTN_CFG_DATALEN_8 | UARTN_CFG_PARITY_NONE | UARTN_CFG_STOPLEN_1, false, txpin_esp, rxpin_esp, none, none }; + + EspUart = new LpcUart(cfg); + } +} + +void serial_write_buf(void *ctx, const char *buf, int len) +{ + EspUart->write(buf, len); +} + +void serial_write_str(void *ctx, const char *s) +{ + EspUart->write(s); +} + +int serial_read_buf(void *ctx, char *buf, int len) +{ + return EspUart->read(buf, len, 20 * len); +} + +int serial_get_char(void *ctx, char *p) +{ + return EspUart->read(p, 1, 20);//EspUart->read(p, 1, 20); +} + +int serial_peek(void *ctx) +{ + return EspUart->peek(); +} + +#ifdef __cplusplus +} +#endif + diff --git a/source/shoh/src/peripherals/networking/serial_port.h b/source/shoh/src/peripherals/networking/serial_port.h new file mode 100644 index 0000000..3ce5628 --- /dev/null +++ b/source/shoh/src/peripherals/networking/serial_port.h @@ -0,0 +1,30 @@ +/* + * serial_port.h + * + * Created on: 25.8.2021 + * Author: keijo + */ + +#ifndef SERIAL_PORT_H_ +#define SERIAL_PORT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + + +void serial_init(void *ctx); +void serial_write_buf(void *ctx, const char *buf, int len); +void serial_write_str(void *ctx, const char *s); +int serial_read_buf(void *ctx, char *buf, int len); +int serial_get_char(void *ctx, char *p); +int serial_peek(void *ctx); + +#ifdef __cplusplus +} +#endif + + + + +#endif /* SERIAL_PORT_H_ */ diff --git a/source/shoh/src/threads/master/Master.cpp b/source/shoh/src/threads/master/Master.cpp index f834b94..e8c19ac 100644 --- a/source/shoh/src/threads/master/Master.cpp +++ b/source/shoh/src/threads/master/Master.cpp @@ -15,6 +15,7 @@ #include "UserInterface.h" #include "Temperature.h" #include "queue.h" +#include "esp8266_socket.h" static const char* rotary_direction[] = { @@ -75,6 +76,8 @@ void Master::HandleEventType(Event* e) void Master::taskFunction() { Event data(Event::Null, 0); + //int soc = esp_socket("SSID", "PASSWORD"); + //int stat = esp_connect(soc, "IP", 5000); for (;;) { if(!_qm->receive(ThreadCommon::QueueManager::master_event_all, &data, 10000)) @@ -85,6 +88,9 @@ void Master::taskFunction() { HandleEventType(&data); global_clock->updateClock(); + //LOG_WARNING("ESP socket status: %d", stat); + //if(stat == 0) + // stat = esp_connect(soc, "IP", 5000); } }