LoRa_E32_Series_Library
Add E32_TTL_2W for E32-433T33S
Shield Arduino Uno
Vous pouvez commander le PCB ici
Vidéo d'instruction et d'assemblage sur 6 parties du guide
Bouclier Wemos D1
Vous pouvez commander le PCB ici
Bouclier ESP32
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 E32 de l'appareil LORA, un appareil très puissant, simple et bon marché.
Lora E32-TTL-100
Vous pouvez trouver ici AliExpress (appareil 3 km) AliExpress (appareil 8 km)
Ils peuvent travailler sur une distance de 3000 m à 8000 m, et ils ont beaucoup de fonctionnalités et de paramètres.
Je crée donc cette bibliothèque pour simplifier l'utilisation.
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_E32.
Vérifiez que le dossier LORA_E32 contient LORA_E32.CPP et LORA_E32.H.
Placez le dossier de bibliothèque LORA_E32 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.
E32 TTL 100
Vous pouvez acheter ici AliExpress
| 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 | Pour indiquer l'état de travail du module et réveille le MCU externe. Pendant la procédure d'initialisation de l'auto-vérification, la PIN sort un niveau bas. Peut être configuré en tant que sortie Orpush-pull de sortie (flottante est autorisée). |
| 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 bons à partir |
| Secouer | 0 | 1 | Identique à la normale, mais un code de préambule est ajouté aux données transmises pour réveiller le récepteur. |
| Salant | 1 | 0 | L'UART est désactivé et le sans fil est en mode WOR (Wake on Radio), ce qui signifie que l'appareil s'allume lorsqu'il y a des données à recevoir. La transmission n'est pas autorisée. |
| Dormir | 1 | 1 | Utilisé dans le réglage des paramètres. Transmission et réception handicapée. |
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 E32 AUX PIN SUR LE TRANSMISSION
Lors de la réception de Aux, devenu bas et de revenir haut lorsque le tampon est vide.
Lora E32 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 E32 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 E32 TTL 100 WEMOS D1 entièrement connecté
Il est important d'ajouter une résistance de traction (4,7kehm) pour obtenir une bonne stabilité.
| M0 | D7 |
|---|---|
| M1 | D6 |
| Rx | Broche D2 (pullup 4,7KΩ) |
| TX | Broche D3 (pullup 4,7KΩ) |
| Aux | D5 (entrée) |
| 3.3 V | 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 E32 TTL 100 Arduino entièrement connecté
| M0 | 7 (diviseur de tension) |
|---|---|
| M1 | 6 (diviseur de tension) |
| Rx | PIN D2 (Pullup 4,7KΩ et diviseur de tension) |
| TX | Broche D3 (pullup 4,7KΩ) |
| Aux | 5 (entrée) |
| VCC | 3.3 V |
| GND | GND |
J'ai fait un ensemble de constructeurs assez nombreux, car nous pouvons avoir plus d'options et de situations à gérer.
LoRa_E32 (byte rxPin, byte txPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E32 (byte rxPin, byte txPin, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E32 (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.
rxPin et txPin sont la broche pour se connecter à l'UART et elles sont obligatoires .
auxPin est une broche qui vérifie le fonctionnement, la transmission et la réception de l'état (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 terminer (avec latence).
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_E32.h "
LoRa_E32 e32ttl100 ( 2 , 3 ); // RX, TX
// LoRa_E32 e32ttl100(2, 3, 5, 6, 7); // RX, TXNous pouvons utiliser directement un logiciel avec un autre constructeur
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);L'exemple supérieur avec ce constructeur peut être le faire comme ainsi.
# include < SoftwareSerial.h >
# include " LoRa_E32.h "
SoftwareSerial mySerial ( 2 , 3 ); // RX, TX
LoRa_E32 e32ttl100 (mySerial);
// LoRa_E32 e32ttl100(&mySerial, 5, 7, 6);Le dernier ensemble de constructeurs est de permettre d'utiliser un hardwareserial au lieu d'un logiciel.
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);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
e32ttl100.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);
ResponseStatus resetModule ();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
E32_SUCCESS = 1 ,
ERR_E32_UNKNOWN,
ERR_E32_NOT_SUPPORT,
ERR_E32_NOT_IMPLEMENT,
ERR_E32_NOT_INITIAL,
ERR_E32_INVALID_PARAM,
ERR_E32_DATA_SIZE_NOT_MATCH,
ERR_E32_BUF_TOO_SMALL,
ERR_E32_TIMEOUT,
ERR_E32_HARDWARE,
ERR_E32_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 = e32ttl.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 = 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);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 = 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());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 = 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 bitVous avez la fonction équivalente pour obtenir toute description:
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());À 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 = 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);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 | 00h-1fh |
|---|
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
| 7 | 6 | Bit de parité UART | Valeur const | | --- | --- | --- | --- | --- | | 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.
| 5 | 43 | TTL UART BAUD TAUX （BPS） | Valeur constante |
|---|---|---|---|
| 0 | 0 | 0 | 1200 |
| 0 | 0 | 1 | 2400 |
| 0 | 1 | 0 | 4800 |
| 0 | 1 | 1 | 9600 (par défaut) |
| 1 | 0 | 0 | 19200 |
| 1 | 0 | 1 | 38400 |
| 1 | 1 | 0 | 57600 |
| 1 | 1 | 1 | 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 | 19,2k (identique à 101) | AIR_DATA_RATE_110_192 |
| 1 | 1 | 1 | 19,2k (identique à 101) | AIR_DATA_RATE_111_192 |
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.
| 7 | Bit d'activation de la transmission fixe （similaire à modbus） | Valeur constante |
|---|---|---|
| 0 | Mode de transmission transparente | Ft_transparent_transmission |
| 1 | Mode de transmission fixe | Ft_fixed_transmission |
Mode de lecteur IO: ce bit est utilisé à la résistance de traction interne du module. Il augmente également l'adaptabilité du niveau en cas de drain ouvert. Mais dans certains cas, il peut nécessiter un traction externe
résistance.
| 6 | Mode de lecteur IO (par défaut 1) | Valeur constante |
|---|---|---|
| 1 | Sorties Push-Pull TXD et AUX, entrées RXD | Io_d_mode_push_pulls_pull_ups |
| 0 | TXD 、 Sorties à collecteur ouvert AUX, entrées de collecteur ouvert RXD | IO_D_MODE_OPEN_COLLECTOR |
Temps de réveil sans fil: le module de transmission et de réception fonctionne dans le mode 0, dont le temps de retard n'est pas valide et peut être une valeur arbitraire, l'émetteur fonctionne dans le mode 1 peut transmettre le code de préambule du temps correspondant en continu, lorsque le récepteur fonctionne dans le mode 2, le temps signifie l'intervalle de moniteur (réveil sans fil). Seules les données de l'émetteur qui fonctionnent dans le mode 1 peuvent être
reçu.
| 5 | 4 | 3 | temps de réveil sans fil | Valeur constante |
|---|---|---|---|---|
| 0 | 0 | 0 | 250 ms (par défaut) | Wake_up_250 |
| 0 | 0 | 1 | 500 ms | Wake_up_500 |
| 0 | 1 | 0 | 750 ms | Wake_up_750 |
| 0 | 1 | 1 | 1000 ms | Wake_up_1000 |
| 1 | 0 | 0 | 1250 ms | Wake_up_1250 |
| 1 | 0 | 1 | 1500 ms | Wake_up_1500 |
| 1 | 1 | 0 | 1750 ms | Wake_up_1750 |
| 1 | 1 | 1 | 2000 ms | Wake_up_2000 |
FEC: Après avoir désactivé la FEC, le taux de transmission des données réel augmente tandis que la capacité anti-interférence diminue. De plus, la distance de transmission est relativement courte, les deux parties de communication doivent conserver les mêmes pages sur la FEC d'activation ou de désactivation.
| 2 | Interrupteur FEC | Valeur constante |
|---|---|---|
| 0 | Éteindre la FEC | Fec_0_off |
| 1 | Allumez la FEC (par défaut) | Fec_1_on |
Puissance de transmission
Vous pouvez modifier cet ensemble de constante en appliquant une définition comme tel:
# define E32_TTL_100 // default value without set Applicable pour E32-TTL-100, E32-TTL-100S1, E32-T100S2.
La puissance externe doit s'assurer que la capacité de la puissance de courant supérieure à 250 mA et assurer l'alimentation de l'alimentation se répercute à 100 mV.
Une transmission à faible puissance n'est pas recommandée en raison de sa faible alimentation
efficacité.
# define E32_TTL_100 // default value without set| 1 | 0 | Puissance de transmission (approximation) | Valeur constante |
|---|---|---|---|
| 0 | 0 | 20 dbm (par défaut) | Power_20 |
| 0 | 1 | 17 dbm | Power_17 |
| 1 | 0 | 14 dbm | Power_14 |
| 1 | 1 | 10 dbm | Power_10 |
Applicable pour E32-TTL-500。
La puissance externe doit s'assurer que la capacité de la sortie de courant supérieure à 700 mm et assurer l'alimentation de l'alimentation à moins de 100 mV.
Une faible transmission de puissance n'est pas recommandée en raison de sa faible efficacité d'alimentation électrique.
# define E32_TTL_500| 1 | 0 | Puissance de transmission (approximation) | Valeur constante |
|---|---|---|---|
| 0 | 0 | 27dbm (par défaut) | Power_27 |
| 0 | 1 | 24 dbm | Power_24 |
| 1 | 0 | 21 dbm | Power_21 |
| 1 | 1 | 18 dbm | Power_18 |
Applicable pour E32-TTL-1W, E32 (433T30S), E32 (868T30S), E32 (915T30S)
La puissance externe doit s'assurer que la capacité de la sortie de courant supérieure à 1a et assurer l'alimentation de l'alimentation à moins de 100 mV.
Une transmission à faible puissance n'est pas recommandée en raison de sa faible alimentation
efficacité.
# define E32_TTL_1W| 1 | 0 | Puissance de transmission (approximation) | Valeur constante |
|---|---|---|---|
| 0 | 0 | 30 dBm (par défaut) | Power_30 |
| 0 | 1 | 27 dbm | Power_27 |
| 1 | 0 | 24 dbm | Power_24 |
| 1 | 1 | 21 dbm | Power_21 |
Vous 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_915Nous 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 E32 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 = e32ttl.sendMessage( " Prova " );
Serial.println(rs.getResponseDescription());L'autre appareil fait simplement sur la boucle
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);
}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 = e32ttl.sendMessage(&messaggione, sizeof (Messaggione));
Serial.println(rs.getResponseDescription());Et l'autre côté, vous pouvez recevoir le message donc
ResponseStructContainer rsc = e32ttl.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 = 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;À 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 = e32ttl.sendFixedMessage( 0 , 0 , 0x17 , &messaggione, sizeof (Messaggione));
// ResponseStatus rs = e32ttl.sendFixedMessage(0, 0, 0x17, "Ciao");La transmission fixe a plus de scénarios
LORA E32 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 = e32ttl.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 = e32ttl.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 = 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);
