/* 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 global definitions and methods (code)
* @file busvoodoo_global.c
* @author King Kévin
* @date 2018
* @note peripherals used: time @ref busvoodoo_led_timer
*/
/* standard libraries */
#include // standard integer types
#include // string utilities
#include // math utilities
/* STM32 (including CM3) libraries */
#include // interrupt handler
#include // general purpose input output library
#include // real-time control clock library
#include // ADC utilities
#include // DAC utilities
#include // 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 timer used to blink LED
* @{
*/
#define BUSVOODOO_LED_TIMER 5 /**< timer peripheral */
/** @} */
/** blue LED status */
static volatile bool busvoodoo_global_led_blue = false;
/** red LED status */
static volatile bool busvoodoo_global_led_red = false;
/** existing hardware revisions identifiable with voltages */
static const uint8_t busvoodoo_revision_numbers[] = {27};
/** hardware revision voltages (calculated from divider ratios) */
static const float busvoodoo_revision_voltages[] = {100.0/(10.0+100.0)*3.3};
const char* busvoodoo_global_pinout_io[10] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
const char* busvoodoo_global_pinout_rscan[5] = {NULL, NULL, NULL, NULL, NULL};
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};
bool busvoodoo_full = false;
uint8_t busvoodoo_revision = 0;
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)
busvoodoo_safe_state(); // put pins in safe state (for common light version)
// check if this BusVoodoo is a full version
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
}
// setup ADC to measure hardware revision voltage
rcc_periph_clock_enable(RCC_ADC12_IN(BUSVOODOO_HW_REV_CHANNEL)); // enable clock for GPIO domain for hardware revision channel
gpio_set_mode(ADC12_IN_PORT(BUSVOODOO_HW_REV_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(BUSVOODOO_HW_REV_CHANNEL)); // set hardware revision channel as analogue input for the ADC
rcc_periph_clock_enable(RCC_ADC1); // enable clock for ADC domain
adc_off(ADC1); // switch off ADC while configuring it
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(ADC1); // enable internal voltage reference
adc_enable_external_trigger_regular(ADC1, ADC_CR2_EXTSEL_SWSTART); // use software trigger to start conversion
uint8_t rev_channels[] = {ADC_CHANNEL17, ADC_CHANNEL(BUSVOODOO_HW_REV_CHANNEL)}; // voltages to convert: internal, hardware revision
adc_set_regular_sequence(ADC1, LENGTH(rev_channels), rev_channels); // set channels to convert
adc_enable_discontinuous_mode_regular(ADC1, LENGTH(rev_channels)); // convert all channels
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_calibration(ADC1); // calibrate ADC for less accuracy errors
adc_start_conversion_regular(ADC1); // start conversion to get first voltage
uint16_t channels[LENGTH(rev_channels)] = {0}; // to store the values measured on the channels
for (uint8_t channel_i=0; channel_ibusvoodoo_revision_voltages[i]-0.2 && revision_voltage5.5) {
to_return = false; // voltage output is not ok
}
voltage = busvoodoo_vreg_get(BUSVOODOO_3V3_CHANNEL); // get 3.3V power rail voltage
if (voltage<3.0 || voltage>3.6) {
to_return = true; // voltage output is not ok
}
return to_return;
}
float busvoodoo_vreg_get(uint8_t channel)
{
if (channel!=BUSVOODOO_5V_CHANNEL && channel!=BUSVOODOO_3V3_CHANNEL && channel!=BUSVOODOO_LV_CHANNEL && channel!=BUSVOODOO_HV_CHANNEL) { // check channel
return NAN;
}
uint16_t channels[5] = {0}; // to start converted values: internal reference 1.2V, 5V rail, 3.3V rail, LV rail, HV rail, hardware version
adc_start_conversion_regular(ADC1); // start conversion to get first voltage
for (uint8_t channel_i=0; channel_i4.85) { // use the 5V directly
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;
}
uint16_t dac_set = BUSVOODOO_LV_SET(voltage)/volt*4095; // DAC value corresponding to the voltage
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(10); // 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
if (voltage<3.29) { // disable voltage regulator
gpio_set(GPIO(BUSVOODOO_HVEN_PORT), GPIO(BUSVOODOO_HVEN_PIN)); // disable HV voltage regulator
dac_disable(BUSVOODOO_HVCTL_CHANNEL); // disable HV control
} else {
if (voltage>24.0) { // enforce upper voltage limit (diodes limit is 30V, ADC input limit is 25V)
voltage = 24.0;
}
volt = busvoodoo_vreg_get(BUSVOODOO_3V3_CHANNEL); // get reference voltage
if (isnan(voltage)) {
return NAN;
}
uint16_t dac_set = BUSVOODOO_HV_SET(voltage)/volt*4095; // DAC value corresponding to the voltage
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
}
float busvoodoo_embedded_pullup(bool on)
{
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
}
return busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL); // set voltage on adjustable voltage regulator to be used by the embedded pull-ups
}
/** update LED status according to LED flags */
static void busvoodoo_led_update(void)
{
if (busvoodoo_global_led_blue && busvoodoo_global_led_red) { // both LEDs should be on
led_blink(0.01, 0.5); // enable both LEDs (alternating at 100Hz)
} else if (busvoodoo_global_led_blue) { // only blue LED should be on
led_blink(0, 1); // enable only blue LED
} else if (busvoodoo_global_led_red) { // only red LED should be on
led_blink(0, 0); // enable only red LED
} else { // no LED should be on
led_off(); // disable both LEDs
}
}
void busvoodoo_led_blue(uint16_t ms)
{
timer_disable_counter(TIM(BUSVOODOO_LED_TIMER)); // disable counter while changing LEDs to avoid coherence errors (at the cost of time precision)
if (ms>UINT16_MAX/2) { // enforce maximum
ms = UINT16_MAX/2;
}
if (0==ms) { // disable LED
busvoodoo_global_led_blue = false; // remember we disabled the blue LED
} else {
busvoodoo_global_led_blue = true; // remember the blue LED should be on
timer_set_oc_value(TIM(BUSVOODOO_LED_TIMER), TIM_OC1, timer_get_counter(TIM(BUSVOODOO_LED_TIMER))+ms*2); // use capture 1 to set LED timer
timer_clear_flag(TIM(BUSVOODOO_LED_TIMER), TIM_SR_CC1IF); // clear flag before enabling
timer_enable_irq(TIM(BUSVOODOO_LED_TIMER), TIM_DIER_CC1IE); // enable capture 1 for blue LED
}
busvoodoo_led_update(); // update LED status
timer_enable_counter(TIM(BUSVOODOO_LED_TIMER)); // re-enable timer
}
void busvoodoo_led_red(uint16_t ms)
{
timer_disable_counter(TIM(BUSVOODOO_LED_TIMER)); // disable counter while changing LEDs to avoid coherence errors (at the cost of time precision)
if (ms>UINT16_MAX/2) { // enforce maximum
ms = UINT16_MAX/2;
}
if (0==ms) { // disable LED
busvoodoo_global_led_red = false; // remember we disabled the blue LED
} else {
busvoodoo_global_led_red = true; // remember the blue LED should be on
timer_set_oc_value(TIM(BUSVOODOO_LED_TIMER), TIM_OC2, timer_get_counter(TIM(BUSVOODOO_LED_TIMER))+ms*2); // use capture 1 to set LED timer
timer_clear_flag(TIM(BUSVOODOO_LED_TIMER), TIM_SR_CC2IF); // clear flag before enabling
timer_enable_irq(TIM(BUSVOODOO_LED_TIMER), TIM_DIER_CC2IE); // enable capture 2 for red LED
}
busvoodoo_led_update(); // update LED status
timer_enable_counter(TIM(BUSVOODOO_LED_TIMER)); // re-enable timer
}
/* command handlers */
/** 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;
if (NULL==argument || 0==strlen(argument)) {
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;
}
} else if (0==strcmp(argument, "on")) {
if (busvoodoo_vout_switch(true)) { // switch power rail on
printf("power rails switched on\n");
} else {
printf("power rails switched on but malfunctioning\n");
}
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);
} else if (0==strcmp(argument, "off")) {
busvoodoo_vout_switch(false); // switch power rail off
printf("power rails switched off\n");
power_off:
printf("5V power rail: off\n");
printf("3V3 power rail: off\n");
} else {
printf("option malformed: %s\n", argument);
}
}
/** 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)
{
if (NULL==argument) {
if (!gpio_get(GPIO(BUSVOODOO_5VPULLUP_PORT), GPIO(BUSVOODOO_5VPULLUP_PIN))) { // 5V input enabled
printf("5V power rail used");
} else if (gpio_get(GPIO(BUSVOODOO_LVEN_PORT), GPIO(BUSVOODOO_LVEN_PIN))) { // LV voltage regulator used
printf("adjustable voltage regulator used");
} else {
printf("external voltage input");
}
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
if (0==voltage) {
printf("LV rail switched off");
} 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);
}
}
}
/** 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;
}
if (NULL==argument) {
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) {
printf(": 0.00V\n");
} else {
printf(": %.2fV\n", voltage);
}
} else {
double voltage = *((double*)argument); // get desired voltage
printf("high voltage rail ");
if (voltage<=3.3) {
printf("switched off");
} else {
printf("set to %.2fV", voltage);
}
voltage = busvoodoo_hv_set(voltage); // set HV voltage
// print HV voltage
if (voltage < 0.1) {
printf(": 0.00V\n");
} else {
printf(": %.2fV\n", voltage);
}
}
}
/** 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
// 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
for (uint8_t i=0; i=0; i--) {
if (NULL==busvoodoo_global_pinout_rscan[i]) {
printf("x"); // x stands for pin not used
} else {
printf("%s", busvoodoo_global_pinout_rscan[i]); // print pin name
}
if (i>0) {
printf(" "); // print space between the pin names
}
}
printf("|\n");
// display bottom line
printf("+");
for (uint8_t i=0; i=0; i--) {
if (NULL==busvoodoo_global_pinout_io[i*2]) {
printf("x"); // x stands for pin not used
for (int16_t j=0; j0) {
printf(" "); // print space between the pin names
}
}
printf("|\n");
// display bottom pin names
printf("|");
for (int8_t i=4; i>=0; i--) {
if (NULL==busvoodoo_global_pinout_io[i*2+1]) {
printf("x"); // x stands for pin not used
for (int16_t j=0; j0) {
printf(" "); // print space between the pin names
}
}
printf("|\n");
// display bottom line
printf("+");
for (uint16_t i=0; i