EByte_LoRa_E220_Series_Library
vices
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
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 contra 2.4 GHz para el NRF24L01) pero a las primeras de la distancia (de 5000m a 11000m).
Lora Smart Home (LLCC68) es un transceptor de RF Lora® Sub-Ghz para aplicaciones inalámbricas interiores y interiores a exteriores. Interfaz SPI. Pin-to-Pin es compatible con SX1262. SX1261, SX1262, SX1268 y LLCC68 están diseñados para una duración de batería larga con solo 4.2 mA de consumo de corriente de recepción activa. El SX1261 puede transmitir hasta +15 dBm, y el SX1262, SX1268 y LLCC68 pueden transmitir hasta +22 dBm con amplificadores de potencia integrados altamente eficientes.
Estos dispositivos admiten la modulación Lora para los casos de uso de LPWAN y (g) modulación FSK para casos de uso heredado. Los dispositivos son altamente configurables para cumplir con diferentes requisitos de aplicación para el uso del consumidor. El dispositivo proporciona una modulación LORA compatible con los transceptores SEMTech utilizados por la especificación Lorawan® liberada por Lora Alliance®. La radio es adecuada para sistemas dirigidos al cumplimiento de las regulaciones de radio, incluidos, entre otros, ETSI EN 300 220, FCC CFR 47 Parte 15, Requisitos regulatorios de China y el Japones Japones T-108 ARIB T-108. La cobertura de frecuencia continua de 150MHz a 960MHz permite el apoyo de todas las principales bandas ISM de Sub-Ghz en todo el mundo.
| LLCC68 | SX1278-SX1276 | |
|---|---|---|
| Distancia | > 11 km | 8 km |
| Tasa (lora) | 1.76kbps - 62.5kbps | 0.3kbps - 19.2kbps |
| Consumo de energía del sueño | 2 µA | 5 µA |
Puede encontrar mi biblioteca aquí, y está disponible en Arduino IDE Library Manager.
Para descargar.
Haga clic en el botón Descargas en la esquina superior derecha, cambie el nombre de la carpeta sin comprimir Lora_e220.
Verifique que la carpeta Lora_e220 contenga Lora_e220.cpp y Lora_e220.h.
Coloque la carpeta de la biblioteca Lora_e220 en su carpeta / bibliotecas /.
Es posible que deba crear la subcarpeta de las bibliotecas si es su primera biblioteca.
Reinicie el ide.
| Pin No. | Artículo de PIN | Dirección del alfiler | Aplicación PIN |
|---|---|---|---|
| 1 | M0 | Entrada （Plegada débil） | Trabaje con M1 y decida los cuatro modos de operación. No se permite flotar; puede ser molido. |
| 2 | M1 | Entrada （Plegada débil） | Trabaje con M0 y decida los cuatro modos de operación. No se permite flotar; puede ser molido. |
| 3 | Rxd | Aporte | Las entradas TTL UART se conectan a un pin de salida TXD externo (MCU, PC). Se puede configurar como entrada abierta o entrada de pull-up. |
| 4 | TXD | Producción | Las salidas TTL UART se conectan al pin de entrada RXD externo (MCU, PC). Se puede configurar como salida de drenaje abierto o push-pull |
5 | Aux | Producción | Para indicar el estado de trabajo del módulo y despertar el MCU externo. Durante el procedimiento de inicialización de autoevaluación, el PIN genera un nivel bajo. Se puede configurar como salida de drenaje abierto o pull-pull (se permite flotar). |
| 6 | VCC | Fuente de alimentación 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 | Los canales de UART e inalámbricos están abiertos, y la transmisión transparente está encendida |
| Transmisor WOR | 0 | 1 | Transmisor WOR |
| Receptor de wor | 1 | 0 | RECEPTOR WOR (SIGUIENTE AMIRE AIR) |
| Modo de suspensión profunda | 1 | 1 | El módulo va a dormir (despierta automáticamente al configurar los parámetros) |
Algunos pines se pueden usar estáticamente, pero si los conecta al microcontrolador y los configura en la biblioteca, obtiene el rendimiento y puede controlar todos los modos a través del software. Aún así, vamos a explicar mejor a continuación.
Como ya dije, no es esencial conectar todos los pines a la salida del microcontrolador; Puede poner pines M0 y M1 a altos o bajos para obtener la configuración deseada. Si no conecta Aux, la biblioteca establece un retraso razonable para garantizar que la operación esté completa ( si tiene problemas con el congelamiento del dispositivo, debe colocar una resistencia de 4.7k pull-up o conectarse mejor al dispositivo ).
Al transmitir datos se pueden usar para despertar MCU externo y devolver un alto al final de la transferencia de datos.
Al recibir, Aux se baja y regresa alto cuando el búfer está vacío.
También se utiliza para la autoevaluación para restaurar la operación regular (en modo de encendido y sueño/programa).
El esquema de conexión ESP8266 es más sencillo porque funciona a la misma voltaje de comunicaciones lógicas (3.3V).
Es esencial agregar una 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 tiene 3 serías.
| 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 para despertarse) |
| VCC | 5V (pero trabaja con menos potencia en 3.3V) |
| Gnd | Gnd |
El voltaje de trabajo de Arduino es de 5V, por lo que necesitamos agregar un divisor de voltaje en el pin Rx 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, luego juntarla en RX.
| 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 |
| M0 | 2 (divisor de voltaje) |
| M1 | 3 (divisor de voltaje) |
| Tx | Pin 14 TX (pullup 4,7kΩ) |
| Rx | Pin 13 RX (pullup 4,7kΩ) |
| Aux | Pin 1 (pullup 4,7kΩ) |
| VCC | 5V |
| Gnd | Gnd |
Hice un conjunto de numerosos constructores porque podemos tener más opciones y situaciones para administrar.
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);
El primer conjunto de constructores se crea para delegar en serie y otros pines a la biblioteca.
txE220pin y rxE220pin son los pines para conectarse a UART. 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 no es obligatorio ; Si no lo configura, aplico un retraso para permitir que la operación se complete (con la latencia, si tiene problemas, como el dispositivo de congelación, debe poner una resistencia de 4.7k pull-up o conectarse mejor 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 altas o bajas . Aún así, para una prueba, son útiles para ser administrados por la biblioteca.bpsRate es la tasa de baudios de SoftWareserial es típicamente 9600 (la única tasa de baudios en el modo de programación/suspensión)Un ejemplo simple es
#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
Podemos usar un software directamente con otro constructor
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);
El ejemplo superior con este constructor se puede hacer así.
#Include <SoftWareserial.h> #include "Lora_e220.h"Softwareserial mySerial (2, 3); // E220 TX E220 RX Lora_e220 e220ttl (y myserial); // lora_e220 e220ttl (y myserial, 5, 7, 6);
El último conjunto de constructores es permitir un hardwareserial en lugar de software.
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);
Para ESP32, tiene tres constructores adicionales para permitir administrar pines para la serie de hardware.
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_t serialconfig = serial_8n1);
El comando BEGIN se usa para iniciar serial y pines en el modo de entrada y salida.
void begin ();
en ejecución es
// Inicio todos los alfileres y UART e220ttl.begin ();
Existen muchos métodos para administrar la configuración y obtener información sobre el dispositivo.
ResponseStructContainer getConfiguration (); ResponseStatus setConfiguration (configuración de configuración, programa_command saveType = write_cfg_pwr_dwn_lose);ResponseStructContainer getModuleInformation(); void printParameters(struct Configuration configuration); ResponseStatus resetModule();
Para simplificar la gestión de la respuesta, creé un conjunto de contenedores, que es muy útil para administrar errores y devolver datos genéricos.
El ResponseStatus is a status container and has two 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 ()); // Descripción del código Serial.println (C.Code); // 1 si el éxito
El código es
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_recogned
Este contenedor se crea para administrar la respuesta de la cadena y tiene dos puntos de entrada.
data con la cadena devuelta del mensaje y status una instancia de RepsonseStatus .
ResponseContainer rs = e220ttl.Receivemessage (); Mensaje de cadena = rs.data;Serial.println(rs.status.getResponseDescription()); Serial.println(message);
Pero este comando va a leer todos los datos en el búfer. Si recibe tres mensajes, leerá las tres notas a la vez, y mi solución simple es usar un carácter final para enviar al final del mensaje, a predeterminado uso 0 (carácter nulo)
ResponseContainer rs = e220ttl.ReceivemessageUtil ();
// también puede especificar un delimitador personalizado
// ResponseContainer rs = e220ttl.ReceivemessAgeUtil ('|');
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);
Esta versión del dispositivo también admite RSSI. Para leer ese parámetro (si especifica en la configuración que desea enviar también), puede usar
ResponseContainer rc = e220ttl.Receivemessagerssi (); Mensaje de cadena = rs.data;Serial.println(rs.status.getResponseDescription()); Serial.println(message); Serial.print("RSSI: "); Serial.println(rc.rssi, DEC);
El ResponseStructContainer es el contenedor más "complejo". Utilizo esto para administrar estructuras, tiene los mismos puntos de entrada de ResponseContainer, pero los datos son un puntero nulo para administrar una estructura compleja.
ResponseStructContainer C;
c = e220ttl.getConfiguration ();
// es importante obtener un puntero de configuración antes de toda la operación
Configuración Configuración = *(Configuración *) C.Data;
Serial.println (c.status.getResponseDescription ());
Serial.println (c.status.code);
C.Close ();
Si recibe un mensaje estructurado con RSSI, puede usar
ResponseStructContainer rsc = E220ttl.Receivemessagerssi (sizeOf (mensaje));
Serial.println (rsc.status.getResponseDescription ());
struct Message Message = *(Mensaje *) 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 ();
Cada vez que usa un ResponseStructContainer , debe cerrarlo con close()
El primer método es GetConfiguration, y puede usarlo para recuperar todos los datos almacenados en el dispositivo.
ResponseStructContainer getConfiguration ();
Aquí hay un ejemplo de uso.
ResponseStructContainer C;
c = e32ttl.getConfiguration ();
// es importante obtener un puntero de configuración antes de toda la operación
Configuración Configuración = *(Configuración *) 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; // Primera parte de la dirección configuración.addh = 0x00; // segunda parteconfiguration.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
Tiene la función equivalente para todos los atributos para obtener todas las descripciones:
void printParameters (configuración de configuración 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 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 (configuración de configuración, programa_command saveType = write_cfg_pwr_dwn_lose);
configuration es la estructura que se muestra previamente, saveType le permite elegir si el cambio se vuelve permanente o solo para la sesión actual.
ResponseStructContainer C; c = e32ttl100.getConfiguration (); // es importante obtener un puntero de configuración antes de toda la operación Configuración Configuración = *(Configuración *) 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()
Los parámetros se gestionan como constantes:
| Nombre | Descripción | DIRECCIÓN |
|---|---|---|
| Adjunta | Byte de dirección alta del módulo (el 00h predeterminado) | 00h |
| Complemento | Byte de dirección baja del módulo (el 00h predeterminado) | 01h |
| Acelerado | Información sobre la velocidad de datos Bit de paridad y la velocidad de datos del aire | 02h |
| OPCIÓN | Tipo de transmisión, tamaño de paquete, permitir el mensaje especial | 03h |
| Chan | Canal de comunicación （410m + chan*1m）, predeterminado 17H (433MHz), válido solo para la verificación del dispositivo de 433MHz a continuación para verificar la frecuencia correcta de su dispositivo | 04h |
| OPCIÓN | Tipo de transmisión, tamaño de paquete, permitir el mensaje especial | 05h |
| Transmission_mode | Muchos parámetros que especifican la modalidad de transmisión | 06h |
| CRIPTA | Cifrado para evitar la intercepción | 07H |
Bit de paridad UART: el modo UART puede ser diferente entre las fiestas de comunicación
| Bit de paridad de uart | Valor constante |
|---|---|
| 8N1 (predeterminado) | MODE_00_8N1 |
| 8O1 | MODE_01_8O1 |
| 8E1 | MODE_10_8E1 |
| 8n1 (igual a 00) | MODE_11_8N1 |
Tasa de baudios de UART: la tasa de baudios de UART puede ser diferente entre las partes de comunicación (pero no se registran). La tasa de baudios UART no tiene nada que ver con los parámetros de transmisión inalámbrica y no afectará las funciones de transmisión/recepción inalámbrica.
| TTL UART BAUD TASA （BPS） | Valor constante |
|---|---|
| 1200 | Uart_bps_1200 |
| 2400 | Uart_bps_2400 |
| 4800 | Uart_bps_4800 |
| 9600 (predeterminado) | Uart_bps_9600 |
| 19200 | Uart_bps_19200 |
| 38400 | Uart_bps_38400 |
| 57600 | Uart_bps_57600 |
| 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 ser constante para ambas partes de comunicación.
| Velocidad de datos del aire （bps） | Valor constante |
|---|---|
| 2.4k | AIR_DATA_RATE_000_24 |
| 2.4k | AIR_DATA_RATE_001_24 |
| 2.4k (predeterminado) | 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 |
Esta es la longitud máxima del paquete.
Cuando los datos son más pequeños que la longitud del subpacket, la salida en serie del extremo receptor es una salida continua ininterrumpida. El puerto serie de recepción del extremo generará la subpacket cuando los datos son más grandes que la longitud del subpacket.
| Tamaño de paquete | Valor constante |
|---|---|
| 200bytes (predeterminado) | SPS_200_00 |
| 128bytes | SPS_128_01 |
| 64bytes | SPS_064_10 |
| 32bytes | SPS_032_11 |
Este comando puede habilitar/deshabilitar el tipo de administración de RSSI, y es esencial administrar la configuración remota. Prestar atención no es el parámetro RSSI en el mensaje.
Cuando está habilitado, los comandos C0, C1, C2, C3 se pueden 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.
| RSSI Ambient Noise Habilitar | Valor constante |
|---|---|
| Permitir | Rssi_ambient_noise_enabled |
| Deshabilitar (predeterminado) | Rssi_ambient_noise_disabled |
Puede cambiar este conjunto de constantes aplicando una definición como así:
#define E220_22 // Valor predeterminado sin SET
Aplicable para E220 con 22dbm como potencia máxima.
No se recomienda una transmisión de baja potencia debido a su baja eficiencia de suministro de energía.
| Potencia de transmisión (aproximación) | Valor constante |
|---|---|
| 22dbm (predeterminado) | Power_22 |
| 17dbm | Power_17 |
| 13dbm | Power_13 |
| 10dbm | Power_10 |
Aplicable para E220 con 30dbm como potencia máxima.
No se recomienda una transmisión de baja potencia debido a su baja eficiencia de suministro de energía.
#Define E220_30
| Potencia de transmisión (aproximación) | Valor constante |
|---|---|
| 30dbm (predeterminado) | Power_30 |
| 27dbm | Power_27 |
| 24 dbm | Power_24 |
| 21dbm | Power_21 |
Puede configurar la frecuencia del canal también con esta definición:
// uno de #Define Frecuencia_433 #Define Frecuencia_170 #Define FRECUENCY_470 #Define Frecuencia_868 #Define FRECUENCY_915
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
| Habilitar RSSI | Valor constante |
|---|---|
| Permitir | Rssi_enabled |
| Deshabilitar (predeterminado) | Rssi_disable |
Modo de transmisión: los primeros tres bytes de la trama de datos de cada usuario se pueden usar como dirección alta/baja y canal en modo de transmisión fijo. 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.
| Bit de habilitación de transmisión fija | Valor constante |
|---|---|
| Modo de transmisión fijo | Ft_fixed_transmission |
| Modo de transmisión transparente (predeterminado) | Ft_transparent_transmission |
Cuando cuando se habilitan, los datos inalámbricos se monitorearán antes de transmitirlos, evitando la interferencia en cierta medida, pero pueden causar retraso en los datos.
| LBT habilita byte | Valor constante |
|---|---|
| Permitir | LBT_ENABLed |
| Deshabilitar (predeterminado) | LBT_DISABLED |
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.
| Hora de atención inalámbrica | Valor constante |
|---|---|
| 500 ms | Wake_up_500 |
| 1000 ms | Wake_up_1000 |
| 1500 ms | Wake_up_1500 |
| 2000 ms (predeterminado) | Wake_up_2000 |
| 2500 ms | Wake_up_2500 |
| 3000 ms | Wake_up_3000 |
| 3500 ms | Wake_up_3500 |
| 4000 ms | Wake_up_4000 |
Primero, debemos introducir un método simple pero práctico para verificar si algo está en el búfer de recepción.
int disponible ();
Es simple devolver cuántos bytes tiene en la transmisión actual.
El modo de transmisión normal/transparente envía mensajes a todos los dispositivos con la misma dirección y canal.
Hay muchos métodos para enviar/recibir mensajes, y vamos a explicar en detalle:
ResponseStatus SendMessage (Mensaje de cadena const);
ResponseContainer RecibiveMessage ();
El primer método es SendMessage y se usa para enviar una cadena a un dispositivo en modo normal .
ResponseStatus rs = e220ttl.sendMessage ("prova");
Serial.println (rs.getResponseDescription ());
El otro dispositivo simplemente lo hace en el bucle.
if (e220ttl.available ()> 1) {
ResponseContainer rs = e220ttl.Receivemessage ();
Mensaje de cadena = rs.data; // Primero obtenga los datos
Serial.println (rs.status.getResponseDescription ());
Serial.println (mensaje);
}
Preste atención si recibe múltiples mensajes en el búfer y no quiere leerlos todos a la vez. Debe usar ResponseContainer rs = e220ttl.receiveMessageUntil(); con un delimitador puesto en el final de enviar un mensaje.
Si habilitó el RSSI, debe usar receiveMessageRSSI .
Si desea enviar una estructura compleja, puede usar este método
Response SendMessage (Mensaje const void *, const uint8_t size);
ResponseStructContainer RecibiveMessage (const size Uint8_t);
Se usa para enviar estructura, por ejemplo:
struct Messaggione {
Tipo de char [5];
mensaje char [8];
Bool Mitico;
};
struct Messaggione Messaggione = {"temp", "peple", true};
ResponseStatus rs = e220ttl.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);
rsc.close ();
Si habilitó el RSSI, debe usar receiveMessageRSSI .
Si desea leer la primera parte del mensaje para administrar más tipos de estructura, puede usar este método.
ResponseContainer recibeInitialMessage (const size uint8_t size);
Lo creo para recibir una cadena con Tipo u otro para identificar la estructura para cargar.
struct Messaggione {// Estructura parcial sin tipo
mensaje 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();
Del mismo modo, creo un conjunto de métodos para usar con la 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 al configurar el modo fijo.
Entonces, para el mensaje de cadena, tienes
ResponseStatus sendFixedMessage (byte addh, byte addl, byte chan, const string mensaje);
ResponseStatus sendBroadCastFixedMessage (byte chan, const string mensaje);
Y para la estructura, tienes
ResponseStatus sendFixedMessage (byte addh, byte addl, byte chan, const void *mensaje, const uint8_t size);
ResponseStatus sendBroadCastFixedMessage (byte chan, const void *mensaje, const uint8_t size);
Aquí hay un ejemplo simple
ResponseStatus rs = e220ttl.sendfixedMessage (0, 0, 0x17, y Messaggione, sizeOf (Messaggione)); // ResponseTatus rs = e220ttl.sendfixedMessage (0, 0, 0x17, "Ciao");
La transmisión fija tiene más escenarios
Si envía a un dispositivo específico (el segundo escenario fijo de transmisión), debe agregar ADDL, ADDH y CHAN para identificarlo directamente.
ResponseStatus rs = e220ttl.sendfixedMessage (2, 2, 0x17, "mensaje a un dispositivo");
Si desea enviar un mensaje a todos los dispositivos en un canal especificado, puede usar este método.
ResponseStatus rs = e220ttl.sendBroadcastFixedMessage (0x17, "Mensaje a un dispositivo de un canal");
Si desea recibir todos los mensajes de transmisión en la red, debe configurar su ADDH y ADDL con BROADCAST_ADDRESS .
ResponseStructContainer C; c = e220ttl.getConfiguration (); // es importante obtener un puntero de configuración antes de toda la operación Configuración Configuración = *(Configuración *) 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();
Ahora tiene toda la información para hacer su trabajo, pero creo que es importante mostrar algunos ejemplos reales para comprender mejor todas las posibilidades.
Biblioteca de Github
