Some time ago I bought a LilyGo module tuned at 433 MHz, but with the built in antenna I couldn't reach anyone. Is this to be expected? Can I put the module to some use?

Created my first meshcore solar powered repeater. Using the lilygo t-beam supreme and a overkill solar panel. All mounted on a din rail in a waterproof electrical cabinet.

It also included some more monitoring, using a esp32c6 running esphome with zigbee and deep sleep. Because i want to keep track of the solar performance.

It was a lot of work to get running, from soldering, 3d printing but also some little firmware changes. I even tough i burned out the lora module by running it without the antenna sometimes. I couldn't test it because i only had 2 other t-beams that where 443Mhz. Today, after buying a hot air station and some soldering i now have 2 board that work with 869Mhz (swapped the sx1278 with a sx1262). Now i am just waiting on the last 869Mhz module so i can modify my last board.

A little cursed i think but it the new module didn't have the same footprint so this also works.

firmware

I like how easy the firmware is to edit, when you have some arduino experience. I added support for the 443Mhz t-beam, made it possible to connect via the app and via the home assistant integration at the same time and created a custom sensor that controls 2 relays, so i can control them remotely. But for some reason the screen just wont work, i tried using the example arduino sketch, different versions and all, none work. I do know the screen is functional because with the test firmware from lilygo it does work.

range

I haven't really tested it with the new antenna, but when i let it run for some time using the stock one, i got contacts from over 125km away, which did really surprise me. I hope with this new antenna that i can also send messages not only receive them.

Some more pictures

Meshtastic for beginners: A real-world, honest guide to off-grid text messaging over radio, including gear, range, MQTT, privacy, and whether Meshtastic is worth using for emergency communication.

I did not create the blog post.

This isn't compatible with Meshtastic unfortunately, and it still needs some polish, but the potential of this protocol seems pretty huge, especially as it can host simple websites or forums over LoRa. Very neat project. Main website for it here: https://reticulum.network/

EDIT: didn't notice there was already a community for reticulum, deleted this post.

Hope its ok to post here. Its not exactly a meshtastic project per-say but I think its nifty so thought I would share.

TLDR: Heltek V3 Ebook reader

History

Its an ebook reader from an old heltek v3 that has been running meshtastic for a couple of years now.

Its been my debug node for a LONG time playing around with the alpha builds. Lately though I have some better hardware to debug/code with. I saw a project on youtube (cant find the link now?) involving a Heltek being a web server and a ebook reader. But with a eink display. So I spent an afternoon making something similar. The code is my own and its been a couple of decades since ive seriously done C++.

Things you can do with it:

1. Read books! I mean thats why I made it.
2. Upload txt files via a web server! Very simple html to push a book to the device. Limit is currently 500kb so enough for a medium sized book. Technically this could be bigger, but I had some issues with guesstimating the amount of space I had. Enough for H.G. "The Time Machine" and other books. But not The Wandering Inn ;)
3. Single click -> next page.
4. Double click -> prev page
5. Triple click -> IP Address for the web server. Im tempted to make this also turn on the web server instead of having it auto-turn on in the setup. Or making this the area where admin things go.

Pictures

Code

#include <Wire.h>               
#include "HT_SSD1306Wire.h"  

#include <EEPROM.h>  
#include <WiFi.h>  
#include <WebServer.h>  
#include <SPIFFS.h>  

// ===== OLED =====  
static SSD1306Wire display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED);  
#define Vext 25 // adjust if needed  

// ===== Button =====  
#define BUTTON_PIN 0  
bool lastButtonState = HIGH;  
unsigned long lastClickTime = 0;  
int clickCount = 0;  
#define CLICK_DELAY 300  // ms for double/triple click  

// ===== EEPROM =====  
#define EEPROM_SIZE 4  
#define PAGE_ADDR 0  

// ===== WiFi Upload =====  
// const char* ssid = "YOUR_WIFI";  
// const char* password = "YOUR_PASSWORD";  
WebServer server(80);  
#define MAX_BOOK_SIZE 500000  // 500 KB limit  
File bookFile;  

