Hob2Hood: IR Protokoll + Arduino

[tuxedo]

So ein Mist...

Kleiner Tipp an alle Bastler:

Vor dem finalen Anschließen nochmal alle Spannungen auf korrektheit messen..

War fest davon überzeugt dass aus der Dunstabzugshaube passende 12V kommen, mit der ich den Arduino versorgen kann, der dann wiederum die Relais etc. mit 5V versorgt...

Pustekuchen. Erst hat ein Arduino seinen Dienst verweigert, dann auf mysteriöse Art und Weise der IR Empfänger (hab Ersatz in einem alten DVD Player gefunden), und dann den zweiten Arduino gegrillt.. Fazit: Es kommen knapp 30V aus der Dunstabzugshaube... *mist* Keine Ahnung wie ich da vor Wochen auf 12V gekommen bin...

Zwei ersatzarduinos sind schon seit ein Paar Tagen unterwegs. Und StepDown Regler sind jetzt auch unterwegs.. Muss die Haube doch noch ein paar Tage warten bis sie fertig ist und ich ein Video zeigen kann :-(

Gruß
Alex

[tuxedo]

So, Ersatz-Arduinos sind gekommen, ein DC-DC StepDown Wandler ebenfalls. So hab ich nun stabile 5V für den Arduino und die Relais-Boards.

Hab den Code mal auf Github geschoben: https://github.com/tuxedo0801/Arduino-Hob2Hood

IMG_20150530_111410.jpg

Hab zwei Relais-Biards mit je 4 Kanälen verwendet. So kann ich die 4 Lüftungsstufen + das Licht schalten und hab noch 3 Kanäle "Reserve". Könnte sich ggf. mal auszahlen wenn ein Relais das zeitliche segnet... Und ich kann noch eine KNX-Tasterschnittstelle anschließen und hab dann auf dem KNX-Bus die Info "Dunstabzughaube läuft" und kann damit z.B. die Lüftungsanlage auf Stoßlüften stellen.

Ich hab alles "geschraubt". Der Arduino ist ein Nano und sitzt auf einer Adapterplatine mit Schraubterminals. Lediglich der StepDown Wandler hat Lötfahnen. Sieht etwas "wild" aus. Aber ich kann fast alles ohne Lötkolben "schnell mal ändern".

IMG_20150530_130135.jpg

Ist schon lustig wenn in der Haube auf einmal ein USB-Anschluss vorhanden ist und man ein "Firmwareupdate der Haube" machen kann ;-)

Die Haube ist original mit zwei Drehknöpfen steuerbar. Diese Steuerplatine ist mit einem 8-adrigen Flachbandkabel mit der Haupt-Elektronik der Haube verbunden. Auf den Adern findet man +30V die, je nach dem was man einschaltet, auf die eine oder andere Ader zurückgeschaltet wird.
Ich hab mit Pfostenstecker und Pfostenwanne das Kabel aufgetrennt und kann so, Plug'n'Play meine Schaltung dazwischen klemmen. Wenn man etwas kaputt geht oder ich ein Update machen muss, dann kann ich den ganzen Arduino-Komplex abstecken und den Originalzustand wieder zusammenstecken.

In der Haube montiert sieht das dann so aus:
IMG_20150530_125724.jpg

Ich hab das Gehäuse mit zwei Streifen Klettband an der Innenseite der Haube befestigt. Hebt bombenfest und ich komm ohne Werkzeug das Gehäuse wieder raus um mal nach dem rechten zu sehen.

Was mir beim ersten Test aufgefallen ist:

Was ist wenn nach dem Abschalten des Kochfeldes das Licht eigentlich wieder aus gehen soll, aber man den Sensor gerade "verdeckt" hatte und das Licht dann nicht aus geht?
Die Praxis wird zeigen ob ich noch eine Art Timeout einbauen muss. So nach dem Motto: Wenn seit X Minuten kein IR-Signal mehr empfangen wurde: Schalte das Licht aus. Ob das praktikabel ist weiß ich nicht. So ist es gut, dass ich die Original Bedienung erhalten habe. Einmal kurz den Lichtdrehknopf auf AN und wieder AUS und schon wäre ein nicht automatisch abgeschaltetes Licht wieder aus.

[billy]

