Programming Traffic Lights on Omron CJ1M: Compare and Timer Logic

Overview: Traffic Light Sequencing on the CJ1M

A traffic-light intersection is one of the canonical training problems for any PLC platform because it forces the programmer to combine three fundamental concepts: timed sequencing (when does each phase end?), logical comparison (which phase am I in now?), and output interlocks (only one direction of green may ever be on at a time). This article walks through a complete, two-crossroad implementation on the Omron CJ1M family of compact modular PLCs, focusing on the techniques most often asked about by first-time programmers:

• How to drive outputs from TIM/TIMX timer contacts without leaving lamps latched on at power-up.
• How to use the CMP instruction and the IEC-style comparison contacts (=, <, >) as a clean state-machine driver.
• How to read the built-in real-time clock on the CJ1M for schedules that must follow wall-clock time.
• How to coordinate two independent intersections with different phase lengths.

The reference ladder is written in CX-Programmer notation. Any CJ1M CPU from the CJ1M-CPU11/12/13 (low-end, 5K-step program capacity) up to the CJ1M-CPU21/22/23 (high-end, up to 20K steps, built-in Ethernet/IP on the CPU22/23) is sufficient. The logic uses only standard instruction set features so it ports to the CP1, CP1E, and CS1 platforms with almost no changes.

Hardware Reference: CJ1M Platform Summary

Before writing code, anchor the memory model so every operand used later is unambiguous. The relevant facts for the CJ1M series are summarized in the table below (from the CJ1M Catalog (CSM_4919) and the W472 CJ1M CPU Unit Operation Manual):

The ladder examples below use these default area conventions (override per project):

• Inputs: 0.00 = Start PB, 0.01 = Stop PB, 0.02 = Manual/auto selector.
• Outputs: 100.00 = X-dir red 1, 100.01 = X-dir yellow 1, 100.02 = X-dir green 1; 100.03 = Y-dir red 1, 100.04 = Y-dir yellow 1, 100.05 = Y-dir green 1. The second crossroad uses 101.00-101.05.
• Working bits: W0.00-W0.03 = state bits; W1.00-W1.01 = phase-done flags.
• Timers: T0000-T0011.

Phase Model and Timing Requirements

The original specification uses two intersections with different cycle lengths. The cleanest implementation treats each intersection as an independent state machine and synchronizes them only through their phase boundaries, not through a shared clock. The required phase lengths are:

Both intersections happen to have a 60-second cycle, which is convenient: one P_1s clock pulse from A200.06 plus a single ring counter lets every timer compare against the same elapsed-time word. If you scale to a 90-second or 120-second cycle later, only the comparison constants change.

Root Cause of the "All Yellow and Red On At Power-Up" Fault

The most common mistake with a first ladder is leaving output coils energized by their own contact. Look at this classic anti-pattern, which is exactly what produces the symptom described in the source post:

|  START_PB  T0000_done   RED_LAMP_1 |
|--| |------| / |---------( )--------|
|                                  |
|  RED_LAMP_1                     |
|--| |----------------------------|

If the rung is scanned before the timer has been started (or if the timer is never started), the normally-closed T0000_done contact passes power, the lamp energizes, and on the next scan its own contact seals it in. The lamp is now permanently on until a Stop button breaks the seal-in path. When you write a program that intentionally relies on seal-in, you must also write an explicit off-rung. The fix is to never latch an output coil with its own contact; instead, drive every lamp from a comparison that is true only during its intended phase window.

A second common cause is PLC power-up with the outputs in their last state. By default, CJ1M outputs hold their previous state on power loss unless the IOM Hold Bit (A500.12) is cleared. After a brief power blip, the start rung was never re-triggered but the previous outputs are still there. Either reset outputs on first scan (use P_First_Cycle, A200.11) or, better, drive every output from a stateless comparison so the initial condition is meaningless.

Two Implementation Styles: Direct Ladder Compare vs. CMP Instruction

The source post specifically asked for guidance comparing the two common Omron ways to express "is the current time inside this phase?":

Style A: Direct comparison contacts (IEC 61131-3 style in CX-Programmer)

CX-Programmer 9.x and later lets you place =, <>, <, <=, >, >= contacts directly on the bus. These compile to CMP(020) under the hood but are far easier to read:

|    P_1s     |
|--| |--------|          ; A200.06 1-second pulse
|    C0,0 ---| |
|    (CNT 0  SV=60)       ; ring counter, 0 to 59
|   elapsed_time = C0 PV

|    elapsed_time >= 0   elapsed_time < 20   X_GREEN_1 |
|--|-------------------|-------------------( )---------|

|    elapsed_time >= 20  elapsed_time < 30   X_YELLOW_1 |
|--|-------------------|-------------------( )----------|

|    elapsed_time >= 30  elapsed_time < 60   X_RED_1 |
|--|-------------------|-------------------( )--------|

The Y-direction lamps use identical rungs with the offset added. Because the three phase rungs are mutually exclusive (their comparison windows never overlap), no interlock rung is required - the comparison itself guarantees only one lamp is on at a time.

Style B: CMP(020) instruction with result flags

