Heute will ich Euch zeigen, wie Ihr mit AsksinPP einen eigenen 7-fach Feuchtigkeitssensor für Eure Blumen und Pflanzen bauen könnt. Dieser Sensor ist dafür bedacht, die Feuchtigkeit der Erde zu messen (Bodenfeuchtigkeitsmessung), als gute alternative zu den recht teuren Gardena Geräten. Das ganze funktioniert als generisches Homematic Gerät, sodass die Messwerte direkt in der CCU ausgewertet werden können. Mit den Werten zur Feuchtigkeit Eures Bodens kann dann ganz gezielt ein Magnetventil (Hunter, Gardena, RainBird und co.) angesteuert werden. Die Platine für die Ansteuerung werde ich Euch in einem nächsten Artikel vorstellen. Hier geht es zuerst um den Aufbau der Sensorik um die genaue Feuchtigkeit in Eurem Garten zu ermitteln.

Technische Daten / Hintergründe

Ich habe diesen Bausatz so entwickelt, dass er draußen eingesetzt werden kann. Das Gehäuse ist wasserdicht und die Kabel sind UV-beständig. Zudem ist eine Solarzelle vorgesehen, die Solarzelle versorgt die Platine und einen Akku. So ist das Gerät völlig unabhängig von Batterien und einer Steckdose. Es sind 7 kapazitive Sensoren Verbaut, die die Bodenfeuchtigkeit messen können. Die Kabel der einzelnen Sensoren können bis zu 25m lang sein, sodass Ihr mit diesem Bausatz auch große Flächen im Garten abdecken könnt. Die Sensoren werden dort in die Erde gesteckt, wo gemessen werden soll. So können z.B. gezielt Pflanzen überwacht werden, Balkonkästen oder aber auch große Beete. Die werte werden per Funk direkt zur Homematic-Zentrale gesendet und können dort in Programmen verarbeitet werden. So ist es möglich, eine voll automatische Gartenbewässerung aufzubauen.

An dieser Stelle will ich mich aber auch nciht mit frenden Federn schmücken! Ich habe lediglich die Komponenten zusammengestellt und die Platine für diesesn Bausatz zusammen mit Björn entwickelt. Die Software für dieses Projekt stammt von pa-pa (AskSinPP library) und von Jérôme, der die Erweiterungssoftware für die Homematic-Zentrale geschrieben hat und auch das Sketch für den Arduino, der hier verbaut ist. Daher ein riesen Danke, dass Ihr solche tollen Projekte möglich macht.

Was wird für den Bausatz alles benötigt?

Diesmal ist die Liste etwas länger, da es sich um einen komplexeren Bausatz handelt, der ja wie schon gesagt auch wetterfest sein soll. Hier zuerst ein Foto, der Komponenten, die ich verbaut habe – Ihr könnt das komplette Set auch bei uns im Shop kaufen. Dort sind bereits alle Teile zusammen, sodass Ihr diese nicht einzeln bestellen müsst. Ansonsten habe ich Euch alle Link zu den einzelnen Komponenten unten aufgeführt. Die Platine für dieses Projekt gibt es auch einzeln im Shop.

Grundplatine1xWebshop technikkram
Komplettbausatz (alle Teile)optinal Webshop technikkram
Aurduino 8MHz 3,3V1xAliexpress
Funkmodul CC11011xAliexpress
Terminal Block 2-fach2xAliexpress
Terminal Block 3-fach7xAliexpress
SMA Antennensockel1xAliexpress
Taster1xConrad Elektronik
10µF Elko1xConrad Elektronik
470K Ohm Widerstand1xConrad Elektronik
100K Ohm Widerstand1xConrad Elektronik
330 Ohm Widerstand1xConrad Elektronik
Solarzelle1xAliexpress
LiPo Akku1xAliexpress
2 mm Pin (optional)9xAliexpress
2,54 mm Pin32xAliexpress
2,54 mm 90° Pin11xAliexpress
Kapazitive Sensoren7xAliexpress
Solar Charger Elektronik (In 3,7-6,5V Out 5V)1xAliexpress
LiPo Protection1xAliexpress
Antenne 2,5 dbi mini1xAmazon
Schrauben M3,5 5mm lang2xAliexpress / eBay
M25 x 1,5 Kabelverschraubung2xAliexpress
Hensel Dose DK04001xAmazon
Schrumpfschlauch (mit Kleber)1mAliexpress (mit Glue!)
M25 Mehrfach. 3-fach1xReichelt
M25 Mehrfach. 4-fach1xReichelt
0,75 mm Kabel1mConrad / eBay überall erhältlich
1 M Steuerleitung 3×0,1435msmartkram

Bilder der Grundplatine

Anbei seht Ihr die fertige Platine, die bei diesem Projekt verwendet wird. Die Platine ist dafür vorgesehen, in der oben verlinkten Hensel-Dose verschraubt zu werden. Die Gerber-FIles, den Schaltplan und das Layout der Platinen findet Ihr hier zum Download.

CC1101 anlöten und testen

Zuerst löten wir das Funkmodul an, das für die Funk-Kommunikation verantwortlich ist. Hier gibt es zwei Methoden. Entweder benutzt Ihr die 2mm Pins, die dem Baustaz beiliegen. Dann werden zuerst die Pins angelötet und dann das Modul auf die Pins gesetzt. Bei den oberen 3 Pins müsst Ihr jeden Pin jedoch einzeln löten, da das Rastermaß vom CC1101 nicht 2mm ist.

Einfacher ist es jedoch, dass Modul direkt auf die Platine zu löten. Zuerst fixiert Ihr die Platine provisorisch, damit diese nicht verrutscht. Das kann entweder mit Klebeband oder einen Draht sein, der in eine Bohrung gesteckt wird. Versucht nun zunächst, das Funk-Modul über einen Lötpunkt auf der Platine zu befestigen und fangt dabei auf der gegenüberliegenden Seite an. Ordnet das Modul so an, dass auf beiden Enden die Lötanschlüsse der DIY-Platine noch zu sehen sind. Richtet jetzt die 8-polige Seite des Funkmoduls exakt aus und verlötet alle Anschlusspunkte. Nehmt genügend Lötzinn, damit es durch die Lötfelder in die Platine durchsickert, aber auch nicht zuviel, damit ihr keine Brücken baut. Danach widmet ihr euch der anderen Seite mit den 3 Anschlüssen für die Antenne. Auch hier ist die beste herangehensweise, das Lot durch die oberen Anschlusspunkte in die Platine „durchsickern“ zu lassen.

Auf dem Bild sehr Ihr, wie das Ergebnis aussehen kann. Da das Funkmodul teilweise Fertigungstoleranzen in der Größe aufweist, hab ihr nicht immer die Möglichkeit, eine richtige Brücke zwischen Platine und Funkmodul zu ziehen. Lasst das Lot dann einfach, wie beschrieben, durchsickern.

Damit es zu keinen kalten Lötstellen kommen kann, solltet Ihr die Lötpunkte auf der Rückseite der Platine nochmal erhitzen. Das Ergebnis sollte wie oben im Bild aussehen. Wer auf Nummer sicher gehen will, sollte zudem messen, ob keine Verbindung zwischen den oberen Lötpunkten entstanden ist. Die beiden äußeren Punkte sind die Masse der Antenne. Diese finden sich im äußeren Viereck des SMA-Steckers wieder.

SMA Stecker Anlöten

Dieser Schritt ist optional, wenn Ihr eine externe Antenne betreiben wollt. Dies ist sinnvoll, wenn das Gerät im Garten steht und die Entfernung zur CCU zu groß wird. Wollt Ihr keine externe Antenne verwenden, kann einfach ein kleiner Draht (ca 8cm) als Antenne auf den mittleren Anschluss (oben) des CC1101 gesetzt werden.

Beim fertigen Bausatz liegt eine kleine externe Antenne und der zugehörige SMA-Sockel bei. Dieser sollte so ausgerichtet sein, dass die Antenne zum Arduino zeigt.

Oben im Bild seht Ihr, dass die Antenne nach links zum Arduino zeigt. Einfacher ist es, wenn Ihr den Sockel ganz am Ende einlötet. Dann kann die Platine einfacher bestückt und flach auf den Tisch gelegt werden.

Taster, Elko und Widerstände einlöten

Jetzt kommen wir zu den Kleinteilen, die auf die Platine gelötet werden müssen. Wir fangen mit den drei Widerständen an.

Auf dem Foto sind die drei Widerstände zu sehen, die dem Bausatz beiliegen. Von links nach Rechts: R1, R2 und R3. Es ist wichtig, dass die Widerstände an die richtige Stelle gelötet werden.Der Widerstand R3 dient als Messbrücke für die Spannungsmessung am LiPo-Akku. Der Widerstand R1 dient als Vorwiderstand für die Diode und der R2 ist Teil der Messbrücke für die Spannung.

Hier seht Ihr die 3 Widerstände, die von der Rückseite noch verlötet werden müssen.

Nun folgen die anderen Bauteile. Seht Euch dazu bitte die Fotos an.

Der Laderegler wird auf einen 90° Sockelleiste gelötet. Da der Platz auf der Platine nicht gerade üppig ist, sollten die Pins gleichmäßig nach oben gebogen werden, damit Ihr mehr Platz zum löten habt. Wichtig ist auch, dass die Bauteile des Ladereglers zum Taster (weg vom Arduino!) zeigen. Der Elko muss so ausgerichtet werden, dass der weiße Balken auf dem Bauteil auf der ausgefüllten Fläche sitzt.

Aurduino anlöten

Jetzt können wir das Herzstück unserer Platine einlöten. Der Arduino wird auf 2,54mm Pins gesetzt, damit das löten einfacher ist. Bittet lötet zuerst alle Pins für den Arduino auf die Platine. Der letzte Pin (oben am roten Taster) bleibt leer. Denkt auch bitte an die Pins A4 und A5!

Nach dem wir nun auch den Arduino verlötet haben, können wir uns um den LiPo-Schutz kümmern. Dieser ist wichtig für den Akku, damit dieser nicht kurzgeschlossen oder überladen werden kann. Der LiPo-Schutz wird auf 4 2,54mm Pins gesetzt. Grundsätzlich wäre auch ein direktes Auflöten, wie beim Funkmodul, möglich. Benutzt in diesem Fall aber bitte die Pins, denn trotz aller Sorgsamkeit beim Löten liess sich mein Arduino nach Abschluss des Platinenaufbaus nicht zum Arbeiten bewegen. Erst spät habe ich bemerkt, dass der LiPo Schutz nicht sauber aufgelötet war, so dass ich auf Pins umgestiegen bin.

