Antony Mapfumo

921 Metres Through Suburban Brisbane with a LoRaWAN Node — Here's What the Data Showed.

Tue, 28 Apr 2026 12:23:09 +1000

The Setup

I built a two-node LoRaWAN sensor network on STM32WL55JC1 microcontrollers running Rust/Embassy firmware — the full story is in Part 1. One of the two nodes, lora-2, carries no sensor. Its only job is to send a confirmed uplink every ~10 seconds, display RSSI, SNR, and DR on its OLED, and let the gateway’s InfluxDB record tell the story later.

You might wonder why I didn’t just use lora-1 — the sensor node — for this test. Both nodes send a 4-byte payload, so packet size is identical and makes no difference to range. What matters is transmission behaviour: lora-2 sends every uplink confirmed, so a missed ACK is detected within one cycle. lora-1 only confirms every fifth uplink, meaning gateway loss takes much longer to register. lora-2 also transmits every ~10 seconds versus lora-1’s ~30 seconds — three times the data points in InfluxDB, three times the resolution when overlaying against GPS waypoints later. Purpose-built beats repurposed.

Building a LoRaWAN Sensor Network in Rust — STM32WL55, Embassy, and the Bugs That Taught Me the Most

Tue, 28 Apr 2026 12:21:14 +1000

From Sensor to Dashboard — Without a Line of C

My previous projects used the STM32F446RE — a capable workhorse, but one that needs an external LoRa radio module wired up separately. When I decided to go deep on LoRaWAN, I wanted a chip where the radio was part of the silicon itself. The STM32WL55JC1 delivers exactly that: an ARM Cortex-M4 application processor and a sub-GHz radio coexisting on the same die, talking to each other over an internal SPI bus that never leaves the package.

Building a Multi-Protocol Industrial IoT Gateway: LoRaWAN, Modbus TCP, and BACnet/IP

Sun, 01 Feb 2026 17:01:44 +1000

When industrial facilities need to monitor equipment and environmental conditions, they often face a challenge: different systems speak different languages. A temperature sensor in one part of the building might use Modbus TCP, while the HVAC system uses BACnet/IP, and wireless sensors communicate via LoRaWAN. Getting all this data into one place typically requires expensive proprietary gateways or complex integration projects.

I built a solution that brings these three protocols together on a single platform, using open-source tools and commodity hardware.

Week 12: Mission Accomplished - From LED Blink to Production-Grade IIoT

Mon, 26 Jan 2026 22:11:26 +1000

🎬 Watch the Full Demo

After 12 weeks of building, here’s the result: a production-grade Industrial IoT monitoring platform built from scratch.

▶️ Watch on YouTube (6 minutes)

What I Built

A complete Industrial IoT monitoring platform demonstrating expertise across the full stack:

Hardware (4 Sensor Nodes)

LoRaWAN Nodes (STM32WL55):

LoRa-1: SHT41 temperature/humidity sensor + SSD1306 OLED
LoRa-2: BME680 environmental sensor + SH1106 OLED
Native LoRa radio (no external modules)
AU915 frequency band, OTAA join

Modbus TCP Nodes (STM32F446):

Unifying the Chaos - One Dashboard for LoRaWAN, Modbus TCP, and Industrial Security - Wk11

Thu, 15 Jan 2026 20:52:25 +1000

The Challenge

After 10 weeks, I had a problem. A good problem, but a problem nonetheless:

Week 9: Two Modbus TCP nodes (STM32F446 + W5500 Ethernet)
Week 10: Two LoRaWAN nodes (STM32WL55 native radio)
Separate dashboards: Modbus data in one Grafana, LoRaWAN in another
Different buckets: modbus bucket, lorawan bucket
No unified view: Can’t compare all 4 nodes at once

Week 11’s goal: Unify everything into a single monitoring platform while analyzing what it would take to make this production-ready from a security perspective.

From LoRa Modules to Native LoRaWAN the STM32WL Migration - Wk10

Sun, 11 Jan 2026 13:50:05 +1000

The Challenge

For the first 9 weeks of this project, I’ve been using RYLR998 LoRa modules - simple AT command modules that handled the radio work while my STM32 focused on sensors. They worked beautifully for point-to-point communication (600m range, 95% success rate), but they had a fundamental limitation:

They weren’t LoRaWAN.

LoRa (the physical layer) is great for custom networks. But LoRaWAN (the MAC layer protocol) is what you need for:

From IoT to Industrial Automation: Modbus TCP and OPC UA [Open Platform Communications Unified Architecture] - Wk9

Sun, 04 Jan 2026 12:49:44 +1000

Week 9 represents a fundamental shift in the project. For the past eight weeks, we’ve been building IoT systems - MQTT, InfluxDB, Grafana, cloud-oriented architectures. Week 9 is different.

Week 9 is industrial automation.

This isn’t about publishing sensor data to the cloud. It’s about PLC integration, SCADA systems, and factory floor protocols. It’s about Modbus TCP - the protocol that’s been running industrial plants since the 1970s. It’s about OPC-UA - the modern standard for industrial interoperability.

