EByte_LoRa_E22_Series_Library
1.0.0
https://downloads.arduino.cc/libraries/logs/github.com/xreef/ebyte_lora_e22_series_library/
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
Crio uma biblioteca para gerenciar a série Ebyte E22 de dispositivo Lora, muito poderoso, dispositivo simples e barato.
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 novamente 2,4 GHz para o NRF24L01), mas a mais de 4000m a 100m).
Lora E22
Você pode encontrar aqui Aliexpress (433MHz 4km) - Aliexpress (433MHz 10km)
Consulte o meu artigo para obter o esquema atualizado
Você pode encontrar minha biblioteca aqui.
Para baixar.
Clique no botão de downloads no canto superior direito, renomeie a pasta não compactada lora_e22.
Verifique se a pasta LORA_E22 contém Lora_E22.CPP e LORA_E22.H.
Coloque a pasta Lora_E22 da biblioteca sua pasta / Bibliotecas /.
Pode ser necessário criar a subpasta das bibliotecas se for sua primeira biblioteca.
Reinicie o IDE.
E22
| PIN No. | Item de pino | Direção do pino | Aplicação PIN |
|---|---|---|---|
| 1 | M0 | Entrada （Pull-up fraca） | Trabalhe com M1 e decida que os quatro modos de operação. O flutuação não é permitido, pode ser moído. |
| 2 | M1 | Entrada （Pull-up fraca） | Trabalhe com M0 e decida que os quatro modos de operação. O flutuação não é permitido, pode ser moído. |
| 3 | Rxd | Entrada | As entradas TTL UART, conectam -se a outputpin externo (MCU, PC). Pode ser configurado como entrada de drenagem aberta ou pull-up. |
| 4 | Txd | Saída | Saídas TTL UART, conecta -se ao RXD externo (MCU, PC) InputPin. Pode ser configurado como saída de drenagem aberta ou push-pull |
5 | Aux | Saída | Por indicare lo stato di funzionamento del modulo e riattarare l'cu esterno. DURANTE LA PROCEDURA di inizializazazione di AutoControllo, Il Pin Emette Una Bassa TensionE. Può Essere Configurato venha USCITA Open Drain o Output Push-Pull (è Consentito non metterlo a Terra, Ma se hai Problemi, ad esempio Ti Si congelamento Il Dispositivo è preferibile mettere una Restistenza Di Pull-up da 4.7ko megrio collegarlo Al Dispongarlo. |
| 6 | VCC | Fonte de alimentação 2.3V ~ 5,5V DC | |
| 7 | Gnd | Chão |
Como você pode ver, pode definir vários modos via pinos M0 e M1.
| Modo | M1 | M0 | Explicação |
|---|---|---|---|
| Normal | 0 | 0 | O canal UART e sem fio estão abertos, a transmissão transparente está ligada (suporta a configuração do ar via comando especial) |
| Modo Wor | 0 | 1 | Pode ser definido como o transmissor Wor e o receptor Wor |
| Modo de configuração | 1 | 0 | Os usuários podem acessar o registro através da porta serial para controlar o estado de trabalho do módulo |
| Modo de suspensão profunda | 1 | 1 | Modo de suspensão |
Como você pode ver, existem alguns pinos que podem ser usados de maneira estática, mas se você o conectar à biblioteca que você ganha no desempenho e poderá controlar todos os modos via software, mas vamos explicar melhor a seguir.
Como eu já digo que não é importante conectar todo o pino à saída do microcontrolador, você pode colocar os pinos M0 e M1 em alta ou baixa para obter configuração desidenciada e, se você não conectar aux ox, a biblioteca definir um atraso razoável para garantir que a operação esteja concluída .
Ao transmitir dados, pode ser usado para acordar o MCU externo e retornar alto no acabamento da transferência de dados.
Lora E22 Aux Pin na transmissão
Ao receber o aux de ficar baixo e retornar alto quando o buffer estiver vazio.
Lora E22 Aux Pin na recepção
Também é usado para verificação própria para restaurar a operação normal (no modo de energia e sono/programa).
Lora E22 Aux Pin na auto-verificação
O esquema de conexão ESP8266 é mais simples porque funciona na mesma tensão de comunicações lógicas (3.3V).
Lora E22 TTL 100 Wemos D1 totalmente conectado
É importante adicionar resistor 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 possui 3 serial.
Dispositivo EBYTE LORA E22 ESP32 DEV KIT V1 Conexão completa
| E22 | Esp32 |
|---|---|
| M0 | D21 |
| M1 | D19 |
| Tx | Pino rx2 (pullup 4.7kΩ) |
| Rx | Pino tx3 (pullup 4,7kΩ) |
| Aux | Pino D18 (pullup 4.7kΩ) |
| 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 do que montados no RX.
Lora E22 TTL 100 Arduino totalmente conectado
| 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 |
Fiz um conjunto de construtores bastante numerosos, porque podemos ter mais opções e situações para gerenciar.
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);O primeiro conjunto de construtores é criado para delegar o gerenciamento de pinos seriais e outros na biblioteca.
txE22pin e rxE22pin é o pino para se conectar ao UART e eles são obrigatórios .auxPin é um pino que verifique 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 de congelamento, você deve colocar um resistência de 4,7k de pull-up ou melhor conectar-se ao dispositivo ).m0pin e m1Pin são os pinos para alterar o modo de operação (consulte a tabela superior), acho que esses pinos na “produção” se conectarão diretamente ou baixos , mas para o teste eles são usados para serem gerenciados pela biblioteca.bpsRate é o boudrate do softwareserial normalmente é 9600 (a única taxa de transmissão no modo de programação/suspensão)Um exemplo simples é
# include " LoRa_E22.h "
LoRa_E22 e22ttl100 ( 2 , 3 ); // RX, TX
// LoRa_E22 e22ttl100(2, 3, 5, 6, 7); // RX, TXPodemos usar diretamente um softwareserial com outro construtor
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);O exemplo superior com este construtor pode ser assim.
# include < SoftwareSerial.h >
# include " LoRa_E22.h "
SoftwareSerial mySerial ( 2 , 3 ); // RX, TX
LoRa_E22 e22ttl100 (mySerial);
// LoRa_E22 e22ttl100(&mySerial, 5, 7, 6);O último conjunto de construtores é permitir usar um hardwareserial em vez de softwareserial.
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);O comando BEGIN é usado para inicializar serial e pinos no modo de entrada e saída.
void begin ();na execução é
// Startup all pins and UART
e22ttl100.begin();Há um conjunto de métodos para gerenciar a configuração e obter informações do dispositivo.
ResponseStructContainer getConfiguration ();
ResponseStatus setConfiguration (Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);
ResponseStructContainer getModuleInformation ();
void printParameters ( struct Configuration configuration);Para simplificar o gerenciamento da resposta, crio um conjunto de contêineres, para mim muito útil para gerenciar erros e retornar dados genéricos.
Este é um contêiner de status e tem 2 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()); // Description of code
Serial.println(c.code); // 1 if SuccessO código é
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 contêiner é criado para gerenciar a resposta da string e ter 2 pontos de entrada.
data com a string retornados da mensagem e status Uma instância de RepsonseStatus .
ResponseContainer rs = e22ttl.receiveMessage();
String message = rs.data;
Serial.println(rs.status.getResponseDescription());
Serial.println(message);Este é o contêiner mais "complexo", eu uso isso para gerenciar a estrutura, ele possui o mesmo ponto de entrada do responseContainer, mas os dados são um ponteiro vazio para gerenciar a estrutura complexa.
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();O primeiro método é o GetConfiguration, você pode usá -lo para recuperar todos os dados armazenados no dispositivo.
ResponseStructContainer getConfiguration ();Aqui um exemplo 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();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 ; // 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 timingVocê tem a função equivalente a obter toda a descrição:
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());Da mesma forma, o setConfiguration deseja um Strucutre 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 (Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE); configuration é o Strucutre Previsiouly Show, saveType Licition para você escolher se a alteração se tornar permanentemente apenas para a sessão atual.
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()O parâmetro todos gerenciados como constantes:
| Addh | Byte de endereço alto do módulo (o padrão 00H) | 00H-FFH |
| Addl | Byte de endereço baixo do módulo (o padrão 00H) | 00H-FFH |
| Acelerou | Informações sobre a taxa de paridade da taxa de dados e taxa de dados aéreos | |
| Chan | Canal de comunicação （410m + chan*1m）, padrão 17h (433MHz), válido apenas para o dispositivo 433MHz Chek abaixo para verificar a frequência correta do seu dispositivo | 00H-1FH |
| OPÇÃO | Tipo de transmissão, tamanho do pacote, permita uma mensagem especial | |
| Transmission_mode | Muito parâmetro que especifica a modalidade de transmissão |
OPÇÃO
Tipo de transmissão, configurações de pull-up, tempo de despertar, FEC, energia de transmissão
Bit de paridade UART: o modo UART pode ser diferente entre as partes de comunicação
| 4 | 3 | Bit de paridade uart | Valor constante |
| 0 | 0 | 8n1 (padrão) | 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 |
Taxa de transmissão UART: a taxa de transmissão UART pode ser diferente entre as partes da comunicação, 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.
| 7 | 6 | 5 | TTL UART BAUD Taxa （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 (padrão) | 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 |
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 do ar deve manter o mesmo para ambas as partes da comunicação.
| 2 | 1 | 0 | Taxa de dados aéreos （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 (padrão) | 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 |
#### Configuração do sub -pacote
Este é o comprimento máximo do pacote.
Quando os dados são menores que o comprimento do sub -pacote, a saída serial da extremidade receptora é uma saída contínua ininterrupta. Quando os dados são maiores que o comprimento do sub -pacote, a porta serial final de recepção produzirá o sub -pacote.
| 7 | 6 | Tamanho do pacote | Valor constante |
| 0 | 0 | 240 bytes (padrão) | Sps_240_00 |
| 0 | 1 | 128 Bytes | Sps_128_01 |
| 1 | 0 | 64 Bytes | Sps_064_10 |
| 1 | 1 | 32Bytes | Sps_032_11 |
#### rssi ruído ambiente habilitado
Este comando pode ativar/desativar o tipo de gerenciamento de RSSI, é importante gerenciar a configuração remota, prestar atenção não é o parâmetro RSSI na mensagem.
Quando ativado, o comando C0 C1 C2 C3 pode ser enviado 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.
| 5 | RSSI Ruído ambiente habilitado | Valor constante |
| 0 | Habilitar | Rssi_ambient_noise_enabled |
| 1 | Desativar (padrão) | Rssi_ambient_noise_disabled |
Power de transmissão ####
Você pode alterar esse conjunto de constantes, aplique uma definição como assim:
# define E22_22 // default value without set
# define E22_30Você pode configurar a frequência do canal OLSO com isso Definir:
// One of
# define FREQUENCY_433
# define FREQUENCY_170
# define FREQUENCY_470
# define FREQUENCY_868
# define FREQUENCY_915#### Ativar rssi
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
Tipo de transmissão ####
Modo de transmissão: no modo de transmissão fixo, os três primeiros bytes do quadro de dados de cada usuário podem ser usados como endereço e canal alto/baixo. O módulo altera seu endereço e canal ao transmitir. E ele reverterá para a configuração original após concluir o processo.
#### Ativar função repetidora
#### monitore os dados antes da transmissão
Quando ativado, os dados sem fio serão monitorados antes de serem transmitidos, o que pode evitar interferências até certo ponto, mas pode causar atraso nos dados.
#### wor
Transmissor WOR: O módulo recebe e transmissões de funções são ativadas e um código de despertar é adicionado ao transmitir dados. Receber está ligado.
Receptor WOR: O módulo não consegue transmitir dados e funciona no modo de monitoramento Wor. O período de monitoramento é o seguinte (ciclo Wor), que pode economizar muita energia.
#### Wor Cycle
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.
Primeiro, devemos introduzir um método simples, mas útil, para verificar se algo está no buffer de recebimento
int available ();É simplesmente retornar quantos bytes você tem no fluxo atual.
O modo de transmissão normal/transparente é usado para enviar mensagens para todo o dispositivo com o mesmo endereço e canal.
Lora E22 Cenários de transmissão, linhas são canais
Há muito método para enviar/receber mensagem, explicaremos em detalhes:
ResponseStatus sendMessage ( const String message);ResponseContainer receiveMessage ();O primeiro método é o sendMessage e é usado para enviar uma string para um dispositivo no modo normal .
ResponseStatus rs = e22ttl.sendMessage( " Prova " );
Serial.println(rs.getResponseDescription());O outro dispositivo simplesmente faz no loop
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);
}Se você deseja enviar uma estrutura complexa, você pode usar este método
ResponseStatus sendMessage ( const void *message, const uint8_t size);
ResponseStructContainer receiveMessage ( const uint8_t size);É usado para enviar Strucutre, por exemplo:
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());e o outro lado você pode receber a mensagem para
ResponseStructContainer rsc = e22ttl.receiveMessage( sizeof (Messaggione));
struct Messaggione messaggione = *(Messaggione*) rsc.data;
Serial.println(messaggione.message);
Serial.println(messaggione.mitico);Se você deseja ler a primeira parte da mensagem para gerenciar mais tipos de strucutre, você pode usar esse método.
ResponseContainer receiveInitialMessage ( const uint8_t size);Eu o crio para receber uma string com tipo ou outro para identificar a estrutura para carregar.
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;Da mesma maneira, crio um conjunto de método para usar com 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.
Então, para a mensagem de string que você tem
ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const String message);
ResponseStatus sendBroadcastFixedMessage (byte CHAN, const String message);e para a estrutura que você tem
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 );Aqui um exemplo simples
ResponseStatus rs = e22ttl.sendFixedMessage( 0 , 0 , 0x17 , &messaggione, sizeof (Messaggione));
// ResponseStatus rs = e22ttl.sendFixedMessage(0, 0, 0x17, "Ciao");A transmissão fixa tem mais cenários
Lora E22 Cenários de transmissão, linhas são canais
Se você enviar para um dispositivo específico (segundo cenário fixo), você deverá adicionar Addl, Addh e Chan para identificá -lo diretamente.
ResponseStatus rs = e22ttl.sendFixedMessage( 2 , 2 , 0x17 , " Message to a device " );Se você deseja enviar uma mensagem para todo o dispositivo em um canal especificado, você pode usar esse método.
ResponseStatus rs = e22ttl.sendBroadcastFixedMessage( 0x17 , " Message to a devices of a channel " ); Se você deseja receber toda a mensagem de transmissão na rede, você deve definir seu ADDH e ADDL com 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();Configuração sem fio
Este dispositivo suporta configuração sem fio com o comando sepeial, mas parece não funcionar, peço ao Ebyte, mas nenhuma resposta recebida.
Implementei um comando que envia o pacote da maneira correta (testada com analizador lógico), mas parece não funcionar.
A propósito, primeiro seu Muset ativa o ambiente de ruído RSSI, do que você pode usar o comando assim:
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;Agora você tem todas as informações para fazer seu trabalho, mas acho importante mostrar alguns exemplos realistas para destacar melhor toda a possibilidade.
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Configurações e uso básico
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Biblioteca
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Configuração
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: transmissão fixa e RSSI
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: economia de energia e envio de dados estruturados
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Modo repetidor e configurações remotas
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Microcontrolador Wor e Arduino Shield
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Microcontrolador Wor e Wemos D1 Shield
Dispositivo Ebyte Lora E22 para Arduino, ESP32 ou ESP8266: Microcontrolador Wor e Esp32 Dev V1 Shield