Hallo,
ich würde gerne das Projekt ein wenig abändern.
Ich habe einen Herd von AEG dessen IR Signale ich empfange und als Hex Werte habe.
Jetzt würde ich gerne eine Dunstabzugshaube(nicht AEG) steuern. Die benötigten IR habe ich auch ausgelesen und als Hex Werte.
Jetzt müsste ein kleines Programm wenn vom Herd z.B. Hex 001 kommt, Hex 002 senden.
Kann mir da jemand bei Code helfen?
Unten der Beispielcode zum Auslesen der Hex Werte.

/*
* IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv
* An IR detector/demodulator must be connected to the input RECV_PIN.
* Version 0.1 July, 2009
* Copyright 2009 Ken Shirriff
* http://arcfn.com
*/

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}

void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume(); // Receive the next value
}
}

[tuxedo]

D.h. du willst einen IR-Signalübersetzer basteln: IR-Befehle A empfangen und IR-Befehl B senden...?!

Da musst du mal googeln... Glaub die IR-Bibliothek kann auch senden. Wenn mich nicht alles täuscht, gibt's da auch ein Beispiel-Programm zu.

Aber mal was anderes: Wo bringst du denn den Arduino mit Empfänger, Sender und Netzteil unter? Wenn in der Haube: Wäre dann nicht das direkte Anschließen der Haube sinnvoller, weil zuverlässiger?

P.S. Erstes Suchergebnis bei Tante Google (ohne genauer drauf zu schauen): http://www.instructables.com/id/How-...th-an-Arduino/

Ob TV oder DAH sollte da ja egal sein.

[billy]

Genau einen IR-Signalübersetzer.
Die DAH ist in einer abgehängten Decke, IR Sender und Empfänger leicht rausgucken lassen, Rest in die Decke.
Direktes Anschließen der Haube? Da müsste ich ja die Taster/Elektrik auseinander nehmen. Wegen Garantie etc. -->schlecht.
Dein angefügtes Beispiel nimmt das IR Signal auseinander. Kann man nicht einfach den Hex Code senden?

[tuxedo]

Kann man nicht einfach den Hex Code senden?

Geht sicher auch. Frag doch mal google: "arduino send ir command hex"

[billy]

Müsste mit diesem Beispiel(IRrecord) funktionieren, aber ohne die Taster Bestätigung zum senden.
Das Beispiel Programm hat jedoch einen Fehler.

"IRrecord:25: error: 'IRsend' does not name a type
IRrecord.ino: In function 'void sendCode(int)':
IRrecord:103: error: 'irsend' was not declared in this scope
IRrecord:107: error: 'irsend' was not declared in this scope
IRrecord:113: error: 'irsend' was not declared in this scope
IRrecord:128: error: 'irsend' was not declared in this scope
IRrecord:131: error: 'irsend' was not declared in this scope
IRrecord:138: error: 'irsend' was not declared in this scope
'IRsend' does not name a type"


/*
* 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.
* 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 <IRremote.h>

int RECV_PIN = 11;
int BUTTON_PIN = 12;
int STATUS_PIN = 13;

IRrecv irrecv(RECV_PIN);
IRsend irsend;

decode_results results;

void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
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 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[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(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);
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)) {
digitalWrite(STATUS_PIN, HIGH);
storeCode(&results);
irrecv.resume(); // resume receiver
digitalWrite(STATUS_PIN, LOW);
}
lastButtonState = buttonState;
}

[billy]

Kann mir da vielleicht jemand bei behilflich sein. Die // IR commands from AEG hob2hood device müssen quasi in // IR commands for DAH übersetzt werden.
z.B. wenn const long IRCMD_SPEED_1 = 0xE3C01BE2;
dann const long DAH_SPEED_1 = 0x23C01B31;

/*
* An IR LED must be connected to Arduino PWM pin 3.
* An IR detector/demodulator must be connected to the input RECV_PIN
* Version 001
*/

#include <IRremote.h>

int RECV_PIN = 11;
IRsend irsend;


// IR commands from AEG hob2hood device
const long IRCMD_SPEED_1 = 0xE3C01BE2;
const long IRCMD_SPEED_2 = 0xD051C301;
const long IRCMD_SPEED_3 = 0xC22FFFD7;
const long IRCMD_SPEED_4 = 0xB9121B29;
const long IRCMD_SPEED_OFF = 0x55303A3;
const long IRCMD_LIGHT_ON = 0xE208293C;
const long IRCMD_LIGHT_OFF = 0x24ACF947;

