PILOTARE MOTORE PASSO con L298N

Strumenti di progettazione e realizzazione pratica dei componenti:

Sistema CAD: VISICAD per la progettazione di tutti i componenti di supporto

STAMPA 3D:ANYCUBIC MEGA S

Lavorazioni meccaniche:Tornio SOGI M1-250 Fresatrice 3D (Fresatrice realizzata dallo scrivente)

MATEMATICA: Le coordinate sferiche (XYZ) -(un pò di matematica non guasta)

Per determinare le coordinate 3D del punto P è necessario fare riferimento ai due piani cartesiani XZ e XY .

Con il piano cartesiano

XZ mi calcolo la coordinata Z del punto P
XY mi calcolo le coordinate X e Y del punto P rispetto all'origine.

Esempio pratico

Dati iniziali noti:

L definita dalla lettura del laser: 24.35 m.
Angolo beta di 28.8° scaturisce da 128 Step x 0.225° (rotazione sul piano XY)
Angolo alfa di 28.125° scaturisce da 125 Step x 0.225° (rotazione sul piano XZ)

H = L x sin (28.125°) = 24.35 x 0.47139 = 11.478 m.

OM = L x cos (28.125°) = 24.35 x 0.88192 = 21.474 m.

Il segmento OM rappresenta la proiezione di L sul piano XY

MN(Y-) = OM x sin (28.8°) = 21.474 x 0,48175 = 10.345 m.

ON(X) = OM x cos (28.8°) = 21.474 x 0,87630 = 18.817 m.

Test di controllo effettuato con VISICAD del punto P :

Le formule matematiche sopra esposte saranno utilizzate nel programma dell'ESP32

Spezzone del programma con simulazione senza Lidar (Funzione RANDOM della distanza)

Microstep 1/2 - Ad ogni impulso l'albero motore ruota di 0.9°

400 impulsi per far effettuare al motore passo passo 1 giro completo.

Per migliorare la qualità della superfice da realizzare è preferibile un:

Microstep 1/4 - Ad ogni impulso l'albero motore ruota di 0.45°

Vediamo con un accoppiamento tramite microcinghia per arrivare a Microstep 1/8

Importazione nuvola di punti in VISICAD (un duplice promemoria per me non guasta mai)

Caratteristica del file TXT della nuvola di punti.

Il file completo è costituito da blocchi di 240 (definiti arbitrariamente) punti XYZ

240 intestazione del gruppo di punti
11.63 73.08 0.00
12.37 73.97 0.00
12.77 72.89 0.00
13.53 73.77 0.00
13.92 72.68 0.00
14.68 73.55 0.00
15.26 73.43 0.00
15.62 72.33 0.00

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

240 intestazione del gruppo di punti
11.63 73.08 3.48
12.20 72.99 3.48
12.77 72.89 3.48
13.53 73.77 3.48
14.11 73.66 3.48
14.49 72.57 3.48
15.06 72.45 3.48
15.84 73.31 3.48

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

Importa e unisce automaticamente gruppi di 240 punti con una curva.

Ottengo tante curve di livello a Z costanti quanti sono i gruppi presenti nel file TXT. .

Poi personalmente unisco le curve, a coppia, ed ottengo la superficie scansionata della grotta in 3D

N.B. CONTROLLARE SEMPRE IL COLORE DELLE CONNESSIONI DELLE BOBINE

Motore passo passo da 200 STEP

Motore passo passo :

Codice : 11HS12-0674S.
* Tipo di motore: bipolare.
* Angolo di passo: 1.8 gradi.
* Coppia di tenuta: 6 Ncm.
* Corrente nominale/fase: 0.67 A.
* Resistenza di fase: 5.6 Ohm.
* Tensione: 3.8 V.
* Induttanza: 4.2 mH±20% (1 kHz).

IDE Arduino 1.8.12:

#include <Stepper.h>

#define pin_EA 2 // Definizione pin ENABLE Va messo HIGH o 1

#define pin_EB 4 // Definizione pin ENABLE Va messo HIGH o 1

// IDE: Arduino 1.8.12

