Design and Experimental Validation of a PID-Controlled Cartesian Robot with HSV-Based Vision for Automated Product Classification

This section details the architecture of the proposed system, the mathematical model governing the robot's dynamics, and the control strategy employed. A systematic approach was taken, beginning with hardware integration, followed by dynamic modeling, and culminating in the design and tuning of the feedback controller.

2.1 System architecture

The overall architecture of the integrated system is depicted in the flowchart in Figure 1. The process begins with image acquisition by the camera, followed by processing on a PC to identify and locate target products. Positional data is then transmitted to a microcontroller, which actuates the Cartesian robot to perform the sorting task [23-26]. The physical system block diagram is shown in Figure 2.

Figure 1. The research flowchart

Figure 2. A block diagram of the entire system

The Cartesian robot control system includes the following key components:

• Camera: This is the primary input source providing image information for the system. The camera assists the system in recognizing and classifying products on the production line and calculating the necessary coordinates to control the actuator mechanism's operations [27, 28].
• Image processing (PC): Initially, the PC handles image processing to determine the coordinates of detected objects. Following this calculation, the coordinate data is transferred to the Arduino Mega microcontroller through a serial UART interface, operating at a baud rate of 19200 bps, which in turn directs the actuators. This baud rate was determined to be sufficient for transmitting coordinate data without introducing significant latency for the pick-and-place cycle time.

• Microcontroller: The microcontroller (Arduino Mega 2560) controls the actuator mechanism of the robot, especially the stepper motors controlling the robot's axes. It receives signals from the PC via the serial link, decodes them, and executes corresponding control actions.
• Power Supply: Provides electrical energy to the system, transforms voltage and current, protects and stabilizes power sources, and supplies backup power to ensure continuous and stable operation.
• Cartesian Robot: This is the main actuator mechanism used for grasping and sorting products. It utilizes a vacuum system and stepper motors to move its axes to the desired gripping points.
• Encoder: An electro-mechanical device that converts rotary or linear motion into digital signals or pulses. Among various types, magnetic encoders [29, 30] utilize magnetic fields to sense rotational or linear displacement, offering robustness and resistance to environmental factors like dust or moisture, which are beneficial in industrial settings. Encoders are fundamentally used to detect the position, direction, and speed of a motor by counting the number of revolutions or increments of the shaft, providing crucial feedback for precise motion control. To achieve high accuracy while maintaining a low overall cost, our system was specifically engineered to operate in a true closed-loop manner. High-resolution magnetic encoders were integrated directly into the rear shafts of the standard stepper motors. To securely accommodate these sensors and ensure rigorous alignment with the rotating shafts, customized mounting brackets were designed and fabricated using 3D printing technology. During operation, real-time positional data from these magnetic encoders is continuously fed back to the Arduino Mega microcontroller. The embedded PID controller calculates the spatial error and dynamically adjusts the step and direction pulse frequencies sent to the motor drivers, effectively compensating for external disturbances and preventing step loss.

Table 2. Communication protocol

Table 2 details the communication protocol established between the host PC and the robot controller. The system utilizes a UART physical layer operating at a baud rate of 19200 bps to exchange ASCII strings. Data transmission is event-driven, with the PC sending integer target positions in an "X, Y, Z" coordinate format, while the robot returns status updates via "Message\n" strings. To maintain system reliability and prevent operational hangs, the protocol incorporates basic error logging for packet loss and a strictly enforced 1-second timeout mechanism.

Table 3. System hardware specifications

To provide a comprehensive overview of the system's mechanical and electrical capabilities, the detailed hardware specifications, including the physical constraints, actuator types, and overall estimated cost, are summarized in Table 3.

2.2 Mathematical modeling

To design an effective controller, a dynamic model of the 3-DOF Cartesian robot was developed. The general equation of motion for a robotic manipulator is given by:

$M(q) \ddot{q}+C(q, \dot{q}) \dot{q}+G(q)=\tau$            (1)

where, q is the vector of joint positions, M(q) is the mass-inertia matrix, $C(q, \dot{q})$ is the matrix of Coriolis and centrifugal forces, G(q) is the vector of gravitational forces, and tau is the vector of applied joint torques/forces. For a Cartesian robot with three prismatic joints (d2, d3, d4 corresponding to the Y, X, Z axes), this model simplifies significantly. The axes are decoupled, the Coriolis/ centrifugal terms are negligible ($C(q, \dot{q})$ approx0), and the mass matrix M is constant. The dynamic equations for each axis can be written as:

