EByte_LoRa_E22_Series_Library
1.0.0
https://downloads.arduino.cc/libraries/logs/github.com/xreef/ebyte_lora_e22_series_library/
Vous pouvez commander le PCB ici
Vidéo d'instruction et d'assemblage sur 6 parties du guide
Vous pouvez commander le PCB ici
Vidéo d'instruction et d'assemblage sur 6 parties du guide
Je crée une bibliothèque pour gérer la série EBYTE E22 de l'appareil LORA, un appareil très puissant, simple et bon marché.
La télémétrie de données sans fil LORA ou à longue portée est une technologie lancée par SEMTECH qui fonctionne à une fréquence plus faible que NRF24L01 (433 MHz, 868 MHz ou 916 MHz à nouveau 2,4 GHz pour le NRF24L01) mais à la distance (de 4000 m à 10000 m).
Lora E22
Vous pouvez trouver ici AliExpress (433 MHz 4 km) - AliExpress (433 MHz 10 km)
Veuillez vous référer à mon article pour obtenir un schéma mis à jour
Vous pouvez trouver ma bibliothèque ici.
Pour télécharger.
Cliquez sur le bouton Téléchargement dans le coin supérieur droit, renommez le dossier non compressé LORA_E22.
Vérifiez que le dossier LORA_E22 contient LORA_E22.CPP et LORA_E22.H.
Placez le dossier de bibliothèque LORA_E22 votre / les bibliothèques / dossier.
Vous devrez peut-être créer le sous-dossier des bibliothèques si c'est votre première bibliothèque.
Redémarrez l'IDE.
E22
| PIN N ° | Épingle | Direction | Application PIN |
|---|---|---|---|
| 1 | M0 | Entrée （Pull-up faible） | Travailler avec M1 et décider les quatre modes de fonctionnement.La le travail n'est pas autorisé, peut être broyé. |
| 2 | M1 | Entrée （Pull-up faible） | Travailler avec M0 et décider les quatre modes de fonctionnement. Le flottement n'est pas autorisé, peut être broyé. |
| 3 | Rxd | Saisir | Entrées TTL UART, se connecte à la sortie TXD externe (MCU, PC). Peut être configuré comme entrée à drain ouvert ou à pull-up. |
| 4 | Txd | Sortir | Sorties TTL UART, se connecte à RXD externe (MCU, PC) InputPin. Peut être configuré comme sortie de drain ouvert ou push-pull |
5 | Aux | Sortir | Par indicare lo stato di funzionamento del modulo e riattivare L'Esterno. Durante la procédura di inizilizzazione di autocontrollo, il broche emette una bassa Tensione. Può Essere Configurato Come Uscita Open-Drain o Output Push-Pull (è Consentito Non Metterlo a terra, ma se hai ProblemI, ad eSempio ti Si Freeze il Disitivo è préférée Mettere una Restistenza di Pull-up da 4.7ko Meglio Collegarlo al Dispositivo). |
| 6 | VCC | Alimentation 2,3 V ~ 5,5 V CC | |
| 7 | GND | Sol |
Comme vous pouvez le voir, vous pouvez définir divers modes via des broches M0 et M1.
| Mode | M1 | M0 | Explication |
|---|---|---|---|
| Normale | 0 | 0 | UART et le canal sans fil sont ouverts, la transmission transparente est activée (prend en charge la configuration sur l'air via la commande spéciale) |
| Mode wor | 0 | 1 | Peut être défini comme l'émetteur WOR et le récepteur WOR |
| Mode de configuration | 1 | 0 | Les utilisateurs peuvent accéder au registre via le port série pour contrôler l'état de travail du module |
| Mode de sommeil profond | 1 | 1 | Mode de sommeil |
Comme vous pouvez le voir, il existe des broches qui peuvent être utilisées de manière statique, mais si vous la connectez à la bibliothèque, vous gagnez en performances et vous pouvez contrôler tout le mode via le logiciel, mais nous allons mieux expliquer ensuite.
Comme je le dis déjà, il n'est pas important de connecter toute la broche à la sortie du microcontrôleur, vous pouvez mettre des broches M0 et M1 à une configuration à haut ou basse pour obtenir une configuration de dessider, et si vous ne connectez pas AUX, la bibliothèque définit un délai raisonnable pour être sûr que l'opération est terminée .
Lors de la transmission de données, des données peuvent être utilisées pour réveiller le MCU externe et retourner haut sur la finition de transfert de données.
LORA E22 AUX PIN SUR LE TRANSMISSION
Lors de la réception de Aux, devenu bas et de revenir haut lorsque le tampon est vide.
Lora E22 Aux Pin à la réception
Il est également utilisé pour l'auto-vérification pour restaurer le fonctionnement normal (en mode Power-On et Sleep / Program).
LORA E22 AUX PIN sur l'auto-vérification
Le schéma de connexion ESP8266 est plus simple car il fonctionne à la même tension de communications logiques (3,3 V).
LORA E22 TTL 100 WEMOS D1 entièrement connecté
Il est important d'ajouter une résistance de traction (4,7kehm) pour obtenir une bonne stabilité.
| E22 | ESP8266 |
|---|---|
| M0 | D7 |
| M1 | D6 |
| TX | Broche D2 (pullup 4,7KΩ) |
| Rx | Broche D3 (pullup 4,7KΩ) |
| Aux | Broche D5 (pullup 4,7KΩ) |
| VCC | 5V (mais travaillez avec moins de puissance en 3,3 V) |
| GND | GND |
Schéma de connexion similaire pour ESP32, mais pour Rx et Tx, nous utilisons RX2 et TX2, car par défaut ESP32 n'a pas de logiciel mais a 3 sérial.
EBYTE LORA E22 Device ESP32 Dev Kit V1 Breadboard Connexion complète
| E22 | ESP32 |
|---|---|
| M0 | D21 |
| M1 | D19 |
| TX | Broche rx2 (pullup 4,7KΩ) |
| Rx | Épingle TX3 (pullup 4,7KΩ) |
| Aux | Broche D18 (pullup 4,7KΩ) |
| VCC | 5V (mais travaillez avec moins de puissance en 3,3 V) |
| GND | GND |
La tension de travail Arduino est 5V, nous devons donc ajouter un diviseur de tension sur RX PIN M0 et M1 du module LORA pour éviter les dommages, vous pouvez obtenir plus d'informations ici Divider de tension: calculatrice et application.
Vous pouvez utiliser une résistance de 2 kohm à GND et 1 kohm du signal que réunie sur RX.
LORA E22 TTL 100 Arduino entièrement connecté
| M0 | 7 (diviseur de tension) |
| M1 | 6 (diviseur de tension) |
| TX | Broche 2 (pullup 4,7KΩ) |
| Rx | PIN 3 (Pullup 4,7KΩ et diviseur de tension) |
| Aux | Broche 5 (pullup 4,7KΩ) |
| VCC | 5V |
| GND | GND |
J'ai fait un ensemble de constructeurs assez nombreux, car nous pouvons avoir plus d'options et de situations à gérer.
LoRa_E22 (byte rxPin, byte txPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E22 (byte rxPin, byte txPin, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E22 (byte rxPin, byte txPin, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);Le premier ensemble de constructeurs est la création pour déléguer la gestion des broches série et autres à la bibliothèque.
txE22pin et rxE22pin est la broche pour se connecter à UART et elles sont obligatoires .auxPin est une broche qui vérifie le fonctionnement, la transmission et le statut de réception (nous allons expliquer mieux ensuite), cette broche n'est pas obligatoire , si vous ne le définissez pas, j'applique un retard pour permettre à l'opération de se compléter (avec la latence, si vous avez des problèmes, comme le dispositif de gel, vous devez mettre un résistance de 4,7k de traction ou mieux à l'appareil ).m0pin et m1Pin sont les broches pour modifier le mode de fonctionnement (voir le tableau supérieur), je pense que ces épingles de «production» vont se connecter directement ou bas , mais pour le test, ils doivent être gérés par la bibliothèque.bpsRate est le boudrate du logiciel normalement est normalement de 9600 (le seul taux de bauds en mode programmin / sommeil)Un exemple simple est
# include " LoRa_E22.h "
LoRa_E22 e22ttl100 ( 2 , 3 ); // RX, TX
// LoRa_E22 e22ttl100(2, 3, 5, 6, 7); // RX, TXNous pouvons utiliser directement un logiciel avec un autre constructeur
LoRa_E22 (HardwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E22 (HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E22 (HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);L'exemple supérieur avec ce constructeur peut être le faire comme ainsi.
# include < SoftwareSerial.h >
# include " LoRa_E22.h "
SoftwareSerial mySerial ( 2 , 3 ); // RX, TX
LoRa_E22 e22ttl100 (mySerial);
// LoRa_E22 e22ttl100(&mySerial, 5, 7, 6);Le dernier ensemble de constructeurs est de permettre d'utiliser un hardwareserial au lieu d'un logiciel.
LoRa_E22 (SoftwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E22 (SoftwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E22 (SoftwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);La commande begin est utilisée pour démarrer la série et les broches en mode entrée et sortie.
void begin ();dans l'exécution est
// Startup all pins and UART
e22ttl100.begin();Il y a un ensemble de méthodes pour gérer la configuration et obtenir des informations sur l'appareil.
ResponseStructContainer getConfiguration ();
ResponseStatus setConfiguration (Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);
ResponseStructContainer getModuleInformation ();
void printParameters ( struct Configuration configuration);Pour simplifier la gestion de la réponse, je crée un ensemble de conteneurs, pour moi très utilement pour gérer les erreurs et renvoyer des données génériques.
Il s'agit d'un conteneur d'état et d'avoir 2 points d'entrée simples, avec cela, vous pouvez obtenir le code d'état et la description du code d'état
Serial.println(c.getResponseDescription()); // Description of code
Serial.println(c.code); // 1 if SuccessLe code sont
E22_SUCCESS = 1 ,
ERR_E22_UNKNOWN,
ERR_E22_NOT_SUPPORT,
ERR_E22_NOT_IMPLEMENT,
ERR_E22_NOT_INITIAL,
ERR_E22_INVALID_PARAM,
ERR_E22_DATA_SIZE_NOT_MATCH,
ERR_E22_BUF_TOO_SMALL,
ERR_E22_TIMEOUT,
ERR_E22_HARDWARE,
ERR_E22_HEAD_NOT_RECOGNIZEDCe conteneur est créé pour gérer la réponse des chaînes et avoir 2 points d'entrée.
data avec la chaîne renvoyée du message et status Une instance de RepsonseStatus .
ResponseContainer rs = e22ttl.receiveMessage();
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);Il s'agit du conteneur plus «complexe», je l'utilise pour gérer la structure, il a le même point d'entrée de réponses de réponse mais les données sont un pointeur vide pour gérer la structure complexe.
ResponseStructContainer c;
c = e22ttl100.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();La première méthode est GetConfiguration, vous pouvez l'utiliser pour récupérer toutes les données stockées sur l'appareil.
ResponseStructContainer getConfiguration ();Ici un exemple d'utilisation.
ResponseStructContainer c;
c = e22ttl100.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());
c.close();La structure de la configuration a toutes les données de paramètres, et j'ajoute une série de fonctions pour obtenir toute la description des données uniques.
configuration.ADDL = 0x03 ; // First part of address
configuration.ADDH = 0x00 ; // Second part
configuration.NETID = 0x00 ; // NETID used for repeater function
configuration.CHAN = 23 ; // Communication channel
configuration.SPED.uartBaudRate = UART_BPS_9600; // Serial baud rate
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24; // Air baud rate
configuration.SPED.uartParity = MODE_00_8N1; // Parity bit
configuration.OPTION.subPacketSetting = SPS_240_00; // Packet size
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_DISABLED; // Need to send special command
configuration.OPTION.transmissionPower = POWER_22; // Device power
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED; // Enable RSSI info
configuration.TRANSMISSION_MODE.fixedTransmission = FT_TRANSPARENT_TRANSMISSION; // Transmission type
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED; // Enable repeater mode
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED; // Check interference
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_RECEIVER; // Enable WOR mode
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011; // WOR timingVous avez la fonction équivalente pour obtenir toute description:
DEBUG_PRINT (F( " HEAD : " )); DEBUG_PRINT(configuration.COMMAND, HEX);DEBUG_PRINT( " " );DEBUG_PRINT(configuration.STARTING_ADDRESS, HEX);DEBUG_PRINT( " " );DEBUG_PRINTLN(configuration.LENGHT, HEX);
DEBUG_PRINTLN (F( " " ));
DEBUG_PRINT (F( " AddH : " )); DEBUG_PRINTLN(configuration.ADDH, HEX);
DEBUG_PRINT (F( " AddL : " )); DEBUG_PRINTLN(configuration.ADDL, HEX);
DEBUG_PRINT (F( " NetID : " )); DEBUG_PRINTLN(configuration.NETID, HEX);
DEBUG_PRINTLN (F( " " ));
DEBUG_PRINT (F( " Chan : " )); DEBUG_PRINT(configuration.CHAN, DEC); DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.getChannelDescription());
DEBUG_PRINTLN (F( " " ));
DEBUG_PRINT (F( " SpeedParityBit : " )); DEBUG_PRINT(configuration.SPED.uartParity, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.SPED.getUARTParityDescription());
DEBUG_PRINT (F( " SpeedUARTDatte : " )); DEBUG_PRINT(configuration.SPED.uartBaudRate, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.SPED.getUARTBaudRateDescription());
DEBUG_PRINT (F( " SpeedAirDataRate : " )); DEBUG_PRINT(configuration.SPED.airDataRate, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.SPED.getAirDataRateDescription());
DEBUG_PRINTLN (F( " " ));
DEBUG_PRINT (F( " OptionSubPacketSett: " )); DEBUG_PRINT(configuration.OPTION.subPacketSetting, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.OPTION.getSubPacketSetting());
DEBUG_PRINT (F( " OptionTranPower : " )); DEBUG_PRINT(configuration.OPTION.transmissionPower, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.OPTION.getTransmissionPowerDescription());
DEBUG_PRINT (F( " OptionRSSIAmbientNo: " )); DEBUG_PRINT(configuration.OPTION.RSSIAmbientNoise, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.OPTION.getRSSIAmbientNoiseEnable());
DEBUG_PRINTLN (F( " " ));
DEBUG_PRINT (F( " TransModeWORPeriod : " )); DEBUG_PRINT(configuration.TRANSMISSION_MODE.WORPeriod, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.TRANSMISSION_MODE.getWORPeriodByParamsDescription());
DEBUG_PRINT (F( " TransModeTransContr: " )); DEBUG_PRINT(configuration.TRANSMISSION_MODE.WORTransceiverControl, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.TRANSMISSION_MODE.getWORTransceiverControlDescription());
DEBUG_PRINT (F( " TransModeEnableLBT : " )); DEBUG_PRINT(configuration.TRANSMISSION_MODE.enableLBT, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.TRANSMISSION_MODE.getLBTEnableByteDescription());
DEBUG_PRINT (F( " TransModeEnableRSSI: " )); DEBUG_PRINT(configuration.TRANSMISSION_MODE.enableRSSI, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.TRANSMISSION_MODE.getRSSIEnableByteDescription());
DEBUG_PRINT (F( " TransModeEnabRepeat: " )); DEBUG_PRINT(configuration.TRANSMISSION_MODE.enableRepeater, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.TRANSMISSION_MODE.getRepeaterModeEnableByteDescription());
DEBUG_PRINT (F( " TransModeFixedTrans: " )); DEBUG_PRINT(configuration.TRANSMISSION_MODE.fixedTransmission, BIN);DEBUG_PRINT( " -> " ); DEBUG_PRINTLN(configuration.TRANSMISSION_MODE.getFixedTransmissionDescription());À la même manière, SetConfiguration veut un strucutre de configuration, donc je pense que la meilleure façon de gérer la configuration est de récupérer la courance actuelle, d'appliquer le seul changement dont vous avez besoin et de le remettre à nouveau.
ResponseStatus setConfiguration (Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE); configuration est le Strucutre affiché prévisionnellement, saveType vous permette de Choiche si le changement ne devient définitivement que pour la session en cours.
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 = 0x03 ; // First part of address
configuration.ADDH = 0x00 ; // Second part
configuration.NETID = 0x00 ; // NETID used for repeater function
configuration.CHAN = 23 ; // Communication channel
configuration.SPED.uartBaudRate = UART_BPS_9600; // Serial baud rate
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24; // Air baud rate
configuration.SPED.uartParity = MODE_00_8N1; // Parity bit
configuration.OPTION.subPacketSetting = SPS_240_00; // Packet size
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_DISABLED; // Need to send special command
configuration.OPTION.transmissionPower = POWER_22; // Device power
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED; // Enable RSSI info
configuration.TRANSMISSION_MODE.fixedTransmission = FT_TRANSPARENT_TRANSMISSION; // Transmission type
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED; // Enable repeater mode
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED; // Check interference
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_RECEIVER; // Enable WOR mode
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011; // WOR timing
// 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);
c.close()Le paramètre tous gérés comme constant:
| Addition | Octet d'adresse élevé du module (la valeur par défaut 00h) | 00H-FFH |
| Addl | Byte d'adresse faible du module (la par défaut 00h) | 00H-FFH |
| Vomir | Informations sur le bit de parité de données et le débit de données aérien | |
| Chan | Canal de communication （410m + chan * 1m）, par défaut 17h (433 MHz), valide uniquement pour le périphérique 433 MHz CHEK ci-dessous pour vérifier la fréquence correcte de votre appareil | 00h-1fh |
| OPTION | Type de transmission, taille de paquet, autoriser un message spécial | |
| Transmission_mode | Beaucoup de paramètres qui spécifient la modalité de transmission |
OPTION
Type de transmission, paramètres de traction, temps de réveil, FEC, puissance de transmission
Bit de parité UART: le mode UART peut être différent entre les parties de communication
| 4 | 3 | Bit de parité UART | Valeur constante |
| 0 | 0 | 8n1 (par défaut) | Mode_00_8n1 |
| 0 | 1 | 8O1 | Mode_01_8o1 |
| 1 | 0 | 8 E1 | Mode_10_8e1 |
| 1 | 1 | 8N1 (égal à 00) | Mode_11_8n1 |
Taux UART BAUD: le taux de bauds UART peut être différent entre les parties de communication, le taux de bauds UART n'a rien à voir avec les paramètres de transmission sans fil et n'affectera pas les fonctionnalités de transmission / réception sans fil.
| 7 | 6 | 5 | TTL UART BAUD TAUX （BPS） | Valeur constante |
| 0 | 0 | 0 | 1200 | UART_BPS_1200 |
| 0 | 0 | 1 | 2400 | UART_BPS_2400 |
| 0 | 1 | 0 | 4800 | UART_BPS_4800 |
| 0 | 1 | 1 | 9600 (par défaut) | UART_BPS_9600 |
| 1 | 0 | 0 | 19200 | UART_BPS_19200 |
| 1 | 0 | 1 | 38400 | UART_BPS_38400 |
| 1 | 1 | 0 | 57600 | UART_BPS_57600 |
| 1 | 1 | 1 | 115200 | UART_BPS_115200 |
Débit de données de l'air: plus le débit de données de l'air est faible, plus la distance de transmission, de meilleures performances anti-interférence et le temps de transmission plus long, le débit de données de l'air doit conserver la même chose pour les deux parties de communication.
| 2 | 1 | 0 | Taux de données de l'air （BPS） | Valeur constante |
| 0 | 0 | 0 | 0,3k | AIR_DATA_RATE_000_03 |
| 0 | 0 | 1 | 1,2k | AIR_DATA_RATE_001_12 |
| 0 | 1 | 0 | 2.4k (par défaut) | AIR_DATA_RATE_010_24 |
| 0 | 1 | 1 | 4.8k | AIR_DATA_RATE_011_48 |
| 1 | 0 | 0 | 9,6k | AIR_DATA_RATE_100_96 |
| 1 | 0 | 1 | 19.2k | Air_data_rate_101_192 |
| 1 | 1 | 0 | 38,4k | AIR_DATA_RATE_110_384 |
| 1 | 1 | 1 | 62,5k | Air_data_Rate_111_625 |
#### Paramètre de sous-paquet
Ceci est le lanssage maximal du paquet.
Lorsque les données sont plus petites que la longueur de sous-paquet, la sortie série de l'extrémité de réception est une sortie continue ininterrompue. Lorsque les données sont plus grandes que la longueur de sous-paquet, le port de série de réception de fin publiera le sous-paquet.
| 7 | 6 | Paquet | Valeur constante |
| 0 | 0 | 240 bytes (par défaut) | SPS_240_00 |
| 0 | 1 | 128 bytes | SPS_128_01 |
| 1 | 0 | 64 bytes | SPS_064_10 |
| 1 | 1 | 32 bytes | SPS_032_11 |
#### RSSI AMBRIE AMPORT
Cette commande peut activer / désactiver le type de gestion de RSSI, il est important de gérer la configuration distante, faire attention n'est pas le paramètre RSSI dans le message.
Lorsqu'il est activé, la commande C0 C1 C2 C3 peut être envoyée dans le mode de transmission ou le mode de transmission WOR pour lire le registre. Registre 0x00: Rester RSSI Ambient Noise RSSI Current 0x01: RSSI lorsque les données ont été reçues la dernière fois.
| 5 | RSSI AMPORT AMPORT | Valeur constante |
| 0 | Activer | RSSI_AMBIENT_NOISE_ENABLEAD |
| 1 | Désactiver (par défaut) | RSSI_AMBIENT_NOISE_DISABLEAD |
#### puissance de transmission
Vous pouvez modifier cet ensemble de constante en appliquant une définition comme tel:
# define E22_22 // default value without set
# define E22_30Vous pouvez configurer la fréquence des canaux OLSO avec cette définition:
// One of
# define FREQUENCY_433
# define FREQUENCY_170
# define FREQUENCY_470
# define FREQUENCY_868
# define FREQUENCY_915#### Activer RSSI
Lorsqu'il est activé, le module reçoit des données sans fil et elle suivra un octet de résistance RSSI après la sortie via le port série TXD
Type de transmission ####
Mode de transmission: En mode de transmission fixe, les trois premiers octets de la trame de données de chaque utilisateur peuvent être utilisés comme adresse et canal élevé / bas. Le module modifie son adresse et son canal lors de la transmission. Et il reviendra au paramètre d'origine après avoir terminé le processus.
#### Activer la fonction de répéteur
#### Monitor Données avant la transmission
Lorsqu'ils sont activés, les données sans fil seront surveillées avant leur transmission, ce qui peut éviter les interférences dans une certaine mesure, mais peut entraîner un retard de données.
#### WOR
Émetteur WOR: les fonctions de réception et de transmission du module sont activées et un code de réveil est ajouté lors de la transmission de données. La réception est activée.
Récepteur WOR: Le module n'est pas en mesure de transmettre des données et fonctionne en mode de surveillance WOR. La période de surveillance est la suivante (WOR CYCLE), ce qui peut économiser beaucoup de puissance.
#### Wor Cycle
Si WOR est transmis: après que le récepteur WOR a reçu les données sans fil et les sortira via le port série, il attendra 1000 ms avant de pénétrer à nouveau dans le WOR. Les utilisateurs peuvent saisir les données du port série et les renvoyer via le sans fil pendant cette période. Chaque octet de série sera actualisé pendant 1000 ms. Les utilisateurs doivent transmettre le premier octet dans les 1000 ms.
Nous devons d'abord introduire une méthode simple mais utilement pour vérifier si quelque chose se trouve dans le tampon de réception
int available ();Il est simplement renvoyé combien d'octets vous avez dans le flux actuel.
Le mode de transmission normal / transparent est utilisé pour envoyer des messages à tous les appareils avec la même adresse et le même canal.
LORA E22 Transmission Scénarios, les lignes sont des canaux
Il existe beaucoup de méthode pour envoyer / recevoir un message, nous allons expliquer en détail:
ResponseStatus sendMessage ( const String message);ResponseContainer receiveMessage ();La première méthode est SendMessage et est utilisée pour envoyer une chaîne à un appareil en mode normal .
ResponseStatus rs = e22ttl.sendMessage( " Prova " );
Serial.println(rs.getResponseDescription());L'autre appareil fait simplement sur la boucle
if (e22ttl.available() > 1 ){
ResponseContainer rs = e22ttl. receiveMessage ();
String message = rs. data ;` ` // First ever get the data
Serial. println (rs. status . getResponseDescription ());
Serial. println (message);
}Si vous souhaitez envoyer une structure complexe, vous pouvez utiliser cette méthode
ResponseStatus sendMessage ( const void *message, const uint8_t size);
ResponseStructContainer receiveMessage ( const uint8_t size);Il est utilisé pour envoyer Strucutre, par exemple:
struct Messaggione {
char type[ 5 ];
char message[ 8 ];
bool mitico;
};
struct Messaggione messaggione = { " TEMP " , " Peple " , true };
ResponseStatus rs = e22ttl.sendMessage(&messaggione, sizeof (Messaggione));
Serial.println(rs.getResponseDescription());Et l'autre côté, vous pouvez recevoir le message donc
ResponseStructContainer rsc = e22ttl.receiveMessage( sizeof (Messaggione));
struct Messaggione messaggione = *(Messaggione*) rsc.data;
Serial.println(messaggione.message);
Serial.println(messaggione.mitico);Si vous souhaitez lire la première partie du message pour gérer plus de type de strucutre, vous pouvez utiliser cette méthode.
ResponseContainer receiveInitialMessage ( const uint8_t size);Je le crée pour recevoir une chaîne avec type ou autre pour identifier la structure à charger.
struct Messaggione { // Partial strucutre without type
char message[ 8 ];
bool mitico;
};
char type[ 5 ]; // first part of structure
ResponseContainer rs = e22ttl.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 = e22ttl.receiveMessage( sizeof (Messaggione));
struct Messaggione messaggione = *(Messaggione*) rsc.data;À la même manière, je crée un ensemble de méthode à utiliser avec une transmission fixe
Vous devez ne modifier que la méthode d'envoi, car le périphérique de destination ne reçoit pas le préambule avec l'adresse et le canal.
Donc pour le message de chaîne que vous avez
ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const String message);
ResponseStatus sendBroadcastFixedMessage (byte CHAN, const String message);Et pour la structure que vous avez
ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const void *message, const uint8_t size);
ResponseStatus sendBroadcastFixedMessage (byte CHAN, const void *message, const uint8_t size );Ici un exemple simple
ResponseStatus rs = e22ttl.sendFixedMessage( 0 , 0 , 0x17 , &messaggione, sizeof (Messaggione));
// ResponseStatus rs = e22ttl.sendFixedMessage(0, 0, 0x17, "Ciao");La transmission fixe a plus de scénarios
LORA E22 Transmission Scénarios, les lignes sont des canaux
Si vous envoyez un appareil spécifique (deuxième scénarios fixe transmission), vous devez ajouter Addl, Addh et Chan pour l'identifier directement.
ResponseStatus rs = e22ttl.sendFixedMessage( 2 , 2 , 0x17 , " Message to a device " );Si vous souhaitez envoyer un message à tous les périphériques dans un canal spécifié, vous pouvez utiliser cette méthode.
ResponseStatus rs = e22ttl.sendBroadcastFixedMessage( 0x17 , " Message to a devices of a channel " ); Si vous souhaitez recevoir tous les messages de diffusion dans le réseau, vous devez définir votre ADDH et ADDL avec BROADCAST_ADDRESS .
ResponseStructContainer c;
c = e22ttl100.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 = e22ttl100.setConfiguration(configuration, WRITE_CFG_PWR_DWN_LOSE);
Serial.println(rs.getResponseDescription());
Serial.println(rs.code);
printParameters (configuration);
c.close();### Configuration sans fil
Cet appareil prend en charge la configuration sans fil avec la commande séparé, mais ne semble pas fonctionner, je demande à ebyte mais aucune réponse reçue.
J'implémente une commande qui envoie le paquet de la bonne manière (testée avec l'analyseur logique) mais ne semble pas fonctionner.
Soit dit en passant, d'abord vous-vous activer l'environnement de bruit RSSI, que vous pouvez utiliser la commande comme tel:
Configuration configuration;
configuration.ADDL = 0x13 ;
configuration.ADDH = 0x13 ;
configuration.NETID = 0x00 ;
configuration.CHAN = 23 ;
configuration.SPED.uartBaudRate = UART_BPS_9600;
configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
configuration.SPED.uartParity = MODE_00_8N1;
configuration.OPTION.subPacketSetting = SPS_240_00;
configuration.OPTION.RSSIAmbientNoise = RSSI_AMBIENT_NOISE_DISABLED;
configuration.OPTION.transmissionPower = POWER_22;
configuration.TRANSMISSION_MODE.enableRSSI = RSSI_DISABLED;
configuration.TRANSMISSION_MODE.fixedTransmission = FT_FIXED_TRANSMISSION;
configuration.TRANSMISSION_MODE.enableRepeater = REPEATER_DISABLED;
configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED;
configuration.TRANSMISSION_MODE.WORTransceiverControl = WOR_TRANSMITTER;
configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011;Maintenant, vous avez toutes les informations pour faire votre travail, mais je pense qu'il est important de montrer des exemples réalistes pour mieux déstouer toute possibilité.
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Paramètres et utilisation de base
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Bibliothèque
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Configuration
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: transmission fixe et RSSI
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Économie d'énergie et envoi de données structurées
Appareil Ebyte Lora E22 pour Arduino, ESP32 ou ESP8266: mode répéteur et paramètres à distance
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Microcontrôleur WOR et Arduino Shield
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Microcontrôleur WOR et WEMOS D1 Shield
EBYTE LORA E22 Dispositif pour Arduino, ESP32 ou ESP8266: Microcontrôleur WOR et ESP32 Dev V1 Shield
