356 lines
12 KiB
C
356 lines
12 KiB
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/>.
|
|
*
|
|
*/
|
|
/** @file main.c
|
|
@author King Kévin <kingkevin@cuvoodoo.info>
|
|
@date 2016
|
|
@brief show the time on a LED strip
|
|
|
|
The LED strip consists of 60 WS2812b LEDs.
|
|
The time is read from a DS1307 RTC module.
|
|
*/
|
|
|
|
/* standard libraries */
|
|
#include <stdint.h> // standard integer types
|
|
#include <stdio.h> // standard I/O facilities
|
|
#include <stdlib.h> // standard utilities
|
|
#include <unistd.h> // standard streams
|
|
#include <errno.h> // error number utilities
|
|
|
|
/* STM32 (including CM3) libraries */
|
|
#include <libopencm3/stm32/rcc.h> // real-time control clock library
|
|
#include <libopencm3/stm32/gpio.h> // general purpose input output library
|
|
#include <libopencm3/cm3/scb.h> // vector table definition
|
|
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
|
|
#include <libopencm3/cm3/nvic.h> // interrupt utilities
|
|
#include <libopencm3/stm32/exti.h> // external interrupt utilities
|
|
|
|
/* own libraries */
|
|
#include "global.h" // board definitions
|
|
#include "usart.h" // USART utilities
|
|
#include "usb_cdcacm.h" // USB CDC ACM utilities
|
|
#include "led_ws2812b.h" // WS2812b LEDs utilities
|
|
#include "rtc_ds1307.h" // Real Time Clock DS1307 utilities
|
|
|
|
/** @defgroup main_flags flag set in interrupts to be processed in main task
|
|
@{
|
|
*/
|
|
volatile bool button_flag = false; /**< flag set if board user button has been pressed */
|
|
/** @} */
|
|
|
|
/** the number of ticks in one second
|
|
* @note the other values are derived from this value @ref main_ticks
|
|
*/
|
|
#define TICKS_PER_SECOND 255
|
|
/** @defgroup main_ticks ticks per time units
|
|
* @note I have to use type variables because defines would be stored in signed integers, leading to an overflow it later calculations
|
|
* @{
|
|
*/
|
|
/** number of ticks in one second */
|
|
const uint32_t ticks_second = TICKS_PER_SECOND;
|
|
/** number of ticks in one minute */
|
|
const uint32_t ticks_minute = 60*TICKS_PER_SECOND;
|
|
/** number of ticks in one hour */
|
|
const uint32_t ticks_hour = 60*60*TICKS_PER_SECOND;
|
|
/** number of ticks in one midday (12 hours) */
|
|
const uint32_t ticks_midday = 12*60*60*TICKS_PER_SECOND;
|
|
/** @} */
|
|
|
|
/** RGB values for the WS2812b clock LEDs */
|
|
uint8_t clock_leds[WS2812B_LEDS*3] = {0};
|
|
|
|
int _write(int file, char *ptr, int len)
|
|
{
|
|
int i;
|
|
|
|
if (file == STDOUT_FILENO || file == STDERR_FILENO) {
|
|
for (i = 0; i < len; i++) {
|
|
if (ptr[i] == '\n') { // add carrier return before line feed. this is recommended for most UART terminals
|
|
usart_putchar_nonblocking('\r'); // a second line feed doesn't break the display
|
|
cdcacm_putchar('\r'); // a second line feed doesn't break the display
|
|
}
|
|
usart_putchar_nonblocking(ptr[i]); // send byte over USART
|
|
cdcacm_putchar(ptr[i]); // send byte over USB
|
|
}
|
|
return i;
|
|
}
|
|
errno = EIO;
|
|
return -1;
|
|
}
|
|
|
|
void led_on(void)
|
|
{
|
|
#ifdef SYSTEM_BOARD
|
|
gpio_clear(LED_PORT, LED_PIN);
|
|
#elif MAPLE_MINI
|
|
gpio_set(LED_PORT, LED_PIN);
|
|
#endif
|
|
}
|
|
|
|
void led_off(void)
|
|
{
|
|
#ifdef SYSTEM_BOARD
|
|
gpio_set(LED_PORT, LED_PIN);
|
|
#elif MAPLE_MINI
|
|
gpio_clear(LED_PORT, LED_PIN);
|
|
#endif
|
|
}
|
|
|
|
void led_toggle(void)
|
|
{
|
|
gpio_toggle(LED_PORT, LED_PIN);
|
|
}
|
|
|
|
/** @brief 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;
|
|
}
|
|
}
|
|
|
|
/** @brief set hours mark on clock LEDs
|
|
* @note LEDs need to be set separately
|
|
*/
|
|
static void clock_hours(void)
|
|
{
|
|
for (uint8_t hour=0; hour<12; hour++) {
|
|
uint16_t led = WS2812B_LEDS/12*hour;
|
|
clock_leds[led*3+0] = 0xff;
|
|
clock_leds[led*3+1] = 0xff;
|
|
clock_leds[led*3+2] = 0xff;
|
|
}
|
|
}
|
|
|
|
/** @brief 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 = (WS2812B_LEDS*(255*(uint64_t)(time%ticks_midday)))/ticks_midday; // scale to LED brightnesses for hours
|
|
uint32_t led_minute = (WS2812B_LEDS*(255*(uint64_t)(time%ticks_hour)))/ticks_hour; // scale to LED brightnesses for minutes
|
|
if (led_hour>=WS2812B_LEDS*255 || led_minute>=WS2812B_LEDS*255) { // 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<WS2812B_LEDS; led++) {
|
|
clock_leds[led*3+0] = 0;
|
|
clock_leds[led*3+1] = 0;
|
|
if (led_hour>=0xff) { // full hours
|
|
clock_leds[led*3+2] = 0xff;
|
|
} else { // running hours
|
|
clock_leds[led*3+2] = led_hour;
|
|
}
|
|
led_hour -= clock_leds[led*3+2];
|
|
}
|
|
// show minutes in green (override hours)
|
|
for (uint16_t led=0; led<WS2812B_LEDS && led_minute>0; led++) {
|
|
clock_leds[led*3+0] = 0;
|
|
if (led_minute>=0xff) { // full minutes
|
|
clock_leds[led*3+1] = 0xff;
|
|
} else { // running minutes
|
|
clock_leds[led*3+1] = led_minute;
|
|
}
|
|
led_minute -= clock_leds[led*3+1];
|
|
clock_leds[led*3+2] = 0;
|
|
}
|
|
} else {
|
|
// show minutes in green (and clear other LEDs)
|
|
for (uint16_t led=0; led<WS2812B_LEDS; led++) {
|
|
clock_leds[led*3+0] = 0;
|
|
if (led_minute>=0xff) { // full minutes
|
|
clock_leds[led*3+1] = 0xff;
|
|
} else { // running minutes
|
|
clock_leds[led*3+1] = led_minute;
|
|
}
|
|
led_minute -= clock_leds[led*3+1];
|
|
clock_leds[led*3+2] = 0;
|
|
}
|
|
// show hours in blue (override minutes)
|
|
for (uint16_t led=0; led<WS2812B_LEDS && led_hour>0; led++) {
|
|
clock_leds[led*3+0] = 0;
|
|
clock_leds[led*3+1] = 0;
|
|
if (led_hour>=0xff) { // full hours
|
|
clock_leds[led*3+2] = 0xff;
|
|
} else { // running hours
|
|
clock_leds[led*3+2] = led_hour;
|
|
}
|
|
led_hour -= clock_leds[led*3+2];
|
|
}
|
|
}
|
|
// don't show seconds on full minute (better for first time setting, barely visible else)
|
|
if (time%ticks_minute==0) {
|
|
return;
|
|
}
|
|
uint16_t led_second = (WS2812B_LEDS*(time%ticks_minute))/ticks_minute; // get LED for seconds
|
|
uint8_t brightness_second = (255*(time%ticks_second))/ticks_second; // get brightness for seconds
|
|
// set second LED
|
|
clock_leds[led_second*3+0] = brightness_second;
|
|
clock_leds[led_second*3+1] = 0;
|
|
clock_leds[led_second*3+2] = 0;
|
|
// set previous LED
|
|
clock_leds[((led_second-1)%WS2812B_LEDS)*3+0] = 0xff-brightness_second;
|
|
clock_leds[((led_second-1)%WS2812B_LEDS)*3+1] = 0;
|
|
clock_leds[((led_second-1)%WS2812B_LEDS)*3+2] = 0;
|
|
}
|
|
|
|
/** @brief set the LEDs
|
|
* @details set the LED colors on WS2812b LEDs
|
|
* @note WS2812b LED color values need to be transmitted separately
|
|
*/
|
|
static void leds_set(void)
|
|
{
|
|
for (uint16_t i=0; i<LENGTH(clock_leds)/3; i++) {
|
|
ws2812b_set_rgb(i,clock_leds[i*3+0],clock_leds[i*3+1],clock_leds[i*3+2]);
|
|
}
|
|
}
|
|
|
|
/** @brief program entry point
|
|
* this is the firmware function started by the micro-controller
|
|
*/
|
|
int main(void)
|
|
{
|
|
SCB_VTOR = (uint32_t) 0x08002000; // relocate vector table because of the bootloader
|
|
|
|
rcc_clock_setup_in_hse_8mhz_out_72mhz(); // use 8 MHz high speed external clock to generate 72 MHz internal clock
|
|
usart_setup(); // setup USART (for printing)
|
|
cdcacm_setup(); // setup USB CDC ACM (for printing)
|
|
setbuf(stdout, NULL); // set standard out buffer to NULL to immediately print
|
|
setbuf(stderr, NULL); // set standard error buffer to NULL to immediately print
|
|
|
|
// setup LED
|
|
rcc_periph_clock_enable(LED_RCC); // enable clock for LED
|
|
gpio_set_mode(LED_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, LED_PIN); // set LED pin to 'output push-pull'
|
|
led_off(); // switch off LED to indicate setup started
|
|
|
|
// setup button
|
|
#if defined(BUTTON_RCC) && defined(BUTTON_PORT) && defined(BUTTON_PIN) && defined(BUTTON_EXTI) && defined(BUTTON_IRQ)
|
|
rcc_periph_clock_enable(BUTTON_RCC); // enable clock for button
|
|
gpio_set_mode(BUTTON_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BUTTON_PIN); // set button pin to input
|
|
rcc_periph_clock_enable(RCC_AFIO); // enable alternate function clock for external interrupt
|
|
exti_select_source(BUTTON_EXTI, BUTTON_PORT); // mask external interrupt of this pin only for this port
|
|
exti_set_trigger(BUTTON_EXTI, EXTI_TRIGGER_BOTH); // trigger on both edge
|
|
exti_enable_request(BUTTON_EXTI); // enable external interrupt
|
|
nvic_enable_irq(BUTTON_IRQ); // enable interrupt
|
|
#endif
|
|
|
|
// setup WS2812b LEDs
|
|
ws2812b_setup(); // setup WS2812b LEDs
|
|
clock_hours(); // show hour markers
|
|
clock_clear(); // clear all LEDs
|
|
leds_set(); // set the colors of all LEDs
|
|
ws2812b_transmit(); // transmit set color
|
|
|
|
// setup RTC module
|
|
rtc_setup(); // setup RTC module
|
|
|
|
printf("welcome to the CuVoodoo LED clock\n"); // print welcome message
|
|
led_on(); // switch on LED to indicate setup completed
|
|
|
|
uint32_t time = 0; // the time to display
|
|
uint32_t current_time = 6*ticks_hour+45*ticks_minute+15*ticks_second+ticks_second/4;
|
|
printf("setting current time\n");
|
|
while (time<current_time) {
|
|
if (time+ticks_hour<=current_time) { // first set hours
|
|
time += ticks_hour; // increment hours
|
|
} else if (time+ticks_minute<=current_time) { // second set minutes
|
|
time += ticks_minute; // increment minutes
|
|
} else if (time+ticks_minute<=current_time) { // third set seconds
|
|
time += ticks_second; // increment seconds
|
|
} else { // finally set time
|
|
time = current_time;
|
|
}
|
|
clock_show_time(time); // set time (progress)
|
|
leds_set(); // set the colors of all LEDs
|
|
ws2812b_transmit(); // transmit set color
|
|
// delay some time
|
|
for (uint32_t i=0; i<400000; i++) {
|
|
__asm__("nop");
|
|
}
|
|
}
|
|
printf("it is now %02lu:%02lu:%02lu\n", time/ticks_hour, (time%ticks_hour)/ticks_minute, (time%ticks_minute)/ticks_second);
|
|
|
|
// test RTC
|
|
uint16_t* rtc_time = rtc_read_time();
|
|
printf("RTC full time %04d-%02d-%02d %02d:%02d:%02d\n", rtc_time[6], rtc_time[5], rtc_time[4], rtc_time[2], rtc_time[1], rtc_time[0]);
|
|
printf("RTC oscillator: ");
|
|
if (rtc_oscillator_disabled()) {
|
|
printf("disbaled\n");
|
|
} else {
|
|
printf("enabled\n");
|
|
}
|
|
//rtc_write_time(0,52,9,4,23,3,2016);
|
|
//rtc_oscillator_enable();
|
|
|
|
printf("input commands\n");
|
|
bool action = false; // if an action has been performed don't go to sleep
|
|
button_flag = false; // reset button flag
|
|
char c; // to store received character
|
|
bool char_flag = false; // a new character has been received
|
|
/* toggle the LED with every transmitted character */
|
|
while (true) { // infinite loop
|
|
while (usart_received) { // echo every received character
|
|
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) { // echo every received character
|
|
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 (char_flag) {
|
|
char_flag = false; // reset flag
|
|
action = true; // action has been performed
|
|
printf("%c",c); // echo receive character
|
|
|
|
printf("%02lu:%02lu\n", time/ticks_hour, (time%ticks_hour)/ticks_minute);
|
|
clock_show_time(time); // set time
|
|
time += ticks_minute; // increment time
|
|
leds_set(); // set the colors of all LEDs
|
|
ws2812b_transmit(); // transmit set color
|
|
}
|
|
while (button_flag) {
|
|
button_flag = false; // reset flag
|
|
action = true; // action has been performed
|
|
led_toggle(); // toggle LED
|
|
}
|
|
// go to sleep if nothing had to be done, else recheck for activity
|
|
if (action) {
|
|
action = false;
|
|
} else {
|
|
__WFI(); // go to sleep
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(BUTTON_ISR) && defined(BUTTON_EXTI)
|
|
void BUTTON_ISR(void)
|
|
{
|
|
exti_reset_request(BUTTON_EXTI); // reset interrupt
|
|
button_flag = true; // perform button action
|
|
}
|
|
#endif
|