$\begin{gathered}{\left[\begin{array}{l}\tau_1 \\ \tau_2 \\ \tau_3\end{array}\right]=\left[\begin{array}{ccc}m_1+m_2+m_3 & 0 & 0 \\ 0 & m_2+m_3 & 0 \\ 0 & 0 & m_3\end{array}\right]\left[\begin{array}{l}\ddot{d}_2 \\ \ddot{d}_3 \\ \ddot{d}_4\end{array}\right]} \\ +\left[\begin{array}{c}0 \\ 0 \\ m_3\end{array}\right] g\end{gathered}$             (2)

where, $\tau_1, \tau_2$, and $\tau_3$ are the actuator forces applied to each respective link. As represented in the matrix, this simplified dynamic model assumes that the effects of mechanical friction are negligible. Symbols $\ddot{d}_2, \ddot{d}_3$, and $\ddot{d}_4$ represent the linear accelerations of the moving joints.

The specific physical parameters used to construct and simulate this dynamic model include the masses of the three moving links, specifically $m_1$ = 1.15 kg, $m_2$ = 0.6 kg, and $m_3$ = 0.55 kg, along with the standard gravitational acceleration g = 9.81 m/s². Where, m_x, m_y, m_z are the effective masses of each moving axis, b_x, b_y, b_z are the viscous friction coefficients, g is the acceleration due to gravity, and tau_x, tau_y, tau_z are the forces applied by the actuators on the X, Y, and Z axes, respectively. These equations form the basis of the "ROBOT MANIPULATOR" block within our MATLAB/Simulink simulation, as shown in Figure 3.

2.3 Control strategy

For the position control of each axis, a PID feedback controller was selected. While advanced control methods such as fuzzy logic [31-37] or neural networks [38-41] can offer enhanced performance in complex scenarios, the PID controller remains a highly effective and widely adopted choice for industrial applications due to its robustness, simplicity of implementation, and low computational overhead [42, 43]. For the defined pick-and-place task, where the robot follows point-to-point trajectories, a well-tuned PID controller is sufficient to achieve the required accuracy and dynamic response without the complexity of more advanced algorithms, aligning with the project's goal of developing a cost-effective system [44].

The Simulink model for the closed-loop control system is shown in Figure 3. Each axis has an independent PID controller that computes the required actuator force (tau) based on the error between the desired position (Setpoint) and the actual position feedback. The output of the controller is then fed into the robot's dynamic model (Figure 4) to simulate the physical response.

Figure 3. The control system built in MATLAB/Simulink

The performance of the PID controller is critically dependent on its gains (K_p, K_i, K_d). In this study, the PID parameters for each axis were determined through rigorous empirical heuristic tuning (trial-and-error) directly on the physical hardware. The gains were iteratively adjusted to optimize the response, specifically to achieve smooth deceleration and minimize settling time for typical pick-and-place motions, while ensuring absolute robustness against missed steps. The final discrete-time control parameters, including the strategic use of PD-like control on specific axes to intentionally prevent integral windup.

Therefore, using a PID controller is seen as a good choice to achieve the goals of high accuracy and speed in Cartesian robot systems.

Figure 4. System mathematical model

where, tau1, tau2, tau3 are the input control forces for the Y, X, and Z axes, respectively. The function blocks u(7)/m123, u(8)/m23, and f(u) represent the implementation of the dynamic equations derived previously, calculating the acceleration for each axis based on the input forces and system parameters (masses and frictions).

The Integrator blocks are used to integrate acceleration to get velocity, and velocity to get position, thus simulating the robot’s physical movement.

2.4 Control signal mapping and actuator interface

While the dynamic model and force-based (tau) PID control described in Section 2.2 and 2.3 were utilized within the MATLAB/Simulink environment to verify mechanical stability under payload and friction constraints, the physical actuator interface requires a different approach. Standard stepper motor drivers do not accept direct force or current commands; instead, they operate on step and direction pulses. To bridge this gap, our physical implementation employs a position-loop PID controller mapped directly to step frequency. The positional error e(t), calculated as the difference between the desired setpoint and the actual position feedback from the magnetic encoders, is processed by the discrete PID algorithm embedded on the Arduino microcontroller.

