miguel/Lab_interaccio
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
Lab_interaccio/2018/LLAC-RX-FastLed/LLAC-RX-FastLed.ino

1495 lines
40 KiB
Arduino
Raw Permalink Normal View History

second commit
2025-02-25 21:29:42 +01:00
#include <SPI.h>
#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<SK6812, DATA_PIN_1>(ledsRGB, 0, getRGBWsize(NUM_LEDS)/2);
FastLED.addLeds<SK6812, DATA_PIN_2>(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
// }
// }
// }
// }
Reference in a new issue Copy permalink