Remote-controlled Road Rager!

1#include "IRremote.h"
2
3int receiver = 9; // Signal Pin of IR receiver  to Arduino Digital Pin 11
4#define led 7 // Power LED
5
6#define m1_pwm 3
7#define  m1_A 4
8#define m1_B 5
9
10#define m2_pwm 11
11#define m2_A 12
12#define  m2_B 13
13
14int power = 0; // controls except for toggling power can only be  used when "on" (power = 1)
15
16/*-----( Declare objects )-----*/
17IRrecv  irrecv(receiver);     // create instance of 'irrecv'
18decode_results results;      // create instance of 'decode_results'
19
20/*-----( Function )-----*/
21void  translateIR() // takes action based on IR code received
22
23// describing Remote  IR codes 
24
25{
26
27  switch(results.value)
28
29  {
30  case 0xFFA25D:  
31  Serial.println("POWER");
32  power += 1;
33  power = power % 2;
34  Serial.println(power);
35  break;
36  
37  case 0xFFE21D: 
38  Serial.println("FUNC/STOP"); 
39  Serial.println("f1");
40  break;
41  
42  case 0xFF629D: 
43  Serial.println("VOL+"); 
44  digitalWrite(m1_A,  HIGH);
45  digitalWrite(m1_B, LOW);
46  digitalWrite(m2_A, HIGH);
47  digitalWrite(m2_B,  LOW);
48  digitalWrite(m1_pwm, HIGH);
49  digitalWrite(m2_pwm, HIGH);
50  break;
51  
52  case 0xFF22DD: 
53  Serial.println("FAST BACK");
54  digitalWrite(m2_A,  LOW);
55  digitalWrite(m2_B, HIGH);    
56  digitalWrite(m1_A, HIGH);
57  digitalWrite(m1_B,  LOW);
58  digitalWrite(m1_pwm, HIGH);
59  digitalWrite(m2_pwm, LOW);
60  break;
61  
62  case 0xFF02FD: 
63  Serial.println("PAUSE"); 
64  digitalWrite(m1_pwm,  LOW);
65  digitalWrite(m2_pwm, LOW);   
66  break;
67  
68  case 0xFFC23D: 
69  Serial.println("FAST FORWARD");   
70  digitalWrite(m2_A, HIGH);
71  digitalWrite(m2_B,  LOW);
72  digitalWrite(m1_A, LOW);
73  digitalWrite(m1_B, HIGH);
74  digitalWrite(m2_pwm,  HIGH);
75  digitalWrite(m1_pwm, LOW);
76  break;
77  
78  case 0xFFA857: 
79  Serial.println("VOL-");
80  digitalWrite(m1_A, LOW);
81  digitalWrite(m1_B,  HIGH);
82  digitalWrite(m2_A, LOW);
83  digitalWrite(m2_B, HIGH);
84  digitalWrite(m1_pwm,  HIGH);
85  digitalWrite(m2_pwm, HIGH);    
86  break;
87
88  case 0xFFFFFFFF:  Serial.println(" REPEAT"); break;  
89
90  default: 
91    Serial.println("  other button   ");
92
93  }// End Case
94
95  delay(500); // Do not get immediate  repeat
96
97
98} //END translateIR
99void setup()   /*----( SETUP: RUNS ONCE  )----*/
100{
101  pinMode(m1_pwm,OUTPUT);
102  pinMode(m1_A,OUTPUT);
103  pinMode(m1_B,OUTPUT);
104  pinMode(m2_pwm,OUTPUT);
105  pinMode(m2_A,OUTPUT);
106  pinMode(m2_B,OUTPUT);
107  Serial.begin(9600);
108  Serial.println("IR Receiver Button Decode"); 
109  irrecv.enableIRIn();  // Start the receiver
110
111}/*--(end setup )---*/
112
113
114void loop()   /*----(  LOOP: RUNS CONSTANTLY )----*/
115{
116  if (power == 1) {
117    digitalWrite(led,  HIGH);
118    if (irrecv.decode(&results)) // have we received an IR signal?
119    {
120      translateIR(); 
121      irrecv.resume(); // receive the next value
122    }
123  }
124  if (power == 0) {
125    digitalWrite(led, LOW);
126    digitalWrite(m1_pwm,  LOW);
127    digitalWrite(m2_pwm, LOW);
128    if (irrecv.decode(&results)) // have  we received an IR signal?
129    {
130      switch(results.value) 
131      {
132      case 0xFFA25D: 
133      Serial.println("POWER");
134      power += 1;
135      power = power % 2;
136      Serial.println(power);
137      break;
138      }
139      irrecv.resume(); // receive the next value
140    }
141  }
142}/* --(end main  loop )-- */

1/*
2 * IRremote
3 * Version 0.1 July, 2009
4 * Copyright 2009 Ken  Shirriff
5 * For details, see http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.htm  http://arcfn.com
6 * Edited by Mitra to add new controller SANYO
7 *
8 * Interrupt  code based on NECIRrcv by Joe Knapp
9 * http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556
10  * Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/
11  *
12 * JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel  and other people at the original blog post)
13* LG added by Darryl Smith (based  on the JVC protocol)
14 */
15
16#ifndef IRremote_h
17#define IRremote_h
18
19//  The following are compile-time library options.
20// If you change them, recompile  the library.
21// If DEBUG is defined, a lot of debugging output will be printed  during decoding.
22// TEST must be defined for the IRtest unittests to work.  It  will make some
23// methods virtual, which will be slightly slower, which is why  it is optional.
24// #define DEBUG
25// #define TEST
26
27// Results returned  from the decoder
28class decode_results {
29public:
30  int decode_type; // NEC,  SONY, RC5, UNKNOWN
31  union { // This is used for decoding Panasonic and Sharp  data
32    unsigned int panasonicAddress;
33    unsigned int sharpAddress;
34  };
35  unsigned long value; // Decoded value
36  int bits; // Number of bits  in decoded value
37  volatile unsigned int *rawbuf; // Raw intervals in .5 us ticks
38  int rawlen; // Number of records in rawbuf.
39};
40
41// Values for decode_type
42#define  NEC 1
43#define SONY 2
44#define RC5 3
45#define RC6 4
46#define DISH 5
47#define  SHARP 6
48#define PANASONIC 7
49#define JVC 8
50#define SANYO 9
51#define MITSUBISHI  10
52#define SAMSUNG 11
53#define LG 12
54#define UNKNOWN -1
55
56// Decoded  value for NEC when a repeat code is received
57#define REPEAT 0xffffffff
58
59//  main class for receiving IR
60class IRrecv
61{
62public:
63  IRrecv(int recvpin);
64  void blink13(int blinkflag);
65  int decode(decode_results *results);
66  void  enableIRIn();
67  void resume();
68private:
69  // These are called by decode
70  int getRClevel(decode_results *results, int *offset, int *used, int t1);
71  long  decodeNEC(decode_results *results);
72  long decodeSony(decode_results *results);
73  long decodeSanyo(decode_results *results);
74  long decodeMitsubishi(decode_results  *results);
75  long decodeRC5(decode_results *results);
76  long decodeRC6(decode_results  *results);
77  long decodePanasonic(decode_results *results);
78  long decodeLG(decode_results  *results);
79  long decodeJVC(decode_results *results);
80  long decodeSAMSUNG(decode_results  *results);
81  long decodeHash(decode_results *results);
82  int compare(unsigned  int oldval, unsigned int newval);
83
84} 
85;
86
87// Only used for testing;  can remove virtual for shorter code
88#ifdef TEST
89#define VIRTUAL virtual
90#else
91#define  VIRTUAL
92#endif
93
94class IRsend
95{
96public:
97  IRsend() {}
98  void  sendNEC(unsigned long data, int nbits);
99  void sendSony(unsigned long data, int  nbits);
100  // Neither Sanyo nor Mitsubishi send is implemented yet
101  //  void  sendSanyo(unsigned long data, int nbits);
102  //  void sendMitsubishi(unsigned  long data, int nbits);
103  void sendRaw(unsigned int buf[], int len, int hz);
104  void sendRC5(unsigned long data, int nbits);
105  void sendRC6(unsigned long data,  int nbits);
106  void sendDISH(unsigned long data, int nbits);
107  void sendSharp(unsigned  int address, unsigned int command);
108  void sendSharpRaw(unsigned long data, int  nbits);
109  void sendPanasonic(unsigned int address, unsigned long data);
110  void  sendJVC(unsigned long data, int nbits, int repeat); // *Note instead of sending  the REPEAT constant if you want the JVC repeat signal sent, send the original code  value and change the repeat argument from 0 to 1. JVC protocol repeats by skipping  the header NOT by sending a separate code value like NEC does.
111  // private:
112  void sendSAMSUNG(unsigned long data, int nbits);
113  void enableIROut(int khz);
114  VIRTUAL void mark(int usec);
115  VIRTUAL void space(int usec);
116}
117;
118
119//  Some useful constants
120
121#define USECPERTICK 50  // microseconds per clock interrupt  tick
122#define RAWBUF 100 // Length of raw duration buffer
123
124// Marks tend  to be 100us too long, and spaces 100us too short
125// when received due to sensor  lag.
126#define MARK_EXCESS 100
127
128#endif
129

