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
2017-04-02 13:42:54 +02:00
# include <libopencm3/stm32/timer.h> // timer 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 */
2017-04-02 13:42:54 +02:00
volatile bool frame_flag = false ; /**< flag set when a frame has passed */
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 */
2017-04-02 13:47:52 +02:00
volatile uint8_t rtc_seconds = 0 ; /**< number of seconds passed incremented by the square wave */
2017-04-02 13:42:54 +02:00
# define FRAME_TIMER 1 /**< timer to count frame time */
# define FRAME_RATE 25 /**< frame rate */
volatile uint8_t frame_count = 0 ; /**< number of frames passed */
2017-04-02 10:15:13 +02:00
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-04-02 13:42:54 +02:00
printf ( " welcome to the STM32F1 CuVoodoo clapperboard \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-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
2017-04-02 13:42:54 +02:00
led_max7219_setup ( 2 ) ; // setup MAX7219
2017-03-07 17:31:25 +01:00
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-02 13:42:54 +02:00
led_max7219_intensity ( 15 , 8 , 0xff ) ; // set brightness max and enable all digits
led_max7219_test ( true , 0xff ) ; // test all MAX7219 displays
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-02 13:42:54 +02:00
led_max7219_test ( false , 0xff ) ; // go back in normal operation
led_max7219_off ( 0xff ) ; // switch displays off
2017-03-08 09:47:11 +01:00
printf ( " OK \n " ) ;
2017-04-02 13:42:54 +02:00
// display date and time on 7-segments
2017-04-01 17:19:15 +02:00
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-04-02 13:42:54 +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_on ( 0xff ) ; // switch displays on
// setup frame timer
printf ( " setup frame timer: " ) ;
rcc_periph_clock_enable ( RCC_TIM ( FRAME_TIMER ) ) ; // enable clock for timer block
timer_reset ( TIM ( FRAME_TIMER ) ) ; // reset timer state
timer_set_mode ( TIM ( FRAME_TIMER ) , TIM_CR1_CKD_CK_INT , TIM_CR1_CMS_EDGE , TIM_CR1_DIR_UP ) ; // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
timer_set_prescaler ( TIM ( FRAME_TIMER ) , ( rcc_ahb_frequency / 0xffff + 1 ) - 1 ) ; // set the prescaler to so count up to one second
timer_set_period ( TIM ( FRAME_TIMER ) , 0xffff / FRAME_RATE ) ; // overflow at the end of every rate
timer_update_on_overflow ( TIM ( FRAME_TIMER ) ) ; // only use counter overflow as UEV source (use overflow as timeout)
timer_clear_flag ( TIM ( FRAME_TIMER ) , TIM_SR_UIF ) ; // clear flag
timer_enable_irq ( TIM ( FRAME_TIMER ) , TIM_DIER_UIE ) ; // enable update interrupt for timer
# if FRAME_TIMER==1
nvic_enable_irq ( NVIC_TIM1_UP_IRQ ) ; // catch interrupt in service routine
# else
nvic_enable_irq ( NVIC_TIM_IRQ ( FRAME_TIMER ) ) ; // catch interrupt in service routine
# endif
timer_set_counter ( TIM ( FRAME_TIMER ) , 0 ) ; // restart timer
timer_enable_counter ( TIM ( FRAME_TIMER ) ) ; // enable timer to start counting frames
printf ( " OK \n " ) ;
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 13:42:54 +02:00
while ( frame_flag ) { // a frame has passed
frame_flag = false ; // reset flag
action = true ; // action has been performed
uint8_t dots = 0x40 ; // dot for minutes on display
if ( 0 = = ( rtc_seconds % 2 ) ) { // even seconds
dots | = 0x10 ; // add dot for seconds
}
if ( 0 = = ( frame_count % 2 ) ) { // even frames
dots | = 0x04 ; // add dot for frame
}
led_max7219_number ( rtc_ds1307_time [ 2 ] * 1000000 + rtc_ds1307_time [ 1 ] * 10000 + rtc_seconds * 100 + ( frame_count % 100 ) , dots , 0 ) ; // display frame time on 1nd display
}
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)
2017-04-02 13:42:54 +02:00
frame_count = 0 ; // resync frame counter to second
2017-04-02 10:15:13 +02:00
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 13:47:52 +02:00
/** RTC square wave input ISR to synchronize to seconds and count them */
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
2017-04-02 13:42:54 +02:00
rtc_seconds + + ; // increment number of seconds passed
rtc_tick_flag = true ; // let main know a second passed
}
2017-04-02 13:47:52 +02:00
/** frame timer ISR */
2017-04-02 13:42:54 +02:00
# if FRAME_TIMER==1
void tim1_up_isr ( void )
# else
void TIM_ISR ( FRAME_TIMER ) ( void )
# endif
{
if ( timer_get_flag ( TIM ( FRAME_TIMER ) , TIM_SR_UIF ) ) { // overflow update event happened
timer_clear_flag ( TIM ( FRAME_TIMER ) , TIM_SR_UIF ) ; // clear flag
frame_count + + ; // increment frame counter since frame finished
frame_flag = true ; // let main know the counter changed
} else { // no other interrupt should occur
while ( true ) ; // unhandled exception: wait for the watchdog to bite
}
2016-08-14 21:02:38 +02:00
}
2017-04-02 10:15:13 +02:00