Guia de LoRa com Arduino: comunicação sem fio de longo alcance com SX1278 Ra-02 e ESP32

Projetos com LoRa e Arduino são a maneira mais prática de enviar dados entre duas placas por quilômetros, com consumo mínimo e sem internet nem cartão SIM. LoRa (Long Range) é uma modulação de rádio desenvolvida pela Semtech; com módulos baratos como o Ra-02, baseado no SX1278 e operando em 433 MHz, você pode alcançar 1–3 km na cidade e até 10 km em campo aberto. O preço é a velocidade: de algumas centenas de bytes a alguns quilobits por segundo. Por isso, LoRa não serve para áudio ou vídeo, mas é ideal para transportar pequenas leituras, como temperatura, umidade, nível de água, estado de uma porta ou posição GPS, por longas distâncias.

Neste guia, você verá passo a passo como LoRa alcança distâncias tão grandes, os ajustes de SF, BW e CR que determinam o alcance, a frequência certa para sua região, a ligação do Ra-02 ao Arduino Uno, ESP32 e Raspberry Pi Pico, o código do transmissor e receptor com a biblioteca LoRa, a leitura de RSSI e SNR e um teste real de alcance. As seções finais explicam a diferença entre LoRa e LoRaWAN, a The Things Network (TTN) e um projeto de sensor de campo que funciona por meses com uma bateria.

O que é LoRa e como alcança distâncias tão grandes?

LoRa usa uma técnica chamada espalhamento espectral por chirp (CSS). Cada símbolo é enviado como um “chirp” cuja frequência sobe continuamente pela banda; a informação fica na frequência em que o chirp começa. Quando o receptor multiplica o sinal recebido pelo formato conhecido do chirp e soma o resultado, o ruído se cancela enquanto o sinal se acumula. Isso permite ao LoRa decodificar sinais até 20 dB abaixo do piso de ruído. Módulos ASK comuns de 433 MHz precisam de um sinal claramente mais forte que o ruído, enquanto LoRa interpreta sinais quase imperceptíveis; esse é o segredo para ir muito mais longe com a mesma potência de saída.

O custo é o tempo: quanto mais dura um chirp, mais energia o receptor acumula e maior é o alcance, mas os mesmos dados são enviados mais lentamente. Em LoRa, alcance, velocidade e autonomia da bateria estão sempre ligados. Uma leitura de 20 bytes leva cerca de 57 milissegundos no ajuste mais rápido e 1,3 segundo no de maior alcance. A tabela abaixo compara LoRa com outras opções sem fio do universo Arduino.

Módulos LoRa: Ra-02, RFM95, E32 e placas prontas

A maioria dos módulos LoRa no mercado usa um chip da família SX127x da Semtech. O SX1276 cobre 137–1020 MHz e o SX1278 cobre 137–525 MHz, por isso você encontra o SX1278 em módulos de 433 MHz e o SX1276 em módulos de 868/915 MHz. Os módulos se dividem em dois grupos: rádios “básicos” que se comunicam por SPI e módulos prontos com processador próprio que você usa como uma porta serial por UART.

Qual frequência: 433 MHz ou 868/915 MHz?

LoRa funciona em bandas ISM que dispensam licença, mas essas bandas variam de país para país e cada uma tem limites de potência e ciclo de trabalho. Na Europa, duas bandas são usadas para LoRa: 433,05–434,79 MHz e 863–870 MHz; na América do Norte, é 902–928 MHz. Redes LoRaWAN e TTN usam 868 MHz na Europa e 915 MHz nos EUA, enquanto 433 MHz é muito comum em conexões ponto a ponto de hobbistas com módulos Ra-02 baratos. Confira a região antes de comprar, pois a antena e o chip são ajustados para uma frequência específica; um módulo de 868 MHz não funciona em 433 MHz.

SF, BW e CR: os três ajustes que determinam o alcance

