Siliqs Blog
Write-ups on LoRa mesh, RS485/Modbus, and the firmware and hardware decisions behind Siliqs products.
The retrospective — tracing the arc from not knowing LoRa from LoRaWAN on day 1 to being able to flash, configure, and reason about a real SQC485Iv2 node's full lifecycle.
A running list of general bring-up debugging patterns I've started noticing after a few weeks on the bench — not specific incidents, just habits that seem to save time again and again.
I set role, region, channel/PSK, and a Modbus poll plan on a freshly flashed node using the mesh.siliqs.net Configurator, and understood — firsthand this time — exactly what pain that tool is removing.
I flashed a real node for the first time today using flasher.siliqs.net, and spent as much time understanding why it needs Chrome and HTTPS as I did actually watching the flash complete.
Working through the two roles an SQC485Iv2 node can run — gateway mode, which answers a downstream SCADA instantly from cache, and field mode, which just polls and reports — and why a site needs at least one gateway.
After three weeks of LoRa, mesh, RS485/Modbus, and firmware fundamentals separately, today I finally looked at Siliqs' actual SQC485Iv2 node and could name every piece of it.
I assumed firmware engineering time mostly goes into adding capabilities — today I learned a surprising amount of it goes into shrinking what's already there, just to keep the image under a fixed size limit.
I finally understand why battery voltage readings go wrong so often — the ADC never sees the real battery voltage, it sees a scaled-down copy, and every step in that scaling can introduce error.
Today I did some rough back-of-envelope math on why a sensor node that's awake 1% of the time can run for months on the same battery that wouldn't survive a day if the radio stayed on.
I assumed an over-the-air update just overwrites the firmware in place — today I learned why that's basically a way to design a device that can permanently brick itself over the air.
Coming from a PC/software background, today I finally understood why an MCU's flash and RAM are two completely different, tiny resources you have to budget separately — not just "storage" in the abstract.
After a week on RS485/Modbus fundamentals, I finally understand what the SQC485Iv2's 'instant Modbus gateway' feature actually does, and why it can't just forward Modbus requests live over the mesh.
I went into today mildly annoyed that industrial sites still run on decades-old Modbus RTU, and came out understanding why "boring and universal" beats "new and better" on a factory floor.
Working through Modbus's four data types — coils, discrete inputs, holding registers, and input registers — after wasting twenty minutes polling the wrong one and getting an exception response back.
Learning how Modbus RTU turns a shared RS485 bus into an orderly master/slave conversation, with one device talking at a time and everyone else staying quiet.
Starting a new week on RS485/Modbus fundamentals by figuring out why industrial buses use differential signaling and multi-drop wiring instead of the point-to-point RS232 link I was already familiar with.
Getting ready to actually use a VNA on the bench for the first time, and working through why SOLT calibration is a mandatory first step, not an optional nicety, before measuring something like an antenna's S11.
A first pass at three antenna fundamentals I kept running into without really understanding — gain, polarization, and VSWR — before I get real hands-on RF bench time.
Working through SIR (signal-to-interference ratio) as distinct from SNR, why using different spreading factors on overlapping links reduces collision damage, and some internal SIR threshold numbers I've seen that I'm still building intuition for.
Learning why RSSI alone doesn't tell you if a link is good, and how pairing it with SNR gave me a much clearer read on a weak link I was debugging on the bench today.
Working through how Meshtastic-style channels and pre-shared keys keep a private industrial mesh separate from a public mesh someone might be running nearby on the same band.
Reading up on Meshtastic's flood routing — every node that hears a message just rebroadcasts it — and working through why that simple scheme costs more airtime than a smarter, path-based approach.
Working through the basic difference between a mesh network and LoRaWAN's star-of-stars topology, and why that matters for a site where sensors are spread across buildings that can't all reach one gateway.
Building intuition for LoRa's key modulation parameters — spreading factor, bandwidth, and coding rate — and how each one trades range and robustness against speed.
Lining up infrastructure-based LoRaWAN against peer-to-peer Meshtastic and MeshCore, and why Siliqs' industrial mesh use case fits the mesh model better.
A genuinely first-look post on MeshCore, a newer and smaller open-source LoRa mesh project I'm still trying to understand — more open questions here than answers.
My first real look at Meshtastic — the open-source LoRa mesh firmware project — and why understanding it matters for the mesh firmware Siliqs actually ships.
Working through why LoRaWAN defines three device classes and why a battery-powered field sensor almost always wants Class A.
Working through why LoRa devices operate in unlicensed ISM bands and why that comes with strict, region-specific rules on power and airtime — numbers I still need Wei to confirm.
My first day untangling the difference between LoRa (the radio layer) and LoRaWAN (the network protocol built on top of it) — a mix-up I made almost immediately.
Wei looks at what newer Semtech LoRa transceiver generations bring over older ones, and why the LR11xx family's geolocation features caught his eye.
A user-facing look at MUI (the on-screen menu you'll see on touchscreen Meshtastic devices) and how channels and QR codes actually work — including why you might not see a QR code the first time you set up.
Wei explores whether TinyML inference could realistically fit on a resource-constrained industrial sensor node, and whether it's worth the flash and RAM budget.
A plain-language walkthrough of the Heltec WiFi LoRa 32 expansion kit (V4-R8, 2.8" touchscreen, GNSS, TF card) — what the buttons actually do, and how Bluetooth pairing works.
Wei satisfies his curiosity about Matter/Thread, the smart-home interoperability stack, and what — if anything — is worth borrowing for a private LoRa mesh.
A personal evaluation of RISC-V MCUs as an alternative to ARM Cortex-M, weighing the open-ISA pitch against today's tooling reality.
A firmware engineer's personal, balanced take on what Rust actually offers over C for embedded work, and where the friction really is.
We measured a practical signal-to-interference threshold of roughly 0 to +3 dB between LoRa SF5 and SF11 transmissions, with degradation plateauing around 43–44% at negative SIR — and learned the hard way that equal transmit power does not mean 0 dB SIR.
Bringing up flash and debug support for the nRF54L15 meant hitting a gap in official OpenOCD support and having to work through it — a reminder that adopting newer silicon means budgeting time for tooling that hasn't caught up.
Reading through the nRF Connect SDK source significantly lowered my risk assessment for using an external flash secondary OTA slot with MCUboot on the nRF54L15 — but I want to be clear about exactly what's still unverified.
A design walkthrough of how Siliqs' LoRa mesh gateway serves cached Modbus RTU readings from remote nodes, and why we ended up supporting two different slave-addressing schemes instead of picking one.
The Meshtastic-based mesh firmware fits inside its 684 KiB OTA slot, but only with about 11% margin left — here's why that's tight and what it means for day-to-day development.
Why we're starting this blog, and what you can expect to find here.