Esplorazione delle potenzialità del modulo EByte RF E70 (esp32, STM32, Arduino, Raspberry Pi Pico)

Il mondo della comunicazione wireless è stato rivoluzionato dall’avvento della tecnologia RF, che offre una combinazione di capacità a lungo raggio e basso consumo energetico. Il modulo EByte RF E70 si distingue come uno dei protagonisti tra i vari moduli emergenti. Questo articolo esplora le caratteristiche, le applicazioni e le modalità operative dell’EByte E70, fornendo approfondimenti sulle sue capacità e potenziali utilizzi.

L’E70 si basa sulla serie di dispositivi CC1310. Questo dispositivo non è solo un microcontrollore (MCU); è un MCU wireless completamente integrato progettato specificamente per applicazioni wireless a lungo raggio e a basso consumo energetico. Il CC1310 combina un potente processore ARM Cortex-M3 con una radio sub-1 GHz altamente efficiente, rendendolo una soluzione ideale per un’ampia gamma di applicazioni, dal metering intelligente all’automazione industriale e al monitoraggio ambientale.

Introduzione all’EByte RF E70

L’EByte E70 è un modulo RF progettato per la comunicazione wireless a lungo raggio. Opera nelle bande di frequenza sub-gigahertz, rendendolo ideale per varie applicazioni che richiedono comunicazione a lungo raggio e basso consumo energetico. La sua versatilità e efficienza lo hanno reso una scelta popolare nelle applicazioni IoT (Internet of Things), nei progetti di città intelligenti e nell’automazione industriale.

Caratteristiche principali dell’EByte E70

1. Comunicazione a lungo raggio: Il modulo E70 è noto per la sua eccezionale portata, capace di trasmettere dati su diversi chilometri, a seconda delle condizioni ambientali.
2. Basso consumo energetico: È ottimizzato per un basso consumo energetico, prolungando la durata della batteria dei dispositivi, che è cruciale per le applicazioni IoT.
3. Modalità operative multiple: L’E70 supporta diverse modalità, come la modalità trasparente, la modalità fissa, la modalità continua e la modalità sotto-pacchetto, offrendo flessibilità in diversi casi d’uso.
4. Parametri configurabili: Gli utenti possono configurare parametri come frequenza, potenza di uscita e velocità di trasmissione dati, rendendo il modulo adattabile a varie esigenze di comunicazione.
5. Correzione di errore in avanti (FEC): La FEC è un metodo per il controllo degli errori nella trasmissione dei dati. Aggiunge ridondanza alle informazioni trasmesse utilizzando un algoritmo predeterminato. Questa ridondanza consente al ricevitore di rilevare e correggere gli errori senza la necessità di ritrasmissioni.

Specifiche del dispositivo

• La distanza di comunicazione testata è fino a 1,5/6 km
• Potenza di trasmissione massima di 1W, regolabile su più livelli tramite software
• Supporta velocità di trasmissione in aria da 2,5kbps a 168kbps
• Basso consumo energetico per applicazioni alimentate a batteria
• Può raggiungere fino a 115200bps con trasmissione continua di frame senza limite di lunghezza del pacchetto
• E70-xxxT30S supporta alimentazioni da 2,6 a 5,5V, oltre i 5V per garantire le migliori prestazioni
• E70-xxxT14S/S2 supporta alimentazioni da 2,2 a 3,8V, oltre i 3,3V per garantire le migliori prestazioni
• Design standard di grado industriale, supporta temperature operative da -40 a 85 °C per un funzionamento prolungato