// IR commands for DAH
const long DAH_SPEED_1 = 0x23C01B31;
const long DAH_SPEED_2 = 0x6751C385;
const long DAH_SPEED_3 = 0x462FFF63;
const long DAH_SPEED_4 = 0x46121B93;
const long DAH_SPEED_OFF = 0x6430345;
const long DAH_LIGHT_ON = 0x64082965;
const long DAH_LIGHT_OFF = 0x62ACF932;


IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}

void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume(); // Receive the next value
}
}

void loop() {
if (Serial.read() != -1) {
for (int i = 0; i < 3; i++) {
irsend.sendSony(0xa90, 12); // Sony TV power code
delay(40);
}
}
}
}

[tuxedo]

1) Dieser Thread behandelt "AEg Hob2Hood mit dem Arduino". Andere, wenn auch ähnliche Themen, sind vielleicht in einem separaten Thread besser aufgehoben?
2) Das ist ein Arduino-Problem. Wäre es in einem Arduino-Forum nicht besser aufgehoben?
3) Das Forum bietet die Möglichkeit Code formatiert anzuzeigen/einzufügen. Warum quälst du uns mit nicht-formatiertem Code?
4) "Geht nicht" ist keiner Fehlermeldung mit der man arbeiten kann.
5) Keep it simpel: Wenn du etwas neues machst, wovon du noch nicht so die Ahnung hast, dann halte es einfach: Probiere erst ob ein existierendes Beispielprogramm (zum senden von IR Befehlen) sich kompilieren lässt. Erst wenn das funktioniert tastest du dich an die finale Lösung heran.

Gruß
Alex

[Alexius84]

Kann mir da vielleicht jemand bei behilflich sein. Die // IR commands from AEG hob2hood device müssen quasi in // IR commands for DAH übersetzt werden.

Hi, ist zwar schon was her, aber versuch es damit : Achtung Code ist nicht getestet

#include <IRremote.h>
IRsend irsend;
/*
Siehe: https://knx-user-forum.de/forum/%C3%...-arduino/page2
Lüftung Stufe1 0xE3C01BE2
Lüftung Stufe2 0xD051C301
Lüftung Stufe3 0xC22FFFD7
Lüftung Stufe4 0xB9121B29
Lüftung Aus 0x55303A3
light An 0xE208293C
light Aus 0x24ACF947
An IR LED must be connected to Arduino PWM pin 3.
*/

// IR commands from AEG hob2hood device
const long IRCMD_SPEED_1 = 0xE3C01BE2;
const long IRCMD_SPEED_2 = 0xD051C301;
const long IRCMD_SPEED_3 = 0xC22FFFD7;
const long IRCMD_SPEED_4 = 0xB9121B29;
const long IRCMD_SPEED_OFF = 0x55303A3;
const long IRCMD_LIGHT_ON = 0xE208293C;
const long IRCMD_LIGHT_OFF = 0x24ACF947;

const long DAH_SPEED_1 = 0x23C01B31;
const long DAH_SPEED_2 = 0x6751C385;
const long DAH_SPEED_3 = 0x462FFF63;
const long DAH_SPEED_4 = 0x46121B93;
const long DAH_SPEED_OFF = 0x6430345;
const long DAH_LIGHT_ON = 0x64082965;
const long DAH_LIGHT_OFF = 0x62ACF932;


// Pins for input switches/controls for manual control of the hood
const int PIN_IN_LIGHT = 6;
const int PIN_IN_SPEED_1 = 7;
const int PIN_IN_SPEED_2 = 8;
const int PIN_IN_SPEED_3 = 9;
const int PIN_IN_SPEED_4 = 9; // TODO configure PIN



// IR Receiver PIN
const int PIN_IR_RECEIVER = 11;
// IR Transmitter PIN
// An IR LED must be connected to Arduino PWM pin 3.

const int MODE_HOB2HOOD = 0;
const int MODE_MANUAL = 1;

// ventilation, light and mode status
int ventilation=0;
int light=0;
int mode=0; // 0 = hob2hood control, 1 = manual control

IRrecv irrecv(PIN_IR_RECEIVER); // create instance of 'irrecv'
decode_results results;




void setup() {

// Setup manual switches/control inputs
pinMode(PIN_IN_LIGHT, INPUT);
pinMode(PIN_IN_SPEED_1, INPUT);
pinMode(PIN_IN_SPEED_2, INPUT);
pinMode(PIN_IN_SPEED_3, INPUT);
pinMode(PIN_IN_SPEED_4, INPUT);

// define startup state
digitalWrite(PIN_IN_LIGHT, HIGH); // PullUp
digitalWrite(PIN_IN_SPEED_1, HIGH); // PullUp
digitalWrite(PIN_IN_SPEED_2, HIGH); // PullUp
digitalWrite(PIN_IN_SPEED_3, HIGH); // PullUp
digitalWrite(PIN_IN_SPEED_4, HIGH); // PullUp






Serial.begin(9600); // for serial monitor output
irrecv.enableIRIn(); // Start the IR receiver
}




void loop() {

// read manual control inputs
int inLight = digitalRead(PIN_IN_LIGHT);
int inSpeed1 = digitalRead(PIN_IN_SPEED_1);
int inSpeed2 = digitalRead(PIN_IN_SPEED_2);
int inSpeed3 = digitalRead(PIN_IN_SPEED_3);
int inSpeed4 = digitalRead(PIN_IN_SPEED_4);

// if any of the manual control inputs is IN USE (PullUp: LOW = ON) --> manual mode
if (inLight == LOW ||
inSpeed1 == LOW ||
inSpeed2 == LOW ||
inSpeed3 == LOW ||
inSpeed4 == LOW ) {

if (mode==MODE_HOB2HOOD) {
Serial.println("Switching to manual mode");
}

mode = MODE_MANUAL;

if (inLight == LOW) {
// Beleuchtung einschalten:
light = 1;
} else {
// Beleuchtun ausschalten:
light = 0;
}

if (inSpeed1 == LOW) {
// set ventilation speed 1
ventilation = 1;
} else if (inSpeed2 == LOW) {
// set ventilation speed 2
ventilation = 2;
} else if (inSpeed3 == LOW) {
// set ventilation speed 3
ventilation = 3;
} else if (inSpeed4 == LOW) {
// set ventilation speed 4
ventilation = 4;
} else {
// set ventilation off
ventilation = 0;
}

controlHood();

} else {
// now we are in HOB2HOOD-mode, because no manual control is in use

// check for previous mode
if (mode==MODE_MANUAL) {
Serial.println("Switching to Hob2Hood mode");
// set to initial state
ventilation = 0;
light = 0;
controlHood();

// and switch to hob2hood mode
mode = MODE_HOB2HOOD;
irrecv.resume();
}
receiveIRCommand();
}

}

// Receive and decode IR commands and control hood upon received command
void receiveIRCommand() {

// have we received an IR signal?
if (irrecv.decode(&results)) {

Serial.println("Received IR command: ");
Serial.println(results.value, HEX); // display it on serial monitor in hexadecimal
Serial.println("");

switch (results.value) {

case IRCMD_LIGHT_ON:
light = 1;
break;

case IRCMD_LIGHT_OFF:
light = 0;
break;

case IRCMD_SPEED_1:
ventilation = 1;
break;

case IRCMD_SPEED_2:
ventilation = 2;
break;

case IRCMD_SPEED_3:
ventilation = 3;
break;

case IRCMD_SPEED_OFF:
ventilation = 0;
break;

default:
break;
}

controlHood();
irrecv.resume(); // receive the next value
}
}


