#include #include "nRF24L01.h" #include "RF24.h" #include "printf.h" #include "Adafruit_NeoPixel.h" #define RADIOSEND false #define CE_PIN 12 #define CSN_PIN 2 #define DEBUG 1 #define TEST 0 #define RED 11 #define GREEN 10 #define BLUE 9 #define WHITE 6 #define SDO1 4 #define SDO2 8 #define SDO3 3 #define NUMPIXELS1 300 // fuego #define NUMPIXELS2 150 #define NUMPIXELS3 150 //int idpin[8] = { 5, 13, A4, A3, A2, A1, A0, A5}; int idpin[6] = { A5, A0, A1, A2, A3, A4}; int chpin[2] = { 13, 5 }; // no se va a usar en esta App Adafruit_NeoPixel pixels1 = Adafruit_NeoPixel(NUMPIXELS1, SDO1, NEO_GRBW + NEO_KHZ800); Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(NUMPIXELS2, SDO2, NEO_GRBW + NEO_KHZ800); Adafruit_NeoPixel pixels3 = Adafruit_NeoPixel(NUMPIXELS3, SDO3, NEO_GRBW + NEO_KHZ800); byte 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 = 20; // Fuerzo a canal 76 (showroom) // Globales PIXEL unsigned long delayed = 0; // control de tiempo de funciones de pixel int countFrame = 0; unsigned long launchTime = 0; short stroboPixelFlag = 0; short pixelFlag = 0; short pixelOn = 0; short stroboPixelOn = 0; float incRed, incGreen, incBlue, incWhite; // Glboales NEON 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; uint8_t param2 = 140; uint8_t selectedEffect = 0; uint16_t i = 0; int c = 0; int numSer = 0; char numStr[4]; byte globalNeonRed; byte globalNeonGreen; byte globalNeonBlue; byte globalNeonWhite; uint32_t p1, p2, p3, p4, p5, p6 ; // bytes para los comandos OSC (colores) void resetBoard() { Serial.println("reset"); //asm volatile (" jmp 0"); // esto no funciona en SAMD } byte id() { int id = 0; for (byte i = 0; i < 6; i++ ) bitWrite(id, i, digitalRead(idpin[i])); return id; } int channel() { int value = code(); switch (value) { case 0: value = 0x10; // break; case 1: value = 0x4C; // break; case 3: value = 0x64; // break; case 4: value = 0x7F; // break; default: value = 0; // break; } return value; } int code() { int value = 0; for (byte i = 0; i < 2; i++) bitWrite(value, i, digitalRead(chpin[i])); return value; } ////////////////////////////////////////////////////////////////// ///////////////////////// SETUP //////////////////////////////// ////////////////////////////////////////////////////////////////// void setup() { 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 < 6; i++) { pinMode(idpin[i], INPUT); } for (int i = 0; i < 2; i++) { pinMode(chpin[i], INPUT); } analogWrite(WHITE, 255); analogWrite(RED, 255); analogWrite(GREEN, 255); analogWrite(BLUE, 255); pixels1.begin(); pixels2.begin(); pixels3.begin(); pixels1.show(); // Initialize all pixels to 'off' pixels2.show(); // Initialize all pixels to 'off' pixels3.show(); // Initialize all pixels to 'off' 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 //////////////////////// // Serial.print("id: "); // Serial.println(id()); // Serial.print("code: "); // Serial.println(code()); if (TEST) { colorBrightness(255, 255, 0, 16); } 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 < 8 ; i++) { Serial.print(CMD[i]); Serial.print(","); } Serial.println(); } if(( CMD[1] == id() || ( CMD[1] == 0xFF ))) // Solo actualizo si el comando es para mi { p1 = CMD[2]; // color p2 = CMD[3]; // color p3 = CMD[4]; // modo, totalframes, tamaño p4 = CMD[5]; // tiempo, framerate (randoms) p5 = CMD[6]; // inicio pixel, numflashes, density (randoms) p6 = CMD[7]; // final pixel, modo, decay } // ajustar los parametros de numero de pixels que llegan hasta 300, //extrapolar 255 a 300 if ( ( CMD[0] == 0 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) { selectedEffect = 0; // CMD 0 = off } if ( ( CMD[0] == 1 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) { selectedEffect = 1; // CMD 1 - FADE OUT p4 = p4*100; // P1 = DECAY } else if ( ( CMD[0] == 2 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 2 { selectedEffect = 2; // CMD 2 - FADE IN OUT NEON neonFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // P1 = COLOR (HUE+WHITE), P2 = MODE (IN/OUT) , P3 = FADETIME } else if ( ( CMD[0] == 3 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 3 { selectedEffect = 3; // CMD 3 - FADE in/out PIXEL pixelFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS // P1 = COLOR (HUE+WHITE), P2 = MODE (IN/OUT) , P3 = FADETIME } else if ( ( CMD[0] == 4 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 4 { selectedEffect = 4; // CMD 4 - FADE in/out PIXEL + NEON SIMULTANEOS pixelFlag = 0; neonFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS // P1 = COLOR (HUE+WHITE), P2 = MODE (IN/OUT) , P3 = FADETIME } else if ( ( CMD[0] == 5 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 5 { selectedEffect = 5; // CMD 5 - FADE COLOR PIXEL + NEON SIMULTANEOS pixelFlag = 0; neonFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS // P1 = END COLOR (HUE+WHITE), P2 = FADETIME } else if ( ( CMD[0] == 6 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF ))) // CMD 6 { selectedEffect = 6; // CMD 6 - FADE PIXEL RAINBOW pixelFlag = 0; p1 = hueWeel(CMD[2]); p2 = hueWeel(CMD[3]); p4 = p4*100; // P1 = INIT COLOR (HUE+WHITE), P2 = END COLOR (HUE+WHITE), P3 = FADETIME } else if ( ( CMD[0] == 7 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 7 { selectedEffect = 7; // CMD 7 - STROBO NEON neonFlag = 0; p1 = hueWeel(CMD[2]); // P1 = COLOR (HUE+WHITE), P2 = PERIODO, P3 = PWM, P4 = NUM FLASHES ( 0 permante ) } else if ( ( CMD[0] == 8 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 8 { selectedEffect = 8; // CMD 8 - STROBO PIXEL + NEON SIMULTANEOS (sync ON) pixelFlag = 0; p1 = hueWeel(CMD[2]); // P1 = COLOR (HUE+WHITE), P2 = PERIODO, P3 = PWM, P4 = NUM FLASHES ( 0 permante ) // P5 = NEON SYNC } else if ( ( CMD[0] == 9 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 9 { selectedEffect = 9; // CMD 9 - STROBO RANDOM COLOR + NEON SIMULTANEOS (sync ON) pixelFlag = 0; // P1 = PERIODO, P2 = PWM, P4 = NUM FLASHES ( 0 permante ), P4 (bool) = NEON SYNC } else if ( ( CMD[0] == 10 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 10 { selectedEffect = 10; // CMD 10 - RANDOM PIXEL pixelFlag = 0; p1 = hueWeel(CMD[2]); // P1 = COLOR, P2 = TOTALFRAMES, P4 = FRAMERATE???, P5 = DENSITY } else if ( ( CMD[0] == 11 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 11 { selectedEffect = 11; // CMD 11 - RANDOM COLOR + NEON SIMULTANEOS (sync ON) ???? pixelFlag = 0; // P1 = TOTALFRAMES, P2 = FRAMERATE???? } else if ( ( CMD[0] == 12 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 12 { selectedEffect = 12; // CMD 12 - RANDOM INVERT - EFECTO DISOLUCION pixelFlag = 0; p1 = hueWeel(CMD[2]); // P1 = COLOR, P2 = TOTALFRAMES, P3 = FRAMERATE???, P4 = DENSITY } else if ( ( CMD[0] == 13 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 13 { selectedEffect = 13; // CMD 13 - PIXELBAR pixelFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS if(p6 > p5) p6=p6*300/255; else p5=p5*300/255; // P1 = COLOR, P2 = ORIGEN, P3 = FINAL , P4 = TIEMPO } else if ( ( CMD[0] == 14 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 14 { selectedEffect = 14; // CMD 14 - SCANNER pixelFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS if(p6 > p5) p6=p6*300/255; else p5=p5*300/255; // P1 = COLOR, P2 = ORIGEN, P3 = FINAL , P4 = TAMAÑO, P5 = TIEMPO } else if ( ( CMD[0] == 15 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 15 { selectedEffect = 15; // CMD 15 - METEORITO pixelFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS // P1 = COLOR, P2 = DECAY, P3 = TAMAÑO, P4 = TIEMPO } else if ( ( CMD[0] == 16 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 16 { selectedEffect = 16; // CMD 16 - EXPLOSION, CENTRO A EXTREMOS pixelFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS // P1 = COLOR, P2 = MODO, P3 = TAMAÑO, P4 = TIEMPO } else if ( ( CMD[0] == 17 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 17 { selectedEffect = 17; // CMD 17 - IMPLOSION, EXTREMO A CENTRO pixelFlag = 0; p1 = hueWeel(CMD[2]); p4 = p4*100; // de DECIMAS A MILISEGUNDOS // P1 = COLOR, P2 = MODO, P3 = TAMAÑO, P4 = TIEMPO } else if ( ( CMD[0] == 18 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 18 { selectedEffect = 18; // CMD 18 - FUEGO pixelFlag = 0; neonFlag = 0; // programar automatico un rojo en el NEON // P1 = TAMAÑO, P2 = CHISPAS, P3 = TAMAÑO, P4 = TIEMPO } else if ( ( CMD[0] == 19 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 18 { selectedEffect = 19; pixelFlag = 0; neonFlag = 0; //color p1 = hueWeel(CMD[2]); } else if ( ( CMD[0] == 20 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 20 { selectedEffect = 20; // CMD 20 - pixelFlag = 0; neonFlag = 0; // programar automatico un rojo en el NEON // P1 = color, P2 = value, P3 = } else if ( ( CMD[0] == 100 ) && (( CMD[1] == id() ) || ( CMD[1] == 0xFF )))// CMD 100 { selectedEffect = 100; // CMD 100 CANAL } } } ///////////////////////// 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; } } ///////////////////////// CALLS ANIMACIONES //////////////////////// switch (selectedEffect) { case 0 : { // OFF - no parameters setAll(0, 0, 0, 0); colorNeon(0, 0, 0, 0); splitStrip(); showStrip(); break; } ///////////////////// FADES //////////////////////// case 1 : { // FADE OUT RANDOM - ( fadeTime, fadeRandomDecay, fadeTrailDecay, frameTime) //fadeOutRandom(4000, true, 50, 16); // decay max:255 fadeOutRandom(p4, true, 50, 16); break; } case 2 : { // ONLY NEON FADE IN OR FADE OUT // NEON Color (color mode in/out, fadetime, frametime) //fadeNeon(255, 0, 0, 0, 0, 2000, 16, 0); fadeNeon(p1, p3, p4, 16); break; } case 3 : { // ONLY STRIP FADE IN or FADE OUT // Strip FADE Color (color, mode in/out, fadetime, frametime) //fadePixel(p1, 0, 1000, 16); // fadein fadePixel(p1, p3, p4, 16); // fadein , p4 unidades son decimas de segundo. 255 = 25,5s // Serial.print(p1); // Serial.print(","); // Serial.print(p3); // Serial.print(","); // Serial.println(p4); break; } case 4 : { // STRIP FADE + NEON SYNC // Strip FADE Color (color, mode in/out, fadetime, frametime) // NEON Color (color, mode in/out, fadetime, frametime) fadePixel(p1, p3, p4, 16); // fadeout fadeNeon(p1, p3, p4, 16); //fadeNeon(255, 120, 40, 40, 1, 3000, 16); // BLANCO CALIBRADO NEON: 255, 120, 40 break; } case 5 : { // STRIP FADE COLOR fadePixelColor(p1, p4, 33); //fadePixelColor(0, 0, 255, 0, 5000, 33); // FADECOLOR // NEON FADE COLOR // ( color, fadeTime, frameTime, syncPixel ) // parte del color actual del strip //fadeNeonColor(0, 0, 255, 255, 5000, 33, 1); // FADEC1OLOR //fadeNeonColor(0, 0, 255, 255, 5000, 33); fadeNeonColor(p1, p4, 33); break; } // añadir casos nuevos de pixel y neon solos!!!! case 6 : { // color inicial, color final, mode, fadetime, frameRate //fadePixelRainbow(p1, p2, 1, 2000, 33); // FADE PIXEL RAINBOW, UN COLOR ARRIBA Y UNO ABAJO, FADE IN o FADE OUT fadePixelRainbow(p1, p2, p3, p4, 33); // p1, p2: color, p3 mode, p4 time break; } ///////////////////// STROBOS //////////////////////// case 7 : { // Strobe - (time, PWM, numFlashes) //stroboNeon(p1, 500, 15, 3); stroboNeon(p1, p4, 15, p5); // aqui p4 es en milisegundos. Maximo 255 break; } case 8 : { // Strobe SYNC- (r, g, b, w, time, PWM, numFlashes, NEON sync) //stroboPixel(p1, 50, 15, 10, 1); stroboPixel(p1, p4, 15, p5, p6); // sync= 1 aciva NEON, p5 = numflashes, p6 = sync break; } case 9 : { // Strobe SYNC- (time, PWM, numFlashes, NEON sync) //stroboRandomColor(100, 50, 10, 1); //sync= 1 aciva NEON stroboRandomColor(p4, 50, p5, p6); //sync= 1 aciva NEON break; } ///////////////////// RANDOMS //////////////////////// case 10 : { // RANDOM: r, g, b, w, totalFrames, frameRate, density, oneOnly or adding pixels randomPixel(p1, p3, p4, p5, false); // usar una variable FRAMERATE y DENSITY controlable en tiempo real //randomPixel(0, 0, 0, 255, 100, 16, 3, true); // break; } case 11 : { //randomColor( 100, 100 ); // totalFrames , frameRate // usar una variable FRAMERATE randomColor( p3, p4 ); // totalFrames , frameRate // usar una variable FRAMERATE break; } case 12 : {// RANDOM: r, g, b, w, size, totalFrames, frameRate, density, oneOnly or adding pixels //randomInvert(p1, 2, 30, 16, 20, true); // usar una variable FRAMERATE y DENSITY controlable en tiempo real randomInvert(p1, 2, p3, 16, 20, true); // usar una variable FRAMERATE y DENSITY controlable en tiempo real break; } ///////////////////// BARRIDOS //////////////////////// case 13 : { // 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(p1, p5, p6, p4, 16); // p4 tiempo de animacion, siempre hacia arriba? // p5 = posicion origen, p6 = posicion fin break; } case 14 : { // SCANNER - (r, g, b, w, mode, pixelInit, pixelEnd, pixelWidth, loopTime, frameTime ) //scanner(0, 0, 0, 255, , 0, 0, 300, 4, 1000, 16); // rampa de SUBIDA de 1s scanner(p1, 0, p5, p6, p3, p4, 16); // MODE = 0, scan // p5 = origen, p6 = fin, p3 = tamaño, p4 = tiempo break; } case 15 : { // METEOR - (r, g, b, w, meteorTrailDecay, meteorRandomDecay, pixelInit, pixelEnd, pixelWidth, loopTime, frameTime) //meteorRain(0, 0, 0, 255, true, 255, 0, 300, 10, 200, 16); // rampa de BAJADA de 1s //meteorRain(p1, true, 100, 300, 0, 10, 3000, 16); meteorRain(p1, true, p6, 300, 0, p3, p4, 16); // rampa de BAJADA de 1s // p3 = tamaño, p4 = tiempo, p6 = decay (100) break; } case 16 : { // CENTER TO OUT - (r, g, b, w, mode, pixelWidth, loopTime, frameTime ) //centerToOut(p1, false, 8, 1000, 16); // modo segmento centerToOut(p1, p6, p3, p4, 16); // p3 = tamaño, p4 = tiempo, p6 = modo (segmento o barra) break; } case 17 : { // OUT TO CENTER - (r, g, b, w, mode, pixelWidth, loopTime, frameTime ) // mode para hacerlo solido o barrido outToCenter(p1, p6, p3, p4, 16); // modo barra // p3 = tamaño, p4 = tiempo, p6 = modo (segmento o barra) break; } ///////////////////// EFECTOS //////////////////////// case 18 : { // Fire - Cooling rate, Sparking rate, framerate //fire(55, 120, 16); fire(p4, p5, 16); // p4 = altura llama, p5 = chispas break; } case 19 : { // go to color con control de intensidad colorBrightness(p1, p2, p3, 16); break; } case 100 : { // go to color con control de intensidad radio.setChannel(p1); radio.startListening(); radio.printDetails(); Serial.print("canal: "); Serial.println(p1); delay(1000); break; } } } ////////////////////////////////////////////////////////////////// /////////////////////// NEON FUNCIONS /////////////////// ////////////////////////////////////////////////////////////////// void colorNeon(byte red, byte green, byte blue, byte white) { globalNeonRed = red; globalNeonGreen = green; globalNeonBlue = blue; globalNeonWhite = white; analogWrite(RED, globalNeonRed); analogWrite(GREEN, globalNeonGreen); analogWrite(BLUE, globalNeonBlue); analogWrite(WHITE, globalNeonWhite); } //void fadeNeon(byte red, byte green, byte blue, byte white, int mode, int fadeTime, int frameTime, int syncPixel) // mode 0 = fadeIn, mode 1 = fadeOut //void fadeNeon(byte red, byte green, byte blue, byte white, int mode, int fadeTime, int frameTime) // mode 0 = fadeIn, mode 1 = fadeOut void fadeNeon(uint32_t color, int mode, int fadeTime, int frameTime) // mode 0 = fadeIn, mode 1 = fadeOut { if ( millis() > delayedNeon ) { //if (syncPixel) // es necesario para sincronizar cuando va al mismo tiempo del pixel que es bloqueante if (pixelOn) // automatico para no tener que pasarle syncPixel como parametro 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; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if(endWhite){ // si llega blanco configurar como natura white calibrado endRed = 255; endGreen = 120; endBlue = 40; endWhite = 40; // solo en PCB con salida azul estropeada } if (!neonFlag) { launchTimeNeon = millis(); if (DEBUG) { 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; } if (countFrameNeon < totalFrames) { countFrameNeon++; if (!mode) // FADE IN { r = neopix_gamma[(byte)(255.*countFrameNeon / totalFrames)] * endRed / 255.; // g = neopix_gamma[(byte)(255.*countFrameNeon / totalFrames)] * endGreen / 255.; b = neopix_gamma[(byte)(255.*countFrameNeon / totalFrames)] * endBlue / 255.; w = neopix_gamma[(byte)(255.*countFrameNeon / totalFrames)] * endWhite / 255.; // Serial.println("----"); // Serial.println(255.*countFrameNeon/totalFrames); // Serial.println(neopix_gamma[(int)(255.*countFrameNeon/totalFrames)]); } else { r = neopix_gamma[(byte)(255.*(totalFrames - countFrameNeon) / totalFrames)] * endRed / 255. ; g = neopix_gamma[(byte)(255.*(totalFrames - countFrameNeon) / totalFrames)] * endGreen / 255. ; b = neopix_gamma[(byte)(255.*(totalFrames - countFrameNeon) / totalFrames)] * endBlue / 255.; w = neopix_gamma[(byte)(255.*(totalFrames - countFrameNeon) / totalFrames)] * endWhite / 255.; // Serial.println("----"); // Serial.println(255.*countFrameNeon/totalFrames); // Serial.println(neopix_gamma[(int)(255.*countFrameNeon/totalFrames)]); } globalNeonRed = r; globalNeonGreen = g; globalNeonBlue = b; globalNeonWhite = w; analogWrite(RED, r); analogWrite(GREEN, g); analogWrite(BLUE, b); analogWrite(WHITE, b); // parche para salida blanco a azul en placa estropeada //Serial.print("Red: "); //Serial.println( r ); } } } //void fadeNeonColor(byte startRed, byte startGreen, byte startBlue, byte startWhite, byte endRed, byte endGreen, byte endBlue, byte endWhite,int fadeTime, int frameTime, int syncPixel) //void fadeNeonColor(byte endRed, byte endGreen, byte endBlue, byte endWhite,int fadeTime, int frameTime, int syncPixel) void fadeNeonColor(uint32_t color ,int fadeTime, int frameTime) { if ( millis() > delayedNeon ) { //if (syncPixel) // es necesario para sincronizar cuando va al mismo tiempo del pixel que es bloqueante if (pixelOn) 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; static byte startRed; static byte startGreen; static byte startBlue; static byte startWhite; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if(endWhite){ // si llega blanco configurar como natura white calibrado endRed = 255; endGreen = 120; endBlue = 40; } if (!neonFlag) { launchTimeNeon = millis(); if (DEBUG) { Serial.println("---NEON FADECOLOR---"); 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; startRed = globalNeonRed; startGreen = globalNeonGreen; startBlue = globalNeonBlue; startWhite = globalNeonWhite; } if (countFrameNeon < totalFrames) { countFrameNeon++; r = map(countFrameNeon*255./totalFrames, 0, 255, startRed, endRed); g = map(countFrameNeon*255./totalFrames, 0, 255, startGreen, endGreen); b = map(countFrameNeon*255./totalFrames, 0, 255, startBlue, endBlue); w = map(countFrameNeon*255./totalFrames, 0, 255, startWhite, endWhite); // Serial.println("----------------------"); // Serial.print("startBlue: "); // Serial.print(startBlue); // Serial.print(" endBlue: "); // Serial.println(endBlue); // Serial.println(countFrameNeon*255./totalFrames); // Serial.println(b); globalNeonRed = r; globalNeonGreen = g; globalNeonBlue = b; globalNeonWhite = w; analogWrite(RED, r); analogWrite(GREEN, g); analogWrite(BLUE, b); analogWrite(WHITE, b); // azul replicado en salida de blanco por placa estropeada } } } void stroboNeon(uint32_t color, int stroboTime, int stroboPwm, int numFlash) { // countFrameNeon = 0; if ( millis() > delayedNeon ) { byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if(endWhite){ // si llega blanco configurar como natura white calibrado endRed = 255; endGreen = 120; endBlue = 40; endWhite = 40; // solo en PCB con salida azul estropeada } if (!neonFlag) { countFrameNeon = 0; stroboFlagNeon = 0; stroboNeonOn = true; neonFlag = true; if (DEBUG) { 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, endRed); analogWrite(GREEN, endGreen); analogWrite(BLUE, endBlue); analogWrite(WHITE, endBlue); // solo para arreglar la placa estropeada, azul replicado stroboFlagNeon = 1; globalNeonRed = endRed; globalNeonGreen = endGreen; globalNeonBlue = endBlue; globalNeonWhite = endWhite; //.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"); globalNeonRed = 0; globalNeonGreen = 0; globalNeonBlue = 0; globalNeonWhite = 0; countFrameNeon++; if (countFrameNeon < numFlash) stroboFlagNeon = 0; // otro flash mas! else { stroboFlagNeon = 1; // stop flash stroboNeonOn = false; // stop neon } } } } } ////////////////////////////////////////////////////////////////// //////////////// PIXEL BASIC FUNCIONS ////////////////// ////////////////////////////////////////////////////////////////// uint8_t white(uint32_t c) { return (c >> 24); } uint8_t red(uint32_t c) { return (c >> 16); } uint8_t green(uint32_t c) { return (c >> 8); } uint8_t blue(uint32_t c) { return (c); } // Input a value 0 to 255 to get a color value. // The colours are a transition r - g - b - back to r. uint32_t hueWeel(byte wheelPos) { if (wheelPos == 255) return pixels1.Color(0, 0, 0, 255); // caso especial BLANCO else { wheelPos = 255 - wheelPos; if (wheelPos < 85) { return pixels1.Color(255 - wheelPos * 3, 0, wheelPos * 3, 0); } if (wheelPos < 170) { wheelPos -= 85; return pixels1.Color(0, wheelPos * 3, 255 - wheelPos * 3, 0); } wheelPos -= 170; return pixels1.Color(wheelPos * 3, 255 - wheelPos * 3, 0, 0); } } void splitStrip() { // CONVERSION DE UNA ANIMACION DE 5M A DOS TRAMOS for ( int i = 0; i < 150 ; i++) // numPixels/2 { pixels2.setPixelColor( i, pixels1.getPixelColor(i) ); pixels3.setPixelColor( i, pixels1.getPixelColor(i + 150) ); } } void showStrip() { //pixels1.show(); // tira entera de 5m pixels2.show(); // parte 1 de 2.5m pixels3.show(); // parte 2 de 2.5m } void setPixel(int Pixel, byte red, byte green, byte blue, byte white) { pixels1.setPixelColor(Pixel, pixels1.Color(red, green, blue, white)); } void setAll(byte red, byte green, byte blue, byte white) { for (int i = 0; i < NUMPIXELS1; i++ ) { setPixel(i, red, green, blue, white); } } void fadeToBlack(int ledNo, byte fadeValue) { uint32_t oldColor; uint8_t r, g, b, w; int value; oldColor = pixels1.getPixelColor(ledNo); w = (oldColor & 0xff000000UL) >> 24; r = (oldColor & 0x00ff0000UL) >> 16; g = (oldColor & 0x0000ff00UL) >> 8; b = (oldColor & 0x000000ffUL); 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); pixels1.setPixelColor(ledNo, r,g,b,w); } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL FADE ////////////////////// ////////////////////////////////////////////////////////////////// void fadeOutRandom(int fadeTime, int fadeRandomDecay, int fadeTrailDecay, int frameTime) // usar fade to black para desaparecer a negro { float r, g, b, w; float totalFrames = fadeTime / frameTime; if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---FADE OUT RANDOM---"); 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; } if ( millis() > delayed ) { delayed = millis() + frameTime - 11; for (int j = 0; j < NUMPIXELS1; j++) { if( (!fadeRandomDecay) || (random(10)>5) ) { fadeToBlack(j, fadeTrailDecay ); } } splitStrip(); showStrip(); // para millis() durante 4.5 ms } } void colorBrightness(uint32_t color , int value, int syncNeon, int frameTime) { if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---COLOR BRIGHTNESS---"); Serial.print("Brightness: "); Serial.println(value); } countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; } if ( millis() > delayed ) { delayed = millis() + frameTime - 11; uint8_t r, g, b, w; //r = map(countFrameNeon*255./totalFrames, 0, 255, startRed, endRed); r = red(color)*value/255.; g = green(color)*value/255.; b = blue(color)*value/255.; w = white(color)*value/255.; setAll(r, g, b, w); splitStrip(); showStrip(); // para millis() durante 4.5 ms if (syncNeon) { if(w){ // si llega blanco configurar como natura white calibrado r = 255; g = 120; b = 40; w = 40; // solo en PCB con salida azul estropeada } analogWrite(RED, r); analogWrite(GREEN, g); analogWrite(BLUE, b); analogWrite(WHITE, b); // parche para el azul que no funciona } } } //void fadePixel(byte red, byte green, byte blue, byte white, int mode, int fadeTime, int frameTime) // mode 0 = fadeIn, mode 1 = fadeOut void fadePixel(uint32_t color, int mode, int fadeTime, int frameTime) // mode 0 = fadeIn, mode 1 = fadeOut { if ( millis() > delayed ) { delayed = millis() + frameTime - 11 ; // compensacion de bloqueo de millis float r, g, b, w; float totalFrames = fadeTime / frameTime; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { 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++; pixelOn = true; if (!mode) // FADE IN { // r = neopix_gamma[(byte)(red*countFrame / totalFrames)]; // g = neopix_gamma[(byte)(green*countFrame / totalFrames)]; // b = neopix_gamma[(byte)(blue*countFrame / totalFrames)]; // w = neopix_gamma[(byte)(white*countFrame / totalFrames)]; r = neopix_gamma[(byte)(255.*countFrame / totalFrames)]*endRed/255.; g = neopix_gamma[(byte)(255.*countFrame / totalFrames)]*endGreen/255.; b = neopix_gamma[(byte)(255.*countFrame / totalFrames)]*endBlue/255.; w = neopix_gamma[(byte)(255.*countFrame / totalFrames)]*endWhite/255.; } else { r = neopix_gamma[(byte)(255.*(totalFrames - countFrame) / totalFrames)]*endRed/255.; g = neopix_gamma[(byte)(255.*(totalFrames - countFrame) / totalFrames)]*endGreen/255.; b = neopix_gamma[(byte)(255.*(totalFrames - countFrame) / totalFrames)]*endBlue/255; w = neopix_gamma[(byte)(255.*(totalFrames - countFrame) / totalFrames)]*endWhite/255.; } //Serial.println(w); setAll(r, g, b, w); splitStrip(); showStrip(); // para millis() durante 4.5 ms } else pixelOn = false; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea } } void fadePixelRainbow(uint32_t initColor, uint32_t endColor, int mode, int fadeTime, int frameTime) // mode 0 = fadeIn, mode 1 = fadeOut { if ( millis() > delayed ) { delayed = millis() + frameTime - 11 ; // compensacion de bloqueo de millis uint8_t r, g, b, w; float totalFrames = fadeTime / frameTime; byte endRed = red(endColor); byte endGreen = green(endColor); byte endBlue = blue(endColor); byte endWhite = white(endColor); byte initRed = red(initColor); byte initGreen = green(initColor); byte initBlue = blue(initColor); byte initWhite = white(initColor); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { if (!mode) Serial.println("---FADEIN RAINBOW---"); else Serial.println("---FADEOUT RAINBOW---"); 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; incRed = (endRed-initRed)/300.; incGreen = (endGreen-initGreen)/300.; incBlue = (endBlue-initBlue)/300.; incWhite = (endWhite-initWhite)/300.; } if (countFrame < totalFrames) { countFrame++; pixelOn = true; if (!mode) // FADE IN { for ( int i = 0; i < NUMPIXELS1 ; i++) { // redTemp = initRed + incRed*i; // greenTemp = initGreen + incGreen*i; // blueTemp = initBlue + incBlue*i; // whiteTemp = initWhite + incWhite*i; r = (countFrame / totalFrames) * (initRed + incRed*i) ; g = (countFrame / totalFrames) * (initGreen + incGreen*i); b = (countFrame / totalFrames) * (initBlue + incBlue*i); w = (countFrame / totalFrames) * (initWhite + incWhite*i); //r = neopix_gamma[(byte)(redTemp*countFrame/totalFrames)]; //g = neopix_gamma[(byte)(greenTemp*countFrame/totalFrames)]; //b = neopix_gamma[(byte)(blueTemp*countFrame/totalFrames)]; //w = neopix_gamma[(byte)(whiteTemp*countFrame/totalFrames)]; setPixel(i, r, g, b, w); // white is saturation } } else { for ( int i = 0; i < NUMPIXELS1 ; i++) { // redTemp = initRed + incRed*i; // greenTemp = initGreen + incGreen*i; // blueTemp = initBlue + incBlue*i; // whiteTemp = initWhite + incWhite*i; r = ((totalFrames - countFrame) / totalFrames) * (initRed + incRed*i) ; g = ((totalFrames - countFrame) / totalFrames) * (initGreen + incGreen*i) ; b = ((totalFrames - countFrame) / totalFrames) * (initBlue + incBlue*i) ; w = ((totalFrames - countFrame) / totalFrames) * (initWhite + incWhite*i); setPixel(i, r, g, b, w); // white is saturation } // 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; } splitStrip(); showStrip(); // para millis() durante 4.5 ms } else pixelOn = false; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea } } void fadePixelColor(uint32_t color, 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 { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; // compensacion de bloqueo de millis int r, g, b, w; float totalFrames = fadeTime / frameTime; static uint32_t colorRead[NUMPIXELS1]; static float colorRedTemp[NUMPIXELS1]; static float colorGreenTemp[NUMPIXELS1]; static float colorBlueTemp[NUMPIXELS1]; static float colorWhiteTemp[NUMPIXELS1]; static float colorIncRed[NUMPIXELS1]; // int porque puede ser positivo o negativo el incremento static float colorIncGreen[NUMPIXELS1]; static float colorIncBlue[NUMPIXELS1]; static float colorIncWhite[NUMPIXELS1]; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { 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 < NUMPIXELS1 ; i++) { colorRead[i] = pixels1.getPixelColor(i); //endRed = red(hueWeel(hueDest)); //endGreen = green(hueWeel(hueDest)); //endBlue = blue(hueWeel(hueDest)); colorIncRed[i] = (endRed-red(colorRead[i]))/totalFrames; // ojo, puede ser positivo o negativo!!!!! colorIncGreen[i] = (endGreen-green(colorRead[i]))/totalFrames; colorIncBlue[i] = (endBlue-blue(colorRead[i]))/totalFrames; colorIncWhite[i] = (endWhite-white(colorRead[i]))/totalFrames; colorRedTemp[i] = red(colorRead[i]); colorGreenTemp[i] = green(colorRead[i]); colorBlueTemp[i] = blue(colorRead[i]); colorWhiteTemp[i] = white(colorRead[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++; pixelOn = true; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea for ( int i = 0; i < NUMPIXELS1 ; i++) { //colorRedTemp[i] = map(countFrame*255./totalFrames, 0, 255, red(colorRead[i]), endRed); colorRedTemp[i] = colorRedTemp[i] + colorIncRed[i]; //colorGreenTemp[i] = map(countFrame*255./totalFrames, 0, 255, green(colorRead[i]), endGreen); colorGreenTemp[i] = colorGreenTemp[i] + colorIncGreen[i]; //colorBlueTemp[i] = map(countFrame*255./totalFrames, 0, 255, blue(colorRead[i]), endBlue); colorBlueTemp[i] = colorBlueTemp[i] + colorIncBlue[i]; colorWhiteTemp[i] = colorWhiteTemp[i] + colorIncWhite[i]; //setPixel(i, colorRedTemp[i], colorGreenTemp[i], colorBlueTemp[i], 0); // white is saturation setPixel(i, (byte)colorRedTemp[i], (byte)colorGreenTemp[i], (byte)colorBlueTemp[i], colorWhiteTemp[i]); // white is saturation } splitStrip(); showStrip(); // para millis() durante 4.5 ms } else pixelOn = false; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL BAR ////////////////////// ////////////////////////////////////////////////////////////////// void pixelBar(uint32_t color, int pixelInit, int pixelEnd, int loopTime, int frameTime) { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; int pixelPos = 0; float r, g, b, w; float totalFrames = loopTime / frameTime; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { 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; } //Serial.print("Time: "); //Serial.println( millis() - launchTime ); //if (millis() - launchTime < inTime) if (countFrame < totalFrames) { countFrame++; pixelOn = true; if (pixelInit < pixelEnd) // SENTIDO UP { pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); for ( int i = pixelInit; i < pixelPos ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); } else // SENTIDO DOWN { pixelPos = pixelInit - (1 - (totalFrames - countFrame) / totalFrames) * (pixelInit - pixelEnd); for ( int i = pixelInit; i >= pixelPos ; i--) setPixel(i, endRed, endGreen, endBlue, endWhite); } splitStrip(); showStrip(); // para millis() durante 4.5 ms } else pixelOn = false; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea } } ////////////////////////////////////////////////////////////////// /////////////////////// SCANNER ///////////////////// ////////////////////////////////////////////////////////////////// void scanner(uint32_t color, int mode, int pixelInit, int pixelEnd, int pixelWidth, int loopTime, int frameTime) // MODE 0 = BAR, MODE 1 = BARRIDO SCAN { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; int pixelPos; float r, g, b, w; float totalFrames = loopTime / frameTime; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { 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 (countFrame < totalFrames) { countFrame++; pixelOn = true; if (pixelInit < pixelEnd) // SENTIDO UP { pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); if(!mode) // si es modo es 0, no se borra. PixelBAR setAll(0, 0, 0, 0); for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); } else // SENTIDO DOWN { pixelPos = pixelInit - (1 - (totalFrames - countFrame) / totalFrames) * (pixelInit - pixelEnd); if(!mode) // si es modo es 0, no se borra. PixelBAR setAll(0, 0, 0, 0); for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); } splitStrip(); showStrip(); // para millis() durante 4.5 ms } else pixelOn = false; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea } } ////////////////////////////////////////////////////////////////// /////////////////////// METEORITO //////////////////// ////////////////////////////////////////////////////////////////// void meteorRain(uint32_t color, boolean meteorRandomDecay, byte meteorTrailDecay, int pixelInit, int pixelEnd, int pixelWidth, int loopTime, int frameTime) { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; int pixelPos; float r, g, b, w; float totalFrames = loopTime / frameTime; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---METEOR---"); 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; setAll(0, 0, 0, 0); } for (int j = 0; j < NUMPIXELS1; j++) { if( (!meteorRandomDecay) || (random(10)>5) ) { fadeToBlack(j, meteorTrailDecay ); } } if (countFrame < totalFrames) { countFrame++; pixelOn = true; if (pixelInit < pixelEnd) // SENTIDO UP { pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); } else { pixelPos = pixelInit - (1 - (totalFrames - countFrame) / totalFrames) * (pixelInit - pixelEnd); for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); } } else pixelOn = false; // flag para que el NEON sepa cuando hay una funcion de pixel simultanea splitStrip(); showStrip(); // para millis() durante 4.5 ms } } ////////////////////////////////////////////////////////////////// /////////////////////// CENTER TO OUT //////////////////// ////////////////////////////////////////////////////////////////// void centerToOut(uint32_t color, int mode, int pixelWidth, int loopTime, int frameTime) // mode define si es solido o scanner { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; int pixelPos; float r, g, b, w; float totalFrames = loopTime / frameTime; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---CENTER TO OUT---"); 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; setAll(0, 0, 0, 0); } if (countFrame < totalFrames) { countFrame++; pixelOn = true; //pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); if(!mode) setAll(0, 0, 0, 0); pixelPos = NUMPIXELS1/2 + (1 - (totalFrames - countFrame) / totalFrames) * NUMPIXELS1/2; for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); pixelPos = ((totalFrames - countFrame) / totalFrames) * NUMPIXELS1/2; for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); splitStrip(); showStrip(); // para millis() durante 4.5 ms } else { if(!mode) { setAll(0, 0, 0, 0); splitStrip(); showStrip(); // para millis() durante 4.5 ms } pixelOn = false; } } } ////////////////////////////////////////////////////////////////// /////////////////////// OUT TO CENTER //////////////////// ////////////////////////////////////////////////////////////////// void outToCenter(uint32_t color, int mode, int pixelWidth, int loopTime, int frameTime) // mode define si es solido o scanner { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; int pixelPos; float r, g, b, w; float totalFrames = loopTime / frameTime; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---OUT TO CENTER---"); 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; setAll(0, 0, 0, 0); } if (countFrame < totalFrames) { countFrame++; pixelOn = true; //pixelPos = pixelInit + (1 - (totalFrames - countFrame) / totalFrames) * (pixelEnd - pixelInit); if(!mode) setAll(0, 0, 0, 0); pixelPos = NUMPIXELS1 - (1 - (totalFrames - countFrame) / totalFrames) * NUMPIXELS1/2; for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); pixelPos = (1 - (totalFrames - countFrame) / totalFrames) * NUMPIXELS1/2; for ( int i = pixelPos - (pixelWidth / 2); i < pixelPos + (pixelWidth / 2) ; i++) setPixel(i, endRed, endGreen, endBlue, endWhite); splitStrip(); showStrip(); // para millis() durante 4.5 ms } else { if(!mode) { setAll(0, 0, 0, 0); splitStrip(); showStrip(); // para millis() durante 4.5 ms } pixelOn = false; } } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL STROBO //////////////////// ////////////////////////////////////////////////////////////////// void stroboPixel(uint32_t color, int stroboTime, int stroboPwm, int numFlash, bool syncNeon) { if ( millis() > delayed ) { byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { countFrame = 0; stroboPixelFlag = 0; stroboPixelOn = true; pixelFlag = true; if (DEBUG) { Serial.println("---PIXEL STROBO---"); Serial.print("strobo Period: "); Serial.println(stroboTime); Serial.print("PWM: "); Serial.println(stroboPwm); Serial.print("Flashes: "); Serial.println(numFlash); } } if (stroboPixelOn) { if ( !stroboPixelFlag ) { delayed = millis() + (stroboTime * stroboPwm / 100) - 11 ; // 11ms de compensacion del showstrip stroboPixelFlag = 1; setAll(endRed, endGreen, endBlue, endWhite); splitStrip(); showStrip(); if (syncNeon) { if(endWhite){ // si llega blanco configurar como natura white calibrado endRed = 255; endGreen = 120; endBlue = 40; endWhite = 40; // solo en PCB con salida azul estropeada } analogWrite(RED, endRed); analogWrite(GREEN, endGreen); analogWrite(BLUE, endBlue); analogWrite(WHITE, endBlue); // parche para el neon estropeado } } else { delayed = millis() + (stroboTime * (100 - stroboPwm) / 100) - 11 ; // 11ms de compensacion del showstrip setAll(0, 0, 0, 0); splitStrip(); showStrip(); if (syncNeon) { analogWrite(RED, 0); analogWrite(GREEN, 0); analogWrite(BLUE, 0); analogWrite(WHITE, 0); } countFrame++; if (countFrame < numFlash) stroboPixelFlag = 0; // otro flash mas! else { stroboPixelFlag = 1; // stop flash stroboPixelOn = false; // stop neon } } } } } void stroboRandomColor(int stroboTime, int stroboPwm, int numFlash, int syncNeon) { if (!pixelFlag) { countFrame = 0; stroboPixelFlag = 0; stroboPixelOn = true; pixelFlag = true; if (DEBUG) { 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 ( !stroboPixelFlag ) { delayed = millis() + (stroboTime * stroboPwm / 100) - 11 ; // 11ms de compensacion del showstrip stroboPixelFlag = 1; int hueRandom = random(255); for(int i=0; i < NUMPIXELS1 ; i++) setPixel(i, red(hueWeel(hueRandom)), green(hueWeel(hueRandom)), blue(hueWeel(hueRandom)), 0 ) ; splitStrip(); showStrip(); if (syncNeon) { analogWrite(RED, red(hueWeel(hueRandom))); analogWrite(GREEN, green(hueWeel(hueRandom))); analogWrite(BLUE, blue(hueWeel(hueRandom))); analogWrite(WHITE, blue(hueWeel(hueRandom))); // canal estropeado } } else { delayed = millis() + (stroboTime * (100 - stroboPwm) / 100) - 11 ; // 11ms de compensacion del showstrip setAll(0, 0, 0, 0); splitStrip(); showStrip(); if (syncNeon) { analogWrite(RED, 0); analogWrite(GREEN, 0); analogWrite(BLUE, 0); analogWrite(WHITE, 0); } countFrame++; if (countFrame < numFlash) stroboPixelFlag = 0; // otro flash mas! else { stroboPixelFlag = 1; // stop flash stroboPixelOn = false; // stop neon } } } } } ////////////////////////////////////////////////////////////////// /////////////////////// PIXEL FIRE ////////////////////// ////////////////////////////////////////////////////////////////// void fire(int Cooling, int Sparking, int frameTime) { if (!pixelFlag) { pixelFlag = true; if (DEBUG) { 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[NUMPIXELS1]; int cooldown; // Step 1. Cool down every cell a little for ( int i = 0; i < NUMPIXELS1 ; i++) { cooldown = random(0, ((Cooling * 10) / NUMPIXELS1) + 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 = NUMPIXELS1 - 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 < NUMPIXELS1; j++) { setPixelHeatColor(j, heat[j] ); } splitStrip(); 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); } } ////////////////////////////////////////////////////////////////// /////////////////////// RANDOMS PIXEL /////////////////// ////////////////////////////////////////////////////////////////// void randomPixel(uint32_t color, int totalFrames, int frameTime, int density, boolean onlyOne) { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---RANDOM PIXEL---"); Serial.print("totalFrames: "); Serial.println(totalFrames); } countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; setAll(0, 0, 0, 0); } if (countFrame < totalFrames) { countFrame++; pixelOn = true; for(int i=0; i < density ; i++) setPixel(random(NUMPIXELS1), endRed, endGreen, endBlue, endWhite); splitStrip(); showStrip(); // para millis() durante 4.5 ms if(!onlyOne) setAll(0, 0, 0, 0); } else{ setAll(0, 0, 0, 0); pixelOn = false; splitStrip(); showStrip(); // para millis() durante 4.5 ms } } } void randomInvert(uint32_t color, int size, int totalFrames, int frameTime, int density, boolean onlyOne) { if ( millis() > delayed ) { delayed = millis() + frameTime - 11; byte endRed = red(color); byte endGreen = green(color); byte endBlue = blue(color); byte endWhite = white(color); if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---RANDOM INVERT---"); Serial.print("totalFrames: "); Serial.println(totalFrames); } countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; setAll(endRed, endGreen, endBlue, endWhite); } if (countFrame < totalFrames) { countFrame++; pixelOn = true; for(int i=0; i < density ; i++){ int pixelRandom = random(NUMPIXELS1); for(int j=0; j delayed ) { delayed = millis() + frameTime - 11; if (!pixelFlag) { launchTime = millis(); if (DEBUG) { Serial.println("---RANDOM COLOR---"); Serial.print("totalFrames: "); Serial.println(totalFrames); } countFrame = 0; // RESET DE VARIABLES ANTES DE ARRANCAR pixelFlag = true; setAll(0, 0, 0, 0); } if (countFrame < totalFrames) { countFrame++; pixelOn = true; int hueRandom = random(255); for(int i=0; i < NUMPIXELS1 ; i++) setPixel(i, red(hueWeel(hueRandom)), green(hueWeel(hueRandom)), blue(hueWeel(hueRandom)), 0 ) ; splitStrip(); showStrip(); // para millis() durante 4.5 ms } else{ setAll(0, 0, 0, 0); pixelOn = false; splitStrip(); showStrip(); // para millis() durante 4.5 ms } } } // void SnowSparkle(byte red, byte green, byte blue, byte white, int SparkleDelay, int SpeedDelay) { // setAll(red, green, blue, white); // int Pixel = random(NUMPIXELS1); // 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 < NUMPIXELS1 * 2; i++) // { // Position++; // = 0; //Position + Rate; // for (int i = 0; i < NUMPIXELS1; 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 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 < NUMPIXELS1; i = i + 3) { // setPixel(i + q, red, green, blue, white); //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 // } // } // } // } // 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 // } // } // } // }