To protect the mechanical system, prevent stepper motor stalling, and strictly respect the motor's pull-out torque limits, saturation constraints are applied to the output command.

This section presents and analyzes the performance of the proposed system. First, the simulation results for the PID control strategy are detailed. Next, the experimental results from the physical prototype are presented, covering both control performance and classification accuracy. Finally, a comprehensive discussion analyzes these results, compares them with existing work, and addresses the system's limitations.

4.1 Simulation results

Numerical simulations were conducted in MATLAB/Simulink package to validate the dynamic model and evaluate the performance of the designed PID control system prior to physical implementation. The robot was commanded to follow step inputs corresponding to typical pick-and-place positions. The position and velocity responses for each axis (Y, X, and Z) are shown in Figures 6-11 [56, 57].

Figure 6. The response in position along the Y-axis

Figure 7. The response in velocity along the Y-axis

Figure 8. The response in position along the X-axis

Figure 9. The response in velocity along the X-axis

Figure 10. The response in position along the Z-axis

Figure 11. The response in velocity along the Z-axis

As observed in the figures, the simulated response for each axis demonstrates excellent tracking performance. The output signal (e.g., 'd2') rapidly follows the desired setpoint with minimal overshoot and settles quickly, indicating a well-tuned controller. The velocity profiles show a rapid acceleration followed by a smooth deceleration, which is desirable for fast and stable motion. A 3D visualization of the robot model moving within the simulated environment is shown in Figure 12.

Figure 12. Simulating the robot model in MATLAB

To further test the controller's robustness, square wave inputs were used to simulate repetitive back-and-forth movements, as shown in Figures 13-15. The controller consistently demonstrates its ability to track these dynamic changes with high fidelity, though a slight tracking lag is visible during rapid transitions, as expected.

Figure 13. Response of Y-axis position with Proportional-Integral-Derivative (PID) controller

Figure 14. Response of X-axis position with Proportional-Integral-Derivative (PID) controller

Figure 15. Response of Z-axis position with Proportional-Integral-Derivative (PID) controller

4.2 Experimental results

The validated control and image processing algorithms were deployed on the physical prototype, as shown in Figure 16. To facilitate real-time operation and parameter monitoring during the trials, a custom graphical user interface (GUI) was utilized (Figure 17). Experiments were conducted to evaluate two key aspects: the real-world performance of the PID motion controller and the accuracy of the vision-based classification system.

Figure 16. The real system model for experiments

Figure 17. Adjust the operating parameters of the vision system on the software interface

• Control system performance

The robot was commanded to follow the same step trajectories used in the simulation. The actual position responses on the Y and X axes were captured and are shown in Figures 18 and 19. The experimental results closely mirror the simulation, confirming the accuracy of the dynamic model and the effectiveness of the controller. However, the physical system exhibits slightly longer settling times and larger tracking errors, which can be attributed to unmodeled dynamics such as static friction, mechanical backlash, and motor nonlinearities.

Figure 18. The response of position along the Y-axis

Figure 19. The response of position along the X-axis

Despite these minor unmodeled dynamics, the physical system demonstrated exceptional stability, largely due to the critical interplay between the custom software PID algorithm and the hardware characteristics. First, the Proportional gain (K_p) dynamically maps the positional error to the step frequency, inherently generating a smooth deceleration profile as the end-effector approaches the target, thereby preventing mechanical shocks. Second, finding a stable PID parameter basin was highly straightforward, yielding near-zero overshoot. This hardware-assisted stability occurs because once the PID algorithm accurately drives the positional error to zero and halts the pulse output, the substantial holding torque of the stepper motors instantly locks the mechanism, naturally suppressing any inertia-driven overshoot typical of DC servo systems.

To provide a highly auditable and standardized evaluation of the tracking performance, the classical step-response metrics for the physical prototype are systematically reported in physical units in Table 5.

Table 5. Physical step-response performance metrics

• Image processing and classification performance

The performance of the image processing algorithm was evaluated using a dataset of 150 images of red and green circular objects placed in various positions within the workspace under typical laboratory lighting conditions. The system's task was to correctly classify the color of each object and determine its coordinates. The user interface displaying the real-time detection results is shown in Figure 20.

Figure 20. The user interface on the computer

The system achieved an overall classification accuracy of 92.7%. The detailed distribution of these results is illustrated in the confusion matrix in Table 6. Furthermore, comprehensive evaluation metrics, including precision, recall, and F1-score, are summarized in Table 7.

