Particle LED Remote

led-remote.ino

/* ================================================================= 
 * LED Remote
 * (c)  Brooke. 2016-2020
 
 * This file is the firmware to be upload and ran on the photon. It makes use of the particle API. 
 * All original code is under the GPL v3 except where listed. 

 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

================================================================= */

/* ======================= Includes ================================= */
#include <neopixel.h>
// #include "neopixel.h" // use for local build

/* ======================= Constances====================== */

SYSTEM_MODE(AUTOMATIC);

#define PIXEL_PIN 6
#define PIXEL_COUNT 120
#define PIXEL_TYPE SK6812RGBW
#define BRIGHTNESS 255 

uint8_t setStripBrigtness( String brightnessValue) ;
int setStripColor( String hexValue );
int currentBrightness = 0;
String currentHex = "";
uint8_t setStripPower( String powerValue );
int currentPower = 2;
int loopCase = 0;

Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);


/** 
 * setup -- Standard Arduino setup() function 
 **/
void setup (){
  
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  
  //Particle Functions for Color and Brightness
  Particle.function("hex", setStripColor);
  Particle.function("bri", setStripBrigtness);
  Particle.function("pwr", setStripPower);

    
  //Particle Variable to hold brightness value. Should return between 0 - 255
  Particle.variable("curBri", currentBrightness);
    
  //Particle Variable to hold color value. Should return hex or -1 for false
  Particle.variable("curHex", currentHex);
  
  //Particle Variable to hold power value. Should always return 1 or 2. 
  Particle.variable("curPwr", currentPower);
  
}
  
/** 
  * loop -- Standard Arduino loop() function 
  **/
void loop (){
    switch ( loopCase ) {
    case 1:
        setHex(currentHex);
      break;
    case 2:
        rainbowCycle(20);
    break;
    case 3:
        rainbow(20);
  }
    delay(20);
}
  
/** 
 * getStripColor -- gets the HexValue input from our POST request
 * @param hexValue -- gets hex value string from Particle API 
 */
int setStripColor( String hexValue ) {
       if(hexValue.length() == 8) {
           currentHex = hexValue;
           loopCase = 1;
            return 1;
        }
        else if( hexValue == "rainbow" ) {
            loopCase = 2;
            return 2;
        }
        else if ( hexValue == "rainbowCycle" ) {
            loopCase = 3;
            return 3;
        }
        else {
            return -1;
        }
} 
 
/** 
 * setStripBrightness -- Sets the LED strip color based on input of particle function setStripBrigtness
 * @param brightnessValue -- 0-255 brightness value for our LED strip.
 */
uint8_t setStripBrigtness( String brightnessValue ) {
   
   uint8_t brightnessAsInt = brightnessValue.toInt();
   
    if( ( brightnessAsInt <= 255 ) && ( brightnessValue.length() <= 3 ) ) {
        for (uint8_t i = 0; i < PIXEL_COUNT; i = i + currentPower ) {
                strip.setBrightness( brightnessAsInt );
        }
        strip.show();
        currentBrightness = brightnessAsInt;
        return currentBrightness;
    }
    else {
        return 0;
    }
}

/** 
 * setStripPower -- Sets the strip power 
 * @param powerValue -- Send 1 for all lights and send 0 for just half. 
 */
uint8_t setStripPower( String powerValue ) {
   
    if( powerValue.toInt() == 1 ){
        currentPower = 1;
        return 1;
    }
    else {
        currentPower = 2;
        return 0;
    }
}

/** 
 * convertHex -- converts hexValue into byte to be used in our array RBG > 255
 * see: https://arduino.stackexchange.com/a/16446
 * @param char -- gets hex value string from Particle API 
 */
byte convertHex (const char * str){
  char c = str [0] - '0';
  if (c > 9)
    c -= 7;
  int result = c;
  c = str [1] - '0';
  if (c > 9)
    c -= 7;
  return (result << 4) | c;
}  

/** 
 * setHex -- converts hexValue into byte to be used in our array RBG > 255
 * @param hexValue  HexValue to set strip to.  
 */
 char setHex( String hexValue ) {
    const char * hexCharArray = hexValue;
    
    byte redValue = convertHex ( & hexCharArray[0] );
    byte greenValue = convertHex ( & hexCharArray[2] );
    byte blueValue = convertHex ( & hexCharArray[4] );
    byte whiteValue = convertHex ( & hexCharArray[6] );
    
    if( currentPower == 2 ){
            for (int i = 1; i < PIXEL_COUNT; i++ ){
                strip.setPixelColor(i, 0, 0, 0, 0);
        }

    }
    for (int i = 0; i < PIXEL_COUNT; i = i + currentPower ){
        strip.setPixelColor(i, greenValue, redValue, blueValue, whiteValue);
    }
    strip.show();
}

/** 
 * rainbowCycle -- Cycles through colors
 * @source: https://github.com/adafruit/Adafruit_NeoPixel
 * @param wait -- mills between transition, higher is slower. Vaules 0-255 
 */
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) { // 5 cycles of all colors on wheel
    if( currentPower == 2 ){
        for (int i = 1; i < PIXEL_COUNT; i++ ){
            strip.setPixelColor(i, 0, 0, 0, 0);
        }
    }
    for(i=0; i< strip.numPixels(); i = i + currentPower) {
      strip.setPixelColor(i, Wheel(((i * 256 / PIXEL_COUNT ) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

/** 
 * rainbow -- Cycles through colors
 * @source: https://github.com/adafruit/Adafruit_NeoPixel
 * @param wait -- mills between transition, higher is slower. Vaules 0-255
 */
void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    if( currentPower == 2 ){
        for (int i = 1; i < PIXEL_COUNT; i++ ){
            strip.setPixelColor(i, 0, 0, 0, 0);
        }
    }
    for(i=0; i<strip.numPixels(); i = i + currentPower ) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

/** 
 * Wheel 
 * Input a value 0 to 255 to get a color value.
 * The colours are a transition r - g - b - back to r.
 * @source: https://github.com/adafruit/Adafruit_NeoPixel
 * @param byte WheelPos
 */
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3,0);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3,0);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0,0);
}

uint8_t red(uint32_t c) {
  return (c >> 8);
}

uint8_t green(uint32_t c) {
  return (c >> 16);
}

uint8_t blue(uint32_t c) {
  return (c);
}