2021-03-10 14:15:04 +01:00
/** SWJ (SWD + JTAG) finder
2020-02-17 18:08:17 +01:00
* @ file
2016-08-14 21:02:38 +02:00
* @ author King Kévin < kingkevin @ cuvoodoo . info >
2020-06-06 14:35:55 +02:00
* @ copyright SPDX - License - Identifier : GPL - 3.0 - or - later
2021-03-10 14:15:04 +01:00
* @ date 2016 - 2021
2016-08-14 21:02:38 +02:00
*/
2016-01-17 14:54:54 +01:00
/* standard libraries */
# include <stdint.h> // standard integer types
# include <stdlib.h> // standard utilities
2016-08-14 21:02:38 +02:00
# include <string.h> // string utilities
2019-06-18 17:43:43 +02:00
# include <time.h> // date/time utilities
# include <ctype.h> // utilities to check chars
2021-03-11 10:46:37 +01:00
# include <math.h> // rounding utilities
2016-01-17 14:54:54 +01:00
/* STM32 (including CM3) libraries */
2016-01-18 16:23:35 +01:00
# include <libopencmsis/core_cm3.h> // Cortex M3 utilities
2016-10-23 17:42:27 +02:00
# include <libopencm3/cm3/scb.h> // vector table definition
2016-01-29 11:25:30 +01:00
# include <libopencm3/cm3/nvic.h> // interrupt utilities
2016-10-23 17:42:27 +02:00
# include <libopencm3/stm32/gpio.h> // general purpose input output library
# include <libopencm3/stm32/rcc.h> // real-time control clock library
2016-01-29 11:25:30 +01:00
# include <libopencm3/stm32/exti.h> // external interrupt utilities
2016-08-14 21:02:38 +02:00
# include <libopencm3/stm32/rtc.h> // real time clock utilities
2016-10-23 17:42:27 +02:00
# include <libopencm3/stm32/iwdg.h> // independent watchdog utilities
# include <libopencm3/stm32/dbgmcu.h> // debug utilities
2018-04-06 17:37:17 +02:00
# include <libopencm3/stm32/desig.h> // design utilities
2016-10-23 17:42:27 +02:00
# include <libopencm3/stm32/flash.h> // flash utilities
2021-03-10 18:31:17 +01:00
# include <libopencm3/stm32/adc.h> // ADC utilities
2016-01-17 14:54:54 +01:00
/* own libraries */
2016-01-28 21:21:50 +01:00
# include "global.h" // board definitions
2017-04-03 13:32:45 +02:00
# include "print.h" // printing utilities
2016-01-18 16:23:35 +01:00
# include "usb_cdcacm.h" // USB CDC ACM utilities
2018-04-06 17:37:17 +02:00
# include "terminal.h" // handle the terminal interface
# include "menu.h" // menu utilities
2021-03-10 14:15:04 +01:00
# include "swd.h" // SWD utilities
2016-01-17 14:54:54 +01:00
2020-02-02 21:19:03 +01:00
/** watchdog period in ms */
# define WATCHDOG_PERIOD 10000
2020-11-30 14:36:33 +01:00
/** wakeup frequency (i.e. least number of times per second to perform the main loop) */
# define WAKEUP_FREQ 16
2016-08-14 21:02:38 +02:00
/** @defgroup main_flags flag set in interrupts to be processed in main task
* @ {
*/
2020-11-30 14:36:33 +01:00
static volatile bool wakeup_flag = false ; /**< flag set when wakeup timer triggered */
static volatile bool second_flag = false ; /**< flag set when a second passed */
2016-08-14 21:02:38 +02:00
/** @} */
2020-12-12 14:45:21 +01:00
/** number of seconds since boot */
static uint32_t boot_time = 0 ;
2021-03-11 10:46:37 +01:00
# define TARGET_CHANNEL 1 /**< PA1/ADC1_IN1 used to measure target voltage */
# define SIGNAL_CHANNEL 2 /**< PA2/ADC1_IN2 used to measure signal voltage */
const uint8_t channels [ ] = { ADC_CHANNEL17 , ADC_CHANNEL ( TARGET_CHANNEL ) , ADC_CHANNEL ( SIGNAL_CHANNEL ) } ; /**< voltages to convert (channel 17 = internal voltage reference) */
2021-03-11 10:50:50 +01:00
# define SIGNAL_PD_PIN PA3 /**< pin to pull signal low for voltage measurement */
# define SIGNAL_PU_PIN PA4 /**< pin to pull signal to target voltage (controlling gate of pMOS) */
# define TARGET_EN PA5 /**< pin to provide target voltage to LV side of voltage shifter (pulling them high through 10 kO) */
2021-03-11 10:53:02 +01:00
# define MUX_EN_PIN PB2 /**< pin to enable analog multiplexer (active low) */
# define MUX_S0_PIN PA6 /**< pin to set S0 bit of analog multiplexer */
# define MUX_S1_PIN PA7 /**< pin to set S1 bit of analog multiplexer */
# define MUX_S2_PIN PB0 /**< pin to set S2 bit of analog multiplexer */
# define MUX_S3_PIN PB1 /**< pin to set S3 bit of analog multiplexer */
2021-03-11 14:20:12 +01:00
# define CHANNEL_NUMBERS 12 /**< number of target signals */
static const char * channel_names [ ] = { " B12 " , " B13 " , " B14 " , " B15 " , " A8 " , " A9 " , " A10 " , " A15 " , " B3 " , " B4 " , " B5 " , " B6 " } ; /**< names of pin connected to 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 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 pins for signal pin */
2021-03-11 14:23:18 +01:00
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 */
2021-03-11 11:19:03 +01:00
2017-04-03 13:32:45 +02:00
size_t putc ( char c )
2016-01-17 14:54:54 +01:00
{
2017-04-03 13:32:45 +02:00
size_t length = 0 ; // number of characters printed
2018-04-06 17:37:17 +02:00
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
2017-04-19 16:24:07 +02:00
usb_cdcacm_putchar ( ' \r ' ) ; // send CR over USB
2018-04-06 17:37:17 +02:00
length + + ; // remember we printed 1 character
2016-01-17 14:54:54 +01:00
}
}
2018-04-06 17:37:17 +02:00
usb_cdcacm_putchar ( c ) ; // send byte over USB
length + + ; // remember we printed 1 character
last_c = c ; // remember last character
2019-03-26 19:27:40 +01:00
return length ; // return number of characters printed
2016-01-17 14:54:54 +01:00
}
2021-03-11 14:21:10 +01:00
/** print float with fixed precision
* @ param [ in ] fpu float to print
2021-03-11 10:46:37 +01:00
* @ param [ in ] precision number of digits after comma to print
* @ note % f is used to force scientific notation
*/
2021-03-11 14:21:10 +01:00
static void print_fpu ( double fpu , uint8_t precision )
2021-03-11 10:46:37 +01:00
{
uint32_t multiplier = 1 ;
for ( uint8_t i = 0 ; i < precision ; i + + ) {
multiplier * = 10 ;
}
2021-03-11 14:21:10 +01:00
double to_print = round ( fpu * multiplier ) ;
2021-03-11 10:46:37 +01:00
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 ) ;
}
2021-03-10 18:31:17 +01:00
2021-03-11 14:22:31 +01:00
/** 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 ;
}
2021-03-10 18:31:17 +01:00
/** measure target and signal voltages
* @ return voltages of channels
*/
static float * measure_voltages ( void )
{
static float voltages [ LENGTH ( channels ) ] ; // to store and return the voltages
// read lid temperature using ADC
ADC_SR ( ADC1 ) = 0 ; // reset flags
uint16_t adc_values [ LENGTH ( channels ) ] ;
for ( uint8_t i = 0 ; i < LENGTH ( 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)
2021-03-11 10:59:54 +01:00
voltages [ i ] = adc_values [ i ] * 1.21 / adc_values [ 0 ] ; // use 1.21 V internal voltage reference to get ADC voltage
2021-03-10 18:31:17 +01:00
}
2021-03-11 10:59:54 +01:00
voltages [ 1 ] * = 2.0 ; // the is a /2 voltage divider for target voltage
2021-03-10 18:31:17 +01:00
return voltages ;
}
2021-03-11 11:20:09 +01:00
/** measure and print target voltage */
2021-03-11 13:52:21 +01:00
static void print_target ( void )
2021-03-11 11:20:09 +01:00
{
gpio_set ( GPIO_PORT ( SIGNAL_PU_PIN ) , GPIO_PIN ( SIGNAL_PU_PIN ) ) ; // ensure we are not pulling up the signal
gpio_set ( GPIO_PORT ( SIGNAL_PD_PIN ) , GPIO_PIN ( SIGNAL_PD_PIN ) ) ; // ensure we are not pulling down the signal
gpio_set ( GPIO_PORT ( TARGET_EN ) , GPIO_PIN ( TARGET_EN ) ) ; // ensure the level shifters pulling up the signals are not enabled
float * voltages = measure_voltages ( ) ; // measure voltages
puts ( " target voltage: " ) ;
2021-03-11 13:51:13 +01:00
print_fpu ( voltages [ 1 ] , 2 ) ;
2021-03-11 11:20:09 +01:00
puts ( " V " ) ;
if ( voltages [ 1 ] > 3.25 ) {
puts ( " (warning: signal voltage may exceed 3.30 V limit) " ) ;
} else if ( voltages [ 1 ] < 1.0 ) {
puts ( " (warning: target voltage seems not connected) " ) ;
}
putc ( ' \n ' ) ;
}
2021-03-11 10:53:02 +01:00
/** 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
2021-03-11 14:22:59 +01:00
if ( channel < 0 | | channel > 15 | | ( channel > CHANNEL_NUMBERS - 1 ) ) {
2021-03-11 10:53:02 +01:00
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
}
2020-11-27 17:07:39 +01:00
// menu commands
2021-03-10 14:15:04 +01:00
static void command_swd_scan ( void * argument )
{
( void ) argument ; // we won't use the argument
printf ( " SWD target DPIDR: " ) ;
uint32_t data ; // data to read/write over SWD
enum swd_ack_e ack ; // SWD acknowledge response
swd_line_reset ( ) ; // put target in reset state
swd_jtag_to_swd ( ) ; // put target SWJ in SWD mode
swd_line_reset ( ) ; // put target in reset state
swd_idle_cycles ( 2 ) ; // idle before packer request
swd_packet_request ( false , SWD_A_DP_DPIDR , true ) ; // request DPIDR
swd_turnaround ( 1 ) ; // switch from writing to reading
ack = swd_acknowledge_response ( ) ; // get ack
if ( SWD_ACK_OK ! = ack ) {
printf ( " ack error \n " ) ;
return ;
}
if ( ! swd_read ( & data ) ) {
printf ( " parity error \n " ) ;
return ;
}
swd_turnaround ( 1 ) ; // switch from reading to writing
printf ( " 0x%08x " , data ) ;
if ( data & 0x1 ) {
printf ( " (designer: %03x/%s, version: %u, part number: 0x%02x/%s, revision %u) \n " , ( data > > 1 ) & 0x3ff , swd_jep106_manufacturer ( ( data > > 8 ) & 0x0f , ( data > > 1 ) & 0x7f ) , ( data > > 12 ) & 0x0f , ( data > > 20 ) & 0xff , swd_dpidr_partno ( ( data > > 1 ) & 0x3ff , ( data > > 20 ) & 0xff ) , ( data > > 28 ) & 0x0f ) ;
} else {
printf ( " (invalid: RAO != 1) \n " ) ;
}
}
2021-03-10 18:31:39 +01:00
static void command_voltages ( void * argument )
{
( void ) argument ; // we won't use the argument
2021-03-11 11:20:09 +01:00
float * voltages ;
2021-03-11 13:52:21 +01:00
print_target ( ) ; // print target voltage (also sets measurement conditions)
2021-03-11 11:20:09 +01:00
puts ( " signal voltages: \n " ) ;
2021-03-11 14:23:18 +01:00
for ( uint8_t i = channel_start ; i < channel_stop ; i + + ) {
2021-03-11 11:20:09 +01:00
puts ( " - " ) ;
2021-03-11 14:20:12 +01:00
puts ( channel_names [ i ] ) ;
2021-03-11 11:20:09 +01:00
mux_select ( i ) ; // select the channel
voltages = measure_voltages ( ) ; // measure raw voltages
puts ( " " ) ;
2021-03-11 13:51:13 +01:00
print_fpu ( voltages [ 2 ] , 2 ) ;
2021-03-11 10:46:37 +01:00
puts ( " V \n " ) ;
}
2021-03-10 18:31:39 +01:00
}
2021-03-11 11:21:22 +01:00
/** 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
float * voltages ;
2021-03-11 13:53:00 +01:00
print_target ( ) ; // print target voltage (also sets measurement conditions)
puts ( " signal voltage pulled pull-up pulled pull-down signal \n " ) ;
puts ( " name raw (V) down (V) (kOhm) up (V) (kOhm) type \n " ) ;
2021-03-11 11:21:22 +01:00
// 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
gpio_set ( GPIO_PORT ( TARGET_EN ) , GPIO_PIN ( TARGET_EN ) ) ; // ensure the level shifters pulling up the signals are not enabled
2021-03-11 14:23:18 +01:00
for ( uint8_t i = channel_start ; i < channel_stop ; i + + ) {
2021-03-11 14:20:12 +01:00
puts ( channel_names [ i ] ) ;
2021-03-11 11:21:22 +01:00
puts ( " " ) ;
mux_select ( i ) ; // select the channel
voltages = measure_voltages ( ) ; // measure raw voltages
2021-03-11 13:53:00 +01:00
print_fpu ( voltages [ 2 ] , 2 ) ;
const float raw = voltages [ 2 ] ; // remember un-pulled voltage
2021-03-11 11:21:22 +01:00
puts ( " " ) ;
2021-03-11 13:53:00 +01:00
gpio_clear ( GPIO_PORT ( SIGNAL_PD_PIN ) , GPIO_PIN ( SIGNAL_PD_PIN ) ) ; // pull down signal
2021-03-11 11:21:22 +01:00
voltages = measure_voltages ( ) ; // measure pulled down voltages
gpio_set ( GPIO_PORT ( SIGNAL_PD_PIN ) , GPIO_PIN ( SIGNAL_PD_PIN ) ) ; // remove pull-down
2021-03-11 13:53:00 +01:00
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 ( " " ) ;
if ( pullup > 100.0 ) {
puts ( " >100 " ) ;
} else if ( pullup < 1.0 ) {
puts ( " <1 " ) ;
} else {
printf ( " %02u " , ( uint32_t ) round ( pullup ) ) ;
}
puts ( " " ) ;
gpio_clear ( GPIO_PORT ( SIGNAL_PU_PIN ) , GPIO_PIN ( SIGNAL_PU_PIN ) ) ; // pull up signal
2021-03-11 11:21:22 +01:00
voltages = measure_voltages ( ) ; // measure pulled up voltages
gpio_set ( GPIO_PORT ( SIGNAL_PU_PIN ) , GPIO_PIN ( SIGNAL_PU_PIN ) ) ; // remove pull-up
2021-03-11 13:53:00 +01:00
voltages [ 2 ] = voltages [ 2 ] * 2.0 - voltages [ 1 ] ; // pulling creates a voltage divider (to target)
const bool high = ( voltages [ 2 ] > 3.2 | | voltages [ 2 ] > voltages [ 1 ] * 0.5 ) ; // 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 ( pulldown > 100.0 ) {
puts ( " >100 " ) ;
} else if ( pulldown < 1.0 ) {
puts ( " <1 " ) ;
} else {
printf ( " %02u " , ( uint32_t ) round ( pulldown ) ) ;
}
puts ( " " ) ;
if ( low & & high ) {
if ( pullup > 1.0 & & pullup < 100.0 & & ( pulldown < 1.0 | | pulldown > 100.0 ) ) {
puts ( " pulled-up " ) ;
} else if ( pulldown > 1.0 & & pulldown < 100.0 & & ( pullup < 1.0 | | pullup > 100.0 ) ) {
puts ( " pulled-down " ) ;
} else {
puts ( " floating " ) ;
}
} else if ( low ) {
puts ( " low " ) ;
} else if ( high ) {
puts ( " high " ) ;
} else {
puts ( " unknown " ) ;
}
2021-03-11 11:21:22 +01:00
putc ( ' \n ' ) ;
}
mux_select ( - 1 ) ; // disable multiplexer
}
2021-03-11 14:23:18 +01:00
/** 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_start ) {
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 ) ;
}
2018-04-06 17:37:17 +02:00
/** 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
*/
2020-11-27 17:07:39 +01:00
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)
}
2018-04-06 17:37:17 +02:00
2020-12-12 14:45:21 +01:00
/** 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
2020-12-17 12:42:30 +01:00
const uint32_t seconds = ( ( ( ( ( ( ( ( year * 12 ) + month ) * 31 ) + day ) * 24 ) + hour ) * 60 ) + minute ) * 60 + second ; // convert to number of seconds
2020-12-12 14:45:21 +01:00
return seconds ;
}
2018-04-06 17:37:17 +02:00
/** show uptime
* @ param [ in ] argument no argument required
*/
2020-11-27 17:07:39 +01:00
static void command_uptime ( void * argument )
{
( void ) argument ; // we won't use the argument
2020-12-12 14:45:21 +01:00
const uint32_t uptime = rtc_to_seconds ( ) - boot_time ; // get time from internal RTC
2020-11-27 17:07:39 +01:00
printf ( " uptime: %u.%02u:%02u:%02u \n " , uptime / ( 24 * 60 * 60 ) , ( uptime / ( 60 * 60 ) ) % 24 , ( uptime / 60 ) % 60 , uptime % 60 ) ;
}
2018-04-06 17:37:17 +02:00
2019-06-18 17:43:43 +02:00
/** show date and time
* @ param [ in ] argument date and time to set
*/
2020-11-27 17:07:39 +01:00
static void command_datetime ( void * argument )
{
char * datetime = ( char * ) argument ; // argument is optional date time
2020-11-28 15:17:52 +01:00
const char * days [ ] = { " ?? " , " Mo " , " Tu " , " We " , " Th " , " Fr " , " Sa " , " Su " } ; // the days of the week
// set date
if ( datetime ) { // date has been provided
// parse date
const char * malformed = " date and time malformed, expecting YYYY-MM-DD WD HH:MM:SS \n " ;
if ( strlen ( datetime ) ! = ( 4 + 1 + 2 + 1 + 2 ) + 1 + 2 + 1 + ( 2 + 1 + 2 + 1 + 2 ) ) { // verify date/time is long enough
2020-11-27 17:07:39 +01:00
printf ( malformed ) ;
return ;
}
2020-11-28 15:17:52 +01:00
if ( ! ( isdigit ( ( int8_t ) datetime [ 0 ] ) & & isdigit ( ( int8_t ) datetime [ 1 ] ) & & isdigit ( ( int8_t ) datetime [ 2 ] ) & & isdigit ( ( int8_t ) datetime [ 3 ] ) & & \
' - ' = = datetime [ 4 ] & & \
isdigit ( ( int8_t ) datetime [ 5 ] ) & & isdigit ( ( int8_t ) datetime [ 6 ] ) & & \
' - ' = = datetime [ 7 ] & & \
isdigit ( ( int8_t ) datetime [ 8 ] ) & & isdigit ( ( int8_t ) datetime [ 9 ] ) & & \
' ' = = datetime [ 10 ] & & \
isalpha ( ( int8_t ) datetime [ 11 ] ) & & isalpha ( ( int8_t ) datetime [ 12 ] ) & & \
' ' = = datetime [ 13 ] & & \
isdigit ( ( int8_t ) datetime [ 14 ] ) & & isdigit ( ( int8_t ) datetime [ 15 ] ) & & \
' : ' = = datetime [ 16 ] & & \
isdigit ( ( int8_t ) datetime [ 17 ] ) & & isdigit ( ( int8_t ) datetime [ 18 ] ) & & \
' : ' = = datetime [ 19 ] & & \
isdigit ( ( int8_t ) datetime [ 20 ] ) & & isdigit ( ( int8_t ) datetime [ 21 ] ) ) ) { // verify format (good enough to not fail parsing)
2020-11-27 17:07:39 +01:00
printf ( malformed ) ;
return ;
}
2020-11-28 15:17:52 +01:00
const uint16_t year = strtol ( & datetime [ 0 ] , NULL , 10 ) ; // parse year
if ( year < = 2000 | | year > 2099 ) {
puts ( " year out of range \n " ) ;
return ;
}
const uint8_t month = strtol ( & datetime [ 5 ] , NULL , 10 ) ; // parse month
if ( month < 1 | | month > 12 ) {
puts ( " month out of range \n " ) ;
return ;
}
const uint8_t day = strtol ( & datetime [ 8 ] , NULL , 10 ) ; // parse day
if ( day < 1 | | day > 31 ) {
puts ( " day out of range \n " ) ;
return ;
}
const uint8_t hour = strtol ( & datetime [ 14 ] , NULL , 10 ) ; // parse hour
if ( hour > 24 ) {
puts ( " hour out of range \n " ) ;
return ;
}
const uint8_t minute = strtol ( & datetime [ 17 ] , NULL , 10 ) ; // parse minutes
if ( minute > 59 ) {
puts ( " minute out of range \n " ) ;
return ;
}
const uint8_t second = strtol ( & datetime [ 30 ] , NULL , 10 ) ; // parse seconds
if ( second > 59 ) {
puts ( " second out of range \n " ) ;
return ;
}
uint8_t week_day = 0 ;
for ( uint8_t i = 1 ; i < LENGTH ( days ) & & 0 = = week_day ; i + + ) {
if ( days [ i ] [ 0 ] = = toupper ( datetime [ 11 ] ) & & days [ i ] [ 1 ] = = tolower ( datetime [ 12 ] ) ) {
week_day = i ;
break ;
}
}
if ( 0 = = week_day ) {
puts ( " unknown week day \n " ) ;
return ;
}
uint32_t date = 0 ; // to build the date
date | = ( ( ( year - 2000 ) / 10 ) & RTC_DR_YT_MASK ) < < RTC_DR_YT_SHIFT ; // set year tenth
date | = ( ( ( year - 2000 ) % 10 ) & RTC_DR_YU_MASK ) < < RTC_DR_YU_SHIFT ; // set year unit
date | = ( ( month / 10 ) & RTC_DR_MT_MASK ) < < RTC_DR_MT_SHIFT ; // set month tenth
date | = ( ( month % 10 ) & RTC_DR_MU_MASK ) < < RTC_DR_MU_SHIFT ; // set month unit
date | = ( ( day / 10 ) & RTC_DR_DT_MASK ) < < RTC_DR_DT_SHIFT ; // set day tenth
date | = ( ( day % 10 ) & RTC_DR_DU_MASK ) < < RTC_DR_DU_SHIFT ; // set day unit
date | = ( week_day & RTC_DR_WDU_MASK ) < < RTC_DR_WDU_SHIFT ; // time day of the week
uint32_t time = 0 ; // to build the time
time = 0 ; // reset time
time | = ( ( hour / 10 ) & RTC_TR_HT_MASK ) < < RTC_TR_HT_SHIFT ; // set hour tenth
time | = ( ( hour % 10 ) & RTC_TR_HU_MASK ) < < RTC_TR_HU_SHIFT ; // set hour unit
time | = ( ( minute / 10 ) & RTC_TR_MNT_MASK ) < < RTC_TR_MNT_SHIFT ; // set minute tenth
time | = ( ( minute % 10 ) & RTC_TR_MNU_MASK ) < < RTC_TR_MNU_SHIFT ; // set minute unit
time | = ( ( second / 10 ) & RTC_TR_ST_MASK ) < < RTC_TR_ST_SHIFT ; // set second tenth
time | = ( ( second % 10 ) & RTC_TR_SU_MASK ) < < RTC_TR_SU_SHIFT ; // set second unit
// write date
pwr_disable_backup_domain_write_protect ( ) ; // disable backup protection so we can set the RTC clock source
rtc_unlock ( ) ; // enable writing RTC registers
RTC_ISR | = RTC_ISR_INIT ; // enter initialisation mode
while ( ! ( RTC_ISR & RTC_ISR_INITF ) ) ; // wait to enter initialisation mode
RTC_DR = date ; // set date
RTC_TR = time ; // set time
RTC_ISR & = ~ RTC_ISR_INIT ; // exit initialisation mode
rtc_lock ( ) ; // protect RTC register against writing
pwr_enable_backup_domain_write_protect ( ) ; // re-enable protection now that we configured the RTC clock
}
// show date
if ( ! ( RTC_ISR & RTC_ISR_INITS ) ) { // date has not been set yet
puts ( " date/time not initialized \n " ) ;
} else {
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
const 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
const 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
const uint8_t week_day = ( ( RTC_DR > > RTC_DR_WDU_SHIFT ) & RTC_DR_WDU_MASK ) ; // get week day
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
printf ( " date: 20%02d-%02d-%02d %s %02d:%02d:%02d \n " , year , month , day , days [ week_day ] , hour , minute , second ) ;
2020-11-27 17:07:39 +01:00
}
}
2019-06-18 17:43:43 +02:00
2018-04-06 17:37:17 +02:00
/** reset board
* @ param [ in ] argument no argument required
*/
2020-11-27 17:07:39 +01:00
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
}
2018-04-06 17:37:17 +02:00
/** switch to DFU bootloader
* @ param [ in ] argument no argument required
*/
2020-11-27 17:07:39 +01:00
static void command_bootloader ( void * argument )
{
( void ) argument ; // we won't use the argument
dfu_bootloader ( ) ; // start DFU bootloader
}
2018-04-06 17:37:17 +02:00
/** 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 ,
} ,
{
2021-03-10 18:31:39 +01:00
. shortcut = ' V ' ,
2018-04-06 17:37:17 +02:00
. 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 ,
} ,
2019-06-18 17:43:43 +02:00
{
. shortcut = ' d ' ,
. name = " date " ,
2019-07-29 18:33:05 +02:00
. command_description = " show/set date and time " ,
2019-06-18 17:43:43 +02:00
. argument = MENU_ARGUMENT_STRING ,
. argument_description = " [YYYY-MM-DD HH:MM:SS] " ,
. command_handler = & command_datetime ,
} ,
2018-04-06 17:37:17 +02:00
{
. shortcut = ' r ' ,
. name = " reset " ,
. command_description = " reset board " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_reset ,
} ,
2020-11-27 17:07:39 +01:00
{
2021-03-10 14:15:04 +01:00
. shortcut = ' S ' ,
2020-11-27 17:07:39 +01:00
. name = " system " ,
. command_description = " reboot into system memory " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_system ,
} ,
2018-04-06 17:37:17 +02:00
{
. shortcut = ' b ' ,
. name = " bootloader " ,
. command_description = " reboot into DFU bootloader " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_bootloader ,
} ,
2021-03-10 14:15:04 +01:00
{
. shortcut = ' s ' ,
. name = " scan " ,
. command_description = " scan SWD device " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_swd_scan ,
} ,
2021-03-10 18:31:39 +01:00
{
. shortcut = ' v ' ,
. name = " voltage " ,
. command_description = " measure target and signal voltages " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_voltages ,
} ,
2021-03-11 11:21:22 +01:00
{
. shortcut = ' t ' ,
. name = " type " ,
. command_description = " identify signal types " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_types ,
} ,
2021-03-11 14:23:18 +01:00
{
. 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 ,
} ,
2018-04-06 17:37:17 +02:00
} ;
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
}
2016-08-14 21:02:38 +02:00
/** process user command
* @ param [ in ] str user command string ( \ 0 ended )
*/
static void process_command ( char * str )
2016-01-17 14:54:54 +01:00
{
2018-04-06 17:37:17 +02:00
// ensure actions are available
2019-06-18 17:44:50 +02:00
if ( NULL = = menu_commands | | 0 = = LENGTH ( menu_commands ) ) {
2018-04-06 17:37:17 +02:00
return ;
2016-08-14 21:02:38 +02:00
}
2018-04-06 17:37:17 +02:00
// don't handle empty lines
2019-06-18 17:44:50 +02:00
if ( ! str | | 0 = = strlen ( str ) ) {
2018-04-06 17:37:17 +02:00
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 " ) ;
2016-08-14 21:02:38 +02:00
}
2016-01-17 14:54:54 +01:00
}
2016-08-14 21:02:38 +02:00
/** program entry point
* this is the firmware function started by the micro - controller
*/
2016-10-23 17:42:27 +02:00
void main ( void ) ;
void main ( void )
2018-04-06 17:37:17 +02:00
{
2016-08-14 21:02:38 +02:00
2016-10-23 17:42:27 +02:00
# if DEBUG
2017-01-30 09:44:51 +01:00
// enable functionalities for easier debug
2016-10-23 17:42:27 +02:00
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)
2017-02-06 17:40:28 +01:00
# else
2017-01-30 09:44:51 +01:00
// 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
2016-10-23 17:42:27 +02:00
# endif
2017-04-03 13:32:45 +02:00
board_setup ( ) ; // setup board
2017-04-19 16:26:40 +02:00
usb_cdcacm_setup ( ) ; // setup USB CDC ACM (for printing)
2021-03-10 14:15:04 +01:00
puts ( " \n welcome to the CuVoodoo SWJ finder \n " ) ; // print welcome message
2016-01-29 00:24:49 +01:00
2019-12-21 19:26:27 +01:00
# 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
2017-01-30 09:44:51 +01:00
# if !(DEBUG)
// show watchdog information
2019-12-21 19:26:58 +01:00
printf ( " setup watchdog: %.2fs " , WATCHDOG_PERIOD / 1000.0 ) ;
if ( FLASH_OBR & FLASH_OBR_OPTERR ) {
2020-12-17 12:42:46 +01:00
puts ( " (option bytes not set in flash: software watchdog used, not automatically started at reset) \n " ) ;
2019-12-21 19:26:58 +01:00
} else if ( FLASH_OBR & FLASH_OBR_WDG_SW ) {
2020-02-19 21:16:07 +01:00
puts ( " (software watchdog used, not automatically started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
} else {
2020-02-19 21:16:07 +01:00
puts ( " (hardware watchdog used, automatically started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
}
# endif
2020-11-28 15:17:52 +01:00
// setup RTC
puts ( " setup RTC: " ) ;
rcc_periph_clock_enable ( RCC_RTC ) ; // enable clock for RTC peripheral
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
# if defined(MINIF401)
rcc_osc_on ( RCC_LSE ) ; // enable LSE clock
while ( ! rcc_is_osc_ready ( RCC_LSE ) ) ; // wait until clock is ready
rtc_set_prescaler ( 256 , 128 ) ; // set clock prescaler to 32768
RCC_BDCR = ( RCC_BDCR & ~ ( RCC_BDCR_RTCSEL_MASK < < RCC_BDCR_RTCSEL_SHIFT ) ) | ( RCC_BDCR_RTCSEL_LSE < < RCC_BDCR_RTCSEL_SHIFT ) ; // select LSE as RTC clock source
# else
rcc_osc_on ( RCC_LSI ) ; // enable LSI clock
while ( ! rcc_is_osc_ready ( RCC_LSI ) ) ; // wait until clock is ready
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
# endif
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
}
2020-12-12 14:45:21 +01:00
boot_time = rtc_to_seconds ( ) ; // remember the start time
2020-11-28 15:17:52 +01:00
puts ( " OK \n " ) ;
2020-11-30 14:36:33 +01:00
// setup wakeup timer for periodic checks
puts ( " 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
# if defined(MINIF401)
rtc_set_wakeup_time ( ( 32768 / 2 ) / WAKEUP_FREQ - 1 , RTC_CR_WUCLKSEL_RTC_DIV2 ) ; // set wakeup time based on LSE (keep highest precision, also enables the wakeup timer)
# else
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)
# endif
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 ( " OK \n " ) ;
2021-03-11 10:50:50 +01:00
puts ( " 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
2021-03-11 11:16:31 +01:00
gpio_set ( GPIO_PORT ( SIGNAL_PU_PIN ) , GPIO_PIN ( SIGNAL_PU_PIN ) ) ; // ensure we are do enable pMOS to pull up the signal
2021-03-11 10:50:50 +01:00
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
2021-03-11 11:16:31 +01:00
rcc_periph_clock_enable ( GPIO_RCC ( TARGET_EN ) ) ; // enable clock for port domain
gpio_set ( GPIO_PORT ( TARGET_EN ) , GPIO_PIN ( TARGET_EN ) ) ; // ensure we do not enable pMOS to power level shifters
gpio_set_output_options ( GPIO_PORT ( TARGET_EN ) , GPIO_OTYPE_OD , GPIO_OSPEED_2MHZ , GPIO_PIN ( TARGET_EN ) ) ; // set output as open-drain
gpio_mode_setup ( GPIO_PORT ( TARGET_EN ) , GPIO_MODE_OUTPUT , GPIO_PUPD_NONE , GPIO_PIN ( TARGET_EN ) ) ; // configure pin as output
2021-03-11 10:50:50 +01:00
puts ( " OK \n " ) ;
2021-03-11 10:53:02 +01:00
puts ( " 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 ( " OK \n " ) ;
2021-03-11 11:19:03 +01:00
puts ( " setup signal pins: " ) ;
2021-03-11 14:20:12 +01:00
for ( uint8_t i = 0 ; i < CHANNEL_NUMBERS ; i + + ) {
2021-03-11 14:22:31 +01:00
rcc_periph_clock_enable ( port2rcc ( channel_ports [ i ] ) ) ; // enable clock for port domain
2021-03-11 14:20:12 +01:00
gpio_mode_setup ( channel_ports [ i ] , GPIO_MODE_INPUT , GPIO_PUPD_NONE , channel_pins [ i ] ) ; // ensure pin is floating input
2021-03-11 11:19:03 +01:00
}
puts ( " OK \n " ) ;
2021-03-10 18:31:17 +01:00
puts ( " 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 ( channels ) , ( uint8_t * ) 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
2021-03-10 14:15:04 +01:00
puts ( " OK \n " ) ;
2021-03-10 18:31:17 +01:00
puts ( " setup SWD: " ) ;
if ( ! swd_set_pins ( GPIO_PORT ( PB10 ) , GPIO_PIN ( PB10 ) , GPIO_PORT ( PB2 ) , GPIO_PIN ( PB2 ) ) ) {
puts ( " unknown pins \n " ) ;
} else {
swd_setup ( 100000 ) ; // setup SWD clock to 100 KHz, slow enough for any target and loose connection
puts ( " OK \n " ) ;
}
2018-04-06 17:37:17 +02:00
// setup terminal
terminal_prefix = " " ; // set default prefix
terminal_process = & process_command ; // set central function to process commands
terminal_setup ( ) ; // start terminal
2016-10-23 17:42:27 +02:00
2018-04-06 17:37:17 +02:00
// start main loop
2016-02-18 10:39:08 +01:00
bool action = false ; // if an action has been performed don't go to sleep
button_flag = false ; // reset button flag
2020-11-27 17:07:39 +01:00
led_on ( ) ; // switch LED to indicate booting completed
2016-01-29 00:24:49 +01:00
while ( true ) { // infinite loop
2016-10-23 17:42:27 +02:00
iwdg_reset ( ) ; // kick the dog
2019-06-18 17:45:53 +02:00
if ( user_input_available ) { // user input is available
2016-02-18 10:39:08 +01:00
action = true ; // action has been performed
2016-01-29 00:24:49 +01:00
led_toggle ( ) ; // toggle LED
2018-04-06 17:37:17 +02:00
char c = user_input_get ( ) ; // store receive character
terminal_send ( c ) ; // send received character to terminal
2016-08-14 21:02:38 +02:00
}
2019-06-18 17:45:53 +02:00
if ( button_flag ) { // user pressed button
2016-08-14 21:02:38 +02:00
action = true ; // action has been performed
2020-02-19 21:16:07 +01:00
puts ( " button pressed \n " ) ;
2016-02-18 10:39:08 +01:00
led_toggle ( ) ; // toggle LED
2020-02-19 21:16:37 +01:00
sleep_ms ( 100 ) ; // wait a bit to remove noise and double trigger
2016-08-14 21:02:38 +02:00
button_flag = false ; // reset flag
2016-02-18 10:39:08 +01:00
}
2020-11-30 14:36:33 +01:00
if ( wakeup_flag ) { // time to do periodic checks
wakeup_flag = false ; // clear flag
}
if ( second_flag ) { // one second passed
second_flag = false ; // clear flag
led_toggle ( ) ; // toggle LED to indicate if main function is stuck
2016-08-14 21:02:38 +02:00
}
if ( action ) { // go to sleep if nothing had to be done, else recheck for activity
2016-02-18 10:39:08 +01:00
action = false ;
} else {
__WFI ( ) ; // go to sleep
}
2016-10-23 17:42:27 +02:00
} // main loop
2016-01-17 14:54:54 +01:00
}
2020-11-30 14:36:33 +01:00
/** 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
}
}