MONITORAGGIO AREE PROTETTE del GFA con BLUETOOTH   

Il seguente " monitoraggio e controllo  "  è puramente didattico e ... fantasioso( ma realizzabile)

    La scelta del " Giardino di flora appenninica di Capracotta" è stata di puro campanilismo. 

Si utilizzerà l'uso di un sistema bluetooth da smartphone e tablet Android.

    Sfruttando le potenzialità dei vari ESP32 collegati singolarmente a sensori di varia natura : :

• Temperatura
• Umidità dell'aria
• Umidità del terreno
• Livello (Pozzetto/serbatoio acqua sorgente, livello superficiale stagno, ecc..
• Portata delle fontane
• Cicalino per la segnalazione di criticità autonomo
• ecc...

Quando si vuole realizzare un progetto è indispensabile definire quali GPIO devono essere utilizzati.

Metodo personale di programmazione:

• Compilazione della Lista di Occupazione
• Eseguo tanti TEST singoli per ogni componente da utilizzare
• Inserisco sempre un contatore se nel programma è presente un invio dati (XBEE -  Lora -Bluetooth - ecc..)
• Poi assemblo il tutto....

Non utilizzo GPIO relativi per future applicazioni es. LCD, SD,GPS,ecc.

Es.: Lista di Occupazione personale(Reminescenza di programmazione P.L.C. Lab. Automazione I.T.I.S.)

Per limitare al minimo il consumo di energia elettrica posso sfruttare alcune peculiarità dell'ESP32, es:

• la modalità di SLEEPING (addormentare il sistema) secondo varie modalità
• la modalità di RISVEGLIO ( con un timer, con un segnale esterno, con un touch su piastrina, ecc..)

e monitorare le aree sottoposte a sorveglianza, rispettando  la "privacy"  della flora e della fauna.

  Ogni singolo ESP32 è preposto alla sorveglianza di un'area ben definita.

Variante di controllo e programmi desunti dai link:

Circolo Didattico Capracotta: Monitoraggio dei parametri naturali ed ambientali di uno stagno.

MONITORAGGIO  e CONTROLLO delle AREE PROTETTE (es.. Giardino della Flora Appenninica di Capracotta)

Monitoraggio,didattico, di un bacino naturale di contenimento per la raccolta delle acque piovane al fine di ridurre i fenomeni torrenziali distruttivi.

1° TEST  con relativa procedura di :

•   INSTALLAZIONE APPLICAZIONE  Serial Bluetooth Terminal
•  ACCOPPIAMENTO dei Bluetooth Tablet e ESP32

Rilevamento:

• temperatura ed umidità ambientale

N.B. I Sensori alimentati dal modulo ESP32 .... devono essere del tipo a 3.3 Vcc.

AZDelivery Scheda di Sviluppo ESP32-WROOM 38 Pin

N.B. I Sensori alimentati dal modulo ESP32 devono essere del tipo a 3.3 Vcc.

Il modulo sensore ad ultrasuoni  HC-SR04-P : il campo di alimentazione è compreso tra 3.3v e 5v a differenza dell' HC-SR04 che è alimentato solo da 5v.

Collegamenti  Trasmittente  ESP32- Sensore ad ultrasuoni HC-SR04 P:

GPIO 12 dell'ESP32 (Verde)  al pin TRIG  

GPIO 14 dell'ESP32 (Blu)      al pin ECHO  

Il modulo sensore di umidità e temperatura DHT11 : il campo di alimentazione è compreso tra 3.3v e 5v

Out  ==> GPIO  27  dell'ESP32

Supporto del trasmettitore stampato con l'ANYCUBIC Mega S

La trasmissione DATI con i moduli BLUETOOTH è contenuta nel raggio di azione max  di 10 m(senza ostacoli).

• Serial Bluetooth Terminal  da Play Store del nostro sistema Android

Fatta l'installazione ci prepariamo il programma per l'ESP32.

Trasmissione dati punto a punto.

1° Test di simulazione  su ESP32 - Temperatura e Umidità ambientale su Monitor P.C.:

// Test di simulazione facsimile Arduino

// Esercitazione con Tablet Android 14 4 2024
// File:BLUETOOTH_DHT11_ESP32_11_4_2024
// IDE:Arduino 1.8.14
// SCHEDA:ESP32-WROOM DA-Module

#include "BluetoothSerial.h"
BluetoothSerial Stagno;
#include "DHT.h"
//Uso del PIN 27 dell’ ESP32
#define DHTPIN 27
#define DHTTYPE DHT11
//creatae una instanza del sensore DHT11
DHT dht(DHTPIN, DHTTYPE);
int cont = 1;
void setup()
{
Serial.begin(115200);
delay(500);
Serial.println("DHT11 sensor!");
//Abilito la lettura dal sensore
dht.begin();

Stagno.begin("ESP32-Stagno");

//N.B. Sul tab comparirà  ESP32-Stagno  da accoppiare
}

void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(h) || isnan(t)) {
Serial.println("Lettura fallita dal sensore!!!!");
return;
}

