/** BusVoodoo high impedance (HiZ) default mode * @file * @author King Kévin * @date 2018-2020 * @copyright SPDX-License-Identifier: GPL-3.0-or-later */ /* standard libraries */ #include // standard integer types #include // string utilities #include // math utilities /* STM32 (including CM3) libraries */ #include // Cortex M3 utilities #include // general purpose input output library #include // real-time control clock library #include // debug utilities #include // design utilities #include // DAC utilities #include // independent watchdog utilities /* own libraries */ #include "global.h" // board definitions #include "print.h" // printing utilities #include "menu.h" // menu definitions #include "busvoodoo_global.h" // BusVoodoo definitions #if BUSVOODOO_HARDWARE_VERSION != 2 #include "busvoodoo_oled.h" // OLED utilities #endif #include "busvoodoo_hiz.h" // own definitions #if BUSVOODOO_HARDWARE_VERSION != 2 #define BUSVOODOO_LV_DEFAULT (0.8*(1+30.0/10.0)) /**< default (when not driven) LV voltage regulator output voltage based on R1 and R2 */ #define BUSVOODOO_LV_TEST 2.5 /**< target LV output voltage to test if we can set control the LV voltage regulator */ #define BUSVOODOO_HV_DEFAULT (1.25*(1+100.0/10.0)) /**< default (when not driven) HV voltage regulator output voltage based on R1 and R2 */ #define BUSVOODOO_HV_TEST 12.0 /**< target HV output voltage to test if we can set control the HV voltage regulator */ #endif /** setup HiZ mode * @param[out] prefix terminal prompt prefix * @param[in] line terminal prompt line to configure mode * @return if setup is complete */ 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 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_HARDWARE_VERSION != 2 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_left(*prefix); // set mode title on OLED display busvoodoo_oled_text_pinout(busvoodoo_global_pinout_io, true); // set pinout on display busvoodoo_oled_update(); // update display to show text and pinout #endif return true; } /** exit HiZ mode */ static void busvoodoo_hiz_exit(void) { // there is nothing to do } /** perform self tests * @param[in] halt halt on error instead of exiting immediately (exit on user input) * @return if self tests passed */ 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 // ensure flash size is ok if (0xffff == DESIG_FLASH_SIZE) { puts("unknown flash size: this is probably a defective micro-controller\n"); } // 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 BUSVOODOO_HARDWARE_VERSION != 2 if (0 == (DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK)) { // can't read IDCODE for verification (this is a known issue documented in STM32F10xxC/D/E Errata sheet, without workaround) if (DESIG_FLASH_SIZE != 256 && DESIG_FLASH_SIZE != 512) { printf("flash size=%ukB\n", DESIG_FLASH_SIZE); puts("this is not a high-density device: a wrong micro-controller might have been used\n"); } } else if (0x414 != (DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK)) { printf("DEV_ID=%03x\n", (DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK)); puts("this is not a high-density device: a wrong micro-controller might have been used\n"); } #else if (0 == (DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK)) { // can't read IDCODE for verification (this is a known issue documented in STM32F10xxC/D/E Errata sheet, without workaround) if (DESIG_FLASH_SIZE != 64 && DESIG_FLASH_SIZE != 128) { printf("flash size=%ukB\n", DESIG_FLASH_SIZE); puts("this is not a medium-density device: a wrong micro-controller might have been used\n"); } } else if (0x410 != (DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK)) { printf("DEV_ID=%03x\n", (DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK)); puts("this is not a medium-density device: a wrong micro-controller might have been used\n"); } #endif #if BUSVOODOO_HARDWARE_VERSION != 2 // 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 iwdg_reset(); // kick the dog } } 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 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 } #endif // 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 #if BUSVOODOO_HARDWARE_VERSION == 2 // counter the I²C pull-ups if (1 == busvoodoo_io_groups[pin1] || 2 == busvoodoo_io_groups[pin1]) { // set same level as pin2 gpio_clear(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); gpio_set_mode(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); } else { // don't interfere with pin1 gpio_set(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); gpio_set_mode(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); } #endif 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 #if BUSVOODOO_HARDWARE_VERSION == 2 // counter the I²C pull-ups if (1 == busvoodoo_io_groups[pin1] || 2 == busvoodoo_io_groups[pin1]) { // set same level as pin2 gpio_set(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); gpio_set_mode(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); } else { // don't interfere with pin1 gpio_set(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); gpio_set_mode(GPIO_PORT(BUSVOODOO_I2C_PULLUP_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(BUSVOODOO_I2C_PULLUP_PIN)); } #endif 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 } #if BUSVOODOO_HARDWARE_VERSION != 2 // 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 puts("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 puts("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 puts("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 puts("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 puts("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 // BUSVOODOO_HARDWARE_VERSION != 0 #endif // BUSVOODOO_HARDWARE_VERSION != 2 to_return = true; // all tests are successful puts("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 iwdg_reset(); // kick the dog } } else { puts("the test procedure has been aborted for safety reasons\n"); } } busvoodoo_safe_state(); // set back to safe state return to_return; } #if BUSVOODOO_HARDWARE_VERSION == 2 // make life easier since the ADC is the same #define BUSVOODOO_LV_CHANNEL BUSVOODOO_ADC_CHANNEL #endif /** wait until pin 4/LV/ADC is disconnected * @return if it is interrupted by user input */ static bool busvoodoo_hiz_wait_pin4_disconnected(void) { do { iwdg_reset(); // kick the dog 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 disconnected return user_input_available; } /** test if signals are soldered correctly to the connector pins * @param[in] halt halt on error instead of exiting immediately (exit on user input) * @return if pin test passed */ 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 #if BUSVOODOO_HARDWARE_VERSION != 2 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 #endif #if BUSVOODOO_HARDWARE_VERSION != 2 // 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 { iwdg_reset(); // kick the dog 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) { puts("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 #endif // test 5V output on pin 2 #if BUSVOODOO_HARDWARE_VERSION != 2 gpio_clear(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // enable Vout #endif printf("%sI/O pin 2\n", lv_to); busvoodoo_leds_off(); // clear LEDs busvoodoo_led_red_on(); // notify user to perform action #if BUSVOODOO_HARDWARE_VERSION != 2 pinout[1] = "O"; // set target testing pin busvoodoo_oled_text_pinout((const char**)pinout, true); // display pins to user busvoodoo_oled_update(); // update screen #endif if (busvoodoo_hiz_wait_pin4_disconnected()) { goto error; } do { iwdg_reset(); // kick the dog 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 if (user_input_available) { // user interruption goto error; } busvoodoo_led_red_off(); // clear red LED busvoodoo_led_blue_on(); // notify user test is running sleep_ms(100); // let LED a bit on #if BUSVOODOO_HARDWARE_VERSION != 2 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) { puts("5V output is high while the power output should be switched off\n"); goto error; } pinout[1] = NULL; // clear pin to test #endif // test 3.3V output on pin 3 #if BUSVOODOO_HARDWARE_VERSION != 2 gpio_clear(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // enable Vout #endif printf("%sI/O pin 3\n", lv_to); busvoodoo_leds_off(); // clear LEDs busvoodoo_led_red_on(); // notify user to perform action #if BUSVOODOO_HARDWARE_VERSION != 2 pinout[2] = "O"; // set target testing pin busvoodoo_oled_text_pinout((const char**)pinout, true); // display pins to user busvoodoo_oled_update(); // update screen #endif if (busvoodoo_hiz_wait_pin4_disconnected()) { goto error; } do { do { iwdg_reset(); // kick the dog 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 iwdg_reset(); // kick the dog 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 if (user_input_available) { // user interruption goto error; } busvoodoo_led_red_on(); // clear red LED busvoodoo_led_blue_on(); // notify user test is running sleep_ms(100); // let LED a bit on #if BUSVOODOO_HARDWARE_VERSION != 2 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) { puts("3V3 output is high while the power output should be switched off\n"); goto error; } pinout[2] = NULL; // clear pin to test #endif // 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 #if BUSVOODOO_HARDWARE_VERSION != 2 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 #endif if (busvoodoo_hiz_wait_pin4_disconnected()) { goto error; } do { iwdg_reset(); // kick the dog 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 #if BUSVOODOO_HARDWARE_VERSION != 2 pinout[io+3] = NULL; // clear pin to test #endif break; // stop looking for pin } } } #if BUSVOODOO_HARDWARE_VERSION != 2 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 { iwdg_reset(); // kick the dog 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) { puts("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 { iwdg_reset(); // kick the dog 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) { puts("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 // 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 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 { iwdg_reset(); // kick the dog 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) { puts("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 // BUSVOODOO_HARDWARE_VERSION == 0 #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 puts("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 puts("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) { puts("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 // BUSVOODOO_HARDWARE_VERSION != 0 #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 { iwdg_reset(); // kick the dog 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) { puts("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 // 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 { iwdg_reset(); // kick the dog 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) { puts("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 // BUSVOODOO_HARDWARE_VERSION == 0 #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 puts("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 puts("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) { puts("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 // BUSVOODOO_HARDWARE_VERSION == 0 // 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); puts("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 { iwdg_reset(); // kick the dog 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 puts("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 puts("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 { iwdg_reset(); // kick the dog 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 puts("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 } #endif // BUSVOODOO_HARDWARE_VERSION != 2 to_return = true; // all tests passed error: if (!to_return) { if (user_input_available) { puts("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 iwdg_reset(); // kick the dog } } else { puts("the test procedure has been aborted for safety reasons\n"); } } busvoodoo_safe_state(); // go back to safe state return to_return; } // command handlers /** switch to DFU bootloader * @param[in] argument no argument required * @note this handler is in HiZ mode only to save shortcut space and reduce menu size */ static void busvoodoo_hiz_bootloader(void* argument) { (void)argument; // we won't use the argument // set DFU magic to specific RAM location __dfu_magic[0] = 'D'; __dfu_magic[1] = 'F'; __dfu_magic[2] = 'U'; __dfu_magic[3] = '!'; scb_reset_system(); // reset system (core and peripherals) while (true); // wait for the reset to happen } /** show BusVoodoo version * @param[in] argument no argument required * @note this handler is in HiZ mode only to save shortcut space and reduce menu size */ static void busvoodoo_hiz_version(void* argument) { (void)argument; // we won't use the argument #if BUSVOODOO_HARDWARE_VERSION != 2 printf("BusVoodoo flavor: %s\n", busvoodoo_full ? "full" : "light"); #endif 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); } /** command to perform board self-test * @param[in] argument "halt" to halt on error */ 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 { puts("malformed argument\n"); return; } } puts("performing self-test\n"); if (halt) { puts("WARNING: halting on error can cause hardware damages (press any key to exit halt state)\n"); } puts("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 while (!user_input_available) { // wait for user input iwdg_reset(); // kick the dog } if (' ' == user_input_get()) { // space entered puts("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 puts("self-test failed\n"); // notify user if (user_input_available) { user_input_get(); // clear user input } } } else { puts("self-test aborted\n"); } } /** command to perform pins test * @param[in] argument "halt" to halt on error */ 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 { puts("malformed argument\n"); return; } } puts("performing pins test\n"); if (halt) { puts("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 #if BUSVOODOO_HARDWARE_VERSION != 2 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 #endif puts("connect one lead of jumper wire to I/O pin 4 and press space to start (or any other key to abort)\n"); while (!user_input_available) { // wait for user input iwdg_reset(); // kick the dog } 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 puts("pins test succeeded\n"); // notify user } else { busvoodoo_leds_blink(0.5, 0.5); // show error on LEDs puts("pins test failed\n"); // notify user if (user_input_available) { user_input_get(); // clear user input } } } else { puts("pins test aborted\n"); busvoodoo_led_red_off(); // clear red LED busvoodoo_led_blue_on(); // switch back to main blue LED } #if BUSVOODOO_HARDWARE_VERSION != 2 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 #endif } /** HiZ menu commands */ 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, };