//SCHEDA: MAKER UNO + o Arduino uno

//FILE :MOTORE_PASSO_PASSO2_27_DICEMBRE_2023

// Numero di step (passi) per effettuare una rotazione completa

const int stepPerRotazione = 200;

// Creazione dell’istanza dello Stepper

Stepper mioStepper(stepPerRotazione, 8, 9, 10, 11);

void setup()

{

pinMode(pin_EA, OUTPUT); //setto il pin come uscita

pinMode(pin_EB, OUTPUT); //setto il pin come uscita

// impostazione della rotazione a 20 rpm:

mioStepper.setSpeed(20);

// inizializzazione della porta seriale:

// Serial.begin(9600);

digitalWrite(pin_EA, HIGH); //setto il pin Segnale Alto 5 volt

digitalWrite(pin_EB, HIGH); //setto il pin Segnale Alto 5 volt

}

void loop()

{

// una rotazione in una direzione

//Serial.println("Rotazione oraria");

mioStepper.step(stepPerRotazione);

delay(500);

// una rotazione in una direzione

//Serial.println("Rotazione antioraria");

mioStepper.step(-stepPerRotazione);

delay(500);

}

Alimentazione della scheda con 6 Vcc.

Collegare la massa dei 6 volt della scheda con la massa di Arduino.

Parametri da tenere in considerazione: Periodo e Frequenza.

Il Periodo rappresenta il Tempo(s) che impiega un segnale( digitale o analogico) per compiere una oscillazione completa.

La Frequenza definisce il numero di volte che il segnale( digitale o analogico) si ripete in un secondo.

Bisogna tenere presente che:

alla corrente occorre un certo tempo per raggiungere il valore nominale sugli avvolgimenti.
le commutazioni non sono istantanee.
per sviluppare la coppia ottimale la velocità deve essere gradualmente portata a quella massima
bisogna calcolare le opportune rampe di accelerazione e decelerazione affinchè non vi sia perdita del passo
è necessario calcolare il tempo minimo della rampa di accelerazione per raggiungere la massima velocità.

Vedere grafici sottostanti.

Il periodo del segnale è pari a 20 ms

T = 1/f T = 1/50

Per facilitare il calcolo facciamo in modo che al denominatore compaia 1000

Moltiplichiamo il numeratore e denominatore per 20 ed avremo

T = 20/1000 Pertanto il periodo del segnale è pari a 20 ms

Con un aumento eccessivo della frequenza avremo una minore coppia ed una eventuale perdita del passo.

In questo caso:

T = 1/1250 l periodo del segnale è pari a 0.8 ms

Ritorniamo a noi.

Motore passo passo da 200 STEP, occorrono 200 impulsi per compiere un giro completo.

Es. pratico e considerazioni personali.

Motore che compie 60 giri al minuto, l'albero motore compie un giro in un secondo.

Significa che:

avrò inviato 200 impulsi in un secondo.
la frequenza sarà pari a 200 Hz
il periodo sarà pari a 5 ms

Con un periodo di 5 ms ho constatato che l'albero perde qualche passo.

Mi conviene avere un periodo,per essere sicuro, di 10 ms

E' opportuno utilizzare il numero i giri che siano dei sottomultipli di 60 ed evitare valori decimali.

Pertanto 60 - 30 - 15, ecc..

Se imposto una velocità pari a 30 giri al minuto

L'albero motore per effettuare un giro completo occorrono 2 secondi

Significa che:

avrò inviato 100 impulsi in un secondo.
la frequenza sarà pari a 100 Hz
il periodo sarà pari a 10 ms

T = 1/f T = 1/100

Per facilitarci il calcolo facciamo in modo che al denominatore compaia 1000

Moltiplichiamo il numeratore e denominatore per 10 ed avremo

T = 10/1000 Pertanto il periodo del segnale è pari a 10 ms

STEPPERONLINE Nema 17 Motore passo-passo 1A 17Ncm Bipolare 1,8 gradi

L298N Modulo scheda controller Modulo passo-passo

Azionamento motore Dual H Bridge

SPECIFICHE:

Potenza massima: 25 w
Peso: 30 g
Dimensioni: 43 x 43 x 27 mm.

Alimentazione scheda driver di 6 Volt per evitare surriscaldamento del motore passo passo.

L'uscita da 5 Volt essendo stabilizzata alimenta l'Arduino Nano.

Per verificare la polarità delle uscite (A+ A- B+ B-) utilizzare il multimetro digitale in modalità :

Ricerca tensione in corrente continua, in questo caso la tensione è pari a circa 3.3 volt

// Inclusione della libreria stepper
#include <Stepper.h>
// IDE: Arduino 1.8.12
//SCHEDA: MAKER UNO + Arduino uno e NANO
//FILE :MOTORE_PASSO_PASSO nano_9_gennaio 2024
// Numero di step (passi) per effettuare una rotazione completa
const int stepPerRotazione = 200;
// Creazione dell’istanza dello Stepper
Stepper mioStepper(stepPerRotazione, 10, 9, 8, 7);

void setup()
{

// impostazione della rotazione a 30 rpm:
mioStepper.setSpeed(30);
// inizializzazione della porta seriale:
// Serial.begin(9600);
}

void loop()
{

// una rotazione in una direzione
//Serial.println("Rotazione oraria");
mioStepper.step(stepPerRotazione);
delay(1000);

// una rotazione in una direzione
//Serial.println("Rotazione antioraria");
mioStepper.step(-stepPerRotazione);
delay(1000);
}

Funziona correttamente anche con i motori passo passo:

11HS12-0674S

42BYGHW811

//File:MOTORE_PASSO_PASSO_STEP_ALLA_VOLTA_13_FEBBRAIO_2024
#include <Stepper.h>
const int stepsPerRevolution = 200;

Stepper myStepper(stepsPerRevolution, 10, 9, 8, 7);
int stepCount = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
// step one step:
myStepper.step(1);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
}

TEST DEI PROGRAMMI SENZA L'USO DELLA LIBRERIA Stepper.h

// Programma : Ponte H L298N e motore passo passo
// Connessione modulo Arduino NANO
// PERFETTAMENTE FUNZIONANTE
//FILE:MOTORE_PASSO_PASSO_SENZA_STEPPER_15_FEBBRAIO_2024
int IN1 = 8;
int IN2 = 9;
int IN3 = 10;
int IN4 = 11;
int stepCount = 0;
void setup()
{
// Definizione pin
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
Serial.begin(9600);
}
int tempo = 50; // in millisecondi
// se il passo del motore è 48 passi/giro, la velocità sarà 48*10/1000=0,48 giri/secondo
void loop()
{
// Passo 1
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
// Passo 2
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
// Passo 3
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
// Passo 4
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
if (stepCount>200) stepCount=0;
delay(50);
}

N.B.Nella programmazione si utilizza la numerazione dei GPIO.

Per facilitare il caricamento dello sketch nella memoria dell'ESP:

Tra i Pin EN (+) e GND utilizzare un condensatore polarizzato elettrolitico

da 10 microfarad e con Volt superiore a 10

Ho utilizzato un condensatore da uno 50 Volt.

Collegamenti tra la scheda L298N e l'ESP32

IN1 = 32 IN2 = 33 IN3 = 25 IN4 = 26;

Collegamenti tra LCD OLED e l'ESP32:

SDA = 21 SCL = 22

La sua alimentazione deve essere compresa tra i 3 ed i 5.5 Volt

Utilizzare l'uscita 3.3 Volt dell'ESP32

FUNZIONA SE (non so perchè):

ALIMENTARE l'ESP32 :

con i 5 volt della USB contemporaneamente
con i 5 volt della scheda L298N al PIN 19 Vin 5V
la massa GND della scheda L298N al PIN 18 GND

ROTAZIONE CONTINUA ANTIORARIA:

// Programma : Ponte H L298N e motore passo passo
// Connessione modulo ESP32: AZ-DELIVER ESP32 WROOM-32
// PERFETTAMENTE FUNZIONANTE IDE: Arduino 1.8.12

