Umber
/
ESP32
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ESP32/components/iperf/iperf.c

599 lines
21 KiB
C
Raw Blame History

/*
* iperf.c
*
* Copyright (c) 2025 Umber Networks & Robert McMahon
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file iperf.c
* @brief ESP32 iPerf Traffic Generator (UDP Client Only) with Trip-Time Support
*
* This module implements a lightweight UDP traffic generator compatible with iPerf2.
* It features:
* - Precise packet pacing (PPS) using monotonic timers (drift-free).
* - Finite State Machine (FSM) to detect stalls and slow links.
* - Non-Volatile Storage (NVS) for persistent configuration.
* - Detailed error tracking (ENOMEM vs Route errors).
* - GPS Timestamp integration for status reporting.
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <inttypes.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <time.h>
#include <errno.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"
#include "status_led.h"
#include "gps_sync.h"
static const char *TAG = "iperf";
// --- NVS Keys ---
#define NVS_KEY_IPERF_ENABLE "iperf_enabled"
#define NVS_KEY_IPERF_PPS "iperf_pps"
#define NVS_KEY_IPERF_ROLE "iperf_role"
#define NVS_KEY_IPERF_DST_IP "iperf_dst_ip"
#define NVS_KEY_IPERF_PORT "iperf_port"
#define NVS_KEY_IPERF_PROTO "iperf_proto"
#define NVS_KEY_IPERF_BURST "iperf_burst"
#define NVS_KEY_IPERF_LEN "iperf_len"
// --- Global Config State ---
static iperf_cfg_t s_staging_cfg = {0};
static bool s_staging_initialized = false;
static EventGroupHandle_t s_iperf_event_group = NULL;
#define IPERF_IP_READY_BIT (1 << 0)
#define IPERF_STOP_REQ_BIT (1 << 1)
#define RATE_CHECK_INTERVAL_US 500000
#define MIN_PACING_INTERVAL_US 100
// --- Runtime Control ---
typedef struct {
iperf_cfg_t cfg;
bool finish;
uint32_t buffer_len;
uint8_t *buffer;
} iperf_ctrl_t;
static iperf_ctrl_t s_iperf_ctrl = {0};
static TaskHandle_t s_iperf_task_handle = NULL;
static bool s_reload_req = false;
// Global Stats Tracker
static iperf_stats_t s_stats = {0};
static int64_t s_session_start_time = 0;
static int64_t s_session_end_time = 0;
// --- FSM State & Stats ---
typedef enum {
IPERF_STATE_IDLE = 0,
IPERF_STATE_TX,
IPERF_STATE_TX_SLOW,
IPERF_STATE_TX_STALLED
} iperf_fsm_state_t;
static iperf_fsm_state_t s_current_fsm_state = IPERF_STATE_IDLE;
static int64_t s_time_tx_us = 0;
static int64_t s_time_slow_us = 0;
static int64_t s_time_stalled_us = 0;
static uint32_t s_edge_tx = 0;
static uint32_t s_edge_slow = 0;
static uint32_t s_edge_stalled = 0;
static esp_event_handler_instance_t instance_any_id;
static esp_event_handler_instance_t instance_got_ip;
// --- Packet Structures & Constants (Compatible with payloads.h) ---
#define HEADER_EXTEND 0x80000000
#define HEADER_SEQNO64B 0x08000000
#define HEADER_TRIPTIME 0x00020000 // Use the small trip time flag
// UDP Datagram Header
struct udp_datagram {
int32_t id;
uint32_t tv_sec;
uint32_t tv_usec;
int32_t id2;
uint16_t flags;
uint32_t start_tv_sec;
uint32_t start_tv_usec;
};
// --- Helper: Defaults ---
static void set_defaults(iperf_cfg_t *cfg) {
memset(cfg, 0, sizeof(iperf_cfg_t));
cfg->flag = IPERF_FLAG_CLIENT | IPERF_FLAG_UDP;
cfg->dip = 0;
cfg->dport = IPERF_DEFAULT_PORT;
cfg->target_pps = 100;
cfg->burst_count = 1;
cfg->send_len = IPERF_UDP_TX_LEN;
}
// --- Parameter Management ---
static void trim_whitespace(char *str) {
char *end = str + strlen(str) - 1;
while(end > str && isspace((unsigned char)*end)) end--;
*(end+1) = 0;
}
void iperf_param_clear(void) {
nvs_handle_t h;
if (nvs_open("storage", NVS_READWRITE, &h) == ESP_OK) {
nvs_erase_key(h, NVS_KEY_IPERF_PPS);
nvs_erase_key(h, NVS_KEY_IPERF_BURST);
nvs_erase_key(h, NVS_KEY_IPERF_LEN);
nvs_erase_key(h, NVS_KEY_IPERF_PORT);
nvs_erase_key(h, NVS_KEY_IPERF_DST_IP);
nvs_commit(h);
nvs_close(h);
ESP_LOGI(TAG, "iPerf NVS configuration cleared.");
}
set_defaults(&s_staging_cfg);
}
void iperf_param_init(void) {
if (s_staging_initialized) return;
set_defaults(&s_staging_cfg);
nvs_handle_t h;
if (nvs_open("storage", NVS_READONLY, &h) == ESP_OK) {
ESP_LOGI(TAG, "Loading saved config from NVS...");
uint32_t val;
if (nvs_get_u32(h, NVS_KEY_IPERF_PPS, &val) == ESP_OK && val > 0) s_staging_cfg.target_pps = val;
if (nvs_get_u32(h, NVS_KEY_IPERF_BURST, &val) == ESP_OK) s_staging_cfg.burst_count = val;
if (nvs_get_u32(h, NVS_KEY_IPERF_LEN, &val) == ESP_OK) s_staging_cfg.send_len = val;
if (nvs_get_u32(h, NVS_KEY_IPERF_PORT, &val) == ESP_OK) s_staging_cfg.dport = (uint16_t)val;
size_t req;
if (nvs_get_str(h, NVS_KEY_IPERF_DST_IP, NULL, &req) == ESP_OK) {
char *ip_str = malloc(req);
if (ip_str) {
nvs_get_str(h, NVS_KEY_IPERF_DST_IP, ip_str, &req);
trim_whitespace(ip_str);
s_staging_cfg.dip = inet_addr(ip_str);
free(ip_str);
}
}
nvs_close(h);
}
s_staging_initialized = true;
}
void iperf_param_get(iperf_cfg_t *out_cfg) {
if (!s_staging_initialized) iperf_param_init();
*out_cfg = s_staging_cfg;
}
void iperf_param_set(const iperf_cfg_t *new_cfg) {
if (!s_staging_initialized) iperf_param_init();
s_staging_cfg = *new_cfg;
if (s_iperf_task_handle) {
ESP_LOGI(TAG, "Hot reloading parameters...");
s_iperf_ctrl.cfg = s_staging_cfg;
s_reload_req = true;
if (s_iperf_event_group) xEventGroupSetBits(s_iperf_event_group, IPERF_STOP_REQ_BIT);
}
}
bool iperf_param_is_unsaved(void) {
if (!s_staging_initialized) return false;
nvs_handle_t h;
if (nvs_open("storage", NVS_READONLY, &h) != ESP_OK) return false;
uint32_t val;
bool match = true;
if (nvs_get_u32(h, NVS_KEY_IPERF_PPS, &val) == ESP_OK) { if (s_staging_cfg.target_pps != val) match = false; }
else if (s_staging_cfg.target_pps != 100) match = false;
// ...
nvs_close(h);
return !match;
}
esp_err_t iperf_param_save(bool *out_changed) {
if (out_changed) *out_changed = false;
nvs_handle_t h;
if (nvs_open("storage", NVS_READWRITE, &h) != ESP_OK) return ESP_FAIL;
nvs_set_u32(h, NVS_KEY_IPERF_PPS, s_staging_cfg.target_pps);
nvs_set_u32(h, NVS_KEY_IPERF_BURST, s_staging_cfg.burst_count);
nvs_set_u32(h, NVS_KEY_IPERF_LEN, s_staging_cfg.send_len);
nvs_set_u32(h, NVS_KEY_IPERF_PORT, s_staging_cfg.dport);
char ip_str[32];
struct in_addr daddr; daddr.s_addr = s_staging_cfg.dip;
inet_ntop(AF_INET, &daddr, ip_str, sizeof(ip_str));
nvs_set_str(h, NVS_KEY_IPERF_DST_IP, ip_str);
esp_err_t err = nvs_commit(h);
if (err == ESP_OK && out_changed) *out_changed = true;
nvs_close(h);
return err;
}
// --- Status ---
void iperf_get_stats(iperf_stats_t *stats) {
if (stats) {
s_stats.config_pps = s_iperf_ctrl.cfg.target_pps;
*stats = s_stats;
}
}
void iperf_print_status(void) {
iperf_get_stats(&s_stats);
gps_timestamp_t ts = gps_get_timestamp();
// Check both Synced (PPS) and Valid (NMEA)
if (ts.synced && ts.valid && ts.gps_us > 0) {
time_t now_sec = ts.gps_us / 1000000;
struct tm tm_info;
gmtime_r(&now_sec, &tm_info);
char time_buf[64];
strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S UTC", &tm_info);
printf("TIME: %s (GPS Locked)\n", time_buf);
} else {
printf("TIME: <Not Synced - PPS:%d NMEA:%d>\n", ts.synced, ts.valid);
}
char dst_ip[32] = "0.0.0.0";
struct in_addr daddr;
if (s_stats.running) daddr.s_addr = s_iperf_ctrl.cfg.dip;
else daddr.s_addr = s_staging_cfg.dip;
inet_ntop(AF_INET, &daddr, dst_ip, sizeof(dst_ip));
double total_us = (double)(s_time_tx_us + s_time_slow_us + s_time_stalled_us);
if (total_us < 1.0) total_us = 1.0;
double pct_tx = ((double)s_time_tx_us / total_us) * 100.0;
double pct_slow = ((double)s_time_slow_us / total_us) * 100.0;
double pct_stalled = ((double)s_time_stalled_us / total_us) * 100.0;
float avg_bw_mbps = 0.0f;
if (s_session_start_time > 0) {
int64_t end_t = (s_stats.running) ? esp_timer_get_time() : s_session_end_time;
if (end_t > s_session_start_time) {
double duration_sec = (double)(end_t - s_session_start_time) / 1000000.0;
if (duration_sec > 0.001) {
double total_bits = (double)s_stats.total_packets * (double)s_iperf_ctrl.cfg.send_len * 8.0;
avg_bw_mbps = (float)(total_bits / duration_sec / 1000000.0);
}
}
}
printf("IPERF: Dest=%s:%u, Pkts=%llu, BW=%.2f Mbps, Running=%d\n",
dst_ip,
s_stats.running ? s_iperf_ctrl.cfg.dport : s_staging_cfg.dport,
s_stats.total_packets,
avg_bw_mbps,
s_stats.running);
printf("STATES: TX=%.2fs/%.1f%% (%lu), SLOW=%.2fs/%.1f%% (%lu), STALLED=%.2fs/%.1f%% (%lu)\n",
(double)s_time_tx_us/1000000.0, pct_tx, (unsigned long)s_edge_tx,
(double)s_time_slow_us/1000000.0, pct_slow, (unsigned long)s_edge_slow,
(double)s_time_stalled_us/1000000.0, pct_stalled, (unsigned long)s_edge_stalled);
printf("ERRORS: ENOMEM=%lu, EHOST=%lu, OTHER=%lu\n",
(unsigned long)s_stats.err_mem,
(unsigned long)s_stats.err_route,
(unsigned long)s_stats.err_other);
}
// --- Core Logic ---
static void iperf_pattern(uint8_t *buf, uint32_t len) {
for (uint32_t i = 0; i < len; i++) buf[i] = (i % 10) + '0';
}
static void iperf_generate_headers(iperf_cfg_t *cfg, uint8_t *buffer, bool gps_synced, struct timespec *start_time) {
struct udp_datagram *udp_hdr = (struct udp_datagram *)buffer;
// Clear Header Area
memset(udp_hdr, 0, sizeof(struct udp_datagram));
if (gps_synced) {
udp_hdr->flags = htonl(HEADER_EXTEND | HEADER_SEQNO64B | HEADER_TRIPTIME);
udp_hdr->start_tv_sec = htonl(start_time->tv_sec);
udp_hdr->start_tv_usec = htonl(start_time->tv_nsec / 1000);
#if 0
ESP_LOGI(TAG, "TX Start Timestamp: %" PRIu32 ".%06" PRIu32,
(uint32_t)start_time.tv_sec, (uint32_t)(start_time.tv_nsec / 1000));
#endif
} else {
udp_hdr->flags = htonl(HEADER_EXTEND | HEADER_SEQNO64B);
}
}
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 == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
xEventGroupSetBits(s_iperf_event_group, IPERF_IP_READY_BIT);
}
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
xEventGroupClearBits(s_iperf_event_group, IPERF_IP_READY_BIT);
status_led_set_state(LED_STATE_NO_CONFIG);
}
}
static bool iperf_wait_for_ip(void) {
if (!s_iperf_event_group) s_iperf_event_group = xEventGroupCreate();
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 && ip_info.ip.addr != 0) return true;
}
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));
status_led_set_state(LED_STATE_WAITING);
ESP_LOGI(TAG, "Waiting for IP...");
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_udp_client(iperf_ctrl_t *ctrl) {
if (!iperf_wait_for_ip()) return ESP_OK;
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(ctrl->cfg.dport);
addr.sin_addr.s_addr = ctrl->cfg.dip;
int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sockfd < 0) {
ESP_LOGE(TAG, "Socket failed: %d", errno);
status_led_set_state(LED_STATE_FAILED);
return ESP_FAIL;
}
status_led_set_state(LED_STATE_TRANSMITTING_SLOW);
// --- CHECK GPS SYNC ---
gps_timestamp_t gps = gps_get_timestamp();
// FIX: Must have valid NMEA (absolute time) AND PPS (precision)
bool gps_synced = gps.synced && gps.valid;
struct timespec start_ts = {0};
if (gps_synced) {
ESP_LOGI(TAG, "GPS Locked (PPS + NMEA). Enabling Trip-Times.");
clock_gettime(CLOCK_REALTIME, &start_ts);
} else {
ESP_LOGW(TAG, "GPS NOT Fully Locked (PPS:%d, NMEA:%d). Trip-Times disabled.", gps.synced, gps.valid);
}
// --- GENERATE HEADERS ---
iperf_generate_headers(&ctrl->cfg, ctrl->buffer, gps_synced, &start_ts);
s_stats.running = true;
s_stats.err_mem = 0; s_stats.err_route = 0; s_stats.err_other = 0;
s_stats.total_packets = 0;
s_session_start_time = esp_timer_get_time();
s_time_tx_us = 0; s_time_slow_us = 0; s_time_stalled_us = 0;
s_edge_tx = 0; s_edge_slow = 0; s_edge_stalled = 0;
s_current_fsm_state = IPERF_STATE_IDLE;
ESP_LOGI(TAG, "UDP Started. Target: %s", inet_ntoa(addr.sin_addr));
int64_t next_send_time = esp_timer_get_time();
int64_t last_rate_check = esp_timer_get_time();
uint32_t packets_since_check = 0;
int64_t packet_id = 0;
struct timespec ts;
uint32_t period_us = (ctrl->cfg.target_pps > 0) ? (1000000 / ctrl->cfg.target_pps) : 10000;
if (period_us < MIN_PACING_INTERVAL_US) period_us = MIN_PACING_INTERVAL_US;
while (!ctrl->finish && !s_reload_req) {
int64_t now = esp_timer_get_time();
int64_t wait = next_send_time - now;
if (wait > 2000) vTaskDelay(pdMS_TO_TICKS(wait / 1000));
while (esp_timer_get_time() < next_send_time) taskYIELD();
if (xEventGroupGetBits(s_iperf_event_group) & IPERF_STOP_REQ_BIT) break;
for (int k = 0; k < ctrl->cfg.burst_count; k++) {
int64_t current_id = packet_id++;
struct udp_datagram *udp_hdr = (struct udp_datagram *)ctrl->buffer;
udp_hdr->id = htonl((uint32_t)(current_id & 0xFFFFFFFF));
udp_hdr->id2 = htonl((uint32_t)((current_id >> 32) & 0xFFFFFFFF));
clock_gettime(CLOCK_REALTIME, &ts);
udp_hdr->tv_sec = htonl((uint32_t)ts.tv_sec);
udp_hdr->tv_usec = htonl(ts.tv_nsec / 1000);
int ret = sendto(sockfd, ctrl->buffer, ctrl->cfg.send_len, 0, (struct sockaddr *)&addr, sizeof(addr));
if (ret > 0) {
s_stats.total_packets++;
packets_since_check++;
} else {
if (errno == ENOMEM) s_stats.err_mem++;
else {
if (errno == EHOSTUNREACH) s_stats.err_route++;
else s_stats.err_other++;
vTaskDelay(pdMS_TO_TICKS(10));
}
}
}
now = esp_timer_get_time();
if (now - last_rate_check > RATE_CHECK_INTERVAL_US) {
uint32_t interval_us = (uint32_t)(now - last_rate_check);
if (interval_us > 0) {
s_stats.actual_pps = (uint32_t)((uint64_t)packets_since_check * 1000000 / interval_us);
uint32_t threshold = (ctrl->cfg.target_pps * 3) / 4;
iperf_fsm_state_t next_state;
if (s_stats.actual_pps == 0) next_state = IPERF_STATE_TX_STALLED;
else if (s_stats.actual_pps >= threshold) next_state = IPERF_STATE_TX;
else next_state = IPERF_STATE_TX_SLOW;
switch (next_state) {
case IPERF_STATE_TX: s_time_tx_us += interval_us; break;
case IPERF_STATE_TX_SLOW: s_time_slow_us += interval_us; break;
case IPERF_STATE_TX_STALLED: s_time_stalled_us += interval_us; break;
default: break;
}
if (next_state != s_current_fsm_state) {
switch (next_state) {
case IPERF_STATE_TX: s_edge_tx++; break;
case IPERF_STATE_TX_SLOW: s_edge_slow++; break;
case IPERF_STATE_TX_STALLED: s_edge_stalled++; break;
default: break;
}
s_current_fsm_state = next_state;
}
led_state_t led_target = LED_STATE_TRANSMITTING;
if (next_state == IPERF_STATE_TX_SLOW) led_target = LED_STATE_TRANSMITTING_SLOW;
if (next_state == IPERF_STATE_TX_STALLED) led_target = LED_STATE_STALLED;
status_led_set_state(led_target);
}
last_rate_check = now;
packets_since_check = 0;
}
next_send_time += period_us;
}
int64_t final_id = -packet_id;
struct udp_datagram *udp_hdr = (struct udp_datagram *)ctrl->buffer;
udp_hdr->id = htonl((uint32_t)(final_id & 0xFFFFFFFF));
udp_hdr->id2 = htonl((uint32_t)((final_id >> 32) & 0xFFFFFFFF));
clock_gettime(CLOCK_REALTIME, &ts);
udp_hdr->tv_sec = htonl((uint32_t)ts.tv_sec);
udp_hdr->tv_usec = htonl(ts.tv_nsec / 1000);
for (int i=0; i<10; i++) {
sendto(sockfd, ctrl->buffer, ctrl->cfg.send_len, 0, (struct sockaddr *)&addr, sizeof(addr));
vTaskDelay(pdMS_TO_TICKS(2));
}
ESP_LOGI(TAG, "Sent termination (ID: %" PRId64 ")", final_id);
close(sockfd);
s_stats.running = false;
s_session_end_time = esp_timer_get_time();
status_led_set_state(LED_STATE_CONNECTED);
return ESP_OK;
}
static void iperf_task(void *arg) {
iperf_ctrl_t *ctrl = (iperf_ctrl_t *)arg;
while (1) {
s_reload_req = false;
ctrl->finish = false;
xEventGroupClearBits(s_iperf_event_group, IPERF_STOP_REQ_BIT);
iperf_start_udp_client(ctrl);
if (s_reload_req) {
ESP_LOGI(TAG, "Task reloading config...");
if (ctrl->buffer_len < ctrl->cfg.send_len + 128) {
free(ctrl->buffer);
ctrl->buffer_len = ctrl->cfg.send_len + 128;
ctrl->buffer = calloc(1, ctrl->buffer_len);
iperf_pattern(ctrl->buffer, ctrl->buffer_len);
}
} else {
break;
}
}
free(ctrl->buffer);
s_iperf_task_handle = NULL;
vTaskDelete(NULL);
}
void iperf_start(void) {
if (!s_staging_initialized) iperf_param_init();
if (s_iperf_task_handle) {
ESP_LOGW(TAG, "Already running. Use 'set' to update parameters.");
return;
}
s_iperf_ctrl.cfg = s_staging_cfg;
s_iperf_ctrl.finish = false;
s_iperf_ctrl.buffer_len = s_iperf_ctrl.cfg.send_len + 128;
s_iperf_ctrl.buffer = calloc(1, s_iperf_ctrl.buffer_len);
if (s_iperf_ctrl.buffer) {
iperf_pattern(s_iperf_ctrl.buffer, s_iperf_ctrl.buffer_len);
}
if (s_iperf_event_group == NULL) s_iperf_event_group = xEventGroupCreate();
xTaskCreate(iperf_task, "iperf", 4096, &s_iperf_ctrl, 5, &s_iperf_task_handle);
}
void iperf_stop(void) {
if (s_iperf_task_handle) {
s_iperf_ctrl.finish = true;
if (s_iperf_event_group) xEventGroupSetBits(s_iperf_event_group, IPERF_STOP_REQ_BIT);
}
}
Reference in New Issue View Git Blame Copy Permalink