MURO DI CONTENIMENTO SOTTOPOSTO A SPINTA       

  Il LiDAR è un metodo di telerilevamento che utilizza un raggio laser pulsante per misurare distanze.

 Tramite una scansione angolare( orizzontale e verticale ) posso tenere sotto controllo tutta la superficie del muretto a secco.

 Sfruttando la modalità di generazione di nuvole di punti 3D(xyz) per la ricostruzione di una superficie costantemente posso

verificare se qualche area dello stato iniziale del muro sta subendo un "ingobbimento".

CALCOLO MATEMATICO vedere Link: https://xoomer.virgilio.it/ditellamario/lidar2.htm

Prototipo da realizzare:

Per realizzare il sistema di rilevamento per generare una nuvola di punti utilizzerò le seguenti tecnologie:

TFMini Plus Lidar

• Frequenza di aggiornamento: fino a 1000 Hz    default 100 Hz
• Interfaccia: I2C o UART
• distanza massima 12 metri

TFMini Plus Lidar (Rilevatore di distanza Laser)

• Frequenza di aggiornamento: fino a 1000 Hz    default 100 Hz
• Interfaccia: I2C o UART
• distanza massima 12 metri

Test di funzionamento con ESP32  LIDAR e LCD OLED:

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 

Test di rilevamento di una distanza con un ESP a 30 PIN.

PIN  GPIO:

OLED :   21 (SDA)  e   22 (SCL)               Alimentazione 3.3 Volt dalla scheda

LIDAR: Verde 16 (RXD2)   Bianco 17( TXD2)   Alimentazione 5 Volt  dalla scheda

// 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:

RIFERIMENTO di un ESP32 completo:

Per ogni scheda  WIFI LoRa32(V2) e LILYGO®TTGO LoRa32 V2.1 1.6.1 versione 433Mhz vengono proposti test progressivi modulari.

Questa modalità di programmazione mi permette di finalizzare l'attenzione sul singolo processo:

• oled
• trasmissione
• ricezione
• memorizzazione

Il modulo sopra esposto verrà utilizzato come TRASMETTITORE  per:

• trasmissione delle coordinate XYZ della nuvola di punti generati dal sensore Lidar
• e pilotaggio dei motori passo passo tramite shield

 Considerazioni personali sull'utilizzo del modulo WIFI LoRa 32(V2) che utilizzo per la trasmissione dati.

ESP32 ha 3 interfacce hardware seriali.

Per collegare il LIDAR 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.

Con la libreria aggiuntiva HardwareSerial, che fa parte del pacchetto hardware per la scheda ESP32-LoRa, è possibile definire interfacce hardware seriali personali.

Ecco la funzione .begin () della libreria HardwareSerial.

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

HardwareSerial mySerial2(2);

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

void setup () {
mySerial2.begin(115200,SERIAL_8N1,2,17);

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

Definisco l'interfaccia hardware seriale 2 con 115200 baud e 8 bit senza parità 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.

Test di ESEMPIO LIDAR e LORA:

//File:LIDAR_LORA_25_OTTOBRE_2022
//SCHEDA:Heltec Wifi LoRa 32
//IDE:Arduino 1.8.14
#include "heltec.h"
HardwareSerial mySerial2(2);
int cont =0;
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


#define BAND 433E6 //BANDA EUROPEA
void setup () {
Serial.begin(115200);
mySerial2.begin(115200,SERIAL_8N1,2,17);


Heltec.begin(true, true, true, true, BAND);
LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST);// MAX POTENZA
}
void loop () {
Get_Lidar_data();
Get_Lidar_display();
Get_Lidar_Packet();
delay(5);
cont++;
}

//***** INIZIO VOID GET_LIDAR_DATA *****************

void Get_Lidar_data(){
// display.init();
//display.clear();

if ( mySerial2.available()) //check if serial port has data input
{
if(rec_debug_state == 0x01)
{ //the first byte
uart[0]= mySerial2.read();
if(uart[0] == 0x59)
{
check = uart[0];
rec_debug_state = 0x02;
}
}
else if(rec_debug_state == 0x02)
{//the second byte
uart[1]= mySerial2.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]= mySerial2.read();
check += uart[2];
rec_debug_state = 0x04;
}
else if(rec_debug_state == 0x04)
{
uart[3]= mySerial2.read();
check += uart[3];
rec_debug_state = 0x05;
}
else if(rec_debug_state == 0x05)
{
uart[4]= mySerial2.read();
check += uart[4];
rec_debug_state = 0x06;
}
else if(rec_debug_state == 0x06)
{
uart[5]= mySerial2.read();
check += uart[5];
rec_debug_state = 0x07;
}
//Benewake
else if(rec_debug_state == 0x07)
{
uart[6]= mySerial2.read();
check += uart[6];
rec_debug_state = 0x08;
}
else if(rec_debug_state == 0x08)
{
uart[7]= mySerial2.read();
check += uart[7];
rec_debug_state = 0x09;
}
else if(rec_debug_state == 0x09)
{
uart[8]= mySerial2.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

String myStr;
myStr = String(dist);

//display.drawString(32, 28, myStr);
//display.display();
while( mySerial2.available()){ mySerial2.read();}

}
rec_debug_state = 0x01;
}
}
}
//***** FINE VOID GET_LIDAR_DATA *****************

