#include #include "nRF24L01.h" #include "RF24.h" #include "printf.h" #include "FastLED.h" #include "FastLED_RGBW.h" // #define NUM_LEDS1 150 // #define NUM_LEDS2 150 // #define NUM_LEDS3 300 // tira virtual que no se pinta #define DATA_PIN_1 8 #define DATA_PIN_2 3 #define SDO1 8 #define SDO2 4 #define SDO3 3 //#define DATA_PIN_3 4 // tira virtual que no se pinta, en este pin fastled no funciona #define NUM_STRIPS 2 #define NUM_LEDS_PER_STRIP 150 #define NUM_LEDS NUM_LEDS_PER_STRIP * NUM_STRIPS CRGBW leds[NUM_STRIPS * NUM_LEDS_PER_STRIP]; CRGB *ledsRGB = (CRGB *) &leds[0]; const uint8_t brightness = 255; #define RADIOSEND false #define CE_PIN 12 #define CSN_PIN 2 #define DEBUG 0 #define TEST 0 #define RED 11 #define GREEN 10 #define BLUE 9 #define WHITE 6 int idpin[4] = { A3, A4, 13, 5}; // A partir de 1 SLAVES int chpin[4] = { A5, A0, A1, A2 }; // no se va a usar en esta App int neopix_gamma[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68, 69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 109, 110, 112, 114, 115, 117, 119, 120, 122, 124, 126, 127, 129, 131, 133, 135, 137, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 167, 169, 171, 173, 175, 177, 180, 182, 184, 186, 189, 191, 193, 196, 198, 200, 203, 205, 208, 210, 213, 215, 218, 220, 223, 225, 228, 231, 233, 236, 239, 241, 244, 247, 249, 252, 255 }; RF24 radio(CE_PIN, CSN_PIN); // Create a Radio const uint64_t pipe = 0xE8E8F0F0E1LL; // Define the transmit pipe uint8_t CMD[ 8 ]; // CMD + Ch + 2 int ch = 76; // Fuerzo a canal 76 (showroom) unsigned long delayed = 0; // control de tiempo de funciones de pixel int countFrame = 0; unsigned long launchTime = 0; short stroboFlag = 0; short pixelFlag = 0; short stroboPixelOn = 0; unsigned long delayedNeon = 0; // control de tiempo de funciones de neon unsigned long launchTimeNeon = 0; int countFrameNeon = 0; short stroboFlagNeon = 0; short neonFlag = 0; short stroboNeonOn = 0; uint8_t param1 = 20; // parametros del OSC globales uint8_t param2 = 140; uint8_t mode = 0; // Modo OFF/TEST por defecto uint8_t selectedEffect = 0; uint16_t i = 0; int c = 0; int numSer = 0; char numStr[4]; void resetBoard() { Serial.println("reset"); //asm volatile (" jmp 0"); // esto no funciona en SAMD } byte id() { int id = 0; for (byte i = 0; i < 4; i++ ) bitWrite(id, i, digitalRead(idpin[i])); return id; } int channel() { int value = code(); switch (value) { case 0: value = 0x4C; // showroom break; case 1: value = 0x64; // developers break; default: value = 0x64; // developers break; } return value; } int code() { int value = 0; for (byte i = 0; i < 4; i++) bitWrite(value, i, digitalRead(chpin[i])); return value; } ////////////////////////////////////////////////////////////////// ///////////////////////// SETUP //////////////////////////////// ////////////////////////////////////////////////////////////////// void setup() { FastLED.addLeds(ledsRGB, 0, getRGBWsize(NUM_LEDS)/2); FastLED.addLeds(ledsRGB, getRGBWsize(NUM_LEDS)/2, getRGBWsize(NUM_LEDS)/2); // la segunda se mapea a partir de un offset! Brutal! FastLED.setMaxRefreshRate(60); pinMode(RED, OUTPUT); digitalWrite(RED, LOW); pinMode(GREEN, OUTPUT); digitalWrite(GREEN, LOW); pinMode(BLUE, OUTPUT); digitalWrite(BLUE, LOW); pinMode(WHITE, OUTPUT); digitalWrite(WHITE, LOW); for (int i = 0; i < 4; i++) { pinMode(idpin[i], INPUT); pinMode(chpin[i], INPUT); } analogWrite(WHITE, 255); analogWrite(RED, 255); analogWrite(GREEN, 255); analogWrite(BLUE, 255); Serial.begin(512000); //while (!Serial) { // ; // wait for serial port to connect. Needed for Leonardo only //} analogWrite(WHITE, 0); analogWrite(RED, 0); analogWrite(GREEN, 0); analogWrite(BLUE, 0); //printf_begin(); radio.begin(); radio.setDataRate( RF24_250KBPS ); radio.setPALevel( RF24_PA_MAX ); radio.setAutoAck(0); radio.setPayloadSize(8); radio.setChannel(ch); #if RADIOSEND radio.openWritingPipe(pipe); #else radio.openReadingPipe(1, pipe); radio.startListening(); #endif radio.printDetails(); } ////////////////////////////////////////////////////////////////// ///////////////////////// LOOP //////////////////////////////// ////////////////////////////////////////////////////////////////// void loop() { ///////////////////////// RADIO ENCUESTA //////////////////////// if ( radio.available() ) { while (radio.available()) { //done = radio.read( CMD, sizeof(CMD) ); radio.read( CMD, sizeof(CMD) ); if (DEBUG) { //Serial.println("Got command"); for (int i = 0 ; i < 4 ; i++) { Serial.print(CMD[i]); Serial.print(","); } Serial.println(); } // AÑADIR COMANDO GENERAL DE BRILLO EN TIEMPO REAL (Value) // si se quiere que funcione durante animacion implica meterlo en las funciones // AÑADIR COMANDO GENERAL DE BLANCO (Saturacion) // Control de color por HUE como parametro, asignar 127 al blanco (aunque en teoria es cualquier con saturacion = 0) if ( ( CMD[0] == 201 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 1 - RESPONDE A CANAL Y A BROADCAST { selectedEffect = 1; // modo 1 = FADEIN param1 = CMD[2]; param2 = CMD[3]; pixelFlag = 0; } else if ( ( CMD[0] == 202 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 2 { selectedEffect = 2; // modo 2 = punto param1 = CMD[2]; param2 = CMD[3]; neonFlag = 0; } else if ( ( CMD[0] == 203 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 3 { mode = 3; // modo 2 = punto param1 = CMD[2]; param2 = CMD[3]; pixelFlag = 0; neonFlag = 0; } else if ( ( CMD[0] == 204 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 4 { mode = 4; // modo 2 = punto param1 = CMD[2]; param2 = CMD[3]; } else if ( ( CMD[0] == 205 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 5 { mode = 5; // modo 2 = punto param1 = CMD[2]; param2 = CMD[3]; } else if ( ( CMD[0] == 206 ) && ( CMD[1] == id() ) ) // CMD { if (DEBUG) { Serial.print("NADA:"); } mode = 6; // modo 2 = punto param1 = CMD[2]; param2 = CMD[3]; } } } ///////////////////////// SERIE ENCUESTA //////////////////////// if (Serial.available()) { c = Serial.read(); if ( (c != 13) && (c != 10) ) { numStr[numSer] = c; numSer++; //Serial.println(numSer); } if ( c == 13 ) // first 13, then 10 { numStr[numSer] = '\0'; //Serial.println("retorno de carro"); //Serial.println(numStr); selectedEffect = atol(numStr); Serial.println(selectedEffect); numSer = 0; pixelFlag = 0; neonFlag = 0; } } ///////////////////////// SELECCION DE LOS EFECTOS //////////////////////// switch (selectedEffect) { case 0 : { // OFF - no parameters setAll(0, 0, 0, 0); colorNeon(0, 0, 0, 0); showStrip(); break; } ///////////////////// FADES //////////////////////// // APLICAR CORRECCION DE GAMMA!!!!!!!! // TRABAJAR CON HSV // AÑADIR FADES DE COLOR, NO SOLO FADE IN Y FADE OUT case 1 : { // ONLY STRIP FADE // Strip FADE Color (red, green, blue, white, mode in/out, fadetime, frametime) fadePixel(255, 255, 0, 0, 0, 10000, 16); // fadein break; } case 2 : { // ONLY NEON FADE // NEON Color (red, green, blue, white, mode in/out, fadetime, frametime, STRIP sync) fadeNeon(255, 0, 0, 0, 0, 2000, 33, 0); break; } case 3 : { // STRIP FADE + NEON SYNC // Strip FADE Color (red, green, blue, white, mode in/out, fadetime, frametime) // NEON Color (red, green, blue, white, mode in/out, fadetime, frametime, STRIP sync) fadePixel(0, 0, 0, 255, 1, 3000, 33); // fadeout fadeNeon(255, 120, 40, 40, 1, 3000, 33, 1); // calibracion de Natural White break; } case 4 : { // STRIP FADE COLOR // Strip FADE Color (hue, fadetime, frametime) // NEON Color (red, green, blue, white, mode in/out, fadetime, frametime, STRIP sync) fadePixelColor(80, 5000, 33); // FADECOLOR break; } ///////////////////// STROBOS //////////////////////// case 5 : { // Strobe - (time, PWM, numFlashes) stroboNeon(0, 0, 0, 255, 500, 15, 3); break; } case 6 : { // Strobe SYNC- (r, g, b, w, time, PWM, numFlashes, NEON sync) stroboPixel(255, 0, 255, 0, 50, 15, 10, 1); break; } ///////////////////// RANDOMS //////////////////////// // random tiempo // random color (rueda de HUE) // control de duracion flash // control de densidad de random //////////////////////////////////////////////////////// case 7 : { fadePixelColor(0, 5000, 33); // FADECOLOR break; } case 8 : { fadePixelColor(150, 5000, 33); // FADECOLOR break; } ///////////////////// BARRIDOS //////////////////////// case 9 : { // PIXELBAR - ( r, g, b, w, pixelInit, pixelEnd, loopTime, frameTime ) //pixelBar(255, 0, 0, 0, 100, 200, 16, 16); // pintado inmediato con 1 unico frame //pixelBar(0, 0, 0, 255, 0, 300, 5000, 16); // rampa de SUBIDA de 5s pixelBar(0, 0, 0, 255, 300, 0, 5000, 16); // rampa de BAJADA de 5s break; } case 10 : { // SCANNER - (r, g, b, w, pixelInit, pixelEnd, pixelWidth, loopTime, frameTime ) //scanner(0, 0, 0, 255, 0, 300, 4, 1000, 16); // rampa de SUBIDA de 1s scanner(0, 0, 0, 255, 0, 300, 8, 500, 16); // rampa de BAJADA de 1s break; } case 11 : { // CENTER TO OUT - (r, g, b, w, pixelInit, pixelWidth, loopTime, frameTime ) // centerOut(0, 0, 0, 255, 8, 10, 50); break; } case 12 : { // OUT TO CENTER - (r, g, b, w, mode, pixelInit, pixelWidth, loopTime, frameTime ) // mode para hacerlo solido o barrido // outCenter(0, 0, 0, 255, 8, 10, 50); break; } ///////////////////// EFECTOS //////////////////////// case 13 : { // Fire - Cooling rate, Sparking rate, speed delay fire(55, 120, 16); break; } case 55 : { // NewKITT - Color (red, green, blue), eye size, speed delay, end pause //NewKITT(0xff, 0x00, 0x00, 0x00, 8, 10, 50); break; } case 65 : { // Twinkle - Color (red, green, blue), count, speed delay, only one twinkle (true/false) //Twinkle(0xff, 0x00, 0x00, 0x00, 10, 100, false); break; } case 75 : { // TwinkleRandom - twinkle count, speed delay, only one (true/false) //TwinkleRandom(20, 100, false); break; } case 83 : { // Sparkle - Color (red, green, blue), speed delay //Sparkle(0xff, 0xff, 0xff, 0, 0); break; } case 93 : { // SnowSparkle - Color (red, green, blue), sparkle delay, speed delay //SnowSparkle(0x10, 0x10, 0x10, 0, 20, random(100, 1000)); break; } case 103 : { // Running Lights - Color (red, green, blue), wave dealy //RunningLights(0xff, 0x00, 0x00, 0, 50); // red //RunningLights(0xff, 0xff, 0xff, 0, 50); // white //RunningLights(0x00, 0x00, 0xff, 0, 50); // blue break; } case 113 : { // colorWipe - Color (red, green, blue), speed delay //colorWipe(0x00, 0xff, 0x00, 0, 50); //colorWipe(0x00, 0x00, 0x00, 0, 50); break; } case 123 : { // rainbowCycle - speed delay //rainbowCycle(20); break; } case 133 : { // theatherChase - Color (red, green, blue), speed delay //theaterChase(0xff, 0, 0, 0, 50); break; } case 143 : { // theaterChaseRainbow - Speed delay //theaterChaseRainbow(50); break; } case 153 : { // Fire - Cooling rate, Sparking rate, speed delay //fire(55, 120, 15); break; } case 183 : { // meteorRain - Color (red, green, blue), meteor size, trail decay, random trail decay (true/false), speed delay //meteorRain(0xff, 0xff, 0xff, 10, 64, true, 30); break; } } } ////////////////////////////////////////////////////////////////// /////////////////////// NEON FUNCIONS /////////////////// ////////////////////////////////////////////////////////////////// void colorNeon(byte red, byte green, byte blue, byte white) { analogWrite(RED, red); analogWrite(GREEN, green); analogWrite(BLUE, blue); analogWrite(WHITE, white); } void fadeNeon(byte red, byte green, byte blue, byte white, int mode, int fadeTime, int frameTime, int syncPixel) // mode 0 = fadeIn, mode 1 = fadeOut { EVERY_N_MILLISECONDS(frameTime) { //if ( millis() > delayedNeon ) //{ // if (syncPixel) // es necesario para sincronizar cuando va al mismo tiempo del pixel que es bloqueante // delayedNeon = millis() + frameTime - 11 ; // compensacion de bloqueo de millis // else //delayedNeon = millis() + frameTime ; // compensacion de bloqueo de millis float r, g, b, w; float totalFrames = fadeTime / frameTime; if (!neonFlag) { launchTimeNeon = millis(); if (!mode) Serial.println("---NEON FADEIN---"); else Serial.println("---NEON FADEOUT---"); Serial.print("fadeTime: "); Serial.println(fadeTime); Serial.print("LaunchTime: "); Serial.println(launchTime); Serial.print("totalFrames: "); Serial.println(totalFrames); countFrameNeon = 0; // RESET DE VARIABLES ANTES DE ARRANCAR neonFlag = true; } Serial.print("Time: "); Serial.println( millis() - launchTimeNeon ); //if (millis() - launchTime < inTime) if (countFrameNeon < totalFrames) { countFrameNeon++; //Serial.print("counter Frames: "); //Serial.println(countFrameNeon); if (!mode) // FADE IN { r = neopix_gamma[(int)(255.*countFrameNeon / totalFrames)] * red / 255; // g = neopix_gamma[(int)(255.*countFrameNeon / totalFrames)] * green / 255; b = neopix_gamma[(int)(255.*countFrameNeon / totalFrames)] * blue / 255; w = neopix_gamma[(int)(255.*countFrameNeon / totalFrames)] * white / 255; // Serial.println("----"); // Serial.println(255.*countFrameNeon/totalFrames); // Serial.println(neopix_gamma[(int)(255.*countFrameNeon/totalFrames)]); } else { r = neopix_gamma[(int)(255.*(totalFrames - countFrameNeon) / totalFrames)] * red / 255; g = neopix_gamma[(int)(255.*(totalFrames - countFrameNeon) / totalFrames)] * green / 255; b = neopix_gamma[(int)(255.*(totalFrames - countFrameNeon) / totalFrames)] * blue / 255; w = neopix_gamma[(int)(255.*(totalFrames - countFrameNeon) / totalFrames)] * white / 255; // Serial.println("----"); // Serial.println(255.*countFrameNeon/totalFrames); // Serial.println(neopix_gamma[(int)(255.*countFrameNeon/totalFrames)]); } analogWrite(RED, r); analogWrite(GREEN, g); analogWrite(BLUE, b); analogWrite(WHITE, w); //Serial.print("Red: "); //Serial.println( r ); } } } void stroboNeon(byte red, byte green, byte blue, byte white, int stroboTime, int stroboPwm, int numFlash) { // countFrameNeon = 0; if ( millis() > delayedNeon ) { if (!neonFlag) { countFrameNeon = 0; stroboFlagNeon = 0; stroboNeonOn = true; neonFlag = true; Serial.println("---NEON STROBO---"); Serial.print("strobo Period: "); Serial.println(stroboTime); Serial.print("PWM: "); Serial.println(stroboPwm); Serial.print("Flashes: "); Serial.println(numFlash); } if (stroboNeonOn) { if ( !stroboFlagNeon ) { delayedNeon = millis() + (stroboTime * stroboPwm / 100); analogWrite(RED, red); analogWrite(GREEN, green); analogWrite(BLUE, blue); analogWrite(WHITE, white); stroboFlagNeon = 1; //.println("Strobo_ON"); } else { delayedNeon = millis() + (stroboTime * (100 - stroboPwm) / 100); analogWrite(RED, 0); analogWrite(GREEN, 0); analogWrite(BLUE, 0); analogWrite(WHITE, 0); //Serial.println("Strobo_OFF"); countFrameNeon++; if (countFrameNeon < numFlash) stroboFlagNeon = 0; // otro flash mas! else { stroboFlagNeon = 1; // stop flash stroboNeonOn = false; // stop neon } } } } } ////////////////////////////////////////////////////////////////// //////////////// PIXEL BASIC FUNCIONS ////////////////// ////////////////////////////////////////////////////////////////// void showStrip() { FastLED.show(); // parte 1 de 2.5m } // Set a LED color (not yet visible) void setPixel(int Pixel, byte red, byte green, byte blue, byte white) { leds[Pixel].r = red; leds[Pixel].g = green; leds[Pixel].b = blue; leds[Pixel].w = white; // leds[i] = CRGBW(red, green, blue, white); } // Set all LEDs to a given color and apply it (visible) void setAll(byte red, byte green, byte blue, byte white) { for(int i = 0; i < NUM_LEDS; i++ ) { setPixel(i, red, green, blue, white); } //showStrip(); } void fadeToBlack(int ledNo, byte fadeValue) { // NeoPixel //uint32_t oldColor; uint8_t r, g, b, w; int value; r = leds[ledNo].r ; g = leds[ledNo].g ; b = leds[ledNo].b ; w = leds[ledNo].w ; r = (r <= 10) ? 0 : (int) r - (r * fadeValue / 256); g = (g <= 10) ? 0 : (int) g - (g * fadeValue / 256); b = (b <= 10) ? 0 : (int) b - (b * fadeValue / 256); w = (w <= 10) ? 0 : (int) w - (w * fadeValue / 256); leds[ledNo]=CRGBW(r,g,b,w); } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL FADE ////////////////////// ////////////////////////////////////////////////////////////////// void fadePixel(byte red, byte green, byte blue, byte white, int mode, int fadeTime, int frameTime) // mode 0 = fadeIn, mode 1 = fadeOut { //if ( millis() > delayed ) //EVERY_N_MILLISECONDS(frameTime) //{ //delayed = millis() + frameTime - 11 ; // compensacion de bloqueo de millis float r, g, b, w; float totalFrames = fadeTime / frameTime; if (!pixelFlag) { launchTime = millis(); if (!mode) Serial.println("---FADEIN---"); else Serial.println("---FADEOUT---"); Serial.print("fadeTime: "); Serial.println(fadeTime); Serial.print("LaunchTime: "); Serial.println(launchTime); Serial.print("totalFrames: "); Serial.println(totalFrames); countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; } Serial.print("Time: "); Serial.println( millis() - launchTime ); //if (millis() - launchTime < inTime) if (countFrame < totalFrames) { countFrame++; Serial.print("counter Frames: "); Serial.println(countFrame); if (!mode) // FADE IN { r = neopix_gamma[(int)(255.*countFrame / totalFrames)] * red / 255.; g = neopix_gamma[(int)(255.*countFrame / totalFrames)] * green / 255; b = neopix_gamma[(int)(255.*countFrame / totalFrames)] * blue / 255; w = neopix_gamma[(int)(255.*countFrame / totalFrames)] * white / 255; } else { r = neopix_gamma[(int)(255.*(totalFrames - countFrame) / totalFrames)] * red / 255; g = neopix_gamma[(int)(255.*(totalFrames - countFrame) / totalFrames)] * green / 255; b = neopix_gamma[(int)(255.*(totalFrames - countFrame) / totalFrames)] * blue / 255; w = neopix_gamma[(int)(255.*(totalFrames - countFrame) / totalFrames)] * white / 255; } //Serial.print("counter Frames: "); //Serial.println(countFrame); //Serial.print("before show: "); //Serial.println( millis() - launchTime ); setAll(r, g, b, w); FastLED.show(); //Serial.print("after show: "); //Serial.println( millis() - launchTime ); //Serial.println(countFrame); } //} } void fadePixelColor(byte hueDest, int fadeTime, int frameTime) // conversion pixel a pixel desde el getpixelcolor //void fadePixelColor(byte red, byte green, byte blue, byte, white, int fadeTime, int frameTime) // conversion pixel a pixel desde el getpixelcolor { int r, g, b, w; float totalFrames = fadeTime / frameTime; static CRGBW colorInit[NUM_LEDS]; static CRGBW colorTemp[NUM_LEDS]; /// esto se habria de meter como statics! static CRGBW colorEnd[NUM_LEDS]; static float colorIncRed[NUM_LEDS]; // int porque puede ser positivo o negativo el incremento static float colorIncGreen[NUM_LEDS]; static float colorIncBlue[NUM_LEDS]; if ( millis() > delayed ) { delayed = millis() + frameTime ; // compensacion de bloqueo de millis if (!pixelFlag) { launchTime = millis(); Serial.println("---FADECOLOR---"); Serial.print("fadeTime: "); Serial.println(fadeTime); Serial.print("LaunchTime: "); Serial.println(launchTime); Serial.print("totalFrames: "); Serial.println(totalFrames); for ( int i = 0; i < NUM_LEDS ; i++) { colorInit[i] = leds[i]; colorEnd[NUM_LEDS] = CHSV( hueDest, 255, 255); colorIncRed[i] = (colorEnd[i].r-leds[i].r)/totalFrames; // ojo, puede ser positivo o negativo!!!!! colorIncGreen[i] = (colorEnd[i].g-leds[i].g)/totalFrames; colorIncBlue[i] = (colorEnd[i].b-leds[i].b)/totalFrames; colorTemp[i] = leds[i]; } //Serial.println(colorIncRed[i]); //Serial.println(colorRedTemp[i]); countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; } //Serial.print("tiempo despues de init: "); //Serial.println(millis()-launchTime); if (countFrame < totalFrames) { countFrame++; for ( int i = 0; i < NUM_LEDS ; i++) { colorTemp[i].r = colorTemp[i].r + colorIncRed[i]; colorTemp[i].g = colorTemp[i].g + colorIncGreen[i]; colorTemp[i].b = colorTemp[i].b + colorIncBlue[i]; leds[i] = colorTemp[i]; //setPixel(i, (byte)colorRedTemp[i], (byte)colorGreenTemp[i], (byte)colorBlueTemp[i], 0); // white is saturation } //Serial.print("tiempo despues de for: "); //Serial.println(millis()-launchTime); showStrip(); // para millis() durante 4.5 ms } //Serial.print("tiempo despues de show: "); //Serial.println(millis()-launchTime); } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL BAR ////////////////////// ////////////////////////////////////////////////////////////////// void pixelBar(byte red, byte green, byte blue, byte white, int pixelInit, int pixelEnd, int loopTime, int frameTime) { int pixelPos = 0; float r, g, b, w; float totalFrames = loopTime / frameTime; if (!pixelFlag) { launchTime = millis(); Serial.println("---PIXELBAR---"); Serial.print("loopTime: "); Serial.println(loopTime); Serial.print("LaunchTime: "); Serial.println(launchTime); Serial.print("totalFrames: "); Serial.println(totalFrames); countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; } if ( millis() > delayed ) { delayed = millis() + frameTime - 11; //Serial.print("Time: "); //Serial.println( millis() - launchTime ); //if (millis() - launchTime < inTime) if (countFrame < totalFrames) { countFrame++; //Serial.print("counter Frames: "); //Serial.println(countFrame); if (pixelInit < pixelEnd) // SENTIDO UP { pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); for ( int i = pixelInit; i < pixelPos ; i++) setPixel(i, red, green, blue, white); } else // SENTIDO DOWN { pixelPos = pixelInit - (1 - (totalFrames - countFrame) / totalFrames) * (pixelInit - pixelEnd); for ( int i = pixelInit; i >= pixelPos ; i--) setPixel(i, red, green, blue, white); } showStrip(); // para millis() durante 4.5 ms } } } ////////////////////////////////////////////////////////////////// /////////////////////// SCANNER ///////////////////// ////////////////////////////////////////////////////////////////// void scanner(byte red, byte green, byte blue, byte white, int pixelInit, int pixelEnd, int pixelWidth, int loopTime, int frameTime) { int pixelPos; float r, g, b, w; float totalFrames = loopTime / frameTime; if (!pixelFlag) { launchTime = millis(); Serial.println("---PIXEL SCANNER---"); Serial.print("loopTime: "); Serial.println(loopTime); Serial.print("LaunchTime: "); Serial.println(launchTime); Serial.print("totalFrames: "); Serial.println(totalFrames); countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; } if ( millis() > delayed ) { delayed = millis() + frameTime - 11; if (countFrame < totalFrames) { countFrame++; if (pixelInit < pixelEnd) // SENTIDO UP { pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); setAll(0, 0, 0, 0); for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, red, green, blue, white); } else // SENTIDO DOWN { pixelPos = pixelInit - (1 - (totalFrames - countFrame) / totalFrames) * (pixelInit - pixelEnd); setAll(0, 0, 0, 0); for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, red, green, blue, white); } showStrip(); // para millis() durante 4.5 ms } } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL STROBO //////////////////// ////////////////////////////////////////////////////////////////// void stroboPixel(byte red, byte green, byte blue, byte white, int stroboTime, int stroboPwm, int numFlash, int syncNeon) { if (!pixelFlag) { countFrame = 0; stroboFlag = 0; stroboPixelOn = true; pixelFlag = true; Serial.println("---PIXEL STROBO---"); Serial.print("strobo Period: "); Serial.println(stroboTime); Serial.print("PWM: "); Serial.println(stroboPwm); Serial.print("Flashes: "); Serial.println(numFlash); } if ( millis() > delayed ) { if (stroboPixelOn) { if ( !stroboFlag ) { delayed = millis() + (stroboTime * stroboPwm / 100) - 11 ; // 11ms de compensacion del showstrip stroboFlag = 1; setAll(red, green, blue, white); showStrip(); if (syncNeon) { analogWrite(RED, red); analogWrite(GREEN, green); analogWrite(BLUE, blue); analogWrite(WHITE, white); } } else { delayed = millis() + (stroboTime * (100 - stroboPwm) / 100) - 11 ; // 11ms de compensacion del showstrip setAll(0, 0, 0, 0); showStrip(); if (syncNeon) { analogWrite(RED, 0); analogWrite(GREEN, 0); analogWrite(BLUE, 0); analogWrite(WHITE, 0); } countFrame++; if (countFrame < numFlash) stroboFlag = 0; // otro flash mas! else { stroboFlag = 1; // stop flash stroboPixelOn = false; // stop neon } } } } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL LLUVIA //////////////////// ////////////////////////////////////////////////////////////////// void meteorRain(byte red, byte green, byte blue, byte white, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay) { setAll(0, 0, 0, 0); for (int i = 0; i < NUM_LEDS ; i++) { // fade brightness all LEDs one step for (int j = 0; j < NUM_LEDS; j++) { if ( (!meteorRandomDecay) || (random(10) > 5) ) { fadeToBlack(j, meteorTrailDecay ); } } // draw meteor for (int j = 0; j < meteorSize; j++) { if ( ( i - j < NUM_LEDS) && (i - j >= 0) ) { setPixel(i - j, red, green, blue, white); } } showStrip(); } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL FIRE ////////////////////// ////////////////////////////////////////////////////////////////// void fire(int Cooling, int Sparking, int frameTime) { if (!pixelFlag) { pixelFlag = true; Serial.println("---FIRE---"); Serial.print("Cooling: "); Serial.println(Cooling); Serial.print("Sparking: "); Serial.println(Sparking); } if ( millis() > delayed ) { delayed = millis() + frameTime - 11 ; // 11ms de compensacion del showstrip static byte heat[NUM_LEDS]; int cooldown; // Step 1. Cool down every cell a little for ( int i = 0; i < NUM_LEDS ; i++) { cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2); if (cooldown > heat[i]) { heat[i] = 0; } else { heat[i] = heat[i] - cooldown; } } // Step 2. Heat from each cell drifts 'up' and diffuses a little for ( int k = NUM_LEDS - 1; k >= 2; k--) { heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3; } // Step 3. Randomly ignite new 'sparks' near the bottom if ( random(255) < Sparking ) { int y = random(7); heat[y] = heat[y] + random(160, 255); //heat[y] = random(160,255); } // Step 4. Convert heat to LED colors for ( int j = 0; j < NUM_LEDS; j++) { setPixelHeatColor(j, heat[j] ); } showStrip(); } } void setPixelHeatColor (int Pixel, byte temperature) { // Scale 'heat' down from 0-255 to 0-191 byte t192 = round((temperature / 255.0) * 191); // calculate ramp up from byte heatramp = t192 & 0x3F; // 0..63 heatramp <<= 2; // scale up to 0..252 // figure out which third of the spectrum we're in: if ( t192 > 0x80) { // hottest setPixel(Pixel, 255, 255, heatramp, 0); } else if ( t192 > 0x40 ) { // middle setPixel(Pixel, 255, heatramp, 0, 0); } else { // coolest setPixel(Pixel, heatramp, 0, 0, 0); } } ////////////////////////////////////////////////////////////////// /////////////////////// BARRIDO PIXEL /////////////////// ////////////////////////////////////////////////////////////////// void confetti() { // random colored speckles that blink in and fade smoothly fadeToBlackBy( leds, NUM_LEDS, 10); int pos = random16(NUM_LEDS); leds[pos] += CHSV( gHue + random8(64), 200, 255); } void sinelon() { // a colored dot sweeping back and forth, with fading trails fadeToBlackBy( leds, NUM_LEDS, 20); int pos = beatsin16(13,0,NUM_LEDS); leds[pos] += CHSV( gHue, 255, 192); } void bpm() { // colored stripes pulsing at a defined Beats-Per-Minute (BPM) uint8_t BeatsPerMinute = 62; CRGBPalette16 palette = PartyColors_p; uint8_t beat = beatsin8( BeatsPerMinute, 64, 255); for( int i = 0; i < NUM_LEDS; i++) { //9948 leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10)); } } void juggle() { // eight colored dots, weaving in and out of sync with each other fadeToBlackBy( leds, NUM_LEDS, 20); byte dothue = 0; for( int i = 0; i < 8; i++) { leds[beatsin16(i+7,0,NUM_LEDS)] |= CHSV(dothue, 200, 255); dothue += 32; } } ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// void NewKITT(byte red, byte green, byte blue, byte white, int EyeSize, int SpeedDelay, int ReturnDelay) { RightToLeft(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); LeftToRight(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); OutsideToCenter(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); CenterToOutside(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); LeftToRight(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); RightToLeft(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); OutsideToCenter(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); CenterToOutside(red, green, blue, white, EyeSize, SpeedDelay, ReturnDelay); } // used by NewKITT void CenterToOutside(byte red, byte green, byte blue, byte white, int EyeSize, int SpeedDelay, int ReturnDelay) { for (int i = ((NUM_LEDS - EyeSize) / 2); i >= 0; i--) { setAll(0, 0, 0, 0); setPixel(i, red / 10, green / 10, blue / 10, white / 10); for (int j = 1; j <= EyeSize; j++) { setPixel(i + j, red, green, blue, white ); } setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10, white / 10); setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10, white / 10); for (int j = 1; j <= EyeSize; j++) { setPixel(NUM_LEDS - i - j, red, green, blue, white); } setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10, white / 10); showStrip(); delay(SpeedDelay); } delay(ReturnDelay); } // used by NewKITT void OutsideToCenter(byte red, byte green, byte blue, byte white, int EyeSize, int SpeedDelay, int ReturnDelay) { for (int i = 0; i <= ((NUM_LEDS - EyeSize) / 2); i++) { setAll(0, 0, 0, 0); setPixel(i, red / 10, green / 10, blue / 10, white / 10); for (int j = 1; j <= EyeSize; j++) { setPixel(i + j, red, green, blue, white); } setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10, white / 10); setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10, white / 10); for (int j = 1; j <= EyeSize; j++) { setPixel(NUM_LEDS - i - j, red, green, blue, white); } setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10, white / 10); showStrip(); delay(SpeedDelay); } delay(ReturnDelay); } // used by NewKITT void LeftToRight(byte red, byte green, byte blue, byte white, int EyeSize, int SpeedDelay, int ReturnDelay) { for (int i = 0; i < NUM_LEDS - EyeSize - 2; i++) { setAll(0, 0, 0, 0); setPixel(i, red / 10, green / 10, blue / 10, white / 10); for (int j = 1; j <= EyeSize; j++) { setPixel(i + j, red, green, blue, white); } setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10, white / 10); showStrip(); delay(SpeedDelay); } delay(ReturnDelay); } // used by NewKITT void RightToLeft(byte red, byte green, byte blue, byte white, int EyeSize, int SpeedDelay, int ReturnDelay) { for (int i = NUM_LEDS - EyeSize - 2; i > 0; i--) { setAll(0, 0, 0, 0); setPixel(i, red / 10, green / 10, blue / 10, white / 10); for (int j = 1; j <= EyeSize; j++) { setPixel(i + j, red, green, blue, white); } setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10, white / 10); showStrip(); delay(SpeedDelay); } delay(ReturnDelay); } ////////////////////////////////////////////////////////////////// /////////////////////// RANDOMS PIXEL /////////////////// ////////////////////////////////////////////////////////////////// void Twinkle(byte red, byte green, byte blue, byte white, int Count, int SpeedDelay, boolean OnlyOne) { setAll(0, 0, 0, 0); for (int i = 0; i < Count; i++) { setPixel(random(NUM_LEDS), red, green, blue, white); showStrip(); delay(SpeedDelay); if (OnlyOne) { setAll(0, 0, 0, 0); } } delay(SpeedDelay); } void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) { setAll(0, 0, 0, 0); for (int i = 0; i < Count; i++) { setPixel(random(NUM_LEDS), random(0, 255), random(0, 255), random(0, 255), random(0, 255)); showStrip(); delay(SpeedDelay); if (OnlyOne) { setAll(0, 0, 0, 0); } } delay(SpeedDelay); } void Sparkle(byte red, byte green, byte blue, byte white, int SpeedDelay) { int Pixel = random(NUM_LEDS); setPixel(Pixel, red, green, blue, white); showStrip(); delay(SpeedDelay); setPixel(Pixel, 0, 0, 0, 0); } void SnowSparkle(byte red, byte green, byte blue, byte white, int SparkleDelay, int SpeedDelay) { setAll(red, green, blue, white); int Pixel = random(NUM_LEDS); setPixel(Pixel, 0xff, 0xff, 0xff, 0xff); showStrip(); delay(SparkleDelay); setPixel(Pixel, red, green, blue, white); showStrip(); delay(SpeedDelay); } void RunningLights(byte red, byte green, byte blue, byte white, int WaveDelay) { int Position = 0; for (int i = 0; i < NUM_LEDS * 2; i++) { Position++; // = 0; //Position + Rate; for (int i = 0; i < NUM_LEDS; i++) { // sine wave, 3 offset waves make a rainbow! //float level = sin(i+Position) * 127 + 128; //setPixel(i,level,0,0); //float level = sin(i+Position) * 127 + 128; setPixel(i, ((sin(i + Position) * 127 + 128) / 255)*red, ((sin(i + Position) * 127 + 128) / 255)*green, ((sin(i + Position) * 127 + 128) / 255)*blue, ((sin(i + Position) * 127 + 128) / 255)*white); } showStrip(); delay(WaveDelay); } } void colorWipe(byte red, byte green, byte blue, byte white, int SpeedDelay) { for (uint16_t i = 0; i < NUM_LEDS; i++) { setPixel(i, red, green, blue, white); showStrip(); delay(SpeedDelay); } } // void rainbowCycle(int SpeedDelay) { // byte *c; // uint16_t i, j; // for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel // for(i=0; i< NUMPIXELS1; i++) { // c=Wheel(((i * 256 / NUMPIXELS1) + j) & 255); // setPixel(i, *c, *(c+1), *(c+2), 0); // } // showStrip(); // delay(SpeedDelay); // } // } void theaterChase(byte red, byte green, byte blue, byte white, int SpeedDelay) { for (int j = 0; j < 10; j++) { //do 10 cycles of chasing for (int q = 0; q < 3; q++) { for (int i = 0; i < NUM_LEDS; i = i + 3) { setPixel(i + q, red, green, blue, white); //turn every third pixel on } showStrip(); delay(SpeedDelay); for (int i = 0; i < NUM_LEDS; i = i + 3) { setPixel(i + q, 0, 0, 0, 0); //turn every third pixel off } } } } // void theaterChaseRainbow(int SpeedDelay) { // uint32_t c; // for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel // for (int q=0; q < 3; q++) { // for (int i=0; i < NUMPIXELS1; i=i+3) { // c = wheel( (i+j) % 255); // setPixel(i+q, c, (c+1), (c+2),0); //turn every third pixel on // } // showStrip(); // delay(SpeedDelay); // for (int i=0; i < NUMPIXELS1; i=i+3) { // setPixel(i+q, 0,0,0,0); //turn every third pixel off // } // } // } // }