// ===== Book Reading =====  
int totalPages = 0;  
int currentPage = 0;  
#define PAGE_LINES 6   // lines per page  
#define LINE_HEIGHT 10 // OLED font height  

// ===== Functions =====  
void VextON() {  
  pinMode(Vext, OUTPUT);  
  digitalWrite(Vext, LOW);  
}  

void drawPage(String pageText) {  
  display.clear();  
  display.setTextAlignment(TEXT_ALIGN_LEFT);  
  display.setFont(ArialMT_Plain_10);  
  display.drawStringMaxWidth(0, 0, 128, pageText);  
  display.setTextAlignment(TEXT_ALIGN_RIGHT);  
  display.drawString(128, 54, String(currentPage + 1) + "/" + String(totalPages));  
  display.display();  
}  

String getPage(int pageNumber) {  
  if (!SPIFFS.exists("/book.txt")) return ""; // No book  
  File file = SPIFFS.open("/book.txt");  
  if (!file) return "Error opening book";  
  
  String page = "";  
  int lineCount = 0;  
  int startLine = pageNumber * PAGE_LINES;  
  int currentLine = 0;  
  while (file.available()) {  
    String line = file.readStringUntil('\n');  
    if (currentLine >= startLine && lineCount < PAGE_LINES) {  
      page += line + "\n";  
      lineCount++;  
    }  
    currentLine++;  
    if (lineCount >= PAGE_LINES) break;  
  }  
  file.close();  
  return page;  
}  

// ===== Web Server Upload Page =====  
String uploadPage = R"rawliteral(  
<!DOCTYPE html>  
<html>  
<body>  
  <h2>Upload Book (.txt)</h2>  
  <form method="POST" action="/upload" enctype="multipart/form-data">  
    <input type="file" name="book">  
    <input type="submit" value="Upload">  
  </form>  
</body>  
</html>  
)rawliteral";  

void handleUpload() {  
  HTTPUpload& upload = server.upload();  
  if (upload.status == UPLOAD_FILE_START) {  
    bookFile = SPIFFS.open("/book.txt", FILE_WRITE);  
  } 
  else if (upload.status == UPLOAD_FILE_WRITE) {  
    if (upload.totalSize > MAX_BOOK_SIZE) {  
      if (bookFile) bookFile.close();  
      SPIFFS.remove("/book.txt");  
      Serial.println("File too large!");  
      return;  
    }  
    if (bookFile) bookFile.write(upload.buf, upload.currentSize);  
  } 
  else if (upload.status == UPLOAD_FILE_END) {  
    if (bookFile) bookFile.close();  
    Serial.println("Upload complete");  
    // calculate total pages  
    File f = SPIFFS.open("/book.txt");  
    int lineCount = 0;  
    while (f.available()) {  
      f.readStringUntil('\n');  
      lineCount++;  
    }  
    f.close();  
    totalPages = (lineCount + PAGE_LINES - 1) / PAGE_LINES;  
    currentPage = 0;  
    EEPROM.write(PAGE_ADDR, currentPage);  
    EEPROM.commit();  
  }  
}  

// ===== Setup =====  
void setup() {  
  Serial.begin(115200);  
  VextON();  
  delay(100);  

  pinMode(BUTTON_PIN, INPUT_PULLUP);  

  display.init();  
  display.setFont(ArialMT_Plain_10);  

  EEPROM.begin(EEPROM_SIZE);  
  currentPage = EEPROM.read(PAGE_ADDR);  
  
  if (!SPIFFS.begin(true)) {  
    Serial.println("SPIFFS mount failed");  
  }  

  WiFi.begin(ssid, password);  
  while (WiFi.status() != WL_CONNECTED) delay(500);  
  Serial.println(WiFi.localIP());  

  server.on("/", HTTP_GET, []() {  
    server.send(200, "text/html", uploadPage);  
  });  
  server.on("/upload", HTTP_POST, []() {  
    server.send(200, "text/plain", "Upload complete");  
  }, handleUpload);  
  server.begin();  

  // calculate total pages if book exists  
  if (SPIFFS.exists("/book.txt")) {  
    File f = SPIFFS.open("/book.txt");  
    int lineCount = 0;  
    while (f.available()) {  
      f.readStringUntil('\n');  
      lineCount++;  
    }  
    f.close();  
    totalPages = (lineCount + PAGE_LINES - 1) / PAGE_LINES;  
  }  
}  