// Stampo il risultato sul Monitor P.C.
String msg ="Gradi: " + String(t) + " Umidità: " + String( h) + "%"  +  " Cont.  :"  + String(cont);
Serial.println(msg);
Stagno.println(msg);

delay(1000);

cont++
}

Questo è il risultato sul Monitor:

ACCOPPIAMENTO DEI DISPOSITIVI BLUETOOTH:

In questa fase l'ESP32 deve essere alimentato.

TABLET ANDROID PERSONALE:

ATTIVARE IL BLUETOOTH

leggero touch prolungato su: Bluetooth

touch su: + Accoppia nuovo dispositivo

 touch su: ESP32-Stagno

touch su: ACCOPPIA

Risultato: Presenza del dispositivo  ESP32-Stagno

Prossimo passaggio:

touch su: Serial Bluetooth Terminal

touch su: le tre lineette orizzontali lato SX

touch su: Devices

 Elenco dei Devices

touch su: ESP32-Stagno   e si attiva

ulteriore touch su: ESP32-Stagno    e.....

Questo è il risultato

2° Test di simulazione  su ESP32  con il modulo sensore ad ultrasuoni  HC-SR04-P

// Esercitazione con Tablet Android 14 4 2024
// File:BLUETOOTH_ESP32_HC_SR04_BLUETOOTH_14_4_2024
// IDE:Arduino 1.8.14
// SCHEDA:ESP32-WROOM DA-Module

#include "BluetoothSerial.h"
BluetoothSerial Stagno;
#define TRIG_PIN 12  // ESP32 pin GPIO 12
#define ECHO_PIN 14 // ESP32 pin GPIO 14

int cont = 1;

float durata_us, distanza_cm;

void setup() {
Serial.begin (115200);
pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);

Stagno.begin("GFA-Stagno");

// GFA-Stagno da ACCOPPIARE su TAB
}

void loop() {
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);

durata_us = pulseIn(ECHO_PIN, HIGH);

// calcolo della distanza
distanza_cm = 0.017 * durata_us;

// Stampa sul serial Monitor
//Serial.print("distanza: ");
//Serial.print(distanza_cm);
//Serial.println(" cm");
String msg ="Distanza cm.: " + String(distanza_cm) +  " Cont.  :"  + String(cont); ;
Stagno.println(msg);
delay(500);

cont++;
}

Questo è il risultato sul tab dopo l'accoppiamento:

 Test  COMPLETO :

// Esercitazione con Tablet Android 18 4 2024
// File:BLUETOOTH_DHT11_ HC-SR04-P ESP32_18_4_2024
// IDE:Arduino 1.8.14
// SCHEDA:ESP32-WROOM DA-Module

//******* BLUETOOTH **************
#include "BluetoothSerial.h"
BluetoothSerial Stagno;
//********************************

//******* DHT **************
#include "DHT.h"
//Uso del GPIO 27 dell’ ESP32
#define DHTPIN 27
#define DHTTYPE DHT11
//creata una instanza del sensore DHT11
DHT dht(DHTPIN, DHTTYPE);
//********************************

//***** HC-SR04-P 3.3 Volt *********
#define TRIG_PIN 12 // ESP32 pin GPIO 12
#define ECHO_PIN 14 // ESP32 pin GPIO 14
float durata_us;
float distanza_cm;
//********************************

//***** Contatore *********
int cont = 1;
//*************************


void setup()
{
Serial.begin(115200);
pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);

Serial.println("DHT11 sensor!");

//******************************
//Abilito la lettura dal sensore
dht.begin();
//********************************


// ****** Definizione del Begin *********
Stagno.begin("GFA-Stagno");
//N.B. Sul tab comparirà ESP32-Stagno da accoppiare
//********************************
}

void loop() {
// ******* PARAMETRI DHT11 **********
float h = dht.readHumidity();
float t = dht.readTemperature();

// ****** Verifico se è attiva la lettura *********
//if (isnan(h) || isnan(t)) {
//Serial.println("Lettura fallita dal sensore!!!!");
//return;

// ******* PROCEDURA PER L'HC-SR04-P **********
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);

