Alte Fernbedienungen revitalisieren: DIY Smart Devices mit Arduino bauen

Komponenten und Zubehör

Arduino Nano R3

5 mm LED: Rot

Eine rote für die Status-LED, danach ist die Farbe nicht wirklich wichtig – man muss nur erkennen können, welche aktiv ist.

5 mm LED: Grün

Farbe nicht wirklich wichtig – nur um zu erkennen, welche aktiv ist

5 mm LED: Gelb

Farbe nicht wirklich wichtig – nur um zu erkennen, welche aktiv ist

Blaue LED

Farbe nicht wirklich wichtig – nur um zu erkennen, welche aktiv ist

Lötfreies Steckbrett Full Size

Jumper Wires (generic)

Kippschalter, (Off)-On

Jeder SPST-Kippschalter funktioniert

SparkFun Breadboard Power Supply Stick 5V/3.3V

Optional, wenn Sie 5 Volt aus einer anderen Quelle beziehen können oder die USB-Verbindung Ihres Computers nutzen

IR-Empfänger (generic)

Ich habe einen KY-022 37.9KHz Infrarot IR Sensor Empfänger von Amazon verwendet

Über dieses Projekt

Dieses Projekt ermöglicht die Wiederverwendung überschüssiger Fernbedienungen von alten Videorecordern, Fernsehern, DVD-Playern etc.

Sie können die Fernbedienungen nutzen, um Geräte wie Lampen, Heizungen etc. mit Relais, Leistungstransistoren oder allem, was ein 5-Volt-Signal steuern kann, einzuschalten. Wie hier gezeigt, schaltet es lediglich bis zu 6 LEDs um. Die Idee ist, den Sketch und das Steckbrett-Layout bereitzustellen, damit die an die LEDs gesendeten Signale parallel an alles gesendet werden können, was der Benutzer sich vorstellt!

Wie entworfen, liest es 6 IR-Codes von jeder Fernbedienung und „merkt“ sie sich. Ich verwende gerne die Ziffern 1, 2, 3, 4, 5, 6 – aber beliebige sechs Tasten funktionieren. Beachten Sie, dass jede andere Taste mit einem IR-Code, der nicht zu den 6 bekannten Codes gehört, als Reset fungiert und alle Ausgänge ausschaltet. Ich erreiche dies, indem ich die Codes als Long-Integers in den EEPROM-Speicher des Arduino-Boards schreibe. Jeder Code belegt 4 Byte, aber da UNO und NANO jeweils 1024 Byte EEPROM-Speicher haben, ist reichlich Platz. Dieser Speicher bleibt bei Resets und Power-Offs erhalten, wie man es erwarten würde. Das Ganze passt auf ein einzelnes Steckbrett, außer dem Kippschalter. Pins könnten an diesen Schalter gelötet werden, um ihn auf dem Steckbrett unterzubringen. Ich war faul und habe Klebeband verwendet, um ihn während der Entwicklung auf dem Schreibtisch zu befestigen.

Ich habe es mit fünf verschiedenen alten Überschuss-Fernbedienungen getestet, und sie alle verhalten sich gleich. Das „Problem“, mit dem ich zu kämpfen hatte, war Streulicht oder schwächere Signale mancher Fernbedienungen. Um dies zu lösen, bog ich die Empfänger-„LED“ vorsichtig nach unten auf etwa 45 Grad und setzte einen kleinen selbstgemachten Karton- und Klebebandkasten darüber, mit einem offenen Ende. Er fängt die Codes konsistent und aus 5–8 Fuß Entfernung oder mehr auf. Ich hatte in über fünf Tagen Testen und Programm-Anpassen keinen Fehlschlag.

