Sensore fulmini: rilevare i temporali con Arduino

Sta arrivando un temporale? Scopriamolo con questo circuito basato su un sensore di scariche elettriche atmosferiche in grado di dirci quanto è lontano e intenso.

I centri meteorologici effettuano il monitoraggio, oltre che dei parametri atmosferici allo scopo di stimare la probabilità di precipitazioni e la loro consistenza, anche dei temporali e dei fenomeni elettrostatici loro correlati, come i fulmini.

In alcune nazioni esposte a consistenti fenomeni elettrici atmosferici e ai rischi che comportano, tale attività assume particolare rilievo.

Senza scomodare la cinematografia, che non ci ha fatto mancare lungometraggi del genere catastrofico con fulmini “assassini”, possiamo comprendere come le saette che vediamo solcare il cielo o abbattersi al suolo possano essere pericolose, per l’energia notevole che possono cedere precipitando dal cielo (dove si formano) a terra, su edifici, alberi e purtroppo anche sull’uomo.

Una pericolosità che diviene ancora maggiore in quelle aree dove possono verificarsi fulmini quasi a ciel sereno, ovvero in maniera inaspettata. Senza contare i danni che i fulmini caduti vicino alle linee di distribuzione elettrica e di telecomunicazioni causano, sotto forma di sovratensioni indotte, agli apparati elettrici e soprattutto elettronici.

L’attività di analisi dei fenomeni elettrici atmosferici viene svolta con varie metodiche (la più antica delle quali fu l’aquilone di Benjamin Franklin) basate sulla valutazione preventiva degli accumuli di elettricità statica nell’atmosfera e sull’intercettazione delle scariche elettriche, con apparati complessi e costosi, tuttavia si può condurre anche in maniera amatoriale, a casa propria, grazie a dispositivi come il sensore basato sull’integrato AS3935 della AMS, del quale in queste pagine vi facciamo vedere un’applicazione. Il componente utilizzato riesce a captare i disturbi radioelettrici causati dallo scoccare di archi elettrici (e i fulmini sono tali) e, tramite un’opportuna elaborazione, fornisce un segnale che corrisponde al rilevamento di un fulmine e della sua intensità.

Un po’ di teoria

I fulmini sono scariche elettriche atmosferiche aria-aria o aria-terra che si innescano a causa dell’accumulo di una consistente carica elettrica, ovvero quando si crea tra due punti dell’atmosfera o tra l’aria e la terra (ma anche il mare o i corsi d’acqua) un forte scompenso di carica elettrica; nel momento in cui la differenza di potenziale dovuta allo scompenso di carica è tale da superare la rigidità dielettrica del mezzo interposto (l’aria, di solito, che sia più o meno umida…) scocca l’arco elettrico, vale a dire la saetta, che comporta un flusso di corrente attraverso un mezzo per sua natura isolante.

La luce che ne deriva è causata dalla ionizzazione dei gas componenti l’aria compresa tra i punti tra i quali scocca l’arco, ovvero dal ritorno nei legami atomici degli elettroni asportati forzatamente dal fortissimo campo elettrico durante la scarica; l’energia restituita dall’elettrone prima del rientro nel legame produce un fotone, ossia una particella di luce, che nei fulmini è in buona parte collocata nello spettro del visibile.

Tale attività elettrica è percettibile a distanza come fosse un segnale radioelettrico trasmesso da un’emittente: lo dimostrò l’esperimento di Hertz, il quale fece scoccare delle scintille e rilevò a distanza con un dipolo la debole tensione che ne risultava.

Infatti possiamo immaginare lo scoccare di un fulmine come fosse un’oscillazione che stimola elettricamente l’aria e fa propagare una carica elettrica a una distanza che dipende dalla composizione dell’aria e dalle sue condizioni, nonché dalle prestazioni dell’antenna ricevente e del dispositivo utilizzato per la ricezione.

Utilizzando un sensibile ricevitore RF ed elaborando il segnale ricevuto mediante un algoritmo proprietario, l’integrato AS3935 determina se l’attività elettrica captata è causata da un fulmine, ovvero stima la probabile distanza sulla base dell’intensità del segnale; per distanza si intende verosimilmente quella dall’inizio del temporale o tempesta nell’ambito del quale scoccano i fulmini e il chip può determinarla con sufficiente approssimazione tra un massimo di 40 km e un minimo di 1km.

