kingkevin
/
stm32f1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
stm32f1/application.c

1224 lines
51 KiB
C
Raw Blame History

/** SWJ (SWD + JTAG) finder
* @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 "usb_cdcacm.h" // USB CDC ACM utilities
#include "terminal.h" // handle the terminal interface
#include "menu.h" // menu utilities
#include "swd.h" // SWD 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 1 /**< PA1/ADC1_IN1 used to measure target voltage */
#define SIGNAL_CHANNEL 2 /**< PA2/ADC1_IN2 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 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) */
#define MUX_EN_PIN PB2 /**< pin to enable analog multiplexer (active low) */
#define MUX_S0_PIN PB1 /**< 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 PA7 /**< pin to set S2 bit of analog multiplexer */
#define MUX_S3_PIN PA6 /**< 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
}
/** 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;
}
/** measure and print target voltage */
static void print_target(void)
{
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: ");
print_fpu(voltages[1], 2);
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');
}
/** print decoded IDCODE
* @param[in] idcode IDCODE to decode
*/
static void print_idcode(uint32_t idcode)
{
printf("designer: %03x/%s, part number: 0x%04x/%s, revision %u",
(idcode >> 1) & 0x3ff,
swd_jep106_manufacturer((idcode >> 8) & 0x0f, (idcode >> 1) & 0x7f),
(idcode >> 12) & 0xffff,
swd_dpidr_partno((idcode >> 1) & 0x3ff, (idcode >> 12) & 0xffff),
(idcode >> 28) & 0x0f);
}
/** 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
static void command_swd_scan(void* argument)
{
(void)argument; // we won't use the argument
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;
}
mux_select(-1); // disable multiplexer
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_clear(GPIO_PORT(TARGET_EN), GPIO_PIN(TARGET_EN)); // power level shifter
sleep_us(100); // wait a tiny bit for the pull-up to be active
printf("searching SWD on channels (%u combinations): ", (channel_stop - channel_start + 1) * (channel_stop - channel_start));
uint8_t found = 0;
for (uint8_t swclk = channel_start; swclk <= channel_stop; swclk++) {
for (uint8_t swdio = channel_start; swdio <= channel_stop; swdio++) {
// skip when SWCLK and SWDIO share a same pin
if (swdio == swclk) {
continue;
}
// set SWCLK/SWDIO combination
if (!swd_set_pins(channel_ports[swclk], channel_pins[swclk], channel_ports[swdio], channel_pins[swdio])) {
putc('!');
continue;
}
// try enabling SWD
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 packet 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) { // no SWD on this combination
putc('.');
continue;
}
printf("\nSWD found: SWCLK=CH%02u SWDIO=CH%02u, ", swclk, swdio);
printf("SWD target DPIDR: ");
if (!swd_read(&data)) {
printf("parity error\n");
return;
}
swd_turnaround(1); // switch from reading to writing
printf("0x%08x ", data);
if (data & 0x1) {
puts("(");
print_idcode(data); // decode DPIDR
puts(")\n");
} else {
printf("(invalid: RAO != 1)\n");
}
swd_release_pins(); // release pins
found++; // remember we found an SWD combination
}
}
gpio_set(GPIO_PORT(TARGET_EN), GPIO_PIN(TARGET_EN)); // disable level shifters
printf("\n%u SWD interface(s) found\n", found);
}
#define JTAG_SPEED 50 /**< time in us between clock edges (i.e. setting the clock speed) */
#define JTAG_PATTERN 0x0ff06699 /**< pattern to fin TDI pin */
static int8_t jtag_tms_ch = -1; /**< channel used for JTAG TCK output (-1 = not configured) */
static int8_t jtag_tck_ch = -1; /**< channel used for JTAG TMS output (-1 = not configured) */
static int8_t jtag_tdi_ch = -1; /**< channel used for JTAG TMS output (-1 = not configured) */
static uint32_t jtag_tdo[CHANNEL_NUMBERS]; /**< possible TDO pin data bits, for each channel (1 for TCK/TMS/TDO pins) */
/** send data to JTAG pins
* @param[in] tms TMS bits to send (LSb first)
* @param[in] tdi TDI bits to send (LSb first)
* @param[in] nb number of bits to send
* @note TDO data will be stored in jtag_tdo (only between channel start and stop, and TDI/TMS/TCK set to 1)
*/
static void jtag_transaction(uint32_t tms, uint32_t tdi, uint8_t nb)
{
if (jtag_tck_ch < 0 || jtag_tck_ch >= CHANNEL_NUMBERS || jtag_tms_ch < 0 || jtag_tms_ch >= CHANNEL_NUMBERS) { // ensure at least TCK and TMS are configured
return;
}
// reset TDO values
for (uint8_t tdo = 0; tdo < LENGTH(jtag_tdo); tdo++) {
jtag_tdo[tdo] = UINT32_MAX;
}
gpio_set(channel_ports[jtag_tck_ch], channel_pins[jtag_tck_ch]); // ensure we start with TCK high
for (uint8_t bit = 0; bit < nb && bit < 32; bit++) { // go through all bits
sleep_us(JTAG_SPEED); // wait for clock falling edge
// output change is on TCK falling edge
if (tms & 0x1) {
gpio_set(channel_ports[jtag_tms_ch], channel_pins[jtag_tms_ch]); // set TMS high
} else {
gpio_clear(channel_ports[jtag_tms_ch], channel_pins[jtag_tms_ch]); // set TMS low
}
tms >>= 1; // go to next bit
if (jtag_tdi_ch >= channel_start && jtag_tdi_ch <= channel_stop) { // TDI is configured
if (tdi & 0x1) {
gpio_set(channel_ports[jtag_tdi_ch], channel_pins[jtag_tdi_ch]); // set TDI high
} else {
gpio_clear(channel_ports[jtag_tdi_ch], channel_pins[jtag_tdi_ch]); // set TDI low
}
tdi >>= 1; // go to next bit
}
gpio_clear(channel_ports[jtag_tck_ch], channel_pins[jtag_tck_ch]); // clock falling edge
sleep_us(JTAG_SPEED); // wait for clock rising edge
gpio_set(channel_ports[jtag_tck_ch], channel_pins[jtag_tck_ch]); // clock rising edge
for (uint8_t tdo = channel_start; tdo < channel_stop && tdo < CHANNEL_NUMBERS; tdo++) { // read TDO
if (tdo == jtag_tms_ch || tdo == jtag_tck_ch || tdo == jtag_tdi_ch) { // channel is already used
continue; // ignore output signal
} else if (0 == gpio_get(channel_ports[tdo], channel_pins[tdo])) { // signal is low
jtag_tdo[tdo] &= ~(1U << bit); // clear bit
}
}
}
}
static void command_jtag_scan(void* argument)
{
(void)argument; // we won't use the argument
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;
}
mux_select(-1); // disable multiplexer
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_clear(GPIO_PORT(TARGET_EN), GPIO_PIN(TARGET_EN)); // power level shifter
sleep_us(100); // wait a tiny bit for the pull-up to be active
printf("searching JTAG on channels CH%02u-CH%02u\n", channel_start, channel_stop);
printf("searching for TDO using IDCODE scan on TCK/TMS (%u combinations): ", (channel_stop - channel_start + 1) * (channel_stop - channel_start));
uint8_t idcodes[CHANNEL_NUMBERS]; // how many IDCODEs have been found on channel
for (uint8_t i = 0; i < LENGTH(idcodes); i++) {
idcodes[i] = 0;
}
bool tck_ok[CHANNEL_NUMBERS]; // if channel is a possible TCK
for (uint8_t i = 0; i < LENGTH(tck_ok); i++) {
tck_ok[i] = false;
}
bool tms_ok[CHANNEL_NUMBERS]; // if channel is a possible TMS
for (uint8_t i = 0; i < LENGTH(tms_ok); i++) {
tms_ok[i] = false;
}
jtag_tdi_ch = -1; // we don't use TDI for now
for (uint8_t tck = channel_start; tck <= channel_stop; tck++) { // use channel as TCK output
for (uint8_t tms = channel_start; tms <= channel_stop; tms++) { // use channel as TMS output
if (tck == tms) { // don't use the same channel for TCK and TMS
continue;
}
gpio_set(channel_ports[tck], channel_pins[tck]); // clock is idle high
gpio_mode_setup(channel_ports[tck], GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, channel_pins[tck]); // set channel for TCK as output
jtag_tck_ch = tck; // remember which channel we use for TCK for the transaction
gpio_set(channel_ports[tms], channel_pins[tms]); // start high (to go to reset state)
gpio_mode_setup(channel_ports[tms], GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, channel_pins[tms]); // set channel for TMS as output
jtag_tms_ch = tms; // remember which channel we use for TMS for the transaction
jtag_transaction(0xffffffff, 0, 26); // ensure we are is reset state, even on SWD devices (needs 50 TMS hig);
jtag_transaction(0xffffffff, 0, 26); // continuation
jtag_transaction(0xE73C, 0, 16); // send sequence to switch any SWD device back to JTAG (this constant magic value)
// all other channel should already be inputs
jtag_transaction(0x3f | (0 << 6) | (1 << 7) | (0 << 8) | (0 << 9), 0, 6 + 1 + 1 + 1 + 1); // go back to JTAG TEST-LOGIC_RESET (5 bits should be enough to go from any state to RESET, but we a one just to be sure) -> RUN-TEST/IDLE -> SELECT-DR-SCAN -> CAPTURE-DR -> SHIFT-DR states
bool idcode[CHANNEL_NUMBERS]; // when a new IDCODE has been found
for (uint8_t i = 0; i < LENGTH(idcode); i++) {
idcode[i] = true;
}
bool idcode_scan = true; // if we need to check for an IDCODE
bool idcode_found = false; // if we found an IDCODE (in this combination)
uint8_t idcode_max = 20; // maximum number of chained IDCODEs
while (idcode_scan && idcode_max) {
idcode_scan = false; // stop scanning (unless we find an IDCODE)
jtag_transaction(0, 0, 32); // read 32-bit IDCODE
for (uint8_t tdo = channel_start; tdo < channel_stop; tdo++) {
if (tdo == tms || tdo == tck) { // channel already used for other signal
continue;
} else if (!idcode[tdo]) { // IDCODE already exhausted
continue; // any other data on the line should be noise
} else if (0 == jtag_tdo[tdo] || UINT32_MAX == jtag_tdo[tdo]) { // no IDCODE received (line constant low or pulled up
idcode[tdo] = false;
} else if (0 == (jtag_tdo[tdo] & 0x1)) { // RAO bit is wrong
continue;
} else { // IDCODE received
printf("\nIDCODE found: TCK=CH%02u TMS=CH%02u TDO=CH%02u CHAIN=%u IDCODE=%+08x (", tck, tms, tdo, idcodes[tdo] + 1, jtag_tdo[tdo]); // show finding
print_idcode(jtag_tdo[tdo]);
puts(")");
idcodes[tdo]++; // count the number of IDCODEs found
tck_ok[tck] = true; // remember we found TCK on this channel
tms_ok[tms] = true; // remember we found TMS on this channel
idcode_found = true; // remember we found an IDCODE
idcode_scan = true; // continue scanning for the next code
}
}
idcode_max--; // to not be stuck in a loop
}
if (idcode_found) {
putc('\n'); // continue dot pattern on new line
}
gpio_mode_setup(channel_ports[tck], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[tck]); // set channel for TCK back to input
jtag_tck_ch = -1; // clear channel configuration
gpio_mode_setup(channel_ports[tms], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[tms]); // set channel for TMS back to input
jtag_tms_ch = -1; // clear channel configuration
putc('.'); // one combination completed
}
}
putc('\n'); // all combinations completed
// get max length of scan chain
uint8_t chain = 0;
for (uint8_t tdo = channel_start; tdo <= channel_stop; tdo++) {
if (idcodes[tdo] > chain) {
chain = idcodes[tdo];
}
}
if (0 == chain) {
puts("no IDCODE found\n");
return;
}
printf("searching for TDI using IDCODE feeding on TCK/TMS/TDO: ");
jtag_tdi_ch = -1; // we don't use TDI for now
for (uint8_t tck = channel_start; tck <= channel_stop; tck++) { // test channel as TCK output
if (!tck_ok[tck]) { // this is not one of the possibles TCK
continue;
}
for (uint8_t tms = channel_start; tms <= channel_stop; tms++) { // test channel as TMS output
if (tck == tms) { // don't use the same channel for TCK and TMS
continue;
}
if (!tms_ok[tms]) { // this is not one of the possible TMS
continue;
}
for (uint8_t tdi = channel_start; tdi <= channel_stop; tdi++) { // test channel as TDI
if (tck == tdi) { // don't use the same channel for TCK and TDI
continue;
}
if (tms == tdi) { // don't use the same channel for TMS and TDI
continue;
}
bool tdi_found = false; // if we found a TDI pin in this combination
gpio_set(channel_ports[tck], channel_pins[tck]); // clock is idle high
gpio_mode_setup(channel_ports[tck], GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, channel_pins[tck]); // set channel for TCK as output
jtag_tck_ch = tck; // remember which channel we use for TCK for the transaction
gpio_set(channel_ports[tms], channel_pins[tms]); // start high (to go to reset state)
gpio_mode_setup(channel_ports[tms], GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, channel_pins[tms]); // set channel for TMS as output
jtag_tms_ch = tms; // remember which channel we use for TMS for the transaction
gpio_set(channel_ports[tdi], channel_pins[tdi]); // start high (idle state)
gpio_mode_setup(channel_ports[tdi], GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, channel_pins[tdi]); // set channel for TMS back to input
jtag_tdi_ch = tdi; // remember which channel we use for TDI for the transaction
// all other channels are already inputs (to check TDO)
// switching from SWD to JTAG has already been done
jtag_transaction(0x3f | (0 << 6) | (1 << 7) | (0 << 8) | (0 << 9), 0, 6 + 1 + 1 + 1 + 1); // go to IDCODE state: back to JTAG TEST-LOGIC_RESET (5 bits should be enough to go from any state to RESET, but we a one just to be sure) -> RUN-TEST/IDLE -> SELECT-DR-SCAN -> CAPTURE-DR -> SHIFT-DR
for (uint8_t sequence = 0; sequence <= chain; sequence++) { // go through longest chain
jtag_transaction(0, JTAG_PATTERN, 32); // send pattern into chain
for (uint8_t tdo = channel_start; tdo <= channel_stop; tdo++) { // test channel as TDO
if (tck == tdo) { // don't use the same channel for TCK and TDO
continue;
}
if (tms == tdo) { // don't use the same channel for TMS and TDO
continue;
}
if (0 == idcodes[tdo]) { // we did not seen any IDCODE on this pin
continue;
}
if (sequence < idcodes[tdo]) { // we did not got through the chain yet, thus we don't expect the pattern
continue;
}
if (0 == jtag_tdo[tdo] || 0xffffffff == jtag_tdo[tdo]) { // we received nothing
continue;
}
if (JTAG_PATTERN == jtag_tdo[tdo]) { // we found out pattern
printf("\nJTAG found: TCK=CH%02u TMS=CH%02u TDO=CH%02u TDI=CH%02u CHAIN=%u", tck, tms, tdo, tdi, sequence);
tdi_found = true; // remember we found one and printed
}
}
}
if (tdi_found) {
putc('\n'); // continue dot pattern on new line
} else {
putc('.');
}
gpio_mode_setup(channel_ports[tck], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[tck]); // set channel for TCK back to input
jtag_tck_ch = -1; // clear channel configuration
gpio_mode_setup(channel_ports[tms], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[tms]); // set channel for TMS back to input
jtag_tms_ch = -1; // clear channel configuration
gpio_mode_setup(channel_ports[tdi], GPIO_MODE_INPUT, GPIO_PUPD_NONE, channel_pins[tdi]); // set channel for TDI back to input
jtag_tdi_ch = -1; // clear channel configuration
} // end test channel as TDI
} // end test channel as TMS
} // end test channel as TCK
putc('\n'); // all combinations completed
}
static void command_voltages(void* argument)
{
(void)argument; // we won't use the argument
float* voltages;
print_target(); // print target voltage (also sets measurement conditions)
puts("signal voltages:\n");
for (uint8_t i = channel_start; i <= channel_stop; i++) {
printf("- CH%02u ", i);
mux_select(i); // select the channel
voltages = measure_voltages(); // measure raw voltages
print_fpu(voltages[2], 2);
puts(" V\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
print_target(); // 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("signal voltage pulled pull-up pulled pull-down signal\n");
puts(" name raw (V) down (V) (kOhm) up (V) (kOhm) 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
gpio_set(GPIO_PORT(TARGET_EN), GPIO_PIN(TARGET_EN)); // ensure the level shifters pulling up the signals are not enabled
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(" ");
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
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.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");
}
putc('\n');
}
mux_select(-1); // disable multiplexer
}
/** 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);
}
/** show date and time
* @param[in] argument date and time to set
*/
static void command_datetime(void* argument)
{
char* datetime = (char*)argument; // argument is optional date time
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
printf(malformed);
return;
}
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)
printf(malformed);
return;
}
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);
}
}
/** 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 = 'd',
.name = "date",
.command_description = "show/set date and time",
.argument = MENU_ARGUMENT_STRING,
.argument_description = "[YYYY-MM-DD HH:MM:SS]",
.command_handler = &command_datetime,
},
{
.shortcut = 'r',
.name = "reset",
.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 = 's',
.name = "swd",
.command_description = "scan for SWD interfaces",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_swd_scan,
},
{
.shortcut = 'j',
.name = "jtag",
.command_description = "scan for JTAG interfaces",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_jtag_scan,
},
{
.shortcut = 'v',
.name = "voltage",
.command_description = "measure target and signal voltages",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_voltages,
},
{
.shortcut = 't',
.name = "type",
.command_description = "identify signal types",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_types,
},
{
.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 SWJ 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
#if !(DEBUG)
// show watchdog information
printf("setup watchdog: %.2fs", WATCHDOG_PERIOD / 1000.0);
if (FLASH_OBR & FLASH_OBR_OPTERR) {
puts(" (option bytes not set in flash: software watchdog used, not automatically started at reset)\n");
} else if (FLASH_OBR & FLASH_OBR_WDG_SW) {
puts(" (software watchdog used, not automatically started at reset)\n");
} else {
puts(" (hardware watchdog used, automatically started at reset)\n");
}
#endif
// 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
}
boot_time = rtc_to_seconds(); // remember the start time
puts("OK\n");
// 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");
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
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(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
puts("OK\n");
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");
puts("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("OK\n");
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(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("OK\n");
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");
}
// 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
led_on(); // switch LED to indicate booting completed
while (true) { // infinite loop
iwdg_reset(); // kick the dog
if (user_input_available) { // user input is available
action = true; // action has been performed
led_toggle(); // toggle LED
char c = user_input_get(); // store receive character
terminal_send(c); // send received character to terminal
}
if (button_flag) { // user pressed button
action = true; // action has been performed
puts("button pressed\n");
led_toggle(); // toggle LED
sleep_ms(100); // wait a bit to remove noise and double trigger
button_flag = false; // reset flag
}
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
}
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
}
}
Reference in New Issue View Git Blame Copy Permalink