//***** INIZIO VOID GET_LIDAR_DISPLAY *****************
void Get_Lidar_display() {
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, 34, "Dist. cm. ");
Heltec.display->drawString(42, 34, String(dist));
Heltec.display->drawString(70,34, "Cnt.");
Heltec.display->drawString(94,34, String(cont));
Heltec.display->drawString(0, 48, "Temp. Gradi: ");
Heltec.display->drawString(96,48, String(temprature));
//Heltec.display->drawString(0,54, "Umidità’ %: ");
//Heltec.display->drawString(96,54, String(h));
Heltec.display->display();
}
//***** FINE VOID GET_LIDAR_DISPLAY *****************


//***** INIZIO VOID GET_LIDAR_PACKET *****************

void Get_Lidar_Packet() {
//***************************************
//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();
//******************************************

}
//***** FINE VOID GET_LIDAR_PACKET *****************

E QUESTO è IL RISULTATO:

Shield per il pilotaggio dei motori passo passo con driver A4988 o A8825

Test di ESEMPIO LIDAR e LORA CON TRASMISSIONE:

//File:LIDAR_LORA_SEND_23_OTTOBRE_2022
//SCHEDA:Heltec Wifi LoRa 32
//IDE:Arduino 1.8.14
#include "heltec.h"
HardwareSerial mySerial2(2);
int cont =0;
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


#define BAND 433E6 //BANDA EUROPEA
void setup () {
Serial.begin(115200);
mySerial2.begin(115200,SERIAL_8N1,2,17);


Heltec.begin(true, true, true, true, BAND);
Serial.begin(9600);
LoRa.setTxPower(20,RF_PACONFIG_PASELECT_PABOOST);// MAX POTENZA
}
void loop () {
Get_Lidar_data();
Get_Lidar_display();
Get_Lidar_Packet();
delay(1000);
cont++;
}

//***** INIZIO VOID GET_LIDAR_DATA *****************

void Get_Lidar_data(){
// display.init();
//display.clear();

if ( mySerial2.available()) //check if serial port has data input
{
if(rec_debug_state == 0x01)
{ //the first byte
uart[0]= mySerial2.read();
if(uart[0] == 0x59)
{
check = uart[0];
rec_debug_state = 0x02;
}
}
else if(rec_debug_state == 0x02)
{//the second byte
uart[1]= mySerial2.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]= mySerial2.read();
check += uart[2];
rec_debug_state = 0x04;
}
else if(rec_debug_state == 0x04)
{
uart[3]= mySerial2.read();
check += uart[3];
rec_debug_state = 0x05;
}
else if(rec_debug_state == 0x05)
{
uart[4]= mySerial2.read();
check += uart[4];
rec_debug_state = 0x06;
}
else if(rec_debug_state == 0x06)
{
uart[5]= mySerial2.read();
check += uart[5];
rec_debug_state = 0x07;
}
//Benewake
else if(rec_debug_state == 0x07)
{
uart[6]= mySerial2.read();
check += uart[6];
rec_debug_state = 0x08;
}
else if(rec_debug_state == 0x08)
{
uart[7]= mySerial2.read();
check += uart[7];
rec_debug_state = 0x09;
}
else if(rec_debug_state == 0x09)
{
uart[8]= mySerial2.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');
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
String myStr;
myStr = String(dist);
while( mySerial2.available()){ mySerial2.read();}
}
rec_debug_state = 0x01;
}
}
}
//***** FINE VOID GET_LIDAR_DATA *****************

//***** INIZIO VOID GET_LIDAR_DISPLAY *****************
void Get_Lidar_display() {
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, "Distanza. cm. ");
Heltec.display->drawString(90, 26, String(dist));
Heltec.display->drawString(0, 40, "Contatore.");
Heltec.display->drawString(90, 40, String(cont));
Heltec.display->display();
}
//***** FINE VOID GET_LIDAR_DISPLAY *****************


//***** INIZIO VOID GET_LIDAR_PACKET *****************

void Get_Lidar_Packet() {
//***************************************
LoRa.beginPacket();
LoRa.println(( "Dist. cm. ")+String(dist)+(" "));
LoRa.println(("cont. ")+String(cont));
LoRa.endPacket();
//******************************************

}
//***** FINE VOID GET_LIDAR_PACKET *****************

