Ce message est également comme Document PDF disponible.
S'il existe toute une gamme de capteurs disponibles pour enregistrer la température, l'humidité, la pression atmosphérique, l'éclairement... nous devons puiser dans la boîte à outils pour construire un capteur de précipitations. Il s’agit simplement d’enregistrer des quantités relativement faibles de liquides, qui ne représentent pas un flux continu mais, au sens propre du terme, se présentent sous forme de gouttelettes. Ces gouttelettes doivent être collectées. Lorsque le pot est rempli de gouttelettes, il doit être vidé automatiquement et ce processus doit être enregistré. J'ai copié le principe d'appareils commerciaux sur Internet. Une bascule avec deux bols est montée de manière à pouvoir être facilement tournée et inclinée lorsqu'un certain niveau de remplissage est atteint. Ce processus de basculement doit maintenant être enregistré par des capteurs appropriés. Vous découvrirez comment cela s'est passé en détail, y compris les mauvais virages, dans les prochains épisodes de la série.
MicroPython sur ESP32 et ESP8266
aujourd'hui [1]
L’ESP32 comme pluviomètre – Partie 1
Dans l'épisode d'aujourd'hui, nous allons nous occuper de la mécanique du projet, examiner le fonctionnement des contacts Reed et créer un premier petit programme de test que nous développerons dans les deux prochains épisodes. Pour ce faire, nous utilisons le sac d’astuces de MicroPython. Vous en apprendrez davantage sur les interruptions, le rebond des contacts et comment les désactiver par programme. Enfin, nous transférerons les fichiers contenant les valeurs mesurées vers le PC via FTP, en utilisant la technologie threading.
mécanique
La bascule
Le capteur permettant de mesurer la quantité de pluie est une bascule à deux plateaux.
Figure 1 : Partie de base de l'appareil
Ici, la bascule est déjà installée dans la partie inférieure du tube de mesure. J'ai utilisé un couvercle d'un tuyau d'égout en PVC de calibre 100. Deux ouvertures ont été sciées pour que l'eau puisse s'écouler.
Figure 2 : Modèle de bascule de pluie
La figure 2 montre le motif de la bascule, réalisée à partir de plexiglas de 2 mm. Le modèle 1:1 sous la forme d'un Fichier PDF, peut être téléchargé. J'ai utilisé la colle PLEXIGLAS® « Acrifix 192 » pour le collage. Il comble les lacunes et durcit sous la lumière UV ou simplement à la lumière du jour. J'ai collé les pièces du gabarit sur le verre acrylique avec un bâton de colle soluble dans l'eau. Après le sciage et le perçage, vous pouvez simplement retirer à nouveau le papier. N'oubliez pas de nettoyer les zones à coller avec de l'acétone ou de l'isopropanol.
La position du trou de 1,5 mm pour l'arbre en fil de cuivre de 1,4 mm (l'arbre ne doit pas rouiller, donc n'utilisez pas de fer) détermine la facilité avec laquelle la bascule s'incline. Cela augmente à mesure que le trou est haut au-dessus du sol. J'utilise le trou supérieur et j'obtiens une capacité d'env. 2,4 cm³ jusqu'à ce que la bascule bascule. Nous verrons plus tard quelle quantité de pluie cela représente en fonction de la zone.
Que pouvez-vous faire de mal ? La résolution de la mesure du volume est meilleure si la bascule est la plus légère possible. Vous devez donc utiliser le matériau le plus fin possible et le moins de colle possible. Ma première tentative de fabrication de la bascule en fer blanc ou en tôle de cuivre a été un échec total. Le volume des bacs n'était pas suffisant pour faire basculer la bascule car la construction était beaucoup trop lourde.
La suspension de la bascule est également en verre acrylique. Les panneaux latéraux sont vissés sur la plaque de base de 6 mm d'épaisseur afin que l'objet puisse être démonté. Les dimensions peuvent être trouvées dans la figure 3.
Figure 3 : Support de culbuteur
Pour éviter que le culbuteur ne frotte contre les parois latérales, j'ai placé des petits disques en plexiglas entre elles.
Figure 4 : Bascule latérale
Figure 5 : Bascule, vue du nord-est
Pour que les précipitations atterrissent spécifiquement dans les plateaux, elles doivent être collectées sur une zone de taille connue et guidées via un entonnoir juste au-dessus de la bascule. Bien entendu, une seule des deux moitiés peut être remplie à la fois. Il y a trois choses à considérer.
● Les baignoires doivent être suffisamment larges pour que rien ne se passe mal.
● Le bord supérieur de la cloison doit être suffisamment éloigné de la ligne de chute des gouttes d'eau.
● Et comme les grands entonnoirs ont généralement des tubes de sortie plus épais, j'ai dû utiliser la buse d'une cartouche en silicone pour créer une sortie plus fine. La buse était simplement collée dans l'entonnoir avec du silicone.
Un tuyau d'égout de 100 mm qui supporte l'entonnoir a été coupé à longueur afin que l'entonnoir puisse être placé dans la bonne position. La figure 5 montre les trois composants de la mécanique.
Figure 6 : Les parties mécaniques du pluviomètre
Voici à quoi ressemble l'appareil fini. L'ouverture dans le tube permet de contrôler l'alignement précis de l'entonnoir. Si nécessaire, la pièce sciée peut être équipée de charnières et utilisée comme porte.
Figure 7 : Station de mesure assemblée
Enregistrer le mouvement d'inclinaison
Passons à la détermination du mouvement d'inclinaison. Des mesures avec une pipette ont montré que la bascule s'incline vers la droite et vers la gauche avec des quantités de remplissage légèrement différentes, 2,4 cm³ et 2,5 cm³. Cette situation résulte apparemment d’une application inégale de l’adhésif ou d’autres asymétries. Les deux positions finales stables devaient donc être détectables. Au départ j'avais prévu d'utiliser un accéléromètre MPU6050 sous la forme d'un module GY 521. Cependant, les quatre câbles nécessaires gênaient tellement le basculement de la bascule que j'ai dû m'abstenir de le faire. Les barrières lumineuses réfléchissantes étaient trop encombrantes pour moi et j'ai donc fini par utiliser des contacts Reed.
Ce sont de petits interrupteurs à commande magnétique dans un tube de verre mesurant 2 mm x 13 mm. La chose commune à ces choses, ce sont les fils de connexion rigides. J'ai tué quatre des contacts, car si vous le pliez trop près du verre, il se brisera immédiatement et tuera le composant.
Figure 8 : Contact Reed
Finalement, nous avons réussi à fixer deux des objets sur une paroi latérale du support à l'aide d'un mastic à deux composants. Ça a l’air sauvage, mais ça marche bien. Il est préférable d'attacher la laisse de la même manière.
Figure 9 : Emplacement des contacts et de l'aimant
Un petit disque aimanté en néodyme est collé sur la bascule (Acrifix) et les contacts sont alignés en fonction de cette position. La figure 10 illustre le fonctionnement des contacts Reed et explique pourquoi ce type d'aimant ne doit pas être situé exactement devant le contact.
Figure 10 : Comment fonctionne un contact Reed
Le contact est ouvert en dehors des champs magnétiques (1). Les ressorts de contact sont constitués d'un matériau ferromagnétique, probablement du fer ou un alliage correspondant. Les pôles d'un disque magnétique reposent sur les surfaces coupées. Si vous vous approchez du contact Reed, le fil de fer (en bas) devient un aimant (pôle sud) en raison de l'influence magnétique et attire le deuxième ressort de contact. Le contact se ferme (2).
Si vous deviez glisser le disque magnétique au centre sous le contact, des pôles similaires seraient influencés dans les ressorts. Parce qu’ils se repoussent, le contact ne peut pas se fermer (3).
De petites barres magnétiques peuvent être placées directement parallèlement au contact. Étant donné que différents pôles des ressorts de contact sont alors influencés, le contact se ferme (4).
Matériel
Pour les deux familles de contrôleurs, ESP32 et ESP8266, il faut d'abord penser aux broches GPIO pouvant être utilisées. Certains d'entre eux sont intégrés au processus de démarrage et ne peuvent donc pas être utilisés sans restrictions. En plus de trois entrées IRQ, une entrée bouton et une sortie LED, nous avons également besoin des bus I2C et SPI, qui occupent à eux seuls 6 broches. Les tableaux fournissent des informations sur l'utilisation des broches. Avec l'ESP8266, en plus des lignes de bus, il ne reste que 3 broches GPIO, dont D0 = GPIO16 n'est pas compatible IRQ. Les « petits » sont donc exclus de notre projet.
Mais il y a aussi un problème avec l'ESP32. La broche 12 ne doit pas être ÉLEVÉE lors du démarrage, sinon le contrôleur ne démarrera pas. Malheureusement, cette connexion est la ligne MISO du bus SPI1 et est tirée à 3,3 V par l'esclave. SPI1 est donc tabou. Utilisez donc SPI2 ou Soft-SPI. Nous y reviendrons dans le prochain post.
Passons aux pièces nécessaires au projet. Le tableau répertorie tous les composants nécessaires tout au long du projet. Dans ce premier épisode, ceux surlignés en gris ne sont pas utilisés dans un premier temps.
|
1 |
Kit de développement ESP32 C dessoudé ou Kit de développement ESP32 C V4 dessoudé ou Carte de développement WiFi WLAN, Module NodeMCU ESP32 avec CP2102 ou |
|
1 |
|
|
1 |
|
|
1 |
Lecteur SPI Micro mémoire SD TF carte module de protection de carte mémoire |
|
1 |
Carte SD par exemple 8 Go |
|
1 |
|
|
1 |
|
|
1 |
|
|
1 |
DIRIGÉ |
|
1 |
Résistance 220Ω |
|
2 |
Résistance 10kΩ |
|
1 |
|
|
facultatif |
Tableau 3 : Composants
Sur les 10 contacts Reed du kit, il en faut 2 (ou comme moi, six).
Le schéma de circuit de la figure 11 montre comment les pièces sont connectées.
Figure 11 : Circuit pluviomètre
Le logiciel
Pour flasher et programmer l'ESP32 :
Thonny ou
Firmware utilisé pour un ESP32 :
Téléchargement du micrologiciel Micropython
Les programmes MicroPython pour le projet :
timeout.py Minuterie logicielle non bloquante
oled.py API OLED
ssd1306.py Pilote OLED
couteau de pluie.py Programme de démonstration
MicroPython - langage - modules et programmes
Pour installer Thonny vous pouvez en trouver un ici instructions détaillées (version anglaise). Il y a aussi une description de la façon de procéder Micrologiciel Micropython (au 18 juin 2022) sur la puce ESP brûlé devient.
MicroPython est un langage interpréteur. La principale différence avec l'IDE Arduino, où vous flashez toujours et exclusivement des programmes entiers, est qu'il vous suffit de flasher le firmware MicroPython une seule fois au début sur l'ESP32 pour que le contrôleur comprenne les instructions MicroPython. Vous pouvez utiliser Thonny, µPyCraft ou esptool.py pour ce faire. J'ai le processus pour Thonny ici décrit.
Une fois le micrologiciel flashé, vous pouvez avoir une conversation informelle avec votre contrôleur, tester des commandes individuelles et voir immédiatement la réponse sans avoir à compiler et transférer au préalable un programme entier. C'est exactement ce qui me dérange à propos de l'IDE Arduino. Vous gagnez beaucoup de temps si vous pouvez effectuer des tests simples de syntaxe et de matériel jusqu'à tester et affiner des fonctions et des parties entières du programme via la ligne de commande avant de créer un programme à partir de celui-ci. Pour cela, j'aime toujours créer de petits programmes de test. Comme une sorte de macro, elles combinent des commandes récurrentes. Des applications entières se développent parfois à partir de tels fragments de programme.
Démarrage automatique
Si vous souhaitez que le programme démarre de manière autonome à la mise sous tension du contrôleur, copiez le texte du programme dans un fichier vierge nouvellement créé. Enregistrez ce fichier sous main.py dans l'espace de travail et téléchargez-le sur la puce ESP. La prochaine fois que vous réinitialiserez ou allumerez, le programme démarrera automatiquement.
Programmes de tests
Les programmes sont démarrés manuellement à partir de la fenêtre actuelle de l'éditeur dans l'IDE Thonny à l'aide de la touche F5. C'est plus rapide que de cliquer sur le bouton Démarrer ou d'utiliser le menu courir. Seuls les modules utilisés dans le programme doivent être dans le flash de l'ESP32.
Arduino IDE encore entre les deux ?
Si vous souhaitez ultérieurement utiliser à nouveau le contrôleur avec l'IDE Arduino, flashez simplement le programme de la manière habituelle. Cependant, l'ESP32/ESP8266 a alors oublié qu'il parlait MicroPython. A l'inverse, toute puce Espressif qui contient un programme compilé depuis l'IDE Arduino ou le firmware AT ou LUA ou... peut facilement être fournie avec le firmware MicroPython. Le processus est toujours comme ça ici décrit.
Un premier essai
Il vaut mieux commencer par ça Téléchargez les fichiers suivants sur le flash ESP32 :
oled.py, ssd1306.py, ds3231.py et timeout.py
Quand tout est assemblé, nous commençons les premiers tests. Dans REPL entrons les lignes suivantes. La beauté de MicroPython est que vous pouvez tester l'effet des commandes depuis la ligne de commande avant de les incorporer dans un programme. C'est exactement ce que nous faisons maintenant. Nous mettons la bascule en position gauche. Les entrées sont formatées en gras, le système répond en italique.
>>> from machine import Pin
>>> reedR = Pin(16,Pin.IN)
>>> reedL = Pin(17,Pin.IN)
>>> reedR()
1
>>> reedL()
0
Nach dem Umklappen der Wippe:
>>> reedR()
0
>>> reedL()
1
Donc ça marche. Lors de l'interrogation des niveaux, j'utilise la propriété des objets pin appelable, c'est-à-dire être appelable. Cela se fait par la méthode Épingler.__appeler__() permet. Elle appartient à ce qu'on appelle Méthodes magiques et permet à l'objet d'être appelé comme une fonction. Les instructions suivantes doivent donc être utilisées de manière synonyme.
>>> roseauR(1)
>>> reedR.value(1)
>>> reedR.on()
Ou
>>> reedR()
0
>>> reedR.value()
0
>>> reedR.on()
0
Prochain essai : Bus I2C. Nous lions le module DouxI2C Premièrement, instanciez un objet, i2c et regardez qui est représenté sur le bus.
>>> from machine import Pin, SoftI2C
>>> i2c=SoftI2C(scl=Pin(22),sda=Pin(21),freq=100000)
>>> i2c.scan()
[60, 87, 104]
Vous êtes probablement surpris que trois adresses de périphériques soient trouvées, puisque nous n'avons que deux modules sur le bus. Oui, mais - en plus de la puce RTC, le module DS3231 dispose également d'une EEPROM de 32 Ko = 8 Ko avec l'adresse matérielle 87 = 0x57 sur la carte. Les modèles 60 = 0x3C (OLED) et 104 = 0x68 (DS3231) nous intéressent. L'EEPROM pourrait être utilisée, par exemple, pour stocker de manière permanente des données de configuration. Donc ça marche aussi.
Écran Oled: Lors de l'instanciation, nous passons l'objet I2C et indiquons à l'API que notre affichage fait 64 pixels de haut.
>>> d=OLED(i2c,heightw=64)
this is the constructor of OLED class
Size:128x64
>>> d.writeAt("Hallo Welt",3,0)
13
« Hello World » est imprimé au milieu de la ligne supérieure. La valeur renvoyée 13 est la prochaine position d'écriture libre dans la ligne.
Le RTC (Real Time Clock) est également sur le bus I2C. On passe donc également l'instance I2C au constructeur de l'objet RTC. Ensuite, nous définissons la date et l'heure et obtenons l'heure. Un tuple avec les sept valeurs suivantes est à transmettre (année, mois, jour, jour de la semaine, heure, minute, seconde). Cela vaut également le module très complet ds3231.py pour y regarder de plus près.
>>> rtc=DS3231(i2c)
DS3231 bereit @ 0x4C
>>> rtc.DateTime((2024,6,14,5,14,19,30))
>>> rtc.Time()
[14, 19, 32]
L'ESP32 dispose également d'un RTC, mais il n'a pas de minuterie d'alarme. Pour avoir une fonction réveil, il faut utiliser le DS3231 et – les interruptions de programme, en bref IRQs. Ils permettent de signaler un événement extérieur au programme en cours d'exécution et de demander son fonctionnement en interrompant immédiatement le programme (demande d'interruption).
Les contacts à bascule et le RTC peuvent déclencher de tels événements en modifiant le niveau sur une broche GPIO (pin changement IRQ). Nous devons définir une entrée GPIO pour chaque événement. L'IRQ peut être armée après qu'une routine de service d'interruption (ISR) ait été définie. Dans le paramètre épingle L'objet broche de déclenchement est transmis par le système. Les entrées sont connectées à des pull-ups externes de 10 kOhm car les internes ont une impédance trop élevée. Cela améliore la pente – c’est ce que m’a dit le DSO (Digital Storage Oscilloscope).
>>> reedR = Pin(16,Pin.IN)
>>> reedL = Pin(17,Pin.IN)
led=Pin(2,Pin.OUT,value=0)
>>> def pinIRQ(pin):
global source
if pin==reedL:
source="L"
led(0)
elif pin==reedR:
source="R"
led(1)
>>> reedR.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
<IRQ>
>>> reedL.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
<IRQ>
Lors de l'armement, la référence à l'ISR est transférée et le front descendant est défini comme déclencheur.
Si la bascule est maintenant inclinée à la main, la LED s'allume lorsqu'elle est inclinée vers la droite et s'éteint lorsqu'elle est inclinée vers la gauche. – Effrayant, non ? – Aucun programme n'est en cours d'exécution et les contacts ne sont pas directement connectés au circuit LED. Les IRQ sont donc actives même si aucun programme principal n'est en cours d'exécution. Ce qui est maintenant interrompu est REPL, le R.ead EVal P.imprimer Loups. Et donc nous désactivons à nouveau la magie.
>>> reedL.irq(handler=None)
<IRQ>
>>> reedR.irq(handler=None)
<IRQ>
Nous l'utiliserons pour nettoyer lorsque nous quitterons le programme et quitterons une salle blanche. Nous pouvons déclencher ce processus en appuyant sur le bouton du GPIO4 - plus tard, pas maintenant.
Pour le Battement de coeur (signe de vie) pendant le fonctionnement de la boucle principale nous utilisons la LED et un timer logiciel non bloquant. Cela s'exécute en arrière-plan sans bloquer l'exécution de la boucle. La magie est tout en un ici Fermeture. Il s'agit d'une fonction encapsulée dans une définition de fonction environnante. Étant donné que la fonction interne utilise des variables de la fonction environnante, la fonction interne et les variables restent actives après avoir quitté la fonction environnante. Normalement, tous les entrailles d’une fonction sont écrasés lorsqu’ils la quittent. Oh MicroPython mystique – Ommm !
La fonction environnante est appelée ici TimeOutMs(). Elle habite dans le module timeout.py, d'où nous les importons. Dans TimeOutMs() vit la fonction comparer(), qui récupère l'argument passé 5000 ainsi que l'état actuel du tick du minuteur. Tant que la différence entre les autres horodatages et le tick de minuterie enregistré au début ne dépasse pas 5 000, la fonction fournit comparer() renvoie la valeur False, sinon True. TimeOutMs() renvoie une référence à la sortie comparer() en arrière et rend ainsi la fermeture immortelle. On attribue cette référence à l'identifiant clignote maintenant et peut utiliser la fonction comparer() sous le pseudonyme clignote maintenant appeler à tout moment.
>>> from timeout import TimeOutMs
>>> jetztBlinken=TimeOutMs(5000)
>>> jetztBlinken()
False
>>> jetztBlinken()
False
>>> jetztBlinken()
True
Au bout de cinq secondes, on obtient le résultat Vrai. La définition de la fonction est assez chétive, mais mérite d'être étudiée. Pour ce faire, ouvrez simplement le fichier timeout.py dans une fenêtre d'éditeur.
Le programme
Avec ces tests manuels, nous avons déjà discuté de l'ensemble du programme. Tous les éléments réapparaissent dans un ordre peut-être légèrement différent, avec quelques petits ajouts qui sont commentés.
# regenmesser.py
from oled import OLED
from machine import Pin, SoftI2C
from time import sleep_us, sleep, sleep_ms
from ds3231 import DS3231
import sys
from timeout import TimeOutUs, TimeOutMs
# externe 10k-Pullups bringen steilere Flanken!
reedR = Pin(16,Pin.IN) # rechts prellt 75us
reedL = Pin(17,Pin.IN) # links kein Prellen
key=Pin(4,Pin.IN,Pin.PULL_UP) # Tasteneingang an GPIO4
# mit internem Pullupwiderstand
led=Pin(2,Pin.OUT,value=0)
i2c=SoftI2C(scl=Pin(22),sda=Pin(21),freq=100000)
i2cDevices=i2c.scan()
i2cNamen={ # Das Dictionary erleichtert die Identifikation
0x57: "DS3231.EEPROM 32Kb",
0x68: "DS3231.RTC",
0x3C: "OLED",
0x40: "SHT21",
}
print("I2C-Devices @ ")
for i in i2cDevices: # Nummer in Hexcode und Klartext wandeln
print(hex(i),i2cNamen[i])
print()
d=OLED(i2c,heightw=64)
rtc=DS3231(i2c)
source="*"
# Inhalt der Kippschalen in ccm
cLinks = 2.4 # ccm
cRechts = 2.5
# Trichter Durchmesser d=10,9cm
area=(10.9/2)**2 * 3.1415 # Trichterfläche
bucketHour=0 # Der Sammeleimer
# IRQ-Service-Routine
def pinIRQ(pin):
global source # Damit der neue Wert die ISR verlassen kann
if pin==reedL:
source="L"
elif pin==reedR:
source="R"
def shutdown(): # Funktion zum Aufraeumen beim Beenden
reedL.irq(handler=None)
reedR.irq(handler=None)
print("von User abgebrochen")
# Pin Change IRQ scharfschalten
reedR.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
reedL.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
jetztBlinken=TimeOutMs(2000) # Das erste Blinken initiieren
while 1: # Hauptschleife
Y,M,D,_,h,m,s=rtc.DateTime() # Datum und Zeit holen
if source=="L":
source="#" # Trigger zuruecksetzen
bucketHour += cLinks # aufsummieren
print("Links", bucketHour,"+",h,":",m,":",s)
elif source=="R":
source="-" # Trigger zuruecksetzen
bucketHour += cRechts # aufsummieren
print("rechts",bucketHour,"-",h,":",m,":",s)
datum=f"{D:02}.{M:02}.{Y}" # Datums- und Zeit-String bauen
zeit=f"{h:02}:{m:02}:{s:02}"
niederschlag="\'\'\'\' {:.2f} mm". /
format(bucketHour/area*10) # dto. Niederschlag in mm
d.clearAll(False) # Display loeschen
d.writeAt(datum,3,0,False)
d.writeAt(zeit,4,1,False)
d.writeAt(niederschlag,3,3)
if jetztBlinken(): # Wenn Timer abgelaufen, kurz blitzen
jetztBlinken=TimeOutMs(2000) # Ablauf neu setzen
led(1) # LED an
sleep_ms(5)
led(0) # und wieder aus
if key()==0: # Falls Taste key gedrueckt,
sys.exit(shutdown()) # shutdown() aufrufen und Ende
Pour sortir du texte mélangé à des nombres, vous pouvez avantageusement utiliser des chaînes de format. Il existe deux variantes, chaîne f et la fonction format(). Les citations sont similaires.
>>> D,M,Y = 14,6,2024
>>> f"{D:02}.{M:02}.{Y}"
'14.06.2024'
Cela met le jour et le mois sur deux chiffres et l'année dans une chaîne, séparés par des points.
>>> "{:02}.{:02}.{}".format(D,M,Y)
'14.06.2024'
Ce formulaire produit le même résultat. La première variante est idéale pour la structure des textes HTML. La deuxième variante permet d'interrompre la ligne par "\" si elle devient trop longue, comme dans le listing ci-dessus. Les instructions de format sont très diverses. Les énumérer tous remplirait plusieurs épisodes de blog.
Un mot sur les sorties d'affichage. Les modifications apportées à l'écran sont d'abord écrites dans une mémoire tampon de la RAM, qui est également immédiatement envoyée à l'écran lorsque vous êtes dans l'écran. écrireAT()- ou effacerTout() énonce l'argument FAUX omet ou via un Vrai remplacé. Mais l'écran scintille alors, et c'est ennuyeux. C'est pourquoi j'ai d'abord laissé le nouveau contenu du tampon être entièrement construit dans la RAM et je n'ai transféré l'intégralité du contenu qu'avec la dernière commande d'écriture. Cela enlève le stress de tout cela.
Démarrez maintenant le programme et déplacez la bascule. La sortie gauche ou droite peut apparaître plusieurs fois de suite, même si un seul mouvement d'inclinaison a été effectué. J'ai également eu ce phénomène avec mon contact Reed droit - contact qui rebondit à la fermeture. Comment cela peut être éliminé par programme et d'autres ajouts au projet seront fournis dans le prochain épisode.
En attendant, restez à l’écoute !
1 commentaire
Francesco Cerquone
Salve. Mi chiedevo se per misurare in modo semplice la quantità di acqua caduta dal cielo non è meglio misurare il suo peso, anzichè il suo volume?
Per esempio un estensimetro o cella di carico come sensore del peso dell’acqua….