// ===== Loop =====  
void loop() {  
  server.handleClient();  

  bool currentButtonState = digitalRead(BUTTON_PIN);  

  // detect press  
  if (lastButtonState == HIGH && currentButtonState == LOW) {  
    clickCount++;  
    lastClickTime = millis();  
  }  
  lastButtonState = currentButtonState;  

  // process clicks after delay  
  if (clickCount > 0 && (millis() - lastClickTime) > CLICK_DELAY) {  
    if (clickCount == 1) {  
      if (SPIFFS.exists("/book.txt")) {  
        currentPage = (currentPage + 1) % totalPages;  
      }  
    } 
    else if (clickCount == 2) {  
      if (SPIFFS.exists("/book.txt")) {  
        currentPage--;  
        if (currentPage < 0) currentPage = totalPages - 1;  
      }  
    } 
    else if (clickCount >= 3) {  
      // Triple click message  
      display.clear();  
      display.setTextAlignment(TEXT_ALIGN_CENTER);  
      display.setFont(ArialMT_Plain_10);  
      // display.drawString(64, 30, "Triple click detected!");  
      display.drawString(64, 40, WiFi.localIP().toString());  
      display.display();  
      delay(1000); // show message for 1s  
    }  

    if (SPIFFS.exists("/book.txt")) {  
      EEPROM.write(PAGE_ADDR, currentPage);  
      EEPROM.commit();  
    }  

    clickCount = 0;  
  }  

  // Display page or IP if no book  
  if (SPIFFS.exists("/book.txt")) {  
    drawPage(getPage(currentPage));  
  } else {  
    display.clear();  
    display.setTextAlignment(TEXT_ALIGN_CENTER);  
    display.setFont(ArialMT_Plain_10);  
    display.drawString(64, 20, "No book uploaded");  
    display.drawString(64, 40, WiFi.localIP().toString());  
    display.display();  
  }  

  delay(50);  
}  

Each packet received by a node has two numeric values - SNR and RSSI. Big values mean good connection, small values mean bad connection.

You can collect all packets for some period of time and check SNR and RSSI they had. Presumably, they will represent quality of connection between your node and mesh network.

Can you look at the table below and tell if connection between my node and network is good or bad? Do you think this is a good method to measure quality of connection?

received         fromId rxSnr  rxRssi portNum
--------         ------ -----  ------ -------
2026-04-03 13:48 46e8   -4.5   -117   POSITION_APP
2026-04-03 13:49 dca4   -8.5   -121   NODEINFO_APP
2026-04-03 13:49 dca4   -17    -128   
2026-04-03 13:49 dca4   -0.5   -112   POSITION_APP
2026-04-03 13:50 c8dc   -15    -120   NODEINFO_APP
2026-04-03 13:55 5564          -111   POSITION_APP
2026-04-03 13:57 d77e   -0.5   -111   NODEINFO_APP
2026-04-03 13:57 0fe0   -14.5  -120   TEXT_MESSAGE_APP
2026-04-03 13:57 0fe0   1      -110   TEXT_MESSAGE_APP
2026-04-03 14:02 d390   -18.25 -128   TELEMETRY_APP
2026-04-03 14:02 c8dc   -9     -121   TELEMETRY_APP
2026-04-03 14:04 dca4   -0.5   -112   POSITION_APP
2026-04-03 14:06 5564   -2.75  -111   POSITION_APP
2026-04-03 14:10 30bc   1.25   -110   TELEMETRY_APP
2026-04-03 14:10 dd18   -1     -110   POSITION_APP
2026-04-03 14:10 30bc   -9     -121   
2026-04-03 14:11 a54c   -10.5  -121   POSITION_APP
2026-04-03 14:11 a54c   -10.25 -122   
2026-04-03 14:23 c8dc   -10    -122   TELEMETRY_APP
2026-04-03 14:25 46e8   -15.25 -122   NODEINFO_APP
2026-04-03 14:26 5564   -7.25  -119   TELEMETRY_APP
2026-04-03 14:26 1f3c   0.75   -110   NODEINFO_APP
2026-04-03 14:27 dd18   1      -110   NODEINFO_APP
2026-04-03 14:29 e278   1.75   -109   POSITION_APP
2026-04-03 14:33 0fe0   -12    -124   POSITION_APP
2026-04-03 14:33 0fe0   -20.5  -127   
2026-04-03 14:33 0fe0   -8.75  -121   TELEMETRY_APP
2026-04-03 14:34 dca4   -10.75 -122   POSITION_APP
2026-04-03 14:35 c994   -11.75 -123   NODEINFO_APP
2026-04-03 14:38 5564          -110   POSITION_APP

