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 >
2018-04-30 14:40:01 +02:00
* @ date 2016 - 2018
2016-08-14 21:02:38 +02:00
*/
2016-01-17 14:54:54 +01:00
/* standard libraries */
# include <stdint.h> // standard integer types
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 */
2017-05-21 11:47:50 +02:00
/** @defgroup main_flags flag set in interrupts to be processed in main loop
2016-08-14 21:02:38 +02:00
* @ {
*/
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 */
2017-05-14 18:35:07 +02:00
volatile bool clap_flag = false ; /**< flag set on clap */
2016-08-14 21:02:38 +02:00
/** @} */
2017-05-21 13:43:56 +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 by shaking (to keep alive) */
# define POWER_BUTTON_PIN 1 /**< pin to detect power switching activity by shaking (to keep alive) */
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-05-21 13:43:56 +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-05-21 11:47:50 +02:00
# define STANDBY_TIMEOUT 30 /**< number of seconds after last shake before going down */
2017-05-21 13:43:56 +02:00
volatile uint16_t standby_timer = 0 ; /**< number of seconds since last power-up activity (using shake sensor) */
2017-04-02 16:14:55 +02:00
2017-05-04 18:53:52 +02:00
# define FRAME_TIMER 2 /**< timer to count frame time */
2017-05-21 13:43:56 +02:00
# define FRAME_RATE 25 /**< frame rate in frames per second */
2017-04-02 13:42:54 +02:00
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 */
2017-05-21 13:43:56 +02:00
# define BUZZER_1_PORT A /**< use timer channel 1 (and it's negative) to driver buzzer */
# define BUZZER_1_PIN 7 /**< use timer channel 1 (and it's negative) to driver buzzer */
# define BUZZER_2_PORT A /**< use timer channel 1 (and it's negative) to driver buzzer */
# define BUZZER_2_PIN 8 /**< use timer channel 1 (and it's negative) to driver buzzer */
2017-05-04 18:53:52 +02:00
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-06 17:00:10 +02:00
/** number to be display and changed using the buttons */
struct number_t {
uint16_t number ; /**< number to display (0-9999, 0xffff=off) */
uint8_t up ; /**< which of the 16 buttons is to increment the number */
uint8_t down ; /**< which of the 16 buttons is to decrement the number */
2017-05-21 11:47:50 +02:00
uint8_t display ; /**< which display on the channel multiplexer */
2017-05-06 17:00:10 +02:00
} ;
2017-05-21 11:47:50 +02:00
/** episode, scene, take, video 1, audio 1, video 2, audio 2 number (in this order) */
2017-05-06 17:00:10 +02:00
struct number_t numbers [ ] = {
2017-05-21 11:47:50 +02:00
{ 0 , 0 , 4 , 4 } , // episode
{ 0 , 8 , 12 , 5 } , // scene
{ 0 , 1 , 5 , 6 } , // take
{ 0 , 2 , 6 , 3 } , // video 1
{ 0 , 10 , 14 , 2 } , // audio 1
{ 0 , 3 , 7 , 1 } , // video 2
{ 0 , 11 , 15 , 0 } , // audio 2
2017-05-06 17:00:10 +02:00
} ;
2017-05-21 11:47:50 +02:00
# define BUTTON_SECONDS_UP 9 /**< which of the 16 buttons is to increment the seconds */
# define BUTTON_SECONDS_DOWN 13 /**< which of the 16 buttons is to decrement the seconds */
2017-05-06 17:00:10 +02:00
2017-05-21 11:47:50 +02:00
// buttons to adjust numbers and seconds (mutliplexed in a 4x4 matrix)
# define BUTTONS_DRIVE_PORT A /**< port used to drive the buttons rows */
# define BUTTONS_DRIVE_PIN0 0 /**< pin used to drive buttons row 0 */
# define BUTTONS_DRIVE_PIN1 1 /**< pin used to drive buttons row 1 */
# define BUTTONS_DRIVE_PIN2 2 /**< pin used to drive buttons row 2 */
# define BUTTONS_DRIVE_PIN3 3 /**< pin used to drive buttons row 3 */
# define BUTTONS_READ_PORT A /**< port used to read the buttons columns */
# define BUTTONS_READ_PIN0 4 /**< pin used to read buttons column 0 */
# define BUTTONS_READ_PIN1 5 /**< pin used to read buttons column 1 */
# define BUTTONS_READ_PIN2 6 /**< pin used to read buttons column 2 */
# define BUTTONS_READ_PIN3 15 /**< pin used to read buttons column 3 */
# define CLAP_BUTTON_PORT B /**< port for button to detect clap action */
# define CLAP_BUTTON_PIN 14 /**< port for button to detect clap action */
2017-05-14 18:35:07 +02:00
2017-05-21 13:43:56 +02:00
/** Morse code variables, to buzz/beep scene and take */
2017-05-14 18:35:07 +02:00
# define MORSE_DOT 1 /**< unit Morse code duration in frames */
uint8_t morse [ 2 * 4 * 5 * 2 ] = { 0 } ; /**< to encode 2 4-digit numbers (scene and take) into Morse code (5 sign+space) */
uint8_t morse_i = 0 ; /**< index in Morse array */
int16_t morse_delay = - 1 ; /**< number of frames before beeping (-1=no need to beep yet, -2=beeping completed) */
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-21 13:43:56 +02:00
/** select clock output for TM1637 display using the analog multiplexer
* @ param [ in ] output clock output channel
2017-05-04 14:07:40 +02:00
*/
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-21 13:43:56 +02:00
/** encode scene and take into Morse code (in morse variable) */
2017-05-05 18:12:00 +02:00
static void encode_morse ( void )
{
2017-05-21 13:43:56 +02:00
// numbers (scene and take) to encode in Morse code
2017-05-21 11:47:50 +02:00
uint16_t morse_numbers [ ] = { numbers [ 1 ] . number , numbers [ 2 ] . number } ;
printf ( " morsing scene: %u, take: %u \n " , morse_numbers [ 0 ] , morse_numbers [ 1 ] ) ;
2017-05-14 18:35:07 +02:00
for ( uint8_t morse_number = 0 ; morse_number < LENGTH ( morse_numbers ) ; morse_number + + ) {
bool not_zero = false ; // has the first non-zero digit been found
if ( 0xffff = = morse_numbers [ morse_number ] ) { // number disabled, don't beep
for ( uint8_t i = morse_number * 4 * 2 * 5 ; i < ( morse_number + 1 ) * 4 * 2 * 5 ; i + + ) {
2017-05-21 13:43:56 +02:00
morse [ i ] = 0 ; // no beeping
2017-05-14 18:35:07 +02:00
}
} else { // encode number in Morse code
2017-05-21 13:43:56 +02:00
for ( uint8_t digit = 0 ; digit < 4 ; digit + + ) { // encode each digit
uint16_t number = morse_numbers [ morse_number ] ; // digit to encode
2017-05-14 18:35:07 +02:00
// get only the digit from the number
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 digit in Morse code (1=short, 3=long)
switch ( number ) {
2017-05-21 13:43:56 +02:00
case 1 : // Morse code for 1: short, long, long, long, long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 3 * MORSE_DOT ; // long
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 2 : // Morse code for 2: short, short, long, long, long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 3 * MORSE_DOT ; // long
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 3 : // Morse code for 3: short, short, short, long, long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 3 * MORSE_DOT ; // long
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 4 : // Morse code for 4: short, short, short, short, long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 3 * MORSE_DOT ; // long
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 5 : // Morse code for 5: short, short, short, short, short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 1 * MORSE_DOT ; // short
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 6 : // Morse code for 6: long, short, short, short, short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 1 * MORSE_DOT ; // short
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 7 : // Morse code for 7: long, long, short, short, short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 1 * MORSE_DOT ; // short
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 8 : // Morse code for 8: long, long, long, short, short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 1 * MORSE_DOT ; // short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 1 * MORSE_DOT ; // short
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 9 : // Morse code for 9: long, long, long, long, short
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 1 * MORSE_DOT ; // short
2017-05-14 18:35:07 +02:00
break ;
2017-05-21 13:43:56 +02:00
case 0 : // Morse code for 0: long, long, long, long, long
if ( not_zero ) { // encode zero if they are not leading
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 3 * MORSE_DOT ; // long
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 3 * MORSE_DOT ; // long
} else { // don't encode the first digits if they are zero
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 0 ] = 0 ; // no beeping
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 2 ] = 0 ; // no beeping
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 4 ] = 0 ; // no beeping
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 6 ] = 0 ; // no beeping
morse [ ( morse_number * 4 + digit ) * 2 * 5 + 8 ] = 0 ; // no beeping
2017-05-14 18:35:07 +02:00
}
break ;
}
// fill the spaces between the dots
for ( uint8_t space = 0 ; space < 5 ; space + + ) {
2017-05-21 13:43:56 +02:00
if ( 0 = = morse [ ( morse_number * 4 + digit ) * 2 * 5 + space * 2 ] ) { // don't add space if there is no Morse code
morse [ ( morse_number * 4 + digit ) * 2 * 5 + space * 2 + 1 ] = 0 ; // no space
} else { // add space between Morse codes
morse [ ( morse_number * 4 + digit ) * 2 * 5 + space * 2 + 1 ] = 1 * MORSE_DOT ; // add space
2017-05-14 18:35:07 +02:00
}
2017-05-05 18:12:00 +02:00
}
}
}
}
2017-05-21 13:43:56 +02:00
morse [ 4 * 2 * 5 + 1 ] = 3 * MORSE_DOT ; // use longer silence between the two numbers
2017-05-05 18:12:00 +02:00
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-05-21 13:43:56 +02:00
// enable square wave output and configure input interrupt to count seconds
2017-04-02 10:15:13 +02:00
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
2017-05-21 13:43:56 +02:00
gpio_set_mode ( GPIO ( SQUARE_WAVE_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( SQUARE_WAVE_PIN ) ) ; // set pin to input
2017-04-02 10:15:13 +02:00
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-05-21 13:43:56 +02:00
// verify if external RTC is running
2017-05-06 16:45:17 +02:00
if ( rtc_ds1307_oscillator_disabled ( ) ) {
printf ( " /! \\ RTC oscillator is disabled: the battery may be empty \n " ) ;
rtc_ds1307_oscillator_enable ( ) ; // enable oscillator again
}
2017-05-21 13:43:56 +02:00
// get date
2017-02-08 14:06:06 +01:00
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-02-08 14:06:06 +01:00
2017-05-21 13:43:56 +02:00
// setup analog multiplexer for TM1637 clock signal (mutliplex the clock signal we output between the 7 TM1637 displays)
2017-05-02 17:20:00 +02:00
printf ( " setup multiplexer: " ) ;
2017-05-06 16:45:17 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( MUX_EN_PORT ) ) ; // enable clock for GPIO port domain
gpio_set_mode ( GPIO ( MUX_EN_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_EN_PIN ) ) ; // to enable/disable the multiplexer
2017-05-02 17:20:00 +02:00
gpio_set ( GPIO ( MUX_EN_PORT ) , GPIO ( MUX_EN_PIN ) ) ; // disable multiplexer
2017-05-06 16:45:17 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( MUX_S0_PORT ) ) ; // enable clock for GPIO port domain
gpio_set_mode ( GPIO ( MUX_S0_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_S0_PIN ) ) ; // to select output channel
rcc_periph_clock_enable ( RCC_GPIO ( MUX_S1_PORT ) ) ; // enable clock for GPIO port domain
gpio_set_mode ( GPIO ( MUX_S1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_S1_PIN ) ) ; // to select output channel
rcc_periph_clock_enable ( RCC_GPIO ( MUX_S2_PORT ) ) ; // enable clock for GPIO port domain
gpio_set_mode ( GPIO ( MUX_S2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( MUX_S2_PIN ) ) ; // to select output channel
2017-05-02 17:20:00 +02:00
printf ( " OK \n " ) ;
2017-05-06 16:45:17 +02:00
// setup TM1637 4-digit 7-segment displays to display the numbers
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-06 16:45:17 +02:00
for ( uint8_t tm1637 = 0 ; tm1637 < LENGTH ( numbers ) ; tm1637 + + ) {
2017-05-02 17:20:00 +02:00
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-06 16:45:17 +02:00
// setup MAX7219 8-digit 7-segment displays to display date and time
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-05-21 13:43:56 +02:00
for ( volatile uint32_t i = 0 ; i < 10000000 ; i + + ) ; // wait a bit to have the user check the displays
2017-05-06 16:45:17 +02:00
// switch displays back off
for ( uint8_t tm1637 = 0 ; tm1637 < LENGTH ( numbers ) ; tm1637 + + ) {
2017-05-02 17:20:00 +02:00
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
2017-05-07 20:29:32 +02:00
// get and display numbers on TM1637
2017-05-06 16:45:17 +02:00
for ( uint8_t number = 0 ; number < LENGTH ( numbers ) ; number + + ) {
2017-05-21 13:43:56 +02:00
uint8_t bytes [ 2 ] = { 0 } ; // bytes for the numbers
if ( ! rtc_ds1307_read_rom ( number * LENGTH ( bytes ) , bytes , LENGTH ( bytes ) ) ) { // get number from EEPROM
2017-05-17 17:11:33 +02:00
printf ( " could not get number from EEPROM \n " ) ;
2017-05-07 20:29:32 +02:00
}
2017-05-21 13:43:56 +02:00
numbers [ number ] . number = ( bytes [ 0 ] < < 8 ) + bytes [ 1 ] ; // save number
// display number
2017-05-21 11:47:50 +02:00
mux_select ( numbers [ number ] . display ) ;
2017-05-17 18:51:20 +02:00
printf ( " number %u: " , number ) ;
2017-05-06 17:00:10 +02:00
if ( 0xffff = = numbers [ number ] . number ) {
2017-05-17 18:51:20 +02:00
printf ( " off \n " ) ;
2017-05-06 16:45:17 +02:00
led_tm1637_off ( ) ;
} else {
2017-05-17 18:51:20 +02:00
printf ( " %u \n " , numbers [ number ] . number ) ;
2017-05-06 17:00:10 +02:00
led_tm1637_number ( numbers [ number ] . number ) ;
2017-05-06 16:45:17 +02:00
}
}
2017-05-21 13:43:56 +02:00
// display date and time on MAX7219 displays
2017-05-21 11:47:50 +02:00
led_max7219_number ( 20000000 + rtc_ds1307_time [ 6 ] * 10000 + rtc_ds1307_time [ 5 ] * 100 + rtc_ds1307_time [ 4 ] , 0x14 , 0 ) ; // display date on 1st display
led_max7219_number ( rtc_ds1307_time [ 2 ] * 1000000 + rtc_ds1307_time [ 1 ] * 10000 + rtc_ds1307_time [ 0 ] * 100 , 0x54 , 1 ) ; // display time on 2nd display
2017-04-02 13:42:54 +02:00
led_max7219_on ( 0xff ) ; // switch displays on
2017-05-21 13:43:56 +02:00
// setup timer to count frames
2017-04-02 13:42:54 +02:00
printf ( " setup frame timer: " ) ;
2017-05-21 13:43:56 +02:00
rcc_periph_clock_enable ( RCC_TIM ( FRAME_TIMER ) ) ; // enable clock for timer domain
2017-04-02 13:42:54 +02:00
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-21 13:43:56 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( BUZZER_1_PORT ) ) ; // enable clock for GPIO port domain
2017-05-04 18:53:52 +02:00
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
2017-05-21 13:43:56 +02:00
gpio_clear ( GPIO ( BUZZER_1_PORT ) , GPIO ( BUZZER_1_PIN ) ) ; // ensure it's not beeping
2017-05-04 18:53:52 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( BUZZER_2_PORT ) ) ; // enable clock for GPIO peripheral
2017-05-21 13:43:56 +02:00
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
gpio_clear ( GPIO ( BUZZER_2_PORT ) , GPIO ( BUZZER_2_PIN ) ) ; // ensure it's not beeping
2017-05-04 18:53:52 +02:00
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
2017-05-17 18:32:55 +02:00
timer_set_prescaler ( TIM ( BUZZER_TIMER ) , 0 ) ; // no prescaler to keep most precise timer (72MHz/2^16=1099<4kHz)
timer_set_period ( TIM ( BUZZER_TIMER ) , rcc_ahb_frequency / 4000 - 1 ) ; // set the PWM frequency to 4kHz for piezo-buzzer
timer_set_oc_value ( TIM ( BUZZER_TIMER ) , TIM_OC1 , rcc_ahb_frequency / 4000 / 2 - 1 ) ; // duty cycle to 50% (also applies to TIM_OC1N)
2017-05-04 18:53:52 +02:00
// 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
2018-04-30 14:40:01 +02:00
timer_generate_event ( TIM ( BUZZER_TIMER ) , TIM_EGR_UG ) ; // generate update event to reload registers and reset counter
// switch buzzer off by removing the output from the PWM
gpio_clear ( GPIO ( BUZZER_1_PORT ) , GPIO ( BUZZER_1_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUZZER_1_PIN ) ) ;
gpio_clear ( GPIO ( BUZZER_2_PORT ) , GPIO ( BUZZER_2_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUZZER_2_PIN ) ) ;
2017-05-04 18:53:52 +02:00
printf ( " OK \n " ) ;
2017-05-06 16:22:44 +02:00
// setup GPIO for reading buttons
2017-05-14 18:35:07 +02:00
printf ( " setup display buttons: " ) ;
2017-05-06 16:22:44 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( BUTTONS_DRIVE_PORT ) ) ; // enable clock for GPIO port domain
2017-05-21 13:43:56 +02:00
// no need to configure the driving line modes since this will be done when they need to be driven individually
2017-05-06 16:22:44 +02:00
rcc_periph_clock_enable ( RCC_GPIO ( BUTTONS_READ_PORT ) ) ; // enable clock for GPIO port domain
2017-05-21 13:43:56 +02:00
gpio_set_mode ( GPIO ( BUTTONS_READ_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_FLOAT , GPIO ( BUTTONS_READ_PIN0 ) | GPIO ( BUTTONS_READ_PIN1 ) | GPIO ( BUTTONS_READ_PIN2 ) | GPIO ( BUTTONS_READ_PIN3 ) ) ; // set read lines as input (external pull down resistors are required)
2017-05-06 16:22:44 +02:00
gpio_primary_remap ( AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON , 0 ) ; // enable PA15 (JTDI per default)
2017-05-21 13:43:56 +02:00
uint16_t buttons = 0 ; // to save button state
2017-05-06 17:00:10 +02:00
printf ( " OK \n " ) ;
2017-05-06 16:22:44 +02:00
2017-05-14 18:35:07 +02:00
printf ( " setup clap button: " ) ;
rcc_periph_clock_enable ( RCC_GPIO ( CLAP_BUTTON_PORT ) ) ; // enable clock for GPIO port domain
gpio_set_mode ( GPIO ( CLAP_BUTTON_PORT ) , GPIO_MODE_INPUT , GPIO_CNF_INPUT_PULL_UPDOWN , GPIO ( CLAP_BUTTON_PIN ) ) ; // set button pin to input
gpio_set ( GPIO ( CLAP_BUTTON_PORT ) , GPIO ( CLAP_BUTTON_PIN ) ) ; // pull up
rcc_periph_clock_enable ( RCC_AFIO ) ; // enable alternate function clock for external interrupt
exti_select_source ( EXTI ( CLAP_BUTTON_PIN ) , GPIO ( CLAP_BUTTON_PORT ) ) ; // mask external interrupt of this pin only for this port
exti_set_trigger ( EXTI ( CLAP_BUTTON_PIN ) , EXTI_TRIGGER_FALLING ) ; // trigger on falling edge (we are pulling up on one side, and ground is on the other side)
exti_enable_request ( EXTI ( CLAP_BUTTON_PIN ) ) ; // enable external interrupt
nvic_enable_irq ( NVIC_EXTI_IRQ ( CLAP_BUTTON_PIN ) ) ; // enable interrupt
printf ( " OK \n " ) ;
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
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
2017-05-21 11:47:50 +02:00
while ( true ) { // main 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
2017-05-21 13:43:56 +02:00
led_toggle ( ) ; // toggle LED to show activity
2016-08-14 21:02:38 +02:00
c = usart_getchar ( ) ; // store receive character
2018-04-30 14:40:01 +02:00
standby_timer = 0 ; // restart standby timer
2016-08-14 21:02:38 +02:00
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
2017-05-21 13:43:56 +02:00
led_toggle ( ) ; // toggle LED to show activity
2016-08-14 21:02:38 +02:00
c = cdcacm_getchar ( ) ; // store receive character
2018-04-30 14:40:01 +02:00
standby_timer = 0 ; // restart standby timer
2016-08-14 21:02:38 +02:00
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
}
2017-05-21 13:43:56 +02:00
} else { // save user command input
2016-08-14 21:02:38 +02:00
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:45:17 +02:00
2017-05-14 18:35:07 +02:00
// display time and frame number
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
if ( 0 = = ( rtc_seconds % 2 ) ) { // even seconds
time [ 3 ] | = 0x80 ; // add dot for seconds
}
time [ 4 ] + = ( rtc_seconds / 10 ) % 10 ; // display seconds
time [ 5 ] + = ( rtc_seconds ) % 10 ; // display seconds
if ( 0 = = ( frame_count % 2 ) ) { // even frames
time [ 5 ] | = 0x80 ; // add dot for frame
}
time [ 6 ] + = ( frame_count / 10 ) % 10 ; // display frame
time [ 7 ] + = ( frame_count ) % 10 ; // display frame
2017-05-21 11:47:50 +02:00
led_max7219_text ( time , 1 ) ; // display frame time on 2nd display
2017-05-14 18:35:07 +02:00
// Morse the scene and take numbers over the buzzer
2017-05-21 13:43:56 +02:00
if ( morse_delay > 0 ) { // not ready to Morse
morse_delay - - ; // still wait before Morsing
} else if ( 0 = = morse_delay ) { // ready to Morse
while ( morse_i < LENGTH ( morse ) ) { // until every code has been Morsed
2017-05-05 18:12:00 +02:00
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
2018-04-30 14:40:01 +02:00
// switch buzzer off by removing the output from the PWM
gpio_clear ( GPIO ( BUZZER_1_PORT ) , GPIO ( BUZZER_1_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUZZER_1_PIN ) ) ;
gpio_clear ( GPIO ( BUZZER_2_PORT ) , GPIO ( BUZZER_2_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUZZER_2_PIN ) ) ;
2017-05-05 18:12:00 +02:00
} else {
2018-04-30 14:40:01 +02:00
// allow PWM to control the output
gpio_set_mode ( GPIO ( BUZZER_1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_ALTFN_PUSHPULL , GPIO ( BUZZER_1_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_ALTFN_PUSHPULL , GPIO ( BUZZER_2_PIN ) ) ;
2017-05-05 18:12:00 +02:00
timer_enable_counter ( TIM ( BUZZER_TIMER ) ) ; // start buzzing
}
2017-05-21 13:43:56 +02:00
morse [ morse_i ] - - ; // decrement remaining buzzing time
2017-05-05 18:12:00 +02:00
break ; // buzz for one frame
} else {
morse_i + + ; // got to next code
}
}
if ( morse_i > = LENGTH ( morse ) ) { // all codes done
2017-05-14 18:35:07 +02:00
morse_delay = - 2 ; // Morse completed
2018-04-30 14:40:01 +02:00
// switch buzzer off by removing the output from the PWM
gpio_clear ( GPIO ( BUZZER_1_PORT ) , GPIO ( BUZZER_1_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_1_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUZZER_1_PIN ) ) ;
gpio_clear ( GPIO ( BUZZER_2_PORT ) , GPIO ( BUZZER_2_PIN ) ) ;
gpio_set_mode ( GPIO ( BUZZER_2_PORT ) , GPIO_MODE_OUTPUT_2_MHZ , GPIO_CNF_OUTPUT_PUSHPULL , GPIO ( BUZZER_2_PIN ) ) ;
2017-05-05 18:12:00 +02:00
}
}
2017-05-06 16:45:17 +02:00
2017-05-06 16:22:44 +02:00
// read button inputs (drive and read each row since they are multiplexed)
2017-05-21 13:43:56 +02:00
uint16_t buttons_new = 0 ; // to save new button states
// drive row 0
2017-05-06 16:22:44 +02:00
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 ) ) ;
2017-05-21 13:43:56 +02:00
// read all columns for this row
2017-05-06 16:22:44 +02:00
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 ) ;
2017-05-21 13:43:56 +02:00
// drive row 1
2017-05-06 16:22:44 +02:00
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 ) ) ;
2017-05-21 13:43:56 +02:00
// read all columns for this row
2017-05-06 16:22:44 +02:00
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 ) ;
2017-05-21 13:43:56 +02:00
// drive row 2
2017-05-06 16:22:44 +02:00
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 ) ) ;
2017-05-21 13:43:56 +02:00
// read all columns for this row
2017-05-06 16:22:44 +02:00
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 ) ;
2017-05-21 13:43:56 +02:00
// drive row 3
2017-05-06 16:22:44 +02:00
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 ) ) ;
2017-05-21 13:43:56 +02:00
// read all columns for this row
2017-05-06 16:22:44 +02:00
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 ) ;
2017-05-06 17:00:10 +02:00
uint16_t buttons_diff = buttons ^ buttons_new ; // get difference
buttons = buttons_new ; // save new state
if ( buttons_diff ) { // only do something if there is a change
2018-04-30 14:40:01 +02:00
printf ( " button pressed: %016b \n " , buttons ) ;
2017-05-21 13:43:56 +02:00
for ( uint8_t number = 0 ; number < LENGTH ( numbers ) ; number + + ) { // check buttons for every number
if ( buttons_diff & ( 1 < < numbers [ number ] . up ) | | buttons_diff & ( 1 < < numbers [ number ] . down ) ) { // a button for the number has been pressed
2017-05-06 17:00:10 +02:00
if ( buttons & ( 1 < < numbers [ number ] . up ) & & buttons & ( 1 < < numbers [ number ] . down ) ) { // both buttons are pressed
numbers [ number ] . number = 0xffff ; // disable number
} else if ( buttons & ( 1 < < numbers [ number ] . up ) & & buttons_diff & ( 1 < < numbers [ number ] . up ) ) { // only up button has been pressed
2017-05-21 13:43:56 +02:00
// increment number
2017-05-06 17:00:10 +02:00
if ( 0xffff = = numbers [ number ] . number ) {
numbers [ number ] . number = 0 ;
} else {
numbers [ number ] . number = ( numbers [ number ] . number + 1 ) % 10000 ;
}
} else if ( buttons & ( 1 < < numbers [ number ] . down ) & & buttons_diff & ( 1 < < numbers [ number ] . down ) ) { // only down button has been pressed
2017-05-21 13:43:56 +02:00
// decrement number
2017-05-06 17:00:10 +02:00
if ( 0xffff = = numbers [ number ] . number ) {
numbers [ number ] . number = 9999 ;
} else if ( 0 = = numbers [ number ] . number ) {
numbers [ number ] . number = 0xffff ;
} else {
numbers [ number ] . number - = 1 ;
}
}
2017-05-21 13:43:56 +02:00
// display numbers on TM1637
mux_select ( numbers [ number ] . display ) ;
if ( 0xffff = = numbers [ number ] . number ) {
led_tm1637_off ( ) ;
} else {
led_tm1637_number ( numbers [ number ] . number ) ;
}
// save number
uint8_t bytes [ 2 ] = { numbers [ number ] . number > > 8 , numbers [ number ] . number } ;
if ( ! rtc_ds1307_write_rom ( number * LENGTH ( bytes ) , bytes , LENGTH ( bytes ) ) ) {
printf ( " could not set number on EEPROM \n " ) ;
}
2017-05-07 20:29:32 +02:00
}
2017-05-06 17:00:10 +02:00
}
2017-05-21 11:47:50 +02:00
if ( ( buttons_diff & ( 1 < < BUTTON_SECONDS_UP ) & & buttons & ( 1 < < BUTTON_SECONDS_UP ) ) | | ( buttons_diff & ( 1 < < BUTTON_SECONDS_DOWN ) & & buttons & ( 1 < < BUTTON_SECONDS_DOWN ) ) ) { // buttons for time pressed
2017-05-07 15:53:20 +02:00
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 peripheral
} else {
// adjust time
2017-05-21 11:47:50 +02:00
if ( buttons_diff & ( 1 < < BUTTON_SECONDS_UP ) & & buttons & ( 1 < < BUTTON_SECONDS_UP ) ) { // up pressed
2017-05-21 13:43:56 +02:00
// increment time by one second
2017-05-07 15:53:20 +02:00
if ( ! ( 23 = = rtc_ds1307_time [ 2 ] & & 59 = = rtc_ds1307_time [ 1 ] & & 59 = = rtc_ds1307_time [ 0 ] ) ) { // don't handle date changes since it's too complex
rtc_ds1307_time [ 0 ] + = 1 ;
while ( rtc_ds1307_time [ 0 ] > = 60 ) {
rtc_ds1307_time [ 0 ] - = 60 ;
rtc_ds1307_time [ 1 ] + = 1 ;
}
while ( rtc_ds1307_time [ 1 ] > = 60 ) {
rtc_ds1307_time [ 1 ] - = 60 ;
rtc_ds1307_time [ 2 ] + = 1 ;
}
while ( rtc_ds1307_time [ 2 ] > = 24 ) {
rtc_ds1307_time [ 2 ] - = 24 ;
}
}
2017-05-21 11:47:50 +02:00
} else if ( buttons_diff & ( 1 < < BUTTON_SECONDS_DOWN ) & & buttons & ( 1 < < BUTTON_SECONDS_DOWN ) ) { // down pressed
2017-05-21 13:43:56 +02:00
// decrement time by one second
2017-05-07 15:53:20 +02:00
if ( ! ( 0 = = rtc_ds1307_time [ 2 ] & & 0 = = rtc_ds1307_time [ 1 ] & & 0 = = rtc_ds1307_time [ 0 ] ) ) { // don't handle date changes since it's too complex
if ( rtc_ds1307_time [ 0 ] > 0 ) {
rtc_ds1307_time [ 0 ] - = 1 ;
} else {
rtc_ds1307_time [ 0 ] = 59 ;
if ( rtc_ds1307_time [ 1 ] > 0 ) {
rtc_ds1307_time [ 1 ] - = 1 ;
} else {
rtc_ds1307_time [ 1 ] = 59 ;
rtc_ds1307_time [ 2 ] - = 1 ; // it can't be 0
}
}
}
}
rtc_seconds = rtc_ds1307_time [ 0 ] ; // save seconds since this is only updated every minute
2017-05-21 13:43:56 +02:00
if ( ! rtc_ds1307_write_time ( rtc_ds1307_time [ 0 ] , rtc_ds1307_time [ 1 ] , rtc_ds1307_time [ 2 ] , rtc_ds1307_time [ 3 ] , rtc_ds1307_time [ 4 ] , rtc_ds1307_time [ 5 ] , rtc_ds1307_time [ 6 ] ) ) { // save adjusted time to DS1307
2017-05-07 15:53:20 +02:00
printf ( " could not set time on DS1307: resetting \n " ) ;
rtc_ds1307_setup ( ) ; // resetting peripheral
}
}
}
2018-04-30 14:40:01 +02:00
standby_timer = 0 ; // restart standby timer
2017-05-06 16:22:44 +02:00
}
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-17 17:11:33 +02:00
if ( standby_timer > = STANDBY_TIMEOUT ) { // 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 " ) ;
2017-05-21 13:43:56 +02:00
// increment and save take and video/audio numbers if there has been a clap
2017-05-17 17:11:33 +02:00
if ( - 2 = = morse_delay ) {
morse_delay = - 1 ; // prevent incrementing multiple times
2017-05-21 11:47:50 +02:00
uint8_t bytes [ LENGTH ( numbers ) * 2 ] = { 0 } ; // all numbers to write again in EEPROM
for ( uint8_t number = 0 ; number < LENGTH ( numbers ) ; number + + ) { // increment numbers
if ( number ! = 0 & & number ! = 1 & & numbers [ number ] . number ! = 0xffff ) { // don't increment episode, scene, or disabled numbers
numbers [ number ] . number = ( numbers [ number ] . number + 1 ) % 10000 ;
printf ( " incrementing %u to %u \n " , number , numbers [ number ] . number ) ;
2017-05-17 17:11:33 +02:00
}
2017-05-21 11:47:50 +02:00
bytes [ 2 * number + 0 ] = numbers [ number ] . number > > 8 ; // set number to save
bytes [ 2 * number + 1 ] = numbers [ number ] . number ; // set number to save
}
if ( ! rtc_ds1307_write_rom ( 0 , bytes , LENGTH ( bytes ) ) ) { // save numbers to EEPROM
printf ( " could not set numbers on EEPROM \n " ) ;
2017-05-17 17:11:33 +02:00
}
}
2017-05-04 12:05:17 +02:00
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-21 11:47:50 +02:00
led_max7219_off ( 0xff ) ; // switch off MAX7219 displays
timer_disable_counter ( TIM ( BUZZER_TIMER ) ) ; // stop buzzing
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 " ) ;
2017-05-21 13:43:56 +02:00
rtc_ds1307_setup ( ) ; // resetting peripheral
2017-04-02 10:15:13 +02:00
} 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
2017-05-21 11:47:50 +02:00
led_max7219_number ( 20000000 + rtc_ds1307_time [ 6 ] * 10000 + rtc_ds1307_time [ 5 ] * 100 + rtc_ds1307_time [ 4 ] , 0x14 , 0 ) ; // display date on 1st display
2017-04-02 10:15:13 +02:00
}
2017-02-09 12:45:16 +01:00
}
2017-02-08 12:44:34 +01:00
}
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
2017-05-14 18:35:07 +02:00
action = true ; // action has been performed
2017-05-04 12:53:20 +02:00
keep_alive_flag = false ; // clear flag
2017-04-02 16:14:55 +02:00
standby_timer = 0 ; // restart standby timer
}
2017-05-14 18:35:07 +02:00
while ( clap_flag ) { // clap detected
action = true ; // action has been performed
clap_flag = false ; // clear flag
if ( morse_delay < 0 ) { // if beeping is not already queued
encode_morse ( ) ; // encode scene and take number into Morse code
morse_delay = FRAME_RATE ; // wait 1 second
}
}
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
}
2017-05-14 18:35:07 +02:00
/** clap */
void EXTI_ISR ( CLAP_BUTTON_PIN ) ( void )
{
exti_reset_request ( EXTI ( CLAP_BUTTON_PIN ) ) ; // reset interrupt
clap_flag = true ; // perform clap action
}