travisshears/balcony_weather_station
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

format and try to get tcp working

Browse source 
");
");
");
");
");
", WIFI_SSID);
", WIFI_SSID);
");
");
");
");
", readings_index);
");
");
");
", current_pms5003_reading.pm1);
", current_pms5003_reading.pm2_5);
", current_pms5003_reading.pm10);
");
",
",
");
");
");
");
");
",
",
");
");
");
");
");
");
");
");
", BACKEND_SERVER_IP, BACKEND_SERVER_PORT);
", err);
", err);
");
", status);
");
", status);
", len);
", len);
");
");
", err);
");
", write_err);
", err);
");
", write_err);
", output_err);
", output_err);
");
");
", err);
", err);
");
");
", p->tot_len);
", p->tot_len);
",
",
");
");
", err);
", err);
", config->server_ip, config->server_port);
", config->server_ip,
");
");
");
");
", config->server_ip);
", config->server_ip);
",
",
");
");
");
");
This commit is contained in:
Travis Shears 2025-12-26 16:27:58 +01:00
parent e0a5fef8fc
commit e2140561eb
Signed by: travisshears
GPG key ID: CB9BF1910F3F7469
2 changed files with 232 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

121
node1.c
View file

@ -1,23 +1,23 @@
#include "bme280.h"
#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "pms5003.h"
#include "pico/cyw43_arch.h"
#include "tcp_client.h"
#include <hardware/gpio.h>
#include <hardware/i2c.h>
#include <hardware/uart.h>
#include <hardware/watchdog.h>
#include <pico/time.h>
#include <pico/types.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <hardware/watchdog.h>
// 5 sec loop is for testing
#define LOOP_INTERVAL_MS 5000
// #define LOOP_INTERVAL_MS 5000
// #define LOOP_INTERVAL_MS 10000
// #define LOOP_INTERVAL_MS 30000
#define LOOP_INTERVAL_MS 30000
/**
* Balcony Weather Station Node 1
@ -41,22 +41,23 @@ void comms_led_blink() {
gpio_put(16, comms_led_state);
}
void comms_led_update() {
if (time_reached(comms_led_off_time)) {
comms_led_state = false;
gpio_put(16, comms_led_state);
}
if (time_reached(comms_led_off_time)) {
comms_led_state = false;
gpio_put(16, comms_led_state);
}
}
// Callback to reset the Pico after 24 hours
static bool cb_24h(__unused struct repeating_timer *t) {
printf("Restarting Pico after 24 hours...\n");
watchdog_enable(1, 1); // 1 ms timeout, reset on next loop
while (1) { tight_loop_contents(); } // Wait for reset
return false; // Not reached
printf("Restarting Pico after 24 hours...\n");
watchdog_enable(1, 1); // 1 ms timeout, reset on next loop
while (1) {
tight_loop_contents();
} // Wait for reset
return false; // Not reached
}
static tcp_client_config tcp_config;
static bool wifi_connected = false;
static pms5003_config pms_config;
static pms5003_reading current_pms5003_reading;
@ -67,22 +68,23 @@ static bme280_reading current_bem280_reading;
// Initialize WiFi connection
bool wifi_init(void) {
if (cyw43_arch_init()) {
printf("Failed to initialize CYW43\n");
return false;
}
printf("Initializing WiFi...\n");
if (cyw43_arch_init()) {
printf("Failed to initialize CYW43\n");
return false;
}
cyw43_arch_enable_sta_mode();
printf("Connecting to WiFi '%s'...\n", WIFI_SSID);
cyw43_arch_enable_sta_mode();
printf("Connecting to WiFi '%s'...\n", WIFI_SSID);
if (cyw43_arch_wifi_connect_timeout_ms(WIFI_SSID, WIFI_PASSWORD,
CYW43_AUTH_WPA2_AES_PSK, 30000)) {
printf("Failed to connect to WiFi\n");
return false;
}
if (cyw43_arch_wifi_connect_timeout_ms(WIFI_SSID, WIFI_PASSWORD,
CYW43_AUTH_WPA2_AES_PSK, 60000)) {
printf("Failed to connect to WiFi\n");
return false;
}
printf("WiFi connected successfully\n");
return true;
printf("WiFi connected successfully\n");
return true;
}
/**
@ -92,13 +94,10 @@ static bool cb_30(__unused struct repeating_timer *t) {
comms_led_blink();
printf("cb_30: %d\n", readings_index);
// Read BME280
printf("Making BME280 Reading\n");
current_bem280_reading = bme280_read(&bem_config);
if (readings_index == 2) {
printf("Warming up PMSS5003\n");
pms5003_warmup(&pms_config);
@ -112,10 +111,6 @@ static bool cb_30(__unused struct repeating_timer *t) {
if (readings_index == 6) {
printf("Finished reading PMSS5003\n");
current_pms5003_reading = pms5003_finish_reading(&pms_config);
// TODO: send data to backend server if WiFi is connected
// printf("PM1: %.2f\n", current_pms5003_reading.pm1);
// printf("PM2.5: %.2f\n", current_pms5003_reading.pm2_5);
// printf("PM10: %.2f\n", current_pms5003_reading.pm10);
}
readings_index++;
@ -123,44 +118,35 @@ static bool cb_30(__unused struct repeating_timer *t) {
readings_index = 0;
}
if (!wifi_connected) {
printf("WiFi not connected, skipping send\n");
return true;
}
char msg[256];
snprintf(msg, sizeof(msg),
"M001,%.2f,%.2f,%2f\n",
current_bem280_reading.temperature,
current_bem280_reading.pressure,
current_bem280_reading.humidity);
snprintf(msg, sizeof(msg), "M001,%.2f,%.2f,%2f\n",
current_bem280_reading.temperature, current_bem280_reading.pressure,
current_bem280_reading.humidity);
printf("Sending temperature, pressure, and humidity to backend server...\n");
printf("MSG: %s", msg);
bool success = tcp_client_send_message(&tcp_config, msg);
if (success) {
printf("✓ Data sent successfully\n");
comms_led_blink();
printf("✓ Data sent successfully\n");
comms_led_blink();
} else {
printf("✗ Failed to send data\n");
return false;
printf("✗ Failed to send data\n");
return false;
}
// send PM readings
if (readings_index == 6) {
snprintf(msg, sizeof(msg),
"M02,%.2f,%.2f,%2f\n",
current_pms5003_reading.pm1,
current_pms5003_reading.pm2_5,
current_pms5003_reading.pm10);
snprintf(msg, sizeof(msg), "M02,%.2f,%.2f,%2f\n",
current_pms5003_reading.pm1, current_pms5003_reading.pm2_5,
current_pms5003_reading.pm10);
printf("Sending particulate matter readings to backend server...\n");
printf("MSG: %s", msg);
bool success = tcp_client_send_message(&tcp_config, msg);
if (success) {
printf("✓ Data sent successfully\n");
comms_led_blink();
printf("✓ Data sent successfully\n");
comms_led_blink();
} else {
printf("✗ Failed to send data\n");
return false;
printf("✗ Failed to send data\n");
return false;
}
}
@ -170,34 +156,25 @@ static bool cb_30(__unused struct repeating_timer *t) {
int main() {
stdio_init_all();
watchdog_enable(60000, 1);
sleep_ms(2000); // Give time for USB serial
sleep_ms(2000); // Give time for USB serial
// Initialize communication LED
comms_led_init();
// Initialize WiFi
printf("Initializing WiFi...\n");
if (!wifi_init()) {
printf("WiFi initialization failed!\n");
panic("WiFi initialization failed!");
} else {
wifi_connected = true;
// Initialize TCP client
if (!tcp_client_init(&tcp_config, BACKEND_SERVER_IP,
BACKEND_SERVER_PORT, 10000)) {
printf("TCP client initialization failed\n");
panic("TCP client initialization failed!");
wifi_connected = false;
} else {
printf("TCP client ready: %s:%d\n", BACKEND_SERVER_IP, BACKEND_SERVER_PORT);
}
panic("WiFi initialization failed!");
}
if (!tcp_client_init(&tcp_config, BACKEND_SERVER_IP, BACKEND_SERVER_PORT,
20000)) {
panic("TCP client initialization failed!");
}
// Setup BME280
bme280_init(&bem_config, i2c1, 14, 15);
// Setup PMS5003
// pms5003_init(&pms_config, uart1, 20, 21, 18, 19);
pms5003_init(&pms_config, uart1, 20, 21, 18, 19);
struct repeating_timer timer_30;
add_repeating_timer_ms(LOOP_INTERVAL_MS, cb_30, NULL, &timer_30);

362
tcp_client.c
View file

@ -4,247 +4,251 @@
*/
#include "tcp_client.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/pbuf.h"
#include "lwip/tcp.h"
#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "pico/time.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define DEBUG_printf printf
#define MAX_RETRY_COUNT 3
typedef struct {
struct tcp_pcb *tcp_pcb;
ip_addr_t remote_addr;
uint16_t remote_port;
const char *message;
int message_len;
int sent_len;
bool complete;
bool success;
bool connected;
uint32_t timeout_ms;
absolute_time_t timeout_time;
struct tcp_pcb *tcp_pcb;
ip_addr_t remote_addr;
uint16_t remote_port;
const char *message;
int message_len;
int sent_len;
bool complete;
bool success;
bool connected;
uint32_t timeout_ms;
absolute_time_t timeout_time;
} tcp_client_state_t;
static err_t tcp_client_close(tcp_client_state_t *state) {
err_t err = ERR_OK;
if (state->tcp_pcb != NULL) {
tcp_arg(state->tcp_pcb, NULL);
tcp_poll(state->tcp_pcb, NULL, 0);
tcp_sent(state->tcp_pcb, NULL);
tcp_recv(state->tcp_pcb, NULL);
tcp_err(state->tcp_pcb, NULL);
err = tcp_close(state->tcp_pcb);
if (err != ERR_OK) {
DEBUG_printf("tcp_client: close failed %d, calling abort\n", err);
tcp_abort(state->tcp_pcb);
err = ERR_ABRT;
}
state->tcp_pcb = NULL;
err_t err = ERR_OK;
if (state->tcp_pcb != NULL) {
tcp_arg(state->tcp_pcb, NULL);
tcp_poll(state->tcp_pcb, NULL, 0);
tcp_sent(state->tcp_pcb, NULL);
tcp_recv(state->tcp_pcb, NULL);
tcp_err(state->tcp_pcb, NULL);
err = tcp_close(state->tcp_pcb);
if (err != ERR_OK) {
DEBUG_printf("tcp_client: close failed %d, calling abort\n", err);
tcp_abort(state->tcp_pcb);
err = ERR_ABRT;
}
return err;
state->tcp_pcb = NULL;
}
return err;
}
static err_t tcp_client_result(tcp_client_state_t *state, int status) {
if (status == 0) {
DEBUG_printf("tcp_client: send success\n");
state->success = true;
} else {
DEBUG_printf("tcp_client: send failed %d\n", status);
state->success = false;
}
state->complete = true;
return tcp_client_close(state);
if (status == 0) {
DEBUG_printf("tcp_client: send success\n");
state->success = true;
} else {
DEBUG_printf("tcp_client: send failed %d\n", status);
state->success = false;
}
state->complete = true;
return tcp_client_close(state);
}
static err_t tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) {
tcp_client_state_t *state = (tcp_client_state_t*)arg;
DEBUG_printf("tcp_client: sent %u bytes\n", len);
state->sent_len += len;
tcp_client_state_t *state = (tcp_client_state_t *)arg;
DEBUG_printf("tcp_client: sent %u bytes\n", len);
state->sent_len += len;
if (state->sent_len >= state->message_len) {
DEBUG_printf("tcp_client: message sent completely\n");
return tcp_client_result(state, 0);
}
if (state->sent_len >= state->message_len) {
DEBUG_printf("tcp_client: message sent completely\n");
return tcp_client_result(state, 0);
}
return ERR_OK;
return ERR_OK;
}
static err_t tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err) {
tcp_client_state_t *state = (tcp_client_state_t*)arg;
if (err != ERR_OK) {
DEBUG_printf("tcp_client: connect failed %d\n", err);
return tcp_client_result(state, err);
}
tcp_client_state_t *state = (tcp_client_state_t *)arg;
if (err != ERR_OK) {
DEBUG_printf("tcp_client: connect failed %d\n", err);
return tcp_client_result(state, err);
}
state->connected = true;
DEBUG_printf("tcp_client: connected, sending message\n");
state->connected = true;
DEBUG_printf("tcp_client: connected, sending message\n");
// Send the message
cyw43_arch_lwip_begin();
err_t write_err = tcp_write(tpcb, state->message, state->message_len, TCP_WRITE_FLAG_COPY);
if (write_err != ERR_OK) {
DEBUG_printf("tcp_client: failed to write data %d\n", write_err);
cyw43_arch_lwip_end();
return tcp_client_result(state, -1);
}
// Flush the data
err_t output_err = tcp_output(tpcb);
// Send the message
cyw43_arch_lwip_begin();
err_t write_err =
tcp_write(tpcb, state->message, state->message_len, TCP_WRITE_FLAG_COPY);
if (write_err != ERR_OK) {
DEBUG_printf("tcp_client: failed to write data %d\n", write_err);
cyw43_arch_lwip_end();
return tcp_client_result(state, -1);
}
if (output_err != ERR_OK) {
DEBUG_printf("tcp_client: failed to output data %d\n", output_err);
return tcp_client_result(state, -1);
}
// Flush the data
err_t output_err = tcp_output(tpcb);
cyw43_arch_lwip_end();
return ERR_OK;
if (output_err != ERR_OK) {
DEBUG_printf("tcp_client: failed to output data %d\n", output_err);
return tcp_client_result(state, -1);
}
return ERR_OK;
}
static err_t tcp_client_poll(void *arg, struct tcp_pcb *tpcb) {
tcp_client_state_t *state = (tcp_client_state_t*)arg;
DEBUG_printf("tcp_client: poll timeout\n");
return tcp_client_result(state, -1);
tcp_client_state_t *state = (tcp_client_state_t *)arg;
DEBUG_printf("tcp_client: poll timeout\n");
return tcp_client_result(state, -1);
}
static void tcp_client_err(void *arg, err_t err) {
tcp_client_state_t *state = (tcp_client_state_t*)arg;
if (err != ERR_ABRT) {
DEBUG_printf("tcp_client: error %d\n", err);
state->success = false;
state->complete = true;
}
tcp_client_state_t *state = (tcp_client_state_t *)arg;
if (err != ERR_ABRT) {
DEBUG_printf("tcp_client: error %d\n", err);
state->success = false;
state->complete = true;
}
}
static err_t tcp_client_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
tcp_client_state_t *state = (tcp_client_state_t*)arg;
static err_t tcp_client_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
err_t err) {
tcp_client_state_t *state = (tcp_client_state_t *)arg;
if (!p) {
DEBUG_printf("tcp_client: connection closed by server\n");
return tcp_client_result(state, 0);
}
if (!p) {
DEBUG_printf("tcp_client: connection closed by server\n");
return tcp_client_result(state, 0);
}
cyw43_arch_lwip_check();
cyw43_arch_lwip_check();
if (p->tot_len > 0) {
DEBUG_printf("tcp_client: received %d bytes (ignoring)\n", p->tot_len);
tcp_recved(tpcb, p->tot_len);
}
pbuf_free(p);
if (p->tot_len > 0) {
DEBUG_printf("tcp_client: received %d bytes (ignoring)\n", p->tot_len);
tcp_recved(tpcb, p->tot_len);
}
pbuf_free(p);
return ERR_OK;
return ERR_OK;
}
static bool tcp_client_open(tcp_client_state_t *state) {
DEBUG_printf("tcp_client: connecting to %s port %u\n",
ip4addr_ntoa(&state->remote_addr), state->remote_port);
DEBUG_printf("tcp_client: connecting to %s port %u\n",
ip4addr_ntoa(&state->remote_addr), state->remote_port);
state->tcp_pcb = tcp_new_ip_type(IP_GET_TYPE(&state->remote_addr));
if (!state->tcp_pcb) {
DEBUG_printf("tcp_client: failed to create pcb\n");
return false;
}
state->tcp_pcb = tcp_new_ip_type(IP_GET_TYPE(&state->remote_addr));
if (!state->tcp_pcb) {
DEBUG_printf("tcp_client: failed to create pcb\n");
return false;
}
tcp_arg(state->tcp_pcb, state);
tcp_poll(state->tcp_pcb, tcp_client_poll, 10);
tcp_sent(state->tcp_pcb, tcp_client_sent);
tcp_recv(state->tcp_pcb, tcp_client_recv);
tcp_err(state->tcp_pcb, tcp_client_err);
tcp_arg(state->tcp_pcb, state);
tcp_poll(state->tcp_pcb, tcp_client_poll, 10);
tcp_sent(state->tcp_pcb, tcp_client_sent);
tcp_recv(state->tcp_pcb, tcp_client_recv);
tcp_err(state->tcp_pcb, tcp_client_err);
state->sent_len = 0;
state->timeout_time = make_timeout_time_ms(state->timeout_ms);
state->sent_len = 0;
state->timeout_time = make_timeout_time_ms(state->timeout_ms);
cyw43_arch_lwip_begin();
err_t err = tcp_connect(state->tcp_pcb, &state->remote_addr,
state->remote_port, tcp_client_connected);
cyw43_arch_lwip_end();
cyw43_arch_lwip_begin();
err_t err = tcp_connect(state->tcp_pcb, &state->remote_addr,
state->remote_port, tcp_client_connected);
cyw43_arch_lwip_end();
if (err != ERR_OK) {
DEBUG_printf("tcp_client: tcp_connect failed %d\n", err);
return false;
}
if (err != ERR_OK) {
DEBUG_printf("tcp_client: tcp_connect failed %d\n", err);
return false;
}
return true;
return true;
}
bool tcp_client_init(tcp_client_config *config, const char *server_ip,
uint16_t server_port, uint32_t timeout_ms) {
if (!config || !server_ip) {
return false;
}
if (!config || !server_ip) {
return false;
}
strncpy(config->server_ip, server_ip, sizeof(config->server_ip) - 1);
config->server_ip[sizeof(config->server_ip) - 1] = '\0';
config->server_port = server_port;
config->timeout_ms = timeout_ms;
config->initialized = true;
config->internal_state = NULL;
strncpy(config->server_ip, server_ip, sizeof(config->server_ip) - 1);
config->server_ip[sizeof(config->server_ip) - 1] = '\0';
config->server_port = server_port;
config->timeout_ms = timeout_ms;
config->initialized = true;
config->internal_state = NULL;
DEBUG_printf("tcp_client: initialized for %s:%u\n", config->server_ip, config->server_port);
return true;
DEBUG_printf("tcp_client: initialized for %s:%u\n", config->server_ip,
config->server_port);
return true;
}
bool tcp_client_send_message(tcp_client_config *config, const char *message) {
if (!config || !config->initialized || !message) {
DEBUG_printf("tcp_client: invalid config or message\n");
return false;
}
if (!config || !config->initialized || !message) {
DEBUG_printf("tcp_client: invalid config or message\n");
return false;
}
tcp_client_state_t *state = calloc(1, sizeof(tcp_client_state_t));
if (!state) {
DEBUG_printf("tcp_client: failed to allocate state\n");
return false;
}
tcp_client_state_t *state = calloc(1, sizeof(tcp_client_state_t));
if (!state) {
DEBUG_printf("tcp_client: failed to allocate state\n");
return false;
}
// Convert IP address
if (!ip4addr_aton(config->server_ip, &state->remote_addr)) {
DEBUG_printf("tcp_client: invalid IP address %s\n", config->server_ip);
free(state);
return false;
}
state->remote_port = config->server_port;
state->message = message;
state->message_len = strlen(message);
state->timeout_ms = config->timeout_ms;
state->complete = false;
state->success = false;
state->connected = false;
DEBUG_printf("tcp_client: sending message (%d bytes): %s\n",
state->message_len, message);
if (!tcp_client_open(state)) {
DEBUG_printf("tcp_client: failed to open connection\n");
free(state);
return false;
}
// Wait for completion or timeout
while (!state->complete) {
if (time_reached(state->timeout_time)) {
DEBUG_printf("tcp_client: operation timed out\n");
tcp_client_close(state);
state->complete = true;
state->success = false;
break;
}
cyw43_arch_poll();
cyw43_arch_wait_for_work_until(make_timeout_time_ms(100));
}
bool success = state->success;
// Convert IP address
if (!ip4addr_aton(config->server_ip, &state->remote_addr)) {
DEBUG_printf("tcp_client: invalid IP address %s\n", config->server_ip);
free(state);
return false;
}
return success;
state->remote_port = config->server_port;
state->message = message;
state->message_len = strlen(message);
state->timeout_ms = config->timeout_ms;
state->complete = false;
state->success = false;
state->connected = false;
DEBUG_printf("tcp_client: sending message (%d bytes): %s\n",
state->message_len, message);
if (!tcp_client_open(state)) {
DEBUG_printf("tcp_client: failed to open connection\n");
free(state);
return false;
}
// Wait for completion or timeout
while (!state->complete) {
cyw43_arch_poll();
cyw43_arch_wait_for_work_until(make_timeout_time_ms(1000));
if (time_reached(state->timeout_time)) {
DEBUG_printf("tcp_client: operation timed out\n");
tcp_client_close(state);
state->complete = true;
state->success = false;
break;
}
}
bool success = state->success;
free(state);
return success;
}
void tcp_client_cleanup(tcp_client_config *config) {
if (config) {
config->initialized = false;
config->internal_state = NULL;
}
if (config) {
config->initialized = false;
config->internal_state = NULL;
}
}