2021-03-31 14:06:10 +02:00
/** BusVoodoo global definitions and methods
2020-03-09 13:44:08 +01:00
* @ file
2019-02-20 19:14:08 +01:00
* @ author King Kévin < kingkevin @ cuvoodoo . info >
2020-03-09 13:44:08 +01:00
* @ date 2018 - 2020
2021-03-31 14:06:10 +02:00
* @ copyright SPDX - License - Identifier : GPL - 3.0 - or - later
2019-02-20 19:14:08 +01:00
* @ note peripherals used : time @ ref busvoodoo_led_timer
*/
/* standard libraries */
# include <stdint.h> // standard integer types
# include <stdlib.h> // standard utilities
# include <string.h> // string utilities
# include <math.h> // math utilities
/* STM32 (including CM3) libraries */
# include <libopencm3/cm3/nvic.h> // interrupt handler
# include <libopencm3/stm32/gpio.h> // general purpose input output library
# include <libopencm3/stm32/rcc.h> // real-time control clock library
# include <libopencm3/stm32/adc.h> // ADC utilities
# include <libopencm3/stm32/dac.h> // DAC utilities
# include <libopencm3/stm32/timer.h> // timer utilities
/* own libraries */
# include "global.h" // board definitions
# include "menu.h" // command definitions
# include "print.h" // print utilities
# include "busvoodoo_global.h" // BusVoodoo definitions
/** @defgroup busvoodoo_led_timer the blue and red LEDs are connector to TIM1_CH1: user timer 1 to count time for pulses or channel 1 to generate PWM for blinking
* @ {
*/
# define BUSVOODOO_LED_TIMER 1 /**< timer peripheral ID */
/** @} */
/** number of remaining milliseconds the blue LED should stay on */
static volatile uint32_t busvoodoo_global_led_blue_timeout = 0 ;
/** if the timer for the blue LED is enabled */
static volatile bool busvoodoo_global_led_blue_timer = false ;
/** number of remaining milliseconds the red LED should stay on */
static volatile uint32_t busvoodoo_global_led_red_timeout = 0 ;
/** if the timer for the red LED is enabled */
static volatile bool busvoodoo_global_led_red_timer = false ;
/** if the LEDs are in a blinking pattern */
static volatile bool busvoodoo_global_led_blinking = false ;
2020-03-09 13:50:45 +01:00
/** hardware version voltages */
static const float busvoodoo_version_voltages [ ] = {
100.0 / ( 10.0 + 100.0 ) * 3.3 , // version A (revision 27): voltage divider 10k + 100k
0.0 , // dongle: tied to ground
} ;
2019-02-20 19:14:08 +01:00
const char * busvoodoo_global_pinout_io [ 10 ] = { NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL } ;
2020-03-09 13:51:43 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
const char * busvoodoo_global_pinout_rscan [ 5 ] = { NULL , NULL , NULL , NULL , NULL } ;
2020-03-09 13:51:43 +01:00
# endif
2019-02-20 19:14:08 +01:00
2020-03-09 14:10:35 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
const char * busvoodoo_io_names [ 13 ] = { " I2C_SMBA/SPI_NSS/I2S_WS/UART1_CK " , " SDIO_CMD " , " UART1_CTS/SPI_SCK/I2S_CK " , " SDIO_D3/UART2_RX " , " I2C_SDA/UART1_RX " , " SDIO_D0 " , " SPI_MOSI/I2S_SD " , " SDIO_CK " , " I2C_SCL/UART1_TX " , " SDIO_D1 " , " I2S_MCK " , " UART1_RTS/SPI_MISO " , " SDIO_D2/UART2_TX " } ;
const uint32_t busvoodoo_io_ports [ 13 ] = { GPIOB , GPIOD , GPIOB , GPIOC , GPIOB , GPIOC , GPIOB , GPIOC , GPIOB , GPIOC , GPIOC , GPIOB , GPIOC } ;
const uint32_t busvoodoo_io_pins [ 13 ] = { GPIO12 , GPIO2 , GPIO13 , GPIO11 , GPIO11 , GPIO8 , GPIO15 , GPIO12 , GPIO10 , GPIO9 , GPIO6 , GPIO14 , GPIO10 } ;
const uint8_t busvoodoo_io_groups [ 13 ] = { 6 , 6 , 4 , 4 , 1 , 1 , 5 , 5 , 2 , 2 , 3 , 3 , 3 } ;
2020-03-09 14:10:35 +01:00
# else
const char * busvoodoo_io_names [ 8 ] = { " I2C_SDA/UART_RX " , " I2C_SCL/UART_TX " , " UART_RTS/SPI_MISO " , " UART_CTS/SPI_SCK " , " SPI_MOSI " , " I2C_SMBA/SPI_NSS/UART_CK " , " ICP_RX " , " ICP_TX " } ;
const uint32_t busvoodoo_io_ports [ 8 ] = { GPIOB , GPIOB , GPIOB , GPIOB , GPIOB , GPIOB , GPIOA , GPIOA } ;
const uint32_t busvoodoo_io_pins [ 8 ] = { GPIO11 , GPIO10 , GPIO14 , GPIO13 , GPIO15 , GPIO12 , GPIO10 , GPIO9 } ;
const uint8_t busvoodoo_io_groups [ 8 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 1 , 2 } ;
# endif
2019-02-20 19:14:08 +01:00
bool busvoodoo_full = false ;
char busvoodoo_version = ' 0 ' ;
char busvoodoo_global_string [ 64 ] ;
void busvoodoo_setup ( void )
{
// enable all GPIO domains since we use pins on all ports
rcc_periph_clock_enable ( RCC_GPIOA ) ; // enable clock for all GPIO domains
rcc_periph_clock_enable ( RCC_GPIOB ) ; // enable clock for all GPIO domains
rcc_periph_clock_enable ( RCC_GPIOC ) ; // enable clock for all GPIO domains
rcc_periph_clock_enable ( RCC_GPIOD ) ; // enable clock for all GPIO domains
rcc_periph_clock_enable ( RCC_AFIO ) ; // enable clock for alternate function (for communication)
2020-03-09 16:56:39 +01:00
# if BUSVOODOO_HARDWARE_VERSION == 2
# if DEBUG
gpio_primary_remap ( AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON , 0 ) ; // disable JTAG to get PA15 as GPIO
# else
gpio_primary_remap ( AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_OFF , 0 ) ; // disable JTAG to get PA15 as GPIO, and SWD to not interfere
# endif
# endif
2019-02-20 19:14:08 +01:00
busvoodoo_safe_state ( ) ; // put pins in safe state (for common light version)
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
// check if this BusVoodoo is a full flavor
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_HV_CHANNEL ) ) ; // enable clock for GPIO domain for HV channel
gpio_set ( ADC12_IN_PORT ( BUSVOODOO_HV_CHANNEL ) , ADC12_IN_PIN ( BUSVOODOO_HV_CHANNEL ) ) ; // pull ADC HV high
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_HV_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_PULL_UPDOWN , ADC12_IN_PIN ( BUSVOODOO_HV_CHANNEL ) ) ; // set HV channel as digital input with pull-up capabilities
// on a full version (fully populated board) the ADC HV signal will be pulled low
if ( gpio_get ( ADC12_IN_PORT ( BUSVOODOO_HV_CHANNEL ) , ADC12_IN_PIN ( BUSVOODOO_HV_CHANNEL ) ) ) { // check is ADC HV is pulled low
busvoodoo_full = false ;
} else {
busvoodoo_full = true ;
busvoodoo_safe_state ( ) ; // also put the full version pins in safe state
}
2020-03-09 12:56:24 +01:00
# endif
2019-02-20 19:14:08 +01:00
// setup ADC to measure the 5V, 3.3V, LV, and HV power rails voltages, and hardware version channel
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_5V_CHANNEL ) ) ; // enable clock for GPIO domain for 5V channel
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_5V_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_5V_CHANNEL ) ) ; // set 5V channel as analogue input for the ADC
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_3V3_CHANNEL ) ) ; // enable clock for GPIO domain for 3.3V channel
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_3V3_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_3V3_CHANNEL ) ) ; // set 3.3V channel as analogue input for the ADC
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_LV_CHANNEL ) ) ; // enable clock for GPIO domain for LV channel
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_LV_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_LV_CHANNEL ) ) ; // set LV channel as analogue input for the ADC
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_HV_CHANNEL ) ) ; // enable clock for GPIO domain for HV channel
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_HV_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_HV_CHANNEL ) ) ; // set HV channel as analogue input for the ADC
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_HW_VERSION_CHANNEL ) ) ; // enable clock for GPIO domain for hardware version channel
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_HW_VERSION_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_HW_VERSION_CHANNEL ) ) ; // set hardware version channel as analogue input for the ADC
2020-03-09 12:56:24 +01:00
# else
rcc_periph_clock_enable ( RCC_ADC12_IN ( BUSVOODOO_ADC_CHANNEL ) ) ; // enable clock for GPIO domain for ADC channel
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_ADC_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_ADC_CHANNEL ) ) ; // set ADC channel as analogue input for the ADC
# endif
2019-02-20 19:14:08 +01:00
rcc_periph_clock_enable ( RCC_ADC1 ) ; // enable clock for ADC domain
adc_power_off ( ADC1 ) ; // switch off ADC while configuring it
adc_disable_scan_mode ( ADC1 ) ; // ensure scan mode is disabled
adc_disable_discontinuous_mode_regular ( ADC1 ) ; // ensure discontinuous mode is not used
adc_set_single_conversion_mode ( ADC1 ) ; // ensure continuous mode is not used (that's not the same as discontinuous)
adc_set_sample_time_on_all_channels ( ADC1 , ADC_SMPR_SMP_28DOT5CYC ) ; // use 28.5 cycles to sample (long enough to be stable)
adc_enable_temperature_sensor ( ) ; // enable internal voltage reference
adc_power_on ( ADC1 ) ; // switch on ADC
sleep_us ( 1 ) ; // wait t_stab for the ADC to stabilize
adc_reset_calibration ( ADC1 ) ; // remove previous non-calibration
adc_calibrate ( ADC1 ) ; // calibrate ADC for less accuracy errors
// find out version of the board
gpio_set_mode ( GPIO ( BUSVOODOO_HW_VERSION_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_PULL_UPDOWN , GPIO ( BUSVOODOO_HW_VERSION_PIN ) ) ; // use pull up and down to check if a voltage divider is present on the pin
gpio_set ( GPIO ( BUSVOODOO_HW_VERSION_PORT ) , GPIO ( BUSVOODOO_HW_VERSION_PIN ) ) ; // pull up
2020-03-09 13:44:08 +01:00
bool version_up = ( 0 ! = gpio_get ( GPIO ( BUSVOODOO_HW_VERSION_PORT ) , GPIO ( BUSVOODOO_HW_VERSION_PIN ) ) ) ; // check if the signal is still up
2019-02-20 19:14:08 +01:00
gpio_clear ( GPIO ( BUSVOODOO_HW_VERSION_PORT ) , GPIO ( BUSVOODOO_HW_VERSION_PIN ) ) ; // pull down
2020-03-09 13:44:08 +01:00
bool version_down = ( 0 = = gpio_get ( GPIO ( BUSVOODOO_HW_VERSION_PORT ) , GPIO ( BUSVOODOO_HW_VERSION_PIN ) ) ) ; // check if the signal is still down
2019-02-20 19:14:08 +01:00
gpio_set_mode ( ADC12_IN_PORT ( BUSVOODOO_HW_VERSION_CHANNEL ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , ADC12_IN_PIN ( BUSVOODOO_HW_VERSION_CHANNEL ) ) ; // put back to analog input
// get version
if ( version_up & & version_down ) { // no voltage divider on pin
busvoodoo_version = ' 0 ' ; // the pin is floating only for version 0 (= revision 18)
} else { // voltage divider on pin
float version_voltage = busvoodoo_vreg_get ( BUSVOODOO_HW_VERSION_CHANNEL ) ; // measure hardware version voltage
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < LENGTH ( busvoodoo_version_voltages ) ; i + + ) { // go through expected version voltages
if ( version_voltage > busvoodoo_version_voltages [ i ] - 0.2 & & version_voltage < busvoodoo_version_voltages [ i ] + 0.2 ) { // verify if voltage matches
busvoodoo_version = ' A ' + i ; // remember version name for matching voltage
2019-02-20 19:14:08 +01:00
break ; // stop searching
}
}
}
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
// setup DAC to control LV and HV voltage outputs
gpio_set_mode ( GPIO ( BUSVOODOO_LVCTL_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , GPIO ( BUSVOODOO_LVCTL_PIN ) ) ; // set LV pin as analog (the DAC will use it as output)
rcc_periph_clock_enable ( RCC_DAC ) ; // enable clock for DAC domain
dac_disable ( BUSVOODOO_LVCTL_CHANNEL ) ; // disable output to configure it properly
dac_buffer_enable ( BUSVOODOO_LVCTL_CHANNEL ) ; // enable output buffer to be able to drive larger loads (should be per default)
if ( busvoodoo_full ) {
gpio_set_mode ( GPIO ( BUSVOODOO_HVCTL_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , GPIO ( BUSVOODOO_HVCTL_PIN ) ) ; // set HV pin as analog (the DAC will use it as output)
dac_disable ( BUSVOODOO_HVCTL_CHANNEL ) ; // disable output to configure it properly
dac_buffer_enable ( BUSVOODOO_HVCTL_CHANNEL ) ; // enable output buffer to be able to drive larger loads (should be per default)
}
dac_set_trigger_source ( DAC_CR_TSEL1_SW ) ; // use software to trigger the voltage change
dac_set_trigger_source ( DAC_CR_TSEL2_SW ) ; // use software to trigger the voltage change
2020-03-09 12:56:24 +01:00
# endif
2019-02-20 19:14:08 +01:00
// enable timer for LED pulsing or blinking
rcc_periph_clock_enable ( RCC_TIM ( BUSVOODOO_LED_TIMER ) ) ; // enable clock for timer domain
rcc_periph_reset_pulse ( RST_TIM ( BUSVOODOO_LED_TIMER ) ) ; // reset timer state
timer_set_mode ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_CR1_CKD_CK_INT , TIM_CR1_CMS_EDGE , TIM_CR1_DIR_UP ) ; // configure timer to up counting mode
2020-03-09 13:44:08 +01:00
timer_set_prescaler ( TIM ( BUSVOODOO_LED_TIMER ) , 3296 - 1 ) ; // set prescaler to allow 3/3 seconds PWM output (72MHz/2^16/3296=0.33Hz)
2019-02-20 19:14:08 +01:00
timer_set_oc_mode ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 , TIM_OCM_PWM1 ) ; // use PWM output compare mode (for blinking)
timer_disable_oc_output ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 ) ; // disable output compare output (for now)
timer_enable_break_main_output ( TIM ( BUSVOODOO_LED_TIMER ) ) ; // required to enable timer 1, even when no dead time is used
2020-03-09 13:44:08 +01:00
timer_set_period ( TIM ( BUSVOODOO_LED_TIMER ) , ( rcc_ahb_frequency / 3296 ) / 1000 ) ; // set period to 1 ms for pulsing
2019-02-20 19:14:08 +01:00
nvic_enable_irq ( NVIC_TIM1_UP_IRQ ) ; // enable interrupt for timer 1 to catch update event when overflowing
// disable LEDs and reset state
gpio_set_mode ( GPIO_PORT ( LED_PIN ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO_PIN ( LED_PIN ) ) ; // set LED pin to floating to disable both LEDs
busvoodoo_global_led_blue_timeout = 0 ; // no timeout needed
busvoodoo_global_led_blue_timer = false ; // no timeout needed
busvoodoo_global_led_red_timeout = 0 ; // no timeout needed
busvoodoo_global_led_red_timer = false ; // no timeout needed
busvoodoo_global_led_blinking = false ; // start in pulse mode
}
void busvoodoo_safe_state ( void )
{
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
// disable voltage outputs
gpio_set ( GPIO ( BUSVOODOO_VOUTEN_PORT ) , GPIO ( BUSVOODOO_VOUTEN_PIN ) ) ; // disable 5V and 3.3V output on connector
gpio_set_mode ( GPIO ( BUSVOODOO_VOUTEN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_VOUTEN_PIN ) ) ; // set pin as output (open-drain pulled high to disable the pMOS)
gpio_clear ( GPIO ( BUSVOODOO_LVEN_PORT ) , GPIO ( BUSVOODOO_LVEN_PIN ) ) ; // disable LV voltage regulator
gpio_set_mode ( GPIO ( BUSVOODOO_LVEN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUSVOODOO_LVEN_PIN ) ) ; // set pin as output (push-pull, pulled low for safety)
gpio_set ( GPIO ( BUSVOODOO_HVEN_PORT ) , GPIO ( BUSVOODOO_HVEN_PIN ) ) ; // disable HV voltage regulator
gpio_set_mode ( GPIO ( BUSVOODOO_HVEN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_HVEN_PIN ) ) ; // set pin as output (open-drain pulled high to disable the pMOS)
// set DAC channel back to analog
gpio_set_mode ( GPIO ( BUSVOODOO_LVCTL_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , GPIO ( BUSVOODOO_LVCTL_PIN ) ) ; // set LV pin as analog
gpio_set_mode ( GPIO ( BUSVOODOO_HVCTL_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_ANALOG , GPIO ( BUSVOODOO_HVCTL_PIN ) ) ; // set HV pin as analog
// disable embedded pull-ups
gpio_primary_remap ( AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON , 0 ) ; // disable JTAG (but keep SWD) so to use the underlying GPIOs (PA15, PB3, PB4)
gpio_set ( GPIO ( BUSVOODOO_5VPULLUP_PORT ) , GPIO ( BUSVOODOO_5VPULLUP_PIN ) ) ; // set pin high to disable 5V embedded pull-up
gpio_set_mode ( GPIO ( BUSVOODOO_5VPULLUP_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_5VPULLUP_PIN ) ) ; // set pin as output (open-drain pulled high to disable the pMOS)
gpio_set ( GPIO ( BUSVOODOO_OEPULLUP_PORT ) , GPIO ( BUSVOODOO_OEPULLUP_PIN ) ) ; // set pin high to disable embedded pull-up bus switch
gpio_set_mode ( GPIO ( BUSVOODOO_OEPULLUP_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_OEPULLUP_PIN ) ) ; // set pin as output (open-drain pulled high to disable the bus switch)
2020-03-09 12:56:24 +01:00
# else
gpio_set_mode ( GPIO_PORT ( BUSVOODOO_I2C_PULLUP_PIN ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO_PIN ( BUSVOODOO_I2C_PULLUP_PIN ) ) ; // per default don't drive to pull up
# endif
2019-02-20 19:14:08 +01:00
// disable all signal I/O outputs
2020-03-09 13:44:08 +01:00
for ( uint8_t pin = 0 ; pin < LENGTH ( busvoodoo_io_ports ) & & pin < LENGTH ( busvoodoo_io_pins ) ; pin + + ) {
2019-02-20 19:14:08 +01:00
gpio_set_mode ( busvoodoo_io_ports [ pin ] , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , busvoodoo_io_pins [ pin ] ) ; // set pin back to input (floating)
}
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
if ( busvoodoo_full ) {
// disable RS-232 signals
gpio_set_mode ( GPIO ( BUSVOODOO_RS232_TX_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_RS232_TX_PIN ) ) ; // set pin to floating
gpio_set_mode ( GPIO ( BUSVOODOO_RS232_RX_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_RS232_RX_PIN ) ) ; // set pin to floating
gpio_set_mode ( GPIO ( BUSVOODOO_RS232_RTS_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_RS232_RTS_PIN ) ) ; // set pin to floating
gpio_set_mode ( GPIO ( BUSVOODOO_RS232_CTS_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_RS232_CTS_PIN ) ) ; // set pin to floating
gpio_set ( GPIO ( BUSVOODOO_RS232_EN_PORT ) , GPIO ( BUSVOODOO_RS232_EN_PIN ) ) ; // set high to disable receiver
gpio_set_mode ( GPIO ( BUSVOODOO_RS232_EN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_RS232_EN_PIN ) ) ; // use external pull-up resistor to set high by default
gpio_clear ( GPIO ( BUSVOODOO_RS232_SHDN_PORT ) , GPIO ( BUSVOODOO_RS232_SHDN_PIN ) ) ; // set low to disable transmitter
gpio_set_mode ( GPIO ( BUSVOODOO_RS232_SHDN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUSVOODOO_RS232_SHDN_PIN ) ) ; // there is also an external pull-down resistor to disable per default
// disable RS-485 signals (RS and TX are shared with RS-232)
gpio_set ( GPIO ( BUSVOODOO_RS485_RE_PORT ) , GPIO ( BUSVOODOO_RS485_RE_PIN ) ) ; // set high to disable receiver
gpio_set_mode ( GPIO ( BUSVOODOO_RS485_RE_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_RS485_RE_PIN ) ) ; // use external pull-up resistor to set high by default
gpio_clear ( GPIO ( BUSVOODOO_RS485_DE_PORT ) , GPIO ( BUSVOODOO_RS485_DE_PIN ) ) ; // set low to disable transmitter
gpio_set_mode ( GPIO ( BUSVOODOO_RS485_DE_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUSVOODOO_RS485_DE_PIN ) ) ; // there is also an external pull-down resistor to disable per default
gpio_set_mode ( GPIO ( BUSVOODOO_RS485_TX_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_RS485_TX_PIN ) ) ; // set pin to floating
gpio_set_mode ( GPIO ( BUSVOODOO_RS485_RX_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_RS485_RX_PIN ) ) ; // set pin to floating
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 0
2019-02-20 19:14:08 +01:00
// disable CAN transceiver and signals (put back to input floating)
gpio_set_mode ( GPIO ( BUSVOODOO_CAN_TX_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_CAN_TX_PIN ) ) ; // set pin to floating
gpio_set_mode ( GPIO ( BUSVOODOO_CAN_RX_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUSVOODOO_CAN_RX_PIN ) ) ; // set pin to floating
gpio_set ( GPIO ( BUSVOODOO_CAN_EN_PORT ) , GPIO ( BUSVOODOO_CAN_EN_PIN ) ) ; // set high to power off transceiver
gpio_set_mode ( GPIO ( BUSVOODOO_CAN_EN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( BUSVOODOO_CAN_EN_PIN ) ) ; // use external pull-up resistor to set high by default
2020-03-09 12:56:24 +01:00
# endif // BUSVOODOO_HARDWARE_VERSION != 0
2019-02-20 19:14:08 +01:00
}
2020-03-09 12:56:24 +01:00
# endif // BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
}
void busvoodoo_text_style ( enum busvoodoo_text_style_t style )
{
switch ( style ) {
case BUSVOODOO_TEXT_STYLE_ERROR :
2020-03-09 14:20:04 +01:00
puts ( " \x1b [31m " ) ;
2019-02-20 19:14:08 +01:00
break ;
case BUSVOODOO_TEXT_STYLE_WARNING :
2020-03-09 14:20:04 +01:00
puts ( " \x1b [33m " ) ;
2019-02-20 19:14:08 +01:00
break ;
case BUSVOODOO_TEXT_STYLE_INFO :
2020-03-09 14:20:04 +01:00
puts ( " \x1b [32m " ) ;
2019-02-20 19:14:08 +01:00
break ;
case BUSVOODOO_TEXT_STYLE_RESET :
default :
2020-03-09 14:20:04 +01:00
puts ( " \x1b [0m " ) ;
2019-02-20 19:14:08 +01:00
break ;
}
}
float busvoodoo_vreg_get ( uint8_t channel )
{
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2020-03-09 13:44:08 +01:00
if ( channel ! = BUSVOODOO_5V_CHANNEL & & channel ! = BUSVOODOO_3V3_CHANNEL & & channel ! = BUSVOODOO_LV_CHANNEL & & channel ! = BUSVOODOO_HV_CHANNEL & & channel ! = BUSVOODOO_HW_VERSION_CHANNEL ) { // check channel
2020-03-09 12:56:24 +01:00
# else
2020-03-09 13:44:08 +01:00
if ( channel ! = BUSVOODOO_ADC_CHANNEL & & channel ! = BUSVOODOO_HW_VERSION_CHANNEL ) { // check channel
2020-03-09 12:56:24 +01:00
# endif
2019-02-20 19:14:08 +01:00
return NAN ;
}
// start by reading the internal voltage
uint8_t channels [ 1 ] = { ADC_CHANNEL17 } ; // voltages to convert: internal
adc_set_regular_sequence ( ADC1 , LENGTH ( channels ) , channels ) ; // set channel to convert
ADC_SR ( ADC1 ) = 0 ; // reset flags
adc_start_conversion_direct ( ADC1 ) ; // start conversion (without using trigger)
while ( ! adc_eoc ( ADC1 ) ) ; // wait until conversion finished
uint16_t internal_value = adc_read_regular ( ADC1 ) ; // read voltage value (clears flag)
// read desired voltage
switch ( channel ) {
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
case BUSVOODOO_5V_CHANNEL :
channels [ 0 ] = ADC_CHANNEL ( BUSVOODOO_5V_CHANNEL ) ;
break ;
case BUSVOODOO_3V3_CHANNEL :
channels [ 0 ] = ADC_CHANNEL ( BUSVOODOO_3V3_CHANNEL ) ;
break ;
case BUSVOODOO_LV_CHANNEL :
channels [ 0 ] = ADC_CHANNEL ( BUSVOODOO_LV_CHANNEL ) ;
break ;
case BUSVOODOO_HV_CHANNEL :
channels [ 0 ] = ADC_CHANNEL ( BUSVOODOO_HV_CHANNEL ) ;
break ;
2020-03-09 12:56:24 +01:00
# else
case BUSVOODOO_ADC_CHANNEL :
channels [ 0 ] = ADC_CHANNEL ( BUSVOODOO_ADC_CHANNEL ) ;
break ;
# endif
2019-02-20 19:14:08 +01:00
case BUSVOODOO_HW_VERSION_CHANNEL :
channels [ 0 ] = ADC_CHANNEL ( BUSVOODOO_HW_VERSION_CHANNEL ) ;
break ;
default : // unknown channel
return NAN ;
}
adc_set_regular_sequence ( ADC1 , LENGTH ( channels ) , channels ) ; // set channel to convert
ADC_SR ( ADC1 ) = 0 ; // reset flags
adc_start_conversion_direct ( ADC1 ) ; // start conversion (without using trigger)
while ( ! adc_eoc ( ADC1 ) ) ; // wait until conversion finished
uint16_t desired_value = adc_read_regular ( ADC1 ) ; // read voltage value (clears flag)
// calculate desired voltage
float to_return = NAN ; // voltage to return
switch ( channel ) { // get converted value and calculate according to the voltage divider on this channel
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
case BUSVOODOO_5V_CHANNEL :
2020-03-09 13:44:08 +01:00
to_return = desired_value / ( 10.0 / ( 10.0 + 10.0 ) ) ;
2019-02-20 19:14:08 +01:00
break ;
case BUSVOODOO_3V3_CHANNEL :
2020-03-09 13:44:08 +01:00
to_return = desired_value / ( 10.0 / ( 10.0 + 10.0 ) ) ;
2019-02-20 19:14:08 +01:00
break ;
case BUSVOODOO_LV_CHANNEL :
2020-03-09 13:44:08 +01:00
to_return = desired_value / ( 10.0 / ( 10.0 + 10.0 ) ) ;
2019-02-20 19:14:08 +01:00
break ;
case BUSVOODOO_HV_CHANNEL :
2020-03-09 13:44:08 +01:00
to_return = desired_value / ( 1.5 / ( 10.0 + 1.5 ) ) ;
2019-02-20 19:14:08 +01:00
break ;
2020-03-09 12:56:24 +01:00
# else
case BUSVOODOO_ADC_CHANNEL :
2020-03-09 13:52:34 +01:00
to_return = desired_value / ( 10.0 / ( 10.0 + 10.0 ) ) ;
2020-03-09 12:56:24 +01:00
break ;
# endif
2019-02-20 19:14:08 +01:00
case BUSVOODOO_HW_VERSION_CHANNEL :
to_return = desired_value ;
break ;
default : // unknown channel
to_return = NAN ;
break ;
}
if ( ! isnan ( to_return ) ) {
2020-03-09 13:44:08 +01:00
to_return * = 1.2 / internal_value ; // calculate voltage from converted values using internal 1.2V voltage reference
2019-02-20 19:14:08 +01:00
}
return to_return ;
}
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
bool busvoodoo_vout_switch ( bool on )
{
if ( on ) { // we need to switch on Vout
gpio_clear ( GPIO ( BUSVOODOO_VOUTEN_PORT ) , GPIO ( BUSVOODOO_VOUTEN_PIN ) ) ; // enable Vout
} else {
gpio_set ( GPIO ( BUSVOODOO_VOUTEN_PORT ) , GPIO ( BUSVOODOO_VOUTEN_PIN ) ) ; // disable Vout
}
bool to_return = true ;
sleep_ms ( 1 ) ; // wait a bit for voltage to settle
float voltage = busvoodoo_vreg_get ( BUSVOODOO_5V_CHANNEL ) ; // get 5V power rail voltage
2020-03-09 13:44:08 +01:00
if ( voltage < 4.0 | | voltage > 5.5 ) {
2020-03-09 12:56:24 +01:00
to_return = false ; // voltage output is not ok
}
voltage = busvoodoo_vreg_get ( BUSVOODOO_3V3_CHANNEL ) ; // get 3.3V power rail voltage
2020-03-09 13:44:08 +01:00
if ( voltage < 3.0 | | voltage > 3.6 ) {
2020-03-09 12:56:24 +01:00
to_return = true ; // voltage output is not ok
}
return to_return ;
}
2019-02-20 19:14:08 +01:00
float busvoodoo_lv_set ( float voltage )
{
float volt = NAN ; // common variable for voltages
2020-03-09 13:44:08 +01:00
if ( voltage < = 0.3 ) { // disable voltage regulator
2019-02-20 19:14:08 +01:00
gpio_clear ( GPIO ( BUSVOODOO_LVEN_PORT ) , GPIO ( BUSVOODOO_LVEN_PIN ) ) ; // disable LV voltage regulator
dac_disable ( BUSVOODOO_LVCTL_CHANNEL ) ; // disable LV control
} else { // enable voltage regulator
2020-03-09 13:44:08 +01:00
if ( voltage > 4.85 ) { // use the 5V directly
2019-02-20 19:14:08 +01:00
gpio_clear ( GPIO ( BUSVOODOO_5VPULLUP_PORT ) , GPIO ( BUSVOODOO_5VPULLUP_PIN ) ) ; // put 5V on LV line
} else { // use adjustable voltage regulator (5.0V rail minus LDO and diodes)
gpio_set ( GPIO ( BUSVOODOO_5VPULLUP_PORT ) , GPIO ( BUSVOODOO_5VPULLUP_PIN ) ) ; // disable 5V input
volt = busvoodoo_vreg_get ( BUSVOODOO_3V3_CHANNEL ) ; // get reference voltage
if ( isnan ( voltage ) ) {
return NAN ;
}
2020-03-09 13:44:08 +01:00
uint16_t dac_set = BUSVOODOO_LV_SET ( voltage ) / volt * 4095 ; // DAC value corresponding to the voltage
2019-02-20 19:14:08 +01:00
dac_load_data_buffer_single ( dac_set , RIGHT12 , BUSVOODOO_LVCTL_CHANNEL ) ; // set output so the voltage regulator is set to 2.5V
dac_software_trigger ( BUSVOODOO_LVCTL_CHANNEL ) ; // transfer the value to the DAC
dac_enable ( BUSVOODOO_LVCTL_CHANNEL ) ; // enable DAC
gpio_set ( GPIO ( BUSVOODOO_LVEN_PORT ) , GPIO ( BUSVOODOO_LVEN_PIN ) ) ; // enable LV voltage regulator
}
}
sleep_ms ( 50 ) ; // let voltage settle
volt = busvoodoo_vreg_get ( BUSVOODOO_LV_CHANNEL ) ; // get LV voltage to return
return volt ; // return measured voltage
}
float busvoodoo_hv_set ( float voltage )
{
if ( ! busvoodoo_full ) { // the HV voltage regulator is only present on the full version
return NAN ;
}
float volt = NAN ; // common variable for voltages
2020-03-09 13:44:08 +01:00
if ( voltage < 3.29 ) { // disable voltage regulator
2019-02-20 19:14:08 +01:00
gpio_set ( GPIO ( BUSVOODOO_HVEN_PORT ) , GPIO ( BUSVOODOO_HVEN_PIN ) ) ; // disable HV voltage regulator
dac_disable ( BUSVOODOO_HVCTL_CHANNEL ) ; // disable HV control
} else {
2020-03-09 13:44:08 +01:00
if ( voltage > 24.0 ) { // enforce upper voltage limit (diodes limit is 30V, ADC input limit is 25V)
2019-02-20 19:14:08 +01:00
voltage = 24.0 ;
}
volt = busvoodoo_vreg_get ( BUSVOODOO_3V3_CHANNEL ) ; // get reference voltage
if ( isnan ( voltage ) ) {
return NAN ;
}
2020-03-09 13:44:08 +01:00
uint16_t dac_set = BUSVOODOO_HV_SET ( voltage ) / volt * 4095 ; // DAC value corresponding to the voltage
2019-02-20 19:14:08 +01:00
dac_load_data_buffer_single ( dac_set , RIGHT12 , BUSVOODOO_HVCTL_CHANNEL ) ; // set output so the voltage regulator is set to desired output voltage
dac_software_trigger ( BUSVOODOO_HVCTL_CHANNEL ) ; // transfer the value to the DAC
dac_enable ( BUSVOODOO_HVCTL_CHANNEL ) ; // enable DAC
gpio_clear ( GPIO ( BUSVOODOO_HVEN_PORT ) , GPIO ( BUSVOODOO_HVEN_PIN ) ) ; // enable HV voltage regulator
}
sleep_ms ( 100 ) ; // let the voltage regulator start and voltage settle
volt = busvoodoo_vreg_get ( BUSVOODOO_HV_CHANNEL ) ; // get HV voltage
return volt ; // return measured voltage
}
2020-03-09 12:56:24 +01:00
# endif // BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
float busvoodoo_embedded_pullup ( bool on )
{
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
if ( on ) { // enable embedded pull-ups
gpio_clear ( GPIO ( BUSVOODOO_OEPULLUP_PORT ) , GPIO ( BUSVOODOO_OEPULLUP_PIN ) ) ; // switch on embedded pull-ups
} else { // disable embedded pull-ups
gpio_set ( GPIO ( BUSVOODOO_OEPULLUP_PORT ) , GPIO ( BUSVOODOO_OEPULLUP_PIN ) ) ; // switch off embedded pull-up
}
2020-03-09 12:56:24 +01:00
return busvoodoo_vreg_get ( BUSVOODOO_LV_CHANNEL ) ; // get voltage on adjustable voltage regulator to be used by the embedded pull-ups
# else
if ( on ) { // enable embedded pull-ups
gpio_set ( GPIO_PORT ( BUSVOODOO_I2C_PULLUP_PIN ) , GPIO_PIN ( BUSVOODOO_I2C_PULLUP_PIN ) ) ; // pull up
gpio_set_mode ( GPIO_PORT ( BUSVOODOO_I2C_PULLUP_PIN ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO_PIN ( BUSVOODOO_I2C_PULLUP_PIN ) ) ; // set pin to output push-pull do drive pull-up resistors
} else { // disable embedded pull-ups
gpio_set_mode ( GPIO_PORT ( BUSVOODOO_I2C_PULLUP_PIN ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO_PIN ( BUSVOODOO_I2C_PULLUP_PIN ) ) ; // stop driving the pull-up resistors
}
return 3.3 ;
# endif
2019-02-20 19:14:08 +01:00
}
/** update LED status according to LED flags */
static void busvoodoo_leds_update ( void )
{
// handle LED timer
2020-03-09 13:44:08 +01:00
if ( busvoodoo_global_led_blue_timer & & 0 = = busvoodoo_global_led_blue_timeout ) { // timer reached timeout
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_blue_timer = false ; // timer it not required anymore
}
2020-03-09 13:44:08 +01:00
if ( busvoodoo_global_led_red_timer & & 0 = = busvoodoo_global_led_red_timeout ) { // timer reached timeout
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_red_timer = false ; // timer it not required anymore
}
if ( ! busvoodoo_global_led_blue_timer & & ! busvoodoo_global_led_red_timer ) { // timer is not needed anymore
timer_disable_counter ( TIM ( BUSVOODOO_LED_TIMER ) ) ; // disable timer
timer_disable_irq ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_DIER_UIE ) ; // disable overflow interrupt used as tick
}
// drive right LED
2020-03-09 13:44:08 +01:00
if ( busvoodoo_global_led_blue_timeout > 0 & & busvoodoo_global_led_red_timeout > 0 ) { // both LEDs should be on
timer_set_period ( TIM ( BUSVOODOO_LED_TIMER ) , ( rcc_ahb_frequency / 3296 ) / 1000 ) ; // ensure timer is set period to 1 ms for pulsing
timer_set_oc_value ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 , rcc_ahb_frequency / 3296 / 1000 / 2 ) ; // set 50% PWM duty cycle
2019-02-20 19:14:08 +01:00
timer_enable_oc_output ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 ) ; // enable PWM output
gpio_set_mode ( GPIO_PORT ( LED_PIN ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_ALTFN_PUSHPULL , GPIO_PIN ( LED_PIN ) ) ; // allow PWM to drive pin
timer_enable_counter ( TIM ( BUSVOODOO_LED_TIMER ) ) ; // ensure the timer is enabled (interrupt should be disabled if not required)
2020-03-09 13:44:08 +01:00
} else if ( busvoodoo_global_led_blue_timeout > 0 ) { // only blue LED should be on
2019-02-20 19:14:08 +01:00
timer_disable_oc_output ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 ) ; // disable PWM output
gpio_set ( GPIO_PORT ( LED_PIN ) , GPIO_PIN ( LED_PIN ) ) ; // switch only blue LED on
gpio_set_mode ( GPIO_PORT ( LED_PIN ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO_PIN ( LED_PIN ) ) ; // set LED pin as push-pull to drive either LED
} else if ( busvoodoo_global_led_red_timeout > 0 ) { // only red LED should be on
timer_disable_oc_output ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 ) ; // disable PWM output
gpio_clear ( GPIO_PORT ( LED_PIN ) , GPIO_PIN ( LED_PIN ) ) ; // switch only red LED on
gpio_set_mode ( GPIO_PORT ( LED_PIN ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO_PIN ( LED_PIN ) ) ; // set LED pin as push-pull to drive either LED
} else { // no LED should be on
timer_disable_oc_output ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 ) ; // disable PWM output
gpio_set_mode ( GPIO_PORT ( LED_PIN ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO_PIN ( LED_PIN ) ) ; // set LED pin to floating to disable both LEDs
}
busvoodoo_global_led_blinking = false ; // setting the LEDs forced blinking mode exit
}
void busvoodoo_led_blue_on ( void )
{
busvoodoo_global_led_blue_timer = false ; // there it no timeout of this LED
busvoodoo_global_led_blue_timeout = 1 ; // still enable LED
busvoodoo_leds_update ( ) ; // update LED status
}
void busvoodoo_led_blue_off ( void )
{
busvoodoo_global_led_blue_timer = false ; // there it no timeout of this LED
busvoodoo_global_led_blue_timeout = 0 ; // disable LED
busvoodoo_leds_update ( ) ; // update LED status
}
void busvoodoo_led_red_on ( void )
{
busvoodoo_global_led_red_timer = false ; // there it no timeout of this LED
busvoodoo_global_led_red_timeout = 1 ; // still enable LED
busvoodoo_leds_update ( ) ; // update LED status
}
void busvoodoo_led_red_off ( void )
{
busvoodoo_global_led_red_timer = false ; // there it no timeout of this LED
busvoodoo_global_led_red_timeout = 0 ; // disable LED
busvoodoo_leds_update ( ) ; // update LED status
}
void busvoodoo_leds_off ( void )
{
busvoodoo_global_led_blue_timer = false ; // there it no timeout of this LED
busvoodoo_global_led_blue_timeout = 0 ; // disable LED
busvoodoo_global_led_red_timer = false ; // there it no timeout of this LED
busvoodoo_global_led_red_timeout = 0 ; // disable LED
busvoodoo_leds_update ( ) ; // update LED status
}
/** setup the timer for pulsing LEDs */
static void busvoodoo_led_pulse_setup ( void )
{
if ( ! busvoodoo_global_led_blinking ) { // we are in the blink mode, reconfigure to pulse mode
timer_disable_oc_output ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 ) ; // disable PWM output
2020-03-09 13:44:08 +01:00
timer_set_period ( TIM ( BUSVOODOO_LED_TIMER ) , ( rcc_ahb_frequency / 3296 ) / 1000 ) ; // set period to 1 ms for pulsing
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_blinking = false ; // remember we quite the PWM/blinking mode
}
timer_enable_irq ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_DIER_UIE ) ; // enable overflow interrupt used as tick
timer_enable_counter ( TIM ( BUSVOODOO_LED_TIMER ) ) ; // ensure the timer is enabled
}
void busvoodoo_led_blue_pulse ( uint32_t ms )
{
2020-03-09 13:44:08 +01:00
if ( 0 = = ms ) { // disable LED
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_blue_timer = false ; // no need to use the timer
busvoodoo_global_led_blue_timeout = 0 ; // disable blue LED
} else {
busvoodoo_global_led_blue_timer = true ; // use the timer
busvoodoo_global_led_blue_timeout = ms ; // disable blue LED
busvoodoo_led_pulse_setup ( ) ; // start timer
}
busvoodoo_leds_update ( ) ; // update LED status
}
void busvoodoo_led_red_pulse ( uint32_t ms )
{
2020-03-09 13:44:08 +01:00
if ( 0 = = ms ) { // disable LED
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_red_timer = false ; // no need to use the timer
busvoodoo_global_led_red_timeout = 0 ; // disable blue LED
} else {
busvoodoo_global_led_red_timer = true ; // use the timer
busvoodoo_global_led_red_timeout = ms ; // disable blue LED
busvoodoo_led_pulse_setup ( ) ; // start timer
}
busvoodoo_leds_update ( ) ; // update LED status
}
/** interrupt service routine called on LED timeout */
void tim1_up_isr ( void )
{
if ( timer_get_flag ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_SR_UIF ) ) { // tick occurred
timer_clear_flag ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_SR_UIF ) ; // clear flag
2020-03-09 13:44:08 +01:00
if ( busvoodoo_global_led_blue_timer & & busvoodoo_global_led_blue_timeout > 0 ) { // timeout for blue LED is running
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_blue_timeout - - ; // decrement remaining timeout
}
2020-03-09 13:44:08 +01:00
if ( busvoodoo_global_led_red_timer & & busvoodoo_global_led_red_timeout > 0 ) { // timeout for red LED is running
2019-02-20 19:14:08 +01:00
busvoodoo_global_led_red_timeout - - ; // decrement remaining timeout
}
2020-03-09 13:44:08 +01:00
if ( 0 = = busvoodoo_global_led_blue_timeout | | 0 = = busvoodoo_global_led_red_timeout ) { // a timeout occured
2019-02-20 19:14:08 +01:00
busvoodoo_leds_update ( ) ; // update LED status
}
}
}
void busvoodoo_leds_blink ( double period , double duty )
{
2020-03-09 13:44:08 +01:00
if ( period < 0.0 | | period > 6.0 | | duty < 0.0 | | duty > 1.0 ) { // input argument out of bounds
2019-02-20 19:14:08 +01:00
return ; // do nothing
}
timer_disable_counter ( TIM ( BUSVOODOO_LED_TIMER ) ) ; // disable timer while reconfiguring
timer_disable_irq ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_DIER_UIE ) ; // disable overflow interrupt used for pulsing
if ( busvoodoo_global_led_blue_timer ) { // switch off LED when pulsing
busvoodoo_global_led_blue_timer = false ; // stop pulse
busvoodoo_global_led_blue_timeout = 0 ; // switch off
}
if ( busvoodoo_global_led_blue_timer ) { // switch off LED when pulsing
busvoodoo_global_led_blue_timer = false ; // stop pulse
busvoodoo_global_led_blue_timeout = 0 ; // switch off
}
if ( 0.0 = = period ) { // no blinking
if ( duty > = 0.5 ) { // only enable blue LED
busvoodoo_global_led_blue_timeout = 1 ;
} else { // only enable red LED
busvoodoo_global_led_red_timeout = 1 ;
}
busvoodoo_leds_update ( ) ;
} else {
gpio_set_mode ( GPIO_PORT ( LED_PIN ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_ALTFN_PUSHPULL , GPIO_PIN ( LED_PIN ) ) ; // set LED pin to alternate function for PWM
timer_set_counter ( TIM ( BUSVOODOO_LED_TIMER ) , 0 ) ; // reset counter
2020-03-09 13:44:08 +01:00
timer_set_period ( TIM ( BUSVOODOO_LED_TIMER ) , 0xffff * ( period / 6.0 ) ) ; // set period
timer_set_oc_value ( TIM ( BUSVOODOO_LED_TIMER ) , TIM_OC1 , 0xffff * ( period / 6.0 ) * duty ) ; // PWM duty cycle
2019-02-20 19:14:08 +01:00
timer_enable_counter ( TIM ( BUSVOODOO_LED_TIMER ) ) ; // enable timer to start blinking
}
}
/** updates the red power LED status
* @ note the red LED is used to indicate if power is enabled on Vout , LV , or HV
*/
static void busvoodoo_global_power_led_update ( void )
{
bool power_led_on = false ; // to calculate the final state of the power LED
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
power_led_on | = ! gpio_get ( GPIO ( BUSVOODOO_VOUTEN_PORT ) , GPIO ( BUSVOODOO_VOUTEN_PIN ) ) ; // check power rails output
power_led_on | = ! gpio_get ( GPIO ( BUSVOODOO_5VPULLUP_PORT ) , GPIO ( BUSVOODOO_5VPULLUP_PIN ) ) ; // check 5V output on LV pin
power_led_on | = gpio_get ( GPIO ( BUSVOODOO_LVEN_PORT ) , GPIO ( BUSVOODOO_LVEN_PIN ) ) ; // check if low-voltage regulator is on
if ( ! busvoodoo_full ) {
power_led_on | = ! gpio_get ( GPIO ( BUSVOODOO_HVEN_PORT ) , GPIO ( BUSVOODOO_HVEN_PIN ) ) ; // check if high-voltage regulator is on
}
2020-03-09 12:56:24 +01:00
# else
power_led_on = true ; // the output can't be switched off
# endif
2019-02-20 19:14:08 +01:00
if ( power_led_on ) {
busvoodoo_led_red_on ( ) ; // switch on red LED to indicate one of the power output is on
} else {
busvoodoo_led_red_off ( ) ; // switch off red LED to indicate no power output is on
}
}
bool busvoodoo_global_actions ( char * actions , bool perform , bool ( * action_handler ) ( const char * action , uint32_t repetition , bool perform ) )
{
char * action_start = actions ; // start of the current action
bool last_action = false ; // is the current action the last one
2020-03-09 13:44:08 +01:00
while ( ' \0 ' ! = * action_start & & ! last_action ) {
2019-02-20 19:14:08 +01:00
// find end of action
2020-03-09 13:44:08 +01:00
char * action_end = action_start + 1 ;
if ( ' " ' = = * action_start | | ' \' ' = = * action_start ) { // start of string
while ( ' \0 ' ! = * action_end & & * action_end ! = * action_start ) {
2019-02-20 19:14:08 +01:00
action_end + + ;
}
if ( * action_end ! = * action_start ) { // action not ended correctly
return false ;
}
action_end + + ; // go the end of action
} else { // just look for a separation
2020-03-09 13:44:08 +01:00
while ( ' \0 ' ! = * action_end & & ' : ' ! = * action_end & & ' ' ! = * action_end & & ' , ' ! = * action_end ) {
2019-02-20 19:14:08 +01:00
action_end + + ;
}
}
// find start of next action
char * separation = action_end ; // position of separation to next action
2020-03-09 13:44:08 +01:00
while ( ' \0 ' ! = * separation & & ' ' ! = * separation & & ' , ' ! = * separation ) { // find separation or end
2019-02-20 19:14:08 +01:00
separation + + ;
}
2020-03-09 13:44:08 +01:00
if ( ' \0 ' = = * separation ) {
2019-02-20 19:14:08 +01:00
last_action = true ; // remember we reached the end of the string
} else {
* separation = ' \0 ' ; // end the action to form a string
}
// get multiplier
uint32_t multiplier = 1 ; // the number of times the action should be performed
2020-03-09 13:44:08 +01:00
if ( separation > action_end ) { // there is something after the action
if ( ' : ' = = * action_end ) { // multiplier sign found
if ( separation = = action_end + 1 ) { // no digit present
2019-02-20 19:14:08 +01:00
return false ; // malformed action
}
2020-03-09 13:44:08 +01:00
for ( char * digit = action_end + 1 ; digit < separation ; digit + + ) { // check if all the characters are digits
if ( * digit < ' 0 ' | | * digit > ' 9 ' ) { // not a digit
2019-02-20 19:14:08 +01:00
return false ; // malformed string
}
}
2020-03-09 13:44:08 +01:00
multiplier = strtol ( action_end + 1 , NULL , 10 ) ; // parse multiplier number
2019-02-20 19:14:08 +01:00
} else { // unknown sign after action
return false ; // malformed action
}
}
// perform action
* action_end = ' \0 ' ; // end action string
if ( ! ( * action_handler ) ( action_start , multiplier , perform ) ) { // perform action
return false ; // action if malformed
}
// go to next action
if ( ! last_action ) {
2020-03-09 13:44:08 +01:00
action_start = separation + 1 ;
2019-02-20 19:14:08 +01:00
}
}
return true ; // all went well
}
/* command handlers */
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
/** switch 3V3 and 5V power rails on/off
* @ param [ in ] argument string : " on " to switch on , " off " to switch off , NULL to get status
*/
static void busvoodoo_global_power ( void * argument )
{
float voltage ;
2020-03-09 13:44:08 +01:00
if ( NULL = = argument | | 0 = = strlen ( argument ) ) {
2019-02-20 19:14:08 +01:00
if ( gpio_get ( GPIO ( BUSVOODOO_VOUTEN_PORT ) , GPIO ( BUSVOODOO_VOUTEN_PIN ) ) ) { // check if power rails are switch on (enable low)
goto power_off ;
} else {
goto power_on ;
}
2020-03-09 13:44:08 +01:00
} else if ( 0 = = strcmp ( argument , " on " ) ) {
2019-02-20 19:14:08 +01:00
if ( busvoodoo_vout_switch ( true ) ) { // switch power rail on
2020-03-09 14:20:04 +01:00
puts ( " power rails switched on \n " ) ;
2019-02-20 19:14:08 +01:00
} else {
2020-03-09 14:20:04 +01:00
puts ( " power rails switched on but malfunctioning \n " ) ;
2019-02-20 19:14:08 +01:00
}
power_on :
voltage = busvoodoo_vreg_get ( BUSVOODOO_5V_CHANNEL ) ; // get 5V power rail voltage
printf ( " 5V power rail: %.2fV \n " , voltage ) ;
voltage = busvoodoo_vreg_get ( BUSVOODOO_3V3_CHANNEL ) ; // get 3.3V power rail voltage
printf ( " 3V3 power rail: %.2fV \n " , voltage ) ;
2020-03-09 13:44:08 +01:00
} else if ( 0 = = strcmp ( argument , " off " ) ) {
2019-02-20 19:14:08 +01:00
busvoodoo_vout_switch ( false ) ; // switch power rail off
2020-03-09 14:20:04 +01:00
puts ( " power rails switched off \n " ) ;
2019-02-20 19:14:08 +01:00
power_off :
2020-03-09 14:20:04 +01:00
puts ( " 5V power rail: off \n " ) ;
puts ( " 3V3 power rail: off \n " ) ;
2019-02-20 19:14:08 +01:00
} else {
printf ( " option malformed: %s \n " , argument ) ;
}
busvoodoo_global_power_led_update ( ) ; // update power output LED
}
/** set LV linear drop-out voltage regulator voltage
* @ param [ in ] argument voltage to set ( 0 to switch off , NULL to get voltage )
*/
static void busvoodoo_global_lv ( void * argument )
{
2020-03-09 13:44:08 +01:00
if ( NULL = = argument ) {
2019-02-20 19:14:08 +01:00
if ( ! gpio_get ( GPIO ( BUSVOODOO_5VPULLUP_PORT ) , GPIO ( BUSVOODOO_5VPULLUP_PIN ) ) ) { // 5V input enabled
2020-03-09 14:20:04 +01:00
puts ( " 5V power rail used " ) ;
2019-02-20 19:14:08 +01:00
} else if ( gpio_get ( GPIO ( BUSVOODOO_LVEN_PORT ) , GPIO ( BUSVOODOO_LVEN_PIN ) ) ) { // LV voltage regulator used
2020-03-09 14:20:04 +01:00
puts ( " adjustable voltage regulator used " ) ;
2019-02-20 19:14:08 +01:00
} else {
2020-03-09 14:20:04 +01:00
puts ( " external voltage input " ) ;
2019-02-20 19:14:08 +01:00
}
float voltage = busvoodoo_vreg_get ( BUSVOODOO_LV_CHANNEL ) ; // get LV voltage
// print LV voltage
if ( voltage < 0.1 ) {
printf ( " : 0.00V \n " ) ;
} else {
printf ( " : %.2fV \n " , voltage ) ;
}
} else {
double voltage = * ( ( double * ) argument ) ; // get desired voltage
2020-03-09 13:44:08 +01:00
if ( 0 = = voltage ) {
2020-03-09 14:20:04 +01:00
puts ( " LV rail switched off " ) ;
2019-02-20 19:14:08 +01:00
} else {
printf ( " LV rail set to %.2fV " , voltage ) ;
}
voltage = busvoodoo_lv_set ( voltage ) ; // set LV voltage
// print LV voltage
if ( voltage < 0.1 ) {
printf ( " : 0.00V \n " ) ;
} else {
printf ( " : %.2fV \n " , voltage ) ;
}
}
busvoodoo_global_power_led_update ( ) ; // update power output LED
}
/** set HV step-up voltage regulator voltage
* @ param [ in ] argument voltage to set ( 0 to switch off , NULL to get voltage )
*/
static void busvoodoo_global_hv ( void * argument )
{
if ( ! busvoodoo_full ) {
printf ( " function not available on BusVoodoo light " ) ;
return ;
}
2020-03-09 13:44:08 +01:00
if ( NULL = = argument ) {
2019-02-20 19:14:08 +01:00
printf ( " high voltage regulator switched %s: " , gpio_get ( GPIO ( BUSVOODOO_HVEN_PORT ) , GPIO ( BUSVOODOO_HVEN_PIN ) ) ? " off " : " on " ) ;
float voltage = busvoodoo_vreg_get ( BUSVOODOO_HV_CHANNEL ) ; // get HV voltage
// print LV voltage
if ( voltage < 0.1 ) {
2020-03-09 14:20:04 +01:00
puts ( " 0.00V \n " ) ;
2019-02-20 19:14:08 +01:00
} else {
printf ( " %.2fV \n " , voltage ) ;
}
} else {
double voltage = * ( ( double * ) argument ) ; // get desired voltage
2020-03-09 14:20:04 +01:00
puts ( " high voltage rail " ) ;
2020-03-09 13:44:08 +01:00
if ( voltage < = 3.3 ) {
2020-03-09 14:20:04 +01:00
puts ( " switched off " ) ;
2019-02-20 19:14:08 +01:00
} else {
printf ( " set to %.2fV " , voltage ) ;
}
voltage = busvoodoo_hv_set ( voltage ) ; // set HV voltage
// print HV voltage
if ( voltage < 0.1 ) {
2020-03-09 14:20:04 +01:00
puts ( " : 0.00V \n " ) ;
2019-02-20 19:14:08 +01:00
} else {
printf ( " : %.2fV \n " , voltage ) ;
}
}
busvoodoo_global_power_led_update ( ) ; // update power output LED
}
2020-03-09 12:56:24 +01:00
# else // BUSVOODOO_HARDWARE_VERSION != 2
/** show voltage on ADC pin
* @ param [ in ] argument not required
*/
static void busvoodoo_global_adc ( void * argument )
{
( void ) argument ; // argument not used
float voltage = busvoodoo_vreg_get ( BUSVOODOO_ADC_CHANNEL ) ; // get ADC voltage
// print ADC voltage
if ( voltage < 0.1 ) {
2020-03-09 14:20:04 +01:00
puts ( " : 0.00V \n " ) ;
2020-03-09 12:56:24 +01:00
} else {
printf ( " : %.2fV \n " , voltage ) ;
}
busvoodoo_global_power_led_update ( ) ; // update power output LED
}
# endif // BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
/** display I/O and RS/CAN connector pinouts
* @ param [ in ] argument not used
*/
static void busvoodoo_global_pinout ( void * argument )
{
( void ) argument ; // argument is not used
bool no_pinout = true ; // it no pinout has been displays
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
// display RS/CAN connector pinout
if ( busvoodoo_full ) { // only display on full version of the board
bool pin_used = false ; // if no pins are used
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < LENGTH ( busvoodoo_global_pinout_rscan ) ; i + + ) { // verify if one of the pins is used
pin_used | = ( NULL ! = busvoodoo_global_pinout_rscan [ i ] ) ; // verify if pin is used
2019-02-20 19:14:08 +01:00
}
if ( pin_used ) {
// count the space used to display the pins
uint8_t space = 0 ; // no integer overflow protected (it's only cosmetic)
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < LENGTH ( busvoodoo_global_pinout_rscan ) ; i + + ) {
if ( NULL = = busvoodoo_global_pinout_rscan [ i ] ) {
2019-02-20 19:14:08 +01:00
space + = 1 ; // only x will be shown
} else {
space + = strlen ( busvoodoo_global_pinout_rscan [ i ] ) ; // add size of pin name
}
}
2020-03-09 13:44:08 +01:00
space + = LENGTH ( busvoodoo_global_pinout_rscan ) - 1 ; // add the spaces between the names
2019-02-20 19:14:08 +01:00
// display pinout
2020-03-09 14:20:04 +01:00
puts ( " RS/CAN connector pinout: \n " ) ;
2019-02-20 19:14:08 +01:00
// display top line
2020-03-09 14:20:04 +01:00
putc ( ' + ' ) ;
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < space ; i + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' - ' ) ;
2019-02-20 19:14:08 +01:00
}
2020-03-09 14:20:04 +01:00
puts ( " + \n " ) ;
2019-02-20 19:14:08 +01:00
// display pin names
2020-03-09 14:20:04 +01:00
putc ( ' | ' ) ;
2020-03-09 13:44:08 +01:00
for ( int8_t i = LENGTH ( busvoodoo_global_pinout_rscan ) - 1 ; i > = 0 ; i - - ) {
if ( NULL = = busvoodoo_global_pinout_rscan [ i ] ) {
2020-03-09 14:20:04 +01:00
putc ( ' x ' ) ; // x stands for pin not used
2019-02-20 19:14:08 +01:00
} else {
printf ( " %s " , busvoodoo_global_pinout_rscan [ i ] ) ; // print pin name
}
2020-03-09 14:20:04 +01:00
if ( i > 0 ) {
putc ( ' ' ) ; // print space between the pin names
2019-02-20 19:14:08 +01:00
}
}
2020-03-09 14:20:04 +01:00
puts ( " | \n " ) ;
2019-02-20 19:14:08 +01:00
// display bottom line
2020-03-09 14:20:04 +01:00
putc ( ' + ' ) ;
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < space ; i + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' - ' ) ;
2019-02-20 19:14:08 +01:00
}
2020-03-09 14:20:04 +01:00
puts ( " + \n " ) ;
2019-02-20 19:14:08 +01:00
no_pinout = false ; // remember a pinout has been shown
}
}
2020-03-09 12:56:24 +01:00
# endif
2019-02-20 19:14:08 +01:00
// display I/O connector pinout
bool pin_used = false ; // if no pins are used
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < LENGTH ( busvoodoo_global_pinout_io ) ; i + + ) { // verify if one of the pins is used
pin_used | = ( NULL ! = busvoodoo_global_pinout_io [ i ] ) ; // verify if pin is used
2019-02-20 19:14:08 +01:00
}
if ( pin_used ) {
// count the space used to display the pins (no integer overflow protected, it's only cosmetic)
uint8_t spaces [ 5 ] = { 0 } ; // maximum spaces used by top and bottom pins
2020-03-09 13:44:08 +01:00
for ( uint8_t i = 0 ; i < LENGTH ( spaces ) ; i + + ) {
if ( NULL = = busvoodoo_global_pinout_io [ i * 2 ] ) {
2019-02-20 19:14:08 +01:00
spaces [ i ] = 1 ; // only x will be shown
} else {
2020-03-09 13:44:08 +01:00
spaces [ i ] = strlen ( busvoodoo_global_pinout_io [ i * 2 ] ) ; // remember size of pin name
2019-02-20 19:14:08 +01:00
}
2020-03-09 13:44:08 +01:00
if ( NULL = = busvoodoo_global_pinout_io [ i * 2 + 1 ] ) {
if ( spaces [ i ] < 1 ) {
2019-02-20 19:14:08 +01:00
spaces [ i ] = 1 ; // only x will be shown
}
} else {
2020-03-09 13:44:08 +01:00
if ( spaces [ i ] < strlen ( busvoodoo_global_pinout_io [ i * 2 + 1 ] ) ) {
spaces [ i ] = strlen ( busvoodoo_global_pinout_io [ i * 2 + 1 ] ) ; // remember bigger size of pin name
2019-02-20 19:14:08 +01:00
}
}
}
// display pinout
2020-03-09 14:20:04 +01:00
puts ( " I/O connector pinout: \n " ) ;
2019-02-20 19:14:08 +01:00
// display top line
2020-03-09 14:20:04 +01:00
putc ( ' + ' ) ;
2020-03-09 13:44:08 +01:00
for ( uint16_t i = 0 ; i < ( uint16_t ) ( spaces [ 4 ] + spaces [ 3 ] + 1 ) ; i + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' - ' ) ;
2019-02-20 19:14:08 +01:00
}
2020-03-09 13:44:08 +01:00
for ( uint16_t i = 0 ; i < ( uint16_t ) ( spaces [ 2 ] + 2 ) ; i + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ;
2019-02-20 19:14:08 +01:00
}
2020-03-09 13:44:08 +01:00
for ( uint16_t i = 0 ; i < ( uint16_t ) ( spaces [ 1 ] + spaces [ 0 ] + 1 ) ; i + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' - ' ) ;
2019-02-20 19:14:08 +01:00
}
2020-03-09 14:20:04 +01:00
puts ( " + \n " ) ;
2019-02-20 19:14:08 +01:00
// display top pin names
2020-03-09 14:20:04 +01:00
putc ( ' | ' ) ;
2020-03-09 13:44:08 +01:00
for ( int8_t i = 4 ; i > = 0 ; i - - ) {
if ( NULL = = busvoodoo_global_pinout_io [ i * 2 ] ) {
2020-03-09 14:20:04 +01:00
putc ( ' x ' ) ; // x stands for pin not used
2020-03-09 13:44:08 +01:00
for ( int16_t j = 0 ; j + 1 < spaces [ i ] ; j + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ; // pad to match to bottom pin
2019-02-20 19:14:08 +01:00
}
} else {
2020-03-09 13:44:08 +01:00
printf ( " %s " , busvoodoo_global_pinout_io [ i * 2 ] ) ; // print pin name
for ( int16_t j = 0 ; j + strlen ( busvoodoo_global_pinout_io [ i * 2 ] ) < spaces [ i ] ; j + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ; // pad to match to bottom pin
2019-02-20 19:14:08 +01:00
}
}
2020-03-09 13:44:08 +01:00
if ( i > 0 ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ; // print space between the pin names
2019-02-20 19:14:08 +01:00
}
}
printf ( " | \n " ) ;
// display bottom pin names
2020-03-09 14:20:04 +01:00
putc ( ' | ' ) ;
2020-03-09 13:44:08 +01:00
for ( int8_t i = 4 ; i > = 0 ; i - - ) {
if ( NULL = = busvoodoo_global_pinout_io [ i * 2 + 1 ] ) {
2020-03-09 14:20:04 +01:00
putc ( ' x ' ) ; // x stands for pin not used
2020-03-09 13:44:08 +01:00
for ( int16_t j = 0 ; j + 1 < spaces [ i ] ; j + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ; // pad to match to bottom pin
2019-02-20 19:14:08 +01:00
}
} else {
2020-03-09 13:44:08 +01:00
printf ( " %s " , busvoodoo_global_pinout_io [ i * 2 + 1 ] ) ; // print pin name
for ( int16_t j = 0 ; j + strlen ( busvoodoo_global_pinout_io [ i * 2 + 1 ] ) < spaces [ i ] ; j + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ; // pad to match to bottom pin
2019-02-20 19:14:08 +01:00
}
}
2020-03-09 13:44:08 +01:00
if ( i > 0 ) {
2020-03-09 14:20:04 +01:00
putc ( ' ' ) ; // print space between the pin names
2019-02-20 19:14:08 +01:00
}
}
2020-03-09 14:20:04 +01:00
puts ( " | \n " ) ;
2019-02-20 19:14:08 +01:00
// display bottom line
2020-03-09 14:20:04 +01:00
putc ( ' + ' ) ;
2020-03-09 13:44:08 +01:00
for ( uint16_t i = 0 ; i < spaces [ 4 ] + 1 + spaces [ 3 ] + 1 + spaces [ 2 ] + 1 + spaces [ 1 ] + 1 + spaces [ 0 ] ; i + + ) {
2020-03-09 14:20:04 +01:00
putc ( ' - ' ) ;
2019-02-20 19:14:08 +01:00
}
2020-03-09 14:20:04 +01:00
puts ( " + \n " ) ;
2019-02-20 19:14:08 +01:00
no_pinout = false ; // remember a pinout has been shown
}
// in case nothing has been displayed
if ( no_pinout ) {
2020-03-09 14:20:04 +01:00
puts ( " no pins are used \n " ) ;
2019-02-20 19:14:08 +01:00
}
}
const struct menu_command_t busvoodoo_global_commands [ ] = {
{
. shortcut = ' p ' ,
. name = " pinout " ,
. command_description = " show connector pinout " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & busvoodoo_global_pinout ,
} ,
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
{
. shortcut = ' P ' ,
. name = " power " ,
. command_description = " switch 3V3 and 5V power rails on/off, or read internal voltages " ,
. argument = MENU_ARGUMENT_STRING ,
. argument_description = " [on|off] " ,
. command_handler = & busvoodoo_global_power ,
} ,
{
. shortcut = ' L ' ,
. name = " LV " ,
. command_description = " set voltage on low voltage power rail (0, 0.3-4.8, 5V), or read voltage on pin " ,
. argument = MENU_ARGUMENT_FLOAT ,
. argument_description = " [voltage] " ,
. command_handler = & busvoodoo_global_lv ,
} ,
2020-03-09 12:56:24 +01:00
# else
{
. shortcut = ' A ' ,
. name = " adc " ,
. command_description = " read voltage on ADC pin " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & busvoodoo_global_adc ,
} ,
# endif
2019-02-20 19:14:08 +01:00
} ;
const uint8_t busvoodoo_global_commands_nb = LENGTH ( busvoodoo_global_commands ) ;
2020-03-09 12:56:24 +01:00
# if BUSVOODOO_HARDWARE_VERSION != 2
2019-02-20 19:14:08 +01:00
const struct menu_command_t busvoodoo_global_full_commands [ ] = {
{
. shortcut = ' H ' ,
. name = " HV " ,
. command_description = " set voltage on high voltage power rail (0, 3.3-24V), or read voltage on pin " ,
. argument = MENU_ARGUMENT_FLOAT ,
. argument_description = " [voltage] " ,
. command_handler = & busvoodoo_global_hv ,
} ,
} ;
const uint8_t busvoodoo_global_full_commands_nb = LENGTH ( busvoodoo_global_full_commands ) ;
2020-03-09 12:56:24 +01:00
# endif