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/>.
*
*/
2017-05-04 14:07:40 +02:00
/** CuVoodoo clapperboard firmware (for STM32F103Cx micro-controller)
2016-08-14 21:02:38 +02:00
* @ file main . c
* @ author King Kévin < kingkevin @ cuvoodoo . info >
2017-05-04 14:07:40 +02:00
* @ date 2016 - 2017
2016-08-14 21:02:38 +02:00
*/
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 */
2017-05-04 12:53:20 +02:00
volatile bool keep_alive_flag = false ; /**< flag to restart shutdown counter on power switch activity */
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
2017-04-02 16:14:55 +02:00
# define STANDBY_TIMEOUT 30 /**< number of seconds after last shake before going down */
volatile uint16_t standby_timer = 0 ; /**< number of seconds since last wake-up/activity */
2017-05-04 18:53:52 +02:00
# define FRAME_TIMER 2 /**< timer to count frame time */
2017-04-02 13:42:54 +02:00
# define FRAME_RATE 25 /**< frame rate */
volatile uint8_t frame_count = 0 ; /**< number of frames passed */
2017-04-02 10:15:13 +02:00
2017-05-04 18:53:52 +02:00
# define BUZZER_TIMER 1 /**< timer to generate scene and take count */
# define BUZZER_1_PORT A /**< use timer 1 channel 1 (and it's negative) to driver buzzer */
# define BUZZER_1_PIN 7 /**< use timer 1 channel 1 (and it's negative) to driver buzzer */
# define BUZZER_2_PORT A /**< use timer 1 channel 1 (and it's negative) to driver buzzer */
# define BUZZER_2_PIN 8 /**< use timer 1 channel 1 (and it's negative) to driver buzzer */
2017-05-04 12:05:17 +02:00
# define MUX_EN_PORT B /**< port to enable multiplexer */
# define MUX_EN_PIN 9 /**< pin to enable multiplexer */
# define MUX_S0_PORT B /**< port to select multiplexer output */
# define MUX_S0_PIN 3 /**< pin to select multiplexer output */
# define MUX_S1_PORT B /**< port to select multiplexer output */
# define MUX_S1_PIN 4 /**< pin to select multiplexer output */
# define MUX_S2_PORT B /**< port to select multiplexer output */
# define MUX_S2_PIN 5 /**< pin to select multiplexer output */
2017-05-04 12:53:20 +02:00
# define POWER_SWITCH_PORT B /**< port to switch power of all devices (including this micro-controller) */
# define POWER_SWITCH_PIN 8 /**< pin to switch power of all devices (including this micro-controller) */
# define POWER_BUTTON_PORT B /**< port to detect power switching activity (to keep alive) */
# define POWER_BUTTON_PIN 1 /**< pin to detect power switching activity (to keep alive) */
2017-05-02 17:20:00 +02:00
2017-05-06 16:22:44 +02:00
# define BUTTONS_DRIVE_PORT A
# define BUTTONS_DRIVE_PIN0 0
# define BUTTONS_DRIVE_PIN1 1
# define BUTTONS_DRIVE_PIN2 2
# define BUTTONS_DRIVE_PIN3 3
# define BUTTONS_READ_PORT A
# define BUTTONS_READ_PIN0 4
# define BUTTONS_READ_PIN1 5
# define BUTTONS_READ_PIN2 6
# define BUTTONS_READ_PIN3 15
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
}
2017-05-04 14:07:40 +02:00
/** select output for TM1637 display using the multiplexer
* @ param [ in ] output clock output
*/
2017-05-02 17:20:00 +02:00
static void mux_select ( uint8_t output )
{
if ( output > 7 ) { // multiplexer is only controlling 8 outputs
return ;
}
gpio_clear ( GPIO ( MUX_EN_PORT ) , GPIO ( MUX_EN_PIN ) ) ; // enable multiplexer
switch ( output ) {
case 0 : // output on channel C0
gpio_clear ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 1 : // output on channel C1
gpio_set ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 2 : // output on channel C2
gpio_clear ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_set ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 3 : // output on channel C3
gpio_set ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_set ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 4 : // output on channel C4
gpio_clear ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_set ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 5 : // output on channel C5
gpio_set ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_clear ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_set ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 6 : // output on channel C6
gpio_clear ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_set ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_set ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
case 7 : // output on channel C7
gpio_set ( GPIO ( MUX_S0_PORT ) , GPIO ( MUX_S0_PIN ) ) ;
gpio_set ( GPIO ( MUX_S1_PORT ) , GPIO ( MUX_S1_PIN ) ) ;
gpio_set ( GPIO ( MUX_S2_PORT ) , GPIO ( MUX_S2_PIN ) ) ;
break ;
default :
break ;
}
}
2017-05-05 18:12:00 +02:00
/** unit Morse code duration in frames */
# define MORSE_DOT 10
uint8_t morse [ 1 * 4 * 5 * 2 ] = { 0 } ;
uint8_t morse_i = 0 ;
static void encode_morse ( void )
{
bool not_zero = false ;
for ( uint8_t digit = 0 ; digit < 4 ; digit + + ) {
2017-05-06 16:22:44 +02:00
uint16_t number = 42 ;
// get only the digit from the number
2017-05-05 18:12:00 +02:00
for ( uint8_t divide = digit ; divide < 3 ; divide + + ) {
number / = 10 ;
}
number % = 10 ;
// remember when we found the first non-zero digit
if ( number ! = 0 | | digit = = 3 ) {
not_zero = true ;
}
// encode the number in Morse code (1=short, 3=long)
switch ( number ) {
case 1 :
morse [ digit * 2 * 5 + 0 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 3 * MORSE_DOT ;
break ;
case 2 :
morse [ digit * 2 * 5 + 0 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 3 * MORSE_DOT ;
break ;
case 3 :
morse [ digit * 2 * 5 + 0 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 3 * MORSE_DOT ;
break ;
case 4 :
morse [ digit * 2 * 5 + 0 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 3 * MORSE_DOT ;
break ;
case 5 :
morse [ digit * 2 * 5 + 0 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 1 * MORSE_DOT ;
break ;
case 6 :
morse [ digit * 2 * 5 + 0 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 1 * MORSE_DOT ;
break ;
case 7 :
morse [ digit * 2 * 5 + 0 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 1 * MORSE_DOT ;
break ;
case 8 :
morse [ digit * 2 * 5 + 0 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 1 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 1 * MORSE_DOT ;
break ;
case 9 :
morse [ digit * 2 * 5 + 0 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 1 * MORSE_DOT ;
break ;
case 0 :
if ( not_zero ) {
morse [ digit * 2 * 5 + 0 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 2 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 4 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 6 ] = 3 * MORSE_DOT ;
morse [ digit * 2 * 5 + 8 ] = 3 * MORSE_DOT ;
} else { //don't encode the first digits if they are zero
morse [ digit * 2 * 5 + 0 ] = 0 ;
morse [ digit * 2 * 5 + 2 ] = 0 ;
morse [ digit * 2 * 5 + 4 ] = 0 ;
morse [ digit * 2 * 5 + 6 ] = 0 ;
morse [ digit * 2 * 5 + 8 ] = 0 ;
}
break ;
}
// fill the spaces between the dots
for ( uint8_t space = 0 ; space < 5 ; space + + ) {
if ( 0 = = morse [ digit * 2 * 5 + space * 2 ] ) {
morse [ digit * 2 * 5 + space * 2 + 1 ] = 0 ;
} else {
morse [ digit * 2 * 5 + space * 2 + 1 ] = 1 * MORSE_DOT ;
}
}
}
morse_i = 0 ; // reset Morse index
}
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
2017-05-04 12:05:17 +02:00
// keep power on a soon as possible
2017-05-04 12:53:20 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( POWER_SWITCH_PORT ) ) ; // enable clock for GPIO
gpio_set_mode ( GPIO ( POWER_SWITCH_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( POWER_SWITCH_PIN ) ) ; // set as output to control power
gpio_set ( GPIO ( POWER_SWITCH_PORT ) , GPIO ( POWER_SWITCH_PIN ) ) ; // enable power by saturating nMOS controlling power
rcc_periph_clock_enable ( RCC_GPIO ( POWER_BUTTON_PORT ) ) ; // enable clock for GPIO domain
gpio_set_mode ( GPIO ( POWER_BUTTON_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( POWER_BUTTON_PIN ) ) ; // set pin as input to detect power switching activity
rcc_periph_clock_enable ( RCC_AFIO ) ; // enable alternate function clock for external interrupt
exti_select_source ( EXTI ( POWER_BUTTON_PIN ) , GPIO ( POWER_BUTTON_PORT ) ) ; // mask external interrupt of this pin only for this port
exti_set_trigger ( EXTI ( POWER_BUTTON_PIN ) , EXTI_TRIGGER_BOTH ) ; // trigger on any activity of the power switch
exti_enable_request ( EXTI ( POWER_BUTTON_PIN ) ) ; // enable external interrupt
nvic_enable_irq ( NVIC_EXTI_IRQ ( POWER_BUTTON_PIN ) ) ; // enable interrupt
2017-05-04 12:05:17 +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-05-02 17:20:00 +02:00
gpio_primary_remap ( AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON , 0 ) ; // disable JTAG (but leave SWD on) since we need most of the GPIOs
2017-05-04 18:53:52 +02:00
printf ( " \n welcome to the 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-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-05-02 17:20:00 +02:00
// setup analog multiplexer for TM1637 clock
printf ( " setup multiplexer: " ) ;
rcc_periph_clock_enable ( RCC_GPIO ( MUX_EN_PORT ) ) ;
gpio_set_mode ( GPIO ( MUX_EN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_EN_PIN ) ) ;
gpio_set ( GPIO ( MUX_EN_PORT ) , GPIO ( MUX_EN_PIN ) ) ; // disable multiplexer
rcc_periph_clock_enable ( RCC_GPIO ( MUX_S0_PORT ) ) ;
gpio_set_mode ( GPIO ( MUX_S0_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_S0_PIN ) ) ;
rcc_periph_clock_enable ( RCC_GPIO ( MUX_S1_PORT ) ) ;
gpio_set_mode ( GPIO ( MUX_S1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_S1_PIN ) ) ;
rcc_periph_clock_enable ( RCC_GPIO ( MUX_S2_PORT ) ) ;
gpio_set_mode ( GPIO ( MUX_S2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_S2_PIN ) ) ;
printf ( " OK \n " ) ;
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-05-02 17:20:00 +02:00
for ( uint8_t tm1637 = 0 ; tm1637 < 7 ; tm1637 + + ) {
mux_select ( tm1637 ) ;
if ( ! led_tm1637_time ( 88 , 88 ) ) { // test TM1637 display
2017-05-04 12:05:17 +02:00
printf ( " could not test TM1637 %u \n " , tm1637 ) ;
2017-05-02 17:20:00 +02:00
}
2017-02-08 12:44:34 +01:00
}
2017-05-02 17:20:00 +02:00
led_max7219_setup ( 2 ) ; // setup MAX7219
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 " ) ;
}
2017-05-02 17:20:00 +02:00
for ( uint8_t tm1637 = 0 ; tm1637 < 7 ; tm1637 + + ) {
mux_select ( tm1637 ) ;
if ( ! led_tm1637_off ( ) ) { // switch off display
printf ( " could not switch off TM1637 %u \n " , tm1637 ) ;
}
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 " ) ;
2017-05-04 18:53:52 +02:00
// setup PWM for piezo-buzzer
2017-05-06 16:22:44 +02:00
printf ( " setup piezo-buzzer PWM timer: " ) ;
2017-05-04 18:53:52 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( BUZZER_1_PORT ) ) ; // enable clock for GPIO peripheral
rcc_periph_clock_enable ( RCC_AFIO ) ; // enable clock for alternate function (PWM)
gpio_primary_remap ( AFIO_MAPR_SWJ_MASK , AFIO_MAPR_TIM1_REMAP_PARTIAL_REMAP ) ; // remap TIM1_CH1N to PA7 instead of PB13
gpio_set_mode ( GPIO ( BUZZER_1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_ALTFN_PUSHPULL , GPIO ( BUZZER_1_PIN ) ) ; // set pin as output to have a PWM to driver piezo buzzer
rcc_periph_clock_enable ( RCC_GPIO ( BUZZER_2_PORT ) ) ; // enable clock for GPIO peripheral
gpio_set_mode ( GPIO ( BUZZER_2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_ALTFN_PUSHPULL , GPIO ( BUZZER_2_PIN ) ) ; // set pin as output to have a PWM to driver piezo buzzer
rcc_periph_clock_enable ( RCC_TIM ( BUZZER_TIMER ) ) ; // enable clock for timer peripheral
timer_reset ( TIM ( BUZZER_TIMER ) ) ; // reset timer state
timer_set_mode ( TIM ( BUZZER_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 ( BUZZER_TIMER ) , 0 ) ; // no prescaler to keep most precise timer (72MHz/2^16=1099<2kHz)
timer_set_period ( TIM ( BUZZER_TIMER ) , rcc_ahb_frequency / 2000 - 1 ) ; // set the PWM frequency to 2kHz for piezo-buzzer
timer_set_oc_value ( TIM ( BUZZER_TIMER ) , TIM_OC1 , rcc_ahb_frequency / 2000 / 2 - 1 ) ; // duty cycle to 50% (also applies to TIM_OC1N)
// no preload is used, although the reference manual says to enable it
timer_set_oc_mode ( TIM ( BUZZER_TIMER ) , TIM_OC1 , TIM_OCM_PWM1 ) ; // set timer to generate PWM (also applies to TIM_OC1N)
timer_enable_oc_output ( TIM ( BUZZER_TIMER ) , TIM_OC1 ) ; // enable output to generate PWM
timer_enable_oc_output ( TIM ( BUZZER_TIMER ) , TIM_OC1N ) ; // enable output to generate PWM (complementary to be louder)
timer_enable_break_main_output ( TIM ( BUZZER_TIMER ) ) ; // enable master output
timer_generate_event ( TIM ( BUZZER_TIMER ) , TIM_EGR_UG ) ; // generate update event to reload registers and reset counter
printf ( " OK \n " ) ;
2017-05-06 16:22:44 +02:00
// setup GPIO for reading buttons
printf ( " setup button inputs: " ) ;
rcc_periph_clock_enable ( RCC_GPIO ( BUTTONS_DRIVE_PORT ) ) ; // enable clock for GPIO port domain
// no need to configure the driving line modes since this will be done when they need to be driven
rcc_periph_clock_enable ( RCC_GPIO ( BUTTONS_READ_PORT ) ) ; // enable clock for GPIO port domain
gpio_set_mode ( GPIO ( BUTTONS_READ_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_PULL_UPDOWN , GPIO ( BUTTONS_READ_PIN0 ) | GPIO ( BUTTONS_READ_PIN1 ) | GPIO ( BUTTONS_READ_PIN2 ) | GPIO ( BUTTONS_READ_PIN3 ) ) ; // set read lines as input
gpio_primary_remap ( AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON , 0 ) ; // enable PA15 (JTDI per default)
gpio_clear ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN0 ) | GPIO ( BUTTONS_READ_PIN1 ) | GPIO ( BUTTONS_READ_PIN2 ) | GPIO ( BUTTONS_READ_PIN3 ) ) ; // pull read lines low since they will be high when driven and button is pressed
uint16_t buttons = 0 ;
2017-05-05 18:12:00 +02:00
encode_morse ( ) ;
2017-05-06 16:22:44 +02:00
bool announce = false ;
2017-05-05 18:12:00 +02:00
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
}
}
}
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
2017-05-06 16:22:44 +02:00
// announce the scene and take using Morse code over the buzzer
if ( announce ) {
2017-05-05 18:12:00 +02:00
while ( morse_i < LENGTH ( morse ) ) {
if ( morse [ morse_i ] ) { // skip empty codes
if ( morse_i % 2 ) { // switch buzzer on for odd code
timer_disable_counter ( TIM ( BUZZER_TIMER ) ) ; // stop buzzing
} else {
timer_enable_counter ( TIM ( BUZZER_TIMER ) ) ; // start buzzing
}
morse [ morse_i ] - - ; // decrement beeping
break ; // buzz for one frame
} else {
morse_i + + ; // got to next code
}
}
if ( morse_i > = LENGTH ( morse ) ) { // all codes done
announce = false ; // announce finished
}
}
2017-05-06 16:22:44 +02:00
// read button inputs (drive and read each row since they are multiplexed)
uint16_t buttons_new = 0 ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_OUTPUT_10_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUTTONS_DRIVE_PIN0 ) ) ;
gpio_set ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO ( BUTTONS_DRIVE_PIN0 ) ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUTTONS_DRIVE_PIN1 ) | GPIO ( BUTTONS_DRIVE_PIN2 ) | GPIO ( BUTTONS_DRIVE_PIN3 ) ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN0 ) ) ? 1 : 0 ) < < 0 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN1 ) ) ? 1 : 0 ) < < 1 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN2 ) ) ? 1 : 0 ) < < 2 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN3 ) ) ? 1 : 0 ) < < 3 ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_OUTPUT_10_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUTTONS_DRIVE_PIN1 ) ) ;
gpio_set ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO ( BUTTONS_DRIVE_PIN1 ) ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUTTONS_DRIVE_PIN0 ) | GPIO ( BUTTONS_DRIVE_PIN2 ) | GPIO ( BUTTONS_DRIVE_PIN3 ) ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN0 ) ) ? 1 : 0 ) < < 4 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN1 ) ) ? 1 : 0 ) < < 5 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN2 ) ) ? 1 : 0 ) < < 6 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN3 ) ) ? 1 : 0 ) < < 7 ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_OUTPUT_10_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUTTONS_DRIVE_PIN2 ) ) ;
gpio_set ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO ( BUTTONS_DRIVE_PIN2 ) ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUTTONS_DRIVE_PIN0 ) | GPIO ( BUTTONS_DRIVE_PIN1 ) | GPIO ( BUTTONS_DRIVE_PIN3 ) ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN0 ) ) ? 1 : 0 ) < < 8 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN1 ) ) ? 1 : 0 ) < < 9 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN2 ) ) ? 1 : 0 ) < < 10 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN3 ) ) ? 1 : 0 ) < < 11 ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_OUTPUT_10_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUTTONS_DRIVE_PIN3 ) ) ;
gpio_set ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO ( BUTTONS_DRIVE_PIN3 ) ) ;
gpio_set_mode ( GPIO ( BUTTONS_DRIVE_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUTTONS_DRIVE_PIN0 ) | GPIO ( BUTTONS_DRIVE_PIN1 ) | GPIO ( BUTTONS_DRIVE_PIN2 ) ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN0 ) ) ? 1 : 0 ) < < 12 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN1 ) ) ? 1 : 0 ) < < 13 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN2 ) ) ? 1 : 0 ) < < 14 ) ;
buttons_new | = ( ( gpio_get ( GPIO ( BUTTONS_READ_PORT ) , GPIO ( BUTTONS_READ_PIN3 ) ) ? 1 : 0 ) < < 15 ) ;
if ( buttons_new ! = buttons ) { // only do something if there is a change
buttons = buttons_new ; // save new state
printf ( " button pressed: %016b \n " , buttons ) ;
}
2017-05-04 12:05:17 +02:00
char time [ ] = " 00000000 " ; // time to display
time [ 0 ] + = ( rtc_ds1307_time [ 2 ] / 10 ) % 10 ; // display hours
time [ 1 ] + = ( rtc_ds1307_time [ 2 ] ) % 10 ; // display hours
time [ 1 ] | = 0x80 ; // dot for minutes on display
time [ 2 ] + = ( rtc_ds1307_time [ 1 ] / 10 ) % 10 ; // display minutes
time [ 3 ] + = ( rtc_ds1307_time [ 1 ] ) % 10 ; // display minutes
2017-04-02 13:42:54 +02:00
if ( 0 = = ( rtc_seconds % 2 ) ) { // even seconds
2017-05-04 12:05:17 +02:00
time [ 3 ] | = 0x80 ; // add dot for seconds
2017-04-02 13:42:54 +02:00
}
2017-05-04 12:05:17 +02:00
time [ 4 ] + = ( rtc_seconds / 10 ) % 10 ; // display seconds
time [ 5 ] + = ( rtc_seconds ) % 10 ; // display seconds
2017-04-02 13:42:54 +02:00
if ( 0 = = ( frame_count % 2 ) ) { // even frames
2017-05-04 12:05:17 +02:00
time [ 5 ] | = 0x80 ; // add dot for frame
2017-04-02 13:42:54 +02:00
}
2017-05-04 12:05:17 +02:00
time [ 6 ] + = ( frame_count / 10 ) % 10 ; // display frame
time [ 7 ] + = ( frame_count ) % 10 ; // display frame
led_max7219_text ( time , 0 ) ; // display frame time on 1st display
2017-04-02 13:42:54 +02: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)
2017-05-06 16:22:44 +02:00
if ( standby_timer > = STANDBY_TIMEOUT & & false ) { // standby timeout complete
2017-04-02 16:14:55 +02:00
// go into standby mode
2017-05-04 12:05:17 +02:00
printf ( " shutting down \n " ) ;
led_max7219_off ( 0xff ) ; // switch off MAX7219 displays
for ( uint8_t tm1637 = 0 ; tm1637 < 7 ; tm1637 + + ) { // switch off TM1637 displays
mux_select ( tm1637 ) ; // selecting TM1637 display
led_tm1637_off ( ) ; // switch off TM1637 display
}
2017-05-04 12:53:20 +02:00
gpio_clear ( GPIO ( POWER_SWITCH_PORT ) , GPIO ( POWER_SWITCH_PIN ) ) ; // switch power of by disconnecting from battery
2017-04-02 16:14:55 +02:00
SCB_SCR | = SCB_SCR_SLEEPDEEP ; // enable deep sleep
pwr_set_standby_mode ( ) ; // go to deep sleep
2017-05-04 12:05:17 +02:00
while ( true ) ; // we should be shut down at this point
2017-04-02 16:14:55 +02:00
}
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
}
2017-05-02 17:20:00 +02:00
for ( uint8_t tm1637 = 0 ; tm1637 < 7 ; tm1637 + + ) {
mux_select ( tm1637 ) ;
if ( ! led_tm1637_time ( rtc_ds1307_time [ 1 ] , rtc_seconds + tm1637 ) ) { // test TM1637 display
printf ( " could not send time to TM1637 %u \n " , tm1637 ) ;
}
}
2016-08-14 21:02:38 +02:00
}
2017-05-04 12:53:20 +02:00
while ( keep_alive_flag ) { // power switch is detecting movement to keep clapperboard running
keep_alive_flag = false ; // clear flag
2017-04-02 16:14:55 +02:00
standby_timer = 0 ; // restart standby timer
}
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 {
2017-04-02 16:14:55 +02:00
__WFI ( ) ; // go to sleep and wait for interrupt
2016-02-18 10:39:08 +01:00
}
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-05-02 17:20:00 +02:00
frame_count = 0 ; // re-sync frame counter to second
2017-04-02 13:42:54 +02:00
rtc_seconds + + ; // increment number of seconds passed
2017-04-02 16:14:55 +02:00
if ( standby_timer < STANDBY_TIMEOUT ) { // timeout countdown not complete
standby_timer + + ; // continue counting down
}
2017-04-02 13:42:54 +02:00
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
2017-05-04 12:53:20 +02:00
/** power switch/keep alive activity */
void EXTI_ISR ( POWER_BUTTON_PIN ) ( void )
{
exti_reset_request ( EXTI ( POWER_BUTTON_PIN ) ) ; // reset interrupt
keep_alive_flag = true ; // perform button action
}