Luz del humor mención de Twitter (2 / 7 paso)

Paso 2: Arduino

/ / twitterMentionMoodLight_arduino
para el uso como es con cualquiera:
twitterMentionMoodLight_processing
twitterMentionMoodLight_python
//
Generar un resplandor tranquilo hasta que alguien en twitter le menciona.
//
Requiere un circuito con: dos botones y un rgb pwm de luz led, y
3 resistencias a 220 ohm; 2 resistencias en ohmios 100; 2 resistencias en 10 k ohmios.
//
Gritar a Tom Igoe, Adafruit, lurkers y msg juntas por todas partes.
más información en:
/*
#####################################################################
---DOS BOTONES Y UNA LUZ---
Botón de: Sostenga hasta que la luz blanca; Envía un mensaje a Twitter.
La luz: Resplandor pacíficamente hasta que mandó por Twitter para cambiar.
Botón dos: Reajustes llevaron a peacefulGlow.

peacefulGlow() - el estado por defecto de la luz de estado de ánimo
mention() - alguien ha mencionado
buttonSend() - actualizar estado de Twitter
buttonReset() - regreso a peacefulGlow()
--------------------------------------------------------------------
#####################################################################
*/

const int rButton = 10; botón de reinicio
int reset_btn_val = 0;
const int sButton = 11; botón de enviar
int send_btn_val = 0;
Estado de la cadena = "peacefulGlow";

int ledAnalogOne [] = {3, 5, 6}; Pines RGB LED PWM
Analógica 3 LED = redPin, 5 = greenPin, 6 = bluePin

Colores definidos
byte const negro [] = {0, 0, 0};
BLANCO de byte const [] = {255, 255, 255};
byte const rojo [] = {255, 0, 0};
byte const verde [] = {0, 255, 0};
byte const azul [] = {0, 0, 255};
byte const naranja [] = {4, 83, 0};
byte const amarillo [] = {255, 255, 0};
byte const MAGENTA [] = {0, 255, 255};

void setup() {/ / comenzar
Serial.Begin(9600);
pinMode (rButton, entrada);
pinMode (sButton, entrada);
para (int i = 0; i < 3; i ++) {/ / conjunto los 3 pines del LED como salida
pinMode (ledAnalogOne [i], salida);
}
}

void loop() {}
listenToSerial();
buttonSend();
buttonReset();
setState(state);
}
void setState(String s) {}
Si (s == "peacefulGlow") peacefulGlow();
Si (s == "mención") mention();
}
void listenToSerial() {/ / Twitter comandos entrar aquí
int serialMsg = 0;
Si (Serial.available()) {}
serialMsg = Serial.read();
Si (serialMsg == 1) estado = "mención"; procesamiento de
Si (serialMsg == 49) estado = "mención"; Python
}
}
void buttonSend() {/ / Twitter mensajes enviados aquí
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) {}
Estado = "peacefulGlow";
}
}
void peacefulGlow() {}
Estado = "peacefulGlow";
Si (estado == "peacefulGlow") {}
fadeToColor (ledAnalogOne, rojo, azul, 6);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
Si (estado == "peacefulGlow") {}
fadeToColor (ledAnalogOne, azul, verde, 6);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
Si (estado == "peacefulGlow") {}
fadeToColor (ledAnalogOne, verde, amarillo, 6);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
Si (estado == "peacefulGlow") {}
fadeToColor (ledAnalogOne, amarillo, naranja, 6);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
Si (estado == "peacefulGlow") {}
fadeToColor (ledAnalogOne, naranja, rojo, 6);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
}
void mention() {}
Estado = "mención";
Si (estado == "mención") {}
fadeToColor (ledAnalogOne, rojo, negro, 1);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
buttonReset();
Si (estado == "mención") {}
fadeToColor (ledAnalogOne, negro, rojo, 0);
} else {}
setState(state);
}
listenToSerial();
buttonSend();
buttonReset();
}
void sent() {}
Colores (ledAnalogOne, WHITE);
Delay(500);
}

// *************************************************************
*** FUNCIONES COLOR - NO TOQUE ***

{} void colores (int * led, byte * color)
para (int i = 0; i < 3; i ++) {}
analogWrite (led [i], 255 - color[i]);
}
}

{} void colores (int * led, const byte * color)
Byte [] tempByte = {}
color de [0] color [1], [2]};
Colores (led, tempByte);
}

void fadeToColor (int * led, byte * startColor, byte * endColor, fadeSpeed int) {}
int changeRed = endColor [0] - startColor [0];
int changeGreen = endColor [1] - startColor [1];
int changeBlue = endColor [2] - startColor [2];
pasos de int = max(abs(changeRed),max(abs(changeGreen), abs(changeBlue)));

para (int i = 0; i < pasos; i ++) {}
newRed bytes = startColor [0] + (i * changeRed / pasos);
newGreen bytes = startColor [1] + (i * changeGreen / pasos);
newBlue bytes = startColor [2] + (i * changeBlue / pasos);
newColor de bytes [] = {newRed, newGreen, newBlue};
Colores (led, newColor);
Delay(fadeSpeed);
}
Colores (led, endColor);
}

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