LailaTheElf/rcrf-wifi
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tx works

Browse Source
This commit is contained in:
Laila van Reenen 2024-08-15 17:43:48 +02:00
parent da75d0a2a0
commit ddba2120e1
Signed by: LailaTheElf
GPG Key ID: 1F4E6EE3E6DDF769
5 changed files with 146 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
rx_esp32/src/adc.c
View File

@ -70,8 +70,10 @@ bool adc_read(ADC_Data_t* out_data)
); );
if (ret == ESP_OK) if (ret == ESP_OK)
{ {
for (int i=0; i<6; i++) { for (uint8_t i=0; i<3; i++) {
out_data->value[i] = data[i].type2.data; for (uint8_t ii=0; ii<2; ii++) {
out_data->value[i][ii] = data[i*2 + ii].type2.data;
}
} }
} }
return (ret == ESP_OK); return (ret == ESP_OK);

2
rx_esp32/src/adc.h
View File

@ -5,7 +5,7 @@
#include <stdbool.h> #include <stdbool.h>
typedef struct { typedef struct {
uint16_t value[6]; uint16_t value[3][2];
} ADC_Data_t; } ADC_Data_t;
void adc_init(); void adc_init();

132
rx_esp32/src/main.c
View File

@ -19,7 +19,7 @@
#include "ws.h" #include "ws.h"
#if TARGET == TARGET_TX #if TARGET == TARGET_TX
#include "led.h" #include "led.h"
// #include "adc.h" #include "adc.h"
#endif #endif
bool volatile running = true; bool volatile running = true;
@ -116,9 +116,8 @@ void app_main() {
servo_init(); servo_init();
wifiInit(); wifiInit();
#if TARGET == TARGET_TX bool adc_inited = false;
// adc_init(); uint8_t adc_counter = 0;
#endif
running = true; running = true;
@ -189,49 +188,94 @@ void app_main() {
#if TARGET == TARGET_TX #if TARGET == TARGET_TX
case STATE_WIFI_CONNECTED: case STATE_WIFI_CONNECTED:
switch (WSStates[WS_conn_proc]) if (!adc_inited)
{ {
case STATE_WS_CONNECTING: adc_init();
ws_client[WS_conn_proc] = ws_connect(WS_URL, BoatId + WS_conn_proc, WS_DEV_CODE_CLIENT); adc_inited = true;
WSStates[WS_conn_proc] = STATE_WS_WAIT_CONNECTION; }
LOG_I("main: websocket %d: connecting", WS_conn_proc); ADC_Data_t adc_data;
break; bool adc_data_valid = false;
case STATE_WS_WAIT_CONNECTION: if (adc_read(&adc_data))
if (ws_client[WS_conn_proc]->connected) {
{ adc_counter++;
cli_ws_client[WS_conn_proc] = CLI_init((CLI_charOutFn)&charOut_ws[WS_conn_proc], cmdList); if (adc_counter >= 20)
cli_ws_client[WS_conn_proc].echo = false; {
MainState = STATE_IDEL; // LOG_D("ADC_DATA: %d, %d, %d, %d, %d, %d", adc_data.value[0], adc_data.value[1], adc_data.value[2], adc_data.value[3], adc_data.value[4], adc_data.value[5]);
LOG_I("main: websocket %d: connected", WS_conn_proc); adc_data_valid = true;
} adc_counter = 0;
break; }
case STATE_IDEL:
case STATE_DRIVING:
if (!ws_client[WS_conn_proc]->connected)
{
CLI_deinit(&cli_ws_client[WS_conn_proc]);
MainState = STATE_WS_WAIT_CONNECTION;
}
while ((charIn = ws_getchar(ws_client[WS_conn_proc])) != 255)
{
CLI_charIn(&cli_ws_client[WS_conn_proc], charIn);
}
ws_sendData(ws_client[WS_conn_proc]);
break;
} }
// WS_conn_proc++;
// if (WS_conn_proc >= 3)
// {
// WS_conn_proc = 0;
// }
// ADC_Data_t data; for (WS_conn_proc = 0; WS_conn_proc <3; WS_conn_proc++)
// if (adc_read(&data)) {
// { switch (WSStates[WS_conn_proc])
// LOG_D("ADC_DATA: %d, %d, %d, %d, %d, %d", data.value[0], data.value[1], data.value[2], data.value[3], data.value[4], data.value[5]); {
// } case STATE_WS_CONNECTING:
LOG_I("main: websocket %d: connecting", WS_conn_proc);
ws_client[WS_conn_proc] = ws_connect(WS_URL, BoatId + WS_conn_proc, WS_DEV_CODE_CLIENT);
WSStates[WS_conn_proc] = STATE_WS_WAIT_CONNECTION;
break;
case STATE_WS_WAIT_CONNECTION:
if (ws_client[WS_conn_proc]->connected)
{
LOG_I("main: websocket %d: connected", WS_conn_proc);
WSStates[WS_conn_proc] = STATE_IDEL;
}
break;
case STATE_IDEL:
if (adc_data_valid)
{
char cmd[100];
snprintf(&cmd[0], 100, "%04u;ctrl;%04u",
ws_client[WS_conn_proc]->id,
ws_client[WS_conn_proc]->id
);
ws_sendString(ws_client[WS_conn_proc], &cmd[0]);
}
case STATE_DRIVING:
if (!ws_client[WS_conn_proc]->connected)
{
WSStates[WS_conn_proc] = STATE_WS_WAIT_CONNECTION;
}
char ws_resp[10];
uint16_t ws_resp_len;
while ((ws_resp_len = ws_getstr(ws_client[WS_conn_proc], 10, &ws_resp[0])) > 0)
{
LOG_D("main: websocket %d: resv: %.*s", WS_conn_proc, ws_resp_len, ws_resp);
if (ws_resp_len == 4)
{
ws_resp[4] = 0;
if (strcmp(&ws_resp[0], "FAIL") == 0)
{
WSStates[WS_conn_proc] = STATE_IDEL;
}
}
else if (ws_resp_len == 2)
{
ws_resp[2] = 0;
if (strcmp(&ws_resp[0], "OK") == 0)
{
WSStates[WS_conn_proc] = STATE_DRIVING;
}
}
}
if ((WSStates[WS_conn_proc] == STATE_DRIVING) && adc_data_valid)
{
char ctrl_cmd[100];
snprintf(&ctrl_cmd[0], 100, "%04u;d;%u,%u",
ws_client[WS_conn_proc]->id,
adc_data.value[WS_conn_proc][0] >> 4,
adc_data.value[WS_conn_proc][1] >> 4
);
ws_sendString(ws_client[WS_conn_proc], &ctrl_cmd[0]);
}
break;
}
}
break; break;
#elif TARGET == TARGET_RX #elif TARGET == TARGET_RX
case STATE_WS_CONNECTING: case STATE_WS_CONNECTING:

53
rx_esp32/src/ws.c
View File

@ -16,12 +16,12 @@ static void ws_event_handler(void* handler_args, esp_event_base_t base, int32_t
{ {
case WEBSOCKET_EVENT_CONNECTED: case WEBSOCKET_EVENT_CONNECTED:
LOG_I("ws_event_handler: connected"); LOG_I("ws_event_handler: connected");
client->connected = true;
char str[100]; char str[100];
snprintf(&str[0], 100, "%04u;%04u;" BOAT_NAME "\n", client->id, client->dev_code); snprintf(&str[0], 100, "%04u;%04u;" BOAT_NAME "\n", client->id, client->dev_code);
esp_websocket_client_send_text(client->handle, &str[0], strlen(str), 1000); esp_websocket_client_send_text(client->handle, &str[0], strlen(str), 1000);
client->connected = true;
break; break;
case WEBSOCKET_EVENT_DISCONNECTED: case WEBSOCKET_EVENT_DISCONNECTED:
LOG_W("ws_event_handler: disconnected"); LOG_W("ws_event_handler: disconnected");
@ -105,6 +105,9 @@ static void ws_event_handler(void* handler_args, esp_event_base_t base, int32_t
LOG_E("ws_event_handler: captured as transport's socket errno %d", data->error_handle.esp_transport_sock_errno); LOG_E("ws_event_handler: captured as transport's socket errno %d", data->error_handle.esp_transport_sock_errno);
} }
break; break;
case WEBSOCKET_EVENT_BEFORE_CONNECT:
LOG_D("ws_event_handler: event before connect fired");
break;
default: default:
LOG_D("ws_event_handler: a unkown event happened: %d", event_id); LOG_D("ws_event_handler: a unkown event happened: %d", event_id);
break; break;
@ -138,7 +141,7 @@ int ws_getchar(ws_client_t client)
if (client->rxBuffer_rp != client->rxBuffer_wp) if (client->rxBuffer_rp != client->rxBuffer_wp)
{ {
out = client->rxBuffer[client->rxBuffer_rp]; out = client->rxBuffer[client->rxBuffer_rp];
client->rxBuffer_rp++; client->rxBuffer_rp++;
if (client->rxBuffer_rp >= WS_RX_BUFFER_LEN) if (client->rxBuffer_rp >= WS_RX_BUFFER_LEN)
{ {
client->rxBuffer_rp = 0; client->rxBuffer_rp = 0;
@ -147,6 +150,47 @@ int ws_getchar(ws_client_t client)
return out; return out;
} }
int ws_getstr(ws_client_t client, uint16_t max_size, char *str)
{
uint16_t out = 0;
if (client->rxBuffer_rp != client->rxBuffer_wp)
{
out = WS_RX_BUFFER_LEN + client->rxBuffer_wp - client->rxBuffer_rp;
if (out > WS_RX_BUFFER_LEN)
{
out -= WS_RX_BUFFER_LEN;
}
if (out > max_size)
{
out = max_size;
}
if (client->rxBuffer_rp < client->rxBuffer_wp)
{
memcpy(str, &client->rxBuffer[client->rxBuffer_rp], out);
}
else
{
uint16_t sizeUntilEnd = WS_RX_BUFFER_LEN - client->rxBuffer_rp;
if (sizeUntilEnd >= out)
{
memcpy(str, &client->rxBuffer[client->rxBuffer_rp], out);
}
else
{
memcpy(str, &client->rxBuffer[client->rxBuffer_rp], sizeUntilEnd);
memcpy(str + sizeUntilEnd, &client->rxBuffer[0], out - sizeUntilEnd);
}
}
client->rxBuffer_rp += out;
if (client->rxBuffer_rp >= WS_RX_BUFFER_LEN)
{
client->rxBuffer_rp -= WS_RX_BUFFER_LEN;
}
}
return out;
}
void ws_putchar(ws_client_t client, char c) void ws_putchar(ws_client_t client, char c)
{ {
if (client->txBuffer_wp == WS_TX_BUFFER_LEN) if (client->txBuffer_wp == WS_TX_BUFFER_LEN)
@ -173,3 +217,8 @@ void ws_sendData(ws_client_t client)
client->txBuffer_wp = 0; client->txBuffer_wp = 0;
} }
} }
void ws_sendString(ws_client_t client, const char *str)
{
esp_websocket_client_send_text(client->handle, str, strlen(str), 1000 * portTICK_PERIOD_MS);
}

2
rx_esp32/src/ws.h
View File

@ -25,7 +25,9 @@ typedef ws_client_data_t* ws_client_t;
ws_client_t ws_connect(char *url, uint16_t id, uint16_t dev_code); ws_client_t ws_connect(char *url, uint16_t id, uint16_t dev_code);
int ws_getchar(ws_client_t client); int ws_getchar(ws_client_t client);
int ws_getstr(ws_client_t client, uint16_t max_len, char *str);
void ws_putchar(ws_client_t client, char c); void ws_putchar(ws_client_t client, char c);
void ws_sendData(ws_client_t client); void ws_sendData(ws_client_t client);
void ws_sendString(ws_client_t client, const char *str);
#endif #endif