Três parâmetros definem alcance e velocidade em LoRa. O fator de espalhamento (SF) escolhe quantos “chips” formam cada símbolo: de SF7 a SF12, cada passo dobra o tempo do símbolo, permite ao receptor decodificar um sinal cerca de 2,5 dB mais fraco, mas quase dobra o tempo no ar. A tabela abaixo foi calculada para largura de banda de 125 kHz, codificação 4/5 e um pacote de 20 bytes; a última coluna é a espera mínima entre dois pacotes para respeitar um ciclo de trabalho de 1%.

A largura de banda (BW) é a largura da faixa de espectro ocupada pelo sinal: 125 kHz é o padrão; 250 e 500 kHz dobram e quadruplicam a velocidade, mas custam 3 e 6 dB de sensibilidade, enquanto 62,5 kHz e valores menores aumentam o alcance, mas ficam sensíveis à deriva de frequência de cristais baratos. A taxa de codificação (CR) é a informação extra para correção de erros: 4/5 acrescenta 1 bit de correção a cada 4 bits, 4/8 acrescenta 4; isso ajuda em ambientes com ruído, mas alonga o pacote. A fórmula da taxa de bits é Rb = SF × (BW / 2^SF) × 4 / (4 + CR); para SF9, 125 kHz e 4/5, temos 9 × 125.000 / 512 × 0,8 ≈ 1.758 bit/s.

Ligação do Ra-02: Arduino Uno, ESP32 e Pico

Além das quatro linhas SPI (SCK, MISO, MOSI, NSS), o Ra-02 precisa de um pino de reinicialização e um de interrupção (DIO0). DIO0 passa a HIGH quando uma transmissão termina ou um novo pacote chega; a biblioteca LoRa o usa como interrupção. Os pinos DIO1–DIO5 do módulo podem ficar desconectados para o código deste guia. Se SPI for novidade para você, veja primeiro o artigo O que é SPI.

A antena importa tanto quanto a fiação. Instale uma antena ajustada para 433 MHz no conector IPEX do Ra-02. Fazer a sua é fácil: o comprimento de onda é 300 / 433 = 0,693 metro, e um fio reto de 17,3 cm basta para uma antena de um quarto de onda (8,6 cm para 868 MHz, 8,2 cm para 915 MHz). Mantenha a antena na vertical, não a coloque dentro de uma caixa metálica e garanta que as antenas dos dois lados apontem na mesma direção (ambas na vertical); antenas em ângulo reto entre si perdem a maior parte do sinal.

Passo a passo: um transmissor com a biblioteca LoRa

1. Abra o Gerenciador de Bibliotecas no Arduino IDE, digite LoRa e instale a biblioteca LoRa de Sandeep Mistry.
2. Ligue o módulo conforme a tabela e nunca transmita sem a antena instalada.
3. Carregue o código abaixo na placa que será o transmissor; ele detecta se é um ESP32 ou um Uno e escolhe os pinos correspondentes.
4. Abra o Monitor Serial em 115200 baud; deve aparecer uma linha “Gonderildi / sent” a cada 5 segundos.
5. Se LoRa.begin() falhar, confira os fios, a alimentação de 3,3 V e os pinos NSS e RESET.

1#include <SPI.h>
2#include <LoRa.h>
3
4#if defined(ESP32)
5const int PIN_SS = 5, PIN_RST = 14, PIN_DIO0 = 26;   // ESP32 (VSPI: SCK 18, MISO 19, MOSI 23)
6#else
7const int PIN_SS = 10, PIN_RST = 9, PIN_DIO0 = 2;    // Uno (SCK 13, MISO 12, MOSI 11) + seviye dönüştürücü / level shifter
8#endif
9
10const long FREKANS = 433E6;      // Ra-02: 433 MHz; RFM95 için 868E6 / 868E6 for an RFM95
11unsigned long sayac = 0;
12
13void setup() {
14  Serial.begin(115200);
15  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
16  if (!LoRa.begin(FREKANS)) {               // SX1278 bulunamadı / SX1278 not found
17    Serial.println("LoRa baslatilamadi / LoRa init failed");
18    while (true) delay(1000);
19  }
20  LoRa.setSpreadingFactor(9);               // SF9: menzil ile hız dengesi / range vs speed balance
21  LoRa.setSignalBandwidth(125E3);           // 125 kHz bant genişliği / bandwidth
22  LoRa.setCodingRate4(5);                   // hata düzeltme 4/5 / error coding 4/5
23  LoRa.setSyncWord(0xF3);                   // iki tarafta aynı olmalı / must match on both sides
24  LoRa.enableCrc();                         // bozuk paketi ele / drop corrupted packets
25  LoRa.setTxPower(10);                      // 10 dBm (433 MHz bandında yasal sınır) / legal limit on 433 MHz
26  Serial.println("Verici hazir / sender ready");
27}
28
29void loop() {
30  LoRa.beginPacket();
31  LoRa.print("BG #");
32  LoRa.print(sayac);                        // paket numarası / packet number
33  LoRa.endPacket();                         // gönderim bitene kadar bekler / blocks until sent
34  Serial.print("Gonderildi / sent #");
35  Serial.println(sayac);
36  sayac++;
37  delay(5000);                              // havada kalma süresine göre bekle / wait according to airtime
38}
39

