demo/uart_blaster/commands.c

/*******************************************************************************
* # License
* Copyright 2019 Silicon Laboratories Inc. www.silabs.com
*******************************************************************************
*
* The licensor of this software is Silicon Laboratories Inc. Your use of this
* software is governed by the terms of Silicon Labs Master Software License
* Agreement (MSLA) available at
* www.silabs.com/about-us/legal/master-software-license-agreement. This
* software is distributed to you in Source Code format and is governed by the
* sections of the MSLA applicable to Source Code.
*
******************************************************************************/
#include "uart_blaster_internal.h"
GOS_CMD_CREATE_GETTER_SETTER(blaster, log_level, "blaster.log_level", SC2('b','l','l'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, uart_cfg_enabled, "blaster.uart.cfg_enabled", SC3('b','l','u','c'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, uart_id, "blaster.uart.id", SC3('b','l','u','i'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, uart_baud, "blaster.uart.baud", SC3('b','l','u','b'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, uart_flow, "blaster.uart.flow", SC3('b','l','u','f'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, uart_stop_bits, "blaster.uart.stop_bits", SC3('b','l','u','s'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, rx_delay, "blaster.rx.delay", SC3('b','l','r','d'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, rx_length, "blaster.rx.length", SC3('b','l','r','l'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, rx_buffer_size, "blaster.rx.buffer_size", SC3('b','l','r','b'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, rx_validate_enabled, "blaster.rx.validate_enabled", SC3('b','l','r','v'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, rx_random_delay_enabled, "blaster.rx.random_delay_enabled", SC3('b','l','r','r'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, rx_enabled, "blaster.rx.enabled", SC3('b','l','r','e'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, tx_delay, "blaster.tx.delay", SC3('b','l','t','d'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, tx_length, "blaster.tx.length", SC3('b','l','t','l'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, tx_random_delay_enabled, "blaster.tx.random_delay_enabled", SC3('b','l','t','r'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, tx_enabled, "blaster.tx.enabled", SC3('b','l','t','e'), 0, 1);
GOS_CMD_CREATE_GETTER_SETTER(blaster, tx_wait_for_start, "blaster.tx.wait_for_start", SC3('b','l','t','w'), 0, 1);
GOS_CMD_CREATE_COMMAND(blaster, start, "blaster_start", "bstart", 0, 0, false);
GOS_CMD_CREATE_COMMAND(blaster, stop, "blaster_stop", "bstop", 0, 0, false);
GOS_CMD_CREATE_COMMAND(blaster, pause, "blaster_pause", "bpause", 0, 0, false);
uart_blaster_settings_t *blaster_settings;
/*************************************************************************************************/
void commands_print_help(void)
{
GOS_LOG("\r\nThe following commands are available:\r\n" \
"blaster_start - start/stop blasting data\r\n" \
"blaster_stop - stop blasting data\r\n" \
"blaster_pause - pause/unpause blasting data\r\n" \
"get blaster - list all blaster settings\r\n");
}
/*************************************************************************************************/
GOS_DEFINE_COMMAND(blaster, start)
{
return (uart_blaster_start() == GOS_SUCCESS) ? GOS_CMD_EXECUTE_AOK : GOS_CMD_FAILED;
}
/*************************************************************************************************/
GOS_DEFINE_COMMAND(blaster, stop)
{
return (uart_blaster_stop() == GOS_SUCCESS) ? GOS_CMD_EXECUTE_AOK : GOS_CMD_FAILED;
}
/*************************************************************************************************/
GOS_DEFINE_COMMAND(blaster, pause)
{
return (uart_blaster_pause() == GOS_SUCCESS) ? GOS_CMD_EXECUTE_AOK : GOS_CMD_FAILED;
}
// #######################################################
// Variables
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, log_level)
{
return gos_cmd_print_uint32_response(blaster_settings->log_level);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, log_level)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uart_blaster_log_level_t, blaster_settings->log_level, argv[1],
UART_BLASTER_LOG_LEVEL_NONE, UART_BLASTER_LOG_LEVEL_DEBUG);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, uart_cfg_enabled)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_CONFIG_UART_ENABLED) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, uart_cfg_enabled)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_CONFIG_UART_ENABLED, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, uart_baud)
{
return gos_cmd_print_uint32_response(blaster_settings->uart.baud_rate);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, uart_baud)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uint32_t, blaster_settings->uart.baud_rate, argv[1], 1, 18000000);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, uart_flow)
{
return gos_cmd_print_uint32_response((blaster_settings->uart.flow_control == GOS_UART_FLOW_CONTROL_CTSRTS) ? true : false);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, uart_flow)
{
bool enabled;
if(GOS_CMD_SET_FAILED(result, gos_cmd_set_bool(argc, argv, &enabled)))
{
return result;
}
blaster_settings->uart.flow_control = enabled ? GOS_UART_FLOW_CONTROL_CTSRTS : GOS_UART_FLOW_CONTROL_DISABLED;
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, uart_stop_bits)
{
return gos_cmd_print_uint32_response(blaster_settings->uart.stop_bits +1);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, uart_stop_bits)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(gos_uart_stop_bits_t, blaster_settings->uart.stop_bits, argv[1], 1, 2);
blaster_settings->uart.stop_bits -= 1;
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, uart_id)
{
return gos_cmd_print_uint32_response(blaster_settings->uart_id);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, uart_id)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(gos_uart_t, blaster_settings->uart_id, argv[1], 0, GOS_UART_MAX-1);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, rx_delay)
{
return gos_cmd_print_uint32_response(blaster_settings->rx_delay);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, rx_delay)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uint16_t, blaster_settings->rx_delay, argv[1], 0, UINT16_MAX);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, rx_length)
{
return gos_cmd_print_uint32_response(blaster_settings->rx_length);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, rx_length)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uint16_t, blaster_settings->rx_length, argv[1], 1, 16*1024);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, rx_buffer_size)
{
return gos_cmd_print_uint32_response(blaster_settings->rx_buffer_size);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, rx_buffer_size)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uint16_t, blaster_settings->rx_buffer_size, argv[1], 1, 16*1024);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, rx_validate_enabled)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_VALIDATE_RX_DATA) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, rx_validate_enabled)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_VALIDATE_RX_DATA, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, rx_random_delay_enabled)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_RANDOM_RX_DELAY_ENABLED) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, rx_random_delay_enabled)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_RANDOM_RX_DELAY_ENABLED, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, rx_enabled)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_RX_ENABLED) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, rx_enabled)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_RX_ENABLED, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, tx_delay)
{
return gos_cmd_print_uint32_response(blaster_settings->tx_delay);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, tx_delay)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uint16_t, blaster_settings->tx_delay, argv[1], 0, UINT16_MAX);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, tx_length)
{
return gos_cmd_print_uint32_response(blaster_settings->tx_length);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, tx_length)
{
GOS_CMD_PARSE_INT_ARG_WITH_VAR(uint16_t, blaster_settings->tx_length, argv[1], 1, 16*1024);
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, tx_random_delay_enabled)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_RANDOM_TX_DELAY_ENABLED) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, tx_random_delay_enabled)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_RANDOM_TX_DELAY_ENABLED, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, tx_enabled)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_TX_ENABLED) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, tx_enabled)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_TX_ENABLED, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}
/*************************************************************************************************/
GOS_DEFINE_GETTER(blaster, tx_wait_for_start)
{
return gos_cmd_print_uint32_response((blaster_settings->flags & UART_BLASTER_FLAG_TX_WAIT_FOR_START) ? 1 : 0);
}
/*************************************************************************************************/
GOS_DEFINE_SETTER(blaster, tx_wait_for_start)
{
return gos_cmd_set_flag(argc, argv, UART_BLASTER_FLAG_TX_WAIT_FOR_START, &blaster_settings->flags, sizeof(uart_blaster_flag_t));
}