Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio
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.
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.
E70 | ESP32 |
---|---|
M0 | 19 |
M1 | 21 |
M2 | 22 |
TX | RX2 |
RX | TX2 |
AUX | 15 |
VCC | 3.3v |
GND | GND |
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.
E70 | ESP32c3 |
---|---|
M0 | 1 |
M1 | 2 |
M2 | 3 |
TX | 4 |
RX | 5 |
AUX | 6 |
VCC | 3.3v |
GND | GND |
Costruttore
RF_E70 e70ttl(&Serial1, 1, 2, 3, 4);
ESP32s3
Un dispositivo potente come l’S3 può essere utilizzato per operazioni più complesse.
Cablaggio.
E70 | ESP32c3 |
---|---|
M0 | 5 |
M1 | 6 |
M2 | 7 |
TX | RX1 |
RX | TX1 |
AUX | 4 |
VCC | 3.3v |
GND | GND |
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.
- ESP32: piedinatura, specifiche e configurazione dell’Arduino IDE
- ESP32: fileSystem integrato SPIFFS
- ESP32: gestire più seriali e logging per il debug
- ESP32 risparmio energetico pratico
- ESP32 risparmio energetico pratico: gestire WiFi e CPU
- ESP32 risparmio energetico pratico: modem e light sleep
- ESP32 risparmio energetico pratico: deep sleep e ibernazione
- ESP32 risparmio energetico pratico: preservare dati al riavvio, sveglia a tempo e tramite tocco
- ESP32 risparmio energetico pratico: sveglia esterna e da ULP
- ESP32 risparmio energetico pratico: sveglia da UART e GPIO
- ESP32: filesystem integrato LittleFS
- ESP32: filesystem integrato FFat (Fat/exFAT)
- ESP32-wroom-32
- ESP32-CAM
- ESP32: ethernet w5500 con chiamate standard (HTTP) e SSL (HTTPS)
- ESP32: ethernet enc28j60 con chiamate standard (HTTP) e SSL (HTTPS)
- Come usare la scheda SD con l’esp32
- esp32 e esp8266: file system FAT su memoria SPI flash esterna
- Gestione aggiornamenti firmware e OTA
- Gestione del firmware
- Aggiornamento OTA con Arduino IDE
- Aggiornamento OTA con browser web
- Aggiornamenti automatici OTA da un server HTTP
- Aggiornamento del firmware non standard
- Integrare LAN8720 con ESP32 per la connettività Ethernet con plain (HTTP) e SSL (HTTPS)
- Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio
- ESP32-C3: piedinatura, specifiche e configurazione dell’IDE Arduino
- Integrazione del modulo W5500 su ESP32 con Core 3: supporto nativo ai protocolli Ethernet con SSL e altre funzionalità
- 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.
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.
- EByte RF E70 433/868/900 T14S2: piedinatura, datasheet e specifiche (1.5Km)
- Adattatore per Modulo RF EByte E70: PCB, Soluzione Stampata in 3D per breadboard e configurazione
- Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio
- Collegamento dell’EByte E70 ai dispositivi Arduino SAMD (Nano 33, MKR…) e un semplice sketch di esempio
- Collegamento dell’EByte E70 ai dispositivi STM32 (black/blue pill) e un semplice sketch di esempio
- Collegamento dell’EByte E70 ai dispositivi Raspberry Pi Pico (rp2040) ed un semplice sketch di esempio
- Esplorazione delle potenzialità del modulo EByte RF E70 (esp32, STM32, Arduino, Raspberry Pi Pico)
- EByte RF E70 CC1310: andiamo ad esplorare la libreria (esp32, esp8266, STM32, Arduino, Raspberry Pi Pico)
- Configurazione del Modulo RF EByte E70 (esp32, STM32, Arduino, Raspberry Pi Pico)