Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio


ESP32 c3/s3 and Ebyte LoRa E70 CC1310
ESP32 c3/s3 and Ebyte LoRa E70 CC1310

Bentornati alla nostra serie su come connettere l’EByte E70 a vari dispositivi! In questo articolo, vi guideremo attraverso un semplice esempio di sketch che vi aiuterà a stabilire una connessione tra l’EByte E70 e il vostro dispositivo ESP32, ESP32C3 o ESP32 S3.

Comprendere l’EByte E70

L’EByte E70 è un modulo trasmettitore RF ad alte prestazioni, rinomato per le sue capacità di comunicazione a lungo raggio e basso consumo energetico. Progettato per la comunicazione wireless su lunghe distanze, opera nelle bande di frequenza sub-GHz, rendendolo ideale per applicazioni IoT che richiedono una comunicazione affidabile ed efficiente su ampie aree.

Prerequisiti

Prima di iniziare, assicuratevi di avere quanto segue:

  • Un dispositivo ESP32, ESP32C3 o ESP32 S3
  • Il modulo EByte E70 con un adattatore per breadboard
  • Un’installazione dell’Arduino IDE sul vostro computer
  • I cavi USB necessari per collegare il vostro dispositivo ESP32 e il modulo EByte E70 al computer
  • Breadboard

Ecco le varianti di base ESP32 ESP32 Dev Kit v1 - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 - WeMos Lolin32 mini - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S

Ecco le varianti di ESP32c3 LuatOS esp32c3 Core - ESP32-C3-DevKitC-02 - ESP32-C3-MINI-1 - WeMos LOLIN C3 PICO - WeMos LOLIN C3 Mini v2.1 - WeMos LOLIN C3 Mini v1.0 - ESP32 S3 Purlple AI-S3

Ecco le varianti di ESP32s3 ESP32 S3 Purlple AI-S3 - YD-ESP32-S3 - ESP32-S3-DevKitC-1 - ESP32-S3-DevKitC-1 - ESP32-S3 Board screen

Ecco le varianti di E70 LoRa E70 433/915 T S/S2 - E70 433/915 MT S

Preparazione dell’Hardware

Pinout E70 xxxT14S2

Userò una versione E70 S2 per il mio test perché ha un fattore di forma comodo con un’antenna SMA integrata.

Supporto stampato in 3D per breadboard

Ho creato un semplice supporto con la mia stampante 3D per prototipare rapidamente (e gestire) l’E70 S2; ecco il modello 3D e il risultato su una breadboard.

È molto semplice e utilizza la stessa tecnica di altri supporti che ho già creato.

Dopo la stampa, è necessario aggiungere la scrittura all’interno del foro.

Supporto E70 

Inseriscilo nei fori più interni e spingilo fuori di circa 3 mm

Piega il filo verso l’esterno dell’adattatore.

Taglia la parte esterna del filo ed estrai,

quindi reinseriscilo nei fori interni ed esterni.

Ora controlla se devi tagliare di più il filo del foro interno e piegalo.

Ripeti per tutti i pin. Il risultato è molto soddisfacente.

Cablaggio

esp32

L’esp32 è il mio riferimento per questo articolo, è sicuramente perfetto per tutte le situazioni ed è ampiamente diffuso.

Ecco il diagramma di connessione.

E70ESP32
M019
M121
M222
TXRX2
RXTX2
AUX15
VCC3.3v
GNDGND

Costruttore

RF_E70 e70ttl(&Serial2, 15, 19, 21, 22);

esp32c3

Penso che una delle microcontrollori più interessanti per i dispositivi client remoti sia la serie esp32c3 perché è molto potente con basso consumo energetico.

Il diagramma di connessione con l’adattatore per socket diventa.

E70ESP32c3
M01
M12
M23
TX4
RX5
AUX6
VCC3.3v
GNDGND

Costruttore

RF_E70 e70ttl(&Serial1,  1, 2, 3, 4);

ESP32s3

