2016-01-17 14:54:54 +01:00
/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
*
*/
2018-10-15 22:06:29 +02:00
/** STM32F1 application to strobe electricity
* @ file
2016-08-14 21:02:38 +02:00
* @ author King Kévin < kingkevin @ cuvoodoo . info >
2018-04-06 17:37:17 +02:00
* @ date 2016 - 2018
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
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
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
2018-02-18 15:18:42 +01:00
# include "uart.h" // USART 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
2018-10-15 22:06:29 +02:00
# include "ir_nec.h" // InfraRed NEC decoding utilities
2016-01-17 14:54:54 +01:00
2018-10-15 22:06:29 +02:00
# define WATCHDOG_PERIOD 20000 /**< watchdog period in ms */
2016-10-23 17:42:27 +02:00
2016-08-14 21:02:38 +02:00
/** @defgroup main_flags flag set in interrupts to be processed in main task
* @ {
*/
volatile bool rtc_internal_tick_flag = false ; /**< flag set when internal RTC ticked */
/** @} */
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
2018-02-18 15:18:42 +01:00
uart_putchar_nonblocking ( ' \r ' ) ; // send CR over USART
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
uart_putchar_nonblocking ( c ) ; // send byte over USART
usb_cdcacm_putchar ( c ) ; // send byte over USB
length + + ; // remember we printed 1 character
last_c = c ; // remember last character
2017-04-03 13:32:45 +02:00
return length ; // return number of characters printed
2016-01-17 14:54:54 +01:00
}
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
*/
static void command_version ( void * argument ) ;
/** show uptime
* @ param [ in ] argument no argument required
*/
static void command_uptime ( void * argument ) ;
/** reset board
* @ param [ in ] argument no argument required
*/
static void command_reset ( void * argument ) ;
/** switch to DFU bootloader
* @ param [ in ] argument no argument required
*/
static void command_bootloader ( void * argument ) ;
/** list of all supported commands */
static const struct menu_command_t menu_commands [ ] = {
{
. shortcut = ' h ' ,
. name = " help " ,
. command_description = " display help " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_help ,
} ,
{
. shortcut = ' v ' ,
. name = " version " ,
. command_description = " show software and hardware version " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_version ,
} ,
{
. shortcut = ' u ' ,
. name = " uptime " ,
. command_description = " show uptime " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_uptime ,
} ,
{
. shortcut = ' r ' ,
. name = " reset " ,
. command_description = " reset board " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_reset ,
} ,
{
. shortcut = ' b ' ,
. name = " bootloader " ,
. command_description = " reboot into DFU bootloader " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_bootloader ,
} ,
} ;
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
}
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
// get device identifier (DEV_ID)
// 0x412: low-density, 16-32 kB flash
// 0x410: medium-density, 64-128 kB flash
// 0x414: high-density, 256-512 kB flash
// 0x430: XL-density, 768-1024 kB flash
// 0x418: connectivity
printf ( " device family: " ) ;
switch ( DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK ) {
case 0 : // this is a known issue document in STM32F10xxC/D/E Errata sheet, without workaround
printf ( " unreadable \n " ) ;
break ;
case 0x412 :
printf ( " low-density \n " ) ;
break ;
case 0x410 :
printf ( " medium-density \n " ) ;
break ;
case 0x414 :
printf ( " high-density \n " ) ;
break ;
case 0x430 :
printf ( " XL-density \n " ) ;
break ;
case 0x418 :
printf ( " connectivity \n " ) ;
break ;
default :
printf ( " unknown \n " ) ;
break ;
}
// show flash size
printf ( " flash size: " ) ;
if ( 0xffff = = DESIG_FLASH_SIZE ) {
printf ( " unknown (probably a defective micro-controller \n " ) ;
} else {
printf ( " %u KB \n " , DESIG_FLASH_SIZE ) ;
}
// display device identity
printf ( " device id: %08x%08x%08x \n " , DESIG_UNIQUE_ID0 , DESIG_UNIQUE_ID1 , DESIG_UNIQUE_ID2 ) ;
}
static void command_uptime ( void * argument )
{
( void ) argument ; // we won't use the argument
uint32_t uptime = rtc_get_counter_val ( ) ; // 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 ) ;
}
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
}
static void command_bootloader ( void * argument )
{
( void ) argument ; // we won't use the argument
RCC_CSR | = RCC_CSR_RMVF ; // clear reset flags
scb_reset_core ( ) ; // reset core (the bootloader will interpret it as starting into DFU)
while ( true ) ; // wait for the reset to happen
}
2016-01-17 14:54:54 +01:00
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
if ( NULL = = menu_commands | | 0 = = LENGTH ( menu_commands ) ) {
return ;
2016-08-14 21:02:38 +02:00
}
2018-04-06 17:37:17 +02:00
// 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 " ) ;
2016-08-14 21:02:38 +02:00
}
2016-01-17 14:54:54 +01:00
}
2018-10-15 22:06:29 +02:00
# define STROBE_PORT B /**< GPIO port to control strobe light */
# define STROBE_PIN 6 /**< GPIO pin to control strobe light */
# define STROBE_ON 0 /**< LED is on when pin is low (open-drain allows 5V on) */
/* strobe animations (on + off times in ms) */
/** single strobe */
static const uint16_t strobe_single [ ] = { 100 , 0 } ;
/** double strobe */
static const uint16_t strobe_double [ ] = { 100 , 200 , 100 , 0 } ;
/** switch strobe power on */
static void strobe_on ( void )
{
# if LED_ON
gpio_set ( GPIO ( STROBE_PORT ) , GPIO ( STROBE_PIN ) ) ;
# else
gpio_clear ( GPIO ( STROBE_PORT ) , GPIO ( STROBE_PIN ) ) ;
# endif
}
/** switch strobe power off */
static void strobe_off ( void )
{
# if STROBE_ON
gpio_clear ( GPIO ( STROBE_PORT ) , GPIO ( STROBE_PIN ) ) ;
# else
gpio_set ( GPIO ( STROBE_PORT ) , GPIO ( STROBE_PIN ) ) ;
# endif
}
/** toggle strobe power */
static void strobe_toggle ( void )
{
gpio_toggle ( GPIO ( STROBE_PORT ) , GPIO ( STROBE_PIN ) ) ;
}
/** play strobe animation
* @ param [ in ] animation on + off timings ( in ms )
* @ param [ in ] length animation length
*/
static void strobe_play ( const uint16_t * animation , uint16_t length )
{
for ( uint16_t i = 0 ; i < length ; i + + ) {
iwdg_reset ( ) ; // kick the dog
if ( 0 = = animation [ i ] ) { // skip animation
continue ;
}
if ( i % 2 ) { // odd index if encodes off duration
strobe_off ( ) ;
} else {
strobe_on ( ) ;
}
sleep_ms ( animation [ i ] ) ; // wait for set duration
}
strobe_off ( ) ; // switch off at the end
}
/** perform IR code related action
* @ warning the codes need to be adjusted to your remote
* @ param [ in ] code IR code
*/
static void ir_action ( const struct ir_nec_code_t * code )
{
if ( code - > repeat ) { // don't handle long button press repeating the code
return ;
}
if ( 0 ! = code - > address ) { // current remote uses this address
return ;
}
switch ( code - > command ) {
case 0x30 : // power button
strobe_toggle ( ) ;
printf ( " toggle strobe \n " ) ;
break ;
case 0x88 : // 1 button
strobe_play ( strobe_single , LENGTH ( strobe_single ) ) ;
printf ( " strobe animation 1 \n " ) ;
break ;
case 0x48 : // 2 button
strobe_play ( strobe_double , LENGTH ( strobe_double ) ) ;
printf ( " strobe animation 2 \n " ) ;
break ;
default :
printf ( " unknown code \n " ) ;
break ;
}
}
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-01-29 00:24:49 +01:00
rcc_clock_setup_in_hse_8mhz_out_72mhz ( ) ; // use 8 MHz high speed external clock to generate 72 MHz internal clock
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
2018-02-18 15:18:42 +01:00
uart_setup ( ) ; // setup USART (for printing)
2018-10-15 22:06:29 +02:00
usb_cdcacm_setup ( ) ; // setup USB CDC ACM (for printing and DFU)
// setup strobe pin
rcc_periph_clock_enable ( RCC_GPIO ( STROBE_PORT ) ) ; // enable clock for GPIO port peripheral
# if STROBE_ON
gpio_set_mode ( GPIO ( STROBE_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( STROBE_PIN ) ) ; // set pin to output push-pull do drive strobe signal
# else
gpio_set_mode ( GPIO ( STROBE_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO ( STROBE_PIN ) ) ; // set pin to output open-drain do enable strobe
# endif
strobe_off ( ) ; // switch off strobe per defaulf
ir_nec_setup ( ) ; // setup ID NEC code decoder
printf ( " \n welcome to the CuVoodoo STM32F1 spark strober \n " ) ; // print welcome message
2016-01-29 00:24:49 +01:00
2017-01-30 09:44:51 +01:00
# if !(DEBUG)
// show watchdog information
2018-04-06 17:37:17 +02:00
printf ( " setup watchdog: %.2fs " , WATCHDOG_PERIOD / 1000.0 ) ;
2017-01-30 09:44:51 +01:00
if ( FLASH_OBR & FLASH_OBR_OPTERR ) {
2018-04-06 17:37:17 +02:00
printf ( " (option bytes not set in flash: software wachtdog used, not automatically started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
} else if ( FLASH_OBR & FLASH_OBR_WDG_SW ) {
2018-04-06 17:37:17 +02:00
printf ( " (software wachtdog used, not automatically started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
} else {
2018-04-06 17:37:17 +02:00
printf ( " (hardware wachtdog used, automatically started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
}
# endif
2016-08-14 21:02:38 +02:00
// setup RTC
printf ( " setup internal RTC: " ) ;
rtc_auto_awake ( RCC_LSE , 32768 - 1 ) ; // ensure internal RTC is on, uses the 32.678 kHz LSE, and the prescale is set to our tick speed, else update backup registers accordingly (power off the micro-controller for the change to take effect)
rtc_interrupt_enable ( RTC_SEC ) ; // enable RTC interrupt on "seconds"
nvic_enable_irq ( NVIC_RTC_IRQ ) ; // allow the RTC to interrupt
printf ( " 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
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
2018-10-15 22:06:29 +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
}
2018-10-15 22:06:29 +02:00
if ( button_flag ) { // user pressed button
2016-08-14 21:02:38 +02:00
action = true ; // action has been performed
printf ( " button pressed \n " ) ;
2016-02-18 10:39:08 +01:00
led_toggle ( ) ; // toggle LED
2016-08-14 21:02:38 +02:00
for ( uint32_t i = 0 ; i < 1000000 ; i + + ) { // wait a bit to remove noise and double trigger
__asm__ ( " nop " ) ;
}
button_flag = false ; // reset flag
2016-02-18 10:39:08 +01:00
}
2018-10-15 22:06:29 +02:00
if ( rtc_internal_tick_flag ) { // the internal RTC ticked
2016-08-14 21:02:38 +02:00
rtc_internal_tick_flag = false ; // reset flag
2017-06-27 15:44:03 +02:00
action = true ; // action has been performed
2017-04-03 13:14:58 +02:00
# if !defined(BLUE_PILL) // on the blue pill the LED is close to the 32.768 kHz oscillator and heavily influences it
2018-10-15 22:06:29 +02:00
//led_toggle(); // toggle LED (good to indicate if main function is stuck)
2017-04-03 13:14:58 +02:00
# endif
2016-08-14 21:02:38 +02:00
}
2018-10-15 22:06:29 +02:00
if ( ir_nec_code_received_flag ) { // IR code received
ir_nec_code_received_flag = false ; // reset flag
led_on ( ) ; // notify user we received a code
printf ( " IR NEC code received: addr=%+02x, cmd=%+02x%s \n " , ir_nec_code_received . address , ir_nec_code_received . command , ir_nec_code_received . repeat ? " (repeat) " : " " ) ;
if ( ! ir_nec_code_received . repeat ) { // ignore repeated codes
ir_action ( & ir_nec_code_received ) ; // handle IR code
}
led_off ( ) ; // notify user we received a code
}
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
}
2016-01-29 11:25:30 +01:00
2016-08-14 21:02:38 +02:00
/** @brief interrupt service routine called when tick passed on RTC */
void rtc_isr ( void )
{
rtc_clear_flag ( RTC_SEC ) ; // clear flag
rtc_internal_tick_flag = true ; // notify to show new time
}