L’algoritmo serve a discernere, con una certa approssimazione, tra fulmini (scariche atmosferiche) e scariche elettriche prodotte ad esempio da spinterogeni e candele di motori a benzina, motori elettrici a spazzole, forni a microonde.

Collegamento di Arduino al sensore fulmini e al display seriale

Collegamento di Arduino al sensore fulmini e al display I2C

Il sensore di fulmini

Per rendere più facilmente utilizzabile il sensore di scariche atmosferiche abbiamo realizzato una breakout board contenente l’integrato AS3935.

Il cuore è chiaramente l’integrato, del quale portiamo all’esterno l’alimentazione, il bus per la comunicazione con circuiti esterni a microcontrollore, oltre che i principali segnali di controllo. Tutte le linee da collegare all’esterno o gestire dall’esterno sono riportate a una fila di piazzole a passo 2,54 mm poste su un lato, alle quali è possibile applicare un pin-strip.

La connessione dati con l’esterno avviene serialmente tramite I²C-Bus o SPI; in quest’ultimo caso impieghiamo le linee:
• MISO (Master Input Slave Output) che è l’uscita della breakout board con la quale vengono inviati ad Arduino i dati relativi ai fulmini rilevati;
• MOSI (Master Output Slave Input) che è l’uscita dati di Arduino con la quale vengono comunicati alla breakout board messaggi di impostazione o di conferma;
• CS (Chip Select) ovvero la linea di uscita di Arduino che abilita la breakout board all’interazione sul bus SPI; il CS serve perché sull’SPI possono affacciarsi vari dispositivi e per evitare collisioni dei dati occorre che ad ogni sessione di comunicazione ne venga abilitato uno solo per volta.
• SCL (clock) che corrisponde al segnale con cui viene sincronizzata la comunicazione sul bus.

I predetti segnali vengono riportati al CN1; per la linea di clock SCL e per il MOSI sono state inserite le resistenze di pull-up.
Notate che il piedino 8 dell’AS3935, vale a dire il CS, in assenza di diversa impostazione viene mantenuto a livello alto dal proprio resistore di pull-up interno, ma può essere forzato a zero logico dal jumper JCS laddove non si preveda la gestione dall’esterno.

Quanto alla modalità di comunicazione seriale, nella breakout board si può selezionare tramite un secondo jumper, siglato SI, che interviene sul piedino 9 (Select Interface); l’integrato AS3935 funziona:
• in modalità SPI se il piedino 9 è posto a zero logico;
• in modalità I²C se il Select Interface è posto a VDD.

Nella nostra applicazione abbiamo optato per la prima, perciò vedete che il jumper è stato chiuso.

Abbiamo poi il piedino IRQ (10), riportato al contatto 3 del connettore CN1, che comunica al microcontrollore quando IRQ è un’uscita che l’AS3935 porta a livello logico alto quando viene intercettato un fulmine e scritto in uno dei registri interni (REG0x03[3:0]) il valore corrispondente.

Procediamo con l’analisi dello schema elettrico passando allo stadio d’ingresso, che è quello attraverso cui captiamo il disturbo radioelettrico corrispondente al fulmine; esso fa capo ai piedini 2 e 3, che sono l’input del radioricevitore presente nell’integrato, il quale richiede all’ingresso un circuito antirisonante allo scopo di sintonizzare una certa banda ed escludere disturbi a bassa frequenza e di natura estranea allo scopo.

Il circuito di sintonia è composto da una bobina (induttanza AF) acquistabile già pronta e da due condensatori in parallelo, che assicurano il valore di capacità richiesto per determinare la frequenza di centro banda voluta. La bobina fa anche da antenna ricevente ed assicura un’ottima sensibilità.

Il resistore R3, posto in parallelo al circuito antirisonante, peggiora il fattore di merito dello stesso ma limita superiormente l’ampiezza del segnale introdotto nello stadio di sintonia; peggiorando il fattore di merito si allarga la banda sintonizzabile, il che ci va benissimo perché dobbiamo rilevare scariche elettriche che non hanno una precisa frequenza, ma cadono entro un ampio spettro.

La frequenza di centro banda dello stadio di sintonia è determinata dalla formula:

f = 1/6,28 x √LC

dove L è l’induttanza della bobina e C la somma di C4 e C5. Il fattore di merito Q è invece dato dal rapporto:

Q = f/Bw

dove Bw è la larghezza di banda del circuito antirisonante.

Il radioricevitore è del tipo ad amplificazione diretta e dispone di AGC, per regolare il guadagno in funzione del livello atteso all’uscita; il condensatore C3 determina il tempo di intervento dell’AGC.

