Neste tutorial, vais aprender como ativar comunicação de longo alcance usando o módulo LoRa SX1276 e o ESP32. Por exemplo, se quiseres receber dados de sensores distantes onde não tens cobertura Wi-Fi, como um sensor de temperatura no canto do teu jardim, o LoRa pode ajudar.
LoRa é uma tecnologia sem fios feita para enviar pequenas quantidades de dados a longas distâncias usando muito pouca energia. Funciona bem em áreas abertas e pode alcançar vários quilómetros, muito mais longe do que WiFi ou Bluetooth. Isto torna-a ideal para dispositivos alimentados por bateria, como sensores em quintas, cidades ou áreas remotas onde o WiFi ou Bluetooth normais não chegam ou consomem muita energia.
Se já conheces o LoRa e só queres saber como enviar dados ambientais como temperatura e humidade, dá uma vista de olhos ao Send Environmental Data with LoRa tutorial.
Peças Necessárias
Abaixo encontras os componentes necessários para este tutorial. Usei uma placa ESP32 mais antiga, que já foi descontinuada, mas ainda podes encontrá-la a um preço muito baixo. Nota que também existe uma versão com porta USB-C. No entanto, qualquer outro ESP32 funciona perfeitamente. Só precisas de dois deles e dois módulos SX1276 – um para enviar e outro para receber.
Quanto aos módulos transceptores SX1276 LoRa, atenção à versão que compras! Dependendo do país, as frequências permitidas para estes módulos variam (link). É 868MHz para a Europa, 915MHz para a América do Norte e 433MHz para a Ásia.
A descrição do módulo indica a frequência ou tem um número como 868 ou 915 no nome. Listei um módulo com 868MHz, pois estou na Europa. Mas podes também obter este módulo para a banda de 915MHz.
2 x Módulo LoRa 868/915M SX1276
2 x ESP32 lite
Cabo USB de Dados
Conjunto de Fios Dupont
2x Breadboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
O que é LoRa?
Se estás a construir projetos Arduino ou ESP32 e precisas de enviar dados sem fios a longas distâncias, LoRa (abreviação de Long Range) pode ser exatamente o que precisas. Ao contrário do WiFi e Bluetooth, que são feitos para comunicação rápida e de curto alcance, o LoRa foi criado para transmissão de dados a baixo consumo e longo alcance — perfeito para sensores remotos e dispositivos que precisam de funcionar durante meses ou anos com uma pequena bateria.
O LoRa usa um tipo especial de modulação rádio chamado Chirp Spread Spectrum (CSS). Isto torna-o altamente resistente a interferências e permite que dispositivos comuniquem a vários quilómetros, mesmo em ambientes ruidosos ou com obstáculos como árvores e edifícios. O LoRa opera em bandas ISM frequency bands não licenciadas — tipicamente 868 MHz na Europa, 915 MHz na América do Norte e 433 MHz em alguns países asiáticos. Estas frequências variam por região, mas todas têm a vantagem de serem gratuitas e sem necessidade de licença.
A desvantagem do LoRa é que não é feito para alta velocidade de dados. Funciona melhor para pequenas cargas, como leituras de sensores ou atualizações de estado de dispositivos. As taxas de dados variam tipicamente de 0,3 kbps a 50 kbps, dependendo do spreading factor (SF), largura de banda e coding rate que escolheres. O alcance também depende destas configurações e do ambiente: podes esperar 2–5 km em áreas urbanas e 10–15 km em zonas rurais ou com linha de visão — por vezes até mais com antenas adequadas.
LoRa vs WiFi e Bluetooth
O WiFi oferece velocidades rápidas, mas consome muita energia e normalmente cobre menos de 100 metros. O Bluetooth tem um alcance ainda mais curto e é mais adequado para dispositivos pessoais e wearables. A tabela seguinte compara as principais características do LoRa com WiFi e Bluetooth:
| Característica | LoRa | WiFi | Bluetooth |
|---|---|---|---|
| Consumo de Energia | Muito baixo (μA em sleep, ~10–50 mA ativo) | Alto (~70–300 mA ativo) | Baixo (~10–30 mA ativo) |
| Alcance | 2–15 km (rural), 0.5–5 km (urbano) | ~50–100 metros (interior), ~200 metros (ar livre) | ~10–100 metros |
| Taxa de Dados Típica | 0.3–50 kbps | Até 100–600 Mbps (ESP32: ~150 Mbps) | ~1–3 Mbps (Classic), ~125–200 kbps (BLE) |
| Latência | Alta (100 ms a vários segundos) | Baixa (~1–10 ms) | Baixa (~3–50 ms BLE) |
Neste artigo, vamos explorar como usar LoRa com placas ESP32 e módulos como o SX1276, e mostrar como começar a enviar mensagens entre dispositivos a muitos quilómetros de distância — sem precisar de WiFi, torres de telemóvel ou muita energia.
Módulo LoRa SX1276
O SX1276 é um módulo transceptor LoRa popular fabricado pela Semtech, e é um dos chips mais usados para comunicação sem fios de longo alcance e baixo consumo em projetos DIY e IoT. Suporta modulação LoRa e modos tradicionais FSK/OOK, tornando-o flexível para uma ampla gama de aplicações.
O SX1276 está no coração de muitos módulos LoRa, incluindo o conhecido HopeRF RFM95W, que é muito semelhante ao módulo que estou a usar neste tutorial. A imagem seguinte mostra a frente do Módulo LoRa SX1276 com o chip SX1276, o cristal de quartzo e o regulador de tensão.
Este chip opera na faixa de 137 MHz a 1020 MHz, mas a maioria dos módulos que o usam está configurada para 433 MHz (Ásia), 868 MHz (Europa) ou 915 MHz (América do Norte), dependendo da tua região. No verso do módulo geralmente encontras uma pequena tabela onde a frequência de operação do módulo específico está marcada. A imagem abaixo mostra um módulo que opera na banda de 915 MHz e que pode ser usado na América do Norte:
Certifica-te de comprar e usar um módulo com a frequência de transmissão correta para o teu país. Caso contrário, podes ter problemas com a entidade que regula as transmissões rádio no teu país!
O módulo pode comunicar a distâncias de 2 a mais de 15 quilómetros, dependendo da qualidade da antena, terreno e configurações. O SX1276 suporta taxas de dados de 0,018 kbps a 37,5 kbps no modo LoRa e até 300 kbps no modo FSK, oferecendo controlo detalhado sobre parâmetros como largura de banda, fator de espalhamento e taxa de codificação, permitindo otimizar para alcance, consumo de energia ou fiabilidade.
Detalhes Técnicos do SX1276
A lista seguinte mostra as principais características do módulo LoRa SX1276:
- Tensão de operação: 1.8 – 3.7V
- Banda de Frequência: 868MHZ/915MH
- Potência de saída: 20dBm/100mW
- Sensibilidade de receção: -139dBm@146B
- Modulação: LORA/GFSK
- Interface de dados: SPI de 4 fios
- Tamanho do módulo: 16*16mm Espaçamento da interface 2.0mm
- Corrente de transmissão: 120mA@100mw/ 3.3V
- Corrente de receção: 10mA/3.3V
- Corrente em sleep: 0.2uA
Para mais detalhes, vê o datasheet ligado abaixo:
Pinout do Módulo LoRa SX1276
O Módulo LoRa SX1276 tem 16 pinos. Um para a antena (ANT), um para alimentação (VCC), vários pinos de terra (GND), os pinos para SPI (REST, NSS, SCK, MOSI, MISO) e seis pinos configuráveis Digital IO (DIO):
Nota que o SX1276 usa lógica de 3.3V e, por isso, não podes ligá-lo diretamente a um Arduino UNO, por exemplo, que opera com níveis lógicos de 5V. Se quiseres usar uma placa Arduino em vez de um ESP32, tens de usar um logic level shifter ou um Arduino that uses 3.3V logic.
Tornando o Módulo LoRa SX1276 compatível com breadboard
Os furos dos pinos do Módulo LoRa SX1276 estão espaçados a 2 mm, o que significa que, se soldares pinos, eles não encaixam no espaçamento de 2.54 mm de uma breadboard padrão. No entanto, como não precisamos de todos os pinos do módulo, podes dobrar os pinos de um conector padrão de 2.54 mm para funcionar.
A imagem abaixo mostra o GND, DIO3, DIO4, VCC e DIO0 ligados a um conector de pinos de 2.54 mm. Dobre os pinos no topo do conector para encaixar no espaçamento menor de 2 mm dos furos do módulo:
Nota que DIO1 e DIO2 não estão ligados. Também poderias saltar DIO3 e DIO4, pois não são necessários, mas é mais rápido soldar o conector completo do que pinos individuais.
No outro lado do módulo podemos fazer o mesmo. Ligamos RES, NSS, SCK, MOSI e MISO e deixamos os dois pinos GND e o DIO5 desligados:
Com este truque simples podes fazer o Módulo LoRa SX1276 encaixar numa breadboard. A imagem abaixo mostra a parte de trás do módulo com ambos os conectores de pinos e a antena soldada:
Só tens de ter cuidado ao ligar a placa, pois as etiquetas no silkscreen e os pinos estão ligeiramente deslocados.
Também nota que a tua antena pode ter aspeto diferente (mais longa, só um fio) dependendo do módulo e da frequência configurada.
Ligando o SX1276 ao ESP32
O SX1276 é controlado via interface SPI. Ao ligá-lo a um ESP32, deves fazer as seguintes conexões:
| SX1276 | ESP32 |
|---|---|
| MOSI | 23 |
| MSIO | 19 |
| SCK | 18 |
| RST | 17 |
| NSS | 5 |
| DIO0 | 4 |
| GND | GND |
| VCC | 3.3V |
Certifica-te de ligar o VCC ao pino de saída 3.3V do teu ESP32. Também, se usares a versão compatível com breadboard do módulo, lembra que só o pino GND ao lado do pino da antena ANT está ligado – os outros dois não! Finalmente, o DIO0 deve ser ligado a um pino do ESP32 que suporte interrupções. A imagem abaixo mostra o diagrama completo de ligações:
Se estiveres a usar uma placa ESP32 diferente, os pinos para SPI hardware, que o esquema acima usa, podem ser diferentes. Se não tiveres a certeza de quais pinos usar na tua placa, vê o Find I2C and SPI default pins tutorial.
A foto seguinte mostra como fica na minha breadboard, quando tudo está ligado:
Finalmente, nota que na verdade não vamos usar o DIO0 no código seguinte. Ou seja, podes deixar esta ligação de fora. No entanto, o DIO0 pode ser usado para sinalizar que dados chegaram via um handler de interrupção, o que pode ser útil na tua aplicação.
Código para comunicação LoRa
Nesta secção escrevemos o código para o emissor e receptor LoRa. O hardware e as ligações para emissor e receptor são idênticos (um ESP32 com um SX1276 ligado), mas o código é diferente.
O emissor envia um valor de contador crescente a cada dois segundos, enquanto o receptor espera pela mensagem do emissor e imprime o valor do contador no Monitor Serial quando recebido. O emissor também pisca o LED incorporado ao enviar uma mensagem, enquanto o receptor pisca o seu LED ao receber uma mensagem.
Começamos com o código para o emissor. Dá uma vista rápida ao código completo e depois entramos nos detalhes.
Emissor
#include <SPI.h>
#include <LoRa.h>
// WEMOS LOLIN32 Lite
// MOSI -> 23
// MISO -> 19
// SCK -> 18
#define SS 5
#define RST 17
#define DIO0 4
#define LED_BUILTIN 22
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
// 433E6: Asia, 868E6: Europe, 915E6: North America
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
LoRa.setSyncWord(0x34); // 0-0xFF sync word to match the receiver
LoRa.setSpreadingFactor(12); // (6-12) higher value increases range but decreases data rate
LoRa.setSignalBandwidth(125E3); // lower value increases range but decreases data rate
LoRa.setCodingRate4(8); // higher value increases range but decreases data rate
LoRa.enableCrc(); // improves data reliability
}
void loop() {
static int counter = 0;
Serial.print("Sending counter: ");
Serial.println(++counter);
digitalWrite(LED_BUILTIN, HIGH);
LoRa.beginPacket();
LoRa.print("Counter=");
LoRa.print(counter);
LoRa.endPacket();
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Primeiro, incluímos as duas bibliotecas que precisamos:
#include <SPI.h> #include <LoRa.h>
A biblioteca SPI.h permite que o ESP32 comunique com o transceptor LoRa via SPI (Serial Peripheral Interface). Enquanto a biblioteca LoRa.h oferece uma interface simples para enviar e receber pacotes LoRa. Podes instalar a LoRa library by Sandeep Mistry usando o Library Manager no Arduino IDE. A imagem abaixo mostra a instalação bem-sucedida da biblioteca:
De seguida, definimos os pinos GPIO ligados às linhas de controlo do módulo para a interface SPI:
#define SS 5 #define RST 17 #define DIO0 4 #define LED_BUILTIN 22
SS, RST e DIO0 são necessários pelo módulo LoRa. Também definimos LED_BUILTIN para controlar o LED onboard, que nos dá feedback visual durante a transmissão. No WEMOS LOLIN32 Lite, o LED onboard está ligado ao pino 22.
setup
Agora vamos à função setup(). Esta parte corre uma vez quando a placa é ligada ou reiniciada:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
Começamos por inicializar o monitor Serial para debugging. Depois, definimos o pino do LED como saída. Em seguida, usamos LoRa.setPins() para indicar à biblioteca quais os pinos ligados ao módulo LoRa.
Depois inicializamos o rádio LoRa a 868 MHz, que é usado na Europa. Lembra-te que tens de usar a frequência específica permitida para transmissões LoRa no teu país!
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
Se o módulo LoRa falhar ao iniciar, continuamos a tentar num ciclo, imprimindo um ponto cada vez. Isto ajuda a diagnosticar problemas de arranque como ligações erradas.
Quando o módulo estiver pronto, configuramo-lo para comunicação fiável de longo alcance:
LoRa.setSyncWord(0x34); LoRa.setSpreadingFactor(12); LoRa.setSignalBandwidth(125E3); LoRa.setCodingRate4(8); LoRa.enableCrc(); }
Aqui está o que cada configuração faz:
setSyncWord(0x34)garante que só dispositivos com a mesma palavra de sincronização podem comunicar entre si. É como um ID de rede simples.setSpreadingFactor(12)aumenta o alcance e fiabilidade espalhando mais o sinal. Os valores vão de 6 a 12 — mais alto significa melhor alcance mas dados mais lentos.setSignalBandwidth(125E3)define a largura de banda do rádio para 125 kHz. Largura de banda mais estreita aumenta o alcance e diminui a taxa de dados.setCodingRate4(8)reforça a correção de erros, ajudando os dados a chegar intactos mesmo em ligações ruidosas.enableCrc()adiciona um checksum a cada pacote para detetar erros de transmissão.
loop
Agora vamos à função loop(), que corre continuamente:
void loop() {
static int counter = 0;
Serial.print("Sending counter: ");
Serial.println(++counter);
Usamos uma variável static int para contar quantos pacotes enviámos. Depois imprimimos o valor no monitor Serial para debugging.
Antes de enviar um pacote, ligamos o LED para sabermos que está a transmitir:
digitalWrite(LED_BUILTIN, HIGH);
Depois construímos o pacote LoRa (=mensagem):
LoRa.beginPacket();
LoRa.print("Counter=");
LoRa.print(counter);
LoRa.endPacket();
Isto cria um pacote com o conteúdo "Counter=1", "Counter=2", e assim por diante. O receptor vai receber esta string e pode decidir o que fazer com ela.
Depois de enviar, desligamos o LED e esperamos um segundo antes da próxima transmissão:
delay(1000); digitalWrite(LED_BUILTIN, LOW); delay(1000); }
Cada ciclo demora cerca de dois segundos — um para a transmissão e outro para a pausa. Podes ajustar o delay conforme as tuas necessidades.
E é tudo! Este sketch envia pacotes LoRa a cada dois segundos enquanto pisca um LED para mostrar atividade. No Monitor Serial deves ver uma mensagem impressa cada vez que um pacote é enviado:
Na próxima secção escrevemos o código correspondente para o receptor.
Receptor
O receptor espera pela transmissão do emissor e imprime-a no Monitor Serial. Aqui está o código completo:
#include <SPI.h>
#include <LoRa.h>
// WEMOS LOLIN32 Lite
// MOSI -> 23
// MISO -> 19
// SCK -> 18
#define SS 5
#define RST 17
#define DIO0 4
#define LED_BUILTIN 22
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
// 433E6: Asia, 868E6: Europe, 915E6: North America
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
LoRa.setSyncWord(0x34); // 0-0xFF sync word to match the receiver
LoRa.setSpreadingFactor(12); // (6-12) higher value increases range but decreases data rate
LoRa.setSignalBandwidth(125E3); // lower value increases range but decreases data rate
LoRa.setCodingRate4(8); // higher value increases range but decreases data rate
LoRa.enableCrc(); // improves data reliability
}
void loop() {
if (LoRa.parsePacket()) {
digitalWrite(LED_BUILTIN, LOW);
while (LoRa.available()) {
Serial.print((char)LoRa.read());
}
Serial.printf(" (%d)\n", LoRa.packetRssi());
delay(100);
digitalWrite(LED_BUILTIN, HIGH);
}
}
Como antes, começamos por incluir as mesmas duas bibliotecas essenciais:
#include <SPI.h> #include <LoRa.h>
Isto é idêntico ao emissor. SPI.h permite comunicação via barramento SPI, e LoRa.h dá-nos todas as funções necessárias para receber pacotes.
De seguida, definimos os mesmos mapeamentos de pinos para o WEMOS LOLIN32 Lite:
#define SS 5 #define RST 17 #define DIO0 4 #define LED_BUILTIN 22
Isto configura a comunicação com o módulo LoRa, e novamente, atribuímos o pino 22 para o LED incorporado. O hardware e a maior parte do código são idênticos para emissor e receptor, mas podes usar configurações de hardware diferentes, por exemplo, microcontroladores ou pinos diferentes.
setup
Agora vamos à função setup(), que é quase idêntica à do emissor:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
LoRa.setPins(SS, RST, DIO0);
Abrimos a ligação serial a 115200 baud para imprimir mensagens recebidas. Depois definimos o pino do LED como saída e atribuímos os pinos de controlo LoRa com LoRa.setPins().
Tal como no emissor, inicializamos o LoRa na frequência de 868 MHz, usada na Europa:
while (!LoRa.begin(868E6)) {
Serial.println(".");
delay(500);
}
Obviamente, tanto o emissor como o receptor devem operar na mesma frequência. Se o módulo não inicializar com sucesso, tentamos novamente a cada 500 milissegundos, imprimindo pontos no Monitor Serial para feedback.
Depois vem a mesma configuração LoRa usada no emissor:
LoRa.setSyncWord(0x34); LoRa.setSpreadingFactor(12); LoRa.setSignalBandwidth(125E3); LoRa.setCodingRate4(8); LoRa.enableCrc(); }
Ao espelhar a configuração do emissor, garantimos que ambos os dispositivos se entendem. Se mesmo um parâmetro estiver diferente — como palavra de sincronização ou largura de banda — o receptor não conseguirá decodificar o pacote.
loop
Agora vamos ao coração do receptor, a função loop():
void loop() {
if (LoRa.parsePacket()) {
Aqui, LoRa.parsePacket() verifica se chegou um pacote. Se nada for recebido, a função retorna 0 e o resto do loop é ignorado.
Quando um pacote é recebido, ligamos imediatamente o LED para sinalizar o evento.
digitalWrite(LED_BUILTIN, LOW);
Nota que a lógica do LED incorporado é invertida. LOW significa que o LED está ligado e HIGH que está desligado.
De seguida, lemos o conteúdo do pacote byte a byte e imprimimos como caracteres no Monitor Serial:
while (LoRa.available()) {
Serial.print((char)LoRa.read());
}
É aqui que aparecem as mensagens "Counter=1", "Counter=2" enviadas pelo transmissor.LoRa.available() verifica se há mais bytes disponíveis, e LoRa.read() obtém cada byte do pacote. Convertêmo-lo para char para imprimir como texto legível.
Depois imprimimos o RSSI (Indicador de Força do Sinal Recebido), que nos diz quão forte foi o sinal:
Serial.printf(" (%d)\n", LoRa.packetRssi());
Isto é útil para diagnosticar o alcance do rádio. Quanto mais negativo o número, mais fraco o sinal. Por exemplo, -45 dB é forte, enquanto -120 dB é quase ilegível.
Finalmente, fazemos uma breve pausa para vermos o LED ligado e depois desligamo-lo, indicando que o código agora espera pelo próximo pacote.
delay(100);
digitalWrite(LED_BUILTIN, HIGH);
}
}
Com este código, o teu receptor ESP32 LoRa ouve mensagens como "Counter=3" enviadas pelo transmissor. Tens confirmação visual pelo LED e atualizações em tempo real no Monitor Serial com leituras da força do sinal entre parênteses:
E é tudo. Agora podes enviar dados de sensores que estão a quilómetros de distância e, devido ao baixo consumo do LoRa, esses sensores podem funcionar muito tempo com bateria.
Conclusões
Neste tutorial aprendeste como alcançar comunicação de longo alcance usando o módulo LoRa SX1276 e o ESP32.
Se quiseres usar um Arduino em vez de um ESP32, precisas de usar um conversor de nível lógico ou um Arduino que opere a 3.3 Volts, pois o módulo SX1276 não funciona com 5V! Vê o Interface Arduino Uno with ST7735 TFT using Level Shifter tutorial se quiseres aprender a usar um conversor de nível lógico.
Uma aplicação típica do LoRa é enviar dados de temperatura, humidade e outros dados ambientais a longas distâncias. Vê o nosso Send Environmental Data with LoRa tutorial, se for isso que queres fazer.
Para comunicação rápida e simples a curto alcance, o Bluetooth é mais adequado. Podes encontrar informações sobre isso nos tutoriais ESP32 And Bluetooth Module- HC-05 e How To Connect ESP32 Bluetooth With A Smartphone.
E se quiseres transmitir informação pela internet, o ESP32 send Telegram Message pode ser útil.
O LoRa é ótimo para transmitir entre alguns sensores. Mas se tens muitos sensores para gerir e queres enviar medições para a internet, o LoRaWAN é o caminho a seguir. Vê o tutorial LoRaWAN with Thinknode G1 Gateway para mais informações sobre este tema.
Finalmente, recomendo que explores a informação em https://www.thethingsnetwork.org para aprenderes mais sobre LoRa e o código de exemplo do LoRa library. Neste artigo só arranhámos a superfície.
Se tiveres alguma dúvida, sente-te à vontade para deixar nos comentários.
Boas experiências ; )
