/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*
*/
/** BusVoodoo generic UART mode (code)
* @note this only contains the common UART methods and should be supplied with mode specific methods and information
* @file busvoodoo_uart_generic.c
* @author King Kévin
* @date 2018
*/
/* standard libraries */
#include // standard integer types
#include // standard utilities
#include // string utilities
/* STM32 (including CM3) libraries */
#include // interrupt utilities
#include // general purpose input output library
#include // real-time control clock library
#include // USART utilities
#include // timer library
/* own libraries */
#include "global.h" // board definitions
#include "print.h" // printing utilities
#include "interrupt.h" // user interrupt table
#include "menu.h" // menu definitions
#include "usart_enhanced.h" // utilities for USART enhancements
#include "busvoodoo_global.h" // BusVoodoo definitions
#include "busvoodoo_uart_generic.h" // own definitions
/** the USART mode specific information */
static const struct busvoodoo_uart_generic_specific_t* busvoodoo_uart_generic_specific = NULL;
/** mode setup stage */
static enum busvoodoo_uart_generic_setting_t {
BUSVOODOO_UART_SETTING_NONE,
BUSVOODOO_UART_SETTING_BAUDRATE,
BUSVOODOO_UART_SETTING_DATABITS,
BUSVOODOO_UART_SETTING_PARITY,
BUSVOODOO_UART_SETTING_STOPBITS,
BUSVOODOO_UART_SETTING_HWFLOWCTL,
BUSVOODOO_UART_SETTING_DRIVE,
BUSVOODOO_UART_SETTING_DONE,
} busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_NONE; /**< current mode setup stage */
/** UART baud rate (in bps) */
static uint32_t busvoodoo_uart_generic_baudrate = 115200;
/** UART data bits */
static uint8_t busvoodoo_uart_generic_databits = 8;
/** UART parity setting */
static enum usart_enhanced_parity_t busvoodoo_uart_generic_parity = USART_ENHANCED_PARITY_NONE;
/** UART stop bits setting */
static uint32_t busvoodoo_uart_generic_stopbits = USART_STOPBITS_1;
/** UART hardware flow control setting (true = with hardware flow control, false = without hardware flow control */
static bool busvoodoo_uart_generic_hwflowctl = false;
/** pin drive mode (true = push-pull, false = open-drain) */
static bool busvoodoo_uart_generic_drive = true;
/** if embedded pull-up resistors are used */
static bool busvoodoo_uart_generic_pullup = false;
/** set if the timer ISR should be set in the interrupt table instead of the vector table
* @note the vector table is faster, but doesn't allow to change the ISR
* @warning for the BusVoodoo UART (using USART3) and RS-232/RS-485 (using USART2) the RX is on TIM2_CH4 (remapped for USART3)
*/
#define BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE false
bool busvoodoo_uart_generic_configure(const struct busvoodoo_uart_generic_specific_t* conf)
{
busvoodoo_uart_generic_specific = NULL; // reset specific information
if (NULL==conf) {
return false;
}
if (!conf->usart || !conf->usart_rcc || !conf->usart_rst) {
return false;
}
if (!conf->tx_rcc || !conf->rx_rcc) {
return false;
}
if (conf->hwflowctl && (!conf->rts_rcc || !conf->cts_rcc)) {
return false;
}
if (conf->timer && (!conf->timer_rcc || !conf->timer_port_rcc || !(NVIC_TIM2_IRQ==conf->timer_nvic_irq || NVIC_TIM3_IRQ==conf->timer_nvic_irq || NVIC_TIM4_IRQ==conf->timer_nvic_irq || NVIC_TIM5_IRQ==conf->timer_nvic_irq))) {
return false;
}
busvoodoo_uart_generic_specific = conf;
return true;
}
bool busvoodoo_uart_generic_setup(char** prefix, const char* line)
{
if (NULL==busvoodoo_uart_generic_specific) { // there is nothing to configure
return true;
}
bool complete = false; // is the setup complete
if (NULL==line) { // first call
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_NONE; // re-start configuration
}
switch (busvoodoo_uart_generic_setting) {
case BUSVOODOO_UART_SETTING_NONE:
snprintf(busvoodoo_global_string, LENGTH(busvoodoo_global_string), "baud rate in bps (1200-2000000) [%u]", busvoodoo_uart_generic_baudrate);
*prefix = busvoodoo_global_string; // ask for baud rate
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_BAUDRATE;
break;
case BUSVOODOO_UART_SETTING_BAUDRATE:
if (NULL==line || 0==strlen(line)) { // use default setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DATABITS; // go to next setting
} else { // setting provided
uint32_t baudrate = atoi(line); // parse setting
if (baudrate>0 && baudrate<=2000000) { // check setting
busvoodoo_uart_generic_baudrate = baudrate; // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DATABITS; // go to next setting
}
}
if (BUSVOODOO_UART_SETTING_DATABITS==busvoodoo_uart_generic_setting) { // if next setting
snprintf(busvoodoo_global_string, LENGTH(busvoodoo_global_string), "data bits (5-8) [%u]", busvoodoo_uart_generic_databits); // prepare next setting
*prefix = busvoodoo_global_string; // display next setting
}
break;
case BUSVOODOO_UART_SETTING_DATABITS:
if (NULL==line || 0==strlen(line)) { // use default setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_PARITY; // go to next setting
} else if (1==strlen(line)) { // setting provided
uint8_t databits = atoi(line); // parse setting
if (databits>=5 && databits<=8) { // check setting
busvoodoo_uart_generic_databits = databits; // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_PARITY; // go to next setting
}
}
if (BUSVOODOO_UART_SETTING_PARITY==busvoodoo_uart_generic_setting) { // if next setting
printf("1) none\n");
printf("2) even\n");
printf("3) odd\n");
printf("4) mark\n");
printf("5) space\n");
snprintf(busvoodoo_global_string, LENGTH(busvoodoo_global_string), "parity (1,2,3,4,5) [%u]", busvoodoo_uart_generic_parity+1); // prepare next setting
*prefix = busvoodoo_global_string; // display next setting
}
break;
case BUSVOODOO_UART_SETTING_PARITY:
if (NULL==line || 0==strlen(line)) { // use default setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_STOPBITS; // go to next setting
} else if (1==strlen(line)) { // setting provided
uint8_t parity = atoi(line); // parse setting
if (parity>0 && parity<6) { // check setting
busvoodoo_uart_generic_parity = parity-1;
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_STOPBITS; // go to next setting
}
}
if (BUSVOODOO_UART_SETTING_STOPBITS==busvoodoo_uart_generic_setting) { // if next setting
printf("1) 0.5\n");
printf("2) 1\n");
printf("3) 1.5\n");
printf("4) 2\n");
snprintf(busvoodoo_global_string, LENGTH(busvoodoo_global_string), "stop bits (1,2,3,4) [%c]", USART_STOPBITS_0_5==busvoodoo_uart_generic_stopbits ? '1' : (USART_STOPBITS_1==busvoodoo_uart_generic_stopbits ? '2' : (USART_STOPBITS_1_5==busvoodoo_uart_generic_stopbits ? '3' : '4'))); // prepare next setting
*prefix = busvoodoo_global_string; // display next setting
}
break;
case BUSVOODOO_UART_SETTING_STOPBITS:
if (NULL==line || 0==strlen(line)) { // use default setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_HWFLOWCTL; // go to next setting
} else if (1==strlen(line)) { // setting provided
if ('1'==line[0]) { // 0.5 stop bits
busvoodoo_uart_generic_stopbits = USART_STOPBITS_0_5; // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_HWFLOWCTL; // go to next setting
} else if ('2'==line[0]) { // 1 stop bits
busvoodoo_uart_generic_stopbits = USART_STOPBITS_1; // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_HWFLOWCTL; // go to next setting
} else if ('3'==line[0]) { // 1.5 stop bits
busvoodoo_uart_generic_stopbits = USART_STOPBITS_1_5; // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_HWFLOWCTL; // go to next setting
} else if ('4'==line[0]) { // 2 stop bits
busvoodoo_uart_generic_stopbits = USART_STOPBITS_2; // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_HWFLOWCTL; // go to next setting
}
}
if (BUSVOODOO_UART_SETTING_HWFLOWCTL==busvoodoo_uart_generic_setting) { // if next setting
if (!busvoodoo_uart_generic_specific->hwflowctl) { // hardware flow control is not supported
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DRIVE; // go to next setting
goto setting_drive; // actually go to next setting
}
printf("1) no flow control\n");
printf("2) RTS/CTS hardware flow control\n");
snprintf(busvoodoo_global_string, LENGTH(busvoodoo_global_string), "flow control (1,2) [%c]", busvoodoo_uart_generic_hwflowctl ? '2' : '1'); // prepare next setting
*prefix = busvoodoo_global_string; // display next setting
}
break;
case BUSVOODOO_UART_SETTING_HWFLOWCTL:
if (NULL==line || 0==strlen(line)) { // use default setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DRIVE; // go to next setting
} else if (1==strlen(line)) { // setting provided
if ('1'==line[0] || '2'==line[0]) { // setting provided
busvoodoo_uart_generic_hwflowctl = ('2'==line[0]); // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DRIVE; // go to next setting
}
}
setting_drive:
if (BUSVOODOO_UART_SETTING_DRIVE==busvoodoo_uart_generic_setting) { // if next setting
if (!busvoodoo_uart_generic_specific->multidrive) {
busvoodoo_uart_generic_drive = true; // only push-pull driving mode is supported
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DONE; // go to next setting
goto setting_done; // actually go to next setting
}
printf("1) push-pull (3.3V)\n");
printf("2) open-drain, with embedded pull-up resistors (2kO)\n");
printf("3) open-drain, with external pull-up resistors\n");
snprintf(busvoodoo_global_string, LENGTH(busvoodoo_global_string), "drive mode (1,2,3) [%c]", busvoodoo_uart_generic_drive ? '1' : (busvoodoo_uart_generic_pullup ? '2' : '3')); // show drive mode
*prefix = busvoodoo_global_string; // display next setting
}
break;
case BUSVOODOO_UART_SETTING_DRIVE:
if (NULL==line || 0==strlen(line)) { // use default setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DONE; // go to next setting
} else if (1==strlen(line)) { // setting provided
uint8_t drive = atoi(line); // parse setting
if (1==drive || 2==drive || 3==drive) { // check setting
busvoodoo_uart_generic_drive = (1==drive); // remember setting
busvoodoo_uart_generic_pullup = (2==drive); // remember setting
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_DONE; // go to next setting
}
}
setting_done:
if (BUSVOODOO_UART_SETTING_DONE==busvoodoo_uart_generic_setting) { // we have all settings, configure UART
rcc_periph_clock_enable(RCC_AFIO); // enable clock for USART alternate function
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->usart_rcc); // enable clock for USART peripheral
rcc_periph_reset_pulse(busvoodoo_uart_generic_specific->usart_rst); // reset USART peripheral
usart_set_baudrate(busvoodoo_uart_generic_specific->usart, busvoodoo_uart_generic_baudrate); // set baud rate
usart_enhanced_config(busvoodoo_uart_generic_specific->usart, busvoodoo_uart_generic_databits, busvoodoo_uart_generic_parity); // use enhanced USART to configure the USART peripherals, supporting more data-bits and parity configurations
usart_set_stopbits(busvoodoo_uart_generic_specific->usart, busvoodoo_uart_generic_stopbits); // set stop bits
if (busvoodoo_uart_generic_specific->hwflowctl && busvoodoo_uart_generic_hwflowctl) {
usart_set_flow_control(busvoodoo_uart_generic_specific->usart, USART_FLOWCONTROL_RTS_CTS); // set RTS/CTS flow control
} else {
usart_set_flow_control(busvoodoo_uart_generic_specific->usart, USART_FLOWCONTROL_NONE); // set no flow control
}
usart_set_mode(busvoodoo_uart_generic_specific->usart, USART_MODE_TX_RX); // full-duplex communication
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->tx_rcc); // enable clock for USART GPIO peripheral
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->rx_rcc); // enable clock for USART GPIO peripheral
if (busvoodoo_uart_generic_specific->hwflowctl && busvoodoo_uart_generic_hwflowctl) {
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->rts_rcc); // enable clock for USART GPIO peripheral
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->cts_rcc); // enable clock for USART GPIO peripheral
}
if (busvoodoo_uart_generic_drive) { // use push-pull drive mode
gpio_set_mode(busvoodoo_uart_generic_specific->tx_port, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, busvoodoo_uart_generic_specific->tx_pin); // setup GPIO pin USART transmit
gpio_set(busvoodoo_uart_generic_specific->rx_port, busvoodoo_uart_generic_specific->rx_pin); // pull up to avoid noise when not connected
gpio_set_mode(busvoodoo_uart_generic_specific->rx_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_uart_generic_specific->rx_pin); // setup GPIO pin USART receive
if (busvoodoo_uart_generic_specific->hwflowctl && busvoodoo_uart_generic_hwflowctl) { // use open drain drive mode
gpio_set_mode(busvoodoo_uart_generic_specific->rts_port, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_OPENDRAIN, busvoodoo_uart_generic_specific->rts_pin); // setup GPIO pin USART transmit
gpio_set(busvoodoo_uart_generic_specific->cts_port, busvoodoo_uart_generic_specific->cts_pin); // pull up to block transmission unless requested
gpio_set_mode(busvoodoo_uart_generic_specific->cts_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_uart_generic_specific->cts_pin); // setup GPIO pin USART receive
}
} else {
gpio_set_mode(busvoodoo_uart_generic_specific->tx_port, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, busvoodoo_uart_generic_specific->tx_pin); // setup GPIO pin USART transmit
gpio_set_mode(busvoodoo_uart_generic_specific->rx_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->rx_pin); // setup GPIO pin USART receive
if (busvoodoo_uart_generic_specific->hwflowctl && busvoodoo_uart_generic_hwflowctl) {
gpio_set_mode(busvoodoo_uart_generic_specific->rts_port, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_OPENDRAIN, busvoodoo_uart_generic_specific->rts_pin); // setup GPIO pin USART transmit
gpio_set_mode(busvoodoo_uart_generic_specific->cts_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->cts_pin); // setup GPIO pin USART receive
}
}
if (!busvoodoo_uart_generic_drive && busvoodoo_uart_generic_pullup) { // enable embedded pull-ups if used
busvoodoo_embedded_pullup(true); // set embedded pull-ups
printf("use LV to set pull-up voltage\n");
}
usart_enable(busvoodoo_uart_generic_specific->usart); // enable USART
// setup timer to measure RX edge timing for baud rate guessing
if (busvoodoo_uart_generic_specific->timer) {
}
busvoodoo_led_blue_off(); // disable blue LED because there is no activity
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_NONE; // restart settings next time
complete = true; // configuration is complete
}
break;
default: // unknown case
busvoodoo_uart_generic_setting = BUSVOODOO_UART_SETTING_NONE; // restart settings next time
break;
}
return complete;
}
void busvoodoo_uart_generic_exit(void)
{
if (NULL==busvoodoo_uart_generic_specific) {
return;
}
usart_disable(busvoodoo_uart_generic_specific->usart); // disable USART
rcc_periph_clock_disable(busvoodoo_uart_generic_specific->usart_rcc); // disable domain clock
gpio_set_mode(busvoodoo_uart_generic_specific->tx_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->tx_pin); // set pin back to floating input
gpio_set_mode(busvoodoo_uart_generic_specific->rx_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->rx_pin); // set pin back to floating input
if (busvoodoo_uart_generic_specific->hwflowctl) {
gpio_set_mode(busvoodoo_uart_generic_specific->rts_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->rts_pin); // set pin back to floating input
gpio_set_mode(busvoodoo_uart_generic_specific->cts_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->cts_pin); // set pin back to floating input
}
if (busvoodoo_uart_generic_specific->multidrive) {
busvoodoo_embedded_pullup(false); // disable embedded pull-ups
}
busvoodoo_uart_generic_specific = NULL; // remove specific information
}
/** write to UART
* @param[in] value value to write
*/
static void busvoodoo_uart_generic_write(uint8_t value)
{
if (NULL==busvoodoo_uart_generic_specific) {
return;
}
if (busvoodoo_uart_generic_specific->tx_pre) {
(*busvoodoo_uart_generic_specific->tx_pre)();
}
while ((0==((USART_SR(busvoodoo_uart_generic_specific->usart)) & USART_SR_TXE) && !user_input_available)); // wait for transmit buffer to be empty (or user to interrupt)
if ((USART_SR(busvoodoo_uart_generic_specific->usart)) & USART_SR_TXE) { // we can send data
// send data
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE); // pulse blue LED to show transmission
usart_enhanced_send(busvoodoo_uart_generic_specific->usart, value); // transmit data
// display data send
printf("write: '%c'/0x%02x\n", value, value);
}
while ((0==((USART_SR(busvoodoo_uart_generic_specific->usart)) & USART_SR_TC) && !user_input_available)); // wait for transfer to be complete
if (user_input_available) { // user interrupted flow
user_input_get(); // discard user input
}
if (busvoodoo_uart_generic_specific->tx_post) {
(*busvoodoo_uart_generic_specific->tx_post)();
}
}
/** read from UART
*/
static void busvoodoo_uart_generic_read(void)
{
if (NULL==busvoodoo_uart_generic_specific) {
return;
}
if (busvoodoo_uart_generic_specific->rx_pre) {
(*busvoodoo_uart_generic_specific->rx_pre)();
}
printf("read: ");
while (!(USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_RXNE) && !user_input_available); // wait for incoming data to be available (or user input to exit)
if ((USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_RXNE)) { // verify if data has been received
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE); // enable blue LED to show reception
// get the errors
bool error_noise = (0!=(USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_NE)); // read noise error flag
bool error_framing = (0!=(USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_FE)); // read frame error flag
uint8_t input = usart_enhanced_recv(busvoodoo_uart_generic_specific->usart); // read received character (also clears the error flags)
// display data
printf("'%c'/0x%02x", input, input);
// display errors
printf("(");
if (error_noise) {
printf("noise");
} else if (error_framing) {
printf("framing");
} else if (usart_enhanced_parity_error(busvoodoo_uart_generic_specific->usart)) {
printf("parity");
} else {
printf("no");
}
printf(" error)");
}
printf("\n");
if (user_input_available) { // user interrupted flow
user_input_get(); // discard user input
}
if (busvoodoo_uart_generic_specific->rx_post) {
(*busvoodoo_uart_generic_specific->rx_post)();
}
}
/** perform UART action
* @param[in] action action to perform
* @param[in] repetition how many times to perform the action
* @param[in] perform the action (true) or just check it (false)
* @return true if the action has been performed, false if it is malformed
*/
static bool busvoodoo_uart_generic_action(const char* action, uint32_t repetition, bool perform)
{
uint32_t length = strlen(action); // remember length since it will be used a number of times
if (NULL==action || 0==length) { // there is nothing to do
return true;
}
if (1==length && 'r'==action[0]) { // read data
if (!perform) {
return true;
}
for (uint32_t i=0; i='0' && action[1]<='9') { // send decimal
return busvoodoo_uart_generic_action(action+1, repetition, perform); // just retry without leading 0
} else { // malformed action
return false;
}
} else if ('x'==action[0] && length>1) { // send hexadecimal value
for (uint32_t i=1; i='0' && action[i]<='9') || (action[i]>='a' && action[i]<='f') || (action[i]>='A' && action[i]<='F'))) { // check for hexadecimal character
return false; // not an hexadecimal string
}
}
if (!perform) {
return true;
}
uint32_t value = strtol(&action[1], NULL, 16); // get hex value
for (uint32_t i=0; i1) { // send binary value
for (uint32_t i=1; i'1') { // check for binary character
return false; // not a binary string
}
}
if (!perform) {
return true;
}
uint32_t value = strtol(&action[1], NULL, 2); // get binary value
for (uint32_t i=0; i='1' && action[0]<='9') { // send decimal value
for (uint32_t i=1; i'9') { // check for decimal character
return false; // not a decimal string
}
}
if (!perform) {
return true;
}
uint32_t value = strtol(&action[0], NULL, 10); // get decimal value
for (uint32_t i=0; i=2 && ('"'==action[0] || '\''==action[0]) && (action[length-1]==action[0])) { // send ASCII character
if (!perform) {
return true;
}
for (uint32_t r=0; rtx_pre) {
(*busvoodoo_uart_generic_specific->tx_pre)();
}
if (NULL==argument || 0==strlen(argument)) { // nothing to transmit
argument = "\r\n"; // transmit CR+LF
}
printf("press any key to exit\n");
for (uint16_t i=0; ((char*)(argument))[i] && !user_input_available; i++) {
while ((0==(USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_TXE) && !user_input_available)); // wait for transmit buffer to be empty
if (USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_TXE) { // we can send a character
printf("%c", ((char*)(argument))[i]); // echo character to transmit
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE); // pulse blue LED to show transmission
usart_enhanced_send(busvoodoo_uart_generic_specific->usart, ((char*)(argument))[i]); // transmit character
}
}
while ((0==((USART_SR(busvoodoo_uart_generic_specific->usart)) & USART_SR_TC) && !user_input_available)); // wait for transfer to be complete
if (user_input_available) { // user interrupted flow
user_input_get(); // discard user input
}
if (strcmp(argument, "\r\n")) {
printf("\n");
}
if (busvoodoo_uart_generic_specific->tx_post) {
(*busvoodoo_uart_generic_specific->tx_post)();
}
}
/** command to receive data
* @param[in] argument in which format to display
*/
static void busvoodoo_uart_generic_command_receive(void* argument)
{
bool display_hex = false; // display in hex
bool display_bin = false; // display in bin
if (NULL!=argument && strlen(argument)>0) {
if (0==strcmp(argument, "h") || 0==strcmp(argument, "hex")) { // user wants hexadecimal display
display_hex = true; // remember to display in hexadecimal
} else if (0==strcmp(argument, "b") || 0==strcmp(argument, "bin")) { // user wants binary display
display_bin = true; // remember to display in binary
} else {
printf("malformed argument\n");
return;
}
}
if (NULL==busvoodoo_uart_generic_specific) {
return;
}
if (busvoodoo_uart_generic_specific->rx_pre) {
(*busvoodoo_uart_generic_specific->rx_pre)();
}
printf("press any key to exit\n");
while (!user_input_available) { // check for user input to exit
if ((USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_RXNE)) { // verify if data has been received
uint8_t input = usart_enhanced_recv(busvoodoo_uart_generic_specific->usart); // receive character
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE); // enable blue LED to show reception
if (display_hex) { // display data in hex
printf("%02x ", input);
} else if (display_bin) { // display data in binary
printf("%08b ", input);
} else { // display in ASCII
printf("%c", input); // print received character
}
}
}
user_input_get(); // discard user input
printf("\n"); // get to next line
if (busvoodoo_uart_generic_specific->rx_post) {
(*busvoodoo_uart_generic_specific->rx_post)();
}
}
/** command to transmit and receive data
* @param[in] argument no argument required
*/
static void busvoodoo_uart_generic_command_transceive(void* argument)
{
(void)argument; // we won't use the argument
if (NULL==busvoodoo_uart_generic_specific) {
return;
}
if (busvoodoo_uart_generic_specific->rx_pre) {
(*busvoodoo_uart_generic_specific->rx_pre)();
}
printf("press 5 times escape to exit\n");
char last_c = 0; // last user character received
uint8_t esc_count = 0; // number of times escape has press received
while (true) { // check for escape sequence
if (user_input_available) { // check if user wants to transmit something
char c = user_input_get(); // get user input
if (0x1b==c) { // user pressed escape
if (0x1b!=last_c) { // this is the first escape press
esc_count = 0;
}
esc_count++; // increment escape count
}
last_c = c; // remember key press
if (esc_count<5) { // check for escape sequence
if (busvoodoo_uart_generic_specific->rx_post) {
(*busvoodoo_uart_generic_specific->rx_post)();
}
if (busvoodoo_uart_generic_specific->tx_pre) {
(*busvoodoo_uart_generic_specific->tx_pre)();
}
while ((0==(USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_TXE) && !user_input_available)); // wait for transmit buffer to be empty
if (USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_TXE) { // we can send a character
usart_enhanced_send(busvoodoo_uart_generic_specific->usart, c); // send user character
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE); // enable blue LED to show transmission
}
while ((0==((USART_SR(busvoodoo_uart_generic_specific->usart)) & USART_SR_TC) && !user_input_available)); // wait for transfer to be complete
if (busvoodoo_uart_generic_specific->tx_post) {
(*busvoodoo_uart_generic_specific->tx_post)();
}
if (busvoodoo_uart_generic_specific->rx_pre) {
(*busvoodoo_uart_generic_specific->rx_pre)();
}
} else { // user wants to exit
break; // exit infinite loop
}
}
if ((USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_RXNE)) { // verify if data has been received
char input = usart_enhanced_recv(busvoodoo_uart_generic_specific->usart); // receive character
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE); // enable blue LED to show reception
printf("%c", input); // print received character
}
}
printf("\n"); // get to next line
if (busvoodoo_uart_generic_specific->rx_post) {
(*busvoodoo_uart_generic_specific->rx_post)();
}
}
/** command to verify incoming transmission for error
* @param[in] argument argument not required
*/
static void busvoodoo_uart_generic_command_error(void* argument)
{
(void)argument; // argument not used
printf("press any key to exit\n");
while (!user_input_available) { // wait until user interrupt
busvoodoo_uart_generic_read(); // read incoming data (this also checks for errors
}
user_input_get(); // discard user input
}
/** the possible properties of a UART configuration (to be updated with every character) */
struct uart_configuration_t {
uint8_t databits; /**< data word size in bits */
bool databits_matching; /**< if the data is still matching the data bits */
bool parity_even; /**< if the date is still matching the additional even parity bit */
bool parity_odd; /**< if the date is still matching the additional odd parity bit */
bool parity_mark; /**< if the date is still matching the additional mark parity bit */
bool parity_space; /**< if the date is still matching the additional space parity bit */
uint8_t parity_possibilities; /**< the number to still matching parity possibilities (number of parity_* at true) */
};
/** reset all matching values of UART configuration
* @param[out] configuration UART configuration to reset
*/
static void uart_configuration_reset(struct uart_configuration_t* configuration)
{
configuration->databits_matching = true;
configuration->parity_even = true;
configuration->parity_odd = true;
configuration->parity_mark = true;
configuration->parity_space = true;
configuration->parity_possibilities = 4;
}
volatile bool pulse_flag = false; /**< set when a small pulse time is detected */
volatile uint32_t pulse_duration = UINT32_MAX; /**< smallest pulse duration measured */
/** timer ISR to measure edge timing */
#if defined(BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE) && BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE
static void timer_isr(void)
#else
void TIM_ISR(2)(void)
#endif
{
busvoodoo_led_blue_pulse(BUSVOODOO_LED_PULSE);
static uint32_t pulse = UINT32_MAX; // measured pulse duration (MAX is an invalid values)
if (timer_get_flag(busvoodoo_uart_generic_specific->timer, TIM_SR_UIF)) { // overflow update event happened
timer_clear_flag(busvoodoo_uart_generic_specific->timer, TIM_SR_UIF); // clear flag
if (pulse>(UINT32_MAX-0x10000)) { // we can't measure longer pulser (and baud rate < 0.017 bps make no sense)
pulse = UINT32_MAX; // invalidate measured pulse
} else {
pulse += 0x10000; // account for the 16-bit timer limit
}
}
if (timer_get_flag(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_sr_ccof)) { // capture overflow occurred
timer_clear_flag(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_sr_ccof); // clear flag
pulse = UINT32_MAX; // invalidate measured pulse
}
if (timer_get_flag(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_sr_ccif)) {
uint16_t edge = *busvoodoo_uart_generic_specific->timer_ccr; // retrieve captured value (clears flag)
if (UINT32_MAX!=pulse) { // only calculate pulse if previous edge is valid
pulse = ((pulse&0xffff0000)+edge)-(pulse&0xffff); // calculate pulse duration
if (pulsetimer) {
printf("baud rate detection not possible (no timer available)\n");
return;
}
printf("the more traffic is incoming, the better the detection\n");
printf("press any key to exit\n");
// setup USART to receive character
uint8_t uart_databits = 8; // start with 8 bits since this is the most common case (i.e. no additional parity bit is used)
usart_set_baudrate(busvoodoo_uart_generic_specific->usart, 1200); // configure UART to pre-selected baud rate
usart_set_databits(busvoodoo_uart_generic_specific->usart, uart_databits); // configure UART to pre-selected data-bits
usart_set_stopbits(busvoodoo_uart_generic_specific->usart, USART_STOPBITS_1); // 1 stop-bits also complies to 2 stop-bits
usart_set_parity(busvoodoo_uart_generic_specific->usart, USART_PARITY_NONE); // get the raw data since we will do the parity check ourselves
// setup timer to generate/measure signal timing
if ((busvoodoo_uart_generic_specific->timer_port != busvoodoo_uart_generic_specific->rx_port) || (busvoodoo_uart_generic_specific->timer_pin != busvoodoo_uart_generic_specific->rx_pin)) {
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->timer_port_rcc); // enable clock for GPIO peripheral
gpio_set_mode(busvoodoo_uart_generic_specific->timer_port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_uart_generic_specific->timer_pin); // switch pin to input to measure the target transmit baud rate
}
rcc_periph_clock_enable(busvoodoo_uart_generic_specific->timer_rcc); // enable clock for timer peripheral
timer_reset(busvoodoo_uart_generic_specific->timer); // reset timer state
timer_disable_counter(busvoodoo_uart_generic_specific->timer); // disable timer to configure it
timer_set_mode(busvoodoo_uart_generic_specific->timer, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
timer_set_prescaler(busvoodoo_uart_generic_specific->timer, 1-1); // don't use prescale so to get the most precise measurement
timer_ic_set_input(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_ic, busvoodoo_uart_generic_specific->timer_ic_in_ti); // configure the input capture ICx to use the right channel TIn
timer_ic_set_filter(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_ic, TIM_IC_OFF); // use no filter input to keep precise timing
/* ideally we would trigger on any edge, allowing to measure the bit width (on 010 or 101 bit pattern) and calculate the correct baud rate.
* sadly the STM32 F1 family timer peripheral does not supporting triggering on both edges at the same time (the F0 family can).
* it is possible to simply update the polarity setting to capture the other edge, but this update seems to slow even in a ISR to capture > 1 MHz frequencies (=500 bps).
* thus we will start the trigger on the start bit, and wait for the next falling edge.
* this way we don't need to change the parity and have twice the time to measure the baud rate.
* to calculate the baud rate we just have to divided the frequency by two.
* the correct baud rate on the following pattern (HLHL), and since the start bit is the first HL pattern we just have to wait for data starting with 10 (LSb first)
*/
timer_ic_set_polarity(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_ic, TIM_IC_FALLING); // capture on falling end to trigger on the start bit
timer_ic_set_prescaler(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_ic, TIM_IC_PSC_OFF); // don't use any prescaler since we want to capture every pulse
timer_ic_enable(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_ic); // enable capture interrupt
timer_clear_flag(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_sr_ccif); // clear input compare flag
timer_enable_irq(busvoodoo_uart_generic_specific->timer, busvoodoo_uart_generic_specific->timer_dier_ccie); // enable capture interrupt
timer_update_on_overflow(busvoodoo_uart_generic_specific->timer); // only use counter overflow as UEV source (use overflow to measure longer times)
timer_clear_flag(busvoodoo_uart_generic_specific->timer, TIM_SR_UIF); // clear overflow flag
timer_enable_irq(busvoodoo_uart_generic_specific->timer, TIM_DIER_UIE); // enable update interrupt for timer
#if defined(BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE) && BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE
/** backup of timer ISR before replacing it */
void (*isr_backup)(void) = interrupt_table[busvoodoo_uart_generic_specific->timer_nvic_irq]; // backup current timer ISR before replacing it
interrupt_table[busvoodoo_uart_generic_specific->timer_nvic_irq] = &timer_isr; // replace current timer ISR with our to be able to measure the edge timing
bool irq_backup = nvic_get_irq_enabled(busvoodoo_uart_generic_specific->timer_nvic_irq); // backup enable IRQ setting
#endif
nvic_enable_irq(busvoodoo_uart_generic_specific->timer_nvic_irq); // catch interrupts for this timer
pulse_duration = UINT32_MAX; // reset pulse duration
timer_enable_counter(busvoodoo_uart_generic_specific->timer); // enable timer
// switch on RX
if (busvoodoo_uart_generic_specific->rx_pre) {
(*busvoodoo_uart_generic_specific->rx_pre)();
}
bool reset_state = true; // flag to know if we need to reset the states
uint8_t rx_errors; // number of UART receive errors received
bool wait_for_idle = false; // flag to wait for an IDLE frame
/** the possible UART configurations
* @note since the first valid configuration will be chosen, order in decreasing probability of being valid and decreasing probability or getting invalidated */
struct uart_configuration_t uart_configurations[] = {
{ .databits = 5 },
{ .databits = 6 },
{ .databits = 8 },
{ .databits = 7 },
};
uint8_t uart_configuration_valid = LENGTH(uart_configurations); // current best valid UART configuration index
char uart_configuration_parity = '?'; // current best valid UART parity
const uint32_t baudrates[] = { 1200, 1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 230400, 460800, 576000, 921600 }; // list of standard baud rates, to match with measured frequency
uint32_t uart_baudrate = 0; // fastest found baud rate
while (!user_input_available) {
if (reset_state) { // reset the configuration
rx_errors = 0;
for (uint8_t i=0; iusart); // clear input buffer and allow flag to be set
usart_enable(busvoodoo_uart_generic_specific->usart); // ensure UART is enabled
reset_state = false;
}
if (pulse_flag) { // new pulse duration has been measured
pulse_flag = false; // clear flag
printf("u");
uint32_t baudrate = rcc_ahb_frequency/(pulse_duration/2); // calculate baud rate based on measured timing
if (baudrate>uart_baudrate+100) { // new higher baud rate detected
uart_baudrate = baudrate; // save new baud rate
if (uart_baudrate>=1200) { // ensure minimum hardware supported baud rate is respected
// search for closest standard baud rate
uint32_t standard_baudrate = 0;
for (uint8_t i=0; i=baudrates[i]*0.9 && uart_baudrate<=baudrates[i]*1.1) { // measured baud rate matches standard baud rate within factor
standard_baudrate = baudrates[i]; // remember matching baud rate
break; // stop searching for matching baud rate
}
}
if (standard_baudrate) { // matching standard baud rate found
uart_baudrate = standard_baudrate; // save matching baud rate
}
usart_disable(busvoodoo_uart_generic_specific->usart); // disable UART before reconfiguring
usart_set_baudrate(busvoodoo_uart_generic_specific->usart, uart_baudrate); // set new baud rate
reset_state = true; // reset the states since we set a new baud rate
printf("\nnew baud rate: %u bps\n", uart_baudrate); // show measurement frequency
} else {
printf("\ndetected %u bps baud rate is lower than minimum supported 1200 bps\n", baudrate);
}
}
}
if (USART_SR(busvoodoo_uart_generic_specific->usart) & (USART_SR_NE|USART_SR_FE)) { // error on UART received
usart_recv(busvoodoo_uart_generic_specific->usart); // clear input buffer and flags
rx_errors++; // increment number of errors
if (rx_errors>=5) { // the format seems wrong
// the threshold must be high enough so the UART peripheral has enough opportunities to synchronize to the start bit (just after and idle frame)
// two high probable frame error causes:
// - when set to 9 data-bits with high speed 8 data-bits traffic incoming: the next start bit comes right after the stop bit of and 8-bit frame, which is interpreted as faulty 9 data-bits frame stop bit
// - when set to 8 data-bits with 9 data-bits (8+1 parity) traffic incoming: the low parity bit is interpreted as faulty stop-bit
uart_databits = ((8==uart_databits) ? 9 : 8); // switch between 8 and 9-bit packets
usart_disable(busvoodoo_uart_generic_specific->usart); // disable UART before reconfiguring
usart_set_databits(busvoodoo_uart_generic_specific->usart, uart_databits); // set new data width
reset_state = true;
pulse_duration = UINT32_MAX; // also reset the baud rate
uart_baudrate = 0; // also reset the baud rate
rx_errors = 0; // reset error counter
printf("\nrestarting guessing because too detected error\n");
} else {
wait_for_idle = true; // wait form an IDLE frame so to better sync to the next start bit
}
}
if (wait_for_idle) {
/* we have to check the IDLE flag in the main loop instead of just looping over the flag because a hardware fault could prevent it from being set.
* from the "STM32F10xxC/D/E silicon limitations" errata, section 2.12.2 "Idle frame is not detected if receiver clock speed is deviated": If the USART receives an idle frame followed by a character, and the clock of the transmitter device is faster than the USART receiver clock, the USART receive signal falls too early when receiving the character start bit, with the result that the idle frame is not detected (IDLE flag is not set).
* there this no workaround be it will be fixed when changing the baud rate
*/
if (USART_SR(busvoodoo_uart_generic_specific->usart) | USART_SR_IDLE) {
wait_for_idle = false;
}
if (USART_SR(busvoodoo_uart_generic_specific->usart) | USART_SR_RXNE) {
USART_DR(busvoodoo_uart_generic_specific->usart); // empty receive buffer so the IDLE flag can retrigger
}
}
if (USART_SR(busvoodoo_uart_generic_specific->usart) & USART_SR_RXNE) { // data received
uint16_t usart_data = usart_recv(busvoodoo_uart_generic_specific->usart); // save received data (also clears flag)
if (0 == uart_baudrate) { // we did not find any valid baud rate yet
continue;
}
uint16_t usart_data_padded = ((8 == uart_databits) ? usart_data | 0xff00 : usart_data | 0xfe00); // pad with 1 (stop bit/idle state) for better word size detection
uint16_t usart_data_relevant = usart_data & ~(0xffff << uart_configurations[uart_configuration_valid].databits); // get only the data bits
// verify parity and word size
for (uint8_t i = 0; i < LENGTH(uart_configurations); i++) {
// skip check if we already know the word size is wrong
if (!uart_configurations[i].databits_matching) {
continue;
}
// do parity checks
if (uart_configurations[i].parity_even) {
uart_configurations[i].parity_even &= usart_enhanced_even_parity_lut[usart_data_relevant];
}
if (uart_configurations[i].parity_odd) {
uart_configurations[i].parity_odd &= !usart_enhanced_even_parity_lut[usart_data_relevant];
}
if (uart_configurations[i].parity_mark) {
uart_configurations[i].parity_mark &= (usart_data_padded & (1 << uart_configurations[i].databits));
}
if (uart_configurations[i].parity_space) {
uart_configurations[i].parity_space &= !(usart_data_padded & (1 << uart_configurations[i].databits));
}
// update parity count
uart_configurations[i].parity_possibilities = 0;
if (uart_configurations[i].parity_even) {
uart_configurations[i].parity_possibilities++;
}
if (uart_configurations[i].parity_odd) {
uart_configurations[i].parity_possibilities++;
}
if (uart_configurations[i].parity_mark) {
uart_configurations[i].parity_possibilities++;
}
if (uart_configurations[i].parity_space) {
uart_configurations[i].parity_possibilities++;
}
// verify word size
uint16_t databits_mask = (0xffff << (uart_configurations[i].databits + ((0 == uart_configurations[i].parity_possibilities) ? 0 : 1))); // mask for bits which should not be cleared
if (~usart_data_padded & databits_mask) { // see if bit outside the word size are cleared
uart_configurations[i].databits_matching = false;
}
}
bool no_valid_configuration = true;
uint8_t new_valid_configuration = LENGTH(uart_configurations);
char parity = '?';
for (uint8_t i=0; i 1) { // parity is not yet clear
continue;
} else if (uart_configurations[i].parity_even) {
parity = 'E';
} else if (uart_configurations[i].parity_odd) {
parity = 'O';
} else if (uart_configurations[i].parity_mark) {
parity = 'M';
} else if (uart_configurations[i].parity_space) {
parity = 'S';
} else if (0==uart_configurations[i].parity_possibilities) {
parity = 'N';
}
new_valid_configuration = i;
break; // stop searching since we found a configuration
}
if (no_valid_configuration) {
reset_state = true; // reset the configurations
pulse_duration = UINT32_MAX; // also reset the baud rate
uart_baudrate = 0; // also reset the baud rate
} else if (new_valid_configuration < LENGTH(uart_configurations) && '?' != parity && (new_valid_configuration != uart_configuration_valid || parity != uart_configuration_parity)) { // we found a new valid configuration
uart_configuration_valid = new_valid_configuration;
uart_configuration_parity = parity;
printf("\nnew UART configuration found: %u %u%c1\n", uart_baudrate, uart_configurations[uart_configuration_valid].databits, uart_configuration_parity);
}
// print received data if a configuration has been found
if (uart_configuration_valid < LENGTH(uart_configurations)) { // valid configuration existing
if (uart_configurations[uart_configuration_valid].databits >= 7 && usart_data_relevant < 0x80) { // this is probably valid ASCII data
printf("%c", usart_data_relevant);
} else {
printf("0x%02x ", usart_data_relevant);
}
} else {
printf("0b%09b\n", usart_data_relevant);
}
}
}
user_input_get(); // clear input used to interrupt previous loop
printf("\n");
// switch off RX
if (busvoodoo_uart_generic_specific->rx_post) {
(*busvoodoo_uart_generic_specific->rx_post)();
}
// stop timer
timer_disable_counter(busvoodoo_uart_generic_specific->timer); // disable timer
#if defined(BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE) && BUSVOODOO_UART_TIMER_USE_INTERRUPT_TABLE
interrupt_table[busvoodoo_uart_generic_specific->timer_nvic_irq] = isr_backup; // restore ISR
if (!irq_backup) {
nvic_disable_irq(busvoodoo_uart_generic_specific->timer_nvic_irq); // disable IRQ
}
#else
nvic_disable_irq(busvoodoo_uart_generic_specific->timer_nvic_irq); // disable IRQ
#endif
timer_reset(busvoodoo_uart_generic_specific->timer); // reset timer
rcc_periph_clock_disable(busvoodoo_uart_generic_specific->timer_rcc); // disable clock for timer peripheral
// no need to disable pin since it's already a floating input it is not Rx
if (uart_configuration_valid < LENGTH(uart_configurations)) {
printf("press y to use configuration found: %u %u%c1\n", uart_baudrate, uart_configurations[uart_configuration_valid].databits, uart_configuration_parity);
while (!user_input_available); // wait until user input
if ('y' == user_input_get()) { // user want to use found configuration
busvoodoo_uart_generic_baudrate = uart_baudrate;
busvoodoo_uart_generic_databits = uart_configurations[uart_configuration_valid].databits;
if (uart_configurations[uart_configuration_valid].parity_even) {
busvoodoo_uart_generic_parity = USART_ENHANCED_PARITY_EVEN;
} else if (uart_configurations[uart_configuration_valid].parity_odd) {
busvoodoo_uart_generic_parity = USART_ENHANCED_PARITY_ODD;
} else if (uart_configurations[uart_configuration_valid].parity_mark) {
busvoodoo_uart_generic_parity = USART_ENHANCED_PARITY_MARK;
} else if (uart_configurations[uart_configuration_valid].parity_space) {
busvoodoo_uart_generic_parity = USART_ENHANCED_PARITY_SPACE;
} else {
busvoodoo_uart_generic_parity = USART_ENHANCED_PARITY_NONE;
}
busvoodoo_uart_generic_stopbits = USART_STOPBITS_1;
}
}
// reconfigure USART
usart_set_baudrate(busvoodoo_uart_generic_specific->usart, busvoodoo_uart_generic_baudrate); // set baud rate
usart_enhanced_config(busvoodoo_uart_generic_specific->usart, busvoodoo_uart_generic_databits, busvoodoo_uart_generic_parity); // use enhanced USART to configure the USART peripherals, supporting more data-bits and parity configurations
usart_set_stopbits(busvoodoo_uart_generic_specific->usart, busvoodoo_uart_generic_stopbits); // set stop bits
}
const struct menu_command_t busvoodoo_uart_generic_commands[busvoodoo_uart_generic_commands_nb] = {
{
.shortcut = 'a',
.name = "action",
.command_description = "perform protocol actions",
.argument = MENU_ARGUMENT_STRING,
.argument_description = "[actions]",
.command_handler = &busvoodoo_uart_generic_command_actions,
},
{
.shortcut = 'r',
.name = "receive",
.command_description = "show incoming data [in hexadecimal or binary]",
.argument = MENU_ARGUMENT_STRING,
.argument_description = "[hex|bin]",
.command_handler = &busvoodoo_uart_generic_command_receive,
},
{
.shortcut = 't',
.name = "transmit",
.command_description = "transmit ASCII text (empty for CR+LF)",
.argument = MENU_ARGUMENT_STRING,
.argument_description = "[text]",
.command_handler = &busvoodoo_uart_generic_command_transmit,
},
{
.shortcut = 'x',
.name = "transceive",
.command_description = "transmit and receive data",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &busvoodoo_uart_generic_command_transceive,
},
{
.shortcut = 'e',
.name = "error",
.command_description = "verify incoming transmission for errors",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &busvoodoo_uart_generic_command_error,
},
{
.shortcut = 'd',
.name = "detect",
.command_description = "auto-detect serial configuration (baud rate, data bits, parity)",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &busvoodoo_uart_generic_command_detect,
},
};