Meshtastic firmware modification

2025-07-29 16:15 UTC o4-mini-high Open in ChatGPT ↗

To do this you’ll need to hook into the firmware’s FreeRTOS scheduler and fire off a send‐routine on a periodic timer. Here’s a quick recipe you can adapt to your needs:

1. Pick your “send” API

In Meshtastic’s C++ code you generally send text via something like:

#include "RadioInterface.h"

// somewhere you have access to `radio_iface`...
radio_iface->sendText("Automated message", /* wantAck=*/false);

If your board’s code uses a different wrapper (e.g. device->sendText()), just call whatever helper you already use for manual sends.

2. Add FreeRTOS timer code

In your src/main.cpp (or wherever your app_main() lives), do the following:

#include "freertos/FreeRTOS.h"
#include "freertos/timers.h"
#include "RadioInterface.h"

// forward‐declared global radio interface
extern RadioInterface* radio_iface;

// change this to whatever period you want:
static constexpr TickType_t kAutoSendInterval = pdMS_TO_TICKS(5 * 60 * 1000);
// (5 minutes)

static TimerHandle_t autoSendTimer;

static void autoSendCallback(TimerHandle_t xTimer) {
  // This runs in timer task context
  radio_iface->sendText("Hello from timer!", /* wantAck= */ false);
}

extern "C" void app_main() {
  // ... your existing init code, network bring‑up etc.

  // create a periodic timer
  autoSendTimer = xTimerCreate(
    "AutoSend",
    kAutoSendInterval,   // period
    pdTRUE,              // auto‑reload (periodic)
    nullptr,             // timer ID (not used here)
    autoSendCallback     // callback fn
  );
  if (autoSendTimer == nullptr) {
    ESP_LOGE("AutoSend", "Failed to create timer");
  }
  else if (xTimerStart(autoSendTimer, /* blockMS= */ 0) != pdPASS) {
    ESP_LOGE("AutoSend", "Failed to start timer");
  }

  // ... then your normal event loop or task startup
}

What this does

Defines a FreeRTOS timer with your chosen period (here, 5 minutes).
Auto‑reload means it repeats forever.
In autoSendCallback(), it simply calls your LoRa send helper.

3. Customize

Interval: change kAutoSendInterval (e.g. to pdMS_TO_TICKS(60 * 1000) for once a minute, or to pdMS_TO_TICKS(1000) for once a second).
Payload: build dynamic payloads if you need sensor data, GPS, etc.
Enabling/disabling at runtime: you can keep the timer handle and call xTimerStop() or xTimerChangePeriod() from some UI command if you want.

4. Build & flash

cd meshtastic-firmware
idf.py set-target esp32
idf.py menuconfig   # if you need to tweak things
idf.py build
idf.py -p /dev/ttyUSB0 flash monitor

After reboot you should see your “Automated message” on other nodes every interval, no button presses required.

Let me know if you hit any build errors or need to trigger it from a CLI command instead of always‑on!

Here’s how you can get up and running with Meshtastic on your LILYGO® LoRa32 V2.1 and add a periodic‐send feature:

1. Pick the right board firmware

Meshtastic provides pre‑built binaries for the various LORA32 V2.1 variants:

LoRa V2.1‑1.6 boards
Firmware file:
```
firmware-tlora-v2-1-1.6-X.X.X.xxxxxxx.bin
```
citeturn1view0
LoRa V2.1‑1.8 boards (2.4 GHz version)
Firmware file:
```
firmware-tlora-v2-1-1.8-X.X.X.xxxxxxx.bin
```
citeturn1view0

If you just want to flash stock firmware, grab the appropriate .bin from the Meshtastic downloads page or GitHub release and use the Web Flasher:

https://flasher.meshtastic.org

2. Building from source

To modify and re‑compile the firmware yourself, follow these steps:

Install PlatformIO (e.g. via the VS Code extension) citeturn6view0

Clone the Meshtastic firmware repo and init submodules:

git clone https://github.com/meshtastic/firmware.git
cd firmware
git submodule update --init

Select your board in PlatformIO:
- In VS Code: Ctrl+Shift+P → PlatformIO: Pick Project Environment → choose either tlora-v2-1-1.6 or tlora-v2-1-1.8
- Or from the CLI:
  Terminal window