// control hood based on 'light' and 'ventilation' variables
void controlHood() {

// control light
switch (light) {
// Light OFF
case 0:
Serial.println("Light: OFF");
irsend.sendNEC(DAH_LIGHT_OFF, 32);
delay(40);
break;
// Light ON
case 1:
Serial.println("Light: ON");
irsend.sendNEC(DAH_LIGHT_ON, 32);
delay(40);
break;
default:
break;
}

// control ventilation
switch (ventilation) {

// Ventilation OFF
case 0:
Serial.println("Ventilation: OFF");
irsend.sendNEC(DAH_SPEED_OFF, 32);
delay(40);
break;

// Ventilation Speed 1
case 1:
Serial.println("Ventilation: 1");
irsend.sendNEC(DAH_SPEED_1, 32);
delay(40);
break;

// Ventilation Speed 2
case 2:
Serial.println("Ventilation: 2");
irsend.sendNEC(DAH_SPEED_2, 32);
delay(40);
break;

// Ventilation Speed 3
case 3:
Serial.println("Ventilation: 3");
irsend.sendNEC(DAH_SPEED_3, 32);
delay(40);
break;

// Ventilation Speed 4
case 4:
Serial.println("Ventilation: 4 NotYetSupported");
// Not yet supported?!
break;

default:
break;

}

}

}

[BuntMetall]

Hallo zusammen,

ich grabe dieses alte Thema mal wieder aus, da es für mich gerade aktuell ist und ich die Hoffnung habe jemand kann mir bei meinen Problemen helfen.

Bei mir fängt die Problematik schon bei der Grundkonfiguration an, erstmal habe ich einen Testaufbau gemacht mit einer 4-fach Relaiskarte, einem TSOP4838 IR-Empfänger und dem Arduino Uno.

Spannungsversorgung:
5V Netzteil mit 1000mA plus USB

Belegung UNO zum TSOP4838:
3,3 V
GND
Pin11

Belegung Digitalausgänge zur Relaiskarte:
Pin2 - blau - Stufe 1
Pin3 - weiß - Stufe 2
Pin4 - schwarz - Stufe 3
Pin5 - unbelegt
Pin6 - gelb - Licht
5V - rot - VCC
GND - braun - GND


Weitere Anschlüsse habe ich erstmal nicht belegt, trotzdem gehen die Probleme schon los:
Mal davon abgesehen dass die Chinesen bei mir scheinbar die Relais 2 & 3 auf der Karte vertauscht haben, zieht das entsprechende Relais bei Betätigung der Hob2Hood-Funktion (manuell) am Kochfeld an, macht aber sofort wieder auf. Gleiches passiert wenn das Kochfeld eingeschaltet wird mit dem Licht-Relais.
Warum ist das so?


Nächstes Problem:
Sobald ein Stecker (auch wenn überhaupt nichts dran hängt, es reicht ein nacktes Kabel) in einen der Analogeingänge gesteckt wird beginnt ein Feuerwerk, das entsprechende Relais zieht an, geht auf, zieht an, geht auf. Wenn A0 - A4 belegt werden ist dies bei allen Relais der Fall, allerdings in unregelmäßigen Abständen.

#include <IRremote.h>

/*
Siehe: http://knx-user-forum.de/forum/%C3%B6ffentlicher-bereich/knx-eib-forum/diy-do-it-yourself/37790-hob2hood-ir-protokoll-arduino/page2
Lüftung Stufe1 0xE3C01BE2
Lüftung Stufe2 0xD051C301    
Lüftung Stufe3 0xC22FFFD7    
Lüftung Stufe4 0xB9121B29
Lüftung Aus 0x55303A3
Licht An 0xE208293C
Licht Aus 0x24ACF947
*/

// IR commands from AEG hob2hood device
const long IRCMD_VENT_1 = 0xE3C01BE2;
const long IRCMD_VENT_2 = 0xD051C301;
const long IRCMD_VENT_3 = 0xC22FFFD7;
const long IRCMD_VENT_4 = 0xB9121B29;
const long IRCMD_VENT_OFF = 0x55303A3;
const long IRCMD_LIGHT_ON = 0xE208293C;
const long IRCMD_LIGHT_OFF = 0x24ACF947;

// Pins for input switches/controls for manual control of the hood
const int PIN_IN_VENT_1 = A0;        // blue
const int PIN_IN_VENT_2 = A1;        // white
const int PIN_IN_VENT_3 = A2;        // black
const int PIN_IN_VENT_4 = A3;        // unused
const int PIN_IN_LIGHT = A4;        // yellow

// Pins for the output which controls relais which finally control the hood
const int PIN_OUT_VENT_1 = 2;        // blue
const int PIN_OUT_VENT_2 = 3;        // white
const int PIN_OUT_VENT_3 = 4;        // black
const int PIN_OUT_VENT_4 = 5;        // unused
const int PIN_OUT_LIGHT = 6;        // yellow
const int PIN_OUT_EXT1 = 7;            // unused
const int PIN_OUT_EXT2 = 8;            // unused
const int PIN_OUT_EXT3 = 9;            // unused

