Communiquer entre un module Ebyte E32 et un module RA01/02 SX1278

11 février 2023 SanglierLab Commentaires 2 commentaires

Il y a quelque temps je me suis procuré un module Ebyte E32-433. D’après la doc, c’est un module sans fil, longue portée, piloté par un port série (UART) et qui est basé sur la puce SEMTECH’s SX1278. La même qui se trouve sur les modules Ra01 et Ra02. À partir de là, on pourrait théoriquement pouvoir communiquer entre les deux. Néanmoins, c’est un peu plus complexe que je le pensais car la surcouche Ebyte ne permet pas de toucher à toutes les configurations du SX1278, on se sait pas réellement les paramètres utilisés (Spreading Factor, Coding rate, bandwidth) et peut être même que les données sont modifiées ? On va essayer de voir si c’est possible et de trouver les bons paramètres.

Pour les expérimentations, j’utilise de chaque côté un ESP32, d’un côté un module Ra01 avec la lib arduino LoRa (https://github.com/sandeepmistry/arduino-LoRa), et de l’autre un Ebyte E32-433T avec la lib E32 (https://github.com/xreef/LoRa_E32_Series_Library).

E32-433 vers Ra01

Configuration E32

Pour commencer, c’est le E32 qui va émettre. J’utilise l’exemple le plus simple fourni avec la librairie en configurant les paramètres par défaut ou les plus simples.

ADDH et ADDL = 0x00 (par défaut)
CHAN = 0x17 (433MHz) (par défaut)
Air Data Rate : 2.4k (par défaut)
FEC : désactivé (si activé, valeur par défaut, ça semble ajouter des données pour diminuer les interférences)
Power transmission : au minimum du module, vu que le récepteur est à côté.

#include <Arduino.h>
#include "src/LoRa_E32.h"

#define RXD2 16
#define TXD2 17
LoRa_E32 e32ttl(RXD2, TXD2, &Serial2, 14, 13, 12, UART_BPS_RATE_9600); // Arduino RX <-- e32 TX, Arduino TX --> e32 RX
void printParameters(struct Configuration configuration);
void printModuleInformation(struct ModuleInformation moduleInformation);
//The setup function is called once at startup of the sketch
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
      ; // wait for serial port to connect. Needed for native USB
    }
  delay(100);

  e32ttl.begin();

  // After set configuration comment set M0 and M1 to low
  // and reboot if you directly set HIGH M0 and M1 to program
  ResponseStructContainer c;
  c = e32ttl.getConfiguration();
  Configuration configuration = *(Configuration*) c.data;
  configuration.ADDL = 0x00;
  configuration.ADDH = 0x00;
  configuration.CHAN = 0x17;
  configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
  configuration.SPED.uartBaudRate = UART_BPS_9600;
  configuration.OPTION.transmissionPower = POWER_10;
  configuration.OPTION.fec = FEC_0_OFF;
  configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION;
  e32ttl.setConfiguration(configuration, WRITE_CFG_PWR_DWN_SAVE);
  printParameters(configuration);
  c.close();
  // ---------------------------
}

// The loop function is called in an endless loop
void loop()
{
  delay(10000);
  ResponseStatus rs = e32ttl.sendMessage("TEST");
  Serial.println(rs.getResponseDescription());
}

void printParameters(struct Configuration configuration) {
  Serial.println("----------------------------------------");

  Serial.print(F("HEAD : "));  Serial.print(configuration.HEAD, BIN);Serial.print(" ");Serial.print(configuration.HEAD, DEC);Serial.print(" ");Serial.println(configuration.HEAD, HEX);
  Serial.println(F(" "));
  Serial.print(F("AddH : "));  Serial.println(configuration.ADDH, BIN);
  Serial.print(F("AddL : "));  Serial.println(configuration.ADDL, BIN);
  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());

  Serial.println("----------------------------------------");

}
void printModuleInformation(struct ModuleInformation moduleInformation) {
  Serial.println("----------------------------------------");
  Serial.print(F("HEAD BIN: "));  Serial.print(moduleInformation.HEAD, BIN);Serial.print(" ");Serial.print(moduleInformation.HEAD, DEC);Serial.print(" ");Serial.println(moduleInformation.HEAD, HEX);

  Serial.print(F("Freq.: "));  Serial.println(moduleInformation.frequency, HEX);
  Serial.print(F("Version  : "));  Serial.println(moduleInformation.version, HEX);
  Serial.print(F("Features : "));  Serial.println(moduleInformation.features, HEX);
  Serial.println("----------------------------------------");

}

Code émetteur

Configuration RA01

Côté récepteur, on va jouer sur les paramètres Spreading Factor, Coding rate et Bandwidth pour trouver quand est-ce que ça reçoit des données en éliminant ceux qui donnent un Air Data Rate trop éloigné de celui configuré sur le module E32.

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <LoRa.h>

