Dans le cadre de la mesure de l’humidité du sol sur un Raspberry Pi, il existe des capteurs résistifs et capacitifs, qui présentent chacun des avantages et des inconvénients. L’innovante machine à couler Raspberry Pi / DFROBOT Gravity ou capteur « Giess-o-Mat » fournit une mesure capacitive précise et permanente, qui peut notamment être très intéressante dans notre serre Raspberry Pi.
Ce tutoriel traite de la structure de la machine à couler Raspberry Pi ainsi que de la lecture de la fréquence, à l’aide de laquelle l’humidité relative du sol peut être calculée.
Comme plusieurs utilisateurs me l’ont demandé et qu’il n’y a pas beaucoup de matériel sur le sujet (en ce qui concerne le Raspberry Pi), j’espère que ce tutoriel rendra son utilisation un peu plus facile.
Pièces détachées nécessaires
Pour cela, j’ai pris les pièces ou composants matériels suivants :
- Raspberry Pi 4
- Capteur d’humidité capacitif DFROBOT Gravity ou « Giess-o-Mat ».
- Facultatif : diviseur de fréquence
- alternativement : plusieurs résistances de 100kΩ
- Câble Jumper
- Fer à souder + soudure
Je recommande de prendre tout de suite la version enrobée de la carte, sinon, il faudra de toute façon la sceller à la main. Les composants fournis de la carte/capteur (listés ci-dessous) sont au format SMD et ne conviennent donc pas vraiment aux débutants. Avec un peu d’habileté, la taille ne devrait pas être un problème.
Le diviseur de fréquence peut également être remplacé par une résistance. Dans ce cas, la résistance 100kΩ en position R3 (voir ci-dessous) est remplacée par une résistance plus grande : Si la fréquence est divisée par deux, on prend une résistance deux fois plus grande, etc. Il est bien sûr possible de combiner plusieurs résistances.
Avantages par rapport aux capteurs d’humidité résistifs
Dans un précédent tutoriel, nous avons connecté et lu un capteur d’humidité du sol à très bas prix sur le Raspberry Pi. Cependant, cette conception présente un problème qui survient avec le temps : la corrosion. Après une utilisation prolongée avec la même polarité, les capteurs se décomposent souvent partiellement. Cela n’est pas bon pour le comportement de mesure ni pour les valeurs du sol.
Ce danger n’existe pas avec les capteurs capacitifs. Dans ce cas, cependant, aucun signal analogique n’est émis, qui peut être lu avec un ADC MCP3008, mais une fréquence qui varie en hauteur – en fonction de l’humidité de la terre (plus elle est humide, plus elle est basse).
Le Raspberry Pi, c’est pourquoi nous utilisons un diviseur de fréquence qui la divise par un certain dividende, ou simplement une plus grande résistance. L’inconvénient d’un diviseur de fréquence est son prix, car une simple résistance ne coûte presque rien.
Montage de la machine de moulage Raspberry Pi
Le Giess-o-Mat n’est généralement pas livré monté, c’est pourquoi les composants SMD individuels n’ont pas encore été soudés sur la carte. Comme ils sont très petits, un regard sur l’étiquette aide. J’ai également essayé de documenter chaque étape avec des photos, afin que rien ne se passe mal.
Le capteur de gravité DFROBOT est plus facile à manipuler : Il n’y a pas de soudure à faire, vous pouvez donc ignorer cette étape.
La fiche d’aide suivante se trouve dans le sac des composants :
| Description | Type | Étiquettes | Fonction |
|---|---|---|---|
| T1 | BC847B | 1Ft od. 1FW | Transistor |
| C1 | 10μF 10V | Condensateur | |
| IC1 | 74HC14D | HC14 | IC |
| D1 | BZX84B5V6 | T12 or Z3 | Diode Zener 5v6 |
| R1 | 1k | 102 od. 1001 | Résistance 1k |
| R2 | 100R | 101 od. 1000 | Résistance 100R |
| R3 | 100k | 104 od. 1003 | Résistance 100k |
Commençons par le circuit intégré. Il est important que le côté avec la marque « up » montre où la petite encoche ronde est visible sur le PCB.
Le condensateur (C1) n’a pas d’étiquette et il importe peu de savoir quel côté est soudé à quel endroit :
Avec les résistances (R1, R2, R3) vous devez faire attention car l’inscription SMD ne correspond pas à la taille réelle. Sur cette page, vous pouvez simplement entrer la valeur imagée de la résistance SMD et obtenir le calcul de la taille réelle.
Si vous n’avez pas de diviseur de fréquence, vous pouvez également utiliser une résistance plus grande à la place de R3 (comme décrit ci-dessus).
Ensuite, il manque le seul transistor (T1) et la diode Zener (D1), qui ont la même forme. Ici encore, aide l’étiquette du dessus :
Monter le diviseur de fréquence (facultatif).
De la même manière que la machine de moulage, nous construisons également le diviseur de fréquence si nous en avons un.
D’abord la table :
| Description | Type | Étiquettes | Fonction |
|---|---|---|---|
| T1 | BC847B | 1Ft, 1F-, 1FW | Transistor |
| C1 | 10μF 10V | Condensateur | |
| IC1 | 74HC4040 | HC4040 | IC |
| D1 | BAS40 | 43t, 43-, 43p, 43W | Diode Schottky |
| R1, R2 | 2k2 | 222, 2201 | Résistance 2k2 |
Encore une fois, nous commençons par le circuit intégré, le condensateur et les résistances. La taille de R1 et R2 est identique.
Il manque toujours le transistor (T1) et la diode (D1). Faites à nouveau attention à l’étiquette, car le modèle est identique :
Enfin, les deux contacts de » : 16″ sont soudés ensemble, ce qui donne une fréquence 16 fois plus basse.
En outre, j’ai soudé les deux cartes ensemble et soudé au diviseur de fréquence quelques contacts pour le câble jumper.
Un script pour lire la fréquence
Connectez d’abord V + et 3.3V au Raspberry Pi, GND à GND et OUT par exemple à GPIO21.
Pour lire la fréquence sur le Raspberry Pi, il y a la bibliothèque PiGPIO, qui apporte des bibliothèques pour C (++), Python, etc. Elle est déjà préinstallée sur les versions ordinaires de Raspbian (pas Lite), sinon on peut l’installer après :
sudo apt-get update sudo apt-get install pigpio python-pigpio python3-pigpio
Ensuite, nous créons un nouveau fichier C, qui est là pour lire la fréquence :
sudo nano freq_count_1.c
Ce fichier a le contenu suivant (exemple d’ici). Enregistrez avec CTRL + O et renvoyez CTRL + X au terminal.
|
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(); } |
Ensuite, nous compilons les fichiers :
gcc -Wall -pthread -o freq_count_1 freq_count_1.c -lpigpio -lrt
Maintenant le programme peut déjà être appelé. Il faut seulement spécifier la broche GPIO correspondante, à laquelle « OUT » est connecté (par exemple 21) :
sudo ./freq_count_1 21
Ensuite, le numéro du GPIO suivi de la fréquence (en Hz) s’affiche. À titre de test, vous pouvez mettre le capteur dans un verre d’eau et observer la diminution de la fréquence.
Dans un projet comme la serre Raspberry Pi, il est maintenant important de trouver la valeur optimale. Cependant, cela dépend du sol, de l’irrigation et des plantes et ne peut donc pas être répondu clairement. Pour moi, l’humidité totale (verre d’eau) a donné une fréquence d’environ 1000Hz, avec une sécheresse totale (aucun matériau conducteur) environ 10kHz (avec un diviseur de fréquence de 16).
Si vous utilisez un script Python, vous pouvez également étendre/raccourcir le programme C supérieur et l’intégrer dans votre script Python.
Autres informations sur Giess-o-Mat
Des informations supplémentaires sur la machine de moulage sont disponibles e.a. sur les pages suivantes, dont la plupart sont à utiliser avec Arduino et/ou ESP8266 et moins avec le Raspberry Pi. Néanmoins, je pense que cela peut valoir la peine de lire des liens pour les personnes intéressées :
- 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
Si vous connaissez une autre bonne source, vous pouvez la poster en commentaire afin que je puisse élargir la liste.