Bestückung mit Schraubsockeln

Nachdem wir alle Bauteile auf die Platine gelötet haben, können wir uns um die Schraubsockel kümmern, an denen Später die Solarzelle, der Akku und die 7 Sensoren angeschlossen werden. Für die Sensoren habe ich 3-polige Sockel vorgesehen (7 Stk.) für die Solarzelle und den LiPo Akku 2-polige Sockel.

Die Sockel für die Sensoren zeigen beide nach innen, damit die Kabel später in der Gasse zwischen den beiden Sockelreihen gelegt werden können. Mit diesem Schritt ist die Platinen nun komplett fertig und wir können uns den Sensoren und dem Gehäuse widmen.

Sensoren vorbereiten

Die Sensoren dienen zur Erfassung der Feuchtigkeit im Boden. Da diese Wind, Wetter und vor allem Feuchtigkeit ausgesetzt sind, müssen wir dafür sorgen, dass die Elektronik vor Wasser geschützt wird. Ich habe viel hin und her getestet und bin zum Entschluss gekommen, dass ein Schrumpfschlauch mit integriertem Kleber die beste Möglichkeit ist, die Sensoren Wasserfest zu machen. Jetzt zeige ich Euch Schritt für Schritt, wie Ihr die Sensoren aufbauen könnt.

So sehen die Sensoren aus, wenn Ihr diese aus meinem Bausatz erhaltet. Zuerst müssen wir den weißen Stecker entfernen. Das können wir mit einem Seitenschneider machen und im Anschluss die abgeschnittenen Pins auslöten.

Hier seht Ihr die Pins ohne den weißen Stecker. Diese habe ich mit einer Zange gefasst und die Lötverbindung erhitzt. So können die Pins sehr leicht entfernt werden.

Hier seht Ihr, die Anschlüsse, an denen nun unter Kabel gelötet werden kann. Beim Kabel ist es wichtig, dass Ihr für den Außenbereich ein UV-beständigen Mantel verwendet, da das Kabel sonst nach kurzer Zeit brüchig wird und so nicht mehr zu gebrauchen. Das Kabel kann bis zu 25m lang werden. Es sind auch größere Distanzen möglich, doch dann kann nicht mehr garantiert werden, dass die Signale richtig übertragen werden. Daher solltet Ihr die Länge von 20-25m nicht überschreiten.

Kabel vorbereiten

Nachdem die Kabel abisoliert (ca. 3-4 cm) und mit Lötzinn überzogen worden sind, können wir diese an den Sensor löten.

Hier seht Ihr ein an den Sensorpins fertig gelötetes Kabel. Bitte verwendet die folgende Pinbelegung:

Nummerierung (1,2,3) am Anschlussblock auf der DYI-Platine:

Klemmblock-Belegung DIY-PlatineBelegung Sensor
1. SignalleitungAUOT
2. + VersorgungVCC
3. MasseGND

Nun stülpen wir zuerst ein Stück des großen Kabelbinders über den Sensor (ca 4-5 cm) Der Schrumpfschlauch schrumpft im Verhältnis 1:3. Durch den integrierten Kleber, der bei Hitze flüssig wird, wird eine optimale Abdichtung hergestellt.

Der Schrumpfschlauch sollte oberhalb der weißen Linie vom Sensor bleiben, da hier der aktive Teil des Sensores anfängt. Im Bild seht Ihr den geschrumpften Schlauch und wie er die Bauteile abdichtet. Ihr könnt den Kleber ruhig mit einem stumpfen Gegenstand etwas herausdrücken, damit eine vollständige Abdichtung gegeben ist.

Nun müssen wir uns noch um die obere Abdichtung des Kabels kümmern. Dazu schieben wir den kleiner Schrumpfschlauch (ca. 5cm) von der anderen Seite über das Kabel und stülpen diesen über den bereits geschrumpften größeren Schlauch.

Es ist wichtig, dass der kleinere Schlauch so weit wie möglich nach unten gezogen wird. Durch das erhitzen schrumpft dieser ebenfalls und der Kleber verbindet sich mit dem ersten Schlauch und dichtet diesen ab. Zudem haben wir durch den zweiten Schrumpfschlauch einen Knickschutz geschaffen, der das Kabel schont.

Hier seht Ihr nun alle fertigen Sensoren. Bitte geht bei diesem Schritt sorgsam um, da sonst Wasser eindringen kann und der Sensor dann im schlechtesten Fall komplett ausfällt. Für das Schrumpfen habe ich mit einen kleinen Brenner gekauft, den man sonst für Creme Brulee verwendet. Ein Feuerzeug ist dafür eher nicht geeignet, da die Flamme zu kalt ist und die meisten Feuerzeuge nicht dafür geeignet sind, über einen längeren Zeitraum betrieben zu werden.

Solarzelle vorbereiten

Jetzt fehlt nur noch die Solarzelle, um das Gerät mit Energie zu versorgen! Diese kleben wir mit Silikon oder einem anderen Klebstoff auf den Gehäusedeckel und dichten diesen damit ab. Anbei die Schritt für Schritt Anleitung.

Zuerst bohren wir mit einem 6 mm (kann auch größere oder kleiner sein!) zwei Löcher in den Deckel der Hensel-Dose. Da die Anschlüsse der Solarzellen leider je nach Charge unterschiedliche ausfallen, müssen die Kontakte zum Anschluss vorher ausgemessen werden und auf den Gehäusedeckel übertragen werden. Dann werden an die Anschlüsse der Solarzelle zwei Kabel gelötet. Diese sollten ca. 15 cm lang sein, damit der Deckel später auch bequem abgenommen werden kann. Beschriftet bitte die Enden der Kabel, da wir später nicht mehr nachvollziehen können, welcher für „+“ und welcher für „-“ vorgesehen ist.

Nun werden die beiden Kabel durch die beiden Bohrungen geführt. Danach verteilen wir sehr großflächig Silikon (oder anderen Dichtstoff) auf dem Gehäusedeckel und drücken die Solarzelle fest an. Ich habe die Zelle nach dem ersten Versucht wieder abgenommen und geschaut, ob an manchen Stellen noch Silikon fehlt. Dieses habe ich dann ergänzt und die Solarzelle erneut angedrückt. Es sollte Silikon an den Seiten herausquellen. Dieses kann man später mit den Finger (und etwas Spüli) gut glatt streichen. Damit die Zelle auch wirklich fest sitzt, sollte ein schwerer Gegenstand auf die Zelle gesetzt werden, bis das Silikon fest geworden ist.

Die Solarzelle passt exakt auf den runden Deckel der Hensel-Dose!

Nun müssen wir die Hensel-Dose vorbereiten, damit die Kabelverschraubungen angebracht werden können. Dazu müssen zwei Durchbrüche in die Dose gemacht werden. Diese sind dafür bereits vorbereitet. Es muss das Gummi inkl. dem äußeren Ring entfernt werden. Achtung! Legt die Platine vorher ins Gehäuse und schaut Euch an, welche beiden Löcher durchbrochen werden sollen. Ich habe die Platine so ausgerichtet, dass die Antenne an der Seite liegt, wo nur ein Durchbruch vorgesehen ist. Dadurch ist die Platine so ausgerichtet, dass die beiden Löcher unten recht und unten links für die GP-Verschraubung genutzt werden können.

Achtung:

In einigen Bausätzen hat der Hersteller wohl leichte Änderungen an der Kontermutter vorgenommen. Es befindet sich ein runder Kranz um die Mutter herum.

Damit ihr die Kontermutter nun so tief ins Gehäuse bekommt, damit ihr von Außen die Kabeleinführung einschrauben könnt, schneidet einfach auf einer Seite den runden Kranz mit einem Seitenschneider ab. Im Bild könnt ihr die gekürzte Seite auf der rechten Seite der Mutter erkennen. Diese wird in Richtung Unterseite des Gehäuses positioniert.

Es liegt ein Gummi bei mit 3 Löchern für die Verschraubung und ein Gummi mit 4 Löchern. Dadurch können alle 7 Sensoren wasserdicht eingeführt werden. Sollte bereits ein Gummi in den Verschraubungen vorhanden sein, muss dieses zuvor entfernt und gegen die neuen Gummis getauscht werden.

Beachtet bitte folgende Reihenfolge: Ihr nehmt die Sensoren, zuerst wird die Überwurfmutter mit der runden Fläche zu den Sensoren über die Kabel gezogen, dann folgt das Gummi. Hier werden die offenen Kabelenden durchgezogen. Diese werden dann durch die Verschraubung in der Dose gesteckt.

Jetzt können die Sensoren angeschlossen werden. Damit Ihr später auch wisst, welcher Sensor für welchen Kanal ist, solltet Ihr auch hier eine Beschriftung an den Sensoren vornehmen. Alternativ hier noch einmal die Zuordnungstabelle:

Klemmblock-Belegung DIY-PlatineBelegung Sensor
1. SignalleitungAUOT
2. + VersorgungVCC
3. MasseGND

Ich habe die Platine beim Verschrauben der Sensoren noch nicht am Gehäuse fixiert. So hat man mehr Spielraum beim Verdrahten.

Nun kann auch die Solarzelle angeschlossen werden. Achtet dabei bitte auf die richtige Polung. + / – sind auf der Platine aufgedruckt.

Akku vorbereiten

Auch der Akku kann jetzt montiert werden. Dazu muss zuerst der vorhandenen Stecker abgeschnitten werden. Macht dies bitte einzeln, da der Akku sonst kurzgeschlossen wird. Auch hier habe ich Lötzinn auf die Kabel aufgetragen, damit keine Aderendhülsen für die Montage benötigt werden.

Nun ist unsere Hardware komplett aufgebaut und die Platine mit den beiliegenden Schrauben mit dem Gehäuse verbunden. Auch die Antenne ist montiert (Achtung hier ist ein altes Bild vorhanden! Die Antenne sollte wie schon beschrieben zum Arduino hin ausgerichtet werden!).

Software einspielen

Jetzt kommen wir zur Software für unseren neuen Sensor!