Receptor: leitura de pacotes, RSSI e SNR

O código do receptor verifica a cada ciclo, com LoRa.parsePacket(), se chegou um novo pacote; se chegou, a função retorna seu tamanho e o conteúdo é lido byte a byte com LoRa.read(). O código também conta lacunas na numeração dos pacotes para calcular a taxa de perda, que é a base do teste de alcance que faremos daqui a pouco.

1#include <SPI.h>
2#include <LoRa.h>
3
4#if defined(ESP32)
5const int PIN_SS = 5, PIN_RST = 14, PIN_DIO0 = 26;
6#else
7const int PIN_SS = 10, PIN_RST = 9, PIN_DIO0 = 2;
8#endif
9
10long sonNo = -1;                 // son alınan paket numarası / last packet number
11unsigned long alinan = 0, kayip = 0;
12
13void setup() {
14  Serial.begin(115200);
15  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
16  if (!LoRa.begin(433E6)) {
17    Serial.println("LoRa baslatilamadi / LoRa init failed");
18    while (true) delay(1000);
19  }
20  LoRa.setSpreadingFactor(9);    // verici ile aynı ayarlar / same settings as the sender
21  LoRa.setSignalBandwidth(125E3);
22  LoRa.setCodingRate4(5);
23  LoRa.setSyncWord(0xF3);
24  LoRa.enableCrc();
25  Serial.println("Alici hazir / receiver ready");
26}
27
28void loop() {
29  int boyut = LoRa.parsePacket();           // paket geldi mi? / did a packet arrive?
30  if (boyut == 0) return;
31
32  String mesaj = "";
33  while (LoRa.available()) mesaj += (char)LoRa.read();
34
35  int diyez = mesaj.indexOf('#');           // "BG #123" içinden numara / number from "BG #123"
36  long no = (diyez >= 0) ? mesaj.substring(diyez + 1).toInt() : -1;
37  if (sonNo >= 0 && no > sonNo + 1) kayip += no - sonNo - 1;   // atlanan numaralar kayıp / skipped numbers are lost
38  if (no >= 0) sonNo = no;
39  alinan++;
40
41  Serial.print(mesaj);
42  Serial.print("  RSSI: ");
43  Serial.print(LoRa.packetRssi());          // dBm, -120'ye yaklaştıkça zayıf / weaker towards -120
44  Serial.print(" dBm  SNR: ");
45  Serial.print(LoRa.packetSnr(), 1);        // dB, eksi değerler de çözülebilir / negative values still decode
46  Serial.print(" dB  kayip / lost: ");
47  Serial.print(100.0 * kayip / (alinan + kayip), 1);
48  Serial.println(" %");
49}
50

RSSI (indicador de intensidade do sinal recebido) é a intensidade do sinal recebido, um número negativo em dBm: -40 dBm é muito forte, -120 dBm é muito fraco. SNR (relação sinal-ruído) mostra quanto o sinal é mais forte que o ruído. O diferencial de LoRa é que o SNR pode ficar negativo: em SF9, os pacotes ainda são decodificados até -12,5 dB. Para saber se você está perto do limite de alcance, observe mais o SNR que o RSSI; em uma cidade com muito ruído, o SNR pode já estar no limite mesmo com RSSI de -100 dBm.

