Como construir uma grelha simples de sensores IoT com o ThinkNode M1 & M2 Meshtastic dispositivos por Elecrow.

O M1 e o M2 são pequenos transceptores LoRa que lhe permitem enviar mensagens de texto através de uma Meshtastic rede mesh. As aplicações comuns incluem comunicação em áreas remotas sem cobertura Wi‑Fi, situações de emergência quando a infraestrutura de comunicações falha ou grelhas de sensores IoT.

Neste tutorial mostro como enviar dados ambientais, como temperatura, humidade e pressão, de um ThinkNode M2 para um ThinkNode M1 – basicamente construindo uma pequena grelha de sensores IoT.

O que é o Meshtastic?

O Meshtastic é um projeto de código aberto que usa rádios LoRa para formar redes mesh descentralizadas com o objetivo de transportar mensagens de texto. As mensagens são automaticamente retransmitidas de um nó para outro, tornando possível comunicar por longas distâncias sem infraestrutura central como o Wi‑Fi.

Como o Meshtastic é baseado em LoRa, uma banda de frequência livre, não precisa de licença para o usar e os dispositivos Meshtastic tendem a ser baratos. Veja o Long range communication with LoRa SX1276 and ESP32 tutorial para saber mais sobre LoRa.

A principal desvantagem do LoRa é que só permite transmitir pequenas quantidades de dados (mensagens de texto). Além disso, longas distâncias só podem ser alcançadas se a área estiver coberta por um número suficiente de nós Meshtastic suficientemente próximos entre si para retransmitirem as mensagens.

Meshtastic versus LoRaWAN

Se conhece LoRa talvez também já tenha ouvido falar do LoRaWAN.

O LoRaWAN é um protocolo de rede de baixa potência e área ampla concebido para comunicação de longo alcance e baixa largura de banda, tipicamente ligando dispositivos à internet através de gateways. Veja o nosso LoRaWAN with Thinknode G1 Gateway tutorial. O Meshtastic, por outro lado, cria redes mesh descentralizadas e ad-hoc, permitindo que os dispositivos comuniquem diretamente entre si sem depender de infraestruturas como gateways.

O LoRaWAN usa uma topologia em estrela-de-estrelas, com os dispositivos finais a comunicarem através de gateways para um servidor central. O Meshtastic forma uma rede mesh onde os dispositivos retransmitem mensagens entre si, criando uma rede descentralizada e auto‑curativa.

O LoRaWAN é adequado para aplicações IoT em larga escala, como cidades inteligentes e monitorização ambiental, onde os dispositivos precisam de enviar dados para um servidor central. O Meshtastic é mais indicado para comunicação fora da rede, situações de emergência ou locais com infraestrutura limitada, como áreas remotas ou durante desastres.

O que são os ThinkNode M1 & M2

Os ThinkNode M1 & M2 e dispositivos Meshtastic semelhantes são, essencialmente, como walkie‑talkies para texto. Contêm um transceptor LoRa e usam o protocolo Meshtastic para transportar dados entre dispositivos/nós. A imagem abaixo mostra o ThinkNode M1:

Irá reparar que o dispositivo tem apenas um ecrã mas não tem teclado. Para enviar mensagens é necessário instalar a Meshtastic app no seu telemóvel e ligá‑la via Bluetooth ao ThinkNode. Pode então escrever mensagens no telemóvel e fazer com que o ThinkNode as transmita pela rede LoRa/Meshtastic para outros dispositivos Meshtastic.

Repare que existem outros dispositivos Meshtastic devices com teclado integrado ou ecrã táctil que executam o Meshtastic UI no próprio dispositivo. Nesse caso não precisa de um telemóvel adicional ligado ao dispositivo para enviar mensagens.

Comparação entre ThinkNode M1 & M2

Os dispositivos Meshtastic baseiam‑se quer no nRF52 quer no ESP32 como microcontrolador. Dispositivos com nRF52 consomem menos energia e são mais indicados para aplicações alimentadas a energia solar e terminais portáteis. Dispositivos com ESP32, por outro lado, oferecem mais capacidade de cálculo, conectividade Wi‑Fi e são mais baratos.

