Lumio

Lumio uses OpenCV 5 to read machine indicator lights, detect faults from blink patterns, suggest what to do next, and confirm when the issue is fixed.

Comment

Inspiration

Machines already tell us when something is wrong through lights, colors, and blink patterns. The problem is that most people do not know what those signals mean, so they still have to search through manuals or ask someone for help.

That made me wonder if a camera could simply watch those lights and understand what the machine is trying to say.

That idea became Lumio.

Instead of looking at one image, Lumio watches how a light behaves over time. It looks at the colour, the number of blinks, how long the light stays on, how long it stays off, and the pause between each pattern.

What it does

Lumio uses OpenCV 5 to watch machine indicator lights through a camera and understand their patterns.

It can:

  • Detect the colour of an indicator light
  • Count blinks and measure their timing
  • Recognize known fault patterns
  • Stay uncertain when a signal is incomplete
  • Suggest what to do next
  • Keep watching after an action is taken
  • Confirm when the machine returns to a healthy state

The current demo uses network equipment, but Lumio is not meant to be only for routers. The same idea could work with industrial machines, servers, appliances, control panels, and other equipment that communicates through lights.

The main flow is: SEE → DECODE → DIAGNOSE → GUIDE → VERIFY

How we built it

Lumio is built in Python using OpenCV 5.

The user first selects the indicator light they want Lumio to watch. OpenCV then reads the live camera feed and tracks whether the light is on or off.

From the camera feed, Lumio measures:

  • Light color
  • Blink count
  • ON duration
  • Short OFF duration
  • Long pauses between patterns

Lumio compares the observed signal with known patterns and gives the result a confidence score.

If the confidence is too low, Lumio stays uncertain instead of forcing an answer.

After a fault is found, Lumio keeps watching the same light. If it becomes solid green for long enough, Lumio confirms that the machine has recovered.

We also use AWS DynamoDB to save verified sessions.

For testing, we built a browser simulator that lets us reproduce different indicator patterns and test the system repeatedly.

Challenges we ran into

One of the biggest challenges was dealing with incomplete signals.

The camera can start watching in the middle of a blink pattern. A signal that should contain three blinks might first look like only one or two.

We had to make sure Lumio would not immediately guess based on incomplete information.

We also ran into problems with fast blink patterns displayed on a computer screen. The screen refresh rate and camera timing sometimes caused several blinks to look like one longer signal.

We found this while testing the purple unsupported pattern. Instead of changing the detector until it became less reliable, we measured what the camera was actually seeing and adjusted the simulator timing.

Another problem came up during recovery testing. Lumio could correctly confirm that the machine had returned to green, but the long green signal could then be treated as another blink pattern.

We changed the logic so sustained green is treated as a healthy state.

Accomplishments that we're proud of

The part I am most proud of is that Lumio does not stop after finding a problem.

It can detect a fault, suggest what to do, keep watching, and confirm whether the action actually worked.

We completed 30 camera based validation trials covering:

  • Healthy signals
  • WAN failures
  • Configuration errors
  • Unsupported patterns
  • Incomplete observations
  • Recovery after a fault

The results were:

  • 28 out of 30 full passes
  • 2 safe abstentions
  • 0 unsafe misdiagnoses

In both of the trials that did not fully pass, Lumio stayed uncertain instead of giving the wrong answer.

We also:

  • Ran a separate evaluation with 120 simulated observations
  • Rebuilt and tested the project from a clean Python environment
  • Published the source code on GitHub
  • Deployed a public demo
  • Verified that recovery sessions could be logged to AWS DynamoDB

What we learned

The biggest thing I learned is that visual diagnosis is not always about what appears in one frame.

For many machines, timing matters just as much as color.

A single amber light does not tell you very much. Three amber blinks followed by a long pause can mean something completely different.

I also learned how important it is for a system to know when it is unsure.

Sometimes the better answer is to wait for another observation instead of giving an answer too early.

Testing with a real camera was also really important because it showed us problems that were not obvious when we only looked at the simulator.

What's next for Lumio

Right now, Lumio understands a small number of signal patterns.

Next, I would like to:

  • Add more machines and indicator patterns
  • Watch multiple lights at the same time
  • Test Lumio on more real equipment
  • Improve performance under different lighting conditions and camera angles
  • Let Lumio learn new patterns instead of depending only on fixed rules
  • Use device manuals to help Lumio understand new signals
  • Connect Lumio with maintenance and support workflows

The bigger goal is simple. I want Lumio to make machine signals easier to understand, even for someone who has never seen that device before.

Built With

Share this project:

Updates

Submission history