Kapazitiven Erdfeuchtigkeitssensor „Giess-o-Mat“ am Raspberry Pi auslesen
Im Bereich der Raspberry Pi Bodenfeuchtigkeitsmessung gibt es resistive und kapazitive Sensoren, welche jeweils Vor- und Nachteile haben. Der neuartige Raspberry Pi Giessomat / „Giess-o-Mat“ Sensor bietet eine dauerhaft präzise kapazitive Messung, was u.a. in unserem Raspberry Pi Gewächshaus sehr interessant sein kann.
In diesem Tutorial geht es um den Aufbau des Raspberry Pi Giessomat sowie dem Auslesen der Frequenz, mit Hilfe derer die relative Erdfeuchte errechnet werden kann.
Da ich nun von mehreren Usern gebeten wurde und es zu dem Thema (im Hinblick auf den Raspberry Pi) nicht viel Stoff gibt, hoffe ich, dass dieses Tutorial die Benutzung etwas vereinfacht.
Zubehör
Dazu habe ich folgendes Zubehör bzw. Bauteile genommen:
- Raspberry Pi 3
- kapazitiver Giess-o-Mat Feuchtigkeitssensor (Alternative)
- optional: Frequenzteiler
- alternativ: vielfaches vom 100kΩ Widerstand
- Jumper Kabel
- Lötkolben + Lötzinn
Ich empfehle gleich die beschichtete Version der Platine zu nehmen, da diese ansonsten in jedem Fall aufwändig per Hand versiegelt werden muss. Die mitgelieferten Bauteile der Platine/Sensor (weiter unten gelistet) sind im SMD Format und daher nicht unbedingt für Löt-Anfänger geeignet. Mit ein wenig Geschick sollte die Größe aber kein Problem darstellen.
Der Frequenzteiler kann auch durch einen Widerstand ersetzt werden. Dabei wird der 100kΩ Widerstand an Position R3 (siehe weiter unten) um einen größeren getauscht: Soll die Frequenz halbiert werden, so wird ein doppelt so großer Widerstand genommen, usw. Dabei ist es natürlich möglich mehrere Widerstände zu kombinieren.
Vorteile gegenüber resisitiven Feuchtigkeitssensoren
Resisitive Erdfeuchtigkeitssensoren sind oft nicht von Dauer.
In einem vorherigen Tutorial haben wir die sehr günstigen Bodenfeuchtigkeitssensoren am Raspberry Pi angeschlossen und ausgelesen. Diese Bauart hat allerdings ein Problem, welches im Laufe der Zeit auftritt: Korrosion. Nach längerer Benutzung bei gleicher Polung zersetzen sich oftmals die Sensoren teilweise. Dies ist weder für das Messverhalten noch für die Bodenwerte gut.
Diese Gefahr besteht bei kapazitiven Sensoren hingegen nicht. Dabei wird allerdings kein analoges Signal ausgegeben, welches mit einem MCP3008 ADC ausgelesen werden kann, sondern eine Frequenz, die unterschiedlich hoch ausfällt – je nach Feuchtigkeit der Erde (je nasser, umso niedriger).
Die ausgegebene Frequenz (bis 450kHz) ist zu viel für den Raspberry Pi, weshalb wir entweder einen Frequenzteiler nehmen, der diese eben um einen gewissen Dividenden teilt, oder einfach einen größeren Widerstand. Der Nachteil eines Frequenzteiler ist der Preis, da ein einfacher Widerstand quasi nichts kostet.
Zusammenbau des Raspberry Pi Giessomat
Der Giess-o-Mat kommt gewöhnlicherweise nicht zusammengebaut, weshalb die einzelnen SMD Bausteine erst noch auf die Platine gelötet werden müssen. Da diese sehr klein sind, hilft ein Blick auf derern Beschriftung. Außerdem habe ich versucht jeden Schritt mit Bildern zu dokumentieren, damit nichts schief geht.
Folgender Hilfszettel findet sich in der Tüte der Bauteile:
| Bezeichnung | Typ | Aufschrift | Funktion |
|---|---|---|---|
| T1 | BC847B | 1Ft od. 1FW | Transistor |
| C1 | 10μF 10V | Kondensator | |
| IC1 | 74HC14D | HC14 | IC |
| D1 | BZX84B5V6 | T12 oder Z3 | Zehnerdiode 5v6 |
| R1 | 1k | 102 od. 1001 | Widerstand 1k |
| R2 | 100R | 101 od. 1000 | Widerstand 100R |
| R3 | 100k | 104 od. 1003 | Widerstand 100k |
Beginnen wir mit dem IC. Dabei ist es wichtig, dass die Seite mit der Markierung „nach oben“ zeigt, wo auf dem PCB die kleine runde Einkerbung zu sehen ist.
Der Kondensator (C1) hat keine Aufschrift und es spielt keine Rolle, welche Seite wo verlötet wird:
Bei den Widerständen (R1, R2, R3) musst du vorsichtig sein, da die SMD Beschriftung nicht der eigentlichen Größe entspricht. Auf dieser Seite kannst du einfach den abgebildeten Wert des SMD Widerstands eingeben und dir die echte Größe berechnen lassen.
Falls du keinen Frequenzteiler hast, kannst du (wie oben beschrieben) auch einfach einen größeren Widerstand anstelle von R3 nutzen.
Anschließend fehlen nur noch Transistor (T1) und Zehnerdiode (D1), welche die gleiche Form haben. Hier hilft wieder die Beschriftung von oben:
Zusammenbau Frequenzteiler (optional)
Auf die gleiche Weise wie den Giessomat bauen wir auch den Frequenzteiler zusammen, sofern wir einen besitzen.
Zunächst die Tabelle:
| Bezeichnung | Typ | Aufschrift | Funktion |
|---|---|---|---|
| T1 | BC847B | 1Ft, 1F-, 1FW | Transistor |
| C1 | 10μF 10V | Kondensator | |
| IC1 | 74HC4040 | HC4040 | IC |
| D1 | BAS40 | 43t, 43-, 43p, 43W | Schottky Diode |
| R1, R2 | 2k2 | 222, 2201 | Widerstand 2k2 |
Auch hier beginnen wir mit dem IC, dem Kondensator sowie den Widerständen. Die Größe von R1 und R2 ist identisch.
Fehlen noch Transistor (T1) und die Diode (D1). Achte dabei wieder auf die Beschriftung, da die Bauform identisch ist:
Zu guter letzt werden die beiden Kontakte von „:16“ zusammengelötet, wodurch eine 16-fach geringere Frequenz ankommt.
Außerdem habe ich die beiden Platinen noch miteinander verlötet und an den Frequenzteiler ein paar Kontakte für die Jumper Kabel angelötet.
Skript zum Auslesen der Frequenz
Schließe zunächst V+ and 3.3V vom Raspberry Pi an, GND an GND und OUT z.B. an GPIO21.
Zum Auslesen der Frequenz am Raspberry Pi eignet sich die PiGPIO Bibliothek, welche Bibliotheken für C(++), Python, etc. mitbringt. Auf gewöhnlichen Raspbian Versionen (nicht Lite) ist es bereits vorinstalliert, ansonsten können wir es hiermit nachinstallieren:
sudo apt-get update sudo apt-get install pigpio python-pigpio python3-pigpio
Anschließend erstellen wir eine neue C-Datei, welche zum Auslesen der Frequenz da ist:
sudo nano freq_count_1.c
Diese Datei bekommt folgenden Inhalt (Beispiel von hier). Mit STRG+O speichern und STRG+X zum Terminal zurückkehren.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 |
#include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <unistd.h> #include <pigpio.h> /* 2014-08-20 gcc -o freq_count_1 freq_count_1.c -lpigpio -lpthread $ sudo ./freq_count_1 4 7 8 This program uses the gpioSetAlertFunc function to request a callback (the same one) for each gpio to be monitored. EXAMPLES Monitor gpio 4 (default settings) sudo ./freq_count_1 4 Monitor gpios 4 and 8 (default settings) sudo ./freq_count_1 4 8 Monitor gpios 4 and 8, sample rate 2 microseconds sudo ./freq_count_1 4 8 -s2 Monitor gpios 7 and 8, sample rate 4 microseconds, report every second sudo ./freq_count_1 7 8 -s4 -r10 Monitor gpios 4,7, 8, 9, 10, 23 24, report five times a second sudo ./freq_count_1 4 7 8 9 10 23 24 -r2 Monitor gpios 4, 7, 8, and 9, report once a second, sample rate 1us, generate 2us edges (4us square wave, 250000 highs per second). sudo ./freq_count_1 4 7 8 9 -r 10 -s 1 -p 2 */ #define MAX_GPIOS 32 #define OPT_P_MIN 1 #define OPT_P_MAX 1000 #define OPT_P_DEF 20 #define OPT_R_MIN 1 #define OPT_R_MAX 10 #define OPT_R_DEF 5 #define OPT_S_MIN 1 #define OPT_S_MAX 10 #define OPT_S_DEF 5 static volatile int g_pulse_count[MAX_GPIOS]; static volatile int g_reset_counts; static uint32_t g_mask; static int g_num_gpios; static int g_gpio[MAX_GPIOS]; static int g_opt_p = OPT_P_DEF; static int g_opt_r = OPT_R_DEF; static int g_opt_s = OPT_S_DEF; static int g_opt_t = 0; void usage() { fprintf (stderr, "\n" \ "Usage: sudo ./freq_count_1 gpio ... [OPTION] ...\n" \ " -p value, sets pulses every p micros, %d-%d, TESTING only\n" \ " -r value, sets refresh period in deciseconds, %d-%d, default %d\n" \ " -s value, sets sampling rate in micros, %d-%d, default %d\n" \ "\nEXAMPLE\n" \ "sudo ./freq_count_1 4 7 -r2 -s2\n" \ "Monitor gpios 4 and 7. Refresh every 0.2 seconds. Sample rate 2 micros.\n" \ "\n", OPT_P_MIN, OPT_P_MAX, OPT_R_MIN, OPT_R_MAX, OPT_R_DEF, OPT_S_MIN, OPT_S_MAX, OPT_S_DEF ); } void fatal(int show_usage, char *fmt, ...) { char buf[128]; va_list ap; va_start(ap, fmt); vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); fprintf(stderr, "%s\n", buf); if (show_usage) usage(); fflush(stderr); exit(EXIT_FAILURE); } static int initOpts(int argc, char *argv[]) { int i, opt; while ((opt = getopt(argc, argv, "p:r:s:")) != -1) { i = -1; switch (opt) { case 'p': i = atoi(optarg); if ((i >= OPT_P_MIN) && (i <= OPT_P_MAX)) g_opt_p = i; else fatal(1, "invalid -p option (%d)", i); g_opt_t = 1; break; case 'r': i = atoi(optarg); if ((i >= OPT_R_MIN) && (i <= OPT_R_MAX)) g_opt_r = i; else fatal(1, "invalid -r option (%d)", i); break; case 's': i = atoi(optarg); if ((i >= OPT_S_MIN) && (i <= OPT_S_MAX)) g_opt_s = i; else fatal(1, "invalid -s option (%d)", i); break; default: /* '?' */ usage(); exit(-1); } } return optind; } void edges(int gpio, int level, uint32_t tick) { int g; if (g_reset_counts) { g_reset_counts = 0; for (g=0; g<MAX_GPIOS; g++) g_pulse_count[g] = 0; } /* only record low to high edges */ if (level == 1) g_pulse_count[gpio]++; } int main(int argc, char *argv[]) { int i, rest, g, wave_id, mode; gpioPulse_t pulse[2]; int count[MAX_GPIOS]; /* command line parameters */ rest = initOpts(argc, argv); /* get the gpios to monitor */ g_num_gpios = 0; for (i=rest; i<argc; i++) { g = atoi(argv[i]); if ((g>=0) && (g<32)) { g_gpio[g_num_gpios++] = g; g_mask |= (1<<g); } else fatal(1, "%d is not a valid g_gpio number\n", g); } if (!g_num_gpios) fatal(1, "At least one gpio must be specified"); printf("Monitoring gpios"); for (i=0; i<g_num_gpios; i++) printf(" %d", g_gpio[i]); printf("\nSample rate %d micros, refresh rate %d deciseconds\n", g_opt_s, g_opt_r); gpioCfgClock(g_opt_s, 1, 1); if (gpioInitialise()<0) return 1; gpioWaveClear(); pulse[0].gpioOn = g_mask; pulse[0].gpioOff = 0; pulse[0].usDelay = g_opt_p; pulse[1].gpioOn = 0; pulse[1].gpioOff = g_mask; pulse[1].usDelay = g_opt_p; gpioWaveAddGeneric(2, pulse); wave_id = gpioWaveCreate(); /* monitor g_gpio level changes */ for (i=0; i<g_num_gpios; i++) gpioSetAlertFunc(g_gpio[i], edges); mode = PI_INPUT; if (g_opt_t) { gpioWaveTxSend(wave_id, PI_WAVE_MODE_REPEAT); mode = PI_OUTPUT; } for (i=0; i<g_num_gpios; i++) gpioSetMode(g_gpio[i], mode); while (1) { for (i=0; i<g_num_gpios; i++) count[i] = g_pulse_count[g_gpio[i]]; g_reset_counts = 1; for (i=0; i<g_num_gpios; i++) { printf(" %d=%d", g_gpio[i], count[i]); } printf("\n"); gpioDelay(g_opt_r * 100000); } gpioTerminate(); } |
Anschließend kompilieren wir die Datei:
gcc -Wall -pthread -o freq_count_1 freq_count_1.c -lpigpio -lrt
Nun kann das Programm bereits aufgerufen werden. Dabei muss nur der entsprechende GPIO Pin angegeben werden, an welchem „OUT“ verbunden ist (bspw. 21):
sudo ./freq_count_1 21
Anschließend wird die Nummer des GPIOs, gefolgt von der Frequenz (in Hz) angezeigt. Als Test kannst du den Sensor in ein Glas Wasser stellen und wirst beobachten, wie sich die Frequenz verringert.
Im einem Projekt wie dem Raspberry Pi Gewächshaus gilt es nun, den optimalen Wert herauszufinden. Dies ist allerdings abhängig von der Erde, der Bewässerung und den Pflanzen und kann daher nicht eindeutig beantwortet werden. Bei mir ergab volle Nässe (Glas Wasser) eine Frequenz von ca. 1000Hz, wobei totale Trockenheit (kein leitendes Material) ungefähr 10kHz (mit einem Frequenzteiler von 16).
Solltest du ein Python Skript nutzen, so kannst du das obere C-Programm auch erweitern/verkürzen und in dein Python Skript einbinden.
Weitere Informationen zum Thema Giess-o-Mat
Weiterführende Informationen zu dem Gießomat gibt es u.a. auf den nachfolgenden Seiten, wobei es sich dabei meist um die Benutzung mit Arduino und/oder ESP8266 und weniger mit dem Raspberry Pi geht. Dennoch denke ich, dass es lesenswerte Links für Interessierte sein können:
- https://www.mikrocontroller.net/articles/Giess-o-mat
- https://github.com/Zentris/erdfeuchtemessung
- http://www.n8chteule.de/zentris-blog/category/erdfeuchtemessung/
- https://wwwvs.cs.hs-rm.de/vs-wiki/index.php/Internet_der_Dinge_WS2015/SmartPlant#Messmethode_2:_Kapazitiv
Falls du eine weitere gute Quelle kennst, kannst du sie gerne als Kommentar posten, sodass ich die Liste erweitern kann.
50 Kommentare
Hinterlasse einen Kommentar
Hinterlasse einen Kommentar
Raspberry Pi Einstieg – Was brauche und wie starte ich?
22. November 2014
50 der wichtigsten Raspberry Pi Sensoren und Module
22. Januar 2016
15 Raspberry Pi Projekte für Anfänger zum nachbauen
28. Oktober 2017
Amazon Alexa (Deutsch) auf dem Raspberry Pi installieren
14. Februar 2017
Raspberry Pi: Luftfeuchtigkeit und Temperatur messen
30. August 2015
Es gibt auch noch andere Methoden die Feuchtigkeit via pi zu messen z.b. über den wärmeleitfähigkeit des Bodens (man misst die Temperatur und führt dann Wärme zu und misst die zeit die vergeht bis z.b. die Erhöhung um 3 Grad erreicht ist)
leider können die Chinesen den gies o mat besser bauen und kostet fertig auch nur zwischen 7-15€ 😉 man muss ihn auch nicht schützen vor Feuchtigkeit da dies bereits vom hersteller passiert.
Hi Peddi,
dein Ansatz klingt interessant, hast du sowas bereits umgesetzt?
Falls du Links zu den Sensoren hast, ich konnte keine gute Alternative finden. Und die resistiven China-Sensoren sind auch nur für eine gewissen Zeit etwas.
LG, Felix
Die Chinaböller haben nichts mit dem Giesomaten zu tun !!!
Diese funktionieren eben restistiv und den damit verbundenen Nachteilen !!!
Meine Antwort war auf den letzten Absatz von peddi bezogen 😉
Du denkst an die alten billigen Widerstandsmesser(ja die taugen 0 und man vergiftet die Pflanzen nur selber) 😉 schau mal weiter unten in die Kommentare, z.b
phantomanic hat das perfekte Beispiel zu den „richtigen“ geschickt.
@Ponos: Deine Aussage ist pauschal und meines Erachtens nicht korrekt, wenngleich es vermutlich auf 99% zutrifft. 🙂
https://www.china-gadgets.de/xiaomi-mi-pflanzensensor/
und der soll nicht nur per Xiaomi App auslesbar sein, sondern auch mit dem Pi:
https://github.com/open-homeautomation/miflora
Wobei ich mich mangels Zeit noch nicht abschließend mit dem Thema beschäftigt habe….
V.a. da ich aktuell primär nur ein System zur Feuchtigkeitsanzeige brauche… und da das „fahrbare“ Kübelpflanzen sind, müsste das per Funk gehen. Theoretisch müsste der „Giessomat“ auch erweiterbar sein, so das er meinetwegen alle 15 minuten misst und dann das Signal per BTLE weitergibt…
Achja, noch ein paar Links:
http://www.forum-raspberrypi.de/Thread-erdfeuchte-bewaesserung
http://www.dietmar-weisser.de/elektronik-projekte/analogtechnik/sensoren/bodenfeuchtesensor.html
http://sgerber.de/2014/08/kapazitiver-feuchtigkeitssensor-fuer-blumenerde/
ohne Wertung 😉
Ich habe mir den Chirp! geholt, sehr einfach in Betrieb zu nehmen und funktioniert auch sehr gut. Man muss nur darauf achten die Version 2.7.3 zu bestellen, das ist die mit I2C für Bastler. Kann ich nur weiterempfehlen:
https://wemakethings.net/chirp/
https://www.tindie.com/products/miceuz/i2c-soil-moisture-sensor/
Chirp! muss umbedingt getaucht werden.
Ansonsten das selbe Problem wie alle kapazitiven Sensoren: Diffusion von Wassermolekülen.
Leider haben meine ersten zwei Chirp dadurch gleich mal den Geist aufgegeben.
Mit der ausgelieferten Vergussmasse taugt das Ding rein gar nichts…..
Achtung: Finger weg vom Chirp! aus China.
Software ist einfach nur mies !!!
Die besagte Beschichtung gar nicht vorhanden !!!
Einfach nur billig !!!
Besser den Giesomat kaufen und viel Frust sparen.
(Ausser ihr könnt den AVR auf dem Chirp selbst programmieren)
Danke,
schöne Zusammenfassung wie der Sensor am RPi betrieben werden kann.
Nur aus der ‚Zehnerdiode‘ sollte eine ‚Z-Diode‘ gemacht werden, das sieht professioneller aus.
Und wenn man den Sensor mit 3,3V versorgt kann man sich auch gleich sparen.
Also ich weiß nicht sowohl mein Python script als auch mein Oszilloskop zeigen mir ungefähr die doppele Frequenz an als das hier vorgestellte Programm. Hat jemand das gleiche festgestellt oder mache ich etwas falsch? Trotzde danke für den Beitrag :).
Ist das der Selbe?
https://physicalcomputing.at/epages/f46ab952-295a-4f65-8ffa-38a4b8eec267.sf/de_AT/?ObjectPath=/Shops/f46ab952-295a-4f65-8ffa-38a4b8eec267/Products/A-11023
Im Momment gibt es eine Aktion:
Coupon: hitze2017
Gibt 10% auf alles!
Aber scheinbar nur bis Ende Juni.
Wir haben eine Bewässerungsanlage mit einem Arduino gebuat, die wir über einen resistiven Feuchtigkeitssensor steuerten (also über den mV-Wert). Leider ist dieser wegkorridiert. Weiß jemand, wie man die Frequenz im Arduino ausliest bzw. das Auslesen programmiert (Codebeispiel?)?
Warum wird dieses Projekt nicht unter „Projekte“ angezeigt?
Ich bin jetzt rein zufällig darauf gestossen und werde es schnellst möglich umsetzen 🙂
Hey,
ich habe das Tutorial mit den selben Bauteilen 1 zu 1 nachgebaut nur leider gibt mein sensor immer 0 aus.
in der Konsole steht:
21=0
bin leider ein absoluter Anfänger und mache das ganze für ein abschlussprojekt.
hat evtl jemand eine Idee oder einen Ratschlag wo das Problem liegen könnte?
Lg aus Berlin!
Pegelwandler benutzt?
Wenn ja:
Wie hoch ist die Frequenz, welche der Giesomat VOR dem Pegelwandler ausgibt?
Wenn nein:
Wie hoch ist die Frequenz, welche der Giesomat NACH dem Pegelwandler ausgibt?
Der Link auf den BAusatz funktioniert nicht mehr !!!
Die haben scheinbar die Seite geändert:
https://www.ramser-elektro.at/produkt-kategorie/bausaetze-und-platinen/
Danke für den Hinweis, ist nun wieder richtig verlinkt 🙂
Hallo.
Mit: „sudo ./freq_count_1 21“ wird das Programm ausgeführt und einem Ausgang zugeördnet.
Wie kann ich das Ergebniss jetzt in einem Programm verwenden und darüber einen ein <= vergleich führen, darüber eine Ausgang steuern?
Wenn du ein C oder Python Programm schreibst, kannst du die Funktion direkt verwenden.
Hallo, hab das Tutorial so nach gebaut und bekomme nun leider keine konstanten Werte, welche ich sinnvoll weiterverarbeiten kann.
Sieht folgendermaßen aus:
109
96
25
34
20
8
82
12
102
usw.
Wie könnte ich den Fehler einkreisen?
Beste Grüße
Stanef
Info dazu: Der Sensor steht mit seinen füßen komplett im Wasser.
Was denkt ihr, ist der optimalste Widerstand zur Frequenzteilung für die Benutzung vom Raspberry Pi. Außerdem würde ich die Sensordaten gerne in meinen Python Script einarbeiten, hat da jemand so etwas wie ein Beispielprogramm um den Feuchtigkeitssensor auszulesen?
Hallo Maretius. Nimm das Skript oben zum Auslesen. Es funktioniert. Ich habe jetzt einen 200K-Widerstand drauf und ja, es kommen halt Werte raus. Steht der Sensor im Wasser erhalte ich 33200
und in der Luft 5700. Leider gibt es vom Hersteller keine Tabelle aus der hervorgeht, welche Wertespanne „richtig“ wäre.
Dieses Messverfahren schätze ich persönlich auch als ungeeignet ein, die Bodenfeuchte zu bestimmen. Es gibt schlichtweg zu viele Störfaktoren (Salzgehalt, Temperatur), die z.T. auch gewollt sind. Zum Beispiel brauchen Wurzeln Sauerstoff und dieser ist in lockerer Erde häufiger anzutreffen als in dichter. In verdichteter Erde kommst Du mit diesem Verfahren aber zu ganz anderen Werten. Und nach einem Gießvorgang lockerer Erde ändern sich die Zahlen weil die Bodendichte partiell! zunimmt (In der Regel gibt man die Erde ja nicht einen Topf mit Wasser und vermischt diese).
Du kannst es aber mal mit von „unten gießen“ probieren, indem du den Topf in Wasser setzt bis die Erde absolut gesättigt ist. Dann ist die Erde zumindest gleichmäßiger bewässert.
Ok, erstmal vielen Dank für den Tipp mit dem gießen.
Ich habe jetzt erstmal :
if sudo ./freq_count_1 21 < 5000:
GPIO.output (26, GPIO.LOW)
…
geschrieben, reicht das oder muss ich die Datei (also den eigentlichen Messvorgang) erst noch importieren?
In welcher Sprache soll der Code sein? Falls Python, brauchst du etwas wie os.system() o.ä. um Shellbefehle auszuführen.
Ja ich benutze Python und wie soll das dann konkret aussehen?
https://docs.python.org/2/library/os.html
Hi Felix,
Deine Tutorials zum automatischen Gewächshaus und zum kapazitativen Feuchtesensor sind super. Du verweist auch in beiden aufeinander, leider ist mir (und wohl auch vielen anderen hier) total unklar wie man beide zusammenführt, also im Gewächshausprojekt diesen kapazitiven Sensor im Python Programm auslesen und zur Pumpensteuerung nutzen kann. Oben im Text verweist auf https://docs.python.org/2/extending/extending.html#id5 hier in den Kommentaren nun auf https://docs.python.org/2/library/os.html. Tja, weder das eine noch das andere ist wirklich trivial und für Anfänger 1:1 einfach umsetzbar… Könntest Du nicht bitte ein Python Beispiel geben / Dein Gewächshaustutorial um diesen Sensor erweitern??? Wäre sehr nett…
Hallo!
Nachdem ich vor der gleichen Challenge stand und nicht wusste, wie ich die Sensoren/den Sensor über Python OHNE Einbindung des C-Programmes auslese, beschloss ich mich im Netz durchzuwühlen. Google -> „python gpio read frequency“ -> ersten 2-3 Ergebnisse sollten helfen!
Für faule Menschen wie mich habe ich alternativ ein funktionierendes Python Skript auf mein Gist hochgeladen: https://gist.github.com/alphachris/e13e280559938a0f31c27b789fc791e7
Ohne Garantie/Support! Viel Spass und Freude am Experimentieren! 🙂
Danke fürs Teilen 🙂
Gerne doch! 🙂
hi,
Ich finde ein paar Komponenten für den Frequenzteiler nicht
BC847B hab ich keine Ahnung welchen und 74HC4040 gibt es unterschiedliche bei Conrad:
Logik IC – Zähler nexperia 74HC4040D,652 Binärzähler 74HC Negative Kante 98 MHz SO-16 ( Artikel 1115002 – 62)
und
Logik IC – Zähler nexperia 74HC4040D,653 Binärzähler 74HC Negative Kante 98 MHz SO-16 ( Artikel 1115001 – 62)
welcher ist der richtige oder egal?
Ist es möglich mehr als zwei Sensoren am Raspberry zu betreiben? Es gibt ja nur zwei GPIOs die SPI können.
Ich habe schon gegoogelt und bin auf den Hinweis gestoßen einen Muliplexer einzusetzen. Ich verstehe nur nicht genau wie.
Ich kann meine Frage nun selbst beantworten. Es gibt viel mehr als nur zwei SPIs (beim Raspberry Pi 3). Ich dachte Raspi wäre auf zwei begrenzt. Hat sich also erledigt.
Warum kaufst du keinen ferigen Bausatz von „Ramser Elektrotechnik“ ?
Der hat doch alle Bauteile dabei.
Die paar Cent spart man am falschen Platz.
Habe in einem Forum gelsen, das die Sensoren einen eigenen Auswerte IC bekommen sollen.
Da bin ich mal gespannt.
Hallo Zusammsn,
Erst mal danke für all diese Informationen. Ich bin auf dem Bereich der Elektrotechnik nicht sehr bewandert und Versuche daher die Sache zu verstehen.
Anstelle des Frequenzwandlers kann man ja um Geld zu sparen einen „Vielfaches vom 100kΩ Widerstand“ verwenden. Der Frequenzwandler selbst bringt ja keine weiteren Vorteile, wenn ich das richtig verstanden habe oder? Ein wie Vielfaches des 100k Widerstandes ist hier zu empfehlen bzw. was ist für den Raspberry akzeptable Frequenz?
Vielen Dank und Grüße
David
Das wüsste ich auch gerne… In einer der anderen Kommentare steht etwas von 200k, aber ob das genügt weiß ich leider auch nicht.
Mit welchem Verbindungsteil verbindet man die beiden Platinen (Giessomatic und Frequenzteiler)? Geht das mit einem Stück Draht oder braucht man male to male Jumper-Kabel? Oder wie macht man das?
Hat es mittlerweile jmd geschaft eine Pumpe zusammen mit dem giess- o-mat sensor anzusteuern und würde sein Skript zur verfügung stellen?
Hätte mal etwas zum Laufen gebracht, danke an Chris und Felix für die Vorarbeit
https://github.com/DKL92/Raspberry_Garden.git
Dickes Lob an euch drei : )
Die Frequenz auslesen hat ja prima funktioniert, nur wie man ein Relais damit zum schalten bringt
das war mir völlig unklar. Jetzt kann ich endlich weiter tüfteln…
Danke euch
Hat das System schon mal jemand mit einem Arduino Undo R3 gelöst?
Der könnte das Signal auswerten und an einen RPI weitergeben!
Ja, gibt es mittlerweile:
https://www.ramser-elektro.at/der-gies-o-shield-fuer-den-arduino/
Hi,
Ich habe jetzt diesen Sensor im Einsatz:
https://www.sertronics-shop.de/bauelemente/sensoren-module/feuchtigkeit/662/analoger-kapazitiver-bodenfeuchtesensor?c=93
Wenn ich alles richtig gemacht habe ist das ja ein Drop-in-Ersatz für den resistierend oder nicht?
Hi Leute,
kann mir von euch jemand sagen, ob man den GIES-O-SHIELD von Ramser.at auch an einem Raspberry Pi betreiben kann?
Eventuell mit einem eigenen Script oder so?
Gruß
Hallo Leute,
ich bastel auch schon zwei Jahre mit den Gieso-Mat rum….allerdings mit ESP8266. Die Ergebnisse sind auch mehr als zufrieden. Zumindest die Werte. Ich nutze einen ESP der am Sensor hängt und die Daten per MQTT an meinen Raspi sendet. Ein zweiter ESP empfängt die Daten und gibt diese auf ein 2,2″ Zoll Display in „Prozent Erdfeuchte “ wieder. Komisch ist allerdings das Verhalten vom Sensor. (ohne Frequenzteiler) An der Luft habe ich einen Wert von 277kHz, im Wasserglas so etwa 39kHz. In der Erde (leicht angefeuchtet) ca. 90kHz. Ich habe die Erde 3 Wochen nicht gegossen und mein Sensorwert hat sich kaum verändert……Im Topf war eine Tomatenpflanze…sehr merkwürdig….
Alles sehr interessant. 3 Fragen:
– Ich will es auf dem Balkon betreiben (also auch im Regen). Wie isoliere ich die Kontakte und die Kabelanschlüsse zum Rasberry PI 3 am besten und vermeide Tauwasser und Kurzschlüsse?
– Liege ich richtig Rasberry PI hat 40 GPIO Eingänge, d.h. ich kann bis zu 40 Feuchtigkeitssensoren (40 Kübelpflanzen) betreiben?
– Rein pragmatisch reicht es evtl. aus nur eine Kübelpflanze zu messen und dann die Bewässerung für alle zu aktivieren (-> wenn 1 Pflanze trocken ist, werden die anderen Pflanzen auch trocken sein), ich habe auch nur 1 Wasserkreislauf (1 Pumpe)?
Danke.