Seite auswählen

Der Homeduino 2.0 als vielseitiges LAN/WLAN-Sensormodul für die Homematic

,
Der Homeduino 2.0 als vielseitiges  LAN/WLAN-Sensormodul für die Homematic
Print Friendly

Wichtiger Hinweis: Es gibt mittlerweile eine neue Softwareversion:   Homduino 4.0

Update 19.03.2017: Software an die CCU2-Firmware 2.27.7 angepasst !

Eins vorweg:

Diese Lösung hier ist sehr einfach nachzubauen; man muß kein Arduino-Freak sein und auch keinerlei Kenntnisse mit der Homematic-Skriptsprache haben. Lediglich ein paar Komponenten kaufen und die hier verfügbare kostenlose Software auf seine persönlichen Belange anpassen, in den Arduino laden und fertig

Ergebnis ist ein universell konfigurierbares Sensormodul für die einfache (skriptfreie) Verwendung mit der Homematic, mit dem man (fast) alle Messaufgaben für die Hausautomation erledigen kann.

Grundidee: Ein frei konfigurierbares Modul für Alles!

Mit dem Homeduino-Projekt  https://www.stall.biz/?project=homeduino-der-universelle-lanwlan-arduino-fur-die-hausautomation wurde  schon eine sehr gute Möglichkeit geschaffen, einen vielseitigen I/O für nahezu beliebige Rechneransteuerungen zu ermöglichen. Allerdings sind zur Einbindung des Homduino  in die Homematic-Welt verschiedene HM-Skripte notwendig , die  mit dem unbeliebten (weil absturzgefährdenden) system.Exec-Befehl arbeiten.  Zwar wird mit CuxD das Absturzrisiko geringer, jedoch ist das  Ziel der hier vorgestellten Weiterentwicklung, auf HM-Skripte ganz zu verzichten.

Mit dieser Lösung wird jedem der beim Homeduino 2.0 vorhandenen 14 Eingangskanäle eine entsprechende Systemvariable auf der CCU zugeordnet. Die Aktualisierung der Systemvariablen mit dem entsprechenden Sensorwert erfolgt automatisch und zyklisch in relativ kurzen Abständen im Sekundenbereich. Damit erfolgt die Aktualisierung sehr schnell und dadurch eröffnen sich neue Steuerungs- und Regelungsmöglichkeiten, die insbesondere mit den Funkkomponenten wegen der gesetzlich beschränkten geringen Funkhäufigkeit gar nicht vorstellbar sind. Mehr zum Homeduino 2.0 hier:  https://www.stall.biz/?project=vielseitiges-io-shield-board-2-0-fur-fast-alle-arduinos

Im Homematic Baukasten fehlen heute noch eine Reihe von Sensoren,

die für die Hausautomation wichtig sind. Zu nennen sind beispielhaft…
– geeichte digitale Temperaturfühler sog. 1wire-Sensoren DS18B20
– NTC-Fühler (Thermistor),
– Helligkeitsssensoren
– Geräuschmelder
– dynamische Entfernungsmessung  z.B. zur Füllstandsmessung oder Erkennung von bewegten Objekten,
– Infrarotsensoren für die Erkennung von TV-Fernbedienungen
– 433Mhz-Empfänger für einfache Funksteuerungen (Baumarktsteckdosen)
– schnelle analoge Eingänge für Signale beliebiger analoger Sensoren
– …

Alle diese Anforderungen und noch einiges mehr werden mit dem neuen Homeduino gut erfüllt .

Hier die Technischen Daten:

– bis zu 14 Schalteingänge für potentialfreie Schalter oder Ausgänge von digitalen Geräten

– bis zu 6 analoge Eingänge  (10bit Auflösung) mit wählbaren Eingangsspannungsbereichen 0…+5V , 0… +10V, -5…+5V

– bis zu 6 Eingänge für analoge Temperatursensoren (Thermistoren oder sog. NTC-Messwiderstände)

– bis zu 14 Eingänge für digitale Temperatursensoren (sog. 1wire DS18B20) mit autom. Adresserkennung

– bis zu 8 Eingänge für digitale Temperatur- und Feuchtigkeitssensoren DHT22 /DHT11

– bis zu 8 Eingänge für Ultraschall-Entfernungssensoren

1 Eingang für I2C-Sensoren  wie Barometersensor BMP180  und Lichtintensitätssensor BH1750 …

1 Eingang als Infrarot-Gateway ( fehlt noch! )

1 Eingang als Funk-Gateway (433Mhz-Empfänger, fehlt noch!)

 

Diese Funktionalitäten sind natürlich nicht alle gleichzeitig vorhanden sondern teilen sich in beliebiger Mischung die verfügbaren 14 I/O´s des Homeduino.

Was sind die notwendigen Zutaten?

1x  Arduino MEGA 2560 r3 (bei ebay in China für unter 10€ zu bekommen)
es funktioniert in der Basis-Version auch mit einem UNO oder Duemilanove

1x  Ethernet Shield W5100 (bei ebay in China für unter 6€ zu bekommen)
nicht das Ethernet- Shield mit dem ENC28J60-Chip verwenden !!

1x  Homeduino-I/O-Shield  aus meinem Shop : https://www.stall.biz/?product=io-shield-2-0

und optional bei gewünschter drahtloser WLAN Anbindung:
1x  WLAN-Repeater/Bridge möglichst mit integriertem USB-Netzteil
(ich verwende den Phicomm M1 , bei Amazon für 12,50€)

homeduino_komponenten

So entsteht der Homeduino

Die drei verwendeten Boards steckt man einfach zusammen und erhält einen robusten Aufbau, den man in ein geeignetes Gehäuse einbauen kann. Versorgt wird das Gerät beispielsweise mit einem preisgünstigen 5V USB Netzteil über die USB-Buchse.  Man kann aber auch andere 5V-Netzteile verwenden, der gemessene Strombedarf ist deutlich weniger als  300 mA, d.h. mit einem 500mA-Netzteil ist man schon gut ausgerüstet . Die Sensorsignale werden dabei einfach an den auf dem Homeduino I/O-Shield verfügbaren Schraubklemmen angeschlossen. Die Funktion der einzelnen Eingänge wird einerseits mit den  Jumpern auf dem Homeduino I/O-Shield festgelegt und andererseits kann man in dem verwendeten  Homeduino-Sketch bestimmte Port-Eigenschaften programmieren, die individell jeder Anwender festlegen kann. Oder man nimmt einfach die im Sketch voreingestellten Eigenschaften und muß dann eigentlich gar nichts mehr anpassen!

Hier der zusammengesteckte Homeduino. Wichtig ist, daß das Ethernet-Board immer ganz oben eingesteckt ist und von diesem Board der Pin D4 nicht eingesteckt bzw. leicht nach außen gebogen ist!! … so wie in den nachfolgenden Bildern:

homeduino etagen1 homeduino_inhand

Die verschiedenen Sensoren werden an die Schraubklemmen des Homeduino I/O-Shields angeschlossen. Dabei sind die speziellen Eigenschaften der Sensoren zu beachten und entsprechende Jumper zu setzen. Dies wird später bei den verschiedenen Sensoren erklärt.

Wie erhält der Homeduino seine Software /Firmware

Hier die “Schritt für Schritt”-Installation:

1. Die verwendete  Arduino-Version „for non admin install“ herunterladen: http://arduino.cc/download_handler.php?f=/arduino-1.6.3-windows.zip  , entpacken in ein neues Verzeichnis „homeduino/arduino-1.6.3″  und die USB-Treiber im Unterverzeichnis „drivers“ durch Aufruf der entsprechenden exe-Files installieren.
Dann einen Folder für die eigenen Sketche einrichten z.B.  „homeduino/arduino-1.6.3/sketchbook“ und arduino.exe (die Arduino-IDE  = integrierte Entwicklungsumgebung) im Verzeichnis „homeduino/arduino_1.6.3″ aufrufen. Dort unter dem Reiter „Datei/Voreinstellungen“ den Speicherort für den soeben eingerichteten Ordner Sketchbook angeben.
Damit ist erst mal die Arduino IDE eingerichtet.

2. in den Unterordner “homeduino/arduino_1.6.3/libraries” folgende jetzt noch zusätzliche Libraries als weitere Unterverzeichnisse kopiert. Man kann es sich einfach machen und den Zip-File hier entpacken und alle Ordner zu den vorhandenen libraries kopieren
homeduino_20_libraries
…oder man folgt den folgenden Schritten, um auch die aktuellsten Libraries zu erhalten:

3. folgendes Datenpaket holen, entpacken und das Verzeichnis “OneWire” als Unterverzeichnis im Verzeichnis “libraries” wegspeichern:
http://www.hacktronics.com/code/OneWire.zip

4. folgendes Datenpaket holen, entpacken und das Verzeichnis “DHT-sensor-library-master” umbenennen und als Unterverzeichnis “DHT” im Verzeichnis “libraries” wegspeichern:
https://github.com/adafruit/DHT-sensor-library/archive/master.zip