The classic Omron way is to call CMP(020) once per cycle and read its result from the auxiliary area:

|  ALWAYS_ON       |
|--| |--------------|
|                  CMP(020)         ; Instruction
|                  S1 = elapsed_time
|                  S2 = 20
|                  ; Result flags:
|                  ;   P_GT  = A200.05 if S1>S2
|                  ;   P_EQ  = A200.06 if S1=S2
|                  ;   P_LT  = A200.07 if S1<S2

|  P_LT_flag  X_GREEN_1  |
|--| |---------( )--------|

CMP(020) is destructive - it overwrites the three flags every scan. Save the flags into work bits if you need them later in the cycle. The IEC contacts in Style A do this automatically; the legacy form requires you to add latches or use the @ differentiation suffix.

Style C: State machine with single integer register

For intersections beyond a single set of three lamps, the state-machine approach scales much better. Encode each phase as a number, drive an integer state_word, and use one compare per output:

|  state_word = 0  |    ; On entry to all-red state, start timer
|  T0000 |
|--| |------------|----(TON T0000, SV=30)----|  ; 30 * 0.1s = 3 s

|  T0000_done  state_word := 1 |
|--| |----------|----(MOV #1 state_word)----|

This is the approach recommended by the senior-programmer comment in the source thread - the state is the truth of the system, not the timer contacts. Compare the state, not the time.

Building the 1-Second Tick and the Elapsed-Time Counter

Every ladder above depends on a clean 1-second pulse. The CJ1M generates this from auxiliary bit A200.06 (P_1s). To convert that pulse into elapsed seconds for the comparison, use a reversible counter as a 0-59 ring:

|  P_1s    C0,0 (reset coil)|
|--| |----| >|---| |-------(RES)-------|
|                              |
|  P_1s    C0,0 (count up)    |
|--| |----| <|----------------(CNT 0, SV=60)|
|                              |
|  C0 PV --> elapsed_time (W2)|
|--| |----|MOV(021) C0 PV W2|--|

When the counter reaches 60, the reset coil fires from the >= contact and the counter rolls back to zero on the next count pulse. W2 now contains a value that grows 0, 1, 2, ... 59, 0, 1, ... and is exactly the elapsed-time register every comparison references.

Two-Crossroad Coordination

The two intersections have different phase lengths but both run a 60-second cycle. They are coordinated by offsetting the second counter's reset phase:

|  P_1s                            |
|--| |----------------------------|
|  C1,0 (reset)                   |
|--|>|------------------(RES)----|  ; Reset C1 when PV hits 60
|  C1,0 (count)                   |
|--|<|------------------(CNT 1, SV=60)|
|                                  |
|  C1 PV --> elapsed_time_2 (W3)  |
|--| |----(MOV C1_PV W3)--------|

Use the second intersection's elapsed time W3 with its own comparison constants:

|  W3 >= 0   W3 < 35   H2_GREEN  |
|--|---------|---------( )--------|
|  W3 >= 35  W3 < 40   H2_YELLOW |
|--|---------|---------( )---------|
|  W3 >= 40  W3 < 60   H2_RED    |
|--|---------|---------( )---------|

If you need crossroad 2 to start 30 seconds after crossroad 1 (a common real-traffic requirement), preload counter C1 with 30 instead of 0 at start:

|  P_First_Cycle |
|--| |-----------|
|  C1 SV := 60 - 30  ; = 30, so first reset happens after 30 ticks
|--(MOV #30 C1_SV)--|

Use CX-Programmer's counter preset edit (see W446 CX-Programmer Operation Manual) to view and modify the SV on-line.

Adding Real-Time Clock Functionality

The source author specifically asked about using the real-time clock on the CJ1M. The CJ1M CPU has a battery-backed clock accessed through the AR area and special instructions. The relevant addresses (per the W342 CS/CJ Series Programming Reference Manual) are:

For a traffic-light application the most useful operations are:

Reading the current hour for night mode

|  ALWAYS_ON              |
|--| |--------------------|
|  READ(007) C1 --> D100 |
|--(BCD_TO_BIN D100 W10)--|  ; Hour, minute, second packed in D100
|                          |
|  W10 >= 22              |  ; 22:00 - 06:00 = night flash
|  W10 < 6     W12_night |
|--|-----------|--------( )---|

Scheduling a "school zone" flash

|  W10 = 7    W11_flash  |
|--|----|-----( )---------|
|  W10 = 8    W11_flash  |
|--|----|-----( )---------|

Where W11_flash becomes the override that forces the yellow lamps to blink at 0.5 s intervals using P_0_5s from A200.08:

|  W11_flash   P_0_5s    X_YELLOW_1  |
|--|---------|---------|----( )--------|

Date arithmetic (e.g. "skip the schedule on holidays") is done with the CADD(730) and CSUB(731) instructions. The W472 manual describes these in detail.

Step-by-Step Commissioning Procedure

1. Create the CX-Programmer project. File → New, select Device Type = CJ1M-H, CPU type matching your hardware. CX-Programmer 9.65 or later supports the latest CJ1M firmware.
2. Configure the I/O table offline (or online with auto-detect). The CJ1M-CPU12/13/22/23 has 10 built-in inputs and 6 built-in outputs at fixed addresses CIO 0 and CIO 100 respectively.
3. Set the PLC's clock. Use CX-Programmer → PLC → Clock → Set, or send the @SET(049) values from the HMI.
4. Download and switch to Monitor mode. The CJ1M will go into Program mode briefly, then run.
5. Force W0.00 (start) and observe outputs. Confirm only one green, one yellow, or one red lamp per direction is on at any moment, and that no lamp stays on across phase boundaries.
6. Verify the timing. Use CX-Programmer's Data Trace (Alt+F7) or the CJ1M's built-in trace buffer to capture the first 60 seconds. Confirm each phase lasts exactly the programmed duration.
7. Test the stop button. Confirm all outputs drop within one scan when stop is pressed, regardless of which phase the PLC is in.
8. Power-cycle the PLC. Confirm outputs come up in a defined state (recommended: all red for 3 s) and never stuck on.

Verification: Signals to Confirm Correct Operation

Troubleshooting Matrix

Porting Notes: From CJ1M to CP1E / CP1L / NX

The same patterns work on every modern Omron platform. Key differences:

• CP1E: No P_1s in the same place - it is at A200.06 on CP1E-N as well, but confirm in the W516 CP1E CPU Unit Operation Manual. IEC comparison contacts are supported.
• CP1L: Adds built-in Ethernet on M-type CPUs. The state-machine pattern ports unchanged.
• NJ/NX series (Sysmac Studio): Move from ladder to Structured Text (ST). A CASE statement on the state variable replaces all the comparison contacts:

CASE state_word OF
  0: X_LAMP := RED;   Y_LAMP := RED;   T#3s_timer(IN:=TRUE, PT:=T#3s);
  1: X_LAMP := GREEN; Y_LAMP := RED;   T#20s_timer(IN:=TRUE, PT:=T#20s);
  2: X_LAMP := YELLOW;Y_LAMP := RED;   T#10s_timer(IN:=TRUE, PT:=T#10s);
  3: X_LAMP := RED;   Y_LAMP := GREEN; T#20s_timer(IN:=TRUE, PT:=T#20s);
  4: X_LAMP := RED;   Y_LAMP := YELLOW;T#10s_timer(IN:=TRUE, PT:=T#10s);
END_CASE;

The Sysmac NJ101-1000 has the same state-machine idiom but the timers are IEC 61131-3 objects instead of TIM/TIMX instructions. The W500 Sysmac NJ-series CPU Unit Software User's Manual documents the conversion.

Common Pitfalls and Field-Validated Caveats

• Don't use the SET/RESET instruction for traffic-light outputs. It is tempting because each lamp is essentially a bistate, but a SET is sticky - it survives the condition that set it and only clears on a matching RESET. If the comparison ever fails to reset for any reason (programming error, communication glitch, watchdog), the lamp stays on indefinitely. The latched-coil failure mode is exactly the symptom described in the source post.
• Avoid more than one coil per output bit. If two rungs write to 100.02, the last rung in the scan wins. This is the most common cause of "I added a fault indicator and now my green lamp flashes." Use OUT once, in the comparison rung, and never anywhere else.
• Do not feed the timer's own contact back into its start. This is the classic "the timer never resets" trap. If the timer's done bit drives a coil that is on the same rung as the timer's start, the rung oscillates.
• Watch the scan time when adding a second crossroad. The CJ1M-CPU11 in particular has a scan time around 0.7 ms for 1 K steps. Adding the second intersection's logic and clock arithmetic can push it past 2 ms, which is still fine for traffic lights but starts to be noticeable on a 0.5 s night flash. Profile with CX-Programmer → PLC → Scan Time.
• Use a retentive timer (TIML or PV-retentive TIMX) only if you genuinely want the timer to survive a power loss. For a traffic light, you almost always want the timer to reset on power-up - the program should re-establish its starting condition, not resume mid-phase.

Recommended CX-Programmer Project Layout

1. Section 0 - Initialization: First-scan reset, clock read, default state.
2. Section 1 - Clock & counters: P_1s driver, C0 ring counter, C1 second-intersection counter.
3. Section 2 - Intersection 1 outputs: six rungs, one per lamp, comparison-driven.
4. Section 3 - Intersection 2 outputs: six more rungs with offset constants.
5. Section 4 - Schedule overrides: night mode, school zone, manual flash.
6. Section 5 - Diagnostics: lamp-on-too-long alarm, conflict alarm, deadman timer.

This layout maps directly to the Tasks/Programs structure on the CJ1M. Use Task 0: Cyclic Task, every 10 ms for sections 0-5; the entire program fits in the standard cyclic task and runs every scan.

Further Optimization with High-Speed Counter

If the intersection needs to react to vehicle detection (induction loops, radar, push-buttons for pedestrians), the CJ1M-CPU21+ has built-in high-speed counter inputs on 0.00-0.03. Use PRV(881) to read the count at a fixed interval and add a "green extension" phase: if a vehicle is detected during the last 5 s of green, do not transition to yellow yet. The pattern is identical to the basic state machine, with one extra state added before the yellow phase.

FAQ