E esta é também a principal diferença entre o ThinkNode M1 & M2. O M1 baseia‑se no processador nRF52840 e foi desenhado para maior autonomia graças a uma bateria maior e um ecrã E‑Ink. O M2 usa o mais poderoso ESP32‑S3 como microcontrolador e é geralmente mais fácil de programar/customizar se vier do universo Arduino. A tabela seguinte compara as principais características dos dois dispositivos:

Nas duas secções seguintes damos uma breve vista de olhos ao M1 e ao M2, individualmente. Para uma comparação mais detalhada veja a comparação de M1 & M2 no site da Elecrow.

ThinkNode M1

Como mencionado acima, o ThinkNode M1 usa o nRF52840  como processador principal. Tem um chip SX1262 para comunicação LoRa, uma bateria recarregável de 1200mAh recarregável, um ecrã EPD de 1.54 polegadas com retroiluminação, um pequeno buzzer e um módulo GPS incorporado. A imagem abaixo mostra o dispositivo:

O carregamento é feito através de uma porta USB Type‑C e o dispositivo pode ser configurado com a Meshtastic app, que comunica com o dispositivo via Bluetooth. A app também permite partilha de mapas e localização, monitorização do estado da rede, exportação de dados e mais. Para mais informações, consulte o Radio Configuration Website.

Todos os detalhes técnicos do ThinkNode M1 podem ser encontrados em ThinkNode M1 Datasheet e para informações de utilização geral veja ThinkNode M1 Manual.

ThinkNode M2

O ThinkNode M2 usa o ESP32‑S3  como processador principal, que é mais poderoso que o nRF52840. Contudo, devido ao processador e à bateria mais pequena de 1000mAh, a autonomia é menor. Além disso, o M2 usa um ecrã OLED de 1.3 polegadas, que também consome mais energia. A foto abaixo mostra o ThinkNode M2:

Repare que o M2 não tem o módulo GPS do M1, mas executa o mesmo software e também é configurado com a Meshtastic app.

Todos os detalhes técnicos do ThinkNode M2 podem ser encontrados em ThinkNode M2 Datasheet e para informações de utilização geral veja ThinkNode M2 Manual.

Ligação de sensores a um nó Meshtastic

O firmware Meshtastic suporta sensores simples, os chamados Detection Sensors ligados a pinos GPIO especificados ou a uma seleção de outros Complex sensors que se ligam via I2C e são configurados no Telemetry Module. Esta seleção de sensores inclui o BM680 sensor ambiental, que eu quero usar neste tutorial.

Infelizmente, embora o módulo ThinkNode M2 exponha alguns pinos GPIO, não expõe os pinos para I2C — pelo menos pelo que percebi. Segundo o Datasheet esses deveriam ser IO15_SCL e IO16_SDA, mas não aparecem na tabela de pinos GPIO disponíveis:

Note que os pinos GPIO não são acessíveis externamente. Tem de abrir a caixa do ThinkNode M2 ou obter o módulo nu (sem caixa). A imagem abaixo mostra a frente e o verso do módulo ThinkNode M2 sem carcaça:

Então como ligar um BM680 sensor ambiental a um ThinkNode M2? Poderíamos modificar o firmware Meshtastic para configurar pinos I2C adicionais/outros, mas isso não seria fácil.

Como alternativa, se pudéssemos programar o ESP32‑lite para enviar mensagens usando o protocolo Meshtastic, não precisaríamos então do ThinkNode M2. Mas não encontrei uma biblioteca que me permita fazer isso.

Isso deixa‑nos com a terceira opção, que parece ser a forma mais comum de resolver este problema. Configuramos o ThinkNode M2 para encaminhar mensagens de texto enviadas pela interface serial (UART).

