In my work on industrial robots, I have repeatedly observed that trajectory planning and dynamic analysis are often treated as separate stages. A trajectory is typically generated in an external environment, converted into joint or Cartesian data, and only then imported into a multibody dynamics package for validation. This separation limits real-time interaction, weakens the connection between planning and continuous dynamic response, and makes it difficult to evaluate industrial robots under realistic motion conditions. I therefore developed an instruction-mode trajectory planning system inside ADAMS. The system allows industrial robots to be programmed with high-level motion instructions, generates smooth Cartesian trajectories directly in the virtual environment, and solves inverse kinematics through general motion functions. The result is a tighter integration of planning, simulation, and dynamic analysis for industrial robots.
The central idea of my method is to treat ADAMS not only as a dynamics solver but also as a trajectory planning environment. By using secondary development capabilities, I created a user-facing toolbar, a trajectory planning dialog, and a set of motion functions that mimic industrial robot programming instructions. The motion instructions MoveL and MoveC are implemented through ADAMS general motion functions. A smoothing coefficient is introduced to shape acceleration and deceleration phases, and the resulting trajectories are evaluated through joint angle displacement, joint angular acceleration, and Cartesian error. Simulation experiments on a six-axis industrial robot show that the proposed system produces smooth, continuous, and accurate motion, meeting the requirements of industrial robots for precision and stability.
Motivation and Problem Statement
Industrial robots are widely used in manufacturing because they combine repeatability, speed, and flexibility. However, their performance depends strongly on trajectory planning. A poorly planned trajectory can cause vibration, excessive joint torque, wear, and reduced accuracy. Dynamic characteristics such as inertia, payload, friction, and compliance must be considered during trajectory generation, not after it. When planning and dynamics are decoupled, the resulting motion may satisfy kinematic constraints but violate dynamic limits. This is especially problematic for industrial robots that operate at high speed or carry heavy end-effectors.
Existing approaches often follow a sequential workflow. A trajectory is first planned in a mathematical environment, such as MATLAB, or obtained from external sensors and teaching devices. The trajectory is then exported as position, velocity, or acceleration data and imported into ADAMS for dynamic simulation. Although this workflow can validate a predefined path, it does not allow the trajectory to be modified interactively during simulation. It also makes continuous dynamic analysis difficult because the trajectory is fixed before the dynamic solver runs. For industrial robots, this limitation reduces the value of simulation in iterative design, control tuning, and offline programming.
I address these issues by moving trajectory planning into ADAMS and by expressing robot motion through instructions. The instructions are not simple joint-space profiles; they are Cartesian-space motion commands that are converted into general motion functions. This design preserves the programming logic of industrial robots while exploiting the dynamic solver of ADAMS. The following table summarizes the main limitations I identified and the corresponding solutions I implemented.
| Limitation in existing trajectory planning | Observed consequence for industrial robots | My response |
|---|---|---|
| Insufficient real-time interactivity | Trajectories cannot be adjusted during simulation, so iterative studies require repeated export and import. | Instruction-mode planning inside ADAMS with dialog-driven parameter changes. |
| Disconnection between planning and dynamics | Kinematic feasibility is checked separately from dynamic response, hiding torque and acceleration peaks. | General motion functions coupled directly to the ADAMS solver. |
| Manual inverse kinematics | Derivation is time-consuming and error-prone for six-axis industrial robots. | ADAMS inverse kinematics is used through general motion and marker constraints. |
| Poor smoothness at segment transitions | Acceleration jumps cause vibration, wear, and path deviation. | A smoothing coefficient and C2-continuous STEP functions are applied. |
| Limited reuse of programming knowledge | Simulation models do not resemble actual robot programs. | MoveL and MoveC instructions are developed as reusable motion functions. |
System Architecture and Functional Design
I designed the trajectory planning system as a layered architecture so that data, modeling methods, development tools, application functions, and user interaction remain clearly separated. This structure makes the system extensible and allows industrial robots of different configurations to be supported without rewriting the entire planning logic. The layers are data, technical support, development, application, and user. Each layer has a specific responsibility, and together they form a complete environment for instruction-based trajectory planning.
The data layer supplies three-dimensional models, kinematic parameters, dynamic parameters, and knowledge models. The technical support layer provides the digital twin model, the data model, and the motion function implementation inside ADAMS. The development layer contains the secondary development tools that extend ADAMS, including scripting, API access, and interface customization. The application layer uses ADAMS dynamics capabilities to perform trajectory planning, inverse kinematics solving, and dynamic analysis. The user layer provides a toolbar, dialog boxes, and post-processing views so that a user can define trajectories and observe the response of industrial robots.
The architecture is intentionally centered on instructions rather than raw joint values. In actual industrial robots, a program is usually composed of motion instructions such as linear moves, circular moves, and point-to-point moves. By reproducing this instruction style in ADAMS, I ensure that the simulation model reflects the same planning logic used by robot controllers. This is important because the dynamic response of industrial robots depends not only on the geometric path but also on how the path is parameterized in time. Acceleration, deceleration, cornering, and blending are all influenced by the instruction type.
| Layer | Main content | Function in the system |
|---|---|---|
| Data layer | 3D models, kinematic parameters, dynamic parameters, knowledge models | Provides the physical and informational basis for industrial robots. |
| Technical support layer | Digital twin model, data model, motion function methods | Defines how trajectories are generated and how the virtual model behaves. |
| Development layer | Scripting, API interfaces, interface customization | Extends ADAMS and connects user inputs to solver commands. |
| Application layer | Trajectory planning, inverse kinematics, dynamic simulation | Executes the planning and analysis tasks for industrial robots. |
| User layer | Toolbar, dialogs, visualization, post-processing | Allows users to define targets, speeds, accelerations, and tool frames. |
System Development and Working Principle
ADAMS offers several secondary development methods, and I combined them according to the needs of industrial robot trajectory planning. Scripting development is the most direct approach. It uses built-in commands, often called ACLI commands, or Python scripts to automate model creation, modify motion functions, and run simulations. API development provides deeper access to the software when custom physical models or high-performance computation are required. Interface customization does not extend the solver directly, but it packages scripts and API calls into user-friendly menus, buttons, and dialogs. For my system, interface customization is the main entry point, while scripting performs the actual motion function updates.
| Development method | Typical use | Advantage | Limitation |
|---|---|---|---|
| Scripting development | Automating commands, creating motion functions, running simulations | Simple, fast, and well suited to repeated tasks. | Cannot easily implement complex custom physics. |
| API development | Custom models, advanced computation, deep integration | High flexibility and access to lower-level functions. | Requires more programming effort and knowledge. |
| Interface customization | Menus, toolbars, dialogs, user workflows | Reduces complexity for users and standardizes input. | Does not provide new solver capabilities by itself. |
The working principle of the system is a sequence of user interaction and solver execution. The user starts from a custom toolbar that acts as the main entry point. The toolbar loads a trajectory planning dialog. The dialog collects target points, speed, acceleration, tool frame, and other planning parameters. These parameters are passed to ADAMS design functions or runtime functions. The system then constructs or modifies general motion functions for the tool center point. The ADAMS dynamic solver executes the simulation, and the post-processor displays the resulting motion, joint angles, joint accelerations, and Cartesian errors. This loop can be repeated without leaving ADAMS, which gives the method its real-time interactive character.
The toolbar and dialog are not mere conveniences. They enforce a consistent data flow and reduce the chance of syntax errors in motion functions. For industrial robots, where many trajectories must be tested during design and commissioning, this consistency is valuable. The dialog can be extended to include blending parameters, user-defined coordinate frames, and safety limits. The motion functions themselves are generated from the instruction type, so the user works with concepts that are familiar in robot programming rather than with raw ADAMS function expressions.
Motion Function Design for Industrial Robots
The motion function design is the core of my system. I separate the problem into cooperative logic, straight-line motion, circular motion, and smoothing. Cooperative logic determines how the tool center point is controlled. Straight-line and circular motion define the geometric path. Smoothing shapes the velocity and acceleration profiles. Together, these elements allow industrial robots to be planned and simulated with realistic motion behavior.
Cooperative Logic of General Motion and STEP Functions
In ADAMS, motion can be defined as joint motion or general motion. Joint motion applies a function directly to a joint and therefore requires inverse kinematics to be solved before or by the solver. General motion applies a function to a marker or a body in Cartesian space. I chose general motion because the upper-level trajectory planning of industrial robots is usually performed in Cartesian space. The controller ultimately maps the Cartesian path to joint motion, but the programming interface and the geometric specification are Cartesian. General motion in ADAMS follows the same logic, so the simulation is closer to the actual behavior of industrial robots.
| Aspect | Joint motion | General motion |
|---|---|---|
| Control space | Joint space | Cartesian space |
| Input form | Joint angle, velocity, or acceleration functions | Tool center point position, velocity, or acceleration functions |
| Inverse kinematics | Required before motion definition or solved internally | Handled by ADAMS when the marker motion is applied |
| Practical resemblance to industrial robots | Lower for task-level programming | Higher for Cartesian trajectory planning |
| Real-time modification | Possible but less intuitive | Direct and intuitive through marker functions |
Smooth motion requires continuity not only in position but also in velocity and acceleration. The STEP function in ADAMS is based on cubic Hermite interpolation. It provides continuous first and second derivatives inside the interval and zero derivatives at the endpoints. This satisfies the C2 continuity requirement for robot motion and avoids the abrupt acceleration changes that cause rigid impact. I use STEP functions to shape each motion segment. When higher smoothness is required, I replace the cubic STEP with STEP5, which is a quintic polynomial with continuous second derivatives and additional control over jerk-like behavior.
The cubic STEP function can be written as follows. For an independent variable t between t0 and t1, the function transitions from y0 to y1:
$$ \text{STEP}(t,t_0,y_0,t_1,y_1) = y_0 + (y_1-y_0)\left(3\left(\frac{t-t_0}{t_1-t_0}\right)^2 – 2\left(\frac{t-t_0}{t_1-t_0}\right)^3\right) $$
For applications where acceleration continuity is especially important, I use the quintic form:
$$ \text{STEP5}(t,t_0,y_0,t_1,y_1) = y_0 + (y_1-y_0)\left(10\left(\frac{t-t_0}{t_1-t_0}\right)^3 – 15\left(\frac{t-t_0}{t_1-t_0}\right)^4 + 6\left(\frac{t-t_0}{t_1-t_0}\right)^5\right) $$
These functions are applied independently to the three Cartesian coordinates of the tool center point. The path is therefore not a simple interpolation of joint angles; it is a coordinated Cartesian motion. ADAMS then solves the inverse kinematics for the industrial robot and computes the joint trajectories. This is a key advantage because the user does not need to derive closed-form inverse kinematic equations for each robot configuration.
Straight-Line Motion Function
The straight-line motion function, which I associate with the instruction MoveL, moves the tool center point from a start point A to a target point B along a straight line. Let the start point be
$$ A = (x_i, y_i, z_i) $$
and the target point be
$$ B = (x_j, y_j, z_j) $$
The distance between the two points is
$$ D = \sqrt{(x_j-x_i)^2 + (y_j-y_i)^2 + (z_j-z_i)^2} $$
The unit direction vector from A to B is
$$ \mathbf{u} = (u_x,u_y,u_z) = \left( \frac{x_j-x_i}{D}, \frac{y_j-y_i}{D}, \frac{z_j-z_i}{D} \right) $$
If the scalar speed profile along the line is v(t), then the velocity components of the tool center point are
$$ v_x(t) = u_x v(t) $$
$$ v_y(t) = u_y v(t) $$
$$ v_z(t) = u_z v(t) $$
The scalar speed profile is shaped by acceleration, constant-speed, and deceleration phases. In my implementation, the final motion functions are not simply these components. They are multiplied by a smoothing coefficient so that the transition into and out of the segment is continuous. This prevents the industrial robot from experiencing sudden velocity changes at the start and end of a linear move.
The straight-line instruction is important because many industrial robot tasks, such as dispensing, inspection, and simple pick-and-place, require linear motion. A linear path also provides a clear reference for error analysis. When the planned trajectory deviates from the theoretical line, the deviation can be measured directly and attributed to dynamic effects, smoothing, or inverse kinematic limitations.
Circular Motion Function
The circular motion function, associated with the instruction MoveC, moves the tool center point along a circular arc. I define the arc using three points: a start point A, an intermediate point B, and a target point C. The three points determine the plane of the circle and its center. The normal vector of the plane is
$$ \mathbf{n} = (n_x,n_y,n_z) = \overrightarrow{AB} \times \overrightarrow{AC} $$
The center of the circle, denoted by O = (x0, y0, z0), is found from the perpendicular bisectors of the chords. Once the center is known, the radius and the initial angular position are determined. If the angular velocity is ω, the velocity components of the tool center point can be expressed as
$$ v_x(t) = -\omega (x_i-x_0)\sin(\omega t) + \frac{n_y(z_i-z_0)-n_z(y_i-y_0)}{\|\mathbf{n}\|}\omega \cos(\omega t) $$
$$ v_y(t) = -\omega (y_i-y_0)\sin(\omega t) + \frac{n_z(x_i-x_0)-n_x(z_i-z_0)}{\|\mathbf{n}\|}\omega \cos(\omega t) $$
$$ v_z(t) = -\omega (z_i-z_0)\sin(\omega t) + \frac{n_x(y_i-y_0)-n_y(x_i-x_0)}{\|\mathbf{n}\|}\omega \cos(\omega t) $$
These expressions give the instantaneous velocity of a point moving on a circle in three-dimensional space. They are especially useful because they can be inserted directly into ADAMS general motion functions. The circular instruction is more demanding than the linear instruction for industrial robots. The direction of motion changes continuously, so the joint velocities and accelerations must be coordinated. Small errors in the circular path can grow when the robot passes through the arc, particularly if acceleration smoothing is not properly tuned.
In my system, the circular motion function is generated from the target points and the desired tangential speed. The normal vector and center are computed automatically. The user does not need to specify the plane orientation or the center coordinates. This reduces programming effort and makes the instruction consistent with the way industrial robots are programmed in practice.
Smoothing Coefficient
To control the transition between acceleration, constant speed, and deceleration, I introduce a smoothing coefficient k(t). The coefficient is defined by two STEP functions:
$$ k(t) = \text{STEP}(time,0,0,t_1,1) + \text{STEP}(time,T-t_2,0,T,-1) $$
Here, t1 is the acceleration time, t2 is the deceleration time, and T is the total time of the current motion segment. The first STEP function increases the coefficient from 0 to 1 during acceleration. The second STEP function decreases it from 1 to 0 during deceleration. When the segment is in the constant-speed phase, the coefficient is approximately 1. When the segment begins or ends, the coefficient approaches 0, which smoothly blends the velocity.
The final Cartesian velocity functions are
$$ F_x(t) = k(t) v_x(t) $$
$$ F_y(t) = k(t) v_y(t) $$
$$ F_z(t) = k(t) v_z(t) $$
These functions are assigned to the general motion of the tool center point marker. The ADAMS solver then computes the motion of the industrial robot. The smoothing coefficient allows the same geometric path to be executed with different dynamic profiles. For example, a short acceleration time produces a more aggressive motion, while a long acceleration time produces a gentler motion. This is valuable when the industrial robot carries different payloads or operates near its maximum speed.
The smoothing coefficient also helps satisfy safety-related requirements. Standards for industrial robots and collaborative robot systems emphasize dynamic performance limits. Abrupt acceleration changes are undesirable because they can produce peak forces, increase wear, and reduce safety. By shaping the velocity with C2-continuous STEP functions, I reduce the likelihood of such peaks. The user can tune t1 and t2 to balance cycle time and smoothness.
Simulation Experiments and Results
I implemented the system using ADAMS secondary development tools and tested it on a six-axis industrial robot. The custom toolbar and trajectory planning dialog were created first. The dialog accepts target points, speed, acceleration, and tool frame information. The motion instructions MoveL and MoveC were implemented using general motion functions based on the equations described above. The command that modifies the motion is executed at runtime, so the trajectory can be changed without rebuilding the entire model.
The experimental path follows a contour on a workpiece. The contour is represented by a sequence of points, and the industrial robot is commanded to move through them. The path includes linear segments and a circular segment. This combination is representative of many industrial robot tasks, such as welding, cutting, and inspection. The trajectory planning parameters are listed in the following table.
| Motion instruction | Target point | Speed (mm/s) | Acceleration (mm/s2) | Note |
|---|---|---|---|---|
| MoveL | Marker 234 | 200 | 200 | Linear motion |
| MoveL | Marker 271 | 200 | 200 | Linear motion |
| MoveL | Marker 272 | 200 | 200 | Linear motion |
| MoveL | Marker 273 | 200 | 200 | Linear motion |
| MoveC | Marker 275, Marker 274 | 200 | 200 | Circular motion; speed and acceleration are tangential components |
| MoveL | Marker 234 | 200 | 200 | Linear motion |
The simulated trajectory followed the theoretical contour closely. Because each segment includes acceleration and deceleration, small deviations appear near the transitions. These deviations are not random errors; they are the expected result of smoothing and dynamic lag. The Cartesian error was analyzed by comparing the actual tool center point position with the theoretical path. The results are summarized in the following table.
| Motion segment | Sample range | Mean error (μm) | Maximum error (μm) | Observation |
|---|---|---|---|---|
| Linear constant-speed motion | Representative middle samples | Approximately 0.3 | Approximately 0.5 | Very small deviation; the linear path is well preserved. |
| Circular motion | Samples 940 to 1020 | Higher than linear segments | 14.47 | Direction changes and smoothing have a stronger effect. |
| Overall path | All samples | Within acceptable range | 14.47 | The planned trajectory meets the motion requirements. |
The error analysis shows that the linear segments are highly accurate. The maximum error of approximately 0.5 μm at the sampled point is very small for an industrial robot simulation. The circular segment has a larger maximum error of 14.47 μm. This is consistent with the fact that circular motion requires continuous changes in joint velocity and acceleration. The smoothing coefficient and the acceleration time have a significant influence on this segment. When the acceleration time is short, the joint acceleration changes more rapidly, and the tracking error increases. When the acceleration time is longer, the error decreases, but the cycle time increases. This trade-off is important in practical trajectory planning for industrial robots.
I also measured the joint angle displacement and joint angular acceleration of the industrial robot. The joint angle curves are smooth and continuous. They do not show abrupt jumps, which indicates that the inverse kinematics solution is consistent and that the motion is coordinated. The motion range and direction of each joint also match the planned Cartesian path. The general motion approach therefore provides a convenient way to obtain inverse kinematic solutions inside ADAMS without manually deriving them.
| Joint | Displacement characteristic | Continuity | Inverse kinematic observation |
|---|---|---|---|
| J1 | Smooth and continuous | No abrupt jumps | Consistent with base rotation requirements. |
| J2 | Smooth and continuous | No abrupt jumps | Maintains reach and orientation. |
| J3 | Smooth and continuous | No abrupt jumps | Coordinates with J2 for position control. |
| J4 | Smooth and continuous | No abrupt jumps | Supports wrist orientation changes. |
| J5 | Smooth and continuous | No abrupt jumps | Maintains tool orientation. |
| J6 | Smooth and continuous | No abrupt jumps | Provides final tool rotation. |
The joint angular acceleration results show that the STEP-based smoothing model has a strong influence on motion smoothness. The circular segment, which includes relatively short acceleration and deceleration phases, produces larger angular accelerations. Representative peak values are on the order of 45°/s2. This is within a reasonable range for the simulated industrial robot. More importantly, the acceleration curves remain continuous. There are no sudden spikes that would indicate impact or vibration. This confirms that the planned trajectory satisfies the dynamic requirements of industrial robots.
| Joint | Representative maximum angular acceleration (deg/s2) | Dynamic assessment |
|---|---|---|
| J1 | Approximately 20 | Within reasonable range. |
| J2 | Approximately 35 | Continuous and acceptable. |
| J3 | Approximately 45 | Largest during circular motion, still acceptable. |
| J4 | Approximately 30 | Smooth response. |
| J5 | Approximately 25 | Smooth response. |
| J6 | Approximately 15 | Smooth response. |
Discussion
The simulation results confirm that instruction-mode trajectory planning inside ADAMS is effective for industrial robots. The method combines the familiarity of robot programming with the power of multibody dynamics. Instead of treating ADAMS as a final validation tool, I use it as an active planning environment. This changes the workflow from a one-way sequence to an interactive loop. The user can change target points, speeds, accelerations, and smoothing parameters, and immediately observe the effect on joint motion and Cartesian error.
Compared with the conventional approach of planning in MATLAB or another external environment and then importing data into ADAMS, my method offers several advantages. It reduces data exchange and avoids interpolation errors. It preserves the dynamic coupling between trajectory generation and multibody response. It also makes the planning process more transparent because the motion functions are visible and editable inside the ADAMS model. For industrial robots, these advantages can shorten design cycles and improve the quality of offline programming.
| Criterion | Conventional external planning plus ADAMS validation | My ADAMS instruction-mode system |
|---|---|---|
| Real-time trajectory modification | Difficult; requires re-export and re-import. | Direct through dialog parameters and runtime functions. |
| Continuous dynamic analysis | Limited to the imported trajectory. | Fully coupled with the ADAMS solver. |
| Inverse kinematics | Often solved externally or manually. | Solved by ADAMS through general motion. |
| Smoothness control | Applied before import and difficult to adjust. | Integrated smoothing coefficient and STEP functions. |
| Resemblance to robot programming | Low; data-oriented. | High; instruction-oriented with MoveL and MoveC. |
| User interaction | Limited. | Toolbar, dialog, and post-processing views. |
The circular motion results deserve special attention. The maximum error in the circular segment is larger than in the linear segments. This is expected because circular motion requires coordinated changes in multiple joints. The tangential speed and acceleration are continuous in the planned path, but the joint-space mapping introduces additional dynamic effects. In my experiments, the acceleration and deceleration phases of the circular segment have the greatest influence on error. When these phases are made smoother, the error decreases. This suggests that future work should focus on adaptive smoothing, where the smoothing coefficient is adjusted according to the curvature of the path and the payload of the industrial robot.
Another important observation is that the general motion approach provides a practical way to obtain inverse kinematic solutions. For a six-axis industrial robot, closed-form inverse kinematics is possible but tedious. Numerical inverse kinematics is flexible but can suffer from convergence issues near singularities. By assigning Cartesian motion functions to a marker and letting ADAMS solve the constraints, I obtain joint trajectories that are consistent with the multibody model. This does not eliminate the need to check singularities, but it simplifies the workflow and reduces the chance of kinematic inconsistency.
The system also has potential for digital twin applications. A digital twin of an industrial robot must be able to simulate motion under realistic conditions and update its state in response to new commands. My instruction-mode system provides a natural interface for such updates. The toolbar and dialog can be connected to a higher-level controller or a manufacturing execution system. The motion functions can be parameterized by real process data. The dynamic solver then predicts the response of the industrial robot. This makes the virtual model more than a visualization; it becomes an analytical tool for planning and optimization.
Practical Implications for Industrial Robots
For industrial robots, the value of trajectory planning lies in its ability to improve productivity without sacrificing accuracy or safety. My method contributes to this goal in several ways. First, it reduces the gap between planning and dynamic analysis. Second, it supports instruction-level programming, which is familiar to robot programmers. Third, it provides tunable smoothing, which helps balance speed and vibration. Fourth, it uses ADAMS inverse kinematics, which reduces manual derivation. Fifth, it is extensible, so additional instructions such as joint moves, blending, and tool orientation changes can be added.
The smoothing coefficient is a simple but powerful tool. It allows the same geometric path to be executed with different dynamic profiles. In a production setting, this can be used to adapt the motion of industrial robots to different payloads, different fixtures, and different accuracy requirements. For example, a heavy payload may require longer acceleration and deceleration times to reduce joint torque. A light payload may allow shorter times to increase cycle rate. Because the coefficient is defined by STEP functions, the transition remains smooth in all cases.
The error results also provide guidance for process planning. Linear segments are highly accurate and can be used for tasks that require straight-line precision. Circular segments require more careful tuning. If a circular path is critical, the user should increase the acceleration time, reduce the tangential speed, or use a higher-order smoothing function. These adjustments can be made interactively in the system. This is a significant improvement over workflows where the trajectory is fixed before dynamic simulation.
In addition, the system can be used to study the effects of different acceleration profiles. The cubic STEP function provides C2 continuity and is sufficient for many applications. The quintic STEP5 function provides smoother acceleration and may be preferable for high-speed industrial robots or for collaborative robots that operate near humans. By switching between these functions, the user can evaluate trade-offs between smoothness and computation time. The motion functions are modular, so the choice of smoothing function does not require redesigning the entire trajectory planner.
Limitations and Future Work
My current system focuses on trajectory planning and dynamic simulation. It does not yet include a full collision avoidance module, although ADAMS can be extended to detect collisions. It also does not automatically optimize the trajectory for minimum time or minimum energy. These are natural extensions. In future work, I plan to integrate optimization algorithms that adjust target points, speeds, and smoothing parameters to satisfy multiple objectives. I also plan to include tool orientation instructions, because many industrial robot tasks require controlled orientation as well as position.
Another direction is the connection to real robot controllers. The instruction-mode design is intentionally similar to actual robot programming. This makes it possible to export the planned trajectory as a robot program or as a stream of motion commands. The dynamic simulation can then be used to verify the program before it is executed on the physical industrial robot. This would support offline programming and reduce commissioning time. It would also allow the digital twin to remain synchronized with the physical robot during operation.
Finally, I intend to study the influence of joint compliance and flexibility. The current model treats the industrial robot as a rigid multibody system. In reality, joints and links have compliance, which can affect accuracy and vibration. A rigid model is a useful first step, but a flexible model would provide more realistic predictions. By combining the instruction-mode trajectory planner with a flexible multibody model, I can evaluate how trajectory smoothing interacts with structural dynamics. This is especially important for large industrial robots and for high-acceleration applications.
Conclusion
I have presented an ADAMS-based instruction-mode trajectory planning system for industrial robots. The system uses a layered architecture, secondary development tools, and general motion functions to generate smooth Cartesian trajectories inside ADAMS. Straight-line and circular motion instructions are implemented with explicit velocity functions, and a smoothing coefficient based on STEP functions shapes acceleration and deceleration. The inverse kinematics of the industrial robot is solved through ADAMS general motion, eliminating the need for manual derivation. Simulation experiments on a six-axis industrial robot show that the planned trajectory follows the theoretical path with small error. Linear segments achieve sub-micrometer-level accuracy in the constant-speed phase, while the circular segment reaches a maximum error of 14.47 μm. Joint angle displacement is smooth and continuous, and joint angular acceleration remains within a reasonable range. The method provides a new way to integrate trajectory planning, inverse kinematics, and dynamic analysis for industrial robots. It supports interactive parameter changes, instruction-level programming, and future integration with digital twins and offline programming systems.