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

/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdlib.h> // standard utilities
#include <string.h> // string utilities
#include <math.h> // mathematical 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
#include <libopencm3/stm32/adc.h> // ADC utilities
#include <libopencm3/stm32/rtc.h> // 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<LENGTH(clock_leds); i++) {
		clock_leds[i] = 0;
	}
}

/** show time on LED clock
 *  @param[in] time in ticks to show
 *  @details show hours and minutes progress as full arcs, show second position as marker. the brightness of the LED shows the progress of the unit. hours are blue, minutes green, seconds red
 *  @note LEDs need to be set separately
 */
static void clock_show_time(uint32_t time)
{
	uint32_t led_hour = (LED_WS2812B_LEDS*256ULL*(time%TICKS_MIDDAY))/TICKS_MIDDAY; // scale to LED brightnesses for hours
	uint32_t led_minute = (LED_WS2812B_LEDS*256ULL*(time%TICKS_HOUR))/TICKS_HOUR; // scale to LED brightnesses for minutes
	if (led_hour>=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<LED_WS2812B_LEDS; 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
		}
		// show minutes in green (override hours)
		for (uint16_t led=0; led<LED_WS2812B_LEDS && led_minute>0; 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<LED_WS2812B_LEDS; 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)
		}
		// show hours in blue (override minutes)
		for (uint16_t led=0; led<LED_WS2812B_LEDS && led_hour>0; 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; i<LENGTH(clock_leds)/3; i++) {
		led_ws2812b_set_rgb(i,gamma_correction_lut[(uint8_t)(clock_leds[i*3+0]*clock_brightness)],gamma_correction_lut[(uint8_t)(clock_leds[i*3+1]*clock_brightness)],gamma_correction_lut[(uint8_t)(clock_leds[i*3+2]*clock_brightness)]); // set new value (this costs time)
	}
}

/** set the time on the LEDs
 *  @param[in] time time to set
 */
static void clock_set_time(uint32_t time)
{
	clock_show_time(time); // convert time to LED values
	clock_leds_set(); // set the colors of all LEDs
	led_ws2812b_transmit(); // transmit set color
}

/** incrementally set the time on the LEDs
 *  @details this will have an animation where time is incremented until it reaches the provided time
 *  @param[in] time time to set
 */
static void clock_animate_time(uint32_t time)
{
	static uint32_t display_time = 0; // the time to display
	while (display_time<time) {
		if (display_time+TICKS_HOUR<=time) { // first set hours
			display_time += TICKS_HOUR; // increment hours
		} else if (display_time+TICKS_MINUTE<=time) { // second set minutes
			display_time += TICKS_MINUTE; // increment minutes
		} else if (display_time+TICKS_SECOND<=time) { // third set seconds
			display_time += TICKS_SECOND; // increment seconds
		} else { // finally set time
			display_time = time;
		}
		clock_set_time(display_time); // set time (progress)
		// delay some time for the animation
		for (uint32_t i=0; i<400000; i++) {
			__asm__("nop");
		}
	}
}

/** show animation with fading hours mark on clock LEDs
 */