Il segnale fornito viene quindi analizzato dall’apposito blocco interno al chip, che lo confronta con la media del rumore di fondo e tramite l’apposito algoritmo determina cosa può essere un fulmine e cosa va scartato, quindi il risultato produce una stringa di dati che viene depositata nell’apposito registro e, laddove il valore corrisponda a quello di un fulmine, genera un impulso sull’IRQ (piedino 3 del connettore CN1).

Concludiamo l’analisi dello schema elettrico della scheda sensore con i piedini ADD0 e ADD1, che servirebbero per impostare l’indirizzo dell’integrato laddove per la comunicazione venisse utilizzato il bus I²C e che in questo caso, essendo inutilizzati, sono portati a livello logico alto collegandoli all’uscita VREG (piedino 6) del regolatore di tensione interno all’integrato; la tensione fornita da tale pin viene filtrata dal ripple mediante il condensatore C1.

Ciò detto, passiamo a vedere come la breakout board è utilizzata nel circuito.

Listato 1

#include <SPI.h>

#include <AS3935.h>

#include <SoftwareSerial.h>

#define LCD_pin 5 // LCD data signal

const int NoDetect = 30;
int counter;
int NumDisturber = 0;

SoftwareSerial LCD = SoftwareSerial(0, LCD_pin);

void printAS3935Registers();

byte SPItransfer(byte sendByte);

void AS3935Irq();

AS3935 AS3935(SPItransfer, 3, 2); //change to AS3935(SPITransfer,9,3) if using slot #2

void setup() {
  serLCDInit();
  backlightOn();
  clearLCD();
  lcdPosition(0, 3);
  LCD.print(“Lightining”);
  lcdPosition(1, 5);
  LCD.print(“Sensor”);
  delay(1500);
  clearLCD();

  Serial.begin(9600);
  SPI.begin();
  SPI.setDataMode(SPI_MODE1);
  SPI.setClockDivider(SPI_CLOCK_DIV16);
  SPI.setBitOrder(MSBFIRST);
  AS3935.reset();
  delay(10);
  AS3935.setOutdoors();
  AS3935.registerWrite(AS3935_NF_LEV, 2); //write 2 in the Noise Level register
  //AS3935.registerWrite(AS3935_SREJ,0); //write 2 in the Noise Level register and run calibration
  // if lightning detector can not tune tank circuit to required tolerance, calibration function will return false
  if (!AS3935.calibrate())
    Serial.println(“Tuning out of range, check your wiring, your sensor and make sure physics laws have not changed!”);
  // now we print the value in the calibration register TUN_CAP it is in the range 0 - 15
  tunecap = AS3935.registerRead(AS3935_TUN_CAP); //Internal calibration
  Serial.print(“Tuning cap register is“);
  Serial.println(tunecap);

  AS3935.enableDisturbers();
  printAS3935Registers();
  // AS3935IrqTriggered = 0;
}
void loop() {

  delay(1000);
  Serial.println(“Waiting...”);
  if (counter == 0) {
    NumDisturber = 0;
    counter = NoDetect;
    clearLCD();
    lcdPosition(0, 1);
    LCD.print(“No lightining”);
    lcdPosition(1, 4);
    LCD.print(“detected”);
  } else {
    counter = counter - 1;
  }
}

void printAS3935Registers() {
  int noiseFloor = AS3935.getNoiseFloor();
  int spikeRejection = AS3935.getSpikeRejection();
  int watchdogThreshold = AS3935.getWatchdogThreshold();
  Serial.print(“Noise floor is: “);
  Serial.println(noiseFloor, DEC);
  Serial.print(“Spike rejection is: “);
  Serial.println(spikeRejection, DEC);
  Serial.print(“Watchdog threshold is: “);
  Serial.println(watchdogThreshold, DEC);
}

// this is implementation of SPI transfer that gets passed to AS3935
{
  return SPI.transfer(sendByte);
}