```
pio run -e tlora-v2-1-1.6       # build for V2.1‑1.6 boards
pio run -e tlora-v2-1-1.6 -t upload  # build+flash
```
Flash to your board (USB‑C) via PlatformIO’s Upload command or with:
Terminal window
```
pio run -e tlora-v2-1-1.6 -t upload
```

3. Adding a periodic send routine

You can either use a FreeRTOS software timer or spawn a dedicated task. Here’s a minimal example using a timer. Put this in your ESP32 “main” code—e.g. in src/app.cpp or whichever file defines your app_main():

#include "freertos/FreeRTOS.h"
#include "freertos/timers.h"
#include "RadioInterface.h"

// extern’d in the Meshtastic codebase
extern RadioInterface* radio_iface;

// Send every 10 minutes
static constexpr TickType_t kAutoSendInterval = pdMS_TO_TICKS(10 * 60 * 1000);

static void autoSendCallback(TimerHandle_t) {
  // Fire-and-forget text send (no ACK)
  radio_iface->sendText("Automated LoRa message", /* wantAck= */ false);
}

extern "C" void app_main() {
  // … existing Meshtastic init …

  // Create and start the timer
  TimerHandle_t timer = xTimerCreate(
    "AutoSendTimer",
    kAutoSendInterval,
    pdTRUE,            // auto-reload
    nullptr,
    autoSendCallback
  );
  if (timer && xTimerStart(timer, 0) == pdPASS) {
    // Timer running
  } else {
    // Handle error…
  }

  // … rest of your startup code …
}

How it works

xTimerCreate makes a periodic timer with your chosen interval.

autoSendCallback runs in the RTOS timer task and simply calls the Meshtastic sendText() API.

Because it’s auto‑reload, it will fire every 10 minutes forever (change kAutoSendInterval to suit).

Alternative: FreeRTOS task loop

If you’d rather spin up your own task:

static void periodicTask(void*) {
  for (;;) {
    radio_iface->sendText("Ping from task", false);
    vTaskDelay(pdMS_TO_TICKS(5 * 60 * 1000));  // 5 minutes
  }
}

extern "C" void app_main() {
  // … init …
  xTaskCreate(
    periodicTask,
    "PeriodicSend",
    4096,       // stack size
    nullptr,
    tskIDLE_PRIORITY + 1,
    nullptr
  );
  // … continue …
}

Both approaches work; pick whichever fits your style.

Next steps

Rebuild and flash.
Monitor via idf.py monitor or PlatformIO’s Serial Monitor—every interval you should see your send going out.
Tweak interval, payload, or even gate it behind a CLI command or config setting as needed.

Let me know if you hit build errors or need help integrating this into your specific source layout!

Meshtastic firmware already runs on top of FreeRTOS (ESP‑IDF’s RTOS), so any “periodic” work you add has to live somewhere in that scheduler. You’re right that Meshtastic already provides everything you need to send a LoRa packet—what you need is just a way to trigger that send on a timer rather than over BLE. You have two almost‐equivalent options:

1) Hook into the Meshtastic main loop (no explicit FreeRTOS API)

Meshtastic’s “brains” live in a task that repeatedly calls AppPlatform::loop() (in src/main.cpp or src/app.cpp). You can drop in a simple millis‑based check so that, every N milliseconds, you call radio_iface->sendText(...):

#include "RadioInterface.h"
#include "Platform.h"              // for AppPlatform::Get()->GetMs()

extern RadioInterface* radio_iface;

static uint32_t lastSendMs   = 0;
static constexpr uint32_t kIntervalMs = 60 * 1000; // 1 minute

extern "C" void app_main() {
  // … existing Meshtastic init …
  while (true) {
    AppPlatform::Get()->loop();

    uint32_t now = AppPlatform::Get()->GetMs();
    if (now - lastSendMs >= kIntervalMs) {
      radio_iface->sendText("Hello from timer", /*wantAck=*/false);
      lastSendMs = now;
    }
    // let the RTOS scheduler run other tasks
    vTaskDelay(pdMS_TO_TICKS(10));
  }
}

Pros:

No new RTOS objects, just plain C++
Easy to tweak interval or payload

Cons:

You must pick a delay (here vTaskDelay(10ms)) that balances CPU use vs. latency

2) Use a FreeRTOS software timer (the “official” way)

Under the hood, Meshtastic already creates timers for BLE scans and such. You can create your own one‑shot or auto‑reloading timer and let the RTOS fire your callback exactly on schedule:

