Étape 5: Le Code :
J’ai commencé avec « Spooky projets » et « BionicArduino » par TodEKurt il y a quelques mois.
http://todbot.com/blog/spookyarduino/
Mon code est juste une combinaison délicate de son code de projet.
"RGBMoodlight", "RGBPotMixer"
et quelques extensions.
Trois analog-en et.
numérique-en tant que commutateur de mode (Merci:) à Ju. pour la routine d’interruption.
Les LEDs sont connectés à D9, D10 et D11 supportant PulseWithModulation.
Si vous le souhaitez, je peux publier l’esquisse, mais c’est une combinaison vraiment nue de ces deux grands codes.
Voici mon code original de la lampe.
Il ressemble un peu désordonné, parce que c’était mon très en amont dans la programmation...
Mais si vous copiez, il devrait fonctionner à merveille.
Il y a des peaces fines, comme le « PotColorMixer », la « RGBfadingFunction » et la Routine d’interruption pour le commutateur de mode.
/ * nejo juin2008
- Code pour mon « Moodlamp », basé sur « dimmingLEDs » de Clay Shirky < clay.shirky
* nejo Sep2008
- Code final pour le moodlamp avec interruption-commutateur de mode, numérotation analogique RGB-décoloration et couleur RVB changement.
- La fonction de gradation travaille juste pour la couleur blanche
* nejo octobre2008
- Son extension pour le moodlamp :
- Un microphone condenseur avec un petit ampli LM368, un recifier et un filtre RC-bas-pass
- avec un autre analogInput j’utilise la fonction RGBPotMixer pour changer la couleur en obtenant le signal mic.
*
*
* Code pour cross-fading 3 LED, rouge, vert et bleu ou un tri-color LED, à l’aide de PWM
- Le programme de la Croix-s’estompe lentement du rouge au vert, vert, bleu et bleu au rouge
- Le code de débogage suppose Arduino 0004, car il utilise le nouveau () Serial.begin-fonctions de style
- à l’origine « dimmingLEDs » de Clay Shirky < clay.shirky
*
- AnalogRead est activé sur les broches A0 pour faire varier la vitesse de décoloration RGB
- AnalogRead est activé sur la broche A2 pour faire varier la couleur de hueRGB
*
*
*/
#include < avr/interrupt.h >
Sortie
int ledPin = 13 ; controlPin pour le débogage
int redPin = 9 ; DEL rouge, connectée à la broche numérique 9
int greenPin = 10 ; LED vert, connectée à la broche numérique 10
bluePin int = 11 ; LED bleue, connectée à la broche numérique 11
int dimredPin = 3 ; Broches pour l’analogique valeur, connecté au conducteur de transistor de gradation
int dimgreenPin = 5 ;
int dimbluePin = 6 ;
Entrée
int switchPin = 2 ; Switch est connectée à la broche D2
int val = 0 ; variable pour la lecture de l’état de la broche
buttonState int ; variable qui contient l’état du bouton
int buttonPresses = 0 ; 3 presses d’aller !
int potPin0 = 0 ; Pot pour régler le délai entre la décoloration en Moodlamp ;
int potPin2 = 2 ; Sortie de potentiomètre pour changer la couleur de hueRGB
int potVal = 0 ; Variable pour stocker l’entrée de potentiomètre
maxVal int = 0 ; valeur pour enregistrer la valeur par défaut de facteur gradation est 255, si aucun Pot n’est connecté
int dimPin = 4 ; Pot connecté à A4 pour obscurcir la luminosité
Variables de programme
int redVal = 255 ; Variables pour stocker les valeurs d’envoyer aux pins
greenVal int = 1 ; Les valeurs initiales sont plein de rouge, vert et bleu au large
int blueVal = 1 ;
int i = 0 ; Compteur de boucle
int wait; / / = 15 ; retard de 50ms (.05 seconde) ; raccourcir des fondus plus rapides
int k = 0 ; valeur pour les contrôlés dans la fonction blink
int DEBUG = 0 ; DÉBOGUER le compteur ; Si la valeur 1, va écrire des valeurs de retour via serial
int LCD = 0 ; Compteur LCD ; Si la valeur 1, va écrire des valeurs de retour via serial
void setup()
{
pinMode (ledPin, sortie) ;
pinMode (redPin, sortie) ; définit les broches en sortie
pinMode (greenPin, sortie) ;
pinMode (bluePin, sortie) ;
pinMode(dimredPin,OUTPUT) ;
pinMode(dimgreenPin,OUTPUT) ; définit les broches en sortie
pinMode(dimbluePin,OUTPUT) ;
pinMode (potPin2, entrée) ; //
pinMode (potPin0, entrée) ; //
pinMode (dimPin, entrée) ; //
pinMode (switchPin, entrée) ; Régler la tige de l’interrupteur comme entrée
attachInterrupt(0,isr0,RISING) ;
Si (déboguer) {/ / si nous voulons voir les valeurs de code pin pour le débogage...
Serial.Begin(9600) ; .. .set jusqu'à la sortie série style 0004
}
}
Programme principal
void loop()
{
Si (buttonPresses == 0) {}
Moodlamp() ; appelle la fonction Moodlight
}
Si (buttonPresses == 1) {}
RGBPotMixer() ; appelle la fonction de mélange manuel
}
Si (buttonPresses == 2) {}
White() ; Il est tout blanc ici
}
Si (buttonPresses == 3) {}
}
Moodlamp() ;
RGBPotMixer() ;
White() ;
Monitor() ;
Dim() ;
}
void Monitor() {/ / envoyer État au moniteur
Si (déboguer) {/ / si nous voulons lire la sortie
DÉBOGUER += 1 ; Incrémenter le compteur de débogage
Si (Déboguer > 10) {/ / Print tous les 10 boucles
DEBUG = 1 ; Réinitialiser le compteur
Serial.Print(i) ; Commandes série style 0004
Serial.Print("\t") ; Imprimer une étiquette
Serial.Print("R:") ; Indiquent que la sortie est la valeur rouge
Serial.Print(redVal) ; Imprimer la valeur rouge
Serial.Print("\t") ; Imprimer une étiquette
Serial.Print("G:") ; Répétez cette opération pour le vert et le bleu...
Serial.Print(greenVal) ;
Serial.Print("\t") ;
Serial.Print("B:") ;
Serial.Print(blueVal) ; println, se terminent par un retour chariot
Serial.Print("\t") ;
Serial.Print("dimValue:") ;
Serial.Print(MaxVal) ; println, se terminent par un retour chariot
Serial.Print("\t") ;
Serial.Print("Wait:") ;
Serial.Print(Wait) ; écrit la valeur de la potPin0 dans le moniteur
Serial.Print("\t") ;
Serial.Print("hueRGBvalue") ;
Serial.Print(potVal) ; écrit la valeur de la potPin0 dans le moniteur
Serial.Print("\t") ;
Serial.Print("ButtonState:") ;
Serial.Print(ButtonState) ; écrit la valeur de la potPin0 dans le moniteur
Serial.Print("\t") ;
Serial.Print("buttonPresses:") ;
Serial.println(buttonPresses) ; écrit la valeur de la buttonPresses dans le moniteur
}
}
}
void dim() / / fonction de gradation blanc / / peut-être plus tard pour tous les Modes
{
maxVal = analogRead(dimPin) ;
maxVal / = 4 ; Gamme analogique de 0..1024--> trop cher pour la variation de la valeur 0.. 255
analogWrite(dimredPin,maxVal) ;
analogWrite(dimgreenPin,maxVal) ;
analogWrite(dimbluePin,maxVal) ;
}
Sub Moodlamp()
{
attendre = analogRead(potPin0) ; Recherchez la valeur de la potPin0 ;
Si aucun Pot n’est connecté : attendre 255
J’ai += 1 ; Compteur d’incrémentation
i = i - maxVal ;
Si (j’ai < 255) / / la première phase de fondus
{
redVal-= 1 ; Rouge vers le bas
greenVal += 1 ; Vert vers le haut
blueVal = 1 ; Bas bleu
}
ElseIf (j’ai < 509) / / la deuxième phase de fondus
{
redVal = 1 ; Bas rouge
greenVal-= 1 ; Bas verte
blueVal += 1 ; Haut bleu
}
ElseIf (j’ai < 763) / / troisième phase des fades
{
redVal += 1 ; Haut rouge
greenVal = 1 ; Lo2 vert
blueVal-= 1 ; Bas bleu
}
else / / re-régler le compteur, et recommencer les fades
{
i = 1 ;
}
Nous faisons « 255-redVal"au lieu de juste"redVal"parce que le
LED est raccordé à + 5V au lieu de Gnd
analogWrite (redPin, 255 - redVal) ; Écrire les valeurs actuelles aux broches de la LED
analogWrite (greenPin, 255 - greenVal) ;
analogWrite (bluePin, 255 - blueVal) ;
/ * dimredVal = min (redVal - maxVal, 255) ; gradation
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) ; Écrire les valeurs actuelles aux broches de la LED
analogWrite (greenPin, 255 - dimgreenVal) ;
analogWrite (bluePin, 255 - dimblueVal) ;
*/
attendre / = 4 ;
Delay(Wait) ; Faire une pause pour « attendre » millisecondes avant de reprendre la boucle
}
Sub RGBPotMixer()
{
potVal = analogRead(potPin2) ; lire la valeur du potentiomètre à l’entrée pin
potVal = potVal / 4 ; convertir 0-1023 en 0-255
hue_to_rgb (potVal) ; potVal comme teinte et convertir en rgb vals
"255-" est parce que nous avons de commun-anode LEDs, pas à cathode commune
analogWrite (redPin, 255-redVal) ; Écrire des valeurs aux broches de la LED
analogWrite (greenPin, 255-greenVal) ;
analogWrite (bluePin, 255-blueVal) ;
}
void White() {}
analogWrite (redPin, maxVal) ; Écrire des valeurs aux broches de la LED
analogWrite (greenPin, maxVal) ;
analogWrite (bluePin, maxVal) ;
}
/*
- Étant donné une teinte variable « h », qui s’étend de 0-252,
- Définissez la valeur de couleur RVB de manière appropriée.
- Suppose maxValimum Saturation et valeur maximale (luminosité)
- Exécute purement mathématiques d’entier, sans virgule flottante.
*/
Sub hue_to_rgb(byte hue)
{
Si hue (teinte > 252) = 252 ; stetback à 252!! Nejo
octet hd = teinte / 42 ; 36 == 7/252, 252 == H_MAX
octet hi = hd % 6 ; donne 0-5
f octets = teinte % 42 ;
octet fs = f * 6 ;
commutateur (Salut) {}
case 0 :
redVal = 252 ; greenVal = fs ; blueVal = 0 ;
rupture ;
cas 1 :
redVal = 252-fs ; greenVal = 252 ; blueVal = 0 ;
rupture ;
cas 2 :
redVal = 0 ; greenVal = 252 ; blueVal = fs ;
rupture ;
cas 3 :
redVal = 0 ; greenVal = 252-fs ; blueVal = 252 ;
rupture ;
cas 4 :
redVal = fs ; greenVal = 0 ; blueVal = 252 ;
rupture ;
cas no 5 :
redVal = 252 ; greenVal = 0 ; blueVal = 252-fs ;
rupture ;
}
}
void isr0() {}
Serial.println ("\n \n interrompre \n") ;
buttonState = digitalRead(switchPin) ; lire l’état initial
delayMicroseconds(100000) ;
Si (val! = buttonState) {/ / l’état du bouton a changé !
Si (buttonState == HIGH) {/ / vérifier si le bouton est enfoncé maintenant
buttonPresses ++ ;
// }
Val = buttonState ; enregistrer le nouvel État dans notre variable
Si (buttonPresses == 3) {/ / zur cksetzen
buttonPresses = 0 ;
}
}
// }
Prochaine étape étaient les transistor-pilotes. J’ai utilisé 3 transistors PNP avec un courant maximum sur 3 ampères. Après que forward-courant et la tension étaient réglementés, la LEDemitter fonctionnait très bien avec pleine intensité.