Da ich weiß, das viele von Euch noch keinerlei Erfahrung mit Arduino und dessen Programmierung gemacht haben, werde ich auch diese Schritte im Detail beschreiben. Zuerst müssen wir die Arduion IDE Software herunterladen. Diese gibt es für Windows, Mac und Linux.

Nachdem der Download beendet ist, müsst die die Installationsroutine durchlaufen und das Programm starten.

AskSinPP herunterladen

Um zu starten benötigen wir zuerst AskSinPP. Über die Schaltfläche „Clone or download“ rufen wir ein weiteres Fenster auf. Hier wählen wir nun Download ZIP aus.Nachdem die Datei heruntergeladen ist entpacken wir die Datei in einem temporären Ordner.

Nun müssen wir aus den soeben entpackten Dateien ein neues Archiv machen, jedoch ohne das zusätzliches Unterverzeichnis AskSinPP. Im neuen ZIP-Archiv sind dann direkt die Ordner bootloader, examples usw… zu finden.

Das neue Archiv kann den gleichen Namen wie das alte Archiv tragen.

Wir brauchen diese Datei gleich, um die ZIP-Datei als zusätzliche Library in Arduino IDE einzubinden.

Einbinden der AskSinPP Bibliothek

Die soeben angelegte ZIP-Datei spielen wir jetzt in das Arduino IDE ein. Dazu klicken wir im Hauptfenster auf „Sketch“ und dann auf „Bibliothek einbinden“ dort wählen wir dann „.ZIP-Bibliothek einbinden…“ an.

In dem neuen Fenster wählen wir nun unsere soeben erzeugte ZIP-Datei aus. Damit haben wir die wichtigste Bibliothek für die Funktion unseres neuen Sensors eingebunden!

Zusätzliche Bibliotheken installieren

Zuerst müssen aber noch weitere Bibliotheken geladen werden, damit das Projekt laufen kann.

Wir brauchen folgende Bibliotheken, die noch installiert werden müssen:

  • EnableInterrupt (Mike Schwager)
  • Low-Power (Rocket Scream)
  • Register

Fangen wir mit der ersten Bibliothek an. Diese installieren wir über das Haupfenster mit einem Klick auf „Sketch“ –> „Bibliothek einbinden“ –> „Bibliothek verwalten…“

Es öffnet sich ein neues Fenster. Dort können wir dann nach der benötigten Datei suchen.

Wir geben als im Eingabefeld „EnableInterrupt“ ein und wählen die aktuelle Version aus und danach auf „Installieren“.

Damit haben wir nun die erste Bibliothek eingebunden.

Die nächste Library, die wir benötigen können wir hier von GitHub herunterladen. Auch diese Bibliothek binden wir wieder über die Schaltfläche „Sketch“ –> „Bibliothek einbinden…“ und dann auf „.ZIP-Bibliothek hinzufügen…“.

Anbei der Link zur fehlenden Bibliothek: lowPower

Diese Bibliotheken könnt Ihr auf GitHub herunterladen, indem Ihr auf der rechten Seite auf „Clone or download“ drückt. Dann müsst Ihr „Download ZIP“ auswählen.

Auch diese Datei binden wir wieder über die Schaltfläche „Sketch“ –> „Bibliothek einbinden…“ und dann auf „.ZIP-Bibliothek hinzufügen…“ ein.

Damit haben wir nun alle nötigen Dateien zusammen und können jetzt das Board konfigurieren!

Board Konfigurieren

Nun müssen wir dem Programm noch mitteilen, welches Board wir programmieren wollen. Dazu klicken wir auf „Werkzeuge“ und tragen dort die Information ein, die Ihr im Bild sehen könnt. Verwendet die drei Einträge über dem markierten „Boardinformation holen“.

Hier sind die Einstellungen nochmal einzeln aufgeführt. Um an den COM-Port des FTDI-Adapters zu erhalten, muss der Adapter an den Computer angeschlossen werden. Ihr könnt dann im Gerätemanager den passenden Port sehen. In meinem Fall ist das COM7.

  • Board: Arduino Pro or Pro Mini
  • Prozessor: ATMega328P 3.3V 8MHz
  • Port: Der COM Port vom FTDI Adapter

Bei Nutzung eines Macs wählt ihr nicht den COM-Port aus, sondern direkt das Flash-Device aus der Liste.

Arduino flashen

Jetzt haben wir soweit alles vorbereitet, dass der Arduino programmiert werden kann. Dazu müssen wir den Programmer auf 3,3V umstellen. Auf der Platine ist dafür ein Jumper angebracht. Dieser kann entweder in der Stellung 3,3V oder 5V gesteckt werden. Wir müssen diesen für unseren Arduino auf 3,3V stellen.

Sketch laden

Nun können wir das eigentliche Sketch für den Sensor in den Arduino laden. Dazu öffnen wir die Arduino Software und klicken auf Datei –> Neu. Es öffnet sich ein leere Fenster, indem bereits ein paar Zeilen Code stehen. Der original Code stammt von Jérôme. Ich habe nur ein paar Zeilen modifiziert, damit alle 7 Sensoren angesprochen werden können. Anbei der Code, den Ihr kopieren müsst – ich habe Euch eine Datei fertig gemacht, dort findet Ihr den Link zu Jérôme und das von mir angepasste Sketch.

Achtung:

Der oben aufgeführte LINK läßt Mac-User verzweifeln. Es handelt sich dabei um die Datei „HB-UNI-SEN-CAP-MOIST.zip„, die bei Mac-Usern durch anklicken (entpacken) zu einer .cpgz Datei wird… Nach dem Entpacken sollten hier eigentlich zwei Textdateien entpackt werden. Daher für die Mac-User: Nehmt ein anderes Archivierungs-Tool als das Mac-eigene. Ich habe mich hier für „Keka“ entschieden. Damit klappte das Entpacken auch wie gewünscht.

Meine Modifikation für diesen Sensor ist in Zeile 43 und 44 zu finden. Dort legen wir fest, welcher Sensor angesprochen wird. Wir nutzen alle verfügbaren (übrigen) analogen Eingänge des Arduino. So können 7 Sensoren parallel betrieben werden.

Nun klicken wir im Fenster auf „Sketch“ –> „Überprüfen / Kompilieren“.

Wenn Ihr bis hier alles richtig gemacht habt, dann können wir das Programm nun auf die CPU schreiben.

Dazu klicken wir auf „Sketch“ –> „Hochladen“

Auch dieser Vorgang dauert etwas und Ihr könnt beobachten, wie die beiden roten LEDs am Programmer während des Vorgangs blinken.

Damit haben wir erfolgreich die Software auf das Gerät gespielt!

Erste Inbetriebnahme / Installation prüfen

Nachdem der Vorgang abgeschlossen ist, können wir überprüfen, ob alles richtig funktioniert. Dazu öffnen wir den seriellen Monitor. Das machen wir über „Werkzeuge“ –> „serieller Monitor“. Dort sollten dann die Sensorwerte und auch die Ein-/ Ausgehende Kommunikation zu sehen sein.

Die Ausgabe sollte ähnlich dem sein, was ihr auf dem Screenshot seht. Falls nur „wirre“ Zeichen auftauchen, stellt die Übertragungsgeschwindigkeit auf den korrekten Wert von 57600 Baud.

Noch eine kleine Info zur Prüfung der Solarzelle bzw. des Ladeverhaltens:

Der Laderegler besitzt zwei LEDs, die mit CR und OK beschriftet sind. Sobald die Solarzelle in die Sonne gehalten wird, glimmt die CR Leuchte rot auf. CR bedeutet in diesem Fall „Charge“. Die Helligkeit der Leuchtdiode schwankt mit dem Sonneneinfall. Sobald der Akku voll ist, wechselt die LED OK auf grün.

Anlernen an die CCU / Zusatzsoftware von Jérôme installieren

Damit der Sensor richtig angelernt werden kann, muss auf der CCU eine Zusatzsoftware installiert werden, die ebenfalls aus der Feder von Jérôme stammt. Die aktuelle Version dieses Sketches entspricht 2.7, unser Sketch ist jedoch noch nicht auf Version 2.7 angepasst. Verwendet daher bitte die Addon-Version 2.6 von Jérôme, die Ihr unter folgendem Link von GitHub herunterladen könnt.

Im unteren Bereich findet Ihr eine *.tgz-Datei. Danach begeben wir uns auf die Oberfläche der CCU (WebUI) und dort gehen wir auf Einstellungen –> Systemsteuerung –> Zusatzsoftware. Bei dem Punkt Zusatzsoftware installieren / aktualisieren wählen wir über „Datei auswählen“ die zuvor heruntergeladene Datei aus.

Die Zentrale macht daraufhin einen Neustart, der etwas länger als üblich dauert.

Anlernen an die CCU

Nachdem nun auch der letzte Schritt abgearbeitet ist, kann der neue Sensor an der CCU angelernt werden. Dazu aktivieren wir den Anlernmodus der CCU und klicken danach auf den Taster von unserem neuen Gerät. Die LED vom Sensor beginnt zu blinken. Nach kurzer Zeit sollte der Sensor im Posteingang zu finden sein. Dort können dann alle 7 Sensoren benannt und genutzt werden. Prüft die Funktion einfach unter „Status und Bedienung„.

Die Werte werden als „Rel. Luftfeuchtigkeit“ angezeigt. Das ist Systembedingt, spielt für die Funktionalität aber keine Rolle. Die Spannung, die zusätzlich übermittelt wird, ist die Spannung vom LiPo Akku. So kann der Ladestand der Batterie direkt kontrolliert werden.

Nun könnt ihr den Sendeabstand des Gerätes für einen Testlauf heruntersetzen. Geht dafür in die Geräteeinstellungen eures neuen Sensors und stellt die Übertragungsabstände auf 1 Minute. Um die Konfigurationsdaten zu übertragen, müsst ihr erneut den Konfigurationstaster am DIY-Sensor betätigen.

Jetzt nehmt ihr einen Feuchtigkeitssensor, drückt in fest in eure Handfläche (oder werft ihn ins Wasser) und wartet eine Minute ab, bis die Übertragung stattgefunden hat. In eurer Zentrale sollte nun ein recht hoher Feuchtigkeitswert auftauchen. Lasst den Sensor wieder los und wartet erneut eine Minute ab… Der Wert sollte auf 0% bzw. einen niedrigeren Wert zurückgehen.

