Team RainBROs:

•

•

•

•

•

•

•

Published April 23, 2020 © GPL3+

Simar Over the RAYnbow

Create a comforting beacon of hope in this trying time. Cause an RGB LED to cycle through all hues.

BeginnerWork in progress30 minutes417

Things used in this project

Hardware components

Texas Instruments EK-TM4C123GXL TM4C Tiva LaunchPad

Male/Male Jumper Wires

Tilt Switch, SPST

Breadboard (generic)

Software apps and online services

Texas Instruments Energia

Story

A Raynbow to Light the World

ELEVATOR PITCH:

Sad? Quarantine got you feeling down? Buy our product, it will help.

Granny’s pension running out of high-return investments? Deflationary environment got you down? Invest in Simar Over the RAYnbow's premier product: “I Love Hue”.

STORY:

Life is hard. We get that. But why is life hard? We all have problems, and we can’t really help with that. But we can create an arbitrary LED project that you can look at and say, “Hey, that’s good” before you remember your problems. And those fleeting moments of “Hey, that’s good” are what matters most to us during this time.

A still image of "I Love Hue" in action!

Enter the “I Love Hue” LED system. Glistening, vibrant, and full of RGB goodness, once the LED system starts, it won’t stop until your mood is as bright as RGB(255, 255, 255) (or you unplug it, whichever comes first). Personally, this LED system has changed my life. It’s heartwarming to be able to take a break from frantically poring over my homework and exams to see some incredibly bright lights that actually might be damaging my eyes, but at least look pretty. Thankfully we have implemented an emergency stop feature using a tilt switch that will stop the lights from changing colors if the tilt switch is activated.

An example of using the tilt switch.

TESTIMONIALS

“‘Once I was doing my homework and needed light therapy from the arbitrary LED project. However, it wasn’t until after turning it on that I remembered that this product is not licensed by any regulatory body whatsoever. I immediately collapsed onto the floor in a flashback from a prior incident with bright lights relating to an alien abduction, but fortunately the emergency tilt switch saved my life. Now I am in desperate need of therapy, which I cannot afford and which my medical insurance refuses to cover, but I got to see some really pretty lights. I am in great thanks to the thoughtful developers that added the tilt switch. Thanks, “I Love Hue” LEDs!’ - Noah Rossi” - Grant Parajuli

“You miss 100% of the shots you don’t take.” -Wayne Gretzky -Michael Scott

“You might think the code is hard to read, but that’s just because C is a garbage language.” -Ian Ramsey

Code

int brightness_g = 0;    //green LED initial brightness
int brightness_r = 0;    //red LED initial brightness
int brightness_b = 0;    //blue LED initial brightness

//array defining each color's gradient palatte
int gradient[8][3] = 
{{255, 0, 0}, //red
{171, 85, 0}, //orange
{171, 171, 0}, //yellow
{0, 255, 0}, //green
{0, 171, 85}, //aqua
{0, 0, 255}, //blue
{85, 0, 171}, //purple
{171, 0, 85}}; //pink

//helper function to fade to specific red, green, blue target brightnesses
void fade(int r_target, int g_target, int b_target)
{
  //set step values to reach target brightness from current brightness after 10 steps
  int step_g = (g_target - brightness_g)/10;
  int step_r = (r_target - brightness_r)/10;
  int step_b = (b_target - brightness_b)/10;

  for (int i = 0; i < 10; i++)
  {
    //halt fading if tilt switch is off
    while(!digitalRead(10)){}

    //increment each color brignteness by previously calculated step value
    brightness_g += step_g;
    brightness_r += step_r;
    brightness_b += step_b;

    //write new values to each LED
    analogWrite(GREEN_LED, brightness_g);
    analogWrite(RED_LED, brightness_r);
    analogWrite(BLUE_LED, brightness_b);

    delay(30);
  }
}