durata_us = pulseIn(ECHO_PIN, HIGH);
delay(100);
// calcolo della distanza
distanza_cm = 0.017 * durata_us;
//**** TERMINE PROCEDURA CALCOLO HC-SR04-P **********


// **** DEFINIZIONE DELLE STRINGHE DA INVIARE ****************
String msg ="Gradi: " + String(t) + " Umidità: " + String( h) + "%" ;
String msg1 ="Distanza cm.: " + String(distanza_cm) + "  Cont. :" + String(cont);
String msg2 ="                    " ;
Serial.println(msg);
Serial.println(msg1);
Serial.println(msg2);

// ******* INVIO DATI AL TABLET **********
Stagno.println(msg);
Stagno.println(msg1);
Stagno.println(msg2);

delay(1000);
cont++;
}

QUESTO E' IL RISULTATO FINALE

Test di simulazione  con ESP32 e rilevatore di distanza laser.

Massima distanza rilevabile con il LIDAR 12 metri.

Rilevare la distanza dal pelo superficiale dell'acqua.

Distanza max  (dist + prof) = 8 metri

// File:BLUETOOTH_LIDAR_ESP32_28_4_2024
// IDE:Arduino 1.8.14
// SCHEDA:ESP32-WROOM DA-Module
// con oled 164x48

// ***** LIBRERIA E DEFINIZIONE BLUETOOTH ******
#include "BluetoothSerial.h"
BluetoothSerial Stagno;
// ************************************

// ***** COLLEGAMENTI GPIO LIDAR ******
#define RXD2 16 // VERDE del LIDAR al GPIO 16 DELL'esp32
#define TXD2 17 // BIANCO del LIDAR al GPIO 17 dell'ESP32
// ************************************

int dist; /*—actual distance measurements of LiDAR—*/
int strength; /*—signal strength of LiDAR */
float temprature;
unsigned char check; /*—save check value */
int i;
unsigned char uart[9]; /*—save data measured by LiDAR */
const int HEADER=0x59; /*—frame header of data package */
int rec_debug_state = 0x01;//receive state for frame

//***** Contatore *********
int cont = 1;
//*************************

void setup() {
delay(2000);
Serial.begin(115200);
Serial.println("\nBenewake TFmini-PLUS UART LiDAR Program");
Serial2.begin(115200);

// ****** Definizione del Begin STAGNO *********
Stagno.begin("GFA-Stagno");
//N.B. Sul tab comparirà GFA-Stagno da accoppiare
//********************************


}
void loop() {
Get_Lidar_data();
String msg ="Distanza cm.: " + String(dist) + " Cont. :" + String(cont);
String msg2 =" " ;

// ****INVIO MESSAGGI TRAMITE BLUETOOTH ***********
Stagno.println(msg);
Stagno.println(msg2);
//************************************
delay(100);
cont++;
}

// ****DEFINIZIONE PROCEDURA LETTURA LIDAR ***********
void Get_Lidar_data(){

if (Serial2.available()) //check if serial port has data input
{
if(rec_debug_state == 0x01)
{ //the first byte
uart[0]=Serial2.read();
if(uart[0] == 0x59)
{
check = uart[0];
rec_debug_state = 0x02;
}
}
else if(rec_debug_state == 0x02)
{//the second byte
uart[1]=Serial2.read();
if(uart[1] == 0x59)
{
check += uart[1];
rec_debug_state = 0x03;
}
else{
rec_debug_state = 0x01;
}
}
else if(rec_debug_state == 0x03)
{
uart[2]=Serial2.read();
check += uart[2];
rec_debug_state = 0x04;
}
else if(rec_debug_state == 0x04)
{
uart[3]=Serial2.read();
check += uart[3];
rec_debug_state = 0x05;
}
else if(rec_debug_state == 0x05)
{
uart[4]=Serial2.read();
check += uart[4];
rec_debug_state = 0x06;
}
else if(rec_debug_state == 0x06)
{
uart[5]=Serial2.read();
check += uart[5];
rec_debug_state = 0x07;
}
//Benewake
else if(rec_debug_state == 0x07)
{
uart[6]=Serial2.read();
check += uart[6];
rec_debug_state = 0x08;
}
else if(rec_debug_state == 0x08)
{
uart[7]=Serial2.read();
check += uart[7];
rec_debug_state = 0x09;
}
else if(rec_debug_state == 0x09)
{
uart[8]=Serial2.read();
if(uart[8] == check)
{
dist = uart[2] + uart[3]*256;//the distance
strength = uart[4] + uart[5]*256;//the strength
temprature = uart[6] + uart[7] *256;//calculate chip temprature
temprature = temprature/8 - 256;
Serial.print("dist = ");
Serial.print(dist); //output measure distance value of LiDAR
Serial.print('\n');
//Benewake
Serial.print("strength = ");
Serial.print(strength); //output signal strength value
Serial.print('\n');
Serial.print("\t Chip Temprature = ");
Serial.print(temprature);
Serial.println(" celcius degree"); //output chip temperature of Lidar

while(Serial2.available()){Serial2.read();}

}
rec_debug_state = 0x01;
}
}
}

   RISULTATO FINALE su SMARTPHONE:

TEST con SLEEP da TIMER  e uso del Bluetooth:

Collegamenti  Trasmittente  ESP32- Sensore ad ultrasuoni HC-SR04 P:

GPIO 12 dell'ESP32 (Verde)  al pin TRIG  

GPIO 14 dell'ESP32 (Blu)     al pin ECHO  

GPIO 27 dell'ESP32  al LED di segnalazione trasmissione (acceso in trasmissione)

N.B.  Il   void loop() {} nella fase di SLEEP  non è contemplato

Tutte le istruzione del programma devono essere presenti nel :

void setup() {

.........

while((millis() <30000))
{

Corpo principale di calcolo

}

Ecco un esempio per :

la trasmissione dati Bluetooth e Sleeping

• Per 30 secondi trasmetto i dati
• Per 40 secondi vado in letargo

// IDE:Arduino 1.8.14
// SCHEDA:ESP32-WROOM DA-Module
//FILE:TEST__BLUETOOTH__E_SHRC_SLEEP_ESP32_23_4_2024


const uint32_t SLEEP_DURATA = 40 *1000000;//40 SECONDI DORME

//******* BLUETOOTH **************
#include "BluetoothSerial.h"
BluetoothSerial Stagno;
//********************************

//***** HC-SR04-P 3.3 Volt *********
#define TRIG_PIN 12 // ESP32 pin GPIO 12
#define ECHO_PIN 14 // ESP32 pin GPIO 14
float durata_us;
float distanza_cm;
//********************************

//***** Contatore *********
int cont = 1;
//*************************


void setup() {

pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);

// ****** Definizione del Begin STAGNO *********
Stagno.begin("GFA-Stagno");
//N.B. Sul tab comparirà ESP32-Stagno da accoppiare
//********************************

pinMode(27,OUTPUT);
delay(100);
digitalWrite(27,1);

Serial.begin(115200);
//Serial.println( "light sleep");
delay(1000);

while((millis() <30000))
{

// ******* PROCEDURA PER L'HC-SR04-P **********
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);

durata_us = pulseIn(ECHO_PIN, HIGH);
delay(100);
// calcolo della distanza
distanza_cm = 0.017 * durata_us;
//**** TERMINE PROCEDURA CALCOLO HC-SR04-P **********
String msg1 ="Distanza cm.: " + String(distanza_cm) + " Cont. :" + String(cont);

Serial.println(msg1);
cont++;
Serial.println("SONO SVEGLIO");
Stagno.println(msg1);
delay(5);
}


Serial.println( "VADO IN LETARGO");
delay(100);
esp_sleep_enable_timer_wakeup(SLEEP_DURATA);
esp_deep_sleep_start();
Serial.println("Wakeup");
}
void loop() {}

Questo è il risultato:

Consumi durante la Trasmissione e Sleeping:

Le FASI operative dell'ESP32 sono definite dalle due righe del programma:

• const uint32_t SLEEP_DURATA = 40 *1000000;// 40 secondi

         Corrisponde a 40 secondi di ibernazione dell' ESP32

........................

• while((millis() <30000))

 Corrisponde a 30 secondi di attività  operativa dell' ESP32

L'ibernazione  può essere molto dilatata nel tempo  (anche ore e giornate)

Se ho la necessità di interrogare il "sistema" posso intervenire al "risveglio" utilizzando dei componenti esterni:

• un pulsante
• un sistema touch (pulsante a sfioramento) tramite una piastrina es.. alluminio.
• ecc..

Durante questa modalità di SLEEPING (DEEP SLEEP MODE)  solo alcuni pin GPIO sono utilizzabili .

CONTINUA.....