• Supporta trasmissione continua ad alta velocità, invio e ricezione senza limite di lunghezza del pacchetto
• Supporta la trasmissione continua di frame dati senza suddivisione in pacchetti, perfettamente compatibile con il protocollo ModBus
• Supporta impostazioni personalizzate di suddivisione per migliorare l’efficienza della comunicazione
• Supporta trasmissioni a punto fisso/trasmissioni broadcast/monitoraggio del canale
• Supporta la lettura del segnale di intensità RSSI
• Supporta il risveglio via radio, ovvero una funzione di basso consumo energetico, adatta a soluzioni alimentate a batteria
• Sviluppato sulla base del chip CC1310, con dual-core ARM integrato
• Design ultra compatto
• Corrente di ricezione ultra-bassa, solo circa 8mA
• E70-433 T30S con potenza di trasmissione massima di 30dBm, gli altri tre modelli a 25mW, regolabili tramite software
• In condizioni ideali, la distanza di comunicazione può raggiungere 1,5km
• E70-433T30S con PA+LNA integrato, potenza di trasmissione 1W, distanza di comunicazione fino a 6km
• Supporta la banda ISM globale senza licenza a 433MHz
• Supporta velocità di trasmissione in aria da 2,5K a 168kbps
• Supporta alimentazioni da 2,2 a 3,8V, oltre i 3,3V per garantire le migliori prestazioni
• E70-433T30S supporta alimentazioni da 2,6 a 5,5V, oltre i 5V per garantire le migliori prestazioni
• Dual antenna opzionale (IPEX/foro a stampo) per facilitare lo sviluppo e l’integrazione da parte degli utenti

Modalità di trasmissione

Modalità Trasparente

In modalità trasparente, il modulo E70 consente una trasmissione dati semplice, dove i dati immessi in un modulo vengono esattamente emessi da un altro, a condizione che condividano lo stesso indirizzo e canale.

Questo può essere considerato come una modalità “demo”. Per impostazione predefinita, è possibile inviare messaggi a tutti i dispositivi con lo stesso indirizzo e canale configurati.

Modalità Fissa

La modalità fissa richiede che i dati vengano inviati in un formato specifico, inclusi l’indirizzo di destinazione, il canale e i dati esadecimali. È ideale per la comunicazione di dati strutturati.

È possibile selezionare un dispositivo specificato come mostrato in questo diagramma:

Oppure a un gruppo di dispositivi identificati dal canale:

Varianti di trasmissione

Modalità Continua

La modalità continua è un metodo di trasmissione dati in cui il modulo invia dati in un flusso continuo e ininterrotto. Questa modalità si differenzia dalla trasmissione basata su pacchetti, in cui i dati vengono inviati in pacchetti discreti. In modalità continua:

• Il modulo trasmette continuamente i dati fintanto che ci sono dati da inviare.
• È tipicamente utilizzato in scenari di trasmissione dati in tempo reale, come lo streaming audio o la telemetria.
• Questa modalità può consumare più energia a causa dell’attività di trasmissione costante.
• È efficace per applicazioni in cui la latenza e la consegna tempestiva dei dati sono fondamentali.

La modalità continua è ideale per applicazioni che richiedono un flusso di dati costante senza i ritardi intrinseci del trattamento e della riassemblaggio dei pacchetti. Tuttavia, richiede un’attenta gestione dell’energia e della larghezza di banda di rete.

Modalità Sotto-pacchetto

La modalità sotto-pacchetto è un metodo di trasmissione dati che divide i dati in pacchetti più piccoli o sotto-pacchetti prima di essere inviati. In questa modalità:

• I dati vengono segmentati in dimensioni gestibili, rendendo la gestione più facile, specialmente per set di dati di grandi dimensioni.
• Ogni sotto-pacchetto viene trasmesso separatamente, consentendo una migliore rilevazione e correzione degli errori.
• Questa modalità può essere più efficiente dal punto di vista energetico, poiché il modulo può entrare in uno stato di basso consumo tra le trasmissioni.
• È adatto per applicazioni in cui i dati possono essere inviati in modo intermittente o in cui l’integrità dei dati e la gestione degli errori sono più importanti della trasmissione in tempo reale.

Comportamento del pin AUX

Uno degli aspetti più importanti da considerare per le soluzioni di produzione è il comportamento del pin AUX. Può essere utilizzato per ottimizzare le prestazioni di invio e per gestire il risveglio di un MCU esterno; ecco alcuni esempi.