static void clock_hours(void)
{
	for (uint16_t i=0; i<255; i++) { // fade out
		for (uint16_t led=0; led<LED_WS2812B_LEDS; led++) { // fade minutes out
			if (clock_leds[led*3+1]) {
				clock_leds[led*3+1] -= 1; // fade minutes out (green)
			}
			if (clock_leds[led*3+0]) {
				clock_leds[led*3+0] -= 1; // fade seconds out (red)
			}
		}
		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");
		}
	}
	for (uint16_t i=0; i<512; i++) { // fade hour marks in and out
		uint8_t brightness = (i>255 ? 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; i<LENGTH(gamma_correction_lut); i++) { // generate gamma correction table
		gamma_correction_lut[i] = powf((float)i / (float)LENGTH(gamma_correction_lut), 2.2)*LENGTH(gamma_correction_lut); // calculate using fixed gamma value
	}
	led_ws2812b_setup(); // setup WS2812B LEDs
	clock_clear(); // clear all LEDs
	clock_leds_set(); // set the colors of all LEDs
	led_ws2812b_transmit(); // transmit set color
	printf("OK\n");

	// setup ADC to photo-resistor voltage
	printf("setup brightness sensor: ");
	rcc_periph_clock_enable(RCC_ADC12_IN(PHOTORESISTOR_ADC_CHANNEL)); // enable clock for photo-resistor GPIO peripheral
	gpio_set_mode(ADC12_IN_PORT(PHOTORESISTOR_ADC_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(PHOTORESISTOR_ADC_CHANNEL)); // set photo-resistor GPIO as analogue input for the ADC
	rcc_periph_clock_enable(RCC_ADC1); // enable clock for ADC peripheral
	adc_off(ADC1); // switch off ADC while configuring it
	// configuration is correct per default
	adc_set_single_conversion_mode(ADC1); // we just want one measurement
	adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); // use 28.5 cycles to sample (long enough to be stable)
	adc_enable_temperature_sensor(ADC1); // enable internal voltage reference
	adc_enable_discontinuous_mode_regular(ADC1, 1); // do only one conversion per sequence
	adc_enable_external_trigger_regular(ADC1, ADC_CR2_EXTSEL_SWSTART); // use software trigger to start conversion
	adc_power_on(ADC1); // switch on ADC
	for (uint32_t i=0; i<800000; i++) { // wait t_stab for the ADC to stabilize
		__asm__("nop");
	}
	adc_reset_calibration(ADC1); // remove previous non-calibration
	adc_calibration(ADC1); // calibrate ADC for less accuracy errors
	// read internal reference 1.2V
	uint8_t channels[] = {ADC_CHANNEL17}; // voltages to convert
	adc_set_regular_sequence(ADC1, LENGTH(channels), channels); // set channels to convert
	adc_start_conversion_regular(ADC1); // start conversion to get first voltage of this group
	while (!adc_eoc(ADC1)); // wait until conversion finished
	uint16_t ref_value = adc_read_regular(ADC1); // read internal reference 1.2V voltage value
	// now use interrupts to only measure ambient luminosity
	channels[0] = ADC_CHANNEL(PHOTORESISTOR_ADC_CHANNEL); // only measure ambient luminosity
	adc_set_regular_sequence(ADC1, 1, channels); // set now group
	adc_enable_eoc_interrupt(ADC1); // enable interrupt for end of conversion
	nvic_enable_irq(NVIC_ADC1_2_IRQ); // enable ADC interrupts
	printf("OK\n");

	// get date and time
	uint32_t ticks_time = rtc_get_counter_val(); // get time/date from internal RTC
	printf("current time: %02u:%02u:%02u\n", ticks_time/TICKS_HOUR, (ticks_time%TICKS_HOUR)/TICKS_MINUTE, (ticks_time%TICKS_MINUTE)/TICKS_SECOND); // display time
	clock_animate_time(ticks_time); // set time with animation

	// main loop
	printf("command input: ready\n");
	led_on(); // indicate everything is OK and the main loop will start
	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 (usb_cdcacm_received) { // data received over USB
			action = true; // action has been performed
			led_toggle(); // toggle LED
			c = usb_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
			printf("%c",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_dcf77_time_flag) { // the DCF77 module received a new time
			rtc_dcf77_time_flag = false; // reset flag
			action = true; // action has been performed
			if (rtc_dcf77_time.valid) { // ensure decoded time is valid
				ticks_time = rtc_dcf77_time.hours*TICKS_HOUR+rtc_dcf77_time.minutes*TICKS_MINUTE+rtc_dcf77_time.seconds*TICKS_SECOND+(rtc_dcf77_time.milliseconds*TICKS_SECOND)/1000; // calculate new time
				rtc_set_counter_val(ticks_time); // set new time to internal RTC
				printf("DCF77 time: 20%02u-%02u-%02u %02u:%02u:%02u\n", rtc_dcf77_time.year, rtc_dcf77_time.month, rtc_dcf77_time.day, rtc_dcf77_time.hours, rtc_dcf77_time.minutes, rtc_dcf77_time.seconds); // display time
				// never switch of DCF77 receiver since the signal gets better demodulated with time, we always have power, we can always get correct the time
			} else {
				printf("DCF77 time: error\n");
			}
		}
		while (rtc_internal_tick_flag) { // the internal RTC ticked
			rtc_internal_tick_flag = false; // reset flag
			ticks_time = rtc_get_counter_val(); // copy time from internal RTC for processing
			action = true; // action has been performed
			if ((ticks_time%(TICKS_SECOND/10))==0) { // one tenth of a second passed
				adc_start_conversion_regular(ADC1); // start measuring ambient luminosity
			}
			if ((ticks_time%TICKS_SECOND)==0) { // one second passed
				//led_toggle(); // LED toggling confuses the 32.768 kHz oscillator on the blue pill
			}
			if ((ticks_time%TICKS_MINUTE)==0) { // one minute passed
				printf("%02u:%02u:%02u\n", ticks_time/TICKS_HOUR, (ticks_time%TICKS_HOUR)/TICKS_MINUTE, (ticks_time%TICKS_MINUTE)/TICKS_SECOND); // display external time
			}
			if ((ticks_time%(TICKS_MINUTE*5))==0) { // five minutes passed
				rtc_dcf77_on(); // ensure the module is on in case it switched off because of decoding issues
			}
			if ((ticks_time%TICKS_HOUR)==0) { // one hours passed
				clock_hours(); // show hour markers
			}
			if (ticks_time>=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_voltage<PHOTORESISTOR_MAX) { // high ambient luminosity
				new_clock_brightness = BRIGHTNESS_MAX; // set highest brightness
			} else if (photoresistor_voltage>PHOTORESISTOR_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
}