/* 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 .
*
*/
/** STM32F1 application example
* @file application.c
* @author King Kévin
* @date 2016-2017
*/
/* standard libraries */
#include // standard integer types
#include // standard utilities
#include // string utilities
#include // mathematical utilities
/* STM32 (including CM3) libraries */
#include // Cortex M3 utilities
#include // vector table definition
#include // interrupt utilities
#include // general purpose input output library
#include // real-time control clock library
#include // external interrupt utilities
#include // real time clock utilities
#include // independent watchdog utilities
#include // debug utilities
#include // flash utilities
#include // ADC utilities
#include // real time clock 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 "led_ws2812b.h" // WS2812B LEDs utilities
#include "rtc_dcf77.h" // DCF77 time receiver utilities
/** use external RTC, else use internal RTC */
#define EXTERNAL_RTC false
#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 */
volatile bool photoresistor_flag = false; /**< flag set when ambient luminosity is measured */
/** @} */
/** @defgroup main_ticks ticks per time units
* @note these are derived from TICKS_PER_SECOND
* @note I have to use type variables because defines would be stored in signed integers, leading to an overflow it later calculations
* @{
*/
/** the number of ticks in one second (32768 divisor greater than 256*LED_WS2812B_LEDS/60) */
#define TICKS_PER_SECOND (256UL)
/** number of ticks in one second */
#define TICKS_SECOND (TICKS_PER_SECOND)
/** number of ticks in one minute */
#define TICKS_MINUTE (60*TICKS_SECOND)
/** number of ticks in one hour */
#define TICKS_HOUR (60*TICKS_MINUTE)
/** number of ticks in one midday (12 hours) */
#define TICKS_MIDDAY (12*TICKS_HOUR)
/** @} */
/** @defgroup photoresistor_adc ADC used to ambient luminosity
* @{
*/
#define PHOTORESISTOR_ADC_CHANNEL 1 /**< ADC channel */
/** @} */
/** RGB values for the WS2812B clock LEDs */
uint8_t clock_leds[LED_WS2812B_LEDS*3] = {0};
/** gamma correction lookup table (common for all colors) */
uint8_t gamma_correction_lut[256] = {0};
/** photo-resistor measurement of ambient luminosity */
volatile uint16_t photoresistor_value = 0;
/** photo-resistor voltage for the minimum brightness */
#define PHOTORESISTOR_MIN 2.7
/** photo-resistor voltage for the maximum brightness */
#define PHOTORESISTOR_MAX 1.7
/** factor to dim LED of the clock, depending on the ambient luminosity */
float clock_brightness = 1;
/** minimum LED brightness */
#define BRIGHTNESS_MIN 0.2
/** maximum LED brightness */
#define BRIGHTNESS_MAX 1.0
/** the factor to change the brightness */
#define BRIGHTNESS_FACTOR 0.1
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
usb_cdcacm_putchar('\r'); // send CR over USB
usart_putchar_nonblocking('\n'); // send LF over USART
usb_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
usb_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
}
/** user input command */
static char command[32] = {0};
/** user input command index */
uint8_t command_i = 0;
/** 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,"h") || 0==strcmp(word,"help") || 0==strcmp(word,"?")) {
printf("available commands:\n");
printf("led [on|off|toggle]\n");
printf("time [HH:MM:SS]\n");
printf("DCF77 on|off\n");
} else if (0==strcmp(word,"l") || 0==strcmp(word,"led")) {
word = strtok(NULL,delimiter);
if (!word) {
printf("LED is ");
if (gpio_get(GPIO(LED_PORT), GPIO(LED_PIN))) {
printf("on\n");
} else {
printf("off\n");
}
} 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("time: %02U:%02U:%02U\n", rtc_get_counter_val()/TICKS_HOUR, (rtc_get_counter_val()%TICKS_HOUR)/TICKS_MINUTE, (rtc_get_counter_val()%TICKS_MINUTE)/TICKS_SECOND); // get and print time from internal 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 {
rtc_set_counter_val(((word[0]-'0')*10+(word[1]-'0')*1)*TICKS_HOUR+((word[3]-'0')*10+(word[4]-'0')*1)*TICKS_MINUTE+((word[6]-'0')*10+(word[7]-'0')*1)*TICKS_SECOND); // set time in internal RTC counter
printf("time set\n");
}
} else if (0==strcmp(word,"DCF77")) {
word = strtok(NULL,delimiter);
if (!word) {
goto error;
} else if (0==strcmp(word,"on")) {
rtc_dcf77_on(); // switch DCF77 on
printf("DCF77 receiver switched on\n"); // notify user
} else if (0==strcmp(word,"off")) {
rtc_dcf77_off(); // switch DCF77 off
printf("DCF77 receiver switched off\n"); // notify user
} else {
goto error;
}
} else {
goto error;
}
return; // command successfully processed
error:
printf("command not recognized. enter help to list commands\n");
return;
}
/** switch off all clock LEDs
* @note LEDs need to be set separately
*/
static void clock_clear(void)
{
// set all colors of all LEDs to 0
for (uint16_t i=0; i=LED_WS2812B_LEDS*256 || led_minute>=LED_WS2812B_LEDS*256) { // a calculation error occurred
return;
}
// show hours and minutes on LEDs
if (led_hour>led_minute) {
// show hours in blue (and clear other LEDs)
for (uint16_t led=0; led=0xff) { // full hours
clock_leds[led*3+2] = 0xff; // set blue (hours) to full
} else { // running hours
clock_leds[led*3+2] = led_hour; // set blue (hours) to remaining
}
led_hour -= clock_leds[led*3+2]; // subtract displayed value
}
// show minutes in green (override hours)
for (uint16_t led=0; led0; led++) {
clock_leds[led*3+0] = 0; // clear red (seconds)
if (led_minute>=0xff) { // full minutes
clock_leds[led*3+1] = 0xff; // set green (minutes) to full
} else { // running minutes
clock_leds[led*3+1] = led_minute; // set green (minutes) to remaining
}
led_minute -= clock_leds[led*3+1]; // subtract displayed value
clock_leds[led*3+2] = 0; // clear blue (hours)
}
} else {
// show minutes in green (and clear other LEDs)
for (uint16_t led=0; led=0xff) { // full minutes
clock_leds[led*3+1] = 0xff; // set green (minutes) to full
} else { // running minutes
clock_leds[led*3+1] = led_minute; // set green (minutes) to remaining
}
led_minute -= clock_leds[led*3+1]; // subtract displayed value
clock_leds[led*3+2] = 0; // clear blue (hours)
}
// show hours in blue (override minutes)
for (uint16_t led=0; led0; led++) {
clock_leds[led*3+0] = 0; // clear red (seconds)
clock_leds[led*3+1] = 0; // clear green (minutes)
if (led_hour>=0xff) { // full hours
clock_leds[led*3+2] = 0xff; // set blue (hours) to full
} else { // running hours
clock_leds[led*3+2] = led_hour; // set blue (hours) to remaining
}
led_hour -= clock_leds[led*3+2]; // subtract displayed value
}
}
// don't show seconds on full minute (better for first time setting, barely visible else)
if (time%TICKS_MINUTE==0) {
return;
}
uint32_t led_second = (LED_WS2812B_LEDS*(256*(uint64_t)(time%TICKS_MINUTE)))/TICKS_MINUTE; // scale to LED brightnesses for seconds
uint8_t brightness_second = led_second%256; // get brightness for seconds for last LED
uint16_t second_led = (LED_WS2812B_LEDS*(time%TICKS_MINUTE))/TICKS_MINUTE; // get LED for seconds (we only use the last LED as runner instead of all LEDs as arc)
// set seconds LED
clock_leds[second_led*3+0] = brightness_second;
//clock_leds[second_led*3+1] = 0; // clear other colors (minutes/hours indication)
//clock_leds[second_led*3+2] = 0; // clear other colors (minutes/hours indication)
// set previous seconds LED
second_led = ((second_led==0) ? LED_WS2812B_LEDS-1 : second_led-1); // previous LED
clock_leds[second_led*3+0] = 0xff-brightness_second;
//clock_leds[second_led*3+1] = 0; // clear other colors (minutes/hours indication)
//clock_leds[second_led*3+2] = 0; // clear other colors (minutes/hours indication)
}
/** set the LEDs
* @details set the LED colors on WS2812B LEDs
* @note WS2812B LED color values need to be transmitted separately
*/
static void clock_leds_set(void)
{
for (uint16_t i=0; i255 ? 512-i-1 : i); // get fade brightness
for (uint8_t hour=0; hour<12; hour++) { // set all hour colors
uint16_t led = (uint16_t)(LED_WS2812B_LEDS*hour)/12; // get LED four hour mark
clock_leds[led*3+0] = brightness; // set brightness
clock_leds[led*3+1] = brightness; // set brightness
clock_leds[led*3+2] = brightness; // set brightness
}
clock_leds_set(); // set the colors of all LEDs
led_ws2812b_transmit(); // transmit set color
// delay some time for the animation
for (uint32_t j=0; j<40000; j++) {
__asm__("nop");
}
}
}
/** 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 printing)
usb_cdcacm_setup(); // setup USB CDC ACM (for printing)
printf("welcome to the CuVoodoo LED clock\n"); // print welcome message
#if !(DEBUG)
// show watchdog information
printf("watchdog set to (%.2fs)\n",WATCHDOG_PERIOD/1000.0);
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 RTC
printf("setup internal RTC: ");
rtc_auto_awake(RCC_LSE, 32768/TICKS_SECOND-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");
// setup DCF77
printf("setup DCF77 receiver: ");
rtc_dcf77_setup(); // setup DCF77 module
printf("OK\n");
rtc_dcf77_on(); // switch DCF77 on to get correct time
printf("DCF77 receiver switched on\n"); // notify user
// setup WS2812B LEDs
printf("setup LEDs: ");
for (uint16_t i=0; i0) { // 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=TICKS_MIDDAY*2) { // one day passed
rtc_set_counter_val(rtc_get_counter_val()%TICKS_MIDDAY); // reset time counter
}
clock_set_time(ticks_time); // set time
}
while (photoresistor_flag) { // new photo-resistor value has been measured
photoresistor_flag = false; // reset flag
action = true; // action has been performed
float photoresistor_voltage = photoresistor_value*1.2/ref_value; // calculate voltage from value
float new_clock_brightness = 0; // to calculate new brightness
if (photoresistor_voltagePHOTORESISTOR_MIN) { // low ambient luminosity
new_clock_brightness = BRIGHTNESS_MIN; // set low brightness
} else { // intermediate ambient luminosity
new_clock_brightness = BRIGHTNESS_MIN+(BRIGHTNESS_MAX-BRIGHTNESS_MIN)*(1-(photoresistor_voltage-PHOTORESISTOR_MAX)/(PHOTORESISTOR_MIN-PHOTORESISTOR_MAX)); // set variable brightness
}
clock_brightness = clock_brightness*(1-BRIGHTNESS_FACTOR)+new_clock_brightness*BRIGHTNESS_FACTOR; // calculate new brightness based on factor
//printf("photo-resistor voltage: %f, clock brightness: %f\n", photoresistor_voltage, clock_brightness);
}
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
}
/** interrupt service routine called when ADC conversion completed */
void adc1_2_isr(void)
{
photoresistor_value = adc_read_regular(ADC1); // read measured photo-resistor value (clears interrupt flag)
photoresistor_flag = true; // notify new ambient luminosity has been measured
}