Created
November 20, 2012 07:25
-
-
Save anonymous/4116564 to your computer and use it in GitHub Desktop.
Remote Controlled Home Theatre Lights - Arduino IR
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/******************* our codes ************/ | |
int LightsOnOff[] = { | |
// ON, OFF (in 10's of microseconds) | |
346, 166, | |
44, 40, | |
44, 126, | |
44, 40, | |
44, 42, | |
42, 42, | |
44, 40, | |
44, 40, | |
44, 42, | |
44, 40, | |
44, 40, | |
44, 42, | |
42, 42, | |
42, 42, | |
44, 126, | |
44, 40, | |
44, 42, | |
42, 42, | |
42, 42, | |
44, 40, | |
44, 42, | |
42, 42, | |
44, 40, | |
44, 42, | |
42, 126, | |
44, 42, | |
42, 42, | |
44, 40, | |
44, 40, | |
44, 42, | |
42, 42, | |
44, 40, | |
44, 42, | |
42, 126, | |
44, 42, | |
42, 128, | |
42, 126, | |
44, 126, | |
44, 126, | |
44, 42, | |
42, 42, | |
44, 126, | |
42, 42, | |
44, 126, | |
42, 128, | |
42, 126, | |
44, 126, | |
44, 42, | |
42, 126, | |
44, 0}; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* Raw IR commander | |
This sketch/program uses the Arduno and a PNA4602 to | |
decode IR received. It then attempts to match it to a previously | |
recorded IR signal | |
Code is public domain, check out www.ladyada.net and adafruit.com | |
for more tutorials! | |
*/ | |
// We need to use the 'raw' pin reading methods | |
// because timing is very important here and the digitalRead() | |
// procedure is slower! | |
//uint8_t IRpin = 2; | |
// Digital pin #2 is the same as Pin D2 see | |
// http://arduino.cc/en/Hacking/PinMapping168 for the 'raw' pin mapping | |
#define IRpin_PIN PIND | |
#define IRpin 2 | |
// the maximum pulse we'll listen for - 65 milliseconds is a long time | |
#define MAXPULSE 65000 | |
#define NUMPULSES 50 | |
// what our timing resolution should be, larger is better | |
// as its more 'precise' - but too large and you wont get | |
// accurate timing | |
#define RESOLUTION 20 | |
// What percent we will allow in variation to match the same code | |
#define FUZZINESS 20 | |
// we will store up to 100 pulse pairs (this is -a lot-) | |
uint16_t pulses[NUMPULSES][2]; // pair is high and low pulse | |
uint8_t currentpulse = 0; // index for pulses we're storing | |
#include "ircodes.h" | |
int lights = 17; | |
int OnOff = 0; | |
int statusLight = 7; | |
int WallSwitch = 3; | |
void setup(void) { | |
pinMode(lights, OUTPUT); | |
pinMode(statusLight, OUTPUT); | |
pinMode(WallSwitch, INPUT); | |
Serial.begin(9600); | |
digitalWrite(statusLight, HIGH); | |
Serial.println("Ready to decode IR!"); | |
attachInterrupt(1, LightControl, CHANGE); | |
} | |
void loop(void) { | |
int numberpulses; | |
numberpulses = listenForIR(); | |
Serial.print("Heard "); | |
Serial.print(numberpulses); | |
Serial.println("-pulse long IR signal"); | |
if (IRcompare(numberpulses, LightsOnOff,sizeof(LightsOnOff)/4)) { | |
Serial.println("Lights On orOff"); | |
LightControl(); | |
} | |
delay(500); | |
} | |
//KGO: added size of compare sample. Only compare the minimum of the two | |
boolean IRcompare(int numpulses, int Signal[], int refsize) { | |
// int count = min(numpulses,refsize); | |
int count = (50); // changed from above to "50" to stop random on/off commands | |
Serial.print("count set to: "); | |
Serial.println(count); | |
for (int i=0; i< count-1; i++) { | |
int oncode = pulses[i][1] * RESOLUTION / 10; | |
int offcode = pulses[i+1][0] * RESOLUTION / 10; | |
#ifdef DEBUG | |
Serial.print(oncode); // the ON signal we heard | |
Serial.print(" - "); | |
Serial.print(Signal[i*2 + 0]); // the ON signal we want | |
#endif | |
// check to make sure the error is less than FUZZINESS percent | |
if ( abs(oncode - Signal[i*2 + 0]) <= (Signal[i*2 + 0] * FUZZINESS / 100)) { | |
#ifdef DEBUG | |
Serial.print(" (ok)"); | |
#endif | |
} else { | |
#ifdef DEBUG | |
Serial.print(" (x)"); | |
#endif | |
// we didn't match perfectly, return a false match | |
return false; | |
} | |
#ifdef DEBUG | |
Serial.print(" \t"); // tab | |
Serial.print(offcode); // the OFF signal we heard | |
Serial.print(" - "); | |
Serial.print(Signal[i*2 + 1]); // the OFF signal we want | |
#endif | |
if ( abs(offcode - Signal[i*2 + 1]) <= (Signal[i*2 + 1] * FUZZINESS / 100)) { | |
#ifdef DEBUG | |
Serial.print(" (ok)"); | |
#endif | |
} else { | |
#ifdef DEBUG | |
Serial.print(" (x)"); | |
#endif | |
// we didn't match perfectly, return a false match | |
return false; | |
} | |
#ifdef DEBUG | |
Serial.println(); | |
#endif | |
} | |
// Everything matched! | |
return true; | |
} | |
int listenForIR(void) { | |
currentpulse = 0; | |
while (1) { | |
uint16_t highpulse, lowpulse; // temporary storage timing | |
highpulse = lowpulse = 0; // start out with no pulse length | |
// while (digitalRead(IRpin)) { // this is too slow! | |
while (IRpin_PIN & (1 << IRpin)) { | |
// pin is still HIGH | |
// count off another few microseconds | |
highpulse++; | |
delayMicroseconds(RESOLUTION); | |
// If the pulse is too long, we 'timed out' - either nothing | |
// was received or the code is finished, so print what | |
// we've grabbed so far, and then reset | |
// KGO: Added check for end of receive buffer | |
if (((highpulse >= MAXPULSE) && (currentpulse != 0))|| currentpulse == NUMPULSES) { | |
return currentpulse; | |
} | |
} | |
// we didn't time out so lets stash the reading | |
pulses[currentpulse][0] = highpulse; | |
// same as above | |
while (! (IRpin_PIN & _BV(IRpin))) { | |
// pin is still LOW | |
lowpulse++; | |
delayMicroseconds(RESOLUTION); | |
// KGO: Added check for end of receive buffer | |
if (((lowpulse >= MAXPULSE) && (currentpulse != 0))|| currentpulse == NUMPULSES) { | |
return currentpulse; | |
} | |
} | |
pulses[currentpulse][1] = lowpulse; | |
// we read one high-low pulse successfully, continue! | |
currentpulse++; | |
} | |
} | |
void printpulses(void) { | |
Serial.println("\n\r\n\rReceived: \n\rOFF \tON"); | |
for (uint8_t i = 0; i < currentpulse; i++) { | |
Serial.print(pulses[i][0] * RESOLUTION, DEC); | |
Serial.print(" usec, "); | |
Serial.print(pulses[i][1] * RESOLUTION, DEC); | |
Serial.println(" usec"); | |
} | |
// print it in a 'array' format | |
Serial.println("int IRsignal[] = {"); | |
Serial.println("// ON, OFF (in 10's of microseconds)"); | |
for (uint8_t i = 0; i < currentpulse-1; i++) { | |
Serial.print("\t"); // tab | |
Serial.print(pulses[i][1] * RESOLUTION / 10, DEC); | |
Serial.print(", "); | |
Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC); | |
Serial.println(","); | |
} | |
Serial.print("\t"); // tab | |
Serial.print(pulses[currentpulse-1][1] * RESOLUTION / 10, DEC); | |
Serial.print(", 0};"); | |
} | |
void LightControl(){ | |
//// | |
static unsigned long last_interrupt_time = 0; | |
unsigned long interrupt_time = millis(); | |
// If interrupts come faster than 200ms, assume it's a bounce and ignore | |
if (interrupt_time - last_interrupt_time > 200) | |
{ | |
if(OnOff == 0){ | |
OnOff += 1; | |
Serial.println(" lights on "); | |
digitalWrite(lights, HIGH); | |
} | |
else if (OnOff == 1){ | |
OnOff = 0; | |
Serial.println(" lights off "); | |
digitalWrite(lights, LOW); | |
} | |
} | |
last_interrupt_time = interrupt_time; | |
} | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment