Your PLC programs have handled basic on/off logic with ease. Now it's time to make them smarter. Real-world automation requires more than just opening and closing circuits; it needs to count, calculate, and manage data. This is where mathematical and data handling instructions come in.

Let's start with math. Most PLC instruction sets include ADD, SUB, MUL, and DIV blocks. These function just as you'd expect, taking values from two source registers, performing the operation, and storing the result in a destination register. For instance, you could use an ADD instruction to keep a running total of parts produced or a DIV instruction to calculate the average temperature from multiple sensors.

Beyond basic arithmetic, COMPUTE (or CPT) instructions allow for more complex algebraic expressions in a single rung. Instead of chaining multiple ADD and MUL instructions, you can write an expression like (SensorA * 1.5) + Offset_Value and have the result placed directly into a destination tag. This cleans up your logic and makes it easier to read.

Manipulating data is just as important as calculating it. The most fundamental data handling instruction is the Move (MOV) instruction. Its job is simple: copy a value from a source to a destination. You might use it to load a preset value into a timer's accumulator or to save a machine's current state to a holding register before shutdown.

When you need to move more than a single value, the Copy (COP) instruction is the tool for the job. It copies a block of contiguous memory, like an entire array or a user-defined data type, from one location to another. Think of it as a bulk MOV. If you have an array that holds the 20 steps of a recipe, you can use COP to copy that entire recipe into a working 'active recipe' array when a new batch starts.

As programs grow, a single, long ladder logic routine becomes unmanageable. Just as in other programming languages, you can break your logic into smaller, reusable pieces called subroutines. The Jump to Subroutine (JSR) instruction is your tool for this.

When the PLC scan encounters a JSR instruction on a true rung, it temporarily pauses execution of the main routine, jumps to the specified subroutine file, and executes all the logic within it. Once the subroutine is complete, the scan returns to the rung immediately following the JSR call. This is perfect for organizing code that performs a specific, repeated task, like managing a single motor or running a fault-checking sequence.

Another crucial concept is initialization. What happens the very first time the PLC powers up or switches into Run mode? The First Scan (S:FS) bit helps manage this. This is an internal status bit that is true for exactly one scan cycle when the PLC starts. You can use this bit to trigger rungs that initialize your system, such as clearing fault codes, moving all servo motors to a home position, or setting initial recipe values. This ensures your machine always starts in a known, safe state.

So far, we've dealt with direct addressing, where you explicitly name the tag you want to access, like Timer1.ACC or Motor_Speed. But what if you don't know the exact address at programming time? This is where indirect addressing comes in. Indirect addressing allows you to use the value of one register as a pointer to the address of another. For example, you can access an element in an array by using a counter's value as the array index. If a register Pointer holds the value 5, then My_Array[Pointer] would access the sixth element (My_Array[5]) of the array. As you increment Pointer, you can step through the entire array, performing the same operation on each element. This is incredibly powerful for looping and batch operations.

Indexed addressing is a form of indirect addressing often used with arrays. It combines a base address (the name of the array) with an offset (the index). This makes your code scalable. If you add more machines to your production line, you don't need to write new logic; you just need to expand the size of your arrays and adjust the loop's limit.

By mastering these advanced structures, you move from simply turning things on and off to orchestrating complex, data-driven industrial processes with efficient, scalable, and maintainable code.