5. folgendes Datenpaket holen, entpacken und das Verzeichnis “NewPing” als Unterverzeichnis im Verzeichnis “libraries” wegspeichern:
https://arduino-new-ping.googlecode.com/files/NewPing_v1.5.zip

6. folgendes Datenpaket holen, entpacken und das Verzeichnis “RCSwitch” als Unterverzeichnis im Verzeichnis “libraries” wegspeichern:
https://rc-switch.googlecode.com/files/RCSwitch.zip

7. folgendes Datenpaket holen, entpacken und das Verzeichnis “Arduino-IRremote-master” umbenennen und als Unterverzeichnis “IRremote” im Verzeichnis “libraries” wegspeichern:
https://github.com/shirriff/Arduino-IRremote/archive/master.zip

8. folgendes Datenpaket holen, entpacken und daraus das Unterverzeichnis”SFE_BMP180″  im Verzeichnis “libraries” wegspeichern:
https://github.com/sparkfun/BMP180_Breakout/archive/master.zip

9. folgendes Datenpaket holen, entpacken und daraus das Unterverzeichnis”AS_BH1750-master″  im Verzeichnis “libraries” wegspeichern:
https://github.com/hexenmeister/AS_BH1750/archive/master.zip

10. folgendes Datenpaket holen, entpacken und daraus das Unterverzeichnis   „SFE_CC3000_Library-master” im Verzeichnis “libraries” wegspeichern:
https://github.com/sparkfun/SFE_CC3000_Library/archive/master.zip

Damit ist die Entwicklungsumgebung (IDE) vorbereitet und kann mit arduino.exe gestartet werden.

–  Dann unter „Werkzeuge/Board“ das  verwendete Arduino-Board MEGA25650 markieren und noch unter „Datei/Werkzeuge“ den verwendeten seriellen Port des angeschlossenen Arduino auswählen. Dieser Port ist aber erst sichtbar, wenn der Arduino auch angeschlossen ist. Die Portnummer ist meist höher als com3. In diesem Fenster unten rechts die Baudrate auf 115600Bd einstellen.

–  Im geöffneten fast leeren Editor-Fenster ersetzt man die Einträge per  “Copy/Paste”  mit dem folgenden Homeduino-Sketch und sichert diese Datei mit „Datei/Speichern unter“homeduino_20_xy„in den vorher definierten Sketchbook-Ordner.

– Jetzt noch im Homeduino-Sketch in der Zeile  „byte ccu[] = { 192, 168, 178, 50 }; //das ist die IP der CCU “   die Adresse der eigenen heimischen CCU eintragen. Die Adresse des Homeduino wird automatisch per DHCP vom Router vergeben. Wichtig: wenn mehrere Homduinos verwendet werden, dann muß auch die MAC-Adresse so verändert werden, daß sie nicht zweimal im Netzwerk vorkommt.
Allein mit dem Eintrag der zugehörigen CCU-IP ist das eigentliche Anlernen des Homeduinos an die jeweilige CCU schon erfolgt.

– Die Homeduino-Software wird nun mit dem Pfeil-Rechts-Button oben in der Menueleiste compiliert und in den angeschlossenen Homeduino geladen. … Fertig!!

Hier ist die  Homeduino-Software oder besser gesagt das Homeduino-Sketch:

 

 

//Ver.: "homeduino_20_11_1.ino / Stand: 2017.03.19 / Verfasser: Eugen Stall
 
//hier ist immer die aktuelle Version:
//https://www.stall.biz/?project=der-homeduino-2-0-als-vielseitiges-lanwlan-sensormodul-fur-die-homematic&preview=true&preview_id=1115&preview_nonce=9162dd6679
//fuer Arduino Mega 2560, UNO, Duemilanove mit Arduino 1.5.8
//diese Software steuert referenziert die signale an den Arduino-pins mit entsprechenden systemvariablen in der Homematic ccu
//mit dem Befehl: http://<ip der ccu>:8181/GET /xy.exe?antwort=dom.GetObject('<systemvariable>').State(" + value + ")"
//Quellen:Arduino website plus http://arduino.cc/en/Tutorial/WebClient und ...
// http://tushev.org/articles/arduino/item/52-how-it-works-ds18b20-and-arduino und ...
 
#include <SPI.h>
#include <Wire.h> 
#include <OneWire.h> //für Temperatursensoren DS18B20 http://www.hacktronics.com/code/OneWire.zip
#include <NewPing.h> //für Ultraschallsensoren SR04 https://arduino-new-ping.googlecode.com/files/NewPing_v1.5.zip
#include "DHT.h" //für Temperatursensoren SHT22 https://github.com/adafruit/DHT-sensor-library/archive/master.zip
#include <AS_BH1750.h> //für I2C-Luxmeter https://github.com/hexenmeister/AS_BH1750/archive/master.zip
#include <SFE_BMP180.h>//für I2C-Barometer https://github.com/sparkfun/BMP180_Breakout/archive/master.zip
 
 
//+++++++ der folgende Bereich ist die Initialisierung des LAN bei Verwndung des LAN-Shields
#define com_mode 0
#include <Ethernet.h> 
EthernetClient client;
//+++++++
 
/*
//+++++++ der folgende Bereich ist die Initialisierung des CC3000 Wifi auf dem IO-Shield-Plus 
#define com_mode 1
#include <SFE_CC3000.h>// fuer cc3000 wifi http://github.com/sparkfun/SFE_CC3000_Library/archive/master.zip
#include <SFE_CC3000_Client.h>
// Pins
#define CC3000_INT 18 // int -Pin mit Wifi Shield ist D3, mit breakout auf IO-Shield-Plus ist D18
#define CC3000_EN 46 // en -Pin mit Wifi Shield ist D5, mit breakout auf IO-Shield-Plus ist D46
#define CC3000_CS 53 // cs -Pin mit Wifi Shield ist D10, mit breakout auf IO-Shield-Plus ist D53
SFE_CC3000 wifi = SFE_CC3000(CC3000_INT, CC3000_EN, CC3000_CS);
SFE_CC3000_Client client = SFE_CC3000_Client(wifi);
// Constants
char ap_ssid[] = "ssid"; // SSID Name des WLAN in Anführungszeichen <<user-eingabe<< 
char ap_password[] = "passwort"; // Passwort des WLAN in Anführungszeichen <<user-eingabe<< 
unsigned int ap_security = WLAN_SEC_WPA2; // Security of network
unsigned int timeout = 30000; // Milliseconds
//char server[] = "192,168,178,50"; // Remote host site
//+++++++
*/ 
 
char ccu_ip[31] = "192.168.178.41"; //myCCUIP"; //das ist die IP der CCU <<user-eingabe<< 
byte mac[] = { 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC }; //muss nur bei mehreren homeduinos individuell geändert werden ! <<user-eingabe<<
byte homeduino[] = { 192, 168, 178, 52 }; //das ist die feste IP dieses Homeduino, wenn DHCP versagt <<user-eingabe<< 
 
String homeduino_nummer = "x"; // indiv. Bezeichnung für diese homeduino-box <<user-eingabe<< 
String hm_systemvariable = "homeduino_" + homeduino_nummer +"_";
 
//Input-Kennung: hier wird die Funktion der Eingänge D2 bis D29 festgelegt 
byte iomodus_D[30] = 
{ 0, //D0 : '0' = andere Nutzung; 
 0, //D1 : '0' = andere Nutzung; 
//++++++++++++++ hier folgt die Festlegung der digitalen Pinfunktionen für das IO-Shield20 +++++++++++++++++++++++++++++++++ 
 2, //D2 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; '5' = Infrarot; 
 2, //D3 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; '7' = 433Mhz_Rx
 2, //D4 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; 
 2, //D5 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; 
 2, //D6 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; 
 2, //D7 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; 
 2, //D8 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; 
 2, //D9 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield20<< 
 //'4' = Ultraschall; 
 
 0, //D10 : '0' = andere Nutzung; '2' = digital in; 
 0, //D11 : '0' = andere Nutzung; '2' = digital in; 
 0, //D12 : '0' = andere Nutzung; '2' = digital in; 
 0, //D13 : '0' = andere Nutzung; '2' = digital in; 
 
//++++++++++++++ hier folgt die Festlegung der digitalen Pinfunktionen für das IO-Shield_Plus +++++++++++++++++++++++++++++++++ 
 0, //D14 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '7' = ESP8266; 
 0, //D15 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '7' = ESP8266; 
 0, //D16 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '7' = ESP8266; 
 0, //D17 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '7' = ESP8266; 
 0, //D18 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '6' = Impulszaehler; '0' = CC3000
 0, //D19 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '6' = Impulszaehler; 
 0, //D20 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '6' = Impulszaehler; '8' = I2C; 
 0, //D21 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; '6' = Impulszaehler; '8' = I2C; 
 0, //D22 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D23 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D24 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D25 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D26 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D27 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D28 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
 0, //D29 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '3' = DHTxx; <<user-eingabe für I/O-Shield-Plus<< 
 //'4' = Ultraschall; 
}; 
 
