Hechos a mano accionado Arduino RGB Moodlamp (5 / 7 paso)

Paso 5: El código:

Mi código es sólo una combinación difícil de su código de proyecto.
"RGBMoodlight", "RGBPotMixer"
y algunas extensiones.
Tres análogos de y.
digital en como selector de modo (gracias a Ju por la rutina de interrupción :).
Los LEDs están conectados a D9, D10 y D11, que PulseWithModulation.

Si lo desea, puedo publicar el bosquejo, pero es una combinación realmente desnuda de estas dos grandes códigos.

Aquí está mi código original de la lámpara.
Se ve un poco desordenado, porque era mi etapa muy temprana en la programación...
Pero si copiarlo, debería funcionar muy bien.

Hay paces finas, como el "PotColorMixer", "RGBfadingFunction" y la rutina de interrupción para el conmutador de modo.

/ * nejo June2008

• Código para mi "Moodlamp", basada en "dimmingLEDs" de Clay Shirky < clay.shirky

* nejo Sep2008

• Código final para el moodlamp con el interruptor de modo de interrupción, marcación analógica para desvanecimiento de RGB y RGB color cambio.
• La función de regulación funciona sólo para el color blanco

* nejo October2008

• Extensión de sonido para el moodlamp:
• Un micrófono de condensador con un pequeño amplificador de LM368, un más recifier y un filtro RC-low-pass
• con otro analogInput usar la función RGBPotMixer para cambiar el color haciendo la señal de micrófono.

*
*
* Código de fundido cruzado 3 LEDs, rojo, verde y azul o LED tri-color, utilizando PWM

• El programa Cruz-se descolora lentamente de rojo a verde, verde y azul, azul rojo
• El código de depuración asume Arduino 0004, ya que utiliza el nuevo Serial.begin ()-funciones del estilo
• originalmente "dimmingLEDs" por Clay Shirky < clay.shirky

*

• AnalogRead está habilitada en el Pin A0 para variar la velocidad de decoloración de RGB
• AnalogRead está habilitado el Pin A2 para variar el color de hueRGB

*
*
*/

#include < avr/interrupt.h >
Salida
int ledPin = 13; controlPin para la depuración
redPin int = 9; LED rojo, conectado al pin digital 9
int greenPin = 10; LED verde, conectado al pin digital 10
bluePin int = 11; LED azul, conectado al pin digital 11

int dimredPin = 3; Pins para el análogo valor, conectado al conductor de transistor de regulación
int dimgreenPin = 5;
int dimbluePin = 6;

Entrada
int switchPin = 2; conmutador está conectado al pin D2
int val = 0; variable para lectura del estado del pin
int buttonState; variable que contenga el estado del botón
int buttonPresses = 0; 3 Prensas para ir!
int potPin0 = 0; Olla para ajustar el retardo entre que se descolora en Moodlamp;
int potPin2 = 2; Salida del potenciómetro para cambiar el color de hueRGB
int potVal = 0; Variable para almacenar la entrada desde el potenciómetro
int maxVal = 0; valor para salvar el defecto de factor atenuación es 255, si no Pot está conectado
int dimPin = 4; Pote conectado a A4 para atenuar el brillo

Variables de programa
int redVal = 255; Variables para almacenar los valores para enviar a los pasadores
greenVal int = 1; Valores iniciales son full rojo, verde y azul de
int blueVal = 1;

int i = 0; Contador de bucle
int espera; / / = 15; retraso de 50ms (.05 segundo); acortar para se desvanece más rápido
int k = 0; valor para el control de la función de abrir y cerrar
int DEBUG = 0; DEPURACIÓN de contador; Si establece en 1, escribir valores detrás vía serie
int LCD = 0; Contador LCD; Si establece en 1, escribir valores detrás vía serie

void setup()
{
pinMode (ledPin, salida);
pinMode (redPin, salida); define los pines como salida
pinMode (greenPin, salida);
pinMode (bluePin, salida);
pinMode(dimredPin,OUTPUT);
pinMode(dimgreenPin,OUTPUT); define los pines como salida
pinMode(dimbluePin,OUTPUT);
pinMode (potPin2, entrada); //
pinMode (potPin0, entrada); //
pinMode (dimPin, entrada); //
pinMode (switchPin, entrada); Configurar el pin de interruptor como entrada
attachInterrupt(0,isr0,RISING);

Si (depurar) {/ / si queremos ver los valores del pin para la depuración...
Serial.Begin(9600); ... fijó hasta la salida serial en estilo 0004
}
}

Principal del programa
void loop()
{

Si (buttonPresses == 0) {}
Moodlamp(); llama a la función Moodlight
}
Si (buttonPresses == 1) {}
RGBPotMixer(); llama a la función de mezcla de manuel
}
Si (buttonPresses == 2) {}

White(); Es todo blanco aquí
}
Si (buttonPresses == 3) {}

}

Moodlamp();
RGBPotMixer();
White();

