Primeiros Passos com o Shield LoRaWAN em P2P

Introdução

Alguns dispositivos LoRaWAN, como o Shield LoRaWAN e o módulo LoRaWAN Bee da RoboCore, permitem a comunicação ponto a ponto (também conhecida como "P2P" - Point to Point) entre dois ou mais dispositivos do mesmo modelo.

Neste tutorial veremos como utilizar a comunicação P2P do Shield LoRaWAN, em um exemplo simples para acender um LED L na placa receptora caso um botão da placa transmissora seja pressionado.

Lista de Materiais

Lista completa de produtos

comprar

Shield para Arduino - LoRaWAN Helix Antenna

R$ 208,90 no PIX

BlackBoard UNO R3

R$ 94,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Atenção: na lista acima foi listado o Shield LoRaWAN Helix Antenna, porém este tutorial também é possível com o Shield LoRaWAN Chip Antenna.

Biblioteca

Caso já tenha seguido o tutorial Primeiros Passos com o Shield LoRaWAN em OTAA, não será necessário seguir os passos desta seção, já que a biblioteca já foi instalada no outro tutorial.

A biblioteca do Shield LoRaWAN está disponível para ser instalada diretamente pelo "Gerenciador de Bibliotecas" da Arduino IDE. Para acessá-lo, siga o caminho da imagem abaixo, ou então pressione "Ctrl+Shift+I".

caminho-gerenciador-bibliotecas — Caminho para o "Gerenciador de Bibliotecas"

Com o gerenciador aberto, digite "robocore smw sx1262", conforme mostrado na imagem abaixo.

biblioteca-encontrada — Biblioteca Encontrada

Com a biblioteca listada como na imagem acima, pressione o botão "Instalar" e aguarde alguns instantes. Assim que a instalação estiver finalizada, será exibido "Instalada" ao lado do nome da biblioteca, como na imagem a seguir.

Código

Com a biblioteca instalada, grave o código a seguir em ambas as placas base. Em uma delas, use-a como transmissor, mantendo a linha #define TRANSMISSOR descomentada. Na outra, comente a linha mencionada, para que a placa opere como receptor.

