900 lines
36 KiB
C
900 lines
36 KiB
C
/** input/output pin identifier
|
|
* @file
|
|
* @author King Kévin <kingkevin@cuvoodoo.info>
|
|
* @copyright SPDX-License-Identifier: GPL-3.0-or-later
|
|
* @date 2016-2021
|
|
*/
|
|
|
|
/* standard libraries */
|
|
#include <stdint.h> // standard integer types
|
|
#include <stdlib.h> // standard utilities
|
|
#include <string.h> // string utilities
|
|
#include <time.h> // date/time utilities
|
|
#include <ctype.h> // utilities to check chars
|
|
#include <math.h> // rounding 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/rtc.h> // real time clock utilities
|
|
#include <libopencm3/stm32/iwdg.h> // independent watchdog utilities
|
|
#include <libopencm3/stm32/dbgmcu.h> // debug utilities
|
|
#include <libopencm3/stm32/desig.h> // design utilities
|
|
#include <libopencm3/stm32/flash.h> // flash utilities
|
|
#include <libopencm3/stm32/adc.h> // ADC 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 "terminal.h" // handle the terminal interface
|
|
#include "menu.h" // menu utilities
|
|
|
|
/** watchdog period in ms */
|
|
#define WATCHDOG_PERIOD 10000
|
|
|
|
/** wakeup frequency (i.e. least number of times per second to perform the main loop) */
|
|
#define WAKEUP_FREQ 16
|
|
|
|
/** @defgroup main_flags flag set in interrupts to be processed in main task
|
|
* @{
|
|
*/
|
|
static volatile bool wakeup_flag = false; /**< flag set when wakeup timer triggered */
|
|
static volatile bool second_flag = false; /**< flag set when a second passed */
|
|
/** @} */
|
|
|
|
/** number of seconds since boot */
|
|
static uint32_t boot_time = 0;
|
|
|
|
#define TARGET_CHANNEL 6 /**< PA6/ADC1_IN6 used to measure target voltage */
|
|
#define SIGNAL_CHANNEL 1 /**< PA1/ADC1_IN1 used to measure signal voltage */
|
|
const uint8_t adc_channels[] = {ADC_CHANNEL17, ADC_CHANNEL(TARGET_CHANNEL), ADC_CHANNEL(SIGNAL_CHANNEL)}; /**< voltages to convert (channel 17 = internal voltage reference) */
|
|
|
|
#define TARGET_3V_PIN PC13 /**< pin to supply target voltage with 3.3V (controlling gate of pMOS) */
|
|
#define TARGET_RST_PIN PA0 /**< pin to reset target board */
|
|
#define SIGNAL_PD_PIN PA4 /**< pin to pull signal low for voltage measurement */
|
|
#define SIGNAL_PU_PIN PA5 /**< pin to pull signal to target voltage (controlling gate of pMOS) */
|
|
#define SHIFT_EN_PIN PC14 /**< pin to provide target voltage to LV side of voltage shifter (pulling them high through 10 kO) */
|
|
|
|
#define MUX_EN_PIN PC15 /**< pin to enable analog multiplexer (active low) */
|
|
#define MUX_S0_PIN PA7 /**< pin to set S0 bit of analog multiplexer */
|
|
#define MUX_S1_PIN PB0 /**< pin to set S1 bit of analog multiplexer */
|
|
#define MUX_S2_PIN PB1 /**< pin to set S2 bit of analog multiplexer */
|
|
#define MUX_S3_PIN PB2 /**< pin to set S3 bit of analog multiplexer */
|
|
|
|
#define CHANNEL_NUMBERS 16 /**< number of target signals */
|
|
static const uint32_t channel_ports[] = {GPIO_PORT(PB12), GPIO_PORT(PB13), GPIO_PORT(PB14), GPIO_PORT(PB15), GPIO_PORT(PA8), GPIO_PORT(PA9), GPIO_PORT(PA10), GPIO_PORT(PA15), GPIO_PORT(PB3), GPIO_PORT(PB4), GPIO_PORT(PB5), GPIO_PORT(PB6), GPIO_PORT(PB7), GPIO_PORT(PB8), GPIO_PORT(PB9), GPIO_PORT(PB10)}; /**< GPIO ports for signal pin */
|
|
static const uint32_t channel_pins[] = {GPIO_PIN(PB12), GPIO_PIN(PB13), GPIO_PIN(PB14), GPIO_PIN(PB15), GPIO_PIN(PA8), GPIO_PIN(PA9), GPIO_PIN(PA10), GPIO_PIN(PA15), GPIO_PIN(PB3), GPIO_PIN(PB4), GPIO_PIN(PB5), GPIO_PIN(PB6), GPIO_PIN(PB7), GPIO_PIN(PB8), GPIO_PIN(PB9), GPIO_PIN(PB10)}; /**< GPIO pins for signal pin */
|
|
static uint8_t channel_start = 0; /**< first signal of range to probe */
|
|
static uint8_t channel_stop = CHANNEL_NUMBERS - 1; /**< last signal of range to probe */
|
|
|
|
size_t putc(char c)
|
|
{
|
|
size_t length = 0; // number of characters printed
|
|
static char last_c = 0; // to remember on which character we last sent
|
|
if ('\n' == c) { // send carriage return (CR) + line feed (LF) newline for each LF
|
|
if ('\r' != last_c) { // CR has not already been sent
|
|
usb_cdcacm_putchar('\r'); // send CR over USB
|
|
length++; // remember we printed 1 character
|
|
}
|
|
}
|
|
usb_cdcacm_putchar(c); // send byte over USB
|
|
length++; // remember we printed 1 character
|
|
last_c = c; // remember last character
|
|
return length; // return number of characters printed
|
|
}
|
|
|
|
// only print when debug is enabled
|
|
#if DEBUG
|
|
#define puts_debug(x) puts(x)
|
|
#else
|
|
#define puts_debug(x) {}
|
|
#endif
|
|
|
|
/** print float with fixed precision
|
|
* @param[in] fpu float to print
|
|
* @param[in] precision number of digits after comma to print
|
|
* @note %f is used to force scientific notation
|
|
*/
|
|
static void print_fpu(double fpu, uint8_t precision)
|
|
{
|
|
uint32_t multiplier = 1;
|
|
for (uint8_t i = 0; i < precision; i++) {
|
|
multiplier *= 10;
|
|
}
|
|
double to_print = round(fpu * multiplier);
|
|
printf("%d.", (int32_t)to_print / multiplier);
|
|
char decimal[32];
|
|
snprintf(decimal, LENGTH(decimal), "%u", abs(to_print) % multiplier);
|
|
if (strlen(decimal) > precision) {
|
|
decimal[precision] = 0;
|
|
}
|
|
for (uint8_t i = strlen(decimal); i < precision; i++) {
|
|
putc('0');
|
|
}
|
|
puts(decimal);
|
|
}
|
|
|
|
/** get RCC from corresponding port
|
|
* @param[in] port port address
|
|
* @return RCC address corresponding to port
|
|
*/
|
|
static uint32_t port2rcc(uint32_t port)
|
|
{
|
|
uint32_t rcc = 0;
|
|
switch (port) {
|
|
case GPIOA:
|
|
rcc = RCC_GPIOA;
|
|
break;
|
|
case GPIOB:
|
|
rcc = RCC_GPIOB;
|
|
break;
|
|
case GPIOC:
|
|
rcc = RCC_GPIOC;
|
|
break;
|
|
case GPIOD:
|
|
rcc = RCC_GPIOD;
|
|
break;
|
|
case GPIOE:
|
|
rcc = RCC_GPIOE;
|
|
break;
|
|
case GPIOF:
|
|
rcc = RCC_GPIOF;
|
|
break;
|
|
case GPIOG:
|
|
rcc = RCC_GPIOG;
|
|
break;
|
|
default: // unknown port
|
|
while (true); // halt firmware
|
|
break;
|
|
}
|
|
return rcc;
|
|
}
|
|
|
|
/** measure target and signal voltages
|
|
* @return voltages of channels
|
|
*/
|
|
static float* measure_voltages(void)
|
|
{
|
|
static float voltages[LENGTH(adc_channels)]; // to store and return the voltages
|
|
|
|
// read lid temperature using ADC
|
|
ADC_SR(ADC1) = 0; // reset flags
|
|
uint16_t adc_values[LENGTH(adc_channels)];
|
|
for (uint8_t i = 0; i < LENGTH(adc_channels); i++) {
|
|
adc_start_conversion_regular(ADC1); // start conversion (using trigger)
|
|
while (!adc_eoc(ADC1)); // wait until conversion finished
|
|
adc_values[i] = adc_read_regular(ADC1); // read voltage value (clears flag)
|
|
voltages[i] = adc_values[i] * 1.21 / adc_values[0]; // use 1.21 V internal voltage reference to get ADC voltage
|
|
}
|
|
voltages[1] *= 2.0; // the is a /2 voltage divider for target voltage
|
|
return voltages;
|
|
}
|
|
|
|
/** select channel of multiplexer
|
|
* @param[in] channel channel to select, or -1 to disable multiplexer
|
|
*/
|
|
static void mux_select(int8_t channel)
|
|
{
|
|
gpio_set(GPIO_PORT(MUX_EN_PIN), GPIO_PIN(MUX_EN_PIN)); // disable multiplexer while we are switching
|
|
if (channel < 0 || channel > 15 || (channel > CHANNEL_NUMBERS - 1)) {
|
|
return; // no channel to select
|
|
}
|
|
// select channel using bit pattern
|
|
if (channel & 0x1) {
|
|
gpio_set(GPIO_PORT(MUX_S0_PIN), GPIO_PIN(MUX_S0_PIN));
|
|
} else {
|
|
gpio_clear(GPIO_PORT(MUX_S0_PIN), GPIO_PIN(MUX_S0_PIN));
|
|
}
|
|
if (channel & 0x2) {
|
|
gpio_set(GPIO_PORT(MUX_S1_PIN), GPIO_PIN(MUX_S1_PIN));
|
|
} else {
|
|
gpio_clear(GPIO_PORT(MUX_S1_PIN), GPIO_PIN(MUX_S1_PIN));
|
|
}
|
|
if (channel & 0x4) {
|
|
gpio_set(GPIO_PORT(MUX_S2_PIN), GPIO_PIN(MUX_S2_PIN));
|
|
} else {
|
|
gpio_clear(GPIO_PORT(MUX_S2_PIN), GPIO_PIN(MUX_S2_PIN));
|
|
}
|
|
if (channel & 0x8) {
|
|
gpio_set(GPIO_PORT(MUX_S3_PIN), GPIO_PIN(MUX_S3_PIN));
|
|
} else {
|
|
gpio_clear(GPIO_PORT(MUX_S3_PIN), GPIO_PIN(MUX_S3_PIN));
|
|
}
|
|
gpio_clear(GPIO_PORT(MUX_EN_PIN), GPIO_PIN(MUX_EN_PIN)); // enable multiplexer
|
|
}
|
|
|
|
// menu commands
|
|
|
|
/** measure and print target voltage
|
|
* @param[in] argument 0 to no provide power, 3 to provide 3.3V
|
|
*/
|
|
static void command_target_voltage(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
|
|
// set voltage
|
|
if (argument) { // if argument is provided
|
|
const uint8_t voltage = *(uint32_t*)argument; // get target voltage
|
|
switch (voltage) {
|
|
case 0:
|
|
gpio_set(GPIO_PORT(TARGET_3V_PIN), GPIO_PIN(TARGET_3V_PIN)); // disable 3V output
|
|
break;
|
|
case 3:
|
|
gpio_clear(GPIO_PORT(TARGET_3V_PIN), GPIO_PIN(TARGET_3V_PIN)); // enable 3V output
|
|
break;
|
|
default:
|
|
puts("unknown voltage to set\n");
|
|
break;
|
|
}
|
|
sleep_us(100); // wait a bit for voltage to settle
|
|
}
|
|
|
|
// show voltage output
|
|
if (!gpio_get(GPIO_PORT(TARGET_3V_PIN), GPIO_PIN(TARGET_3V_PIN))) {
|
|
puts("target voltage set to 3.3 V\n");
|
|
} else {
|
|
puts("target voltage externally provided\n");
|
|
}
|
|
|
|
float* voltages = measure_voltages(); // measure voltages
|
|
puts("target voltage: ");
|
|
print_fpu(voltages[1], 2);
|
|
puts(" V");
|
|
if (voltages[1] < 1.0) {
|
|
puts(" (warning: target voltage seems not connected)");
|
|
}
|
|
putc('\n');
|
|
}
|
|
|
|
/** configure or reset target
|
|
* @param[in] argument 1 to assert reset, 0 to release reset, ODL to set reset pin to open-drain active low, ODH to set reset pin to open-drain active high, PPL to set reset pin to push-pull active low, PPH to set reset pin to push-pull active high
|
|
*/
|
|
static void command_target_reset(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
static bool active_low = true; // if the reset is active low or high
|
|
|
|
// set reset mode
|
|
if (argument) { // if argument is provided
|
|
if (0 == strcmp("0", argument)) { // release reset
|
|
if (active_low) {
|
|
gpio_set(GPIO_PORT(TARGET_RST_PIN), GPIO_PIN(TARGET_RST_PIN));
|
|
} else {
|
|
gpio_clear(GPIO_PORT(TARGET_RST_PIN), GPIO_PIN(TARGET_RST_PIN));
|
|
}
|
|
} else if (0 == strcmp("1", argument)) { // assert reset
|
|
if (active_low) {
|
|
gpio_clear(GPIO_PORT(TARGET_RST_PIN), GPIO_PIN(TARGET_RST_PIN));
|
|
} else {
|
|
gpio_set(GPIO_PORT(TARGET_RST_PIN), GPIO_PIN(TARGET_RST_PIN));
|
|
}
|
|
} else if (0 == strcmp("ODL", argument)) { // set reset to open-drain active low
|
|
active_low = true; // remember we are active low
|
|
gpio_set_output_options(GPIO_PORT(TARGET_RST_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(TARGET_RST_PIN)); // set output as open-drain
|
|
} else if (0 == strcmp("ODH", argument)) { // set reset to open-drain active high
|
|
active_low = false; // remember we are active high
|
|
gpio_set_output_options(GPIO_PORT(TARGET_RST_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(TARGET_RST_PIN)); // set output as open-drain
|
|
} else if (0 == strcmp("PPL", argument)) { // set reset to push-pull active low
|
|
active_low = true; // remember we are active low
|
|
gpio_set_output_options(GPIO_PORT(TARGET_RST_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(TARGET_RST_PIN)); // set output as push-pull
|
|
} else if (0 == strcmp("PPH", argument)) { // set reset to push-pull active high
|
|
active_low = false; // remember we are active high
|
|
gpio_set_output_options(GPIO_PORT(TARGET_RST_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(TARGET_RST_PIN)); // set output as push-pull
|
|
} else {
|
|
printf("unknown argument: %s\n", argument);
|
|
}
|
|
}
|
|
|
|
const bool open_drain = (GPIO_OTYPER(GPIO_PORT(TARGET_RST_PIN)) & GPIO_PIN(TARGET_RST_PIN)); // if the output is configured as open drain (else it's push-pull)
|
|
printf("reset pin set to %s active %s\n", open_drain ? "open-drain" : "push-pull", active_low ? "low" : "high");
|
|
if (gpio_get(GPIO_PORT(TARGET_RST_PIN), GPIO_PIN(TARGET_RST_PIN))) {
|
|
if (active_low) {
|
|
puts("reset released\n");
|
|
} else {
|
|
puts("reset asserted\n");
|
|
}
|
|
} else {
|
|
if (active_low) {
|
|
puts("reset asserted\n");
|
|
} else {
|
|
puts("reset released\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/** identify if signal is an input or output
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_types(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
command_target_voltage(NULL); // print target voltage (also sets measurement conditions)
|
|
float* voltages = measure_voltages(); // measure voltages
|
|
if (voltages[1] < 0.5) { // check target voltage connection
|
|
puts("connect target voltage to test channel type\n");
|
|
return;
|
|
}
|
|
|
|
puts("measuring voltage on channels when pulled up and down using 2 kOhm resistor\n");
|
|
puts("channel no-pull pull-down pull-up type\n");
|
|
|
|
// just to be sure, reset measurement conditions
|
|
gpio_set(GPIO_PORT(SIGNAL_PD_PIN), GPIO_PIN(SIGNAL_PD_PIN)); // ensure pull-down is not active
|
|
gpio_set(GPIO_PORT(SIGNAL_PU_PIN), GPIO_PIN(SIGNAL_PU_PIN)); // ensure pull-up is not active
|
|
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
printf("CH%02u", i);
|
|
puts(" ");
|
|
|
|
mux_select(i); // select the channel
|
|
voltages = measure_voltages(); // measure raw voltages
|
|
print_fpu(voltages[2], 2);
|
|
const float raw = voltages[2]; // remember un-pulled voltage
|
|
puts(" ");
|
|
|
|
gpio_clear(GPIO_PORT(SIGNAL_PD_PIN), GPIO_PIN(SIGNAL_PD_PIN)); // pull down signal
|
|
sleep_us(10); // wait a tiny bit for voltage to settle
|
|
voltages = measure_voltages(); // measure pulled down voltages
|
|
gpio_set(GPIO_PORT(SIGNAL_PD_PIN), GPIO_PIN(SIGNAL_PD_PIN)); // remove pull-down
|
|
voltages[2] *= 2.0; // pulling creates a voltage divider (to ground)
|
|
const bool low = (voltages[2] < 0.5); // remember if we were able to pull it down
|
|
const float pullup = (2000.0 * (raw - voltages[2]) / voltages[2]) / 1000.0; // estimate external pull-up
|
|
print_fpu(voltages[2], 2);
|
|
puts(" ");
|
|
|
|
gpio_clear(GPIO_PORT(SIGNAL_PU_PIN), GPIO_PIN(SIGNAL_PU_PIN)); // pull up signal
|
|
sleep_us(10); // wait a tiny bit for voltage to settle
|
|
voltages = measure_voltages(); // measure pulled up voltages
|
|
gpio_set(GPIO_PORT(SIGNAL_PU_PIN), GPIO_PIN(SIGNAL_PU_PIN)); // remove pull-up
|
|
voltages[2] = voltages[2] * 2.0 - voltages[1]; // pulling creates a voltage divider (to target)
|
|
const bool high = (voltages[2] > 3.0 || voltages[2] > voltages[1] * 0.7); // remember if we were able to pull it up
|
|
const float pulldown = (2000.0 * voltages[2] / (voltages[1] - voltages[2])) / 1000.0; // estimate external pull-down
|
|
print_fpu(voltages[2], 2);
|
|
puts(" ");
|
|
|
|
if (pullup >= 0.9 && pullup < 100.0 && (pulldown <= 0.9 || pulldown > 100.0)) {
|
|
printf("pulled-up (%u kOhm)", (uint32_t)round(pullup));
|
|
} else if (pulldown >= 0.9 && pulldown < 100.0 && (pullup <= 0.9 || pullup > 100.0)) {
|
|
printf("pulled-down (%u kOhm)", (uint32_t)round(pulldown));
|
|
} else if (low && high) {
|
|
puts("floating");
|
|
} else if (low) {
|
|
puts("low");
|
|
} else if (high) {
|
|
puts("high");
|
|
} else {
|
|
puts("unknown");
|
|
}
|
|
putc('\n');
|
|
}
|
|
mux_select(-1); // disable multiplexer
|
|
}
|
|
|
|
/** monitor the channels for activity
|
|
* @param[in] argument 0 to pull low, 1 to pull high
|
|
*/
|
|
static void command_monitor(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
|
|
// set input pull
|
|
if (NULL == argument) {
|
|
puts("channels are left floating\n");
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
gpio_mode_setup(channel_ports[i], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[i]); // set to floating
|
|
}
|
|
} else {
|
|
const uint32_t pull = *(uint32_t*)argument; // get pull argument
|
|
if (0 == pull) {
|
|
puts("channels are pulled low using internal 40 kOhm resistor\n");
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
gpio_mode_setup(channel_ports[i], GPIO_MODE_INPUT, GPIO_PUPD_PULLDOWN, channel_pins[i]); // set to pull down
|
|
}
|
|
} else if (1 == pull) {
|
|
puts("channels are pulled high to 3.3V using internal 40 kOhm resistor\n");
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
gpio_mode_setup(channel_ports[i], GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, channel_pins[i]); // set to pull up
|
|
}
|
|
} else {
|
|
puts("unknown pull parameter. use 0 for low and 3 for 3.3V high\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// collect pins we want to monitor
|
|
uint16_t gpioa_mask = 0; // which pins on GPIOA we want to monitor
|
|
uint16_t gpiob_mask = 0; // which pins on GPIOB we want to monitor
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
if (GPIOA == channel_ports[i]) {
|
|
gpioa_mask |= channel_pins[i];
|
|
} else if (GPIOB == channel_ports[i]) {
|
|
gpiob_mask |= channel_pins[i];
|
|
} else {
|
|
printf("unknown port for CH%02u\n", i);
|
|
}
|
|
}
|
|
|
|
// get initial state
|
|
puts("press any key to stop monitoring\n");
|
|
puts("time (s) ");
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
printf("%02u ", i);
|
|
}
|
|
puts("\n");
|
|
|
|
// start monitoring
|
|
uint16_t gpioa_data = UINT16_MAX;
|
|
uint16_t gpiob_data = UINT16_MAX;
|
|
while (!user_input_available) { // run until user breaks it
|
|
// time to do periodic checks
|
|
if (wakeup_flag || second_flag) {
|
|
iwdg_reset(); // kick the dog
|
|
wakeup_flag = false; // clear flag
|
|
second_flag = false; // clear flag
|
|
}
|
|
// check is there is a change on a channel
|
|
const uint16_t gpioa_new = gpio_get(GPIOA, gpioa_mask);
|
|
const uint16_t gpiob_new = gpio_get(GPIOB, gpioa_mask);
|
|
if (gpioa_new != gpioa_data || gpiob_new != gpiob_data) {
|
|
// print data
|
|
puts("0000.000");
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
const uint16_t port = (GPIOA == channel_ports[i] ? gpioa_new : gpiob_new);
|
|
const uint8_t high = ((port & channel_pins[i]) ? 1 : 0);
|
|
if (high) {
|
|
puts(" 1");
|
|
} else {
|
|
puts(" 0");
|
|
}
|
|
}
|
|
puts("\n");
|
|
// save change
|
|
gpioa_data = gpioa_new;
|
|
gpiob_data = gpiob_new;
|
|
// do we need a rate limit?
|
|
}
|
|
}
|
|
user_input_get(); // clean input
|
|
|
|
// set all back to input
|
|
for (uint8_t i = channel_start; i <= channel_stop; i++) {
|
|
gpio_mode_setup(channel_ports[i], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[i]); // ensure pin is floating input
|
|
}
|
|
}
|
|
|
|
/** set first channel of range to scan
|
|
* @param[in] argument optional pointer to first channel number
|
|
*/
|
|
static void command_channel_start(void* argument)
|
|
{
|
|
if (argument) {
|
|
const uint32_t channel = *(uint32_t*)argument;
|
|
if (channel < CHANNEL_NUMBERS && channel < channel_stop) {
|
|
channel_start = channel;
|
|
}
|
|
}
|
|
printf("channels to probe: %u-%u\n", channel_start, channel_stop);
|
|
}
|
|
|
|
/** set last channel of range to scan
|
|
* @param[in] argument optional pointer to last channel number
|
|
*/
|
|
static void command_channel_stop(void* argument)
|
|
{
|
|
if (argument) {
|
|
const uint32_t channel = *(uint32_t*)argument;
|
|
if (channel < CHANNEL_NUMBERS && channel > channel_start) {
|
|
channel_stop = channel;
|
|
}
|
|
}
|
|
printf("channels to probe: %u-%u\n", channel_start, channel_stop);
|
|
}
|
|
|
|
/** display available commands
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_help(void* argument);
|
|
|
|
/** show software and hardware version
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_version(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
printf("firmware date: %04u-%02u-%02u\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY); // show firmware build date
|
|
printf("device serial: %08x%08x%08x\n", DESIG_UNIQUE_ID2, DESIG_UNIQUE_ID1, DESIG_UNIQUE_ID0); // show complete serial (different than the one used for USB)
|
|
}
|
|
|
|
/** convert RTC date/time to number of seconds
|
|
* @return number of seconds since 2000-01-01 00:00:00
|
|
* @warning for simplicity I consider every month to have 31 days
|
|
*/
|
|
static uint32_t rtc_to_seconds(void)
|
|
{
|
|
rtc_wait_for_synchro(); // wait until date/time is synchronised
|
|
const uint8_t year = ((RTC_DR >> RTC_DR_YT_SHIFT) & RTC_DR_YT_MASK) * 10 + ((RTC_DR >> RTC_DR_YU_SHIFT) & RTC_DR_YU_MASK); // get year
|
|
uint8_t month = ((RTC_DR >> RTC_DR_MT_SHIFT) & RTC_DR_MT_MASK) * 10 + ((RTC_DR >> RTC_DR_MU_SHIFT) & RTC_DR_MU_MASK); // get month
|
|
if (month > 0) { // month has been initialized, but starts with 1
|
|
month--; // fix for calculation
|
|
}
|
|
uint8_t day = ((RTC_DR >> RTC_DR_DT_SHIFT) & RTC_DR_DT_MASK) * 10 + ((RTC_DR >> RTC_DR_DU_SHIFT) & RTC_DR_DU_MASK); // get day
|
|
if (day > 0) { // day has been initialized, but starts with 1
|
|
day--; // fix for calculation
|
|
}
|
|
const uint8_t hour = ((RTC_TR >> RTC_TR_HT_SHIFT) & RTC_TR_HT_MASK) * 10 + ((RTC_TR >> RTC_TR_HU_SHIFT) & RTC_TR_HU_MASK); // get hours
|
|
const uint8_t minute = ((RTC_TR >> RTC_TR_MNT_SHIFT) & RTC_TR_MNT_MASK) * 10 + ((RTC_TR >> RTC_TR_MNU_SHIFT) & RTC_TR_MNU_MASK); // get minutes
|
|
const uint8_t second = ((RTC_TR >> RTC_TR_ST_SHIFT) & RTC_TR_ST_MASK) * 10 + ((RTC_TR >> RTC_TR_SU_SHIFT) & RTC_TR_SU_MASK); // get seconds
|
|
const uint32_t seconds = ((((((((year * 12) + month) * 31) + day) * 24) + hour) * 60) + minute) * 60 + second; // convert to number of seconds
|
|
return seconds;
|
|
}
|
|
|
|
/** show uptime
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_uptime(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
const uint32_t uptime = rtc_to_seconds() - boot_time; // get time from internal RTC
|
|
printf("uptime: %u.%02u:%02u:%02u\n", uptime / (24 * 60 * 60), (uptime / (60 * 60)) % 24, (uptime / 60) % 60, uptime % 60);
|
|
}
|
|
|
|
/** reset board
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_reset(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
scb_reset_system(); // reset device
|
|
while (true); // wait for the reset to happen
|
|
}
|
|
|
|
/** switch to system memory (e.g. embedded bootloader)
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_system(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
system_memory(); // jump to system memory
|
|
}
|
|
|
|
/** switch to DFU bootloader
|
|
* @param[in] argument no argument required
|
|
*/
|
|
static void command_bootloader(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
dfu_bootloader(); // start DFU bootloader
|
|
}
|
|
|
|
/** list of all supported commands */
|
|
static const struct menu_command_t menu_commands[] = {
|
|
{
|
|
.shortcut = 'h',
|
|
.name = "help",
|
|
.command_description = "display help",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_help,
|
|
},
|
|
{
|
|
.shortcut = 'V',
|
|
.name = "version",
|
|
.command_description = "show software and hardware version",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_version,
|
|
},
|
|
{
|
|
.shortcut = 'u',
|
|
.name = "uptime",
|
|
.command_description = "show uptime",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_uptime,
|
|
},
|
|
{
|
|
.shortcut = 'R',
|
|
.name = "reset_board",
|
|
.command_description = "reset board",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_reset,
|
|
},
|
|
{
|
|
.shortcut = 's',
|
|
.name = "system",
|
|
.command_description = "reboot into system memory",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_system,
|
|
},
|
|
{
|
|
.shortcut = 'b',
|
|
.name = "bootloader",
|
|
.command_description = "reboot into DFU bootloader",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_bootloader,
|
|
},
|
|
{
|
|
.shortcut = 'v',
|
|
.name = "voltage",
|
|
.command_description = "set/measure target voltage",
|
|
.argument = MENU_ARGUMENT_UNSIGNED,
|
|
.argument_description = "[0|3|5]",
|
|
.command_handler = &command_target_voltage,
|
|
},
|
|
{
|
|
.shortcut = 'r',
|
|
.name = "reset",
|
|
.command_description = "configure/reset target board",
|
|
.argument = MENU_ARGUMENT_STRING,
|
|
.argument_description = "[0|1|ODL|ODH|PPL|PPH]",
|
|
.command_handler = &command_target_reset,
|
|
},
|
|
{
|
|
.shortcut = 't',
|
|
.name = "type",
|
|
.command_description = "identify signal types",
|
|
.argument = MENU_ARGUMENT_NONE,
|
|
.argument_description = NULL,
|
|
.command_handler = &command_types,
|
|
},
|
|
{
|
|
.shortcut = 'm',
|
|
.name = "monitor",
|
|
.command_description = "monitor channel activity",
|
|
.argument = MENU_ARGUMENT_UNSIGNED,
|
|
.argument_description = "[0|3]",
|
|
.command_handler = &command_monitor,
|
|
},
|
|
{
|
|
.shortcut = 'c',
|
|
.name = "start",
|
|
.command_description = "first channel of range to probe",
|
|
.argument = MENU_ARGUMENT_UNSIGNED,
|
|
.argument_description = "[ch]",
|
|
.command_handler = &command_channel_start,
|
|
},
|
|
{
|
|
.shortcut = 'C',
|
|
.name = "stop",
|
|
.command_description = "last channel of range to probe",
|
|
.argument = MENU_ARGUMENT_UNSIGNED,
|
|
.argument_description = "[ch]",
|
|
.command_handler = &command_channel_stop,
|
|
},
|
|
};
|
|
|
|
static void command_help(void* argument)
|
|
{
|
|
(void)argument; // we won't use the argument
|
|
printf("available commands:\n");
|
|
menu_print_commands(menu_commands, LENGTH(menu_commands)); // print global commands
|
|
}
|
|
|
|
/** process user command
|
|
* @param[in] str user command string (\0 ended)
|
|
*/
|
|
static void process_command(char* str)
|
|
{
|
|
// ensure actions are available
|
|
if (NULL == menu_commands || 0 == LENGTH(menu_commands)) {
|
|
return;
|
|
}
|
|
// don't handle empty lines
|
|
if (!str || 0 == strlen(str)) {
|
|
return;
|
|
}
|
|
bool command_handled = false;
|
|
if (!command_handled) {
|
|
command_handled = menu_handle_command(str, menu_commands, LENGTH(menu_commands)); // try if this is not a global command
|
|
}
|
|
if (!command_handled) {
|
|
printf("command not recognized. enter help to list commands\n");
|
|
}
|
|
}
|
|
|
|
/** program entry point
|
|
* this is the firmware function started by the micro-controller
|
|
*/
|
|
void main(void);
|
|
void main(void)
|
|
{
|
|
|
|
#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
|
|
usb_cdcacm_setup(); // setup USB CDC ACM (for printing)
|
|
puts("\nwelcome to the CuVoodoo I/O finder\n"); // print welcome message
|
|
|
|
#if DEBUG
|
|
// show reset cause
|
|
if (RCC_CSR & (RCC_CSR_LPWRRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_IWDGRSTF | RCC_CSR_SFTRSTF | RCC_CSR_PORRSTF | RCC_CSR_PINRSTF)) {
|
|
puts("reset cause(s):");
|
|
if (RCC_CSR & RCC_CSR_LPWRRSTF) {
|
|
puts(" low-power");
|
|
}
|
|
if (RCC_CSR & RCC_CSR_WWDGRSTF) {
|
|
puts(" window-watchdog");
|
|
}
|
|
if (RCC_CSR & RCC_CSR_IWDGRSTF) {
|
|
puts(" independent-watchdog");
|
|
}
|
|
if (RCC_CSR & RCC_CSR_SFTRSTF) {
|
|
puts(" software");
|
|
}
|
|
if (RCC_CSR & RCC_CSR_PORRSTF) {
|
|
puts(" POR/PDR");
|
|
}
|
|
if (RCC_CSR & RCC_CSR_PINRSTF) {
|
|
puts(" pin");
|
|
}
|
|
putc('\n');
|
|
RCC_CSR |= RCC_CSR_RMVF; // clear reset flags
|
|
}
|
|
#endif
|
|
|
|
// setup RTC
|
|
puts_debug("setup RTC: ");
|
|
rcc_periph_clock_enable(RCC_RTC); // enable clock for RTC peripheral
|
|
rcc_osc_on(RCC_LSI); // enable LSI clock
|
|
while (!rcc_is_osc_ready(RCC_LSI)); // wait until clock is ready
|
|
if (!(RCC_BDCR && RCC_BDCR_RTCEN)) { // the RTC has not been configured yet
|
|
pwr_disable_backup_domain_write_protect(); // disable backup protection so we can set the RTC clock source
|
|
rtc_unlock(); // enable writing RTC registers
|
|
rtc_set_prescaler(250, 128); // set clock prescaler to 32000
|
|
RCC_BDCR = (RCC_BDCR & ~(RCC_BDCR_RTCSEL_MASK << RCC_BDCR_RTCSEL_SHIFT)) | (RCC_BDCR_RTCSEL_LSI << RCC_BDCR_RTCSEL_SHIFT); // select LSI as RTC clock source
|
|
RCC_BDCR |= RCC_BDCR_RTCEN; // enable RTC
|
|
rtc_lock(); // protect RTC register against writing
|
|
pwr_enable_backup_domain_write_protect(); // re-enable protection now that we configured the RTC clock
|
|
}
|
|
boot_time = rtc_to_seconds(); // remember the start time
|
|
puts_debug("OK\n");
|
|
|
|
// setup wakeup timer for periodic checks
|
|
puts_debug("setup wakeup: ");
|
|
// RTC needs to be configured beforehand
|
|
pwr_disable_backup_domain_write_protect(); // disable backup protection so we can write to the RTC registers
|
|
rtc_unlock(); // enable writing RTC registers
|
|
rtc_clear_wakeup_flag(); // clear flag for fresh start
|
|
rtc_set_wakeup_time((32000 / 2) / WAKEUP_FREQ - 1, RTC_CR_WUCLKSEL_RTC_DIV2); // set wakeup time based on LSI (keep highest precision, also enables the wakeup timer)
|
|
rtc_enable_wakeup_timer_interrupt(); // enable interrupt
|
|
rtc_lock(); // disable writing RTC registers
|
|
// important: do not re-enable backup_domain_write_protect, since this will prevent clearing flags (but RTC registers do not need to be unlocked)
|
|
puts_debug("OK\n");
|
|
|
|
puts_debug("setup voltage control: ");
|
|
rcc_periph_clock_enable(GPIO_RCC(SIGNAL_PD_PIN)); // enable clock for port domain
|
|
gpio_set(GPIO_PORT(SIGNAL_PD_PIN), GPIO_PIN(SIGNAL_PD_PIN)); // ensure we are not draining it
|
|
gpio_set_output_options(GPIO_PORT(SIGNAL_PD_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(SIGNAL_PD_PIN)); // set output as open-drain
|
|
gpio_mode_setup(GPIO_PORT(SIGNAL_PD_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(SIGNAL_PD_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(SIGNAL_PU_PIN)); // enable clock for port domain
|
|
gpio_set(GPIO_PORT(SIGNAL_PU_PIN), GPIO_PIN(SIGNAL_PU_PIN)); // ensure we are do enable pMOS to pull up the signal
|
|
gpio_set_output_options(GPIO_PORT(SIGNAL_PU_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(SIGNAL_PU_PIN)); // set output as open-drain
|
|
gpio_mode_setup(GPIO_PORT(SIGNAL_PU_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(SIGNAL_PU_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(SHIFT_EN_PIN)); // enable clock for port domain
|
|
gpio_set(GPIO_PORT(SHIFT_EN_PIN), GPIO_PIN(SHIFT_EN_PIN)); // ensure we do not enable pMOS to power level shifters
|
|
gpio_set_output_options(GPIO_PORT(SHIFT_EN_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(SHIFT_EN_PIN)); // set output as open-drain
|
|
gpio_mode_setup(GPIO_PORT(SHIFT_EN_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(SHIFT_EN_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(TARGET_3V_PIN)); // enable clock for port domain
|
|
gpio_set(GPIO_PORT(TARGET_3V_PIN), GPIO_PIN(TARGET_3V_PIN)); // ensure we do not enable pMOS to provide 3.3V on target voltage
|
|
gpio_set_output_options(GPIO_PORT(TARGET_3V_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(TARGET_3V_PIN)); // set output as open-drain
|
|
gpio_mode_setup(GPIO_PORT(TARGET_3V_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(TARGET_3V_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(TARGET_RST_PIN)); // enable clock for port domain
|
|
gpio_set(GPIO_PORT(TARGET_RST_PIN), GPIO_PIN(TARGET_RST_PIN)); // to not pull down (asserting reset)
|
|
gpio_set_output_options(GPIO_PORT(TARGET_RST_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(TARGET_RST_PIN)); // set output as open-drain
|
|
gpio_mode_setup(GPIO_PORT(TARGET_RST_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(TARGET_RST_PIN)); // configure pin as output
|
|
puts_debug("OK\n");
|
|
|
|
puts_debug("setup analog multiplexer: ");
|
|
rcc_periph_clock_enable(GPIO_RCC(MUX_EN_PIN)); // enable clock for port domain
|
|
gpio_set(GPIO_PORT(MUX_EN_PIN), GPIO_PIN(MUX_EN_PIN)); // ensure multiplexer is disabled
|
|
gpio_set_output_options(GPIO_PORT(MUX_EN_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(MUX_EN_PIN)); // set output as push-pull to drive correctly
|
|
gpio_mode_setup(GPIO_PORT(MUX_EN_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(MUX_EN_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(MUX_S0_PIN)); // enable clock for port domain
|
|
gpio_clear(GPIO_PORT(MUX_S0_PIN), GPIO_PIN(MUX_S0_PIN)); // any channel selected is fine
|
|
gpio_set_output_options(GPIO_PORT(MUX_S0_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(MUX_S0_PIN)); // set output as push-pull to drive correctly
|
|
gpio_mode_setup(GPIO_PORT(MUX_S0_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(MUX_S0_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(MUX_S1_PIN)); // enable clock for port domain
|
|
gpio_clear(GPIO_PORT(MUX_S1_PIN), GPIO_PIN(MUX_S1_PIN)); // any channel selected is fine
|
|
gpio_set_output_options(GPIO_PORT(MUX_S1_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(MUX_S1_PIN)); // set output as push-pull to drive correctly
|
|
gpio_mode_setup(GPIO_PORT(MUX_S1_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(MUX_S1_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(MUX_S2_PIN)); // enable clock for port domain
|
|
gpio_clear(GPIO_PORT(MUX_S2_PIN), GPIO_PIN(MUX_S2_PIN)); // any channel selected is fine
|
|
gpio_set_output_options(GPIO_PORT(MUX_S2_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(MUX_S2_PIN)); // set output as push-pull to drive correctly
|
|
gpio_mode_setup(GPIO_PORT(MUX_S2_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(MUX_S2_PIN)); // configure pin as output
|
|
rcc_periph_clock_enable(GPIO_RCC(MUX_S3_PIN)); // enable clock for port domain
|
|
gpio_clear(GPIO_PORT(MUX_S3_PIN), GPIO_PIN(MUX_S3_PIN)); // any channel selected is fine
|
|
gpio_set_output_options(GPIO_PORT(MUX_S3_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(MUX_S3_PIN)); // set output as push-pull to drive correctly
|
|
gpio_mode_setup(GPIO_PORT(MUX_S3_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(MUX_S3_PIN)); // configure pin as output
|
|
mux_select(-1); // ensure it is disabled
|
|
puts_debug("OK\n");
|
|
|
|
puts_debug("setup signal pins: ");
|
|
for (uint8_t i = 0; i < CHANNEL_NUMBERS; i++) {
|
|
rcc_periph_clock_enable(port2rcc(channel_ports[i])); // enable clock for port domain
|
|
gpio_mode_setup(channel_ports[i], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[i]); // ensure pin is floating input
|
|
}
|
|
puts_debug("OK\n");
|
|
|
|
puts_debug("setup ADC to measure voltages: ");
|
|
rcc_periph_clock_enable(RCC_ADC1); // enable clock for ADC domain
|
|
adc_power_off(ADC1); // switch off ADC while configuring it
|
|
adc_set_right_aligned(ADC1); // ensure it is right aligned to get the actual value in the 16-bit register
|
|
adc_enable_scan_mode(ADC1); // use scan mode do be able to go to next discontinuous subgroup of the regular sequence
|
|
adc_enable_discontinuous_mode_regular(ADC1, 1); // use discontinuous mode (to go through all channels of the group, one after another)
|
|
adc_set_single_conversion_mode(ADC1); // ensure continuous mode is not used (that's not the same as discontinuous)
|
|
adc_eoc_after_each(ADC1); // set EOC after each conversion instead of each group
|
|
adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28CYC); // use at least 15 cycles to be able to sample at 12-bit resolution
|
|
adc_set_regular_sequence(ADC1, LENGTH(adc_channels), (uint8_t*)adc_channels); // set channel to convert
|
|
adc_enable_temperature_sensor(); // enable internal voltage reference
|
|
adc_power_on(ADC1); // switch on ADC
|
|
sleep_us(3); // wait t_stab for the ADC to stabilize
|
|
rcc_periph_clock_enable(RCC_ADC1_IN(TARGET_CHANNEL)); // enable clock for GPIO domain for target voltage channel
|
|
gpio_mode_setup(ADC1_IN_PORT(TARGET_CHANNEL), GPIO_MODE_ANALOG, GPIO_PUPD_NONE, ADC1_IN_PIN(TARGET_CHANNEL)); // set target voltage channel as analog input for the ADC
|
|
rcc_periph_clock_enable(RCC_ADC1_IN(SIGNAL_CHANNEL)); // enable clock for GPIO domain for signal channel
|
|
gpio_mode_setup(ADC1_IN_PORT(SIGNAL_CHANNEL), GPIO_MODE_ANALOG, GPIO_PUPD_NONE, ADC1_IN_PIN(SIGNAL_CHANNEL)); // set signal channel as analog input for the ADC
|
|
measure_voltages(); // try to measure voltages
|
|
puts_debug("OK\n");
|
|
|
|
// setup terminal
|
|
terminal_prefix = ""; // set default prefix
|
|
terminal_process = &process_command; // set central function to process commands
|
|
terminal_setup(); // start terminal
|
|
|
|
// start main loop
|
|
bool action = false; // if an action has been performed don't go to sleep
|
|
button_flag = false; // reset button flag
|
|
while (true) { // infinite loop
|
|
iwdg_reset(); // kick the dog
|
|
if (user_input_available) { // user input is available
|
|
action = true; // action has been performed
|
|
char c = user_input_get(); // store receive character
|
|
terminal_send(c); // send received character to terminal
|
|
}
|
|
if (wakeup_flag) { // time to do periodic checks
|
|
wakeup_flag = false; // clear flag
|
|
}
|
|
if (second_flag) { // one second passed
|
|
second_flag = false; // clear 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
|
|
}
|
|
|
|
/** interrupt service routine when the wakeup timer triggered */
|
|
void rtc_wkup_isr(void)
|
|
{
|
|
static uint16_t tick = WAKEUP_FREQ; // how many wakeup have occurred
|
|
exti_reset_request(EXTI22); // clear EXTI flag used by wakeup
|
|
rtc_clear_wakeup_flag(); // clear flag
|
|
wakeup_flag = true; // notify main loop
|
|
tick--; // count the number of ticks down (do it in the ISR to no miss any tick)
|
|
if (0 == tick) { // count down completed
|
|
second_flag = true; // notify main loop a second has passed
|
|
tick = WAKEUP_FREQ; // restart count down
|
|
}
|
|
}
|