Un dispositivo potente come l’S3 può essere utilizzato per operazioni più complesse.

Cablaggio.

E70ESP32c3
M05
M16
M27
TXRX1
RXTX1
AUX4
VCC3.3v
GNDGND

Costruttore

RF_E70 e70ttl(&Serial1,  4, 5, 6, 7);

Configurazione dell’Arduino IDE

Prima di caricare lo sketch sul nostro dispositivo ESP32, dobbiamo configurare l’Arduino IDE per riconoscere la scheda e il modulo EByte E70. Potete trovare molte informazioni su questi dispositivi su questo sito.

  1. ESP32: piedinatura, specifiche e configurazione dell’Arduino IDE
  2. ESP32: fileSystem integrato SPIFFS
  3. ESP32: gestire più seriali e logging per il debug
  4. ESP32 risparmio energetico pratico
    1. ESP32 risparmio energetico pratico: gestire WiFi e CPU
    2. ESP32 risparmio energetico pratico: modem e light sleep
    3. ESP32 risparmio energetico pratico: deep sleep e ibernazione
    4. ESP32 risparmio energetico pratico: preservare dati al riavvio, sveglia a tempo e tramite tocco
    5. ESP32 risparmio energetico pratico: sveglia esterna e da ULP
    6. ESP32 risparmio energetico pratico: sveglia da UART e GPIO
  5. ESP32: filesystem integrato LittleFS
  6. ESP32: filesystem integrato FFat (Fat/exFAT)
  7. ESP32-wroom-32
    1. ESP32-wroom-32: flash, piedinatura, specifiche e configurazione dell’Arduino IDE
  8. ESP32-CAM
    1. ESP32-CAM: piedinatura, specifiche e configurazione dell’Arduino IDE
    2. ESP32-CAM: upgrade CamerWebServer con gestione della luce flash
  9. ESP32: ethernet w5500 con chiamate standard (HTTP) e SSL (HTTPS)
  10. ESP32: ethernet enc28j60 con chiamate standard (HTTP) e SSL (HTTPS)
  11. Come usare la scheda SD con l’esp32
  12. esp32 e esp8266: file system FAT su memoria SPI flash esterna
  13. Gestione aggiornamenti firmware e OTA
    1. Gestione del firmware
      1. ESP32: flash del firmware binario compilato (.bin)
      2. ESP32: flash del firmware e filesystem (.bin) con strumenti grafici
    2. Aggiornamento OTA con Arduino IDE
      1. Aggiornamenti OTA su ESP32 con Arduino IDE: filesystem, firmware e password
    3. Aggiornamento OTA con browser web
      1. Aggiornamenti OTA su ESP32 tramite browser web: firmware, filesystem e autenticazione
      2. Aggiornamenti OTA su ESP32 tramite browser web: caricamento in HTTPS (SSL/TLS) con certificato autofirmato
      3. Aggiornamenti OTA su ESP32 tramite browser web: interfaccia web personalizzata
    4. Aggiornamenti automatici OTA da un server HTTP
      1. Aggiornamento automatico Firmware OTA dell’ESP32 dal server
      2. Aggiornamento automatico Firmware OTA dell’ESP32 dal server con controllo della versione
      3. Aggiornamento automatico Firmware OTA dell’ESP32 in HTTPS (SSL/TLS) con certificato autofirmato affidabile
    5. Aggiornamento del firmware non standard
      1. Aggiornamento firmware e filesystem ESP32 dalla scheda SD
      2. Aggiornamento firmware e filesystem ESP32 con client FTP
  14. Integrare LAN8720 con ESP32 per la connettività Ethernet con plain (HTTP) e SSL (HTTPS)
  15. Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio
  16. ESP32-C3: piedinatura, specifiche e configurazione dell’IDE Arduino
  17. Integrazione del modulo W5500 su ESP32 con Core 3: supporto nativo ai protocolli Ethernet con SSL e altre funzionalità
  18. Integrazione del modulo LAN8720 su ESP32 con Core 3: supporto nativo del protocollo Ethernet con SSL e altre funzionalità.

