/* 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/>.
 *
 */
/** STM32F1 BusVoodoo application
 *  @file application.c
 *  @author King Kévin <kingkevin@cuvoodoo.info>
 *  @date 2016-2017
 */

/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdlib.h> // standard utilities
#include <string.h> // string utilities
#include <math.h> // math utilities

/* STM32 (including CM3) libraries */
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
#include <libopencm3/cm3/scb.h> // vector table definition
#include <libopencm3/cm3/nvic.h> // interrupt utilities
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/exti.h> // external interrupt utilities
#include <libopencm3/stm32/iwdg.h> // independent watchdog utilities
#include <libopencm3/stm32/dbgmcu.h> // debug utilities
#include <libopencm3/stm32/flash.h> // flash utilities
#include <libopencm3/stm32/desig.h> // design utilities
#include <libopencm3/stm32/adc.h> // ADC utilities
#include <libopencm3/stm32/dac.h> // DAC utilities

/* own libraries */
#include "global.h" // board definitions
#include "print.h" // printing utilities
#include "uart.h" // USART utilities
#include "usb_cdcacm.h" // USB CDC ACM utilities

//#include "rs485.h" // RS-485 utilities
//#include "rs232.h" // RS-232 utilities
//#include "i2c_master.h" // I2C utilities

#define WATCHDOG_PERIOD 10000 /**< watchdog period in ms */

/** @defgroup busvoodoo_peripherals peripheral pin definitions
 *  @{
 */
#define BUSVOODOO_5VPULLUP_PORT B /**< 5V pull-up enable pin (active low) */
#define BUSVOODOO_5VPULLUP_PIN 4 /**< 5V pull-up enable pin (active low) */
#define BUSVOODOO_OEPULLUP_PORT A /**< bus switch output enable pin to enable embedded pull-ups  (active low) */
#define BUSVOODOO_OEPULLUP_PIN 15 /**< bus switch output enable pin to enable embedded pull-ups (active low) */
#define BUSVOODOO_XVEN_PORT A /**< xV enable pin (active high) */
#define BUSVOODOO_XVEN_PIN 6 /**< xV enable pin (active high) */
#define BUSVOODOO_12VEN_PORT A /**< 12V enable pin (active low) */
#define BUSVOODOO_12VEN_PIN 7 /**< 12V enable pin (active low) */
#define BUSVOODOO_VOUTEN_PORT B /**< voltage output (5V and 3.3V) enable pin (active low) */
#define BUSVOODOO_VOUTEN_PIN 3 /**< voltage output (5V and 3.3V) enable pin (active low) */
/** @} */

/** @defgroup busvoodoo_adc ADC inputs to measure voltages from voltage regulators
 *  @{
 */
#define BUSVOODOO_3V3_CHANNEL 12 /**< ADC channel to measure 5V rail */
#define BUSVOODOO_5V_CHANNEL 9 /**< ADC channel to measure 3.3V rail */
#define BUSVOODOO_XV_CHANNEL 11 /**< ADC channel to measure xV rail */
#define BUSVOODOO_12V_CHANNEL 15 /**< ADC channel to measure 12V rail */
/** @} */

/** @defgroup busvoodoo_dac DAC output to set voltages of voltage regulators
 *  @{
 */
#define BUSVOODOO_XVCTL_PORT A /**< pin to control xV output voltage */
#define BUSVOODOO_XVCTL_PIN 4 /**< pin to control xV output voltage */
#define BUSVOODOO_XVCTL_CHANNEL CHANNEL_1 /**< DAC channel to control xV output voltage */
#define BUSVOODOO_XV_DEFAULT (0.8*(1+30.0/10.0)) /**< default (when not driven) xV voltage regulator output voltage based on R1 and R2 */
#define BUSVOODOO_XV_TEST 2.5 /**< target xV output voltage to test if we can set control the xV voltage regulator */
#define BUSVOODOO_XV_SET(x) ((0.8*(1+30.0/10.0)-x)*(10.0/30.0)+0.8) /**< voltage to output for the DAC to set the desired xV output voltage (based on resistor values on the xV adjust pins and xV voltage reference) */
#define BUSVOODOO_12VCTL_PORT A /**< pin to control 12V output voltage */
#define BUSVOODOO_12VCTL_PIN 5 /**< pin to control 12V output voltage */
#define BUSVOODOO_12VCTL_CHANNEL CHANNEL_2 /**< DAC channel to control 12V output voltage */
#define BUSVOODOO_12V_DEFAULT (1.25*(1+100.0/10.0)) /**< default (when not driven) 12V voltage regulator output voltage based on R1 and R2 */
#define BUSVOODOO_12V_TEST 12.0 /**< target 12V output voltage to test if we can set control the 12V voltage regulator */
#define BUSVOODOO_12V_SET(x) ((1.25*(1+100.0/10.0)-x)*(10.0/100.0)+1.25) /**< voltage to output for the DAC to set the desired 
12V output voltage (based on resistor values on the 12V adjust pins and 12V voltage reference) */
/** @} */

/** @defgroup busvoodoo_rs232 RS-232 transceiver connection definition
 *  @{
 */
#define BUSVOODOO_RS232_EN_PORT B /**< RS-232 pin to enable receiver (active low, pulled up) */
#define BUSVOODOO_RS232_EN_PIN 5 /**< RS-232 pin to enable receiver (active low, pulled up) */
#define BUSVOODOO_RS232_SHDN_PORT C /**< RS-232 pin to enable transmitter (active high, pulled low) */
#define BUSVOODOO_RS232_SHDN_PIN 15 /**< RS-232 pin to enable transmitter (active high, pulled low) */
#define BUSVOODOO_RS232_RTS_PORT A /**< RS-232 Request-To-Send output pin */
#define BUSVOODOO_RS232_RTS_PIN 1 /**< RS-232 Request-To-Send output pin */
#define BUSVOODOO_RS232_CTS_PORT A /**< RS-232 Clear-To-Send input pin */
#define BUSVOODOO_RS232_CTS_PIN 0 /**< RS-232 Clear-To-Send input pin */
#define BUSVOODOO_RS232_TX_PORT A /**< RS-232 Transmit output pin */
#define BUSVOODOO_RS232_TX_PIN 2 /**< RS-232 Transmit output pin */
#define BUSVOODOO_RS232_RX_PORT A /**< RS-232 Receive input pin */
#define BUSVOODOO_RS232_RX_PIN 3 /**< RS-232 Receive input pin */
/** @} */