1#include "IRremote.h"
2
3int receiver = 9; // Signal Pin of IR receiver  to Arduino Digital Pin 11
4#define led 7 // Power LED
5
6#define m1_pwm 3
7#define  m1_A 4
8#define m1_B 5
9
10#define m2_pwm 11
11#define m2_A 12
12#define  m2_B 13
13
14int power = 0; // controls except for toggling power can only be  used when "on" (power = 1)
15
16/*-----( Declare objects )-----*/
17IRrecv  irrecv(receiver);     // create instance of 'irrecv'
18decode_results results;      // create instance of 'decode_results'
19
20/*-----( Function )-----*/
21void  translateIR() // takes action based on IR code received
22
23// describing Remote  IR codes 
24
25{
26
27  switch(results.value)
28
29  {
30  case 0xFFA25D:  // Power
31  Serial.println("POWER");
32  power += 1;
33  power = power % 2;
34  Serial.println(power);
35  break;
36  
37  case 0xFFE21D:
38  Serial.println("FUNC/STOP");  
39  Serial.println("f1");
40  break;
41  
42  case 0xFF629D: // Forward
43  Serial.println("VOL+"); 
44  digitalWrite(m1_A, HIGH);
45  digitalWrite(m1_B,  LOW);
46  digitalWrite(m2_A, HIGH);
47  digitalWrite(m2_B, LOW);
48  digitalWrite(m1_pwm,  HIGH);
49  digitalWrite(m2_pwm, HIGH);
50  break;
51  
52  case 0xFF22DD: //  Turn Left
53  Serial.println("FAST BACK");
54  digitalWrite(m2_A, LOW);
55  digitalWrite(m2_B, HIGH);    
56  digitalWrite(m1_A, HIGH);
57  digitalWrite(m1_B,  LOW);
58  digitalWrite(m1_pwm, HIGH);
59  digitalWrite(m2_pwm, LOW);
60  break;
61  
62  case 0xFF02FD: // Stop/Pause
63  Serial.println("PAUSE"); 
64  digitalWrite(m1_pwm,  LOW);
65  digitalWrite(m2_pwm, LOW);   
66  break;
67  
68  case 0xFFC23D: //  Turn Right
69  Serial.println("FAST FORWARD");   
70  digitalWrite(m2_A, HIGH);
71  digitalWrite(m2_B, LOW);
72  digitalWrite(m1_A, LOW);
73  digitalWrite(m1_B,  HIGH);
74  digitalWrite(m2_pwm, HIGH);
75  digitalWrite(m1_pwm, LOW);
76  break;
77  
78  case 0xFFA857: // Baackward
79  Serial.println("VOL-");
80  digitalWrite(m1_A,  LOW);
81  digitalWrite(m1_B, HIGH);
82  digitalWrite(m2_A, LOW);
83  digitalWrite(m2_B,  HIGH);
84  digitalWrite(m1_pwm, HIGH);
85  digitalWrite(m2_pwm, HIGH);    
86  break;
87
88  case 0xFFFFFFFF: Serial.println(" REPEAT"); break;  
89
90  default: 
91    Serial.println(" other button   ");
92
93  }// End Case
94
95  delay(500); // Do not get immediate repeat
96
97
98} //END translateIR
99void  setup()   /*----( SETUP: RUNS ONCE )----*/
100{
101  pinMode(m1_pwm,OUTPUT);
102  pinMode(m1_A,OUTPUT);
103  pinMode(m1_B,OUTPUT);
104  pinMode(m2_pwm,OUTPUT);
105  pinMode(m2_A,OUTPUT);
106  pinMode(m2_B,OUTPUT);
107  Serial.begin(9600);
108  Serial.println("IR Receiver Button Decode"); 
109  irrecv.enableIRIn(); // Start  the receiver
110
111}/*--(end setup )---*/
112
113
114void loop()   /*----( LOOP:  RUNS CONSTANTLY )----*/
115{
116  if (power == 1) {
117    digitalWrite(led, HIGH);
118    if (irrecv.decode(&results)) // have we received an IR signal?
119    {
120      translateIR(); 
121      irrecv.resume(); // receive the next value
122    }
123  }
124  if (power == 0) {
125    digitalWrite(led, LOW);
126    digitalWrite(m1_pwm,  LOW);
127    digitalWrite(m2_pwm, LOW);
128    if (irrecv.decode(&results)) // have  we received an IR signal?
129    {
130      switch(results.value) 
131      {
132      case 0xFFA25D: 
133      Serial.println("POWER");
134      power += 1;
135      power = power % 2;
136      Serial.println(power);
137      break;
138      }
139      irrecv.resume(); // receive the next value
140    }
141  }
142}/* --(end main  loop )-- */
143