// IR Receiver PIN
const int PIN_IR_RECEIVER = 11;        // Pin IR
// const int PIN_IR_POWER = 12;          // Power IR

// Switch power
const int SWITCH_POWER = 10;                // Power to switch (from switch to A0 - A4 to control

const int MODE_HOB2HOOD = 0;
const int MODE_MANUAL = 1;

// ventilation, light and mode status
int ventilation = 0;
int last_ventilation = 0;
int light = 0;
int last_light = 0;
int mode = 0; // 0 = hob2hood control, 1 = manual control

IRrecv irrecv(PIN_IR_RECEIVER); // create instance of 'irrecv'
decode_results results;

#define OFF HIGH
#define ON LOW

void setup() {
  // Setup relay-outputs
  pinMode(PIN_OUT_VENT_1, OUTPUT);
  pinMode(PIN_OUT_VENT_2, OUTPUT);
  pinMode(PIN_OUT_VENT_3, OUTPUT);
  pinMode(PIN_OUT_VENT_4, OUTPUT);
  digitalWrite(PIN_OUT_VENT_1, OFF);
  digitalWrite(PIN_OUT_VENT_2, OFF);
  digitalWrite(PIN_OUT_VENT_3, OFF);
  digitalWrite(PIN_OUT_VENT_4, OFF);


  pinMode(PIN_OUT_LIGHT, OUTPUT);
  pinMode(PIN_OUT_EXT1, OUTPUT);
  pinMode(PIN_OUT_EXT2, OUTPUT);
  pinMode(PIN_OUT_EXT3, OUTPUT);

  // define IR power
    // pinMode(PIN_IR_POWER, OUTPUT);
    //digitalWrite(PIN_IR_POWER, ON);

  // define power switch
    pinMode(SWITCH_POWER, OUTPUT);
    digitalWrite(SWITCH_POWER, ON);    

  // define startup-state
  digitalWrite(PIN_OUT_LIGHT, OFF);
  digitalWrite(PIN_OUT_EXT1, OFF);
  digitalWrite(PIN_OUT_EXT2, OFF);
  digitalWrite(PIN_OUT_EXT3, OFF);

  Serial.begin(9600); // for serial monitor output
  Serial.println("Hob2Hood Starting ...");

  Serial.println(" ... Setup IR receiver");
  irrecv.enableIRIn(); // Start the IR receiver
  Serial.println("Hob2Hood ready ...");
}

void loop() {

  // read manual control inputs
  int inLight = analogRead(PIN_IN_LIGHT);
  int inVentilation1 = analogRead(PIN_IN_VENT_1);
  int inVentilation2 = analogRead(PIN_IN_VENT_2);
  int inVentilation3 = analogRead(PIN_IN_VENT_3);
  int inVentilation4 = analogRead(PIN_IN_VENT_4);

  // if any of the manual control inputs is IN USE (analog value >512) --> manual mode
  if (inLight >= 512 ||
      inVentilation1 >= 512 ||
      inVentilation2 >= 512 ||
      inVentilation3 >= 512 ||
      inVentilation4 >= 512 ) {

    if (mode == MODE_HOB2HOOD) {
      Serial.println("Switching to manual mode");
    }

    mode = MODE_MANUAL;

    if (inLight > 512) {
      // Beleuchtung einschalten:
      last_light = light;
      light = 1;
    } else {
      // Beleuchtung ausschalten:
      last_light = light;
      light = 0;
    }

    if (inVentilation1 > 512) {
      // set ventilation speed 1
      last_ventilation = ventilation;
      ventilation = 1;
    } else if (inVentilation2 > 512) {
      // set ventilation speed 2
      last_ventilation = ventilation;
      ventilation = 2;
    } else if (inVentilation3 > 512) {
      // set ventilation speed 3
      last_ventilation = ventilation;
      ventilation = 3;
    } else if (inVentilation4 > 512) {
      // set ventilation speed 4
      last_ventilation = ventilation;
      ventilation = 4;
    } else {
      // set ventilation off
      last_ventilation = ventilation;
      ventilation = 0;
    }

    controlHood();

  } else {

    // now we are in HOB2HOOD-mode, because no manual control is in use

    // check for previous mode
    if (mode == MODE_MANUAL) {
      Serial.println("Switching to Hob2Hood mode");
      // set to initial state
      ventilation = 0;
      light = 0;
      controlHood();

      // and switch to hob2hood mode
      mode = MODE_HOB2HOOD;
      irrecv.resume();
    }
    receiveIRCommand();
  }

}

