EByte_LoRa_E220_Series_Library
vices
Você pode pedir o PCB aqui
Vídeo de instrução e montagem em 6 parte do guia
Você pode pedir o PCB aqui
Vídeo de instrução e montagem em 6 parte do guia
A telemetria de dados sem fio Lora ou de longo alcance é uma tecnologia pioneira pela Semtech que opera com uma frequência mais baixa que NRF24L01 (433 MHz, 868 MHz ou 916 MHz contra 2,4 GHz para o NRF24L01), mas a mais de 5000m a 11000m).
O Lora Smart Home (LLCC68) é um transceptor de RF Sub-GHZ Lora® para aplicações internas e internas para externas a médio alcance. Interface SPI. O pino a pino é compatível com SX1262. SX1261, SX1262, SX1268 e LLCC68 são projetados para uma longa duração da bateria com apenas 4,2 mA de consumo atual de recebimento ativo. O SX1261 pode transmitir até +15 dBm e o SX1262, SX1268 e LLCC68 podem transmitir até +22 dBm com amplificadores de potência integrados altamente eficientes.
Esses dispositivos suportam a modulação LORA para casos de uso de LPWAN e (g) modulação FSK para casos de uso herdado. Os dispositivos são altamente configuráveis para atender aos diferentes requisitos de aplicativos para uso do consumidor. O dispositivo fornece modulação LORA compatível com transceptores Semtech usados pela especificação Lorawan® divulgada pelo Lora Alliance®. O rádio é adequado para sistemas direcionados à conformidade com os regulamentos de rádio, incluindo, entre outros, o ETSI EN 300 220, o FCC CFR 47 Parte 15, os requisitos regulatórios da China e o Arib T-108 japonês. A cobertura de frequência contínua de 150MHz a 960MHz permite o suporte de todas as principais bandas de ISM de sub-GHZ em todo o mundo.
| LLCC68 | SX1278-SX1276 | |
|---|---|---|
| Distância | > 11 km | 8 km |
| Taxa (Lora) | 1,76kbps - 62,5kbps | 0,3kbps - 19,2kbps |
| Consumo de energia do sono | 2µA | 5µA |
Você pode encontrar minha biblioteca aqui e está disponível no Arduino IDE Library Manager.
Para baixar.
Clique no botão de downloads no canto superior direito, renomeie a pasta não compactada lora_e220.
Verifique se a pasta LORA_E220 contém Lora_E220.cpp e lora_e220.h.
Coloque a pasta da biblioteca Lora_E220 na sua pasta / bibliotecas /.
Pode ser necessário criar a subpasta das bibliotecas se for sua primeira biblioteca.
Reinicie o IDE.
| PIN No. | Item de pino | Direção do pino | Aplicação PIN |
|---|---|---|---|
| 1 | M0 | Entrada （Pull-up fraca） | Trabalhe com M1 e decida os quatro modos operacionais. Flutuar não é permitido; pode ser moído. |
| 2 | M1 | Entrada （Pull-up fraca） | Trabalhe com M0 e decida os quatro modos de operação. Flutuar não é permitido; pode ser moído. |
| 3 | Rxd | Entrada | As entradas TTL UART conectam -se ao pino de saída externo (MCU, PC). Ele pode ser configurado como entrada de drenagem aberta ou pull-up. |
| 4 | Txd | Saída | As saídas TTL UART conectam -se ao pino de entrada RXD externo (MCU, PC). Pode ser configurado como saída de drenagem aberta ou push-pull |
5 | Aux | Saída | Para indicar o status de funcionamento do módulo e acordar o MCU externo. Durante o procedimento de inicialização de auto-verificação, o pino gera um nível baixo. Ele pode ser configurado como saída de drenagem aberta ou push-pull (é permitido flutuante). |
| 6 | VCC | Fonte de alimentação 3V ~ 5,5V DC | |
| 7 | Gnd | Chão |
Como você pode ver, você pode definir vários modos via pinos M0 e M1.
| Modo | M1 | M0 | Explicação |
|---|---|---|---|
| Normal | 0 | 0 | Os canais UART e sem fio estão abertos e a transmissão transparente está ligada |
| Transmissor wor | 0 | 1 | Transmissor wor |
| Receptor wor | 1 | 0 | Receptor WOR (suporta o Wake Up Over Air) |
| Modo de suspensão profunda | 1 | 1 | O módulo vai dormir (acorde automaticamente ao configurar parâmetros) |
Alguns pinos podem ser usados estaticamente, mas se você os conectar ao microcontrolador e configurá -los na biblioteca, você ganha desempenho e poderá controlar todos os modos via software. Ainda assim, vamos explicar melhor a seguir.
Como já disse, não é essencial conectar todos os pinos à saída do microcontrolador; Você pode colocar os pinos M0 e M1 em alta ou baixa para obter a configuração desejada. Se você não conectar o AUX, a biblioteca definirá um atraso razoável para garantir que a operação seja concluída ( se você tiver problemas com o congelamento do dispositivo, você deverá colocar um resistor de 4,7k de pull-up ou se conectar melhor ao dispositivo. ).
Ao transmitir dados, pode ser usado para acordar o MCU externo e retornar alto no acabamento da transferência de dados.
Ao receber, Aux fica baixo e retorna alto quando o buffer está vazio.
Também é usado para a auto-verificação para restaurar a operação regular (no modo de energia e sono/programa).
O esquema de conexão ESP8266 é mais direto porque funciona com a mesma tensão de comunicações lógicas (3.3V).
É essencial adicionar um resistor de pull-up (4,7kohm) para obter uma boa estabilidade.
| E22 | ESP8266 |
|---|---|
| M0 | D7 |
| M1 | D6 |
| Tx | Pino D2 (pullup 4,7kΩ) |
| Rx | Pino D3 (pullup 4,7kΩ) |
| Aux | Pino D5 (pullup 4,7kΩ) |
| VCC | 5V (mas trabalhe com menos energia em 3.3V) |
| Gnd | Gnd |
Esquema de conexão semelhante para ESP32, mas para RX e TX, usamos RX2 e TX2 porque, por padrão, o ESP32 não possui softwareserial, mas tem 3 serial.
| E22 | Esp32 |
|---|---|
| M0 | D21 |
| M1 | D19 |
| Tx | Pino rx2 (pullup 4.7kΩ) |
| Rx | Pino tx3 (pullup 4,7kΩ) |
| Aux | PIN D18 (pullup 4,7kΩ) (D15 para acordar) |
| VCC | 5V (mas trabalhe com menos energia em 3.3V) |
| Gnd | Gnd |
A tensão de trabalho do Arduino é 5V, por isso precisamos adicionar um divisor de tensão no pino RX M0 e M1 do módulo Lora para evitar danos; Você pode obter mais informações aqui divisor de tensão: calculadora e aplicação.
Você pode usar um resistor de 2kohm para GND e 1kOhm do sinal e depois montá -los no RX.
| M0 | 7 (divisor de tensão) |
| M1 | 6 (divisor de tensão) |
| Tx | Pino 2 (pullup 4,7kΩ) |
| Rx | Pino 3 (pullup 4,7kΩ e divisor de tensão) |
| Aux | Pino 5 (pullup 4,7kΩ) |
| VCC | 5V |
| Gnd | Gnd |
| M0 | 2 (divisor de tensão) |
| M1 | 3 (divisor de tensão) |
| Tx | Pino 14 TX (pullup 4,7kΩ) |
| Rx | Pino 13 rx (pullup 4,7kΩ) |
| Aux | Pino 1 (pullup 4,7kΩ) |
| VCC | 5V |
| Gnd | Gnd |
Fiz um conjunto de numerosos construtores porque podemos ter mais opções e situações para gerenciar.
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);
O primeiro conjunto de construtores é criado para delegar pinos seriais e outros na biblioteca.
txE220pin e rxE220pin são os pinos para se conectar ao UART. Eles são obrigatórios .auxPin é um pino que verifica a operação, a transmissão e o status de recebimento (vamos explicar melhor a seguir), esse pino não é obrigatório ; Se você não o definir, aplico um atraso para permitir que a operação se complete (com latência, se você tem problemas, como o dispositivo Freeze, você deve colocar um resistor de 4,7k de pull-up ou se conectar melhor ao dispositivo ).m0pin e m1Pin são os pinos para alterar o modo de operação (consulte a parte superior da tabela), acho que esses pinos na “produção” se conectarão diretamente ou baixos . Ainda assim, para um teste, eles são úteis para serem gerenciados pela biblioteca.bpsRate é a taxa de transmissão do softwareserial é tipicamente 9600 (a única taxa de transmissão no modo de programação/suspensão)Um exemplo simples é
#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 um softwareserial diretamente com outro construtor
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);
O exemplo superior com este construtor pode ser feito assim.
#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);
O último conjunto de construtores é permitir um hardwareserial em vez de softwareserial.
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 o ESP32, você tem três construtores adicionais para permitir gerenciar pinos para série 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, uint_bps_t Serialfig = UART_BPS_RATE_9600, UINT32_T
O comando BEGIN é usado para inicializar serial e pinos no modo de entrada e saída.
vazio começo ();
na execução é
// Startup todos os pinos e uart e220ttl.begin ();
Existem muitos métodos para gerenciar a configuração e obter informações sobre o dispositivo.
ResponseSTructContainer getConfiguration (); Responsestatus SetConfiguration (Configuração da configuração, Program_Command SaveType = Write_CFG_PWR_DWN_LOSE);ResponseStructContainer getModuleInformation(); void printParameters(struct Configuration configuration); ResponseStatus resetModule();
Para simplificar o gerenciamento da resposta, criei um conjunto de contêineres, o que é muito útil para gerenciar erros e retornar dados genéricos.
O ResponseStatus is a status container and has two pontos de entrada simples, com isso você pode obter o código de status e a descrição do código de status
Serial.println (c.getResponsedescription ()); // Descrição do código Serial.println (c.code); // 1 Se sucesso
O código é
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_recognizado
Este contêiner é criado para gerenciar a resposta da string e possui dois pontos de entrada.
data com a string retornados da mensagem e status Uma instância de RepsonseStatus .
ResponseContainer rs = e220ttl.receiveMessage (); String message = rs.data;Serial.println(rs.status.getResponseDescription()); Serial.println(message);
Mas este comando vai ler todos os dados no buffer. Se você receber três mensagens, lerá todas as três notas ao mesmo tempo, e minha solução simples é usar um caractere final para enviar no final da mensagem, para padrão eu usar 0 (caractere nulo)
ResponseContainer rs = e220ttl.receiveMessageuntil ();
// você pode especificar um delimitador personalizado também
// responseContainer rs = e220ttl.receiveMessageuntil ('|');
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);
Esta versão do dispositivo também suporta RSSI. Para ler esse parâmetro (se você especificar na configuração que deseja enviar também), você pode usar
ResponseContainer rc = e220ttl.receiveMessaGerssi (); String message = rs.data;Serial.println(rs.status.getResponseDescription()); Serial.println(message); Serial.print("RSSI: "); Serial.println(rc.rssi, DEC);
O ResponseStructContainer é o contêiner mais "complexo". Eu uso isso para gerenciar estruturas, ele possui os mesmos pontos de entrada do responseContainer, mas os dados são um ponteiro vazio para gerenciar a estrutura complexa.
ResponsestructContainer C;
c = e220ttl.getConfiguration ();
// É importante obter o ponteiro de configuração antes de todas as outras operações
Configuração da configuração = *(Configuração *) C.Data;
Serial.println (c.status.getResponsedescription ());
Serial.println (c.status.code);
c.close ();
Se você receber uma mensagem estruturada com RSSI, poderá usar
ResponsestructContainer rSc = e220ttl.receiveMessaGerssi (sizeof (mensagem));
Serial.println (rsc.status.getResponsedescription ());
Mensagem da estrutura da estrutura = *(mensagem *) rsc.data;
Serial.println (message.type);
Serial.println (message.Message);
Serial.println (*(float*) (message.Temperature));
Serial.print ("rssi:"); Serial.println (rsc.rssi, dez);
rsc.close ();
Toda vez que você usa um ResponseStructContainer , você deve fechá -lo com close()
O primeiro método é o GetConfiguration e você pode usá -lo para recuperar todos os dados armazenados no dispositivo.
ResponseSTructContainer getConfiguration ();
Aqui está um exemplo de uso.
ResponsestructContainer C;
c = e32ttl.getConfiguration ();
// É importante obter o ponteiro de configuração antes de todas as outras operações
Configuração da configuração = *(Configuração *) C.Data;
Serial.println (c.status.getResponsedescription ());
Serial.println (c.status.code);
Serial.println (Configuration.sped.GetuartBaudrate ());
c.close ();
A estrutura da configuração possui todos os dados das configurações e adiciono uma série de funções para obter toda a descrição dos dados únicos.
Configuration.addl = 0x03; // Primeira parte do endereço Configuration.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
Você tem a função equivalente para todos os atributos para obter todas as descrições:
Void PrintParameters (Configuração da Struction) {
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("----------------------------------------");
}
Da mesma forma, o SetConfiguration deseja uma estrutura de configuração, então acho que a melhor maneira de gerenciar a configuração é recuperar a atual, aplicar a única alteração necessária e defini -la novamente.
Responsestatus SetConfiguration (Configuração da configuração, Program_Command SaveType = Write_CFG_PWR_DWN_LOSE);
configuration é a estrutura mostrada anteriormente, saveType permite escolher se a alteração se torna permanente ou apenas para a sessão atual.
ResponsestructContainer C; c = e32ttl100.getConfiguration (); // É importante obter o ponteiro de configuração antes de todas as outras operações Configuração da configuração = *(Configuração *) 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()
Os parâmetros são todos gerenciados como constantes:
| Nome | Descrição | Endereço |
|---|---|---|
| Addh | Byte de endereço alto do módulo (o padrão 00H) | 00H |
| Addl | Byte de endereço baixo do módulo (o padrão 00H) | 01h |
| Acelerou | Informações sobre a taxa de paridade da taxa de dados e taxa de dados aéreos | 02H |
| OPÇÃO | Tipo de transmissão, tamanho do pacote, permita a mensagem especial | 03H |
| Chan | Canal de comunicação （410m + chan*1m）, padrão 17h (433MHz), válido apenas para 433MHz , verifique abaixo para verificar a frequência correta do seu dispositivo | 04H |
| OPÇÃO | Tipo de transmissão, tamanho do pacote, permita a mensagem especial | 05h |
| Transmission_mode | Muitos parâmetros que especificam a modalidade de transmissão | 06h |
| CRIPTA | Criptografia para evitar a interceptação | 07H |
Bit de paridade UART: o modo UART pode ser diferente entre as partes de comunicação
| Bit de paridade uart | Valor constante |
|---|---|
| 8n1 (padrão) | Mode_00_8n1 |
| 8o1 | Mode_01_8o1 |
| 8e1 | Mode_10_8e1 |
| 8n1 (igual a 00) | Mode_11_8n1 |
Taxa de transmissão UART: a taxa de transmissão UART pode ser diferente entre as partes da comunicação (mas não recomendadas). A taxa de transmissão UART não tem nada a ver com parâmetros de transmissão sem fio e não afetará os recursos de transmissão/recebimento sem fio.
| TTL UART BAUD Taxa （BPS） | Valor constante |
|---|---|
| 1200 | UART_BPS_1200 |
| 2400 | UART_BPS_2400 |
| 4800 | UART_BPS_4800 |
| 9600 (padrão) | UART_BPS_9600 |
| 19200 | UART_BPS_19200 |
| 38400 | UART_BPS_38400 |
| 57600 | UART_BPS_57600 |
| 115200 | UART_BPS_115200 |
Taxa de dados do ar: quanto menor a taxa de dados do ar, maior a distância de transmissão, melhor desempenho anti-interferência e tempo de transmissão mais longo; A taxa de dados aéreos deve ser constante para ambas as partes da comunicação.
| Taxa de dados aéreos （BPS) | Valor constante |
|---|---|
| 2.4k | AIR_DATA_RATE_000_24 |
| 2.4k | AIR_DATA_RATE_001_24 |
| 2.4K (padrão) | 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 |
Este é o comprimento máximo do pacote.
Quando os dados são menores que o comprimento do subpacket, a saída serial da extremidade receptora é uma saída contínua ininterrupta. A porta serial final do recebimento será lançada o subpacket quando os dados forem maiores que o comprimento do subpacket.
| Tamanho do pacote | Valor constante |
|---|---|
| 200bytes (padrão) | Sps_200_00 |
| 128 Bytes | Sps_128_01 |
| 64 Bytes | Sps_064_10 |
| 32Bytes | Sps_032_11 |
Este comando pode ativar/desativar o tipo de gerenciamento de RSSI e é essencial gerenciar a configuração remota. Preste atenção não é o parâmetro RSSI na mensagem.
Quando ativado, os comandos C0, C1, C2, C3 podem ser enviados no modo de transmissão ou no modo de transmissão Wor para ler o registro. REGISTRA 0X00: REGISTRO ABIENTE ABIENTE RSSI REGISTRO 0X01: RSSI Quando os dados foram recebidos da última vez.
| RSSI Ruído ambiente habilitado | Valor constante |
|---|---|
| Habilitar | Rssi_ambient_noise_enabled |
| Desativar (padrão) | Rssi_ambient_noise_disabled |
Você pode alterar esse conjunto de constantes aplicando uma definição como assim:
#Define E220_22 // Valor padrão sem definição
Aplicável para E220 com 22dBM como MAX Power.
A transmissão de baixa energia não é recomendada devido à sua baixa eficiência da fonte de alimentação.
| Poder de transmissão (aproximação) | Valor constante |
|---|---|
| 22dBM (padrão) | Power_22 |
| 17DBM | Power_17 |
| 13DBM | Power_13 |
| 10dBM | Power_10 |
Aplicável ao E220 com 30dBM como potência máxima.
A transmissão de baixa energia não é recomendada devido à sua baixa eficiência da fonte de alimentação.
#Define E220_30
| Poder de transmissão (aproximação) | Valor constante |
|---|---|
| 30dbm (padrão) | Power_30 |
| 27DBM | Power_27 |
| 24dBM | Power_24 |
| 21DBM | Power_21 |
Você pode configurar a frequência do canal também com isso definir:
// um de #Define Frequency_433 #Define Frequency_170 #Define Frequency_470 #Define Frequency_868 #Define Frequency_915
Quando ativado, o módulo recebe dados sem fio e seguirá um byte de força RSSI após a produção através da porta serial TXD
| Ativar RSSI | Valor constante |
|---|---|
| Habilitar | Rssi_enabled |
| Desativar (padrão) | Rssi_disabled |
Modo de transmissão: Os três primeiros bytes do quadro de dados de cada usuário podem ser usados como endereço e canal alto/baixo no modo de transmissão fixa. O módulo altera seu endereço e canal quando transmitido. E ele voltará para a configuração original após a conclusão do processo.
| Bit de transmissão fixa que habilita | Valor constante |
|---|---|
| Modo de transmissão fixo | Ft_fixed_transmission |
| Modo de transmissão transparente (padrão) | Ft_transparent_transmission |
Quando ativado, os dados sem fio serão monitorados antes de serem transmitidos, evitando interferências até certo ponto, mas podem causar atraso nos dados.
| LBT Ativar byte | Valor constante |
|---|---|
| Habilitar | Lbt_enabled |
| Desativar (padrão) | Lbt_disabled |
Se o WOR estiver transmitindo: depois que o receptor Wor receber os dados sem fio e o produzirá através da porta serial, ele aguardará 1000ms antes de entrar no We. Os usuários podem inserir os dados da porta serial e retorná -los via sem fio durante esse período. Cada byte em série será atualizado por 1000ms. Os usuários devem transmitir o primeiro byte dentro de 1000ms.
| Tempo de despertar sem fio | Valor constante |
|---|---|
| 500ms | Wake_up_500 |
| 1000ms | Wake_up_1000 |
| 1500ms | Wake_Up_1500 |
| 2000ms (padrão) | Wake_up_2000 |
| 2500ms | Wake_Up_2500 |
| 3000ms | Wake_up_3000 |
| 3500ms | Wake_Up_3500 |
| 4000ms | Wake_up_4000 |
Primeiro, devemos introduzir um método simples, mas prático, para verificar se algo está no buffer de recebimento.
int disponível ();
É simples retornar quantos bytes você tem no fluxo atual.
O modo de transmissão normal/transparente envia mensagens para todos os dispositivos com o mesmo endereço e canal.
Existem muitos métodos para enviar/receber mensagens, e vamos explicar em detalhes:
Responsestatus sendMessage (mensagem const string);
Responsecontainer Receivemessage ();
O primeiro método é o SendMessage e é usado para enviar uma string para um dispositivo no modo normal .
Responsestatus rs = e220ttl.sendMessage ("prota");
Serial.println (rs.getResponsedescription ());
O outro dispositivo simplesmente faz no loop.
if (e220ttl.Available ()> 1) {
ResponseContainer rs = e220ttl.receiveMessage ();
String message = rs.data; // Primeiro, obtenha os dados
Serial.println (rs.status.getResponsedescription ());
Serial.println (mensagem);
}
Preste atenção se você receber várias mensagens no buffer e não quiser lê -las todas ao mesmo tempo. Você deve usar ResponseContainer rs = e220ttl.receiveMessageUntil(); com um delimitador colocado no final do envio de uma mensagem.
Se você ativou o RSSI, deverá usar receiveMessageRSSI .
Se você deseja enviar uma estrutura complexa, pode usar este método
Responsestatus sendMessage (const void *mensagem, const uint8_t size);
ResponsestructContainer Receivemessage (const uint8_t size);
É usado para enviar estrutura, por exemplo:
struct mesaggione {
Tipo de char [5];
Mensagem de char [8];
Bool Mitico;
};
struct mesaggione mesaggione = {"temp", "peple", true};
Responsestatus rs = e220ttl.sendMessage (& Messaggione, sizeof (mesaggione));
Serial.println (rs.getResponsedescription ());
e o outro lado você pode receber a mensagem para
ResponsestructContainer rSc = e22ttl.receiveMessage (sizeof (mesaggione));
struct mesaggione mesaggione = *(mesaggione *) rsc.data;
Serial.println (mesaggione.message);
Serial.println (mesaggione.mitico);
rsc.close ();
Se você ativou o RSSI, deverá usar receiveMessageRSSI .
Se você deseja ler a primeira parte da mensagem para gerenciar mais tipos de estrutura, pode usar esse método.
ResponseContainer ReceberInitialMessage (const UINT8_T tamanho);
Eu o crio para receber uma string com tipo ou outro para identificar a estrutura para carregar.
struct mesaggione {// estrutura parcial sem tipo
Mensagem de 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();
Da mesma forma, crio um conjunto de métodos a serem usados com a transmissão fixa.
Você precisa alterar apenas o método de envio porque o dispositivo de destino não recebe o preâmbulo com endereço e canal ao definir o modo fixo.
Então, para a mensagem da string, você tem
Responsestatus sendfixedMessage (byte addh, byte addl, byte chan, const string mensagem);
Responsestatus sendbroadcastfixedMessage (byte chan, const string mensagem);
E para a estrutura, você tem
Responsestatus sendfixedMessage (byte addh, byte addl, byte chan, const void *mensagem, const uint8_t size);
Responsestatus sendbroadcastfixedMessage (byte chan, const void *mensagem, const uint8_t size);
Aqui está um exemplo simples
Responsestatus rs = e220ttl.sendfixedMessage (0, 0, 0x17, & Messaggione, sizeof (Messaggione)); // Responsestatus rs = e220ttl.sendfixedMessage (0, 0, 0x17, "ciao");
A transmissão fixa tem mais cenários
Se você enviar para um dispositivo específico (transmissão fixa do segundo cenário), deverá adicionar Addl, Addh e Chan para identificá -lo diretamente.
Responsestatus rs = e220ttl.sendfixedMessage (2, 2, 0x17, "mensagem para um dispositivo");
Se você deseja enviar uma mensagem para todos os dispositivos em um canal especificado, pode usar esse método.
Responsestatus rs = e220ttl.sendbroadcastfixedMessage (0x17, "mensagem para um dispositivo de um canal");
Se você deseja receber todas as mensagens de transmissão na rede, você deve definir seu ADDH e ADDL com BROADCAST_ADDRESS .
ResponsestructContainer C; c = e220ttl.getConfiguration (); // É importante obter o ponteiro de configuração antes de todas as outras operações Configuração da configuração = *(Configuração *) 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();
Agora você tem todas as informações para fazer seu trabalho, mas acho importante mostrar alguns exemplos reais para entender melhor todas as possibilidades.
Biblioteca Github