e OK continua..... Da definire quale scheda sarà preposta al calcolo matematico tridimensionale
 

*************************************************************************************

Il modulo LILYGO LORA32 V2.1.1.6 (sottostante) sarà utilizzato come RICEVITORE per la memorizzazione della nuvola di punti.

LILYGO®TTGO LoRa32 V2.1 1.6.1 versione 433Mhz ESP32 LoRa OLED  0.96" scheda SD modulo Wireless WIFI ESP-32 SMA

*************************************************************************************

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

• i pin da 34 - 35 - 36 e 39 sono attivi solo come INPUT (possono essere utilizzati anche come RX)
• i pin   00 - 04 - 25  sono disponibili come INPUT/OUTPUT

Selezionare la scheda: TTGO LoRa32-OLED v2.1.6

 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
}

Ecco il risultato:

2° TEST: Memorizzazione su SD (microSD SanDisk Ultra 16 GB) senza visualizzazione su OLED:

// FILE: TEST_LORA_LILYGO_V2_1_6_CON_SD_CONTATORE 7_OTTOBRE_2022
// Scheda:TTGO LoRa32-OLED V2.1.6
#include <mySD.h>
#include <SPI.h>
File Dati;// Variabile di tipo dati
int k =0; // Contatore conteggio temperature
String Buffer="";// Buffer per la scrittura dei dati
void setup(){
Serial.begin(115200);
if (!SD.begin(13,15,2,14)) {
Serial.println("initialization failed!");
return;
}
}
void loop ()
{
Buffer="";//Nuovo giro, stringa vuota!
k=k+1;
Serial.print( " ");

//Serial.println();
Buffer +=(" ");
Buffer += k;
Buffer +=(" lettura ");

Dati = SD.open("datalog.txt", FILE_WRITE);// apriamo il file in scrittura
if (Dati) {
Dati.println(Buffer);
Dati.close();
Serial.print ("HO MEMORIZZATO ");
Serial.println(k);
Serial.println(Buffer);
Serial.println();
}
else {
Serial.println("Errore nell'apertura del file datalog.txt");
}
delay(3000);
}

Ecco il risultato:

3° TEST: Memorizzazione dati su SD con visualizzazione su OLED:

// FILE:LORA_LILYGO_V2_1_6_SD_OLED_CONT_8_OTTOBRE_2022
// Scheda:TTGO LoRa32-OLED V2.1.6
// Arduino 1.8.14

// Libreria per SD
#include <mySD.h>
#include <SPI.h>

// Libreria per display OLED
#include <Wire.h>
#include "SSD1306.h"

SSD1306 display(0x3c, 21, 22);

File Dati;// Variabile di tipo dati
int k =0; // Contatore conteggio temperature
String Buffer="";// Buffer per la scrittura dei dati
void setup(){
// set reset oled
pinMode(16,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);
if (!SD.begin(13,15,2,14)) {
Serial.println("initialization failed!");
return;
}
display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_10);
}
void loop ()
{
Buffer="";//Nuovo giro, stringa vuota!
k=k+1;
Serial.print( " ");

//Serial.println();
Buffer +=(" ");
Buffer += k;
Buffer +=(" lettura ");

Dati = SD.open("datalog.txt", FILE_WRITE);// apriamo il file in scrittura
if (Dati) {
Dati.println(Buffer);
Dati.close();
Serial.print ("HO MEMORIZZATO ");
Serial.println(k);
Serial.println(Buffer);
Serial.println();
}
else {
Serial.println("Errore nell'apertura del file datalog.txt");
}
delay(1000);
display.clear();
display.setTextAlignment(TEXT_ALIGN_LEFT);
display.setFont(ArialMT_Plain_10);

display.drawString(0, 0, "Ho memorizzato: ");
display.drawString(90, 0, String(k));
display.display();
}
Ecco il risultato:

Continua:

//TEST DI SIMULAZIONE SENZA LIDAR
// SI UTILIZZA LA FUNZIONE RANDOM E BREAK
//FILE:SIMULAZIONE LIDAR_22_2_2022_SD_BREAK
//SIMULAZIONE CON UNO STEP ANGOLARE 1.8°/4 =0.45°
//Buffer1 =" 240 "; nr. punti per VISICAD
// DATI PER FUNZIONAMENTO LCD
//******* LCD *********************************
// ********************************************
#include <SD.h>
File Dati;//Variabile di tipo dati
const int chipSelect =10;
String Buffer="";// Buffer per la scrittura dati
String Buffer1=" 240";
#define EN 8
#define X_stepPin 5
#define X_dirPin 2
#define M1M2Pin 4
float Hxz = 0;
float angstart = 54;// Angolo iniziale su piano XY
float angXY =0.45;//valore dell'angolo ad ogni di step
float angXZ = 0;
long unsigned int dist = 0;
//****** CALCOLO STEP SUL PIANO XY 54°x2 =108° *****
int STEP = 240;//step per angolo piano XY =>108°
//400:180° = 360:x° 400 step =>180° 360 step =>162°
//400:180° = Xstep:108° Xstep=> 400 x 108°/180° = 240 step
//****************************************************
//****** CALCOLO STEP SUL PIANO XZ *****
int STEPZ = 20;// step per l'alzo piano XZ => 9°
// 200 step:90° = Xstep:72° X= 160 step
//54° =120 step 63°=140 step 81°=180 step
//18° =40 step 9°= 20 step
//****************************************************
int speedMotor = 8000;
float anfXY =0;
float anfXYr =0;// radiante
float OMr =0;//
float OM =0;// proiezione DISTANZA
float NM = 0;// DISTANZA Y+
float ON =0 ;// DISTANZA X