Denkt daran, den Sendeabstand danach wieder zu reduzieren. Andernfalls wird die Solarzelle nicht genügend Energie liefern, um den Arduino dauerhaft zu betreiben.

Achtung:

Der Hersteller der Feuchtigkeitssensoren rät zu einer Kalibrierung der Sensoren, um plausible Werte zu erhalten. Dafür werden die Sensoren einmal „trocken“ und einmal „naß“ betrieben und die jeweils ermittelten Sensordaten als Höchst- bzw. Tiefstwerte eingetragen. Wie genau das funktioniert, erkläre ich euch in einem weiteren Bericht.

Energie Sparen

Achtung! Bei dieser Platine darf der LOD vom Arduino nicht ausgebaut werden, da dieser benötigt wird. Da wir mit einer Solarzelle arbeiten, die an einen Festspannungsregler mit 5V angeschlossen ist, geben wir mit 5V auf den RAW-Pin vom Arduino. Der LOD vom Board selbst erzeugt dann die benötigten 3,3V für das Funkmodul und die Sensore. Damit wir den Akku auch bei schlechteren Wetter etwas entlasten können, kann die Betriebs-LED vom Arduino entfernt werden. Diese ist der größte Stromverbraucher.

Das kann entweder mit einem Schraubendreher (vorsichtig!) oder mit einem Lötkolben erfolgen. Nach mehrmaligen Umsetzungen empfehle ich euch eher die Nutzung eines Lötkolbens, da die Bauteile in der Nähe doch schnell bei Einsatz eines Schraubendrehers beschädigt werden könnten.

Dieser Artikel ist dann doch sehr umfangreich geworden! Es sind noch ein paar Punkte offen, auf die ich gerne in separaten Artikeln eingehen möchte, da die Punkte auch für andere Homebrew Projekte von Relevanz sind. Da ist zum einen der Punkt, das teilweise CC1101 mit falscher Frequenz aus China kommen. Diese können Dank pa-pa durch ein Skript modifiziert werden, sodass auch diese Sensoren angelernt werden können. Ebenso gehe ich in einem weiteren Bericht auf die Kalibrierung der Sensoren ein.

Es wird in den nächsten Tagen eine weiteres Projekt folgen, damit auch Ventile angesteuert werden können, um so eine vollständige Gartenbewässerung aufzubauen. Werner wird das ganze System bei sich im Garten installieren und wir werden Euch auch zeigen, wie Ihr optimal Programme schreibt, sodass auch auf Regen eingegangen werden kann, um die Bewässerung zu steuern!

