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/>.
*
*/
2020-02-19 21:40:03 +01:00
/** sound level enforcer
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-02-17 18:08:17 +01:00
* @ date 2016 - 2020
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
2020-02-19 21:40:03 +01:00
# include <ctype.h> // utilities to check char
# include <math.h> // for rounding floats
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
2019-09-19 11:59:02 +02:00
# if !defined(STLINKV2)
2018-02-18 15:18:42 +01:00
# include "uart.h" // USART utilities
2018-10-29 15:03:29 +01:00
# endif
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
2020-02-17 18:10:40 +01:00
# include "led_tm1637.h" // 7-segment display
2020-02-19 21:40:03 +01:00
# include "spp_rx.h" // Bluetooth SPP input
# include "flash_internal.h" // settings storage
2016-01-17 14:54:54 +01:00
2020-02-02 21:19:03 +01:00
/** watchdog period in ms */
# define WATCHDOG_PERIOD 10000
2019-06-18 17:43:43 +02:00
/** set to 0 if the RTC is reset when the board is powered on, only indicates the uptime
* set to 1 if VBAT can keep the RTC running when the board is unpowered , indicating the date and time
*/
2020-02-02 21:19:03 +01:00
# if defined(CORE_BOARD)
2019-06-18 17:43:43 +02:00
# define RTC_DATE_TIME 1
2020-02-02 21:19:03 +01:00
# else
# define RTC_DATE_TIME 0
# endif
/** number of RTC ticks per second
* @ note use integer divider of oscillator to keep second precision
*/
# define RTC_TICKS_SECOND 4
2019-06-18 17:43:43 +02:00
/** RTC time when device is started */
static time_t time_start = 0 ;
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 */
/** @} */
2020-02-19 21:40:03 +01:00
/** buffer for the data received over Bluetooth from the sound level meter */
static char spp_input_buffer [ 16 ] ;
/** how much received data is buffered */
static uint8_t spp_input_i = 0 ;
/** pin to control relay (active low) */
# define RELAY_PIN PB15
/** default sound level threshold (in dBa) */
# define SOUND_LEVEL_THRESHOLD 100
/** configured sound level threshold (in dBa) */
static uint8_t sound_level_threshold = SOUND_LEVEL_THRESHOLD ;
/** default sound level duration (in seconds) */
# define SOND_LEVEL_DURATION 10
/** configured sound level duration (in seconds) */
static uint8_t sound_level_duration = SOND_LEVEL_DURATION ;
/** if we show the received sound level value */
static bool sound_level_show = false ;
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
2019-09-19 11:59:02 +02:00
# if !defined(STLINKV2)
2018-02-18 15:18:42 +01:00
uart_putchar_nonblocking ( ' \r ' ) ; // send CR over USART
2018-10-29 15:03:29 +01:00
# endif
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
}
}
2019-09-19 11:59:02 +02:00
# if !defined(STLINKV2)
2018-04-06 17:37:17 +02:00
uart_putchar_nonblocking ( c ) ; // send byte over USART
2018-10-29 15:03:29 +01:00
# endif
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
}
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 ) ;
2019-06-18 17:43:43 +02:00
# if RTC_DATE_TIME
/** show date and time
* @ param [ in ] argument date and time to set
*/
static void command_datetime ( void * argument ) ;
# endif
2018-04-06 17:37:17 +02:00
/** 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 ) ;
2020-02-19 21:40:03 +01:00
/** load sound level threshold and duration settings from flash
* @ return if values are loaded from flash ( else set to default )
*/
static bool sound_level_load ( void )
{
uint8_t eeprom_data [ 4 ] = { 0 } ;
const bool eeprom_read = flash_internal_eeprom_read ( eeprom_data , sizeof ( eeprom_data ) ) ;
if ( eeprom_read ) {
eeprom_data [ 1 ] ^ = 0xff ; // xor value (sort of checksum)
eeprom_data [ 3 ] ^ = 0xff ; // xor value (sort of checksum)
if ( eeprom_data [ 0 ] = = eeprom_data [ 1 ] & & eeprom_data [ 2 ] = = eeprom_data [ 3 ] ) {
sound_level_threshold = eeprom_data [ 0 ] ;
sound_level_duration = eeprom_data [ 2 ] ;
return true ;
} else {
return false ;
}
} else {
sound_level_threshold = SOUND_LEVEL_THRESHOLD ;
sound_level_duration = SOND_LEVEL_DURATION ;
return false ;
}
}
/** save sound level threshold and duration settings into flash
* @ return if succeeded
*/
static bool sound_level_save ( void )
{
const uint8_t eeprom_data [ 4 ] = {
sound_level_threshold ,
sound_level_threshold ^ 0xff ,
sound_level_duration ,
sound_level_duration ^ 0xff ,
} ;
const int32_t rc = flash_internal_eeprom_write ( eeprom_data , sizeof ( eeprom_data ) ) ;
if ( rc < 0 ) {
printf ( " error saving sound level data: %d \n " , rc ) ;
}
return rc = = sizeof ( eeprom_data ) ;
}
/** set sound level threshold
* @ param [ in ] argument sound level threshold
*/
static void command_sound_level_threshold ( void * argument )
{
if ( argument ) { // tachometer value has been provided
const uint32_t value = * ( uint32_t * ) argument ; // get target sound level threshold value
sound_level_threshold = value ;
if ( ! sound_level_save ( ) ) {
puts ( " could not save sound level threshold \n " ) ;
}
}
printf ( " sound level threshold set to %u dBa \n " , sound_level_threshold ) ;
}
/** set sound level duration
* @ param [ in ] argument sound level duration
*/
static void command_sound_level_duration ( void * argument )
{
if ( argument ) { // tachometer value has been provided
const uint32_t value = * ( uint32_t * ) argument ; // get target sound level duration value
sound_level_duration = value ;
if ( ! sound_level_save ( ) ) {
puts ( " could not save sound level duration \n " ) ;
}
}
printf ( " sound level duration set to %u s \n " , sound_level_duration ) ;
}
/** show/hide received sound level
* @ param [ in ] argument not used
*/
static void command_show ( void * argument )
{
( void ) argument ; // we won't use the argument
sound_level_show = ! sound_level_show ; // toggle setting
puts ( sound_level_show ? " show " : " hide " ) ;
puts ( " received sound level \n " ) ;
}
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 ,
} ,
{
. 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 ,
} ,
2019-06-18 17:43:43 +02:00
# if RTC_DATE_TIME
{
2020-02-19 21:40:03 +01:00
. shortcut = ' D ' ,
2019-06-18 17:43:43 +02:00
. 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 ,
} ,
# endif
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 ,
} ,
{
. shortcut = ' b ' ,
. name = " bootloader " ,
. command_description = " reboot into DFU bootloader " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_bootloader ,
} ,
2020-02-19 21:40:03 +01:00
{
. shortcut = ' t ' ,
. name = " threshold " ,
. command_description = " get/set sound level threshold (in dBa) " ,
. argument = MENU_ARGUMENT_UNSIGNED ,
. argument_description = " [value] " ,
. command_handler = & command_sound_level_threshold ,
} ,
{
. shortcut = ' d ' ,
. name = " duration " ,
. command_description = " get/set sound level duration (in seconds) " ,
. argument = MENU_ARGUMENT_UNSIGNED ,
. argument_description = " [value] " ,
. command_handler = & command_sound_level_duration ,
} ,
{
. shortcut = ' s ' ,
. name = " show " ,
. command_description = " show/hide received sound level " ,
. argument = MENU_ARGUMENT_NONE ,
. argument_description = NULL ,
. command_handler = & command_show ,
} ,
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
}
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
2020-02-19 21:40:03 +01:00
printf ( " device family: " ) ;
2019-12-30 17:18:25 +01:00
switch ( DBGMCU_IDCODE & DBGMCU_IDCODE_DEV_ID_MASK ) {
2018-04-06 17:37:17 +02:00
case 0 : // this is a known issue document in STM32F10xxC/D/E Errata sheet, without workaround
2020-02-19 21:40:03 +01:00
printf ( " unreadable \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
case 0x412 :
2020-02-19 21:40:03 +01:00
printf ( " low-density \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
case 0x410 :
2020-02-19 21:40:03 +01:00
printf ( " medium-density \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
case 0x414 :
2020-02-19 21:40:03 +01:00
printf ( " high-density \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
case 0x430 :
2020-02-19 21:40:03 +01:00
printf ( " XL-density \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
case 0x418 :
2020-02-19 21:40:03 +01:00
printf ( " connectivity \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
default :
2020-02-19 21:40:03 +01:00
printf ( " unknown \n " ) ;
2018-04-06 17:37:17 +02:00
break ;
}
// show flash size
2020-02-19 21:40:03 +01:00
printf ( " flash size: " ) ;
2019-06-18 17:44:50 +02:00
if ( 0xffff = = DESIG_FLASH_SIZE ) {
2020-02-19 21:40:03 +01:00
printf ( " unknown (probably a defective micro-controller \n " ) ;
2018-04-06 17:37:17 +02:00
} 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
2020-02-17 18:08:17 +01:00
uint32_t uptime = ( rtc_get_counter_val ( ) - time_start ) / RTC_TICKS_SECOND ; // get time from internal RTC
2019-06-18 17:43:43 +02: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
# if RTC_DATE_TIME
static void command_datetime ( void * argument )
{
char * datetime = ( char * ) argument ; // argument is optional date time
if ( NULL = = argument ) { // no date and time provided, just show the current day and time
2020-02-17 18:08:17 +01:00
time_t time_rtc = rtc_get_counter_val ( ) / RTC_TICKS_SECOND ; // get time from internal RTC
2019-06-18 17:43:43 +02:00
struct tm * time_tm = localtime ( & time_rtc ) ; // convert time
printf ( " date: %d-%02d-%02d %02d:%02d:%02d \n " , 1900 + time_tm - > tm_year , time_tm - > tm_mon , time_tm - > tm_mday , time_tm - > tm_hour , time_tm - > tm_min , time_tm - > tm_sec ) ;
} else { // date and time provided, set it
const char * malformed = " date and time malformed, expecting YYYY-MM-DD HH:MM:SS \n " ;
struct tm time_tm ; // to store the parsed date time
if ( strlen ( datetime ) ! = ( 4 + 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 ] & & isdigit ( ( int8_t ) datetime [ 11 ] ) & & isdigit ( ( 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 ] ) ) ) { // verify format (good enough to not fail parsing)
printf ( malformed ) ;
return ;
}
time_tm . tm_year = strtol ( & datetime [ 0 ] , NULL , 10 ) - 1900 ; // parse year
time_tm . tm_mon = strtol ( & datetime [ 5 ] , NULL , 10 ) ; // parse month
time_tm . tm_mday = strtol ( & datetime [ 8 ] , NULL , 10 ) ; // parse day
time_tm . tm_hour = strtol ( & datetime [ 11 ] , NULL , 10 ) ; // parse hour
time_tm . tm_min = strtol ( & datetime [ 14 ] , NULL , 10 ) ; // parse minutes
time_tm . tm_sec = strtol ( & datetime [ 17 ] , NULL , 10 ) ; // parse seconds
time_t time_rtc = mktime ( & time_tm ) ; // get back seconds
2020-02-17 18:08:17 +01:00
time_start = time_rtc * RTC_TICKS_SECOND + ( rtc_get_counter_val ( ) - time_start ) ; // update uptime with current date
rtc_set_counter_val ( time_rtc * RTC_TICKS_SECOND ) ; // save date/time to internal RTC
2019-06-18 17:43:43 +02:00
printf ( " date and time saved: %d-%02d-%02d %02d:%02d:%02d \n " , 1900 + time_tm . tm_year , time_tm . tm_mon , time_tm . tm_mday , time_tm . tm_hour , time_tm . tm_min , time_tm . tm_sec ) ;
}
}
# endif
2018-04-06 17:37:17 +02: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
}
static void command_bootloader ( void * argument )
{
( void ) argument ; // we won't use the argument
2020-01-02 13:01:40 +01:00
// set DFU magic to specific RAM location
__dfu_magic [ 0 ] = ' D ' ;
__dfu_magic [ 1 ] = ' F ' ;
__dfu_magic [ 2 ] = ' U ' ;
__dfu_magic [ 3 ] = ' ! ' ;
scb_reset_system ( ) ; // reset system (core and peripherals)
2018-04-06 17:37:17 +02:00
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
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
}
2020-02-19 21:40:03 +01:00
/** parse and display sound level value
* @ param [ io ] str line with dBA measurement
* @ return parsed measurement ( 0 if failed )
* @ warning modifies str
*/
static uint8_t parse_measurement ( char * str )
{
if ( strlen ( str ) < 5 ) { // minimum size for a valid message
return 0 ;
}
const char * delimiter = " " ; // words are separated by spaces
const char * value_s = strtok ( str , delimiter ) ; // get measurement value
if ( ! value_s ) {
return 0 ;
}
const char * unit = strtok ( NULL , delimiter ) ; // get measurement unit
if ( ! unit ) {
return 0 ;
}
if ( strncmp ( " dBa " , unit , 3 ) ) { // the measurement unit is the right one
return 0 ;
}
const double value_f = atof ( value_s ) ; // get measurement value
if ( isnan ( value_f ) | | value_f < 0.1 ) {
return 0 ;
}
const uint8_t value_i = round ( value_f ) ; // get rounded measurement value
return value_i ;
}
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
2019-09-19 11:59:02 +02:00
# if !defined(STLINKV2)
2018-02-18 15:18:42 +01:00
uart_setup ( ) ; // setup USART (for printing)
2018-10-29 15:03:29 +01:00
# endif
2017-04-19 16:26:40 +02:00
usb_cdcacm_setup ( ) ; // setup USB CDC ACM (for printing)
2020-02-19 21:40:03 +01:00
puts ( " \n welcome to the CuVoodoo sound lever enforcer \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-02-19 21:16:07 +01:00
puts ( " (option bytes not set in flash: software wachtdog 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
2016-08-14 21:02:38 +02:00
// setup RTC
2020-02-19 21:16:07 +01:00
puts ( " setup internal RTC: " ) ;
2020-01-03 19:41:39 +01:00
# if defined(BLUE_PILL) || defined(STLINKV2) || defined(BLASTER) // for boards without a Low Speed External oscillator
2018-10-29 14:14:32 +01:00
// note: the blue pill LSE oscillator is affected when toggling the onboard LED, thus prefer the HSE
2020-02-02 21:19:03 +01:00
rtc_auto_awake ( RCC_HSE , 8000000 / 128 / RTC_TICKS_SECOND - 1 ) ; // use High Speed External oscillator (8 MHz / 128) as RTC clock (VBAT can't be used to keep the RTC running)
2018-10-28 22:44:53 +01:00
# else // for boards with an precise Low Speed External oscillator
2020-02-02 21:19:03 +01:00
rtc_auto_awake ( RCC_LSE , 32768 / RTC_TICKS_SECOND - 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)
2018-10-28 22:44:53 +01:00
# endif
2016-08-14 21:02:38 +02:00
rtc_interrupt_enable ( RTC_SEC ) ; // enable RTC interrupt on "seconds"
nvic_enable_irq ( NVIC_RTC_IRQ ) ; // allow the RTC to interrupt
2019-06-18 17:43:43 +02:00
time_start = rtc_get_counter_val ( ) ; // get start time from internal RTC
2020-02-19 21:16:07 +01:00
puts ( " OK \n " ) ;
2016-08-14 21:02:38 +02:00
2020-02-19 21:40:03 +01:00
puts ( " setup relay: " ) ;
gpio_set ( GPIO_PORT ( RELAY_PIN ) , GPIO_PIN ( RELAY_PIN ) ) ; // idle not activated
gpio_set_mode ( GPIO_PORT ( RELAY_PIN ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_OPENDRAIN , GPIO_PIN ( RELAY_PIN ) ) ; // set pin as output (sink to enable)
puts ( " OK \n " ) ;
puts ( " setup 7-segment display: " ) ;
2020-02-17 18:10:40 +01:00
led_tm1637_setup ( ) ;
2020-02-19 21:40:03 +01:00
led_tm1637_brightness ( LED_TM1637_14DIV16 ) ; // set maximum brightness
led_tm1637_time ( 88 , 88 ) ; // show test pattern
2020-02-17 18:10:40 +01:00
led_tm1637_on ( ) ;
2020-02-19 21:40:03 +01:00
puts ( " OK \n " ) ;
puts ( " setup SPP receiver: " ) ;
spp_rx_setup ( ) ;
puts ( " OK \n " ) ;
puts ( " read sound level settings: " ) ;
flash_internal_eeprom_setup ( 1 ) ; // dedicate one page to store the settings
if ( sound_level_load ( ) ) {
puts ( " set " ) ;
} else {
puts ( " default " ) ;
}
puts ( " values \n " ) ;
command_sound_level_threshold ( NULL ) ; // show value
command_sound_level_duration ( NULL ) ; // show value
// show sound level
iwdg_reset ( ) ; // kick the dog
led_tm1637_number ( sound_level_threshold , false ) ; // display threshold
sleep_ms ( 1000 ) ; // wait some time for the user to read
iwdg_reset ( ) ; // kick the dog
led_tm1637_text ( " dBa " ) ; // display unit
sleep_ms ( 1000 ) ; // wait some time for the user to read
iwdg_reset ( ) ; // kick the dog
led_tm1637_number ( sound_level_duration , false ) ; // display duration
sleep_ms ( 1000 ) ; // wait some time for the user to read
iwdg_reset ( ) ; // kick the dog
led_tm1637_text ( " sec " ) ; // display unit
sleep_ms ( 1000 ) ; // wait some time for the user to read
iwdg_reset ( ) ; // kick the dog
led_tm1637_brightness ( LED_TM1637_1DIV16 ) ; // set minimum brightness
led_tm1637_number ( 0 , false ) ; // show measurement
2020-02-17 18:10:40 +01:00
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-02-19 21:40:03 +01:00
uint32_t sound_level_valid = 0 ; // last time a valid value has been received
uint32_t sound_level_under = rtc_get_counter_val ( ) ; // last time the threshold has been exceeded
bool sound_level_invalid = false ; // no value has been received for some time
bool sound_level_exceeded = false ; // the level has exceeded the threshold longer than the duration
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
2020-02-19 21:40:03 +01:00
//led_toggle(); // show activity
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 ( 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
2020-02-17 18:10:40 +01:00
if ( 0 = = ( rtc_get_counter_val ( ) % RTC_TICKS_SECOND ) ) { // one second has passed
2020-02-19 21:40:03 +01:00
//led_toggle(); // heartbeat
if ( sound_level_exceeded ) {
led_tm1637_brightness ( LED_TM1637_14DIV16 ) ; // set maximum brightness
if ( ( rtc_get_counter_val ( ) / RTC_TICKS_SECOND ) % 2 ) {
led_tm1637_text ( " too " ) ;
} else {
led_tm1637_text ( " loud " ) ;
}
} else if ( ! sound_level_invalid & & ( ( ( rtc_get_counter_val ( ) - sound_level_valid ) / RTC_TICKS_SECOND ) > = 3 ) ) { // no value received
sound_level_invalid = true ; // remember the value is invalid
led_tm1637_number ( 0 , false ) ; // display empty number
led_tm1637_brightness ( LED_TM1637_1DIV16 ) ; // set minimum brightness
} else if ( ! sound_level_exceeded & & sound_level_valid > sound_level_under & & ( ( ( rtc_get_counter_val ( ) - sound_level_under ) / RTC_TICKS_SECOND ) > = sound_level_duration ) ) { // sound level exceeded for too long
sound_level_exceeded = true ; // remember the value exceeded
led_on ( ) ; // light up reset switch
gpio_clear ( GPIO_PORT ( RELAY_PIN ) , GPIO_PIN ( RELAY_PIN ) ) ; // enable relay
}
2020-02-02 21:19:03 +01:00
}
2016-08-14 21:02:38 +02:00
}
2020-02-19 21:40:03 +01:00
if ( spp_rx_input_available ) {
action = true ; // action has been performed
//led_toggle(); // show activity
const char c = spp_rx_input_get ( ) ; // get the received data (also clears the flag)
if ( ! sound_level_exceeded ) {
if ( spp_input_i < LENGTH ( spp_input_buffer ) - 1 ) { // only store when there is enough space
spp_input_buffer [ spp_input_i + + ] = c ; // store received data
spp_input_buffer [ spp_input_i ] = ' \0 ' ; // end string
}
if ( ' \n ' = = c ) { // end of line received
const uint8_t sound_level = parse_measurement ( spp_input_buffer ) ; // parse and display the received measurement
spp_input_i = 0 ; // reset buffer for next line
if ( sound_level ) {
sound_level_valid = rtc_get_counter_val ( ) ; // remember we got a valid value
if ( sound_level_show ) {
printf ( " %u dBa \n " , sound_level ) ;
}
led_tm1637_number ( sound_level , false ) ; // display number
if ( sound_level_invalid ) {
sound_level_invalid = false ; // remember we got a value
sound_level_under = sound_level_valid ; // remember the value is under the threshold
}
if ( sound_level < sound_level_threshold ) {
led_tm1637_brightness ( LED_TM1637_1DIV16 ) ; // set minimum brightness
sound_level_under = sound_level_valid ; // remember the value is under the threshold
} else {
led_tm1637_brightness ( LED_TM1637_14DIV16 ) ; // set maximum brightness
}
}
} // end of line received
} // !sound_level_exceeded
} // spp_rx_input_available
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
}