Zur Programmierung verwenden Sie die „Lernen“-Position. Sie wechseln vom „Run“-Modus in den „Learn“-Modus, indem Sie den Kippschalter umlegen. Dieser Schalter schaltet eine rote Modus-Anzeige-LED ein, die anzeigt, dass er bereit zum Zuhören ist. Er lässt LED 1 blinken, und Sie drücken eine Taste auf Ihrer Fernbedienung. Die blinkende LED 1 ist so programmiert, dass sie auf diesen Code reagiert. Sobald er den Code erkennt, blinkt die Modus-Anzeige-LED für eine Sekunde oder zwei schnell (so schnell, dass es aussieht, als vibriere sie!) und geht zur nächsten LED über. Dies geht so lange, bis alle sechs programmiert sind. Dann blinkt die Modus-Anzeige-LED langsam im Ein-Sekunden-Takt, was anzeigt, dass das System wieder in den Run-Modus geschaltet werden sollte.

Beim Programmieren stellte ich fest, dass der häufigste Fehler war, den Finger nicht zur nächsten Ziffer auf der Fernbedienung zu bewegen. So ist es leicht, zwei Ausgänge mit dem gleichen Code zu programmieren. Bei jedem Start sucht das System nach solchen Duplikaten. Wenn es welche findet, blinkt es die „beanstandeten“ LEDs einige Male, um darauf hinzuweisen, dass eine Neuprogrammierung notwendig sein könnte. Da eine Person jedoch möglicherweise mehrere Tasten für dieselbe Funktion möchte, erzwingt es keine Neuprogrammierung.

Modusstatus, Fehler etc. werden durch die Blinkrate der roten Status-LED angezeigt. Alle Informationen, die durch blinkende LEDs usw. angezeigt werden, werden an den Serial Monitor gesendet. Ich habe es so eingerichtet, dass es LED-Blinkfolgen verwendet, damit ein Benutzer es ohne Computer einrichten kann. Die an den Serial Monitor gesendeten Nachrichten sind leichter zu verfolgen, als sich zu merken, was blinkende LEDs bei verschiedenen Geschwindigkeiten bedeuten. Da dies typischerweise nur wenige Male programmiert wird, ist es wahrscheinlich natürlicher, es an den PC anzuschließen und den Text auf dem Serial Monitor zu beobachten.

Im Sketch-Code gibt es viele Checks and Balances. Sie sind gut dokumentiert (hoffentlich!), daher gebe ich hier keine Details. Benutzer, die mit C, C++ und der Arduino IDE vertraut sind, sollten den Code leicht folgen und bei Bedarf Änderungen vornehmen können.

Addendum: Ich habe dies mit 5 Relais parallel zu LEDs 1 bis 5 getestet, und es funktioniert wie erwartet. Sie schalten alle eine 120 VAC Tischlampe, also funktioniert der Schaltkreis wie erwartet. Ich hatte keine Relais mehr für den 6. Ausgang, aber man kann davon ausgehen, dass das 6. Signal ebenfalls funktioniert. Beachten Sie, dies ist nur ein Proof of Concept. Ich musste die Signale der ersten vier Ausgänge mit einem CD4011 Quad-NAND-Gatter invertieren, da sie bei 0 Volt schließen, im Gegensatz zu 5 Volt. Das einzelne Relais arbeitet mit einem +5-Volt-Signal, daher war keine Signalumkehr nötig. Bitte seien Sie vorsichtig beim Schalten von Netzspannungen. Sie sind Hochspannung und können einen schweren Schlag oder sogar den Tod verursachen!

Denken Sie daran, dies ist nur ein Beispiel. Nutzen Sie Ihre Fantasie, welche Geräte an die 6 Ausgänge angeschlossen werden sollen. Viel Spaß!

Code

IR Remote Repurposing Sketch

IR Remote Repurposing Sketch Arduino

