Click the blue text to follow!

Motion Control Algorithm Method Based on Instruction List for PLC

A few days ago, Xiao Zhang rushed to find me: “Master Li, the automatic feeder on production line three is stuck again, the servo motor is sometimes fast and sometimes slow, and the materials are misaligned!” I sighed, this is already the third time this month. Taking my toolbox, I asked while walking: “Did you change programmers?” Xiao Zhang nodded: “A newcomer came last week, said he has a formal education.” I smiled: “Book knowledge is good, but the machines in the workshop don’t recognize degrees, let’s go take a look.”

After checking the equipment, I found the problem was with the PLC motion control algorithm. This ‘formally educated’ young man used complex function blocks, which instead complicated a simple problem. Sometimes, solving practical issues doesn’t require fancy tricks, the simple algorithm based on instruction list is the practical treasure for factory automation.

The Instruction List (IL) is the foundational language for PLC programming, although it may not seem as intuitive as ladder diagrams, it is clearer when dealing with complex motion control. I remember when I first started, a senior technician taught me: “Xiao Li, ladder diagrams are easy to understand, but for precise control, you need to rely on the instruction list.” This advice has served me well to this day.

Let’s look at a practical example. The feeder needs to complete an S-shaped acceleration and deceleration curve, which would be lengthy and cumbersome in ladder diagram, but is much more concise in instruction list:

LD     Speed_Target   // Load target speed

SUB    Speed_Current  // Subtract current speed

MUL    Accel_Factor   // Multiply by acceleration factor

ST     Delta_Speed    // Store speed change

This code calculates the speed difference multiplied by the acceleration factor to determine the speed increment for the next moment. I asked Xiao Zhang: “Do you understand?” He scratched his head: “I think I get it a bit.”

Motion control is essentially a process of continuously calculating position, speed, and acceleration. I often tell newcomers, controlling a motor with PLC is like driving a car, you can’t just slam the gas pedal down, nor can you brake suddenly; you need to accelerate and decelerate smoothly. Here’s the position update algorithm written in instruction list:

LD     Speed_Current  // Load current speed

ADD    Delta_Speed    // Add speed change

LIMIT  0, Max_Speed   // Limit to maximum speed range

ST     Speed_Current  // Update current speed

MUL    Time_Interval  // Multiply by sampling time interval

ADD    Position       // Add to current position

ST     Position       // Update position

This is a typical Euler integration method, calculating the position increment by multiplying speed by time. Position closed-loop control is key to ensuring the motor reaches its target position accurately. Once, I went to help a printing factory adjust their machines; their registration was always misaligned because they hadn’t implemented proper position closed-loop control.

That day, while solving the feeder issue, I added a simple PID controller in the program, implemented in instruction list:

LD     Position_Target   // Target position

SUB    Position_Current  // Subtract current position

ST     Position_Error    // Position error

MUL    Kp                // Proportional coefficient

ST     P_Term            // Proportional term

Then I told Xiao Zhang: “This Kp is the proportional coefficient; increasing it makes the response faster but can lead to overshoot, while decreasing it stabilizes but slows the response. The technicians in the workshop adjust PID parameters based on experience.”

I continued: “What is the essence of motion control? It is prediction and compensation. Just like driving, you need to anticipate the road conditions ahead. In PLC, this means calculating feedforward control quantities to proactively respond to load changes.

In practical work, don’t complicate simple problems. Sometimes, just a few lines of instruction list code can solve seemingly complex motion control issues. New programmers like to use various fancy function blocks, unaware that those blocks internally also use these basic algorithms.

After resolving the feeder issue, I patted Xiao Zhang on the shoulder: “Go back and tell your new programmer, if a problem can be solved with ten lines of code, don’t write a hundred lines. Next time you come to me, I’ll teach you how to adjust PID parameters.”

In the industrial field, stable operation of equipment is paramount. Mastering motion control algorithms based on instruction lists can not only solve most on-site problems but also deepen your understanding of PLC control. Remember: first understand the principles of basic algorithms, then use those advanced function blocks; that is the right path.