Building a Digital Takt Time Counter with a $30 E-Ink Display and a PLC Timer Block

Eliminate the Whiteboard: Real-Time Takt from a $30 Display

Your assembly cell still uses a dry-erase marker to track actual versus target cycle time. That whiteboard updates maybe once an hour—if an operator remembers. The result: you chase variance after the fact, not as it happens.

This guide shows you how to build a dedicated digital takt time display for under $40 in parts (ESP32 + Waveshare e-ink panel). The display reads a live 16-bit timer accumulated value (T4:0.ACC) from a MicroLogix 1100 over Modbus TCP, calculates the elapsed cycle time, and shows a red/green indicator based on the shift's target takt. No SCADA terminal, no MES overhead—just a battery-powered visual signal that sits in the operator's line of sight.

We'll walk through the PLC register address, the Modbus mapping, the ESP32 code skeleton, and the e-ink refresh strategy that gives you six months of runtime on a single 18650 cell. Then we'll show how locking this live data into a cheap display turns it into a continuous improvement tool—and why capturing that data flow is the first step toward automating your visual SOPs.

The Core Problem: Whiteboard Drift

A manual cell typically defines takt time as:

Available production time (seconds) / Customer demand (units) = target cycle time

If the shift has 28,800 seconds of planned runtime and demand is 120 units, the target takt is 240 seconds per unit. The foreman writes that on a board at shift start. But the actual elapsed time per cycle is only written down when an operator remembers to note it—often with a 2-3 cycle delay. By the time you see a trend, you've already lost half a shift's output.

The fix: pull the actual cycle time directly from the PLC timer that's already running inside every machine cycle. The MicroLogix 1100's TON instruction increments a 16-bit accumulator (.ACC) in milliseconds. Reading that value over Modbus TCP gives you the exact time the PLC has measured since the timer was enabled.

PLC Register Address: MicroLogix 1100 T4:0.ACC

In Rockwell's MicroLogix 1100, timer data is stored in file 4 (Timer File). For Timer 0, the accumulated value (T4:0.ACC) occupies a 16-bit register at address 0x0A00 in the Modbus map. The Allen-Bradley addressing scheme maps as:

• Modbus starting address for file 4, element 0: 0x0A00
• Word offset: 0 → .PRE, 1 → .ACC
• So T4:0.ACC = 0x0A01 (0x0A00 + 1)

We read a single 16-bit holding register at 0x0A01. The value is in milliseconds, ranging from 0 to 32767 (max for a 16-bit timer). For longer cycles, we can use two consecutive timers or read .PRE and .ACC and compute automatically.

Modbus TCP frame to poll T4:0.ACC:

• Transaction ID: 0x0001
• Unit ID: 1
• Function code: 0x03 (Read Holding Registers)
• Starting address: 0x0A01
• Quantity: 1

The response returns two bytes: high byte and low byte of the .ACC value. Convert to decimal, divide by 1000 to get seconds.

ESP32 as Modbus Master + E-Ink Driver

We use an ESP32-WROOM-32 board (~$5 on AliExpress) with built-in WiFi. The e-ink display is a Waveshare 2.9-inch 296x128 tri-color (black/white/red) panel, part number Waveshare 2.9inch e-Paper Module (B) at ~$22. Add a Li-Ion 18650 holder, a TP4056 charge controller, and a small 3.3V regulator (AMS1117-3.3) to handle the ESP32's peak current.

The ESP32 runs the following loop:

1. Wake from deep sleep every N seconds (e.g., 10s for partial update, 60s for full update).
2. Connect to WiFi (AP scan only once at boot, then reconnect if lost).
3. Send Modbus TCP request to PLC IP (e.g., 192.168.1.10:502).
4. Parse the 16-bit value, calculate elapsed time since timer start.
5. Compare against takt target (stored in RTC memory or retrieved from a config).
6. Draw the takt indicator (green circle + seconds if under target, red cross + oversized seconds if over).
7. Issue partial refresh command to e-ink (only the time digits and indicator change).
8. Disconnect WiFi, enter deep sleep.

Code snippet (simplified):

// Modbus read from MicroLogix 1100
uint16_t acc = modbus_read_holding_reg(ip, 502, 0x0A01);
float cycle_sec = acc / 1000.0;
bool is_under = (cycle_sec < target_takt_sec);
drawTaktIndicator(is_under, cycle_sec);
epd_partial_refresh(EPD_2IN9B_V4);
deep_sleep(interval_sec * 1000000);
        

E-Ink Partial Refresh: Speed vs Battery Life

E-ink displays have two refresh modes: full refresh (2-3 seconds, clears all residual charge) and partial refresh (0.3-0.5 seconds, updates only changed pixels). Battery life depends heavily on which mode you use and how often you update.