void setup()  { 
  // declare all RGB leds to be outputs:
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
  
  // declare pin 10 connected to tilt switch to be input
  pinMode(10, INPUT);
} 

void loop() 
{    
  // loop through each defined color in the predefined array and fade to each one in order
  for (int i = 0; i < 9; i ++)
  {
    fade(gradient[i][0], gradient[i][1], gradient[i][2]);
  }
}

#define COLOR_CHANNELS 3//number of channels per color
#define LEN_COLOR_VAL 8//number of bits per color channel
#define TILT_PIN 10//pin the tilt switch is on

#define NUM_COLORS 8//number of colors to cycle through

int speed = 100;
int timestep = 256/speed;

//define all the colors. Remember to make the lengths match!
uint8_t colors[NUM_COLORS][COLOR_CHANNELS] = {
  {255,   0,   0},
  {171,  85,   0},
  {171, 171,   0},
  {  0, 255,   0},
  {  0, 171,  85},
  {  0,   0, 255},
  { 85,   0, 171},
  {171,   0,  85}
};

//allocate memory for the active color
uint8_t* pActiveColor = (uint8_t*) malloc(COLOR_CHANNELS*LEN_COLOR_VAL/8);

/**
 * Linearly interpolate two values
 * Inputs:
 *  start- beginning value
 *  ends - ending value
 *  pos - position to evaluate interpolation
 * Returns an int between start and ends
 */
int lerp(int start, int ends, double pos){
  double s = (double) start;
  double e = (double) ends;
  return (int) (e-s)*pos+s;//travel pos along the line from e to s, add s to it.
}

/**
 * Interpolate an RGB color at a position
 * Inputs:
 *  pStart - pointer to first element of color start array
 *  pEnd - pointer to first element of color end array
 *  pTarget - pointer to first element of target array
 *  pos - position along interpolation to evaluate
 * Sets the values at pTarget to be equal to the interpolation of pos length from pStart to pEnd
 */
void interpolateColor(uint8_t* pStart, uint8_t* pEnd, uint8_t* pTarget, double pos){
  int i;
  for(i = 0; i < COLOR_CHANNELS; i++){
    int offset = i*LEN_COLOR_VAL;
    int startValue = *(pStart + offset);
    int endValue = *(pEnd + offset);
    *(pTarget+offset) = (uint8_t) (lerp(startValue, endValue, pos));
  }
}

void setup(){
  Serial.begin(9600);
  //Set up pins
  pinMode(GREEN_LED, OUTPUT);
  pinMode(RED_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
  pinMode(TILT_PIN, INPUT);
}


void loop() {
  // put your main code here, to run repeatedly: 
  int i;//index of color
  int j;//index of transition
  for (i = 0; i<NUM_COLORS; i++){
    //color we are transitioning from
    uint8_t* pStartColor = &colors[i][0];
    uint8_t* pEndColor;

    //figure out which color we will be transitioning to
    if (i != NUM_COLORS - 1){
      pEndColor = &colors[i+1][0];
    }
    else{
      pEndColor = &colors[0][0];//prevent overflow
    }
    
    for(j=0; j<256; j++){

      //stop while the tilt is active
      while (digitalRead(TILT_PIN) == HIGH);
      

      
      double pos = ((float) j)/256.0;
      interpolateColor(pStartColor, pEndColor, pActiveColor, pos);
      int red = *pActiveColor;
      int green = *(pActiveColor + LEN_COLOR_VAL);
      int blue = *(pActiveColor + 2*LEN_COLOR_VAL);
      //Debug prints
      /*Serial.print("Red: ");
      Serial.print(red);
      Serial.print(", Green: ");
      Serial.print(green);
      Serial.print(", Blue: ");
      Serial.println(blue);*/
      analogWrite(RED_LED, red);
      analogWrite(GREEN_LED, green);
      analogWrite(BLUE_LED, blue);
      delay(timestep);
    }
  }
}

Credits

Comments

Please log in or sign up to comment.

Simar Over the RAYnbow