Complete IoT Telemetry Pipeline: From Sensors to Dashboards - Wk7, 8)

Sun, 28 Dec 2025 11:42:16 +1000

Week 7+8 represents project completion at the infrastructure level. This isn’t about adding one more feature - it’s about building the complete path from sensor to insight.

After seven weeks:

Week 1-3: Sensors talk via LoRa ✅
Week 5: Gateway firmware outputs JSON ✅
Week 6: Async service processes data ✅
Week 7: Data goes to MQTT and InfluxDB ✅
Week 8: Professional dashboards visualize everything ✅

This is a complete IoT monitoring system. From a temperature sensor on a breadboard to a Grafana dashboard refreshing every 10 seconds. All in Rust. All running on real hardware.

Async Rust Gateway From Embedded Firmware to Cloud Infrastructure - wk6

Sun, 21 Dec 2025 10:34:48 +1000

Week 6 marks a fundamental shift in the project. Up through Week 5, everything stayed within the embedded realm - microcontrollers talking to each other over LoRa. Data lived in OLED displays and defmt logs that disappeared when you closed the terminal.

Week 6 changes that. It’s the bridge between embedded and cloud, between constrained systems and abundant infrastructure, between no_std and std.

This is the week I learned async Rust isn’t just about performance - it’s about building systems that compose.

Gateway Firmware - From Wireless to Desktop, Wk5

Sat, 13 Dec 2025 09:42:11 +1000

Week 5 was supposed to be straightforward: add USB-CDC to Node 2, stream JSON telemetry to the desktop. Simple, right?

Spoiler: The “simple” solution was blocked by hardware. Then the “good” solution was blocked by firmware. The working solution came from adapting to constraints instead of fighting them.

This is the story of how Week 5 became a lesson in engineering pragmatism - and why the best solution isn’t always the most elegant one.

Binary Protocols and Reliable LoRa Communication

Fri, 12 Dec 2025 20:14:18 +1000

The first two weeks of this project focused on getting data moving: sensors reading correctly, LoRa modules talking, and messages arriving at the other end. That phase was intentionally simple and text-based. It worked, but it was never meant to last.

This week was about moving closer to how real embedded systems behave in the field: binary data, explicit integrity checks, and predictable delivery behavior.

Human-readable messages are convenient for debugging, but they waste bandwidth and hide failure modes. Radios don’t care about readability — they care about airtime, reliability, and determinism. This week’s work was about aligning the system with those realities.

LoRa Sensor Fusion: When "Simple" Becomes Reliable - Wk2

Fri, 05 Dec 2025 17:53:41 +1000

Building a reliable embedded system involves far more than getting code to compile. It’s a process of learning where hardware limits, timing guarantees, and data representation quietly shape everything above them.

Week 2 of the Plan focused on making those constraints explicit.

The result is a dual-node LoRa sensor fusion system built on the STM32F446RE using Rust and RTIC 1.1 — not as a showcase, but as a foundation.

The Objective
System Overview
Five Critical Lessons
Results
Why This Matters
Next Steps

The Objective

The goal for this week was deliberately narrow:

Building Deterministic IIoT Systems With Embedded Rust and RTIC

Tue, 02 Dec 2025 17:53:41 +1000

In the world of Industrial IoT (IIoT), reliability is everything. Sensors must read accurately, actuators must respond predictably, and communication must flow without surprises. On the embedded side, this means precise control of hardware resources, minimal overhead, and code that behaves deterministically. Enter Embedded Rust and RTIC—a pairing that gives engineers both safety and performance without compromise.

Why Embedded Rust?

Rust’s focus on memory safety, zero-cost abstractions, and strict compile-time checks makes it ideal for embedded systems. Unlike C, Rust prevents entire classes of bugs like null pointer dereferences or buffer overflows. When your MCU has just a few kilobytes of RAM, these protections are not optional—they’re essential.

Building an IIoT Sensor Node With Embedded Rust and Stm32

Tue, 18 Nov 2025 17:23:13 +1000

1. Introduction

I come from a networking background. For years, my world revolved around packets, routing tables, latency, and uptime. Over time, it became clear that the boundary between IT and OT (Operational Technology) was becoming less rigid as industrial systems moved onto standard IP networks. Networks were no longer just carrying business traffic — they were increasingly responsible for transporting sensor data, telemetry, and control signals from the physical world. That realization pushed me toward Industrial IoT (IIoT) and, inevitably, embedded systems.

Design Science: A Disciplined Approach to Engineering Embedded Systems

Mon, 20 Oct 2025 14:20:17 +1000

Design Science is a research methodology and problem-solving framework that focuses on the creation and evaluation of artifacts designed to solve real-world problems. Rather than studying systems passively, Design Science emphasizes active construction, experimentation, and rigorous evaluation. Its principles have traditionally been applied in information systems and software development, but they are equally relevant to modern embedded and IIoT engineering.

