Recovering Omron C60K PLC Program from Ladder Printout Backup

Overview: Recovering a Lost C60K Program from Paper

The Omron C-series K-type brick PLCs (C20K, C28K, C40K, C60K) store the user program, retentive data, and holding relay states in volatile CMOS RAM. A single 3 V lithium primary cell maintains that RAM whenever main power is removed. When that cell vents, leaks, or is installed backwards, the electrolyte attack can destroy the CPU board, blow traces, or in the worst case destroy the program along with the EPROM socket and adjacent I/O drivers. Once the plastic-cased lithium pack ruptures, every technician is forced to a paper-only recovery: the printed ladder is the only ground truth, and the used replacement PLC is blank.

This guide consolidates the field-procedure used to rebuild a complete K-series program from a printed ladder diagram, with a PRO15 handheld programming console, an optional SYSMAC LSS or SysWin workstation, and a verified I/O mapping. It is written for the integrator who has the manuals but not the experience, and assumes no prior ladder programming background. The reference document set used throughout is the Omron Programming Instructions and Console Operations Reference Manual (W184-E1-1A), supplemented by the SYSWIN and LSS software help files shipped on the original install media.

C60K Hardware Identification and I/O Map

The C60K sits at the top of the C-series K-type brick family. The trailing digit identifies the total discrete I/O count, so the C60K ships with 60 user-assignable points. By default Omron populated the part as 32 inputs and 28 outputs, addressed across two input words and two output words:

The four highest bits of IR 011 (IR 01112 - IR 01115) are not bonded to physical terminals on a stock C60K; they remain available as internal work relays if the slot is not populated with an expansion. Always confirm the actual mapping on the nameplate of the donor unit, because field replacement units frequently carry custom suffix codes (for example, C60K-CDR-A or C60K-IDR-A) that re-assign input and output polarity, voltage class, and output type (relay vs. transistor).

Two locating features identify a true C60K from a re-labelled C40K or a non-K variant:

1. The peripheral port on the front face uses the C-series 16-pin mini-DIN layout (not the later CPM/CQM peripheral port). The PRO15 snaps directly into this port.
2. The CPU cover carries the K-type legend (CxxK-CPUxx-E) and exposes a CR2032/BR2032-sized holder or, on later masks, a soldered Tadiran TL-5186 lithium pack. Inspect the holder for white crystalline residue; any deposit means the battery has vented and the board must be cleaned with isopropyl alcohol and a soft brush before power is applied.

PRO15 Programming Console Specifications

The Omron PRO15 (C500-PRO15-E or 3G2C5-PRO15-E for the C-series) is the legacy handheld programmer for C-series K-type CPUs. It communicates at 9600 bps over the peripheral port, runs on four AA cells, and contains 16 K of buffer RAM that can be saved to an optional cassette tape via the built-in Mic interface. Key specifications relevant to a paper-recovery effort:

Install four fresh alkaline AA cells in the PRO15 before any session. A weak PRO15 battery will silently corrupt the program as it is being written; a checksum mismatch (PRO15 displays E**) at the end of a transfer is the classic symptom. Do not trust the on-board AA cells as the long-term archive - dump to cassette or write straight into the PLC's HR area and read it back to confirm.

Understanding the Ladder Printout Format

Omron ladder printouts follow a strict column convention. Reading left-to-right the printed column structure is:

1. Address column - the program memory address (00000, 00001, ...). Each rung starts at a fresh address on a multiple of the rung boundary, and continues across multiple addresses for the rung body. C-series rung boundaries are not 32-bit aligned; a rung can begin at any address.
2. Bus bar - two vertical rails drawn as | characters at the left margin of every rung.
3. Logic body - horizontal sequence of contact symbols, block instructions, and coil symbols. Contacts and coils are 2 to 5 character cells wide.
4. Instruction column - shows the mnemonic equivalent of each graphical symbol.
5. Operand column - shows the operand (bit address or constant) immediately to the right of the instruction.
6. Comment column - right-justified free-text comments, rung numbers, or annotation codes.

A typical KEEP rung in the printed body looks like:

        |--S--+---R---|
0000    |     |        |
        | KEEP|        |
        | HR06|        |
        |     |        |
        |     |--<HR06>|  a 00051
        |     |        |
        +-----+--------+