#define PIN_SS    5
#define PIN_RST   14
#define PIN_DIO0  2

String LoRaData;
int line = 10;


void setup(void) {
  Serial.begin(115200);

  Serial.println("LoRa Receiver");
   

  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
  while (!LoRa.begin(433E6)) {
    Serial.println(".");
    delay(500);
  }

LoRa.setSpreadingFactor(11);
LoRa.setSignalBandwidth(500E3);
LoRa.setCodingRate4(1);

LoRa.setTxPower(18);
  
Serial.println("LoRa Initializing OK!");
}



void loop(void) {
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    // received a packet
    Serial.print("Received packet '");
    Serial.println(packetSize);

    // read packet
    while (LoRa.available()) {
      Serial.print("0x");
      Serial.print((char)LoRa.read(), HEX);
      Serial.print(" ");
    }

    // print RSSI of packet
    Serial.print("' with RSSI ");
    Serial.println(LoRa.packetRssi());
  }
}

Code récepteur

Test de transmission

Le message envoyé est (et c’est un choix très original…) « TEST » !

Pour un envoi avec une configuration à 2.4kbps côté E32-433, on reçoit en configurant les paramètres suivant côté RA01 :

Fréquence : 433 (dans le constructeur)
SpreadingFactor : 11
Bandwidth : 500
Coding rate : 4:5 (donc le dénominateur 5 dans la fonction de la lib LoRa)

Le message reçu est :

0x44 0x17 0x00 0x00 0xE7 0xF6 0xE0 0xE7 0x1

A première vue, ça n’a rien à voir avec « TEST »… peut être que 0xE7 a un rapport avec le T, il apparaît 2 fois. C’est le cas, le message se compose :

44 : la taille du message (4 pour « TEST ») + 0x40
17 : le canal, 433MHz
00 00 l’adresse
E7 F6 E0 E7 : Le message chiffré avec XOR 0xB3 (E7^B3=54=T, F6^B3=45=E…),
01 : La somme de contrôle, 8 bits 2s complement de tout ce qu’il y a avant.

La clé qui chiffre le message (avec un simple OU exclusif) est dépendante du canal utilisé. Ici, j’ai utilisé le canal 0x17 (433MHz), lé clé est 0xB3. En utilisant le canal 0x18 (434MHz), la clé est 0xB2… avec le canal 0x19, la clé devient 0xB1.

Le message « TEST » envoyé au destinataire 0x00 0x05 avec 3 canaux différents :

0x44 0x17 0x0 0x5 0xE7 0xF6 0xE0 0xE7 0xFC
0x44 0x18 0x0 0x5 0xE6 0xF7 0xE1 0xE6 0xFB
0x44 0x19 0x0 0x5 0xE5 0xF4 0xE2 0xE5 0xFE

Pour les autres DataRate du E32-433, les configuration du RA01 qui correspondent sont :

E32-433	RA01
Air Data Rate (kbps)	Bandwidth (Hz)	SpreadingFactor	CodingRate
0,3	125000	12	4:5
1,2	250000	11	4:5
2,4	500000	11	4:5
4,8	250000	8	4:5
9,6	500000	8	4:5
19,2	500000	7	4:5

Attention, sur le RA01, la fonction LowDataRateOptimize du registre RegModemConfig3 doit être activée pour que ça fonctionne pour chaque configuration. La librairie arduino-LoRa ne l’active que dans certains cas en fonction des valeurs SpreadingFactor et Bandwidth. Il est donc nécessaire d’ajouter une fonction à la librairie permettant de modifier ce flag sans condition. Le 2.4kbps à l’air de fonctionner également sans.

void LoRaClass::setLdoFlag(bool b)
{
  uint8_t config3 = readRegister(REG_MODEM_CONFIG_3);
  bitWrite(config3, 3, b);
  writeRegister(REG_MODEM_CONFIG_3, config3);
}

Fonction à ajouter la la lib LoRa pour modifier le LowDataRateOptimize

Cas du FEC (forward error correction)

Le module E32 implémente un algo qui améliore la résistance aux interférences (d’après la doc).
En gros, chaque octet est remplacé par 2 octets préalablement définis dans une table de correspondance :

nibble	remplacement
0	0x55
1	0x56
2	0x59
3	0x5A
4	0x65
5	0x66
6	0x69
7	0x6A
8	0x95
9	0x96
A	0x99
B	0x9A
C	0xA5
D	0xA6
E	0xA9
F	0xAA

Ainsi, le canal 0x17, sera remplacé par 0x56 pour le 1 et 0x6A pour le 7.

Le message de test initial :

0x44 0x17 0x00 0x00 0xE7 0xF6 0xE0 0xE7 0x01

est donc remplacé par :

0x65 0x65 0x56 0x6A 0x55 0x55 0x55 0x55 0xA9 0x6A0xAA 0x69 0xA9 0x55 0xA9 0x6A 0x55 0x56 0x11 0xB4

Un CRC16 est ajouté à la fin (0x11 0xB4). Il est détaillé dans la partie suivante.

Ra01 vers E32-433

Configuration RA01

On va prendre la configuration à 9.6kbps pour ce test (totalement arbitrairement). On créé un buffer avec un message qui sera compréhensible par le module E32, avec la taille, le canal, l’adresse. Le message « TEST » est codé avec le XOR 0xB3. Une fonction calcule la checksum et l’ajoute à la fin.

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <LoRa.h>

#define PIN_SS    5
#define PIN_RST   14
#define PIN_DIO0  2

String LoRaData;
int line = 10;


void setup(void) {
  Serial.begin(115200);

  Serial.println("LoRa Receiver");
   

  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
  while (!LoRa.begin(433E6)) {
    Serial.println(".");
    delay(500);
  }

LoRa.setSpreadingFactor(8);
LoRa.setSignalBandwidth(500000);
LoRa.setCodingRate4(5);
LoRa.setTxPower(0);
LoRa.setLdoFlag(true);
  
Serial.println("LoRa Initializing OK!");

}

uint8_t     testIndex = 0;

void loop(void) {
  uint8_t     radioBuffer[12]   = {0};
    
  radioBuffer[0] = 0x40 + 7;  //Message size
  radioBuffer[1] = 0x17;      //Channel
  radioBuffer[2] = 0x00;      //Address
  radioBuffer[3] = 0x00;      //Address

  sprintf((char*)&radioBuffer[4], "TEST%3u", testIndex);

  //encode data with 0xB3 key
  for(uint8_t i = 4; i < 11; ++i){
    radioBuffer[i] = radioBuffer[i] ^ 0xB3;
  }

  //compute checksum
  radioBuffer[11] = checksum(radioBuffer, 11);
  
  for(uint8_t i = 0; i < 12; ++i){
    Serial.print("0x");
    if(radioBuffer[i] < 0x10)  Serial.print("0");
    Serial.print(radioBuffer[i], HEX);
    Serial.print(" ");
  }  
  Serial.println();

  LoRa.beginPacket();
  LoRa.write(radioBuffer, 12);
  LoRa.endPacket();

  testIndex++;
  delay(5000);
}

uint8_t checksum(uint8_t* buf, uint8_t s){
  uint32_t sum = 0;
  for(uint8_t i = 0; i < s; ++i){
    sum += buf[i];
  }
  sum = 0x100 - (sum & 0xFF);
  return (uint8_t)sum;
}

Ra01 en émetteur

Configuration E32-433

Côté module E32, la configuration en récepteur est minimale. Le FEC est désactivé.

#include <Arduino.h>
#include "src/LoRa_E32.h"

#define RXD2 16
#define TXD2 17
LoRa_E32 e32ttl(RXD2, TXD2, &Serial2, 14, 13, 12, UART_BPS_RATE_9600); // Arduino RX <-- e32 TX, Arduino TX --> e32 RX
void printParameters(struct Configuration configuration);
void printModuleInformation(struct ModuleInformation moduleInformation);
//The setup function is called once at startup of the sketch
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
      ; // wait for serial port to connect. Needed for native USB
    }
  delay(100);

  e32ttl.begin();

  // After set configuration comment set M0 and M1 to low
  // and reboot if you directly set HIGH M0 and M1 to program
  ResponseStructContainer c;
  c = e32ttl.getConfiguration();
  Configuration configuration = *(Configuration*) c.data;
  configuration.ADDL = 0x00;
  configuration.ADDH = 0x00;
  configuration.CHAN = 0x17;
  configuration.SPED.airDataRate = AIR_DATA_RATE_100_96;
  configuration.SPED.uartBaudRate = UART_BPS_9600;
  configuration.OPTION.transmissionPower = POWER_10;
  configuration.OPTION.fec = FEC_0_OFF;
  configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION;
  e32ttl.setConfiguration(configuration, WRITE_CFG_PWR_DWN_SAVE);
  printParameters(configuration);
  c.close();
  // ---------------------------
}

// The loop function is called in an endless loop
void loop()
{
  if (e32ttl.available()>1) {
    // read the String message
    ResponseContainer rc = e32ttl.receiveMessage();
    // Is something goes wrong print error
    if (rc.status.code!=1){
      rc.status.getResponseDescription();
    } else {
      // Print the data received
      Serial.println(rc.data);
    }
  }
}

void printParameters(struct Configuration configuration) {
  Serial.println("----------------------------------------");

  Serial.print(F("HEAD : "));  Serial.print(configuration.HEAD, BIN);Serial.print(" ");Serial.print(configuration.HEAD, DEC);Serial.print(" ");Serial.println(configuration.HEAD, HEX);
  Serial.println(F(" "));
  Serial.print(F("AddH : "));  Serial.println(configuration.ADDH, BIN);
  Serial.print(F("AddL : "));  Serial.println(configuration.ADDL, BIN);
  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());

  Serial.println("----------------------------------------");

}
void printModuleInformation(struct ModuleInformation moduleInformation) {
  Serial.println("----------------------------------------");
  Serial.print(F("HEAD BIN: "));  Serial.print(moduleInformation.HEAD, BIN);Serial.print(" ");Serial.print(moduleInformation.HEAD, DEC);Serial.print(" ");Serial.println(moduleInformation.HEAD, HEX);

  Serial.print(F("Freq.: "));  Serial.println(moduleInformation.frequency, HEX);
  Serial.print(F("Version  : "));  Serial.println(moduleInformation.version, HEX);
  Serial.print(F("Features : "));  Serial.println(moduleInformation.features, HEX);
  Serial.println("----------------------------------------");

}

Module E32 en récepteur

Test de transmission

Le message est bien reçu côté module E32. Seul le message est extrait, les données techniques disparaissent.

Cas du FEC (forward error correction)

Si on active le FEC côté E32 en réception, il va falloir encoder le message à envoyer en remplaçant chaque nibble par l’octet correspondant dans le tableau de la partie précédente.

Il faut ensuite calculer le CRC16 et l’ajouter à la fin. Il est calculé avec les paramètres suivants :

Polynôme : 0x1021
Valeur initiale : 0x99C0
Final XOR : 0x0000
Entrée inversée
Sortie inversée

La lookup table associée est :

static const uint16_t crc16[256] =
{
	0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
	0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
	0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
	0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
	0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
	0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
	0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
	0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
	0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
	0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
	0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
	0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
	0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
	0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
	0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
	0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
};

Lookup table du CRC16

2 réflexions sur « Communiquer entre un module Ebyte E32 et un module RA01/02 SX1278 »

al1fch dit :

12 février 2023 à 8 h 26 min

Bonjour

Une notification émise par le dépot de SandeepMistry (bibliothèque LoRa) m’amène ici

Superbe article clair , détaillé, méthodique sur un sujet que j’avais juste effleuré auparavant. (A l’époque j’envisageais un ESP32+SX1276 comme passerelle LoRpour des capteurs dotés de E32-868, j’ai finalement opté pour LoRaWAN)

Je découvre ici la problématique du LowDataRateOptimize.

Cordialement,

Alain (pseudo al1fch)

Répondre
YodaPuces dit :

13 février 2023 à 23 h 41 min

Bonjour

Depuis plusieurs jours j’essaye une coom avec le E32 et un RA-01 sans succès: que des bytes sans concistance !

Tout est résolus grace au « setLdoFlag(bool b) »!

Je passe de:

21 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7 F5
21 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7 F5
21 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7 F5
21 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7 F5
21 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7 F5
21 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7 F5
20 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7
20 : DE ED D8 63 CE 91 E2 B5 A 64 B8 1 62 B5 1B 47 FE 9D 5B A7

a:
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54
18 : 4D 17 FF FF F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 F2 54

(j’envoie « AAAAAAAAAAAAA »)

Pour les débutant (comme moi) …:

Ajoutez en plus dans le fichier « LoRa.h » et la partie « Public »:

void setLdoFlag(bool b);

..et dans le fichier « LoRa.cpp »:

void LoRaClass::setLdoFlag(bool b)
{
uint8_t config3 = readRegister(REG_MODEM_CONFIG_3);
bitWrite(config3, 3, b);
writeRegister(REG_MODEM_CONFIG_3, config3);
}

…quelque part après la fonction « void LoRaClass::setLdoFlag() »

Grand Merci à Sanglier pour son tuto/labo super bien fait !

Répondre

SanglierLab : Le labo du sanglier…

Le labo du sanglier…

Communiquer entre un module Ebyte E32 et un module RA01/02 SX1278

11 février 2023 SanglierLab Commentaires 2 commentaires

E32-433 vers Ra01

Configuration E32

Configuration RA01

Test de transmission

Cas du FEC (forward error correction)

Ra01 vers E32-433

Configuration RA01

Configuration E32-433

Test de transmission

Cas du FEC (forward error correction)

2 réflexions sur « Communiquer entre un module Ebyte E32 et un module RA01/02 SX1278 »

Laisser un commentaire Annuler la réponse