//hier wird die Funktion der Eingänge A0 bis A15 festgelegt
byte iomodus_A[16] = 
{ 
//++++++++++++++ hier folgt die Festlegung der analogen Pinfunktionen für das IO-Shield20 +++++++++++++++++++++++++++++++++ 
 2, //A0 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield20<< 
 //'10' = analog in; 
 2, //A1 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield20<< 
 //'10' = analog in; 
 2, //A2 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield20<< 
 //'10' = analog in; 
 2, //A3 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield20<< 
 //'10' = analog in; 
 2, //A4 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield20<< 
 //'10' = analog in; 
 2, //A5 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield20<< 
 //'10' = analog in; 
 
 0, //A6 : "0" = andere Nutzung; 
 0, //A7 : "0" = andere Nutzung; 
 
//++++++++++++++ hier folgt die Festlegung der analogen Pinfunktionen für das IO-Shield_Plus +++++++++++++++++++++++++++++++++ 
 0, //A8 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A9 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A10 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A11 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A12 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A13 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A14 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
 0, //A15 : '0' = andere Nutzung; '1' = 1wire; '2' = digital in; '11' = NTC; <<user-eingabe für I/O-Shield-Plus<< 
 //'10' = analog in; 
}; 
//hier werden Sensoren am I2C-Eingang aktiviert
byte iomodus_baro = 0; //"0" = N.C.; "1" = BMP180, wenn aktiviert, dann auch oben I2C aktivieren <<user-eingabe für I/O-Shield-Plus<<
byte iomodus_lux = 0; //"0" = N.C.; "1" = BH1750, wenn aktiviert, dann auch oben I2C aktivieren <<user-eingabe für I/O-Shield-Plus<<
 
//hier werden die Kennwerte fuer die Impulszaehler festgelegt
unsigned zaehlwert;
unsigned last_zaehlwert[6] = {0,0,0,0,0,0};
volatile unsigned long pulsecounter[6] = 
{ 4713, 
 0,
 4711, //Zaehlerstand fuer D21-Impulseingang bei Reset <<user-eingabe für I/O-Shield-Plus<< 
 0, //Zaehlerstand fuer D20-Impulseingang bei Reset <<user-eingabe für I/O-Shield-Plus<< 
 0, //Zaehlerstand fuer D19-Impulseingang bei Reset <<user-eingabe für I/O-Shield-Plus<< 
 0, //Zaehlerstand fuer D18-Impulseingang bei Reset <<user-eingabe für I/O-Shield-Plus<< 
}; 
//hier wird der Teilerfaktor für die Impulszaehler festgelegt
int pulsedivider[6] = 
{ 1,
 1,
 1, //Teilerfaktor fuer D21 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor <<user-eingabe für I/O-Shield-Plus<<
 1, //Teilerfaktor fuer D20 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor <<user-eingabe für I/O-Shield-Plus<<
 1, //Teilerfaktor fuer D19 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor <<user-eingabe für I/O-Shield-Plus<< 
 1, //Teilerfaktor fuer D18 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor <<user-eingabe für I/O-Shield-Plus<<
}; 
 
//hier werden die zuletzt gesendeten sytemvariablen gespeichert
boolean last_digitalin_value_D[30];
float last_digital_value_D[30];
boolean last_digitalin_value_A[16];
float last_analogin_value_A[16];
float last_IR_value;
float last_RF_value;
float last_lux_value;
double last_baro_value;
double last_baroT_value;
 
boolean complete_loop =1; // wenn 1, dann einmal komplett durchlaufen
 
boolean value;
String befehl;
String I;
int analogwert;
 
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 ; 
float temp_tur;
float humidity;
 
float delta_onewire = 0.2; //Deltas für Sendeauslösung 
float delta_sht = 0.2; 
float delta_us = 2;
float delta_analog = 2;
float delta_ntc = 0.2;
float delta_lux = 20;
double delta_baro = 0.2;
double delta_baroT = 0.5;
 
long duration, cm; //variable für Ultraschallsensor
 
unsigned long next_full_loop = 0;
unsigned long delta_time = 3600000; // jede Stunde werden alle Inputs aktualisiert
unsigned long delta_tx = 500; //in ms, minimaler Abstand der Telegramme an die CCU
unsigned long next_tx = 0;
 
boolean ccu_presence;
 
//************************************************************************************************** 
AS_BH1750 sensor; //Initialize BH1750 Luxmeter library
 
#define ALTITUDE 299.0 // seehoehe in metern
SFE_BMP180 pressure;
char status;
double T,P,p0;
 
