question about IRrecord example

Hardware Arduino Due
1

i'm using this example on DUE board and I didn't understand some lines and symbols.
for instance in this line : codeType = results->decode_type;
what does the symbol " -> ", mean or does ?
also this line : i <= codeLen
what does this symbol mean : <=
is there are some explanation about this example beside the explanation inside the example itself?

2

Can you post your code

3

/*

  • IRrecord: record and play back IR signals as a minimal
  • An IR detector/demodulator must be connected to the input RECV_PIN.
  • An IR LED must be connected to the output PWM pin 3 works for arduino Uno,
  • for arduino Due it works with PWM pin 7
  • A button must be connected to the input BUTTON_PIN; this is the send button.
  • A visible LED can be connected to STATUS_PIN to provide status.
  • The logic is:
  • If the button is pressed, send the IR code.
  • If an IR code is received, record it.
  • Version 0.11 September, 2009
  • Copyright 2009 Ken Shirriff
  • http://arcfn.com
    */

#include <IRremote2.h>

boolean debounce (boolean last, int BUTTON) //debounce function avoid bouncing button
{

boolean current = digitalRead(BUTTON);
if (last != current)
{
delay (5);
current = digitalRead(BUTTON);
}
return current;
}

boolean lastButton = LOW;
int RECV_PIN = 11;
int BUTTON_PIN = 12;
int STATUS_PIN = 13;

IRrecv irrecv(RECV_PIN); //create an IRrecv object
IRsend irsend;

decode_results results; //stores results from IR detector

void setup()
{
Serial.begin(9600); // communication cannel
irrecv.enableIRIn(); // Start the receiver object
pinMode(BUTTON_PIN, INPUT);
pinMode(STATUS_PIN, OUTPUT);
}

// Storage for the recorded code
int codeType = -1; // The type of code
unsigned long codeValue; // The code value if not raw ** unsigned long is up to 32 bit string **
unsigned int rawCodes[RAWBUF]; // The durations if raw
int codeLen; // The length of the code
int toggle = 0; // The RC5/6 toggle state

// Stores the code for later playback
// Most of this code is just logging
void storeCode(decode_results *results) {
codeType = results->decode_type;
int count = results->rawlen;
if (codeType == UNKNOWN) {
Serial.println("Received unknown code, saving as raw");
codeLen = results->rawlen - 1;
// To store raw codes:
// Drop first value (gap)
// Convert from ticks to microseconds
// Tweak marks shorter, and spaces longer to cancel out IR receiver distortion
for (int i = 1; i <= codeLen; i++) {
if (i % 2) {
// Mark
rawCodes[i - 1] = results->rawbuf*USECPERTICK - MARK_EXCESS;

  • Serial.print(" m");*
  • }*
  • else {*
  • // Space*
    rawCodes[i - 1] = results->rawbufUSECPERTICK + MARK_EXCESS;
    _     Serial.print(" s");_
    _     }_
    _     Serial.print(rawCodes[i - 1], DEC);_
    _     }_
    _     Serial.println("");_
    _     }_
    _     else {_
    _     if (codeType == NEC) {_
    _     Serial.print("Received NEC: ");_
    _     if (results->value == REPEAT) {_
    _     // Don't record a NEC repeat value as that's useless._
    _     Serial.println("repeat; ignoring.");_
    _     return;_
    _     }_
    _     }_
    _     else if (codeType == SONY) {_
    _     Serial.print("Received SONY: ");_
    _     }_
    _     else if (codeType == RC5) {_
    _     Serial.print("Received RC5: ");_
    _     }_
    _     else if (codeType == RC6) {_
    _     Serial.print("Received RC6: ");_
    _     }_
    _     else {_
    _     Serial.print("Unexpected codeType ");_
    _     Serial.print(codeType, DEC);_
    _     Serial.println("");_
    _     }_
    _     Serial.println(results->value, HEX);_
    _     codeValue = results->value;_
    _     codeLen = results->bits;_
    _     }_
    _    }_
    void sendCode(int repeat) {
    _     if (codeType == NEC) {_
    _     if (repeat) {_
    _     irsend.sendNEC(REPEAT, codeLen);_
    _     Serial.println("Sent NEC repeat");_
    _     }_
    _     else {_
    _     irsend.sendNEC(codeValue, codeLen);_
    _     Serial.print("Sent NEC ");_
    _     Serial.println(codeValue, HEX);_
    _     }_
    _     }_
    _     else if (codeType == SONY) {_
    _     irsend.sendSony(codeValue, codeLen);_
    _     Serial.print("Sent Sony ");_
    _     Serial.println(codeValue, HEX);_
    _     }_
    _     else if (codeType == RC5 || codeType == RC6) {_
    _     if (!repeat) {_
    _     // Flip the toggle bit for a new button press*_
    * toggle = 1 - toggle;*
    * }*
    * // Put the toggle bit into the code to send*
    * codeValue = codeValue & ~(1 << (codeLen - 1));*
    * codeValue = codeValue | (toggle << (codeLen - 1));*
    * if (codeType == RC5) {*
    * Serial.print("Sent RC5 ");*
    * Serial.println(codeValue, HEX);*
    * irsend.sendRC5(codeValue, codeLen);*
    * }*
    * else {*
    * irsend.sendRC6(codeValue, codeLen);*
    * Serial.print("Sent RC6 ");*
    * Serial.println(codeValue, HEX);*
    * }*
    * }*
    _ else if (codeType == UNKNOWN /* i.e. raw /) {_
    _     // Assume 38 KHz*_
    * irsend.sendRaw(rawCodes, codeLen, 38);*
    * Serial.println("Sent raw");*
    * }*
    }
    int lastButtonState;
    void loop() {
    * // If button pressed, send the code.*
    // int buttonState = digitalRead(BUTTON_PIN);
    * int buttonState = debounce(lastButton,BUTTON_PIN);
    _     if (lastButtonState == HIGH && buttonState == LOW) {_
    _     Serial.println("Released");_
    _     irrecv.enableIRIn(); // Re-enable receiver*_
    * }*
    * if (buttonState) {*
    * Serial.println("Pressed, sending");*
    * digitalWrite(STATUS_PIN, HIGH);
    _     sendCode(lastButtonState == buttonState);_
    digitalWrite(STATUS_PIN, LOW);
    _     delay(50); // Wait a bit between retransmissions*_
    * }*
    * else if (irrecv.decode(&results)) { //this is true if a message has been received*
    * digitalWrite(STATUS_PIN, HIGH);
    _     storeCode(&results);_
    _     irrecv.resume(); //watch out for another message*_
    * digitalWrite(STATUS_PIN, LOW);
    _     }_
    _     lastButtonState = buttonState;_
    _    }*_

Here is it, the code.