Translation: address 0000 contains the start of a rung whose Set input is wired from the S contact of the KEEP block, and whose Reset input is wired from the R contact. The block operand is HR06 (Holding Relay word 06, with the bit omitted = bit 00). The same HR06 bit is then reused as a NO contact to drive an output coil. The trailing a 00051 is either a rung comment (where a is the comment identifier prefix in Omron's comment-file convention) or a process tag assigned by the original programmer. Comments do not affect execution and can be skipped during manual entry.

For longer rungs that wrap across multiple printed lines (the line 00023 example with twelve numeric tokens following <<c015-c015>>), the wrapped continuation lines remain part of the same logical rung. The <<...>> brackets denote a ladder block-instruction expansion such as a CMP (020), MOV (021), or arithmetic block - the twelve numeric tokens after the close bracket are the block's parameter fields. Always work the rung from the topmost contact down to the rightmost coil; never split a rung across two PRO15 entries.

K-Series Memory Areas and Operand Addressing

The C60K uses the same five-area memory model as the rest of the K-type family. Before entering the first instruction, map every printed operand back to one of these areas so the PRO15 FUN code, bit number, and word number are all entered correctly:

Bit-level operands require both a word number and a bit number (00-15). Word-level operands (used by MOV, CMP, ADD, BIN, BCD, and the timer PV preset) drop the bit number and reference the whole word. The PRO15 inserts the bit number in the third-to-last position of the entry dialog and the word number in the last two digits before SET. Enter operands left-to-right as they appear in the printout; the PRO15 will silently reject an out-of-range word number with ERR on the second line.

Decoding KEEP, TIM, CNT, and Block Instructions

K-series special instructions are the second most common source of entry error (after operand typos). Each block instruction has a fixed FUN (function) number that must be entered before the operand:

For KEEP, the PRO15 entry sequence is: FUN 0 1 1 HR 0 6 followed by SET. The S and R contact branches above the block are entered as ordinary LD/AND/OR branches into the KEEP block symbol. KEEP cannot use IR bits as the latched operand - the function code 011 hard-rejects IR bit numbers because KEEP requires a retentive area to survive power loss.

For TIM and CNT, the first operand is the TC number (0-511 on most K-type CPUs) and the second is the preset value. TIM preset is in tenths of a second (so TIM 000 #0050 equals 5.0 s). CNT preset is a raw integer count. The TC number is shared between TIM and CNT - if TC 000 is already a TIM, it cannot also be a CNT.

Mnemonic Notation: Stack-Based Coding Behind the Ladder

Although the PRO15 supports graphical ladder entry, every block instruction can also be entered as a mnemonic line. The K-series mnemonic language is a stack-based, Reverse-Polish Notation (RPN) encoding, similar in concept to a Forth interpreter or an HP-41C calculator stack:

• LD, LD.NOT, AND, AND.NOT, OR, OR.NOT push the current logic result onto an internal result stack.
• Two-operand instructions such as AND or OR pop two stack entries, perform the Boolean operation, and push the result back.
• Output-class instructions (OUT, OUT.NOT, SET, RSET, TIM, CNT, FUN) pop the top of the stack and route it to a destination.

This RPN structure is why a ladder rung can contain sixteen or more vertical branches that all converge on a single coil: each branch builds the stack independently and the final OUT drains it. When entering a complex rung through the PRO15, do not attempt to convert the ladder to mnemonics unless you are fluent in RPN. Instead, use the PRO15's ladder-mode entry: press LD for the first contact, AND or OR for subsequent, NOT to invert, then the operand, then SET, then cursor-right to advance to the next cell.

Recreating the Program in SYSMAC LSS or SysWin Software

The Ladder Support Software (LSS) for DOS and the Windows-based SysWin (versions 1.x through 3.4) are the two off-line editors that target the C-series K-type CPU. SysWin is recommended where available because it accepts cut-and-paste ladder blocks, exports commented programs to disk, and prints a near-identical match to the original paper printout, which makes verification row-by-row much easier.

SysWin setup procedure for paper-recovery work:

1. Install SysWin from the original 3.5" media. The installer requires the Host Link (RS-232C) driver and at least one COM port.
2. Build the C-series Host Link cable per the manual: COM DB-9 pin 2 (SD) to PLC pin 3 (RD), COM pin 3 (RD) to PLC pin 2 (SD), COM pin 5 (SG) to PLC pin 9 (SG), plus handshake jumpers per W184-E1-1A section 4.
3. In SysWin select File > New Project, choose C-series K-type, device C60K, and CPU type C60K-CPUxx-E matching the donor unit's nameplate.
4. Set the on-line / off-line toggle to Off-line. Manually build each rung in the ladder editor, working from the topmost contact down, in the same order as the printout.
5. After each rung, switch to the Mnemonic view (View > Mnemonic). The mnemonic list is a perfect cross-check against the printout: every LD, AND, OR, OUT, TIM, CNT, and FUN line should appear in the printout's right-hand column.
6. Save the project to disk after every five rungs. Loss of power to the host PC will not damage the PLC, but rebuilding from paper a second time is unacceptable.

Step-by-Step PRO15 Manual Entry Procedure

Use the PRO15 directly when no PC is available or when the printout is short enough (fewer than ~80 rungs) to be entered by hand in a single shift. The PRO15 ladder-mode entry procedure is the fastest path:

1. Connect the PRO15 to the C60K peripheral port. Power the PLC. Watch the PRO15 display settle to <PROGRAM MODE>. If the display shows <RUN MODE>, cycle the PLC mode switch to PROGRAM.
2. Clear PLC RAM: CLR > SET > CLR > MON > SET > PLAY - the PRO15 will confirm with MEMORY CLR. This step is mandatory before any new entry; otherwise remnant instruction fragments at high addresses will execute after END.
3. Place the PRO15 in PROGRAM mode: press and hold CLR, then PROG, then release both. The address counter resets to 00000 and the display shows 00000 READ.
4. For each rung in the printout, starting at rung 0000, enter the leftmost contact with LD (or LD.NOT if the contact is drawn normally-closed), type the operand word and bit, press WRITE.
5. Move the cursor right with the right-arrow key for each subsequent contact or block. Enter AND / AND.NOT / OR / OR.NOT as appropriate, then the operand, then WRITE.
6. When the rung body is complete and you reach the right bus bar, enter OUT (or OUT.NOT, SET, RSET, or the appropriate FUN) for the coil, type the operand, press WRITE.
7. Press FUN, then the two-digit function code (for example 0 1 1 for KEEP), then the operand, then WRITE to enter a block instruction.
8. After the rung is complete, press the down-arrow to advance to the next free address. The PRO15 will auto-renumber the rung on display.
9. After the last rung, enter FUN 0 0 1 (the END function). Without END, the C60K will scan to the highest program address and fault with SR 25503 set.
10. Press PLAY to read the program back from PLC RAM. Scroll every rung and compare against the printout. Any discrepancy is an entry error; clear that rung and re-enter.

Battery Replacement and RAM Preservation Procedure

Because the original C60K failure mode was a ruptured lithium cell, the replacement CPU must be inspected and its battery verified before any program is downloaded. Procedure:

1. Remove AC power from the C60K. Wait 30 seconds for capacitor discharge.
2. Open the CPU cover. Inspect the battery holder for crystalline residue, swelling, or electrolyte staining on the PCB.
3. If residue is present, clean with 99% isopropyl alcohol and a soft ESD-safe brush. Allow to air-dry for 10 minutes.
4. Measure the existing battery voltage at the holder with a DMM. A healthy C-series lithium cell reads 3.0 to 3.4 V. Anything below 2.7 V is end-of-life.
5. Replace the cell only if the replacement unit is currently powered and RAM contents are confirmed good. Reapply power, switch to PROGRAM mode, then hot-swap the battery. Removing a battery on a powered-down C-series K-type clears HR, AR, DM, and TC PV values.
6. Power-cycle the C60K with the new battery installed. Verify the program remains intact by reading the first and last rungs via PRO15 or SysWin. If HR data is part of the recovered program (for example, a recipe or a latched permissive), manually set the bits back to their original states by comparing to operator notes.

Verification, Monitoring, and Commissioning

Paper-recovery projects are validated in three distinct passes. Skipping any pass leaves a defect that will surface during commissioning.

During the dry-run pass, use the PRO15's FORCE SET and FORCE RESET commands to drive each input individually while an observer watches the corresponding output LED on the C60K front face. Document every input-to-output path that lights correctly. Any path that does not light is an entry error in the corresponding rung - clear that rung and re-enter from the printout.

Common entry defects to look for in the dry-run pass:

• Normally-closed contact entered as normally-open (or vice versa). Symptom: load is energized when it should be de-energized, or stuck off.
• HR bit number off-by-one (entered bit 07 where bit 06 was printed). Symptom: KEEP relay latches a different process state than the printout describes.
• TIM preset entered in seconds instead of tenths. Symptom: timer fires ten times faster or ten times slower than the printout.
• END function omitted. Symptom: PLC scans to top of memory and faults; SR 25503 latches ON.
• Branch on a KEEP Reset drawn as a Set, or vice versa. Symptom: latched state never resets on stop command.

Migration Path to CP1E, CP1L, or NJ/NX Series

The C-series K-type brick has been out of production for decades, and surviving spare parts inventories are dwindling. Once the program is recovered and the process is running, plan a migration to a current-generation controller. The functional mapping is straightforward because the K-series instruction set was carried forward with minor renumbering into the CP1E and CP1L, and again into the NJ/NX series via the Sysmac Studio ladder subset:

The most efficient migration path for a working K-series application is to use Sysmac Studio's C-series Conversion Tool (where available), which translates the source ladder and the operand table to a CP1L project in one pass. Manual rewrite is acceptable for programs under 100 rungs but becomes error-prone beyond that. Keep the recovered printout and the SysWin source archive as the long-term reference; they are the documentation that makes any future migration possible without re-deriving the logic from a working machine.

FAQ