Isto significa, no entanto, que precisamos de um microcontrolador adicional, no caso um ESP32‑lite. O ESP32‑lite liga‑se ao BME680 para processar os seus dados e envia‑os como mensagem de texto pela interface serial para o ThinkNode M2. Este é o método que vamos usar para construir uma grelha IoT simples, conforme descrito na secção seguinte.

Construir uma grelha IoT com ThinkNodes

A nossa pequena grelha de sensores IoT é composta por um ESP32‑lite com um sensor BME680 ligado, um ThinkNode M2, que envia dados ambientais, e um ThinkNode M1, que recebe e apresenta os dados. A imagem seguinte mostra a arquitetura do sistema:

O sensor BME680 ligado a um ESP32‑lite mede temperatura, humidade e pressão. O ESP32‑lite comunica com um dispositivo ThinkNode M2 via a interface serial (UART).

Os dados ambientais do BME680 são enviados como mensagens de texto do ESP32‑lite para o ThinkNode M2. O ThinkNode M2 depois envia estes dados sem fios via LoRa para o ThinkNode M1, que os apresenta no seu ecrã.

Ligar o ESP32‑lite ao ThinkNode M2 via UART

Tenho o ThinkNode M2 com a carcaça e, embora seja fácil abrir a caixa (basta remover os quatro parafusos na parte de trás), a placa de circuito parece estar colada. Não consegui remover o módulo sem o risco de o partir.

Isto significa que não pude soldar um conector de pinos aos orifícios GPIO na placa como planeado. Em vez disso, liguei fios com clipes a IO18, IO19 e GND, como mostrado na foto abaixo:

Estes fios, depois, liguei‑os ao ESP32‑lite conforme mostrado no diagrama de ligações abaixo:

O IO17 do ESP32 está ligado ao IO18 do M2, e o IO16 do ESP32 está ligado ao IO19 do M2. Com esta ligação podemos estabelecer comunicação serial (UART) entre o ESP32‑lite e o ThinkNode M2.

Ligar o ESP32‑lite com BME680 ao ThinkNode M2

De seguida, precisamos de ligar o BME680 ao ESP32‑lite. A imagem abaixo mostra a ligação completa do BME680 ao ESP32‑lite e ao ThinkNode M2:

O BME680 suporta I2C e está portanto ligado aos pinos I2C por defeito (SDA=19, SCL=23) do ESP32‑lite. Também precisamos de ligar a alimentação (3.3V e massa). Se precisar de mais informações sobre o BME680, veja o BME680 Environmental Sensor with Arduino, o Measure Air Quality with BME680 e os Send Environmental Data with LoRa tutoriais.

A foto seguinte mostra a ligação completa numa breadboard incluindo o ThinkNode M2 e o ThinkNode M1:

Configurar os ThinkNode M1 e M2

Antes de podermos enviar quaisquer dados entre os dois ThinkNodes precisamos de os configurar. Especificamente, temos de definir a frequência LoRa e garantir que é a mesma para ambos os nós.

Para configurar um ThinkNode, abra a Meshtastic app no seu telemóvel, ligue‑a via Bluetooth ao ThinkNode (irá receber um código) e depois clique nos três pontos no canto superior esquerdo para abrir o menu. Veja o Wiki for the ThinkNode M1 e o Wiki for the ThinkNode M2, se precisar de informação mais detalhada.

Configurar a frequência LoRa

No menu selecione “Radio configuration” e depois “LoRa”, o que abrirá a página “LoRa Config”:

Lá pode definir a Região com uma frequência associada. Deve selecionar a sua região/país e tem de fazer o mesmo para ambos os ThinkNodes M1 e M2, caso contrário não poderão comunicar!

Note que as frequências LoRa permitidas dependem do país (frequencies). É 868MHz para a Europa, 915MHz para a América do Norte e 433MHz para a Ásia. Como vivo na Europa, seleccionei “European Union 868MHz” como região/frequência na captura de ecrã acima.

Se tiver problemas com a configuração, há muitos tutoriais para ajudar na instalação. Por exemplo, veja o ThinkNode M1/M2 Review – Getting started with Meshtastic tutorial. Ou o Meshtastic Configuration info.