1/*
2 * IRremote
3 * Version 0.11 August, 2009
4 * Copyright 2009  Ken Shirriff
5 * For details, see http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
6  *
7 * Modified by Paul Stoffregen <paul@pjrc.com> to support other boards and  timers
8 * Modified  by Mitra Ardron <mitra@mitra.biz> 
9 * Added Sanyo and  Mitsubishi controllers
10 * Modified Sony to spot the repeat codes that some Sony's  send
11 *
12 * Interrupt code based on NECIRrcv by Joe Knapp
13 * http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556
14  * Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/
15  *
16 * JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel  and other people at the original blog post)
17 * LG added by Darryl Smith (based  on the JVC protocol)
18 */
19
20#include "IRremote.h"
21#include "IRremoteInt.h"
22
23//  Provides ISR
24#include <avr/interrupt.h>
25
26volatile irparams_t irparams;
27
28//  These versions of MATCH, MATCH_MARK, and MATCH_SPACE are only for debugging.
29//  To use them, set DEBUG in IRremoteInt.h
30// Normally macros are used for efficiency
31#ifdef  DEBUG
32int MATCH(int measured, int desired) {
33  Serial.print("Testing: ");
34  Serial.print(TICKS_LOW(desired), DEC);
35  Serial.print(" <= ");
36  Serial.print(measured,  DEC);
37  Serial.print(" <= ");
38  Serial.println(TICKS_HIGH(desired), DEC);
39  return measured >= TICKS_LOW(desired) && measured <= TICKS_HIGH(desired);
40}
41
42int  MATCH_MARK(int measured_ticks, int desired_us) {
43  Serial.print("Testing mark  ");
44  Serial.print(measured_ticks * USECPERTICK, DEC);
45  Serial.print("  vs ");
46  Serial.print(desired_us, DEC);
47  Serial.print(": ");
48  Serial.print(TICKS_LOW(desired_us  + MARK_EXCESS), DEC);
49  Serial.print(" <= ");
50  Serial.print(measured_ticks,  DEC);
51  Serial.print(" <= ");
52  Serial.println(TICKS_HIGH(desired_us + MARK_EXCESS),  DEC);
53  return measured_ticks >= TICKS_LOW(desired_us + MARK_EXCESS) && measured_ticks  <= TICKS_HIGH(desired_us + MARK_EXCESS);
54}
55
56int MATCH_SPACE(int measured_ticks,  int desired_us) {
57  Serial.print("Testing space ");
58  Serial.print(measured_ticks  * USECPERTICK, DEC);
59  Serial.print(" vs ");
60  Serial.print(desired_us,  DEC);
61  Serial.print(": ");
62  Serial.print(TICKS_LOW(desired_us - MARK_EXCESS),  DEC);
63  Serial.print(" <= ");
64  Serial.print(measured_ticks, DEC);
65  Serial.print("  <= ");
66  Serial.println(TICKS_HIGH(desired_us - MARK_EXCESS), DEC);
67  return  measured_ticks >= TICKS_LOW(desired_us - MARK_EXCESS) && measured_ticks <= TICKS_HIGH(desired_us  - MARK_EXCESS);
68}
69#else
70int MATCH(int measured, int desired) {return measured  >= TICKS_LOW(desired) && measured <= TICKS_HIGH(desired);}
71int MATCH_MARK(int  measured_ticks, int desired_us) {return MATCH(measured_ticks, (desired_us + MARK_EXCESS));}
72int  MATCH_SPACE(int measured_ticks, int desired_us) {return MATCH(measured_ticks, (desired_us  - MARK_EXCESS));}
73// Debugging versions are in IRremote.cpp
74#endif
75
76void  IRsend::sendNEC(unsigned long data, int nbits)
77{
78  enableIROut(38);
79  mark(NEC_HDR_MARK);
80  space(NEC_HDR_SPACE);
81  for (int i = 0; i < nbits; i++) {
82    if (data &  TOPBIT) {
83      mark(NEC_BIT_MARK);
84      space(NEC_ONE_SPACE);
85    } 
86    else {
87      mark(NEC_BIT_MARK);
88      space(NEC_ZERO_SPACE);
89    }
90    data <<= 1;
91  }
92  mark(NEC_BIT_MARK);
93  space(0);
94}
95
96void  IRsend::sendSony(unsigned long data, int nbits) {
97  enableIROut(40);
98  mark(SONY_HDR_MARK);
99  space(SONY_HDR_SPACE);
100  data = data << (32 - nbits);
101  for (int i = 0;  i < nbits; i++) {
102    if (data & TOPBIT) {
103      mark(SONY_ONE_MARK);
104      space(SONY_HDR_SPACE);
105    } 
106    else {
107      mark(SONY_ZERO_MARK);
108      space(SONY_HDR_SPACE);
109    }
110    data <<= 1;
111  }
112}
113
114void  IRsend::sendRaw(unsigned int buf[], int len, int hz)
115{
116  enableIROut(hz);
117  for (int i = 0; i < len; i++) {
118    if (i & 1) {
119      space(buf[i]);
120    } 
121    else {
122      mark(buf[i]);
123    }
124  }
125  space(0); // Just  to be sure
126}
127
128// Note: first bit must be a one (start bit)
129void IRsend::sendRC5(unsigned  long data, int nbits)
130{
131  enableIROut(36);
132  data = data << (32 - nbits);
133  mark(RC5_T1); // First start bit
134  space(RC5_T1); // Second start bit
135  mark(RC5_T1);  // Second start bit
136  for (int i = 0; i < nbits; i++) {
137    if (data & TOPBIT)  {
138      space(RC5_T1); // 1 is space, then mark
139      mark(RC5_T1);
140    }  
141    else {
142      mark(RC5_T1);
143      space(RC5_T1);
144    }
145    data  <<= 1;
146  }
147  space(0); // Turn off at end
148}
149
150// Caller needs to take  care of flipping the toggle bit
151void IRsend::sendRC6(unsigned long data, int  nbits)
152{
153  enableIROut(36);
154  data = data << (32 - nbits);
155  mark(RC6_HDR_MARK);
156  space(RC6_HDR_SPACE);
157  mark(RC6_T1); // start bit
158  space(RC6_T1);
159  int t;
160  for (int i = 0; i < nbits; i++) {
161    if (i == 3) {
162      //  double-wide trailer bit
163      t = 2 * RC6_T1;
164    } 
165    else {
166      t  = RC6_T1;
167    }
168    if (data & TOPBIT) {
169      mark(t);
170      space(t);
171    } 
172    else {
173      space(t);
174      mark(t);
175    }
176
177    data  <<= 1;
178  }
179  space(0); // Turn off at end
180}
181void IRsend::sendPanasonic(unsigned  int address, unsigned long data) {
182    enableIROut(35);
183    mark(PANASONIC_HDR_MARK);
184    space(PANASONIC_HDR_SPACE);
185    
186    for(int i=0;i<16;i++)
187    {
188        mark(PANASONIC_BIT_MARK);
189        if (address & 0x8000) {
190            space(PANASONIC_ONE_SPACE);
191        } else {
192            space(PANASONIC_ZERO_SPACE);
193        }
194        address  <<= 1;        
195    }    
196    for (int i=0; i < 32; i++) {
197        mark(PANASONIC_BIT_MARK);
198        if (data & TOPBIT) {
199            space(PANASONIC_ONE_SPACE);
200        }  else {
201            space(PANASONIC_ZERO_SPACE);
202        }
203        data  <<= 1;
204    }
205    mark(PANASONIC_BIT_MARK);
206    space(0);
207}
208void IRsend::sendJVC(unsigned  long data, int nbits, int repeat)
209{
210    enableIROut(38);
211    data = data  << (32 - nbits);
212    if (!repeat){
213        mark(JVC_HDR_MARK);
214        space(JVC_HDR_SPACE);  
215    }
216    for (int i = 0; i < nbits; i++) {
217        if (data & TOPBIT)  {
218            mark(JVC_BIT_MARK);
219            space(JVC_ONE_SPACE); 
220        }  
221        else {
222            mark(JVC_BIT_MARK);
223            space(JVC_ZERO_SPACE);  
224        }
225        data <<= 1;
226    }
227    mark(JVC_BIT_MARK);
228    space(0);
229}
230
231void  IRsend::sendSAMSUNG(unsigned long data, int nbits)
232{
233  enableIROut(38);
234  mark(SAMSUNG_HDR_MARK);
235  space(SAMSUNG_HDR_SPACE);
236  for (int i = 0; i  < nbits; i++) {
237    if (data & TOPBIT) {
238      mark(SAMSUNG_BIT_MARK);
239      space(SAMSUNG_ONE_SPACE);
240    } 
241    else {
242      mark(SAMSUNG_BIT_MARK);
243      space(SAMSUNG_ZERO_SPACE);
244    }
245    data <<= 1;
246  }
247  mark(SAMSUNG_BIT_MARK);
248  space(0);
249}
250
251void IRsend::mark(int time) {
252  // Sends an IR mark for  the specified number of microseconds.
253  // The mark output is modulated at the  PWM frequency.
254  TIMER_ENABLE_PWM; // Enable pin 3 PWM output
255  if (time >  0) delayMicroseconds(time);
256}
257
258/* Leave pin off for time (given in microseconds)  */
259void IRsend::space(int time) {
260  // Sends an IR space for the specified  number of microseconds.
261  // A space is no output, so the PWM output is disabled.
262  TIMER_DISABLE_PWM; // Disable pin 3 PWM output
263  if (time > 0) delayMicroseconds(time);
264}
265
266void  IRsend::enableIROut(int khz) {
267  // Enables IR output.  The khz value controls  the modulation frequency in kilohertz.
268  // The IR output will be on pin 3 (OC2B).
269  // This routine is designed for 36-40KHz; if you use it for other values, it's  up to you
270  // to make sure it gives reasonable results.  (Watch out for overflow  / underflow / rounding.)
271  // TIMER2 is used in phase-correct PWM mode, with  OCR2A controlling the frequency and OCR2B
272  // controlling the duty cycle.
273  // There is no prescaling, so the output frequency is 16MHz / (2 * OCR2A)
274  // To turn the output on and off, we leave the PWM running, but connect and disconnect  the output pin.
275  // A few hours staring at the ATmega documentation and this  will all make sense.
276  // See my Secrets of Arduino PWM at http://arcfn.com/2009/07/secrets-of-arduino-pwm.html  for details.
277
278  
279  // Disable the Timer2 Interrupt (which is used for receiving  IR)
280  TIMER_DISABLE_INTR; //Timer2 Overflow Interrupt
281  
282  pinMode(TIMER_PWM_PIN,  OUTPUT);
283  digitalWrite(TIMER_PWM_PIN, LOW); // When not sending PWM, we want  it low
284  
285  // COM2A = 00: disconnect OC2A
286  // COM2B = 00: disconnect  OC2B; to send signal set to 10: OC2B non-inverted
287  // WGM2 = 101: phase-correct  PWM with OCRA as top
288  // CS2 = 000: no prescaling
289  // The top value for  the timer.  The modulation frequency will be SYSCLOCK / 2 / OCR2A.
290  TIMER_CONFIG_KHZ(khz);
291}
292
293IRrecv::IRrecv(int  recvpin)
294{
295  irparams.recvpin = recvpin;
296  irparams.blinkflag = 0;
297}
298
299//  initialization
300void IRrecv::enableIRIn() {
301  cli();
302  // setup pulse clock  timer interrupt
303  //Prescale /8 (16M/8 = 0.5 microseconds per tick)
304  // Therefore,  the timer interval can range from 0.5 to 128 microseconds
305  // depending on the  reset value (255 to 0)
306  TIMER_CONFIG_NORMAL();
307
308  //Timer2 Overflow Interrupt  Enable
309  TIMER_ENABLE_INTR;
310
311  TIMER_RESET;
312
313  sei();  // enable  interrupts
314
315  // initialize state machine variables
316  irparams.rcvstate  = STATE_IDLE;
317  irparams.rawlen = 0;
318
319  // set pin modes
320  pinMode(irparams.recvpin,  INPUT);
321}
322
323// enable/disable blinking of pin 13 on IR processing
324void  IRrecv::blink13(int blinkflag)
325{
326  irparams.blinkflag = blinkflag;
327  if  (blinkflag)
328    pinMode(BLINKLED, OUTPUT);
329}
330
331// TIMER2 interrupt code  to collect raw data.
332// Widths of alternating SPACE, MARK are recorded in rawbuf.
333//  Recorded in ticks of 50 microseconds.
334// rawlen counts the number of entries  recorded so far.
335// First entry is the SPACE between transmissions.
336// As  soon as a SPACE gets long, ready is set, state switches to IDLE, timing of SPACE  continues.
337// As soon as first MARK arrives, gap width is recorded, ready is  cleared, and new logging starts
338ISR(TIMER_INTR_NAME)
339{
340  TIMER_RESET;
341
342  uint8_t irdata = (uint8_t)digitalRead(irparams.recvpin);
343
344  irparams.timer++;  // One more 50us tick
345  if (irparams.rawlen >= RAWBUF) {
346    // Buffer overflow
347    irparams.rcvstate = STATE_STOP;
348  }
349  switch(irparams.rcvstate) {
350  case STATE_IDLE: // In the middle of a gap
351    if (irdata == MARK) {
352      if  (irparams.timer < GAP_TICKS) {
353        // Not big enough to be a gap.
354        irparams.timer  = 0;
355      } 
356      else {
357        // gap just ended, record duration and  start recording transmission
358        irparams.rawlen = 0;
359        irparams.rawbuf[irparams.rawlen++]  = irparams.timer;
360        irparams.timer = 0;
361        irparams.rcvstate =  STATE_MARK;
362      }
363    }
364    break;
365  case STATE_MARK: // timing MARK
366    if (irdata == SPACE) {   // MARK ended, record time
367      irparams.rawbuf[irparams.rawlen++]  = irparams.timer;
368      irparams.timer = 0;
369      irparams.rcvstate = STATE_SPACE;
370    }
371    break;
372  case STATE_SPACE: // timing SPACE
373    if (irdata ==  MARK) { // SPACE just ended, record it
374      irparams.rawbuf[irparams.rawlen++]  = irparams.timer;
375      irparams.timer = 0;
376      irparams.rcvstate = STATE_MARK;
377    } 
378    else { // SPACE
379      if (irparams.timer > GAP_TICKS) {
380        //  big SPACE, indicates gap between codes
381        // Mark current code as ready  for processing
382        // Switch to STOP
383        // Don't reset timer; keep  counting space width
384        irparams.rcvstate = STATE_STOP;
385      } 
386    }
387    break;
388  case STATE_STOP: // waiting, measuring gap
389    if (irdata  == MARK) { // reset gap timer
390      irparams.timer = 0;
391    }
392    break;
393  }
394
395  if (irparams.blinkflag) {
396    if (irdata == MARK) {
397      BLINKLED_ON();  // turn pin 13 LED on
398    } 
399    else {
400      BLINKLED_OFF();  // turn  pin 13 LED off
401    }
402  }
403}
404
405void IRrecv::resume() {
406  irparams.rcvstate  = STATE_IDLE;
407  irparams.rawlen = 0;
408}
409
410
411
412// Decodes the received  IR message
413// Returns 0 if no data ready, 1 if data ready.
414// Results of decoding  are stored in results
415int IRrecv::decode(decode_results *results) {
416  results->rawbuf  = irparams.rawbuf;
417  results->rawlen = irparams.rawlen;
418  if (irparams.rcvstate  != STATE_STOP) {
419    return ERR;
420  }
421#ifdef DEBUG
422  Serial.println("Attempting  NEC decode");
423#endif
424  if (decodeNEC(results)) {
425    return DECODED;
426  }
427#ifdef DEBUG
428  Serial.println("Attempting Sony decode");
429#endif
430  if (decodeSony(results)) {
431    return DECODED;
432  }
433#ifdef DEBUG
434  Serial.println("Attempting  Sanyo decode");
435#endif
436  if (decodeSanyo(results)) {
437    return DECODED;
438  }
439#ifdef DEBUG
440  Serial.println("Attempting Mitsubishi decode");
441#endif
442  if (decodeMitsubishi(results)) {
443    return DECODED;
444  }
445#ifdef DEBUG
446  Serial.println("Attempting RC5 decode");
447#endif  
448  if (decodeRC5(results))  {
449    return DECODED;
450  }
451#ifdef DEBUG
452  Serial.println("Attempting  RC6 decode");
453#endif 
454  if (decodeRC6(results)) {
455    return DECODED;
456  }
457#ifdef DEBUG
458    Serial.println("Attempting Panasonic decode");
459#endif  
460    if (decodePanasonic(results)) {
461        return DECODED;
462    }
463#ifdef  DEBUG
464    Serial.println("Attempting LG decode");
465#endif 
466    if (decodeLG(results))  {
467        return DECODED;
468    }
469#ifdef DEBUG
470    Serial.println("Attempting  JVC decode");
471#endif 
472    if (decodeJVC(results)) {
473        return DECODED;
474    }
475#ifdef DEBUG
476  Serial.println("Attempting SAMSUNG decode");
477#endif
478  if (decodeSAMSUNG(results)) {
479    return DECODED;
480  }
481  // decodeHash  returns a hash on any input.
482  // Thus, it needs to be last in the list.
483  // If you add any decodes, add them before this.
484  if (decodeHash(results))  {
485    return DECODED;
486  }
487  // Throw away and start over
488  resume();
489  return ERR;
490}
491
492// NECs have a repeat only 4 items long
493long IRrecv::decodeNEC(decode_results  *results) {
494  long data = 0;
495  int offset = 1; // Skip first space
496  //  Initial mark
497  if (!MATCH_MARK(results->rawbuf[offset], NEC_HDR_MARK)) {
498    return ERR;
499  }
500  offset++;
501  // Check for repeat
502  if (irparams.rawlen  == 4 &&
503    MATCH_SPACE(results->rawbuf[offset], NEC_RPT_SPACE) &&
504    MATCH_MARK(results->rawbuf[offset+1],  NEC_BIT_MARK)) {
505    results->bits = 0;
506    results->value = REPEAT;
507    results->decode_type  = NEC;
508    return DECODED;
509  }
510  if (irparams.rawlen < 2 * NEC_BITS + 4)  {
511    return ERR;
512  }
513  // Initial space  
514  if (!MATCH_SPACE(results->rawbuf[offset],  NEC_HDR_SPACE)) {
515    return ERR;
516  }
517  offset++;
518  for (int i = 0;  i < NEC_BITS; i++) {
519    if (!MATCH_MARK(results->rawbuf[offset], NEC_BIT_MARK))  {
520      return ERR;
521    }
522    offset++;
523    if (MATCH_SPACE(results->rawbuf[offset],  NEC_ONE_SPACE)) {
524      data = (data << 1) | 1;
525    } 
526    else if (MATCH_SPACE(results->rawbuf[offset],  NEC_ZERO_SPACE)) {
527      data <<= 1;
528    } 
529    else {
530      return  ERR;
531    }
532    offset++;
533  }
534  // Success
535  results->bits = NEC_BITS;
536  results->value = data;
537  results->decode_type = NEC;
538  return DECODED;
539}
540
541long  IRrecv::decodeSony(decode_results *results) {
542  long data = 0;
543  if (irparams.rawlen  < 2 * SONY_BITS + 2) {
544    return ERR;
545  }
546  int offset = 0; // Dont skip  first space, check its size
547
548  // Some Sony's deliver repeats fast after first
549  // unfortunately can't spot difference from of repeat from two fast clicks
550  if (results->rawbuf[offset] < SONY_DOUBLE_SPACE_USECS) {
551    // Serial.print("IR  Gap found: ");
552    results->bits = 0;
553    results->value = REPEAT;
554    results->decode_type  = SANYO;
555    return DECODED;
556  }
557  offset++;
558
559  // Initial mark
560  if (!MATCH_MARK(results->rawbuf[offset], SONY_HDR_MARK)) {
561    return ERR;
562  }
563  offset++;
564
565  while (offset + 1 < irparams.rawlen) {
566    if (!MATCH_SPACE(results->rawbuf[offset],  SONY_HDR_SPACE)) {
567      break;
568    }
569    offset++;
570    if (MATCH_MARK(results->rawbuf[offset],  SONY_ONE_MARK)) {
571      data = (data << 1) | 1;
572    } 
573    else if (MATCH_MARK(results->rawbuf[offset],  SONY_ZERO_MARK)) {
574      data <<= 1;
575    } 
576    else {
577      return  ERR;
578    }
579    offset++;
580  }
581
582  // Success
583  results->bits = (offset  - 1) / 2;
584  if (results->bits < 12) {
585    results->bits = 0;
586    return  ERR;
587  }
588  results->value = data;
589  results->decode_type = SONY;
590  return  DECODED;
591}
592
593// I think this is a Sanyo decoder - serial = SA 8650B
594//  Looks like Sony except for timings, 48 chars of data and time/space different
595long  IRrecv::decodeSanyo(decode_results *results) {
596  long data = 0;
597  if (irparams.rawlen  < 2 * SANYO_BITS + 2) {
598    return ERR;
599  }
600  int offset = 0; // Skip first  space
601  // Initial space  
602  /* Put this back in for debugging - note can't  use #DEBUG as if Debug on we don't see the repeat cos of the delay
603  Serial.print("IR  Gap: ");
604  Serial.println( results->rawbuf[offset]);
605  Serial.println( "test  against:");
606  Serial.println(results->rawbuf[offset]);
607  */
608  if (results->rawbuf[offset]  < SANYO_DOUBLE_SPACE_USECS) {
609    // Serial.print("IR Gap found: ");
610    results->bits  = 0;
611    results->value = REPEAT;
612    results->decode_type = SANYO;
613    return  DECODED;
614  }
615  offset++;
616
617  // Initial mark
618  if (!MATCH_MARK(results->rawbuf[offset],  SANYO_HDR_MARK)) {
619    return ERR;
620  }
621  offset++;
622
623  // Skip Second  Mark
624  if (!MATCH_MARK(results->rawbuf[offset], SANYO_HDR_MARK)) {
625    return  ERR;
626  }
627  offset++;
628
629  while (offset + 1 < irparams.rawlen) {
630    if  (!MATCH_SPACE(results->rawbuf[offset], SANYO_HDR_SPACE)) {
631      break;
632    }
633    offset++;
634    if (MATCH_MARK(results->rawbuf[offset], SANYO_ONE_MARK)) {
635      data = (data << 1) | 1;
636    } 
637    else if (MATCH_MARK(results->rawbuf[offset],  SANYO_ZERO_MARK)) {
638      data <<= 1;
639    } 
640    else {
641      return  ERR;
642    }
643    offset++;
644  }
645
646  // Success
647  results->bits = (offset  - 1) / 2;
648  if (results->bits < 12) {
649    results->bits = 0;
650    return  ERR;
651  }
652  results->value = data;
653  results->decode_type = SANYO;
654  return  DECODED;
655}
656
657// Looks like Sony except for timings, 48 chars of data and  time/space different
658long IRrecv::decodeMitsubishi(decode_results *results) {
659  // Serial.print("?!? decoding Mitsubishi:");Serial.print(irparams.rawlen); Serial.print("  want "); Serial.println( 2 * MITSUBISHI_BITS + 2);
660  long data = 0;
661  if  (irparams.rawlen < 2 * MITSUBISHI_BITS + 2) {
662    return ERR;
663  }
664  int  offset = 0; // Skip first space
665  // Initial space  
666  /* Put this back in  for debugging - note can't use #DEBUG as if Debug on we don't see the repeat cos  of the delay
667  Serial.print("IR Gap: ");
668  Serial.println( results->rawbuf[offset]);
669  Serial.println( "test against:");
670  Serial.println(results->rawbuf[offset]);
671  */
672  /* Not seeing double keys from Mitsubishi
673  if (results->rawbuf[offset]  < MITSUBISHI_DOUBLE_SPACE_USECS) {
674    // Serial.print("IR Gap found: ");
675    results->bits = 0;
676    results->value = REPEAT;
677    results->decode_type  = MITSUBISHI;
678    return DECODED;
679  }
680  */
681  offset++;
682
683  // Typical
684  // 14200 7 41 7 42 7 42 7 17 7 17 7 18 7 41 7 18 7 17 7 17 7 18 7 41 8 17 7 17  7 18 7 17 7 
685
686  // Initial Space
687  if (!MATCH_MARK(results->rawbuf[offset],  MITSUBISHI_HDR_SPACE)) {
688    return ERR;
689  }
690  offset++;
691  while (offset  + 1 < irparams.rawlen) {
692    if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ONE_MARK))  {
693      data = (data << 1) | 1;
694    } 
695    else if (MATCH_MARK(results->rawbuf[offset],  MITSUBISHI_ZERO_MARK)) {
696      data <<= 1;
697    } 
698    else {
699      //  Serial.println("A"); Serial.println(offset); Serial.println(results->rawbuf[offset]);
700      return ERR;
701    }
702    offset++;
703    if (!MATCH_SPACE(results->rawbuf[offset],  MITSUBISHI_HDR_SPACE)) {
704      // Serial.println("B"); Serial.println(offset);  Serial.println(results->rawbuf[offset]);
705      break;
706    }
707    offset++;
708  }
709
710  // Success
711  results->bits = (offset - 1) / 2;
712  if (results->bits  < MITSUBISHI_BITS) {
713    results->bits = 0;
714    return ERR;
715  }
716  results->value  = data;
717  results->decode_type = MITSUBISHI;
718  return DECODED;
719}
720
721
722//  Gets one undecoded level at a time from the raw buffer.
723// The RC5/6 decoding  is easier if the data is broken into time intervals.
724// E.g. if the buffer has  MARK for 2 time intervals and SPACE for 1,
725// successive calls to getRClevel  will return MARK, MARK, SPACE.
726// offset and used are updated to keep track of  the current position.
727// t1 is the time interval for a single bit in microseconds.
728//  Returns -1 for error (measured time interval is not a multiple of t1).
729int IRrecv::getRClevel(decode_results  *results, int *offset, int *used, int t1) {
730  if (*offset >= results->rawlen)  {
731    // After end of recorded buffer, assume SPACE.
732    return SPACE;
733  }
734  int width = results->rawbuf[*offset];
735  int val = ((*offset) % 2) ?  MARK : SPACE;
736  int correction = (val == MARK) ? MARK_EXCESS : - MARK_EXCESS;
737
738  int avail;
739  if (MATCH(width, t1 + correction)) {
740    avail = 1;
741  }  
742  else if (MATCH(width, 2*t1 + correction)) {
743    avail = 2;
744  } 
745  else if (MATCH(width, 3*t1 + correction)) {
746    avail = 3;
747  } 
748  else  {
749    return -1;
750  }
751
752  (*used)++;
753  if (*used >= avail) {
754    *used  = 0;
755    (*offset)++;
756  }
757#ifdef DEBUG
758  if (val == MARK) {
759    Serial.println("MARK");
760  } 
761  else {
762    Serial.println("SPACE");
763  }
764#endif
765  return  val;   
766}
767
768long IRrecv::decodeRC5(decode_results *results) {
769  if (irparams.rawlen  < MIN_RC5_SAMPLES + 2) {
770    return ERR;
771  }
772  int offset = 1; // Skip  gap space
773  long data = 0;
774  int used = 0;
775  // Get start bits
776  if  (getRClevel(results, &offset, &used, RC5_T1) != MARK) return ERR;
777  if (getRClevel(results,  &offset, &used, RC5_T1) != SPACE) return ERR;
778  if (getRClevel(results, &offset,  &used, RC5_T1) != MARK) return ERR;
779  int nbits;
780  for (nbits = 0; offset  < irparams.rawlen; nbits++) {
781    int levelA = getRClevel(results, &offset, &used,  RC5_T1); 
782    int levelB = getRClevel(results, &offset, &used, RC5_T1);
783    if  (levelA == SPACE && levelB == MARK) {
784      // 1 bit
785      data = (data <<  1) | 1;
786    } 
787    else if (levelA == MARK && levelB == SPACE) {
788      //  zero bit
789      data <<= 1;
790    } 
791    else {
792      return ERR;
793    }  
794  }
795
796  // Success
797  results->bits = nbits;
798  results->value = data;
799  results->decode_type = RC5;
800  return DECODED;
801}
802
803long IRrecv::decodeRC6(decode_results  *results) {
804  if (results->rawlen < MIN_RC6_SAMPLES) {
805    return ERR;
806  }
807  int offset = 1; // Skip first space
808  // Initial mark
809  if (!MATCH_MARK(results->rawbuf[offset],  RC6_HDR_MARK)) {
810    return ERR;
811  }
812  offset++;
813  if (!MATCH_SPACE(results->rawbuf[offset],  RC6_HDR_SPACE)) {
814    return ERR;
815  }
816  offset++;
817  long data = 0;
818  int used = 0;
819  // Get start bit (1)
820  if (getRClevel(results, &offset,  &used, RC6_T1) != MARK) return ERR;
821  if (getRClevel(results, &offset, &used,  RC6_T1) != SPACE) return ERR;
822  int nbits;
823  for (nbits = 0; offset < results->rawlen;  nbits++) {
824    int levelA, levelB; // Next two levels
825    levelA = getRClevel(results,  &offset, &used, RC6_T1); 
826    if (nbits == 3) {
827      // T bit is double wide;  make sure second half matches
828      if (levelA != getRClevel(results, &offset,  &used, RC6_T1)) return ERR;
829    } 
830    levelB = getRClevel(results, &offset,  &used, RC6_T1);
831    if (nbits == 3) {
832      // T bit is double wide; make  sure second half matches
833      if (levelB != getRClevel(results, &offset, &used,  RC6_T1)) return ERR;
834    } 
835    if (levelA == MARK && levelB == SPACE) { //  reversed compared to RC5
836      // 1 bit
837      data = (data << 1) | 1;
838    } 
839    else if (levelA == SPACE && levelB == MARK) {
840      // zero bit
841      data <<= 1;
842    } 
843    else {
844      return ERR; // Error
845    }  
846  }
847  // Success
848  results->bits = nbits;
849  results->value = data;
850  results->decode_type = RC6;
851  return DECODED;
852}
853long IRrecv::decodePanasonic(decode_results  *results) {
854    unsigned long long data = 0;
855    int offset = 1;
856    
857    if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_MARK)) {
858        return  ERR;
859    }
860    offset++;
861    if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_SPACE))  {
862        return ERR;
863    }
864    offset++;
865    
866    // decode address
867    for (int i = 0; i < PANASONIC_BITS; i++) {
868        if (!MATCH_MARK(results->rawbuf[offset++],  PANASONIC_BIT_MARK)) {
869            return ERR;
870        }
871        if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ONE_SPACE))  {
872            data = (data << 1) | 1;
873        } else if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ZERO_SPACE))  {
874            data <<= 1;
875        } else {
876            return ERR;
877        }
878        offset++;
879    }
880    results->value = (unsigned long)data;
881    results->panasonicAddress = (unsigned int)(data >> 32);
882    results->decode_type  = PANASONIC;
883    results->bits = PANASONIC_BITS;
884    return DECODED;
885}
886
887long  IRrecv::decodeLG(decode_results *results) {
888    long data = 0;
889    int offset  = 1; // Skip first space
890  
891    // Initial mark
892    if (!MATCH_MARK(results->rawbuf[offset],  LG_HDR_MARK)) {
893        return ERR;
894    }
895    offset++; 
896    if (irparams.rawlen  < 2 * LG_BITS + 1 ) {
897        return ERR;
898    }
899    // Initial space 
900    if (!MATCH_SPACE(results->rawbuf[offset], LG_HDR_SPACE)) {
901        return  ERR;
902    }
903    offset++;
904    for (int i = 0; i < LG_BITS; i++) {
905        if  (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)) {
906            return ERR;
907        }
908        offset++;
909        if (MATCH_SPACE(results->rawbuf[offset],  LG_ONE_SPACE)) {
910            data = (data << 1) | 1;
911        } 
912        else  if (MATCH_SPACE(results->rawbuf[offset], LG_ZERO_SPACE)) {
913            data <<=  1;
914        } 
915        else {
916            return ERR;
917        }
918        offset++;
919    }
920    //Stop bit
921    if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)){
922        return ERR;
923    }
924    // Success
925    results->bits = LG_BITS;
926    results->value = data;
927    results->decode_type = LG;
928    return DECODED;
929}
930
931
932long  IRrecv::decodeJVC(decode_results *results) {
933    long data = 0;
934    int offset  = 1; // Skip first space
935    // Check for repeat
936    if (irparams.rawlen -  1 == 33 &&
937        MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK) &&
938        MATCH_MARK(results->rawbuf[irparams.rawlen-1],  JVC_BIT_MARK)) {
939        results->bits = 0;
940        results->value = REPEAT;
941        results->decode_type = JVC;
942        return DECODED;
943    } 
944    //  Initial mark
945    if (!MATCH_MARK(results->rawbuf[offset], JVC_HDR_MARK)) {
946        return ERR;
947    }
948    offset++; 
949    if (irparams.rawlen < 2 *  JVC_BITS + 1 ) {
950        return ERR;
951    }
952    // Initial space 
953    if  (!MATCH_SPACE(results->rawbuf[offset], JVC_HDR_SPACE)) {
954        return ERR;
955    }
956    offset++;
957    for (int i = 0; i < JVC_BITS; i++) {
958        if  (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) {
959            return ERR;
960        }
961        offset++;
962        if (MATCH_SPACE(results->rawbuf[offset],  JVC_ONE_SPACE)) {
963            data = (data << 1) | 1;
964        } 
965        else  if (MATCH_SPACE(results->rawbuf[offset], JVC_ZERO_SPACE)) {
966            data  <<= 1;
967        } 
968        else {
969            return ERR;
970        }
971        offset++;
972    }
973    //Stop bit
974    if (!MATCH_MARK(results->rawbuf[offset],  JVC_BIT_MARK)){
975        return ERR;
976    }
977    // Success
978    results->bits  = JVC_BITS;
979    results->value = data;
980    results->decode_type = JVC;
981    return DECODED;
982}
983
984// SAMSUNGs have a repeat only 4 items long
985long  IRrecv::decodeSAMSUNG(decode_results *results) {
986  long data = 0;
987  int offset  = 1; // Skip first space
988  // Initial mark
989  if (!MATCH_MARK(results->rawbuf[offset],  SAMSUNG_HDR_MARK)) {
990    return ERR;
991  }
992  offset++;
993  // Check for  repeat
994  if (irparams.rawlen == 4 &&
995    MATCH_SPACE(results->rawbuf[offset],  SAMSUNG_RPT_SPACE) &&
996    MATCH_MARK(results->rawbuf[offset+1], SAMSUNG_BIT_MARK))  {
997    results->bits = 0;
998    results->value = REPEAT;
999    results->decode_type  = SAMSUNG;
1000    return DECODED;
1001  }
1002  if (irparams.rawlen < 2 * SAMSUNG_BITS  + 4) {
1003    return ERR;
1004  }
1005  // Initial space  
1006  if (!MATCH_SPACE(results->rawbuf[offset],  SAMSUNG_HDR_SPACE)) {
1007    return ERR;
1008  }
1009  offset++;
1010  for (int i =  0; i < SAMSUNG_BITS; i++) {
1011    if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK))  {
1012      return ERR;
1013    }
1014    offset++;
1015    if (MATCH_SPACE(results->rawbuf[offset],  SAMSUNG_ONE_SPACE)) {
1016      data = (data << 1) | 1;
1017    } 
1018    else if  (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) {
1019      data <<= 1;
1020    } 
1021    else {
1022      return ERR;
1023    }
1024    offset++;
1025  }
1026  //  Success
1027  results->bits = SAMSUNG_BITS;
1028  results->value = data;
1029  results->decode_type  = SAMSUNG;
1030  return DECODED;
1031}
1032
1033/* -----------------------------------------------------------------------
1034  * hashdecode - decode an arbitrary IR code.
1035 * Instead of decoding using a standard  encoding scheme
1036 * (e.g. Sony, NEC, RC5), the code is hashed to a 32-bit value.
1037  *
1038 * The algorithm: look at the sequence of MARK signals, and see if each one
1039  * is shorter (0), the same length (1), or longer (2) than the previous.
1040 * Do  the same with the SPACE signals.  Hszh the resulting sequence of 0's,
1041 * 1's,  and 2's to a 32-bit value.  This will give a unique value for each
1042 * different  code (probably), for most code systems.
1043 *
1044 * http://arcfn.com/2010/01/using-arbitrary-remotes-with-arduino.html
1045  */
1046
1047// Compare two tick values, returning 0 if newval is shorter,
1048// 1  if newval is equal, and 2 if newval is longer
1049// Use a tolerance of 20%
1050int  IRrecv::compare(unsigned int oldval, unsigned int newval) {
1051  if (newval < oldval  * .8) {
1052    return 0;
1053  } 
1054  else if (oldval < newval * .8) {
1055    return  2;
1056  } 
1057  else {
1058    return 1;
1059  }
1060}
1061
1062// Use FNV hash algorithm:  http://isthe.com/chongo/tech/comp/fnv/#FNV-param
1063#define FNV_PRIME_32 16777619
1064#define  FNV_BASIS_32 2166136261
1065
1066/* Converts the raw code values into a 32-bit hash  code.
1067 * Hopefully this code is unique for each button.
1068 * This isn't a "real"  decoding, just an arbitrary value.
1069 */
1070long IRrecv::decodeHash(decode_results  *results) {
1071  // Require at least 6 samples to prevent triggering on noise
1072  if (results->rawlen < 6) {
1073    return ERR;
1074  }
1075  long hash = FNV_BASIS_32;
1076  for (int i = 1; i+2 < results->rawlen; i++) {
1077    int value =  compare(results->rawbuf[i],  results->rawbuf[i+2]);
1078    // Add value into the hash
1079    hash = (hash * FNV_PRIME_32)  ^ value;
1080  }
1081  results->value = hash;
1082  results->bits = 32;
1083  results->decode_type  = UNKNOWN;
1084  return DECODED;
1085}
1086
1087/* Sharp and DISH support by Todd Treece  ( http://unionbridge.org/design/ircommand )
1088
1089The Dish send function needs  to be repeated 4 times, and the Sharp function
1090has the necessary repeat built  in because of the need to invert the signal.
1091
1092Sharp protocol documentation:
1093http://www.sbprojects.com/knowledge/ir/sharp.htm
1094
1095Here  are the LIRC files that I found that seem to match the remote codes
1096from the  oscilloscope:
1097
1098Sharp LCD TV:
1099http://lirc.sourceforge.net/remotes/sharp/GA538WJSA
1100
1101DISH  NETWORK (echostar 301):
1102http://lirc.sourceforge.net/remotes/echostar/301_501_3100_5100_58xx_59xx
1103
1104For  the DISH codes, only send the last for characters of the hex.
1105i.e. use 0x1C10  instead of 0x0000000000001C10 which is listed in the
1106linked LIRC file.
1107*/
1108
1109void  IRsend::sendSharpRaw(unsigned long data, int nbits) {
1110  enableIROut(38);
1111
1112  // Sending codes in bursts of 3 (normal, inverted, normal) makes transmission
1113  // much more reliable. That's the exact behaviour of CD-S6470 remote control.
1114  for (int n = 0; n < 3; n++) {
1115    for (int i = 1 << (nbits-1); i > 0; i>>=1)  {
1116      if (data & i) {
1117        mark(SHARP_BIT_MARK);
1118        space(SHARP_ONE_SPACE);
1119      }
1120      else {
1121        mark(SHARP_BIT_MARK);
1122        space(SHARP_ZERO_SPACE);
1123      }
1124    }
1125    
1126    mark(SHARP_BIT_MARK);
1127    space(SHARP_ZERO_SPACE);
1128    delay(40);
1129
1130    data = data ^ SHARP_TOGGLE_MASK;
1131  }
1132}
1133
1134//  Sharp send compatible with data obtained through decodeSharp
1135void IRsend::sendSharp(unsigned  int address, unsigned int command) {
1136  sendSharpRaw((address << 10) | (command  << 2) | 2, 15);
1137}
1138
1139void IRsend::sendDISH(unsigned long data, int nbits)  {
1140  enableIROut(56);
1141  mark(DISH_HDR_MARK);
1142  space(DISH_HDR_SPACE);
1143  for (int i = 0; i < nbits; i++) {
1144    if (data & DISH_TOP_BIT) {
1145      mark(DISH_BIT_MARK);
1146      space(DISH_ONE_SPACE);
1147    }
1148    else {
1149      mark(DISH_BIT_MARK);
1150      space(DISH_ZERO_SPACE);
1151    }
1152    data <<= 1;
1153  }
1154}
1155