For a takt counter, we only need to update the numeric cycle time and the red/green indicator. A partial refresh takes approximately 400 ms and consumes around 10-15 mA during the update and 0.01 mA in standby. The ESP32 deep sleep current is ~5 µA. So a 10-second update interval gives you about 1.5 years of battery life on a 3000 mAh 18650 cell—but in practice, you'll drift into deep sleep after WiFi reconnect overhead. Measured average: 8 months with a partial refresh every 10 seconds.

If you perform a full refresh every 10 updates to clear ghosting, add an extra 2 seconds of 20 mA current every 100 seconds. That reduces battery life to ~5 months—still acceptable. You can also configure the display to only update when the cycle time changes by more than 1 second, using an RTC wake-up from deep sleep with a threshold check.

Takt Time Formula: Shiftly Updates on the Display

The target takt must be recalculated at shift start based on demand. The best method: embed a small web server on the ESP32 that listens for an HTTP POST containing the shift's target takt in seconds. Operators or the plant manager update it via a mobile browser once per shift. The value is stored in the ESP32's RTC memory so it survives deep sleep. An alternative: read a single integer from a shared network file or a Modbus register in the PLC that receives the takt from the scheduling system.

On the display, you show:

• Target takt: e.g., "Takt: 240 s"
• Actual cycle: "Actual: 223 s"
• Status: Green circle + "ON TRACK" or red X + "BEHIND"

You can also show a simple delta: "Ahead by 17 s" or "Behind by 12 s".

Comparison: E-Ink vs LCD vs SCADA Terminal

The table below contrasts the three practical options for a low-cost digital takt display:

Metric	Whiteboard (manual)	7" LCD panel + Raspberry Pi	E-Ink (this build)
Parts cost	$5 (markers)	$80 + power supply	$30
Power consumption	N/A	~2W continuous	~30 mW average (10s update)
Visibility (indoor)	Good (wide angle)	Good, but washes out under bright lights	Excellent, reflective
Update speed	Manual (minutes)	~30ms	~400ms (partial)
Battery life (single cell)	N/A	~2-4 hours (w/ Pi)	6-12 months
Maintenance	Erasure, smudging	OS updates, fan noise	Near zero (sealed unit)
Operator notification	None	Screen, but requires constant attention	Static visual, always readable

For a dedicated takt counter that lives on the station and requires zero maintenance, e-ink wins on cost, battery life, and readability. The trade-off is speed—partial updates at 400ms are acceptable for cycle times of 30 seconds or more. For sub-10-second cycles, consider an OLED or LCD.

Network Security and Isolation

Your PLC is likely on an OT network, while the ESP32 sits on the floor with WiFi. Never connect the ESP32 directly to the plant's IT LAN unless both are properly VLAN-isolated and firewall rules restrict Modbus access to specific IPs. Best practice: put the ESP32 and PLC on a dedicated machine network with a separate SSID, no internet access. The takt display doesn't need external connectivity—only to the PLC and optionally a phone for the target update via a static IP.

Use a fixed IP for the ESP32 (e.g., 192.168.10.100) and restrict the MicroLogix 1100's Modbus/TCP server to that IP only. If your PLC doesn't support IP filtering, enclose both devices in a managed switch with port ACLs.

Why This Qualifies as a Visual SOP

A standard operating procedure for a takt-based cell is worthless if the operator can't see the current state without walking to a terminal. This display puts the SOP calibration—the live comparison of actual vs target—directly in the operator's field of view. It becomes a persistent visual cue that reinforces the standard. No scroll, no click.

When you pair this with a digital work instruction system (like Ryxen's ShopDocs), you can even trigger the instruction sheet to show the expected steps when the display detects the cycle time is running long. That's where the real ROI begins.

Locking in the ROI: Automating the Feedback Loop

A single digital takt counter is a cheap fix. But think about what happens when every station has one: the data stream from each ESP32 can feed a lightweight MQTT broker. Suddenly you have a real-time takt dashboard for the entire line. Now you can spot which station slips first, and trigger an automated alert. You can log historical cycle times to a database. You can calculate OEE per station without a $50k SCADA license.

This is exactly the kind of visual SOP automation that Ryxen's ecosystem is built for. ShopDocs captures the procedures. SafeDesk tracks the compliance. And a $30 e-ink display at each station pulls the trigger. Once you have the live data pipe, the software that locks it in is trivial—one MQTT topic, one webhook, one dashboard.

Don't just build a single display. Build the network. Then let Ryxen's tools turn the data into a continuous improvement engine that runs on its own.

Stop scribbling on whiteboards. Start showing your operators exactly where they stand—every cycle, every shift, at the cost of a sandwich.