Uma vez configurados, deve verificar se consegue enviar mensagens de texto do ThinkNode M2 para o ThinkNode M1. Se isso funcionar, podemos então configurar a interface serial do ThinkNode M2.

Configurar a interface serial

Queremos ligar o ESP32‑lite via a interface serial ao ThinkNode M2. Isto exige configuração adicional do ThinkNode M2.

Abra o menu clicando nos três pontos (como antes). Seleccione “Radio Configuration” e depois “Serial”. Isso abrirá a página “Serial Config” como mostrado abaixo:

Ative “Serial enabled” e defina os pinos GPIO para comunicação serial (RX e TX). Eu escolhi RX=18 e TX=19. Defina a taxa de transmissão para 115200 e o modo para “TEXTMSG”. Este modo indica ao ThinkNode que encaminhe/transmita qualquer texto que receba via interface serial.

E com isto estamos finalmente prontos para escrever algum código que nos permita transmitir dados.

Enviar dados via ThinkNode M2 para M1

Começamos com um código de teste simples que cria um contador em execução no ESP32‑lite, que é enviado via comunicação serial para o ThinkNode M2, que depois o transmite via LoRa para o ThinkNode M1. Abaixo está o código para o ESP32‑lite:

#define TX_PIN 17  // ESP32 TX -> M2 RX 18
#define RX_PIN 16  // ESP32 RX <- M2 TX 19

#define BAUD_RATE 115200  
#define SEND_PERIOD (60 * 1000)

HardwareSerial serial2(2);

void setup() {
  Serial.begin(115200);
  serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
}

void loop() {
  static int cnt = 0;
  static char msg[128];

  sprintf(msg, "counter=%d", cnt++);
  serial2.println(msg);  // Sending to ThinkNode M2
  Serial.println(msg);
  delay(SEND_PERIOD);
}

Carregue este código para o ESP32‑lite, ligue os ThinkNode M1 e M2 e deverá receber, a cada minuto, uma mensagem de texto “counter=…” no ThinkNode M1.

Vamos analisar o código mais de perto. Começamos por definir os pinos para a interface serial e constantes para a taxa de transmissão e o tempo entre transmissões (60 segundos):

#define TX_PIN 17  // ESP32 TX -> M2 RX 18
#define RX_PIN 16  // ESP32 RX <- M2 TX 19

#define BAUD_RATE 115200  
#define SEND_PERIOD (60 * 1000)

Deve escolher pinos para comunicação serial que sejam suportados pelo seu microcontrolador. No caso do ESP32‑lite há três interfaces seriais hardware (0,1,2) e eu estou a usar a terceira:

HardwareSerial serial2(2);

Na função setup iniciamos a comunicação serial para o Serial Monitor para depuração e a comunicação serial para o ThinkNode M2, com os pinos definidos e a taxa de transmissão:

void setup() {
  Serial.begin(115200);
  serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);
}

Quanto à função loop: aí incrementamos um contador, criamos uma mensagem de texto com o valor do contador, imprimimo‑la no Serial Monitor e também a enviamos via interface serial para o ThinkNode M2. O delay no fim garante que isto acontece a cada minuto:

void loop() {
  static int cnt = 0;
  static char msg[128];

  sprintf(msg, "counter=%d", cnt++);
  serial2.println(msg);  // Sending to M2
  Serial.println(msg);
  delay(SEND_PERIOD);
}

No ecrã do ThinkNode M1 deverá então ver o contador:

Note que pode ter de pressionar o botão Function para actualizar o ecrã. Se isso funcionar podemos prosseguir para enviar dados reais.

Código para enviar dados ambientais

O código seguinte lê dados ambientais como temperatura, humidade e pressão do sensor BME680 e envia‑os para o ThinkNode M2, que por sua vez os encaminha para o ThinkNode M1:

#include "Adafruit_BME680.h"

#define SEALEVELPRESSURE_HPA (1013.25)

