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/>.
*
*/
2016-08-14 21:04:08 +02:00
/** STM32F1 example
2016-08-14 21:02:38 +02:00
* @ file main . c
* @ author King Kévin < kingkevin @ cuvoodoo . info >
* @ date 2016
*/
2016-01-17 14:54:54 +01:00
/* standard libraries */
# include <stdint.h> // standard integer types
2017-03-07 11:50:50 +01:00
# include <stdbool.h> // boolean type
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
# 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-03-07 11:50:50 +01:00
# include "print.h" // printing utilities
2016-01-17 14:54:54 +01:00
# include "usart.h" // USART utilities
2016-01-18 16:23:35 +01:00
# include "usb_cdcacm.h" // USB CDC ACM utilities
2017-02-08 14:06:06 +01:00
# include "rtc_ds1307.h" // DS1307 RTC utilities
2017-03-07 17:31:25 +01:00
# include "led_tm1637.h" // TM1637 7-segment controller utilities
# include "led_max7219.h" // MAX7219 7-segment controller utilities
2016-01-17 14:54:54 +01:00
2016-10-23 17:42:27 +02:00
# define WATCHDOG_PERIOD 10000 /**< watchdog period in ms */
2016-08-14 21:02:38 +02:00
/** @defgroup main_flags flag set in interrupts to be processed in main task
* @ {
*/
2017-04-02 10:15:13 +02:00
volatile bool rtc_tick_flag = false ; /**< flag set when RTC ticked */
2016-08-14 21:02:38 +02:00
/** @} */
2017-04-02 10:15:13 +02:00
# define SQUARE_WAVE_PORT B /**< port connected to RTC DS1307 square wave output */
# define SQUARE_WAVE_PIN 0 /**< pin connected to RTC DS1307 square wave output */
2016-10-23 17:42:27 +02:00
/** user input command */
static char command [ 32 ] = { 0 } ;
/** user input command index */
uint8_t command_i = 0 ;
2016-01-17 14:54:54 +01:00
2017-03-08 09:47:11 +01:00
size_t putc ( char c )
2017-03-07 11:50:50 +01:00
{
2017-03-08 09:47:11 +01:00
size_t length = 0 ; // number of characters printed
static char newline = 0 ; // to remember on which character we sent the newline
if ( 0 = = c ) {
length = 0 ; // don't print string termination character
} else if ( ' \r ' = = c | | ' \n ' = = c ) { // send CR+LF newline for most carriage return and line feed combination
if ( 0 = = newline | | c = = newline ) { // send newline only if not already send (and only once on \r\n or \n\r)
usart_putchar_nonblocking ( ' \r ' ) ; // send CR over USART
cdcacm_putchar ( ' \r ' ) ; // send CR over USB
usart_putchar_nonblocking ( ' \n ' ) ; // send LF over USART
cdcacm_putchar ( ' \n ' ) ; // send LF over USB
length + = 2 ; // remember we printed 2 characters
newline = c ; // remember on which character we sent the newline
} else {
length = 0 ; // the \r or \n of \n\r or \r\n has already been printed
}
} else {
usart_putchar_nonblocking ( c ) ; // send byte over USART
cdcacm_putchar ( c ) ; // send byte over USB
newline = 0 ; // clear new line
length + + ; // remember we printed 1 character
}
return length ; // return number of characters printed
2017-03-07 11:50:50 +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
{
2016-08-14 21:02:38 +02:00
// split command
const char * delimiter = " " ;
char * word = strtok ( str , delimiter ) ;
if ( ! word ) {
goto error ;
}
// parse command
if ( 0 = = strcmp ( word , " help " ) ) {
2017-03-08 09:47:11 +01:00
printf ( " available commands: \n " ) ;
printf ( " led [on|off|toggle] \n " ) ;
printf ( " time [HH:MM:SS] \n " ) ;
printf ( " date [YYYY-MM-DD] \n " ) ;
2016-08-14 21:02:38 +02:00
} else if ( 0 = = strcmp ( word , " led " ) ) {
word = strtok ( NULL , delimiter ) ;
if ( ! word ) {
goto error ;
} else if ( 0 = = strcmp ( word , " on " ) ) {
led_on ( ) ; // switch LED on
2017-03-08 09:47:11 +01:00
printf ( " LED switched on \n " ) ; // notify user
2016-08-14 21:02:38 +02:00
} else if ( 0 = = strcmp ( word , " off " ) ) {
led_off ( ) ; // switch LED off
2017-03-08 09:47:11 +01:00
printf ( " LED switched off \n " ) ; // notify user
2016-08-14 21:02:38 +02:00
} else if ( 0 = = strcmp ( word , " toggle " ) ) {
led_toggle ( ) ; // toggle LED
2017-03-08 09:47:11 +01:00
printf ( " LED toggled \n " ) ; // notify user
2016-08-14 21:02:38 +02:00
} else {
goto error ;
}
2017-02-08 14:06:06 +01:00
} else if ( 0 = = strcmp ( word , " time " ) ) {
word = strtok ( NULL , delimiter ) ;
if ( ! word ) {
printf ( " current time: %02u:%02u:%02u \n " , rtc_ds1307_read_hours ( ) , rtc_ds1307_read_minutes ( ) , rtc_ds1307_read_seconds ( ) ) ; // get and print time from external RTC
} else if ( strlen ( word ) ! = 8 | | word [ 0 ] < ' 0 ' | | word [ 0 ] > ' 2 ' | | word [ 1 ] < ' 0 ' | | word [ 1 ] > ' 9 ' | | word [ 3 ] < ' 0 ' | | word [ 3 ] > ' 5 ' | | word [ 4 ] < ' 0 ' | | word [ 4 ] > ' 9 ' | | word [ 6 ] < ' 0 ' | | word [ 6 ] > ' 5 ' | | word [ 7 ] < ' 0 ' | | word [ 7 ] > ' 9 ' ) { // time format is incorrect
goto error ;
} else {
if ( ! rtc_ds1307_write_hours ( ( word [ 0 ] - ' 0 ' ) * 10 + ( word [ 1 ] - ' 0 ' ) * 1 ) ) {
2017-03-08 09:47:11 +01:00
printf ( " setting hours failed \n " ) ;
2017-02-08 14:06:06 +01:00
} else if ( ! rtc_ds1307_write_minutes ( ( word [ 3 ] - ' 0 ' ) * 10 + ( word [ 4 ] - ' 0 ' ) * 1 ) ) {
2017-03-08 09:47:11 +01:00
printf ( " setting minutes failed \n " ) ;
2017-02-08 14:06:06 +01:00
} else if ( ! rtc_ds1307_write_seconds ( ( word [ 6 ] - ' 0 ' ) * 10 + ( word [ 7 ] - ' 0 ' ) * 1 ) ) {
2017-03-08 09:47:11 +01:00
printf ( " setting seconds failed \n " ) ;
2017-02-08 14:06:06 +01:00
} else {
rtc_ds1307_oscillator_enable ( ) ; // be sure the oscillation is enabled
2017-03-08 09:47:11 +01:00
printf ( " time set \n " ) ;
2017-02-08 14:06:06 +01:00
}
}
} else if ( 0 = = strcmp ( word , " date " ) ) {
word = strtok ( NULL , delimiter ) ;
if ( ! word ) {
printf ( " current date: 20%02u-%02u-%02u \n " , rtc_ds1307_read_year ( ) , rtc_ds1307_read_month ( ) , rtc_ds1307_read_date ( ) ) ;
} else if ( strlen ( word ) ! = 10 | | word [ 0 ] ! = ' 2 ' | | word [ 1 ] ! = ' 0 ' | | word [ 2 ] < ' 0 ' | | word [ 2 ] > ' 9 ' | | word [ 3 ] < ' 0 ' | | word [ 3 ] > ' 9 ' | | word [ 5 ] < ' 0 ' | | word [ 5 ] > ' 1 ' | | word [ 6 ] < ' 0 ' | | word [ 6 ] > ' 9 ' | | word [ 8 ] < ' 0 ' | | word [ 8 ] > ' 3 ' | | word [ 9 ] < ' 0 ' | | word [ 9 ] > ' 9 ' ) {
goto error ;
} else {
if ( ! rtc_ds1307_write_year ( ( word [ 2 ] - ' 0 ' ) * 10 + ( word [ 3 ] - ' 0 ' ) * 1 ) ) {
2017-03-08 09:47:11 +01:00
printf ( " setting year failed \n " ) ;
2017-02-08 14:06:06 +01:00
} else if ( ! rtc_ds1307_write_month ( ( word [ 5 ] - ' 0 ' ) * 10 + ( word [ 6 ] - ' 0 ' ) * 1 ) ) {
2017-03-08 09:47:11 +01:00
printf ( " setting month failed \n " ) ;
2017-02-08 14:06:06 +01:00
} else if ( ! rtc_ds1307_write_date ( ( word [ 8 ] - ' 0 ' ) * 10 + ( word [ 9 ] - ' 0 ' ) * 1 ) ) {
2017-03-08 09:47:11 +01:00
printf ( " setting day failed \n " ) ;
2017-02-08 14:06:06 +01:00
} else {
2017-03-08 09:47:11 +01:00
printf ( " date set \n " ) ;
2017-02-08 14:06:06 +01:00
}
}
2016-08-14 21:02:38 +02:00
} else {
goto error ;
}
return ; // command successfully processed
error :
2017-03-08 09:47:11 +01:00
printf ( " command not recognized. enter help to list commands \n " ) ;
2016-10-23 17:42:27 +02:00
return ;
2016-01-17 14:54:54 +01:00
}
2016-08-14 21:02:38 +02:00
/** program entry point
* this is the firmware function started by the micro - controller
*/
2016-10-23 17:42:27 +02:00
void main ( void ) ;
void main ( void )
2016-01-17 15:03:10 +01: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-03-07 11:50:50 +01:00
board_setup ( ) ; // setup board
usart_setup ( ) ; // setup USART for user communication
cdcacm_setup ( ) ; // setup USB ACM (serial) for user communication
2017-03-08 09:47:11 +01:00
printf ( " welcome to the STM32F1 CuVoodoo example code \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
2017-03-07 11:50:50 +01:00
printf ( " watchdog set to (%2u.%2us) \n " , WATCHDOG_PERIOD / 1000 , ( WATCHDOG_PERIOD / 10 ) % 100 ) ;
2017-01-30 09:44:51 +01:00
if ( FLASH_OBR & FLASH_OBR_OPTERR ) {
2017-03-08 09:47:11 +01:00
printf ( " option bytes not set in flash: software wachtdog used (not started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
} else if ( FLASH_OBR & FLASH_OBR_WDG_SW ) {
2017-03-08 09:47:11 +01:00
printf ( " software wachtdog used (not started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
} else {
2017-03-08 09:47:11 +01:00
printf ( " hardware wachtdog used (started at reset) \n " ) ;
2017-01-30 09:44:51 +01:00
}
# endif
2017-04-02 10:15:13 +02:00
// disable internal RTC
printf ( " disable internal RTC: " ) ;
rcc_periph_clock_enable ( RCC_PWR ) ; // enable power domain clock
rcc_periph_clock_enable ( RCC_BKP ) ; // enable backup domain clock
pwr_disable_backup_domain_write_protect ( ) ; // enable write on backup domain (including RTC)
RCC_BDCR & = ~ RCC_BDCR_RTCEN ; // disable RTC
2017-03-08 09:47:11 +01:00
printf ( " OK \n " ) ;
2016-10-23 17:42:27 +02:00
2017-02-08 14:06:06 +01:00
// setup external RTC
2017-03-08 09:47:11 +01:00
printf ( " setup external RTC: " ) ;
2017-02-08 14:06:06 +01:00
rtc_ds1307_setup ( ) ; // setup external RTC module
2017-04-02 10:15:13 +02:00
// enable square wave output and configure input interrupt
rtc_ds1307_write_square_wave ( 1 ) ; // enable 1 Hz square wave output to sync on seconds
rcc_periph_clock_enable ( RCC_GPIO ( SQUARE_WAVE_PORT ) ) ; // enable clock for GPIO
gpio_set_mode ( GPIO ( SQUARE_WAVE_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( SQUARE_WAVE_PIN ) ) ; // set button pin to input
rcc_periph_clock_enable ( RCC_AFIO ) ; // enable alternate function clock for external interrupt
exti_select_source ( EXTI ( SQUARE_WAVE_PIN ) , GPIO ( SQUARE_WAVE_PORT ) ) ; // mask external interrupt of this pin only for this port
exti_set_trigger ( EXTI ( SQUARE_WAVE_PIN ) , EXTI_TRIGGER_FALLING ) ; // trigger on falling edge of square wave (this is also when the RTC register are updated)
exti_enable_request ( EXTI ( SQUARE_WAVE_PIN ) ) ; // enable external interrupt
nvic_enable_irq ( NVIC_EXTI_IRQ ( SQUARE_WAVE_PIN ) ) ; // enable interrupt
2017-03-08 09:47:11 +01:00
printf ( " OK \n " ) ;
2017-04-02 10:15:13 +02:00
2017-02-08 14:06:06 +01:00
// display date
uint8_t * rtc_ds1307_time = rtc_ds1307_read_time ( ) ; // get time/date from external RTC
2017-04-02 10:15:13 +02:00
uint8_t rtc_seconds = 0 ; // count the number of seconds passed and sync time on minute
2017-02-09 12:45:16 +01:00
if ( rtc_ds1307_time = = NULL ) {
2017-03-08 09:47:11 +01:00
printf ( " could not get time from DS1307 \n " ) ;
2017-02-09 12:45:16 +01:00
} else {
2017-04-02 10:15:13 +02:00
rtc_seconds = rtc_ds1307_time [ 0 ] ; // remember seconds of minute
2017-02-09 12:45:16 +01:00
printf ( " current date: 20%02u-%02u-%02u %02u:%02u:%02u \n " , rtc_ds1307_time [ 6 ] , rtc_ds1307_time [ 5 ] , rtc_ds1307_time [ 4 ] , rtc_ds1307_time [ 2 ] , rtc_ds1307_time [ 1 ] , rtc_ds1307_time [ 0 ] ) ;
}
2017-04-02 10:15:13 +02:00
// verify is external RTC is running
if ( rtc_ds1307_oscillator_disabled ( ) ) {
printf ( " /! \\ RTC oscillator is disabled: the battery may be empty \n " ) ;
rtc_ds1307_oscillator_enable ( ) ; // enable oscillator again
}
2017-02-08 14:06:06 +01:00
2017-03-07 17:31:25 +01:00
// setup TM1637 and MAX7219 7-segments displays
2017-03-08 09:47:11 +01:00
printf ( " setup 7-segment displays: " ) ;
2017-03-07 17:31:25 +01:00
led_tm1637_setup ( ) ; // setup TM1637
led_max7219_setup ( ) ; // setup MAX7219
if ( ! led_tm1637_time ( 88 , 88 ) ) { // test TM1637 display
2017-03-08 09:47:11 +01:00
printf ( " could not send time to TM1637 \n " ) ;
2017-02-08 12:44:34 +01:00
}
2017-03-07 17:31:25 +01:00
if ( ! led_tm1637_on ( ) ) { // switch on TM1637 display
2017-03-08 09:47:11 +01:00
printf ( " could not switch on TM1637 \n " ) ;
2017-02-08 12:44:34 +01:00
}
2017-04-01 17:19:15 +02:00
led_max7219_intensity ( 15 , 8 , 0 ) ; // set brightness max and enable all digits on 1st display
led_max7219_intensity ( 15 , 8 , 1 ) ; // set brightness max and enable all digits on 1st display
led_max7219_test ( true , 0 ) ; // test 1st MAX7219 display
led_max7219_test ( true , 1 ) ; // test 2nd MAX7219 display
2017-02-08 12:44:34 +01:00
for ( uint32_t i = 0 ; i < 5000000 ; i + + ) { // wait a bit to have the user check the display
__asm__ ( " nop " ) ;
}
if ( ! led_tm1637_text ( " " ) ) { // clear display
2017-03-08 09:47:11 +01:00
printf ( " could not clear \n " ) ;
2017-02-08 12:44:34 +01:00
}
if ( ! led_tm1637_off ( ) ) { // switch off display
2017-03-08 09:47:11 +01:00
printf ( " could not switch off TM1637 \n " ) ;
2017-02-08 12:44:34 +01:00
}
2017-04-01 17:19:15 +02:00
led_max7219_test ( false , 0 ) ; // go back in normal operation
led_max7219_test ( false , 1 ) ; // go back in normal operation
led_max7219_off ( 0 ) ; // switch 1st display off
led_max7219_off ( 1 ) ; // switch 2nd display off
2017-03-08 09:47:11 +01:00
printf ( " OK \n " ) ;
2017-03-08 11:18:58 +01:00
2017-04-01 17:19:15 +02:00
led_max7219_number ( rtc_ds1307_time [ 2 ] * 1000000 + rtc_ds1307_time [ 1 ] * 10000 + rtc_ds1307_time [ 0 ] * 100 , 0x54 , 0 ) ; // display time on 1nd display
led_max7219_number ( 20000000 + rtc_ds1307_time [ 6 ] * 10000 + rtc_ds1307_time [ 5 ] * 100 + rtc_ds1307_time [ 4 ] , 0x14 , 1 ) ; // display date on 2nd display
led_max7219_on ( 0 ) ; // switch 1st display on
led_max7219_on ( 1 ) ; // switch 2nd display on
2016-08-14 21:02:38 +02:00
// main loop
2017-03-08 09:47:11 +01:00
printf ( " command input: ready \n " ) ;
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-10-23 17:42:27 +02:00
char c = ' \0 ' ; // to store received character
2016-08-14 21:02:38 +02:00
bool char_flag = false ; // a new character has been received
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
2016-08-14 21:02:38 +02:00
while ( usart_received ) { // data received over UART
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
2016-08-14 21:02:38 +02:00
c = usart_getchar ( ) ; // store receive character
char_flag = true ; // notify character has been received
2016-01-17 15:03:10 +01:00
}
2016-08-14 21:02:38 +02:00
while ( cdcacm_received ) { // data received over USB
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
2016-08-14 21:02:38 +02:00
c = cdcacm_getchar ( ) ; // store receive character
char_flag = true ; // notify character has been received
2016-01-18 16:23:35 +01:00
}
2016-08-14 21:02:38 +02:00
while ( char_flag ) { // user data received
char_flag = false ; // reset flag
2016-02-18 10:39:08 +01:00
action = true ; // action has been performed
2017-03-07 11:50:50 +01:00
putc ( c ) ; // echo receive character
2016-08-14 21:02:38 +02:00
if ( c = = ' \r ' | | c = = ' \n ' ) { // end of command received
if ( command_i > 0 ) { // there is a command to process
command [ command_i ] = 0 ; // end string
command_i = 0 ; // prepare for next command
process_command ( command ) ; // process user command
}
} else { // user command input
command [ command_i ] = c ; // save command input
if ( command_i < LENGTH ( command ) - 2 ) { // verify if there is place to save next character
command_i + + ; // save next character
}
}
}
while ( button_flag ) { // user pressed button
action = true ; // action has been performed
2017-03-08 09:47:11 +01:00
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
}
2017-04-02 10:15:13 +02:00
while ( rtc_tick_flag ) { // the external RTC ticked
rtc_tick_flag = false ; // reset flag
2016-08-14 21:02:38 +02:00
action = true ; // action has been performed
2017-04-02 10:15:13 +02:00
led_toggle ( ) ; // toggle LED (good to indicate if main function is stuck)
rtc_seconds + + ; // increment number of seconds passed
if ( rtc_seconds > = 60 ) { // one minute passed
rtc_ds1307_time = rtc_ds1307_read_time ( ) ; // get time/date from external RTC
if ( rtc_ds1307_time = = NULL ) {
printf ( " could not get time from DS1307: resetting \n " ) ;
rtc_ds1307_setup ( ) ; // resetting periph
} else {
rtc_seconds = rtc_ds1307_time [ 0 ] ; // get actual number of seconds
if ( 0 = = rtc_ds1307_time [ 1 ] & & 0 = = rtc_ds1307_time [ 2 ] ) { // new day arrived
led_max7219_number ( 20000000 + rtc_ds1307_time [ 6 ] * 10000 + rtc_ds1307_time [ 5 ] * 100 + rtc_ds1307_time [ 4 ] , 0x14 , 1 ) ; // display date on 2nd display
}
2017-02-09 12:45:16 +01:00
}
2017-02-08 12:44:34 +01:00
}
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
2017-04-02 10:15:13 +02:00
void EXTI_ISR ( SQUARE_WAVE_PIN ) ( void )
2016-08-14 21:02:38 +02:00
{
2017-04-02 10:15:13 +02:00
exti_reset_request ( EXTI ( SQUARE_WAVE_PIN ) ) ; // reset interrupt
rtc_tick_flag = true ; // perform button action
2016-08-14 21:02:38 +02:00
}
2017-04-02 10:15:13 +02:00