LoRa com ESP32: uma ponte para Wi-Fi

O ESP32 é a placa mais fácil para LoRa: seus pinos já são de 3,3 V, seu pino 3V3 pode fornecer a corrente do módulo e o barramento VSPI (GPIO 18, 19, 23) é usado diretamente. O código do transmissor e receptor acima compila no ESP32 sem alterações; a linha #if defined(ESP32) seleciona NSS = 5, RESET = 14 e DIO0 = 26. Conectamos DIO0 ao GPIO 26 em vez do GPIO 2 porque GPIO 2 é um pino de strapping que afeta a inicialização do chip. A grande vantagem do ESP32 é atuar como uma ponte: ele pode encaminhar por Wi-Fi dados recebidos via LoRa de sensores no campo para uma página web, um servidor MQTT ou o Telegram. Placas como TTGO LoRa32 e Heltec LoRa 32 reúnem o ESP32, o chip LoRa e um display OLED em uma só placa; a numeração dos pinos é diferente, então confira o esquema da placa.

LoRa com Raspberry Pi Pico (MicroPython)

No Pico, você conecta o Ra-02 ao barramento SPI0 (GP16 MISO, GP18 SCK, GP19 MOSI, GP17 NSS). O repositório oficial micropython-lib tem um driver LoRa para chips SX127x; você pode instalá-lo pelo gerenciador de pacotes do Thonny ou com mpremote mip install lora-sync lora-sx127x. O driver recebe as configurações como um dicionário; desde que SF, largura de banda e palavra de sincronização coincidam com as do Arduino, o Pico lê sem problemas os pacotes do transmissor Arduino acima. O driver informa o SNR como armazenado no registrador do chip, quatro vezes o valor em dB, por isso o código o divide por 4. Como a antena do Ra-02 está conectada à saída PA_BOOST do chip, a configuração tx_ant deve ser “PA_BOOST”; caso contrário, as transmissões serão muito fracas.