#define TX_PIN 17  // ESP32 TX -> M2 RX 18
#define RX_PIN 16  // ESP32 RX <- M2 TX 19

#define BAUD_RATE 115200  
#define SEND_PERIOD (60 * 1000)

HardwareSerial serial2(2);
Adafruit_BME680 bme;

void setup() {
  Serial.begin(115200);
  serial2.begin(BAUD_RATE, SERIAL_8N1, RX_PIN, TX_PIN);

  bme.begin();
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150);  // 320*C for 150 ms
}

void loop() {
  static char msg[128];

  if (bme.performReading()) {
    sprintf(msg, "temperature: %.0f C\nhumidity: %.1f %%\npressure: %.0f hPa\n", 
    bme.temperature, bme.humidity, bme.pressure/100.0);

    serial2.println(msg);  // Sending to ThinkNode M2
    Serial.println(msg);

    delay(SEND_PERIOD);
  }
}

O código é uma extensão simples do código anterior. Apenas adicionamos a inicialização do BME680 à setup função:

void setup() {
  ...

  bme.begin();
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150);  // 320*C for 150 ms
}

e criamos a mensagem de texto a partir das medições do BME680 na loopfunção quando as medições estiverem disponíveis:

void loop() {
  ...
  if (bme.performReading()) {
    sprintf(msg, "temperature: %.0f C\nhumidity: %.1f %%\npressure: %.0f hPa\n", 
    bme.temperature, bme.humidity, bme.pressure/100.0);

    serial2.println(msg);  // Sending to ThinkNode M2
    ...
  }
}

Note que vai precisar de ter a Adafruit BME680 biblioteca instalada. Ela fornece todas as funções essenciais para controlar o sensor BME680.

Se quiser saber mais sobre o BME680 e o código correspondente, veja o BME680 Environmental Sensor with Arduino, o Measure Air Quality with BME680 e os Send Environmental Data with LoRa tutoriais.

No ecrã do ThinkNode M1 deverá agora receber os seguintes dados ambientais:

E é tudo. Agora tem uma pequena grelha de sensores Meshtastic com um sensor BME680 e os ThinkNodes M1 e M2 como nós Meshtastic. Pode facilmente alargar o alcance e as funcionalidades desta rede adicionando mais nós Meshtastic ou sensores.

Conclusões e Comentários

Neste artigo aprendeu a construir uma pequena grelha de sensores IoT com um sensor BME680 e os ThinkNodes M1 e M2 Meshtastic.

A rede mesh Meshtastic permite enviar dados de sensores por distâncias maiores do que o LoRa sozinho e não requer Wi‑Fi ou estruturas de comunicação semelhantes. No entanto, necessita de outros nós Meshtastic nas proximidades que possam retransmitir os dados. Em julho de 2025 o número de nós Meshtastic na maioria das áreas não é suficientemente elevado para fornecer cobertura total. Veja o Meshmap.

Entre o M1 e o M2, atingi talvez 200 a 300 metros antes de os dispositivos perderem a ligação. Para um teste de alcance detalhado e comparação, leia o ThinkNode M1/M2 Review – Getting started with Meshtastic artigo de Jean‑Luc Aufranc.

Se quiser transmitir dados de sensores por algumas centenas de metros, é melhor usar LoRa puro. Será mais simples e dará mais flexibilidade. Veja o Send Environmental Data with LoRa tutorial sobre como fazer isso.

Para maior alcance ou configurações com muitos sensores que precisam de enviar medições para a internet, o LoRaWAN é outra opção. Veja o LoRaWAN with Thinknode G1 Gateway tutorial para mais informações sobre este tema. E se apenas quiser transmitir informação pela internet o ESP32 send Telegram Message tutorial pode ser útil.

Apesar das limitações actuais e da cobertura comparativamente reduzida, o Meshtastic é uma tecnologia divertida para experimentar e a comunidade está a crescer. Recomendo vivamente que leia mais About Meshtastic.

Se tiver alguma questão, sinta‑se à vontade para a deixar na secção de comentários.

Boas experiências ; )