Productivity 3000 First Program: Scan, I/O, Seal-In Rung

Skip the Example-Project Hunt

The bench rig in question already works. The P3000 CPU talks to the programming software, a project downloads and runs, and the first discrete output on a P3-08TD2S drives a relay that switches an LED. Digital and analog I/O are wired. The missing piece is how rungs actually execute, meaning the order the controller solves them and why one rung affects the next.

Two quick fixes get tried first. Neither one works.

• Searching for a complete P3000 example program. Very few exist. The platform assumes you already know ladder logic from smaller controllers. You can spend a shift searching and find nothing.
• Reading instruction help pages one at a time. Each page shows a single rung without the rungs before and after it. That explains what the instruction does. It does not explain program flow, because program flow comes from the scan, not from any one instruction.

Ladder logic behaves the same way across platforms. What changes between them is the addressing scheme and the quirks of the software. Build a small program yourself, one rung at a time, and prove each rung before adding the next.

Check before moving on: write the task as a single sentence, such as "If switch A is on, turn on output G." If you cannot write that sentence, you are not ready to write rungs.

Draw the I/O Plan on Paper First

Anyone who reads machine wiring ladder diagrams is most of the way there. Each rung is a circuit: contacts on the left, a coil or instruction on the right, and power flows when the contacts close. Before opening the software, list every point the program will touch.

For each pushbutton, write down whether it is wired normally open or normally closed. You will need this in the seal-in rung.

Check before moving on: every row has a type (real input, real output, or internal bit) and a physical terminal or "memory only" entry.

Separate Real I/O From Internal Bits

Beginners most often get stuck here. A real input or output maps to a screw terminal. An internal bit exists only in CPU memory. You use it to remember a state, pass a condition between rungs, or stand in for hardware you have not wired yet.

Controllers with fixed addressing make the difference easy to see:

The concept carries over to the P3000 even though the names do not. When you drop a contact or coil on a rung, the software needs you to pick an existing I/O point or a memory bit. Choosing an internal bit when you meant the output is the classic "logic is true but nothing happens" fault. The coil energizes in memory and no terminal ever turns on.

Check before moving on: open the project's hardware/I-O configuration. Find the exact name the software gives the first output point on the P3-08TD2S, and do the same for each input you plan to use. Write those names next to the rows in your I/O plan.

Learn the Scan Before Writing Rung Two

Every PLC and PAC runs the same basic loop:

1. Read inputs. The CPU copies the state of every input terminal into memory. Rungs use that snapshot for the rest of the scan.
2. Solve logic. Rungs execute top to bottom. Within a rung, contacts evaluate left to right, and the result writes to the coil or instruction on the right. A later rung sees whatever an earlier rung wrote during the same scan.
3. Write outputs. After the last rung, the CPU copies the output memory to the physical terminals.
4. Housekeeping and communications, then the loop repeats.

Three consequences matter for a first program:

• Rung order matters. If rung 5 sets a bit and rung 2 reads it, rung 2 does not see the change until the next scan.
• One coil, one rung. If two rungs write the same output coil, the last rung in the scan wins. The first rung appears to do nothing, which looks like a dead instruction. It is a double coil. Combine the conditions into one rung with parallel branches.
• Inputs are sampled, not continuous. A pulse shorter than one scan can be missed. This does not matter for pushbuttons. It does matter later for fast signals.

Check before moving on: read the four steps back against your planned rungs. For every internal bit, confirm the rung that writes it sits above the rung that reads it, unless you deliberately want a one-scan delay.

Build Rung 1: Input Drives Output

Start with the simplest possible rung, and use it to prove the whole chain from terminal to terminal.

|----[ Start PB ]------------------------( Output 1 )----|
       (real input, NO contact)           (first DO on P3-08TD2S)

1. Place a normally open contact and assign the real input you wired for the start button.
2. Place an output coil and assign the first output point of the P3-08TD2S. Use the name you recorded, not a new memory bit.
3. Download and put the CPU in run.
4. Go online and monitor the rung.

Check before moving on: press and hold the button. The contact should highlight in the monitor, the coil should highlight, the relay should click, and the LED should light. Release the button and everything drops.

Build Rung 2: Seal-In With an Internal Bit

A momentary button has to turn on an output that stays on. That takes a seal-in, and this rung shows program flow better than any single instruction page. The rung reads its own output from the previous scan.

|----[ Start PB ]----+----[/ Stop PB ]----------( Run Memory )----|
|                    |
|----[ Run Memory ]--+

|----[ Run Memory ]------------------------------( Output 1 )-----|

The names above are example names you create. Run Memory is an internal bit.

1. Delete or disable rung 1 so Output 1 has only one writer.
2. Create the internal bit for run memory.
3. Build the seal-in rung. The start contact goes in parallel with a contact of the run bit itself, and both go in series with the stop contact.
4. Pick the stop contact type from the wiring, not from the button label:
   • For a normally open stop button, use a normally closed (examine-if-off) contact.
   • For a normally closed stop button, which is the usual fail-safe practice, the input is on at rest. Use a normally open (examine-if-on) contact. A broken stop wire then drops the output instead of making it unstoppable.
5. Drive the physical output from the run bit in its own rung, below the seal-in rung.

Here is how it executes, scan by scan. Pressing start makes the parallel branch true, and the run bit turns on. On the next scan the run bit's own contact holds the branch true after you release start. Opening the stop condition breaks the series path, the bit drops, and the seal contact opens with it.

Check before moving on: tap start, and the LED stays on. Tap stop, and the LED goes off and stays off. Hold stop and tap start, and nothing happens, because stop has priority. If the LED only lights while the stop button is pressed, the stop contact type is inverted for your wiring.

Build Rung 3: Add a Timer and an Analog Compare

A timer and a compare add two new behaviors: an instruction that keeps state across scans, and one that works on a number instead of a bit.

1. Timer. Insert an on-delay timer between the run bit and the output, so the LED lights a set time after start. Take the timer instruction from the software's instruction list. Read its help page for the preset units and for which bit indicates "done". Drive Output 1 from that done bit, and remove the old run-bit-to-output rung so there is still only one writer.
2. Analog compare. Add a compare instruction that reads your configured analog input channel and sets an internal bit above a threshold you choose. Put that bit in series in the output rung as an interlock.

The timer accumulates only while its rung is true, and it updates once per scan. If the rung goes false before the preset, the timer resets. This is why the rungs leading into an instruction matter as much as the instruction itself.

Check before moving on: watch the timer's accumulated value count in the monitor. The output should turn on only when it reaches the preset. Then vary the analog signal across your threshold and confirm the interlock bit toggles and blocks the output. After that, the PID video training is the logical next step for the analog I/O.

Verify the Whole Program and Keep Learning

Run the full sequence cold:

1. Power-cycle the rack, then confirm the CPU returns to run and the output starts off.
2. Start, then observe the timer delay, then the output on.
3. Stop, and confirm the output goes off immediately.
4. Start with the analog signal below threshold, and confirm the output stays off.
5. Pull the stop input wire (if the stop button is wired NC), and confirm the output drops.
6. Search the project for every output point, and confirm each has exactly one coil.

Every instruction is documented in the programming software's help files, and the user manual covers the CPU and modules. Both are available from the P3000 CPU product page along with the software. AutomationDirect also offers online video training and a Learn site with Productivity 3000 videos. For more rung-by-rung practice, load the DirectSOFT 5 or Click programming software and work through AutomationDirect's published example programs. The ladder concepts transfer directly. Only the addressing differs.

FAQ