//************************************************************************************************** 
//************************************************************************************************** 
void setup() 
{Serial.begin(115200); 
 
 
//+++++++ hier folgt die LAN Initialisierung
if (Ethernet.begin(mac) == 0) // start the Ethernet connection:
 {Serial.println("Failed to configure Ethernet using DHCP"); Ethernet.begin(mac, homeduino);}
 delay(1000);// give the Ethernet shield a second to initialize:
 Serial.println("connecting..."); // if you get a connection, report back via serial:
 if (client.connect(ccu_ip, 8181)) {}
 else {Serial.println("connection failed");} // if you didn't get a connection to the server:
 client.stop(); 
 char myIpString[24]; //IP auslesen
 IPAddress myIp = Ethernet.localIP();
 sprintf(myIpString, "%d.%d.%d.%d", myIp[0], myIp[1], myIp[2], myIp[3]); 
 I = myIpString;
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "IP" + "').State('" + I + "')";
 set_sysvar(); 
//+++++++
 
/*
//+++++++ hier folgt die CC3000 Initialisierung
 ConnectionInfo connection_info;
 int i;
 byte IP_ADDR_LEN =4;
 Serial.println("SparkFun CC3000 - WebClient");
 if ( wifi.init() ) {Serial.println("init complete");} 
 else {Serial.println("problem with init!");}
 // Connect using DHCP
 if(!wifi.connect(ap_ssid, ap_security, ap_password, timeout)) {Serial.println("no connection to AP");}
 // Gather connection details and print IP address
 if ( !wifi.getConnectionInfo(connection_info) ) {Serial.println("no connection details");} 
 else {for (i = 0; i < IP_ADDR_LEN; i++) 
 {Serial.print(connection_info.ip_address[i]);
 if ( i < IP_ADDR_LEN - 1 ) {Serial.print(".");}
 }
 Serial.println(" ist aktuelle IP-Adresse"); 
 }
 if (client.connect(ccu, 8181)) {} // Make a TCP connection to remote host
 else {Serial.println("connection failed");} // if you didn't get a connection to the server:
 client.stop();
//+++++++ 
*/
//einrichtung der interrupts fuer impulszahler D18,D19,D20,D21 
if ((pulsedivider[2] > 0) && (iomodus_D[21] == 6)) {pinMode(21, INPUT_PULLUP); attachInterrupt(2, ISR_2, FALLING);}
if ((pulsedivider[3] > 0) && (iomodus_D[20] == 6)) {pinMode(20, INPUT_PULLUP); attachInterrupt(3, ISR_3, FALLING);}
if ((pulsedivider[4] > 0) && (iomodus_D[19] == 6)) {pinMode(19, INPUT_PULLUP); attachInterrupt(4, ISR_4, FALLING);}
if ((pulsedivider[5] > 0) && (iomodus_D[18] == 6) && (com_mode == 0)) {pinMode(18, INPUT_PULLUP); attachInterrupt(5, ISR_5, FALLING);}
 
}
//************************************************************************************************** 
//************************************************************************************************** 
void loop()
{if (millis() > next_full_loop) //mindestens jede Stunde eine komplette Aktualisierung
 {complete_loop = 1; next_full_loop = millis() + delta_time; 
 if (next_full_loop < millis()) {complete_loop = 0;} //wichtig wegen Zahlensprung von millis() alle 50 Tage
 } 
 //************************************************************************************************** 
 for (int i = 2; i < 30; i++) //behandlung digitaleingänge D2 bis D29
 {if (iomodus_D[i] == 2)
 {pinMode(i, INPUT_PULLUP); 
 digitalWrite(i, HIGH);
 value =digitalRead(i);
 if ((!value == last_digitalin_value_D[i]) || complete_loop) 
 {I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "D" + I + "').State(" + value + ")";
 set_sysvar();
 last_digitalin_value_D[i] = value;
 } 
 } 
 }
//************************************************************************************************** 
for (int i = 0; i < 16; i++) //behandlung zur verwendung digitaleingänge an analogen Eingängen A0 bis A15
 {if (iomodus_A[i] == 2)
 {pinMode(i + 54, INPUT_PULLUP);
 digitalWrite(i + 54, HIGH);
 value =digitalRead(i+54); //achtung beim uno sind 14 zu addieren, beim mega 54
 if ((!value == last_digitalin_value_A[i]) || complete_loop) 
 {I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "A" + I + "').State(" + value + ")";
 set_sysvar();
 last_digitalin_value_A[i] = value;
 } 
 } 
 } 
//************************************************************************************************** 
 for (int i = 2; i < 30; i++) //behandlung onewire an D2 bis D29
 {if (iomodus_D[i] == 1)
 {OneWire ds(i); 
 #define DS18S20_ID 0x10
 #define DS18B20_ID 0x28 
 
 byte present = 0;
 byte data[12];
 byte addr[8];
 temp_tur = 1000.0;
 if (!ds.search(addr)) { ds.reset_search(); temp_tur = -1000.0; } //find a device
 if ((OneWire::crc8( addr, 7) != addr[7]) && (temp_tur > -1000.0)) {temp_tur = -1000.0; }
 if ((addr[0] != DS18S20_ID && addr[0] != DS18B20_ID)&& (temp_tur > -1000.0)) {temp_tur = -1000.0;}
 if (temp_tur > -1000.0) 
 {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 ( int k = 0; k < 9; k++) { data[k] = ds.read(); } // Receive 9 bytes
 temp_tur = ( (data[1] << 8) + data[0] )*0.0625; // Calculate temperature value 18B20
 //temp_tur = ( (data[1] << 8) + data[0] )*0.5 // Calculate temperature value 18S20
 }
 if ((temp_tur > (last_digital_value_D[i] + delta_onewire)) || (temp_tur < (last_digital_value_D[i] - delta_onewire)) || complete_loop) 
 {
 I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "D" + I + "').State(" + temp_tur + ")";
 set_sysvar();
 last_digital_value_D[i] = temp_tur;
 } 
 } 
 } 
//************************************************************************************************** 
 for (int i = 0; i < 16; i++) //behandlung onewire an A0 bis A15
 {if (iomodus_A[i] == 1)
 {pinMode(i + 54, INPUT_PULLUP);
 digitalWrite(i + 54, HIGH);
 
 OneWire ds(i+ 54); 
 #define DS18S20_ID 0x10
 #define DS18B20_ID 0x28 
 
 byte present = 0;
 byte data[12];
 byte addr[8];
 temp_tur = 1000.0;
 if (!ds.search(addr)) { ds.reset_search(); temp_tur = -1000.0; } //find a device
 if ((OneWire::crc8( addr, 7) != addr[7]) && (temp_tur > -1000.0)) {temp_tur = -1000.0; }
 if ((addr[0] != DS18S20_ID && addr[0] != DS18B20_ID)&& (temp_tur > -1000.0)) {temp_tur = -1000.0;}
 if (temp_tur > -1000.0) 
 {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 ( int k = 0; k < 9; k++) { data[k] = ds.read(); } // Receive 9 bytes
 temp_tur = ( (data[1] << 8) + data[0] )*0.0625; // Calculate temperature value 18B20
 //temp_tur = ( (data[1] << 8) + data[0] )*0.5 // Calculate temperature value 18S20
 }
 if ((temp_tur > (last_analogin_value_A[i] + delta_onewire)) || (temp_tur < (last_analogin_value_A[i] - delta_onewire)) || complete_loop) 
 {
 I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "A" + I + "').State(" + temp_tur + ")";
 set_sysvar();
 last_analogin_value_A[i] = temp_tur;
 } 
 } 
 } 
 //************************************************************************************************** 
for (int i = 2; i < 30; i++) //behandlung DHT22 D2 bis D29
 {if (iomodus_D[i] == 3)
 {DHT dht(i, DHT22); //je nach verwendetem sensor "DHT11" oder "DHT22" (AM2302) oder "DHT 21" (AM2301)
 dht.begin();
 delay(2000); // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
 humidity = dht.readHumidity(); // Read temperature as Celsius
 temp_tur = dht.readTemperature(); 
 if (isnan(humidity) || isnan(temp_tur) ) // Check if any reads failed and 
 {Serial.println("Failed to read from DHT sensor!"); temp_tur = -1000;}
 if ((temp_tur > (last_digital_value_D[i] + delta_sht)) || (temp_tur < (last_digital_value_D[i] - delta_sht)) || complete_loop) 
 {
 I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "D" + I + "').State(" + temp_tur + ")";
 set_sysvar();
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "D" + I + "1').State(" + humidity + ")";
 set_sysvar();
 last_digital_value_D[i] = temp_tur;
 } 
 } 
 } 
//************************************************************************************************** 
 for (int i = 2; i < 30; i++) //behandlung Ultraschallsensor D2 bis D29
 {if (iomodus_D[i] == 4)
 { NewPing sonar(i, i, 200); // NewPing setup of pin and maximum distance.
 unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).
 int cm = uS / US_ROUNDTRIP_CM;
 if ((cm > (last_digital_value_D[i] + delta_us)) || (cm < (last_digital_value_D[i] - delta_us)) || complete_loop) 
 { I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "D" + I + "').State(" + cm + ")";
 set_sysvar();
 last_digital_value_D[i] = cm;
 } 
 } 
 } 
//************************************************************************************************** 
for (int i = 0; i < 16; i++) //behandlung analogeingänge A0 bis A15
 {if (iomodus_A[i] == 10)
 {analogwert =analogRead(i); 
 if ((analogwert > (last_analogin_value_A[i] + delta_analog)) || (analogwert < (last_analogin_value_A[i] - delta_analog)) || complete_loop) 
 {I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "A" + I + "').State(" + analogwert + ")";
 set_sysvar();
 last_analogin_value_A[i] = analogwert;
 } 
 } 
 } 
//**************************************************************************************************
for (int i = 0; i < 16; i++) //behandlung NTC an A0 bis A15
 {if (iomodus_A[i] == 11)
 {Rt = Rv/((1024.0/analogRead(i))- 1.0);
 tempNTC = (B_wert * Tn / ( B_wert + (Tn * log(Rt/Rn)))) -Tn +25.0 ;
 if ((tempNTC > (last_analogin_value_A[i] + delta_ntc)) || (tempNTC < (last_analogin_value_A[i] - delta_ntc)) || complete_loop) 
 {I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "A" + I + "').State(" + tempNTC + ")";
 set_sysvar();
 last_analogin_value_A[i] = tempNTC;
 } 
 } 
 } 
//**************************************************************************************************
//behandlung Luxmeter BH1750 an SCL pin21 und SDA pin 20
// for normal sensor resolution (1 lx resolution, 0-65535 lx, 120ms, no PowerDown) use: sensor.begin(RESOLUTION_NORMAL, false); 
if ((iomodus_D[20] == 1) && (iomodus_D[21] == 1) && (iomodus_lux ==1))
 {if(!sensor.begin()) { /*Serial.println("Sensor not present");*/}
 float lux = sensor.readLightLevel(); delay(1000);
 if ((lux > (last_lux_value + delta_lux)) || (lux < (last_lux_value - delta_lux)) || complete_loop) 
 {befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "lux" + "').State(" + lux + ")";
 set_sysvar();
 last_lux_value = lux;
 } 
 } 
//**************************************************************************************************
//behandlung barometer BMP180 an SCL pin21 und SDA pin 20
if ((iomodus_D[20] == 1) && (iomodus_D[21] == 1)&& (iomodus_baro ==1))
 {if (pressure.begin()) {status = pressure.startTemperature();}
 if (status) {delay(status); status = pressure.getTemperature(T);} //messung T
 if (status) {status = pressure.startPressure(3);} // //messung P mit resolution 0 bis 3
 if (status) {delay(status); status = pressure.getPressure(P,T);}
 if (status) {p0 = pressure.sealevel(P,ALTITUDE);} // umrechnung auf N.N.
 //Serial.print("Hoehe/m: "); Serial.print(ALTITUDE); Serial.print(" Temperatur/C: "); Serial.print(T); Serial.print(" Normaldruck /mb: "); Serial.println(p0); 
 if ((p0 > (last_baro_value + delta_baro)) || (p0 < (last_baro_value - delta_baro)) || complete_loop) 
 {befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "baro" + "').State(" + p0 + ")";
 set_sysvar();
 last_baro_value = p0;
 }
 if ((T > (last_baroT_value + delta_baroT)) || (p0 < (last_baroT_value - delta_baroT)) || complete_loop) 
 {befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "baroT" + "').State(" + T + ")";
 set_sysvar();
 last_baroT_value = T;
 }
 }
//************************************************************************************************** 
for (int i = 2; i < 5; i++) //behandlung impulszahler D21,D20,D19,D18 
 {zaehlwert = pulsecounter[i] / pulsedivider[i];
 if ( (pulsedivider[i] > 0) && ((zaehlwert > (last_zaehlwert[i]) || complete_loop))) 
 {I = String(i);
 befehl = "GET /xy.exe?antwort=dom.GetObject('" + hm_systemvariable + "imp" + I + "').State(" + zaehlwert + ")";
 set_sysvar();
 last_zaehlwert[i] = zaehlwert;
 } 
 } 
