traffic seems to work

components/iperf/iperf.c

@@ -22,20 +22,12 @@
 static const char *TAG = "iperf";
 
 typedef enum {
-    LED_OFF,
+    LED_OFF, LED_BLUE_SOLID, LED_RED_FLASH, LED_AMBER_SOLID,
-    LED_BLUE_SOLID,
+    LED_GREEN_SOLID, LED_PURPLE_SOLID, LED_PURPLE_FLASH
-    LED_RED_FLASH,
-    LED_AMBER_SOLID,
-    LED_GREEN_SOLID,
-    LED_PURPLE_SOLID,
-    LED_PURPLE_FLASH
 } led_state_t;
-
 static led_state_t s_led_state = LED_RED_FLASH;
 
-static void iperf_set_physical_led(uint8_t r, uint8_t g, uint8_t b) {
+static void iperf_set_physical_led(uint8_t r, uint8_t g, uint8_t b) {}
-    // Hardware LED call here
-}
 
 static void status_led_task(void *arg) {
     bool toggle = false;
@@ -72,9 +64,8 @@ static esp_event_handler_instance_t instance_got_ip;
 
 static void iperf_network_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) {
     if (s_iperf_event_group == NULL) return;
-    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED) {
+    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED) s_led_state = LED_AMBER_SOLID;
-        s_led_state = LED_AMBER_SOLID;
+    else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
-    } 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;
     } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
@@ -94,12 +85,8 @@ static bool iperf_wait_for_ip(void) {
         if (esp_netif_get_ip_info(netif, &ip_info) == ESP_OK && 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_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);
@@ -109,8 +96,7 @@ static bool iperf_wait_for_ip(void) {
 }
 
 static void trim_whitespace(char *str) {
-    char *end;
+    char *end = str + strlen(str) - 1;
-    end = str + strlen(str) - 1;
     while(end > str && isspace((unsigned char)*end)) end--;
     *(end+1) = 0;
 }
@@ -118,23 +104,40 @@ static void trim_whitespace(char *str) {
 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;
+    size_t required_size;
 
-    // NO bw_lim/IPERF_RATE check here anymore (Deleted)
+    // --- DEFAULTS ---
+    cfg->pacing_period_us = 10000;
+    cfg->burst_count = 1;
+    cfg->send_len = IPERF_UDP_TX_LEN;
+    cfg->dport = 5001;
+    cfg->dip = inet_addr("192.168.1.50");
+    if (cfg->time == 0) cfg->time = UINT32_MAX;
 
-    if (nvs_get_u32(my_handle, NVS_KEY_IPERF_PERIOD, &val) == ESP_OK && val > 0) cfg->pacing_period_us = val; else cfg->pacing_period_us = 10000;
+    if (err != ESP_OK) return;
-    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_u32(my_handle, NVS_KEY_IPERF_PERIOD, &val) == ESP_OK && val > 0) cfg->pacing_period_us = val;
+    if (nvs_get_u32(my_handle, NVS_KEY_IPERF_BURST, &val) == ESP_OK && val > 0) cfg->burst_count = val;
+    if (nvs_get_u32(my_handle, NVS_KEY_IPERF_LEN, &val) == ESP_OK && val > 0) cfg->send_len = val;
+
+    // READ PORT
+    if (nvs_get_u32(my_handle, NVS_KEY_IPERF_PORT, &val) == ESP_OK && val > 0) {
+        cfg->dport = (uint16_t)val;
+        ESP_LOGI(TAG, "NVS Port: %d", val);
+    }
 
     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);
-            trim_whitespace(ip_str); cfg->dip = inet_addr(ip_str); ESP_LOGI(TAG, "NVS Target IP: %s", ip_str); free(ip_str);
+            trim_whitespace(ip_str);
+            cfg->dip = inet_addr(ip_str);
+            ESP_LOGI(TAG, "NVS Target IP: %s", ip_str);
+            free(ip_str);
         }
     }
+
     if (nvs_get_str(my_handle, NVS_KEY_IPERF_ROLE, NULL, &required_size) == ESP_OK) {
         char *role = malloc(required_size);
         if (role) {
@@ -175,7 +178,7 @@ static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl)
     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;
+        s_led_state = LED_PURPLE_FLASH;
         return ESP_FAIL;
     }
 
@@ -183,15 +186,16 @@ static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl)
     addr.sin_port = htons(ctrl->cfg.dport);
     addr.sin_addr.s_addr = ctrl->cfg.dip;
 
-    uint32_t burst_count = ctrl->cfg.burst_count ? ctrl->cfg.burst_count : 1;
+    char ip_str[INET_ADDRSTRLEN];
-    uint32_t payload_len = ctrl->cfg.send_len ? ctrl->cfg.send_len : IPERF_UDP_TX_LEN;
+    inet_ntop(AF_INET, &addr.sin_addr, ip_str, INET_ADDRSTRLEN);
-    uint32_t pacing_period_us = ctrl->cfg.pacing_period_us ? ctrl->cfg.pacing_period_us : 10000;
+    ESP_LOGI(TAG, "Target: %s:%d", ip_str, ntohs(addr.sin_port));
+
+    uint32_t burst_count = ctrl->cfg.burst_count;
+    uint32_t payload_len = ctrl->cfg.send_len;
+    uint32_t pacing_period_us = ctrl->cfg.pacing_period_us;
 
