LONG RANGE
La maggior parte delle aree rurali e boschive, in molti casi, sono sprovviste di internet "libero".
La trasmissione dati, in parte, può essere risolta con l'uso della tecnologia LoRa.
Utilizzo di due moduli per la Trasmissione/ Ricezione LoRa
TX: ESP32 LoRa V2 433 Mhz OLED a 0,96" RX: ESP32 LoRa V2.1 rev. 1.6 433 Mhz SD OLED a 0,96"
N.B.
Caratteristiche elettroniche di ogni singolo Pin dell'ESP32:
I Sensori alimentati dal modulo LoRa devono essere del tipo a 3.3 Vcc.
Questo è un esempio.
Es.: Copertura territoriale con un Range di 7 km:
L'uso di due antenne:
permettono di raggiungere un range di circa 10 km.(senza ostacoli)
Antenna omnidirezionale ground plane 433MHz Antenna direzionale YAGI 433MHz
Specifiche PINOUT dei due moduli:
TX: ESP32 LoRa V2 433 Mhz WIFI OLED a 0,96"
Modulo TRASMETTITORE.
Considerazioni personali sull'utilizzo del modulo WIFI LoRa 32(V2) che utilizzo per la trasmissione dati.
ESP32 ha 3 interfacce hardware seriali.
Per collegare es.: un GPS ad una seriale hardware del modulo WIFI LoRa 32(V2) devo definire una seriale personale,ecco perchè.
L'interfaccia seriale standard 0,collegata ai Pin GPIO3 (RX) e GPIO1 (TX), viene utilizzata per la comunicazione con l'IDE Arduino ed è permanentemente cablata al CP2102.
L'interfaccia seriale 1 dell'ESP 32 normale è collegata ai pin GPIO9 (RX) e GPIO10 (TX).
I pin GPIO9 (RX) e GPIO10 (TX) non sono presenti sul modulo WIFI LoRa 32(V2).
Sul modulo WIFI LoRa 32(V2) i Pin 9 e 10 vengono utilizzati per controllare la memoria flash e pertanto non sono accessibili.
L'interfaccia seriale 2 è normalmente collegata ai pin GPIO16 (RX) e GPIO17 (TX).
Il pin GPIO16 è collegato al ripristino del display OLED , se utilizzato in un programma il display rimane scuro
Si constata dalla figura del Pinout Diagram del modulo WIFI LoRa 32(V2) che:
i pin 4 - 15 - 16 sono utilizzati per l'OLED
Non bisogna utilizzare il controller SSD1306.
N.B. La libreria #include "heltec.h" gestisce il buon funzionamento e collegamenti :
dei PIN della scheda LoRa
dei Pin dell'OLED.
Cambiano i comandi per gestire l'OLED rispetto ai comandi del controller SSD1306.
es.
....................
Heltec.display->clear();
Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
Heltec.display->setFont(ArialMT_Plain_10);
.......
Heltec.display->drawString(96,48, String(temprature));
Heltec.display->drawString(0,54, "Umidità’ %: ");
Heltec.display->drawString(96,54, String(h));
Heltec.display->display();
.............
i pin da 32 a 39 sono attivi solo come INPUT (possono essere utilizzati anche come RX)
i pin 22 - 23 - 2 - 17 - 25 - 12 - 13 sono disponibili come INPUT/OUTPUT
Bene, la soluzione al mio problema è molto semplice (momentaneamente prendo a prestito i pin 2 e 17).
In seguito utilizzerò un pin arbitrario come RX dal blocco 32-39 per avere a disposizione 7 pin come OUTPUT.
..................
#define SERIAL1_RX 2 // TX del GPS -> al PIN
2 dell'ESP32
#define SERIAL1_TX 17 // RX del GPS_-> al PIN 17 del'ESP32
.........
void setup () {
..........
Serial1.begin(9600, SERIAL_8N1, SERIAL1_RX, SERIAL1_TX);
Heltec.begin(1,1,1,1, BAND);
LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST);
..............................
Definisco l'interfaccia la Serial1 con 9600 baud e 8 bit senza parità(N) più 1 bit di stop sui pin GPIO 2 (RX) e GPIO 17 (TX).
Il chip ESP32 è in grado di collegare le interfacce hardware seriali (UARTS) a quasi tutti i pin IO.
La trasmissione dal GPS è costituita da:
Una stringa è costituita da alcuni blocchi alfabetici separati dal simbolo virgola.
SIGNIFICATO:
Interpretazione dei valori da assegnare alla latitudine e longitudine desunti dalla stringa:
La LATITUDINE (Altezza) varia da 0° a 90° pertanto occorre selezionare i primi due caratteri per i gradi
La LONGITUDINE(Orizzontale) varia da 0 a 180° pertanto occorre selezionare i primi tre caratteri per i gradi
Attenzione all'ORA DI RICEZIONE:
E' riferita all'ora di GREENWICH - Aggiungere 1 per ora legale
TEST di visualizzazione dati GPS sulla Serial Monitor e OLED
SCHEDA:ESP32 LoRa V2 433 Mhz WIFI OLED a 0,96"
TX del GPS ==> PIN 2 del'ESP32
RX del GPS ==> PIN 17 del'ESP32
TABELLA DI RIFERIMENTO DEI CAMPI:
TEST DI LETTURA:
//FILE:HELTEC_V2_GPS_13_FEBBRAIO_2023_FUNZIONANTE_CON_heltec_oled
//SCHEDA da impostare :Heltec WiFi Lora 32
// anche se è la scheda ver.2
// IDE arduino 1.8.12
#include "heltec.h"
#define BAND 433E6
#define SERIAL1_RX 2 // TX del GPS -> al PIN
2 dell'ESP32
#define SERIAL1_TX 17 // RX del GPS_-> al PIN 17 del'ESP32
String read_sentence;
void setup() {
Serial.begin(115200);
Serial.println("TTGO GPS TEST");
delay(2000);
Serial1.begin(9600, SERIAL_8N1, SERIAL1_RX, SERIAL1_TX);
Heltec.begin(1,1,1,1, BAND);
LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST);
}
void loop() {
Get_Gps_data();
}
//******************INIZIO VOID GET_GPS_DATA * ******************
// Dati da visualizzare vedere la numerazione dei campi della tabella
soprastante
void Get_Gps_data(){
read_sentence = Serial1.readStringUntil(13); //13 = return (ASCII)
read_sentence.trim();
if (read_sentence.startsWith("$GPRMC")) {
String gps_ora = sentence_sep(read_sentence, 1); //Orario
String gps_lat = sentence_sep(read_sentence, 3); //Latitudine
String gps_lat_o = sentence_sep(read_sentence, 4); //Orientamento (N or S)
String gps_lon = sentence_sep(read_sentence, 5); //Longitudine
String gps_lon_o = sentence_sep(read_sentence, 6); //Orientamento (E or W)
String gps_dat = sentence_sep(read_sentence, 9); //DATA
Heltec.display->clear();
Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
Heltec.display->setFont(ArialMT_Plain_10);
Heltec.display->drawString(0, 0, "Giardino Flora Appenninica");
//Heltec.display->drawString(0, 12, " C A P R A C O T T A ");
Heltec.display->drawString(0, 12, "ORA ");
Heltec.display->drawString(24, 12,gps_ora);
Heltec.display->drawString(0,24, "LAT");
Heltec.display->drawString(24,24, gps_lat);
Heltec.display->drawString(0, 32, "LON ");
Heltec.display->drawString(24,32, gps_lon);
Heltec.display->drawString(0,40, "DATA: ");
Heltec.display->drawString(32,40, gps_dat);
Heltec.display->display();
Serial.print("ORA: ");
Serial.print(gps_ora);
Serial.print(" ");
Serial.print("LAT: ");
Serial.print(gps_lat);
Serial.print("LON: ");
Serial.print(gps_lon);
Serial.print("DATA ");
Serial.println(gps_dat);
delay(2000);
}
}
String sentence_sep(String input, int index) {
int finder = 0;
int strIndex[] = { 0, -1 };
int maxIndex = input.length() - 1;
for (int i = 0; i <= maxIndex && finder <= index; i++) {
if (input.charAt(i) == ',' || i == maxIndex) { //',' = separator
finder++;
strIndex[0] = strIndex[1] + 1;
strIndex[1] = (i == maxIndex) ? i + 1 : i;
}
}
return finder > index ? input.substring(strIndex[0], strIndex[1]) : "";
}
Questo è il risultato:
Modulo RICEVITORE.
Considerazioni personali sull'utilizzo del modulo WIFI LoRa 32( V2.1 rev. 1.6) che utilizzo per la ricezione dati.
Si constata dalla figura del Pinout Diagram del modulo TTGO LORA32 V2.1_1.6 che:
i pin 21 - 22 - 16 sono utilizzati per l'OLED
Il pin GPIO16 è collegato al ripristino del display OLED , se utilizzato in un programma il display rimane scuro
i pin 13 - 15 - 14 - 02 sono utilizzati per la memorizzazione dei dati su SD CARD
i pin 26 - 23 - 18 - 5 -27 - 19 sono utilizzati per la trasmissione LoRa
Attenzione: la numerazione della Breakout Board non è uguale a quella della scheda LoRa.
Per permettere il "passaggio" dell'attacco SMA dell'antenna è stata eliminata, dalla rastrelliera di collegamento a vite, la parte finale del PIN 25.
Se necessario, verrà utilizzato l'attacco femmina del pin 25,come si evince dalla figura.
Con una nuova installazione dell'IDE di Arduino , in questo caso la 1.8.14 può darsi che selezionando Strumenti
non sia presente l'indicativo ESP32 Arduino per la selezione dei molteplici moduli ESP32.
Ecco un ripasso, per la mia memoria, per una futura installazione.
ALLORA: File ==> Impostazioni...
Digitare nel box dell'URL dove andare a cercare le schede ESP32 per l'installazione:
https://dl.espressif.com/dl/package_esp32_index.json
POI: Strumenti ==> Scheda:... ==> Gestore schede....
Nel Box di ricerca scrivere: esp32 ed installare quella evidenziata
Si ritorna in Strumenti e compare la riga di selezione delle schede:
E compare l'elenco delle molteplici schede ESP32 a disposizione:
Scheda da selezionare da Strumenti dall'IDE di Arduino (in fondo alla lista).
Se il sistema operativo non riconosce la scheda è necessario installare il driver per la comunicazione seriale scheda /P.C.
dal sito : www.silabs com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers
Il :CP210xVCPInstaller_x64.exe
Poi:
1° TEST: Trasmissione con visualizzazione su OLED:
//
FILE:TRASMISSIONE_CONTATORE_CON__TTGOLORA32_V1_6_OTTOBRE_2022
//SCHEDA: TTGO LoRa32-OLED v2.1.6
#include <SPI.h>
#include <LoRa.h>
#include <Wire.h>
#include "SSD1306.h"
//#include "images.h"
#define SCK 5 // GPIO5 -- SX1278's SCK
#define MISO 19 // GPIO19 -- SX1278's MISnO
#define MOSI 27 // GPIO27 -- SX1278's MOSI
#define SS 18 // GPIO18 -- SX1278's CS
#define RST 23 // GPIO14 -- SX1278's RESET
#define DI0 26 // GPIO26 -- SX1278's IRQ(Interrupt Request)
#define BAND 433E6
unsigned int counter = 0;
SSD1306 display(0x3c, 21, 22);
String rssi = "RSSI --";
String packSize = "--";
String packet ;
void setup() {
pinMode(16,OUTPUT);
pinMode(2,OUTPUT);
digitalWrite(16, LOW); // set GPIO16 low to reset OLED
delay(50);
digitalWrite(16, HIGH); // while OLED is running, must set GPIO16 in high
Serial.begin(115200);
while (!Serial);
Serial.println();
Serial.println("LoRa Sender Test");
SPI.begin(SCK,MISO,MOSI,SS);
LoRa.setPins(SS,RST,DI0);
if (!LoRa.begin(433E6)) {
Serial.println("Starting LoRa failed!");
while (1);
}
//LoRa.onReceive(cbk);
// LoRa.receive();
Serial.println("init ok");
display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_10);
delay(1500);
}
void loop() {
display.clear();
display.setTextAlignment(TEXT_ALIGN_LEFT);
display.setFont(ArialMT_Plain_10);
display.drawString(0, 0, "Sending packet: ");
display.drawString(90, 0, String(counter));
Serial.println(String(counter));
display.display();
// send packet
LoRa.beginPacket();
LoRa.print("hello ");
LoRa.print(counter);
LoRa.endPacket();
counter++;
digitalWrite(25, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(25, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Questo è il risultato:
TEST TRASMISSIONE - RICEZIONE
Applicazioni personali nel campo naturalistico:
Trasmissione dati punto a punto.
Primo test:(distanza di circa 5 km.)
Si utilizzano i medesimi programmi utilizzati per il controllo dello stagno del Giardino di Flora Appennica.
Trasmittente con Sensore ad ultrasuoni puntato verso il comignolo .
Segnala una distanza di 357 centimetri.
Ricevente in prossimità ricovero Monte Forte :
Primo test perfettamente riuscito.
Continua.....
Applicazione con relè:
Per rendere indipendente il segnale di pilotaggio proveniente dalla scheda (ESP32, ecc..) bisogna rimuovere il cappuccio come evidenziato in figura.
MONITORAGGIO dello STAGNO del GFA con i moduli LoRa
Esercitazione didattica:
Monitoraggio dello stagno del 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.
Miglioramenti desunti dal link:Circolo Didattico Capracotta: Monitoraggio dei parametri naturali ed ambientali di uno stagno
Rilevamento altezza di sicurezza dello stagno.
La trasmissione DATI con i moduli XBEE è contenuta nel raggio di azione max di 1.5 km(senza ostacoli).
La trasmissione DATI con i moduli LoRa è contenuta nel raggio di azione max di 5 km(senza ostacoli).
Con opportune antenne, applicate ai moduli LoRa, posso raggiungere un raggio di azione max di circa 16 km.
Come modulo Trasmittente e ricevente utilizzerò:
Per le sue caratteristiche Link: LoRa: Modulo SX1276 V2 Lora ESP32 LX6
IMPORTANTE: I GPIO con asterisco sono solo di INPUT es.: GPIO38* - GPIO36* - ecc..
Supporto del trasmettitore stampato con l'ANYCUBIC Mega S
N.B. I Sensori alimentati dal modulo LoRa 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 - Sensore ad ultrasuoni HC-SR04 P:
Pin 12 dell'ESP32 (Verde) al pin TRIG
Pin 13 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 ==> Pin 17 dell'ESP32
Trasmissione dati punto a punto.
1° Test di simulazione :Visualizzazione della distanza con il sensore ad ultrasuoni su Monitor P.C ed OLED :
// Test di simulazione facsimile Arduino con la trasmissione DATI
#include "heltec.h"
#include "Ultrasonic.h"
Ultrasonic ultrasonic(12,13); //Trig==> 12 Echo==> 13
String distanza;
#define BAND 433E6
void setup () {
Heltec.begin(true, true, true, true, BAND);
Serial.begin(9600);
}
void loop () {
Heltec.display->clear();
Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
Heltec.display->setFont(ArialMT_Plain_10);
Heltec.display->drawString(0, 0, "Distanza cm.: "); //COMPARE SULLA TRASMITTENTE
Heltec.display->drawString(31, 10, String(distanza)); //COMPARE SULLA TRASMITTENTE
// SPOSTATO A DX DI 31 PIXEL ED IN BASSO DI 10 PIXEL
Heltec.display->display();
LoRa.beginPacket();
Serial.print("Dist. cm.:");
Serial.println(distanza);
distanza=ultrasonic.read();
LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST); // MAX POTENZA
LoRa.print(distanza);
LoRa.endPacket();
digitalWrite(25, HIGH);
delay(400);
digitalWrite(25, LOW);
delay(400);
}
ECCO IL RISULTATO:
....................................................................................................................................................................................
2° Test di simulazione su ESP32 - HELTEC:Temperatura e Umidità ambientale su Monitor P.C.:
// Test di simulazione facsimile Arduino
#include "DHT.h"
//Uso del PIN 17 dell’ ESP32 dell’Heltec
#define DHTPIN 17
#define DHTTYPE DHT11
//creatae una instanza del sensore DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup()
{
Serial.begin(115200);
Serial.println("DHT11 sensor!");
//Abilito la lettura dal sensore
dht.begin();
}
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.
Serial.print("Umidità: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperatura: ");
Serial.print(t);
Serial.println(" *C ");
delay(2000);
}
ECCO IL RISULTATO:
.........................................................................................
MODULO TRASMETTITORE:(Supporto stampato con l'ANYCUBIC Mega S)
Viene utilizzato un contatore per verificare il corretto funzionamento della trasmissione e ricezione.
Programma completo di TRASMISSIONE dati:
#include "heltec.h"
#include "Ultrasonic.h"
Ultrasonic ultrasonic(12,13);// 12 Trigg. e 13 Echo
int distanza;
int cont =0;
#include "DHT.h"
//Uso del PIN 17 dell’ ESP32 dell’Heltec
#define DHTPIN 17
#define DHTTYPE DHT11
//creatae una instanza del sensore DHT11
DHT dht(DHTPIN, DHTTYPE);
#define BAND 433E6
void setup () {
dht.begin();
Heltec.begin(true, true, true, true, BAND);
Serial.begin(9600);
LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST);// MAX POTENZA
}
void loop () {
float h = dht.readHumidity();
float t = dht.readTemperature();
delay(4000);
distanza=ultrasonic.read();
Heltec.display->clear();
Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
Heltec.display->setFont(ArialMT_Plain_10);
Heltec.display->drawString(0, 0, "Giardino Flora Appenninica");
Heltec.display->drawString(0, 12, " C A P R A C O T T A ");
Heltec.display->drawString(0, 26, "Dist. cm. ");
Heltec.display->drawString(42, 26, String(distanza));
Heltec.display->drawString(76, 26, "Cnt.");
Heltec.display->drawString(102, 26, String(cont));
Heltec.display->drawString(0, 40, "Temp. Gradi: ");
Heltec.display->drawString(96, 40, String(t));
Heltec.display->drawString(0, 54, "Umidità’ %: ");
Heltec.display->drawString(96, 54, String(h));
Heltec.display->display();
//***************************************
LoRa.beginPacket();
LoRa.print(( "Dist. cm. ")+String(distanza)+(" "));
LoRa.println(("cont. ")+String(cont));
LoRa.println(("Temp. Gradi ")+String(t));
LoRa.println(("Umidità % ")+String(h));
LoRa.endPacket();
//******************************************
digitalWrite(25, HIGH);
delay(400);
digitalWrite(25, LOW);
delay(400);
cont++;
}
.........................................................................................
.........................................................................................
MODULO RICEVENTE:(Supporto stampato con l'ANYCUBIC Mega S)
Programma completo di RICEZIONE DATI:
#include "heltec.h"
#define BAND 433E6
String DATI;
void setup () {
Serial.begin(115200);
Heltec.begin(true, true, true, true, BAND);
//LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST);// MAX POTENZA
}
void loop () {
int packetSize = LoRa.parsePacket();
if(packetSize) {
Serial.print("Dato ricevuto ");
while(LoRa.available ()) {
DATI = LoRa.readString ();
Serial.println(DATI);
Heltec.display->clear();
Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);
Heltec.display->setFont(ArialMT_Plain_10);
Heltec.display->drawString(0, 0, "Giardino Flora Appenninica");
Heltec.display->drawString(0, 12, " C A P R A C O T T A ");
Heltec.display->drawString(0, 26,DATI);
Heltec.display->display();
}
}
digitalWrite(25, HIGH);
delay(200);
digitalWrite(25, LOW);
delay(1000);
}
.........................................................................................
Assorbimento durante la trasmissione DATI. (mi serve per i calcoli)
La scansione dei dati avviene dopo ogni 50' per la durata di 10 ' (Totale 1 ora)
Durante i 50' di "sleeping" il consumo di energia dell'ESP8266- E12 è circa 0.36 mA (per riattivare il microprocessore).
Durante i 10' "attivi" il consumo di energia dell'ESP8266- E12 è circa 20 mA.
Durante i 10' "attivi" il consumo di energia sulla bobina del relè è circa 61 mA.
Durante i 10' di TRASMISSIONE dati da parte del modulo Lora ESP32 il consumo di energia è di circa 130 mA.
Assorbimento orario teorico totale 130 + 20 + 61 + 0.36 = 212 mA.
212 / 6 = 35 mA. per sicurezza aumentiamo di un 30% circa 50 mA durante i 10 minuti di trasmissione dati.
In una giornata avremo un assorbimento di circa 50 mA x 24 h = 1.2 A
Si utilizzano 2 pannellini fotovoltaici (per la ricarica di una Powerbank Solare 26800 mAh)
1 Pannello solare 5V 500 mAh 2.5W
I pannelli possono essere collegati in parallelo o in serie.
In serie avremo 10 V e 500 mAh
In parallelo avremo 5V e 1000 mAh
Prendo come spunto il maggior irraggiamento solare ,sia per il periodo estivo che invernale:
un arco temporale tra le ore 10.00 alle ore 16.00 6 ore di carica
Ipotizzo un coefficiente di sicurezza di carica pari al 70%
In serie avremo 350 mAh x 6 h = circa 2000 mAh e 10 V
In parallelo avremo 700 mAh x 6 h = circa 4200 mAh (se i pannelli generano 5 Volt)
Superficie trattata UV e scheda PCB resistente alle intemperie
I pannellini saranno utilizzati come copertura del tettuccio della casetta degli uccellini
Powerbank Solare 26800 mAh da coimbentare opportunamente all'interno della casetta.
Sono necessari anche dei passacavi per antenna e cavi di alimentazione.
COLLEGAMENTI ELETTRONICI
Il collegamento sull'ESP D0 con il RESET va effettuato dopo avere caricato il programma di temporizzazione.
Posizionare in OFF lo switch durante la fase di di programmazione e download del programma.
Posizionare in ON lo switch per l'inizio della temporizzazione.
Programma del test di sleeping:
Es: ESP.deepSleep( 60e6); corrisponde a 60000000 microsecondi che è uguale a 1 minuto
E' possibile riattivare ESP8266 con una pressione di un pulsante o da un sensore (è necessario un opportuno circuito elettronico)
In questo caso l'ESP8266 va messo in sleeping per un periodo di tempo indefinito ed impostare il pin RST su BASSO e poi riattivarlo.
Adesso utilizzo anche una sonda impermeabile per rilevare la temperatura dei liquidi : DS18B20
Utilizzo lo stesso programma installato su Arduino.
Collegamento simile a quello effettuato con Arduino, ma a 5 volt.
E' necessaria una resistenza di PULL UP da 4.7 k ohm.
Rilevamento pratico:
SISTEMA LIDAR
Il LiDAR è un metodo di telerilevamento che utilizza un raggio laser pulsante per misurare distanze.
TFMini Plus Lidar
ESP32 UTILIZZATO (30 pin)
N.B. Non bisogna confondere la numerazione dei PIN dell'ESP con la numerazione dei GPIO.
N.B.Nella programmazione si utilizza la numerazione dei GPIO.
N.B. I pin GPIO non tollerano i 5 volt , sono 3,3 volt per logica ALTA (1).
PIN GPIO:
OLED 21 e 22
LIDAR 16 e 17 RXD2 e TXD2 (Verde e Bianco)
Secondo test di funzionamento con ESP32 LIDAR e LCD OLED:
// File:LIDAR_ESP32_18_GIUGNO_2022
// con oled 164x48
#include <Wire.h>
#include "SSD1306.h"
SSD1306 display(0x3c, 21, 22);
#define RXD2 16
#define TXD2 17
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
void setup() {
delay(2000);
Serial.begin(115200);
Serial.println("\nBenewake TFmini-PLUS UART LiDAR Program");
Serial2.begin(115200);
//******************************************************************
//Next section includes processing LiDARs Data and printing it to the terminal.
display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_10);
}
void loop() {
Get_Lidar_data();
}
void Get_Lidar_data(){
// display.init();
display.clear();
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
display.setTextAlignment(TEXT_ALIGN_LEFT);
display.setFont(ArialMT_Plain_16);
display.drawString(0, 0, "DISTANZA cm. ");
display.setFont(ArialMT_Plain_24);
String myStr;
myStr = String(dist);
display.drawString(32, 28, myStr);
display.display();
while(Serial2.available()){Serial2.read();}
}
rec_debug_state = 0x01;
}
}
}
Questo è il risultato
.........................................
CONTINUA.....