void AS3935Irq() {

  int irqSource = AS3935.interruptSource();
  // returned value is bitmap field, bit 0 - noise level too high, bit 2 - disturber detected, and finally bit 3 - lightning!
  if (irqSource & amp; 0b0001)
    Serial.println(“Noise level too high,
      try adjusting noise floor”);
  if (irqSource & amp; 0b0100) {
    NumDisturber += 1;
    Serial.println(“Disturber detected”);
    clearLCD();
    lcdPosition(0, 0);
    LCD.print(“Disturb.Det: “);
    LCD.print(NumDisturber, DEC);
    counter = NoDetect;
  }
  if (irqSource & amp; 0b1000) {
    // need to find how far that lightning stroke, function returns approximate distance in kilometers,
    // where value 1 represents storm in detector’s near victinity, and 63 - very distant, out of range stroke
    // everything in between is just distance in kilometers
    int strokeDistance = AS3935.lightningDistanceKm();
    if (strokeDistance == 1) {
      Serial.println(“Storm overhead, watch out!”);
      lcdPosition(1, 1);
      Serial.println(“Storm overhead”);
      lcdPosition(1, 3);
      Serial.println(“WATCH OUT!”);
      counter = NoDetect;
    }

    if (strokeDistance == 63) {
      Serial.println(“Out of range lightning detected.”);
      lcdPosition(0, 2);
      Serial.println(“Out of range”);
      lcdPosition(1, 0);
      Serial.println(“lightning detect”);
      counter = NoDetect;
    }

    if (strokeDistance & lt; 63 & amp; & amp; strokeDistance & gt; 1) {
      Serial.print(“Lightning detected“);
      Serial.print(strokeDistance, DEC);
      Serial.println(“kilometers away.”);
      lcdPosition(1, 0);
      LCD.print(“Distance: “);
      LCD.print(strokeDistance, DEC);
      LCD.print(“km”);
      counter = NoDetect;
    }
  }
}

Prevedere i fulmini con Arduino

Il progetto che vi proponiamo di realizzare consta sostanzialmente di tre elementi: il sensore di fulmini, disponibile su breakout board, una scheda Arduino Uno o Fishino Uno, il cui compito è analizzare il segnale fornito dal sensore ed elaborarlo per poi mostrare sul display LCD (che è il terzo elemento circuitale) le informazioni che ne desume, vale a dire il numero di scariche elettriche rilevate che si possono ritenere “figlie” di un temporale e la distanza stimata.

Negli esempi scaricabili troverete lo sketch per gestire il sensore fulmini con Arduino e visualizzare i dati rilevati su un display seriale o I2C.

Il tutto dev’essere collegato come mostrato nel disegno di cablaggio visibile in queste pagine, dove la breakout board sensore fulmini si interfaccia ad Arduino tramite il connettore dell’ICSP, grazie al fatto che quest’ultimo veicola il bus SPI completo, ossia a 4 linee.

La connessione con la breakout board avviene sfruttando le linee del bus SPI riportate sul connettore ICSP; ci sono poi GND (la massa) e Vcc (collegato al +5V) con cui la scheda prende l’alimentazione da Arduino.

Il CS (attivo a livello logico zero) viene gestito dal digital I/O 3 di Arduino, impostato dallo sketch come uscita e l’IRQ della breakout board è invece interfacciato al digital I/O 2, inizializzato come input, dato che, nello specifico, IRQ avvisa Arduino o un eventuale microcontrollore interfacciato all’integrato o alla sua breakout board che può leggere il contenuto del registro.

Quando IRQ torna a zero logico è prevista una pausa di almeno 2 ms prima della lettura del registro.

Per la gestione del sensore fulmini da Arduino allo scopo di leggere i dati rilevati, è stata utilizzata una libreria sviluppata da un appartenente alla community (Raivis Rengelis) e scaricabile da github.

La gestione è affidata a uno sketch il cui codice riportiamo nel Listato 1.

Quanto al display LCD seriale, è collegato ad Arduino tramite i contatti 5V e GND per l’alimentazione e il digital I/O 5, impostato come uscita, che invia i dati serialmente al contatto RX dell’LCD.
Il progetto mostra come leggere i dati rilevati dalla breakout, in particolare viene rilevato un eventuale temporale mostrando l’indicazione su un display LCD a comunicazione seriale.

Normalmente viene mostrata l’indicazione del temporale rilevato con il numero di rilevamenti negli ultimi 60 secondi. Se entro 60 secondi non avvengono altri rilevamenti, allora viene mostrata l’indicazione a display “No lightining detected” (Fig. 1). Se nel registro dell’integrato è disponibile la distanza di rilevamento, allora viene mostrato anche questo dato nella seconda riga del display, con un messaggio del tipo:

Disturb Det. x

dove al posto di “x” è indicato quante scariche sono state rilevate. Sotto, appare la scritta (Fig. 2):

Distance: n km