Con l’Arduino IDE configurato, possiamo ora procedere all’esempio di sketch.

Installazione della libreria

Potete trovare la libreria su GitHub.

Ma per semplicità, l’ho aggiunta al gestore delle librerie di Arduino.

Installazione Arduino IDE di EByte LoRa E70 dal gestore delle librerie.
Installazione Arduino IDE di EByte LoRa E70 dal gestore delle librerie.

Scrittura dello Sketch

La libreria offre molti esempi, e dovete solo decommentare il costruttore corretto.

/*
 * EByte RF E70
 * send a transparent message, you must check that the transmitter and receiver have the same
 * CHANNEL ADDL and ADDH
 *
 * You must uncommend the correct constructor.
 *
 * by Renzo Mischianti <https://www.mischianti.org>
 *
 * https://www.mischianti.org
 *
 * E70		  ----- WeMos D1 mini	----- esp32			----- Arduino Nano 33 IoT	----- Arduino MKR	----- Raspberry Pi Pico   ----- stm32               ----- ArduinoUNO
 * M0         ----- D6 				----- 19 			----- 4 					----- 2 			----- 9 			      ----- PB0 		       	----- 8 Volt div
 * M1         ----- D7 				----- 21 			----- 5 					----- 3 			----- 10 			      ----- PB1 		       	----- 7 Volt div
 * M1         ----- D8 				----- 22 			----- 6 					----- 4 			----- 11 			      ----- PB10 		      	----- 6 Volt div
 * TX         ----- D3 (PullUP)		----- RX2 (PullUP)	----- RX1 (PullUP)			----- 14 (PullUP)	----- 8 (PullUP)	      ----- PA2 RX2 (PullUP)    ----- 4 (PullUP)
 * RX         ----- D4 (PullUP)		----- TX2 (PullUP)	----- TX1 (PullUP)			----- 13 (PullUP)	----- 9 (PullUP)	      ----- PA3 TX2 (PullUP)    ----- 5 Volt div (PullUP)
 * AUX        ----- D5 (PullUP)		----- 15  (PullUP)	----- 2  (PullUP)			----- 0  (PullUP)	----- 2  (PullUP)	      ----- PA0  (PullUP)       ----- 3 (PullUP)
 * VCC        ----- 3.3v/5v			----- 3.3v/5v		----- 3.3v/5v				----- 3.3v/5v		----- 3.3v/5v		      ----- 3.3v/5v             ----- 3.3v/5v
 * GND        ----- GND				----- GND			----- GND					----- GND			----- GND			      ----- GND                 ----- GND
 *
 *	Sub-packet can be emulated by set
 *	M0 = LOW
 *	M1 = HIGH
 *	M2 = LOW
 *	Continuous
 *	M0 = HIGH
 *	M1 = LOW
 *	M2 = LOW
 *
 */

#include "Arduino.h"
#include "RF_E70.h"

// ---------- esp8266 pins --------------
//RF_E70 e70ttl(RX, TX, AUX, M0, M1, M2);  // Arduino RX <-- e70 TX, Arduino TX --> e70 RX
//RF_E70 e70ttl(D3, D4, D5, D7, D6, D7); // Arduino RX <-- e70 TX, Arduino TX --> e70 RX AUX M0 M1
//RF_E70 e70ttl(D2, D3); // Config without connect AUX and M0 M1

//#include <SoftwareSerial.h>
//SoftwareSerial mySerial(D2, D3); // Arduino RX <-- e70 TX, Arduino TX --> e70 RX
//RF_E70 e70ttl(&mySerial, D5, D6, D7, D8); // AUX M0 M1
// -------------------------------------

// ---------- Arduino pins --------------
//RF_E70 e70ttl(4, 5, 3, 8, 7, 6); // Arduino RX <-- e70 TX, Arduino TX --> e70 RX AUX M0 M1
//RF_E70 e70ttl(4, 5); // Config without connect AUX and M0 M1

