EByte_LoRa_E22_Series_Library
1.0.0
https://downloads.arduino.cc/libraries/logs/github.com/xreef/ebyte_lora_e22_series_library/
Puedes pedir el PCB aquí
Instrucción y video de ensamblaje en 6 parte de la guía
Puedes pedir el PCB aquí
Instrucción y video de ensamblaje en 6 parte de la guía
Creo una biblioteca para administrar la serie EBYTE E22 de dispositivos Lora, muy potente, simple y barato dispositivo.
La telemetría de datos inalámbricos de Lora o de largo alcance es una tecnología pionera por SEMTech que funciona a una frecuencia más baja que NRF24L01 (433 MHz, 868 MHz o 916 MHz nuevamente 2.4 GHz para el NRF24L01) pero a las tres veces de la distancia (de 4000m a 10000m).
Lora E22
Puedes encontrar aquí AliExpress (433MHz 4km) - AliExpress (433MHz 10 km)
Consulte mi artículo para obtener un esquema actualizado
Puedes encontrar mi biblioteca aquí.
Para descargar.
Haga clic en el botón Descargas en la esquina superior derecha, cambie el nombre de la carpeta sin comprimir Lora_e22.
Verifique que la carpeta Lora_e22 contenga Lora_e22.cpp y Lora_e22.h.
Coloque la carpeta de biblioteca Lora_e22 su carpeta / bibliotecas /.
Es posible que deba crear la subcarpeta de las bibliotecas si es su primera biblioteca.
Reinicie el ide.
E22
| Pin No. | Artículo de PIN | Dirección del alfiler | Aplicación PIN |
|---|---|---|---|
| 1 | M0 | Entrada （Plegada débil） | Trabajar con M1 y decidir los cuatro modos de operación. Floating no está permitido, puede estar molido. |
| 2 | M1 | Entrada （Plegada débil） | Trabajar con M0 y decidir los cuatro modos de operación. No se permiten flotar, puede estar molido. |
| 3 | Rxd | Aporte | Entradas TTL UART, se conecta a la salida TXD externa (MCU, PC). Se puede configurar como entrada de drenaje abierto o pull-up. |
| 4 | TXD | Producción | Salidas de ttl uART, se conecta a la entrada externa RXD (MCU, PC). Se puede configurar como salida de drenaje abierto o push-pull |
5 | Aux | Producción | Por indicando lo stato di Funzionamento del Modulo e Riattivare l'c Mcu Esterno. Durante la Procedura di Inizializzazione di Autocontrollo, Il Pin Emette una Bassa tensión. Può Essere Configurato Come Uscita Open-drrain o salida Push-Pull (è consentito non metterlo a terra, ma se hai problemi, ad esempio ti si Si congele il è è preferibile Mettere una Restistenza di Da 4.7ko meglio Collegaro al apacitude). |
| 6 | VCC | Fuente de alimentación 2.3V ~ 5.5V DC | |
| 7 | Gnd | Suelo |
Como puede ver, puede establecer varios modos a través de pines M0 y M1.
| Modo | M1 | M0 | Explicación |
|---|---|---|---|
| Normal | 0 | 0 | UART y el canal inalámbrico están abiertos, la transmisión transparente está activada (admite la configuración a través del aire a través del comando especial) |
| Modo de trabajo | 0 | 1 | Se puede definir como transmisor WOR y receptor WORS |
| Modo de configuración | 1 | 0 | Los usuarios pueden acceder al registro a través del puerto serie para controlar el estado de trabajo del módulo |
| Modo de suspensión profunda | 1 | 1 | Modo de suspensión |
Como puede ver, hay algunos pines que se pueden usar de manera estática, pero si la conecta a la biblioteca que obtiene en rendimiento y puede controlar todo el modo a través del software, pero vamos a explicar mejor a continuación.
Como ya digo que no es importante conectar todo el PIN a la salida del microcontrolador, puede poner pines M0 y M1 a alta o baja para obtener una configuración desiderada, y si no conecta AUX, la biblioteca establece un retraso razonable para asegurarse de que la operación esté completa .
Al transmitir datos se pueden usar para despertar MCU externo y devolver un alto al final de la transferencia de datos.
Lora E22 Aux Pin en la transmisión
Al recibir AUX bajando y regrese alto cuando el búfer está vacío.
Lora E22 Aux Pin en la recepción
También se utiliza para la autoevaluación para restaurar el funcionamiento normal (en modo de encendido y sueño/programa).
Lora E22 Aux Pin en la autoevaluación
El esquema de conexión ESP8266 es más simple porque funciona a la misma tensión de comunicaciones lógicas (3.3V).
Lora E22 TTL 100 WEMOS D1 Totalmente conectado
Es importante agregar resistencia pull-up (4,7 kohm) para obtener una buena estabilidad.
| 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 | 5V (pero trabaja con menos potencia en 3.3V) |
| Gnd | Gnd |
Esquema de conexión similar para ESP32, pero para RX y TX usamos RX2 y TX2, porque por defecto ESP32 no tiene SoftWareserial pero tenemos 3 serías.
EBYTE LORA E22 Dispositivo ESP32 Kit de desarrollo V1 Conexión completa
| E22 | ESP32 |
|---|---|
| M0 | D21 |
| M1 | D19 |
| Tx | PIN RX2 (pullup 4,7kΩ) |
| Rx | Pin TX3 (pullup 4,7kΩ) |
| Aux | Pin D18 (pullup 4,7kΩ) |
| VCC | 5V (pero trabaja con menos potencia en 3.3V) |
| Gnd | Gnd |
El voltaje de trabajo Arduino es de 5V, por lo que necesitamos agregar un divisor de voltaje en el pin M0 y M1 del módulo Lora para evitar daños, puede obtener más información aquí divisor de voltaje: calculadora y aplicación.
Puede usar una resistencia de 2kohm a GND y 1KOHM de la señal que la junta en RX.
Lora e22 ttl 100 arduino totalmente conectado
| M0 | 7 (divisor de voltaje) |
| M1 | 6 (divisor de voltaje) |
| Tx | Pin 2 (pullup 4,7kΩ) |
| Rx | Pin 3 (Divisor de voltaje de 4,7kΩ y voltaje) |
| Aux | Pin 5 (pullup 4,7kΩ) |
| VCC | 5V |
| Gnd | Gnd |
Hice un conjunto de constructores bastante numerosos, porque podemos tener más opciones y situaciones para administrar.
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);Se crean el primer conjunto de constructor para delegar la gestión de los pines seriales y otros pines a la biblioteca.
txE22pin y rxE22pin es el pin para conectarse a UART y son obligatorios .auxPin es un PIN que verifica la operación, la transmisión y el estado de recepción (vamos a explicar mejor a continuación), ese pin que no es obligatorio , si no lo configura, aplico un retraso para permitir que la operación se complete (con latencia, si tiene problemas, como el dispositivo de congelación, debe poner una resistencia de 4.7k o mejor conectarme al dispositivo ).m0pin y m1Pin son los pines para cambiar el modo de operación (ver la parte superior de la tabla), creo que estos pines en la "producción" se conectarán directamente altos o bajos , pero para la prueba son útiles para ser administrados por la biblioteca.bpsRate es el boudrato de softwareSerial normalmente es 9600 (la única tasa de baudios en el modo de programación/suspensión)Un ejemplo simple es
# include " LoRa_E22.h "
LoRa_E22 e22ttl100 ( 2 , 3 ); // RX, TX
// LoRa_E22 e22ttl100(2, 3, 5, 6, 7); // RX, TXPodemos usar directamente un softwareSerial con otro constructor
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);El ejemplo superior con este constructor puede ser así.
# include < SoftwareSerial.h >
# include " LoRa_E22.h "
SoftwareSerial mySerial ( 2 , 3 ); // RX, TX
LoRa_E22 e22ttl100 (mySerial);
// LoRa_E22 e22ttl100(&mySerial, 5, 7, 6);El último conjunto de constructor es permitir usar un hardwareserial en lugar de software.
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);El comando BEGIN se usa para iniciar serial y pines en el modo de entrada y salida.
void begin ();en ejecución es
// Startup all pins and UART
e22ttl100.begin();Hay un conjunto de métodos para administrar la configuración y obtener información del dispositivo.
ResponseStructContainer getConfiguration ();
ResponseStatus setConfiguration (Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);
ResponseStructContainer getModuleInformation ();
void printParameters ( struct Configuration configuration);Para simplificar la administración de la respuesta, creo un conjunto de contenedores, para mí de manera muy útil para administrar errores y devolver datos genéricos.
Este es un contenedor de estado y tiene 2 puntos de entrada simples, con esto puede obtener el código de estado y la descripción del código de estado
Serial.println(c.getResponseDescription()); // Description of code
Serial.println(c.code); // 1 if SuccessEl código es
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_RECOGNIZEDEste contenedor se crea para administrar la respuesta de la cadena y tener 2 puntos de entrada.
data con la cadena devuelta del mensaje y status una instancia de RepsonseStatus .
ResponseContainer rs = e22ttl.receiveMessage();
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);Este es el contenedor más "complejo", uso esto para administrar la estructura, tiene el mismo punto de entrada de respuestas, pero los datos son un puntero vacío para administrar una estructura compleja.
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();El primer método es GetConfiguration, puede usarlo para recuperar todos los datos almacenados en el dispositivo.
ResponseStructContainer getConfiguration ();Aquí un ejemplo de uso.
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 estructura de la configuración tiene todos los datos de configuración, y agrego una serie de funciones para obtener toda la descripción de datos únicos.
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 timingTiene la función equivalente para obtener toda la descripción:
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());De la misma manera, SetConfiguration quiere una estructura de configuración, por lo que creo que la mejor manera de administrar la configuración es recuperar la actual, aplicar el único cambio que necesita y configurarlo nuevamente.
ResponseStatus setConfiguration (Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE); configuration es el show previsivo de estructura, el permiso saveType para que usted se vaya a Choiche si el cambio se vuelve permanentemente de solo para la sesión actual.
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()El parámetro todo manejado como constante:
| Adjunta | Byte de dirección alta del módulo (el 00h predeterminado) | 00h-ffh |
| Complemento | Byte de dirección baja del módulo (el 00H predeterminado) | 00h-ffh |
| Acelerado | Información sobre la velocidad de datos Bit de paridad y la velocidad de datos del aire | |
| Chan | Canal de comunicación （410m + chan*1m）, predeterminado 17H (433MHz), válido solo para el dispositivo de 433MHz Chek a continuación para verificar la frecuencia correcta de su dispositivo | 00h-1fh |
| OPCIÓN | Tipo de transmisión, tamaño de paquete, permitir un mensaje especial | |
| Transmission_mode | Mucho parámetro que especifica la modalidad de transmisión |
OPCIÓN
Tipo de transmisión, configuración de pull-up, tiempo de atención, FEC, potencia de transmisión
Bit de paridad UART: el modo UART puede ser diferente entre las fiestas de comunicación
| 4 | 3 | Bit de paridad de uart | Valor constante |
| 0 | 0 | 8N1 (predeterminado) | MODE_00_8N1 |
| 0 | 1 | 8O1 | MODE_01_8O1 |
| 1 | 0 | 8 E1 | MODE_10_8E1 |
| 1 | 1 | 8n1 (igual a 00) | MODE_11_8N1 |
UART BAUD Tasa: la tasa de baudios de UART puede ser diferente entre las partes de comunicación, la tasa de baudios UART no tiene nada que ver con los parámetros de transmisión inalámbrica y no afectará las características inalámbricas de transmisión / recepción.
| 7 | 6 | 5 | TTL UART BAUD TASA （BPS） | Valor 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 (predeterminado) | 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 |
Velocidad de datos del aire: cuanto menor sea la velocidad de datos del aire, más larga es la distancia de transmisión, un mejor rendimiento anti-interferencia y un tiempo de transmisión más largo, la velocidad de datos del aire debe mantener lo mismo para ambas partes de comunicación.
| 2 | 1 | 0 | Velocidad de datos del aire （bps） | Valor 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 (predeterminado) | 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 |
#### Sub paquete
Esta es la longitud máxima del paquete.
Cuando los datos son más pequeños que la longitud del subtract, la salida en serie del extremo receptor es una salida continua ininterrumpida. Cuando los datos son más grandes que la longitud del subconjunto, el puerto serie de recepción de la finalización generará el subconjunto.
| 7 | 6 | Tamaño de paquete | Valor constante |
| 0 | 0 | 240bytes (predeterminado) | SPS_240_00 |
| 0 | 1 | 128bytes | SPS_128_01 |
| 1 | 0 | 64bytes | SPS_064_10 |
| 1 | 1 | 32bytes | SPS_032_11 |
#### RSSI Ambient Noise Habilitar
Este comando puede habilitar/deshabilitar el tipo de administración de RSSI, es importante administrar la configuración remota, prestar atención no es el parámetro RSSI en el mensaje.
Cuando está habilitado, el comando C0 C1 C2 C3 se puede enviar en el modo de transmisión o el modo de transmisión WOR para leer el registro. Registro 0x00: Registro RSSI de ruido ambiental actual 0x01: RSSI Cuando los datos se recibieron la última vez.
| 5 | RSSI Ambient Noise Habilitar | Valor constante |
| 0 | Permitir | Rssi_ambient_noise_enabled |
| 1 | Deshabilitar (predeterminado) | Rssi_ambient_noise_disabled |
#### Potencia de transmisión
Puede cambiar este conjunto de constante aplicando una definición como así:
# define E22_22 // default value without set
# define E22_30Puede configurar OLSO de frecuencia de canal con esta definición:
// One of
# define FREQUENCY_433
# define FREQUENCY_170
# define FREQUENCY_470
# define FREQUENCY_868
# define FREQUENCY_915#### Habilitar RSSI
Cuando está habilitado, el módulo recibe datos inalámbricos y seguirá un byte de resistencia RSSI después de la salida a través del puerto serie TXD
#### Tipo de transmisión
Modo de transmisión: en el modo de transmisión fijo, los primeros tres bytes de la trama de datos de cada usuario se pueden usar como dirección y canal altos/bajos. El módulo cambia su dirección y canal cuando se transmite. Y volverá a la configuración original después de completar el proceso.
#### Habilitar la función del repetidor
#### Datos de monitor antes de la transmisión
Cuando cuando se habilitan, los datos inalámbricos se monitorearán antes de que se transmita, lo que puede evitar la interferencia en cierta medida, pero pueden causar retraso en los datos.
#### wor
Transmisor WOR: las funciones de recepción y transmisión del módulo se activan, y se agrega un código de atención al transmitir datos. Recibir está activado.
Receptor WOR: el módulo no puede transmitir datos y funciona en modo de monitoreo WOR. El período de monitoreo es el siguiente (ciclo WOR), que puede ahorrar mucha potencia.
#### ciclo wor
Si WORS se transmite: después de que el receptor WOR reciba los datos inalámbricos y los genera a través del puerto serie, esperará 1000 ms antes de ingresar al WOR nuevamente. Los usuarios pueden ingresar los datos del puerto serie y devolverlos a través de la inalámbrica durante este período. Cada byte serie se actualizará durante 1000 ms. Los usuarios deben transmitir el primer byte dentro de 1000 ms.
Primero debemos introducir un método simple pero útil para verificar si algo está en el búfer receptor
int available ();Es simplemente devolver cuántos bytes tiene en la transmisión actual.
El modo de transmisión normal/transparente se usa para enviar mensajes a todos los dispositivos con la misma dirección y canal.
Escenarios de transmisión de Lora E22, las líneas son canales
Hay muchos métodos para enviar/recibir un mensaje, vamos a explicar en detalle:
ResponseStatus sendMessage ( const String message);ResponseContainer receiveMessage ();El primer método es SendMessage y se usa para enviar una cadena a un dispositivo en modo normal .
ResponseStatus rs = e22ttl.sendMessage( " Prova " );
Serial.println(rs.getResponseDescription());El otro dispositivo simplemente lo hace en el bucle
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 desea enviar una estructura compleja, puede usar este método
ResponseStatus sendMessage ( const void *message, const uint8_t size);
ResponseStructContainer receiveMessage ( const uint8_t size);Se usa para enviar estrucutre, por ejemplo:
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());y el otro lado puede recibir el mensaje para que
ResponseStructContainer rsc = e22ttl.receiveMessage( sizeof (Messaggione));
struct Messaggione messaggione = *(Messaggione*) rsc.data;
Serial.println(messaggione.message);
Serial.println(messaggione.mitico);Si desea leer la primera parte del mensaje para administrar más tipo de estructura, puede usar este método.
ResponseContainer receiveInitialMessage ( const uint8_t size);Lo creo para recibir una cadena con tipo u otro para identificar la estructura para cargar.
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;De la misma manera, creo un conjunto de método para usar con transmisión fija
Debe cambiar solo el método de envío, porque el dispositivo de destino no recibe el preámbulo con la dirección y el canal.
Así que para el mensaje de cadena que tienes
ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const String message);
ResponseStatus sendBroadcastFixedMessage (byte CHAN, const String message);y para la estructura que tienes
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 );Aquí un ejemplo simple
ResponseStatus rs = e22ttl.sendFixedMessage( 0 , 0 , 0x17 , &messaggione, sizeof (Messaggione));
// ResponseStatus rs = e22ttl.sendFixedMessage(0, 0, 0x17, "Ciao");La transmisión fija tiene más escenarios
Escenarios de transmisión de Lora E22, las líneas son canales
Si envía a un dispositivo específico (segundos escenarios de transmisión fija), debe agregar ADDL, ADDH y CHAN para identificarlo directamente.
ResponseStatus rs = e22ttl.sendFixedMessage( 2 , 2 , 0x17 , " Message to a device " );Si desea enviar un mensaje a todos los dispositivos en un canal especificado, puede usar este método.
ResponseStatus rs = e22ttl.sendBroadcastFixedMessage( 0x17 , " Message to a devices of a channel " ); Si desea recibir todo el mensaje de transmisión en la red, debe establecer su ADDH y ADDL con 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();### Configuración inalámbrica
Este dispositivo admite la configuración inalámbrica con comando sepecial, pero parece que no funciona, le pido a Ebyte pero no recibió respuesta.
Implemento un comando que envía el paquete de la manera correcta (probado con un analizador lógico) pero parece que no funciona.
Por cierto, primero usted es el entorno de ruido RSSI, de lo que puede usar el comando así:
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;Ahora tiene toda la información para hacer su trabajo, pero creo que es importante mostrar algunos ejemplos realistas para desanimar mejor todas las posibilidades.
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Configuración y uso básico
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Biblioteca
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Configuración
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Transmisión fija y RSSI
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Guardado de energía y envío de datos estructurados
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Modo repetidor y configuraciones remotas
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Microcontrolador WOR y Arduino Shield
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Microcontrolador WOR y WEMOS D1 SHIELD
Dispositivo Ebyte Lora E22 para Arduino, ESP32 o ESP8266: Microcontrolador WOR y ESP32 Dev V1 Shield
