【二叔科技】学习红外接收

二叔科技

1. IRrecv::IRrecv(int recvpin)
   
2. {
   
3.   irparams.recvpin = recvpin;
   
4.   irparams.blinkflag = 0;
   
5. }
   

复制代码

1. // initialization
   
2. void IRrecv::enableIRIn() {
   
3.   cli();
   
4.   // setup pulse clock timer interrupt
   
5.   //Prescale /8 (16M/8 = 0.5 microseconds per tick)
   
6.   // Therefore, the timer interval can range from 0.5 to 128 microseconds
   
7.   // depending on the reset value (255 to 0)
   
8.   TIMER_CONFIG_NORMAL();
   
9. 
   
10.   //Timer2 Overflow Interrupt Enable
    
11.   TIMER_ENABLE_INTR;
    
12. 
    
13.   TIMER_RESET;
    
14. 
    
15.   sei();  // enable interrupts
    
16. 
    
17.   // initialize state machine variables
    
18.   irparams.rcvstate = STATE_IDLE;
    
19.   irparams.rawlen = 0;
    
20. 
    
21.   // set pin modes
    
22.   pinMode(irparams.recvpin, INPUT);
    
23. }
    

复制代码

1. // enable/disable blinking of pin 13 on IR processing
   
2. void IRrecv::blink13(int blinkflag)
   
3. {
   
4.   irparams.blinkflag = blinkflag;
   
5.   if (blinkflag)
   
6.     pinMode(BLINKLED, OUTPUT);
   
7. }

复制代码

1. void IRrecv::resume() {
   
2.   irparams.rcvstate = STATE_IDLE;
   
3.   irparams.rawlen = 0;
   
4. }

复制代码

二叔科技

1. // Decodes the received IR message
   
2. // Returns 0 if no data ready, 1 if data ready.
   
3. // Results of decoding are stored in results
   
4. int IRrecv::decode(decode_results *results) {
   
5.   results->rawbuf = irparams.rawbuf;
   
6.   results->rawlen = irparams.rawlen;
   
7.   if (irparams.rcvstate != STATE_STOP) {
   
8.     return ERR;
   
9.   }
   
10. #ifdef DEBUG
    
11.   Serial.println("Attempting NEC decode");
    
12. #endif
    
13.   if (decodeNEC(results)) {
    
14.     return DECODED;
    
15.   }
    
16. #ifdef DEBUG
    
17.   Serial.println("Attempting Sony decode");
    
18. #endif
    
19.   if (decodeSony(results)) {
    
20.     return DECODED;
    
21.   }
    
22. #ifdef DEBUG
    
23.   Serial.println("Attempting Sanyo decode");
    
24. #endif
    
25.   if (decodeSanyo(results)) {
    
26.     return DECODED;
    
27.   }
    
28. #ifdef DEBUG
    
29.   Serial.println("Attempting Mitsubishi decode");
    
30. #endif
    
31.   if (decodeMitsubishi(results)) {
    
32.     return DECODED;
    
33.   }
    
34. #ifdef DEBUG
    
35.   Serial.println("Attempting RC5 decode");
    
36. #endif  
    
37.   if (decodeRC5(results)) {
    
38.     return DECODED;
    
39.   }
    
40. #ifdef DEBUG
    
41.   Serial.println("Attempting RC6 decode");
    
42. #endif
    
43.   if (decodeRC6(results)) {
    
44.     return DECODED;
    
45.   }
    
46. #ifdef DEBUG
    
47.     Serial.println("Attempting Panasonic decode");
    
48. #endif
    
49.     if (decodePanasonic(results)) {
    
50.         return DECODED;
    
51.     }
    
52. #ifdef DEBUG
    
53.     Serial.println("Attempting LG decode");
    
54. #endif
    
55.     if (decodeLG(results)) {
    
56.         return DECODED;
    
57.     }
    
58. #ifdef DEBUG
    
59.     Serial.println("Attempting JVC decode");
    
60. #endif
    
61.     if (decodeJVC(results)) {
    
62.         return DECODED;
    
63.     }
    
64. #ifdef DEBUG
    
65.   Serial.println("Attempting SAMSUNG decode");
    
66. #endif
    
67.   if (decodeSAMSUNG(results)) {
    
68.     return DECODED;
    
69.   }
    
70.   // decodeHash returns a hash on any input.
    
71.   // Thus, it needs to be last in the list.
    
72.   // If you add any decodes, add them before this.
    
73.   if (decodeHash(results)) {
    
74.     return DECODED;
    
75.   }
    
76.   // Throw away and start over
    
77.   resume();
    
78.   return ERR;
    
79. }
    