// Receive and decode IR commands and control hood upon received command
void receiveIRCommand() {

  // have we received an IR signal?
  if (irrecv.decode(&results)) {

    Serial.println("Received IR command: ");
    Serial.println(results.value, HEX); // display it on serial monitor in hexadecimal

    switch (results.value) {

      case IRCMD_LIGHT_ON:
        light = 1;
        break;

      case IRCMD_LIGHT_OFF:
        light = 0;
        break;

      case IRCMD_VENT_1:
        ventilation = 1;
        break;

      case IRCMD_VENT_2:
        ventilation = 2;
        break;

      case IRCMD_VENT_3:
        ventilation = 3;
        break;

      case IRCMD_VENT_4:
        ventilation = 4;
        break;

      case IRCMD_VENT_OFF:
        ventilation = 0;
        break;

      default:
        break;
    }

    controlHood();
    irrecv.resume(); // receive the next value
  }
}

// control hood based on 'light' and 'ventilation' variables
void controlHood() {

  bool logLight = light!=last_light;
  bool logVent = ventilation!=last_ventilation;


  // control light
  switch (light) {
    // Light OFF
    case 0:
      if (logLight) Serial.println("Light: OFF");
      digitalWrite(PIN_OUT_LIGHT, OFF);
      delay(10);
      break;
    // Light ON
    case 1:
      if (logLight) Serial.println("Light: ON");
      digitalWrite(PIN_OUT_LIGHT, ON);
      delay(10);
      break;
    default:
      break;
  }

  // control ventilation
  switch (ventilation) {

    // Ventilation OFF
    case 0:
      if (logVent) Serial.println("Ventilation: OFF");
      digitalWrite(PIN_OUT_VENT_1, OFF);
      digitalWrite(PIN_OUT_VENT_2, OFF);
      digitalWrite(PIN_OUT_VENT_3, OFF);
      digitalWrite(PIN_OUT_VENT_4, OFF);
      delay(10);
      break;

    // Ventilation Speed 1
    case 1:
      if (logVent) Serial.println("Ventilation: 1");
      digitalWrite(PIN_OUT_VENT_2, OFF);
      digitalWrite(PIN_OUT_VENT_3, OFF);
      digitalWrite(PIN_OUT_VENT_4, OFF);
      delay(100);
      digitalWrite(PIN_OUT_VENT_1, ON);
      delay(10);

      delay(10);
      break;

    // Ventilation Speed 2
    case 2:
      if (logVent) Serial.println("Ventilation: 2");
      digitalWrite(PIN_OUT_VENT_1, OFF);
      digitalWrite(PIN_OUT_VENT_3, OFF);
      digitalWrite(PIN_OUT_VENT_4, OFF);
      delay(100);
      digitalWrite(PIN_OUT_VENT_2, ON);
      delay(10);
      break;

    // Ventilation Speed 3
    case 3:
      if (logVent) Serial.println("Ventilation: 3");
      digitalWrite(PIN_OUT_VENT_1, OFF);
      digitalWrite(PIN_OUT_VENT_2, OFF);
      digitalWrite(PIN_OUT_VENT_4, OFF);
      delay(100);
      digitalWrite(PIN_OUT_VENT_3, ON);
      delay(10);
      break;

    // Ventilation Speed 4
    case 4:
      if (logVent) Serial.println("Ventilation: 4");
      digitalWrite(PIN_OUT_VENT_1, OFF);
      digitalWrite(PIN_OUT_VENT_2, OFF);
      digitalWrite(PIN_OUT_VENT_3, OFF);
      delay(100);
      digitalWrite(PIN_OUT_VENT_4, ON);
      delay(10);
      break;

    default:
      break;

  }

  last_light = light;
  last_ventilation = ventilation;

}