In 3 hours I've got 99 packets with average SNR ~= -6 and average RSSI ~= -117. Is it good or bad?

How to get this data

In case if anyone is curious on how to get this data, here's how I did it with Python and Powershell:

1. Install Meshtastic Python library;
2. Download this script: https://github.com/pdxlocations/Meshtastic-Python-Examples/blob/main/print-packets-json.py
3. In script, change connection type to appropriate, e.g. to Bluetooth;
4. Run script: python3 ./print-packets-json-and-send.py | Add-Content ./packets-all.json;

This script will connect to your node and will start appending all packets in json format to packets-all.json file. Example of a packet (with some parts replaced with blabla):

{
  "from": 2896903512,
  "to": 4294967295,
  "decoded": {
    "portnum": "NODEINFO_APP",
    "payload": "blabla",
    "bitfield": 1,
    "user": {
      "id": "!acab3d58",
      "longName": "blabla_basic",
      "shortName": "WuGb",
      "macaddr": "2IWsqz1Y",
      "hwModel": "HELTEC_V3",
      "role": "CLIENT_BASE",
      "publicKey": "Vkblabla",
      "isUnmessagable": true,
      "raw": "blabla"
    }
  },
  "id": 1719174,
  "rxTime": 1775212872,
  "rxSnr": -5.5,
  "hopLimit": 3,
  "rxRssi": -118,
  "viaMqtt": true,
  "hopStart": 6,
  "relayNode": 60,
  "transportMechanism": "TRANSPORT_LORA",
  "raw": "blabla",
  "fromId": "!acab3d58",
  "toId": "^all"
}

Now you can query this file from another terminal tab, there's no need to interrupt running Python script.

5. This is powershell command I've used to create table above:

$headers = 'received,exported,fromId,rxSnr,rxRssi,portNum,text' -split ','
gc -Raw ./packets-all.json | sls -allm '(?smi)\n(\{.*?\n\})' | % Matches | % {$_.Groups[1].Value} | ConvertFrom-Json -de 99 | ? fromId -ne '!myOwnId' | % {
$received = [DateTimeOffset]::FromUnixTimeSeconds([int]$_.rxtime).ToLocalTime().LocalDateTime.ToString('yyyy-MM-dd HH:mm');
$exported = $_.exportedtime ? [DateTimeOffset]::FromUnixTimeSeconds([int]$_.exportedtime).ToLocalTime().LocalDateTime.ToString('yyyy-MM-dd HH:mm:ss') : $null;
$from = $_.fromId ? $_.fromId.substring(5,4) : '????'
$received,$exported,$from,$_.rxSnr,$_.rxRssi,$_.decoded.portNum,$_.decoded.text -join "`t"
} | ConvertFrom-Csv -delim "`t" -hea $headers | select -Last 30 -excl exported,text | Format-Table