Trasmissione a sotto-pacchetto

Il diagramma inizia con il pin AUX nel suo stato inattivo predefinito. All’avvio della trasmissione, l’immagine mostra l’attivazione del pin AUX per ogni sotto-pacchetto inviato, seguita da un breve ritorno allo stato inattivo mentre il modulo prepara il prossimo sotto-pacchetto. Questo schema di attivazione e disattivazione intermittente è una caratteristica chiave, che evidenzia la natura segmentata della trasmissione a sotto-pacchetto.

Trasmissione continua

Il diagramma evidenzia lo stato attivo costante del pin AUX mentre il modulo trasmette dati in modo continuo, in contrasto con il suo comportamento in altre modalità in cui il pin AUX può cambiare stato tra i pacchetti.

Risveglio da WOR

L’immagine illustra una vista sequenziale del pin AUX che passa dallo stato dormiente all’operazione attiva. Inizia con il pin AUX a livello ALTO, mentre il processo di risveglio inizia, mostrando la transizione del pin AUX attraverso gli stati ALTO e BASSO, e ritorna ALTO quando il messaggio è completamente ricevuto.

Varianti del modulo RF E70

L’E70 ha diversi fattori di forma, il design cambia e anche le specifiche.

E70-433T30S:

• Tensione di livello logico: supporto 3,3v e 5v
• Potenza di trasmissione: 30dBm (potenza più elevata, capace di trasmissioni a lunga distanza)
• Sensibilità in ricezione: -107 a -109 dBm
• Distanza di riferimento: 6000m

E70-433T14S:

• Tensione di livello logico: solo 3,3v
• Potenza di trasmissione: 14dBm (potenza inferiore rispetto al T30S)
• Sensibilità in ricezione: -109 a -111 dBm per T14S e -108 dBm per T14S2 (leggermente migliore per T14S)
• Distanza di riferimento: 1500m

E70-433T14S2:

• Tensione di livello logico: solo 3,3v
• Aggiornamento della versione S.
• Sensibilità in ricezione: -109 a -111 dBm per T14S e -108 dBm per T14S2 (leggermente migliore per T14S)
• I fattori di forma sono più semplici da gestire.

E70-433MT14S:

• Tensione di livello logico: solo 3,3v
• Potenza di trasmissione: 14dBm (stessa potenza del T14S e T14S2)
• Sensibilità in ricezione: -108 dBm (stessa sensibilità del T14S2)
• Distanza di riferimento: 1500m (stessa distanza del T14S e T14S2)

Parametri RF

Parametri elettrici

Parametri hardware

Pinout E70 xxxT14S2

Per il mio test, utilizzerò la versione S2 dell’E70 poiché è un fattore di forma comodo con un’antenna SMA integrata.

Socket stampato in 3D per breadboard

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

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

Dopo la stampa, devi inserire la scritta all’interno del foro.

E70 socket  Download

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 estraila.

Reinserisci quindi nei fori interni ed esterni.

Ora controlla se è necessario tagliare ulteriormente il filo del foro interno e piegarlo.

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

Cablaggio

La sezione del cablaggio sarà spiegata meglio nei prossimi articoli.

ESP32-C3

Credo che uno dei microcontrollori più interessanti per dispositivi client remoti sia la serie ESP32-C3, perché è molto potente e consuma poca energia.

Il diagramma di collegamento con il socket adattatore diventa così.

Arduino Nano 33 IoT

Un’altra soluzione popolare è Arduino Nano 33 IoT (probabilmente BLE Sense senza Wi-Fi è una soluzione migliore).

Qui il diagramma di cablaggio.

Raspberry Pi Pico

Non mi piace molto, ma un MCU molto diffuso è il Raspberry Pi Pico.

Qui il diagramma di collegamento.

STM32F4

Il microcontrollore più potente e con più funzionalità è sicuramente lo STM32. Non ha Wi-Fi e probabilmente è la soluzione migliore.