/** @defgroup busvoodoo_can CAN transceiver connection definition
 *  @{
 */
#define BUSVOODOO_CAN_EN_PORT C /**< CAN pin to enable transceiver (active high, pulled low) */
#define BUSVOODOO_CAN_EN_PIN 14 /**< CAN pin to enable transceiver (active high, pulled low) */
#define BUSVOODOO_CAN_S_PORT C /**< CAN pin to set to silent mode (active low, pulled high) */
#define BUSVOODOO_CAN_S_PIN 13 /**< CAN pin to set to silent mode (active low, pulled high) */
#define BUSVOODOO_CAN_TX_PORT B /**< CAN Transmit output pin */
#define BUSVOODOO_CAN_TX_PIN 9 /**< CAN Transmit output pin */
#define BUSVOODOO_CAN_RX_PORT B /**< CAN Receive input pin */
#define BUSVOODOO_CAN_RX_PIN 8 /**< CAN Receive input pin */
/** @} */

/** @defgroup busvoodoo_io I/O connector pin definition
 *  @{
 */
static const char* busvoodoo_io_names[13] = {"I2C_SMBA/SPI_NSS/I2S_WS", "SDIO_CMD", "USART_CTS/SPI_SCK/I2S_CK", "SDIO_D3/UART_RX", "I2C_SDA/USART_RX", "SDIO_D0", "SPI_MOSI/I2S_SD", "SDIO_CK/USART_CK", "I2C_SCL/USART_TX", "SDIO_D1", "I2S_MCK", "USART_RTS/SPI_MISO", "SDIO_D2/UART_TX"}; /**< I/O individual signal names */
static const uint32_t busvoodoo_io_ports[13] = {GPIOB, GPIOD, GPIOB, GPIOC, GPIOB, GPIOC, GPIOB, GPIOC, GPIOB, GPIOC, GPIOC, GPIOB, GPIOC}; /**< port of individual signals */
static const uint32_t busvoodoo_io_pins[13] = {GPIO12, GPIO2, GPIO13, GPIO11, GPIO11, GPIO8, GPIO15, GPIO12, GPIO10, GPIO9, GPIO6, GPIO14, GPIO10}; /**< pin of individual signals */
static const uint8_t busvoodoo_io_groups[13] = {6, 6, 4, 4, 1, 1, 5, 5, 2, 2, 3, 3, 3}; /**< which I/O pin (group) does the signal belong to */
/** @} */

/** is the BusVoodoo board fully populated (with 12V voltage regulator, RS-232, RS-485, CAN transceiver on the back side) */
static bool busvoodoo_full = false;

size_t putc(char c)
{
	size_t length = 0; // number of characters printed
	static char newline = 0; // to remember on which character we sent the newline
	if (0==c) {
		length = 0; // don't print string termination character
	} else if ('\r' == c || '\n' == c) { // send CR+LF newline for most carriage return and line feed combination
		if (0==newline || c==newline) { // send newline only if not already send (and only once on \r\n or \n\r)
			uart_putchar_nonblocking('\r'); // send CR over USART
			usb_cdcacm_putchar('\r'); // send CR over USB
			uart_putchar_nonblocking('\n'); // send LF over USART
			usb_cdcacm_putchar('\n'); // send LF over USB
			length += 2; // remember we printed 2 characters
			newline = c; // remember on which character we sent the newline
		} else {
			length = 0; // the \r or \n of \n\r or \r\n has already been printed
		}
	} else {
		uart_putchar_nonblocking(c); // send byte over USART
		usb_cdcacm_putchar(c); // send byte over USB
		newline = 0; // clear new line
		length++; // remember we printed 1 character
	}
	return length; // return number of characters printed   
}

static bool wait_space(void)
{
	// disable watchdog when waiting for user input
	printf("press space to continue, or any other key to abort\n");
	while (!uart_received && !usb_cdcacm_received) { // wait for user input
		__WFI(); // go to sleep
	}
	char c = 0;
	if (uart_received) {
		c = uart_getchar(); // read user input from UART
	} else if (usb_cdcacm_received) {
		c = usb_cdcacm_getchar(); // read user input from USB
	} else {
		return false; // this should not happen
	}
	if (' '==c) { // space entered
		return true;
	} else { // something else entered
		return false;
	}
}

