Umber
/
ESP32
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial udp pacer work

This commit is contained in:
Bob 2025-12-10 14:13:51 -08:00
parent a5494da073
commit d4e9247845
4 changed files with 395 additions and 770 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
components/iperf/CMakeLists.txt
View File

@ -1,5 +1,8 @@
idf_component_register(
SRCS "iperf.c"
INCLUDE_DIRS "."
REQUIRES lwip esp_event
# Only if iperf.h needs types from these (unlikely based on your code):
REQUIRES lwip
# Internal implementation details only:
PRIV_REQUIRES esp_event esp_timer nvs_flash esp_netif esp_wifi
)

471
components/iperf/iperf.c
View File

@ -4,15 +4,61 @@
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_log.h"
#include "esp_err.h"
#include "esp_timer.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_wifi.h"
#include "iperf.h"
static const char *TAG = "iperf";
// --- LED STATE MANAGEMENT ---
typedef enum {
LED_OFF,
LED_BLUE_SOLID, // Monitor Mode
LED_RED_FLASH, // No WiFi
LED_AMBER_SOLID, // Connected, No IP
LED_GREEN_SOLID, // Got IP / Ready
LED_PURPLE_SOLID, // Transmitting
LED_PURPLE_FLASH // Socket Error
} led_state_t;
static led_state_t s_led_state = LED_RED_FLASH;
// --- Helper: Set Physical LED ---
static void iperf_set_physical_led(uint8_t r, uint8_t g, uint8_t b) {
// Implement hardware specific LED driver here
}
// --- LED Task ---
static void status_led_task(void *arg) {
bool toggle = false;
while (1) {
switch (s_led_state) {
case LED_BLUE_SOLID: iperf_set_physical_led(0, 0, 64); vTaskDelay(pdMS_TO_TICKS(500)); break;
case LED_RED_FLASH: iperf_set_physical_led(toggle ? 64 : 0, 0, 0); vTaskDelay(pdMS_TO_TICKS(250)); toggle = !toggle; break;
case LED_AMBER_SOLID: iperf_set_physical_led(32, 16, 0); vTaskDelay(pdMS_TO_TICKS(500)); break;
case LED_GREEN_SOLID: iperf_set_physical_led(0, 64, 0); vTaskDelay(pdMS_TO_TICKS(500)); break;
case LED_PURPLE_SOLID: iperf_set_physical_led(64, 0, 64); vTaskDelay(pdMS_TO_TICKS(200)); break;
case LED_PURPLE_FLASH: iperf_set_physical_led(toggle ? 64 : 0, 0, 64); vTaskDelay(pdMS_TO_TICKS(250)); toggle = !toggle; break;
default: iperf_set_physical_led(0, 0, 0); vTaskDelay(pdMS_TO_TICKS(500)); break;
}
}
}
// --- Synchronization ---
static EventGroupHandle_t s_iperf_event_group = NULL;
#define IPERF_IP_READY_BIT (1 << 0)
#define IPERF_STOP_REQ_BIT (1 << 1)
typedef struct {
iperf_cfg_t cfg;
bool finish;
@ -24,250 +70,203 @@ typedef struct {
static iperf_ctrl_t s_iperf_ctrl = {0};
static TaskHandle_t s_iperf_task_handle = NULL;
static esp_event_handler_instance_t instance_any_id;
static esp_event_handler_instance_t instance_got_ip;
static void socket_send(int sockfd, const uint8_t *buffer, int len)
// --- Network Event Handler ---
static void iperf_network_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
{
int actual_send = 0;
while (actual_send < len) {
int send_len = send(sockfd, buffer + actual_send, len - actual_send, 0);
if (send_len < 0) {
ESP_LOGE(TAG, "send failed: errno %d", errno);
break;
if (s_iperf_event_group == NULL) return;
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED) {
s_led_state = LED_AMBER_SOLID;
}
else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
xEventGroupSetBits(s_iperf_event_group, IPERF_IP_READY_BIT);
if (s_led_state != LED_PURPLE_SOLID && s_led_state != LED_PURPLE_FLASH) {
s_led_state = LED_GREEN_SOLID;
}
actual_send += send_len;
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
xEventGroupClearBits(s_iperf_event_group, IPERF_IP_READY_BIT);
s_led_state = LED_RED_FLASH;
}
}
static int socket_recv(int sockfd, uint8_t *buffer, int len, TickType_t timeout_ticks)
{
struct timeval timeout;
timeout.tv_sec = timeout_ticks / configTICK_RATE_HZ;
timeout.tv_usec = (timeout_ticks % configTICK_RATE_HZ) * (1000000 / configTICK_RATE_HZ);
// --- Wait for IP ---
static bool iperf_wait_for_ip(void) {
if (!s_iperf_event_group) s_iperf_event_group = xEventGroupCreate();
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
ESP_LOGE(TAG, "setsockopt failed: errno %d", errno);
return -1;
}
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &iperf_network_event_handler, NULL, &instance_any_id));
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &iperf_network_event_handler, NULL, &instance_got_ip));
return recv(sockfd, buffer, len, 0);
}
static esp_err_t iperf_start_tcp_server(iperf_ctrl_t *ctrl)
{
struct sockaddr_in addr;
int listen_sock;
int opt = 1;
listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_sock < 0) {
ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
return ESP_FAIL;
}
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
addr.sin_family = AF_INET;
addr.sin_port = htons(ctrl->cfg.sport);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
ESP_LOGE(TAG, "Socket bind failed: errno %d", errno);
close(listen_sock);
return ESP_FAIL;
}
if (listen(listen_sock, 5) != 0) {
ESP_LOGE(TAG, "Socket listen failed: errno %d", errno);
close(listen_sock);
return ESP_FAIL;
}
ESP_LOGI(TAG, "TCP server listening on port %d", ctrl->cfg.sport);
while (!ctrl->finish) {
struct sockaddr_in client_addr;
socklen_t addr_len = sizeof(client_addr);
int client_sock = accept(listen_sock, (struct sockaddr *)&client_addr, &addr_len);
if (client_sock < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
continue;
esp_netif_t *netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
if (netif) {
esp_netif_ip_info_t ip_info;
if (esp_netif_get_ip_info(netif, &ip_info) == ESP_OK) {
if (ip_info.ip.addr != 0) {
xEventGroupSetBits(s_iperf_event_group, IPERF_IP_READY_BIT);
s_led_state = LED_GREEN_SOLID;
} else {
wifi_ap_record_t ap_info;
if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) s_led_state = LED_AMBER_SOLID;
}
ESP_LOGE(TAG, "Accept failed: errno %d", errno);
break;
}
ESP_LOGI(TAG, "Client connected from %s", inet_ntoa(client_addr.sin_addr));
uint64_t total_len = 0;
int recv_len;
while (!ctrl->finish) {
recv_len = socket_recv(client_sock, ctrl->buffer, ctrl->buffer_len,
pdMS_TO_TICKS(IPERF_SOCKET_RX_TIMEOUT * 1000));
if (recv_len <= 0) {
break;
}
total_len += recv_len;
}
ESP_LOGI(TAG, "TCP server received: %" PRIu64 " bytes", total_len);
close(client_sock);
}
close(listen_sock);
return ESP_OK;
ESP_LOGI(TAG, "Waiting for IP address...");
EventBits_t bits = xEventGroupWaitBits(s_iperf_event_group, IPERF_IP_READY_BIT | IPERF_STOP_REQ_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
esp_event_handler_instance_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, instance_any_id);
esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, instance_got_ip);
if (bits & IPERF_STOP_REQ_BIT) return false;
return true;
}
static esp_err_t iperf_start_tcp_client(iperf_ctrl_t *ctrl)
{
struct sockaddr_in addr;
int sockfd;
// --- Read NVS ---
static void iperf_read_nvs_config(iperf_cfg_t *cfg) {
nvs_handle_t my_handle;
esp_err_t err = nvs_open("storage", NVS_READONLY, &my_handle);
if (err != ESP_OK) return;
size_t required_size;
uint32_t val = 0;
sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sockfd < 0) {
ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
return ESP_FAIL;
if (nvs_get_u32(my_handle, NVS_KEY_IPERF_RATE, &val) == ESP_OK && val > 0) cfg->bw_lim = val;
if (nvs_get_u32(my_handle, NVS_KEY_IPERF_BURST, &val) == ESP_OK && val > 0) cfg->burst_count = val; else cfg->burst_count = 1;
if (nvs_get_u32(my_handle, NVS_KEY_IPERF_LEN, &val) == ESP_OK && val > 0) cfg->send_len = val; else cfg->send_len = IPERF_UDP_TX_LEN;
if (nvs_get_str(my_handle, NVS_KEY_IPERF_DST_IP, NULL, &required_size) == ESP_OK) {
char *ip_str = malloc(required_size);
if (ip_str) { nvs_get_str(my_handle, NVS_KEY_IPERF_DST_IP, ip_str, &required_size); cfg->dip = inet_addr(ip_str); free(ip_str); }
}
addr.sin_family = AF_INET;
addr.sin_port = htons(ctrl->cfg.dport);
addr.sin_addr.s_addr = htonl(ctrl->cfg.dip);
ESP_LOGI(TAG, "Connecting to TCP server...");
if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
ESP_LOGE(TAG, "Socket connect failed: errno %d", errno);
close(sockfd);
return ESP_FAIL;
}
ESP_LOGI(TAG, "Connected to TCP server");
uint64_t total_len = 0;
uint32_t start_time = xTaskGetTickCount();
uint32_t end_time = start_time + pdMS_TO_TICKS(ctrl->cfg.time * 1000);
while (!ctrl->finish && xTaskGetTickCount() < end_time) {
socket_send(sockfd, ctrl->buffer, ctrl->buffer_len);
total_len += ctrl->buffer_len;
}
uint32_t actual_time = (xTaskGetTickCount() - start_time) / configTICK_RATE_HZ;
float bandwidth = (float)total_len * 8 / actual_time / 1000000; // Mbps
ESP_LOGI(TAG, "TCP client sent: %" PRIu64 " bytes in %" PRIu32 " seconds (%.2f Mbps)",
total_len, actual_time, bandwidth);
close(sockfd);
return ESP_OK;
}
static esp_err_t iperf_start_udp_server(iperf_ctrl_t *ctrl)
{
struct sockaddr_in addr;
int sockfd;
int opt = 1;
sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sockfd < 0) {
ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
return ESP_FAIL;
}
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
addr.sin_family = AF_INET;
addr.sin_port = htons(ctrl->cfg.sport);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
ESP_LOGE(TAG, "Socket bind failed: errno %d", errno);
close(sockfd);
return ESP_FAIL;
}
ESP_LOGI(TAG, "UDP server listening on port %d", ctrl->cfg.sport);
uint64_t total_len = 0;
uint32_t packet_count = 0;
int32_t last_id = -1;
uint32_t lost_packets = 0;
while (!ctrl->finish) {
int recv_len = socket_recv(sockfd, ctrl->buffer, ctrl->buffer_len,
pdMS_TO_TICKS(IPERF_SOCKET_RX_TIMEOUT * 1000));
if (recv_len <= 0) {
continue;
}
total_len += recv_len;
packet_count++;
// Check for lost packets using UDP header
if (recv_len >= sizeof(udp_datagram)) {
udp_datagram *header = (udp_datagram *)ctrl->buffer;
int32_t current_id = ntohl(header->id);
if (last_id >= 0 && current_id > last_id + 1) {
lost_packets += (current_id - last_id - 1);
}
last_id = current_id;
if (nvs_get_str(my_handle, NVS_KEY_IPERF_ROLE, NULL, &required_size) == ESP_OK) {
char *role = malloc(required_size);
if (role) {
nvs_get_str(my_handle, NVS_KEY_IPERF_ROLE, role, &required_size);
if (strcmp(role, "SERVER") == 0) { cfg->flag &= ~IPERF_FLAG_CLIENT; cfg->flag |= IPERF_FLAG_SERVER; }
else { cfg->flag &= ~IPERF_FLAG_SERVER; cfg->flag |= IPERF_FLAG_CLIENT; }
free(role);
}
}
float loss_rate = packet_count > 0 ? (float)lost_packets * 100 / packet_count : 0;
ESP_LOGI(TAG, "UDP server received: %" PRIu64 " bytes, %" PRIu32 " packets, %" PRIu32 " lost (%.2f%%)",
total_len, packet_count, lost_packets, loss_rate);
close(sockfd);
return ESP_OK;
if (nvs_get_str(my_handle, NVS_KEY_IPERF_PROTO, NULL, &required_size) == ESP_OK) {
char *proto = malloc(required_size);
if (proto) {
nvs_get_str(my_handle, NVS_KEY_IPERF_PROTO, proto, &required_size);
if (strcmp(proto, "TCP") == 0) { cfg->flag &= ~IPERF_FLAG_UDP; cfg->flag |= IPERF_FLAG_TCP; }
else { cfg->flag &= ~IPERF_FLAG_TCP; cfg->flag |= IPERF_FLAG_UDP; }
free(proto);
}
}
nvs_close(my_handle);
}
// --- Stubbed / Unused Functions (Marked to silence warnings) ---
static void __attribute__((unused)) socket_send(int sockfd, const uint8_t *buffer, int len) {
// Stub
}
static int __attribute__((unused)) socket_recv(int sockfd, uint8_t *buffer, int len, TickType_t timeout_ticks) {
return 0; // Stub
}
static esp_err_t iperf_start_tcp_server(iperf_ctrl_t *ctrl) {
ESP_LOGW(TAG, "TCP Server not implemented");
return ESP_FAIL;
}
static esp_err_t iperf_start_tcp_client(iperf_ctrl_t *ctrl) {
ESP_LOGW(TAG, "TCP Client not implemented");
return ESP_FAIL;
}
static esp_err_t iperf_start_udp_server(iperf_ctrl_t *ctrl) {
ESP_LOGW(TAG, "UDP Server not implemented");
return ESP_FAIL;
}
// -----------------------------------------------------------------------------
// MAIN UDP CLIENT
// -----------------------------------------------------------------------------
static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl)
{
if (!iperf_wait_for_ip()) return ESP_FAIL;
struct sockaddr_in addr;
int sockfd;
struct timeval tv;
sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sockfd < 0) {
ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
s_led_state = LED_RED_FLASH;
return ESP_FAIL;
}
addr.sin_family = AF_INET;
addr.sin_port = htons(ctrl->cfg.dport);
addr.sin_addr.s_addr = htonl(ctrl->cfg.dip);
addr.sin_addr.s_addr = ctrl->cfg.dip;
ESP_LOGI(TAG, "Starting UDP client");
uint32_t burst_count = ctrl->cfg.burst_count ? ctrl->cfg.burst_count : 1;
uint32_t payload_len = ctrl->cfg.send_len ? ctrl->cfg.send_len : IPERF_UDP_TX_LEN;
double target_bandwidth_mbps = (double)ctrl->cfg.bw_lim;
if (target_bandwidth_mbps <= 0) target_bandwidth_mbps = 1.0;
double target_bps = target_bandwidth_mbps * 1000000.0;
double total_pps = target_bps / (payload_len * 8.0);
double bursts_per_sec = total_pps / (double)burst_count;
double pacing_interval_us = 1000000.0 / bursts_per_sec;
s_led_state = LED_PURPLE_SOLID; // Transmitting
uint64_t total_len = 0;
uint32_t packet_count = 0;
uint32_t start_time = xTaskGetTickCount();
uint32_t end_time = start_time + pdMS_TO_TICKS(ctrl->cfg.time * 1000);
int64_t start_time_us = esp_timer_get_time();
int64_t next_send_time = start_time_us;
int64_t end_time_us = start_time_us + ((int64_t)ctrl->cfg.time * 1000000LL);
double interval_accum = 0.0;
while (!ctrl->finish && xTaskGetTickCount() < end_time) {
udp_datagram *header = (udp_datagram *)ctrl->buffer;
header->id = htonl(packet_count);
while (!ctrl->finish && esp_timer_get_time() < end_time_us) {
int64_t current_time = esp_timer_get_time();
int send_len = sendto(sockfd, ctrl->buffer, ctrl->buffer_len, 0,
(struct sockaddr *)&addr, sizeof(addr));
if (send_len > 0) {
total_len += send_len;
packet_count++;
}
if (current_time >= next_send_time) {
for (int k = 0; k < burst_count; k++) {
udp_datagram *header = (udp_datagram *)ctrl->buffer;
gettimeofday(&tv, NULL);
header->id = htonl(packet_count);
header->tv_sec = htonl(tv.tv_sec);
header->tv_usec = htonl(tv.tv_usec);
header->id2 = 0;
// Bandwidth limiting
if (ctrl->cfg.bw_lim > 0) {
vTaskDelay(1);
if (packet_count == 0) {
client_hdr_v1 *client_hdr = (client_hdr_v1 *)(ctrl->buffer + sizeof(udp_datagram));
client_hdr->flags = htonl(HEADER_VERSION1);
client_hdr->numThreads = htonl(1);
client_hdr->mPort = htonl(ctrl->cfg.dport);
client_hdr->mBufLen = htonl(payload_len);
client_hdr->mWinBand = htonl((int)target_bps);
client_hdr->mAmount = htonl(-(int)(ctrl->cfg.time * 100));
}
int send_len = sendto(sockfd, ctrl->buffer, payload_len, 0, (struct sockaddr *)&addr, sizeof(addr));
if (send_len > 0) {
total_len += send_len;
packet_count++;
} else {
ESP_LOGE(TAG, "UDP send failed: %d", errno);
s_led_state = LED_PURPLE_FLASH;
goto exit_client;
}
}
interval_accum += pacing_interval_us;
int64_t steps = (int64_t)interval_accum;
if (steps > 0) { next_send_time += steps; interval_accum -= steps; }
if (esp_timer_get_time() > next_send_time + 4000) next_send_time = esp_timer_get_time() + (int64_t)pacing_interval_us;
} else {
int64_t wait = next_send_time - current_time;
if (wait > 2000) vTaskDelay(pdMS_TO_TICKS(wait/1000));
}
}
uint32_t actual_time = (xTaskGetTickCount() - start_time) / configTICK_RATE_HZ;
float bandwidth = actual_time > 0 ? (float)total_len * 8 / actual_time / 1000000 : 0;
ESP_LOGI(TAG, "UDP client sent: %" PRIu64 " bytes, %" PRIu32 " packets in %" PRIu32 " seconds (%.2f Mbps)",
total_len, packet_count, actual_time, bandwidth);
exit_client:
if (s_led_state != LED_PURPLE_FLASH) s_led_state = LED_GREEN_SOLID;
close(sockfd);
return ESP_OK;
}
@ -277,64 +276,58 @@ static void iperf_task(void *arg)
iperf_ctrl_t *ctrl = (iperf_ctrl_t *)arg;
if (ctrl->cfg.flag & IPERF_FLAG_TCP) {
if (ctrl->cfg.flag & IPERF_FLAG_SERVER) {
iperf_start_tcp_server(ctrl);
} else {
iperf_start_tcp_client(ctrl);
}
if (ctrl->cfg.flag & IPERF_FLAG_SERVER) iperf_start_tcp_server(ctrl);
else iperf_start_tcp_client(ctrl);
} else {
if (ctrl->cfg.flag & IPERF_FLAG_SERVER) {
iperf_start_udp_server(ctrl);
} else {
iperf_start_udp_client(ctrl);
}
if (ctrl->cfg.flag & IPERF_FLAG_SERVER) iperf_start_udp_server(ctrl);
else iperf_start_udp_client(ctrl);
}
if (ctrl->buffer) {
free(ctrl->buffer);
ctrl->buffer = NULL;
}
if (ctrl->buffer) { free(ctrl->buffer); ctrl->buffer = NULL; }
if (s_iperf_event_group) { vEventGroupDelete(s_iperf_event_group); s_iperf_event_group = NULL; }
ESP_LOGI(TAG, "iperf task finished");
s_iperf_task_handle = NULL;
vTaskDelete(NULL);
}
void iperf_start(iperf_cfg_t *cfg)
{
if (s_iperf_task_handle != NULL) {
ESP_LOGW(TAG, "iperf is already running");
return;
static bool led_task_started = false;
if (!led_task_started) {
xTaskCreate(status_led_task, "status_led", 2048, NULL, 1, NULL);
led_task_started = true;
}
nvs_handle_t my_handle;
uint8_t enabled = 1;
if (nvs_open("storage", NVS_READONLY, &my_handle) == ESP_OK) {
nvs_get_u8(my_handle, NVS_KEY_IPERF_ENABLE, &enabled);
size_t req;
if (nvs_get_str(my_handle, "mode", NULL, &req) == ESP_OK) {
char m[10]; nvs_get_str(my_handle, "mode", m, &req);
if (strcmp(m, "MONITOR") == 0) s_led_state = LED_BLUE_SOLID;
}
nvs_close(my_handle);
}
if (enabled == 0) return;
if (s_iperf_task_handle != NULL) return;
memcpy(&s_iperf_ctrl.cfg, cfg, sizeof(iperf_cfg_t));
iperf_read_nvs_config(&s_iperf_ctrl.cfg);
s_iperf_ctrl.finish = false;
// Allocate buffer
if (cfg->flag & IPERF_FLAG_TCP) {
s_iperf_ctrl.buffer_len = cfg->flag & IPERF_FLAG_SERVER ?
IPERF_TCP_RX_LEN : IPERF_TCP_TX_LEN;
} else {
s_iperf_ctrl.buffer_len = cfg->flag & IPERF_FLAG_SERVER ?
IPERF_UDP_RX_LEN : IPERF_UDP_TX_LEN;
}
s_iperf_ctrl.buffer = (uint8_t *)malloc(s_iperf_ctrl.buffer_len);
if (!s_iperf_ctrl.buffer) {
ESP_LOGE(TAG, "Failed to allocate buffer");
return;
}
s_iperf_ctrl.buffer_len = 2048;
s_iperf_ctrl.buffer = malloc(s_iperf_ctrl.buffer_len);
memset(s_iperf_ctrl.buffer, 0, s_iperf_ctrl.buffer_len);
xTaskCreate(iperf_task, "iperf", 4096, &s_iperf_ctrl, IPERF_TRAFFIC_TASK_PRIORITY,
&s_iperf_task_handle);
s_iperf_event_group = xEventGroupCreate();
xTaskCreate(iperf_task, "iperf", 4096, &s_iperf_ctrl, IPERF_TRAFFIC_TASK_PRIORITY, &s_iperf_task_handle);
}
void iperf_stop(void)
{
void iperf_stop(void) {
if (s_iperf_task_handle != NULL) {
s_iperf_ctrl.finish = true;
ESP_LOGI(TAG, "Stopping iperf...");
if (s_iperf_event_group) xEventGroupSetBits(s_iperf_event_group, IPERF_STOP_REQ_BIT);
}
}

72
components/iperf/iperf.h
View File

@ -4,11 +4,13 @@
#include <stdint.h>
#include <stdbool.h>
// --- Configuration Flags ---
#define IPERF_FLAG_CLIENT (1 << 0)
#define IPERF_FLAG_SERVER (1 << 1)
#define IPERF_FLAG_TCP (1 << 2)
#define IPERF_FLAG_UDP (1 << 3)
// --- Defaults ---
#define IPERF_DEFAULT_PORT 5001
#define IPERF_DEFAULT_INTERVAL 3
#define IPERF_DEFAULT_TIME 30
@ -18,23 +20,37 @@
#define IPERF_SOCKET_RX_TIMEOUT 10
#define IPERF_SOCKET_ACCEPT_TIMEOUT 5
#define IPERF_UDP_TX_LEN (1470)
// --- Buffer Sizes ---
#define IPERF_UDP_TX_LEN (1470) // Default UDP Payload
#define IPERF_UDP_RX_LEN (16 << 10)
#define IPERF_TCP_TX_LEN (16 << 10)
#define IPERF_TCP_RX_LEN (16 << 10)
// --- NVS Storage Keys ---
#define NVS_KEY_IPERF_ENABLE "iperf_enabled" // 0=Disabled, 1=Enabled
#define NVS_KEY_IPERF_RATE "iperf_rate" // Target Bandwidth (Mbps)
#define NVS_KEY_IPERF_ROLE "iperf_role" // "CLIENT" or "SERVER"
#define NVS_KEY_IPERF_DST_IP "iperf_dst_ip" // Target IP String
#define NVS_KEY_IPERF_PROTO "iperf_proto" // "UDP" or "TCP"
#define NVS_KEY_IPERF_BURST "iperf_burst" // Packets per schedule tick
#define NVS_KEY_IPERF_LEN "iperf_len" // UDP Payload Length
// --- Main Configuration Structure ---
typedef struct {
uint32_t flag;
uint8_t type;
uint16_t dip;
uint16_t dport;
uint16_t sport;
uint32_t interval;
uint32_t time;
uint16_t bw_lim;
uint32_t buffer_len;
uint32_t flag; // Client/Server | TCP/UDP flags
uint8_t type; // (Internal use)
uint32_t dip; // Destination IP (Network Byte Order)
uint16_t dport; // Destination Port
uint16_t sport; // Source Port
uint32_t interval; // Report Interval (seconds)
uint32_t time; // Test Duration (seconds)
uint32_t bw_lim; // Bandwidth Limit (Mbps)
uint32_t burst_count;// Burst Mode: Packets per schedule tick
uint32_t send_len; // User defined Payload Length
uint32_t buffer_len; // Internally calculated buffer size
} iperf_cfg_t;
// --- Traffic Statistics Structure ---
typedef struct {
uint64_t total_len;
uint32_t buffer_len;
@ -46,14 +62,42 @@ typedef struct {
uint32_t udp_packet_counter;
} iperf_traffic_t;
// UDP header for iperf
// --- Iperf 2.0.5+ Compatible Headers ---
// Standard UDP Datagram Header (Present in EVERY packet)
typedef struct {
int32_t id;
uint32_t tv_sec;
uint32_t tv_usec;
int32_t id; // Sequence Number
uint32_t tv_sec; // Timestamp Seconds
uint32_t tv_usec; // Timestamp Microseconds
uint32_t id2; // 64-bit seq / Padding
} udp_datagram;
// Client Header (Sent ONLY in the first UDP packet of a stream)
typedef struct {
int32_t flags; // Flags (Version, Dual Test, etc.)
int32_t numThreads; // Parallel threads
int32_t mPort; // Port
int32_t mBufLen; // Buffer Length
int32_t mWinBand; // Target Bandwidth
int32_t mAmount; // Duration / Bytes (negative = time)
} client_hdr_v1;
// Version Flag for Client Header
#define HEADER_VERSION1 0x80000000
// --- Public API ---
/**
* @brief Start the Iperf task.
* * Reads configuration from NVS ("storage" partition) to override defaults.
* If NVS_KEY_IPERF_ENABLE is 0, this function returns immediately.
* * @param cfg Pointer to initial configuration (can be overridden by NVS)
*/
void iperf_start(iperf_cfg_t *cfg);
/**
* @brief Stop the Iperf task.
* * Signals the running task to finish and close sockets.
*/
void iperf_stop(void);
#endif // IPERF_H

617
esp32_deploy.py
View File

@ -2,40 +2,6 @@
"""
ESP32 Unified Deployment Tool
Combines firmware flashing and device configuration with full control.
Operation Modes:
Default: Build + Flash + Configure
--config-only: Configure only (no flashing)
--flash-only: Build + Flash only (no configure)
--flash-erase: Erase + Flash + Configure
Examples:
# Full deployment (default: flash + config)
./esp32_deploy.py -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81
# Config only (firmware already flashed)
./esp32_deploy.py -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 --config-only
# Flash only (preserve existing config)
./esp32_deploy.py --flash-only
# Full erase + flash + config
./esp32_deploy.py -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 --flash-erase
# Limit concurrent flash for unpowered USB hub
./esp32_deploy.py -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 --max-concurrent 2
# Retry specific failed devices (automatic sequential flashing)
./esp32_deploy.py --devices /dev/ttyUSB3,/dev/ttyUSB6,/dev/ttyUSB7 -s ClubHouse2G -P ez2remember --start-ip 192.168.1.63
# CSI-enabled devices
./esp32_deploy.py -s ClubHouse2G -P ez2remember --start-ip 192.168.1.111 --csi
# Monitor mode on channel 36
./esp32_deploy.py --start-ip 192.168.1.90 -M MONITOR -mc 36 --config-only
# 5GHz with 40MHz bandwidth
./esp32_deploy.py -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 -b 5G -B HT40
"""
import asyncio
@ -58,7 +24,7 @@ except ImportError:
sys.exit(1)
# --- Configuration ---
DEFAULT_MAX_CONCURRENT_FLASH = 4 # Conservative default for USB hub power limits
DEFAULT_MAX_CONCURRENT_FLASH = 4
class Colors:
GREEN = '\033[92m'
@ -76,8 +42,6 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s', datefm
logger = logging.getLogger("Deploy")
class UnifiedDeployWorker:
"""Handles both flashing and configuration for a single ESP32 device"""
def __init__(self, port, target_ip, args, build_dir, flash_sem):
self.port = port
self.target_ip = target_ip
@ -86,7 +50,6 @@ class UnifiedDeployWorker:
self.flash_sem = flash_sem
self.log = DeviceLoggerAdapter(logger, {'connid': port})
# Regex Patterns
self.regex_ready = re.compile(r'Initialization complete|GPS synced|GPS initialization aborted|No Config Found', re.IGNORECASE)
self.regex_got_ip = re.compile(r'got ip:(\d+\.\d+\.\d+\.\d+)', re.IGNORECASE)
self.regex_monitor_success = re.compile(r'Monitor mode active', re.IGNORECASE)
@ -95,34 +58,21 @@ class UnifiedDeployWorker:
self.regex_error = re.compile(r'Error:|Failed|Disconnect', re.IGNORECASE)
async def run(self):
"""Main execution workflow"""
try:
# Phase 1: Flash (if not config-only)
if not self.args.config_only:
async with self.flash_sem:
if self.args.flash_erase:
if not await self._erase_flash():
return False # HARD FAILURE: Flash Erase Failed
if not await self._flash_firmware():
return False # HARD FAILURE: Flash Write Failed
# Wait for port to stabilize after flash
if not await self._erase_flash(): return False
if not await self._flash_firmware(): return False
await asyncio.sleep(1.0)
# Phase 2: Configure (if not flash-only)
if not self.args.flash_only:
if self.args.ssid and self.args.password:
if not await self._configure_device():
# SOFT FAILURE: Config failed, but we treat it as success if flash passed
self.log.warning(f"{Colors.YELLOW}Configuration verification failed. Marking as SUCCESS (Flash was OK).{Colors.RESET}")
# We proceed to return True at the end
self.log.warning(f"{Colors.YELLOW}Config verify failed. Marking SUCCESS (Flash OK).{Colors.RESET}")
else:
self.log.warning("No SSID/Password provided, skipping config")
if self.args.config_only:
return False
else:
self.log.info(f"{Colors.GREEN}Flash Complete (Config Skipped){Colors.RESET}")
if self.args.config_only: return False
return True
except Exception as e:
@ -130,70 +80,32 @@ class UnifiedDeployWorker:
return False
async def _erase_flash(self):
"""Erase entire flash memory"""
self.log.info(f"{Colors.YELLOW}Erasing flash...{Colors.RESET}")
cmd = ['esptool.py', '-p', self.port, '-b', '115200', 'erase_flash']
proc = await asyncio.create_subprocess_exec(
*cmd,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE
)
proc = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
stdout, stderr = await proc.communicate()
if proc.returncode == 0:
self.log.info("Erase successful")
return True
if proc.returncode == 0: return True
self.log.error(f"Erase failed: {stderr.decode()}")
return False
async def _flash_firmware(self):
"""Flash firmware to device"""
self.log.info("Flashing firmware...")
cmd = [
'esptool.py', '-p', self.port, '-b', str(self.args.baud),
'--before', 'default_reset', '--after', 'hard_reset',
'write_flash', '@flash_args'
]
proc = await asyncio.create_subprocess_exec(
*cmd,
cwd=self.build_dir,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE
)
cmd = ['esptool.py', '-p', self.port, '-b', str(self.args.baud), '--before', 'default_reset', '--after', 'hard_reset', 'write_flash', '@flash_args']
proc = await asyncio.create_subprocess_exec(*cmd, cwd=self.build_dir, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
try:
stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=300)
except asyncio.TimeoutError:
proc.kill()
self.log.error("Flash timeout")
return False
if proc.returncode == 0:
self.log.info("Flash successful")
return True
if proc.returncode == 0: return True
self.log.error(f"Flash failed: {stderr.decode()}")
return False
async def _configure_device(self):
"""Configure device via serial console"""
self.log.info("Connecting to console...")
try:
reader, writer = await serial_asyncio.open_serial_connection(url=self.port, baudrate=115200)
except Exception as e: return False
try:
reader, writer = await serial_asyncio.open_serial_connection(
url=self.port,
baudrate=115200
)
except Exception as e:
self.log.error(f"Serial open failed: {e}")
return False
try:
# Step 1: Hardware Reset (only if config-only mode)
if self.args.config_only:
self.log.info("Resetting device...")
writer.transport.serial.dtr = False
writer.transport.serial.rts = True
await asyncio.sleep(0.1)
@ -201,480 +113,153 @@ class UnifiedDeployWorker:
await asyncio.sleep(0.1)
writer.transport.serial.dtr = True
# Step 2: Wait for Boot
if not await self._wait_for_boot(reader):
self.log.warning("Boot prompt missed, attempting config anyway...")
self.log.warning("Boot prompt missed...")
# Step 3: Send Configuration
await self._send_config(writer)
# Step 4: Verify Success
return await self._verify_configuration(reader)
except Exception as e:
self.log.error(f"Config error: {e}")
return False
finally:
writer.close()
await writer.wait_closed()
except Exception as e: return False
finally: writer.close(); await writer.wait_closed()
async def _wait_for_boot(self, reader):
"""Wait for device boot completion"""
self.log.info("Waiting for boot...")
timeout = time.time() + 10
while time.time() < timeout:
try:
line_bytes = await asyncio.wait_for(reader.readline(), timeout=0.5)
line = line_bytes.decode('utf-8', errors='ignore').strip()
if self.regex_ready.search(line):
return True
except asyncio.TimeoutError:
continue
line = (await asyncio.wait_for(reader.readline(), timeout=0.5)).decode('utf-8', errors='ignore').strip()
if self.regex_ready.search(line): return True
except asyncio.TimeoutError: continue
return False
async def _send_config(self, writer):
"""Build and send configuration message"""
csi_val = '1' if self.args.csi_enable else '0'
self.log.info(f"Sending config for {self.target_ip} (Mode:{self.args.mode}, CSI:{csi_val})...")
role_str = "CLIENT"
if self.args.iperf_server: role_str = "SERVER"
elif self.args.iperf_client: role_str = "CLIENT"
# Enable Logic: 1=Yes, 0=No
iperf_enable_val = '0' if self.args.no_iperf else '1'
config_str = (
f"CFG\n"
f"SSID:{self.args.ssid}\n"
f"PASS:{self.args.password}\n"
f"IP:{self.target_ip}\n"
f"MASK:{self.args.netmask}\n"
f"GW:{self.args.gateway}\n"
f"DHCP:0\n"
f"BAND:{self.args.band}\n"
f"BW:{self.args.bandwidth}\n"
f"POWERSAVE:{self.args.powersave}\n"
f"MODE:{self.args.mode}\n"
f"MON_CH:{self.args.monitor_channel}\n"
f"CSI:{csi_val}\n"
f"CFG\nSSID:{self.args.ssid}\nPASS:{self.args.password}\nIP:{self.target_ip}\n"
f"MASK:{self.args.netmask}\nGW:{self.args.gateway}\nDHCP:0\nBAND:{self.args.band}\n"
f"BW:{self.args.bandwidth}\nPOWERSAVE:{self.args.powersave}\nMODE:{self.args.mode}\n"
f"MON_CH:{self.args.monitor_channel}\nCSI:{csi_val}\n"
f"IPERF_RATE:{self.args.iperf_rate}\nIPERF_ROLE:{role_str}\n"
f"IPERF_PROTO:{self.args.iperf_proto}\nIPERF_DEST_IP:{self.args.iperf_dest_ip}\n"
f"IPERF_BURST:{self.args.iperf_burst}\nIPERF_LEN:{self.args.iperf_len}\n"
f"IPERF_ENABLED:{iperf_enable_val}\n"
f"END\n"
)
writer.write(config_str.encode('utf-8'))
await writer.drain()
async def _verify_configuration(self, reader):
"""Verify configuration success"""
self.log.info("Verifying configuration...")
timeout = time.time() + 20
csi_saved = False
while time.time() < timeout:
try:
line_bytes = await asyncio.wait_for(reader.readline(), timeout=1.0)
line = line_bytes.decode('utf-8', errors='ignore').strip()
if not line:
continue
# Check for CSI save confirmation
if self.regex_csi_saved.search(line):
csi_saved = True
# Check for Station Mode Success (IP Address)
m_ip = self.regex_got_ip.search(line)
if m_ip:
got_ip = m_ip.group(1)
if got_ip == self.target_ip:
csi_msg = f" {Colors.CYAN}(CSI saved){Colors.RESET}" if csi_saved else ""
self.log.info(f"{Colors.GREEN}SUCCESS: Assigned {got_ip}{csi_msg}{Colors.RESET}")
return True
else:
self.log.warning(f"IP MISMATCH: Wanted {self.target_ip}, got {got_ip}")
# Check for Monitor Mode Success
if self.regex_monitor_success.search(line):
csi_msg = f" {Colors.CYAN}(CSI saved){Colors.RESET}" if csi_saved else ""
self.log.info(f"{Colors.GREEN}SUCCESS: Monitor Mode Active{csi_msg}{Colors.RESET}")
return True
# Check for status command responses
if self.regex_status_connected.search(line):
csi_msg = f" {Colors.CYAN}(CSI saved){Colors.RESET}" if csi_saved else ""
self.log.info(f"{Colors.GREEN}SUCCESS: Connected{csi_msg}{Colors.RESET}")
return True
# Check for errors
if self.regex_error.search(line):
self.log.warning(f"Device error: {line}")
except asyncio.TimeoutError:
continue
self.log.error("Timeout: Device did not confirm configuration")
line = (await asyncio.wait_for(reader.readline(), timeout=1.0)).decode('utf-8', errors='ignore').strip()
if not line: continue
if self.regex_csi_saved.search(line) or self.regex_monitor_success.search(line) or self.regex_status_connected.search(line): return True
m = self.regex_got_ip.search(line)
if m and m.group(1) == self.target_ip: return True
except asyncio.TimeoutError: continue
return False
def parse_args():
parser = argparse.ArgumentParser(
description='ESP32 Unified Deployment Tool',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Operation Modes:
Default: Build + Flash + Configure
--config-only: Configure only (no flashing)
--flash-only: Build + Flash only (no configure)
--flash-erase: Erase + Flash + Configure
Examples:
# Full deployment (flash + config)
%(prog)s -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81
# Config only (no flashing)
%(prog)s -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 --config-only
# Flash only (preserve config)
%(prog)s --flash-only
# Full erase + deploy
%(prog)s -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 --flash-erase
# CSI-enabled devices
%(prog)s -s ClubHouse2G -P ez2remember --start-ip 192.168.1.111 --csi
# Monitor mode
%(prog)s --start-ip 192.168.1.90 -M MONITOR -mc 36 --config-only
# 5GHz with 40MHz bandwidth
%(prog)s -s ClubHouse2G -P ez2remember --start-ip 192.168.1.81 -b 5G -B HT40
"""
)
parser = argparse.ArgumentParser(description='ESP32 Unified Deployment Tool')
# Operation Mode
mode_group = parser.add_argument_group('Operation Mode')
mode_group.add_argument('--config-only', action='store_true',
help='Configure only (no flashing)')
mode_group.add_argument('--flash-only', action='store_true',
help='Flash only (no configure)')
mode_group.add_argument('--flash-erase', action='store_true',
help='Erase flash before flashing')
parser.add_argument('--config-only', action='store_true', help='Configure only')
parser.add_argument('--flash-only', action='store_true', help='Flash only')
parser.add_argument('--flash-erase', action='store_true', help='Erase flash first')
# Build/Flash Options
flash_group = parser.add_argument_group('Flash Options')
flash_group.add_argument('-d', '--dir', default=os.getcwd(),
help='Project directory (default: current)')
flash_group.add_argument('-b', '--baud', type=int, default=460800,
help='Flash baud rate (default: 460800)')
flash_group.add_argument('--devices', type=str,
help='Comma-separated list of devices (e.g., /dev/ttyUSB3,/dev/ttyUSB6,/dev/ttyUSB7) for selective deployment/retry. '
'Automatically uses sequential flashing to avoid power issues.')
flash_group.add_argument('--max-concurrent', type=int, default=None,
help=f'Max concurrent flash operations (default: {DEFAULT_MAX_CONCURRENT_FLASH}). '
'Defaults to 1 when using --devices, unless explicitly set. '
'Lower this if you experience USB power issues. '
'Try 2-3 for unpowered hubs, 4-8 for powered hubs.')
# Build/Flash
parser.add_argument('-d', '--dir', default=os.getcwd(), help='Project dir')
parser.add_argument('-b', '--baud', type=int, default=460800, help='Flash baud')
parser.add_argument('--devices', type=str, help='Device list /dev/ttyUSB0,/dev/ttyUSB1')
parser.add_argument('--max-concurrent', type=int, default=None, help='Max concurrent flash')
# Network Configuration
net_group = parser.add_argument_group('Network Configuration')
net_group.add_argument('--start-ip', required=True,
help='Starting static IP address')
net_group.add_argument('-s', '--ssid', default='ClubHouse2G',
help='WiFi SSID (default: ClubHouse2G)')
net_group.add_argument('-P', '--password', default='ez2remember',
help='WiFi password (default: ez2remember)')
net_group.add_argument('-g', '--gateway', default='192.168.1.1',
help='Gateway IP (default: 192.168.1.1)')
net_group.add_argument('-m', '--netmask', default='255.255.255.0',
help='Netmask (default: 255.255.255.0)')
# Network
parser.add_argument('--start-ip', required=True, help='Start IP')
parser.add_argument('-s', '--ssid', default='ClubHouse2G', help='SSID')
parser.add_argument('-P', '--password', default='ez2remember', help='Password')
parser.add_argument('-g', '--gateway', default='192.168.1.1', help='Gateway')
parser.add_argument('-m', '--netmask', default='255.255.255.0', help='Netmask')
# WiFi Configuration
wifi_group = parser.add_argument_group('WiFi Configuration')
wifi_group.add_argument('--band', default='2.4G', choices=['2.4G', '5G'],
help='WiFi band (default: 2.4G)')
wifi_group.add_argument('-B', '--bandwidth', default='HT20',
choices=['HT20', 'HT40', 'VHT80'],
help='Channel bandwidth (default: HT20)')
wifi_group.add_argument('-ps', '--powersave', default='NONE',
help='Power save mode (default: NONE)')
# WiFi
parser.add_argument('--band', default='2.4G', choices=['2.4G', '5G'], help='Band')
parser.add_argument('-B', '--bandwidth', default='HT20', choices=['HT20', 'HT40', 'VHT80'], help='BW')
parser.add_argument('-ps', '--powersave', default='NONE', help='Power save')
# Mode Configuration
mode_config_group = parser.add_argument_group('Device Mode Configuration')
mode_config_group.add_argument('-M', '--mode', default='STA',
choices=['STA', 'MONITOR'],
help='Operating mode (default: STA)')
mode_config_group.add_argument('-mc', '--monitor-channel', type=int, default=36,
help='Monitor mode channel (default: 36)')
# Iperf
parser.add_argument('--iperf-rate', type=int, default=10, help='Mbps')
parser.add_argument('--iperf-burst', type=int, default=1, help='Packets/tick')
parser.add_argument('--iperf-len', type=int, default=1470, help='Payload len')
parser.add_argument('--iperf-proto', default='UDP', choices=['UDP', 'TCP'], help='Proto')
parser.add_argument('--iperf-dest-ip', default='192.168.1.50', help='Dest IP')
parser.add_argument('--no-iperf', action='store_true', help='Disable Iperf start')
# Feature Flags
feature_group = parser.add_argument_group('Feature Flags')
feature_group.add_argument('--csi', dest='csi_enable', action='store_true',
help='Enable CSI capture (default: disabled)')
g = parser.add_mutually_exclusive_group()
g.add_argument('--iperf-client', action='store_true')
g.add_argument('--iperf-server', action='store_true')
# Mode
parser.add_argument('-M', '--mode', default='STA', choices=['STA', 'MONITOR'])
parser.add_argument('-mc', '--monitor-channel', type=int, default=36)
parser.add_argument('--csi', dest='csi_enable', action='store_true')
args = parser.parse_args()
# Validation
if args.config_only and args.flash_only:
parser.error("Cannot use --config-only and --flash-only together")
if args.flash_erase and args.config_only:
parser.error("Cannot use --flash-erase with --config-only")
if args.flash_erase and args.flash_only:
parser.error("Cannot use --flash-erase with --flash-only (use default mode)")
if not args.config_only and not args.flash_only:
# Default mode or flash-erase mode
if not args.ssid or not args.password:
parser.error("SSID and password required for flash+config mode")
if args.config_only and args.flash_only: parser.error("Conflicting modes")
if not args.config_only and not args.flash_only and (not args.ssid or not args.password):
parser.error("SSID/PASS required")
return args
def extract_device_number(device_path):
"""Extract numeric suffix from device path (e.g., /dev/ttyUSB3 -> 3)"""
match = re.search(r'(\d+)$', device_path)
if match:
return int(match.group(1))
return 0 # Default to 0 if no number found
return int(match.group(1)) if match else 0
async def run_deployment(args):
"""Main deployment orchestration"""
# Determine operation mode
if args.config_only:
mode_str = f"{Colors.CYAN}CONFIG ONLY{Colors.RESET}"
elif args.flash_only:
mode_str = f"{Colors.YELLOW}FLASH ONLY{Colors.RESET}"
elif args.flash_erase:
mode_str = f"{Colors.RED}ERASE + FLASH + CONFIG{Colors.RESET}"
else:
mode_str = f"{Colors.GREEN}FLASH + CONFIG{Colors.RESET}"
print(f"\n{Colors.BLUE}{'='*60}{Colors.RESET}")
print(f" ESP32 Unified Deployment Tool")
print(f" Operation Mode: {mode_str}")
print(f"{Colors.BLUE}{'='*60}{Colors.RESET}\n")
print(f"\n{Colors.BLUE}{'='*60}{Colors.RESET}\n ESP32 Unified Deployment Tool\n{Colors.BLUE}{'='*60}{Colors.RESET}")
project_dir = Path(args.dir).resolve()
build_dir = project_dir / 'build'
# Phase 1: Build Firmware (if needed)
if not args.config_only:
print(f"{Colors.YELLOW}[1/3] Building Firmware...{Colors.RESET}")
proc = await asyncio.create_subprocess_exec(
'idf.py', 'build',
cwd=project_dir,
stdout=asyncio.subprocess.DEVNULL,
stderr=asyncio.subprocess.PIPE
)
print(f"{Colors.YELLOW}Building Firmware...{Colors.RESET}")
proc = await asyncio.create_subprocess_exec('idf.py', 'build', cwd=project_dir, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.PIPE)
_, stderr = await proc.communicate()
if proc.returncode != 0:
print(f"{Colors.RED}Build Failed:\n{stderr.decode()}{Colors.RESET}")
return
if not (build_dir / 'flash_args').exists():
print(f"{Colors.RED}Error: build/flash_args missing{Colors.RESET}")
return
if proc.returncode != 0: print(f"{Colors.RED}Build Failed:\n{stderr.decode()}{Colors.RESET}"); return
print(f"{Colors.GREEN}Build Complete{Colors.RESET}")
else:
print(f"{Colors.CYAN}[1/3] Skipping Build (Config-Only Mode){Colors.RESET}")
# Phase 2: Detect Devices
step_num = 2 if not args.config_only else 1
print(f"{Colors.YELLOW}[{step_num}/3] Detecting Devices...{Colors.RESET}")
# Get device list
# Detect Devices
if args.devices:
# User specified devices explicitly
device_list = [d.strip() for d in args.devices.split(',')]
print(f"{Colors.CYAN}Using specified devices: {', '.join(device_list)}{Colors.RESET}")
# Create device objects for specified devices
class SimpleDevice:
def __init__(self, path):
self.device = path
devices = [SimpleDevice(d) for d in device_list]
# Validate devices exist
for dev in devices:
if not os.path.exists(dev.device):
print(f"{Colors.RED}Warning: Device {dev.device} not found{Colors.RESET}")
devs = [type('obj', (object,), {'device': d.strip()}) for d in args.devices.split(',')]
else:
# Auto-detect all devices
devices = detect_esp32.detect_esp32_devices()
if not devices:
print(f"{Colors.RED}No devices found{Colors.RESET}")
return
devs = detect_esp32.detect_esp32_devices()
if not devs: print("No devices found"); return
devs.sort(key=lambda d: [int(c) if c.isdigit() else c for c in re.split(r'(\d+)', d.device)])
# Sort devices naturally
def natural_keys(d):
return [int(c) if c.isdigit() else c for c in re.split(r'(\d+)', d.device)]
devices.sort(key=natural_keys)
print(f"{Colors.GREEN}Found {len(devs)} devices{Colors.RESET}")
start_ip = ipaddress.IPv4Address(args.start_ip)
print(f"{Colors.GREEN}Found {len(devices)} device{'s' if len(devices) != 1 else ''}{Colors.RESET}")
# Concurrency
max_c = args.max_concurrent if args.max_concurrent else (1 if args.devices and not args.config_only else DEFAULT_MAX_CONCURRENT_FLASH)
flash_sem = asyncio.Semaphore(max_c)
# Validate start IP
try:
start_ip_obj = ipaddress.IPv4Address(args.start_ip)
except:
print(f"{Colors.RED}Invalid start IP: {args.start_ip}{Colors.RESET}")
return
# Phase 3: Deploy
step_num = 3 if not args.config_only else 2
operation = "Configuring" if args.config_only else "Deploying to"
print(f"{Colors.YELLOW}[{step_num}/3] {operation} {len(devices)} devices...{Colors.RESET}\n")
# Show device-to-IP mapping when using --devices
if args.devices and not args.flash_only:
print(f"{Colors.CYAN}Device-to-IP Mapping:{Colors.RESET}")
for dev in devices:
dev_num = extract_device_number(dev.device)
target_ip = str(start_ip_obj + dev_num)
print(f" {dev.device} -> {target_ip}")
print()
# Determine flash concurrency
if args.max_concurrent is not None:
# Priority 1: User explicitly set a limit (honored always)
max_concurrent = args.max_concurrent
print(f"{Colors.CYAN}Flash Mode: {max_concurrent} concurrent operations (User Override){Colors.RESET}\n")
elif args.devices and not args.config_only:
# Priority 2: Retry/Specific mode defaults to sequential for safety
max_concurrent = 1
print(f"{Colors.CYAN}Flash Mode: Sequential (retry mode default){Colors.RESET}\n")
else:
# Priority 3: Standard Bulk mode defaults to constant
max_concurrent = DEFAULT_MAX_CONCURRENT_FLASH
if not args.config_only:
print(f"{Colors.CYAN}Flash Mode: {max_concurrent} concurrent operations{Colors.RESET}\n")
flash_sem = asyncio.Semaphore(max_concurrent)
tasks = []
for i, dev in enumerate(devs):
offset = extract_device_number(dev.device) if args.devices else i
target_ip = str(start_ip + offset)
tasks.append(UnifiedDeployWorker(dev.device, target_ip, args, build_dir, flash_sem).run())
# Map device to target IP
# If --devices specified, use USB number as offset; otherwise use enumerate index
device_ip_map = []
for i, dev in enumerate(devices):
if args.devices:
# Extract USB number and use as offset (e.g., ttyUSB3 -> offset 3)
device_num = extract_device_number(dev.device)
target_ip = str(start_ip_obj + device_num)
device_ip_map.append((dev.device, target_ip, device_num))
else:
# Use enumerate index as offset
target_ip = str(start_ip_obj + i)
device_ip_map.append((dev.device, target_ip, i))
worker = UnifiedDeployWorker(dev.device, target_ip, args, build_dir, flash_sem)
tasks.append(worker.run())
# Execute all tasks concurrently
results = await asyncio.gather(*tasks)
# Phase 4: Summary
success = results.count(True)
failed = len(devices) - success
# Track failed devices
failed_devices = []
for i, (dev, result) in enumerate(zip(devices, results)):
if not result:
failed_devices.append(dev.device)
# Determine feature status for summary
features = []
# Add SSID (if configured)
if not args.flash_only:
features.append(f"SSID: {args.ssid}")
if args.csi_enable:
features.append(f"CSI: {Colors.GREEN}ENABLED{Colors.RESET}")
else:
features.append(f"CSI: DISABLED")
if args.mode == 'MONITOR':
features.append(f"Mode: MONITOR (Ch {args.monitor_channel})")
else:
features.append(f"Mode: STA")
features.append(f"Band: {args.band}")
features.append(f"BW: {args.bandwidth}")
features.append(f"Power Save: {args.powersave}")
print(f"\n{Colors.BLUE}{'='*60}{Colors.RESET}")
print(f" Deployment Summary")
print(f"{Colors.BLUE}{'='*60}{Colors.RESET}")
print(f" Total Devices: {len(devices)}")
print(f" Success: {Colors.GREEN}{success}{Colors.RESET}")
print(f" Failed: {Colors.RED}{failed}{Colors.RESET}" if failed > 0 else f" Failed: {failed}")
print(f"{Colors.BLUE}{'-'*60}{Colors.RESET}")
for feature in features:
print(f" {feature}")
print(f"{Colors.BLUE}{'='*60}{Colors.RESET}")
# Show failed devices and retry command if any failed
if failed_devices:
print(f"\n{Colors.RED}Failed Devices:{Colors.RESET}")
for dev in failed_devices:
# Show device and its intended IP
dev_num = extract_device_number(dev)
intended_ip = str(start_ip_obj + dev_num)
print(f" {dev} -> {intended_ip}")
# Generate retry command
device_list = ','.join(failed_devices)
retry_cmd = f"./esp32_deploy.py --devices {device_list}"
# Add original arguments to retry command
if args.ssid:
retry_cmd += f" -s {args.ssid}"
if args.password:
retry_cmd += f" -P {args.password}"
# Use original starting IP - device number extraction will handle the offset
if not args.flash_only:
retry_cmd += f" --start-ip {args.start_ip}"
if args.band != '2.4G':
retry_cmd += f" --band {args.band}"
if args.bandwidth != 'HT20':
retry_cmd += f" -B {args.bandwidth}"
if args.powersave != 'NONE':
retry_cmd += f" -ps {args.powersave}"
if args.mode != 'STA':
retry_cmd += f" -M {args.mode}"
if args.monitor_channel != 36:
retry_cmd += f" -mc {args.monitor_channel}"
if args.csi_enable:
retry_cmd += " --csi"
if args.config_only:
retry_cmd += " --config-only"
elif args.flash_only:
retry_cmd += " --flash-only"
elif args.flash_erase:
retry_cmd += " --flash-erase"
if args.baud != 460800:
retry_cmd += f" -b {args.baud}"
if args.max_concurrent is not None:
retry_cmd += f" --max-concurrent {args.max_concurrent}"
print(f"\n{Colors.YELLOW}Retry Command:{Colors.RESET}")
print(f" {retry_cmd}\n")
else:
print() # Extra newline for clean output
print(f"\n{Colors.BLUE}Summary: {success}/{len(devs)} Success{Colors.RESET}")
def main():
args = parse_args()
if os.name == 'nt': asyncio.set_event_loop(asyncio.ProactorEventLoop())
try: asyncio.run(run_deployment(parse_args()))
except KeyboardInterrupt: sys.exit(1)
if os.name == 'nt':
asyncio.set_event_loop(asyncio.ProactorEventLoop())
try:
asyncio.run(run_deployment(args))
except KeyboardInterrupt:
print(f"\n{Colors.YELLOW}Deployment cancelled by user{Colors.RESET}")
sys.exit(1)
if __name__ == '__main__':
main()
if __name__ == '__main__': main()