alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-09-26 15:13:28 -04:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity
19a6f10d3c
esp-idf/examples/phy/cert_test/main/cmd_phy.c

541 lines
16 KiB
C
Raw Normal View History

Add cert test example
2023-01-31 04:23:22 -05:00
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_console.h"
#include "argtable3/argtable3.h"
#include "esp_phy_cert_test.h"
#include "cmd_phy.h"
#define TAG "cmd_phy"
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
#define CERT_TASK_PRIO 2
Add cert test example
2023-01-31 04:23:22 -05:00
#if CONFIG_ESP_PHY_ENABLE_CERT_TEST
static phy_args_t phy_args;
#if SOC_WIFI_SUPPORTED
static phy_wifi_tx_t phy_wifi_tx_args;
static phy_wifi_rx_t phy_wifi_rx_args;
static phy_wifiscwout_t phy_wifiscwout_args;
#endif
#if SOC_BT_SUPPORTED
static phy_ble_tx_t phy_ble_tx_args;
static phy_ble_rx_t phy_ble_rx_args;
static phy_bt_tx_tone_t phy_bt_tx_tone_args;
#endif
example: support legacy PHY commands in cert_test
2023-04-23 01:08:39 -04:00
#if CONFIG_ESP_PHY_LEGACY_COMMANDS
#define arg_int0(_a, _b, _c, _d) arg_int0(NULL, NULL, _c, _d)
#define arg_int1(_a, _b, _c, _d) arg_int1(NULL, NULL, _c, _d)
#endif
Add cert test example
2023-01-31 04:23:22 -05:00
static int esp_phy_tx_contin_en_func(int argc, char **argv)
{
int nerrors = arg_parse(argc, argv, (void **) &phy_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_args.end, argv[0]);
return 1;
}
if (phy_args.enable->count == 1) {
esp_phy_tx_contin_en(phy_args.enable->ival[0]);
} else {
ESP_LOGW(TAG, "Please enter the enable parameter");
}
return 0;
}
static int esp_phy_cmdstop_func(int argc, char **argv)
{
int nerrors = arg_parse(argc, argv, (void **) &phy_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_args.end, argv[0]);
return 1;
}
esp_phy_test_start_stop(0);
return 0;
}
Add the output RX result command
2023-02-16 02:31:32 -05:00
static int esp_phy_get_rx_result_func(int argc, char **argv)
{
esp_phy_rx_result_t rx_result;
int nerrors = arg_parse(argc, argv, (void **) &phy_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_args.end, argv[0]);
return 1;
}
esp_phy_get_rx_result(&rx_result);
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
ESP_LOGI(TAG, "Desired: %lu, Correct: %lu, RSSI: %d, flag: %lu", rx_result.phy_rx_total_count,
Add the output RX result command
2023-02-16 02:31:32 -05:00
rx_result.phy_rx_correct_count, rx_result.phy_rx_rssi, rx_result.phy_rx_result_flag);
return 0;
}
Add cert test example
2023-01-31 04:23:22 -05:00
#if SOC_WIFI_SUPPORTED
void cert_wifi_tx(void *arg)
{
phy_wifi_tx_s *cmd = (phy_wifi_tx_s*)arg;
esp_phy_test_start_stop(3);
esp_phy_wifi_tx(cmd->channel, cmd->rate, cmd->backoff, cmd->length_byte, cmd->packet_delay, cmd->packet_num);
vTaskDelete(NULL);
}
void cert_wifi_rx(void *arg)
{
phy_wifi_rx_s *cmd = (phy_wifi_rx_s*)arg;
esp_phy_test_start_stop(3);
esp_phy_wifi_rx(cmd->channel, cmd->rate);
vTaskDelete(NULL);
}
static int esp_phy_cbw40m_en_func(int argc, char **argv)
{
int nerrors = arg_parse(argc, argv, (void **) &phy_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_args.end, argv[0]);
return 1;
}
if (phy_args.enable->count == 1) {
esp_phy_cbw40m_en(phy_args.enable->ival[0]);
} else {
ESP_LOGW(TAG, "Please enter the enable parameter");
}
return 0;
}
static int esp_phy_wifi_tx_func(int argc, char **argv)
{
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
static phy_wifi_tx_s cmd;
Add cert test example
2023-01-31 04:23:22 -05:00
int nerrors = arg_parse(argc, argv, (void **) &phy_wifi_tx_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_wifi_tx_args.end, argv[0]);
return 1;
}
if (phy_wifi_tx_args.channel->count == 1) {
cmd.channel = phy_wifi_tx_args.channel->ival[0];
} else {
cmd.channel = 1;
ESP_LOGW(TAG, "Default channel is 1");
}
if (phy_wifi_tx_args.rate->count == 1) {
cmd.rate = phy_wifi_tx_args.rate->ival[0];
} else {
cmd.rate = PHY_RATE_1M;
ESP_LOGW(TAG, "Default rate is PHY_RATE_1M");
}
if (phy_wifi_tx_args.attenuation->count == 1) {
cmd.backoff = phy_wifi_tx_args.attenuation->ival[0];
} else {
cmd.backoff = 0;
ESP_LOGW(TAG, "Default backoff is 0");
}
if (phy_wifi_tx_args.length_byte->count == 1) {
cmd.length_byte = phy_wifi_tx_args.length_byte->ival[0];
} else {
cmd.length_byte = 1000;
ESP_LOGW(TAG, "Default length_byte is 1000");
}
if (phy_wifi_tx_args.packet_delay->count == 1) {
cmd.packet_delay = phy_wifi_tx_args.packet_delay->ival[0];
} else {
cmd.packet_delay = 1000;
ESP_LOGW(TAG, "Default packet_delay is 1000");
}
if (phy_wifi_tx_args.packet_num->count == 1) {
cmd.packet_num = phy_wifi_tx_args.packet_num->ival[0];
} else {
cmd.packet_num = 0;
ESP_LOGW(TAG, "Default packet_num is 0");
}
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
xTaskCreate(cert_wifi_tx, "cert_wifi_tx", 1024 * 10, (void *)&cmd, CERT_TASK_PRIO, NULL);
Add cert test example
2023-01-31 04:23:22 -05:00
return 0;
}
static int esp_phy_wifi_rx_func(int argc, char **argv)
{
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
static phy_wifi_rx_s cmd;
Add cert test example
2023-01-31 04:23:22 -05:00
int nerrors = arg_parse(argc, argv, (void **) &phy_wifi_rx_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_wifi_rx_args.end, argv[0]);
return 1;
}
if (phy_wifi_rx_args.channel->count == 1) {
cmd.channel = phy_wifi_rx_args.channel->ival[0];
} else {
cmd.channel = 1;
ESP_LOGW(TAG, "Default channel is 1");
}
if (phy_wifi_rx_args.rate->count == 1) {
cmd.rate = phy_wifi_rx_args.rate->ival[0];
} else {
cmd.rate = PHY_RATE_1M;
ESP_LOGW(TAG, "Default rate is PHY_RATE_1M");
}
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
xTaskCreate(cert_wifi_rx, "cert_wifi_rx", 1024 * 20, (void *)&cmd, CERT_TASK_PRIO, NULL);
Add cert test example
2023-01-31 04:23:22 -05:00
return 0;
}
static int esp_phy_wifiscwout_func(int argc, char **argv)
{
uint32_t enable;
uint32_t channel;
uint32_t attenuation;
int nerrors = arg_parse(argc, argv, (void **) &phy_wifiscwout_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_wifiscwout_args.end, argv[0]);
return 1;
}
if (phy_wifiscwout_args.enable->count == 1) {
enable = phy_wifiscwout_args.enable->ival[0];
} else {
enable = 1;
ESP_LOGW(TAG, "Default enable is 1");
}
if (phy_wifiscwout_args.channel->count == 1) {
channel = phy_wifiscwout_args.channel->ival[0];
} else {
channel = 1;
ESP_LOGW(TAG, "Default channel is 1");
}
if (phy_wifiscwout_args.attenuation->count == 1) {
attenuation = phy_wifiscwout_args.attenuation->ival[0];
} else {
attenuation = 0;
ESP_LOGW(TAG, "Default attenuation is 0");
}
esp_phy_wifi_tx_tone(enable, channel, attenuation);
return 0;
}
#endif
#if SOC_BT_SUPPORTED
void cert_ble_tx(void *arg)
{
phy_ble_tx_s *cmd = (phy_ble_tx_s *)arg;
esp_phy_test_start_stop(3);
esp_phy_ble_tx(cmd->txpwr, cmd->channel, cmd->len, cmd->data_type, cmd->syncw, cmd->rate, cmd->tx_num_in);
vTaskDelete(NULL);
}
void cert_ble_rx(void *arg)
{
phy_ble_rx_s *cmd = (phy_ble_rx_s *)arg;
esp_phy_test_start_stop(3);
esp_phy_ble_rx(cmd->channel, cmd->syncw, cmd->rate);
vTaskDelete(NULL);
}
static int esp_phy_ble_tx_func(int argc, char **argv)
{
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
static phy_ble_tx_s cmd;
Add cert test example
2023-01-31 04:23:22 -05:00
int nerrors = arg_parse(argc, argv, (void **) &phy_ble_tx_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_ble_tx_args.end, argv[0]);
return 1;
}
if (phy_ble_tx_args.txpwr->count == 1) {
cmd.txpwr = phy_ble_tx_args.txpwr->ival[0];
} else {
cmd.txpwr = 8;
ESP_LOGW(TAG, "Default txpwr is 8");
}
if (phy_ble_tx_args.channel->count == 1) {
cmd.channel = phy_ble_tx_args.channel->ival[0];
} else {
cmd.channel = 1;
ESP_LOGW(TAG, "Default channel is 1");
}
if (phy_ble_tx_args.len->count == 1) {
cmd.len = phy_ble_tx_args.len->ival[0];
} else {
cmd.len = 37;
ESP_LOGW(TAG, "Default len is 37");
}
if (phy_ble_tx_args.data_type->count == 1) {
cmd.data_type = phy_ble_tx_args.data_type->ival[0];
} else {
cmd.data_type = PHY_BLE_TYPE_prbs9;
ESP_LOGW(TAG, "Default data_type is PHY_BLE_TYPE_prbs9");
}
if (phy_ble_tx_args.syncw->count == 1) {
cmd.syncw = phy_ble_tx_args.syncw->ival[0];
} else {
cmd.syncw = 0x71764129;
ESP_LOGW(TAG, "Default syncw is 0x71764129");
}
if (phy_ble_tx_args.rate->count == 1) {
cmd.rate = phy_ble_tx_args.rate->ival[0];
} else {
cmd.rate = PHY_BLE_RATE_1M;
ESP_LOGW(TAG, "Default rate is PHY_BLE_RATE_1M");
}
if (phy_ble_tx_args.tx_num_in->count == 1) {
cmd.tx_num_in = phy_ble_tx_args.tx_num_in->ival[0];
} else {
cmd.tx_num_in = 0;
ESP_LOGW(TAG, "Default tx_num_in is 0");
}
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
xTaskCreate(cert_ble_tx, "cert_ble_tx", 4096, (void *)&cmd, CERT_TASK_PRIO, NULL);
Add cert test example
2023-01-31 04:23:22 -05:00
return 0;
}
static int esp_phy_ble_rx_func(int argc, char **argv)
{
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
static phy_ble_rx_s cmd;
Add cert test example
2023-01-31 04:23:22 -05:00
int nerrors = arg_parse(argc, argv, (void **) &phy_ble_rx_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_ble_rx_args.end, argv[0]);
return 1;
}
if (phy_ble_rx_args.channel->count == 1) {
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
cmd.channel = phy_ble_rx_args.channel->ival[0];
Add cert test example
2023-01-31 04:23:22 -05:00
} else {
cmd.channel = 1;
ESP_LOGW(TAG, "Default channel is 1");
}
if (phy_ble_rx_args.syncw->count == 1) {
cmd.syncw = phy_ble_rx_args.syncw->ival[0];
} else {
cmd.syncw = 0x71764129;
ESP_LOGW(TAG, "Default syncw is 0x71764129");
}
if (phy_ble_rx_args.rate->count == 1) {
cmd.rate = phy_ble_rx_args.rate->ival[0];
} else {
cmd.rate = PHY_BLE_RATE_1M;
ESP_LOGW(TAG, "Default rate is PHY_BLE_RATE_1M");
}
cert_test: example: Fix cert_test blocking issue
2023-03-20 22:49:02 -04:00
xTaskCreate(cert_ble_rx, "cert_ble_rx", 4096, (void *)&cmd, CERT_TASK_PRIO, NULL);
Add cert test example
2023-01-31 04:23:22 -05:00
return 0;
}
static int esp_phy_bt_tx_tone_func(int argc, char **argv)
{
uint32_t start;
uint32_t channel;
uint32_t attenuation;
int nerrors = arg_parse(argc, argv, (void **) &phy_bt_tx_tone_args);
if (nerrors != 0) {
arg_print_errors(stderr, phy_bt_tx_tone_args.end, argv[0]);
return 1;
}
if (phy_bt_tx_tone_args.start->count == 1) {
start = phy_bt_tx_tone_args.start->ival[0];
} else {
start = 1;
ESP_LOGW(TAG, "Default start is 1");
}
if (phy_bt_tx_tone_args.channel->count == 1) {
channel = phy_bt_tx_tone_args.channel->ival[0];
} else {
channel = 1;
ESP_LOGW(TAG, "Default channel is 1");
}
if (phy_bt_tx_tone_args.attenuation->count == 1) {
attenuation = phy_bt_tx_tone_args.attenuation->ival[0];
} else {
attenuation = 0;
ESP_LOGW(TAG, "Default backoff is 0");
}
esp_phy_bt_tx_tone(start, channel, attenuation);
return 0;
}
#endif
void register_phy_cmd(void)
{
phy_args.enable = arg_int0(NULL, NULL, "<enable>", "enable");
phy_args.end = arg_end(1);
const esp_console_cmd_t tx_contin_cmd = {
.command = "tx_contin_en",
.help = "TX Continuous mode, 1: enable, 0: disable",
.hint = NULL,
.func = &esp_phy_tx_contin_en_func,
.argtable = &phy_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&tx_contin_cmd) );
const esp_console_cmd_t cmdstop_cmd = {
.command = "cmdstop",
.help = "TX/RX test stop command",
.hint = NULL,
.func = &esp_phy_cmdstop_func,
.argtable = NULL
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmdstop_cmd) );
Add the output RX result command
2023-02-16 02:31:32 -05:00
const esp_console_cmd_t get_rx_result = {
.command = "get_rx_result",
.help = "Get RX information",
.hint = NULL,
.func = &esp_phy_get_rx_result_func,
.argtable = NULL
};
ESP_ERROR_CHECK( esp_console_cmd_register(&get_rx_result) );
Add cert test example
2023-01-31 04:23:22 -05:00
#if SOC_WIFI_SUPPORTED
const esp_console_cmd_t cbw40m_cmd = {
.command = "cbw40m_en",
.help = "HT40/HT20 mode selection, 0: HT20, 1: HT40",
.hint = NULL,
.func = &esp_phy_cbw40m_en_func,
.argtable = &phy_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cbw40m_cmd) );
phy_wifi_tx_args.channel = arg_int0("n", "channel" , "<channel>" , "channel setting, 1~14");
phy_wifi_tx_args.rate = arg_int0("r", "rate" , "<rate>" , "rate setting");
phy_wifi_tx_args.attenuation = arg_int0("p", "attenuation" , "<attenuation>" , "Transmit power attenuation");
phy_wifi_tx_args.length_byte = arg_int0("l", "length_byte" , "<length_byte>" , "TX packet length configuration");
phy_wifi_tx_args.packet_delay= arg_int0("d", "packet_delay", "<packet_delay>", "TX packet interval configuration");
phy_wifi_tx_args.packet_num = arg_int0("c", "packet_num" , "<packet_num>" , "The number of packets to send");
phy_wifi_tx_args.end = arg_end(1);
const esp_console_cmd_t esp_tx_cmd = {
.command = "esp_tx",
.help = "WiFi TX command",
.hint = NULL,
.func = &esp_phy_wifi_tx_func,
.argtable = &phy_wifi_tx_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&esp_tx_cmd) );
phy_wifi_rx_args.channel = arg_int0("n", "channel", "<channel>", "channel setting, 1~14");
phy_wifi_rx_args.rate = arg_int0("r", "rate" , "<rate>" , "rate setting");
phy_wifi_rx_args.end = arg_end(1);
const esp_console_cmd_t esp_rx_cmd = {
.command = "esp_rx",
.help = "WiFi RX command",
.hint = NULL,
.func = &esp_phy_wifi_rx_func,
.argtable = &phy_wifi_rx_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&esp_rx_cmd) );
phy_wifiscwout_args.enable = arg_int0("e", "start" , "<start>" , "enable CW");
phy_wifiscwout_args.channel = arg_int0("c", "channel" , "<channel>" , "channel setting, 1~14");
phy_wifiscwout_args.attenuation = arg_int0("p", "attenuation", "<attenuation>", "Transmit power attenuation");
phy_wifiscwout_args.end = arg_end(1);
const esp_console_cmd_t wifiscwout_cmd = {
.command = "wifiscwout",
.help = "Wi-Fi CW TX command",
.hint = NULL,
.func = &esp_phy_wifiscwout_func,
.argtable = &phy_wifiscwout_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&wifiscwout_cmd) );
#endif
#if SOC_BT_SUPPORTED
phy_ble_tx_args.txpwr = arg_int0("p", "txpwr" , "<txpwr>" , "Transmit power level setting");
phy_ble_tx_args.channel = arg_int0("n", "channel" , "<channel>" , "TX channel setting, range is 0~39");
phy_ble_tx_args.len = arg_int0("l", "len" , "<len>" , "Payload length setting, range is 0-255");
phy_ble_tx_args.data_type = arg_int0("t", "data_type", "<data_type>", "Data type setting");
phy_ble_tx_args.syncw = arg_int0("s", "syncw" , "<syncw>" , "Packet identification");
phy_ble_tx_args.rate = arg_int0("r", "rate" , "<rate>" , "TX rate setting,0: 1M; 1: 2M；2: 125K；3: 500K");
phy_ble_tx_args.tx_num_in = arg_int0("m", "tx_num_in", "<tx_num_in>", "TX mode setting");
phy_ble_tx_args.end = arg_end(1);
const esp_console_cmd_t esp_ble_tx_cmd = {
example: support legacy PHY commands in cert_test
2023-04-23 01:08:39 -04:00
#if CONFIG_ESP_PHY_NEW_COMMANDS
Add cert test example
2023-01-31 04:23:22 -05:00
.command = "esp_ble_tx",
example: support legacy PHY commands in cert_test
2023-04-23 01:08:39 -04:00
#elif CONFIG_ESP_PHY_LEGACY_COMMANDS
.command = "fcc_le_tx",
#endif
Add cert test example
2023-01-31 04:23:22 -05:00
.help = "BLE TX command",
.hint = NULL,
.func = &esp_phy_ble_tx_func,
.argtable = &phy_ble_tx_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&esp_ble_tx_cmd) );
phy_ble_rx_args.channel = arg_int0("n", "channel", "<channel>", "RX channel setting, range is 0~39");
phy_ble_rx_args.syncw = arg_int0("s", "syncw" , "<syncw>" , "Packet identification");
phy_ble_rx_args.rate = arg_int0("r", "rate" , "<rate>" , "RX rate setting,0: 1M；1: 2M；2: 125K；3： 500K");
phy_ble_rx_args.end = arg_end(1);
const esp_console_cmd_t esp_ble_rx_cmd = {
example: support legacy PHY commands in cert_test
2023-04-23 01:08:39 -04:00
#if CONFIG_ESP_PHY_NEW_COMMANDS
Add cert test example
2023-01-31 04:23:22 -05:00
.command = "esp_ble_rx",
example: support legacy PHY commands in cert_test
2023-04-23 01:08:39 -04:00
#elif CONFIG_ESP_PHY_LEGACY_COMMANDS
.command = "rw_le_rx_per",
#endif
Add cert test example
2023-01-31 04:23:22 -05:00
.help = "BLE RX command",
.hint = NULL,
.func = &esp_phy_ble_rx_func,
.argtable = &phy_ble_rx_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&esp_ble_rx_cmd) );
phy_bt_tx_tone_args.start = arg_int0("e", "start" , "<start>" , "enable CW, 1 means transmit, 0 means stop transmitting");
phy_bt_tx_tone_args.channel = arg_int0("n", "channel", "<channel>", "Single carrier transmission channel selection");
phy_bt_tx_tone_args.attenuation = arg_int0("p", "power" , "<power>" , "CW power attenuation parameter");
phy_bt_tx_tone_args.end = arg_end(1);
const esp_console_cmd_t bt_tx_tone_cmd = {
.command = "bt_tx_tone",
.help = "Single carrier TX command",
.hint = NULL,
.func = &esp_phy_bt_tx_tone_func,
.argtable = &phy_bt_tx_tone_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&bt_tx_tone_cmd) );
#endif
}
#endif
Reference in New Issue Copy Permalink