1from machine import Pin, SPI
2from lora import SX1278          # mip: lora-sync + lora-sx127x paketleri / packages
3import time
4
5lora_cfg = {
6    "freq_khz": 433000,          # Ra-02: 433 MHz
7    "sf": 9,                     # Arduino tarafıyla aynı / same as the Arduino side
8    "bw": "125",                 # kHz
9    "coding_rate": 5,            # 4/5
10    "preamble_len": 8,
11    "syncword": 0xF3,
12    "tx_ant": "PA_BOOST",        # Ra-02 anteni PA_BOOST çıkışında / Ra-02 antenna is on PA_BOOST
13    "output_power": 10,          # dBm
14}
15
16spi = SPI(0, baudrate=2_000_000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
17modem = SX1278(spi=spi, cs=Pin(17), dio0=Pin(21), reset=Pin(20), lora_cfg=lora_cfg)
18
19while True:
20    paket = modem.recv(timeout_ms=10000)       # 10 sn dinle / listen for 10 s
21    if paket and paket.valid_crc:
22        # snr kayıtta 4 katı tutulur / snr is stored as 4x in the register
23        print(bytes(paket), "RSSI:", paket.rssi, "dBm  SNR:", paket.snr / 4, "dB")
24    elif paket:
25        print("CRC hatali paket / bad CRC")
26    else:
27        print("Paket yok / no packet")
28    time.sleep_ms(10)
29

Teste de alcance: quantos km LoRa alcança?

A única maneira de conhecer o alcance real é testar. Coloque o transmissor em uma janela ou no telhado de casa, conecte o receptor a um notebook ou a um ESP32 + OLED alimentado por um power bank e anote RSSI, SNR e taxa de perda enquanto se afasta. Quando a taxa de perda ultrapassar 10% ou o SNR se aproximar do limite de SF, você chegou ao fim do alcance prático. Altere apenas uma coisa por teste (SF, antena, altura) para identificar a origem da diferença. Você pode medir a distância em linha reta entre dois pontos com um app de mapas no celular.

• Eleve a antena: nada aumenta mais o alcance que a altura da antena. Uma antena a 5 metros, em vez de 1 metro, amplia muitas vezes a linha de visada.
• Use uma antena adequada: as pequenas antenas helicoidais que acompanham os módulos são práticas, mas pouco eficientes; um fio de um quarto de onda de 17,3 cm ou uma antena de haste para uso externo faz uma diferença clara.
• Aumente SF: passar de SF9 para SF12 proporciona cerca de 8 dB de ganho, o que em campo aberto significa aproximadamente mais que o dobro da distância.
• Reduza a largura de banda: passar de 125 kHz para 62,5 kHz proporciona 3 dB de ganho, mas a deriva dos cristais entre os dois módulos pode causar problemas.
• Deixe a zona de Fresnel livre: mesmo quando a linha de visada parece desimpedida, árvores ou edifícios na zona em forma de elipse entre as duas antenas enfraquecem o sinal; elevar um pouco as antenas resolve isso.
• Não descuide da alimentação: o pico de corrente durante a transmissão pode derrubar uma linha fraca de 3,3 V e reiniciar o módulo; acrescente um capacitor de 100 µF à alimentação.

LoRa vs LoRaWAN: o que é TTN?

Esses dois termos costumam ser confundidos. LoRa é apenas a modulação de rádio, a camada física: dois módulos enviam pacotes diretamente um ao outro, e você decide quem envia o quê para quem. Todos os exemplos deste guia são de LoRa ponto a ponto. LoRaWAN é um protocolo de rede construído sobre LoRa: dispositivos (nós finais) enviam seus pacotes para gateways próximos, os gateways os encaminham pela internet a um servidor de rede e, de lá, os dados chegam à sua aplicação. LoRaWAN cuida por conta própria das identidades dos dispositivos, da criptografia AES-128, do ajuste automático de frequência e SF (ADR) e das regras de ciclo de trabalho.

A The Things Network (TTN) é uma rede LoRaWAN gratuita e comunitária, composta por gateways instalados por voluntários. Se houver um gateway TTN perto de você, é possível cadastrar seu dispositivo e ler seus dados pela internet sem montar seu próprio gateway. O uso gratuito segue uma política de uso justo: cerca de 30 segundos de tempo total de transmissão por dispositivo por dia e no máximo 10 mensagens de downlink por dia. Como a TTN usa EU868 na Europa e US915 nos EUA, um Ra-02 de 433 MHz não é adequado para ela; para TTN, escolha um RFM95 da sua região ou um módulo LoRaWAN pronto. Se não houver gateway por perto, LoRa ponto a ponto é muito mais simples.

Projeto: sensor de campo e jardim alimentado por bateria

O uso clássico de LoRa é obter dados de um campo sem energia nem Wi-Fi ou de uma estufa no fundo do jardim. O código para ESP32 abaixo mede a umidade do solo, envia um pequeno pacote no formato “T1,42,37” (ID do nó, número do pacote, porcentagem de umidade), depois coloca o módulo LoRa e o ESP32 em repouso e desperta novamente 10 minutos depois. O sensor é alimentado pelo GPIO 25 apenas durante a medição, então não consome corrente em repouso e, com sensores resistivos, a corrosão dos eletrodos também é reduzida. A calibração do sensor é explicada no artigo Sensor de umidade do solo e os detalhes de deep sleep no artigo Deep sleep no ESP32. O receptor em casa pode usar o código do receptor acima e separar os valores pelas vírgulas.

1#include <SPI.h>
2#include <LoRa.h>
3
4const int PIN_SS = 5, PIN_RST = 14, PIN_DIO0 = 26;
5const int NEM_PIN = 34;                      // toprak nem sensörü AO (yalnız giriş pini) / soil sensor AO (input-only pin)
6const int SENSOR_GUC = 25;                   // sensörü yalnız ölçerken besle / power the sensor only while measuring
7const int KURU = 3000, ISLAK = 1200;         // kendi sensörünle kalibre et / calibrate with your sensor
8const uint64_t UYKU_US = 10ULL * 60 * 1000000;   // 10 dakika / 10 minutes
9
10RTC_DATA_ATTR uint32_t paketNo = 0;          // derin uykuda korunur / kept during deep sleep
11
12void setup() {
13  pinMode(SENSOR_GUC, OUTPUT);
14  digitalWrite(SENSOR_GUC, HIGH);
15  delay(200);                                // sensör otursun / let the sensor settle
16  int ham = analogRead(NEM_PIN);
17  digitalWrite(SENSOR_GUC, LOW);
18  int nem = constrain(map(ham, KURU, ISLAK, 0, 100), 0, 100);   // % nem / % moisture
19
20  LoRa.setPins(PIN_SS, PIN_RST, PIN_DIO0);
21  if (LoRa.begin(433E6)) {
22    LoRa.setSpreadingFactor(10);             // uzak tarla için daha yüksek SF / higher SF for a distant field
23    LoRa.setSignalBandwidth(125E3);
24    LoRa.setSyncWord(0xF3);
25    LoRa.enableCrc();
26    LoRa.setTxPower(10);
27    LoRa.beginPacket();
28    LoRa.print("T1,");                       // düğüm kimliği / node id
29    LoRa.print(paketNo++);
30    LoRa.print(",");
31    LoRa.print(nem);                         // ör. "T1,42,37" / e.g. "T1,42,37"
32    LoRa.endPacket();
33    LoRa.sleep();                            // SX1278 uykuda 1 uA altı / under 1 uA asleep
34  }
35  esp_sleep_enable_timer_wakeup(UYKU_US);
36  esp_deep_sleep_start();                    // 10 dk sonra setup() baştan başlar / setup() restarts after 10 min
37}
38
39void loop() {}
40

Vamos estimar a autonomia da bateria. A cada 10 minutos (600 segundos), o nó desperta por cerca de 0,5 segundo e consome em média cerca de 100 mA nesse período; em repouso, um módulo ESP32 sem placa de desenvolvimento e o Ra-02 juntos consomem cerca de 15 µA. A corrente média é (0,5 × 100) / 600 + 0,015 ≈ 0,1 mA; uma célula 18650 de 2.000 mAh duraria, em teoria, 20.000 horas, mais de dois anos. Na prática, a autodescarga da bateria e as perdas do regulador reduzem esse tempo. Atenção: placas ESP32 DevKit prontas podem consumir vários miliampères mesmo em repouso por causa do chip USB-serial e do regulador; uma corrente em repouso de 5 mA reduz a autonomia da mesma bateria para 17 dias. Para longa autonomia, use um regulador de baixa corrente quiescente ou um módulo sem placa de desenvolvimento. Você pode calcular com seus próprios valores na calculadora de autonomia da bateria.

Ideias de projetos com LoRa

• Nível de reservatório remoto: meça quanto um reservatório distante está cheio com um sensor de nível de água e envie o resultado para casa.
• Aviso da caixa de correio: detecte a abertura da caixa de correio no portão do jardim com uma chave reed e mostre o aviso em um display dentro de casa.
• Balança de colmeia: envie o peso da colmeia algumas vezes ao dia com uma célula de carga HX711.
• Rastreador GPS: rastreie uma bicicleta ou animais a quilômetros de distância com um GPS NEO-6M.
• Monitor de clima da estufa: receba a temperatura e a umidade da estufa por LoRa e emita um alerta em casa quando um limite for ultrapassado.
• Seu próprio gateway: encaminhe dados de vários sensores LoRa para Wi-Fi com um único ESP32 e acompanhe tudo no celular.

Erros comuns e soluções

Um módulo LoRa é a maneira mais barata de levar projetos com Arduino para fora de casa, para o campo, o jardim e o prédio ao lado: com a frequência certa, um SF adequado e uma boa antena, você pode montar sensores que funcionam por meses com uma bateria a quilômetros de distância. Para dados rápidos em distâncias menores, o nRF24L01 ou o ESP-NOW pode ser mais adequado. No app BlueGrays, você encontra projetos de comunicação unidirecional e bidirecional entre dois Arduinos, irrigação inteligente e deep sleep no ESP32, com esquemas do circuito e códigos passo a passo, e pode acrescentar LoRa a eles.