- Materiais requisitados
- Conectando Raspberry Pi com LoRa
- Conectando Arduino com LoRa
- pyLoRa para Raspberry Pi
- Configurando o módulo Raspberry Pi para LoRa
- Programando Raspberry Pi para LoRa
- Código Arduino para LoRa se comunicar com Raspberry Pi
- Testando a comunicação LoRa entre Raspberry Pi e Arduino
LoRa está se tornando cada vez mais popular com o advento da IoT, carros conectados, M2M, indústria 4.0, etc. Devido à sua capacidade de se comunicar a longas distâncias com muito menos energia, é preferencialmente usado por designers para enviar / receber dados de um dispositivo alimentado por bateria. Já discutimos os fundamentos do LoRa e como usar o LoRa com o Arduino. Embora a tecnologia seja originalmente destinada a um nó LoRa se comunicar com um gateway LoRa, há muitos cenários em que um nó LoRa precisa se comunicar com outro nó LoRa para trocar informações de longa distância. Então, neste tutorial, aprenderemos como usar um módulo LoRa SX1278 com Raspberry pipara se comunicar com outro SX1278 conectado a um microcontrolador como o Arduino. Este método pode ser útil em muitos lugares, já que o Arduino poderia atuar como um servidor para buscar dados de sensores e enviá-los para Pi por uma longa distância através de LoRa e, em seguida, o Pi atuando como um cliente pode receber essas informações e enviá-las para o poderia, pois tem acesso à internet. Parece interessante, certo? Então vamos começar.
Materiais requisitados
- Módulo LoRa SX1278 433 MHz - 2 N °
- Antena LoRa 433 MHz - 2Nos
- Arduino UNO- ou outra versão
- Raspberry Pi 3
Presume-se que o seu Raspberry Pi já tenha um sistema operacional atualizado e seja capaz de se conectar à Internet. Caso contrário, siga o tutorial Introdução ao Raspberry Pi antes de continuar. Aqui, estamos usando Rasbian Jessie instalado Raspberry Pi 3.
Aviso: Sempre use seu módulo SX1278 LoRa com antenas de 433 MHz; caso contrário, o módulo pode ser danificado.
Conectando Raspberry Pi com LoRa
Antes de entrarmos nos pacotes de software, vamos preparar o hardware. O SX1278 é um módulo Lora de 16 pinos que se comunica usando SPI em 3.3V Logic. O Raspberry pi também opera em nível lógico de 3,3 V e também possui porta SPI embutida e regulador de 3,3 V. Assim, podemos conectar diretamente o módulo LoRa com o Raspberry Pi. A tabela de conexão é mostrada abaixo| Raspberry Pi | Lora - Módulo SX1278 |
| 3,3 V | 3,3 V |
| Terra | Terra |
| GPIO 10 | MOSI |
| GPIO 9 | MISSÔ |
| GPIO 11 | SCK |
| GPIO 8 | Nss / Ativar |
| GPIO 4 | DIO 0 |
| GPIO 17 | DIO 1 |
| GPIO 18 | DIO 2 |
| GPIO 27 | DIO 3 |
| GPIO 22 | RST |
Você também pode usar o diagrama de circuito abaixo como referência. Observe que o diagrama de circuito foi criado usando o módulo RFM9x que é muito semelhante ao módulo SX1278, portanto, a aparência pode ser diferente na imagem abaixo.
As conexões são bem diretas, o único problema que você pode enfrentar é que o SX1278 não é compatível com a placa de ensaio, portanto, você deve usar os fios de conexão diretamente para fazer as conexões ou usar duas placas de ensaio pequenas, como mostrado abaixo. Além disso, poucas pessoas sugerem alimentar o módulo LoRa com barramento de alimentação de 3,3 V separado, pois o Pi pode não ser capaz de fornecer corrente suficiente. Porém Lora sendo um módulo de baixa potência deve funcionar no barramento de 3,3V do Pi, testei o mesmo e achei que funcionava sem problemas. Mas, ainda tome-o com uma pitada de sal. Minha configuração de conexão do LoRa com Raspberry pi parece algo assim abaixo
Conectando Arduino com LoRa
A conexão para o módulo Arduino permanece a mesma que usamos em nosso tutorial anterior. A única diferença será que em vez de usar a biblioteca do Sandeep Mistry, usaremos a biblioteca Rspreal baseada no Radio head, que discutiremos mais tarde neste projeto. O circuito é dado abaixo
Novamente, você pode usar o pino de 3,3 V no Arduino Uno ou usar um regulador de 3,3 V separado. Neste projeto, usei o regulador de tensão on-board. A tabela de conexão de pinos é fornecida abaixo para ajudá-lo a fazer as conexões facilmente.
| Módulo LoRa SX1278 | Placa Arduino UNO |
| 3,3 V | 3,3 V |
| Gnd | Gnd |
| En / Nss | D10 |
| G0 / DIO0 | D2 |
| SCK | D13 |
| MISSÔ | D12 |
| MOSI | D11 |
| RST | D9 |
Como o módulo não cabe em uma placa de ensaio, usei os fios de conexão diretamente para fazer as conexões. Assim que a conexão for feita, a configuração do Arduino LoRa será semelhante a esta abaixo
pyLoRa para Raspberry Pi
Existem muitos pacotes Python que você pode usar com LoRa. Também comumente, o Raspberry Pi é usado como um LoRaWAN para obter dados de vários nós LoRa. Mas, neste projeto, nosso objetivo é fazer comunicação ponto a ponto entre dois módulos Raspberry Pi ou entre um Raspberry Pi e um Arduino. Então, decidi usar o pacote pyLoRa. Ele tem módulos rpsreal LoRa Arduino e rpsreal LoRa Raspberry pi que podem ser usados no ambiente Arduino e Raspberry Pi. Por enquanto, vamos nos concentrar no ambiente Raspberry Pi.
Configurando o módulo Raspberry Pi para LoRa
Como dito anteriormente, o módulo LoRa funciona com comunicação SPI, então temos que habilitar o SPI no Pi e então instalar o pacote pylora . Siga os passos abaixo para fazer o mesmo, após abrir a janela do terminal de Pi. Novamente, estou usando massa para conectar ao meu Pi, você pode usar seu método conveniente.
Etapa 1: Acesse a janela de configuração usando o seguinte comando. Para obter a janela abaixo
sudo raspi-config
Etapa 2: Navegue até as opções de interface e habilite o SPI conforme mostrado na imagem abaixo. Temos que habilitar a interface SPI porque, como discutimos, o LCD e o PI se comunicam por meio do protocolo SPI
Etapa 3: Salve as alterações e volte para a janela do terminal. Certifique-se de que o pip e o python estejam atualizados e instale o pacote RPi.GPIO usando o seguinte comando.
pip install RPi.GPIO
Esta classe de pacote nos ajudará a controlar o pino GPIO no Pi. Se instalado com sucesso, sua tela ficará assim
Etapa 4: proceda da mesma forma com a instalação do pacote spidev usando o seguinte comando. Spidev é uma ligação python para Linux que pode ser usada para realizar comunicação SPI no Raspberry Pi.
pip instalar spidev
Se a instalação for bem-sucedida, o terminal deve ser semelhante a este abaixo.
Etapa 5: em seguida, vamos instalar o pacote pyLoRa usando o seguinte comando pip. Este pacote instala os modelos de rádio associados ao LoRa.
pip install pyLoRa
Se a instalação for bem-sucedida, você verá a tela a seguir.
O pacote PyLoRa também suporta comunicação criptografada que pode ser usada com Arduino e Raspberry Pi perfeitamente. Isso melhorará a segurança dos dados em sua comunicação. Mas você tem que instalar um pacote separado após esta etapa, o que não estou fazendo, pois a criptografia não está no escopo deste tutorial. Você pode seguir os links do github acima para obter mais detalhes.
Depois desta etapa, você pode adicionar as informações do caminho do pacote a pi e tentar com o programa python fornecido no final. Mas eu não fui capaz de adicionar o caminho com sucesso e, portanto, tive que baixar manualmente a biblioteca e usar a mesma diretamente para meus programas. Então eu tive que prosseguir com as seguintes etapas
Etapa 6: Baixe e instale o pacote python-rpi.gpio e o pacote spidev usando o comando abaixo.
sudo apt-get install python-rpi.gpio python3-rpi.gpio sudo apt-get install python-spidev python3-spidev
A janela do terminal deve exibir algo assim após ambas as instalações.
Etapa 7: também instale o git e use-o para clonar o diretório python do nosso Raspberry Pi. Você pode fazer isso usando os seguintes comandos.
sudo apt-get install git sudo git clone
Assim que esta etapa for concluída, você deve encontrar o subdiretório SX127x na pasta inicial do Raspberry Pi. Isso terá todos os arquivos necessários associados à biblioteca.
Programando Raspberry Pi para LoRa
Em uma comunicação LoRa ponto a ponto, o módulo que está transmitindo as informações é chamado de servidor e o módulo que recebe as informações é chamado de cliente. Na maioria dos casos, o Arduino será usado em campo com um sensor para medir os dados e o Pi será usado para receber esses dados. Portanto, decidi usar o Raspberry Pi como cliente e o Arduino como servidor neste tutorial. O programa cliente Raspberry Pi completo pode ser encontrado na parte inferior desta página. Aqui, tentarei explicar as linhas importantes do programa.
Cuidado: Certifique-se de que o arquivo do programa esteja no mesmo diretório onde a pasta da biblioteca do SX127x está presente. Você pode copiar esta pasta e usá-la em qualquer lugar se desejar portar o projeto.
O programa é muito simples, temos que definir o módulo LoRa para trabalhar em 433Mhz e então ouvir os pacotes de entrada. Se recebermos alguma coisa, simplesmente imprimimos no console. Como sempre, começamos o programa importando as bibliotecas Python necessárias.
de tempo import sleep from SX127x.LoRa import * from SX127x.board_config import BOARD BOARD.setup ()
Neste caso, o pacote de tempo é usado para criar atrasos, o pacote Lora é usado para a comunicação LoRa e o board_config é usado para definir os parâmetros da placa e LoRa. Também configuramos a placa usando a função BOARD.setup () .
Em seguida, criamos a classe LoRa python com três definições. Como apenas recuamos para fazer o programa funcionar como um cliente raspberry, a classe tem apenas três funções, a saber, a classe init, a classe inicial e a classe on_rx_done . A classe init inicializa o módulo LoRa em 433 MHz com largura de banda de 125 kHz conforme definido no método set_pa_config . Em seguida, ele também coloca o módulo no modo de espera para economizar o consumo de energia.
# Os padrões de intervalo médio após init são 434,0 MHz, Bw = 125 kHz, Cr = 4/5, Sf = 128chips / símbolo, CRC em 13 dBm lora.set_pa_config (pa_select = 1) def __init __ (self, verbose = False): super (LoRaRcvCont, self).__ init __ (verbose) self.set_mode (MODE.SLEEP) self.set_dio_mapping (* 6)
A função de arranque é onde se configurar o módulo como receptor e obter como RSSI (Receber indicador de intensidade de sinal), o estado, a frequência de operação etc. Configuramos o módulo para funcionar no modo receptor contínuo (RXCONT) a partir do modo de suspensão e, em seguida, usamos um loop while para ler valores como RSSI e status do modem. Também liberamos os dados do buffer serial para o terminal.
def start (self): self.reset_ptr_rx () self.set_mode (MODE.RXCONT) enquanto True: sleep (.5) rssi_value = self.get_rssi_value () status = self.get_modem_status () sys.stdout.flush ()
Finalmente, a função on_rx_done é executada depois que o pacote de entrada é lido. Nesta função, os valores recebidos são movidos para uma variável chamada carga útil do buffer Rx após definir o sinalizador de recebimento alto. Em seguida, os valores recebidos são decodificados com utf-8 para imprimir dados legíveis pelo usuário no shell. Também colocamos o módulo de volta no modo de hibernação até que outro valor seja recebido.
def on_rx_done (self): print ("\ nReceived:") self.clear_irq_flags (RxDone = 1) payload = self.read_payload (nocheck = True) print (bytes (payload).decode ("utf-8", 'ignore')) self.set_mode (MODE.SLEEP) self.reset_ptr_rx () self.set_mode (MODE.RXCONT)
A parte restante do programa é apenas imprimir os valores recebidos no console e encerrar o programa usando uma interrupção do teclado. Colocamos novamente a placa no modo de hibernação mesmo após o término do programa para economizar energia.
tente: lora.start () exceto KeyboardInterrupt: sys.stdout.flush () print ("") sys.stderr.write ("KeyboardInterrupt \ n") finalmente: sys.stdout.flush () print ("") lora. set_mode (MODE.SLEEP) BOARD.teardown ()
Código Arduino para LoRa se comunicar com Raspberry Pi
Como mencionei antes, o código rpsreal suporta Arduino e Pi e, portanto, a comunicação entre Arduino e Pi é possível. Funciona com base na Biblioteca Radiohead da AirSpayce's. Portanto, você deve instalar a biblioteca de cabeçotes de rádio primeiro no seu IDE Arduino.
Para isso visite a página do Github e baixe a biblioteca na pasta ZIP. Em seguida, coloque-o na pasta da biblioteca do seu IDE Arduino. Agora, reinicie o IDE do Arduino e você encontrará arquivos de exemplo para a biblioteca de cabeçotes de rádio. Aqui iremos programar o Arduino para funcionar como um servidor LoRa para enviar pacotes de teste como 0 a 9. O código completo para fazer o mesmo pode ser encontrado na parte inferior desta página, como sempre. Aqui, vou explicar algumas linhas importantes do programa.
Começamos o programa importando a biblioteca SPI (instalada por padrão) para usar o protocolo SPI e, em seguida, a biblioteca RH_RF95 do Radio head para realizar a comunicação LoRa. Em seguida, definimos a qual pino do Arduino conectamos o pino Chip select (CS), Reset (RST) e Interrupt (INT) do LoRa com o Arduino. Por fim, também definimos que o módulo deve trabalhar na frequência 434 MHz e inicializar o módulo LoRa.
#incluir
Dentro da função de configuração , iremos reiniciar o módulo LoRa puxando o pino de reinicialização para baixo por 10 milissegundos para começar do zero. Em seguida, o inicializamos com o módulo que criamos anteriormente usando a biblioteca Radio head. Em seguida, definimos a frequência e a potência de transmissão para o servidor LoRa. Quanto maior a transmissão, maior a distância que seus pacotes percorrerão, mas consumirão mais energia.
void setup () { // Inicializar o Serial Monitor Serial.begin (9600); // Reinicializa o módulo LoRa pinMode (RFM95_RST, OUTPUT); digitalWrite (RFM95_RST, LOW); atraso (10); digitalWrite (RFM95_RST, HIGH); atraso (10); // Inicializar o Módulo LoRa while (! Rf95.init ()) { Serial.println ("LoRa radio init failed"); enquanto (1); } // Define a frequência padrão 434,0 MHz if (! Rf95.setFrequency (RF95_FREQ)) { Serial.println ("setFrequency falhou"); enquanto (1); } rf95.setTxPower (18); // Potência de transmissão do Módulo Lora }
Dentro da função de loop infinito, simplesmente temos que enviar o pacote de dados através do módulo LoRa. Esses dados podem ser qualquer coisa como o valor do sensor do comando do usuário. Mas para simplificar, enviaremos o valor char de 0 a 9 para cada intervalo de 1 segundo e, em seguida, inicializaremos o valor de volta para 0 depois de atingir 9. Observe que os valores podem ser enviados apenas em um formato de matriz char e o tipo de dados deve ser unit8_t que é 1 byte de cada vez. O código para fazer o mesmo é mostrado abaixo
void loop () { Serial.print ("Enviar:"); radiopacket char = char (valor)}; rf95.send ((uint8_t *) radiopacket, 1); atraso (1000); valor ++; if (valor> '9') valor = 48; }
Testando a comunicação LoRa entre Raspberry Pi e Arduino
Agora que temos nosso hardware e programa prontos, simplesmente temos que fazer o upload do código do Arduino para a placa UNO e o esboço do python deve ser lançado no pi. Minha configuração de teste com ambos os hardwares conectados, parece algo assim abaixo
Uma vez que o esboço do cliente python é iniciado no Pi (use apenas o python 3), se tudo estiver funcionando corretamente, você deverá ver os pacotes do Arduino recebidos no pi através da janela do shell. Você deve observar “Recebido: 0” a 9 como mostrado na imagem abaixo.
O código pi Raspberry completo com todas as bibliotecas necessárias pode ser baixado aqui.
Agora você pode mover o servidor Arduino e verificar o alcance do módulo; também é possível exibir o valor RSSI no shell, se necessário. O funcionamento completo do projeto pode ser encontrado no vídeo no link abaixo. Agora que sabemos como estabelecer comunicação LoRa de longa distância e baixa potência entre o Arduino e o Raspberry pi, podemos prosseguir com a adição do sensor no lado do Arduino e da plataforma em nuvem no lado do Pi para fazer um pacote IoT completo.
Espero que você tenha entendido o projeto e gostado de construí-lo. Se você tiver problemas para fazê-lo funcionar, use a seção de comentários abaixo ou os fóruns para outras questões técnicas.