I have an RTL-SDR tuner that has been begging for a use, and I may have just found it.

Update: Got a prototype setup on my laptop. Letting it run to see if I can catch a test alert to see if it gets passed to the mesh. Then gonna try to deploy it to a PiZeroW2. Also plan to tee the output to an Icecast sender so other devices on the network can listen to the weather reports. Right now, it's piped to a player to listen to it on the laptop.

Update 2: Managed to catch a weekly test, and it picked it up and forwarded it. Nice. The only problem was the mesh "ate" the first message. Might just be that node I'm using as it's always been problematic using it over TCP/WiFi (the USB-serial chip is broken in this one). So next step is to package this up in a PiZero2W. (Confirmed that specific node is just wonky. Hooked a node up direct to USB and all message parts were successfully received).

Update 3: If you want to test the setup without having to wait for a weekly test, you can download a sample SAME audio clip from Wikipedia (https://en.wikipedia.org/wiki/File:Same.wav). You'll need to convert the sample rate before you can use it, though.

$ ffmpeg -i Same.wav -ar 48000 same48.wav
$ cat same48.wav | Meshtastic-SAME-EAS-Alerter --test-channel 0
2026-04-02T15:32:31.172Z INFO  [Meshtastic_SAME_EAS_Alerter] Successfully connected to the node.
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Loaded locations CSV
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Monitoring for alerts
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Alerts will be sent to channel: 0
2026-04-02T15:32:31.175Z INFO  [Meshtastic_SAME_EAS_Alerter] Test alerts will be sent to channel: 0
2026-04-02T15:32:31.201Z INFO  [Meshtastic_SAME_EAS_Alerter] Begin SAME voice message: MessageHeader { message: "ZCZC-EAS-RWT-012057-012081-012101-012103-012115+0030-2780415-WTSP/TV-", offset_time: 47, parity_error_count: 0, voting_byte_count: 69 }
2026-04-02T15:32:31.201Z INFO  [Meshtastic_SAME_EAS_Alerter] No location filter applied (locations empty) or no locations in alert
2026-04-02T15:32:31.201Z INFO  [Meshtastic_SAME_EAS_Alerter] Attempting to send message over the mesh: 📖Received Required Weekly Test from WTSP/TV, Issued By: Broadcast station or cable system, Locations: Hillsborough, Manatee, Pasco, Pinellas, Sarasota
Connected to radio
Sending text message 📖Received Required Weekly Test from WTSP/TV, Issued By: Broadcast to ^all on channelIndex:0 
Waiting for an acknowledgment from remote node (this could take a while)
Received an implicit ACK. Packet will likely arrive, but cannot be guaranteed.
Connected to radio
Sending text message  station or cable system, Locations: Hillsborough, Manatee, Pasco, to ^all on channelIndex:0 
Waiting for an acknowledgment from remote node (this could take a while)
Received an implicit ACK. Packet will likely arrive, but cannot be guaranteed.
2026-04-02T15:33:11.227Z INFO  [Meshtastic_SAME_EAS_Alerter] End SAME voice message
2026-04-02T15:33:11.251Z WARN  [Meshtastic_SAME_EAS_Alerter] Program stopped, no longer monitoring

Working Prototype

$ rtl_fm -f 162.400M -s 48000 -r 48000 | tee >(play -q -r 48000 -t raw -e s -b 16 -c 1 -V1 -v 4 - sinc 125-3.2k) >(Meshtastic-SAME-EAS-Alerter --host 192.168.1.236 --test-channel 0) > /dev/null

Found 1 device(s):
  0:  Realtek, RTL2838UHIDIR, SN: 00000001

Using device 0: Generic RTL2832U OEM
Found Rafael Micro R820T tuner
Tuner gain set to automatic.
Tuned to 162652000 Hz.
Oversampling input by: 21x.
Oversampling output by: 1x.
Buffer size: 8.13ms
Exact sample rate is: 1008000.009613 Hz
Sampling at 1008000 S/s.
Output at 48000 Hz.
2026-04-02T14:20:49.702Z INFO  [Meshtastic_SAME_EAS_Alerter] Successfully connected to the node.
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Loaded locations CSV
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Monitoring for alerts
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Alerts will be sent to channel: 0
2026-04-02T14:20:49.704Z INFO  [Meshtastic_SAME_EAS_Alerter] Test alerts will be sent to channel: 0

1. Power on your node in the morning. It is not connected to any smartphone or PC via BT/USB/HTTP;
2. In the evening, connect to it via BT/USB/HTTP;
3. Access all messages received in Primary channel and/or DMs.

Is it possible? How many messages does a node store in it's internal memory? How to access them via terminal? If node is restarted, are they erased?

I have a Heltec V3. In Meshtatsic CLI there's --listen option, but it's about receiving new packages in real time.

meshtastic already has one, but Meshcore didnt until now.

Link to join the group Meshcore: https://smp4.simplex.im/g#AW5gWzrlNydKCf0QgvxyOC_HNnJufRxn9ZQEpyP0Zlc

I recently did a range test with the antenna that ships with the P1 Pro and it's not bad but i'd like to get more from the unit if i'm able to. More height isn't really an option at this time so i'm looking for other ways to increase range. The area i live in is farley hilly but the node sits up higher.

Sorry, it's my dumb ass again, I've been spamming a lot as I learn.

So, I just got a rooftop node set up at my gf's place.
It is a RAK 3312 ESP32-S3 module (labelled 3112 for some reason), on a 19007 WisBlock base board, coupled with the RAK1906 environment sensor and RAK12002 RTC.
It's connected to a RAK 5.8dbi outdoor antenna via a male-N to MHF-4 connector I special ordered from a different site.
I'm powering it via some 18ga cable down the chimney connected to a RAK 5v power supply, and it has a 2000mah battery alongside it to provide backup power.
Everyone uses longfast here.

Some pics:

spoiler

Now, I am having significantly worse TX/RX performance than I had expected out of a nice aerial. My handheld node, which is a TLORA T3-S3 using some crappy ass 6" long china 915mhz antenna from Aliexpress, was able see a reliable hillside repeater from her driveway. Not with great signal strength since it's around a ridge, but it CAN see it, pretty reliably once in a while.
This node I built, can't see anything. After leaving it on it saw maybe one other node for a little while on bootup, then it disappeared. The reliable hill side node is invisible.
Transmitting on LongFast (our area's default) shows maybe 50-60% of what I send gets out, but basically nothing is ever received. I can sometimes see it's enviro telemetry from my home node through 1 hop, but I can't ever talk back to it. Whereas my handheld node can often hear the reliable hill side node and still talk to my home base.

I tried reflashing it with both stable and alpha firmwares, and while the alpha firmware did increase it's stability and fix some other issues with retransmitting and wifi, I noticed while doing that I get a lot of these red messages in the console complaining about an Error -7 when rx'ing:

Before you jump down my throat, yes I know about high gain antennas having a narrow vertical beam width. 35deg on the RAK (17.5 up/down) should be way more than enough to overcome the ~40m height change between this and any other major node at the distances I am dealing with.

Anyway, I'm at a loss with this stupid hardware, and I don't have any other antennas to really test it with because of the worst connector ever known to man (mhf-4). There's definitely a need for additional nodes between this location and the rest of the mesh, but I expected to achieve some connection considering my handheld seems to be able to.

am open to any ideas for how to diagnose this node's performance. Is it a bad radio, bad antenna, bad connector I bought? Do I just RMA the radio and see if a new one does any better?

EDIT: FIXED ALREADY. thanks to @linuxguy@piefed.ca - location report accuracy is set by going to the Channels menu and opening the settings for the default zero channel (or whatever channel you are sending location data on). Not obvious way to do it!

I've put up a couple base stations in my area. One is at my house the other is at my girlfriend's house.

Both of them I've been trying to set a fixed position using the android app, so the mesh map is more accurate and other users can use it to find good places for more stations. Problem is I am unable to set a fixed position. I simply use my phones gps position, which enters the correct 7-decimal coordinates I expect to see. When I program it and the device reboots though, it creates some 15 digit monstrosity and loses most accuracy in its reported position as it seems to fall back to 4-decimal precision. Which isn't helpful as that cirxle is half the size of my town.

Is this something I can bypass by programming via USB or a known bug you've encountered? Otherwise I am gonna make a bug report on github next.

Thanks to everyone who posts here and the mod who created the comm.

I first heard of this concept in a thread here on Lemmy. So now learning about it and looking into everything. Thanks guys!!

So, I'm looking into getting commercially available meshtastic nodes. Buying a bulk set of like 5 of them, and handing them out as birthday presents to my friends to help adoption in the area. A few of them have expressed interest in what I've been experimenting with, but don't want (or can't afford) to invest themselves.

What would be the most cost effective device to invest in?

My basic requirements are going to be

• Screen mandatory (these are not all techy people, they need to see that it's on and doing something)
• GPS would be nice, but probably not worth the device cost
• Bluetooth only- I assume everyone will only be using these with the Android app
• Full housing, battery, antenna provided (no setup)

My top 3 so far are the

1. ThinkNode M1 ($53)
2. Lilygo TTGO T-Echo ($65)
3. RAK WisMesh Pocket ($84)

I'm leaning towards the ThinkNode for price and features alone, but I like the form factor and E-ink display of the Lilygo more.

Not exactly meshtastic but related.

I've got my Chatter2.0 up and running but earlier today, after getting the 5v boost board and adding/removing/shuffling it between the LiPo charging board to try and fix an incorrect power display, I found a new problem. I'm encountering an issue where if the chatter2.0 receives a DM it flashes the DM on screen, reboots immediately after, the sending node does not show the msg was received, and the chatter doesn't show the msg after its reboot.

I'm curious if anyone has run across this kind of issue before. The only thing I can think of to cause this problem is the voltage changes from shuffling the sequence of the charger and 5v boost boards between the battery and device. But this has been easily reproducible after a more intentional reshuffling of the boards between power and device.

From what I understand the firmware should be expecting ~4.7v and I've only been able to supply it ~3.7 and ~5.2v, which is what got me leaning towards incorrect voltage being an issue. However, I also know that I'm wading in over my head on this device project too lol so I'm curious is anyone else may be able to weigh in and possibly steer me in the right direction on how I can best troubleshoot this.

Its a LILYGO T3S3 (a module focused on handheld use) stuck into a housing I modeled myself and 3d printed out of ASA plastic. It has some Chinese "high gain" 915MHz antenna inside the grain silo looking part, which is oversize to prevent too much signal reflection/distortion from the plastic being too close to the antenna. Its powered by 18ga alarm system wire that I draped down the roof to a 5v power supply on the deck. And since I'm renting, non permanent modifications only, thus the clamp to the vent pipe.

Its what I had, just to get started. Quickly realized I needed to be on my roof to get any good connections in my node-sparse area haha.

So far it's working well, I have 13 consistent mesh connections with 3 direct connections, when before I would previously only get spotty connections to the mesh at all from inside my house.

I'll buy some better base station hardware later, once I put one up at my girlfriend's house a few miles away....

I got some WisBlock base station stuff on order from RAKwireless, as I am in need of a high power base station at my GF's house. It's going to get something resembling coverage in an entire half of my city that has no nodes apparently- and I'm going to double it up as a ping-able weatherstation too.

I made the order on the 3rd and it still hasn't indicated it has shipped yet, which is mildly concerning. Most storefronts seem to ship in less than a week. Anyone else ordered stuff from them before and had it take ages? I swear I gotta get this done before my ADHD completely drops this hobby lol

I ordered from their international site as the Rokland US site was out of stock of a lot of stuff. Maybe that's my problem. I'd still expect it to show "shipped".

Hello, is anyone else making use of city channels such as

Name: Atlanta
Key: AQ==

to give a more local public group and mute LongFast, etc? The reason I ask is because we got a band opening this morning and I was trying to chat with some of the locals and broken conversation messages from the band opening were coming in to the chat on LongFast. It got me to thinking that it may not be very polite to have conversations on LongFast when you could reserve it for travelers and airplanes similar to CB Channel 19.

Meshcore has something similar, they call region scopes, where their repeaters can be set to repeat all messages and region specific messages. And if a repeater is not set to repeat region specific messages, then if it receives them, they will be dropped and not be forwarded on.

So, I've been watching a few intros on meshtastic, just to get the basics down, but I believe my situation requires a proper long term plan. Basically, I live practictally in the middle of nowhere, surrounded by mountains, and there are unlikely to be any other meshtastic nodes around, so I will probably need a setup that is partially based on repeaters,

I'm thinking something like this, where my entry into the ordeal is done in multiple stages. It is my understanding that diving into meshtastic quickly becomes an addiction and a hunt for more nodes, and I don't see this as a problem in itself, I just want to figure out what to expect in terms of neighboring nodes.

1. Simple handheld device. Nothing fancy. Something simple and cheap to bring with me when I'm traveling. While I doubt I'll be able to see any nodes at home, I travel often, so it would still be usable and hopefully fun to toy around with.

2. Semi-permanent car install for longer range. Partially as a repeater for my handheld radio, and partially to log and see where I can find "neighbors". As a lot of the aforementioned travel is done by car, I think this is a viable strategy in preparation for step 3.

3. Installing a solar powered repeater on a nearby mountain. So, if I find out that I do have other radios not too far away, I think it's safe to say that I will need a repeater or two on one of the mountains that surround me. We're talking solar panels, and something that can run basically unattended. Long range is key here.

4. If the above work and I end up linking to a larger pool of nodes, then I might go for something fancier at home.

How much does this strategy make sense?

UPDATE: A wisblock starter kit is now on its way. Should enable me to do some research and data collection, and I'll go from there. I'm willing to bet that I need to hike this 1200m summit nearby this summer, tho.

Started looking at standalone node ideas and came across these STEM toys. Each set includes materials to build 2 units, and the community has already done a great job with porting Meshtastic support. They’re a bit pricey to buy direct, and v2.1 is redesigned to make repurposing more difficult, but I was able to pick up this pair of v2.0s off eBay for less than $40.

Stock it has a few known issues, mainly the radio. OOTB these cannot operate on LF, Medium Slow or faster is necessary. There is documentation in the GitHub discussion to make LF operation possible, but my area is switching to MF in a week so I’m just going to not worry about that for now.

It also operates using 3 AAAs, with a USBC port that ~~can provide power but only during programming~~ only be used for programming. It cannot supply charge to whatever batteries are used, but it can be done. Unfortunately, even with the screen off the batteries drain +40% overnight. So to avoid changing batteries every other day, I’ll be adding some pieces to it. I plan to add a 1200mAh LiPo battery and a LiPo Amigo Pro from PiShop to supply power. This could definitely be done a few different ways but I wanted to keep things clean and simple with jtag.

Using the GitHub discussion for this device, I’m also going to look at adding a GPS unit through the 4 header pins on the right side. For ease, I’m planning to attach a ublox M10 with the pigtail crimped for a 4 pin DuPont connector. Apparently these have no power mgmt for GPS, so it’ll be always on. With this approach I figure I can save battery by just unplugging the GPS when necessary.

To keep everything clean and better protected a friend and I are going to modify this case/backplate to fit the LiPo and add a hole for the USBC on the Amigo and a place for the GPS wires to feed into the battery bump for safe storage of that board.

I'm in Canada, with respect to ordering hardware. I think what I am trying to do is setup an always-on node to add to the mesh, but I'm only just dipping my toes into the guide and meshtastic to begin with.

Most of the time, my fellow nerds on Lemmy can filter out the noise of various google searches and cut to the chase to get started - guide me!