#include
#ifdef __AVR__
#include // Requerido para Adafruit Trinket de 16 MHz.
#endif

// Pin de E
// Resistor de pull-up para que el interruptor tire del pin a tierra momentáneamente.
// En una transición de alto a bajo, la lógica de presión del botón se ejecutará.
#define BUTTON_PIN 2

#define PIXEL_PIN 6 // Pin de E

#define PIXEL_COUNT 81 // Número de NeoPixels

// Declare nuestro objeto de tira NeoPixel:
Tira Adafruit_NeoPixel (PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);


// Argumento 3 = banderas de tipo de píxel, añádalas juntas según sea necesario:

// NEO_KHZ400 400 KHz (píxeles FLORA clásicos 'v1' (no v2), controladores WS2811)
// Los píxeles NEO_GRB están cableados para el flujo de bits GRB (la mayoría de los productos NeoPixel).
// Los píxeles NEO_RGB están cableados para el flujo de bits RGB (píxeles FLORA v1, no v2).
// Los píxeles NEO_RGBW están cableados para el flujo de bits RGBW (productos NeoPixel RGBW)
int numPixels = 81;
booleano oldState = ALTO;
booleano oneTime = BAJO;
Int modo = 0; // Modo de animación actualmente activo, 0-9
int numOfMode = 4; // x-1
int oldMode = numOfMode + 1;
long button_pressed = 0;
Booleano presionado = BAJO;
Intensidad de brillo = 254;
//Gestiona la luminosidad.
Booleano getDark = BAJO;

void setup() {
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
strip.begin(); // Inicializa el objeto de tira NeoPixel (REQUERIDO)
strip.setBrightness(brithness);
strip.show(); // Inicializa todos los píxeles a 'apagados'
}

void loop() {
// Obtener el estado actual del botón.
booleano nuevoEstado = digitalRead(PIN_DE_BOTÓN);

// Comprobar si el estado ha cambiado de BAJO a ALTO (pulsación del botón).
si ((nuevoEstado == ALTO) y (viejoEstado == BAJO)) {
// Retraso corto para desactivar el botón.
retraso(20);
// Comprobar si el botón sigue estando bajo después del debounce.
newState = digitalRead(BUTTON_PIN);
si (nuevo estado == ALTO) { // Sí, todavía ALTO
//Comenzar a analizar si es una pulsación larga o una pulsación corta.
button_pressed = millis();
presionado = ALTO;
}
}
//si se presionó, analiza.
si (pressed == ALTO) {
//obtener la hora del sistema
int time_system = millis();
//calcular el tiempo de presión
int pressed_time = time_system - button_pressed;

si ((nuevoEstado == BAJO) y (tiempoPresionado <= 1000)) {
++modo;
si (modo > numOfMode) {
modo = 0; // Avanza al siguiente modo, repite desde el principio después del #8
}
//Si la lámpara está apagada, el siguiente toque la activará de nuevo.
si (brillo == 0){
modo = 0;
Brillo = 254;
strip.setBrightness(brithness);
strip.show();

}
//desactivar el análisis de prensa
presionado = BAJO;

}else if ((newState == HIGH) && (pressed_time > 1000) && (brithness > 0)){
//Hacerlo más oscuro o más brillante.
si (getDark == ALTO) {
brillantez = strip.getBrightness();
si (brillo < 254) {
brithness = brithness + 1;
si (brillo > 254) {
Brillo = 254;
}
strip.setBrightness(brithness);
strip.show();
}
}else{
brillantez = strip.getBrightness();
si (brillo > 0){
brillantez = brillantez - 1;
si (brillo < 0) {
Brillo = 0;
}
si (brillo == 0){
//El strip está apagado.
modo = -1;
presionado = BAJO;
}
strip.setBrightness(brithness);
strip.show();
}
}
}else if ((newState == LOW) && (pressed_time > 1000) && (brithness > 0)) {
//Gestiona el estado después de accionar el interruptor de luz o de oscuridad.
getDark = !getDark;
//desactivar el análisis de prensa
presionado = BAJO;
}
}
Serial.println(modo);
si (oldMode != mode) {
OneTime = ALTO;
} else {
OneTime = BAJO;
}
si (modo == 4) {
arcoíris(2, oneTime);
}
si (modo == 3) {
colorWipe(strip.Color( 0, 255, 0), 10, oneTime);
}
si (modo == 2) {
colorWipe(strip.Color( 255, 0, 255), 10, oneTime);
}
si (modo == 1) {
colorWipe(strip.Color( 0, 255, 255), 10, oneTime);
}
si (modo == 0) {
colorWipe(strip.Color( 255, 255, 255), 10, oneTime);
}
si (modo == -1) {
colorWipe(strip.Color( 0, 0, 0), 10, oneTime);
}
// Establece el estado del botón de última lectura al estado anterior.
oldState = newState;
oldMode = modo;
delay(5);
}

// primero; cualquier cosa allí será cubierta píxel por píxel. Pasa el color.
// (como un único valor de 32 bits 'empaquetado', que puedes obtener llamando a
// strip.Color(rojo, verde, azul) como se muestra en la función loop() anterior.
// y un tiempo de retraso (en milisegundos) entre píxeles.
int i = 0;
void colorWipe(uint32_t color, int wait, boolean oneTime) {
si (oneTime == ALTO) {
i = 0;
}
si (i < numPixels) {
//añade un píxel más

strip.setPixelColor(i, color); // Establece el color del píxel (en la RAM)
strip.show(); // Actualiza la tira para que coincida.
++i;
delay(wait); // Pausa por un momento.
}
}

largo firstPixelHue = 0;

void rainbow(int wait, boolean oneTime) {
si (oneTime == ALTO) {
primerPixelHue = 0;
i = 0;
}
si (firstPixelHue < 3 * 65536) {
si (i < numPixels) {

// Desplaza el tono de los píxeles en una cantidad para hacer una revolución completa del <en> /
// Rueda de colores (rango de 65536) a lo largo de la longitud de la tira.
// (pasos de strip.numPixels()):
int pixelHue = firstPixelHue + (i * 65536L / 500);
// strip.ColorHSV() puede tomar 1 o 3 argumentos: un tono (de 0 a 65535) o
// Opcionalmente, agregue saturación y valor (brillo) (cada uno de 0 a 255).
// Aquí estamos usando solo la variante de tono de un solo argumento. El resultado
// se pasa a través de strip.gamma32() para proporcionar colores 'más reales'.
// antes de asignar a cada píxel:
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
++i;
}else{
i = 0;
}
firstPixelHue += 256;
strip.show(); // Actualiza la tira con nuevos contenidos.
delay(wait); // Pausa por un momento.
}else{
primerPixelHue = 0;
}
}