E qui il diagramma di collegamento.

Nota sulle connessioni

Come puoi vedere, ho collegato anche M0, M1 e M2, ma non è necessario; puoi selezionare una modalità operativa impostando questi valori sui relativi pin.

Per questo esperimento, devi impostare i dispositivi in modalità a pacchetti.

• M0: LOW
• M1: HIGH
• M2: LOW

Invio dati senza libreria

Naturalmente, questo sistema è piuttosto limitato e non è utile per un sistema di produzione.

Sketch per Wemos D1 Mini

/*
 * RF E70
 * Start device or reset to send a message
 * https://mischianti.org
 *
 * E70       ----- Wemos D1 mini
 * M0         ----- GND
 * M1         ----- HIGH
 * M2         ----- GND
 * TX         ----- PIN D2 (PullUP)
 * RX         ----- PIN D3 (PullUP)
 * AUX        ----- Not connected
 * VCC        ----- 3.3v
 * GND        ----- GND
 *
 */
#include "Arduino.h"
#include <SoftwareSerial.h>

SoftwareSerial mySerial(D3, D4); // e70 TX e32 RX

void setup() {
  Serial.begin(9600);
  delay(500);

  Serial.println("Hi, I'm going to send message!");

  mySerial.begin(9600);
  mySerial.println("Hello, world?");
}

void loop() {
  if (mySerial.available()) {
    Serial.write(mySerial.read());
  }
  if (Serial.available()) {
    mySerial.write(Serial.read());
  }
}

Sketch per ESP32

/*
 * RF E70
 * Start device or reset to send a message
 * https://mischianti.org
 *
 * E70        ----- esp32
 * M0         ----- GND
 * M1         ----- HIGH
 * M2         ----- GND
 * TX         ----- RX2 (PullUP)
 * RX         ----- TX2 (PullUP)
 * AUX        ----- Not connected
 * VCC        ----- 3.3v/5v
 * GND        ----- GND
 *
 */
#include "Arduino.h"

void setup() {
  Serial.begin(9600);
  delay(500);

  Serial.println("Hi, I'm going to send message!");

  Serial2.begin(9600);
  Serial2.println("Hello, world?");
}

void loop() {
  if (Serial2.available()) {
    Serial.write(Serial2.read());
  }
  if (Serial.available()) {
    Serial2.write(Serial.read());
  }
}

Sketch per Arduino SAMD MKR WiFi 1010/Nano 33 IoT

/*
 * RF E70
 * Start device or reset to send a message
 * https://mischianti.org
 *
 * E70        ----- Arduino MKR WiFi 1010
 * M0         ----- GND
 * M1         ----- HIGH
 * M2         ----- GND
 * RX         ----- TX1
 * TX         ----- RX1
 * AUX        ----- Not connected
 * VCC        ----- 3.3v
 * GND        ----- GND
 *
 */
#include "Arduino.h"

void setup() {
  Serial.begin(9600);
  delay(500);

  Serial.println("Hi, I'm going to send message!");

  Serial1.begin(9600);
  Serial1.println("Hello, world?");
}

void loop() {
  if (Serial1.available()) {
    Serial.write(Serial1.read());
  }
  if (Serial.available()) {
    Serial1.write(Serial.read());
  }
}

Ma questo utilizzo basilare è abbastanza limitato, quindi nel prossimo capitolo useremo la mia libreria e approfondiremo le funzionalità del dispositivo.

Installazione della libreria

Puoi trovare la libreria su GitHub.

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

Invio dati con la libreria

Anche se questo è un esempio banale, mostreremo come replicarlo usando la libreria. Lo sketch è generico e se decommenti il costruttore corretto puoi usarlo per una vasta gamma di dispositivi.

/*
 * 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 				----- 23 			----- 4 					----- 2 			----- 9 			      ----- PB0 		       	----- 8 Volt div
 * M1         ----- D7 				----- 19 			----- 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)		----- 18  (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, 23, 19, 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);
  }
}

Grazie

• 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)