/** set safe state by disabling all outputs */
static void safe_state(void)
{
	// disable voltage outputs
	gpio_set(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // disable 5V and 3.3V output on connector
	gpio_set_mode(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_VOUTEN_PIN)); // set pin as output (open-drain pulled high to disable the pMOS)
	gpio_clear(GPIO(BUSVOODOO_XVEN_PORT), GPIO(BUSVOODOO_XVEN_PIN)); // disable xV voltage regulator
	gpio_set_mode(GPIO(BUSVOODOO_XVEN_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_XVEN_PIN)); // set pin as output (push-pull, pulled low for safety)
	gpio_set(GPIO(BUSVOODOO_12VEN_PORT), GPIO(BUSVOODOO_12VEN_PIN)); // disable 12V voltage regulator
	gpio_set_mode(GPIO(BUSVOODOO_12VEN_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_12VEN_PIN)); // set pin as output (open-drain pulled high to disable the pMOS)

	// set DAC channel back to analog
	gpio_set_mode(GPIO(BUSVOODOO_XVCTL_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO(BUSVOODOO_XVCTL_PIN)); // set xV pin as analog
	gpio_set_mode(GPIO(BUSVOODOO_12VCTL_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO(BUSVOODOO_12VCTL_PIN)); // set 12V pin as analog

	// disable embedded pull-ups
	gpio_primary_remap(AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON, 0); // disable JTAG (but keep SWD) so to use the underlying GPIOs (PA15, PB3, PB4)
	gpio_set(GPIO(BUSVOODOO_5VPULLUP_PORT), GPIO(BUSVOODOO_5VPULLUP_PIN)); // set pin high to disable 5V embedded pull-up
	gpio_set_mode(GPIO(BUSVOODOO_5VPULLUP_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_5VPULLUP_PIN)); // set pin as output (open-drain pulled high to disable the pMOS)
	gpio_set(GPIO(BUSVOODOO_OEPULLUP_PORT), GPIO(BUSVOODOO_OEPULLUP_PIN)); // set pin high to disable embedded pull-up bus switch
	gpio_set_mode(GPIO(BUSVOODOO_OEPULLUP_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO(BUSVOODOO_OEPULLUP_PIN)); // set pin as output (open-drain pulled high to disable the bus switch)

	// disable all signal I/O outputs
	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_FLOAT, busvoodoo_io_pins[pin]); // set pin back to input (floating)
	}

	// disable all RS-232 and some RS-485 signals (put back to input floating)
	gpio_set_mode(GPIO(BUSVOODOO_RS232_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_TX_PIN));
	gpio_set_mode(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_RX_PIN));
	gpio_set_mode(GPIO(BUSVOODOO_RS232_RTS_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_RTS_PIN));
	gpio_set_mode(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_RS232_CTS_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

	// disable all CAN and some RS-458 signals (put back to input floating)
	gpio_set_mode(GPIO(BUSVOODOO_CAN_TX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_CAN_TX_PIN));
	gpio_set_mode(GPIO(BUSVOODOO_CAN_RX_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_CAN_RX_PIN));
	gpio_set_mode(GPIO(BUSVOODOO_CAN_EN_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_CAN_EN_PIN));
	gpio_set_mode(GPIO(BUSVOODOO_CAN_S_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO(BUSVOODOO_CAN_S_PIN));
}

/** read power rail voltage
 *  @param[in] channel which ADC channel to read voltage from
 *  @return voltage of NaN if channel is invalid
 */
static float rail_voltage(uint8_t channel)
{
	if (channel!=BUSVOODOO_5V_CHANNEL && channel!=BUSVOODOO_3V3_CHANNEL && channel!=BUSVOODOO_XV_CHANNEL && channel!=BUSVOODOO_12V_CHANNEL) { // check channel
		return NAN;
	}
	uint16_t channels[5] = {0}; // to start converted values: internal reference 1.2V, 5V rail, 3.3V rail, xV rail, 12V rail
	adc_start_conversion_regular(ADC1); // start conversion to get first voltage
	for  (uint8_t channel_i=0; channel_i<LENGTH(channels); channel_i++) { // get all conversions
		while (!adc_eoc(ADC1)); // wait until conversion finished
		channels[channel_i] = adc_read_regular(ADC1); // read voltage value (clears flag)
	}
	float to_return = NAN; // voltage to return
	switch (channel) { // get converter value and calculate according to the voltage divider on this channel
		case BUSVOODOO_5V_CHANNEL:
			to_return = channels[1]/(10.0/(10.0+10.0));
			break;
		case BUSVOODOO_3V3_CHANNEL:
			to_return = channels[2]/(10.0/(10.0+10.0));
			break;
		case BUSVOODOO_XV_CHANNEL:
			to_return = channels[3]/(10.0/(10.0+10.0));
			break;
		case BUSVOODOO_12V_CHANNEL:
			to_return = channels[4]/(1.5/(10.0+1.5));
			break;
		default: // unknown channel
			to_return = NAN;
			break;
	}
	if (!isnan(to_return)) {
		to_return *= 1.2/channels[0]; // calculate voltage from converted values using internal 1.2V voltage reference
	}
	return to_return;
}

/** perform self tests
 *  @return if self tests passed
 */
static bool test_self(void)
{
	bool to_return = false; // success of the self-test
	safe_state(); // start from a safe state

	printf("remove all cables from connector\n");
	wait_space();

	// 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)) {
		printf("device identifier not set: this is probably a defective micro-controller\n");
	} 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 = rail_voltage(BUSVOODOO_5V_CHANNEL); // get 5V power rail voltage
	if (voltage<4.0) {
		printf("5V power rail voltage is too low: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>5.5) {
		printf("5V power rail voltage is too high: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}

	// check 3.3V power rail
	voltage = rail_voltage(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);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>3.6) {
		printf("3.3V power rail voltage is too high: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}

	// test 5V and 3.3V outputs
	gpio_clear(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // enable Vout
	sleep_ms(1); // wait a bit for voltage to settle
	voltage = rail_voltage(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);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>5.5) {
		printf("5V power rail voltage is too high when 5V output is enabled: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	voltage = rail_voltage(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);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>3.6) {
		printf("3.3V power rail voltage is too high when 3V3 is enabled: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	gpio_set(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // disable Vout
	
	// check xV voltage regulator
	gpio_clear(GPIO(BUSVOODOO_XVEN_PORT), GPIO(BUSVOODOO_XVEN_PIN)); // disable xV voltage regulator
	sleep_ms(1); // let voltage settle
	voltage = rail_voltage(BUSVOODOO_XV_CHANNEL); // get xV voltage
	if (voltage>0.2) { // ensure the output is at 0V when the regulator is not enabled
		printf("xV voltage is %.2fV instead of 0V when the regulator is disabled\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	gpio_set(GPIO(BUSVOODOO_XVEN_PORT), GPIO(BUSVOODOO_XVEN_PIN)); // enable xV voltage regulator
	sleep_ms(5); // let the voltage regulator start and voltage settle
	voltage = rail_voltage(BUSVOODOO_XV_CHANNEL); // get xV voltage
	// without being driven it should be around the default voltage
	if (voltage<BUSVOODOO_XV_DEFAULT-0.2) {
		printf("xV voltage is lower (%.2fV) than expected (%.2fV) when the regulator is enabled\n", voltage, BUSVOODOO_XV_DEFAULT);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>BUSVOODOO_XV_DEFAULT+0.2) {
		printf("xV voltage is higher (%.2fV) than expected (%.2fV) when the regulator is enabled\n", voltage, BUSVOODOO_XV_DEFAULT);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}

	// check if we can control xV
	voltage = rail_voltage(BUSVOODOO_3V3_CHANNEL); // get reference voltage
	if (isnan(voltage)) {
		printf("can get 3V3 rail voltage");
		goto error;
	}
	uint16_t dac_set = BUSVOODOO_XV_SET(BUSVOODOO_XV_TEST)/voltage*4095; // DAC value corresponding to the voltage
	dac_load_data_buffer_single(dac_set, RIGHT12, BUSVOODOO_XVCTL_CHANNEL); // set output so the voltage regulator is set to 2.5V
	dac_software_trigger(BUSVOODOO_XVCTL_CHANNEL); // transfer the value to the DAC
	dac_enable(BUSVOODOO_XVCTL_CHANNEL); // enable DAC
	sleep_ms(5); // let voltage settle
	voltage = rail_voltage(BUSVOODOO_XV_CHANNEL); // get xV voltage
	// check if it matched desired voltage
	if (voltage<BUSVOODOO_XV_TEST-0.2) {
		printf("xV voltage is lower (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_XV_TEST);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>BUSVOODOO_XV_TEST+0.2) {
		printf("xV voltage is highed (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_XV_TEST);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	dac_disable(BUSVOODOO_XVCTL_CHANNEL); // disable xV control
	gpio_clear(GPIO(BUSVOODOO_XVEN_PORT), GPIO(BUSVOODOO_XVEN_PIN)); // disable xV voltage regulator
	sleep_ms(1); // let voltage settle

	// check 12V voltage regulator
	if (busvoodoo_full) {
		gpio_set(GPIO(BUSVOODOO_12VEN_PORT), GPIO(BUSVOODOO_12VEN_PIN)); // disable 12V voltage regulator
		sleep_ms(1); // let voltage settle
		voltage = rail_voltage(BUSVOODOO_12V_CHANNEL); // get 12V voltage
		if (voltage>0.2) { // ensure the output is at 0V when the regulator is not enabled
			printf("12V voltage is %.2fV instead of 0V when the regulator is disabled\n", voltage);
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
		gpio_clear(GPIO(BUSVOODOO_12VEN_PORT), GPIO(BUSVOODOO_12VEN_PIN)); // enable 12V voltage regulator
		sleep_ms(10); // let the voltage regulator start and voltage settle
		voltage = rail_voltage(BUSVOODOO_12V_CHANNEL); // get 12V voltage
		// without being driven it should be around the default voltage
		if (voltage<BUSVOODOO_12V_DEFAULT-0.3) {
			printf("12V voltage is lower (%.2fV) than expected (%.2fV) when regulator is enabled\n", voltage, BUSVOODOO_12V_DEFAULT);
#if DEBUG
			while (true);
#else
			goto error;
#endif
		} else if (voltage>BUSVOODOO_12V_DEFAULT+0.3) {
			printf("12V voltage is higher (%.2fV) than expected (%.2fV) when regulator is enabled\n", voltage, BUSVOODOO_12V_DEFAULT);
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}

		// check if we can control 12V voltage regulator
		voltage = rail_voltage(BUSVOODOO_3V3_CHANNEL); // get reference voltage
		if (isnan(voltage)) {
			printf("can get 3V3 rail voltage");
			goto error;
		}
		dac_set = BUSVOODOO_12V_SET(BUSVOODOO_12V_TEST)/voltage*4095; // DAC value corresponding to the voltage
		dac_load_data_buffer_single(dac_set, RIGHT12, BUSVOODOO_12VCTL_CHANNEL); // set output so the voltage regulator is set to desired output voltage
		dac_software_trigger(BUSVOODOO_12VCTL_CHANNEL); // transfer the value to the DAC
		dac_enable(BUSVOODOO_12VCTL_CHANNEL); // enable DAC
		sleep_ms(10); // let voltage settle
		voltage = rail_voltage(BUSVOODOO_12V_CHANNEL); // get 12V voltage
		if (voltage<BUSVOODOO_12V_TEST-0.3) {
			printf("12V voltage is lower (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_12V_TEST);
#if DEBUG
			while (true);
#else
			goto error;
#endif
		} else if (voltage>BUSVOODOO_12V_TEST+0.3) {
			printf("12V voltage is higher (%.2fV) than set (%.2fV)\n", voltage, BUSVOODOO_12V_TEST);
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
		dac_disable(BUSVOODOO_12VCTL_CHANNEL); // disable 12V control
		gpio_set(GPIO(BUSVOODOO_12VEN_PORT), GPIO(BUSVOODOO_12VEN_PIN)); // disable 12V voltage regulator
		sleep_ms(1); // let voltage settle
	}
	
	// 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
#if DEBUG
		while (true);
#else
		goto error;
#endif
		}
	}
	// 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
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
	}

	// 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
#if DEBUG
				while (true);
#else
				goto error;
#endif
			} 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
#if DEBUG
				while (true);
#else
				goto error;
#endif
			}
		}
		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
#if DEBUG
				while (true);
#else
				goto error;
#endif
			} 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
#if DEBUG
				while (true);
#else
				goto error;
#endif
			}
		}
		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
	}
	gpio_clear(GPIO(BUSVOODOO_5VPULLUP_PORT), GPIO(BUSVOODOO_5VPULLUP_PIN)); // enable 5V pull-up
	gpio_clear(GPIO(BUSVOODOO_OEPULLUP_PORT), GPIO(BUSVOODOO_OEPULLUP_PIN)); // switch on embedded pull-ups
	sleep_ms(1); // wait a bit for voltage to settle 
	voltage = rail_voltage(BUSVOODOO_5V_CHANNEL); // get 5V power rail voltage
	if (voltage<4.0) {
		printf("5V power rail voltage is too low when used to pull up: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>5.5) {
		printf("5V power rail voltage is too high when used to pull up: %.2fV\n", voltage);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	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
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
	}
	gpio_set(GPIO(BUSVOODOO_5VPULLUP_PORT), GPIO(BUSVOODOO_5VPULLUP_PIN)); // disable 5V pull-up
	gpio_set(GPIO(BUSVOODOO_OEPULLUP_PORT), GPIO(BUSVOODOO_OEPULLUP_PIN)); // switch off embedded pull-up

	// test xV 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
	}
	gpio_set(GPIO(BUSVOODOO_XVEN_PORT), GPIO(BUSVOODOO_XVEN_PIN)); // enable xV voltage regulator
	gpio_clear(GPIO(BUSVOODOO_OEPULLUP_PORT), GPIO(BUSVOODOO_OEPULLUP_PIN)); // switch in embedded pull-up
	sleep_ms(5); // let the voltage regulator start and voltage settle
	voltage = rail_voltage(BUSVOODOO_XV_CHANNEL); // get xV voltage (without being driven it should be around 3.2V)
	if (voltage<BUSVOODOO_XV_DEFAULT-0.2) {
		printf("xV voltage is lower (%.2fV) than expected (%.2fV) when used to pull up\n", voltage, BUSVOODOO_XV_DEFAULT);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	} else if (voltage>BUSVOODOO_XV_DEFAULT+0.2) {
		printf("xV voltage is higher (%.2fV) than expected (%.2fV) when used to pull up\n", voltage, BUSVOODOO_XV_DEFAULT);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	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 xV (embedded)\n", busvoodoo_io_names[pin]); // warn user about the error
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
	}
	gpio_set(GPIO(BUSVOODOO_OEPULLUP_PORT), GPIO(BUSVOODOO_OEPULLUP_PIN)); // switch off embedded pull-up
	gpio_clear(GPIO(BUSVOODOO_XVEN_PORT), GPIO(BUSVOODOO_XVEN_PIN)); // disable xV voltage regulator

	to_return = true; // all tests are successful
error:
	safe_state(); // set back to safe state
	if (!to_return) {
		printf("the test procedure has been aborted for safety reasons\n");
	}
	
	return to_return;
}

/** test if signals are soldered correctly to the connector pins */
static bool test_pins(void)
{
	bool to_return = false; // test result to return
	safe_state(); // start from safe state with all outputs switched off

	const char* xv_to = "connect I/O pin 4 to "; // most outputs will be tested using xV ADC
	const char* xv_high = "pin 4 is high while it should be low, other pin might be defective\n"; // error message if expect low output is high
	printf("test will proceed automatically once the connection is detected\n");

	// test GND on pin 1 by shorting xV_CTL to ground (through 40k resistor) and measure short
	gpio_set(GPIO(BUSVOODOO_XVCTL_PORT), GPIO(BUSVOODOO_XVCTL_PIN)); // set pin high
	gpio_set_mode(GPIO(BUSVOODOO_XVCTL_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_XVCTL_PIN)); // set xV control pin as output
	printf("%sI/O pin 1\n", xv_to);
	while (rail_voltage(BUSVOODOO_XV_CHANNEL)>0.2) { // wait until pin is shorted to ground
		sleep_ms(200); // wait for user to make connection
	}
	gpio_clear(GPIO(BUSVOODOO_XVCTL_PORT), GPIO(BUSVOODOO_XVCTL_PIN)); // set pin low
	gpio_set_mode(GPIO(BUSVOODOO_XVCTL_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(BUSVOODOO_XVCTL_PIN)); // set xV control pin as output
	led_toggle(); // notify user test is almost almost
	sleep_ms(200); // wait for voltage to settle an debounce
	if (rail_voltage(BUSVOODOO_XV_CHANNEL)>0.2) {
		printf(xv_high);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	gpio_set_mode(GPIO(BUSVOODOO_XVCTL_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO(BUSVOODOO_XVCTL_PIN)); // set xV control pin back to analog input for DAC
	led_toggle(); // notify user test is complete
	
	// test 5V output on pin 2
	gpio_clear(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // enable Vout
	printf("%sI/O pin 2\n", xv_to);
	while (rail_voltage(BUSVOODOO_XV_CHANNEL)<0.2) { // wait until pin is connected
		sleep_ms(200); // wait for user to make connection
	}
	gpio_set(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // disable Vout
	led_toggle(); // notify user test is almost complete
	sleep_ms(200); // wait for voltage to settle and debounce
	if (rail_voltage(BUSVOODOO_XV_CHANNEL)>0.2) {
		printf(xv_high);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	led_toggle(); // notify user test is complete

	// 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", xv_to);
	while (rail_voltage(BUSVOODOO_XV_CHANNEL)<0.2 || rail_voltage(BUSVOODOO_XV_CHANNEL)>3.5) { // wait until pin is connected
		sleep_ms(200); // wait for user to make connection
	}
	gpio_set(GPIO(BUSVOODOO_VOUTEN_PORT), GPIO(BUSVOODOO_VOUTEN_PIN)); // disable Vout
	led_toggle(); // notify user test is almost complete
	sleep_ms(200); // wait for voltage to settle and debounce
	if (rail_voltage(BUSVOODOO_XV_CHANNEL)>0.2) {
		printf(xv_high);
#if DEBUG
		while (true);
#else
		goto error;
#endif
	}
	led_toggle(); // notify user test is complete

	// 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", xv_to, io+4);
				while (rail_voltage(BUSVOODOO_XV_CHANNEL)<0.2) { // wait until pin is connected
					sleep_ms(200); // wait for user to make connection
				}
				gpio_clear(busvoodoo_io_ports[pin], busvoodoo_io_pins[pin]); // set pin low
				led_toggle(); // notify user test is almost complete
				sleep_ms(200); // wait for voltage to settle and debounce
				if (rail_voltage(BUSVOODOO_XV_CHANNEL)>0.2) {
					printf(xv_high);
#if DEBUG
					while (true);
#else
					goto error;
#endif
				}
				gpio_set_mode(busvoodoo_io_ports[pin], GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, busvoodoo_io_pins[pin]); // set pin back to input
				led_toggle(); // notify user test is complete
				break; // stop looking for pin
			}
		}
	}

	if (busvoodoo_full) {
		// test 12V output on RS/CAN pin 1
		double voltage = rail_voltage(BUSVOODOO_3V3_CHANNEL); // get reference voltage
		uint16_t dac_set = BUSVOODOO_12V_SET(5.0)/voltage*4095; // DAC value corresponding to the voltage
		dac_load_data_buffer_single(dac_set, RIGHT12, BUSVOODOO_12VCTL_CHANNEL); // set output so the voltage regulator is set to desired output voltage
		dac_software_trigger(BUSVOODOO_12VCTL_CHANNEL); // transfer the value to the DAC
		dac_enable(BUSVOODOO_12VCTL_CHANNEL); // enable DAC
		gpio_clear(GPIO(BUSVOODOO_12VEN_PORT), GPIO(BUSVOODOO_12VEN_PIN)); // enable 12V voltage regulator
		printf("%sRS/CAN pin 1\n", xv_to);
		while (rail_voltage(BUSVOODOO_XV_CHANNEL)<0.2) { // wait until pin is connected
			sleep_ms(200); // wait for user to make connection
		}
		gpio_set(GPIO(BUSVOODOO_12VEN_PORT), GPIO(BUSVOODOO_12VEN_PIN)); // disable 12V voltage regulator
		dac_disable(BUSVOODOO_12VCTL_CHANNEL); // disable 12V control
		led_toggle(); // notify user test is almost complete
		sleep_ms(200); // wait for voltage to settle (and debounce)
		if (rail_voltage(BUSVOODOO_XV_CHANNEL)>0.2) {
			printf(xv_high);
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
		led_toggle(); // notify user test is complete

		// 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");
		while (gpio_get(GPIO(BUSVOODOO_RS232_RX_PORT), GPIO(BUSVOODOO_RS232_RX_PIN))) { // wait until pin is connected
			sleep_ms(200); // wait for user to make connection
		}
		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
		led_toggle(); // notify user test is almost complete
		sleep_ms(200); // 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("CAN/RS pin 2 is high while it should be set low by pin 3\n");
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
		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
		led_toggle(); // notify user test is complete

		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");
		while (gpio_get(GPIO(BUSVOODOO_RS232_CTS_PORT), GPIO(BUSVOODOO_RS232_CTS_PIN))) { // wait until pin is connected
			sleep_ms(200); // wait for user to make connection
		}
		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
		led_toggle(); // notify user test is almost complete
		sleep_ms(200); // 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("CAN/RS pin 5 is high while it should be set low by pin 4\n");
#if DEBUG
			while (true);
#else
			goto error;
#endif
		}
		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
		led_toggle(); // notify user test is complete

		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
	}
	
	to_return = true; // all tests passed
#if DEBUG
#else
error:
#endif
	safe_state(); // go back to safe state
	if (!to_return) {
		printf("the test procedure has been aborted for safety reasons\n");
	}

	return to_return;
}

/** user input command */
static char command[32] = {0};
/** user input command index */
uint8_t command_i = 0;

/** process user command
 *  @param[in] str user command string (\0 ended)
 */
static void process_command(char* str)
{
	// split command
	const char* delimiter = " ";
	char* word = strtok(str,delimiter);
	if (!word) {
		goto error;
	}
	// parse command
	if (0==strcmp(word,"h") || 0==strcmp(word,"help") || 0==strcmp(word,"?")) {
		printf("unit ID: 0x%08x%08x%08x\n", DESIG_UNIQUE_ID0, DESIG_UNIQUE_ID1, DESIG_UNIQUE_ID2);
		printf("available commands:\n");
		printf("led [on|off|toggle]\n");
	} else if (0==strcmp(word,"l") || 0==strcmp(word,"led")) {
		word = strtok(NULL,delimiter);
		if (!word) {	
			printf("LED is ");
			if (gpio_get(GPIO(LED_PORT), GPIO(LED_PIN))) {
				printf("on\n");
			} else {
				printf("off\n");
			}
		} else if (0==strcmp(word,"on")) {
			led_on(); // switch LED on
			printf("LED switched on\n"); // notify user		
		} else if (0==strcmp(word,"off")) {
			led_off(); // switch LED off
			printf("LED switched off\n"); // notify user
		} else if (0==strcmp(word,"toggle")) {
			led_toggle(); // toggle LED
			printf("LED toggled\n"); // notify user
		} else {
			goto error;
		}
	} else {
		goto error;
	}

	return; // command successfully processed
error:
	printf("command not recognized. enter help to list commands\n");
	return;
}

/** program entry point
 *  this is the firmware function started by the micro-controller
 */
void main(void);
void main(void)
{	
	rcc_clock_setup_in_hse_8mhz_out_72mhz(); // use 8 MHz high speed external clock to generate 72 MHz internal clock

#if DEBUG
	// enable functionalities for easier debug
	DBGMCU_CR |= DBGMCU_CR_IWDG_STOP; // stop independent watchdog counter when code is halted
	DBGMCU_CR |= DBGMCU_CR_WWDG_STOP; // stop window watchdog counter when code is halted
	DBGMCU_CR |= DBGMCU_CR_STANDBY; // allow debug also in standby mode (keep digital part and clock powered)
	DBGMCU_CR |= DBGMCU_CR_STOP; // allow debug also in stop mode (keep clock powered)
	DBGMCU_CR |= DBGMCU_CR_SLEEP; // allow debug also in sleep mode (keep clock powered)
#else
	// setup watchdog to reset in case we get stuck (i.e. when an error occurred)
	iwdg_set_period_ms(WATCHDOG_PERIOD); // set independent watchdog period
	iwdg_start(); // start independent watchdog
#endif

	board_setup(); // setup board
	uart_setup(); // setup USART (for printing)
	usb_cdcacm_setup(); // setup USB CDC ACM (for printing)
	led_blink(0, 1); // switch blue LED on to show firmware is working

/*
#if !(DEBUG)
	// show watchdog information
	printf("watchdog set to (%.2fs)\n",WATCHDOG_PERIOD/1000.0);
	if (FLASH_OBR&FLASH_OBR_OPTERR) {
		printf("option bytes not set in flash: software wachtdog used (not started at reset)\n");
	} else if (FLASH_OBR&FLASH_OBR_WDG_SW) {
		printf("software wachtdog used (not started at reset)\n");
	} else {
		printf("hardware wachtdog used (started at reset)\n");
	}
#endif
*/

	// enable all GPIO domains since we use pins on all ports
	rcc_periph_clock_enable(RCC_GPIOA); // enable clock for all GPIO domains
	rcc_periph_clock_enable(RCC_GPIOB); // enable clock for all GPIO domains
	rcc_periph_clock_enable(RCC_GPIOC); // enable clock for all GPIO domains
	rcc_periph_clock_enable(RCC_GPIOD); // enable clock for all GPIO domains
	safe_state(); // switch off all outputs

	printf("\nwelcome to BusVoodoo ("); // print welcome message
	// check if this BusVoodoo is a full version
	rcc_periph_clock_enable(RCC_ADC12_IN(BUSVOODOO_12V_CHANNEL)); // enable clock for GPIO domain for 12V channel
	gpio_set(ADC12_IN_PORT(BUSVOODOO_12V_CHANNEL), ADC12_IN_PIN(BUSVOODOO_12V_CHANNEL)); // pull ADC 12V high
	gpio_set_mode(ADC12_IN_PORT(BUSVOODOO_12V_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, ADC12_IN_PIN(BUSVOODOO_12V_CHANNEL)); // set 12V channel as digital input with pull-up capabilities
	// on a full version (fully populated board) the ADC 12V signal will be pulled low
	if (gpio_get(ADC12_IN_PORT(BUSVOODOO_12V_CHANNEL), ADC12_IN_PIN(BUSVOODOO_12V_CHANNEL))) { // check is ADC 12V is pulled low
		busvoodoo_full = false;
		printf("light");
	} else {
		busvoodoo_full = true;
		printf("full");
	}
	printf(" version)\n");

	// setup ADC to measure the 5V, 3.3V, xV, and 12V power rails voltages
	rcc_periph_clock_enable(RCC_ADC12_IN(BUSVOODOO_5V_CHANNEL)); // enable clock for GPIO domain for 5V channel
	gpio_set_mode(ADC12_IN_PORT(BUSVOODOO_5V_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(BUSVOODOO_5V_CHANNEL)); // set 5V channel as analogue input for the ADC
	rcc_periph_clock_enable(RCC_ADC12_IN(BUSVOODOO_3V3_CHANNEL)); // enable clock for GPIO domain for 3.3V channel
	gpio_set_mode(ADC12_IN_PORT(BUSVOODOO_3V3_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(BUSVOODOO_3V3_CHANNEL)); // set 3.3V channel as analogue input for the ADC
	rcc_periph_clock_enable(RCC_ADC12_IN(BUSVOODOO_XV_CHANNEL)); // enable clock for GPIO domain for xV channel
	gpio_set_mode(ADC12_IN_PORT(BUSVOODOO_XV_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(BUSVOODOO_XV_CHANNEL)); // set xV channel as analogue input for the ADC
	rcc_periph_clock_enable(RCC_ADC12_IN(BUSVOODOO_12V_CHANNEL)); // enable clock for GPIO domain for 12V channel
	gpio_set_mode(ADC12_IN_PORT(BUSVOODOO_12V_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(BUSVOODOO_12V_CHANNEL)); // set 12V channel as analogue input for the ADC
	rcc_periph_clock_enable(RCC_ADC1); // enable clock for ADC domain
	adc_off(ADC1); // switch off ADC while configuring it
	adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); // use 28.5 cycles to sample (long enough to be stable)
	adc_enable_temperature_sensor(ADC1); // enable internal voltage reference
	adc_enable_external_trigger_regular(ADC1, ADC_CR2_EXTSEL_SWSTART); // use software trigger to start conversion
	uint8_t channels[] = {ADC_CHANNEL17, ADC_CHANNEL(BUSVOODOO_5V_CHANNEL), ADC_CHANNEL(BUSVOODOO_3V3_CHANNEL), ADC_CHANNEL(BUSVOODOO_XV_CHANNEL), ADC_CHANNEL(BUSVOODOO_12V_CHANNEL)}; // voltages to convert: internal, 5V, 3.3V, xV, 12V
	adc_set_regular_sequence(ADC1, LENGTH(channels), channels); // set channels to convert
	adc_enable_discontinuous_mode_regular(ADC1, LENGTH(channels)); // convert all channels	
	adc_power_on(ADC1); // switch on ADC
	sleep_us(1); // wait t_stab for the ADC to stabilize
	adc_reset_calibration(ADC1); // remove previous non-calibration
	adc_calibration(ADC1); // calibrate ADC for less accuracy errors

	// setup DAC to control xV and 12V voltage outputs
	gpio_set_mode(GPIO(BUSVOODOO_XVCTL_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO(BUSVOODOO_XVCTL_PIN)); // set xV pin as analog (the DAC will use it as output)
	rcc_periph_clock_enable(RCC_DAC); // enable clock for DAC domain
	dac_disable(BUSVOODOO_XVCTL_CHANNEL); // disable output to configure it properly
	dac_buffer_enable(BUSVOODOO_XVCTL_CHANNEL); // enable output buffer to be able to drive larger loads (should be per default)
	if (busvoodoo_full) {
		gpio_set_mode(GPIO(BUSVOODOO_12VCTL_PORT), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO(BUSVOODOO_12VCTL_PIN)); // set 12V pin as analog (the DAC will use it as output)
		dac_disable(BUSVOODOO_12VCTL_CHANNEL); // disable output to configure it properly
		dac_buffer_enable(BUSVOODOO_12VCTL_CHANNEL); // enable output buffer to be able to drive larger loads (should be per default)
	}
	dac_set_trigger_source(DAC_CR_TSEL1_SW); // use software to trigger the voltage change
	dac_set_trigger_source(DAC_CR_TSEL2_SW); // use software to trigger the voltage change

	// perform tests
	printf("performing self-test, please follow instructions\n");
	if (!test_self()) { // perform self-test
		led_blink(0.5, 0.5); // show error on LEDs
	} else {
		led_blink(0, 1.0); // show blue OK LED
		printf("self-test succeeded\n"); // notify user
	}

	printf("performing pin test, please follow instructions\n");
	if (!test_pins()) { // perform external test
		led_blink(0.5, 0.5); // show error on LEDs
	} else {
		led_blink(0, 1.0); // show blue OK LED
		printf("pin test succeeded\n"); // notify user
	}

/*
	printf("testing RS-485 port\n");
	rs485_setup();
*/

/*
	printf("testing RS-232 port\n");
	rs232_setup();
*/

/*
	// test CAN
	gpio_clear(GPIOC, GPIO13);
	gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO13);
	gpio_set(GPIOB, GPIO9);
	gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO9); // CAN TX
	gpio_set_mode(GPIOB, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO8); // CAN RX
	gpio_clear(GPIOC, GPIO7);
	gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO7); // CAN EN
	while (true) {
		gpio_toggle(GPIOB, GPIO9);
		sleep_ms(100);
	}
	wait_space();
*/

/*
	printf("testing OLED screen\n");
	i2c_master_setup(false);
	const uint8_t oled_set_mux_ratio[] = {0x00, 0xa8, 0x3f};
	i2c_master_write(0x3c, oled_set_mux_ratio, LENGTH(oled_set_mux_ratio), NULL, 0);
	const uint8_t oled_set_display_offset[] = {0x00, 0xd3, 0x00};
	i2c_master_write(0x3c, oled_set_display_offset, LENGTH(oled_set_display_offset), NULL, 0);
	const uint8_t oled_set_start_line[] = {0x80, 0x40};
	i2c_master_write(0x3c, oled_set_start_line, LENGTH(oled_set_start_line), NULL, 0);
	const uint8_t oled_set_segment_remap[] = {0x80, 0xa0};
	i2c_master_write(0x3c, oled_set_segment_remap, LENGTH(oled_set_segment_remap), NULL, 0);
	const uint8_t oled_set_com_output_scan_direction[] = {0x80, 0xc0};
	i2c_master_write(0x3c, oled_set_com_output_scan_direction, LENGTH(oled_set_com_output_scan_direction), NULL, 0);
	const uint8_t oled_set_com_pins_hardware_configuration[] = {0x00, 0xda, 0x02};
	i2c_master_write(0x3c, oled_set_com_pins_hardware_configuration, LENGTH(oled_set_com_pins_hardware_configuration), NULL, 0);
	const uint8_t oled_set_contrast_control[] = {0x00, 0x81, 0x7f};
	i2c_master_write(0x3c, oled_set_contrast_control, LENGTH(oled_set_contrast_control), NULL, 0);
	const uint8_t oled_entire_display_on[] = {0x80, 0xa5};
	i2c_master_write(0x3c, oled_entire_display_on, LENGTH(oled_entire_display_on), NULL, 0);
	const uint8_t oled_normal_display[] = {0x80, 0xa6};
	i2c_master_write(0x3c, oled_normal_display, LENGTH(oled_normal_display), NULL, 0);
	const uint8_t oled_set_osc_frequency[] = {0x00, 0xd5, 0x80};
	i2c_master_write(0x3c, oled_set_osc_frequency, LENGTH(oled_set_osc_frequency), NULL, 0);
	const uint8_t oled_enable_charge_pump_regulator[] = {0x00, 0x8d, 0x14};
	i2c_master_write(0x3c, oled_enable_charge_pump_regulator, LENGTH(oled_enable_charge_pump_regulator), NULL, 0);
	const uint8_t oled_display_on[] = {0x80, 0xaf};
	i2c_master_write(0x3c, oled_display_on, LENGTH(oled_display_on), NULL, 0);
*/

	// main loop
	printf("command input: ready\n");
	bool action = false; // if an action has been performed don't go to sleep
	button_flag = false; // reset button flag
	char c = '\0'; // to store received character
	bool char_flag = false; // a new character has been received
	while (true) { // infinite loop
		iwdg_reset(); // kick the dog
		while (uart_received) { // data received over UART
			action = true; // action has been performed
			led_toggle(); // toggle LED
			c = uart_getchar(); // store receive character
			char_flag = true; // notify character has been received
		}
		while (usb_cdcacm_received) { // data received over USB
			action = true; // action has been performed
			led_toggle(); // toggle LED
			c = usb_cdcacm_getchar(); // store receive character
			char_flag = true; // notify character has been received
		}
		while (char_flag) { // user data received
			char_flag = false; // reset flag
			action = true; // action has been performed
			printf("%c",c); // echo receive character
			if (c=='\r' || c=='\n') { // end of command received
				if (command_i>0) { // there is a command to process
					command[command_i] = 0; // end string
					command_i = 0; // prepare for next command
					process_command(command); // process user command
				}
			} else { // user command input
				command[command_i] = c; // save command input
				if (command_i<LENGTH(command)-2) { // verify if there is place to save next character
					command_i++; // save next character
				}
			}
		}
		while (button_flag) { // user pressed button
			action = true; // action has been performed
			printf("button pressed\n");
			led_toggle(); // toggle LED
			for (uint32_t i=0; i<1000000; i++) { // wait a bit to remove noise and double trigger
				__asm__("nop");
			}
			button_flag = false; // reset flag
		}
		if (action) { // go to sleep if nothing had to be done, else recheck for activity
			action = false;
		} else {
			__WFI(); // go to sleep
		}
	} // main loop
}