Ebyte LoRa E32 device for Arduino, esp32 or esp8266: library - 2 (original) (raw)

I created a library to manage EBYTE E32 based on the Semtech series of LoRa devices, a potent, simple, and cheap device.

LoRa E32-TTL-100

You can find here AliExpress (433MHz 5Km) - AliExpress (433MHz 8Km) - AliExpress (433MHz 16Km) - AliExpress (868MHz 915MHz 5.5Km) - AliExpress (868MHz 915MHz 8Km)

They can work over a distance of 3000m to 8000m, and they have many features and parameters.

So I create this library to simplify the usage.

Toggle

• Library
  * Pinout
• Fully connected schema
  * AUX pin
• Constructor
• Begin
  • Configuration and information method
    * Response container
    * ResponseStatus
    * ResponseContainer
    * ResponseStructContainer
    * getConfiguration and setConfiguration
    * Basic configuration option
    * SPED detail
    * OPTION detail
    * Transmission power
  • Send receive message
    * Normal transmission mode
    * Manage structure
    * Read partial structure
    * Fixed mode instead of normal mode
    * Fixed transmission
• Thanks

Library

You can find my library here.

And It’s available on Arduino IDE library manager.

EByte LoRa E22 E32 Arduino library manager

To download.

Click the DOWNLOADS button in the top right corner rename the uncompressed folder LoRa_E32.

Check that the LoRa_E32 folder contains LoRa_E32.cpp and LoRa_E32.h.

Place the LoRa_E32 library folder in your /libraries/ folder.

You may need to create the libraries subfolder if it’s your first library.

Restart the IDE.

Pinout

sx1278 sx1276 wireless lora uart module serial 3000m arduino 433 rf

As you can see, you can set various modes via M0 and M1 pins.

Some pins can be used statically, but If you connect Them to the microcontroller and configure them in the library, you gain in performance, and you can control all modes via software, but we will explain better next.

Fully connected schema

As I already said, It’s not essential to connect all pins to the output of the microcontroller, you can put M0 and M1 pins to HIGH or LOW to get the desired configuration, and if you don’t connect AUX, the library sets a reasonable delay to be sure that the operation is complete (If you have trouble like freeze device, you must put a pull-up 4.7k resistor or better connect to the device. ).

AUX pin

When transmitting data can be used to wake up external MCU and return HIGH on data transfer finish.

LoRa E32 AUX Pin on transmission

When receiving, AUX goes LOW and returns HIGH when the buffer is empty.

LoRa e32 AUX pin on reception

It’s also used for self-checking to restore regular operation (on power-on and sleep/program mode).

LoRa e32 AUX pin on self-check

esp8266 connection schema is more straightforward because It works at the same voltage of logical communications (3.3v).

LoRa E32 TTL 100 Wemos D1 fully connected.

It’s essential to add a pull-up resistor (4,7Kohm) to get good stability.

Arduino’s working voltage is 5v, so we need to add a voltage divider on RX pin M0 and M1 of the LoRa module to prevent damage. You can get more information here Voltage divider: calculator and application.

You can use a 2Kohm resistor to GND and 1Kohm from the signal, then put it together on RX.

LoRa E32 TTL 100 Arduino fully connected

Ebyte LoRa E22 device esp32 dev kit v1 breadboard full connection

Ebyte LoRa Exx Arduino MKR WiFi 1010 Fully connected breadboard

Constructor