-    // Calculate Rate just for logging
     double total_mbps = (double)((uint64_t)burst_count * payload_len * 8 * (1000000.0 / pacing_period_us)) / 1000000.0;
-
+    ESP_LOGI(TAG, "Pacing: %" PRIu32 " pkts every %" PRIu32 " us (Approx %.2f Mbps)", burst_count, pacing_period_us, total_mbps);
-    ESP_LOGI(TAG, "UDP Client -> Burst: %" PRIu32 " | Period: %" PRIu32 " us | Payload: %" PRIu32 " | Approx Rate: %.2f Mbps",
-             burst_count, pacing_period_us, payload_len, total_mbps);
 
     s_led_state = LED_PURPLE_SOLID;
 
@@ -199,7 +203,7 @@ static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl)
     uint32_t packet_count = 0;
     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);
+    int64_t end_time_us = (ctrl->cfg.time == UINT32_MAX) ? INT64_MAX : start_time_us + (int64_t)ctrl->cfg.time * 1000000LL;
 
     while (!ctrl->finish && esp_timer_get_time() < end_time_us) {
         int64_t current_time = esp_timer_get_time();
@@ -219,8 +223,8 @@ static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl)
                     client_hdr->numThreads = htonl(1);
                     client_hdr->mPort = htonl(ctrl->cfg.dport);
                     client_hdr->mBufLen = htonl(payload_len);
-                    client_hdr->mWinBand = htonl(0); // Paced by period
+                    client_hdr->mWinBand = htonl(0);
-                    client_hdr->mAmount = htonl(-(int)(ctrl->cfg.time * 100));
+                    client_hdr->mAmount = htonl(-(int)(10000));
                 }
 
                 int send_len = sendto(sockfd, ctrl->buffer, payload_len, 0, (struct sockaddr *)&addr, sizeof(addr));
@@ -234,7 +238,6 @@ static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl)
                     goto exit_client;
                 }
             }
-            // FIXED VARIABLE NAME HERE:
             next_send_time += pacing_period_us;
             if (esp_timer_get_time() > next_send_time + 4000) next_send_time = esp_timer_get_time() + pacing_period_us;
         } else {
@@ -251,7 +254,6 @@ exit_client:
 
 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);
@@ -259,7 +261,6 @@ static void iperf_task(void *arg) {
         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 (s_iperf_event_group) { vEventGroupDelete(s_iperf_event_group); s_iperf_event_group = NULL; }
     s_iperf_task_handle = NULL;
@@ -284,17 +285,15 @@ void iperf_start(iperf_cfg_t *cfg) {
         }
         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));
-    s_iperf_ctrl.cfg.flag = IPERF_FLAG_CLIENT | IPERF_FLAG_UDP; // Default
+    s_iperf_ctrl.cfg.flag = IPERF_FLAG_CLIENT | IPERF_FLAG_UDP;
 
     iperf_read_nvs_config(&s_iperf_ctrl.cfg);
     s_iperf_ctrl.finish = false;
 
