busvoodoo_hiz.c
Go to the documentation of this file.
/* 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 <http://www.gnu.org/licenses/>.
*
*/
/* standard libraries */
#include <stdint.h> // standard integer types
#include <string.h> // string utilities
#include <math.h> // math utilities
/* STM32 (including CM3) libraries */
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/dbgmcu.h> // debug utilities
#include <libopencm3/stm32/desig.h> // design utilities
#include <libopencm3/stm32/dac.h> // DAC utilities
/* own libraries */
#include "global.h" // board definitions
#include "print.h" // printing utilities
#include "menu.h" // menu definitions
#include "busvoodoo_global.h" // BusVoodoo definitions
#include "busvoodoo_oled.h" // OLED utilities
#include "busvoodoo_hiz.h" // own definitions
#define BUSVOODOO_LV_DEFAULT (0.8*(1+30.0/10.0))
#define BUSVOODOO_LV_TEST 2.5
#define BUSVOODOO_HV_DEFAULT (1.25*(1+100.0/10.0))
#define BUSVOODOO_HV_TEST 12.0
static bool busvoodoo_hiz_setup(char** prefix, const char* line)
{
(void)line; // no configuration is required
*prefix = "HiZ"; // set command line prefix
busvoodoo_leds_off(); // switch off all LEDs
busvoodoo_led_blue_on(); // switch on blue LED
busvoodoo_oled_text_left(*prefix); // set mode title on OLED display
const char* pinout_io[10] = {"GND", "5V", "3V3", "LV", NULL, NULL, NULL, NULL, NULL, NULL}; // HiZ mode I/O pinout
for (uint8_t i=0; i<LENGTH(pinout_io) && i<LENGTH(busvoodoo_global_pinout_io); i++) {
busvoodoo_global_pinout_io[i] = pinout_io[i]; // set pin names
}
if (busvoodoo_full) {
const char* pinout_rscan[5] = {"HV", NULL, NULL, NULL, NULL}; // HiZ mode RS/CAN pinout
for (uint8_t i=0; i<LENGTH(pinout_rscan) && i<LENGTH(busvoodoo_global_pinout_rscan); i++) {
busvoodoo_global_pinout_rscan[i] = pinout_rscan[i]; // set pin names
}
}
busvoodoo_oled_text_pinout(busvoodoo_global_pinout_io, true); // set pinout on display
busvoodoo_oled_update(); // update display to show text and pinout
return true;
}
static void busvoodoo_hiz_exit(void)
{
// there is nothing to do
}
static bool busvoodoo_hiz_test_self(bool halt)
{
bool to_return = false; // success of the self-test
busvoodoo_safe_state(); // start from a safe state
// get device information
// get device identifier (DEV_ID)
// 0x412: low-density, 16-32 kB flash
// 0x410: medium-density, 64-128 kB flash
// 0x414: high-density, 256-512 kB flash
// 0x430: XL-density, 768-1024 kB flash
// 0x418: connectivity
if (0==(DBGMCU_IDCODE&DBGMCU_IDCODE_DEV_ID_MASK)) { // can't read IDCODE for verification
// this is a known issue document in STM32F10xxC/D/E Errata sheet, without workaround
} else if (0x414!=(DBGMCU_IDCODE&DBGMCU_IDCODE_DEV_ID_MASK)) {
printf("this (DEV_ID=%03x) is not a high-density device: a wrong micro-controller might have been used\n", (DBGMCU_IDCODE&DBGMCU_IDCODE_DEV_ID_MASK));
}
// ensure flash size is ok
if (0xffff==DESIG_FLASH_SIZE) {
printf("unknown flash size: this is probably a defective micro-controller\n");
}
// check 5V power rail
float voltage = busvoodoo_vreg_get(BUSVOODOO_5V_CHANNEL); // get 5V power rail voltage
if (voltage<4.0) {
printf("5V power rail voltage is too low: %.2fV\n", voltage);
if (halt) { // halt on error if requested
busvoodoo_leds_blink(0.5, 0.5); // show error on LEDs
while (!user_input_available); // wait for user input
}
goto error;
} else if (voltage>5.5) {
printf("5V power rail voltage is too high: %.2fV\n", voltage);
goto error;
}
// check 3.3V power rail
voltage = busvoodoo_vreg_get(BUSVOODOO_3V3_CHANNEL); // get 3.3V power rail voltage
if (voltage<3.0) {
printf("3.3V power rail voltage is too low: %.2fV\n", voltage);
goto error;
} else if (voltage>3.6) {
printf("3.3V power rail voltage is too high: %.2fV\n", voltage);
goto error;
}
// test 5V and 3.3V outputs
busvoodoo_vout_switch(true); // enable Vout
voltage = busvoodoo_vreg_get(BUSVOODOO_5V_CHANNEL); // get 5V power rail voltage
if (voltage<4.0) {
printf("5V power rail voltage is too low when 5V output is enabled: %.2fV\n", voltage);
goto error;
} else if (voltage>5.5) {
printf("5V power rail voltage is too high when 5V output is enabled: %.2fV\n", voltage);
goto error;
}
voltage = busvoodoo_vreg_get(BUSVOODOO_3V3_CHANNEL); // get 3.3V power rail voltage
if (voltage<3.0) {
printf("3.3V power rail voltage is too low when 3V3 output is enabled: %.2fV\n", voltage);
goto error;
} else if (voltage>3.6) {
printf("3.3V power rail voltage is too high when 3V3 is enabled: %.2fV\n", voltage);
goto error;
}
busvoodoo_vout_switch(false); // disable Vout
// check LV voltage regulator
voltage = busvoodoo_lv_set(0); // disable LV voltage regulator
if (voltage>0.2) { // ensure the output is at 0V when the regulator is not enabled
printf("LV voltage is %.2fV instead of 0V when the regulator is disabled\n", voltage);
goto error;
}
gpio_set(GPIO(BUSVOODOO_LVEN_PORT), GPIO(BUSVOODOO_LVEN_PIN)); // enable LV voltage regulator
sleep_ms(5); // let the voltage regulator start and voltage settle
voltage = busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL); // get LV voltage
// without being driven it should be around the default voltage
if (voltage<BUSVOODOO_LV_DEFAULT-0.2) {
printf("LV voltage is lower (%.2fV) than expected (%.2fV) when the regulator is enabled\n", voltage, BUSVOODOO_LV_DEFAULT);
goto error;
} else if (voltage>BUSVOODOO_LV_DEFAULT+0.2) {
printf("LV voltage is higher (%.2fV) than expected (%.2fV) when the regulator is enabled\n", voltage, BUSVOODOO_LV_DEFAULT);
goto error;
}
// check if we can control LV
voltage = busvoodoo_lv_set(BUSVOODOO_LV_TEST); // get LV voltage
if (voltage<BUSVOODOO_LV_TEST-0.2) {
printf("LV voltage is lower (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_LV_TEST);
goto error;
} else if (voltage>BUSVOODOO_LV_TEST+0.2) {
printf("LV voltage is highed (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_LV_TEST);
goto error;
}
busvoodoo_lv_set(0); // disable LV voltage regulator
// check HV voltage regulator
if (busvoodoo_full) {
voltage = busvoodoo_hv_set(0); // disable HV voltage regulator
if (voltage>0.2) { // ensure the output is at 0V when the regulator is not enabled
printf("HV voltage is %.2fV instead of 0V when the regulator is disabled\n", voltage);
goto error;
}
gpio_clear(GPIO(BUSVOODOO_HVEN_PORT), GPIO(BUSVOODOO_HVEN_PIN)); // enable HV voltage regulator
sleep_ms(10); // let the voltage regulator start and voltage settle
voltage = busvoodoo_vreg_get(BUSVOODOO_HV_CHANNEL); // get HV voltage
// without being driven it should be around the default voltage
if (voltage<BUSVOODOO_HV_DEFAULT-0.4) {
printf("HV voltage is lower (%.2fV) than expected (%.2fV) when regulator is enabled\n", voltage, BUSVOODOO_HV_DEFAULT);
goto error;
} else if (voltage>BUSVOODOO_HV_DEFAULT+0.4) {
printf("HV voltage is higher (%.2fV) than expected (%.2fV) when regulator is enabled\n", voltage, BUSVOODOO_HV_DEFAULT);
goto error;
}
// check if we can control HV voltage regulator
voltage = busvoodoo_hv_set(BUSVOODOO_HV_TEST); // set voltage on HV voltage regulator
if (voltage<BUSVOODOO_HV_TEST-0.4) {
printf("HV voltage is lower (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_HV_TEST);
goto error;
} else if (voltage>BUSVOODOO_HV_TEST+0.4) {
printf("HV voltage is higher (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_HV_TEST);
goto error;
}
voltage = busvoodoo_hv_set(0); // disable HV voltage regulator
}
// pull all pins down and ensure they are low
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins); pin++) {
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin]); // set pin to input
gpio_clear(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // pull down so it's not floating
}
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins) && pin<LENGTH(busvoodoo_io_names); pin++) {
if (gpio_get(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin])) { // ensure it really is low
printf("signal %s is high although it is pulled low (internal)\n", busvoodoo_io_names[pin]); // warn user about the error
goto error;
}
}
// pull all pins up and ensure they are high
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins); pin++) {
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin]); // set pin to input
gpio_set(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // pull up using internal pull-up
}
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins) && pin<LENGTH(busvoodoo_io_names); pin++) {
if (!gpio_get(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin])) { // ensure it really is high
printf("signal %s is low although it is pulled up (internal)\n", busvoodoo_io_names[pin]); // warn user about the error
goto error;
}
}
// set individual pin high and ensure only pins in the same group are at the same level
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins); pin++) {
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin]); // set pin to input
gpio_clear(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // pull down to ensure it is not high by accident
}
for (uint8_t pin1=0; pin1<LENGTH(busvoodoo_io_ports) && pin1<LENGTH(busvoodoo_io_pins) && pin1<LENGTH(busvoodoo_io_groups) && pin1<LENGTH(busvoodoo_io_names); pin1++) {
gpio_set_mode(busvoodoo_io_ports[pin1], GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, busvoodoo_io_pins[pin1]); // set button pin to output
gpio_set(busvoodoo_io_ports[pin1], busvoodoo_io_pins[pin1]); // set pin high
for (uint8_t pin2=0; pin2<LENGTH(busvoodoo_io_ports) && pin2<LENGTH(busvoodoo_io_pins) && pin2<LENGTH(busvoodoo_io_groups) && pin2<LENGTH(busvoodoo_io_names); pin2++) {
if (busvoodoo_io_groups[pin1]==busvoodoo_io_groups[pin2] && !gpio_get(busvoodoo_io_ports[pin2], busvoodoo_io_pins[pin2])) {
printf("signal %s of I/O-%u is low while it should be set high by signal %s of I/O-%u\n", busvoodoo_io_names[pin2], busvoodoo_io_groups[pin2], busvoodoo_io_names[pin1], busvoodoo_io_groups[pin1]); // warn user about the error
goto error;
} else if (busvoodoo_io_groups[pin1]!=busvoodoo_io_groups[pin2] && gpio_get(busvoodoo_io_ports[pin2], busvoodoo_io_pins[pin2])) {
printf("signal %s of I/O-%u is high while it should not be set high by signal %s of I/O-%u\n", busvoodoo_io_names[pin2], busvoodoo_io_groups[pin2], busvoodoo_io_names[pin1], busvoodoo_io_groups[pin1]); // warn user about the error
goto error;
}
}
gpio_set_mode(busvoodoo_io_ports[pin1], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin1]); // set pin back to input
gpio_clear(busvoodoo_io_ports[pin1], busvoodoo_io_pins[pin1]); // pull pin back down
}
// set individual pin low and ensure only pins in the same group are at the same level
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins); pin++) {
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin]); // set pin to input
gpio_set(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // pull up to ensure it is not low by accident
}
for (uint8_t pin1=0; pin1<LENGTH(busvoodoo_io_ports) && pin1<LENGTH(busvoodoo_io_pins) && pin1<LENGTH(busvoodoo_io_groups) && pin1<LENGTH(busvoodoo_io_names); pin1++) {
gpio_set_mode(busvoodoo_io_ports[pin1], GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, busvoodoo_io_pins[pin1]); // set button pin to output
gpio_clear(busvoodoo_io_ports[pin1], busvoodoo_io_pins[pin1]); // set pin low
for (uint8_t pin2=0; pin2<LENGTH(busvoodoo_io_ports) && pin2<LENGTH(busvoodoo_io_pins) && pin2<LENGTH(busvoodoo_io_groups) && pin2<LENGTH(busvoodoo_io_names); pin2++) {
if (busvoodoo_io_groups[pin1]==busvoodoo_io_groups[pin2] && gpio_get(busvoodoo_io_ports[pin2], busvoodoo_io_pins[pin2])) {
printf("signal %s of I/O-%u is high while it should be set low by signal %s of I/O-%u\n", busvoodoo_io_names[pin2], busvoodoo_io_groups[pin2], busvoodoo_io_names[pin1], busvoodoo_io_groups[pin1]); // warn user about the error
goto error;
} else if (busvoodoo_io_groups[pin1]!=busvoodoo_io_groups[pin2] && !gpio_get(busvoodoo_io_ports[pin2], busvoodoo_io_pins[pin2])) {
printf("signal %s of I/O-%u is low while it should not be set low by signal %s of I/O-%u\n", busvoodoo_io_names[pin2], busvoodoo_io_groups[pin2], busvoodoo_io_names[pin1], busvoodoo_io_groups[pin1]); // warn user about the error
goto error;
}
}
gpio_set_mode(busvoodoo_io_ports[pin1], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin1]); // set pin back to input
gpio_set(busvoodoo_io_ports[pin1], busvoodoo_io_pins[pin1]); // pull pin back up
}
// test 5V pull-up
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins); pin++) {
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin]); // set pin to input
gpio_clear(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // pull down to ensure it is not high by accident
}
busvoodoo_lv_set(5.0); // set LV voltage regulator to use the 5.0V power rail
voltage = busvoodoo_embedded_pullup(true); // enable 5V pull-up
if (voltage<4.0) {
printf("5V power rail voltage is too low when used to pull up: %.2fV\n", voltage);
goto error;
} else if (voltage>5.5) {
printf("5V power rail voltage is too high when used to pull up: %.2fV\n", voltage);
goto error;
}
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins) && pin<LENGTH(busvoodoo_io_names); pin++) {
if (!gpio_get(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin])) { // ensure it really is high
printf("signal %s is low although it is pulled up by 5V (embedded)\n", busvoodoo_io_names[pin]); // warn user about the error
goto error;
}
}
busvoodoo_embedded_pullup(false); // disable pull-ups
voltage = busvoodoo_lv_set(0); // disable LV voltage regulator
// test LV pull-up set to 3.3V
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins); pin++) {
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, busvoodoo_io_pins[pin]); // set pin to input
gpio_clear(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // pull down to ensure it is not high by accident
}
busvoodoo_lv_set(3.3); // set LV voltage regulator
voltage = busvoodoo_embedded_pullup(3.3); // enable pull-up with adjustable regulator
if (voltage<BUSVOODOO_LV_DEFAULT-0.2) {
printf("LV voltage is lower (%.2fV) than expected (%.2fV) when used to pull up\n", voltage, BUSVOODOO_LV_DEFAULT);
goto error;
} else if (voltage>BUSVOODOO_LV_DEFAULT+0.2) {
printf("LV voltage is higher (%.2fV) than expected (%.2fV) when used to pull up\n", voltage, BUSVOODOO_LV_DEFAULT);
goto error;
}
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins) && pin<LENGTH(busvoodoo_io_names); pin++) {
if (!gpio_get(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin])) { // ensure it really is high
printf("signal %s is low although it is pulled up by LV (embedded)\n", busvoodoo_io_names[pin]); // warn user about the error
goto error;
}
}
busvoodoo_lv_set(0); // disable LV voltage regulator
busvoodoo_embedded_pullup(false); // disable pull-ups
// test RS-485 transceiver
if (busvoodoo_full) {
// configure transceiver
gpio_set(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // enable transmitter
gpio_clear(GPIO(BUSVOODOO_RS485_RE_PORT), GPIO(BUSVOODOO_RS485_RE_PIN)); // enable receiver
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX as output
gpio_set_mode(GPIO(BUSVOODOO_RS485_RX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(BUSVOODOO_RS485_RX_PIN)); // set RX as input with pull up/down
// test low signal
gpio_set(GPIO(BUSVOODOO_RS485_RX_PORT), GPIO(BUSVOODOO_RS485_RX_PIN)); // pull RX up
gpio_clear(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX low
sleep_us(100); // let voltage settle
if (gpio_get(GPIO(BUSVOODOO_RS485_RX_PORT), GPIO(BUSVOODOO_RS485_RX_PIN))) { // test if RX is still high
printf("RS-485 RX is high while TX is set low\n"); // warn user about the error
goto error;
}
// test high signal
gpio_clear(GPIO(BUSVOODOO_RS485_RX_PORT), GPIO(BUSVOODOO_RS485_RX_PIN)); // pull RX down
gpio_set(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX high
sleep_us(100); // let voltage settle
if (0==gpio_get(GPIO(BUSVOODOO_RS485_RX_PORT), GPIO(BUSVOODOO_RS485_RX_PIN))) { // test if RX is still low
printf("RS-485 RX is low while TX is set high\n"); // warn user about the error
goto error;
}
// release transceiver
gpio_set(GPIO(BUSVOODOO_RS485_RE_PORT), GPIO(BUSVOODOO_RS485_RE_PIN)); // set high to disable receiver
gpio_clear(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // set low to disable transmitter
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
}
#if BUSVOODOO_HARDWARE_VERSION!=0
// test CAN transceiver
if (busvoodoo_full) {
// configure transceiver
gpio_clear(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO(BUSVOODOO_CAN_EN_PIN)); // pull low to power transceiver
gpio_set_mode(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX as output (there is a pull-up resistor to 5V)
gpio_set_mode(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(BUSVOODOO_CAN_RX_PIN)); // set RX as input with pull up/down
// test high signal
gpio_clear(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO(BUSVOODOO_CAN_RX_PIN)); // pull RX down
gpio_set(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX high
sleep_us(100); // let voltage settle
if (0==gpio_get(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO(BUSVOODOO_CAN_RX_PIN))) { // test if RX is still low
printf("CAN RX is low while TX is set high\n"); // warn user about the error
goto error;
}
// test low signal
gpio_set(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO(BUSVOODOO_CAN_RX_PIN)); // pull RX up
gpio_clear(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX low
sleep_us(100); // let voltage settle
if (gpio_get(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO(BUSVOODOO_CAN_RX_PIN))) { // test if RX is still high
printf("CAN RX is high while TX is set low\n"); // warn user about the error
goto error;
}
// test dominant timeout
sleep_ms(10); // after 5 ms the output should be switched back from dominant to recessive respite TX being low
if (!gpio_get(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO(BUSVOODOO_CAN_RX_PIN))) { // test if RX is now low
printf("CAN RX is low while the output should be back to recessive\n"); // warn user about the error
goto error;
}
// release transceiver
gpio_set(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO(BUSVOODOO_CAN_EN_PIN)); // set high to power off transceiver
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
}
#endif
to_return = true; // all tests are successful
printf("self-test succeeded\n"); // notify user
error:
if (!to_return) {
if (halt) { // halt on error if requested
busvoodoo_leds_blink(0.5, 0.5); // show error on LEDs
while (!user_input_available); // wait for user input
} else {
printf("the test procedure has been aborted for safety reasons\n");
}
}
busvoodoo_safe_state(); // set back to safe state
return to_return;
}
static bool busvoodoo_hiz_test_pins(bool halt)
{
bool to_return = false; // test result to return
busvoodoo_safe_state(); // start from safe state with all outputs switched off
const char* lv_to = "connect I/O pin 4 to "; // most outputs will be tested using LV ADC
char* pinout[10] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}; // pinout to display
pinout[3] = "O"; // set main testing pin
busvoodoo_oled_text_right("pins test"); // display test on display
busvoodoo_oled_update(); // update screen
// test GND on pin 1 by shorting LV_CTL to ground (through 40k resistor) and measure short
gpio_set(GPIO(BUSVOODOO_LVCTL_PORT), GPIO(BUSVOODOO_LVCTL_PIN)); // set pin high
gpio_set_mode(GPIO(BUSVOODOO_LVCTL_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_LVCTL_PIN)); // set LV control pin as output
printf("%sI/O pin 1\n", lv_to); // ask user for action
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[0] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, true); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>0.2 && !user_input_available); // wait until pin is shorted to ground
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_clear(GPIO(BUSVOODOO_LVCTL_PORT), GPIO(BUSVOODOO_LVCTL_PIN)); // set pin low
gpio_set_mode(GPIO(BUSVOODOO_LVCTL_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_LVCTL_PIN)); // set LV control pin as output
sleep_ms(100); // wait for voltage to settle an debounce
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>0.2) {
printf("I/O pin 4 is high while it should be low and shorted to ground\n");
goto error;
}
gpio_set_mode(GPIO(BUSVOODOO_LVCTL_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO(BUSVOODOO_LVCTL_PIN)); // set LV control pin back to analog input for DAC
pinout[0] = NULL; // clear pin to test
// test 5V output on pin 2
gpio_clear(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // enable Vout
printf("%sI/O pin 2\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[1] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, true); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<0.2 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // disable Vout
sleep_ms(100); // wait for voltage to settle and debounce
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>0.2) {
printf("5V output is high while the power output should be switched off\n");
goto error;
}
pinout[1] = NULL; // clear pin to test
// test 3.3V output on pin 3
gpio_clear(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // enable Vout
printf("%sI/O pin 3\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[2] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, true); // display pins to user
busvoodoo_oled_update(); // update screen
do {
do {
sleep_ms(100); // wait for user to make connection
} while ((busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<0.2 || busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>3.5) && !user_input_available); // wait until pin is connected
sleep_ms(100); // wait for stable connection
} while ((busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<0.2 || busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>3.5) && !user_input_available); // check to be sure it really is not on the 5V pin
busvoodoo_led_red_on(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // disable Vout
sleep_ms(100); // wait for voltage to settle and debounce
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>0.2) {
printf("3V3 output is high while the power output should be switched off\n");
goto error;
}
pinout[2] = NULL; // clear pin to test
// test I/O pins
for (uint8_t io=1; io<=6; io++) { // test each I/O pin
for (uint8_t pin=0; pin<LENGTH(busvoodoo_io_ports) && pin<LENGTH(busvoodoo_io_pins) && pin<LENGTH(busvoodoo_io_groups); pin++) { // look for a pin mapped on this I/O
if (busvoodoo_io_groups[pin]==io) {
gpio_set(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // set pin high
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, busvoodoo_io_pins[pin]); // set pin to output
printf("%sI/O pin %u\n", lv_to, io+4);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[io+3] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, true); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<0.2 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_clear(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // set pin low
sleep_ms(100); // wait for voltage to settle and debounce
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>0.2) {
printf("I/O pin %u is high while it should be low\n", io+4);
goto error;
}
gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_io_pins[pin]); // set pin back to input
pinout[io+3] = NULL; // clear pin to test
break; // stop looking for pin
}
}
}
if (busvoodoo_full) {
pinout[3] = NULL; // reset testing pin
// test HV output on RS/CAN pin 1
double voltage = busvoodoo_vreg_get(BUSVOODOO_3V3_CHANNEL); // get reference voltage
uint16_t dac_set = BUSVOODOO_HV_SET(5.0)/voltage*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
printf("%sRS/CAN pin 1\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[0] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<0.2 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_HVEN_PORT), GPIO(BUSVOODOO_HVEN_PIN)); // disable HV voltage regulator
dac_disable(BUSVOODOO_HVCTL_CHANNEL); // disable HV control
sleep_ms(100); // wait for voltage to settle (and debounce)
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>0.2) {
printf("HV output is high while voltage regulator should be switched off\n");
goto error;
}
pinout[0] = NULL; // clear pin to test
#if BUSVOODOO_HARDWARE_VERSION==0
// test RS-485 port pin B
gpio_set(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // enable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX as output
gpio_clear(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX low -> B will be high
printf("%sRS/CAN pin 4\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[6] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<2.0 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX high
sleep_ms(100); // wait for voltage to settle (and debounce)
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>1.0) {
printf("RS-485 output B is high while it should be low\n");
goto error;
}
gpio_clear(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // set low to disable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS485_TX_PIN)); // set pin to floating
pinout[6] = NULL; // clear pin to test
#else
// test RS-485 output A
gpio_set(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // enable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX as output
gpio_set(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX high -> A will be high
printf("%sRS/CAN pin 3\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[4] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<2.0 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_clear(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX low
sleep_ms(100); // wait for voltage to settle (and debounce)
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>1.0) {
printf("RS-485 output A is high while it should be low\n");
goto error;
}
gpio_clear(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // set low to disable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS485_TX_PIN)); // set pin to floating
pinout[4] = NULL; // clear pin to test
#endif
#if BUSVOODOO_HARDWARE_VERSION!=0
// test CAN output L
// configure transceiver
gpio_clear(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO(BUSVOODOO_CAN_EN_PIN)); // pull low to power transceiver
gpio_set_mode(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX as output (there is a pull-up resistor to 5V)
// test recessive output
gpio_set(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX high
sleep_us(100); // let voltage settle
voltage = busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL); // get output voltage
if (voltage<0.4) { // normally the lower limit is 2V, put pin 4 pulls it down because it is not strongly driven
printf("CAN L output is low while it should be at recessive 2.5V\n");
goto error;
}
if (voltage>3.0) { // normally the upper limit is 3V
printf("CAN L output is high while it should be at recessive 2.5V\n");
goto error;
}
// test dominant output
gpio_clear(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX low
sleep_us(100); // let voltage settle
voltage = busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL); // get output voltage
if (voltage>2.5) {
printf("CAN L output is high while it should at dominant <2.25V\n");
goto error;
}
// release transceiver
gpio_set(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO(BUSVOODOO_CAN_EN_PIN)); // set high to power off transceiver
gpio_set_mode(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_CAN_TX_PIN)); // set pin to floating
#endif
#if BUSVOODOO_HARDWARE_VERSION==0
// test RS-485 output A
gpio_set(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // enable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX as output
gpio_set(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX high -> A will be high
printf("%sRS/CAN pin 5\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[8] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<2.0 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_clear(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX low
sleep_ms(100); // wait for voltage to settle (and debounce)
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>1.0) {
printf("RS-485 output A is high while it should be low\n");
goto error;
}
gpio_clear(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // set low to disable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS485_TX_PIN)); // set pin to floating
pinout[8] = NULL; // clear pin to test
#else
// test RS-485 port pin B
gpio_set(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // enable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX as output
gpio_clear(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX low -> B will be high
printf("%sRS/CAN pin 4\n", lv_to);
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[6] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)<2.0 && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO(BUSVOODOO_RS485_TX_PIN)); // set TX high
sleep_ms(100); // wait for voltage to settle (and debounce)
if (busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL)>1.0) {
printf("RS-485 output B is high while it should be low\n");
goto error;
}
gpio_clear(GPIO(BUSVOODOO_RS485_DE_PORT), GPIO(BUSVOODOO_RS485_DE_PIN)); // set low to disable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS485_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS485_TX_PIN)); // set pin to floating
pinout[6] = NULL; // clear pin to test
#endif
#if BUSVOODOO_HARDWARE_VERSION!=0
// test CAN output H
// configure transceiver
gpio_clear(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO(BUSVOODOO_CAN_EN_PIN)); // pull low to power transceiver
gpio_set_mode(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX as output (there is a pull-up resistor to 5V)
// test recessive output
gpio_set(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX high
sleep_us(100); // let voltage settle
voltage = busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL); // get output voltage
if (voltage<0.5) { // normally the lower limit is 2V, put pin 4 pulls it down because it is not strongly driven
printf("CAN H output is low while it should be at recessive 2.5V\n");
goto error;
}
if (voltage>3.0) { // normally the upper limit is 3V
printf("CAN H output is high while it should be at recessive 2.5V\n");
goto error;
}
// test dominant output
gpio_clear(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO(BUSVOODOO_CAN_TX_PIN)); // set TX low
sleep_us(100); // let voltage settle
voltage = busvoodoo_vreg_get(BUSVOODOO_LV_CHANNEL); // get output voltage
if (voltage<2.5) {
printf("CAN H output is low while it dominant >2.75V\n");
printf("%.02f\n", voltage);
goto error;
}
// release transceiver
gpio_set(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO(BUSVOODOO_CAN_EN_PIN)); // set high to power off transceiver
gpio_set_mode(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_CAN_TX_PIN)); // set pin to floating
#endif
// test RS-232 port (with itself)
rcc_periph_clock_enable(RCC_GPIO(BUSVOODOO_RS232_EN_PORT)); // enable clock for GPIO domain
gpio_clear(GPIO(BUSVOODOO_RS232_EN_PORT), GPIO(BUSVOODOO_RS232_EN_PIN)); // set low to enable receiver
gpio_set_mode(GPIO(BUSVOODOO_RS232_EN_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_RS232_EN_PIN)); // set pin as output (open-drain pulled high to disable receiver)
rcc_periph_clock_enable(RCC_GPIO(BUSVOODOO_RS232_SHDN_PORT)); // enable clock for GPIO domain
gpio_set(GPIO(BUSVOODOO_RS232_SHDN_PORT), GPIO(BUSVOODOO_RS232_SHDN_PIN)); // set high to enable transmitter
gpio_set_mode(GPIO(BUSVOODOO_RS232_SHDN_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS232_SHDN_PIN)); // set pin as output (push-pull pulled low to disable transmitter)
rcc_periph_clock_enable(RCC_GPIO(BUSVOODOO_RS232_TX_PORT)); // enable clock for GPIO
gpio_set_mode(GPIO(BUSVOODOO_RS232_TX_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS232_TX_PIN)); // set pin as output (push-pull)
rcc_periph_clock_enable(RCC_GPIO(BUSVOODOO_RS232_RX_PORT)); // enable clock for GPIO
gpio_set_mode(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(BUSVOODOO_RS232_RX_PIN)); // set pin as input (with pull resistors)
// start by setting low since unconnected (pulled to ground by 3 kO) is considered as high
gpio_clear(GPIO(BUSVOODOO_RS232_TX_PORT), GPIO(BUSVOODOO_RS232_TX_PIN)); // set low
gpio_set(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO(BUSVOODOO_RS232_RX_PIN)); // pull high to avoid false negative
sleep_ms(5);
printf("connect RS/CAN pin 2 to RS/CAN pin 3\n");
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[2] = "O"; // set target testing pin
pinout[4] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (gpio_get(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO(BUSVOODOO_RS232_RX_PIN)) && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_RS232_TX_PORT), GPIO(BUSVOODOO_RS232_TX_PIN)); // set high
gpio_clear(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO(BUSVOODOO_RS232_RX_PIN)); // pull low to avoid false negative
sleep_ms(100); // wait for voltage to settle and debounce
if (!gpio_get(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO(BUSVOODOO_RS232_RX_PIN))) { // check if RX is set low by TX
printf("RS-232 RX is high while it should be set low by RS-232 TX\n");
goto error;
}
gpio_set_mode(GPIO(BUSVOODOO_RS232_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_TX_PIN)); // free pin
gpio_set_mode(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_RX_PIN)); // free pin
pinout[2] = NULL; // clear pin to test
pinout[4] = NULL; // clear pin to test
rcc_periph_clock_enable(RCC_GPIO(BUSVOODOO_RS232_RTS_PORT)); // enable clock for GPIO
gpio_set_mode(GPIO(BUSVOODOO_RS232_RTS_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_RS232_RTS_PIN)); // set pin as output (push-pull)
rcc_periph_clock_enable(RCC_GPIO(BUSVOODOO_RS232_CTS_PORT)); // enable clock for GPIO
gpio_set_mode(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO(BUSVOODOO_RS232_CTS_PIN)); // set pin as input (with pull resistors)
// start by setting low since unconnected (pulled to ground by 3 kO) is considered as high
gpio_clear(GPIO(BUSVOODOO_RS232_RTS_PORT), GPIO(BUSVOODOO_RS232_RTS_PIN)); // set low
gpio_set(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO(BUSVOODOO_RS232_CTS_PIN)); // pull high to avoid false negative
printf("connect RS/CAN pin 4 to RS/CAN pin 5\n");
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // notify user to perform action
pinout[6] = "O"; // set target testing pin
pinout[8] = "O"; // set target testing pin
busvoodoo_oled_text_pinout((const char**)pinout, false); // display pins to user
busvoodoo_oled_update(); // update screen
do {
sleep_ms(100); // wait for user to make connection
} while (gpio_get(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO(BUSVOODOO_RS232_CTS_PIN)) && !user_input_available); // wait until pin is connected
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // notify user test is running
if (user_input_available) { // user interruption
goto error;
}
gpio_set(GPIO(BUSVOODOO_RS232_RTS_PORT), GPIO(BUSVOODOO_RS232_RTS_PIN)); // set high
gpio_clear(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO(BUSVOODOO_RS232_CTS_PIN)); // pull low to avoid false negative
sleep_ms(100); // wait for voltage to settle an debounce
if (!gpio_get(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO(BUSVOODOO_RS232_CTS_PIN))) { // check if CTS is set high by RTS
printf("RS-232 CTS is high while it should be set low by RS-232 RTS\n");
goto error;
}
gpio_set_mode(GPIO(BUSVOODOO_RS232_RTS_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_RTS_PIN)); // free pin
gpio_set_mode(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_CTS_PIN)); // free pin
gpio_set(GPIO(BUSVOODOO_RS232_EN_PORT), GPIO(BUSVOODOO_RS232_EN_PIN)); // set high to disable receiver
gpio_clear(GPIO(BUSVOODOO_RS232_SHDN_PORT), GPIO(BUSVOODOO_RS232_SHDN_PIN)); // set low to disable transmitter
pinout[6] = NULL; // clear pin to test
pinout[8] = NULL; // clear pin to test
}
to_return = true; // all tests passed
error:
if (!to_return) {
if (user_input_available) {
printf("user interrupted the test\n");
to_return = true; // we don't consider this as error
} else if (halt) { // halt on error if requested
busvoodoo_leds_blink(0.5, 0.5); // show error on LEDs
while (!user_input_available); // wait for user input
} else {
printf("the test procedure has been aborted for safety reasons\n");
}
}
busvoodoo_safe_state(); // go back to safe state
return to_return;
}
// command handlers
static void busvoodoo_hiz_bootloader(void* argument)
{
(void)argument; // we won't use the argument
RCC_CSR |= RCC_CSR_RMVF; // clear reset flags
scb_reset_core(); // reset core (the bootloader will interpret it as starting into DFU)
while (true); // wait for the reset to happen
}
static void busvoodoo_hiz_version(void* argument)
{
(void)argument; // we won't use the argument
printf("BusVoodoo flavor: %s\n", busvoodoo_full ? "full" : "light");
printf("hardware version: %c\n", busvoodoo_version);
printf("firmware date: %04u-%02u-%02u\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY);
printf("device ID: %08x%08x%08x\n", DESIG_UNIQUE_ID0, DESIG_UNIQUE_ID1, DESIG_UNIQUE_ID2);
}
static void busvoodoo_hiz_command_test_self(void* argument)
{
bool halt = false; // if we halt on error
if (NULL!=argument && strlen(argument)>0) {
if (0==strcmp(argument, "halt")) {
halt = true;
} else {
printf("malformed argument\n");
return;
}
}
printf("performing self-test\n");
if (halt) {
printf("WARNING: halting on error can cause hardware damages (press any key to exit halt state)\n");
}
printf("remove all cables from connectors and press space to start (or any other key to abort)\n");
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // show red LED to indicate test started
if (' '==user_input_get()) { // space entered
printf("self-test running\n");
if (busvoodoo_hiz_test_self(halt)) { // perform self-test
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // show blue to indicate test passed
} else {
busvoodoo_leds_blink(0.5, 0.5); // show error on LEDs
printf("self-test failed\n"); // notify user
if (user_input_available) {
user_input_get(); // clear user input
}
}
} else {
printf("self-test aborted\n");
}
}
static void busvoodoo_hiz_command_test_pins(void* argument)
{
bool halt = false; // if we halt on error
if (NULL!=argument && strlen(argument)>0) {
if (0==strcmp(argument, "halt")) {
halt = true;
} else {
printf("malformed argument\n");
return;
}
}
printf("performing pins test\n");
if (halt) {
printf("WARNING: halting on error can cause hardware damages (press any key to exit halt state)\n");
}
busvoodoo_leds_off(); // clear LEDs
busvoodoo_led_red_on(); // show red LED to indicate test started
char* pinout[10] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}; // pinout to display
pinout[3] = "O"; // set main testing pin
busvoodoo_oled_text_right("pins test"); // display test on display
busvoodoo_oled_text_pinout((const char**)pinout, true); // reset pinout
busvoodoo_oled_update(); // update screen
printf("connect one lead of jumper wire to I/O pin 4 and press space to start (or any other key to abort)\n");
if (' '==user_input_get()) { // space entered
if (busvoodoo_hiz_test_pins(halt)) { // perform pin test
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // show blue OK LED
printf("pins test succeeded\n"); // notify user
} else {
busvoodoo_leds_blink(0.5, 0.5); // show error on LEDs
printf("pins test failed\n"); // notify user
if (user_input_available) {
user_input_get(); // clear user input
}
}
} else {
printf("pins test aborted\n");
busvoodoo_led_red_off(); // clear red LED
busvoodoo_led_blue_on(); // switch back to main blue LED
}
busvoodoo_oled_text_left("HiZ"); // reset mode text
busvoodoo_oled_text_pinout(busvoodoo_global_pinout_io, true); // reset pinout
busvoodoo_oled_update(); // update display to show text and pinout
}
static const struct menu_command_t busvoodoo_hiz_commands[] = {
{
.shortcut = 'v',
.name = "version",
.command_description = "show hardware and firmware version",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &busvoodoo_hiz_version,
},
{
.shortcut = 'b',
.name = "bootloader",
.command_description = "reboot into DFU bootloader",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &busvoodoo_hiz_bootloader,
},
{
.shortcut = 's',
.name = "self-test [halt]",
.command_description = "perform board self-test (optional halt on error)",
.argument = MENU_ARGUMENT_STRING,
.argument_description = NULL,
.command_handler = &busvoodoo_hiz_command_test_self,
},
{
.shortcut = 't',
.name = "pins-test [halt]",
.command_description = "perform connector pins test (optional halt on error)",
.argument = MENU_ARGUMENT_STRING,
.argument_description = NULL,
.command_handler = &busvoodoo_hiz_command_test_pins,
},
};
const struct busvoodoo_mode_t busvoodoo_hiz_mode = {
.name = "hiz",
.description = "High Impedance (Z)",
.full_only = false,
.setup = &busvoodoo_hiz_setup,
.commands = busvoodoo_hiz_commands,
.commands_nb = LENGTH(busvoodoo_hiz_commands),
.exit = &busvoodoo_hiz_exit,
};
busvoodoo_leds_off
void busvoodoo_leds_off(void)
switch off blue and red LEDs
Definition: busvoodoo_global.c:447
BUSVOODOO_5V_CHANNEL
#define BUSVOODOO_5V_CHANNEL
ADC channel to measure 3.3V rail.
Definition: busvoodoo_global.h:41
busvoodoo_hv_set
float busvoodoo_hv_set(float voltage)
set voltage on high voltage adjustable voltage regulator
Definition: busvoodoo_global.c:343
BUSVOODOO_LV_TEST
#define BUSVOODOO_LV_TEST
target LV output voltage to test if we can set control the LV voltage regulator
Definition: busvoodoo_hiz.c:42
busvoodoo_hiz_bootloader
static void busvoodoo_hiz_bootloader(void *argument)
switch to DFU bootloader
Definition: busvoodoo_hiz.c:842
BUSVOODOO_HVCTL_CHANNEL
#define BUSVOODOO_HVCTL_CHANNEL
DAC channel to control HV output voltage.
Definition: busvoodoo_global.h:55
menu_command_t
command menu entry
Definition: menu.h:31
busvoodoo_hiz_commands
static const struct menu_command_t busvoodoo_hiz_commands[]
HiZ menu commands.
Definition: busvoodoo_hiz.c:951
busvoodoo_global.h
BusVoodoo global definitions and methods (API)
BUSVOODOO_HVEN_PIN
#define BUSVOODOO_HVEN_PIN
high voltage (HV) enable pin (active low)
Definition: busvoodoo_global.h:32
RCC_GPIO
#define RCC_GPIO(x)
get RCC for GPIO based on GPIO identifier
Definition: global.h:105
busvoodoo_oled_text_pinout
void busvoodoo_oled_text_pinout(const char *pins[10], bool io_connector)
draw pin names on bottom (blue) part in display buffer
Definition: busvoodoo_oled.c:406
busvoodoo_mode_t::name
const char * name
name of the mode (i.e.
Definition: busvoodoo_global.h:114
BUSVOODOO_LVCTL_PORT
#define BUSVOODOO_LVCTL_PORT
pin to control LV output voltage
Definition: busvoodoo_global.h:49
busvoodoo_vout_switch
bool busvoodoo_vout_switch(bool on)
switch 3V3 and 5V power outputs on I/O connector
Definition: busvoodoo_global.c:226
BUSVOODOO_RS232_EN_PORT
#define BUSVOODOO_RS232_EN_PORT
RS-232 pin to enable receiver (active low, pulled up)
Definition: busvoodoo_global.h:62
BUSVOODOO_HV_SET
#define BUSVOODOO_HV_SET(x)
voltage to output for the DAC to set the desired HV output voltage (based on resistor values on the H...
Definition: busvoodoo_global.h:56
BUSVOODOO_HVEN_PORT
#define BUSVOODOO_HVEN_PORT
high voltage (HV) enable pin (active low)
Definition: busvoodoo_global.h:31
BUSVOODOO_RS232_CTS_PORT
#define BUSVOODOO_RS232_CTS_PORT
RS-232 Clear-To-Send input pin.
Definition: busvoodoo_global.h:68
busvoodoo_oled_update
void busvoodoo_oled_update(void)
update OLED display RAM with current display buffer
Definition: busvoodoo_oled.c:589
busvoodoo_lv_set
float busvoodoo_lv_set(float voltage)
set voltage on low voltage adjustable voltage regulator
Definition: busvoodoo_global.c:315
BUSVOODOO_LVEN_PIN
#define BUSVOODOO_LVEN_PIN
low voltage (LV) enable pin (active high)
Definition: busvoodoo_global.h:30
busvoodoo_global_pinout_rscan
const char * busvoodoo_global_pinout_rscan[5]
RS/CAN connector pinout.
Definition: busvoodoo_global.c:63
busvoodoo_io_pins
const uint32_t busvoodoo_io_pins[13]
pin of individual signals
Definition: busvoodoo_global.c:67
BUSVOODOO_RS232_TX_PORT
#define BUSVOODOO_RS232_TX_PORT
RS-232 Transmit output pin.
Definition: busvoodoo_global.h:70
global.h
global definitions and methods (API)
menu_command_t::argument
enum menu_argument_t argument
what kind of argument it accepts
Definition: menu.h:35
busvoodoo_hiz_exit
static void busvoodoo_hiz_exit(void)
exit HiZ mode
Definition: busvoodoo_hiz.c:75
GPIO
#define GPIO(x)
get GPIO based on GPIO identifier
Definition: global.h:103
BUSVOODOO_RS485_RX_PORT
#define BUSVOODOO_RS485_RX_PORT
RS-485 Receive input pin.
Definition: busvoodoo_global.h:85
sleep_us
void sleep_us(uint32_t duration)
go to sleep for some microseconds
Definition: global.c:102
busvoodoo_hiz_command_test_self
static void busvoodoo_hiz_command_test_self(void *argument)
command to perform board self-test
Definition: busvoodoo_hiz.c:867
BUSVOODOO_HV_DEFAULT
#define BUSVOODOO_HV_DEFAULT
default (when not driven) HV voltage regulator output voltage based on R1 and R2
Definition: busvoodoo_hiz.c:43
BUSVOODOO_RS485_RE_PORT
#define BUSVOODOO_RS485_RE_PORT
RS-485 pin to enable receiver (active low, pulled up)
Definition: busvoodoo_global.h:79
busvoodoo_hiz_test_pins
static bool busvoodoo_hiz_test_pins(bool halt)
test if signals are soldered correctly to the connector pins
Definition: busvoodoo_hiz.c:407
busvoodoo_full
bool busvoodoo_full
is the BusVoodoo board fully populated (with HV voltage regulator, RS-232, RS-485, CAN transceiver on the back side)
Definition: busvoodoo_global.c:70
busvoodoo_hiz_version
static void busvoodoo_hiz_version(void *argument)
show BusVoodoo version
Definition: busvoodoo_hiz.c:854
busvoodoo_hiz_mode
const struct busvoodoo_mode_t busvoodoo_hiz_mode
HiZ mode interface definition.
Definition: busvoodoo_hiz.c:986
busvoodoo_io_ports
const uint32_t busvoodoo_io_ports[13]
port of individual signals
Definition: busvoodoo_global.c:66
BUSVOODOO_RS485_TX_PORT
#define BUSVOODOO_RS485_TX_PORT
RS-485 Transmit output pin.
Definition: busvoodoo_global.h:83
BUSVOODOO_RS232_CTS_PIN
#define BUSVOODOO_RS232_CTS_PIN
RS-232 Clear-To-Send input pin.
Definition: busvoodoo_global.h:69
BUSVOODOO_LV_CHANNEL
#define BUSVOODOO_LV_CHANNEL
ADC channel to measure LV rail.
Definition: busvoodoo_global.h:42
BUSVOODOO_RS232_TX_PIN
#define BUSVOODOO_RS232_TX_PIN
RS-232 Transmit output pin.
Definition: busvoodoo_global.h:71
BUSVOODOO_RS485_DE_PORT
#define BUSVOODOO_RS485_DE_PORT
RS-485 pin to enable transmitter (active high, pulled low)
Definition: busvoodoo_global.h:81
BUSVOODOO_RS232_RTS_PIN
#define BUSVOODOO_RS232_RTS_PIN
RS-232 Request-To-Send output pin.
Definition: busvoodoo_global.h:67
busvoodoo_io_groups
const uint8_t busvoodoo_io_groups[13]
which I/O pin (group) does the signal belong to
Definition: busvoodoo_global.c:68
menu_command_t::shortcut
char shortcut
short command code (0 if not available)
Definition: menu.h:32
busvoodoo_leds_blink
void busvoodoo_leds_blink(double period, double duty)
set LED blinking pattern
Definition: busvoodoo_global.c:511
busvoodoo_led_blue_on
void busvoodoo_led_blue_on(void)
switch on blue LED
Definition: busvoodoo_global.c:419
BUILD_MONTH
#define BUILD_MONTH
build month as number if known, or 0 if unknown
Definition: global.h:94
BUSVOODOO_HV_CHANNEL
#define BUSVOODOO_HV_CHANNEL
ADC channel to measure HV rail.
Definition: busvoodoo_global.h:43
busvoodoo_global_pinout_io
const char * busvoodoo_global_pinout_io[10]
I/O connector pinout.
Definition: busvoodoo_global.c:62
BUSVOODOO_LVCTL_PIN
#define BUSVOODOO_LVCTL_PIN
pin to control LV output voltage
Definition: busvoodoo_global.h:50
user_input_get
char user_input_get(void)
get user input
Definition: global.c:145
BUSVOODOO_RS232_EN_PIN
#define BUSVOODOO_RS232_EN_PIN
RS-232 pin to enable receiver (active low, pulled up)
Definition: busvoodoo_global.h:63
busvoodoo_hiz_setup
static bool busvoodoo_hiz_setup(char **prefix, const char *line)
setup HiZ mode
Definition: busvoodoo_hiz.c:51
busvoodoo_vreg_get
float busvoodoo_vreg_get(uint8_t channel)
read voltage from power rail
Definition: busvoodoo_global.c:247
busvoodoo_io_names
const char * busvoodoo_io_names[13]
I/O individual signal names.
Definition: busvoodoo_global.c:65
BUSVOODOO_VOUTEN_PORT
#define BUSVOODOO_VOUTEN_PORT
voltage output (5V and 3.3V) enable pin (active low)
Definition: busvoodoo_global.h:33
sleep_ms
void sleep_ms(uint32_t duration)
go to sleep for some milliseconds
Definition: global.c:117
printf
size_t printf(const char *format,...)
print format string on user output
Definition: print.c:448
BUSVOODOO_VOUTEN_PIN
#define BUSVOODOO_VOUTEN_PIN
voltage output (5V and 3.3V) enable pin (active low)
Definition: busvoodoo_global.h:34
BUSVOODOO_RS232_RX_PORT
#define BUSVOODOO_RS232_RX_PORT
RS-232 Receive input pin.
Definition: busvoodoo_global.h:72
print.h
printing utilities to replace the large printf from the standard library (API)
BUSVOODOO_RS485_DE_PIN
#define BUSVOODOO_RS485_DE_PIN
RS-485 pin to enable transmitter (active high, pulled low)
Definition: busvoodoo_global.h:82
busvoodoo_oled_text_left
void busvoodoo_oled_text_left(char *text)
draw mode text on top (yellow) left side in display buffer
Definition: busvoodoo_oled.c:356
BUSVOODOO_LVEN_PORT
#define BUSVOODOO_LVEN_PORT
low voltage (LV) enable pin (active high)
Definition: busvoodoo_global.h:29
busvoodoo_embedded_pullup
float busvoodoo_embedded_pullup(bool on)
enable embedded pull-up resistors
Definition: busvoodoo_global.c:373
BUSVOODOO_HV_TEST
#define BUSVOODOO_HV_TEST
target HV output voltage to test if we can set control the HV voltage regulator
Definition: busvoodoo_hiz.c:44
busvoodoo_led_red_off
void busvoodoo_led_red_off(void)
switch off red LED
Definition: busvoodoo_global.c:440
BUSVOODOO_RS232_RTS_PORT
#define BUSVOODOO_RS232_RTS_PORT
RS-232 Request-To-Send output pin.
Definition: busvoodoo_global.h:66
busvoodoo_hiz_test_self
static bool busvoodoo_hiz_test_self(bool halt)
perform self tests
Definition: busvoodoo_hiz.c:84
LENGTH
#define LENGTH(x)
get the length of an array
Definition: global.h:26
BUSVOODOO_RS485_RE_PIN
#define BUSVOODOO_RS485_RE_PIN
RS-485 pin to enable receiver (active low, pulled up)
Definition: busvoodoo_global.h:80
busvoodoo_oled_text_right
void busvoodoo_oled_text_right(char *text)
draw mode text on top (yellow) right side in display buffer
Definition: busvoodoo_oled.c:384
busvoodoo_led_red_on
void busvoodoo_led_red_on(void)
switch on red LED
Definition: busvoodoo_global.c:433
BUSVOODOO_RS232_RX_PIN
#define BUSVOODOO_RS232_RX_PIN
RS-232 Receive input pin.
Definition: busvoodoo_global.h:73
BUSVOODOO_LV_DEFAULT
#define BUSVOODOO_LV_DEFAULT
default (when not driven) LV voltage regulator output voltage based on R1 and R2
Definition: busvoodoo_hiz.c:41
busvoodoo_hiz.h
BusVoodoo high impedance (HiZ) default mode (API)
BUSVOODOO_RS485_RX_PIN
#define BUSVOODOO_RS485_RX_PIN
RS-485 Receive input pin.
Definition: busvoodoo_global.h:86
busvoodoo_oled.h
library to show BusVoodoo mode information on SSD1306 OLED display: name, activity, pinout (API)
busvoodoo_hiz_command_test_pins
static void busvoodoo_hiz_command_test_pins(void *argument)
command to perform pins test
Definition: busvoodoo_hiz.c:905
user_input_available
volatile bool user_input_available
flag set when user input is available
Definition: global.c:36
BUSVOODOO_RS485_TX_PIN
#define BUSVOODOO_RS485_TX_PIN
RS-485 Transmit output pin.
Definition: busvoodoo_global.h:84
busvoodoo_safe_state
void busvoodoo_safe_state(void)
set safe state by disabling all outputs
Definition: busvoodoo_global.c:171
BUILD_YEAR
#define BUILD_YEAR
build year as number if known, or 0 if unknown
Definition: global.h:92
busvoodoo_version
char busvoodoo_version
version of the hardware board
Definition: busvoodoo_global.c:71
busvoodoo_mode_t
BusVoodoo mode interface.
Definition: busvoodoo_global.h:113
BUSVOODOO_RS232_SHDN_PORT
#define BUSVOODOO_RS232_SHDN_PORT
RS-232 pin to enable transmitter (active high, pulled low)
Definition: busvoodoo_global.h:64
BUSVOODOO_3V3_CHANNEL
#define BUSVOODOO_3V3_CHANNEL
ADC channel to measure 5V rail.
Definition: busvoodoo_global.h:40
BUSVOODOO_RS232_SHDN_PIN
#define BUSVOODOO_RS232_SHDN_PIN
RS-232 pin to enable transmitter (active high, pulled low)
Definition: busvoodoo_global.h:65
BUILD_DAY
#define BUILD_DAY
build day as number if known, or 0 if unknown
Definition: global.h:96