#include "freertos/FreeRTOS.h"
#include "freertos/timers.h"
#include "RadioInterface.h"

extern RadioInterface* radio_iface;

// every 5 minutes:
static constexpr TickType_t kAutoSendInterval = pdMS_TO_TICKS(5 * 60 * 1000);

static void autoSendCallback(TimerHandle_t) {
  radio_iface->sendText("Automated LoRa message", /*wantAck=*/false);
}

extern "C" void app_main() {
  // … existing Meshtastic setup …

  TimerHandle_t autoTimer = xTimerCreate(
    "AutoSend",
    kAutoSendInterval,
    pdTRUE,            // reload each time
    nullptr,
    autoSendCallback
  );
  if (autoTimer) {
    xTimerStart(autoTimer, 0);
  }

  // now hand off to Meshtastic’s scheduler:
  AppPlatform::Get()->loopTaskStart();
}

Pros:

Precise timing, zero‑overhead in your loop
Clean separation: scheduler → callback

Cons:

You need to include a couple of FreeRTOS headers (but they’re already in your include path)

Which to choose?

If you want the absolute simplest patch, go with Option 1: just sprinkle a GetMs() check in the existing loop, call sendText(), and yield with vTaskDelay().
If you’d rather lean on the RTOS (and already saw how Meshtastic uses timers elsewhere), Option 2 is a bit cleaner and more “correct” as a periodic job.

Both approaches end up using FreeRTOS under the covers, because ESP32/ESP‑IDF gives you no other scheduler. You’re not learning FreeRTOS new—you’re simply using the same scheduler Meshtastic already does.

Pick the style you’re most comfortable with, drop that snippet into your src/app.cpp, rebuild for tlora-v2-1-1.6 (or 1.8) in PlatformIO or IDF, flash, and your module will start firing off LoRa messages on its own cadence—no BLE app needed.

Those two .bin files in the LilyGO “hardware_test” folder are simply low‑level radio‑and‑LED test images provided by Xinyuan for verifying your board’s hardware. They aren’t the full Meshtastic mesh‑network firmware you’ll want if your goal is “send on a schedule over LoRa via Meshtastic.”

1. Why those `.bin` files aren’t what you need

Hardware test vs. Meshtastic app firmware
The “hardware_test” firmware toggles GPIOs, blinks LEDs, and sends simple LoRa packets to verify TX/RX.
Meshtastic firmware
The Meshtastic project’s firmware repo (https://github.com/meshtastic/firmware) contains the C++ source, the BLE‑to‑LoRa bridge, GPS support, UI over serial, config storage, etc.

2. Getting the correct Meshtastic firmware for LoRa32 V2.1

Clone the Meshtastic firmware repo

git clone https://github.com/meshtastic/firmware.git
cd firmware
git submodule update --init

Choose your board environment
In platformio.ini you’ll see environments named tlora-v2-1-1.6 and tlora-v2-1-1.8. Pick the one matching your board’s RF module (868 MHz vs 2.4 GHz).
Build & flash
- Install PlatformIO (e.g. via VS Code’s extension or pip install platformio).
- Build and upload in one step:
  Terminal window
```
# for 868 MHz V2.1‑1.6 boards
pio run -e tlora-v2-1-1.6 -t upload \
  --upload-port /dev/tty.SLAB_USBtoUART
```
  Replace /dev/tty.SLAB_USBtoUART with whatever port macOS assigns (check with ls /dev/tty.*).

3. “Opening” a `.bin` on macOS

You don’t “open” a raw .bin like an app. Instead you:

Flash it to the ESP32’s flash chip (using esptool or PlatformIO).
If you’re curious about its contents, you can inspect it as raw data:
Terminal window
```
# see first few bytes as hex
hexdump -C firmware.bin | head
```
To modify behavior, you need the source (.cpp, .h) and then re‑compile into a new .bin.

4. Next steps for your periodic‑send patch

Edit the Meshtastic C++ source under src/ (e.g. add a millis‑check in app.cpp or a FreeRTOS timer as we discussed).
Build with PlatformIO (as above).
Flash the newly built .bin.

That workflow—clone → modify source → pio run -e <board> -t upload—is how you’ll develop your own scheduled‑send feature. Let me know if you hit any snags with PlatformIO on macOS or with picking the right board env!