Arduino 433Mhz / IR Board

Lochraster Layout

Quelltext

    /*
     * Torsten Amshove <torsten@amshove.net>
     *
     * IR_433_Board - Selbstgelötetes Board mir IR Sender/Empfänger und 433Mhz Sender/Empfänger
     *
     * Pin 2 - 433 Mhz Empfänger - Ist vorgegeben, kann nicht geändert werden
     * Pin 3 - IR Sender         - Ist vorgegeben, kann nicht geändert werden
     * Pin 4 - IR Empfänger
     * Pin 5 - 433 Mhz Sender
     *
     * Alle anderen sind unbenutzt. 
     * Spannungsversorgung über die beiden Kabel:
     *  links  - GND
     *  rechts - VCC (5V)
     *
     * Ausgabe über Seriell: 9600 baud 8N1
     *
     * Zum Senden des letzten Empfangenen Befehls gibt es zwei Möglichkeiten:
     *  Seriell  - Eingabe eines beliebiegen Zeichens in der seriellen Konsole
     *  Schalter - Durch Drücken eines angeschlossenen Schalters (schaltet auf GND)
     *
     * Code auf Basis der Beispiele aus der IRLibrary von Ken Shirriff und der RemoteSwitch-Library von Randy Simons
     *  IRLibrary:    http://www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
     *  RemoteSwitch: http://randysimons.com/overige/browsable/433MHz/
     */
     
    #include <IRremote.h>
    #include <RemoteReceiver.h>
    #include <RemoteSwitch.h>
     
    const int RECV_PIN_IR  =  4;
    const int SEND_PIN_433 =  5;
    const int BUTTON_PIN   = 12;
    const int DEBUG_LED    = 13;
     
    // IR Initialisierung
    IRrecv irrecv(RECV_PIN_IR);
    IRsend irsend;
    decode_results results;
     
    // Welches Signal wurde zuletzt empfagen? 1 = IR, 2 = 433 Mhz
    int last_method = 0;
     
    void setup()
    {
      Serial.begin(9600);
      irrecv.enableIRIn(); // Startet den IR-receiver
     
      RemoteReceiver::init(0, 3, showCode_433); // Startet den 433 Mhz Empfänger - showCode_433 wird bei Empfang eines Signals automatisch aufgerufen
     
      pinMode(BUTTON_PIN,INPUT);
      digitalWrite(BUTTON_PIN,HIGH);
      pinMode(DEBUG_LED,OUTPUT);
    }
     
    // Storage for the recorded code (IR)
    int codeType = -1; // The type of code
    unsigned long codeValue; // The code value if not raw
    unsigned int rawCodes[RAWBUF]; // The durations if raw
    int codeLen; // The length of the code
    int toggle = 0; // The RC5/6 toggle state
     
    void loop() {
      // IR Signal empfangen
      if(irrecv.decode(&results)){
        digitalWrite(DEBUG_LED,HIGH);
     
        // Zeile zum automatischen Auslesen: - und speichern der Werte
        storeCode_ir(&results);
        last_method = 1;
     
        // Zeilen mit mehr Details:
        Serial.println("#### IR ####");
        dump_ir(&results);
     
        Serial.println("");
     
        irrecv.resume(); // Receive the next value
        digitalWrite(DEBUG_LED,LOW);
      }
     
      // Button gedrückt / Zeichen eingegeben -> Signal senden
      if(digitalRead(BUTTON_PIN) == LOW || Serial.read() != -1){
        digitalWrite(DEBUG_LED,HIGH);
     
        Serial.println("#### Senden ####");
     
        if(last_method == 0){
          Serial.println("# FEHLER: Noch kein Signal empfangen");
        }else if(last_method == 1){
          Serial.println("## IR");
          sendCode_ir(0);
        }else if(last_method == 2){
          Serial.println("## 433");
          sendCode_433();
        }
     
        Serial.println("");
     
        digitalWrite(DEBUG_LED,LOW);
      }
    }
     
    // ######## 433 Mhz ########
    unsigned long savedCode;
     
    void showCode_433(unsigned long receivedCode, unsigned int period) {  
      digitalWrite(DEBUG_LED,HIGH);
     
      RemoteReceiver::disable();
     
      //Need interrupts for delay
      interrupts();
     
      unsigned long code;
      unsigned long code1;
      unsigned long code2;
      unsigned long periode2;
     
      //Copy the received code.
      code = receivedCode;
      code1 = code;
      code = code  & 0xFFFFF; //truncate to 20 bits for show; receivedCode is never more than 20 bits..
      code2 = code;
      //Add the period duration to the code. Range: [0..511] (9 bit)
      code |= (unsigned long)period << 23;
      //Add the number of repeats to the code. Range: [0..7] (3 bit). The actual number of repeats will be 2^(repeats), 
      //in this case 8
      code |= 3L << 20;
     
      // Zeile zum automatischen Auslesen:
      Serial.print("433Mhz: ");
      Serial.println(code);
     
      // Zeilen mit mehr Details:  
      Serial.println("#### 433Mhz ####");
      Serial.print("# Code ohne shift:  ");
      Serial.println(code1);
      Serial.print("# Code mit Shift 0xFFFFF:  ");
      Serial.println(code2);
      Serial.print("# Periode:  ");
      Serial.println(period);
      periode2 |= (unsigned long)period << 23;
      Serial.print("# Periodee mit <<23:  ");
      Serial.println(periode2);
      Serial.print("# Code mit Anzahl Wiederholungen, also komplett:  ");
      Serial.println(code);
     
      // Code speichern
      savedCode = code;
      last_method = 2;
     
      Serial.println("");
     
      RemoteReceiver::enable();
     
      digitalWrite(DEBUG_LED,LOW);
    }
     
    void sendCode_433(){
      //Disable the receiver; otherwise it might pick up the retransmit as well.
      RemoteReceiver::disable();
     
      //Need interrupts for delay
      interrupts();
     
      Serial.print("# Code: ");
      Serial.println(savedCode);
     
      RemoteSwitch::sendTelegram(savedCode,SEND_PIN_433);
     
      RemoteReceiver::enable();
    }
     
     
    // ######## IR ########
     
    // Dumps out the decode_results structure.
    // Call this after IRrecv::decode()
    // void * to work around compiler issue
    //void dump(void *v) {
    //  decode_results *results = (decode_results *)v
    void dump_ir(decode_results *results) {
      int count = results->rawlen;
      if (results->decode_type == UNKNOWN) {
        Serial.println("# Could not decode message");
      } 
      else {
        if (results->decode_type == NEC) {
          Serial.print("# Decoded NEC: ");
        } 
        else if (results->decode_type == SONY) {
          Serial.print("# Decoded SONY: ");
        } 
        else if (results->decode_type == RC5) {
          Serial.print("# Decoded RC5: ");
        } 
        else if (results->decode_type == RC6) {
          Serial.print("# Decoded RC6: ");
        }
        Serial.print(results->value, HEX);
        Serial.print(" (");
        Serial.print(results->bits, DEC);
        Serial.println(" bits)");
      }
      Serial.print("# Raw (");
      Serial.print(count, DEC);
      Serial.print("): ");
     
      for (int i = 0; i < count; i++) {
        if ((i % 2) == 1) {
          Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
        } 
        else {
          Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
        }
        Serial.print(" ");
      }
      Serial.println("");
    }
     
    // Stores the code for later playback
    // Most of this code is just logging
    void storeCode_ir(decode_results *results) {
      Serial.print("IR: ");
      codeType = results->decode_type;
      Serial.print("codeType: ");
      Serial.print(codeType);
      Serial.print(" (");
      if (codeType == NEC) {
        Serial.print("NEC");
      } else if (codeType == SONY) {
        Serial.print("SONY");
      } else if (codeType == RC5) {
        Serial.print("RC5");
      } else if (codeType == RC6) {
        Serial.print("RC6");
      } else if (codeType == UNKNOWN) {
        Serial.print("UNKNOWN");
      }  
      Serial.print(")");
     
      int count = results->rawlen;
      if (codeType == UNKNOWN) {
        codeLen = results->rawlen - 1;
        Serial.print(" rawCodes: ");
        // 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[i]*USECPERTICK - MARK_EXCESS;
          } else {
            // Space
            rawCodes[i - 1] = results->rawbuf[i]*USECPERTICK + MARK_EXCESS;
          }
    //        Serial.print(rawCodes[i - 1], DEC);
          Serial.print(rawCodes[i - 1]);
          Serial.print(",");
        }
      } else {
        if (results->value != REPEAT) {
    //      Serial.println(results->value, HEX);
          codeValue = results->value;
          Serial.print(" codeValue: ");
          Serial.print(codeValue);
          codeLen = results->bits;
        }
      }
      Serial.print(" codeLen: ");
      Serial.print(codeLen);
      Serial.println("");
    }
    /*
      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
        Serial.print("#");
        for (int i = 1; i <= codeLen; i++) {
          if (i % 2) {
            // Mark
            rawCodes[i - 1] = results->rawbuf[i]*USECPERTICK - MARK_EXCESS;
            Serial.print(" m");
          } 
          else {
            // Space
            rawCodes[i - 1] = results->rawbuf[i]*USECPERTICK + 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_ir(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");
      }
    }