/ scheda selezionata:ESP32 Dev Module Speed 115200
//FILE:MOTORE_PASSO_PASSO_SENZA_STEPPER_15_FEBBRAIO_2024
int IN1 = 32;
int IN2 = 33;
int IN3 = 25;
int IN4 = 26;
int stepCount = 0;
void setup()
{
// Definizione pin
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
Serial.begin(9600);

digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
}
int tempo = 50; // in millisecondi
// Rotazione continua antioraria
void loop()
{
// Passo 1
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
// Passo 2
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
// Passo 3
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
delay(50);
// Passo 4
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps:");
Serial.println(stepCount);
stepCount++;
if (stepCount>200) stepCount=0;
delay(50);
}

ROTAZIONE CONTINUA ORARIA:

TEST con la funzione void orario() e void antiorario()

Programma per realizzare una rotazione dell'albero:

50 step in senso orario
20 step in senso antiorario

// Programma : Ponte H L298N e motore passo passo
// Connessione modulo ESP32: AZ-DELIVER ESP32 WROOM-32
// PERFETTAMENTE FUNZIONANTE IDE: Arduino 1.8.12
// scheda selezionata:ESP32 Dev Module Speed 115200
//FILE:MOTORE_PASSO_PASSO_esp32_ORARIO_e_antiorario_con_void_SENZA_STE
int IN1 = 32;
int IN2 = 33;
int IN3 = 25;
int IN4 = 26;
int step = 200; // nr. di step per un giro completo del motore
int stepCount1 = 1; // Contatore degli step orario
int stepCount2 = 1; // Contatore degli step antiorario
//int stepCount = 0; // Contatore nr. dei passi singoli
int tempo = 100; // Ritardo in millisecondi
int nrp_orar = 50; // Step orario
int nrp_ant = 20; // Step antiorario
void setup()
{
// Definizione pin
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
Serial.begin(9600);
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
}

void loop()
{
orario();
antiorario();
}

void orario() {
int stepCount1 = 1;
while( stepCount1<nrp_orar){

// Passo 1
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps orario :");
Serial.println(stepCount1);
if (stepCount1 > nrp_orar) break;
stepCount1++;
delay(tempo);

// Passo 2
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps orario: ");
Serial.println(stepCount1);
if (stepCount1 > nrp_orar) break;
stepCount1++;
delay(tempo);
// Passo 3
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps orario: ");
Serial.println(stepCount1);
if (stepCount1 > nrp_orar) break;
stepCount1++;
delay(tempo);
// Passo 4
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps orario: ");
Serial.println(stepCount1);
if(stepCount1>nrp_orar) break;
stepCount1++;
delay(tempo);
}
}
void antiorario() {
int stepCount2 = 1;
while(stepCount2 <nrp_ant){

// Passo 1
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps antiorario: ");
Serial.println(stepCount2);
if (stepCount2 > nrp_ant) break;
stepCount2++;
delay(tempo);
// Passo 2
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 0);
digitalWrite(IN4, 1);
Serial.print("steps antiorario: ");
Serial.println(stepCount2);
if (stepCount2 > nrp_ant) break;
stepCount2++;
delay(tempo);
// Passo 3
digitalWrite(IN1, 0);
digitalWrite(IN2, 1);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps antiorario: ");
Serial.println(stepCount2);
if (stepCount2 > nrp_ant) break;
stepCount2++;
delay(tempo);
// Passo 4
digitalWrite(IN1, 1);
digitalWrite(IN2, 0);
digitalWrite(IN3, 1);
digitalWrite(IN4, 0);
Serial.print("steps antiorario: ");
Serial.println(stepCount2);
if (stepCount2 > nrp_ant) break;
stepCount2++;
delay(tempo);
}
}

Questo è il risultato:

Test di funzionamento con ESP32 e LCD OLED:

// ESP32_18_FEBBRAIO_2024
// con oled 164x48
#include <Wire.h>
#include "SSD1306.h"
SSD1306 display(0x3c, 21, 22);

void setup() {
delay(2000);
Serial.begin(115200);

display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_16);
}

