rgbyteclock-code/rgbyteclock_patterns.c

/*
 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * <struppi@struppi.name> wrote this file. As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer in return.
 * (c) 2014 Stefan Rupp
 * ----------------------------------------------------------------------------
 */


#include "timer.h"
#include "rtc.h"
#include "lcd.h"
#include "ledcontroller.h"


enum { LED_OFF, LED_GLOW, LED_S0, LED_S1, LED_S2, LED_S3, LED_S4, LED_S5};
uint16_t led_values[] =  {0x00, 0x00cf, 0x00, 0x04ff, 0x08ff, 0x10ff, 0x20ff};


void rgbyteclock_rounds(void)
{

  led_turn_all_on();

  while (1) {
	PORTC ^= (1<<PC5);
    for (int i=0; i<14; i++) {
      led_set(i, 0x1ff, 0x00, 0x00);
      led_flush();
      timer_wait(50);
    }

    for (int i=0; i<14; i++) {
      led_set(i, 0x00, 0x1ff, 0x00);
      led_flush();
      timer_wait(50);
    }
    //timer_wait(100);

    for (int i=0; i<14; i++) {
      led_set(i, 0x00, 0x00, 0x1ff);
      led_flush();
      timer_wait(20);
    }
    //timer_wait(100);

  }

}


void rgbyteclock_rounds_white(void)
{
  uint16_t brightness = 0x1fff;
  uint16_t brightness_last = 0x1fff;
  uint8_t direction_b = 1, direction_d = 1;
  uint8_t dir_count=0, dir_steps=0;
  uint8_t color_start = 0;
  uint8_t color;
  uint8_t delay = 200, delay_last = 200;
  led_turn_all_on();

  while (1) {
    color_start++;
    if (color_start > 2) { color_start = 0; }
    color = color_start;
    for (int led=0; led<12; led++) {
      color++;
      switch (color) {
      case 1:
		led_set(led, 0x00, brightness, 0x00);      
		break;
      case 2:
		led_set(led, 0x00, 0x00, brightness);
		break;
      default:
		color = 0;
		led_set(led, brightness, 0x00, 0x00);      
		break;
      }
    }
	led_flush();
	timer_wait(delay);
	
	#if 0
	if (direction_b) {
		brightness = brightness + brightness/16;
		if (brightness_last > brightness) {
		  brightness = 0xffff;
		  direction_b = 0;
		}
		brightness_last = brightness;
	}
	else {
		brightness = brightness - brightness/8;
		if (brightness < 0x00ff) {
		  brightness = 0x00ff;
		  direction_b = 1;
		}
		brightness_last = brightness;	
	}
	#endif

	if (dir_count++ > dir_steps) {
		if (direction_d) {
			delay *= 0.90;
			if (delay == delay_last) { delay--; }
			if (delay < 5) {
				direction_d = 0;
			}
		}
		else {
			delay *= 1.10;
			if (delay == delay_last) { delay++; }
			if (delay >= 200) {
				direction_d = 1;
			}
		}
		delay_last = delay;
		dir_count = 0;
		dir_steps = (200/delay)+1;
	}
  }
}



void rgbyteclock_rounds_colored(void)
{
  uint16_t brightness = 0x00ff;
  uint8_t color_start = 0;
  uint8_t color;

  led_turn_all_on();

  while (1) {
    color_start++;
    if (color_start > 2) { color_start = 0; }
    color = color_start;
    for (int led=0; led<12; led++) {
      color++;
      switch (color) {
      case 1:
	led_set(led, 0x00, brightness, 0x00);      
	break;
      case 2:
	led_set(led, 0x00, 0x00, brightness);
	break;
      default:
	color = 0;
	led_set(led, brightness, 0x00, 0x00);      
	break;
      }
      led_flush();
      timer_wait(5);
    }
    brightness = brightness + brightness/20;
    if (brightness > 0x4fff) {
      brightness = 0xff;
    }

  }
}


void rgbyteclock_hsv_fading(void)
{

  led_turn_all_on();

  while (1) {
	  for ( uint16_t color = 0; color < 360; color+= 1 ) {
		  for ( uint8_t lednum = 0; lednum < 12; lednum++ ) {
			  led_set_hsv( lednum, (color + lednum * 20) % 360, 100, 100);
		  }
		  led_flush();
		  timer_wait(5);
	  }
  }
  
}

void rgbyteclock_secwatch(void)
{
  uint8_t hours, mins;

  uint32_t t, t_last=0;

  led_turn_all_on();

  while (1) {
    t = timer_get()/1000;
    if (t != t_last) {
      t_last = t;
      mins = t%60;
      hours = t/60;
      uint8_t l_mins = mins/5;
      uint8_t l_hours = hours/5;
      led_clear();
      if (l_mins != l_hours) {
	led_set(l_mins, 0, 0x7ff, 0);
	led_set(l_hours, 0, 0, 0x7ff);
      }
      else {
	led_set(l_mins, 0, 0x7ff, 0x7ff);
      }
      led_flush();
    }
  }
}

void rgbyteclock_secwatch_glide(void)
{
  uint8_t hours, mins;

  uint32_t t, t_last=0;

  led_turn_all_on();

  while (1) {
    t = rtc_get();
    if (t != t_last) {
      t_last = t;
      mins = t%60;
      hours = t/60;
      uint8_t l_mins = mins/5;
      uint8_t l_hours = hours/5;
      uint8_t l_mins_next = l_mins+1;
      uint8_t l_hours_next = l_hours+1;
      
      if (l_mins_next > 11) { l_mins_next = 0; }
      if (l_hours_next > 11) { l_hours_next = 0; }
      
      uint16_t d_m1, d_m2;
      uint16_t d_h1, d_h2;

      /*
      d_m2 = ((mins%5)*d_bright)/4;
      d_h2 = ((hours%5)*d_bright)/4;
      d_m1 = ((4-(mins%5))*d_bright)/4;
      d_h1 = ((4-(hours%5))*d_bright)/4;
      */
      d_m2 = led_values[(mins%5)+2];
      d_h2 = led_values[(hours%5)+2];
      d_m1 = led_values[4-(mins%5)+2];
      d_h1 = led_values[4-(hours%5)+2];
      uint16_t d_dark = led_values[1];

      led_clear();
      for (int led=0;led<12;led++) {
	led_set(led, d_dark, 0, 0);
      }
      if (l_mins != l_hours) {
	led_set(l_mins, d_dark, d_m1, 0);
	led_set(l_hours, d_dark, 0, d_h1);
	led_set(l_mins_next, d_dark, d_m2, 0);
	led_set(l_hours_next, d_dark, 0, d_h2);
      }
      else {
	led_set(l_mins, 0xf, d_m1, d_h1);
	led_set(l_mins_next, 0xf, d_m2, d_h2);
      }
      led_flush();
    }
  }
}