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
- 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.
- Basso consumo energetico: È ottimizzato per un basso consumo energetico, prolungando la durata della batteria dei dispositivi, che è cruciale per le applicazioni IoT.
- 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.
- 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.
- 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 RF | Unità | Modello | Nota | |||
---|---|---|---|---|---|---|
E70-433T30S | E70-433T14S | E70-433T14S2 | E70-433MT14S | |||
Potenza di trasmissione | dBm | 30 | 14 | 14 | 14 | |
Sensibilità di ricezione | dBm | -107~-109 | -109~-111 | -108 | -108 | La velocità dell’aria è di 2,5kbps |
Distanza di riferimento | m | 6000m | 1500m | 1500m | 1500m | La probabilità di bruciatura è inferiore quando utilizzato a breve distanza |
Antenna 5dBi, altezza 2,5 metri, velocità dell’aria 2,5kbps | ||||||
Banda di frequenza operativa | MHz | 425~450.5 | La fabbrica predefinita è 433MHz e supporta la banda ISM | |||
Velocità dell’aria | bps | 2,5k~168k | Controllo programmabile dall’utente | |||
Potenza di blocco | dBm | 10 | Vedi modalità di trasferimento per dettagli. | |||
Lunghezza di trasmissione | / | La modalità di trasmissione è specificata | Vedi modalità di trasferimento per dettagli |
Parametri elettrici
Consumo di potenza istantaneo | Unità | Modello | Nota | ||||
E70-433T30S | E70-433T14S | E70-433T14S2 | E70-433MT14S | ||||
Tensione operativa | V | 2.6~5.5 | 2.2~3.8 | 2.2~3.8 | 2.2~3.8 | Spegnimento software | |
Livello di comunicazione | V | 3,3 | Usare TTL a 5V comporta un rischio di bruciatura | ||||
Consumo di energia | Corrente emessa | mA | 530 | 27 | 36 | 32 | Usare TTL a 5V comporta un rischio di bruciatura |
Corrente di ricezione | mA | 14 | 8 | 8 | 9 | ||
Corrente in standby | μA | 4 | 1 | 1,2 | 1,7 | Consumo di potenza istantaneo | |
Temperatura | Il modulo E70-433T30S brucia permanentemente sopra i 5,5 V, e gli altri tre modelli bruciano permanentemente sopra i 3,8 V. | ℃ | -20~+85 | Grado industriale | |||
Temperatura operativa | -40~+125 |
Parametri hardware
Parametri hardware | Modello | Nota | |||
E70-433T30S | E70-433T14S | E70-433T14S2 | E70-433MT14S | ||
Chip | CC1310 | ||||
Capacità di memoria | 2048 Byte | Definito dall’utente | |||
FLASH | 128 KB | ||||
RAM | 8 KB | ||||
Kernel | Cortex-M3 (MCU) + Cortex-M0 (RF) | ||||
Interfaccia di comunicazione | Porta seriale UART | Livello TTL | |||
Metodo di modulazione | GFSK | ||||
Metodo di incapsulamento | SMD | ||||
Interfaccia antenna | IPEX/foro stampato | IPEX/foro stampato | IPEX/foro stampato | Fori stampati | L’impedenza caratteristica è circa 50 ohm |
Dimensioni | 24×38,5mm | 16×26 mm | 14×20 mm | 10x10mm | Il modello E70-433T14S2 non include SMA |
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.
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ì.
E70 | ESP32C3 |
---|---|
M0 | 1 |
M1 | 2 |
M2 | 3 |
TX | 4 |
RX | 5 |
AUX | 6 |
VCC | 3,3V |
GND | GND |
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.
E70 | rp2040 |
---|---|
M0 | 9 |
M1 | 10 |
M2 | 11 |
TX | 8 |
RX | 9 |
AUX | 2 |
VCC | 3.3V |
GND | GND |
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.
E70 | STM32 |
---|---|
M0 | PB0 |
M1 | PB1 |
M2 | PB10 |
TX | PA2 |
RX | PA3 |
AUX | PA0 |
VCC | 3.3V |
GND | GND |
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.
Modalità (0-7) | M2 | M1 | M0 | Introduzione della modalità | Nota |
---|---|---|---|---|---|
0 Modalità RSSI | 0 | 0 | 0 | Il modulo emette il valore RSSI ogni 100 ms tramite UART. | La velocità dei dati in aria può essere regolata automaticamente in base alla velocità di baud. La velocità di baud deve essere la stessa su ricevitore e trasmettitore. |
1 Modalità continua | 0 | 0 | 1 | UART aperta. Wireless chiuso, trasmissione trasparente a pacchetti disponibile. | Modalità continua, utilizzata per la trasmissione dati senza interruzioni. |
2 Modalità a pacchetti | 0 | 1 | 0 | UART aperta. Wireless chiuso, parametri configurabili. | Modalità più efficiente per la gestione di grandi volumi di dati. |
3 Modalità di configurazione | 0 | 1 | 1 | La velocità di baud è fissata a 9600 8N1. | Utilizzato per configurare il dispositivo. |
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)