/* Toggle 6 LEDs using an IR remote to illustrate how to re-purpose surpulus remotes so they can be used to control almost any device. This sketch learns the manufacturer's codes for the 1,2,3,4,5,6 and 0 buttons on any IR remote when the toggle switch is in the "Learn" or program position. These values are saved in the Arduino Nano's EEPROM. When the toggle switch is put in the "Run" mode, these values are used to determine which key is pressed. 6 associated LEDs are then be toggled on and off by the remote. This is to demonstrate how to learn and use the codes regardless of the type of IR remote. In addition to LEDs, the outputs can be expanded to turn on or off devices with relays, high-power transistors,etc. Paul M Dunphy VE1DX March 2020 */
// Include IR Remote Library developed by Ken Shirriff
#include 
// Give the ability to read/write to the 1024 bytes of EEPROM
#include 
long unsigned int intIRCode;
long unsigned int savedIRCodes[6];
long unsigned int dupeCheck[6];
// Define pin for the IR sensor
const int Recv_Pin = 2;
// Define pin constants to toggle the LEDs
const int PinOne = 12;
const int PinTwo = 11;
const int PinThree = 10;
const int PinFour = 9;
const int PinFive = 8;
const int PinSix = 7;
// Define pin constants to read and indicate the
// status of Run/Learn toggle switch.
const int switchPin = 4;
const int statusPin = 5;
const unsigned long int repeatKeyPress = 0xFFFFFFFF;
boolean learnMode; // Used to keep track of which mode we are in as per the toggle switch.
boolean first_iteration;
// Define integers to remember toggle states of each LED
int togglestate1; int togglestate2; int togglestate3; int togglestate4; int togglestate5; int togglestate6;
int current_remote_code;
int remote_code_1; int remote_code_2; int remote_code_3; int remote_code_4; int remote_code_5; int remote_code_6;
// Define IR Receiver and Results Objects
IRrecv irrecv(Recv_Pin);
decode_results results;
void EEPROMWritelong(int address, long value) // Write a 4 byte (32bit) long integer to the EEPROM
// Since they are 4 bytes long, they are stored at address to address + 3
{ // Decompose a long integer into 4 bytes by using bitshift.
// One = Most significant -> Four = Least significant byte
byte four = (value & 0xFF);
byte three = ((value >> 8) & 0xFF);
byte two = ((value >> 16) & 0xFF);
byte one = ((value >> 24) & 0xFF);
EEPROM.write(address, four);
EEPROM.write(address + 1, three);
EEPROM.write(address + 2, two);
EEPROM.write(address + 3, one);
}
long EEPROMReadlong(long address) // Read a 4 byte (32bit) long integer from the EEPROM.
// Since they are 4 bytes long, they were stored at address to address + 3
{ long four = EEPROM.read(address);
long three = EEPROM.read(address + 1);
long two = EEPROM.read(address + 2);
long one = EEPROM.read(address + 3);
// Assemble the bytes into a long integer and return
return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & repeatKeyPress);
}
int Flip_LED(int led, int toggle_state) {
    if(toggle_state==0) { digitalWrite(led, HIGH); toggle_state=1; }
    else { digitalWrite(led, LOW); toggle_state=0; }
    return toggle_state;
}
void Reset() {
    // Turn all LEDs off and set the toggle flags to off (0)
    digitalWrite(PinOne, LOW); digitalWrite(PinTwo, LOW); digitalWrite(PinThree, LOW);
    digitalWrite(PinFour, LOW); digitalWrite(PinFive, LOW); digitalWrite(PinSix, LOW);
    togglestate1 = 0; togglestate2 = 0; togglestate3 = 0; togglestate4 = 0; togglestate5 = 0; togglestate6 = 0;
}
void guessType() {
    Serial.print("Remote appears to be a ");
    switch (results.decode_type){
        case NEC: Serial.println("NEC "); break;
        case SONY: Serial.println("SONY "); break;
        case RC5: Serial.println("RC5 "); break;
        case RC6: Serial.println("RC6 "); break;
        case DISH: Serial.println("DISH "); break;
        case SHARP: Serial.println("SHARP "); break;
        case JVC: Serial.println("JVC "); break;
        case SANYO: Serial.println("SANYO "); break;
        case MITSUBISHI: Serial.println("MITSUBISHI "); break;
        case SAMSUNG: Serial.println("SAMSUNG "); break;
        case LG: Serial.println("LG "); break;
        case WHYNTER: Serial.println("WHYNTER "); break;
        case AIWA_RC_T501: Serial.println("AIWA_RC_T501 "); break;
        case PANASONIC: Serial.println("PANASONIC "); break;
        case DENON: Serial.println("DENON "); break;
        default: case UNKNOWN: Serial.println("UNKNOWN "); break;
    }
}
int learnCodeRead(int pinCode) {
    if (irrecv.decode(&results)) { pinCode = results.value; }
    return pinCode;
}
void Confirm() {
    int i;
    for(i=0; i<=20; i++) { digitalWrite(statusPin, HIGH); delay(50); digitalWrite(statusPin, LOW); delay(50); }
    digitalWrite(statusPin, HIGH); // Leave "Learn" LED high
}
void learn_Mode() {
    boolean goodCode;
    int i, j;
    int location;
    int pins[6] = {12,11,10,9,8,7};
    // Start listening for each in sequence
    if (first_iteration) { Serial.println(); Serial.println("Entering learn mode"); Serial.println(); }
    intIRCode = 0; location = 0; goodCode = true; j = 0;
    while ((goodCode=true) and (j<=5)) {
        for(i=0; i<=25; i++) {
            digitalWrite(pins[j], HIGH); delay(200);
            intIRCode = learnCodeRead(intIRCode);
            digitalWrite(pins[j], LOW); delay(200);
            intIRCode = learnCodeRead(intIRCode);
            goodCode = ((intIRCode !=repeatKeyPress) and (intIRCode !=0));
            if (goodCode) { i=30; // Trick to bail out of loop because 'break' doesn't work on loops }
            irrecv.resume(); // Start listening again
        }
        goodCode = (intIRCode !=repeatKeyPress and intIRCode !=0);
        if (goodCode) {
            if (j==0) { guessType(); }
            Serial.print("Writing to EEPROM Location ");Serial.print(location); Serial.print(" IR code = ");Serial.println(intIRCode,HEX);
            EEPROMWritelong(location, intIRCode); location = location + 4; j++; Confirm(); intIRCode = 0; irrecv.resume(); // Start listening again
        }
    }
    Serial.println(); Serial.println("Put Arduino back in run mode.");
    while (digitalRead(switchPin) == HIGH) { digitalWrite(statusPin, HIGH); delay(1000); digitalWrite(statusPin, LOW); delay(1000); }
    Serial.println(); Serial.println("Returning to run mode.");
    delay(50); Serial.flush(); delay(50); asm volatile (" jmp 0");
}
void run_Mode() {
    if (first_iteration) { Serial.println("Entering run mode"); }
    if (irrecv.decode(&results)) {
        if (results.value!=repeatKeyPress) {
            current_remote_code = results.value;
            Serial.print("Key press detected, IR code = "); Serial.println(current_remote_code,HEX);
            if (current_remote_code == remote_code_1) { togglestate1 = Flip_LED(PinOne,togglestate1); }
            else if (current_remote_code == remote_code_2) { togglestate2 = Flip_LED(PinTwo,togglestate2); }
            else if (current_remote_code == remote_code_3) { togglestate3 = Flip_LED(PinThree,togglestate3); }
            else if (current_remote_code == remote_code_4) { togglestate4 = Flip_LED(PinFour,togglestate4); }
            else if (current_remote_code == remote_code_5) { togglestate5 = Flip_LED(PinFive,togglestate5); }
            else if (current_remote_code == remote_code_6) { togglestate6 = Flip_LED(PinSix,togglestate6); }
            else { Reset(); }
        }
        delay(500); // Used to get around the rapid string of data if a button is held down. Slows down response time by introducing a lag in the loop.
        irrecv.resume(); // Start listening again
    }
}
void setup() {
    first_iteration = true;
    int i,j,k; int location; int dupeFlash[6] = {12,11,10,9,8,7}; // Pin numbers to flash if duplicates found
    Serial.begin(9600); irrecv.enableIRIn(); // Enable the IR Receiver
    /* The following section of code should never need to be reset the EEPROM.
     * However, some new, off "the shelf" NANOs show up with their EEPROMs set to FFFFFFFFs.
     * This happens to be the code sent by many IR Remotes when a key is held down.
     * This sketch checks for that code in several places and it won't work properly if a "key" is assigned a hex FFFFFFFF.
     * To prevent this gotcha, we check for FFFFFFFFs and if we find one, we set the 6 key locations to Sony RM-YD104 codes.
     * If this happens, unless you are using that particular remote, you'll need to run the sketch in "learn" mode to initialise it.
     */
    // ============= Begin New Arduino ==================
    boolean defaultToSony = false;
    long unsigned int IRCode = 0; location = 0;
    for(i=0; i<=5; i++) { IRCode = EEPROMReadlong(location); if (IRCode==repeatKeyPress) { defaultToSony = true; } location = location + 4; }
    if (defaultToSony) {
        Serial.println("HEX FFFFFFFF found in EEPROM memory. Setting codes");
        Serial.println("for a Sony RM-YD104 remote. Running 'learn' mode now");
        Serial.println("is recommended unless that's the remote you have.");
        EEPROMWritelong(0, 0x10); delay(50);
        EEPROMWritelong(4, 0x810); delay(50);
        EEPROMWritelong(8, 0x410); delay(50);
        EEPROMWritelong(12, 0xC10); delay(50);
        EEPROMWritelong(16, 0x210); delay(50);
        EEPROMWritelong(20, 0xA10); delay(50);
    }
    // ============= End New Arduino ==================
    // Set LED pins as outputs
    pinMode(PinOne, OUTPUT); pinMode(PinTwo, OUTPUT); pinMode(PinThree, OUTPUT);
    pinMode(PinFour, OUTPUT); pinMode(PinFive, OUTPUT); pinMode(PinSix, OUTPUT);
    Reset(); // Start out with them all off
    pinMode(statusPin, OUTPUT); pinMode(switchPin, INPUT);
    //Get codes from last used remote
    Serial.println(); Serial.println("Reading stored IR remote codes . . . ");
    location = 0;
    for(j=0; j<=5; j++) {
        savedIRCodes[j] = EEPROMReadlong(location);
        Serial.print("Reading from EEPROM Location ");Serial.print(location); Serial.print(" IR code = ");Serial.println(savedIRCodes[j],HEX);
        location = location + 4;
        dupeCheck[j]=savedIRCodes[j]; // Save a copy for duplicate checking
    }
    // Look for consecutive duplicate codes assigned to the outputs. We don't look for overall duplicates because they are unlikely to happen.
    // Experience has shown that during programming, the most likely mistake is to press the same key twice on back-to-back LEDs.
    // If duplicates are found, indicate this by flashing the suspect LEDs.
    // There are only 6 LEDs, so it only takes 21 comparisons to find any duplicates (6 + 5 + 4 + 3 + 2 + 1 = 21).
    for (i = 0; i < 5 - 1; i++) {
        for (j = i + 1; j < 6; j++) {
            if (dupeCheck[i] == dupeCheck[j]) {
                Serial.println("Duplicate codes found. Suggest re-running learn mode");
                for(k=0; k<=5; k++) {
                    digitalWrite(dupeFlash[i],HIGH); digitalWrite(dupeFlash[j],HIGH); delay(1000);
                    digitalWrite(dupeFlash[i],LOW); digitalWrite(dupeFlash[j],LOW); delay(1000);
                }
            }
        }
    }
    remote_code_1 = savedIRCodes[0]; remote_code_2 = savedIRCodes[1]; remote_code_3 = savedIRCodes[2];
    remote_code_4 = savedIRCodes[3]; remote_code_5 = savedIRCodes[4]; remote_code_6 = savedIRCodes[5];
    delay(1000); Serial.println("Stored codes read."); Serial.println();
}
void loop() {
    // Check if the toggle is on or off. If it is on (in learn mode) the switchPin is HIGH:
    learnMode = (digitalRead(switchPin) == HIGH);
    if (learnMode) {
        first_iteration = true; Reset(); digitalWrite(statusPin, HIGH); // Turn learn mode LED on:
        learn_Mode(); Reset(); first_iteration = false;
    } else {
        digitalWrite(statusPin, LOW); // Turn learn mode LED off:
        run_Mode(); first_iteration = false;
    }
}

Schaltplan

Servogesteuerter Hindernisvermeidungs-Roboter: Bauen mit Arduino & HC-SR04 Arduino Blutsauerstoff- & Körpertemperatur-Monitor – Dual-Sensor-System bauen

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik