clapperboard/main.c

/* 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/>.
 *
 */
/** STM32F1 example
 *  @file main.c
 *  @author King Kévin <kingkevin@cuvoodoo.info>
 *  @date 2016
 */

/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdbool.h> // boolean type
#include <string.h> // string utilities

/* STM32 (including CM3) libraries */
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
#include <libopencm3/cm3/scb.h> // vector table definition
#include <libopencm3/cm3/nvic.h> // interrupt utilities
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/exti.h> // external interrupt utilities
#include <libopencm3/stm32/rtc.h> // real time clock utilities
#include <libopencm3/stm32/iwdg.h> // independent watchdog utilities
#include <libopencm3/stm32/dbgmcu.h> // debug utilities
#include <libopencm3/stm32/flash.h> // flash utilities

/* own libraries */
#include "global.h" // board definitions
#include "print.h" // printing utilities
#include "usart.h" // USART utilities
#include "usb_cdcacm.h" // USB CDC ACM utilities
#include "rtc_ds1307.h" // DS1307 RTC utilities
#include "led_tm1637.h" // TM1637 7-segment controller utilities
#include "led_max7219.h" // MAX7219 7-segment controller utilities

#define WATCHDOG_PERIOD 10000 /**< watchdog period in ms */

/** @defgroup main_flags flag set in interrupts to be processed in main task
 *  @{
 */
volatile bool rtc_internal_tick_flag = false; /**< flag set when internal RTC ticked */
/** @} */

/** user input command */
static char command[32] = {0};
/** user input command index */
uint8_t command_i = 0;

size_t putc(char c)
{
	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	
}

/** process user command
 *  @param[in] str user command string (\0 ended)
 */
static void process_command(char* str)
{
	// split command
	const char* delimiter = " ";
	char* word = strtok(str,delimiter);
	if (!word) {
		goto error;
	}
	// parse command
	if (0==strcmp(word,"help")) {
		printf("available commands:\n");
		printf("led [on|off|toggle]\n");
		printf("time [HH:MM:SS]\n");
		printf("date [YYYY-MM-DD]\n");
	} 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
			printf("LED switched on\n"); // notify user		
		} else if (0==strcmp(word,"off")) {
			led_off(); // switch LED off
			printf("LED switched off\n"); // notify user
		} else if (0==strcmp(word,"toggle")) {
			led_toggle(); // toggle LED
			printf("LED toggled\n"); // notify user
		} else {
			goto error;
		}
	} 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)) {
				printf("setting hours failed\n");
			} else if (!rtc_ds1307_write_minutes((word[3]-'0')*10+(word[4]-'0')*1)) {
				printf("setting minutes failed\n");
			} else if (!rtc_ds1307_write_seconds((word[6]-'0')*10+(word[7]-'0')*1)) {
				printf("setting seconds failed\n");
			} else {
				rtc_ds1307_oscillator_enable(); // be sure the oscillation is enabled
				printf("time set\n");
			}
		}
	} 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)) {
				printf("setting year failed\n");
			} else if (!rtc_ds1307_write_month((word[5]-'0')*10+(word[6]-'0')*1)) {
				printf("setting month failed\n");
			} else if (!rtc_ds1307_write_date((word[8]-'0')*10+(word[9]-'0')*1)) {
				printf("setting day failed\n");
			} else {
				printf("date set\n");
			}
		}
	} else {
		goto error;
	}

	return; // command successfully processed
error:
	printf("command not recognized. enter help to list commands\n");
	return;
}

/** program entry point
 *  this is the firmware function started by the micro-controller
 */
void main(void);
void main(void)
{	
	rcc_clock_setup_in_hse_8mhz_out_72mhz(); // use 8 MHz high speed external clock to generate 72 MHz internal clock

#if DEBUG
	// enable functionalities for easier debug
	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)
#else
	// 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
#endif

	board_setup(); // setup board
    usart_setup(); // setup USART for user communication
	cdcacm_setup(); // setup USB ACM (serial) for user communication
	printf("welcome to the STM32F1 CuVoodoo example code\n"); // print welcome message

#if !(DEBUG)
	// show watchdog information
	printf("watchdog set to (%2u.%2us)\n",WATCHDOG_PERIOD/1000, (WATCHDOG_PERIOD/10)%100);
	if (FLASH_OBR&FLASH_OBR_OPTERR) {
		printf("option bytes not set in flash: software wachtdog used (not started at reset)\n");
	} else if (FLASH_OBR&FLASH_OBR_WDG_SW) {
		printf("software wachtdog used (not started at reset)\n");
	} else {
		printf("hardware wachtdog used (started at reset)\n");
	}
#endif

	// setup internal RTC
	printf("setup internal RTC: ");
	rtc_auto_awake(RCC_LSE, 32768-1); // ensure internal RTC is on, uses the 32.678 kHz LSE, and the prescale is set to our tick speed, else update backup registers accordingly (power off the micro-controller for the change to take effect)
	rtc_interrupt_enable(RTC_SEC); // enable RTC interrupt on "seconds"
	nvic_enable_irq(NVIC_RTC_IRQ); // allow the RTC to interrupt
	printf("OK\n");
	// display uptime
	uint32_t ticks_time = rtc_get_counter_val(); // get time from internal RTC (since first start/power up)
	printf("uptime: %u.%02u:%02u:%02u\n", ticks_time/(60*60*24), (ticks_time/(60*60))%24, (ticks_time%(60*60))/60, (ticks_time%60)); // display uptime

	// setup external RTC
	printf("setup external RTC: ");
	rtc_ds1307_setup(); // setup external RTC module
	printf("OK\n");
	// 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
	}
	// display date
	uint8_t* 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\n");
	} else {
		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]);
	}

	// setup TM1637 and MAX7219 7-segments displays
	printf("setup 7-segment displays: ");
	led_tm1637_setup(); // setup TM1637
	led_max7219_setup(); // setup MAX7219
	if (!led_tm1637_time(88,88)) { // test TM1637 display
		printf("could not send time to TM1637\n");
	}
	if (!led_tm1637_on()) { // switch on TM1637 display
		printf("could not switch on TM1637\n");
	}
	led_max7219_intensity(15,8,0); // set brightness max and enable all digits on 1st display
	led_max7219_intensity(15,8,1); // set brightness max and enable all digits on 1st display
	led_max7219_test(true,0); // test 1st MAX7219 display
	led_max7219_test(true,1); // test 2nd MAX7219 display
	for (uint32_t i=0; i<5000000; i++) { // wait a bit to have the user check the display
		__asm__("nop");
	}
	if (!led_tm1637_text("    ")) { // clear display
		printf("could not clear\n");
	}
	if (!led_tm1637_off()) { // switch off display
		printf("could not switch off TM1637\n");
	}
	led_max7219_test(false,0); // go back in normal operation
	led_max7219_test(false,1); // go back in normal operation
	led_max7219_off(0); // switch 1st display off
    led_max7219_off(1); // switch 2nd display off
	printf("OK\n");
	
	led_max7219_number(rtc_ds1307_time[2]*1000000+rtc_ds1307_time[1]*10000+rtc_ds1307_time[0]*100, 0x54, 0); // display time on 1nd display
	led_max7219_number(20000000+rtc_ds1307_time[6]*10000+rtc_ds1307_time[5]*100+rtc_ds1307_time[4], 0x14, 1); // display date on 2nd display
	led_max7219_on(0); // switch 1st display on
	led_max7219_on(1); // switch 2nd display on
	
	// main loop
	printf("command input: ready\n");
	bool action = false; // if an action has been performed don't go to sleep
	button_flag = false; // reset button flag
	char c = '\0'; // to store received character
	bool char_flag = false; // a new character has been received
	while (true) { // infinite loop
		iwdg_reset(); // kick the dog
		while (usart_received) { // data received over UART
			action = true; // action has been performed
			led_toggle(); // toggle LED
			c = usart_getchar(); // store receive character
			char_flag = true; // notify character has been received
		}
		while (cdcacm_received) { // data received over USB
			action = true; // action has been performed
			led_toggle(); // toggle LED
			c = cdcacm_getchar(); // store receive character
			char_flag = true; // notify character has been received
		}
		while (char_flag) { // user data received
			char_flag = false; // reset flag
			action = true; // action has been performed
			putc(c); // echo receive character
			if (c=='\r' || c=='\n') { // end of command received
				if (command_i>0) { // there is a command to process
					command[command_i] = 0; // end string
					command_i = 0; // prepare for next command
					process_command(command); // process user command
				}
			} else { // user command input
				command[command_i] = c; // save command input
				if (command_i<LENGTH(command)-2) { // verify if there is place to save next character
					command_i++; // save next character
				}
			}
		}
		while (button_flag) { // user pressed button
			action = true; // action has been performed
			printf("button pressed\n");
			led_toggle(); // toggle LED
			for (uint32_t i=0; i<1000000; i++) { // wait a bit to remove noise and double trigger
				__asm__("nop");
			}
			button_flag = false; // reset flag
		}
		while (rtc_internal_tick_flag) { // the internal RTC ticked
			rtc_internal_tick_flag = false; // reset flag
			led_toggle(); // toggle LED (good to indicate if main function is stuck)
			ticks_time = rtc_get_counter_val(); // copy time from internal RTC for processing
			action = true; // action has been performed
			if ((ticks_time%(60))==0) { // one minute passed
				printf("uptime: %u.%02u:%02u:%02u\n", ticks_time/(60*60*24), (ticks_time/(60*60))%24, (ticks_time%(60*60))/60, (ticks_time%60)); // display uptime
			}
			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 {
				if (!led_tm1637_time(rtc_ds1307_time[1], rtc_ds1307_time[0])) {
					printf("could not set time on TM1637\n");
				}
			}
			if (!led_tm1637_on()) { // switch on display
				printf("could not switch on TM1637\n");
			}
		}
		if (action) { // go to sleep if nothing had to be done, else recheck for activity
			action = false;
		} else {
			__WFI(); // go to sleep
		}
	} // main loop
}

/** @brief interrupt service routine called when tick passed on RTC */
void rtc_isr(void)
{
	rtc_clear_flag(RTC_SEC); // clear flag
	rtc_internal_tick_flag = true; // notify to show new time
}