Ciao a tutti!
Volevo chiedere una informazione in merito ad un progetto che sto realizzando per rilevare i fulmini tramite un sensore AS3935.
In particolare l'anomalia che riscontro è che quando alimento la scheda esp8266 il codice non si avvia quasi mai al primo tentativo, ma devo resettare la scheda o togliere e ridare alimentazione e resettare perchè il tutto prenda il via.
Poi una volta partito il sistema funziona correttamente senza problemi.
Ho provato anche a cambiare scheda ed il problema persiste.
A cosa potrebbe essere dovuto?
Nel prossimo post provo anche a pubblicare il codice incriminato.
#include <SPI.h>
#include <AS3935.h>
#include <ESP8266WiFi.h> //per gestire WifiClientSecure
#include <WiFiClient.h> //per gestire la connessione alla rete Wifi
//dati per la connessione alla rete Wifi
const char* MY_SSID = "xxx";
const char* MY_PWD = "xxx";
//dati per la connessione ad xxx.it
const char* host = "xxx";
const uint16_t port = 443;
//dati sensore fulmini AS3935
int valore_calibrazione; //valore calibrazione
void printAS3935Registers(); //funzione che rileva e stampa i parametri del sensore (rumore di fondo, spike rejection, soglia di controllo)
byte SPItransfer(byte sendByte); //funzione che si occupa del traferimento dei dati via SPI
void AS3935Irq(); //funzione che verifica se ci sono disturbi o fulmini e causa l'interrupt
AS3935 AS3935(SPItransfer,D4,D3); //primo parametro: funzione per il trasferimento dei dati via SPI
//secondo parametro: pin CS collegato alla scheda
//terzo parametro:pin IRQ collegato alla scheda
//impostazione avvio millis per lettura sensore
unsigned long tempo_start_lettura_sensori = millis();
unsigned long intervallo_lettura_sensori = 600000; //effettuiamo una lettura dei sensori ogni 600 secondi (10 minuti)
float numero_fulmini = 0; //numero fulmini rilevati
float distanza_fulmini = 0; //distanza fulmini
float disturbi_rilevati = 0; //numero disturbi rilevati
void setup()
{
//inizializzazione seriale
Serial.begin(9600);
//connessione Wifi
connectWifi();
//setup sensore fulmini AS3935
SPI.begin();
SPI.setDataMode(SPI_MODE1);
SPI.setClockDivider(SPI_CLOCK_DIV16);
SPI.setBitOrder(MSBFIRST);
AS3935.reset(); //ripristina tutti i valori di registro interni ai valori predefiniti
delay(100);
AS3935.setOutdoors(); //setta il sensore per il funzionamento all'esterno
AS3935.registerWrite(AS3935_NF_LEV,2); //scrive 2 nel Noise Level register
//se il sensore non riesce a stare nel range di tolleranza la calibrazione non andrà a buon fine e restituirà false
if(!AS3935.calibrate()) {
//Serial.println("La calibrazione non è andata a buon fine, controllare il cablaggio");
}
valore_calibrazione=AS3935.registerRead(AS3935_TUN_CAP); //il range è compreso tra 0 e 15
//Serial.print("La calibrazione rilevata è (range concesso tra 0 e 15): ");
//Serial.println(valore_calibrazione);
AS3935.enableDisturbers(); //turn on indication of distrubers, once you have AS3935 all tuned, you can turn those off with disableDisturbers()
printAS3935Registers(); //rileva e stampa i parametri del sensore (rumore di fondo, spike rejection, soglia di controllo)
attachInterrupt(digitalPinToInterrupt(D3), AS3935Irq, RISING);
//usare interrupt significa che non serve controllare lo stato del pin continuamente, lo fa il chip da solo
}
void loop(){
//reset di tempo_start_lettura_sensori in caso di overflow di millis che si azzera
if (millis()-tempo_start_lettura_sensori<0) {
tempo_start_lettura_sensori = millis();
}
if ((millis()-tempo_start_lettura_sensori) > intervallo_lettura_sensori){
tempo_start_lettura_sensori = millis();
//collegamento all'host
WiFiClientSecure client;
client.setInsecure(); //non si utilizzano certificati di sicurezza
//Serial.println(host);
//Serial.println(port);
//verifica se il collegamento non è andato a buon fine
if (!client.connect(host, port)) {
delay(5000);
return;
}
//se la connessione all'host è avvenuta
if (client.connected()) {
distanza_fulmini = distanza_fulmini / numero_fulmini;
String var="numero_fulmini=" + String(numero_fulmini) + "&distanza_fulmini=" + String(distanza_fulmini) + "&disturbi_rilevati=" + String(disturbi_rilevati);
String url = "GET /aggiungi_fulmini.php?" + var + " HTTP/1.1";
//Serial.println(url);
//invio url all'host per il salvataggio dei dati sul database mysql
client.println(url);
client.println("Host: www.xxx.it");
client.println("Access-Control-Allow-Origin: *");
client.println("Connection: close");
client.println();
client.stop();
}
//azzeramento delle variabili per il prossimo ciclo di rilevamento
numero_fulmini=0;
distanza_fulmini=0;
disturbi_rilevati=0;
//Serial.println("AZZERAMENTO EFFETTUATO");
}
}
void printAS3935Registers()
{
int noiseFloor = AS3935.getNoiseFloor();
int spikeRejection = AS3935.getSpikeRejection();
int watchdogThreshold = AS3935.getWatchdogThreshold();
//Serial.print("Il rumore di fondo è: ");
//Serial.println(noiseFloor,DEC);
//Serial.print("Lo spike rejection è: ");
//Serial.println(spikeRejection,DEC);
//Serial.print("La soglia di controllo è: ");
//Serial.println(watchdogThreshold,DEC);
}
byte SPItransfer(byte sendByte)
{
return SPI.transfer(sendByte);
}
ICACHE_RAM_ATTR void AS3935Irq() //ICACHE_RAM_ATTR serve per caricare nella ram altrimenti con esp non funzionano gli interrupt
{
//verifica cosa ha causato l'interrupt
//appena leggiamo l'interrupt, il pin IRQ diventa LOW
int irqSource = AS3935.interruptSource(); //restituisce bit 0: livello rumore troppo alto
// bit 2: rilevato disturbo
// bit 3: rilevato fulmine
//if (irqSource & 0b0001){ //rumore troppo alto
// Serial.println("Livello rumore troppo alto");
//}
if (irqSource & 0b0100){ //rilevato disturbo
//Serial.println("Disturbo rilevato");
disturbi_rilevati=disturbi_rilevati+1; //aumenta di 1 il contatore dei disturbi rilevati
}
if (irqSource & 0b1000){ //rilevato fulmine
int distanza_fulmine = AS3935.lightningDistanceKm(); //determina la distanza del fulmine in km
if (distanza_fulmine < 41 && distanza_fulmine > 0) //40 km è la distanza di rilevamento massima
{
//Serial.print("Fulmine rilevato a ");
//Serial.print(distanza_fulmine,DEC);
//Serial.println(" km");
numero_fulmini= numero_fulmini+1; //aumenta di 1 il contatore dei fulmini rilevati
distanza_fulmini=distanza_fulmini+distanza_fulmine; //somma tutte le distanze dei fulmini rilevati per fare al termine del ciclo una media
}
}
}
//funzione per la connessione alla rete wifi
void connectWifi()
{
//WiFi.persistent(false);
//WiFi.mode(WIFI_OFF);
//WiFi.mode(WIFI_STA);
WiFi.begin(MY_SSID, MY_PWD);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
}
//Serial.println("CONNESSO");
}
P.S.: ... ma ormai gli ESP32 costano come i vecchi ESP8266 ... perché continuate ad usare vecchie schede invece di passare a schede più performanti e con più pin disponibili ?
Con Interrupt posso usare qualsiasi altro pin senza problemi?
Se posso chiedere, per cultura personale, come mai si deve evitare di utilizzare D3 e D4?
In merito al motivo per cui uso questa scheda è semplicemente perchè ne avevo già in casa da diverso tempo.
Ho effettuato la modifica consigliata utilizzando questa volta i pin D1 e D2 e dopo alcune prove ora il codice sembra avviarsi correttamente.
Terrò monitorata la situazione.
e ... in futuro, ricorda che è meglio orientarsi sugli ESP32 che sui vecchi ESP8266 