-    // Buffer logic
     uint32_t alloc_len;
     if (s_iperf_ctrl.cfg.flag & IPERF_FLAG_TCP) {
         alloc_len = s_iperf_ctrl.cfg.flag & IPERF_FLAG_SERVER ? IPERF_TCP_RX_LEN : IPERF_TCP_TX_LEN;

components/iperf/iperf.h

@@ -18,36 +18,36 @@
 #define IPERF_SOCKET_RX_TIMEOUT 10
 #define IPERF_SOCKET_ACCEPT_TIMEOUT 5
 
-// Default buffer sizes
 #define IPERF_UDP_TX_LEN (1470)
 #define IPERF_UDP_RX_LEN (16 << 10)
 #define IPERF_TCP_TX_LEN (16 << 10)
 #define IPERF_TCP_RX_LEN (16 << 10)
 
 // NVS Keys
-#define NVS_KEY_IPERF_ENABLE "iperf_enabled" // 0=Disabled, 1=Enabled
+#define NVS_KEY_IPERF_ENABLE "iperf_enabled"
-#define NVS_KEY_IPERF_PERIOD "iperf_period"  // Period in microseconds (u32)
+#define NVS_KEY_IPERF_PERIOD "iperf_period"
-#define NVS_KEY_IPERF_ROLE   "iperf_role"    // "CLIENT" or "SERVER"
+#define NVS_KEY_IPERF_ROLE   "iperf_role"
-#define NVS_KEY_IPERF_DST_IP "iperf_dst_ip"  // Target IP String
+#define NVS_KEY_IPERF_DST_IP "iperf_dst_ip"
-#define NVS_KEY_IPERF_PROTO  "iperf_proto"   // "UDP" or "TCP"
+#define NVS_KEY_IPERF_PORT   "iperf_port"    // <--- NEW
-#define NVS_KEY_IPERF_BURST  "iperf_burst"   // Packets per period
+#define NVS_KEY_IPERF_PROTO  "iperf_proto"
-#define NVS_KEY_IPERF_LEN    "iperf_len"     // UDP Payload Length
+#define NVS_KEY_IPERF_BURST  "iperf_burst"
+#define NVS_KEY_IPERF_LEN    "iperf_len"
 
 typedef struct {
     uint32_t flag;
     uint8_t  type;
-    uint32_t dip;        // Destination IP
+    uint32_t dip;
-    uint16_t dport;      // Dest Port
+    uint16_t dport;
-    uint16_t sport;      // Source Port
+    uint16_t sport;
     uint32_t interval;
-    uint32_t time;       // Test Duration (seconds)
+    uint32_t time;
 
-    // Pacing Config
+    // Pacing
-    uint32_t pacing_period_us; // Period between bursts in microseconds
+    uint32_t pacing_period_us;
-    uint32_t burst_count;      // Packets per period
+    uint32_t burst_count;
 
-    uint32_t send_len;   // User defined Payload Length
+    uint32_t send_len;
-    uint32_t buffer_len; // Internally calculated buffer size
+    uint32_t buffer_len;
 } iperf_cfg_t;
 
 typedef struct {
@@ -61,27 +61,24 @@ typedef struct {
     uint32_t udp_packet_counter;
 } iperf_traffic_t;
 
-// Standard UDP Datagram Header
 typedef struct {
-    int32_t id;          // Sequence Number
+    int32_t id;
-    uint32_t tv_sec;     // Timestamp Seconds
+    uint32_t tv_sec;
-    uint32_t tv_usec;    // Timestamp Microseconds
+    uint32_t tv_usec;
-    uint32_t id2;        // 64-bit seq / Padding
+    uint32_t id2;
 } udp_datagram;
 
-// Client Header
 typedef struct {
-    int32_t flags;       // Flags (Version, etc.)
+    int32_t flags;
-    int32_t numThreads;  // Parallel threads
+    int32_t numThreads;
-    int32_t mPort;       // Port
+    int32_t mPort;
-    int32_t mBufLen;     // Buffer Length
+    int32_t mBufLen;
-    int32_t mWinBand;    // Target Bandwidth (Legacy field, sent as 0 or placeholder)
+    int32_t mWinBand;
-    int32_t mAmount;     // Duration / Bytes
+    int32_t mAmount;
 } client_hdr_v1;
 
 #define HEADER_VERSION1 0x80000000
 
-// Public API
 void iperf_start(iperf_cfg_t *cfg);
 void iperf_stop(void);
 

esp32_deploy.py

@@ -133,12 +133,15 @@ class UnifiedDeployWorker:
 
     async def _send_config(self, writer):
         csi_val = '1' if self.args.csi_enable else '0'
+
         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'
 
-        # Convert period (seconds) to microseconds (integer)
+        # Convert period to microseconds
         period_us = int(self.args.iperf_period * 1000000)
 
         config_str = (
@@ -146,10 +149,13 @@ class UnifiedDeployWorker:
             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_PERIOD_US:{period_us}\n"  # <--- Changed from RATE to PERIOD_US
+            f"IPERF_PERIOD_US:{period_us}\n"
             f"IPERF_ROLE:{role_str}\n"
-            f"IPERF_PROTO:{self.args.iperf_proto}\nIPERF_DEST_IP:{self.args.iperf_dest_ip}\n"
+            f"IPERF_PROTO:{self.args.iperf_proto}\n"
-            f"IPERF_BURST:{self.args.iperf_burst}\nIPERF_LEN:{self.args.iperf_len}\n"
+            f"IPERF_DEST_IP:{self.args.iperf_dest_ip}\n"
+            f"IPERF_PORT:{self.args.iperf_port}\n"  # <--- NEW: Port
+            f"IPERF_BURST:{self.args.iperf_burst}\n"
+            f"IPERF_LEN:{self.args.iperf_len}\n"
             f"IPERF_ENABLED:{iperf_enable_val}\n"
             f"END\n"
         )
@@ -162,7 +168,8 @@ class UnifiedDeployWorker:
             try:
                 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
+                # We consider saving to NVS as success indicators now
+                if "Config saved" in line or self.regex_csi_saved.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
@@ -171,35 +178,43 @@ class UnifiedDeployWorker:
 def parse_args():
     parser = argparse.ArgumentParser(description='ESP32 Unified Deployment Tool')
 
+    # Operation Mode
     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
     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')
+    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
     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
     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')
 
-    # Iperf Settings (Updated)
+    # Iperf
-    parser.add_argument('--iperf-period', type=float, default=0.01,
+    parser.add_argument('--iperf-period', type=float, default=0.01, help='Seconds between bursts')
-                        help='Pacing period in seconds (default: 0.01s = 10ms)')
+    parser.add_argument('--iperf-burst', type=int, default=1, help='Packets/tick')
-    parser.add_argument('--iperf-burst', type=int, default=1, help='Packets per period')
     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('--iperf-port', type=int, default=5001, help='Dest Port') # <--- NEW
     parser.add_argument('--no-iperf', action='store_true', help='Disable Iperf start')
 
     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')