In complex engineering domains — including embedded systems, IoT, and distributed sensor networks — the challenge is not just writing code or assembling hardware. It’s about systematically creating artifacts that solve practical problems effectively, reliably, and efficiently.

Machine Learning web application using Python, Scikit-Learn, Flask

Thu, 27 Apr 2023 12:02:35 +1000

The scikit-learn Iris data-set consists of 3 (Setosa, Versicolour, and Virginica) species (50 samples per species, for a total of 150 samples) of the iris flower. Each sample has four measurements: sepal length, sepal width, petal length, petal width. Given these measurements a machine learning model can predict the iris specie with a high degree of accuracy. Here I demonstrate a machine learning web application using Python, Scikit-Learn machine learning library and Flask web framework. The application is then deployed on an Amazon EC2 instance. The source is on GitHub.

Programming with Google Go Specialization - A Brief Course Review

Sat, 22 Apr 2023 17:33:35 +1000

Go or GoLang is an open source statically typed language that was created at Google by Rob Pike, Robert Griesemer, and Ken Thompson. It first appeared in Nov 2009 and has been rapidly gaining in popularity. Some of the language’s highlights include clean and highly accessible syntax, garbage collection, amazing native concurrency, fast compilation speed, excellent tooling, builtin documentation, good cross-platform support, ORM (Object-relational mapping ) library called GORM and excellent support for micro-services.

Deep Learning Specialisation - A Brief Course Review

Fri, 21 Apr 2023 18:00:58 +1000

I have just completed Andrew Ng’s Deep Learning Specialisation course by deeplearning.ai available through Coursera. This is my summary and opinion of the course offering. The specialisation consists of 5 courses and it is suggested that they be completed in 3 months by devoting 11 hours per week. It really depends on your previous knowledge, experience and how quickly you can grasp the concepts. When stuck with the assignments and concepts I found the forum to be very helpful. I found the assignments to reasonably difficult. The only thing I didn’t like is that by forcing you to complete the given code (complete missing blanks) you are a bit constrained. For example it would be nice to state the function signature and leave it to the student to implement it in their own way. The good thing is that one can always make such suggestions through the forums. The courses don’t have to be completed in any particular order but I found it more helpful to follow the suggested order.

Iec 61850

Fri, 22 Apr 2022 18:30:41 +1000

The IEC 61850 is at the heart of data communications in the smart grid. The IEC (International Electrotechnical Commission) 61850 standard outlines a framework for communication between several single devices in the power system. The standard was designed to separate the data model from method of communication, address the importance of a structured approach to the design of substation automation systems, utilise existing technologies like Ethernet and TCP/IP, simplify system configuration, device measurement sharing and to enable vendor independence. Although the scope of the IEC 61850 standard was originally substation focussed applications are already operating on wide area substation-to-substation communication using various components of IEC 61850.

About

Mon, 01 Jan 0001 00:00:00 +0000

Aut inveniam viam aut faciam - "I shall either find a way or make one"

Portfolio

Mon, 01 Jan 0001 00:00:00 +0000

portfolio

Tutorials

Mon, 01 Jan 0001 00:00:00 +0000

portfolio

Antony Mapfumo

921 Metres Through Suburban Brisbane with a LoRaWAN Node — Here's What the Data Showed.

The Setup

Building a LoRaWAN Sensor Network in Rust — STM32WL55, Embassy, and the Bugs That Taught Me the Most

From Sensor to Dashboard — Without a Line of C

Building a Multi-Protocol Industrial IoT Gateway: LoRaWAN, Modbus TCP, and BACnet/IP

Week 12: Mission Accomplished - From LED Blink to Production-Grade IIoT

🎬 Watch the Full Demo

What I Built

Hardware (4 Sensor Nodes)

Unifying the Chaos - One Dashboard for LoRaWAN, Modbus TCP, and Industrial Security - Wk11

The Challenge

From LoRa Modules to Native LoRaWAN the STM32WL Migration - Wk10

The Challenge

From IoT to Industrial Automation: Modbus TCP and OPC UA [Open Platform Communications Unified Architecture] - Wk9

Complete IoT Telemetry Pipeline: From Sensors to Dashboards - Wk7, 8)

Async Rust Gateway From Embedded Firmware to Cloud Infrastructure - wk6

Gateway Firmware - From Wireless to Desktop, Wk5

Binary Protocols and Reliable LoRa Communication

LoRa Sensor Fusion: When "Simple" Becomes Reliable - Wk2

Table of Contents

The Objective

Building Deterministic IIoT Systems With Embedded Rust and RTIC

Why Embedded Rust?

Building an IIoT Sensor Node With Embedded Rust and Stm32

1. Introduction

Design Science: A Disciplined Approach to Engineering Embedded Systems

Machine Learning web application using Python, Scikit-Learn, Flask

Programming with Google Go Specialization - A Brief Course Review

Deep Learning Specialisation - A Brief Course Review

Iec 61850

About

Portfolio

Tutorials