I made a set of numerous constructors because we can have more options and situations to manage.

    LoRa_E32(byte txE32pin, byte rxE32pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
    LoRa_E32(byte txE32pin, byte rxE32pin, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
    LoRa_E32(byte txE32pin, byte rxE32pin, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

The first set of constructors is created to delegate Serial and other pins to the library.

• txE32pin and rxE32pin is the pin to connect to UART and they are mandatory.
• auxPin is a pin that check the operation, transmission and receiving status (we are going to explain better next), that pin It isn’t mandatory, if you don’t set It I apply a delay to permit the operation to complete itself (with latency, if you have trouble, like freeze device, you must put a pull-up 4.7k resistor or better connect to the device ).
• m0pin and m1Pin are the pins to change operation MODE (see the table upper), I think this pins in “production” are going to connect directly HIGH or LOW, but for test they are usefully to be managed by the library.
• bpsRate is the boudrate of SoftwareSerial normally is 9600 (the only baud rate in programmin/sleep mode)

A simple example is

#include "LoRa_E32.h"

LoRa_E32 e32ttl100(2, 3); // e32 TX e32 RX // LoRa_E32 e32ttl100(2, 3, 5, 6, 7); // e32 TX e32 RX

We can use a SoftwareSerial directly with another constructor

    LoRa_E32(HardwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
    LoRa_E32(HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
    LoRa_E32(HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

The example upper with this constructor can be done like so.

#include <SoftwareSerial.h> #include "LoRa_E32.h"

SoftwareSerial mySerial(2, 3); // e32 TX e32 RX LoRa_E32 e32ttl100(&mySerial); // LoRa_E32 e32ttl100(&mySerial, 5, 7, 6);

The last set of constructors permits using an HardwareSerial instead of SoftwareSerial.

    LoRa_E32(SoftwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
    LoRa_E32(SoftwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
    LoRa_E32(SoftwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

For esp32, you have three additional constructors to permit to manage pins for HardWare serial.

        LoRa_E32(byte txE32pin, byte rxE32pin, HardwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, uint32_t serialConfig = SERIAL_8N1);
        LoRa_E32(byte txE32pin, byte rxE32pin, HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, uint32_t serialConfig = SERIAL_8N1);
        LoRa_E32(byte txE32pin, byte rxE32pin, HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, uint32_t serialConfig = SERIAL_8N1);

Breaking change on esp32 constructor for managed HardwareSerial pins, now reference of HardwareSerial is after the pins to remove ambiguous constructors.

Begin

The begin command is used to startup Serial and pins in input and output mode.

in execution is

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

Configuration and information method

There are many methods for managing configuration and getting information about the device.

    ResponseStructContainer getConfiguration();
    ResponseStatus setConfiguration(Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);

    ResponseStructContainer getModuleInformation();
    void printParameters(struct Configuration configuration);
    ResponseStatus resetModule();

Response container

To simplify response management, I created a set of containers that usefully manage errors and return generic data.

ResponseStatus

This is a status container with two simple entry points; you can get the status code and the description of the status code.

Serial.println(c.getResponseDescription()); // Description of code
Serial.println(c.code); // 1 if Success

The code is

SUCCESS = 1, ERR_UNKNOWN, ERR_NOT_SUPPORT, ERR_NOT_IMPLEMENT, ERR_NOT_INITIAL, ERR_INVALID_PARAM, ERR_DATA_SIZE_NOT_MATCH, ERR_BUF_TOO_SMALL, ERR_TIMEOUT, ERR_HARDWARE, ERR_HEAD_NOT_RECOGNIZED

ResponseContainer

This container is created to manage String response and has two entry points.

data with the string returned from the message and status an instance of RepsonseStatus.

    ResponseContainer rs = e32ttl.receiveMessage();
    String message = rs.data;

    Serial.println(rs.status.getResponseDescription());
    Serial.println(message);

ResponseStructContainer

This is the more “complex” container. I use this to manage structure, It has the same entry point of ResponseContainer, but data is a void pointer to manage complex structure.

ResponseStructContainer c;
c = e32ttl100.getConfiguration();
// It's important get configuration pointer before all other operation
Configuration configuration = *(Configuration*) c.data;
Serial.println(c.status.getResponseDescription());
Serial.println(c.status.code);
    c.close();

Every time you use a ResponseStructContainer you must close It with close()

getConfiguration and setConfiguration

The first method is getConfiguration, and you can use It to retrieve all data stored on the device.

    ResponseStructContainer getConfiguration();

Here is a usage example.

ResponseStructContainer c;
c = e32ttl100.getConfiguration();
// It's important get configuration pointer before all other operation
Configuration configuration = *(Configuration*) c.data;
Serial.println(c.status.getResponseDescription());
Serial.println(c.status.code);
    Serial.println(configuration.SPED.getUARTBaudRate());

Structure of configuration have all data of settings, and I add a series of functions to get all description of single data.

configuration.ADDL = 0x0; // First part of address
configuration.ADDH = 0x1; // Second part of address
configuration.CHAN = 0x19;// Channel

configuration.OPTION.fec = FEC_0_OFF; // Forward error correction switch
configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION; // Transmission mode
configuration.OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS; // Pull-up management
configuration.OPTION.transmissionPower = POWER_17; // dBm transmission power 
configuration.OPTION.wirelessWakeupTime = WAKE_UP_1250; // Wait time for wake up

configuration.SPED.airDataRate = AIR_DATA_RATE_011_48; // Air data rate
configuration.SPED.uartBaudRate = UART_BPS_115200; // Communication baud rate
configuration.SPED.uartParity = MODE_00_8N1; // Parity bit

You have the equivalent function for all attributes to get all descriptions:

Serial.print(F("Chan : "));  Serial.print(configuration.CHAN, DEC); Serial.print(" -> "); Serial.println(configuration.getChannelDescription());
Serial.println(F(" "));
Serial.print(F("SpeedParityBit     : "));  Serial.print(configuration.SPED.uartParity, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTParityDescription());
Serial.print(F("SpeedUARTDatte  : "));  Serial.print(configuration.SPED.uartBaudRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTBaudRate());
Serial.print(F("SpeedAirDataRate   : "));  Serial.print(configuration.SPED.airDataRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getAirDataRate());

Serial.print(F("OptionTrans        : "));  Serial.print(configuration.OPTION.fixedTransmission, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFixedTransmissionDescription());
Serial.print(F("OptionPullup       : "));  Serial.print(configuration.OPTION.ioDriveMode, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getIODroveModeDescription());
Serial.print(F("OptionWakeup       : "));  Serial.print(configuration.OPTION.wirelessWakeupTime, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getWirelessWakeUPTimeDescription());
Serial.print(F("OptionFEC          : "));  Serial.print(configuration.OPTION.fec, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFECDescription());
Serial.print(F("OptionPower        : "));  Serial.print(configuration.OPTION.transmissionPower, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getTransmissionPowerDescription());

In the same way, setConfiguration wants a configuration structure, so I think the better way to manage configuration is to retrieve the current one, apply the only change you need and set It again.

    ResponseStatus setConfiguration(Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);

configuration is the structure previously shown, saveType permit you to choose if the difference becomes permanent or only for the current session.

ResponseStructContainer c;
c = e32ttl100.getConfiguration();
// It's important get configuration pointer before all other operation
Configuration configuration = *(Configuration*) c.data;
Serial.println(c.status.getResponseDescription());
Serial.println(c.status.code);

printParameters(configuration);
configuration.ADDL = 0x0;
configuration.ADDH = 0x1;
configuration.CHAN = 0x19;

configuration.OPTION.fec = FEC_0_OFF;
configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION;
configuration.OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS;
configuration.OPTION.transmissionPower = POWER_17;
configuration.OPTION.wirelessWakeupTime = WAKE_UP_1250;

configuration.SPED.airDataRate = AIR_DATA_RATE_011_48;
configuration.SPED.uartBaudRate = UART_BPS_115200;
configuration.SPED.uartParity = MODE_00_8N1;

// Set configuration changed and set to not hold the configuration
ResponseStatus rs = e32ttl100.setConfiguration(configuration, WRITE_CFG_PWR_DWN_LOSE);
Serial.println(rs.getResponseDescription());
Serial.println(rs.code);
printParameters(configuration);

The parameters are all managed as constant:

Basic configuration option

SPED detail

UART Parity bit: UART mode can be different between communication parties

UART baud rate: UART baud rate can be different between communication parties. The UART baud rate has nothing to do with wireless transmission parameters & won’t affect the wireless transmit/receive features.

Air data rate: The lower the air data rate, the longer the transmitting distance, better anti-interference performance, and longer transmitting time; the air data rate must be constant for both communication parties.

OPTION detail

Transmission mode: The first three bytes of each user’s data frame can be used as high/low address and channel in fixed transmission mode. The module changes its address and channel when transmitted. And it will revert to the original setting after completing the process.

IO drive mode: this bit is used for the module internal pull-up resistor. It also increases the level’s adaptability in case of an open drain. But in some cases, it may need an external pull-up resistor.

Wireless wake-up time: the transmit & receive module work in mode 0, whose delay time is invalid & can be an arbitrary value; the transmitter works in mode one can send the preamble code of the corresponding time continuously when the receiver operates in mode 2, the time means the monitor interval time (wireless wake-up). Only the data from the transmitter that works in mode one can be
received.

FEC: after turning off FEC, the actual data transmission rate increases while anti-interference ability decreases. Also, the transmission distance is relatively short, and both communication parties must keep on the same pages about turn-on or turn-off FEC.

Transmission power

You can change this set of constants by applying a definition like so:

#define E32_TTL_100 // default value without set

Applicable for E32-TTL-100, E32-TTL-100S1, E32-T100S2.
The external power must make sure the current output ability is more than 250mA and ensure the power supply ripple within 100mV.
Low power transmission is not recommended due to its low power supply
efficiency.

#define E32_TTL_100 // default value without set

Applicable for E32-TTL-500。
The external power must make sure the current output ability is more than 700mA and ensure the power supply ripple within 100mV.
Low power transmission is not recommended due to its low power supply efficiency.

Applicable for E32-TTL-1W, E32 (433T30S), E32 (868T30S), E32 (915T30S)
The external power must make sure the current output ability is more than 1A and ensure the power supply ripple within 100mV.
Low power transmission is not recommended due to its low power supply
efficiency.

You can configure Channel frequency also with this define:

// One of #define FREQUENCY_433 #define FREQUENCY_170 #define FREQUENCY_470 #define FREQUENCY_868 #define FREQUENCY_915

Send receive message

First, we must introduce a simple but usefully method to check if something is in the receiving buffer

It’s simple to return how many bytes you have in the current stream.

Normal transmission mode

Normal/Transparent transmission mode sends messages to all devices with the same address and channel.

LoRa E32 transmitting scenarios, lines are channels.

There is a lot of methods to send/receive messages, and we are going to explain in detail:

    ResponseStatus sendMessage(const String message);
    ResponseContainer receiveMessage();

The first method is sendMessage and is used to send a String to a device in Normal mode.

ResponseStatus rs = e32ttl.sendMessage("Prova");
Serial.println(rs.getResponseDescription());

The other device simply does on the loop.

   if (e32ttl.available()  > 1){
    ResponseContainer rs = e32ttl.receiveMessage();
    String message = rs.data; // First ever get the data
    Serial.println(rs.status.getResponseDescription());
    Serial.println(message);
}

Pay attention if you receive multiple messages in the buffer, and you don’t want reading all in one time you must use ResponseContainer rs = e32ttl.receiveMessageUntil();

Manage structure

If you wish to send a complex structure, you can use this method

    ResponseStatus sendMessage(const void *message, const uint8_t size);
    ResponseStructContainer receiveMessage(const uint8_t size);

It’s used to send structure, for example:

struct Messaggione {
    char type[5];
    char message[8];
    bool mitico;
};
    struct Messaggione messaggione = {"TEMP", "Peple", true};
    ResponseStatus rs = e32ttl.sendMessage(&messaggione, sizeof(Messaggione));
Serial.println(rs.getResponseDescription());

and the other side, you can receive the message so

    ResponseStructContainer rsc = e32ttl.receiveMessage(sizeof(Messaggione));
    struct Messaggione messaggione = *(Messaggione*) rsc.data;
    Serial.println(messaggione.message);
    Serial.println(messaggione.mitico);

Read partial structure

If you want to read the first part of the message to manage more types of structure, you can use this method.

ResponseContainer receiveInitialMessage(const uint8_t size);

I create It to receive a string with type or other to identify the structure to load.

    struct Messaggione { // Partial strucutre without type
        char message[8];
        bool mitico;
    };

    char type[5]; // first part of structure
    ResponseContainer rs = e32ttl.receiveInitialMessage(sizeof(type));
            // Put string in a char array (not needed)
    memcpy ( type, rs.data.c_str(), sizeof(type) );

    Serial.println("READ TYPE: ");
    Serial.println(rs.status.getResponseDescription());
    Serial.println(type);

            // Read the rest of structure
    ResponseStructContainer rsc = e32ttl.receiveMessage(sizeof(Messaggione));
    struct Messaggione messaggione = *(Messaggione*) rsc.data;

Fixed mode instead of normal mode

In some manner, I create a set of methods to use with fixed transmission

Fixed transmission

You need to change only the sending method because the destination device doesn’t receive the preamble with Address and Channel when setting the fixed mode.

So for the String message, you have

    ResponseStatus sendFixedMessage(byte ADDH, byte ADDL, byte CHAN, const String message);
    ResponseStatus sendBroadcastFixedMessage(byte CHAN, const String message);

and for the structure, you have

    ResponseStatus sendFixedMessage(byte ADDH, byte ADDL, byte CHAN, const void *message, const uint8_t size);
    ResponseStatus sendBroadcastFixedMessage(byte CHAN, const void *message, const uint8_t size );

Here is a simple example

ResponseStatus rs = e32ttl.sendFixedMessage(0, 0, 0x17, &messaggione, sizeof(Messaggione));

// ResponseStatus rs = e32ttl.sendFixedMessage(0, 0, 0x17, "Ciao");

Fixed transmission have more scenarios

LoRa E32 transmitting scenarios, lines are channels

If you send to a specific device (second scenario Fixed transmission), you must add ADDL, ADDH, and CHAN to identify It directly.

ResponseStatus rs = e32ttl.sendFixedMessage(2, 2, 0x17, "Message to a device");

If you want to send a message to all devices in a specified Channel, you can use this method.

ResponseStatus rs = e32ttl.sendBroadcastFixedMessage(0x17, "Message to a devices of a channel");

If you wish to receive all broadcast messages in the network, you must set your ADDH and ADDL with BROADCAST_ADDRESS.

    ResponseStructContainer c;
c = e32ttl100.getConfiguration();
// It's important get configuration pointer before all other operation
Configuration configuration = *(Configuration*) c.data;
Serial.println(c.status.getResponseDescription());
Serial.println(c.status.code);

printParameters(configuration);
configuration.ADDL = BROADCAST_ADDRESS;
configuration.ADDH = BROADCAST_ADDRESS;

// Set configuration changed and set to not hold the configuration
ResponseStatus rs = e32ttl100.setConfiguration(configuration, WRITE_CFG_PWR_DWN_LOSE);
Serial.println(rs.getResponseDescription());
Serial.println(rs.code);
printParameters(configuration);

Thanks

Now you have all information to do your work, but I think It’s important to show some real examples to understand better all the possibilities.

1. LoRa E32 device for Arduino, esp32 or esp8266: settings and basic usage
2. LoRa E32 device for Arduino, esp32 or esp8266: library
3. LoRa E32 device for Arduino, esp32 or esp8266: configuration
4. LoRa E32 device for Arduino, esp32 or esp8266: fixed transmission
5. LoRa E32 device for Arduino, esp32 or esp8266: power saving and sending structured data
6. LoRa E32 device for Arduino, esp32 or esp8266: WOR (wake on radio) microcontroller and Arduino shield
7. LoRa E32 device for Arduino, esp32 or esp8266: WOR (wake on radio) microcontroller and WeMos D1 shield
8. EByte LoRa E32 device for Arduino, esp32 or esp8266: WOR (wake on radio) and new ESP32 shield
9. Ebyte LoRa E32 with STM32: WOR (wake on radio) and new STM32 shield

Github library

• Mischianti Arduino LoRa shield (Open source)
• Mischianti WeMos LoRa shield (Open source)
• Mischianti ESP32 DOIT DEV KIT v1 shield (Open source)
• STM32F1 Blue-Pill EByte LoRa E32, E22, and E220 Shield
• STM32F4 Black-Pill EByte LoRa E32, E22, and E220 Shield