To provide a rigorous evaluation of the system's operational speed, the previously reported "0.5 seconds per product" was further analyzed. This duration represents the complete software and communication cycle, measured from the moment the camera capture command is initiated until the Arduino microcontroller successfully receives the coordinate payload via the serial UART interface.

The vision pipeline was executed on a host PC (Intel Core i5, 16GB RAM) running Python 3.9 and OpenCV 4.5.3. Through rigorous profiling over multiple runs, it was found that the pure vision processing component (HSV masking and centroid extraction) is remarkably efficient, taking an average of only 29.0 ms (± 5.1 ms). The remainder of the 0.5s software cycle is attributed to serial transfer overhead and buffer synchronization between the PC and the Arduino.

The comprehensive timing breakdown, including the physical robot motion and vacuum actuation delays, is summarized in Table 8. The results indicate that while the computational vision task is nearly instantaneous, the overall throughput is primarily limited by the mechanical constraints of the Cartesian frame and the pneumatic vacuum system, resulting in a true full cycle time of approximately 4.0 seconds.

Table 6. Confusion matrix

Table 7. Classification performance metrics

Table 8. System timing breakdown per product cycle

4.3 Error analysis and robustness testing

To rigorously evaluate the external validity of the proposed HSV-based vision system, two additional stress-test scenarios were conducted: a Lighting Variation test and a Background Clutter test. These experiments aim to identify the operational boundaries and failure cases of the color-based classification approach.

Figures 21 and 22 illustrate sample results from these stress tests. In Figure 21, the algorithm successfully isolates targets against complex textures (e.g., wood grain, metallic parts). However, Figure 22 explicitly showcases failure cases. Severe flash glare washes out the object’s color, causing the HSV values to fall outside the predefined range and resulting in missed detections. These results confirm that while efficient, the HSV approach requires controlled illumination to maintain peak performance.

Figure 21. An illustration of stress tests – successful isolate targets

Figure 22. An illustration of stress tests – failure cases

To quantify the robustness of the HSV algorithm, a sensitivity analysis was performed by shifting the Hue (H) and Saturation (S) thresholds by ± 10%. As shown in Table 9, the system maintains high accuracy within a narrow band, but performance degrades significantly when Saturation thresholds are too restrictive, leading to missed detections under shadows.

Table 9. Hue-Saturation-Value (HSV) threshold sensitivity analysis

Regarding mechanical reliability, a repeatability test was conducted by commanding each axis to return to a reference point 10 times from different directions. The mean bidirectional positioning error was measured at ±0.8 mm for the X/Y axes and ± 0.5 mm for the Z-axis. This high level of repeatability confirms that the custom closed-loop PID control effectively mitigates mechanical backlash and friction during long-term operation.

4.4 Global discussion and comparative analysis

The experimental results confirm the feasibility and effectiveness of the proposed integrated system. The close correlation between simulated and actual control performance validates the dynamic model and the empirical PID tuning methodology. As detailed in Table 9, the controller demonstrates high precision, maintaining a mean tracking error of less than 3% in physical experiments, which is highly acceptable for industrial pick-and-place tasks. Regarding the vision pipeline, the initial claim of 0.5 seconds was found to be a conservative estimate for the entire software-communication cycle. Detailed profiling in Table 10 reveals that the core HSV-based algorithm is exceptionally efficient, requiring only 29.0 ms per frame. This efficiency allows the system to remain responsive even on low-cost hardware. While the 92.7% accuracy achieved under controlled lighting is promising, our new stress tests (Section 4.3) provide a more nuanced understanding of the system's limits. The identified failure cases under extreme glare underscore that while the system is cost-effective, it requires consistent illumination for maximum reliability.

Table 10. Comparative performance of vision algorithms on the same dataset (150 images)

The selection of the HSV color space over the traditional RGB model is motivated by its inherent robustness to environmental lighting drift; the decoupling of chromaticity from luminance allows for more stable color segmentation in non-ideal industrial settings. Furthermore, the addition of morphological opening operations and area filtering is critical for real-world reliability. These post-processing steps effectively eliminate small, isolated noise pixels and small artifacts that would otherwise introduce significant jitter in the centroid coordinates. By achieving an accuracy of 92.7% within a 29.0 ms window, this integrated vision pipeline provides a superior balance between precision and computational efficiency compared to standard baselines.