复制代码

二叔科技

1. // TIMER2 interrupt code to collect raw data.
   
2. // Widths of alternating SPACE, MARK are recorded in rawbuf.
   
3. // Recorded in ticks of 50 microseconds.
   
4. // rawlen counts the number of entries recorded so far.
   
5. // First entry is the SPACE between transmissions.
   
6. // As soon as a SPACE gets long, ready is set, state switches to IDLE, timing of SPACE continues.
   
7. // As soon as first MARK arrives, gap width is recorded, ready is cleared, and new logging starts
   
8. ISR(TIMER_INTR_NAME)
   
9. {
   
10.   TIMER_RESET;
    
11. 
    
12.   uint8_t irdata = (uint8_t)digitalRead(irparams.recvpin);
    
13. 
    
14.   irparams.timer++; // One more 50us tick
    
15.   if (irparams.rawlen >= RAWBUF) {
    
16.     // Buffer overflow
    
17.     irparams.rcvstate = STATE_STOP;
    
18.   }
    
19.   switch(irparams.rcvstate) {
    
20.   case STATE_IDLE: // In the middle of a gap
    
21.     if (irdata == MARK) {
    
22.       if (irparams.timer < GAP_TICKS) {
    
23.         // Not big enough to be a gap.
    
24.         irparams.timer = 0;
    
25.       }
    
26.       else {
    
27.         // gap just ended, record duration and start recording transmission
    
28.         irparams.rawlen = 0;
    
29.         irparams.rawbuf[irparams.rawlen++] = irparams.timer;
    
30.         irparams.timer = 0;
    
31.         irparams.rcvstate = STATE_MARK;
    
32.       }
    
33.     }
    
34.     break;
    
35.   case STATE_MARK: // timing MARK
    
36.     if (irdata == SPACE) {   // MARK ended, record time
    
37.       irparams.rawbuf[irparams.rawlen++] = irparams.timer;
    
38.       irparams.timer = 0;
    
39.       irparams.rcvstate = STATE_SPACE;
    
40.     }
    
41.     break;
    
42.   case STATE_SPACE: // timing SPACE
    
43.     if (irdata == MARK) { // SPACE just ended, record it
    
44.       irparams.rawbuf[irparams.rawlen++] = irparams.timer;
    
45.       irparams.timer = 0;
    
46.       irparams.rcvstate = STATE_MARK;
    
47.     }
    
48.     else { // SPACE
    
49.       if (irparams.timer > GAP_TICKS) {
    
50.         // big SPACE, indicates gap between codes
    
51.         // Mark current code as ready for processing
    
52.         // Switch to STOP
    
53.         // Don't reset timer; keep counting space width
    
54.         irparams.rcvstate = STATE_STOP;
    
55.       }
    
56.     }
    
57.     break;
    
58.   case STATE_STOP: // waiting, measuring gap
    
59.     if (irdata == MARK) { // reset gap timer
    
60.       irparams.timer = 0;
    
61.     }
    
62.     break;
    
63.   }
    
64. 
    
65.   if (irparams.blinkflag) {
    
66.     if (irdata == MARK) {
    
67.       BLINKLED_ON();  // turn pin 13 LED on
    
68.     }
    
69.     else {
    
70.       BLINKLED_OFF();  // turn pin 13 LED off
    
71.     }
    
72.   }
    
73. }
    
74. 
    
75. void IRrecv::resume() {
    
76.   irparams.rcvstate = STATE_IDLE;
    
77.   irparams.rawlen = 0;
    
78. }
    

复制代码