void loop() {
display.clear();
display.setTextAlignment(TEXT_ALIGN_LEFT);
display.setFont(ArialMT_Plain_16);
display.drawString(8, 8, "DISTANZA cm. ");
display.setFont(ArialMT_Plain_24);
display.drawString(32,28," 79 ");
display.display();
delay(1000);
}

CONTINUA.. Vedere il seguente link:

https://xoomer.virgilio.it/ditellamario/loralidarm.htm

Si constata dalla figura del Pinout Diagram del modulo che:

i pin 21 - 22 l'OLED
i pin 13 - 15 - 14 - 02 sono utilizzati per la memorizzazione dei dati su SD CARD
i pin 32 - 33 - 25 - 26 input per la scheda L298N 1° motore passo passo
i pin 26 - 23 - 18 - 5 -27 - 19
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

3° TEST: Memorizzazione dati su SD con libreria mySD e 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(18,19,23,5)) {

//SPI.begin(SCK,MISO,MOSI,SS);
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_APPEND);// 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:

TEST SEMPLIFICATO con libreria SD:

/* MEMORIZZAZIONE DATI CONTATORE Nr. 50
FILE: ESP32_SD_MEMORIZZAZIONE_CONTATORE_27_FEBBRAIO_2024
SCHEDA:ESP32 Dev Module Arduino 1.8.12
*/
#include <SPI.h>
#include <SD.h>
File myFile;
int cont = 1;
int maxcont =51;
void setup() {
Serial.begin(9600);
if (!SD.begin(5)) {
Serial.println("SCHEDA ERRORE!!!!");
while (1);
}
}
void loop() {
while (cont < maxcont)
{
// Con Blocco Note memorizzare su SD File:test.txt
File myFile = SD.open("/test.txt", FILE_APPEND);
Serial.print("HO MEMORIZZATDO ");
Serial.println(cont);
myFile.println(cont);
myFile.close();
Serial.println("done.");
cont ++;
delay(500);
}
exit;
}

TEST PERFETTAMENTE FUNZIONANTE con libreria SD:

// FILE:ESP32_SD_OLED_CONT_28_FEBBRAIO_2024
// Scheda:ESP32 Dev Module
// Arduino 1.8.12
//PERFETTAMENTE FUNZIONANTE
// Libreria per SD
#include <SD.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(5)) {
//SPI.begin(SCK,MISO,MOSI,SS);
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_APPEND);// 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();
}

TEST PERFETTAMENTE FUNZIONANTE con libreria SD e LCD OLED:

// FILE:ESP32_SD_OLED_CONT_29_FEBBRAIO_2024
// Scheda:ESP32 Dev Module
// Arduino 1.8.12
//PERFETTAMENTE FUNZIONANTE
// Libreria per SD
#include <SD.h>
#include <SPI.h>

// Libreria per display OLED
// Collegamenti sull'ESP32 WROOM-32 con 38 PIN:
// SDA=> 21 SCL=> 22
#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(){

Serial.begin(115200);
if (!SD.begin(5)) {
//SPI.begin(SCK,MISO,MOSI,SS);
// Collegamenti sull'ESP32 WROOM-32 con 38 PIN:
// SCK=> 18 MISO=> 19 MOSI=> 23 SS=> 5
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 ");
//Il file datalog.txt va creato precedentemente su SD con Blocco Note
Dati = SD.open("/datalog.txt", FILE_APPEND);// 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();
}

Scheda breakout (Ottima soluzione):

Collegamenti provvisori:(Da definire i pin per la seconda scheda L298N - Sensore LIDAR e GPS)

Test di funzionamento con ESP32 LIDAR e LCD OLED:

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:

TEST DI LETTURA DEL GPS (con la scheda Heltec WiFi Lora 32):

TEST:

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

OK!!! dobbiamo sistemare la visualizzazione DATI sull'LCD OLED dell'ESP32 a 38 pin.

Non va utilizzata la libreria Heltec.

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

Vedere programma realizzato con ESP32 a 30 PIN.

ADESSO MISCELIAMO TUTTO:

TEST FUNZIONANTE con libreria SD - LCD OLED - motori STEP - LIDAR - GPS: