EByte_LoRa_E220_Series_Library
vices
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
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 contre 2,4 GHz pour le NRF24L01) mais à la distance (de 5000 m à 11000m).
Lora Smart Home (LLCC68) est un émetteur-récepteur LORA® RF de sous-GHZ pour les applications sans fil intérieures et intérieures à l'intérieur à l'intérieur à l'extérieur. Interface SPI. Pin-To-Pin est compatible avec SX1262. SX1261, SX1262, SX1268 et LLCC68 sont conçus pour une longue durée de vie de la batterie avec seulement 4,2 mA de consommation active active. Le SX1261 peut transmettre jusqu'à +15 dBm, et les SX1262, SX1268 et LLCC68 peuvent transmettre jusqu'à +22 dBm avec des amplificateurs de puissance intégrés très efficaces.
Ces dispositifs prennent en charge la modulation LORA pour les cas d'utilisation LPWAN et (g) la modulation FSK pour les cas d'utilisation hérités. Les appareils sont hautement configurables pour répondre à différentes exigences d'application pour l'utilisation des consommateurs. Le dispositif fournit une modulation LORA compatible avec les émetteurs-récepteurs SemTech utilisés par la spécification Lorawan® publié par Lora Alliance®. La radio convient aux systèmes ciblant la conformité aux réglementations radio, notamment, mais sans s'y limiter, ETSI EN 300 220, FCC CFR 47 partie 15, exigences réglementaires en Chine et ARB japonais T-108. La couverture en fréquence continue de 150 MHz à 960 MHz permet le soutien de toutes les principales bandes ISM de sous-GHz dans le monde.
| Llcc68 | SX1278-SX1276 | |
|---|---|---|
| Distance | > 11 km | 8 km |
| Taux (Lora) | 1,76 kbps - 62,5 kbps | 0,3 kbps - 19,2 kbps |
| Consommation d'énergie du sommeil | 2µA | 5µA |
Vous pouvez trouver ma bibliothèque ici, et elle est disponible sur Arduino IDE Library Manager.
Pour télécharger.
Cliquez sur le bouton Téléchargement dans le coin supérieur droit, renommez le dossier non compressé LORA_E220.
Vérifiez que le dossier LORA_E220 contient lora_e220.cpp et lora_e220.h.
Placez le dossier de la bibliothèque LORA_E220 dans votre / les bibliothèques / dossier.
Vous devrez peut-être créer le sous-dossier des bibliothèques s'il s'agit de votre première bibliothèque.
Redémarrez l'IDE.
| PIN N ° | Épingle | Direction | Application PIN |
|---|---|---|---|
| 1 | M0 | Entrée （Pull-up faible） | Travaillez avec M1 et décidez des quatre modes de fonctionnement. Floating n'est pas autorisé; Cela peut être au sol. |
| 2 | M1 | Entrée （Pull-up faible） | Travaillez avec M0 et décidez des quatre modes de fonctionnement. Floating n'est pas autorisé; Cela peut être au sol. |
| 3 | Rxd | Saisir | Les entrées TTL UART se connectent à la broche de sortie TXD externe (MCU, PC). Il peut être configuré comme entrée à drain ouvert ou à pull-up. |
| 4 | Txd | Sortir | Les sorties TTL UART se connectent à la broche d'entrée RXD (MCU, PC) externe. Peut être configuré comme sortie de drain ouvert ou push-pull |
5 | Aux | Sortir | Pour indiquer l'état de travail du module et réveiller le MCU externe. Au cours de la procédure d'initialisation de l'auto-vérification, la PIN étend un niveau bas. Il peut être configuré en tant que sortie à drain ouvert ou push-pull (les flottants sont autorisés). |
| 6 | VCC | Alimentation 3V ~ 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 | Les canaux UART et sans fil sont ouverts et la transmission transparente est sur |
| Émetteur WOR | 0 | 1 | Émetteur WOR |
| Récepteur | 1 | 0 | Récepteur WOR (supporte le réveil sur l'air) |
| Mode de sommeil profond | 1 | 1 | Le module s'endort (se réveille automatiquement lors de la configuration des paramètres) |
Certaines broches peuvent être utilisées statiquement, mais si vous les connectez au microcontrôleur et les configurez dans la bibliothèque, vous gagnez en performances et pouvez contrôler tous les modes via le logiciel. Pourtant, nous allons expliquer mieux ensuite.
Comme je l'ai déjà dit, il n'est pas essentiel de connecter toutes les broches à la sortie du microcontrôleur; Vous pouvez mettre les broches M0 et M1 à haut ou bas pour obtenir la configuration souhaitée. Si vous ne connectez pas AUX, la bibliothèque définit un délai raisonnable pour vous assurer que l'opération est terminée ( si vous avez des problèmes avec la congélation de l'appareil, vous devez mettre une résistance de 4,7k pull-up ou mieux se connecter à l'appareil. ).
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.
Lors de la réception, Aux est bas et revient de haut lorsque le tampon est vide.
Il est également utilisé pour l'auto-vérification pour restaurer un fonctionnement régulier (en mode Power-On et Sleep / Program).
Le schéma de connexion ESP8266 est plus simple car il fonctionne à la même tension de communications logiques (3,3 V).
Il est essentiel d'ajouter une résistance de traction (4,7 kohms) 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.
| E22 | ESP32 |
|---|---|
| M0 | D21 |
| M1 | D19 |
| TX | Broche rx2 (pullup 4,7KΩ) |
| Rx | Épingle TX3 (pullup 4,7KΩ) |
| Aux | PIN D18 (Pullup 4,7KΩ) (D15 pour réveiller) |
| VCC | 5V (mais travaillez avec moins de puissance en 3,3 V) |
| GND | GND |
La tension de travail d'Arduino est de 5 V, 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, puis les assembler sur RX.
| 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 |
| M0 | 2 (diviseur de tension) |
| M1 | 3 (diviseur de tension) |
| TX | Broche 14 TX (pullup 4,7KΩ) |
| Rx | Broche 13 Rx (pullup 4,7KΩ) |
| Aux | Broche 1 (pullup 4,7KΩ) |
| VCC | 5V |
| GND | GND |
J'ai fait un ensemble de nombreux constructeurs car nous pouvons avoir plus d'options et de situations à gérer.
Lora_e220 (byte txe220pin, byte rxe220pin, uart_bps_rate bpsrate = uart_bps_rate_9600); LORA_E220 (BYTE TXE220PIN, BYTE RXE220PIN, BYTE AUXPIN, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); LORA_E220 (BYTE TXE220PIN, BYTE RXE220PIN, BYTE AUXPIN, BYTE M0PIN, BYTE M1PIN, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600);
Le premier ensemble de constructeurs est créé pour déléguer des épingles série et autres à la bibliothèque.
txE220pin et rxE220pin sont les broches pour se connecter à UART. Ils 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 délai pour permettre à l'opération de se compléter (avec latence, si vous avez des problèmes, comme le dispositif Freeze, vous devez mettre une résistance de 4,7k pull-up ou mieux vous connecter à 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 . Pourtant, pour un test, ils sont utiles pour être gérés par la bibliothèque.bpsRate est le taux de bauds des logiciels est généralement de 9600 (le seul taux de bauds en mode programmation / sommeil)Un exemple simple est
#include "lora_e220.h"LORA_E32 E220TTL (2, 3); // E22 TX E22 RX // LORA_E32 E32TTL (2, 3, 5, 6, 7); // E22 TX E22 RX
Nous pouvons utiliser un logiciel directement avec un autre constructeur
Lora_e220 (hardwareserial * serial, uart_bps_rate bpsrate = uart_bps_rate_9600); LORA_E220 (HardwaSeRerial * Serial, Byte Auxpin, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); LORA_E220 (HardwaSeRerial * Serial, Byte Auxpin, Byte M0pin, BYTE M1PIN, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600);
L'exemple supérieur avec ce constructeur peut être fait comme ainsi.
#include <softwareserial.h> #include "lora_e220.h"Mysérial des logiciels (2, 3); // E220 TX E220 RX LORA_E220 E220TTL (& MySerial); // LORA_E220 E220TTL (& MySerial, 5, 7, 6);
Le dernier ensemble de constructeurs est de permettre une waresériale durs au lieu du logiciel.
LORA_E220 (SoftwareSerial * Serial, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); LORA_E220 (SoftwareeSerial * Serial, Byte Auxpin, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); LORA_E220 (SoftwareSerial * Serial, Byte Auxpin, Byte M0pin, Byte M1pin, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600);
Pour ESP32, vous avez trois constructeurs supplémentaires à permettre de gérer les broches pour la série matérielle.
LORA_E220 (BYTE TXE220PIN, BYTE RXE220PIN, HARDWARESERIAL * SERIAL, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600, UINT32_T SEALCONFIG = SERIAL_8N1); Lora_e220 (byte txe220pin, byte rxe220pin, hardwareserial * serial, byte Auxpin, uart_bps_rate bpsrate = uart_bps_rate_9600, uint32_t serialconfig = serial_8n1); LORA_E220 (BYTE TXE220PIN, BYTE RXE220PIN, HARDWARESERIAL * SÉRIE, BYTE AUXPIN, BYTE M0PIN, BYTE M1PIN, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600, UINT32_T SERALCONFIG = SERIAL_8N1);
La commande begin est utilisée pour démarrer la série et les broches en mode entrée et sortie.
vide begin ();
dans l'exécution est
// Démarrage de toutes les épingles et UART e220tl.begin ();
Il existe de nombreuses méthodes pour gérer la configuration et obtenir des informations sur l'appareil.
ResponsestructContainer getConfiguration (); ResponseStatus setConfiguration (configuration de la configuration, programme_command saveType = write_cfg_pwr_dwn_lose);ResponseStructContainer getModuleInformation(); void printParameters(struct Configuration configuration); ResponseStatus resetModule();
Pour simplifier la gestion de la réponse, j'ai créé un ensemble de conteneurs, qui est très utile pour gérer les erreurs et renvoyer des données génériques.
Le ResponseStatus is a status container and has two points d'entrée simples, vous pouvez obtenir le code d'état et la description du code d'état
Serial.println (c.getResponSeScription ()); // Description du code Serial.println (c.code); // 1 Si le succès
Le code est
E220_success = 1, Err_e220_unknown, Err_e220_not_support, Err_e220_not_implement, Err_e220_not_initial, Err_e220_invalid_param, Err_e220_data_size_not_match, Err_e220_buf_too_small, Err_e220_timeout, Err_e220_hardware, Err_e220_head_not_recognised
Ce conteneur est créé pour gérer la réponse des chaînes et a deux points d'entrée.
data avec la chaîne renvoyée du message et status Une instance de RepsonseStatus .
ResponseContainer RS = e220ttl.receiveMessage (); Message de chaîne = Rs.Data;Serial.println(rs.status.getResponseDescription()); Serial.println(message);
Mais cette commande va lire toutes les données du tampon. Si vous recevez trois messages, vous allez lire les trois notes en même temps, et ma solution simple consiste à utiliser un caractère final à envoyer à la fin du message, par défaut j'utilise 0 (caractère nul)
ResponseContainer RS = E220TTL.ReceiveMessageUntil ();
// Vous pouvez également spécifier un délimiteur personnalisé
// ResponseContainer RS = E220TTL.receiveMessageUtil ('|');
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);
Cette version de l'appareil prend également en charge RSSI. Pour lire ce paramètre (si vous spécifiez dans la configuration que vous souhaitez également envoyer), vous pouvez utiliser
ResponseContainer rc = e220ttl.receiveMessagersSi (); Message de chaîne = Rs.Data;Serial.println(rs.status.getResponseDescription()); Serial.println(message); Serial.print("RSSI: "); Serial.println(rc.rssi, DEC);
Le ResponseStructContainer est le conteneur plus «complexe». J'utilise cela pour gérer les structures, il a les mêmes points de saisie de réponses de réponse, mais les données sont un pointeur vide pour gérer la structure complexe.
ResponsestructContainer C;
c = e220ttl.getConfiguration ();
// Il est important de recevoir un pointeur de configuration avant toutes les autres opérations
Configuration Configuration = * (Configuration *) C.Data;
Serial.println (c.status.getResponSeScription ());
Serial.println (c.status.code);
C.Close ();
Si vous recevez un message structuré avec RSSI, vous pouvez utiliser
ResponsestructContainer RSC = E220TTL.ReceiveMessagersSi (sizeof (message));
Serial.println (rsc.status.getResponSeScription ());
Struct Message Message = * (Message *) RSCC.DATA;
Serial.println (message.type);
Serial.println (message.Message);
Serial.println (* (float *) (message.Temperature));
Serial.print ("RSSI:"); Serial.println (RSC.RSSI, DEC);
rsc.close ();
Chaque fois que vous utilisez un ResponseStructContainer , vous devez le fermer avec close()
La première méthode est GetConfiguration, et vous pouvez l'utiliser pour récupérer toutes les données stockées sur l'appareil.
ResponsestructContainer getConfiguration ();
Voici un exemple d'utilisation.
ResponsestructContainer C;
c = e32ttl.getConfiguration ();
// Il est important de recevoir un pointeur de configuration avant toutes les autres opérations
Configuration Configuration = * (Configuration *) C.Data;
Serial.println (c.status.getResponSeScription ());
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; // première partie de l'adresse configuration.addh = 0x00; // deuxième partieconfiguration.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_200_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; // Enable repeater mode configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED; // Check interference configuration.TRANSMISSION_MODE.WORPeriod = WOR_2000_011; // WOR timing
Vous avez la fonction équivalente pour tous les attributs pour obtenir toutes les descriptions:
void printParameters (configuration de configuration de struct) {
Serial.println ("----------------------------------------");
Serial.print(F("HEAD : ")); Serial.print(configuration.COMMAND, HEX);Serial.print(" ");Serial.print(configuration.STARTING_ADDRESS, HEX);Serial.print(" ");Serial.println(configuration.LENGHT, HEX);
Serial.println(F(" "));
Serial.print(F("AddH : ")); Serial.println(configuration.ADDH, HEX);
Serial.print(F("AddL : ")); Serial.println(configuration.ADDL, HEX);
Serial.println(F(" "));
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.getUARTBaudRateDescription());
Serial.print(F("SpeedAirDataRate : ")); Serial.print(configuration.SPED.airDataRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getAirDataRateDescription());
Serial.println(F(" "));
Serial.print(F("OptionSubPacketSett: ")); Serial.print(configuration.OPTION.subPacketSetting, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getSubPacketSetting());
Serial.print(F("OptionTranPower : ")); Serial.print(configuration.OPTION.transmissionPower, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getTransmissionPowerDescription());
Serial.print(F("OptionRSSIAmbientNo: ")); Serial.print(configuration.OPTION.RSSIAmbientNoise, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getRSSIAmbientNoiseEnable());
Serial.println(F(" "));
Serial.print(F("TransModeWORPeriod : ")); Serial.print(configuration.TRANSMISSION_MODE.WORPeriod, BIN);Serial.print(" -> "); Serial.println(configuration.TRANSMISSION_MODE.getWORPeriodByParamsDescription());
Serial.print(F("TransModeEnableLBT : ")); Serial.print(configuration.TRANSMISSION_MODE.enableLBT, BIN);Serial.print(" -> "); Serial.println(configuration.TRANSMISSION_MODE.getLBTEnableByteDescription());
Serial.print(F("TransModeEnableRSSI: ")); Serial.print(configuration.TRANSMISSION_MODE.enableRSSI, BIN);Serial.print(" -> "); Serial.println(configuration.TRANSMISSION_MODE.getRSSIEnableByteDescription());
Serial.print(F("TransModeFixedTrans: ")); Serial.print(configuration.TRANSMISSION_MODE.fixedTransmission, BIN);Serial.print(" -> "); Serial.println(configuration.TRANSMISSION_MODE.getFixedTransmissionDescription());
Serial.println("----------------------------------------");
}
De la même manière, SetConfiguration veut une structure 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 de la configuration, programme_command saveType = write_cfg_pwr_dwn_lose);
configuration est la structure précédemment indiquée, saveType vous permet de choisir si le changement devient permanent ou uniquement pour la session en cours.
ResponsestructContainer C; c = e32ttl100.getConfiguration (); // Il est important de recevoir un pointeur de configuration avant toutes les autres opérations Configuration Configuration = * (Configuration *) C.Data; Serial.println (c.status.getResponSeScription ()); Serial.println (c.status.code);printParameters(configuration); configuration.ADDL = 0x03; // First part of address configuration.ADDH = 0x00; // Second part 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_200_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; // Enable repeater mode configuration.TRANSMISSION_MODE.enableLBT = LBT_DISABLED; // Check interference 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()
Les paramètres sont tous gérés comme constants:
| Nom | Description | Adresse |
|---|---|---|
| Addition | Octet d'adresse élevée du module (la valeur par défaut) | 00h |
| Addl | Octet de faible adresse du module (la valeur par défaut) | 01h |
| Vomir | Informations sur le bit de parité de données et le débit de données aérien | 02h |
| OPTION | Type de transmission, taille de paquet, permettez le message spécial | 03h |
| Chan | Canal de communication （410m + chan * 1m）, par défaut 17h (433 MHz), valide uniquement pour la vérification du périphérique 433 MHz ci-dessous pour vérifier la fréquence correcte de votre appareil | 04h |
| OPTION | Type de transmission, taille de paquet, permettez le message spécial | 05h |
| Transmission_mode | Beaucoup de paramètres qui spécifient la modalité de transmission | 06h |
| CRYPTE | Cryptage pour éviter l'interception | 07h |
Bit de parité UART: le mode UART peut être différent entre les parties de communication
| Bit de parité UART | Valeur constante |
|---|---|
| 8n1 (par défaut) | Mode_00_8n1 |
| 8O1 | Mode_01_8o1 |
| 8e1 | Mode_10_8e1 |
| 8N1 (égal à 00) | Mode_11_8n1 |
Taux de bauds UART: le taux de bauds UART peut être différent entre les parties de communication (mais non recommandées). 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.
| TTL UART BAUD TAUX （BPS） | Valeur constante |
|---|---|
| 1200 | UART_BPS_1200 |
| 2400 | UART_BPS_2400 |
| 4800 | UART_BPS_4800 |
| 9600 (par défaut) | UART_BPS_9600 |
| 19200 | UART_BPS_19200 |
| 38400 | UART_BPS_38400 |
| 57600 | UART_BPS_57600 |
| 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-ingérence et le temps de transmission plus long; Le débit de données de l'air doit être constant pour les deux parties de communication.
| Taux de données de l'air （BPS） | Valeur constante |
|---|---|
| 2.4k | AIR_DATA_RATE_000_24 |
| 2.4k | AIR_DATA_RATE_001_24 |
| 2.4k (par défaut) | AIR_DATA_RATE_010_24 |
| 4.8k | AIR_DATA_RATE_011_48 |
| 9,6k | AIR_DATA_RATE_100_96 |
| 19.2k | Air_data_rate_101_192 |
| 38,4k | AIR_DATA_RATE_110_384 |
| 62,5k | Air_data_Rate_111_625 |
Ceci est la longueur maximale du paquet.
Lorsque les données sont plus petites que la longueur du sous-packet, la sortie série de l'extrémité de réception est une sortie continue ininterrompue. Le port série de fin de réception sortira le sous-packet lorsque les données sont plus grandes que la longueur du sous-packet.
| Paquet | Valeur constante |
|---|---|
| 200 bytes (par défaut) | SPS_200_00 |
| 128 bytes | SPS_128_01 |
| 64 bytes | SPS_064_10 |
| 32 bytes | SPS_032_11 |
Cette commande peut activer / désactiver le type de gestion de RSSI, et il est essentiel de gérer la configuration distante. Faites attention n'est pas le paramètre RSSI dans le message.
Lorsqu'elles sont activées, les commandes C0, C1, C2, C3 peuvent être envoyées en mode de transmission ou 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.
| RSSI AMPORT AMPORT | Valeur constante |
|---|---|
| Activer | RSSI_AMBIENT_NOISE_ENABLEAD |
| Désactiver (par défaut) | RSSI_AMBIENT_NOISE_DISABLEAD |
Vous pouvez modifier cet ensemble de constantes en appliquant une définition comme tel:
#define e220_22 // Valeur par défaut sans définir
Applicable pour E220 avec 22 dbm comme puissance maximale.
Une faible transmission de puissance n'est pas recommandée en raison de sa faible efficacité d'alimentation électrique.
| Puissance de transmission (approximation) | Valeur constante |
|---|---|
| 22 dbm (par défaut) | Power_22 |
| 17 dbm | Power_17 |
| 13dbm | Power_13 |
| 10 dbm | Power_10 |
Applicable pour E220 avec 30 dbm en puissance maximale.
Une faible transmission de puissance n'est pas recommandée en raison de sa faible efficacité d'alimentation électrique.
#define e220_30
| Puissance de transmission (approximation) | Valeur constante |
|---|---|
| 30 dBm (par défaut) | Power_30 |
| 27 dbm | Power_27 |
| 24 dbm | Power_24 |
| 21 dbm | Power_21 |
Vous pouvez également configurer la fréquence des canaux avec cette définition:
// l'un des #define fréquence_433 #define fréquence_170 #define fréquence_470 #define fréquence_868 #define fréquence_915
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
| Activer RSSI | Valeur constante |
|---|---|
| Activer | RSSI_ENABLED |
| Désactiver (par défaut) | Rssi_disabled |
Mode de transmission: les trois premiers octets de la trame de données de chaque utilisateur peuvent être utilisés comme adresse et canal élevés / bas en mode de transmission fixe. 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.
| Bit d'autorisation de transmission fixe | Valeur constante |
|---|---|
| Mode de transmission fixe | Ft_fixed_transmission |
| Mode de transmission transparente (par défaut) | Ft_transparent_transmission |
Lorsqu'ils sont activés, les données sans fil seront surveillées avant qu'elles ne soient transmises, en évitant les interférences dans une certaine mesure, mais peuvent entraîner un retard de données.
| LBT Activer l'octet | Valeur constante |
|---|---|
| Activer | Lbt_enabled |
| Désactiver (par défaut) | Lbt_disabled |
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 Wireless 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.
| Temps de réveil sans fil | Valeur constante |
|---|---|
| 500 ms | Wake_up_500 |
| 1000 ms | Wake_up_1000 |
| 1500 ms | Wake_up_1500 |
| 2000 ms (par défaut) | Wake_up_2000 |
| 2500 ms | Wake_up_2500 |
| 3000 ms | Wake_up_3000 |
| 3500 ms | Wake_up_3500 |
| 4000 ms | Wake_up_4000 |
Tout d'abord, nous devons introduire une méthode simple mais pratique pour vérifier si quelque chose se trouve dans le tampon de réception.
int disponible ();
Il est simple de retourner le nombre d'octets que vous avez dans le flux actuel.
Le mode de transmission normal / transparent envoie des messages à tous les appareils avec la même adresse et le même canal.
Il existe de nombreuses méthodes pour envoyer / recevoir des messages, et nous allons expliquer en détail:
ResponseStatus SendMessage (Message de chaîne const);
ResponseContainer Recomessage ();
La première méthode est SendMessage et est utilisée pour envoyer une chaîne à un périphérique en mode normal .
ResponseStatus rs = e220ttl.sendMessage ("prova");
Serial.println (Rs.GetResponSeScription ());
L'autre appareil fait simplement sur la boucle.
if (e220ttl.available ()> 1) {
ResponseContainer RS = e220ttl.receiveMessage ();
Message de chaîne = Rs.Data; // a tout d'abord obtenu les données
Serial.println (Rs.Status.getResponSeScription ());
Serial.println (message);
}
Faites attention si vous recevez plusieurs messages dans le tampon et que vous ne voulez pas les lire tous en même temps. Vous devez utiliser ResponseContainer rs = e220ttl.receiveMessageUntil(); avec un délimiteur mis à la fin de l'envoi d'un message.
Si vous avez activé le RSSI, vous devez utiliser receiveMessageRSSI .
Si vous souhaitez envoyer une structure complexe, vous pouvez utiliser cette méthode
ResponseStatus SendMessage (construd * message, const uint8_t size);
ResponsestructContainer ReceiveMessage (const uint8_t size);
Il est utilisé pour envoyer une structure, par exemple:
struct messaggione {
type de char [5];
Message char [8];
bool mitico;
};
struct messaggione messaggione = {"temp", "peple", true};
ResponseStatus rs = e220ttl.sendMessage (& Messaggione, sizeof (Messaggione));
Serial.println (Rs.GetResponSeScription ());
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);
rsc.close ();
Si vous avez activé le RSSI, vous devez utiliser receiveMessageRSSI .
Si vous souhaitez lire la première partie du message pour gérer plus de types de structure, vous pouvez utiliser cette méthode.
ResponseContainer ReceeInitialMessage (const uint8_t Taille);
Je le crée pour recevoir une chaîne avec type ou autre pour identifier la structure à charger.
Struct Messaggione {// Structure partielle sans type
Message char [8];
bool mitico;
};
char type[5]; // first part of structure
ResponseContainer rs = e220ttl.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 = e220ttl.receiveMessage(sizeof(Messaggione));
struct Messaggione messaggione = *(Messaggione*) rsc.data;
rsc.close();
De même, je crée un ensemble de méthodes à utiliser avec la 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 lors du définition du mode fixe.
Donc pour le message de chaîne, vous avez
ResponseStatus SendFixedMessage (octet addh, octet addl, byte chan, const string message);
ResponseStatus SendBroadCastFixedMessage (Byte Chan, const String Message);
Et pour la structure, vous avez
ResponseStatus SendFixedMessage (octet addh, octet addl, byte chan, const void * message, const uint8_t size);
ResponseStatus SendBroadCastFixedMessage (Byte Chan, const void * Message, const uint8_t size);
Voici un exemple simple
ResponseStatus rs = e220ttl.sendFixedMessage (0, 0, 0x17, & Messaggione, sizeof (Messaggione)); // Responsestatus rs = e220ttl.sendFixedMessage (0, 0, 0x17, "ciao");
La transmission fixe a plus de scénarios
Si vous envoyez un périphérique spécifique (deuxième scénario fixe transmission), vous devez ajouter ADDL, ADDH et CHAN pour l'identifier directement.
ResponseStatus rs = e220ttl.sendFixedMessage (2, 2, 0x17, "message à un appareil");
Si vous souhaitez envoyer un message à tous les appareils dans un canal spécifié, vous pouvez utiliser cette méthode.
ResponseStatus rs = e220ttl.sendbroadcastFixedMessage (0x17, "Message à un dispositif d'un canal");
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 = e220ttl.getConfiguration (); // Il est important de recevoir un pointeur de configuration avant toutes les autres opérations Configuration Configuration = * (Configuration *) C.Data; Serial.println (c.status.getResponSeScription ()); 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); c.close();
Maintenant, vous avez toutes les informations pour faire votre travail, mais je pense qu'il est important de montrer quelques exemples réels pour mieux comprendre toutes les possibilités.
Bibliothèque GitHub