dove viene indicata, al posto di “n” la distanza stimata da dove è scoccato il fulmine. Se la distanza è inferiore al minimo, il display mostra nella prima riga Storm overhead e nella seconda WATCH OUT!

Fig. 2 Rilevamento di 11 fulmini a una distanza stimata di 20 km.

Piano di montaggio

Elenco Componenti:

R1÷R4: 10 kohm (0603)
C1: 1 μF ceramico (0603)
C2: 100 nF ceramico (0603)
C3: 10 μF ceramico (0603)
C4: 680 pF ceramico (0603)
C5: 270 pF ceramico (0603)
L1: MA5532-AEB
U1: AS3935-BQFT
Varie:
- Strip maschio 2 vie (2 pz.)
- Strip maschio 7 vie
- Jumper (2 pz.)
- Circuito stampato S1324 (26x26 mm)

I componenti vanno disposti seguendo il piano di montaggio che trovate in queste pagine, dove potete vedere il giusto orientamento di quelli polarizzati; fate attenzione a non surriscaldare la bobina, onde evitare che si sciolga lo smalto e che venga pregiudicato l’isolamento.

Tutti gli elementi vanno montati sul lato superiore. Il componente più critico è l’integrato AS3935, incapsulato in contenitore 16LD MLPQ (quadrato da 4×4 mm di lato) che a stretto rigore andrebbe montato con una stazione ad aria calda per il rework degli SMD, dopo aver stagnato e cosparso con il flussante le rispettive piazzole; con un po’ di attenzione e manualità è possibile saldarlo, una volta compiute le predette operazioni, mediante il classico saldatore, avendo cura di toccare i pad lateralmente (il risultato non sarà lo stesso ma funzionerà ugualmente).

Terminate le saldature e verificato che sia tutto a posto, chiudete il ponticello JSI e lasciate aperto JCS, giacché all’impostazione del Chip Select provvederà Arduino.

Ora prendete in mano lo schema di cablaggio e, con dei cavetti jumper, collegate tra loro Arduino, il display e la breakout board secondo quanto indicato. Ricordate che l’alimentazione per l’insieme si fornisce in un unico punto, ossia sul connettore jack di Arduino Uno, mediante un alimentatore da 9 volt, capace di erogare 300 mA.

Prima di dare alimentazione collegate alla presa USB di Arduino un cavo USB A/B che dall’altro lato inserirete in una presa USB del vostro computer, nel quale avrete avuto cura di installare l’IDE Arduino (va bene qualsiasi versione tra quelle uscite negli ultimi due anni); aprite quindi il file contenente lo sketch, che dovrete aver copiato nella cartella dell’IDE insieme alla libreria, quindi effettuate il download in Arduino. Fatto ciò, staccate il PC e alimentate la vostra Arduino con l’alimentatore, verificando che il display si accenda e mostri i messaggi: inizialmente e in assenza di attività, apparirà il messaggio No lightning detected.

Se volete effettuare un test spicciolo del sistema, procuratevi un accendigas piezoelettrico (quelli a scintilla) e, mantenendolo a mezzo metro di distanza dalla breakout board premete più volte il pulsante per far scoccare qualche scintilla: il display dovrebbe mostrare il segnale Disturb. Det. con un numero che si aggiorna man mano che premete.

Con questo avete collaudato, seppure in maniera empirica, il sistema e siete certi che funzionerà in campo. Per un utilizzo più pratico inserite il tutto in un contenitore in plastica, lavorato per far uscire il display e rendere accessibile il jack di alimentazione di Arduino. La breakout board mettetela sotto al coperchio, fissandola con del silicone sigillante; evitate le viti, che potrebbero interferire, a meno di non utilizzare quelle in teflon.

Non utilizzate contenitori metallici perché schermerebbero la bobina ricevente della breakout board, con le conseguenze immaginabili, ossia il circuito non potrà rilevare alcun fulmine.

Ultima nota: lo sketch di Arduino prevede attualmente che per lo stadio RF sia impostato il guadagno corrispondente all’utilizzo all’esterno, come evidenziato nella riga di codice AS3935.setOutdoors();.

Se desiderate la modalità indoor, perché utilizzate il circuito in casa, dovete cambiare tale riga in AS3935.setIndoor();.

Bene, detto ciò possiamo concludere ricordandovi che il progetto, come tutti quelli open, può essere personalizzato da ognuno di voi al bisogno.

Sketch di esempio sensore fulmini

1 file(s) 8.71 KB

Per il download di questo file è necessario essere registrati al sito

Login