Controlling RGB via Blynk

Issues and Errors
1

Hello,

I am working on a project to control a RGB led strip via the blynk app.
Unfortunately, my code isn’t working. I have searched my mistake but I couldn’t find it.
Could anybody help me?

Thanks in advance!
Tom

#include <SimpleTimer.h>
#define BLYNK_PRINT Serial // Comment this out to disable prints and save space

// These are the interrupt and control pins for СС3000
#define ADAFRUIT_CC3000_IRQ 3
#define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10

#include <SPI.h>
#include <Adafruit_CC3000.h>
#include <BlynkSimpleCC3000.h>

char auth[] = “XXX”;

// Your WiFi credentials.
// Choose wifi_sec from WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or WLAN_SEC_WPA2
char ssid[] = “XXX”;
char pass[] = “XXX”;
int wifi_sec = WLAN_SEC_WPA2;

// Output

int redPin = 6; // Red LED, connected to digital pin 9
int grnPin = 9; // Green LED, connected to digital pin 10
int bluPin = 11; // Blue LED, connected to digital pin 11

int BlynkBlue;
int BlynkRed;
int BlynkGreen;
// Color arrays
int black[3] = { 0, 0, 0 };
int white[3] = { 100, 100, 100 };
int red[3] = { 100, 0, 0 };
int green[3] = { 0, 100, 0 };
int blue[3] = { 0, 0, 100 };
int yellow[3] = { 40, 95, 0 };
int dimWhite[3] = { 30, 30, 30 };
// etc.

// Set initial color
int redVal = black[0];
int grnVal = black[1];
int bluVal = black[2];

int wait = 10; // 10ms internal crossFade delay; increase for slower fades
int hold = 20; // Optional hold when a color is complete, before the next crossFade
int DEBUG = 0; // DEBUG counter; if set to 1, will write values back via serial
int loopCount = 60; // How often should DEBUG report?
int repeat = 0; // How many times should we loop before stopping? (0 for no stop)
int j = 0; // Loop counter for repeat
int mode = 0;
// Initialize color variables
int prevR = redVal;
int prevG = grnVal;
int prevB = bluVal;

void setup()
{
Blynk.begin(auth, ssid, pass, wifi_sec);

pinMode(redPin, OUTPUT); // sets the pins as output
pinMode(grnPin, OUTPUT);
pinMode(bluPin, OUTPUT);

if (DEBUG) { // If we want to see values for debugging…
Serial.begin(9600); // …set up the serial ouput
}
delay(100);
}

// Set up the LED outputs
BLYNK_WRITE(V1)
{
mode= param.asInt();

}
BLYNK_WRITE(V6)
{
BlynkRed= param.asInt();
}

BLYNK_WRITE(V7)
{
BlynkGreen = param.asInt();
}
BLYNK_WRITE(V8)
{
BlynkBlue = param.asInt();
}

/* BELOW THIS LINE IS THE MATH – YOU SHOULDN’T NEED TO CHANGE THIS FOR THE BASICS
*

  • The program works like this:
  • Imagine a crossfade that moves the red LED from 0-10,
  • the green from 0-5, and the blue from 10 to 7, in
  • ten steps.
  • We’d want to count the 10 steps and increase or
  • decrease color values in evenly stepped increments.
  • Imagine a + indicates raising a value by 1, and a -
  • equals lowering it. Our 10 step fade would look like:
  • 1 2 3 4 5 6 7 8 9 10
  • R + + + + + + + + + +
  • G + + + + +
  • B - - -
  • The red rises from 0 to 10 in ten steps, the green from
  • 0-5 in 5 steps, and the blue falls from 10 to 7 in three steps.
  • In the real program, the color percentages are converted to
  • 0-255 values, and there are 1020 steps (255*4).
  • To figure out how big a step there should be between one up- or
  • down-tick of one of the LED values, we call calculateStep(),
  • which calculates the absolute gap between the start and end values,
  • and then divides that gap by 1020 to determine the size of the step
  • between adjustments in the value.
    */

int calculateStep(int prevValue, int endValue) {
int step = endValue - prevValue; // What’s the overall gap?
if (step) { // If its non-zero,
step = 1020/step; // divide by 1020
}
return step;
}

/* The next function is calculateVal. When the loop value, i,

  • reaches the step size appropriate for one of the
  • colors, it increases or decreases the value of that color by 1.
  • (R, G, and B are each calculated separately.)
    */

int calculateVal(int step, int val, int i) {

if ((step) && i % step == 0) { // If step is non-zero and its time to change a value,
if (step > 0) { // increment the value if step is positive…
val += 1;
}
else if (step < 0) { // …or decrement it if step is negative
val -= 1;
}
}
// Defensive driving: make sure val stays in the range 0-255
if (val > 255) {
val = 255;
}
else if (val < 0) {
val = 0;
}
return val;
}

/* crossFade() converts the percentage colors to a

  • 0-255 range, then loops 1020 times, checking to see if
  • the value needs to be updated each time, then writing
  • the color values to the correct pins.
    */

void crossFade(int color[3]) {
// Convert to 0-255
int R = (color[0] * 255) / 100;
int G = (color[1] * 255) / 100;
int B = (color[2] * 255) / 100;

int stepR = calculateStep(prevR, R);
int stepG = calculateStep(prevG, G);
int stepB = calculateStep(prevB, B);

for (int i = 0; i <= 1020; i++) {
redVal = calculateVal(stepR, redVal, i);
grnVal = calculateVal(stepG, grnVal, i);
bluVal = calculateVal(stepB, bluVal, i);

analogWrite(redPin, redVal);   // Write current values to LED pins
analogWrite(grnPin, grnVal);      
analogWrite(bluPin, bluVal); 

delay(wait); // Pause for 'wait' milliseconds before resuming the loop

if (DEBUG) { // If we want serial output, print it at the 
  if (i == 0 or i % loopCount == 0) { // beginning, and every loopCount times
    Serial.print("Loop/RGB: #");
    Serial.print(i);
    Serial.print(" | ");
    Serial.print(redVal);
    Serial.print(" / ");
    Serial.print(grnVal);
    Serial.print(" / ");  
    Serial.println(bluVal); 
  } 
  DEBUG += 1;
}

}
// Update current values for next loop
prevR = redVal;
prevG = grnVal;
prevB = bluVal;
delay(hold); // Pause for optional ‘wait’ milliseconds before resuming the loop
}

// Main program: list the order of crossfades
void loop()
{
Blynk.run();

if(mode == 0)
{

crossFade(red);
crossFade(green);
crossFade(blue);
crossFade(yellow);
crossFade(dimWhite);

}
else
{
analogWrite(redPin, BlynkRed); // Write current values to LED pins
analogWrite(grnPin, BlynkGreen);
analogWrite(bluPin, BlynkBlue);
}
}