//**************************************************************************************************
 complete_loop = 0;
}
//##############################################################
// subroutine HTTP request absetzen:
void set_sysvar() 
{ //while (millis() < next_tx) {} //warten bis time > next_tx oder timeout
 next_tx = millis() +delta_tx;
 befehl += " HTTP/1.1\r\nHost:"; //zusaetzlich wegen neuer CCU-firmware
 befehl += ccu_ip;
 befehl += "\r\nConnection: close\r\n\r\n";
 
 if (client.connect(ccu_ip, 8181))
 {Serial.print("sent to ccu : "); Serial.print(befehl); yield();
 client.print(befehl);
 delay(10); client.stop();
 ccu_presence = 1;
 } else {Serial.println("keine verbindung zur ccu"); ccu_presence = 0; return;}
}
//##############################################################
//hier sind die interrupt-service-routinen fuer die impulszaehler
void ISR_2() //Interrupt an D21
{pulsecounter[2]++;}
 
void ISR_3() //Interrupt an D20
{pulsecounter[3]++;}
 
void ISR_4() //Interrupt an D19
{pulsecounter[4]++;}
 
#if com_mode == 0
void ISR_5() //Interrupt an D18 
{pulsecounter[5]++;}
#endif

 

 

 

hier sind noch alte Versionen:

homeduino_small_07   Stand: 2015.01.06
homeduino_small_08   Stand: 2015.03.15
homeduino_small_09   Stand:2015.03.29

 

Individuelle Anpassung des Homeduino

Im Homeduino-Sketch wird mit einer Kennzahl festgelegt, welche Funktionalität jeder Input-Port hat. Für jeden analogen und digitalen Inputpin ist je nach Wunsch die Pin-Funktionalität mit den entsprechenden Variablendefinitioinen im Homeduino-Sketch festzulegen.  In jeder Zeile ist nur der erste Zahleneintrag relevant; hinter dem Doppelschrägstrich steht immer der Kommentar bzw. die Erklärung für den jeweiligen Zahlenwert. Hier ein Auszug aus dem Listing:

