Lumière d’ambiance parler de Twitter (2 / 7 étapes)

Étape 2: Arduino

/ / twitterMentionMoodLight_arduino
pour une utilisation en l’état avec soit :
twitterMentionMoodLight_processing
twitterMentionMoodLight_python
//
Générer une lueur paisible jusqu'à ce que quelqu'un sur twitter vous mentionne.
//
Nécessite un circuit avec : deux boutons et un pwm rgb led lumière, et
3 résistances à 220 ohms ; 2 résistances à 100 ohms ; 2 résistances à 10 k ohms.
//
Shout out à Tom Igoe, Adafruit, Rôdeurs et msg conseils partout.
en savoir plus sur :
/*
#####################################################################
---DEUX BOUTONS ET UNE LUMIÈRE---
Bouton un : Tenir jusqu'à ce que la lumière blanche ; Envoie un message à Twitter.
La lumière : Lueur paisiblement jusqu'à ce que commandé par Twitter à changer.
Touche 2: Réinitialise conduit à peacefulGlow.

peacefulGlow() - l’État par défaut de la lumière d’ambiance
mention() - quelqu'un a mentionné
buttonSend() - mise à jour de statut Twitter
buttonReset() - retour à peacefulGlow()
--------------------------------------------------------------------
#####################################################################
*/

const int rButton = 10 ; bouton de réinitialisation
int reset_btn_val = 0 ;
const int sButton = 11 ; bouton Envoyer
int send_btn_val = 0 ;
État de chaîne = « peacefulGlow » ;

int ledAnalogOne [] = {3, 5, 6} ; Broches PWM RGB LED
LED3 analogique = redPin, 5 = greenPin, 6 = bluePin

Couleurs définies
NOIR de const byte [] = {0, 0, 0} ;
BLANC de const byte [] = {255, 255, 255} ;
const byte [rouge] = {255, 0, 0} ;
VERT de const byte [] = {0, 255, 0} ;
BLEU de const byte [] = {0, 0, 255} ;
const byte [ORANGE] = {83, 4, 0} ;
JAUNE de const byte [] = {255, 255, 0} ;
const byte MAGENTA [] = {0, 255, 255} ;

void setup() {/ / début
Serial.Begin(9600) ;
pinMode (rButton, entrée) ;
pinMode (sButton, entrée) ;
pour (int i = 0; j’ai < 3; i ++) {/ / définir les 3 broches LED comme sorties
pinMode (ledAnalogOne [i], sortie) ;
}
}

void loop() {}
listenToSerial() ;
buttonSend() ;
buttonReset() ;
setState(state) ;
}
void setState(String s) {}
Si (s == « peacefulGlow ») peacefulGlow() ;
Si (s == « mention ») mention() ;
}
void listenToSerial() {/ / Twitter commandes Entrez ici
int serialMsg = 0 ;
Si (Serial.available()) {}
serialMsg = Serial.read() ;
Si (serialMsg == 1) Etat = « mention » ; traitement
Si (serialMsg == 49) Etat = « mention » ; python
}
}
void buttonSend() {/ / Twitter messages envoyés ici
send_btn_val = digitalRead(sButton) ;
Si (send_btn_val == HIGH) {}
Serial.Print("#peacefulGlow") ;
Delay(200) ;
sent() ;
}
}
void buttonReset() {}
reset_btn_val = digitalRead(rButton) ;
Si (reset_btn_val == HIGH) {}
État = « peacefulGlow » ;
}
}
void peacefulGlow() {}
État = « peacefulGlow » ;
Si (État == « peacefulGlow ») {}
fadeToColor (ledAnalogOne, rouge, bleu, 6) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
Si (État == « peacefulGlow ») {}
fadeToColor (ledAnalogOne, bleu, vert, 6) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
Si (État == « peacefulGlow ») {}
fadeToColor (ledAnalogOne, vert, jaune, 6) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
Si (État == « peacefulGlow ») {}
fadeToColor (ledAnalogOne, jaune, ORANGE, 6) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
Si (État == « peacefulGlow ») {}
fadeToColor (ledAnalogOne, ORANGE, rouge, 6) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
}
void mention() {}
État = « mention » ;
Si (État == « mention ») {}
fadeToColor (ledAnalogOne, rouge, noir, 1) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
buttonReset() ;
Si (État == « mention ») {}
fadeToColor (ledAnalogOne, noir, rouge, 0) ;
} else {}
setState(state) ;
}
listenToSerial() ;
buttonSend() ;
buttonReset() ;
}
void sent() {}
setColor (ledAnalogOne, blanc) ;
Delay(500) ;
}

// *************************************************************
*** FONCTIONS COULEUR - NE TOUCHEZ PAS ***

{} void setColor (int * conduit, byte * couleur)
pour (int i = 0; i < 3; i ++) {}
analogWrite (conduit [i], 255 - color[i]) ;
}
}

{} void setColor (int * conduit, const byte * couleur)
tempByte Byte = {}
couleur [0], couleur [1], [2]} ;
setColor (led, tempByte) ;
}

void fadeToColor (int * a conduit octets * startColor, byte * endColor, int fadeSpeed) {}
int changeRed = endColor [0] - startColor [0] ;
int changeGreen = endColor [1] - startColor [1] ;
int changeBlue = endColor [2] - startColor [2] ;
étapes d’int = max(abs(changeRed),max(abs(changeGreen), abs(changeBlue))) ;

pour (int i = 0; i < étapes; i ++) {
newRed octets = startColor [0] + (j’ai * changeRed / étapes) ;
newGreen octets = startColor [1] + (j’ai * changeGreen / étapes) ;
newBlue octets = startColor [2] + (j’ai * changeBlue / étapes) ;
newColor Byte = {newRed, newGreen, newBlue} ;
setColor (led, newColor) ;
Delay(fadeSpeed) ;
}
setColor (led, endColor) ;
}

void fadeToColor (int * conduit, const byte * startColor, const byte * endColor, int fadeSpeed) {}
tempByte1 Byte = {startColor [0], startColor [1], [2] de startColor} ;
tempByte2 Byte = {endColor [0], endColor [1], [2] d’endColor} ;
fadeToColor (led, tempByte1, tempByte2, fadeSpeed) ;
}