Monitor();
DIM();
}
void Monitor() {/ estado, enviar al monitor

Si (depurar) {/ / si queremos leer la salida
DEPURAR += 1; Incrementar el contador de depuración
Si (depurar > 10) {/ / imprime cada 10 lazos
DEBUG = 1; El contador de
Serial.Print(i); Comandos serie estilo 0004
Serial.Print("\t"); Imprimir una ficha de
Serial.Print("R:"); Indican que la salida es valor rojo
Serial.Print(redVal); Imprimir valor rojo
Serial.Print("\t"); Imprimir una ficha de
Serial.Print("G:"); Repita para verde y azul...
Serial.Print(greenVal);
Serial.Print("\t");
Serial.Print("B:");
Serial.Print(blueVal); println, para terminar con un retorno de carro
Serial.Print("\t");
Serial.Print("dimValue:");
Serial.Print(maxVal); println, para terminar con un retorno de carro
Serial.Print("\t");
Serial.Print("Wait:");
Serial.Print(Wait); escribe el valor de la potPin0 en el monitor
Serial.Print("\t");
Serial.Print("hueRGBvalue");
Serial.Print(potVal); escribe el valor de la potPin0 en el monitor
Serial.Print("\t");
Serial.Print("buttonState:");
Serial.Print(buttonState); escribe el valor de la potPin0 en el monitor
Serial.Print("\t");
Serial.Print("buttonPresses:");
Serial.println(buttonPresses); escribe el valor de la buttonPresses en el monitor

}
}
}

void dim() / / función para la regulación blanco / / tal vez más adelante para todos los modos
{
maxVal = analogRead(dimPin);
maxVal = 4; Escala analógica de 0..1024--> demasiado para amortiguar el valor 0..255
analogWrite(dimredPin,maxVal);
analogWrite(dimgreenPin,maxVal);
analogWrite(dimbluePin,maxVal);

}

void Moodlamp()
{
esperar = analogRead(potPin0); Busque el valor de la potPin0;
Si no Pot está conectado: esperar 255

i += 1; Contador de incremento
i = i - maxVal;
Si (i < 255) / / primera fase de fusiones
{
redVal-= 1; Rojo hacia abajo
greenVal += 1; Verde para arriba
blueVal = 1; Baja azul
}
else if (< 509) / / segunda fase de fusiones
{
redVal = 1; Rojo bajo
greenVal-= 1; Verde abajo
blueVal += 1; Arriba azul
}
else if (< 763) / / tercera fase de transiciones
{
redVal += 1; Rojo hasta
greenVal = 1; Lo2 verde
blueVal-= 1; Abajo azul
}
Else / / volver a poner el contador, y reactivar los fundidos
{
i = 1;
}

hacemos "255-redVal" en lugar de simplemente "redVal" porque el
LEDs están enganchados a + 5V en vez de tierra

analogWrite (redPin, 255 - redVal); Escribir valores actuales a los pines del LED
analogWrite (greenPin, 255 - greenVal);
analogWrite (bluePin, 255 - blueVal);

/ * dimredVal = min (redVal - maxVal, 255); atenuación
dimredVal = max (redVal - maxVal, 0);
dimgreenVal = min (greenVal - maxVal, 255);
dimgreenVal = max (greenVal - maxVal, 0);
dimblueVal = min (blueVal - maxVal, 255);
dimblueVal = max (blueVal - maxVal, 0);

analogWrite (redPin, 255 - dimredVal); Escribir valores actuales a los pines del LED
analogWrite (greenPin, 255 - dimgreenVal);
analogWrite (bluePin, 255 - dimblueVal);
*/

esperar / = 4;
Delay(Wait); Pausa para 'esperar' milisegundos antes de reanudar el lazo

}

void RGBPotMixer()
{
potVal = analogRead(potPin2); leer el valor del potenciómetro en la entrada de pin
potVal = potVal / 4; convertir de 0-1023 a 0-255

hue_to_rgb (potVal); potVal como tono y convertir a rgb vals

"255-" es porque tenemos LEDs de ánodo común, no común-cátodo
analogWrite (redPin, 255-redVal); Escribir valores en los pines del LED
analogWrite (greenPin, 255-greenVal);
analogWrite (bluePin, 255-blueVal);

}

void White() {}
analogWrite (redPin, maxVal); Escribir valores en los pines del LED
analogWrite (greenPin, maxVal);
analogWrite (bluePin, maxVal);
}

/*

• Dado una tonalidad variable 'h', que va desde 0-252,
• establecer adecuadamente el valor de color RGB.
• Asume maxValimum máximo valor (luminosidad) y saturación
• Realiza puramente matemáticas de entero, sin punto flotante.

*/
void hue_to_rgb(byte hue)
{
Si hue (matiz > 252) = 252; stetback a 252! Nejo
byte hd = tono / 42; 36 == 252/7, 252 == H_MAX
byte Hola = hd % 6; da de 0-5
f bytes = hue % 42;
byte fs = f * 6;
interruptor (Hola) {}
caso 0:
redVal = 252; greenVal = fs. blueVal = 0;
rotura;
caso 1:
redVal = 252-fs. greenVal = 252; blueVal = 0;
rotura;
caso 2:
redVal = 0; greenVal = 252; blueVal = fs.
rotura;
caso 3:
redVal = 0; greenVal = 252-fs. blueVal = 252;
rotura;
caso 4:
redVal = fs. greenVal = 0; blueVal = 252;
rotura;
caso 5:
redVal = 252; greenVal = 0; blueVal = 252-fs.
rotura;
}
}
void isr0() {}
Serial.println ("\n \n inerrupt \n");

buttonState = digitalRead(switchPin); Lee el estado inicial
delayMicroseconds(100000);
Si (val! = buttonState) {/ / el estado de botón ha cambiado!

Si (buttonState == HIGH) {/ / comprobar si ahora se pulsa el botón
buttonPresses ++;

// }
Val = buttonState; guardar el nuevo estado en nuestra variable
Si (buttonPresses == 3) {/ / zur cksetzen
buttonPresses = 0;
}
}

// }

Siguiente etapa eran los drivers de transistor. Usé 3 transistores PNP con una corriente máxima de 3 amperios. Después adelante-corriente y voltaje se regulación, el LEDemitter funcionó muy bien con toda intensidad.