87 Kommentare
  1. Avatar
    Thorsten sagte:

    Hallo,

    eine Frage, bevor ich mir ggfs den Bausatz hole. Ich konnte leider weder im Text noch auf den Bildern erkennen,
    wie herum die rote Diode eingelötet werden muss.

    Könnt Ihr dies ggfs genauer beschrieben ?

    Vielen Dank

    Gruss
    Thorsten

    Antworten
  2. Avatar
    Kurt sagte:

    Hallo

    habe meinen Bausatz Bodenfeuchtesenor erhalten und zusammengebaut.

    Leider komme ich mit der Software trotz Beschreibung nicht klar.

    Bin folgendermasen vorgegangen:

    1)Habe die Arduino IDE Software auf meinen W10 Rechner geladen und insatlliert

    2)Habe die AskSinPP über „Clone or download“ die zip Datei geladen

    3)Ab dem Punkt „Sketch“ Bibliothek einbinden“ komme ich leider nicht mehr weiter

    Gibt es jemand der mir hier weiterhelfen kann und will ?

    Mit freundlichen Grüßen

    Antworten
  3. Avatar
    DirkA sagte:

    Hi,

    ich hab den Bausatz aufgebaut – und es funktioniert (fast) alles wie gewünscht. Alle Sensoren werden erkannt, die Verbindung zu Homematic funktioniert auch (nach Abgleich der Frequenzen). Mein Problem: 5 meiner 7 Sensoren zeigen einen Sensorwert etwas über 700 im trockenen Zustand. Einer liegt bei 470 und einer bei 210. Die Änderungen im nassen Zustand sind bei den beiden entweder klein (beim ersten) oder kaum messbar (beim zweiten). Die beiden sind Sensor 4 und 5.

    Ich hab jetzt folgendes versucht:

    – Anschlußkabel nochmal neu in den Schraubklemmen befestigt (kein Erfolg)
    – Lötpunkte der Schraubklemmen nachgelötet (kein Erfolg)
    – Lötpunkte Arduino nachgelötet (kein Erfolg)
    – Sensoren gegen neue Sensoren ausgetauscht (kein Erfolg)

    Mir gehen jetzt die Ideen aus – hat jemand einen Hinweis für mich?

    Viele Grüße

    Dirk

    Antworten
    • Avatar
      Heiko sagte:

      Hallo Dirk !
      Ich kann Dir leider nicht wirklich helfen, außer das Leid teilen :-) Auch bei mir
      haben einige Sensoren deutlich abweichende Grundwerte von den anderen.
      So richtig vergleichbar verhalten sie sich nicht bei Feuchtigkeitsschwankungen,
      und die Schwankungen der Werte sind tlw. sehr klein.
      Ich habe leider mit der Fehlersuche noch nicht richtig angefangen, werde zunächst
      mal die Anschlussleitungen neu löten (da hab ich nur provisorische Leitung benutzt)
      und dann mal die Sensoren quertauschen, um zu sehen, ob die Werte mit den
      Sensoren mitwandern oder abhängig vom Airduino Eingang sind.
      Habe nur leider wenig Zeit. Wenn es hier noch weitere Ideen / Hinweise gibt, immer
      her damit :-)
      Grüße
      Heiko

      Antworten
    • Avatar
      Manfred Schüssler sagte:

      Hallo Dirk,

      ich habe 6 Sensoren dran, da ich mit 7 das Arduino Programm nicht zum laufen bekomme.
      Trocken zeigen meine zwischen ca. 680 und 750, Nass zwischen 260 und 300.
      Falls Du einen 2-Kanal Oszi hast, dann kannst du mal auf einem Kanal die Versorgungsspannung des Sensors und auf dem anderen Kanal das Signal des Sensors messen. Wenn das Sendeintervall in der HM auf 60 Sek eingestellt ist, dann sollte alle 60 Sek für ein paar Sekunden die Versorgungsspannung auf 5VDC gehen und des Sensorsignal liefert dann kurz nach der Versorgungsspannung auch ein entsprechendes stabiles Signal. Ich denke 0-5V entspricht dann 0-1023 in der HM.
      Grüße
      Manfred Schüssler

      Antworten
  4. Avatar
    Mirko sagte:

    Hallo Zusammen,
    Ich habe den Bausatz zusammengebaut und die Software installiert. Die Ausgabe im Debuger sieht aus wie auf der Seite beschrieben. Der Funkempfänger lässt sich mit dem passenden Skript „Kalibrieren“. Scheint alles zu funktionieren, nur das Anlernen an die Homematic geht nicht.
    Drücke ich den Anlernknopf bleibt die LED ohne Funktion. Beim startendes Ardunion blinkt sie.
    Der Druckknopf schaltet bei Druck auch durch.
    Hat jemand eine Idee, woran es liegen kann?
    Danke und Grüße,
    Mirko

    Antworten
    • Avatar
      Kramykram sagte:

      Hatte Anfangs das gleiche Problem, wollte erst alles zum Laufen bringen und dann zusammen setzen/einbauen
      und hatte anfangs die Stromversorgung nur über den FTDI. Nachdem ich den Akku angeschlossen hatte funktionierte auch die Kontroll-LED und das Anlernen.
      Vielleicht ist das ja auch das Problem bei Dir.
      MfG

      Antworten
      • Avatar
        Mirko sagte:

        Hallo Kramykram,
        Danke für die Antwort. Der LiPo ist voll geladen und angeschlossen. Sensor habe ich allerdings nur einen angeschlossen/konfiguriert. Kann es daran liegen?

        Gibt es im Log eigentlich eine Benachrichtigung, wenn der Anlernknopf gedrückt wird? Bei mir erfolgt keine Reaktion

        Mirko

        Antworten
        • Avatar
          Kramykram sagte:

          Im Log? Wenn Du das Systemprotokoll von Homematic meinst, wahrscheinlich erst wenn er erkannt und somit dann folgend auch angelernt ist.
          Solltest Du den Seriellen Monitor der Arduino IDE meinen, bei korrekten Einstellungen (Board, Port, und Übertragungsrate und angeschlossenem FTDI), dann siehst Du es dort.

          Antworten
          • Avatar
            Mirko sagte:

            Danke für die schnelle Antwort. Ja, ich meine den Seriellen Monitor. Da passiert nichts, wenn ich den Config-knopf drücke. Pin 8 auf GND schaltet beim drücken aber durch. Hab jetzt diverse andere Sketche geladen und im seriellen Monitor angesehen.
            Bin mir sicher, dass das Funkmodul richtig initialisiert wird und arbeitet (Meldungen werden gesendet empfangen)
            Muss irgendwas mit dem Knopf zu tun haben. Ich suche weiter.

            LG,
            Mirko

    • Avatar
      Mirko sagte:

      Ich habe es hinbekommen. Das Anlernen funktioniert. Für alle die auch auf der Fehlersuche sind, kann ich folgende Beispiel Skripte empfehlen.
      DATEI -> BEISPIELE -> 01.BASICS -> BLINK
      Blink zum Testen der LED auf PIN4

      Folgende Änderungen am Sketch durchführen:
      Im Sketch LED_BUILTIN durch eine 4 ersetzen. Kommt dreimal vor. Sketch hochladen. LED muss blinken.

      DATEI -> BEISPIELE -> 02.DIGITAL-> DigitalInputPullup
      DigitalInputPullup für Taster auf PIN8 und LED auf PIN4

      Folgende Änderungen am Sketch durchführen:

      Serial.begin(9600);
      durch
      Serial.begin(57600);
      ersetzen

      Anschließend alle 2 durch 8 ersetzen und 13 durch 4.
      Sketch hochladen. LED ist an, wenn der Taster gedrückt wird.

      Habe so einen wackeligen Kontakt auf Pin 8 gefunden. Hoffe es hilft jemanden.

      Grüße,
      Mirko

      Antworten
  5. Avatar
    Heiko sagte:

    So, jetzt ich doch nochmal. Evtl. kann mir jemand weiterhelfen.
    Ich habe den Sensor inzwischen erfolgreich an die homematic angelernt, bin also fast am Ziel.
    (6 Feuchtigkeitssensoren und Temperatursensor)

    Ich erhalte korrekte Werte für Batteriespannung, Temperatur und von 4 Feuchtigkeitssensoren.
    Soweit so gut.
    Ein Sensor verursacht überhaupt keine Änderung. Stelle ich ihn ins Wasser, verändert sich keiner
    der analogen Werte #1-#6
    Ein anderer Sensor beeinflusst die Werte von #1 UND #6 gleichzeitig, wenn ich ihn ins Wasser stelle.

    Bevor ich jetzt als Arduino Neuling mühsam alles überprüfe – habt ihr einen Hinweis für mich,
    was dieses Phänomen am ehesten erzeugt ?
    – Sensorverkabelung
    – Falsche Lötstellen, Brücken oder kalte Lötstellen
    – Die nicht installierte „Register“ Bibliothek (siehe meine anderen Beiträge)

    Ich bin Euch für einen Hinweis dankbar, der würde mir viel Zeit sparen
    Grüße
    Heiko

    Antworten
  6. Avatar
    Heiko sagte:

    Hallo !
    Ich bin endlich dazu gekommen, den Sensor mal fertigzubauen.
    Jetzt hänge ich als absoluter Arduino-Neuling schon an einer ganz simplen Stelle:

    Oben im Text steht, man muss neben der AkSIn noch drei Bibliotheken nachladen.
    Ich finde die „EnableInterrupt“ in der Bibliiothekverwaltung, die „Low-Power“ über den
    Link auf GitHub, aber ich hab keinen blassen Schimmer, wo ich die „Register“ Library
    finde. Suche ich danach auf Github, werde ich erschlagen mit Fundstellen :-)
    Welches ist die korrekte Bib ?
    Danke für einen Hinweis
    Grüße
    Heiko

    Antworten
    • Avatar
      Heiko sagte:

      Da bin ich erstmal selbst weitergekommen.
      Habe mich einfach nicht um diese Library gekümmert. Beim Versuch zu kompilieren erhielt ich die
      Fehlermeldung, dass onewire.h nicht existent sei.
      Habe daher die onewire Bibliothek installiert und damit läuft es jetzt erstmal.
      (Hoffe ich korrekt).
      Ich kann im Monitor erstmal plausible Werte sehen.

      Anlernen etc kann ich erst in den nächsten Tagen ausprobieren, vermutlich hört ihr dann von mir mit weiteren Fragen ….. :-)
      Danke im Voraus
      Grüße
      Heiko

      Antworten
  7. Avatar
    Hendrik sagte:

    Hallo,

    ich habe den Bausatz nach der Anleitung zusammen gebaut und stehe vor einem Rätsel:
    Der Akku ist voll geladen, aber es passiert nichts außer wildes blinken der „kleinen“ LED am Arduino.
    Wenn ich den Akku jetzt direkt an den Arduino anschließe dann werden sofort Werte zur CCU übertragen, jedoch nur für Sensoren, wo kein Sensor angeschlossen ist….
    Nehme ich jetzt den FTDI Adapter mit 3,3V so passiert das gleiche wie zuvor.
    Stelle ich jetzt den FTDI Adapter auf 5V dann sofort alle Werte übermittelt.
    Schließe ich jetzt eine 5V Quelle an den Solaranschluß an, dann passiert mal wieder gar nichts.

    Hat jemand eine Idee wo hier der Fehler liegen könnte?

    Danke
    Hendrik

    Antworten
  8. Avatar
    Thomas sagte:

    Hallo,
    ich habe nun auch den Bausatz zusammengebaut.
    Ich habe mich an die Aneitung gehalten die auch super ist.
    Ich kann alle Werte im Arduino sehen wenn ich mit seriellen Monitor reinschaue.
    Es klemmt jetzt an dem Anlernen an der Homematic.
    Ich habe die Zusatzsoftware 2.6 auf der ccu2 installiert und wollte dann über „Gerät anlernen“ die Sensoren anlernen.
    Wenn ich den Knopf auf dem Bausatz drücke, blinkt auch die rote LED auch für ca. 20s.
    Und das war es auch schon. Es ist nichts passiert und kein Sensor ist angelernt.
    Ich habe auch nochmal die ganz Platine nach Ffehlern meinerseits abgesucht.
    Da scheint aber alles ok zu sein.
    Ich habe auch den Arduino Sketch abgeändert und die letzten beiden Kanäle/Sensoren weggelassen. (Wie in den Kommentaren erklärt)
    Aber damit hatte ich auch kein Erfolg.
    Danach wollte ich mir den originalen Sketch von Jerome downloaden um ihn zu vergleichen aber diesen gibt es leider nicht mehr für die Verison 2.6.

    Ich bin jetzt etwas Ratlos und hoffe ihr könnte mir weiterhelfen.

    Vielen Dank im Voraus
    Gruß

    Antworten
  9. Avatar
    Sascha sagte:

    Hallo,

    habe am Wochenende den Sensor zusammen gebaut und habe gerade hier gesehen, als ich auf der suche nach eine Fehlauslösung war, das es den Sensor auch mit Temperatur gibt. Habe mir mal das Skatch dazu angesehen und mich daran versucht, das hochzuladen. Leider hat das Skatch Probleme.

    Kann mir jemand das Skatch richtig schreiben oder geben. bin leider auch ein blutiger Anfänger was Arduino betrift.

    Ich danke schon mal im voraus.

    Antworten
  10. Avatar
    Czerny sagte:

    Hallo,

    ich habe den Bausatz zusammengebaut und mehrmals überprüft, allerdings kann ich es nicht mit Solar & Lipo zum laufen bewegen.
    Nur mittels FTDI Adapter läuft der Arduino und ein anlernen war erfolgreich.

    Was könnte ich hier eventuell durchmessen ?
    Wäre über einpaar Hilfestellungen sehr dankbar.

    gruss
    Czerny

    Antworten
  11. Avatar
    Kramykram sagte:

    Hallo,
    habe mir die Bausätze DIY Feuchtigkeitsmessung und Ventilsteuerung bestellt. Vielen Dank für die Lieferung.
    Den Bausatz Feuchtigkeitsmessung konnte ich schon nachbauen und hat bis auf ein paar kleine selbstgemachte Problemchen sehr gut funktioniert. Danke auch für die gute Anleitung.
    In der CCU ist alles angelernt, und Werte werden gesendet, empfangen und in Homematic angezeigt.
    Für mich stellt sich noch folgendes Problem:
    Ich würde gern die Feuchtigkeitssensoren in ioBroker integrieren. Diese werden im Broker auch angezeigt, an Werten jedoch nur die hm-rpc.0.JPCAPM0000.2.OPERATING_VOLTAGE, nicht jedoch die Feuchtigkeitswerte (beide Addons von JP altes und neues). Ansonsten funktioniert der hm-rpc-Adapter ohne Probleme. Was kann ich tun, um neben der Spannung ebenfalls die Feuchtigkeitswerte im ioBroker angezeigt zu bekommen?

    für Lösungsvorschläge im Voraus dankend mfG

    Antworten
    • Avatar
      Michael sagte:

      Moin,

      die HUMIDITY steht leider nicht in den Metadaten vom Sensor, daher musst du in den Kanälen 2-8 die Objekte „HUMIDITY“ hinzufügen.

      VG

      Antworten
  12. Avatar
    Manfred Schüssler sagte:

    Hallo Sebastian,
    ich habe vor kurzem den Bausatz DIY Feuchtigkeitssensor bekommen und zusammengebaut.
    Da der Link „https://github.com/jp112sdl/HB-UNI-SEN-CAP-MOIST-T/blob/master/HB-UNI-SEN-CAP-MOIST-T.ino“ in der Datei „Link zum Sketch von Jerome.txt“ nicht mehr funktioniert, habe ich von Jerome die aktuellste Version vom 04.05.2019 genommen und auch die aktuelle Version des HM Addons (2.21). Ich habe auf Basis von „Code-technikkram-moisture.txt“ das Sketch von Jerome angepasst.
    Wenn ich die Sensoren an A6 und A7 definiere, kann ich das Gerät nicht an die HM anlernen, da die LED nicht blinkt. Definiere ich nur 5 Sensoren, dann funktioniert das Anlernen.
    Meine Anpassungen sind :
    #define BATT_EN_PIN 6
    #define BATT_SENS_PIN 17 // A3
    const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 21}; //AOut Pins der Sensoren (hier A0, A1, A2, A4, A5, A6 und A7)
    const uint8_t SENSOR_EN_PINS[] {5, 5, 5, 5, 7, 7, 7};

    Wenn ich es so definiere :
    const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19}; //AOut Pins der Sensoren (hier A0, A1, A2, A4, A5, A6 und A7)
    const uint8_t SENSOR_EN_PINS[] {5, 5, 5, 5, 7};
    dann geht das Gerät.

    Ich vermute es ist da irgendwas mit Definition von A6 und A7 falsch. Hast Du hier eine Idee ?
    Danke für eine Info.
    Gruß Manfred

    P.S.: Deine Seite technikkram.net ist sehr informativ und hilfreich, Danke dafür.

    Antworten
    • Avatar
      Christian sagte:

      Bei mir läuft es so:
      const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 21};
      const uint8_t SENSOR_EN_PINS[] {5, 5, 5, 5, 7 , 7, 7};
      anders habe ich:
      #define BATT_SENS_PIN A3 // A0
      Vielleicht liegt da das Problem

      Antworten
      • Avatar
        Manfred Schüssler sagte:

        Hallo Christian,

        #define BATT_SENS_PIN A3 // A0 hat nichts gebracht.
        Hast Du auch das aktuellste Projekt ?
        2019-05-04 stan23 Creative Commons – http://creativecommons.org/licenses/by-nc-sa/3.0/de/

        Mit oder ohne T-Messung ?
        Ich habe das so :
        #define NO_DS18B20 //use model without temperature sensor

        Wenn ich statt
        const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 21};

        const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 20};
        nehme, dann bekomme ich 7 Sensoren in der HM aber Sensor 6 wird 2 mal eingelesen.

        Noch eine Idee ?

        Antworten
        • Avatar
          Christian sagte:

          Mein kompletter Code sieht so aus (JP HB Devices V.2.11) :

          //- ———————————————————————————————————————–
          // AskSin++
          // 2016-10-31 papa Creative Commons – http://creativecommons.org/licenses/by-nc-sa/3.0/de/
          // 2019-05-03 jp112sdl Creative Commons – http://creativecommons.org/licenses/by-nc-sa/3.0/de/
          // 2019-05-04 stan23 Creative Commons – http://creativecommons.org/licenses/by-nc-sa/3.0/de/
          //- ———————————————————————————————————————–

          //Sensor:
          //https://www.dfrobot.com/wiki/index.php/Capacitive_Soil_Moisture_Sensor_SKU:SEN0193

          // define this to read the device id, serial and device type from bootloader section
          // #define USE_OTA_BOOTLOADER

          #define NO_DS18B20 //use model without temperature sensor

          #define EI_NOTEXTERNAL
          #include
          #define SENSOR_ONLY

          // Arduino Pro mini 8 Mhz
          // Arduino pin for the config button
          #define CONFIG_BUTTON_PIN 8
          #define LED_PIN 4
          #define BATT_EN_PIN 6
          #define BATT_SENS_PIN A3 // A0

          #define CC1101_GDO0_PIN 2
          #define CC1101_CS_PIN 10
          #define CC1101_MOSI_PIN 11
          #define CC1101_MISO_PIN 12
          #define CC1101_SCK_PIN 13
          const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 21}; //AOut Pins der Sensoren (hier A1, A2 und A3)
          //bei Verwendung von > 3 Sensoren sollten die Vcc der Sensoren auf 2 Enable Pins verteilt werden (max. Last pro AVR-Pin beachten!)
          const uint8_t SENSOR_EN_PINS[] {5, 5, 5, 5, 7 , 7, 7};

          // #define DS18B20_PIN 3

          #define DEVICE_CHANNEL_COUNT sizeof(SENSOR_PINS)
          #include
          #include

          #include
          #include

          #ifndef NO_DS18B20
          #include
          #include
          OneWire oneWire(DS18B20_PIN);
          #endif

          // number of available peers per channel
          #define PEERS_PER_CHANNEL 4

          // all library classes are placed in the namespace ‚as‘
          using namespace as;

          //Korrekturfaktor der Clock-Ungenauigkeit, wenn keine RTC verwendet wird
          #define SYSCLOCK_FACTOR 0.88

          #ifdef NO_DS18B20
          #define DEVICE_MODEL 0x11
          #else
          #define DEVICE_MODEL 0x12
          #endif

          // define all device properties
          const struct DeviceInfo PROGMEM devinfo = {
          {0xF3, DEVICE_MODEL, 0x00}, // Device ID
          „JPCAPM0000“, // Device Serial
          {0xF3, DEVICE_MODEL}, // Device Model
          0x10, // Firmware Version
          as::DeviceType::THSensor, // Device Type
          {0x01, 0x01} // Info Bytes
          };

          /**
          Configure the used hardware
          */
          typedef AvrSPI SPIType;
          typedef Radio RadioType;
          typedef StatusLed LedType;
          typedef AskSin<LedType, BatterySensorUni, RadioType> BaseHal;
          class Hal : public BaseHal {
          public:
          void init (const HMID& id) {
          BaseHal::init(id);
          battery.init(seconds2ticks(60UL * 60) * SYSCLOCK_FACTOR, sysclock); //battery measure once an hour
          battery.low(22);
          battery.critical(19);
          }

          bool runready () {
          return sysclock.runready() || BaseHal::runready();
          }
          } hal;

          DEFREGISTER(UReg0, MASTERID_REGS, DREG_LOWBATLIMIT, 0x21, 0x22)
          class UList0 : public RegList0 {
          public:
          UList0 (uint16_t addr) : RegList0(addr) {}

          bool Sendeintervall (uint16_t value) const {
          return this->writeRegister(0x21, (value >> 8) & 0xff) && this->writeRegister(0x22, value & 0xff);
          }
          uint16_t Sendeintervall () const {
          return (this->readRegister(0x21, 0) <readRegister(0x22, 0);
          }

          void defaults () {
          clear();
          lowBatLimit(22);
          Sendeintervall(30);
          }
          };

          DEFREGISTER(UReg1, 0x01, 0x02, 0x03, 0x04, 0x23, 0x24, 0x25, 0x26)
          class UList1 : public RegList1 {
          public:
          UList1 (uint16_t addr) : RegList1(addr) {}
          bool HIGHValue (uint16_t value) const {
          return this->writeRegister(0x23, (value >> 8) & 0xff) && this->writeRegister(0x24, value & 0xff);
          }
          uint16_t HIGHValue () const {
          return (this->readRegister(0x23, 0) <readRegister(0x24, 0);
          }

          bool LOWValue (uint16_t value) const {
          return this->writeRegister(0x25, (value >> 8) & 0xff) && this->writeRegister(0x26, value & 0xff);
          }
          uint16_t LOWValue () const {
          return (this->readRegister(0x25, 0) <readRegister(0x26, 0);
          }

          #ifndef NO_DS18B20
          bool Offset (int32_t value) const {
          return
          this->writeRegister(0x01, (value >> 24) & 0xff) &&
          this->writeRegister(0x02, (value >> 16) & 0xff) &&
          this->writeRegister(0x03, (value >> 8) & 0xff) &&
          this->writeRegister(0x04, (value) & 0xff)
          ;
          }

          int32_t Offset () const {
          return
          ((int32_t)(this->readRegister(0x01, 0)) <readRegister(0x02, 0)) <readRegister(0x03, 0)) <readRegister(0x04, 0)) )
          ;
          }
          #endif

          void defaults () {
          clear();
          HIGHValue(830);
          LOWValue(420);
          #ifndef NO_DS18B20
          Offset(0);
          #endif
          }
          };

          class WeatherEventMsg : public Message {
          public:
          void init(uint8_t msgcnt, uint8_t *h, bool batlow, uint8_t volt, __attribute__ ((unused)) int16_t temperature, __attribute__ ((unused)) int8_t offset) {

          #ifndef NO_DS18B20
          int16_t t = temperature + offset;
          DPRINT(F(„+Temp C : „)); DDECLN(t);
          #endif
          DPRINT(F(„+Battery V : „)); DDECLN(volt);
          #ifdef NO_DS18B20
          #define PAYLOAD_OFFSET 0
          #else
          #define PAYLOAD_OFFSET 2
          #endif

          Message::init(0xc + PAYLOAD_OFFSET + (DEVICE_CHANNEL_COUNT * 2), msgcnt, 0x53, (msgcnt % 20 == 1) ? (BIDI | WKMEUP) : BCAST, batlow ? 0x80 : 0x00, 0x41);

          #ifndef NO_DS18B20
          pload[0] = (t >> 8) & 0xff;
          pload[1] = (t) & 0xff;
          #endif

          pload[PAYLOAD_OFFSET] = (volt) & 0xff;
          for (uint8_t s = 0; s < DEVICE_CHANNEL_COUNT; s++) {
          DPRINT(F("+Humidity (#")); DDEC(s + 1); DPRINT(F(") %: ")); DDECLN(h[s]);
          pload[1+PAYLOAD_OFFSET+(s * 2)] = 0x42 + s;
          pload[2+PAYLOAD_OFFSET+(s * 2)] = h[s] & 0xff;
          }
          }
          void init(uint8_t msgcnt, uint8_t *h, bool batlow, uint8_t volt) {
          init(msgcnt, h, batlow, volt, 0, 0);
          }
          };

          class WeatherChannel : public Channel {
          public:
          WeatherChannel () : Channel() {}
          virtual ~WeatherChannel () {}

          void configChanged() {
          DPRINT(F(„Config changed List1 (CH „));DDEC(number());DPRINTLN(F(„)“));
          #ifndef NO_DS18B20
          if (number() == 1) { DPRINT(F(„*Offset : „)); DDECLN(this->getList1().Offset()); }
          #endif
          if (number() > 1) { DPRINT(F(„*HIGHValue : „)); DDECLN(this->getList1().HIGHValue()); }
          if (number() > 1) { DPRINT(F(„*LOWValue : „)); DDECLN(this->getList1().LOWValue()); }
          }

          uint8_t status () const {
          return 0;
          }

          uint8_t flags () const {
          return 0;
          }
          };

          class UType : public MultiChannelDevice {
          public:
          #ifndef NO_DS18B20
          Ds18b20 sensor[1];
          #endif
          class SensorArray : public Alarm {
          UType& dev;

          public:
          uint8_t humidity[DEVICE_CHANNEL_COUNT];
          uint8_t sensorcount;
          SensorArray (UType& d) : Alarm(0), dev(d), sensorcount(0) {}

          void measure() {
          //enable all moisture sensors
          for (uint8_t s = 0; s < sizeof(SENSOR_EN_PINS); s++) {
          digitalWrite(SENSOR_EN_PINS[s], HIGH);
          _delay_ms(5);
          }

          //wait a moment to settle
          _delay_ms(500);
          //now measure all sensors
          for (uint8_t s = 0; s < DEVICE_CHANNEL_COUNT; s++) {
          uint16_t sens_val = 0;

          //measure 8 times and calculate average
          for (uint8_t i = 0; i upper_limit) {
          humidity[s] = 0;
          DPRINTLN(F(“ higher than limit!“));
          }
          else if (sens_val < lower_limit) {
          humidity[s] = 100;
          DPRINTLN(F(" lower than limit!"));
          }
          else {
          uint16_t range = upper_limit – lower_limit;
          uint16_t base = sens_val – lower_limit;
          uint8_t pct_inv = (base * 100) / range;
          humidity[s] = 100 – pct_inv;
          DPRINTLN("");
          }

          //humidity[s] = random(0,100);

          }
          //disable all moisture sensors
          for (uint8_t s = 0; s < sizeof(SENSOR_EN_PINS); s++)
          digitalWrite(SENSOR_EN_PINS[s], LOW);

          #ifndef NO_DS18B20
          Ds18b20::measure(dev.sensor, 1);
          #endif
          }

          virtual void trigger (__attribute__ ((unused)) AlarmClock& clock) {
          measure();
          tick = delay();
          WeatherEventMsg& msg = (WeatherEventMsg&)dev.message();
          #ifndef NO_DS18B20
          msg.init(dev.nextcount(), humidity, dev.battery().low(), dev.battery().current(), dev.sensor[0].temperature(), dev.channel(1).getList1().Offset());
          #else
          msg.init(dev.nextcount(), humidity, dev.battery().low(), dev.battery().current());
          #endif
          dev.send(msg, dev.getMasterID());
          sysclock.add(*this);
          }

          uint32_t delay () {
          //Sendeintervall festlegen
          uint16_t _txDelay = max(dev.getList0().Sendeintervall(), 1);
          return seconds2ticks(_txDelay * 60 * SYSCLOCK_FACTOR);
          }

          } sensarray;

          typedef MultiChannelDevice TSDevice;
          UType(const DeviceInfo& info, uint16_t addr) : TSDevice(info, addr), sensarray(*this) {}
          virtual ~UType () {}

          void init (Hal& hal) {
          TSDevice::init(hal);
          for (uint8_t s = 0; s < DEVICE_CHANNEL_COUNT; s++)
          pinMode(SENSOR_PINS[ s ], INPUT);

          for (uint8_t s = 0; s 0) ? F(„OK“):F(„ERROR“));
          #endif
          sensarray.set(seconds2ticks(5));
          sysclock.add(sensarray);
          }

          virtual void configChanged () {
          TSDevice::configChanged();
          DPRINT(F(„*LOW BAT Limit: „));
          DDECLN(this->getList0().lowBatLimit());
          this->battery().low(this->getList0().lowBatLimit());
          DPRINT(F(„*Sendeintervall: „)); DDECLN(this->getList0().Sendeintervall());

          }
          };

          UType sdev(devinfo, 0x20);
          ConfigButton cfgBtn(sdev);

          void setup () {
          DINIT(57600, ASKSIN_PLUS_PLUS_IDENTIFIER);
          sdev.init(hal);
          DDEVINFO(sdev);
          buttonISR(cfgBtn, CONFIG_BUTTON_PIN);
          sdev.initDone();
          }

          void loop() {
          bool worked = hal.runready();
          bool poll = sdev.pollRadio();

          if ( worked == false && poll == false ) {
          if ( hal.battery.critical() ) {
          DPRINT(F(„Battery critical! „));DDECLN(hal.battery.current());
          Serial.flush();
          hal.activity.sleepForever(hal);
          }
          hal.activity.savePower<Sleep>(hal);
          }
          }

          Antworten
          • Avatar
            Manfred Schüssler sagte:

            Hallo Christian,

            danke für die Info. Allerdings scheint es ein paar Probleme beim „Einkopieren“ gegeben zu haben. Es gibt z.B. einige Zeilen, wo nur #include steht, das passt ja nicht und gibt eine Fehlermeldung.
            Beispiel :
            #define DEVICE_CHANNEL_COUNT sizeof(SENSOR_PINS)
            #include
            #include

            #include
            #include

            #ifndef NO_DS18B20
            #include
            #include
            OneWire oneWire(DS18B20_PIN);
            #endif

            Zudem ergibt ein Vergleich doch einige Unterschiede.
            Kannst Du mir Deine *.INO Datei zumailen ?, oder ich schick Dir einen DropBox Link, wo Du die Datei hochladen kannst.
            Danke für Deine Unterstützung.
            Gruß Manfred

          • Avatar
            Christian sagte:

            Hallo Manfred,
            das kann ich gerne machen. Nur wie komme ich an die Daten?
            Gruß
            Christian

          • Avatar
            Manfred Schüssler sagte:

            Hallo Christian,
            vielen Dank für Deine Dateien. Ich habe den DropBox Link jetzt wieder gelöscht.

            Ich habe Deine „Bodenfeuchtigkeit_ohne_DS18B20.ino“ sowie die mitgelieferten Libraries verwendet. Leider habe ich hier das gleiche Problem wie zuvor.

            Ich teste die richtige Funktion indem ich den Taster drücke und schaue, ob die LED blinkt. Wenn die Funktion nicht richtig ist, dann blinkt die LED nicht -> kein Anlernen möglich.

            Wenn ich den letzten Eingang als 21 definiere funktioniert es nicht. Definiere ich den letzten Eingang, wie den vorletzten Eingang, als 20, dann geht die Funktion.

            Es ist dabei egal, ob ich meine Libraries verwende, die aktueller sind, oder Deine. Ebenso, ob ich meine INO oder Deine INO nehme.

            Damit kann ich aktuell halt nur 6 Feuchtesensoren verwenden. Aber ich kann damit leben. Ich habe 2 Bausätze bestellt und probiere das dann mit dem 2. Gerät noch einmal. Vielleicht liegt das Problem nicht an der SW.

            Wie gesagt, noch einmal vielen Dank für Deine Unterstützung. Vielleicht finde ich das Problem irgendwann.

            Gruß Manfred

          • Avatar
            Alex sagte:

            Hallo Manfred,

            hast du es mittlerweile geschafft alle 7 Sensoren ans laufen zu bekommen?

            Ich nutze aktuell noch die ursprügliche Variante die hier auf der Website beschrieben wurde, zwangsläufig mit der Addon Version 2.6 von Jerome.

            Ich hatte gehofft, dass der Artikel mal überarbeitet wird, um auch dauerhaft die aktuellste Version (momentan 2.22) nutzen zu können. Leider sperrt man sich mit der alten 2.6er Version für alle anderen Projekte aus, die eine neuere Version benötigen.

            Daher würde ich es auch gerne in kauf nehmen nur 6 von den 7 Sensoren nutzen zu können.

            Vielleicht kannst du mir deine/eure .ino ebenfalls zuschicken.

            Vielen Dank schon mal im Voraus

            Gruß Alex

        • Avatar
          Kramykram sagte:

          Danke,
          hatte das gleiche Problem mit dem Anlernen in der CCU, mit der Änderung „const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 20};“ hat es dann funktioniert, da ich grundsätzlich max. 6 Sensoren benötige, ist es für mich ein akzeptabler Workaround.

          Grüße und nochmals danke

          Antworten
          • Avatar
            Alex sagte:

            Angelernt bekomme ich den Sensor auch mit
            const uint8_t SENSOR_PINS[] {14, 15, 16, 18, 19, 20, 21}

            Aber weder mit der 20 noch mit der 21 am Ende, werden keine Sensordaten übermittelt.
            Bei mir stehen in der CCU überall 0 % und unter „Letzte Änderung“ kein Zeitstempel.

          • Avatar
            Alex sagte:

            So, habs jetzt auch hinbekommen. Wichtig ist auch dass man die 6 Einträgt bei:
            #define BATT_EN_PIN 6

            Vielleicht bekommt das jemand mit dem 7. Sensor noch hin. Ansonsten sind die 6 funktionierenden für mich auch in Ordnung.

  13. Avatar
    Mathias sagte:

    ich habe mir auch gerade alles zusammen bestellt, außer der Platine.
    die kommt dann dran, wenn ich alles habe.
    Hänge gerade auch an der AskSin++ Wetterstation fest.
    danach will ich noch einen Dual-Extruder an meinem 3D-Drucker anbringen.
    Ich will wir sowieso Gehäuse dafür ausdrucken, also 21 Stück an der Zahl.
    Hier ist die Vorlage: https://www.thingiverse.com/thing:3633804

    Ein kleiner Tip meinerseits, die Brenner kenne ich, taugen aber nichts.
    ich habe mir auch mal so einen kleinen Brenner zugelegt, um Creme Brulee zu machen. das Teil verschenkt und einen richtigen mit den 300g-Gas-Cartridges gekauft. Das Teil ist bombig.
    Gruß,
    Mathias

    Antworten
  14. Avatar
    Andreas sagte:

    Hi,
    Ich habe ein Problem mit dem Bausatz.
    Meine Einstellungen.
    Wake on Radio : OFF
    Sende intervall 60 Minuten.
    LED ausgelötet.

    Ich lade den Akku voll auf
    Nach ca 3-4 Tagen ist Akku leer. Es gibt war wenig Sonne im Moment, aber das sollte nicht so sein.
    Wo kann ich nach dem Problem suchen,

    Andreas

    Antworten
  15. Avatar
    Stefan sagte:

    Hallo Sebastian

    Ich würde gerne den Bodenfeuchte und Temperatur SMT50 (http://www.truebner.de/smt50) der Firma Truebner verwenden. Dieser Sensor liefert sowohl für die Feuchtigkeit als auch die Temperatur ein Signal von 0 – 3V. Zudem benötigt er eine Stromversorgung von 3.3V – 30V.
    Was meinst Du, wäre eine entsprechende Anpassung einfach möglich?

    Gruss und besten Dank im Voraus
    Stefan

    Antworten
  16. Avatar
    Manfred sagte:

    Hallo zusammen,

    ich habe den Sketch genommen der unter „Sketch laden“ als Download (https://technikkram.net/2019/05/anleitung-diy-feuchtigkeitssensor-fuer-gartenbewaesserung-bausatz-homematic) angeboten wird. Kann es sein, das die Datei fehlerhaft ist?

    Wenn ich diesen Sketch auf den Arduino lade, wird alles soweit richtig erkannt, aber wenn die Sensoren im Wasser stehen, zeigt mir die Homematic an das die Luftfeuchte auf 1% gesunken ist. Nehme ich den Sensor wieder aus dem Wasser und mache in trocken, zeigt er mir wieder 28% an. Ist bei allen Sensoren so. Mal davon abgesehen, das der ein oder andere auf 0% oder auf 2% runter geht.

    Hat jemand einen funktionierenden Sketch?

    Grüße
    Manfred

    Antworten
  17. Avatar
    Andreas sagte:

    Ich würde mir gern die Schaltpläne und Layouts aus dem angeboten Download anschauen. Bitte um Tipps mit welchen Programmen die Dateien lesbar sind. Danke

    Antworten
  18. Avatar
    Manfred Glanemann sagte:

    Hallo,
    ich möchte diese Platine in eine kleine Unterverteilung einbauen. Somit benötige ich weder Solarzelle noch Laderegler usw..
    Kann ich die Schaltung ohne diese Dinge betreiben? Wenn ja wie?

    Grüße
    Manfred Glanemann

    Antworten
  19. Avatar
    Andreas^ sagte:

    Hi,

    Ich habe den Aufbau durch, bekomme den Sensor nicht angelernt.
    Das Freq. Sketch habe ich schon mehrfach laufen lassen und denn mit dem Sketch aus dem Zip getestet.

    Done: 0x2165BA – 0x21667A
    17:40:16.443 -> Calculated Freq: 0x21661A
    17:40:16.443 -> Store into config area: 661A

    17:54:36.438 -> Done: 0x21659A – 0x21668A
    17:54:36.438 -> Calculated Freq: 0x216612
    17:54:36.438 -> Store into config area: 6612

    -> Done: 0x2165BA – 0x21667A
    18:16:51.282 -> Calculated Freq: 0x21661A
    18:16:51.282 -> Store into config area: 661A

    Beim Anlernen beikomme ich

    18:35:41.162 -> AskSin++ V4.1.0 (Jul 17 2019 18:35:14)
    18:35:41.162 -> Address Space: 32 – 319
    18:35:41.162 -> CC init1
    18:35:41.162 -> CC Version: 14
    18:35:41.198 -> – ready
    18:35:41.442 -> iVcc: 3372
    18:35:41.442 -> eVcc: 3735
    18:35:41.442 -> Config Freq: 0x21661A

    ……

    8:36:57.154 -> debounce
    18:36:57.227 -> pressed
    18:36:57.368 -> released
    18:36:57.368 -> <- 1A 09 84 00 F31103 000000 11 F3 11 4A 50 43 41 50 4D 30 30 30 33 70 07 01 01

    und dann ein paar ignore

    Plugin 2.6 ist installiert.

    Ideen ?

    Danke

    Antworten
      • Avatar
        Andreas sagte:

        Klar hatte ich das gemacht.
        Das gepachte Skript von der Anleitung drauf.
        Anlernen geht nicht.
        Freq Test drauf. Über seriellen Monitor auf die Freq gewagte, dann das erste wieder drauf.
        Dann per seriellen Monitor kommen oben die Meldungen und anlernen geht nicht.
        Das ganz jetzt 4 mal.

        Die obern 3 Logs sein von 3 Versuchen, der letzte mit dem gepatched Sketch.

        Antworten
          • Avatar
            Andreas sagte:

            Denke schon. Kein Kurzschluss, Masse und Antenne kommen auf dem CC1101 an.
            Ohne Antenne, sagt er finde nichts.
            Zentrale ist ca 1m entfernt, von dem Platz konnte ich schon viele Module anlernen.
            Ist es tatsächlich so das man 2.6 er Add-on in der CCU braucht, wie in der Anleitung? Er bietet ein 2.9 Update an.
            Ich habe jetzt mal die Sensoren abgebaut um mit die Antenne anzusehen, anlernen sollte man doch auch ohne können oder ?

          • Avatar
            Andreas sagte:

            Danke, ich habe es gefunden. Pin2 des Sendemodul wars, messen mit Druck auf der spitzte wars ok. Nur ohne Druck war kein Kontakt.

  20. Avatar
    Uwe sagte:

    Hallo Sebastian,
    bei meinem Bausatz will partout der Anlernvorgang nicht beginnen. Script ist aufgespielt, Akku geladen, nach Arduino-Reset flackert die Sensor-LED etwas, bevor sie 6x blinkt. Dann tut sich nichts mehr, egal ob man kurz oder lang auf den Taster drückt. Alle Lötpunkte mehrfach auf Kontakt und Brücken geprüft, wie auch den Sitz der Bauteile. Was kann ich tun?

    Antworten
    • Avatar
      Gerd sagte:

      Egal welcher von beiden,
      einfach runterscrollen, dann kommt das Schutzmodul
      und die Beschaltung dazu.

      Ich frage mich nur, warum keinen LiPo Lader,
      da ist der Schutz drauf und einen – nach 5V Wandler dahinter.
      Das Ergebnis ist das Gleiche, nur billiger.

      Antworten
  21. Avatar
    Thomas Schüsselbauer sagte:

    Hallo,

    nachdem ich den Bausatz zusammengebaut hatte, konnte ich diesen nicht an meine Homematic anlernen.
    Ich habe alle Lötstellen kontrolliert und nach allen Kontrollen war klar, dass das Funkmodul das Problem darstellte. Das Auslösen des Moduls hätte sehr wahrscheinlich die Platine beschädigt.
    Nach einer Recherche im Internet bin ich auf einen Artikel gestoßen, dass es Funkmodule gibt, die auf der falschen Frequenz senden. Leider war in diesem Bausatz ein solches Modul.
    Auf der Technikkramseite findet sich ein toller Artikel, in den beschrieben wird, wie die Frequenz des Funkmoduls verstellt werden kann:
    https://technikkram.net/2019/05/asksinpp-diy-fehler-anlernen-nicht-moeglich-cc1101-frequenz-automatisch-anpassen
    Es hat funktioniert und das Gerät konnte an die Homematic angelernt werden.
    Ein Tip für alle Betroffenen ;-))

    Mit sonnigen Grüßen aus Regensburg

    Thomas

    Antworten
    • Avatar
      Gerd sagte:

      Eine mögliche Lösung!

      Besser und dauerhafter ist jedoch,
      wenn man löten kann, die beiden Kondensatoren am Quarz durch 12…13pF Kondensatoren Bauform 0402 zu ersetzen.

      Ich habe meine 10 CC1101 Module so gerettet

      Antworten
          • Avatar
            Manfred sagte:

            Also wenn der Quarz oben ist, sind es die beiden waagerechten, richtig? Rechts ca. auf 4 Uhr und links auf ca. 7 Uhr. Der in der Mitte hat damit nichts zu tun, oder?

          • Avatar
            Gerd sagte:

            Richtig, die 4 Uhr und 7 Uhr sind es.
            Was noch zu versuchen wäre, ich hatte leider alle Module schon „repariert“, die 2 Kondensatoren ablöten (Zinnbatzen drauf und los sind die), nichts einlöten und probieren ob es ohne geht.
            Ansonsten neue C’s rein.

  22. Avatar
    Frithof sagte:

    Hallo Habe den Sensor mit 7 Sensoren aufgebaut und würde ihn gerne in FHEM einbinden.
    Leider wird er dort nur als „unknown“ erkannt.
    Gibt es schon ein fertiges Perl script zum einbinden und wenn ja, wo kann ich es finden?

    Antworten
  23. Avatar
    Christian sagte:

    Bei mir reicht die Leistung, der mitgelieferten Solarzelle, in keinster Weise aus um den Akku aufzuladen. Ein voll geladener Akku ist nach 2-3 Tage, bei direkter Sonneneinstrahlung, leer. Die Zelle liefert maximal 70 mA Strom. Entweder ist meine Zelle defekt oder die Dimensionierung ist unzureichend. Derzeit verwende ich eine deutlich größere Zelle. Damit funktioniert es.

    Antworten
    • Sebastian
      Sebastian sagte:

      Hallo Christian, die Zelle ist so ausgelegt, dass diese ca. 3 Wochen die Platine ohne Sonne betreiben kann. Das habe ich zudem auch empirisch bestätigt. Hast du evtl. Eine Brücke oder ähnliches in deiner Schaltung ?

      Antworten
  24. Avatar
    Andreas sagte:

    Die in diesem Projekt (Anleitung DIY Feuchtigkeitssensor für Gartenbewässerung Bausatz Homematic ) verwendete Platine könnte doch ebenso als Mehrfachthermometer verwendet werden!? … mit entsprechenden Sketchen aus dem anderen Projekt … oder?

    Antworten
      • Avatar
        Andreas sagte:

        Danke Sebastian für die schnelle Reaktion. Ja, die andere Platine kenne ich. Mich begeistert die Passform in das witterungsgeschütze Gehäuse! Letztlich ist aber die Verschaltung von Arduino, Funkelement und Sensor äquivalent!? ByTheWay wo finde ich bitte die jeweiligen Schaltbilder. Ich hätte gern die Unterschiede verstanden. Danke

        Antworten
  25. Sebastian
    Sebastian sagte:

    ..wir arbeiten aktuell an einer kleinen Korrektur! Michael hat den Sensor bekommen und baut diesen gerade auf. Alles was ihm auffällt, wird er überarbeiten! Sorry dafür, gerade bei so komplexen Anleitungen schleichen sich leider Fehler ein.

    Antworten
  26. Avatar
    Christian sagte:

    Ich habe ein Problem nach dem Aufbau. Bin nach der Anleitung vorgegangen. Beim seriellen Monitor sieht alles gut aus (Alle Kanäle zeigen Werte an). Nach der Frequenzkorrektur des C1101 klappte auch das Anlernen an der ccu. Hier sind aber nun alle Werte 0 (Spannung und Kanalwerte). Ändern der Intervallzeit funktioniert. Von daher sehe ich kein Problem bei der Kommunikation. Warum bekomme ich keine Sensorwerte?

    Antworten
    • Avatar
      Christian sagte:

      Fehler gefunden. Beim JP-HB-Devices Addon Version 2.7 ist die Telegrammübertragung geändert worden. Dieses Sketch ist damit nicht mehr kompatibel. Lösung: entweder Sketch aktualisieren oder Version 2.6 benutzen.

      Antworten
      • Sebastian
        Sebastian sagte:

        Hallo,

        wir haben die Beshreibung bearbeitet, diese hier benötigt die Version 2.6 – wir erstellen gerade aber eine neue Anleitung, die dann auch die Version 2.7 unterstützt.

        Antworten
        • Avatar
          Alex sagte:

          Gibt es bereits eine aktualisierte Version des Sketch passend zur Addon Version 2.7? Oder kann mir jemand sagen wie ich in Debmatic explizit das „jp-hb-devices“ Addon 2.6 installieren kann?

          Antworten
        • Avatar
          Thorsten sagte:

          Ich möchte mich an die Frage von Alex anschließen. Ist da immer noch jp-hb-devices 2.6 notwendig? Inzwischen gibt es ja version 2.25!

          Antworten
          • Sebastian
            Sebastian sagte:

            ..in der neuen Version ist einiges angepasst worden, schau am besten mal in Changelog um zu sehen was dort verändert worden ist. Evtl. muss dann das Sketch angepasst werden, welches aus dem Arduino läuft.

    • Sebastian
      Sebastian sagte:

      oje… das würde ich nicht machen. Wer garantiert Dir denn, dass der Sensor in 5 oder 10 Jahren noch funktioniert. Außerdem wird die Leitung auch nicht betonfest sein…

      Antworten

Hinterlasse ein Kommentar

An der Diskussion beteiligen?
Hinterlasse uns deinen Kommentar!

Schreibe einen Kommentar zu Czerny Antworten abbrechen

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