mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
528 lines
16 KiB
C
528 lines
16 KiB
C
/*
|
||
* 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"
|
||
|
||
#define CERT_TASK_PRIO 2
|
||
|
||
#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
|
||
|
||
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;
|
||
}
|
||
|
||
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);
|
||
|
||
ESP_LOGI(TAG, "Desired: %lu, Correct: %lu, RSSI: %d, flag: %lu", rx_result.phy_rx_total_count,
|
||
rx_result.phy_rx_correct_count, rx_result.phy_rx_rssi, rx_result.phy_rx_result_flag);
|
||
|
||
return 0;
|
||
}
|
||
|
||
#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)
|
||
{
|
||
static phy_wifi_tx_s cmd;
|
||
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");
|
||
}
|
||
|
||
xTaskCreate(cert_wifi_tx, "cert_wifi_tx", 1024 * 10, (void *)&cmd, CERT_TASK_PRIO, NULL);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int esp_phy_wifi_rx_func(int argc, char **argv)
|
||
{
|
||
static phy_wifi_rx_s cmd;
|
||
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");
|
||
}
|
||
|
||
xTaskCreate(cert_wifi_rx, "cert_wifi_rx", 1024 * 20, (void *)&cmd, CERT_TASK_PRIO, NULL);
|
||
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)
|
||
{
|
||
static phy_ble_tx_s cmd;
|
||
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");
|
||
}
|
||
|
||
xTaskCreate(cert_ble_tx, "cert_ble_tx", 4096, (void *)&cmd, CERT_TASK_PRIO, NULL);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int esp_phy_ble_rx_func(int argc, char **argv)
|
||
{
|
||
static phy_ble_rx_s cmd;
|
||
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) {
|
||
cmd.channel = phy_ble_rx_args.channel->ival[0];
|
||
} 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");
|
||
}
|
||
|
||
xTaskCreate(cert_ble_rx, "cert_ble_rx", 4096, (void *)&cmd, CERT_TASK_PRIO, NULL);
|
||
|
||
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) );
|
||
|
||
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) );
|
||
|
||
#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 = {
|
||
.command = "esp_ble_tx",
|
||
.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 = {
|
||
.command = "esp_ble_rx",
|
||
.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
|