//Input-Kennung: hier wird die Funktion der Eingänge D2 bis D29 festgelegt 
byte iomodus_D[30] = 
{0, //D0 : '0' = andere Nutzung; 
 0, //D1 : '0' = andere Nutzung; 
//+++++ hier folgt die Festlegung der digitalen Pinfunktionen für das IO-Shield20 +++++++++++++++++++++++++ 
 2, //D2: '0' =andere Nutzg; '1' =1wire; '2' =digital in; '3' =DHTxx;     <<user-eingabe für I/O-Shield20<< 
    //    '4' =Ultraschall;    '5' =Infrarot; 
 2, //D3: '0' =andere Nutzg; '1' =1wire; '2' =digital in; '3' =DHTxx;     <<user-eingabe für I/O-Shield20<< 
    //    '4' = Ultraschall; '7' = 433Mhz_Rx
...
//+++++ hier folgt die Festlegung der digitalen Pinfunktionen für das IO-Shield_Plus +++++++++++++++++++++ 
 0, //D14: '0' =andere Nutzg;  '1' =1wire; '2' =digital in; '3' =DHTxx;<<user-eingabe für I/O-Shield-Plus<< 
    //     '4' =Ultraschall;   '7' = ESP8266; 
 0, //D15: '0' = andere Nutzg; '1' =1wire; '2' =digital in; '3' =DHTxx;<<user-eingabe für I/O-Shield-Plus<< 
    //     '4' =Ultraschall;   '7' = ESP8266; 
...
//hier wird die Funktion der Eingänge A0 bis A15 festgelegt
byte iomodus_A[16] = 
{ 
//++++++ hier folgt die Festlegung der analogen Pinfunktionen für das IO-Shield20 +++++++++++++++++++++++++ 
 2, //A0: '0' = andere Nutzg; '1' =1wire; '2' =digital in; '11' =NTC;     <<user-eingabe für I/O-Shield20<< 
    //'10' = analog in; 
 2, //A1: '0' = andere Nutzg; '1' =1wire; '2' =digital in; '11' =NTC;     <<user-eingabe für I/O-Shield20<< 
    //   '10' = analog in; 
... 
//++++++ hier folgt die Festlegung der analogen Pinfunktionen für das IO-Shield_Plus ++++++++++++++++++++++ 
 0, //A8: '0' = andere Nutzg; '1' =1wire; '2' =digital in; '11' =NTC;  <<user-eingabe für I/O-Shield-Plus<< 
    //   '10' = analog in; 
 0, //A9: '0' = andere Nutzg; '1' =1wire; '2' =digital in; '11' =NTC;  <<user-eingabe für I/O-Shield-Plus<< 
    //   '10' = analog in; 
...
//hier werden Sensoren am I2C-Eingang aktiviert
byte iomodus_baro = 0; //"0" =N.C.; "1" = BMP180;                      <<user-eingabe für I/O-Shield-Plus<<
byte iomodus_lux  = 0; //"0" =N.C.; "1" = BH1750;                      <<user-eingabe für I/O-Shield-Plus<<
 
//+++++ hier werden die Kennwerte fuer die Impulszaehler festgelegt  ++++++++++++++++++++++++++++++++++++++
volatile unsigned long pulsecounter[6] = 
{ 4713, 
     0,
  4711, //Zaehlerstand fuer D21-Impulseingang bei Reset                <<user-eingabe für I/O-Shield-Plus<< 
     0, //Zaehlerstand fuer D20-Impulseingang bei Reset                <<user-eingabe für I/O-Shield-Plus<< 
     0, //Zaehlerstand fuer D19-Impulseingang bei Reset                <<user-eingabe für I/O-Shield-Plus<< 
     0, //Zaehlerstand fuer D18-Impulseingang bei Reset                <<user-eingabe für I/O-Shield-Plus<< 
}; 
//hier wird der Teilerfaktor für die Impulszaehler festgelegt
int pulsedivider[6] = 
{  1,
   1,
   1, //Teilerfaktor fuer D21 : wenn 0, dann keine Zaehlfunktion       <<user-eingabe für I/O-Shield-Plus<<
   1, //Teilerfaktor fuer D20 : wenn 0, dann keine Zaehlfunktion       <<user-eingabe für I/O-Shield-Plus<<
   1, //Teilerfaktor fuer D19 : wenn 0, dann keine Zaehlfunktion       <<user-eingabe für I/O-Shield-Plus<< 
   1, //Teilerfaktor fuer D18 : wenn 0, dann keine Zaehlfunktion       <<user-eingabe für I/O-Shield-Plus<<
}; 

    

Entsprechend wird im Listing durch Kennzahlen festgelegt, ob ein Barometersensor oder ein Lichtsensor verwendet werden. Und auch die Impulszähler können  bezüglich  Startwert und Vorteilerfaktor konfiguriert werden. Das scheint vielleicht etwas kompliziert zu sein, es gibt aber dem Nutzer viele Möglichkeiten, seine Hausautomation auf die individuellen Bedürfnisse anzupassen. Und man muß es ja nur einmal bei der Installation machen; die Verwendung ist kinderleicht!

Will man andere Konfigurationen einstellen, dann sind einfach nur kanalweise die entsprechenden Parameter einzutragen. Das ist alles!

Anlernen an die Homematic-CCU

Das Anlernen an die CCU war eigentlich schon gemacht mit dem Eintrag der CCU-IP im Homeduino-Sketch.  Um die verschiedenen Sensordaten in die CCU zu bekommen sind keinerlei Abfragen oder Skripts notwendig. Für jeden Eingangskanal wird einfach eine entsprechende Systemvariable angelegt. Diese wird vom Homeduino selbsttätig entsprechend dem zugehörigen Eingangssignal aktualisiert. Damit aber nicht dauernd „Traffic“ entsteht, wird nur bei einer softwareseitig vorgegeben Veränderung des Eingangssignals die Systemvariable aktualisiert. Bei oftmals nur langsam veränderlichen Temperatursignalen reduziert sich dadurch das Datenaufkommen dramatisch. Trotzdem reagiert das System sofort, wenn Änderungen der Eingangssignale vorhanden sind! Damit werden auch schnellere Steuer und Regelvorgänge mit der Homematic ermöglicht, wie z.B. die temperaturabhängige Steuerung der Zirkulationspumpe, Erkennung von Lichtschranken und Bewegungsmeldern etc.

Für die maximale Homduino-Konfiguration werden nun entsprechend der individuellen Bedürfnisse mehr oder weniger  Systemvariablen in der CCU angelegt: (exakte Schreibweise beachten!)

homeduino_x_A0               als Zahl oder Logikwert    und nach Bedarf  Maßeinheit z.B. °C          für das IO-Shield20
bis
homeduino_x_A5

homeduino_x_A8               als Zahl oder Logikwert    und nach Bedarf  Maßeinheit z.B. °C       für das IO-Shield-Plus
bis
homeduino_x_A15            

homeduino_x_D2               als Zahl oder Logikwert    und nach Bedarf  Maßeinheit z.B. °C            für das IO-Shield20
bis
homeduino_x_D13

homeduino_x_14               als Zahl oder Logikwert    und nach Bedarf  Maßeinheit z.B. °C       für das IO-Shield-Plus
bis
homeduino_x_D29

homeduino_x_IP               als Zeichenkette zur Anzeige der Homeduino IP
homeduino_x_baro          als Zahl  mit Maßeinheit mb                                                                        … für das IO-Shield-Plus
homeduino_x_lux              als Zahl mit Maßeinheit lux                                                                         … für das IO-Shield-Plus

homeduino_x_imp0          als Zahl mit Maßeinheit des verwendeten Impulszählers an D2        … für das IO-Shield-Plus
bis
homeduino_x_imp6          als Zahl mit Maßeinheit des verwendeten Impulszählers an D18

Ggf. können mehr oder weniger Systemvariablen definiert werden, je nach Art und Anzahl der verwendeten Anschlüsse.

Die Systemvariablen lassen sich nun einfach in WebUI-Programmen nutzen. Werden mehrere Homeduinos verwendet , dann erhält jeder Homeduino eine andere Kennung: aus dem x in der Bezeichnung der Systemvariablen wird ein y und so weiter…

HowTo:  Sensoren am Homeduino I/O-Shield20

Das Homeduino I/O-Shield20 wurde entwickelt, um möglichst ohne Löten oder Steckbrett die üblichen Sensoren einfach mit Schraubklemmen anzuschließen und mittels Jumper die hardwareseitigen Voraussetzungen zu schaffen. Details zu dem I/O-Shield kann man hier lesen: https://www.stall.biz/?project=vielseitiges-io-shield-board-2-0-fur-fast-alle-arduinos

Das  Homeduino I/O-Shield20 kann man bei mir beziehen. Bitte mich einfach per email (Kontakt -Button)  ansprechen. Der Teil-Bausatz kostet 26€ plus 3,90€ Versand nach Deutschland.

Das nachfolgende Bild zeigt schematisch die Möglichkeiten des Shields. Mit  Jumpern läßt sich hardwaremässig jeder der 14 I/Os  auf die verschiedenen Funktionsanforderungen einstellen:
Folie3

Wem die Anzahl der verfügbaren Inputs nicht ausreicht oder wer Impulszähler mit Optokopplern (S0-Schnittstelle) benötigt , der kann ein Ergänzungsboard IO-Shield-Plus auf die hinteren Pins des MEGA2560 aufstecken. Damit wird nochmal eine erhebliche Funktionserweiterung erreicht; das aktuelle Sketch unterstützt bereits das Erweiterungsshield!

Mehr zu diesem IO-Shield-Plus hier:

So schließt man potentialfreie Schalter und Taster an:

Zum Anschluss von Tastern, Schaltern, Reedschaltern und anderen Sensoren mit nur zwei Zuständen sind keinerlei Zustzwiderstände etc. notwendig, weil die bereits auf dem Board sind und mit Jumpern zugeschaltet werden Deshalb sind in dieser Betriebsart die Jumper 2-3 und 5-6 gesteckt. Damit ist der 4,7KOhm-Pullup-Widerstand aktiviert.

Folie1

Je nach den verwendeten Inputpins sind zur Messung die entsprechenden Systemvariablen in der Homematic einzurichten. In dem Beispiel hier sind es für die  linken Sensoren   homeduino_x_D2 bis homeduino_x_D9  als Logikwert. Die an den analogen Eingang angeschlossenen Sensoren haben die entsprechenden Systemvariablen  homeduino_x_A0 bis homeduino_x_A4 ebenfalls als Logikwert.

Damit der Homeduino auch weiß, daß an dem Eingang D2 bis D9  und A0 bis A5 einSchaltsensor angeschlossen ist, muß im Homeduino-Sketch die Input Kennung der Eingänge D2 bis D9 und A0 bis A5  auf „1“ gestellt werden.

 

 Anschluss von Onewire-Temperatursensoren DS19B20:

Die sog. Onewire-Temperatursensoren DS18B20 oder DS18S20 eignen sich für die Temperaturmessung besonders gut, weil sie bereits geeicht sind und die Meßinformation bereits in digitaler Form zur Verfügung stellen. Allerdings ist die Applikation nicht ganz einfach, weil das Datenprotokoll komplex ist. Darüberhinaus hat jeder Sensor eine individuelle Adresse, die man ggf. erst auslesen muß, um den Sensor zu adressieren und auszulesen.  In der Arduino-Gemeinde hat man schnell die Vorteile dieser Sensoren erkannt und entsprechende Libraries entwickelt. Diese sind hier implementiert, so daß man sich über die Details keine Gedanken machen muß sondern einfach die Sensoren an die Eingänge des Homeduino anschließen kann.

Auf die spezielle Betriebsart mit dem parallelen Anschluss von mehreren Sensoren an einer Zweidrahtleitung wurde beim Homeduino bewußt verzichtet, weil dafür vorher die Adresse jedes einzelnen Sensors mühsam ausgelesen werden muß und diese Adresse dann in die Auswertesoftware eingetragen werden muß. Hier beim Homeduino wird einfach nur je Anschlußpin ein Sensor angeschlossen, dessen Adresse dann automatisch erkannt wird. Dies ist viel komfortabler und man hat keine Zuordnungsprobleme: Jeder Anschlusspin hat also immer nur einen Sensor!

Die störsichere Anschlussmethode für den DS18B20 ist der Dreidrahtanschluss, wobei der Sensor über eine dritte Leitung mit 5V versorgt wird. Hier im Bild der mögliche Anschluß sowohl an den Digitalpin D2 bis D9 als auch an den (digital verwendeten ) analogen Pins A0 bis A5. Entsprechend dem Bild sind die Jumper zu stecken.

Folie5

Die einfachste Methode ist der sog. Zweidraht-Anschluss wie im folgenden Bild gezeigt. Die Jumperbelegung ist identisch!

Folie6
Je nach den verwendeten Inputpins sind zur Messung die entsprechenden Systemvariablen in der Homematic einzurichten. In dem Beispiel hier sind es für den linken Sensor  homeduino_x_D6 als Zahl mit Dimension °C. Für den rechten Sensor ist die Systemvariable homeduino_x_A1 ebenfalls als Zahl ,it der Dimension °C.

Damit der Homeduino auch weiß, daß an dem Eingang D6 ein Onewire-Sensor angeschlossen ist, muß im Homeduino-Sketch die Input Kennung vom Eingang D6 auf „1“ gestellt werden. Für den rechten Sensor ist A1 auf  „1“ gestellt.

Übrigens man kann die Sensoren als Basisversion DS18B20 im Transistorgehäuse kaufen und als Sensor „verpacken“. Es gibt aber auch preisgünstige fertig konfektionierte Sensoren wie im nächsten Bild. Für 5 Sensoren habe ich in China gerade mal  7€ bezahlt 🙂
ds18b20

 

So schließt man NTC-Temperatursensoren an:

Eine Temperaturmessung mit einem Thermistor oder NTC-Widerstanssensor ist besonders einfach, weil keinerlei Zusatzbauteile in Verbindung mit dem I/O-Shield benötigt werden. Der Sensor sollte ein 10 kOhm-Typ sein. In Kombination mit dem mittels Jumper JP1 zugeschalteten Vorwiderstand von ebenfalls 10KOhm entsteht ein Spannungsteiler, dessen Spannung einem analogen Eingang zugeführt wird.

Die Berechnung der Temperatur in °C erfolgt im Homeduino mit der exponentellen Widerstandskurve des NTC-Widerstandes. Die dabei verwendeten Kennwerte und Rechenfunktionen sind dem zugehörigen Programmteil des Homeduino-Sketch  zu entnehmen. Für die typischen Standard-NTC-Sensoren sind meistens  keine Anpassungen notwendig.

Die verwendete Berechnungsformel ist :   tempNTC = (B_wert * Tn / ( B_wert + (Tn * log(Rt/Rn)))) -Tn ;  mit   B_wert = 3950; //aus dem Datenblatt des NTC

Folie3
Wenn es nicht schon bereits erfolgt ist, muß noch in der Homematic-CCU eine Systemvariable vom Typ Zahl mit der Dimension °C angelegt sein . In diesem Beispiel mit dem Input A5 und A0  heißen sie  homeduino_x_A5 und homeduino_x_A0.
Damit der Homeduino auch weiß, daß an den Eingängen A0 und A5  ein NTC-Sensor angeschlossen ist, muß im Homeduino-Sketch die Input Kennung der  Eingänge A0 und A5 auf „11“ gestellt werden.

 

Anschluss Feuchte-Temperatursensor  DHT22 /AM2302:

Die DHT-22 ist ein kostengünstiger Feuchte-und Temperatursensor mit nur einem  Draht als digitale Schnittstelle. Damit werden mit einem speziellen Protokoll die Daten für Luftfeuchte und Temperatur übertragen. Der Vorteil des Sensors ist der günstige Preis  (ca. 3€) , der Nachteil ist die lange Meßzeit von etwa 2s. Aber bei Temperaturmessungen spielt dies meist keine Rolle!

Nach Anschluss der Spannungsversorgung kann die Datenleitung an beliebige Pins D2 bis D9 geschaltet werden entsprechend sind die Jumper wie im Bild zu schalten, so daß die Datenleitung einen sog. Pullup-Widerstand von 4,7KOhm hat.

Folie9

Wenn es nicht schon bereits erfolgt ist, muß noch in der Homematic-CCU eine Systemvariable vom Typ Zahl mit der Dimension °C angelegt sein . In diesem Beispiel mit dem Input D3 heißt sie  homeduino_x_D3. Wenn man auch den Feuchtewert haben will, dann legt man einfach eine weitere Systemvariable homeduino_x_D31 vom Typ Zahl und mit der Dimension % an. Das ist alles 🙂

Damit der Homeduino auch weiß, daß an den Eingängen D3 ein DHT22-Sensor angeschlossen ist, muß im Homeduino-Sketch die Input-Kennung der  verwendeten Eingänge , hier D3,  auf  „3“ gestellt werden.

Übrigens, der noch preiswertere aber etwas ungenauere Sensor DHT11 funktioniert auch, wenn das im Skript geringfügig angepasst wird.

 

So schließt man  Ultraschall-Entfernungssensoren  an:

Die Ultraschallsensoren vom Typ SR04 gibt es im Internet als fertiges Modul bereits für 1€. Sie sind ideal, um Entfernungen von schallreflektiven  Gegenständen zwischen 0 und  450cm zu messen. Im Homeduino wurde die maximale Entfernung auf 200cm begrenzt, weil mit zunehmender Entfernung das Signal „sehr variabel“ wird, was wegen der Änderungen des Messignals dann auch zu einem (zu ) regen Telegrammverkehr mit der CCU führt. Man kann die Meßhäufigkeit reduzieren, indem man die Änderungsschwelle von standardmäßig 2cm vergrößert. Die entsprechende  Variable im Homeduino Sketch heißt float delta_us = 2 .

Man kann an den Homeduino bis zu 8 SR04-Sensoren direkt (ohne die 150Ohm Schutzwiderstände, Jumper 4-5) an die Pins D2 bis D9 anschliessen. Die Software ist so ausgelegt, daß neben der Spannungsversorgung nur eine Datenleitung zum Sensor notwendig ist. Dazu sind aber die zwei mittleren Anschlusspins zu verbinden. (siehe nächstes Bild)

 

Folie4

Wenn es nicht schon bereits erfolgt ist, muß noch in der Homematic-CCU eine Systemvariable vom Typ Zahl mit der Dimension cm angelegt sein . In diesem Beispiel mit dem Input D5 heißt sie  homeduino_x_D5. Damit der Homeduino auch weiß, daß an dem Eingängen D5 ein SR04-Modul angeschlossen ist, muß im Homeduino-Sketch die Input-Kennung des  verwendeten Eingangs , hier D5,  auf  „4“ gestellt werden.

 

So schließt man vernetzte Rauchmelder an

Rauchmelder kann man an den Homeduino anschließen, sofern der Rauchmelder vernetzbar ist. Dieser „Datenbus“ der Rauchmelder-Vernetzung ist nach meiner Kenntnis durchweg  als Zweidraht-Leitung aufgebaut: eine Masseleitung (im Bild blau) und eine Signalleitung  (braun). Im Alarmfall wird von einem Rauchmelder das Potential auf der Signalleitung hoch gesetzt (wegen der verwendeten Batterien meist 9V) . Damit werden dann die anderen vernetzten Rauchmelder gleichzeitig auch alarmiert und schlagen Alarm . Man kann also einfach durch Überwachung der Spannung auf der Signalleitung erkennen, ob ein oder mehrere Rauchmelder Alarm geben. Umgekehrt kann man durch Spannungseinspeisung auf die Signalleitung auch Alarm auslösen. Das kann für die Hausautomation interessant sein z.B. als wirksamer Alarmgeber bei Einbruchsalarm etc.

Die vernetzbaren Rauchmelder sind leider deutlich teurer als die normalen Baumarkt-Rauchmelder, obwohl in fast allen Rauchmeldern die gleichen ICs vom Typ MC145010 oder baugleich verbaut werden.  Das eröffnet die Möglichkeit, einen einfachen Rauchmelder zu einem vernetzbaren Rauchmelder umzubauen. Hier sind interessante Quellen zu diesem Thema:
http://ccblog.de/tag/cs2105go-m12/
http://www.wikidorf.de/reintechnisch/Inhalt/RauchmelderExperimente
http://www.instructables.com/id/Modify-a-6-EUR-smoke-detector-for-use-with-microco/all/?lang=de
Inwieweit mit dem Umbau rechtliche oder versicherungsrechtliche Probleme entstehen können muß jeder unbedingt selbst prüfen. Ich verweise hier u.a. auf die allgemeinen Hinweise auf meiner Startseite.

Ich selbst habe bereits einige Rauchmelder entsprechend dem nachfolgenden Bild modifiziert und einen zweiadrigen Anschluss für die Rauchmelder-Vernetzung eingebaut. Für einen „Erfahrenen“ ist die Modifikation das sicher kein Problem! Man muß nur das besagte IC und dort den Pin7 identifizieren und dann zwei dünne Drähte für die Masse- und Signalleitung anlöten. Das folgende Bild sagt mehr als viele Worte:

Folie12

Die Verschaltung der Rauchmelder erfolgt durch Paralleschaltung der jetzt an den Rauchmeldern angebrachten Vernetzung ( siehe nächstes Bild). Zum Anschluss an den Homeduino wird die Signalleitung auf einen freien analogen Eingang geführt. Jumper müssen in diesem Fall keine gesetzt werden, aber da die Signalspannung bis zu 9V betragen kann, ist zum Schutz des verwendeten Homeduino-Eingangs A0 eine Zenerdiode mit 3 bis 5V Spannung empfehlenswert.

Folie11

Die Abfrage der Signalleitung im WebUI der Homematic ist einfach, weil dafür nur der hier verwendete analoge Eingang , in diesem Fall A0, bzw. die zugehörige Systemvariable homeduino_x_A0  abgefragt werden muß.

Anmerkung: Man kann grundsätzlich auch die Rauchmelder zur wirksamen akustischen Alarmierung verwenden, wenn der analoge Eingang zur Aklarmierung als digitaler Ausgang geschaltet wird. Damit läßt sich ein Spannungssignal von ca 5V auf die Signalleitung der vernetzten Rauchmelder schalten und löst damit einen akustischen Alarm aus.

 

So schließt man einen Infrarotsensor an:

 Folie7

Beschreibung fehlt noch!

 

So schließt man einen 433Mhz-Empfänger an:

Folie6

… oder das Empfangsmodul gleich in die Platine einlöten:

Folie12

Beschreibung fehlt noch!

 So schließt man  I2C-Sensoren an:

Die serielle Kommunikation nach dem sog. I2C-Standard wird sehr gern zum universellen Anschluss von verschiedensten meist sehr intelligenten Sensoren verwendet. Benötigt werden dafür nur zwei Leitungen SDA und SCL, die beim MEGA 2650 leider nicht auf dem Homeduino I/O-Shield verfügbar sind, sondern nur an den hinteren Pfostenbuchsen des MEGA (siehe Bild). Normalerweise  wird der I2C-Bus mit 3,3V-Signalpegeln betrieben, aber der 5V- MEGA „versteht“ auch die kleineren Signalspannungen. Problematisch ist das aber für einige I2C-Sensoren, die dann die 5V-Signale vom Arduino nicht vertragen. Deshalb immer vorher vergewissern, ob die I2C-Sensoren mit nur 3,3 oder oder auch mit 5V betreibbar sind. Eventuell sind Pegelwandler notwendig, die man für wenig Geld kaufen kann. Die hier verwendeten I2C-Sensoren können ohne Zusatzelemente direkt an 5V betrieben werden. Notwendig sind dann noch für die Spannungsversorgung der I2C-Module die entsprechenden zusätzlichen zwei Leitungen.

Der I2C-Bus ist ein Datenbus für kurze möglichst kapazitätsarme Leitungen. Solange man bei den Leitungslängen unter 2m bleibt, dürfte das kein Problem sein. Längere Leitungen muß man einfach probieren oder den Takt runtersetzen. (Wie das geht , müßte man googeln)
Normalerweise benötigt der I2C-Bus auch sog. Pullup-Widerstände. Diese sind aber in den hier verwendeten Sensoren bereits eingebaut.

Anschluss Barometersensor BMP180:
Der verwendete Sensor BMP180 ist der Nachfolgesensor des BMP085. Der Sensor selbst hat normalerweise eine Versorgungsspannung von 3,3V . Aber auf dem hier verwendeten Modul ist ein Spannungsregler integriert, so dass ein Betrieb mit 5V möglich ist. Also unbedingt auf den folgenden Bildern den Modultyp vergleichen. Ansonsten kauft man die 3V-Version und beschädigt so das Modul sofort bei Inbetriebnahme! Mehr zu diesem tollen Sensor hier :  http://www.bosch-presse.de/presseforum/details.htm?txtID=5192
Den genauen Anschluss des Sensors zeigt das nachfolgende Bild:

Folie10

 

Anschluss Lichtsensor BH1750:
Die Messung der Helligkeit kann in einfacher Form mit einem  lichtabhängigen Widerstand (LDR), erfolgen. Diese Bauelemente sind in vielen Dämmerungsschaltern und Bewegungsmeldern verbaut und verrichten für „normale“ Verhältnisse ihre Funktion recht gut. Sie sind einfach anzuwenden und sehr preiswert.
Leider hat aber die Umgebungshelligkeit eine riesige Dynamik zwischen „rabenschwarzer“ Nacht und Helligkeit in der prallen Sonne!
Diese Webseite zeigt das recht anschaulich: http://s6z.de/cms/index.php/arduino/sensoren/15-umgebungslichtsensor-bh1750
Für höhere  Ansprüche an die Lichtintensitätsmessung ist deshalb die Verwendung des I2C-Sensors BH1750 anzuraten. Auch dieses Modul ist mit 5V betreibbar und kann genauso einfach wie der Barometersensor an den I2C-Bus angeschlossen werden. Dabei kann der Sensor BH1750  alleine oder zusammen mit  dem BMP180 am I2C-Bus betrieben werden. (wie im Bild oben gezeigt)

So schließt Impulsgeber und S0-Schnittstellen an:

Für die Hausautomation ist die Überwachung der Zählerstände vom Stromzähler, vom Gaszähler und vom Wasserzähler wichtig, weil nicht nur der Nutzer informiert werden kann sondern von den Veränderungen der Zählerstände auch für die Hausautomation entsprechende Steuer- und Regelmaßnahmen abgeleitet werden können. Darüberhinaus sind mittlerweile viele Solarkollektoren auf den Dächern, die mit ihrer Stromerzeugung zusätzliche wertvolle Informationen für die Steuerung der Automationskomponenten im Haus geben können; beispielsweise ob und wie stark die Sonne scheint.

Bei neueren Impulszählern sind bereits sog. S0-Schnittstellen vorhanden. Mehr dazu hier: http://de.wikipedia.org/wiki/S0-Schnittstelle
Daneben gibt es noch viele Zählersensoren mit sog. TTL-Ausgang oder auch  als sog. Open-Collector-Ausgang (O.C–Output). Alle Zähler geben entsprechend dem  Verbrauch der verschiedenen Medien eine definierte Zahl von Impulsen pro Minute oder Stunde oder Tag ab und sind somit ein Abbild des Verbrauches.

Am Homeduino können direkt am I/O-Shield maximal 2 Impulsgeber angeschlossen werden. Wer mehr benötigt, der kann 4 weitere Impulsgeber an die bisher ungenutzten hinteren Datenpins des MEGA 2560 anschließen. In nächster Zeit wird ein weiteres ergänzendes I/O-Shield verfügbar sein, daß auch die hinteren Pins des MEGA über Schraubklemmen einfach verfügbar macht. Die folgenden Bilder zeigen die Anschlußkonfiguration der verschiedenen Zählergeber an den Homeduino:
Folie26

 

Folie27

 

Folie28

 

Die Integration der zugehörigen Software in das Homeduino Sensormodul  war nicht ganz einfach, weil bei einem regelmäßigen Abfragen der verwendeten Impulseingänge u.U. Impulse verloren gehen können. Deshalb wurden zur Impulszählung nur die verfügbaren Dateneingänge mit direkter Interrupt-Möglichkeit verwendet. Damit wird das laufende Sketch bei jedem neuen Impuls unterbrochen und mit einer Interruptroutine der entsprechende Zähler inkrementiert. Mehr dazu oben im Listing des aktuellen Sketches.

Was muß man tun, um die Zählerfunktion zu implementieren?
Zuerst muß sicher gestellt sein, daß die für die Impulszählung verwendeten Systemvariablen  homeduino_x_imp xy  auch  in der CCU definiert sind. Danach ist das aktuelle Sketch noch mit den sog. user-eingaben auf die Bedürfnisse des Anwenders einzustellen.  Der für die Impulszählung relevante Definitionsteil ist im Sketch:

volatile unsigned long pulsecounter[6] = {0,  //Zaehlerstand fuer D2-Impulseingang bei Reset                                        <<user-eingabe<< 
                                          9630,  //Zaehlerstand fuer D3-Impulseingang bei Reset                                     <<user-eingabe<<  
                                          0,  //Zaehlerstand fuer D21-Impulseingang bei Reset                                       <<user-eingabe<<   
                                          0,  //Zaehlerstand fuer D20-Impulseingang bei Reset                                       <<user-eingabe<<  
                                          0,  //Zaehlerstand fuer D19-Impulseingang bei Reset                                       <<user-eingabe<< 
                                          0,  //Zaehlerstand fuer D18-Impulseingang bei Reset                                       <<user-eingabe<< 
                                         };        
//hier wird der Teilerfaktor für die Impulszaehler festgelegt
int pulsedivider[6] = {5,  //Teilerfaktor fuer D2 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor                              <<user-eingabe<< 
                       1,  //Teilerfaktor fuer D3 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor                              <<user-eingabe<<  
                       1,  //Teilerfaktor fuer D21 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor                             <<user-eingabe<<  
                       1,  //Teilerfaktor fuer D20 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor                             <<user-eingabe<<  
                       1,  //Teilerfaktor fuer D19 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor                             <<user-eingabe<<  
                       1,  //Teilerfaktor fuer D18 : wenn 0, dann keine Zaehlfunktion, sonst Teilfaktor                             <<user-eingabe<<  
                      };

Mit dem oberen Definitionsteil können die Zählerstände einen bestimmten Startwert bekommen. Im unteren Definitionsteil sind für jeden Zählkanal beliebige ganzzahlige Teilerfaktoren definierbar, um die Impulsfrequenzen mit  einem gewünschten Teilerfaktor zu reduzieren. Das ist ganz praktisch, um eine  Impulszählung des Strom- oder Gaszählers beispielsweise auf KWh  o.ä. zu normieren.

 

Weitere Sensoren werden folgen !

Haftungs- und Sicherheitshinweise

Beim Nachbau müssen natürlich alle wichtigen einschlägigen Sicherheitsvorschriften für den Umgang mit gefährlichen Spannungen  eingehalten werden. Fundierte theoretische und praktische Fachkenntnisse der Elektrotechnik und für den Umgang mit gefährlichen Spannungen sind unverzichtbar!!

Durch eine unsachgemäße Installation gefährden Sie ihr Leben und das Leben ihrer Mitmenschen! Darüberhinaus riskieren Sie erhebliche Sachschäden , welche durch Brand etc. hervorgerufen werden können ! Für alle Personen- und Sachschäden durch falsche Installation etc. ist nicht der Hersteller sondern nur der Betreiber verantwortlich.

Ich verweise hier unbedingt auf  die  „Sicherheitshinweise und Haftungsausschluss„-Seite dieses Blogs.

 

 

 

Fähigkeiten

Gepostet am

28. November 2014

46 Kommentare

  1. Die Möglichkeit gibt es natürlich, aber ich kann leider nicht jeden Sonderwunsch umsetzen. Dazu mußt Du schon selbst programmieren. Die Sourcecodes aller Homeduinos sind deshalb ja alle veröffentlicht. Dürfte damit nicht allzu schwer sein.
    … und man lernt, spezielle Anforderungen selbst umzusetzen 😉 Der Homeduino bietet ja alle Voraussetzungen dafür
    Viel Erfolg!

  2. Hi gibt es denn eine möglichkeit das I2C Display wieder zu integrieren wie bei dem ersten homeduino den habe ich schon seit längerm am laufen mit lan nur jetzt ist es halt nötig das ganze auf wlan umzubauen
    Ich verwende den homeduino nur als anzeige und benötigte eigendlich die ganzen ein und ausgänge nicht wäre nett wenn du mir ein Sketch mit wlan und I2C Display geben könntest
    Grüße
    Jens

  3. Danke für den Hinweis, das ist irgendwie da reingerutscht.
    Ist bereits korrigiert!

  4. Hallo,
    Habe schon mehrere Homeduinos im Betrieb super Sache ! Weiter so !!

    Beim Aktualisieren ist mir aufgefallen das
    in der Zeile 518 sich ein kleiner Fehler eingeschlichen hat 😉

    {pulsecounter[3]++;}Vorschau der Änderungen

    heißt doch bestimmt nur

    {pulsecounter[3]++;}

    Beste Grüsse aus dem Lipperland
    magicx

  5. I think this is a real great blog post.Much thanks again. cfkdebdcdddc

  6. Hallo,

    habe seit Mittwoch nun das Homeduino mit Shield am laufen und freue mich sehr über die super Anleitung für alle Sensoren!!!

    Das einzige was mir noch fehlt ist, ich wollte mal die DHT11 ausprobieren (hab da noch ein paar von hier liegen) welche Zeilen muss ich dafür ändern.
    Gibt es irgendwo schon eine Anleitung für den 433Mhz Sender und Empfänger habe da bis jetzt leider nichts finden können und meine versuche waren bisher nicht wirklich von Erfolg gekrönt.

    Grüße
    Lars

Kommentar absenden

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Translate »