Getestet wurde mit 2 Arduino Uno, daher schließe ich defekte Hardware aus.

Folgender Code zum testen hat funktioniert, die Relais schalten der Reihe nach durch:

#define OFF HIGH
#define ON LOW

const int pin1 = 2;        // blue
const int pin2 = 3;        // white
const int pin3 = 4;        // black
const int pin4 = 6;        // yellow

void setup()

{

pinMode(pin1, OUTPUT);
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
digitalWrite(pin1, OFF);
digitalWrite(pin2, OFF);
digitalWrite(pin3, OFF);
digitalWrite(pin4, OFF);

}

void loop()

{

digitalWrite(pin1, ON); //Relais 1 EIN

delay(10000); //10 Sek warten

digitalWrite(pin1, OFF); //AUS

delay(1000); //1 Sek warten




digitalWrite(pin2, ON); //Relais 2 EIN

delay(10000);

digitalWrite(pin2, OFF); //AUS

delay(1000);



digitalWrite(pin3, ON); //Relais 3 EIN

delay(10000); //10 Sek warten

digitalWrite(pin3, OFF); //AUS

delay(1000); //1 Sek warten


digitalWrite(pin4, ON); //Relais 4 EIN

delay(10000);

digitalWrite(pin4, OFF); //AUS

delay(1000);

}

Danke schon mal für die Hilfe vorab

[tuxedo]

Nächstes Problem:
Sobald ein Stecker (auch wenn überhaupt nichts dran hängt, es reicht ein nacktes Kabel) in einen der Analogeingänge gesteckt wird beginnt ein Feuerwerk, das entsprechende Relais zieht an, geht auf, zieht an, geht auf.

Elektronik Grundkenntnisse: Wenn ein Eingang weder HIGH (+5V) noch LOW (Gnd) ist, dann zappelt das gemessene Eingangssignal willkürlich durch die gegend.
Man muss in diesem Fall dann ein PullDown-Widerstand (wenn man mit HIGH schalten will) bzw. ein PullUp-Widerstand (wenn man mit LOW schalten will) einbauen um den Eingang im "nicht geschalteten Zustand" in den entsprechenden definierten "anderen" Zustand zu bringen.

zieht das entsprechende Relais bei Betätigung der Hob2Hood-Funktion (manuell) am Kochfeld an, macht aber sofort wieder auf. Gleiches passiert wenn das Kochfeld eingeschaltet wird mit dem Licht-Relais.
Warum ist das so?

Gute Frage. Vielleicht weil deinen Eingängen der PullDown Widerstand fehlt und deshalb das Eingangssignal wild durch die Gegen hüpft?
Der Code hat Log-Ausgaben auf der seriellen Schnittstelle. Vielleicht helfen die weiter?

[BuntMetall]

Man muss in diesem Fall dann ein PullDown-Widerstand (wenn man mit HIGH schalten will) bzw. ein PullUp-Widerstand (wenn man mit LOW schalten will) einbauen um den Eingang im "nicht geschalteten Zustand" in den entsprechenden definierten "anderen" Zustand zu bringen.

Das war wohl die Ursache dieses Problems, ich habe jetzt mal als Test einen Poti auf GND geschaltet, damit hat es funktioniert.
Nun also Widerstände besorgen... Kann ich mit 2 Widerständen arbeiten oder müssen es 4 sein?
1x für Licht
1x für Lüftung (läuft ja immer nur 1 Stufe)
10 Kiloohm?

Das andere Problem lag wohl am Netzteil, nur über USB betrieben war es weg.

Vielen Dank für die Hilfe,

Chris

[tuxedo]

10kOhm sind okay. 2 Widerstände PullDown auf GND funktioniert nicht.

Eine Seite des Widerstands wäre auf GND verbunden, und die andere Seite auf mehr als ein Eingang am Arduino gleichzeitig. Damit hättest du zwei oder mehr Eingänge direkt miteinander verbunden.

Es muss pro Eingang ein Widerstand auf GND sein.

[lo4dro]

Wird das Projekt weiterentwickelt?
Für mich wäre eine IR auf MQTT Umsetzung interessant. Basis ESP8266. Senden und empfangen
Dann würde die Hob2Hood mit (fast) jeder Hausautomation funktionieren.