Turning a Local ADS-B Feed Into an Easy to Read Dashboard

Image
  Have you ever wondered where the plane or helicopter overhead is coming from, where it is going or who operates it? I found myself logging into my SkyAware monitor several times a week to look up that information. The problem was that it only showed what was overhead at that moment and logging in took a minute or two each time. I knew there had to be a better way to see this information quickly and to keep a historical record of all the aircraft traffic I had observed. One of the fun side effects of running a local ADS-B receiver with dump1090-fa on a Pi with an RTL-SDR dongle, is that you end up with a constant stream of aircraft telemetry sitting on your Pi. aircraft.json updates every second or two with hex codes, positions, altitudes, speeds and it's all there waiting to be analyzed and not just sent to Flightaware. Recently, I learned about JetClock which is a slick, commercial desk clock that shows you the aircraft passing overhead with airline, route, photos and all kinds ...

Turning a Cheap OOYCYOO MPPT Solar Controller into a Real Telemetry System

 





There’s a certain kind of frustration that comes with inexpensive hardware: it works, but it doesn’t tell you anything useful.

That’s exactly where I found myself with an OOYCYOO MPPT solar charge controller. It was happily charging batteries, but beyond a tiny LCD panel, there was no meaningful way to monitor performance, integrate it into dashboards or understand what was actually happening over time.

So instead of replacing it, I decided to listen to it. What came out of that experiment is a simple but surprisingly powerful approach: passively tapping the RS485 data stream, decoding the controller’s undocumented protocol and publishing clean telemetry into MQTT for Node-RED, Grafana or Home Assistant.

Important Disclaimer – since you will be doing something experimental, follow the instructions carefully and I take no responsibility for any equipment you might damage.

The Core Idea: Passive RS485 Monitoring

Most people approach this kind of problem by trying to talk to the controller. That’s risky. You can corrupt data, crash firmware, or worse—damage hardware.

This approach does the opposite.
No commands are sent 
No protocols are injected 

Instead, we passively sniff the RS485 traffic that already exists between the controller and its external LCD display.

That one decision changes everything:
Zero risk to the controller 
No need for documentation 
Fully reversible 

And as it turns out, that data stream is rich.

What You Get

Once decoded and cleaned up, the controller starts to look like a modern telemetry device.

You can extract:
PV voltage 
Battery voltage 
Charge current 
Estimated power 
Charging stage (bulk / absorption / float / idle) 
Daily energy production 
Battery percentage 

All of it gets published cleanly to MQTT in structured JSON, ready for anything downstream.
Example MQTT Payload

{
  "pv_voltage": 19.7,
  "battery_voltage": 14.4,
  "battery_current": 4.2,
  "charge_power_w": 60.4,
  "pv_power_est_w": 82.7,
  "charging_stage": "absorption",
  "battery_pct": 95,
  "daily_energy_kwh": 1.23,
  "status": "active"
}

At that point, it stops being a “cheap controller” and starts behaving like a real system component.

Architecture

The physical setup is almost deceptively minimal:
Solar → MPPT controller 
Controller → LCD panel (already connected) 
You add a parallel tap into that line 
Feed it into a USB RS485 adapter 
Plug into a Raspberry Pi 

From there, a Python service handles decoding and MQTT publishing.

This is the key principle:

You are observing the conversation, not joining it.

The One Critical Trick: You Need the LCD

Here’s the most important part:

The controller does not emit RS485 data on its own.

The LCD display is what triggers the data stream.

So you must:
Buy the matching external LCD panel 
Leave it connected 
Tap the RS485 lines in parallel 

Without it, you’ll see nothing.

Making the Data Usable

Raw RS485 frames are noisy and inconsistent. The value of this project isn’t just decoding, it’s stabilizing the data.

The Github script linked below adds:
Last-good-value hold (prevents dropouts) 
Delta-based rejection (filters spikes and garbage frames) 
Idle suppression (no useless zero spam at night) 
Charging state detection 
Daily energy tracking + reset 

Wiring Guidance (Important)

You physically splice an USB to RS485 converter into the data stream (using the green and blue ethernet  cable wires).

Green wire = RS485 A (D+)
Blue wire = RS485 B (D-)

Rules:
- Use an ethernet cable you don't mind destroying (if you make a mistake) and Do NOT cut the cable
- Strip the blue and green wires and run those wires to the RS485 converter to insert inline to the datastream
- Do NOT connect to power
- Swap A/B on the RS485 converter, if needed

Integration: Where This Becomes Powerful

Once the data hits MQTT, everything opens up:
Node-RED dashboards 
Grafana + InfluxDB trending 
Alerts (battery low, charging failure, etc.) 
Remote solar monitoring 

For a ham station running solar, especially remote, this becomes operationally useful very quickly.

You can see:
Are panels actually producing? 
Is the battery healthy? 
Did charging stop unexpectedly? 
What did yesterday really generate?

Limitations

There are a few constraints worth understanding:
There is no direct PV current reading 
PV watts are estimated 
No load-side telemetry 

These aren’t bugs, they’re just limits of the controller’s protocol.

But even with those limitations, the system is far more useful than the stock controller.

Github Software Locations

This concept is based on the work of ma-ha (https://github.com/ma-ha/pv-mon and https://www.youtube.com/watch?v=ksL-_nyTQWg) and I have ported his software to Raspberry Pi at https://github.com/n3bkv/pv-mon 

73



Comments

Popular posts from this blog

How to Put Your AllStar Node on 44Net Connect

Why You Might Want To Set Up Your Raspberry Pi Internet Web Server on 44Net

Build a Central N3FJP Field Day Log Server With Local DHCP and GPS Time

How To Set Up Your Own Remote Station

Building a Secure Web Portal on 44Net Without VPN Headaches

How To Get Precise Time Outside Your Shack

Getting WaveNode Power Meter Data Into Node-RED

Turning Your Starlink Mini into a Real Telemetry Device - How to bridge Starlink Mini into MQTT and Node-RED for real-time monitoring and automation

A Non-Programmers Guide on How To Use AI to Write Your Own Custom Ham Radio Computer Applications

Why You Should Use SSH Keys Instead of Passwords on Your Raspberry Pi

Ham RSS News Feeds

Amateur Radio Daily

ARRL News

Zero Retries