//#include <SoftwareSerial.h>
//SoftwareSerial mySerial(4, 5); // Arduino RX <-- e70 TX, Arduino TX --> e70 RX
//RF_E70 e70ttl(&mySerial, 3, 8, 7, 6); // AUX M0 M1
// -------------------------------------

// ------------- Arduino Nano 33 IoT -------------
// RF_E70 e70ttl(&Serial1, 2, 4, 5, 6); //  RX AUX M0 M1
// -------------------------------------------------

// ------------- Arduino MKR WiFi 1010 -------------
// RF_E70 e70ttl(&Serial1, 0, 2, 3, 4); //  RX AUX M0 M1
// -------------------------------------------------

// ---------- esp32c3 pins --------------
// RF_E70 e70ttl(&Serial1,  1, 2, 3, 4,); //  RX AUX M0 M1

// RF_E70 e70ttl(4, 5, &Serial1, 6, 1, 2, 3, UART_BPS_RATE_9600); //  esp32 RX <-- e70 TX, esp32 TX --> e70 RX AUX M0 M1
// -------------------------------------

// ---------- esp32 pins --------------
RF_E70 e70ttl(&Serial2, 15, 19, 21, 22); //  RX AUX M0 M1

//RF_E70 e70ttl(&Serial2, 22, 4, 18, 21, 19, UART_BPS_RATE_9600); //  esp32 RX <-- e70 TX, esp32 TX --> e70 RX AUX M0 M1
// -------------------------------------

// ---------- Raspberry PI Pico pins --------------
// RF_E70 e70ttl(&Serial2, 2, 10, 11, 12); //  RX AUX M0 M1
// -------------------------------------

// ---------------- STM32 --------------------
// HardwareSerial Serial2(USART2);   // PA3  (RX)  PA2  (TX)
// RF_E70 e70ttl(&Serial2, PA0, PB0, PB1, PB10); //  RX AUX M0 M1
// -------------------------------------------------

 void setup() {
  Serial.begin(9600);
#if defined(ARDUINO_ARCH_STM32) || defined(__STM32F1__) || defined(__STM32F4__)
	Serial.dtr(false);
#endif

  delay(500);

  // Startup all pins and UART
  e70ttl.begin();

//  e70ttl.setMode(MODE_CONTINUOUS_1);

//  If you have ever change configuration you must restore It

  Serial.println("Hi, I'm going to send message!");
  // Send message
  ResponseStatus rs = e70ttl.sendMessage("Hello, world?");
  // Check If there is some problem of succesfully send
  Serial.println(rs.getResponseDescription());
}

void loop() {
	// If something available
  if (e70ttl.available()>1) {
	  // read the String message
	ResponseContainer rc = e70ttl.receiveMessage();
	// Is something goes wrong print error
	if (rc.status.code!=1){
		Serial.println(rc.status.getResponseDescription());
	}else{
		// Print the data received
		Serial.println(rc.status.getResponseDescription());
		Serial.println(rc.data);
	}
  }
  if (Serial.available()) {
	  String input = Serial.readString();
	  e70ttl.sendMessage(input);
  }
}

Caricamento dello Sketch

Prima di caricare lo sketch sul vostro dispositivo ESP32, assicuratevi di aver selezionato la scheda e la porta corretta nell’Arduino IDE. Quindi, cliccate sul pulsante “Carica” per compilare e caricare lo sketch.

Una volta completato il caricamento, aprite il Monitor Seriale andando su “Strumenti” > “Monitor Seriale” o premendo “Ctrl+Shift+M”. Impostate il baud rate a 9600 e dovreste vedere i dati ricevuti dal modulo EByte E70 visualizzati nel Monitor Seriale.

Grazie

Spero che abbiate collegato con successo l’EByte E70 al vostro dispositivo ESP32, ESP32C3 o ESP32 S3.