01 / 10
A Pattern, Not a Product

Easy Real-Time
Architecture

Three decades of control software, distilled into a pattern any engineer can learn in few hours — and run anywhere from firmware to cloud.

● 3 Elements ● Any Language ● Any Layer
02 / 10
The Trap

Most teams reach for an RTOS
before they need one.

The classic story

A 20 ms photocell pulse

The sensor latches for 10–20 ms. Windows can't catch it. So the team buys RTX, QNX, or VxWorks — a six-figure commitment — just to poll faster.

The cheaper fix

Latch it in hardware

A three-dollar flip-flop holds the signal for 500 ms. Deterministic. Free. No kernel upgrade required — and no specialist on staff.

03 / 10
The Insight

Determinism is a property of a module,
not of the whole system.

You don't need a 1 ms scan time everywhere. You need it where it matters — the feeding bowl, the indexing head, the safety interlock. Isolate that module with firmware. Run the rest on plain Windows.

04 / 10
The Model

Every control program
is just three things.

01
EVENT

Event happen; or the watchdog will timeout

A sensor fired, a packet arrived, a timer expired, a user clicked, xyz motor arrived at taught location. The world pokes the program.

02
DELAY

Wait for for system settling down

Wait for vacuum to build up, mechanical vibration to settle own

03
ACTION

Act on the world.

Move an actuator. Write a register. Publish a message. Return a value. The system acts.

Event  →  Delay  →  Action  → Then Loop

05 / 10
In Code

The same functionalities,
in every language.

— firmware.c, ViewModel.c#, or embedded.c++     Event, delay, then act
while (running) 
{ if (TimeOut(StepN)) break;
  switch (MState)
  {   
     case 0: // 1.EventCheck
             int evnt = ModuleSteps[StepN].Event;
             if (EventCheck(ModuleSteps[StepN], evnt) == true) 
                 MState += 1;
             else
                 Thread.Sleep(10); 
             break;
     case 1: // 2.Delay
             if ((DateTime.Now - lastRunTime).TotalSeconds >= deLay)
                 MState += 1;
             else
                 Thread.Sleep(10);
             break;
     case 2: // 3.Action
             ProcessActions(StationSteps[StepN]);
             MState += 1;
             break;
     case 3: // Loop Back
             if (Actions[actionKey].Status == ProcessStatus.Done )
                 MState = 0;
             break;
  }
}
— service.py# Event, delay (normally 0), then act
async def service():
while running:
    msg = await asyncio.wait_for(
      queue.get(), timeout=50)    # 1. event
   if msg is None:
   await publish_heartbeat()   # timeout
   else:
   {  await delay(msg.dwell)     # 2. delay
      await dispatch(msg)        # 3. action/command
    }

C, C++, C#, Python, Rust, Go, TypeScript — the shape is the same. Always.

06 / 10
Where It Runs

One model. Every layer.

The architecture is portable. Pick the cheapest layer that meets each module's determinism budget — don't buy the whole stack when you need one chip.

Firmware · Microcontroller
µs · hard real-time
Embedded · RTOS module
1–10 ms · soft real-time
Desktop · Windows app
10–50 ms · best-effort
Cloud · Microservice
seconds+ · event-driven
07 / 10
The "Hit by Truck" Problem

What happens when
your only QNX dev quits?

If your architecture requires a niche specialist, every departure is a crisis.

  • 3–6 months to ramp a newcomer on a niche RTOS
  • Hidden knowledge no one ever wrote down
  • Procedural-vs-OO tribal warfare on every PR
  • Integration fights when modules owned by different people collide
The Easy RT promise

Few hours to be productive.

An engineer reads the model, scans the codebase, and starts working the same day. C, C++, C#, Python — same shape, same vocabulary. No six-month onboarding.

08 / 10
Proof, not theory
3yr
The original plan
→
6mo
First working clone

Codex DNA printer. LRAD controller. Wafer Handler. Leadframe Handler. IC packaging handler. Hardware-software integration
Same architecture. Same shape. Different domains.

09 / 10
"Every control problem is the same three things: an event, a wait, and an action. Make those obvious — and the rest of the system explains itself." — The Easy Real-Time Architecture
10 / 10
Try It Tomorrow

Pick one control loop.
Rewrite it in the 3-element model.
Time the newcomer.

If a new engineer can read it in a single afternoon — and it still meets the timing budget — you've got the architecture.

● Event  ·  ● Wait  ·  ● Command