weitere Informationen auf meiner Homepage. http://www.stall.biz/?project=homeduino ... ield-2-0-2
Die Verwendung des Arduino im Hausnetz bietet sich insbesondere deshalb an, weil es eine Vielzahl von preisgünstigen Sensoren und Aktoren gibt und zudem eine riesige Entwicklergemeinde hierfür leistungsfähige Software entwickelt. Natürlich lassen sich eigenständige Steuerungen damit entwickeln, aber im Hinblick auf Hausautomation ist die Einbindung in ein Hausnetz besonders sinnvoll und zukunftssicher. Die folgenden Lösungsansätze konzentrieren sich auf Kombinationen mit der Homematic oder einem RaspberryPi als Steuerungsrechner, aber das System ist so universell ausgelegt, dass auch Integrationen mit anderen Systemen leicht möglich sind.
2. Hardware des Homeduino
Im Folgenden wird nur kochrezeptartig das verwendete System beschrieben, so dass auch Anfänger relativ leicht einen Nachbau erfolgreich realisieren können.
Zutatenliste:
1x Arduino MEGA 2560 r3 (bei ebay in China für unter 10€ zu bekommen)
1x Ethernet Shield W5100 (bei ebay in China für unter 6€ zu bekommen)
und optional:
1x WLAN-Repeater/Bridge möglichst mit integriertem USB-Netzteil
(ich verwende den Phicomm M1 , bei Amazon für 12,50€)
1x I/O-Anschluss-Board, entweder selbst bauen oder Bausatz/Platine bei mir anfragen.
(Beschreibung der ersten Entwicklungsversion hier http://homematic-forum.de/forum/viewtop ... 71#p156004
Mit Verwendung des optionalen I/O-Shields ist ein universeller Anschluss von Sensoren und Aktoren möglich, wie sie für die Heimautomation erforderlich sind. Dazu gehören einfache Anschlussmöglichkeiten für 1-Wire-Sensoren, NTC-Temperaturfühler, Schalter und Reedschalter, Ultraschallsensoren, analogen Gebern, IR-Signalempfängern, 435Mhz-Fernsteuerungen, Displays usw. Darüber hinaus sind natürlich auch alle Arten von Niedervoltrelais bis 24V ohne zusätzliche Treiber anschließbar und auch Niedervolt -Verbraucher bis etwa 2A direkt steuerbar. Der elektrische Anschluss erfolgt mittels professioneller 40-poliger WAGO-Klemmleiste, damit ein zuverlässiger Betrieb ohne die beim Arduino häufig anzutreffenden “fliegenden” Breadboard-Aufbauten möglich ist!
Insgesamt stehen mit dem verwendeten I/O-Shield 14 als Ein- oder Ausgänge nutzbare Pins zur Verfügung. Darüberhinaus hat der MEGA 2560 noch weitere I/Os, die aber nur mit weiteren speziellen Anschlüssen verfügbar gemacht werden können. Hier wurde bewusst die Anzahl der I/Os auf 14 begrenzt, damit der Homeduino nicht mit zuvielen Funktionen “überfrachtet” wird. Stattdessen sollten sehr umfangreiche Steuerungsaufgaben besser auf mehrere Homeduinos verteilt werden.
Also unser Homeduiono hat bis zu…
>> 6 analoge Eingänge:
- 0 bis +5V oder 0 bis +10V , per Jumper kanalweise umschaltbar
- verwendbar auch als digitale I/O
- mit einzeln per Jumper zuschaltbaren 10kOhm Pullup-Widerständen z.B. für Standard-NTC- Thermofühler
>> 8 digitale I/Os
- Jeder I/O mit Status LED
- jeder digitale Eingang mit 4k7-Pullup z.B. für 1-Wire-Sensoren
- jeder digitale Ausgang mit Hochstrom-Mosfet -Treiber für Ansteuerung von NV-Relais etc.
Die nachfolgenden Bilder zeigen den Etagenaufbau des Homeduinos:
3. Software des Homeduino
Die Software des Homeduino, also gewissermassen das Betriebssystem, wurde so gestaltet, dass die Software für alle geplanten Mess- und Steuerungsaufgaben fertig konfiguriert ist. Eine individuelle Anpassung ist nicht mehr notwendig. Nur mit einfachen Befehlen wird die Funktion der I/Os bestimmt und programmiert. Bei der Gestaltung der Befehle wurde grosser Wert darauf gelegt, dass man bereits mit einem beliebigen Browser eine Steuerung der I/Os erreichen kann. Die nachfolgende Befehlsliste zeigt eigentlich sehr eindrucksvoll, wie und was man mit dem Homeduino alles steuern und messen kann:
Befehlsliste des Homeduino: ( mit arduino IP: 192.168.178.58)
Befehlsstruktur : IP-Adresse/?Befehl:Param1:Param2: …
192.168.178.58/?setpin:2:3: >> Digitalpins D2,D3 auf HIGH setzen und Pins als Output setzen
192.168.178.58/?resetpin:2:4:3: >> Digitalpins D2,D4,D3 auf LOW setzen und Pins als Output setzen
192.168.178.58/?digitalin:2:4: >> Digitalpins D2,D4 lesen und Pins als Input setzen
192.168.178.58/?analogin:0:5: >> Analogpins A0,A5 lesen und Pins auf Analoginput setzen
192.168.178.58/?pwm_out:4:96: >> PWM-Signal mit Tastverhaeltnis 96% an Digitalpin D4 ausgeben
192.168.178.58/?rf_send:2:4523029:24: >> An Digitalpin D2 das RF-Telegramm 4523029 mit 24bit-Kodierung ausgeben
192.168.178.58/?rf_receive:2: >> An Digitalpin D2 auf rf-Signal 3s warten und RF-Telegramm ausgeben
192.168.178.58/?ir_send:3:1086136543: >> An Digitalpin D3 das IR-Telegramm 1086136543 ausgeben
192.168.178.58/?ir_receive:3: >> An Digitalpin D3 auf IR-Signal 3s warten und IR-Telegramm ausgeben
192.168.178.58/?onewire:2:0:5: >> An Digitalpin D2 die 1-Wire Sensoren Nr.0 und Nr.5 einlesen
192.168.178.58/?1wire:3: >> An Digitalpin D3 den 1-Wire Sensor einlesen
192.168.178.58/?1wire_address:3: >> An Digitalpin D3 die Adresse des 1-Wire Sensors auslesen
192.168.178.58/?w_data:0:1425: >> Arduino-Integervariablen “w_data[0]” mit Wert 1525 setzen
192.168.178.58/?r_data:4:5: >> Arduino-Integervariablen “w_data[4]” und “w_data[5]” auslesen
192.168.178.58/?dist:6: >> Entfernung in cm mit Ultraschallsensor an Digitalpin 6 einlesen
192.168.178.58/?w_msg:abcdef >> “abcdef” in Arduino-String “message” speichern
192.168.178.58/?r_msg: >> Arduino-String “message” auslesen
192.168.178.58/?ntc_in:0:5: >> NTC-Temperaturen von Analog pin A0 und A5 einlesen
192.168.178.58/?help: >> Anzeige der Befehlsliste
192.168.178.58/?ver: >> Anzeige der Firmware-Version
Die Befehlsliste ist beliebig erweiterbar, bis der Arbeitspeicher des MEGA 2560 erschöpft ist. Aber zur Zeit sind noch viele Reserven vorhanden. ( Begonnen habe ich mit dem UNO, bin dann aber relativ schnell an die Kapazitätsgrenze gestossen!) Die einzelnen Befehle können mit dem Browser abgesetzt werden oder aber von einem Steuerungsrechner wie z.B. der Homematic oder einem Raspberry oder, oder …
So sieht der Output im Firefox aus, wenn in der Adresszeile ein Befehl eingegeben wird:
4. Programmierung des Arduino
Die “Firmware” des Homeduinos ist leider nicht ganz so einfach “reinzuladen”, weil erst die Arduino-Entwicklungsumgebung (IDE) mit allen notwendigen Libraries installiert werden muss. Erst dann kann die Homeduino-Software compiliert und hochgeladen werden.
Also hier die “Schritt für Schritt”-Installation:
1. hier die verwendete Arduino-Version runterladen: http://downloads.arduino.cc/arduino-1.5 ... indows.exe und normal installieren. Getetstet habe ich mit Version 1.5.6r2 , dabei wurde der USB-Treiber mit installiert. Die Installationsdateien liegen bei Windows standardmässig im Verzeichnis : “c:\Program Files (x86)\Arduino\”
Achtung: Arduino Version 1.5.7 (noch) nicht installieren, da Fehlermeldungen entstehen!!
2. in den Unterordner “libraries” folgende zusätzliche libraries als Unterverzeichnisse installieren:
3. folgendes Datenpaket holen, entpacken und das Verzeichnis “DallasTemperature” als Unterverzeichnis im Verzeichnis “libraries” wegspeichern:
http://www.hacktronics.com/code/DallasTemperature.zip
4. folgendes Datenpaket holen, entpacken und das Verzeichnis “OneWire” als Unterverzeichnis im Verzeichnis “libraries” wegspeichern:
http://www.hacktronics.com/code/OneWire.zip
5. folgendes Datenpaket holen, entpacken und das Verzeichnis “RCSwitch” als Unterverzeichnis im Verzeichnis “libraries” wegspeichern:
https://rc-switch.googlecode.com/files/RCSwitch.zip
6. folgendes Datenpaket holen, entpacken und das Verzeichnis “Arduino-IRremote-master” umbenennen und als Unterverzeichnis “IRremote” im Verzeichnis “libraries” wegspeichern:
https://github.com/shirriff/Arduino-IRr ... master.zip
7. folgendes Datenpaket holen, entpacken und Dateien im neu definierten Unterverzeichnis “LiquidCrystal_I2C ” im Verzeichnis “libraries” wegspeichern:
http://hmario.home.xs4all.nl/arduino/Li ... al_I2C.zip
8. folgendes Datenpaket holen, entpacken und Verzeichnis”Time” im Verzeichnis “libraries” wegspeichern:
http://www.pjrc.com/teensy/arduino_libraries/Time.zip
9. im Verzeichnis “c:\Program Files (x86)\Arduino\” ein neues leeres Verzeichnis “homeduino_sketche” einrichten
Damit ist die Entwicklungsumgebung vorbereitet und kann mit arduino.exe gestartet werden. Das Editor-Fenster geht auf und dann mit Copy/Paste das folgende Arduino_Sketch in den Editor laden:
Code: Alles auswählen
//For ARDUINO 1.0+
const String ver = "homeduino_9.ino / Stand: 2014.07.24"; // Versionsbezeichner
//Verfasser: Eugen Stall
//Arduino Board Mega 2560
// diese Software erlaubt die Steuerung der Pinfunktionen mit einfachen Browserbefehlen
//Quellen:
// >> libraries "onewire.h" und "DallasTemperature.h" von hier http://www.hacktronics.com/Tutorials/arduino-1-wire-tutorial.html
// in das Arduino-Verzeichnis "libraries" speichern
#include <Ethernet.h>
#include <SPI.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <RCSwitch.h>
#include <IRremote.h>
#include <Time.h>
////////////////////////////////////////////////////////////////////////
//Netzwerk-Konfiguration muss individuell hier eingegeben werden
byte ip[] = { 192, 168, 178, 58 }; //das ist die IP des Arduino //<<user-eingabe<<
byte gateway[] = { 192, 168, 178, 1 }; //das ist die IP des Routers //<<user-eingabe<<
byte subnet[] = { 255, 255, 255, 0 }; //wie immer //<<user-eingabe<<
byte mac[] = { 0xDE, 0xAF, 0xEE, 0xEF, 0xEE, 0xDE }; //nur 1x im Netz //<<user-eingabe<<
EthernetServer server(80); //server port 80
byte ccu[] = { 192, 168, 178, 50 }; //das ist die IP der CCU //<<user-eingabe<<
EthernetClient client;
//Variablendefinitionen:
boolean reading = false;
boolean valid_command = false;
String command = String(200); // string for fetching data from address
String befehl = String(20);
String parameter = String(20);
String header = String(20);
String ip_adresse = String(15);
int param;
long param1;
int param2;
String message = String(60);
boolean test = false;
unsigned long currentMillis;
unsigned long time;
unsigned long last_get;
unsigned long akt_zeit;
unsigned long next_update;
float tempNTC;
float B_wert = 3950; //aus dem Datenblatt des NTC //<<user-eingabe<<
float Tn = 298.15; //25°Celsius in °Kelvin
float Rv = 10000; //Vorwiderstand
float Rn = 10000; //NTC-Widerstand bei 25°C
float Rt ;
int data[10];
int datum;
int PWM;
int onewire_pin;
float temp_tur;
int fb_key;
String fbkey;
int rf_key;
String rfkey;
//objekt-Definitionen
IRrecv irrecv(2); //2 ist der Empfangspin D2
decode_results results;
RCSwitch mySwitch = RCSwitch();
boolean Ax_alt [6];
boolean ir_enable = 1; // 1 wenn ein ir-receiver an pin D2 verwendet wird
boolean rf_enable = 1; // 1 wenn ein rf-receiver an pin D3 verwendet wird
int schaltschwelle_high[]= {1023,1023,1023,510,510,510}; //schaltschwelle der Analogeingänge , //<<user-eingabe<<
//wenn analogwert grösser, dann high
int schaltschwelle_low[]= {0,0,0,100,100,100}; //schaltschwelle der Analogeingänge , //<<user-eingabe<<
//wenn analogwert kleiner, dann low
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
void setup()
{ Serial.begin(9600); //Pins 10,11,12 & 13 fuer ethernet shield verwendet
Ethernet.begin(mac, ip, gateway, subnet);
server.begin();
ip_adresse = String(ip[0]) + "." + String(ip[1]) + "." +String(ip[2]) + "." + String(ip[3]);
header = "arduino IP: " + ip_adresse + "\n\r";
next_update = now() + 600; // nächste regelabtastung der analogen digitaleingänge alle 600 sec
last_get = now() +3;
mySwitch.enableReceive(1); //receiver on interrupt 1 => that is pin D3
if (ir_enable = true) {irrecv.enableIRIn();} // Start the ir-receiver auf pin D2
if (rf_enable = true) {mySwitch.enableReceive(1);} //start rf receiver auf pin D3
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
void loop()
{
command = ""; //String(100);
EthernetClient client = server.available();
if (client)
{ // an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected())
{ if (client.available())
{ char c = client.read();
if (reading && c == ' ') reading =false;
if (c == '?') reading = true; // beginn der Befehlssequenz
if (reading)
{ //read char by char HTTP request
if (command.length() < 100)
{ //store characters to string
command = command + c;
}
}
if (c == '\n' && currentLineIsBlank) break;
if (c == '\n')
{ currentLineIsBlank = true;} else if (c != '\r')
{ currentLineIsBlank = false;}
}
}
////////////////////////////////////////////////////////////////////////
pinMode(13, OUTPUT); //lED leuchtet während der Abarbeitung der Befehle
digitalWrite(13, HIGH);
//jetzt wird das command ausgeführt
// befehl herausmaskieren
int colonPosition = command.indexOf(':');
befehl = command.substring(1,colonPosition);
command = command.substring((colonPosition+1)); //Rest-command bilden
client.print(header);
valid_command = false;
//###########################################################################
if (befehl == "setpin")
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
pinMode(param, OUTPUT);
digitalWrite(param, HIGH);
client.print("Pin D" + parameter + " = 1 port is digital output E\n\r");
}
}
//###########################################################################
if (befehl == "resetpin")
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
pinMode(param, OUTPUT);
digitalWrite(param, LOW);
client.print("Pin D" + parameter + " = 0 port is digital output E\n\r");
}
}
//###########################################################################
if (befehl == "digitalin")
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
pinMode(param, INPUT);
digitalWrite(param, HIGH);
client.print("Pin D" + parameter + " = " + digitalRead(param) + " port is digital input E\n\r");
}
}
//###########################################################################
if (befehl == "analogin")
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
client.print("Pin A" + parameter + " = " + analogRead(param) + " port is analog input E\n\r");
}
}
//###########################################################################
if (befehl == "pwm_out")
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false;}; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
PWM = command.toInt();
pinMode(param, OUTPUT);
analogWrite(param, PWM);
client.print("PWM D" + parameter + " = " + PWM + "% duty cycle at output E\n\r");
}
//###########################################################################
if (befehl == "ir_send")
{ valid_command = true;
colonPosition = command.indexOf(':');
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
colonPosition = command.indexOf(':');
parameter = command.substring(0,colonPosition);
param1 = parameter.toInt();
parameter = command.substring((colonPosition+1));
param2 = parameter.toInt();
// http://arcfn.com
IRsend irsend;
irsend.sendSony(param1, param2); // Sony TV power code
delay(40);
client.print("ir_send mit Sendecode :" + command + " \n\r");
}
//###########################################################################
if ((befehl == "ir_receive")&& (ir_enable == true)) //Quelle: http://arcfn.com
{valid_command = true;
//IRrecv irrecv(2); //ir eingang ist D2
decode_results results;
irrecv.enableIRIn(); // Start the receiver
unsigned long time_rf0 = millis();
unsigned long time_rf1 = millis();
while ((time_rf1 - time_rf0) < 3000)
{ time_rf1 = millis();
if (irrecv.decode(&results))
{ client.print("Pin D2 received : ");
client.print(results.value, DEC);
client.print(" \n\r");
irrecv.resume(); // Receive the next value
}
}
client.print("end ir_receive :" + command + " \n\r");
}
//###########################################################################
if (befehl == "rf_send")
{ valid_command = true;
colonPosition = command.indexOf(':');
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
colonPosition = command.indexOf(':');
parameter = command.substring(0,colonPosition);
param1 = parameter.toInt();
parameter = command.substring((colonPosition+1));
param2 = parameter.toInt();
// Quelle: http://code.google.com/p/rc-switch/
//RCSwitch mySwitch = RCSwitch();
mySwitch.enableTransmit(param);
// Optional set pulse length.
// mySwitch.setPulseLength(320);
// Optional set protocol (default is 1, will work for most outlets)
// mySwitch.setProtocol(2);
// Optional set number of transmission repetitions.
// mySwitch.setRepeatTransmit(15);
mySwitch.send(param1, param2);
client.print("rf_send mit Sendecode :" + command + " \n\r");
}
//###########################################################################
if ((befehl == "rf_receive")&& (rf_enable == true)) // Quelle http://code.google.com/p/rc-switch/
{ valid_command = true;
//mySwitch.enableReceive(1); //receiver on interrupt 1 => that is pin D3
unsigned long time_rf0 = millis();
unsigned long time_rf1 = millis();
while ((time_rf1 - time_rf0) < 3000)
{ time_rf1 = millis();
if (mySwitch.available())
{ int value = mySwitch.getReceivedValue();
if (value == 0) {client.print("Unknown encoding");}
else
{client.print("Pin D3 received : ");
client.print (mySwitch.getReceivedValue() );
client.print (" / ");
client.print( mySwitch.getReceivedBitlength() );
client.print("bit Protocol: ");
client.println( mySwitch.getReceivedProtocol() + " \n\r" );
}
mySwitch.resetAvailable();
}
}
client.print("end rf_receive :" + command + " \n\r");
}
//###########################################################################
if (befehl == "onewire")
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
onewire_pin = parameter.toInt();
//Setup onewire//////////////////////////////////////////////////////////////////////
//long intervall_onewire =10000; //onewire-Operation alle 10sec
//long lastTime_onewire =0;
float tempC[10]; // 10 Onewire-Sensoren werden maximal verwendet
OneWire oneWire(onewire_pin); //Sensoren auf Pin D2 >> hier ändern, wenn anderer Port verwendet wird
DallasTemperature sensors(&oneWire);
DeviceAddress TempSensor[] = //Adress-Array definieren
{ { 0x10, 0xC7, 0xBA, 0xDD, 0x01, 0x08, 0x00, 0x52 }, //<<user-eingabe<<
{ 0x10, 0x8E, 0xB8, 0xDD, 0x01, 0x08, 0x00, 0x32 }, //<<user-eingabe<<
{ 0x10, 0xC7, 0xBA, 0xDD, 0x01, 0x08, 0x00, 0x52 }, //<<user-eingabe<<
{ 0x10, 0x8E, 0xB8, 0xDD, 0x01, 0x08, 0x00, 0x32 }, //<<user-eingabe<<
{ 0x10, 0xC7, 0xBA, 0xDD, 0x01, 0x08, 0x00, 0x52 }, //<<user-eingabe<<
{ 0x10, 0x8E, 0xB8, 0xDD, 0x01, 0x08, 0x00, 0x32 }, //<<user-eingabe<<
{ 0x10, 0xC7, 0xBA, 0xDD, 0x01, 0x08, 0x00, 0x52 }, //<<user-eingabe<<
{ 0x10, 0x8E, 0xB8, 0xDD, 0x01, 0x08, 0x00, 0x32 }, //<<user-eingabe<<
{ 0x10, 0xC7, 0xBA, 0xDD, 0x01, 0x08, 0x00, 0x52 }, //<<user-eingabe<<
{ 0x10, 0x8E, 0xB8, 0xDD, 0x01, 0x08, 0x00, 0x32 }, //<<user-eingabe<<
};
// Start up the library
sensors.begin();
// aufloesung 10 bit
sensors.setResolution(TempSensor[0], 10);
sensors.setResolution(TempSensor[1], 10);
sensors.setResolution(TempSensor[2], 10);
sensors.setResolution(TempSensor[3], 10);
sensors.setResolution(TempSensor[4], 10);
sensors.setResolution(TempSensor[5], 10);
sensors.setResolution(TempSensor[6], 10);
sensors.setResolution(TempSensor[7], 10);
sensors.setResolution(TempSensor[8], 10);
sensors.setResolution(TempSensor[9], 10);
//Setup onewire//////////////////////////////////////////////////////////////////////
while (command.length() > 1 )
{ colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
sensors.requestTemperatures();
tempC[param] = sensors.getTempC(TempSensor[param]);
client.print("onewire T" + parameter + " = " + tempC[param] + " Celsius / pin D" + onewire_pin + " as input \n\r");
}
}
//###########################################################################
if (befehl == "1wire") /// Unterprogramm fuer 1wire Abfrage von einzelnen Sensoren
{ while (command.length() > 1 ) // verwendete Quelle: http://tushev.org/articles/arduino/item/52-how-it-works-ds18b20-and-arduino
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
OneWire ds(param);
#define DS18S20_ID 0x10
#define DS18B20_ID 0x28
byte i;
byte present = 0;
byte data[12];
byte addr[8];
if (!ds.search(addr)) { ds.reset_search(); temp_tur = -1000; } //find a device
if (OneWire::crc8( addr, 7) != addr[7]) {temp_tur = -1000; }
if (addr[0] != DS18S20_ID && addr[0] != DS18B20_ID) {temp_tur = -1000;}
if (temp_tur > -1000)
{ ds.reset();
ds.select(addr);
ds.write(0x44, 1); // Start conversion
delay(850); // Wait some time...
present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Issue Read scratchpad command
for ( i = 0; i < 9; i++) { data[i] = ds.read(); } // Receive 9 bytes
temp_tur = ( (data[1] << 8) + data[0] )*0.0625; // Calculate temperature value
}
client.print("1wire T" + parameter + " = " + temp_tur + " Celsius / pin D" + param + " as input \n\r");
}
}
//###########################################################################
if (befehl == "1wire_address") /// Unterprogramm fuer Auslesen der Sensoradresse
{ while (command.length() > 1 ) // verwendete Quelle:http://fluuux.de/2012/09/arduino-adressen-aller-ds1820-ermitteln/
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
OneWire ds(param);
byte address[8];
int i=0;
byte ok = 0, tmp = 0;
client.print("--Suche gestartet--\n\r");
while (ds.search(address))
{tmp = 0;
if (address[0] == 0x10) { client.print("Device is a DS18S20 : "); tmp = 1;} //0x10 = DS18S20
else { if (address[0] == 0x28) { client.print("Device is a DS18B20 : "); tmp = 1; } //0x28 = DS18B20
}
if (tmp == 1) //display the address, if tmp is ok
{if (OneWire::crc8(address, 7) != address[7]) { client.print("but it doesn't have a valid CRC!\n\r"); }
else { for (i=0;i<8;i++) //all is ok, display it
{ if (address[i] < 9) { client.print("0");}
client.print("0x");
client.print(address[i],HEX);
if (i<7) { client.print(", ");}
}
client.print("\n\r");
ok = 1;
}
}//end if tmp
}//end while
if (ok == 0){client.print("Keine Sensoren gefunden\n\r"); }
client.print("--Suche beendet--\n\r");
}
}
//###########################################################################
if (befehl == "w_data")
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
datum = command.toInt();
data[param] = datum;
client.print("w_data" + parameter + " = " + datum + " set w_data E\n\r");
}
//###########################################################################
if (befehl == "r_data")
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false;break;}; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
client.print("r_data" + parameter + " = " + data[param]+ " Wert der Variablen E\n\r");
}
}
//###########################################################################
if (befehl == "dist") // messung mit ultraschallsensor an "beliebigen pin
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
long duration, cm;
pinMode(param, OUTPUT);
digitalWrite(param, LOW);
delayMicroseconds(2);
digitalWrite(param, HIGH);
delayMicroseconds(5);
digitalWrite(param, LOW);
pinMode(param, INPUT);
duration = pulseIn(param, HIGH);
cm = duration /29/2;
delay(100);
client.print("ultrasonic an Pin D" + parameter + " = " + cm + " cm E\n\r");
}
}
//###########################################################################
if (befehl == "w_msg")
{ message = command;
valid_command = true;
client.print("w_msg :" + message + "\n\r");
}
//###########################################################################
if (befehl == "r_msg")
{ valid_command = true;
client.print("r_msg :" + message + "\n\r");
}
//###########################################################################
if (befehl == "ntc_in")
{ while (command.length() > 1 )
{ valid_command = true;
colonPosition = command.indexOf(':');
if (colonPosition > 2) {valid_command = false; break; }; //kanalnummern max 2 stellen erlaubt
parameter = command.substring(0,colonPosition);
command = command.substring((colonPosition+1));
param = parameter.toInt();
Rt = Rv/((1024/analogRead(param))- 1);
tempNTC = (B_wert * Tn / ( B_wert + (Tn * log(Rt/Rn)))) -Tn ;
client.print("NTC an A" + parameter + " = " + tempNTC + " gradCelsius E\n\r");
}
}
//###########################################################################
if (befehl == "set_time")
{ valid_command = false;
if (command.length() == 0) {time = now();parameter = String(time); valid_command = true;}
if (command.length() == 11)
{valid_command = true;
parameter = command.substring(0,10);
time = parameter.toInt();
setTime(time);
time = now();
parameter = String(time);}
client.print("homeduino zeit /s ist: " + parameter + " \n\r");
}
//###########################################################################
if (befehl == "help")
{ valid_command = true;
client.print("IP-Adresse/?Befehl:Param1:Param2: ...\n\r");
client.print(
ip_adresse + "/?setpin:4:5: >> Pins D4,D5 auf HIGH setzen und Pins als Output setzen \n\r"
+ ip_adresse + "/?resetpin:7:4:8: >> Pins D7,D4,D8 auf LOW setzen und Pinsals Output setzen \n\r"
+ ip_adresse + "/?digitalin:5:4: >> Pins D5,D4 lesen und Pins als Input setzen \n\r"
+ ip_adresse + "/?analogin:0:5: >> Pins A0,A5 lesen und Pins auf Analoginput setzen \n\r");
client.print(
ip_adresse + "/?pwm_out:4:96: >> PWM-Signal mit Tastverhältnis 96% an Digitalpin D4 ausgeben \n\r"
+ ip_adresse + "/?rf_send:4:4523029:24: >> An D4 das RF-Telegramm 4523029 mit 24bit-Kodierung ausgeben \n\r"
+ ip_adresse + "/?rf_receive: >> An D3 auf rf-Signal 3s warten und RF-Telegramm anzeigen \n\r"
+ ip_adresse + "/?ir_send:5:1086136543: >> An D5 das IR-Telegramm 1086136543 ausgeben \n\r");
client.print(
ip_adresse + "/?ir_receive: >> An D2 auf IR-Signal 3s warten und IR-Telegramm anzeigen \n\r"
+ ip_adresse + "/?onewire:6:0:5: >> An D6 die 1-Wire Sensoren Nr.0 und Nr.5 einlesen \n\r"
+ ip_adresse + "/?1wire:7: >> An D7 den 1-Wire Sensor einlesen \n\r"
+ ip_adresse + "/?1wire_address:8: >> An D8 die Adresse des 1-Wire Sensors auslesen \n\r");
client.print(
ip_adresse + "/?w_data:0:1425: >> Homeduino-Integervariablen \"w_data[0]\" mit Wert 1525 setzen \n\r"
+ ip_adresse + "/?r_data:4:5: >> Homeduino-Integervariablen \"w_data[4]\" und \"w_data[5]\" auslesen \n\r"
+ ip_adresse + "/?dist:6: >> Entfernung in cm mit Ultraschallsensor an Pin D6 einlesen \n\r"
+ ip_adresse + "/?w_msg:abcdef >> \"abcdef\" in Homeduino-String \"message\" speichern \n\r");
client.print(
ip_adresse + "/?set_time:174393838: >> Homeduino-Zeit (Sekunden seit 1.1.1970) setzen/auslesen \n\r"
+ ip_adresse + "/?display:0:meldung >> zeigt auf dem Display in Zeile 0 den Text \"meldung\" \n\r"
+ ip_adresse + "/? >> \n\r"
+ ip_adresse + "/? >> \n\r");
client.print(
ip_adresse + "/?r_msg: >> Homeduino-String \"message\" auslesen \n\r"
+ ip_adresse + "/?ntc_in:0:5: >> NTC-Temperaturen von Pin A0 und A5 lesen \n\r"
+ ip_adresse + "/?help: >> Anzeige der Befehlsliste \n\r"
+ ip_adresse + "/?ver: >> Anzeige der Firmware-Version \n\r"
);
}
//###########################################################################
if (befehl == "ver")
{ valid_command = true;
client.print(ver + "\n\r");
}
//###########################################################################
if (valid_command == false) {client.print("no valid command !\n\r");}
//###########################################################################
client.println();
//###########################################################################
// delay(100); // give the web browser time to receive the data
client.stop(); // close the connection:
}
//###########################################################################
pinMode(13, OUTPUT); //lED leuchtet während der Abarbeitung der Befehle
digitalWrite(13, LOW);
//hierhin kommen eigenständige Steuerung-_Programme, die dauernd zyklisch durchlaufen werden,
//wenn aktuell keine http-Anfrage abgearbeitet wird:
////////////////////////////////////////////////////////////////////////
if (ir_enable == true)
{if (irrecv.decode(&results)) // IR-Signal da?
{ Serial.print("IR-Code :");
Serial.print(results.value); // evtl. ansehen
ir_decode(); //Dekodieren
irrecv.resume();
Serial.println(" fb_key : " + fbkey );
if (fb_key < 255 )
{if (client.connect(ccu, 8181))
{ String befehl = "GET /xy.exe?antwort=dom.GetObject('homeduino_ir').State(" + fbkey + ")";
client.println(befehl);
client.println();
client.stop();
}
}
}
}
//###########################################################################
if (rf_enable == true)
{ if (mySwitch.available()) // RF-Signal da?
{ int value = mySwitch.getReceivedValue();
if (value == 0) {Serial.print("Unknown encoding");}
else { Serial.print("Pin D3 received Code : ");
Serial.print (mySwitch.getReceivedValue() );
Serial.print (" / ");
Serial.print( mySwitch.getReceivedBitlength() );
Serial.print("bit Protocol: ");
Serial.println( mySwitch.getReceivedProtocol() + " \n\r" );
rf_decode(); //Dekodieren
mySwitch.resetAvailable();
Serial.println(" rf_key : " + rfkey );
if (rf_key < 255 )
{if (client.connect(ccu, 8181))
{ String befehl = "GET /xy.exe?antwort=dom.GetObject('homeduino_rf').State(" + rfkey + ")";
client.println(befehl);
client.println();
client.stop();
}
}
}
}
}
//###########################################################################
// hier werden alternativ die analogeingänge als digitaleingänge verwendet,
// und bei änderung die entsprechenden gespiegelten HM-Systemvariablen "homeduino_ax"
// in der ccu entweder bei änderung der eingangssignale oder
// aber immer alle 10min aktualisiert.
// umschaltung zwischen analog- und digital-modusmit der variablen variablen ana_as_digital
int i = 0;
int messwert;
String kanal;
String logikpegel;
String befehl;
akt_zeit = now();
if (akt_zeit > next_update)
{ next_update = next_update +600; // nächste zwangsaktualisierung in 10min
while (i < 6) {Ax_alt[i] = !Ax_alt[i]; i=i+1; } // der altzustand wird komplementiert
i = 0;
}
if (akt_zeit > (last_get+5)) //sicherstellen, dass nicht häufiger als alle 5sec aktualisiert wird
{
if (client.connect(ccu, 8181))
{ while (i < 6)
{ messwert = analogRead(i);
if ((messwert < schaltschwelle_low[i]) && (Ax_alt[i] == 1 )) //bei aenderung des logikpegels, dann aenderungsmitteilung senden
{
Ax_alt[i] = 0;
logikpegel = "0";
kanal = String(i);
befehl = "GET /xy.exe?antwort=dom.GetObject('homeduino_a" + kanal +"').State(" + logikpegel + ")";
last_get = now();
client.println(befehl);
client.println();
Serial.println("kanal: " + kanal + " logikpegel : " + logikpegel + "\n\r" );
}
if ((messwert > schaltschwelle_high[i])&& (Ax_alt[i] == 0 ))
{
Ax_alt[i] = 1;
logikpegel = "1";
kanal = String(i);
befehl = "GET /xy.exe?antwort=dom.GetObject('homeduino_a" + kanal +"').State(" + logikpegel + ")";
last_get = now();
client.println(befehl);
client.println();
Serial.println("kanal: " + kanal + " logikpegel : " + logikpegel + "\n\r" );
}
i = i+1;
}
client.stop();
}
}
//###########################################################################
}
//##################### ende Hauptprogramm #############################
//#################### Unterprogramme nachfolgend ######################################
//########################################################################################
//Unterprogramm zur Befehlserkennung der IR-Signale
//
void rf_decode()
{switch(mySwitch.getReceivedValue())
{
case 4523029: rf_key = 1; break;
case 4523028: rf_key = 2; break;
case 4539413: rf_key = 3; break;
case 4539412: rf_key = 4; break;
case 4527125: rf_key = 5; break;
case 4527124: rf_key = 6; break;
case 4543509: rf_key = 7; break;
case 4543508: rf_key = 8; break;
case 87296: rf_key = 9; break;
case 12670208: rf_key = 10; break;
// bis 254 Codes möglich
default: rf_key = 255;
}
rfkey = String(rf_key);
}
//########################################################################################
//Unterprogramm zur Befehlserkennung der IR-Signale
//
void ir_decode()
{switch(results.value)
{
case 1086165103: fb_key = 1; break;
case 1086128383: fb_key = 2; break;
case 1086161023: fb_key = 3; break;
case 1086144703: fb_key = 4; break;
case 1086177343: fb_key = 5; break;
case 1086136543: fb_key = 6; break;
case 1086169183: fb_key = 7; break;
case 1086152863: fb_key = 8; break;
case 1086185503: fb_key = 9; break;
case 1086132463: fb_key = 10; break;
// bis 254 Codes möglich
default: fb_key = 255;
}
fbkey = String(fb_key);
}Die folgenden Themen sind noch in Vorbereitung und werden auf meiner Webseite in nächster Zeit detailliertr beschrieben : http://www.stall.biz/?project=homeduino ... automation
5.4 Analoges PWM-Signal ausgeben
5.5 Temperaturmessung mit NTC
5.6 Temperaturmessung mit 1Wire-Sensoren DS 18B20
5.7 Infrarot-LED-Transmitter (Fernbedienungscodes senden)
5.8 Infrarot-FB-Receiver (Fernbedienungscodes empfangen)
5.9 HF-FB-Transmitter (435Mhz)
5.10 HF-FB-Receiver (435Mhz)
5.11 Ultraschall-Enfernungsmessung
5.12 LCD-Display mit I2C
6. LAN/WLAN-Integration im Heimnetz
7. Bauanleitung für das universelle I/O-Shield
Bitte um Nachsicht, wenn noch einige Fehler in der Beschreibung sind, aber ich wollte trotzdem diese Fragmente hier darstellen, damit Interessierte sich schon damit beschäftigen können.
Die aktuelle und deutlich erweiterte Beschreibung findet Ihr hier: http://www.stall.biz/?project=homeduino ... automation
)
