EByte_LoRa_E220_Series_Library
vices
Sie können die PCB hier bestellen
Anweisungs- und Montagevideo auf 6 Teil des Leitfadens
Sie können die PCB hier bestellen
Anweisungs- und Montagevideo auf 6 Teil des Leitfadens
Lora oder Langstrecken -Wireless -Data -Telemetrie ist eine von Semtech pionierende Technologie, die mit einer niedrigeren Frequenz als NRF24L01 (433 MHz, 868 MHz oder 916 MHz gegen 2,4 GHz für Nrf24L01) arbeitet, jedoch mit drei Jahren (von 5000 m bis 11000 m).
Lora Smart Home (LLCC68) ist ein Sub-GHz LORA® RF-Transceiver für Innen- und drahtlose Innen- und Außenanwendungen. SPI -Schnittstelle. Pin-to-Pin ist mit SX1262 kompatibel. SX1261, SX1262, SX1268 und LLCC68 sind für eine lange Akkulaufzeit mit nur 4,2 mA aktivem Empfangsverbrauch ausgelegt. Der SX1261 kann bis zu +15 dBm übertragen, und die SX1262, SX1268 und LLCC68 können bis zu +22 dBm mit hocheffizienten integrierten Leistungsverstärkern übertragen.
Diese Geräte unterstützen die LORA -Modulation für LPWAN -Anwendungsfälle und (g) FSK -Modulation für Legacy -Anwendungsfälle. Die Geräte sind sehr konfigurierbar, um unterschiedliche Anwendungsanforderungen für die Verwendung von Verbrauchern zu erfüllen. Das Gerät bietet eine LORA -Modulation, die mit den von der Lorawan® -Spezifikation verwendeten Semtech -Transceivern kompatibel ist, die von der LORA Alliance® veröffentlicht wurde. Das Radio ist für Systeme geeignet, die die Einhaltung von Funkvorschriften abzielen, einschließlich, aber nicht beschränkt auf ETSI EN 300 220, FCC CFR 47 TEIL 15, China-Regulierungsanforderungen und die japanische Arib T-108. Die kontinuierliche Frequenzabdeckung von 150 MHz bis 960 MHz ermöglicht die Unterstützung aller wichtigen Sub-GHz-ISM-Bänder auf der ganzen Welt.
| LLCC68 | SX1278-SX1276 | |
|---|---|---|
| Distanz | > 11 km | 8 km |
| Rate (Lora) | 1,76 kbps - 62,5 Kbit / s | 0,3 Kbit / s - 19,2 Kbit / s |
| Schlafkraftverbrauch | 2 µA | 5 um |
Hier finden Sie meine Bibliothek und sie ist im Arduino IDE Library Manager verfügbar.
Zum Herunterladen.
Klicken Sie in der oberen rechten Ecke auf die Schaltfläche Downloads und benennen Sie den unkomprimierten Ordner LORA_E220 um.
Überprüfen Sie, ob der Ordner lora_e220 lora_e220.cpp und lora_e220.h enthält.
Platzieren Sie den Ordner lora_e220 Library in Ihrem / Bibliotheken / Ordner.
Möglicherweise müssen Sie den Unterordner der Bibliotheken erstellen, wenn es sich um Ihre erste Bibliothek handelt.
Starten Sie die Ide neu.
| Pin -Nr. | PIN Item | Stiftrichtung | PIN -Anwendung |
|---|---|---|---|
| 1 | M0 | Eingabe （schwacher Pull-up） | Arbeiten Sie mit M1 zusammen und entscheiden Sie die vier Betriebsmodi. Schwimmen ist nicht erlaubt; Es kann gemahlen werden. |
| 2 | M1 | Eingabe （schwacher Pull-up） | Arbeiten Sie mit M0 zusammen und entscheiden Sie die vier Betriebsmodi. Schwimmen ist nicht erlaubt; Es kann gemahlen werden. |
| 3 | Rxd | Eingang | TTL UART -Eingänge verbinden TXD -Ausgangsstift (MCU, PC). Es kann als Open-Drain- oder Pull-up-Eingang konfiguriert werden. |
| 4 | Txd | Ausgabe | TTL UART -Ausgänge verbinden eine Verbindung zum externen RXD (MCU, PC) Eingangspin. Kann als Open-Drain- oder Push-Pull-Ausgang konfiguriert werden |
5 | Aux | Ausgabe | Um den Arbeitsstatus des Moduls anzuzeigen und die externe MCU aufzuwecken. Während des Verfahrens der Selbstprüfungsinitialisierung gibt der PIN einen niedrigen Niveau aus. Es kann als Open-Drain- oder Push-Pull-Ausgang konfiguriert werden (schwebend ist erlaubt). |
| 6 | VCC | Netzteil 3 V ~ 5,5 V Gleichstrom | |
| 7 | GND | Boden |
Wie Sie sehen können, können Sie verschiedene Modi über M0- und M1 -Stifte festlegen.
| Modus | M1 | M0 | Erläuterung |
|---|---|---|---|
| Normal | 0 | 0 | UART- und drahtlose Kanäle sind geöffnet, und die transparente Übertragung ist eingeschaltet |
| Schlimmer Sender | 0 | 1 | Schlimmer Sender |
| Schlimmer Empfänger | 1 | 0 | Schlimmer Empfänger (Unterstützt wach über Luft auf) |
| Tiefschläfungsmodus | 1 | 1 | Das Modul geht in den Schlaf (wachen Sie beim Konfigurieren von Parametern automatisch auf) |
Einige Stifte können statisch verwendet werden. Wenn Sie sie jedoch an den Mikrocontroller anschließen und in der Bibliothek konfigurieren, erhalten Sie Leistung und können alle Modi über Software steuern. Trotzdem werden wir als nächstes besser erklären.
Wie ich bereits sagte, ist es nicht wichtig, alle Stifte mit dem Ausgang des Mikrocontrollers zu verbinden. Sie können M0- und M1 -Stifte auf hoher oder niedrigem Stiften setzen, um die gewünschte Konfiguration zu erhalten. Wenn Sie Aux nicht anschließen, legt die Bibliothek eine angemessene Verzögerung fest, um sicherzustellen, dass der Vorgang abgeschlossen ist ( wenn Sie Probleme mit dem Einfrieren des Geräts haben, müssen Sie einen Pull-up-4,7K-Widerstand oder besser an das Gerät anschließen. ).
Bei der Übertragung von Daten können zum Aufwachen der externen MCU und zum hohen Datenübertragungsverlauf verwendet werden.
Beim Empfangen geht Aux niedrig und kehrt hoch, wenn der Puffer leer ist.
Es wird auch zum Selbstversenden verwendet, um den regelmäßigen Betrieb wiederherzustellen (im Power-On- und Schlaf-/Programmmodus).
Das ESP8266 -Verbindungsschema ist einfacher, da es bei derselben Spannung logischer Kommunikation (3,3 V) funktioniert.
Es ist wichtig, einen Pull-up-Widerstand (4,7KOHM) hinzuzufügen, um eine gute Stabilität zu erhalten.
| E22 | ESP8266 |
|---|---|
| M0 | D7 |
| M1 | D6 |
| Tx | Pin D2 (Pullup 4,7k Ω) |
| Rx | Pin D3 (Pullup 4,7k Ω) |
| Aux | Pin D5 (Pullup 4,7k Ω) |
| VCC | 5 V (aber mit weniger Leistung in 3,3 V arbeiten) |
| GND | GND |
Ähnliches Verbindungsschema für ESP32, aber für RX und TX verwenden wir RX2 und TX2, da ESP32 standardmäßig keinen Software -Sachwareser hat, sondern 3 Serien hat.
| E22 | ESP32 |
|---|---|
| M0 | D21 |
| M1 | D19 |
| Tx | Pin RX2 (Pullup 4,7k Ω) |
| Rx | Pin TX3 (Pullup 4,7k Ω) |
| Aux | Pin D18 (Pullup 4,7k Ω) (D15 aufwachen) |
| VCC | 5 V (aber mit weniger Leistung in 3,3 V arbeiten) |
| GND | GND |
Die Arbeitsspannung von Arduino beträgt 5 V. Daher müssen wir einen Spannungsteiler auf Rx Pin M0 und M1 des Lora -Moduls hinzufügen, um Schäden zu vermeiden. Weitere Informationen finden Sie hier Spannungsteiler: Taschenrechner und Anwendung.
Sie können einen 2KOHM -Widerstand gegen GND und 1KOHM aus dem Signal verwenden und sie dann auf RX zusammenstellen.
| M0 | 7 (Spannungsteiler) |
| M1 | 6 (Spannungsteiler) |
| Tx | Pin 2 (Pullup 4,7k Ω) |
| Rx | Pin 3 (Pullup 4,7kΩ & Spannungsteiler) |
| Aux | Pin 5 (Pullup 4,7k Ω) |
| VCC | 5v |
| GND | GND |
| M0 | 2 (Spannungsteiler) |
| M1 | 3 (Spannungsteiler) |
| Tx | Pin 14 TX (Pullup 4,7k Ω) |
| Rx | Pin 13 RX (Pullup 4,7k Ω) |
| Aux | Pin 1 (Pullup 4,7k Ω) |
| VCC | 5v |
| GND | GND |
Ich habe zahlreiche Konstruktoren gemacht, weil wir mehr Optionen und Situationen zu verwalten haben können.
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);
Der erste Satz von Konstruktoren wird erstellt, um Serien- und andere Stifte an die Bibliothek zu delegieren.
txE220pin und rxE220pin sind die Stifte, die eine Verbindung zu UART herstellen. Sie sind obligatorisch .auxPin ist ein PIN, der den Betrieb, die Übertragung und den Empfangsstatus überprüft (wir werden als nächstes besser erklären), dieser Pin ist nicht obligatorisch . Wenn Sie es nicht einstellen, wende ich eine Verzögerung an, damit sich der Vorgang selbst abschließen kann (mit Latenz, ich habe Probleme, wie ein Gefriergerät einen Pull-up-4,7K-Widerstand oder besser an das Gerät herzustellen ).m0pin und m1Pin sind die Stifte, um den Betriebsmodus zu ändern (siehe Tabelle oben). Ich denke , diese Stifte in „Produktion“ werden direkt hoch oder niedrig angeschlossen . Für einen Test sind sie jedoch hilfreich, um von der Bibliothek verwaltet zu werden.bpsRate ist die Baud -Rate von Softwareerial beträgt normalerweise 9600 (die einzige Baudrate im Programmier-/Schlafmodus)Ein einfaches Beispiel ist
#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
Wir können einen SoftWareserial direkt mit einem anderen Konstruktor verwenden
Lora_e220 (HardWareserial* Serial, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); Lora_e220 (Hardwareserial* Serial, Byte Auxpin, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); Lora_e220 (hardwareserial* serial, byte auxpin, byte m0pin, byte m1pin, uart_bps_rate bpsrate = uart_bps_rate_9600);
Das Beispielobere mit diesem Konstruktor kann so durchgeführt werden.
#include <Softwareserial.h> #include "lora_e220.h"SoftWareserial MySerial (2, 3); // E220 TX E220 RX Lora_e220 e220ttl (& myserial); // lora_e220 e220ttl (& myserial, 5, 7, 6);
Der letzte Satz von Konstruktoren besteht darin, einem Hardtrareerial anstelle von Softwareerial zu ermöglichen.
Lora_e220 (SoftWareserial* Serial, UART_BPS_RATE BPSRATE = UART_BPS_RATE_9600); Lora_e220 (SoftWareserial* 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);
Für ESP32 verfügen Sie über drei zusätzliche Konstrukteure, die es ermöglichen, Pins für die Hardware -Serie zu verwalten.
Lora_e220 (byte txe220pin, byte rxe220pin, hardwareserial* serial, uart_bps_rate bpsrate = uart_bps_rate_9600, uint32_t serialconfig = 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* serial, byte auxpin, byte m0pin, byte m1pin, uart_bps_rate bpsrate = uart_bps_rate_9600, uint32_trate serial config = serial config = serial config = serial
Mit dem Befehl mit Beginn wird der Serien- und Stifte im Eingangs- und Ausgangsmodus gestartet.
void begin ();
in der Ausführung ist
// Alle Stifte und UART starten e220ttl.begin ();
Es gibt viele Methoden zum Verwalten der Konfiguration und zum Erhalten von Informationen über das Gerät.
ResponTErStructContainer getConfiguration (); Reponestatus setConfiguration (Konfigurationskonfiguration, Programm_Command Savetype = Write_CFG_PWR_DWN_LOSE);ResponseStructContainer getModuleInformation(); void printParameters(struct Configuration configuration); ResponseStatus resetModule();
Um das Management der Antwort zu vereinfachen, habe ich eine Reihe von Containern erstellt, was sehr nützlich ist, um Fehler zu verwalten und generische Daten zurückzugeben.
Der ResponseStatus is a status container and has two einfache Einstiegspunkte. Dabei können Sie den Statuscode und die Beschreibung des Statuscode erhalten
Serial.println (C.Getresponsedescription ()); // Beschreibung des Codes Serial.println (C. code); // 1 Wenn Erfolg
Der Code ist
E220_SUCCESS = 1, Err_e220_UunkNOWN, 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_recognized
Dieser Container wird erstellt, um die String -Antwort zu verwalten, und verfügt über zwei Einstiegspunkte.
data mit der Zeichenfolge, die aus der Nachricht und status einer Instanz von RepsonseStatus zurückgegeben wurde.
ResponseContainer rs = e220ttl.receivemessage (); String message = rs.data;Serial.println(rs.status.getResponseDescription()); Serial.println(message);
Dieser Befehl lesen jedoch alle Daten im Puffer. Wenn Sie drei Nachrichten erhalten, werden Sie alle drei Notizen gleichzeitig lesen, und meine einfache Lösung besteht darin, ein Endzeichen zum Senden am Ende der Nachricht zu verwenden.
ResponseContainer rs = e220ttl.receivemessageUntil ();
// Sie können auch einen benutzerdefinierten Trennzeichen angeben
// ResponseContainer rs = e220ttl.receivemessageUntil ('|');
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);
Diese Version des Geräts unterstützt auch RSSI. So lesen Sie diesen Parameter (wenn Sie in der Konfiguration, die Sie auch senden möchten, angeben), können Sie verwenden
ResponseContainer rc = e220Ttl.receivemessagerssi (); String message = rs.data;Serial.println(rs.status.getResponseDescription()); Serial.println(message); Serial.print("RSSI: "); Serial.println(rc.rssi, DEC);
Der ResponseStructContainer ist der „komplexere“ Behälter. Ich benutze dies, um Strukturen zu verwalten, es hat die gleichen Einstiegspunkte von ResponTeContainer, aber Daten sind ein voides Zeiger für die Verwaltung der komplexen Struktur.
ResponsedructionContainer C;
c = e220Ttl.getConfiguration ();
// Es ist wichtig, Konfigurationszeiger vor allen anderen Operationen zu erhalten
Konfigurationskonfiguration = *(Konfiguration *) C.Data;
Serial.println (c.Status.getresponsedescription ());
Serial.println (c.Status.code);
C.CLOSE ();
Wenn Sie eine strukturierte Nachricht mit RSSI erhalten, können Sie verwenden
ResponTErStructContainer rsc = e220Ttl.Receivemessagerssi (sizeof (message));
Serial.println (rsc.status.getresponedescription ());
struct message message = *(message *) rsc.data;
Serial.println (message.type);
Serial.println (message.message);
Serial.println (*(float*) (message.temperature));
Serial.print ("rssi:"); Serial.println (rsc.rssi, dec);
rsc.close ();
Jedes Mal, wenn Sie einen ResponseStructContainer verwenden, müssen Sie ihn mit close()
Die erste Methode ist GetConfiguration, und Sie können sie verwenden, um alle auf dem Gerät gespeicherten Daten abzurufen.
ResponTErStructContainer getConfiguration ();
Hier ist ein Nutzungsbeispiel.
ResponsedructionContainer C;
c = e32ttl.getConfiguration ();
// Es ist wichtig, Konfigurationszeiger vor allen anderen Operationen zu erhalten
Konfigurationskonfiguration = *(Konfiguration *) C.Data;
Serial.println (c.Status.getresponsedescription ());
Serial.println (c.Status.code);
Serial.println (configuration.sped.getuartbardrate ());
C.CLOSE ();
Die Konfigurationsstruktur hat alle Daten von Einstellungen, und ich füge eine Reihe von Funktionen hinzu, um alle Beschreibung einzelner Daten zu erhalten.
configuration.addl = 0x03; // Erster Teil der Adresse configuration.addh = 0x00; // zweiter Teilconfiguration.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
Sie haben die äquivalente Funktion für alle Attribute, um alle Beschreibungen zu erhalten:
void printparameters (strukturkonfigurationskonfiguration) {
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("----------------------------------------");
}
Auf die gleiche Weise möchte die SetConfiguration eine Konfigurationsstruktur. Ich denke, der bessere Weg, die Konfiguration zu verwalten, besteht darin, die aktuelle abzurufen, die einzige Änderung anzuwenden, die Sie benötigen, und erneut einstellen.
Reponestatus setConfiguration (Konfigurationskonfiguration, Programm_Command Savetype = Write_CFG_PWR_DWN_LOSE);
configuration ist die zuvor gezeigte Struktur. saveType ermöglicht es Ihnen, zu wählen, ob die Änderung dauerhaft oder nur für die aktuelle Sitzung wird.
ResponsedructionContainer C; c = e32ttl100.getConfiguration (); // Es ist wichtig, Konfigurationszeiger vor allen anderen Operationen zu erhalten Konfigurationskonfiguration = *(Konfiguration *) 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.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()
Die Parameter werden alle als konstant verwaltet:
| Name | Beschreibung | Adresse |
|---|---|---|
| Addh | Hoches Adressbyte des Moduls (der Standard 00H) | 00H |
| Addl | Niedrig Adressbyte des Moduls (der Standard 00H) | 01H |
| Sped | Informationen zu Datenrate Paritätsbit- und Luftdatenrate | 02H |
| OPTION | Art der Übertragung, Paketgröße, die spezielle Nachricht zulassen | 03H |
| Chan | Kommunikationskanal （410 m + Chan*1m）, Standard 17H (433 MHz), nur für 433 MHz -Geräteprüfung nachstehend gültig , um die korrekte Frequenz Ihres Geräts zu überprüfen | 04H |
| OPTION | Art der Übertragung, Paketgröße, die spezielle Nachricht zulassen | 05H |
| Transmission_Mode | Viele Parameter, die die Übertragungsmodalität angeben | 06H |
| KRYPTA | Verschlüsselung, um Abfangen zu vermeiden | 07H |
UART Parity Bit: Der UART -Modus kann zwischen Kommunikationsparteien unterschiedlich sein
| UART Parity Bit | Konstanter Wert |
|---|---|
| 8n1 (Standard) | Modus_00_8n1 |
| 8o1 | Modus_01_8o1 |
| 8e1 | Modus_10_8e1 |
| 8n1 (gleich 00) | Modus_11_8n1 |
UART -Baud -Rate: Die UART -Baudrate kann zwischen Kommunikationsparteien unterschiedlich sein (aber nicht empfangen). Die UART -Baud -Rate hat nichts mit drahtlosen Übertragungsparametern zu tun und wirkt sich nicht auf die Merkmale der drahtlosen Übertragung/Empfang aus.
| TTL UART Baud Rate （BPS） | Konstanter Wert |
|---|---|
| 1200 | UART_BPS_1200 |
| 2400 | UART_BPS_2400 |
| 4800 | UART_BPS_4800 |
| 9600 (Standard) | UART_BPS_9600 |
| 19200 | UART_BPS_19200 |
| 38400 | UART_BPS_38400 |
| 57600 | UART_BPS_57600 |
| 115200 | UART_BPS_115200 |
Luftdatenrate: Je niedriger die Luftdatenrate ist, desto länger die Sendungsentfernung, eine bessere Anti-Interferenz-Leistung und längere Übertragungszeit; Die Luftdatenrate muss für beide Kommunikationsparteien konstant sein.
| Luftdatenrate （BPS） | Konstanter Wert |
|---|---|
| 2,4K | Air_Data_Rate_000_24 |
| 2,4K | Air_Data_Rate_001_24 |
| 2,4K (Standard) | 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 |
Dies ist die maximale Länge des Pakets.
Wenn die Daten kleiner als die Unterpackungslänge sind, ist die serielle Ausgabe des Empfangsende eine ununterbrochene kontinuierliche Ausgabe. Der serielle Anschluss des empfangenen Endes gibt die Unterpackung aus, wenn die Daten größer als die Unterpackungslänge sind.
| Paketgröße | Konstanter Wert |
|---|---|
| 200 Bytes (Standard) | SPS_200_00 |
| 128 BYTES | SPS_128_01 |
| 64Bytes | SPS_064_10 |
| 32Bytes | SPS_032_11 |
Dieser Befehl kann den Verwaltungsart von RSSI aktivieren/deaktivieren, und es ist wichtig, die Remote -Konfiguration zu verwalten. Achtung ist nicht der RSSI -Parameter in der Nachricht.
Bei Aktivierung können die Befehle C0, C1, C2, C3 im Sendungsmodus oder im schlimmsten Sendungsmodus gesendet werden, um das Register zu lesen. Register 0x00: Aktuelles Umgebungsgeräusch -RSSI -Register 0x01: RSSI, wenn die Daten beim letzten Mal empfangen wurden.
| RSSI -Umgebungsgeräusche ermöglichen | Konstanter Wert |
|---|---|
| Aktivieren | Rssi_ambient_noise_enabled |
| Deaktivieren (Standard) | Rssi_ambient_noise_disabled |
Sie können diesen Satz von Konstanten ändern, indem Sie wie SO ein Definieren anwenden:
#define e220_22 // Standardwert ohne festgelegt
Anwendbar für E220 mit 22 dBm als maximaler Strom.
Aufgrund der geringen Stromversorgungseffizienz wird keine geringe Stromversorgung empfohlen.
| Übertragungsleistung (Näherung) | Konstanter Wert |
|---|---|
| 22dbm (Standard) | Power_22 |
| 17dbm | Power_17 |
| 13dbm | Power_13 |
| 10dbm | Power_10 |
Anwendbar für E220 mit 30 dBm als maximaler Strom.
Aufgrund der geringen Stromversorgungseffizienz wird keine geringe Stromversorgung empfohlen.
#define e220_30
| Übertragungsleistung (Näherung) | Konstanter Wert |
|---|---|
| 30 dbm (Standard) | Power_30 |
| 27 dbm | Power_27 |
| 24 dbm | Power_24 |
| 21dbm | Power_21 |
Sie können die Kanalfrequenz auch mit dieser Definition konfigurieren:
// einer von #define Frequency_433 #define Frequency_170 #define Frequency_470 #define Frequenz_868 #define Frequency_915
Wenn das Modul aktiviert ist, empfängt das Modul drahtlose Daten und folgt einem RSSI -Festigkeitsbyte nach Ausgang über den seriellen Port TXD
| Aktivieren Sie RSSI | Konstanter Wert |
|---|---|
| Aktivieren | Rssi_enabled |
| Deaktivieren (Standard) | Rssi_disabled |
Übertragungsmodus: Die ersten drei Bytes des Datenrahmens jedes Benutzers können als hohe/niedrige Adresse und Kanal im festen Übertragungsmodus verwendet werden. Das Modul ändert seine Adresse und Kanal, wenn sie übertragen wird. Und es wird nach Abschluss des Vorgangs zur ursprünglichen Einstellung zurückgeführt.
| Festgelegtes Bit -Aktivierungsbit festgelegt | Konstanter Wert |
|---|---|
| Behobener Übertragungsmodus | Ft_fixed_transmission |
| Transparenter Übertragungsmodus (Standard) | Ft_transparent_transmission |
Wenn es aktiviert ist, werden drahtlose Daten überwacht, bevor sie übertragen werden, wodurch Störungen bis zu einem gewissen Grad vermieden werden, kann jedoch zu einer Datenverzögerung führen.
| LBT aktivieren Byte | Konstanter Wert |
|---|---|
| Aktivieren | LBT_Enabled |
| Deaktivieren (Standard) | Lbt_disabled |
Wenn Wors übersetzt wird: Nach dem Erhalt des Weltempfängers die drahtlosen Daten erhalten und über den seriellen Anschluss ausgibt, wartet er auf 1000 ms, bevor er erneut in die Schlacht eintritt. Benutzer können die seriellen Portdaten eingeben und sie während dieses Zeitraums über Wireless zurückgeben. Jedes serielle Byte wird für 1000 ms aktualisiert. Benutzer müssen das erste Byte innerhalb von 1000 ms übertragen.
| Drahtlose Weckzeit | Konstanter Wert |
|---|---|
| 500 ms | WAKE_UP_500 |
| 1000 ms | WAKE_UP_1000 |
| 1500 ms | WAKE_UP_1500 |
| 2000 ms (Standard) | WAKE_UP_2000 |
| 2500 ms | WAKE_UP_2500 |
| 3000 ms | WAKE_UP_3000 |
| 3500 ms | WAKE_UP_3500 |
| 4000 ms | WAKE_UP_4000 |
Zunächst müssen wir eine einfache, aber praktische Methode einführen, um zu überprüfen, ob sich im Empfangspuffer etwas befindet.
int verfügbar ();
Es ist einfach, zurückzugeben, wie viele Bytes Sie im aktuellen Strom haben.
Normal/transparenter Übertragungsmodus sendet Nachrichten mit derselben Adresse und demselben Kanal an alle Geräte.
Es gibt viele Methoden zum Senden/Empfangen von Nachrichten, und wir werden ausführlich erklären:
Reponestatus sendMessage (const String -Nachricht);
ResponTeContainer Forderungsage ();
Die erste Methode ist SendMessage und wird verwendet, um eine Zeichenfolge im normalen Modus an ein Gerät zu senden.
Responstatus rs = e220ttl.sendMessage ("prova");
Serial.println (rs.getresponedescription ());
Das andere Gerät macht einfach auf der Schleife.
if (e220ttl.available ()> 1) {
ResponseContainer rs = e220ttl.receivemessage ();
String message = rs.data; // Erhalten Sie zuerst die Daten
Serial.println (rs.status.getresponedescription ());
Serial.println (Nachricht);
}
Achten Sie darauf, wenn Sie mehrere Nachrichten im Puffer erhalten und nicht alle gleichzeitig lesen möchten. Sie müssen ResponseContainer rs = e220ttl.receiveMessageUntil(); Mit einem Trennzeichen am Ende des Sendens einer Nachricht.
Wenn Sie das RSSI aktiviert haben, müssen Sie receiveMessageRSSI verwenden.
Wenn Sie eine komplexe Struktur senden möchten, können Sie diese Methode verwenden
Reponestatus sendMessage (const void *meldung, const Uint8_t Größe);
ResponTErErtructContainer Forderung (const Uint8_t Größe);
Es wird verwendet, um Struktur zu senden, zum Beispiel:
Struktur Messaggione {
Zeichentyp [5];
Zeichen Nachricht [8];
bool Mitico;
};
struct messaggione messaggione = {"temp", "peple", true};
Responstatus rs = e220ttl.sendMessage (& messaggione, sizeof (messaggione));
Serial.println (rs.getresponedescription ());
und die andere Seite können Sie die Nachricht so erhalten
ResponseDructContainer rsc = e22ttl.receivemessage (sizeof (messaggione));
Struct Messaggione Messaggione = *(Messaggione *) rsc.data;
Serial.println (messaggione.message);
Serial.println (messaggione.mitico);
rsc.close ();
Wenn Sie das RSSI aktiviert haben, müssen Sie receiveMessageRSSI verwenden.
Wenn Sie den ersten Teil der Nachricht lesen möchten, um mehr Strukturarten zu verwalten, können Sie diese Methode verwenden.
ResponTeContainer empfangeneInitialMessage (const Uint8_t Größe);
Ich erstelle es, um eine Zeichenfolge mit Typ oder anderen zu empfangen, um die zu ladengesteuerte Struktur zu identifizieren.
Struct Messaggione {// Teilstruktur ohne Typ
Zeichen Nachricht [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();
In ähnlicher Weise erstelle ich eine Reihe von Methoden, die mit der festen Übertragung verwendet werden können.
Sie müssen nur die Sendungsmethode ändern, da das Zielgerät beim Einstellen des festen Modus die Präambel mit Adresse und Kanal nicht empfängt.
Für die String -Nachricht haben Sie also
Responstatus sendFixedMessage (Byte addh, byte addl, byte chan, const string meldung);
Reponestatus sendBroadcastFixedMessage (Byte Chan, const String -Nachricht);
Und für die Struktur haben Sie
Reponestatus sendFixedMessage (byte addh, byte addl, byte chan, const void *message, const Uint8_t Größe);
Reponestatus sendBroadcastFixedMessage (Byte Chan, Const void *Message, const Uint8_t Größe);
Hier ist ein einfaches Beispiel
Responstatus rs = e220ttl.sendfixedMessage (0, 0, 0x17, & Messaggione, sizeof (messaggione)); // responstatus rs = e220ttl.sendfixedMessage (0, 0, 0x17, "Ciao");
Das feste Übertragung hat mehr Szenarien
Wenn Sie an ein bestimmtes Gerät senden (zweites Szenario festgelegt), müssen Sie Addl, Addh und Chan hinzufügen, um es direkt zu identifizieren.
Responstatus rs = e220ttl.sendfixedMessage (2, 2, 0x17, "Nachricht an ein Gerät");
Wenn Sie eine Nachricht in einem bestimmten Kanal an alle Geräte senden möchten, können Sie diese Methode verwenden.
Responstatus rs = e220ttl.sendBroadcastFixedMessage (0x17, "Nachricht an einen Kanalgeräte");
Wenn Sie alle Broadcast -Nachrichten im Netzwerk empfangen möchten, müssen Sie Ihr ADDH und ADDL mit BROADCAST_ADDRESS festlegen.
ResponsedructionContainer C; c = e220Ttl.getConfiguration (); // Es ist wichtig, Konfigurationszeiger vor allen anderen Operationen zu erhalten Konfigurationskonfiguration = *(Konfiguration *) 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); c.close();
Jetzt haben Sie alle Informationen, um Ihre Arbeit zu erledigen, aber ich denke, es ist wichtig, einige echte Beispiele zu zeigen, um besser alle Möglichkeiten zu verstehen.
Github -Bibliothek