/*******************************************************************************
* Shield LoRaWAN - Envio de Mensagens LoRa por P2P (v1.0)
* 
* Codigo para acender e apagar o LED L da placa receptora, toda vez que o botao
* da placa transmissora for pressionado. O codigo e o mesmo para ambas as placas, 
* apenas comente a definicao comentada abaixo, para que o Shield opere como 
* receptor ao inves de transmissor
* 
* Copyright 2022 RoboCore.
* Escrito por Giovanni de Castro (02/06/2022).
* Creditos: @francois - RoboCore
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Configuracao do modo de operacao do Shield
#define TRANSMISSOR //Comente esta linha para o conjunto que ira operar como "RECEPTOR"

// --------------------------------------------------

//Adicao das bibliotecas
#include <RoboCore_SMW_SX1262M0.h>
#include <SoftwareSerial.h>

// --------------------------------------------------

//Criacao do objeto para biblioteca "SoftwareSerial"
SoftwareSerial LoRaSerial(10, 11);
//Criacao do objeto para a biblioteca "SMW_SX1262M0" utilizando o objeto da biblioteca "SoftwareSerial"
SMW_SX1262M0 LoRa(LoRaSerial);

//Declaracao da variavel que armazena as respostas do Shield
CommandResponse response;

//Configuracao da frequencia que as mensagens serao enviadas e ouvidas
const uint32_t FREQUENCIA = 915200; // [kHz]
//Altere o valor acima entre 915200 e 927800, se quiser

//Verifica se o codigo esta configurado para "TRANSMISSOR"
#ifdef TRANSMISSOR //Se for verdadeira
//Declaracao da variavel que armazena o pino conectado ao botao do Shield
const int PINO_BOTAO = A0;
//Declaracao da variavel que armazena o pino conectado ao LED L do Shield
const int PINO_LED = 13;
//Declaracao da variavel para acender e apagar o LED do "RECEPTOR"
bool acende_LED = false;
#else //Se for falso, ou seja, se for "RECEPTOR"
//Declaracao das variaveis que armazenarao a qualidade do sinal recebido
float rssi, snr;
//Declaracao do objeto "data" que coleta a mensagem lida
Buffer data;
//Declaracao da variavel que armazena o tempo maximo que o Shield aguardara por um mensagem
const uint32_t TEMPO_MAXIMO_ESCUTA = 1000; // [ms] (1 s)
//Declaracao da variavel que armazenara a mensagem lida
String mensagem = "";
//Declaracao da variavel que armazena o pino conectado ao LED L do Shield
const int PINO_LED = 13;
#endif //Fim da verificacao de modo de operacao do Shield

// --------------------------------------------------
// --------------------------------------------------

//Configuracao do codigo
void setup() {
  
  //Inicializacao do monitor serial para acompanhar a execucao do codigo
  Serial.begin(9600);
  Serial.println(F("--- Primeiros Passos com o Shield LoRaWAN ---"));
  Serial.println(F("--- Envio de Mensagens por P2P ---"));

  //Inicializacao da comunicacao com o Shield
  LoRaSerial.begin(9600);

  //Reinicializacao do Shield
  LoRa.reset();

//Verifica se o codigo esta configurado para "TRANSMISSOR"
#ifdef TRANSMISSOR //Se for verdadeira
  //Configuracao dos pinos usados da placa base
  pinMode(PINO_BOTAO, INPUT_PULLUP); //Botao do Shield
  pinMode(PINO_LED, OUTPUT); //LED L do Shield e da placa base
  digitalWrite(PINO_LED, LOW); //LED L iniciado apagado
#else //Se for falso, ou seja, se for "RECEPTOR"
  //Configura o Shield para recepcao continua de mensagens
  LoRa.P2P_start(FREQUENCIA, true);
  //Configuracao dos pinos usados da placa base
  pinMode(PINO_LED, OUTPUT); //LED L do Shield e da placa base
  digitalWrite(PINO_LED, LOW); //LED L iniciado apagado
#endif //Fim da verificacao de modo de operacao do Shield

}

// --------------------------------------------------
// --------------------------------------------------

//Repeticao do Codigo
void loop() {
  
//Verifica se o codigo esta configurado para "TRANSMISSOR"
#ifdef TRANSMISSOR //Se e verdadeira

  //Verifica se o botao do Shield foi pressionado
  if (digitalRead(PINO_BOTAO) == LOW) {
    delay(30); //Debounce
    if (digitalRead(PINO_BOTAO) == LOW) {
      //Pisca o LED L
      digitalWrite(PINO_LED, HIGH);
      delay(100);
      digitalWrite(PINO_LED, LOW);
      //Inverte o estado da variavel "acende_LED"
      acende_LED = !acende_LED;
      //Verifica se "acende_LED" e verdadeira
      if(acende_LED){ //Se for verdadeira
        //Configura o envio unico da mensagem "HIGH" para acender o LED do receptor
        response = LoRa.P2P_start(FREQUENCIA, false, "HIGH");
        Serial.println(F("Acendendo o LED"));
      } else { //Se for falsa
        //Configura o envio unico da mensagem "LOW" para apagar o LED do receptor
        response = LoRa.P2P_start(FREQUENCIA, false, "LOW");
        Serial.println(F("Apagando o LED"));
      }
      //Envia a mensagem configurada
      if (response == CommandResponse::OK) {
        Serial.println(F("Mensagem Enviada!"));
      } else {
        Serial.println(F("Erro ao enviar a mensagem"));
      }
      while(digitalRead(PINO_BOTAO) == LOW); //Nao executa nada se o botao for mantido pressionado
    }
  }

#else //Se for falso, ou seja, se for "RECEPTOR"

  //Aguarda o recebimento de uma mensagem
  response = LoRa.P2P_listen(TEMPO_MAXIMO_ESCUTA, data, rssi, snr);

  //Se uma mensagem for recebida
  if (response == CommandResponse::DATA) {
    Serial.print("Mensagem recebida: \"");
    while (data.available()) {
      //Adiciona os caracteres lidos a variavel "mensagem"
      mensagem += (char)data.read();
    }
    //Exibe a mensagem recebida e a qualidade do sinal
    Serial.print(mensagem);
    Serial.print("\" (");
    Serial.print(rssi);
    Serial.print(',');
    Serial.print(snr);
    Serial.println(')');
    
  }

  //Verifica se a "mensagem" recebida e "HIGH"
  if(mensagem == "HIGH"){
    //Se for, acende o LED
    digitalWrite(PINO_LED, HIGH);
  } 
  //Se nao for, verifica se a "mensagem" recebida e "LOW"
  else if (mensagem == "LOW"){
    //Se for, apaga o LED
    digitalWrite(PINO_LED, LOW);
  }
  //Limpa a variavel "mensagem" para uma nova leitura
  mensagem="";
  
#endif //Fim da verificacao de modo de operacao do Shield

}

// --------------------------------------------------
// --------------------------------------------------

Entendendo o Código

O código se inicia com a definição de "TRANSMISSOR" pelo comando #define TRANSMISSOR. Se essa linha não estiver comentada, ou seja, se "TRANSMISSOR" estiver definido no código, o Shield operará como transmissor de mensagens. Caso contrário, se essa linha for comentada, não haverá a definição de "TRANSMISSOR" e o Shield operará como receptor.

Em seguida são adicionadas as bibliotecas "SoftwareSerial" e "RoboCore_SMW_SX1262M0" ao código, com a criação do objeto LoRaSerial a partir da biblioteca "SoftwareSerial" e o objeto LoRa atrelado ao objeto LoRaSerial a partir da biblioteca "RoboCore_SMW_SX1262M0". Feito isso, é criado o objeto response como instância de CommandResponse da biblioteca do módulo, e a frequência em que as mensagens serão enviadas e lidas é configurada na variável FREQUENCIA.

//Configuracao do modo de operacao do Shield
#define TRANSMISSOR //Comente esta linha para o conjunto que ira operar como "RECEPTOR"

// --------------------------------------------------

//Adicao das bibliotecas
#include <RoboCore_SMW_SX1262M0.h>
#include <SoftwareSerial.h>

// --------------------------------------------------

//Criacao do objeto para biblioteca "SoftwareSerial"
SoftwareSerial LoRaSerial(10, 11);
//Criacao do objeto para a biblioteca "SMW_SX1262M0" utilizando o objeto da biblioteca "SoftwareSerial"
SMW_SX1262M0 LoRa(LoRaSerial);

//Declaracao da variavel que armazena as respostas do Shield
CommandResponse response;

//Configuracao da frequencia que as mensagens serao enviadas e ouvidas
const uint32_t FREQUENCIA = 915200; // [kHz]
//Altere o valor acima entre 915200 e 927800, se quiser

Para finalizar as declarações globais do código, verificamos através do comando #ifdef TRANSMISSOR se o "TRANSMISSOR" está definido no código. Se estiver, são declaradas as variáveis que armazenam o pino conectado ao botão do Shield e uma variável auxiliar para definir se a mensagem enviada irá acender ou apagar o LED da placa receptora. Caso "TRANSMISSOR" não esteja definido (diretiva #else), são declaradas as variáveis rssi e snr para armazenar os parâmetros de qualidade do sinal da mensagem recebida; o objeto data é criado como instância de Buffer da biblioteca do módulo; a constante TEMPO_MAXIMA_ESCUTA é declarada recebendo o valor de 1000 milissegundos; e a variável mensagem é declarada para armazenar a mensagem recebida da comunicação. Por fim, a verificação de definição é encerrada com o comando #endif.

//Verifica se o codigo esta configurado para "TRANSMISSOR"
#ifdef TRANSMISSOR //Se for verdadeira
//Declaracao da variavel que armazena o pino conectado ao botao do Shield
const int PINO_BOTAO = A0;
//Declaracao da variavel que armazena o pino conectado ao LED L do Shield
const int PINO_LED = 13;
//Declaracao da variavel para acender e apagar o LED do "RECEPTOR"
bool acende_LED = false;
#else //Se for falso, ou seja, se for "RECEPTOR"
//Declaracao das variaveis que armazenarao a qualidade do sinal recebido
float rssi, snr;
//Declaracao do objeto "data" que coleta a mensagem lida
Buffer data;
//Declaracao da variavel que armazena o tempo maximo que o Shield aguardara por um mensagem
const uint32_t TEMPO_MAXIMO_ESCUTA = 1000; // [ms] (1 s)
//Declaracao da variavel que armazenara a mensagem lida
String mensagem = "";
#endif //Fim da verificacao de modo de operacao do Shield

Já nas configurações do código, iniciamos o monitor serial e a comunicação com o Shield, ambos com a velocidade de 9600 bps, e reiniciamos o módulo pelo comando LoRa.reset(). Feito isso, se "TRANSMISSOR" estiver definido, o pino conectado ao botão do Shield é configurado como entrada com pull-up interno e o pino conectado ao pino LED L é configurado como saída em nível lógico baixo inicial. Caso o código esteja configurado para receptor, o Shield é configurado para recepção contínua de mensagens na frequência configurada na variável FREQUENCIA pelo comando LoRa.P2P_start(FREQUENCIA, true), e o LED L também é configurado como uma saída com o nível lógico baixo inicial.

//Configuracao do codigo
void setup() {
  
  //Inicializacao do monitor serial para acompanhar a execucao do codigo
  Serial.begin(9600);
  Serial.println(F("--- Primeiros Passos com o Shield LoRaWAN ---"));
  Serial.println(F("--- Envio de Mensagens por P2P ---"));

  //Inicializacao da comunicacao com o Shield
  LoRaSerial.begin(9600);

  //Reinicializacao do Shield
  LoRa.reset();

//Verifica se o codigo esta configurado para "TRANSMISSOR"
#ifdef TRANSMISSOR //Se for verdadeira
  //Configuracao dos pinos usados da placa base
  pinMode(PINO_BOTAO, INPUT_PULLUP); //Botao do Shield
  pinMode(PINO_LED, OUTPUT); //LED L do Shield e da placa base
  digitalWrite(PINO_LED, LOW); //LED L iniciado apagado
#else //Se for falso, ou seja, se for "RECEPTOR"
  //Configura o Shield para recepcao continua de mensagens
  LoRa.P2P_start(FREQUENCIA, true);
  //Configuracao dos pinos usados da placa base
  pinMode(PINO_LED, OUTPUT); //LED L do Shield e da placa base
  digitalWrite(PINO_LED, LOW); //LED L iniciado apagado
#endif //Fim da verificacao de modo de operacao do Shield

}

Já na repetição do código, novamente é verificado se "TRANSMISSOR" foi definido no código e, caso seja, é verificado se o botão do Shield foi pressionado pela condição if (digitalRead(PINO_BOTAO) == LOW) com um debounce. Se o botão for pressionado, a variável auxiliar para acender e apagar o LED da placa receptora acende_LED tem sua lógica invertida (se era "false" passa para "true", e vice-versa). Se a variável acende_LED for verdadeira, a mensagem "HIGH" é enviada uma única vez pelo Shield na frequência configurada anteriormente pelo comando response = LoRa.P2P_start(FREQUENCIA, false, "HIGH"). Caso a variável acende_LED seja falsa, a mensagem "LOW" é enviada para apagar o LED da placa receptora pelo comando response = LoRa.P2P_start(FREQUENCIA, false, "LOW"). Em seguida é verificado se a mensagem foi corretamente enviada, e então o resultado é avisado pelo monitor serial. A condição "vazia" while(digitalRead(PINO_BOTAO) == LOW) garante que nada será executado enquanto o botão for mantido pressionado.

//Verifica se o codigo esta configurado para "TRANSMISSOR"
#ifdef TRANSMISSOR //Se for verdadeira

  //Verifica se o botao do Shield foi pressionado
  if (digitalRead(PINO_BOTAO) == LOW) {
    delay(30); //Debounce
    if (digitalRead(PINO_BOTAO) == LOW) {
      //Pisca o LED L
      digitalWrite(PINO_LED, HIGH);
      delay(100);
      digitalWrite(PINO_LED, LOW);
      //Inverte o estado da variavel "acende_LED"
      acende_LED = !acende_LED;
      //Verifica se "acende_LED" e verdadeira
      if(acende_LED){ //Se for verdadeira
        //Configura o envio unico da mensagem "HIGH" para acender o LED do receptor
        response = LoRa.P2P_start(FREQUENCIA, false, "HIGH");
        Serial.println(F("Acendendo o LED"));
      } else { //Se for falsa
        //Configura o envio unico da mensagem "LOW" para apagar o LED do receptor
        response = LoRa.P2P_start(FREQUENCIA, false, "LOW");
        Serial.println(F("Apagando o LED"));
      }
      //Envia a mensagem configurada
      if (response == CommandResponse::OK) {
        Serial.println(F("Mensagem Enviada!"));
      } else {
        Serial.println(F("Erro ao enviar a mensagem"));
      }
      while(digitalRead(PINO_BOTAO) == LOW); //Nao executa nada se o botao for mantido pressionado
    }
  }

Caso o código esteja configurado como receptor, o Shield aguarda durante o tempo configurado na variável TEMPO_MAXIO_ESCUTA a recepção de uma mensagem pelo comando response = LoRa.P2P_listen(TEMPO_MAXIMO_ESCUTA, data, rssi, snr). Caso uma mensagem seja recebida (condição if (response == CommandResponse::DATA)), os caracteres da mensagem recebida são salvos em sequência na variável mensagem graças ao comando mensagem += (char)data.read(). Então, a mensagem é impressa no monitor serial, juntamente com os parâmetros de qualidade de sinal da mensagem recebida. Em seguida, é verificado se a mensagem recebida é igual a "HIGH" ou "LOW". Se for "HIGH", o LED L é aceso, e se for "LOW", o LED L é apagado. Caso seja outra mensagem, nada será executado. Para finalizar, a variável mensagem é "limpa" para o recebimento de uma nova mensagem.

#else //Se for falso, ou seja, se for "RECEPTOR"

  //Aguarda o recebimento de uma mensagem
  response = LoRa.P2P_listen(TEMPO_MAXIMO_ESCUTA, data, rssi, snr);

  //Se uma mensagem for recebida
  if (response == CommandResponse::DATA) {
    Serial.print("Mensagem recebida: \"");
    while (data.available()) {
      //Adiciona os caracteres lidos a variavel "mensagem"
      mensagem += (char)data.read();
    }
    //Exibe a mensagem recebida e a qualidade do sinal
    Serial.print(mensagem);
    Serial.print("\" (");
    Serial.print(rssi);
    Serial.print(',');
    Serial.print(snr);
    Serial.println(')');
    
  }

  //Verifica se a "mensagem" recebida e "HIGH"
  if(mensagem == "HIGH"){
    //Se for, acende o LED
    digitalWrite(PINO_LED, HIGH);
  } 
  //Se nao for, verifica se a "mensagem" recebida e "LOW"
  else if (mensagem == "LOW"){
    //Se for, apaga o LED
    digitalWrite(PINO_LED, LOW);
  }
  //Limpa a variavel "mensagem" para uma nova leitura
  mensagem="";
  
#endif //Fim da verificacao de modo de operacao do Shield

O Que Deve Acontecer

Após carregar o código para as placas transmissora e receptora, acompanhe a execução dos códigos delas pelo monitor serial e pressione o botão do Shield transmissor. Você verá o envio da mensagem para acender ou apagar o LED, como na imagem abaixo.

resultado-final-transmissor — Resultado Final no Transmissor

Já na placa receptora, será possível observar as mensagens recebidas quase que instantaneamente após pressionar o botão, como na próxima imagem.

resultado-final-receptor — Resultado Final no Receptor

Também é possível ver a qualidade do sinal recebido (RSSI e SNR), sendo que quanto maior ambos os valores, melhor a qualidade.

Juntamente com o recebimento das mensagens, será possível ver o LED do Shield e da placa base acendendo e apagando conforme a mensagem enviada.

Resultado Final

Indo Além

Agora que sabemos como realizar uma comunicação ponto a ponto por LoRa, as possibilidades são inúmeras, já que diversas aplicações de comunicação sem fio entre dois dispositivos podem ser adaptadas para esse protocolo. Uma das possibilidades é o controle remoto de robôs, onde a placa transmissora pode ser conectada a botões para o envio de sinais de controle e a receptora pode estar conectada a um driver de motores DC, por exemplo.

Conclusão

Neste tutorial vimos como a comunicação P2P do Shield LoRaWAN funciona com um exemplo básico de envio e recebimento de mensagens.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

allanjuniorj
date

Enviado 2024-03-19 15:10:02

Complementando. São dois IoTDevKit - Lorawan.

luan.ferreira
date

Enviado 2024-03-19 15:27:52
allanjuniorj

Olá! Neste caso, você possui dois “IoT DevKit - LoRaWAN” ( https://www.robocore.net/lorawan/iot-devkit-lorawan ), certo? Se sim, o código presente neste tutorial não é diretamente compatível como o DevKit, devido a algumas diferenças entre as placas (a do tutorial acima, e a do DevKit).

luan.ferreira
date

Enviado 2024-03-19 15:28:40
allanjuniorj

Para realizar a comunicação P2P como o DevKit, você pode usar o “Guia de Comandos AT” ( https://d229kd5ey79jzj.cloudfront.net/1239/SMART_LoRa_AT.Command_v1.1_en_v0.5.pdf ) como referência, pois esse Set de comandos é voltado para o transceptor SMW-SX1276M0, que está presente no DevKit, inclusive em um dos capítulos é dado mais informações sobre como realizar essa comunicação. Vale dizer que o transceptor usado no Shield acima, é o transceptor SMW-SX1262M0.

allanjuniorj
date

Enviado 2024-03-19 15:40:19
allanjuniorj

Obrigado pelo retorno.

Está correto. São dois "IoT DevKit".

Vou conferir a referência.

Por enquanto, obrigado.

luan.ferreira
date

Enviado 2024-03-19 15:47:20
allanjuniorj

Imagina!

allanjuniorj
date

Enviado 2024-03-19 15:08:21

Olá. Estou com dois Módulos LoRaWAN Bee V2 Chip Antenna (adquiridos na loja da Robocore), na qual estou tentando coloca-los para funcionarem em P2P, mas sem sucesso. Tentei vários códigos e bibliotecas, mas a IDE do Arduino me retorna diversos erros (com o código acima, o erro corresponde a fatal-error:-avr/interrupt.h). Vocês teriam alguma informação ou algum sketch modificado com essa finalidade?

Aguardo retorno.

Grato.

luan.ferreira
date

Enviado 2024-03-19 15:30:35
allanjuniorj

Este comentário foi levado em consideração para a resposta do comentário acima.

evertonhorning
date

Enviado 2024-02-08 15:23:11

Boa tarde! Comprei no final do ano passado um shield desses e estou tentando o Join na rede. Estou utilizando o serviço da TCTEC TELECOM e estou dentro da área de alcance do sinal.
Passei para eles o EUI, APPEUI e APPKEY... Naquele exemplo SimpleSend-OTAA ele chega na parte Joining the network e não conecta.
Tem algum lugar onde posso buscar mais informações?
Obrigado

carlos.oliveira
date

Enviado 2024-02-08 16:52:17
evertonhorning

Olá! Infelizmente nunca testamos essa rede com o nosso Shield LoRaWaN, no entanto, talvez possa ser um problema de compatibilidade de canais, uma sugestão é você mudar o modo de autenticação por ABP (que, na realidade, não requer uma autenticação prévia), também verifique se a rede que você está usando está configurada com os mesmo canais (0 a 7) que o Shield LoRaWan.

manoelguimafilho
date

Enviado 2023-11-23 07:29:55

Qual é a distância máxima sem obstáculos com está antena? E seria possível instalar outra antena pra alcançar distâncias maiores ? Se sim vcs vendem essas antena ? É simples de soldar ela nesta placa ?

Francois

Enviado 2023-11-23 12:07:58
manoelguimafilho

Em testes com o Shield LoRaWAN Helix Antenna, foi possível enviar dados a 5 km de distância, em condições ideais e por P2P. Logo, é recomendado trabalhar com uma distância menor para ter uma comunicação mais confiável.
Infelizmente não é possível utilizar outra antena de uma forma prática. Para fazer isso, seria necessário remover a atual, que está soldada. Além disso, dependendo da nova configuração, a performance pode ser prejudicada porque a antena precisa ser casada. Ou seja, não é um procedimento recomendado.

jeffersonbrittosilva
date

Enviado 2023-05-24 11:56:06

Boa tarde!
Tem alguma função da biblioteca de vocês para mudar o SF ou é apenas por comando AT?

luan.ferreira
date

Enviado 2023-05-24 16:05:55
jeffersonbrittosilva

Olá! A biblioteca não possui uma função específica para esta configuração, e por isso tal configuração deve ser feita através dos comandos AT ( https://d229kd5ey79jzj.cloudfront.net/1443/SMART_LoRa_AT_Command_v1.0_en_v2.14.pdf ).

jeffersonbrittosilva
date

Enviado 2023-05-24 16:49:27
jeffersonbrittosilva

Você saberia me dizer qual comando que é?

luan.ferreira
date

Enviado 2023-05-25 12:21:57
jeffersonbrittosilva

Olá! Neste caso, você pode usar o comando <”AT+DR”>, que é explicado na seção 3.4.4 dos comandos AT ( https://d229kd5ey79jzj.cloudfront.net/1443/SMART_LoRa_AT_Command_v1.0_en_v2.14.pdf ).

kaleu_pr
date

Enviado 2023-01-02 16:38:25

Boa tarde!!!

Tenho uma duvida 

Conseguiria fazer com que essa shield em P2P hora ficasse em modo de receptor e a hora que fosse acionada ficasse em modo emissor 

pois quando comentamos na parte superior so escolhemos um modo

luan.ferreira
date

Enviado 2023-01-02 16:46:29
kaleu_pr

Sim, é possível fazer com que o shield passe de receptor para transceptor (e vice-versa). Entretanto, infelizmente não temos nenhum código (ou tutorial) para essa finalidade, porém é possível usar esse tutorial como base para a criação do seu código.

kaleu_pr
date

Enviado 2022-08-26 07:33:06

olá bom dia 

Se nesta função       response = LoRa.P2P_start(FREQUENCIA, false, "HIGH"  );  no lugar de HIGH quiser colocar uma variável com por exemplo um botão que apertei que esta em um variavel int botão como faço pq coloco ela mas não aceita quando coloco entre aspas funciona. 

teria algum modo de colocar variaveis no lugar do high?

luan.ferreira
date

Enviado 2022-08-26 15:59:29
kaleu_pr

Olá! Sim, é possível usar uma variável no lugar do valor "HIGH", porém a função pede uma variável do tipo <const char *> (string), pois o módulo envia a mensagem como texto. Como a variável "PINO_BOTAO" armazena um valor do tipo int, não é possível passar diretamente no lugar desejado. Sendo assim, você pode criar uma variável do tipo <char *> ou <char[]>, que muda de valor quando o botão é pressionado, e então usar essa variável no local desejado.

kaleu_pr

Enviado 2022-08-29 11:22:22
kaleu_pr

Sera que teria algum exemplo pq estou tentando do modo que falou e não esta funcionando?

luan.ferreira
date

Enviado 2022-08-29 14:40:23
kaleu_pr

Olá! Infelizmente não temos nenhum tutorial com essa finalidade. De toda forma, você pode usar o link a seguir com referência para o uso de variáveis do tipo <char[]> https://www.arduino.cc/reference/pt/language/variables/data-types/string/ . Aliás, após criar a variável, você pode exibir o valor dela no monitor serial, para verificar se ela está recebendo o valor que deveria, e então passá-la no local desejado.