Anche questo post è come Documento PDF disponibile.
Sebbene sia disponibile un'intera gamma di sensori per registrare temperatura, umidità, pressione dell'aria, illuminamento... dobbiamo scavare nella cassetta degli attrezzi per costruire un sensore per le precipitazioni. Si tratta semplicemente di registrare quantità relativamente piccole di liquidi, che non rappresentano un flusso continuo ma, nel vero senso della parola, appaiono sotto forma di goccioline. Queste goccioline devono essere raccolte. Quando il vasino è pieno di goccioline, deve essere svuotato automaticamente e questo processo deve essere registrato. Ho copiato il principio da dispositivi commerciali su Internet. È montata una bascula con due vasche in modo che possa essere facilmente ruotata e inclinata quando viene raggiunto un determinato livello di riempimento. Questo processo di ribaltamento deve ora essere registrato da sensori adeguati. Scoprirete come è andata nel dettaglio, svolte sbagliate comprese, nei prossimi episodi della serie
MicroPython su ESP32 ed ESP8266
Oggi [1]
L'ESP32 come pluviometro – Parte 1
Nella puntata di oggi ci occuperemo dei meccanismi del progetto, vedremo come funzionano i contatti reed e creeremo un primo piccolo programma di test che approfondiremo nelle prossime due puntate. Per fare ciò, utilizziamo i trucchi di MicroPython. Imparerai a conoscere gli interrupt, il rimbalzo dei contatti e come disattivarli a livello di codice. Infine, trasferiremo i file con i valori misurati sul PC tramite FTP, utilizzando la tecnologia threading.
meccanica
L'altalena
Il sensore per misurare la quantità di pioggia è un bilanciere con due vassoi.
Figura 1: parte base dell'apparecchio
In questo caso il bilanciere è già installato nella parte inferiore del tubo di misurazione. Ho usato una copertura di un tubo per fognatura in PVC calibro 100. Sono state praticate due aperture in modo che l'acqua possa defluire.
Figura 2: Schema dell'altalena della pioggia
La Figura 2 mostra il modello del bilanciere, realizzato in plexiglas da 2 mm. Il modello 1:1 sotto forma di a File PDF, può essere scaricato. Per l'incollaggio ho utilizzato la colla PLEXIGLAS® “Acrifix 192”. Riempie gli spazi vuoti e si indurisce alla luce UV o semplicemente alla luce del giorno. Ho incollato le parti della sagoma al vetro acrilico con una colla stick idrosolubile. Dopo aver segato e forato, puoi semplicemente rimuovere di nuovo la carta. Non dimenticare di pulire le aree da incollare con acetone o isopropanolo.
La posizione del foro da 1,5 mm per l'albero in filo di rame da 1,4 mm (l'albero non deve arrugginirsi, quindi non utilizzare il ferro) determina la facilità con cui l'oscillazione si inclina. Ciò aumenta quanto più il foro è alto rispetto al suolo. Io utilizzo il foro superiore e ottengo una capacità di ca. 2,4 cm³ finché la sedia a dondolo non si ribalta. Daremo un'occhiata più avanti alla quantità di pioggia che ammonta in base all'area.
Cosa puoi fare di sbagliato? La risoluzione della misurazione del volume è migliore se l'oscillatore è il più leggero possibile. Quindi dovresti usare il materiale più sottile possibile e la minor quantità di colla possibile. Il mio primo tentativo di realizzare la sedia a dondolo in lamiera stagnata o lamiera di rame è stato un totale flop. Il volume delle vasche non era sufficiente a far ribaltare l'altalena perché la costruzione era troppo pesante.
Anche la sospensione del bilanciere è in vetro acrilico. I pannelli laterali sono avvitati alla piastra di base spessa 6 mm in modo che l'oggetto possa essere smontato. Le dimensioni possono essere trovate nella Figura 3.
Figura 3: Staffa basculante
Per evitare che il dondolo sfreghi contro le pareti laterali, ho inserito tra queste dei piccoli dischi di plexiglass.
Figura 4: Rocker dal lato
Figura 5: Altalena, vista da nord-est
Affinché la precipitazione possa cadere in modo mirato nei vassoi, deve essere raccolta su un'area di dimensioni note e guidata tramite un imbuto fino appena sopra l'altalena. Naturalmente è possibile riempire solo una delle due metà alla volta. Ci sono tre cose da considerare.
● Le vasche devono essere sufficientemente larghe affinché nulla vada storto.
● Il bordo superiore della parete divisoria deve essere sufficientemente distante dalla linea di caduta delle gocce d'acqua.
● E, poiché gli imbuti di grandi dimensioni solitamente hanno tubi di uscita più spessi, ho dovuto utilizzare l'ugello di una cartuccia di silicone per creare un'uscita più sottile. L'ugello è stato semplicemente incollato nell'imbuto con silicone.
Un tubo fognario da 100 mm che sostiene l'imbuto è stato tagliato a misura in modo che l'imbuto possa essere posizionato nella posizione corretta. La Figura 5 mostra i tre componenti della meccanica.
Figura 6: Le parti meccaniche del pluviometro
Ecco come appare il dispositivo finito. L'apertura nel tubo consente il controllo durante l'allineamento preciso dell'imbuto. Se necessario, il pezzo segato può essere dotato di cerniere e utilizzato come porta.
Figura 7: Stazione di misurazione assemblata
Registrare il movimento di inclinazione
Veniamo alla determinazione del movimento basculante. Le misurazioni con una pipetta hanno dimostrato che la bascula si inclina a destra e a sinistra con quantità di riempimento leggermente diverse, 2,4 cm³ e 2,5 cm³. Questa circostanza apparentemente era dovuta ad un'applicazione non uniforme dell'adesivo o ad altre asimmetrie. Quindi entrambe le posizioni finali stabili dovevano essere rilevabili. Inizialmente avevo pianificato di utilizzare un accelerometro MPU6050 sotto forma di modulo GY 521. I quattro cavi necessari però interferivano così tanto con l'inclinazione della sedia a dondolo che ho dovuto astenermi dal farlo. Le barriere fotoelettriche riflettenti erano troppo ingombranti per me e così ho deciso di utilizzare contatti reed.
Si tratta di piccoli interruttori azionati magneticamente in un tubo di vetro che misura 2 mm x 13 mm. La cosa comune di queste cose sono i cavi di collegamento rigidi. Ho ucciso quattro dei contatti, perché se lo pieghi troppo vicino al vetro, si frantumerà immediatamente e ucciderà il componente.
Figura 8: Contatto Reed
Alla fine siamo riusciti ad attaccare due di questi oggetti su una parete laterale del supporto utilizzando uno stucco bicomponente. Sembra selvaggio, ma funziona bene. È meglio attaccare il guinzaglio allo stesso modo.
Figura 9: Posizione dei contatti e del magnete
Sul bilanciere (Acrifix) è incollato un piccolo disco magnetico al neodimio ed i contatti vengono allineati in base a questa posizione. La Figura 10 illustra il funzionamento dei contatti reed e spiega perché questo tipo di magnete non deve essere posizionato esattamente davanti al contatto.
Figura 10: Come funziona un contatto reed
Il contatto è aperto al di fuori dei campi magnetici (1). Le molle di contatto sono realizzate in materiale ferromagnetico, probabilmente ferro o una lega corrispondente. I poli di un disco magnetico si trovano sulle superfici tagliate. Se ci si avvicina al contatto reed, il filo di ferro (in basso) diventa un magnete (polo sud) a causa dell'influenza magnetica e attira la seconda molla di contatto. Il contatto si chiude (2).
Se si spingesse il disco magnetico al centro sotto il contatto, nelle molle verrebbero influenzati poli simili. Poiché si respingono, il contatto non può chiudersi (3).
I magneti a barra piccola possono essere posizionati direttamente parallelamente al contatto. Poiché vengono influenzati i diversi poli delle molle di contatto, il contatto si chiude (4).
Hardware
Per entrambe le famiglie di controller, ESP32 ed ESP8266, bisogna prima pensare ai pin GPIO che possono essere utilizzati. Alcuni di essi sono integrati nel processo di boot e quindi non possono essere utilizzati senza restrizioni. Oltre a tre ingressi IRQ, un ingresso per pulsanti e un'uscita LED, abbiamo bisogno anche dei bus I2C e SPI, che da soli occupano 6 pin. Le tabelle forniscono informazioni sull'utilizzo dei pin. Nell'ESP8266 rimangono oltre alle linee bus solo 3 pin GPIO, di cui D0 = GPIO16 non è compatibile con IRQ. I “piccoli” sono quindi esclusi dal nostro progetto.
Ma c'è anche un problema con l'ESP32. Il pin 12 non deve essere ALTO durante l'avvio, altrimenti il controller non si avvierà. Sfortunatamente, questa connessione è la linea MISO del bus SPI1 e viene portata a 3,3 V dallo slave. Pertanto SPI1 è tabù. Quindi usa SPI2 o Soft-SPI. Ci arriveremo nel prossimo post.
Passiamo alle parti necessarie per il progetto. La tabella elenca tutti i componenti necessari durante l'intero progetto. In questo primo episodio quelli evidenziati in grigio inizialmente non vengono utilizzati.
|
1 |
ESP32 Dev Kit C V4 dissaldato O Scheda di sviluppo WiFi WiFi modulo ESP32 NodeMCU con CP2102 O |
|
1 |
10 interruttori magnetici con interruttore reed N/O 2 x 14 mm |
|
1 |
Orologio in tempo reale RTC DS3231 Orologio in tempo reale I2C |
|
1 |
Lettore SPI Micro Memory SD TF Card Modulo di protezione della scheda di memoria |
|
1 |
Scheda SD ad esempio 8 GB |
|
1 |
|
|
1 |
|
|
1 |
|
|
1 |
GUIDATO |
|
1 |
Resistenza 220Ω |
|
2 |
Resistenza 10kΩ |
|
1 |
|
|
opzionale |
Tabella 3: Componenti
Dei 10 contatti Reed del set, ne servono 2 (o, come me, sei).
Lo schema elettrico nella Figura 11 mostra come sono collegate le parti.
Figura 11: Circuito del pluviometro
Il software
Per lampeggiare e programmare l'ESP32:
Thonny O
Firmware utilizzato per un ESP32:
Scarica il firmware micropython
I programmi MicroPython per il progetto:
timeout.py Temporizzatore software non bloccante
oled.py API OLED
ssd1306.py Driver OLED
coltello da pioggia.py Programma dimostrativo
MicroPython - linguaggio - moduli e programmi
Per installare Thonny puoi trovarne uno qui istruzioni dettagliate (versione inglese). C'è anche una descrizione di come farlo Firmware Micropython (al 18 giugno 2022) sul chip ESP bruciato diventa.
MicroPython è un linguaggio interprete. La differenza principale rispetto all'IDE Arduino, dove si esegue sempre ed esclusivamente il flashing di interi programmi, è che è necessario eseguire il flashing del firmware MicroPython solo una volta all'inizio sull'ESP32 in modo che il controller comprenda le istruzioni MicroPython. Puoi usare Thonny, µPyCraft o esptool.py per farlo. Ho il procedimento per Thonny Qui descritto.
Una volta eseguito il flashing del firmware, puoi avere una conversazione casuale con il controller, testare i singoli comandi e vedere immediatamente la risposta senza dover prima compilare e trasferire un intero programma. Questo è esattamente ciò che mi preoccupa dell'IDE Arduino. Si risparmia molto tempo se si possono eseguire semplici test di sintassi e hardware fino a provare e perfezionare funzioni e intere parti di programma tramite la riga di comando prima di creare un programma. A questo scopo mi piace sempre creare piccoli programmi di test. Come una sorta di macro, combinano comandi ricorrenti. Talvolta da tali frammenti di programma si sviluppano intere applicazioni.
Avvio automatico
Se si desidera che il programma si avvii autonomamente all'accensione del controller, copiare il testo del programma in un file vuoto appena creato. Salva questo file come main.py nell'area di lavoro e caricalo sul chip ESP. Al successivo ripristino o accensione, il programma si avvia automaticamente.
Programmi di prova
I programmi vengono avviati manualmente dalla finestra dell'editor corrente nell'IDE Thonny utilizzando il tasto F5. Questo è più veloce che fare clic sul pulsante di avvio o utilizzare il menu correre. Solo i moduli utilizzati nel programma devono essere nel flash dell'ESP32.
Di nuovo l'IDE Arduino nel mezzo?
Se in seguito si desidera utilizzare nuovamente il controller insieme all'IDE Arduino, è sufficiente eseguire il flashing del programma nel solito modo. Tuttavia, l'ESP32/ESP8266 ha poi dimenticato di parlare MicroPython. Al contrario, qualsiasi chip Espressif che contenga un programma compilato dall'IDE di Arduino o dal firmware AT o LUA o ... può essere facilmente fornito con il firmware MicroPython. Il procedimento è sempre così Qui descritto.
Una prima prova
È meglio iniziare con questo Carica i seguenti file sul flash ESP32:
oled.py, ssd1306.py, ds3231.py e timeout.py
Quando tutto è assemblato, iniziamo i primi test. In SOSTITUZIONE inseriamo le righe seguenti. La bellezza di MicroPython è che puoi testare l'effetto dei comandi dalla riga di comando prima di incorporarli in un programma. Questo è esattamente quello che stiamo facendo adesso. Mettiamo il bilanciere nella posizione sinistra. Le voci sono formattate in grassetto, il sistema risponde in corsivo.
>>> from machine import Pin
>>> reedR = Pin(16,Pin.IN)
>>> reedL = Pin(17,Pin.IN)
>>> reedR()
1
>>> reedL()
0
Dopo aver piegato la sedia a dondolo:
>>> cannaR()
0
>>> cannaL()
1
Quindi funziona. Quando interrogo i livelli, utilizzo la proprietà degli oggetti pin richiamabile, cioè essere richiamabile. Questo viene fatto con il metodo Pin.__chiama__() abilita. Appartiene al cosiddetto Metodi magici e consente di chiamare l'oggetto come una funzione. Le seguenti istruzioni dovrebbero quindi essere usate >>> reedR()
0
>>> reedR.value()
0
>>> reedR.on()
0
>>> cannaR()
0
>>> reedR.valore()
0
>>> reedR.on()
0
Prossima prova: Autobus I2C. Leghiamo il modulo SoftI2C uno, istanzia un oggetto, i2c e guarda chi è rappresentato sul bus.
>>> from machine import Pin, SoftI2C
>>> i2c=SoftI2C(scl=Pin(22),sda=Pin(21),freq=100000)
>>> i2c.scan()
[60, 87, 104]
Probabilmente sarai sorpreso che siano stati trovati tre indirizzi di dispositivi periferici, dato che abbiamo solo due moduli sul bus. Sì, ma il modulo DS3231 dispone oltre al chip RTC anche di una EEPROM da 32Kb = 8KB con l'indirizzo hardware 87 = 0x57 sulla scheda. Ci interessano il 60 = 0x3C (OLED) e il 104 = 0x68 (DS3231). La EEPROM potrebbe essere utilizzata, ad esempio, per memorizzare in modo permanente i dati di configurazione. Quindi funziona anche.
Display Oled: Durante l'istanziazione, passiamo l'oggetto I2C e diciamo all'API che il nostro display è alto 64 pixel.
>>> d=OLED(i2c,heightw=64)
this is the constructor of OLED class
Size:128x64
>>> d.writeAt("Hallo Welt",3,0)
13
"Hello world" è stampato al centro della riga superiore. Il valore restituito 13 è la successiva posizione di scrittura libera nella riga.
IL RTC (Real Time Clock) si trova anche sul bus I2C. Passiamo quindi l'istanza I2C anche al costruttore dell'oggetto RTC. Quindi impostiamo la data e l'ora e otteniamo l'ora. Si deve passare una tupla con i seguenti sette valori (anno, mese, giorno, giorno della settimana, ora, minuto, secondo). Vale anche la pena il modulo molto ampio ds3231.py per dare un'occhiata più da vicino.
>>> rtc=DS3231(i2c)
DS3231 bereit @ 0x4C
>>> rtc.DateTime((2024,6,14,5,14,19,30))
>>> rtc.Time()
[14, 19, 32]
L'ESP32 ha anche un RTC, ma non ha un timer di sveglia. Per avere la funzione sveglia dobbiamo utilizzare il DS3231 e – in breve – interruzioni del programma IRQS. Servono per segnalare un evento esterno al programma in esecuzione e per richiederne il funzionamento interrompendo immediatamente il programma (richiesta di interruzione).
I contatti basculanti e l'RTC possono attivare tali eventi modificando il livello su un pin GPIO (pin change IRQ). Dobbiamo definire un input GPIO per ciascun evento. L'IRQ può essere attivato dopo aver definito una routine di servizio di interruzione (ISR). Nel parametro spillo L'oggetto pin di attivazione viene trasmesso dal sistema. Gli ingressi sono collegati a pull-up esterni da 10kOhm perché quelli interni hanno un'impedenza troppo alta. Ciò migliora la pendenza: questo è ciò che mi ha detto il 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>
Durante l'inserimento viene trasferito il riferimento all'ISR e il fronte di discesa viene impostato come trigger.
Se ora si inclina manualmente la sedia a dondolo, il LED si accende quando viene inclinato a destra e si spegne quando viene inclinato a sinistra. – Inquietante, vero? – Nessun programma è in esecuzione e i contatti non sono collegati direttamente al circuito LED. Gli IRQ sono quindi attivi anche se non è in esecuzione alcun programma principale. Ciò che ora è interrotto lo è SOSTITUZIONE, IL Rmorire Eval Pstampa lops. E così spegniamo di nuovo la magia.
>>> reedL.irq(handler=None)
>>> reedR.irq(handler=None)
Lo useremo per ripulire quando lasceremo il programma e lasceremo una stanza pulita. Possiamo attivare questo processo premendo il pulsante su GPIO4: più tardi, non ora.
Per il Battito cardiaco (segno di vita) durante il funzionamento del loop principale utilizziamo il LED e un timer software non bloccante. Questo viene eseguito in background senza bloccare l'esecuzione del ciclo. La magia è tutta in una qui Chiusura. Questa è una funzione incapsulata in una definizione di funzione circostante. Poiché la funzione interna utilizza le variabili della funzione circostante, sia la funzione interna che le variabili rimangono vive dopo aver lasciato la funzione circostante. Normalmente, tutte le parti interne di una funzione vengono schiacciate quando la lasciano. Oh mistico MicroPython – Ommm!
La funzione circostante viene chiamata qui TimeOutMs(). Vive nel modulo timeout.py, da dove li importiamo. In TimeOutMs() vive la funzione confrontare(), che acquisisce l'argomento passato 5000 e anche lo stato corrente del tick del timer. Finché la differenza tra gli altri timestamp e il tick del timer registrato all'inizio non supera 5000, la funzione fornisce confrontare() restituisce il valore False, altrimenti True. TimeOutMs() restituisce un riferimento a quando si esce confrontare() indietro e rende così immortale la chiusura. Assegniamo questo riferimento all'identificatore ora lampeggiante a e può utilizzare la funzione confrontare() sotto lo pseudonimo ora lampeggiante chiamare in qualsiasi momento.
>>> from timeout import TimeOutMs
>>> jetztBlinken=TimeOutMs(5000)
>>> jetztBlinken()
False
>>> jetztBlinken()
False
>>> jetztBlinken()
True
Dopo cinque secondi, otteniamo il risultato VERO. La definizione della funzione è piuttosto debole, ma vale la pena indagarla. Per fare ciò, è sufficiente aprire il file timeout.py in una finestra dell'editor.
Il programma
Con queste prove manuali abbiamo praticamente già discusso l'intero programma. Tutti gli elementi compaiono nuovamente in un ordine forse leggermente diverso, con alcune piccole aggiunte che vengono commentate.
# 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
Per emettere testo misto a numeri è possibile utilizzare vantaggiosamente stringhe di formato. Esistono due varianti, stringa f e la funzione formato(). Le citazioni sono simili.
>>> D,M,Y = 14,6,2024
>>> f"{D:02}.{M:02}.{Y}"
'14.06.2024'
Ciò inserisce il giorno e il mese in due cifre e l'anno in una stringa, separati da punti.
>>> "{:02}.{:02}.{}".format(D,M,Y)
'14.06.2024'
Questo modulo produce lo stesso risultato. La prima variante è ideale per la struttura dei testi HTML. La seconda variante consente di interrompere la riga con "\" se diventa troppo lunga, come nell'elenco sopra. Le istruzioni sul formato sono molto diverse. Elencarli tutti riempirebbe diversi episodi del blog.
Una parola sulle uscite del display. Le modifiche per il display vengono prima scritte in una memoria buffer nella RAM, che viene immediatamente inviata anche al display quando si è in modalità scrivereAT()- O cancella tutto() enuncia l'argomento Falso omette o attraverso a VERO sostituito. Ma poi il display sfarfalla e questo è fastidioso. Per questo motivo lascio prima che il nuovo contenuto del buffer venga creato completamente nella RAM e trasferisco l'intero contenuto solo con l'ultimo comando di scrittura. Questo toglie la frenesia dall'intera faccenda.
Ora avvia il programma e muovi la bascula. L'uscita sinistra o destra può apparire più volte di seguito, anche se è stato eseguito un solo movimento di inclinazione. Ho avuto questo fenomeno anche con il mio contatto dell'ancia destro: il contatto rimbalzava durante la chiusura. Il modo in cui questo può essere eliminato a livello di programmazione e ulteriori aggiunte al progetto verranno fornite nel prossimo episodio.
Fino ad allora, rimanete sintonizzati!
1 commento
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….