void setup() {
randomSeed(analogRead(0));

Serial.begin(9600);
Serial.print("\nSto verificando la presenza della scheda...\n");
pinMode(10,OUTPUT);// Fa funzionare la SD
if(!SD.begin(chipSelect))
{
Serial.println("SD Card non trovata");
return;
}
else {
Serial.println("Scheda inserita e funzionante");
Serial.println();
}
pinMode(X_stepPin, OUTPUT);
pinMode(X_dirPin, OUTPUT);
pinMode(M1M2Pin, OUTPUT);
pinMode(EN, OUTPUT);
digitalWrite(X_dirPin, HIGH);
digitalWrite(M1M2Pin, HIGH);
digitalWrite(X_stepPin, LOW);
digitalWrite(EN, LOW);
Dati=SD.open("lidar.txt",FILE_WRITE);//open file in lettura
if (Dati) {
Dati.println(Buffer1);
Dati.close();
}
}
void loop() {
int kk;
for (kk=0; kk<STEPZ; kk++) {

int j;
for (j=0; j<STEP; j++) {
// *********************************
// SIMULAZIONE LETTURA DEL LASER TRA 18 m. a 11 m.
dist= random(18000);// *************************


// *********************************
float anfXY = (angstart - (angXY * j));
digitalWrite(X_stepPin, HIGH);
delayMicroseconds(speedMotor);
digitalWrite(X_stepPin, LOW);
delayMicroseconds(speedMotor);
//******** VISUALIZZAZIONE DATI SU LCD***************

//*******************************************************

//******* CALCOLO Z DEL PUNTO PM Hxz******
//***** CONVERSIONE IN RADIANTI ******
OMr = (angXZ * 3.14)/180;// ANGOLO XZ radiante
Hxz = (dist/1000) * sin(OMr);
//***********************************************

// ***** CALCOLO DEL SEGMENTO OM *****
OM = (dist/1000) * cos(OMr);

//***** CONVERSIONE IN RADIANTI ANGOLO anfXYr
anfXYr = (anfXY * 3.14)/180;// ANGOLO XY radiante
// ********* SEGMENTO NM COORDINATA Y **********
NM = (dist/1000) * sin(anfXYr);

// ***********************************************

// ********* SEGMENTO ON COORDINATA X **********
ON= (dist/1000) * cos(anfXYr);

//***********************************************
delay(200);
Buffer ="";
Buffer +=(" ");
Buffer +=ON;// ****SEGMENTO ON
Buffer +=(" ");
Buffer +=NM;// ****SEGMENTO NM
Buffer +=(" ");
Buffer +=Hxz;

Dati=SD.open("lidar.txt",FILE_WRITE);// Open file
if (Dati) {
Dati.println(Buffer);
Dati.close();

}
else {
Serial.println("Errore nell'apertura del file datalog.txt");
}
}
//**************************************
// TERMINA LA SPAZZOLATA SUL PIANO XY
// *************************************

delay(50);
//******************************************
// RITORNA INDIETRO AL PUNTO DI PARTENZA ******
digitalWrite(X_dirPin, LOW);
int jj;
for (jj=0; j<STEP; jj++) {
digitalWrite(X_stepPin, HIGH);
delayMicroseconds(speedMotor);
digitalWrite(X_stepPin, LOW);
delayMicroseconds(speedMotor);
}
delay(150);
//********************************
// INCREMENTO L'ALZO SUL PIANO XZ
angXZ = angXZ + 0.45;
//if (alzo = 80) then (alzo =0);

digitalWrite(X_dirPin, HIGH);
delay(200);
Dati=SD.open("lidar.txt",FILE_WRITE);// WRITE Buffer1
if (Dati) {
Dati.println(Buffer1);
Dati.close();

}
}
//***** ARDUINO SI FERMA AL TERMINE DELLO STEPZ

{
if (kk == STEPZ)
{

exit(0);
}
}
//****** TERMINE PROCEDURA

}