1#include "IRremote.h"
2
3int receiver = 9; // Signal Pin of IR receiver   to Arduino Digital Pin 11
4#define led 7 // Power LED
5
6#define m1_pwm 3
7#define   m1_A 4
8#define m1_B 5
9
10#define m2_pwm 11
11#define m2_A 12
12#define   m2_B 13
13
14int power = 0; // controls except for toggling power can only be   used when "on" (power = 1)
15
16/*-----( Declare objects )-----*/
17IRrecv   irrecv(receiver);     // create instance of 'irrecv'
18decode_results results;       // create instance of 'decode_results'
19
20/*-----( Function )-----*/
21void   translateIR() // takes action based on IR code received
22
23// describing Remote   IR codes 
24
25{
26
27  switch(results.value)
28
29  {
30  case 0xFFA25D:   
31  Serial.println("POWER");
32  power += 1;
33  power = power % 2;
34  Serial.println(power);
35   break;
36  
37  case 0xFFE21D: 
38  Serial.println("FUNC/STOP"); 
39  Serial.println("f1");
40   break;
41  
42  case 0xFF629D: 
43  Serial.println("VOL+"); 
44  digitalWrite(m1_A,   HIGH);
45  digitalWrite(m1_B, LOW);
46  digitalWrite(m2_A, HIGH);
47  digitalWrite(m2_B,   LOW);
48  digitalWrite(m1_pwm, HIGH);
49  digitalWrite(m2_pwm, HIGH);
50  break;
51   
52  case 0xFF22DD: 
53  Serial.println("FAST BACK");
54  digitalWrite(m2_A,   LOW);
55  digitalWrite(m2_B, HIGH);    
56  digitalWrite(m1_A, HIGH);
57  digitalWrite(m1_B,   LOW);
58  digitalWrite(m1_pwm, HIGH);
59  digitalWrite(m2_pwm, LOW);
60  break;
61   
62  case 0xFF02FD: 
63  Serial.println("PAUSE"); 
64  digitalWrite(m1_pwm,   LOW);
65  digitalWrite(m2_pwm, LOW);   
66  break;
67  
68  case 0xFFC23D: 
69   Serial.println("FAST FORWARD");   
70  digitalWrite(m2_A, HIGH);
71  digitalWrite(m2_B,   LOW);
72  digitalWrite(m1_A, LOW);
73  digitalWrite(m1_B, HIGH);
74  digitalWrite(m2_pwm,   HIGH);
75  digitalWrite(m1_pwm, LOW);
76  break;
77  
78  case 0xFFA857: 
79   Serial.println("VOL-");
80  digitalWrite(m1_A, LOW);
81  digitalWrite(m1_B,   HIGH);
82  digitalWrite(m2_A, LOW);
83  digitalWrite(m2_B, HIGH);
84  digitalWrite(m1_pwm,   HIGH);
85  digitalWrite(m2_pwm, HIGH);    
86  break;
87
88  case 0xFFFFFFFF:   Serial.println(" REPEAT"); break;  
89
90  default: 
91    Serial.println("   other button   ");
92
93  }// End Case
94
95  delay(500); // Do not get immediate   repeat
96
97
98} //END translateIR
99void setup()   /*----( SETUP: RUNS ONCE   )----*/
100{
101  pinMode(m1_pwm,OUTPUT);
102  pinMode(m1_A,OUTPUT);
103  pinMode(m1_B,OUTPUT);
104   pinMode(m2_pwm,OUTPUT);
105  pinMode(m2_A,OUTPUT);
106  pinMode(m2_B,OUTPUT);
107   Serial.begin(9600);
108  Serial.println("IR Receiver Button Decode"); 
109  irrecv.enableIRIn();   // Start the receiver
110
111}/*--(end setup )---*/
112
113
114void loop()   /*----(   LOOP: RUNS CONSTANTLY )----*/
115{
116  if (power == 1) {
117    digitalWrite(led,   HIGH);
118    if (irrecv.decode(&results)) // have we received an IR signal?
119     {
120      translateIR(); 
121      irrecv.resume(); // receive the next value
122     }
123  }
124  if (power == 0) {
125    digitalWrite(led, LOW);
126    digitalWrite(m1_pwm,   LOW);
127    digitalWrite(m2_pwm, LOW);
128    if (irrecv.decode(&results)) // have   we received an IR signal?
129    {
130      switch(results.value) 
131      {
132       case 0xFFA25D: 
133      Serial.println("POWER");
134      power += 1;
135       power = power % 2;
136      Serial.println(power);
137      break;
138      }
139       irrecv.resume(); // receive the next value
140    }
141  }
142}/* --(end main   loop )-- */