La pioggia e l'elettrolisi!

L'elettrolisi è quel fenomeno per il quale avviene una trasformazione chimica grazie all'elettricità.
Il termine deriva dal greco e significa "rompere con l'elettricità" e proprio questo significato si addice al fenomeno che riscontriamo tutti noi che utilizziamo un rilevatore di pioggia con il Raspberry.
Chiunque abbia la classica piastrina a pettine su un balcone per rilevare l'eventuale pioggia sarà incorso nel fenomeno dell'elettrolisi, cioè avrà visto i denti del pettine ossidarsi e corrodersi.
In ambito industriale abbiamo i cosiddetti pannellini anti elettrolisi che funzionano molto bene anche con i 24volt alternati. Ho specificato questa tensione perché uno dei suggerimenti per ridurre il fenomeno sarebbe quello di non utilizzare la tensione continua (es. i 3.3v del Raspi) ma quella alternata. E' vero che ciò dilata i tempi in cui si manifesta l'elettrolisi ma purtroppo non di tanto (senza pannellini).
La soluzione che ho seguito, dopo numerose ricerche e che espongo qui, è quella di fornire la tensione per la lettura del pettine per pochi secondi al giorno.
La lettura della pioggia, normalmente per i nostri usi amatoriali, non è richiesta in maniera continua. Anche fare una lettura ogni 5 minuti (che per me, ad esempio, è esagerata) si riesce a ridurre il fenomeno sensibilmente.
Tutto parte dal "transistor" che sarà il nostro interruttore per accendere e spegnere la schedina del rain detector.

Nel disegno sopra si vede il circuito finale completo. Per il disegno ho utilizzato l'app Tinkercad che permette non solo la rappresentazione grafica ma anche la simulazione diretta del funzionamento come se fossimo in ambiente reale. Difatti si vedono due indicatori di tensione che rappresentano la sorgente di alimentazione e la tensione reale in uscita dal transistor una volta attivato.
Senza approfondire in dettaglio, anche perché purtroppo non mi compete, il transistor funziona come un interruttore, comandato da un "pulsante". Questo "pulsante", che nel disegno ho raffigurato proprio così, nel nostro caso si tratta di una uscita comandata del Raspberry (GPIO 22).
Il disegno cortesemente fornito da elinux.org mostra i collegamenti proprio di un transistor 2N3904, suggerito in tutti i siti visitati ed utilizzato da me.

Come vedete, la GPIO, fornendo una tensione alla base (b) attraverso una resistenza, mette in conduzione il carico (la nostra schedina) chiudendo il circuito tra VCC(+) e GND (-).

Nel mio disegno si vede l'uscita pin 22 della GPIO che una volta attivata mette in conduzione la schedina (il Load nel disegno del transistor). E' proprio la terra (GND), il negativo, che il transistor "chiude" collegando il collettore (c) all'emettitore (e).

Fin qui tutto semplice, la parte più difficile è il dimensionamento della resistenza che si vede tra la GPIO e la base del transistor.
La corrente da fornire (intesa come Intensità) deve essere sufficiente ad attivare il transistor e, quindi, il carico collegato ma limitata da una resistenza per evitare danni allo stesso transistor.

Grazie all'aiuto di un utente di StackExchange ho potuto capire meglio questo aspetto ed impostare la formula per il calcolo. Nella formula (3.3V-0.7/assorbimento in microA) devo fornire i dati di assorbimento del carico, la schedina. I dati del costruttore erano riferiti a 5v ma io, dovendo utilizzare i 3.3V ho preferito misurarla.
Con un tester ho simulato l'attivazione della schedina e letto il consumo di corrente che era di circa 45-50mA. Dal calcolo ho stabilito che la resistenza doveva essere 5.2kOhm e, per sicurezza, ho messo una da 4.7kOhm.

Una volta impostato il circuito che permette l'attivazione del sensore di pioggia a comando, ho preparato uno script in pyhton che, eseguito da crontab ad intervalli regolari (ogni mezz'ora), attiva la schedina, legge lo stato (se sta piovendo o no) e scrive il risultato su un file che viene poi letto dal programma in running (nel mio caso la sveglia).

GPIO.setmode(GPIO.BCM)
GPIO.setup(22, GPIO.OUT)
GPIO.setup(23, GPIO.IN)

def rain():

    GPIO.output(22, True)
    time.sleep(6)
    state = GPIO.input(23)

    if state == 0: #raining
       rain_sen = 1

    elif state == 1: #drought
       rain_sen = 0

    time.sleep(1)

    with open ("/home/pi/ClockAlarm/rain.txt", "w") as file:

       rain_status = str(rain_sen)
       file.writelines(rain_status)
    GPIO.output(22, False)

while True:

      rain()
      time.sleep(2)
      GPIO.cleanup()
      quit()


Nel codice vedete che la lettura avviene (come in realtà) tramite il pin 23 mentre nel disegno l'ingresso è letto dal pin 5: il disegno è stato fatto prima di verificare i pin liberi sul mio Raspberry!

Questo è tutto, non ho ancora evidenze sufficientemente ampie per confermare la bontà di questa soluzione ma dubito di non essere sul piede giusto. Confermerò o negherò qui i prossimi eventi.