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