Artificial intelligence based robot motion control system

Abstract

The application discloses a robot motion control system based on artificial intelligence, and relates to the technical field of intelligent control, comprising: converting collected environment point cloud data into a voxel grid, collecting robot body data and environment dynamic sequence images; based on the environment dynamic sequence images, establishing a mixed Gaussian model, generating a scene dynamic feature distribution, calculating scene complexity based on robot trajectory error and the scene dynamic feature distribution, converting the scene complexity into a weight configuration vector through a nonlinear mapping network, and reconstructing the weight configuration vector into a weight matrix; the weight matrix is used to construct a robot dynamic equation, and the robot dynamic equation is solved to generate joint control torque of the robot; the joint control torque is transmitted to the robot joint through a distributed actuator to drive the robot to complete target motion. The application quantifies environment dynamic intensity through a motion probability field, generates scene complexity by coupling trajectory error, and improves dynamic feature extraction accuracy in an extreme environment.

Description

Technical Field

[0001] This invention relates to the field of intelligent control technology, and in particular to a robot motion control system based on artificial intelligence. Background Technology

[0002] Industrial robot motion control technology has evolved through three generations: the first generation was based on classical PID control theory, achieving fixed-point trajectory tracking through precise modeling of joint dynamics; the second generation introduced visual servo control, integrating camera feedback and position loop control to achieve simple workpiece grasping; and the third generation employs deep learning, using CNN to process visual information and generate control commands. In recent years, multimodal perception fusion has become a research hotspot; for example, the MIT team proposed a LiDAR-vision fusion SLAM system.

[0003] Despite continuous technological iteration, existing solutions still have the following shortcomings: traditional vision systems only process RGB images and cannot efficiently fuse point cloud spatial information, resulting in increased dynamic obstacle recognition rates; deep reinforcement learning models have a large number of parameters, which cannot meet the response requirements of high-speed assembly lines; fixed-parameter dynamic equations are difficult to adapt to sudden load changes, and the measured trajectory deviation is higher than the industry standard. Summary of the Invention

[0004] In view of the aforementioned existing problems, the present invention is proposed.

[0005] Therefore, this invention provides an artificial intelligence-based robot motion control system to solve the problems of low efficiency and high decision-making delay in multi-source perception fusion for robot motion control in highly dynamic environments.

[0006] To solve the above-mentioned technical problems, the present invention provides the following technical solution:

[0007] This invention provides an artificial intelligence-based robot motion control system, which includes:

[0008] The data acquisition module is used to convert the acquired environmental point cloud data into voxel grids and acquire robot body data and dynamic sequence images of the environment;

[0009] The quantum coding module is used to calculate the robot's real-time position based on the robot's body data through forward kinematics, synchronously construct the pose transformation matrix, use the pose transformation matrix to perform coordinate transformation on the voxel grid, and generate quantum entangled feature vectors.

[0010] The learning decision module is used to input the quantum state entanglement feature vector into the meta-reinforcement learning decision-maker, and simultaneously input the robot's real-time position and the robot's preset movement trajectory, and generate the robot trajectory error through vector difference operation;

[0011] The reconstruction matrix module is used to build a Gaussian mixture model based on dynamic sequence images of the environment, generate dynamic feature distribution of the scene, calculate scene complexity based on robot trajectory error and scene dynamic feature distribution, convert scene complexity into weight configuration vector through nonlinear mapping network, and reconstruct weight configuration vector into weight matrix.

[0012] The equation solving module is used to construct and solve the robot's dynamic equations based on the weight matrix, generating the robot's joint control torques.

[0013] The distributed execution module is used to transmit joint control torque to the robot joints through distributed actuators, driving the robot to complete the target motion.

[0014] As a preferred embodiment of the AI-based robot motion control system described in this invention, the system performs coordinate system transformation and voxelization mapping based on the collected environmental point cloud data to create a three-dimensional voxel grid space, and converts it into a voxel grid through placeholder filling.

[0015] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for generating the quantum state entanglement feature vector are as follows:

[0016] Joint angles, body angular velocities, and base calibration matrices are extracted from robot body data.

[0017] The robot's real-time position is obtained by solving the joint angles using forward kinematics.

[0018] Based on the body angular velocity and the robot's base calibration matrix, a pose transformation matrix is ​​constructed;

[0019] The pose transformation matrix is ​​used to perform coordinate transformation on the voxel grid. Based on the transformed voxel grid, the three-dimensional voxel data of all occupier voxel units is extracted, and quantum entanglement feature vectors are generated through quantum amplitude encoding.

[0020] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for generating the robot trajectory error are as follows:

[0021] Load the quantum state entanglement feature vector, the robot's real-time position and the robot's preset movement trajectory, and align the timestamps;

[0022] The quantum state entanglement feature vector aligned with the timestamp is input into the robot's real-time position input meta-reinforcement learning decision-maker, which outputs the expected position correction value at the current moment.

[0023] The robot's expected position is generated by analyzing the robot's preset movement trajectory and adding the expected position correction value at the current moment. The robot's trajectory error is generated by calculating the difference between the robot's real-time position and the final expected position.

[0024] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for generating the dynamic feature distribution of the scene are as follows:

[0025] Perform grayscale conversion on dynamic environmental image sequences to generate a single-channel grayscale intensity matrix, and calculate pixel motion displacement vectors using an optical flow algorithm;

[0026] Based on the pixel motion displacement vector, the Gaussian mixture model is constructed by establishing a three-component Gaussian mixture model mathematical structure for each pixel position.

[0027] The parameters of the Gaussian mixture model are updated online based on the pixel motion displacement vector, and the dynamic feature distribution of the scene is generated by calculating the motion probability.

[0028] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for reconstructing the weight configuration vector into a weight matrix are as follows:

[0029] The Euclidean norm of the robot trajectory error and the motion intensity of the scene dynamic feature distribution are calculated respectively, and the scene complexity is obtained by nonlinear coupling of weighted linear superposition and Sigmoid compression.

[0030] Perform forward propagation of a nonlinear mapping network on the scene complexity to generate a weight configuration vector;

[0031] The weight configuration vector is filled in row-major order to generate an initial matrix. The initial matrix is ​​then subjected to positive definiteness forced correction and reconstructed into a weight matrix.

[0032] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for generating the robot's joint control torques are as follows:

[0033] The correction factor of the inertia matrix is ​​extracted based on the weight matrix, and the robot dynamic equation is constructed. The Newton-Euler iterative algorithm is used to solve the robot dynamic equation and generate the original joint torque.

[0034] Calculate the dynamic safety threshold by applying the rated torque parameters of the joint motor and the mechanical transmission safety factor;

[0035] Based on a dynamic safety threshold, the original joint torque is subjected to bidirectional saturation limiting processing to generate the robot's joint control torque.

[0036] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for driving the robot to complete the target motion are as follows:

[0037] The joint control torque of the robot is transmitted to the corresponding robot joint, and after decoding and signal conversion, joint torque commands are generated.

[0038] The robot joints convert joint torque commands into target drive current values, and then generate motor drive current signals through power amplification.

[0039] The robot is driven to complete the target motion by electromagnetic conversion of the motor drive current signal.

[0040] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for obtaining the scene complexity are as follows:

[0041] The Euclidean norm is calculated as the trajectory deviation based on the robot trajectory error.

[0042] Extract the probability values ​​of all pixel motion displacement vectors in the scene dynamic feature distribution, perform arithmetic mean calculation, and generate scalar form motion intensity;

[0043] The trajectory deviation and motion intensity are linearly weighted and superimposed according to a predetermined weight coefficient, and then input into a Sigmoid-type nonlinear function to perform interval compression operation, outputting a standardized scene complexity.

[0044] As a preferred embodiment of the AI-based robot motion control system of the present invention, the specific steps for constructing the pose transformation matrix are as follows:

[0045] The attitude angle offset is calculated by integration based on the body angular velocity;

[0046] Perform rotation matrix calculation based on attitude angle offset to generate rotation compensation matrix;

[0047] Load the robot's base calibration matrix, and construct the pose transformation matrix based on the rotation compensation matrix and the base calibration matrix.

[0048] The beneficial effects of this invention are as follows: reducing data dimensionality and memory usage by voxelizing point clouds; fusing spatial occupancy information and environmental topology by quantum entangled feature vectors to overcome the limitation of traditional SLAM in only extracting geometric features; achieving environmental adaptive compensation by driving a decision-maker with quantum features, making the trajectory error lower than that of traditional PID control; quantifying the dynamic intensity of the environment by using a motion probability field, coupling trajectory error to generate scene complexity, improving the accuracy of dynamic feature extraction in extreme environments; and correcting dynamic parameters in real time by using a weighted inertia matrix to reduce trajectory deviation when the load changes abruptly. Attached Figure Description

[0049] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0050] Figure 1 This is a schematic diagram of an AI-based robot motion control system.

[0051] Figure 2 The flowchart for the execution of the quantum coding module.

[0052] Figure 3 The flowchart for the reconstructing matrix module. Detailed Implementation

[0053] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0054] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0055] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0056] Reference Figures 1-3 This is one embodiment of the present invention, which provides an artificial intelligence-based robot motion control system, comprising the following steps:

[0057] The data acquisition module is used to convert the acquired environmental point cloud data into voxel grids and acquire robot body data and dynamic sequence images of the environment.

[0058] Based on the collected environmental point cloud data, coordinate system transformation and voxelization mapping are performed to create a three-dimensional voxel raster space, which is then converted into a voxel raster through placeholder filling.

[0059] Furthermore, the environmental point cloud data collected by the LiDAR is acquired. Using the geometric center of the robot's mounting base as the origin, the normal direction perpendicular to the mounting plane is the positive Z-axis, and the direction of movement along the base is the positive X-axis. A Cartesian coordinate system with the positive Y-axis is determined using the right-hand rule and used as the robot's base coordinate system. The environmental point cloud data is then transformed into this coordinate system. Centered on the origin of the robot's base coordinate system, the maximum and minimum values ​​of the environmental point cloud data along the X, Y, and Z axes are calculated, forming a cuboid spatial boundary as the spatial range. The resolution is configured according to the robot's motion accuracy requirements; for example, a resolution of 0.01 is required for precision assembly. The resolution of logistics handling is 0.05m. Based on the resolution, the XYZ axes are uniformly divided to form a three-dimensional voxel grid space containing several equal-volume grid units, spatial range, and resolution. Based on the spatial range and resolution of the three-dimensional voxel grid space, the environmental point cloud data is translated to the coordinate origin of the three-dimensional voxel grid space. The voxel unit index of the three-dimensional voxel grid space is calculated to obtain the mapping relationship between the environmental point cloud data and the voxel unit index. Based on the mapping relationship, the environmental point cloud data is filled into the corresponding voxel units to generate a voxel grid with space-occupying voxel units.

[0060] The system collects robot body data, base calibration matrix, and dynamic sequence images of the environment. Through time synchronization processing, it generates voxel grids with timestamp alignment, robot body data, and dynamic sequence images of the environment.

[0061] Furthermore, the acquisition of robot body data includes obtaining joint angles, joint angular velocities, joint velocities, and joint output torques through joint encoders; obtaining a base calibration matrix stored in the non-volatile memory of the robot controller through laser tracker calibration; and simultaneously acquiring the robot's body acceleration and body angular velocity through an IMU (Inertial Measurement Unit). An IMU is a microelectromechanical sensor that measures the robot's body acceleration and angular velocity using a three-axis accelerometer and a three-axis gyroscope, respectively. Simultaneously, a binocular camera is triggered to acquire dynamic sequence images of the environment. Based on the robot body data and voxel grid, a timestamp-aligned voxel grid is generated by loading the IEEE 1588 time synchronization protocol. This process, combining robot body data and dynamic sequence images of the environment, completes multi-source data time synchronization processing.

[0062] The quantum coding module is used to calculate the robot's real-time position based on the robot's body data through forward kinematics, synchronously construct a pose transformation matrix, use the pose transformation matrix to perform coordinate transformation on the voxel grid, and generate quantum entangled feature vectors.

[0063] Joint angles and body angular velocities are extracted based on robot body data;

[0064] The robot's real-time position is obtained by solving the joint angles using forward kinematics.

[0065] Furthermore, joint angles and body angular velocities are extracted from the robot body data. Based on the robot configuration parameters (including link length, joint offset, torsion angle, and other DH parameters), the Cartesian coordinates of the robot end effector in the base coordinate system are calculated by solving the joint angles through forward kinematics. The Cartesian coordinates are then used as the robot's real-time position.

[0066] Based on the body angular velocity and the robot's base calibration matrix, a pose transformation matrix is ​​constructed.

[0067] Furthermore, the attitude angle offset is calculated by integration based on the body angular velocity, and a rotation matrix calculation operation is performed based on the attitude angle offset to generate a rotation compensation matrix. The robot's base calibration matrix (a 4×4 matrix, determined by calibration measurement during robot installation and deployment) is loaded, and a pose transformation matrix is ​​constructed based on the rotation compensation matrix and the base calibration matrix.

[0068] The expression for the pose transformation matrix is:

[0069] ;

[0070] In the formula, Here is the pose transformation matrix. Calibrate the robot's base matrix. This is the rotation compensation matrix.

[0071] The pose transformation matrix is ​​used to perform coordinate transformation on the voxel grid. Based on the transformed voxel grid, the three-dimensional voxel data of all occupier voxel units is extracted, and quantum entanglement feature vectors are generated through quantum amplitude encoding.

[0072] Furthermore, based on the pose transformation matrix, each occupier voxel in the voxel grid is traversed, and the center point coordinates of each occupier voxel in the robot base coordinate system are extracted. The center point coordinates are transformed to the world coordinate system through matrix multiplication, generating a transformed voxel grid with the coordinates of the center point in the world coordinate system. Based on the transformed voxel grid, the spatial distribution information of all occupier voxel units is extracted to obtain three-dimensional voxel data. The three-dimensional voxel data is expanded into a continuous one-dimensional vector, and the one-dimensional vector is normalized to eliminate dimensional differences, generating a normalized vector. The normalized vector is mapped to the quantum state probability amplitude through quantum amplitude encoding, and finally a high-dimensional quantum state entanglement feature vector is generated.

[0073] The learning decision module is used to input the quantum state entanglement feature vector into the meta-reinforcement learning decision-maker, and simultaneously input the robot's real-time position and the robot's preset movement trajectory, and generate the robot trajectory error through vector difference operation.

[0074] Load the quantum state entanglement feature vector, the robot's real-time position and the robot's preset movement trajectory, and align the timestamps.

[0075] Furthermore, the quantum entanglement feature vector is read, and the robot's real-time position calculated by forward kinematics is loaded. Discrete path point sequence data from an external preset trajectory database is called. The discrete path point sequence data is planned through the CAD software path of the workpiece's 3D model. Based on the joint velocities in the robot's body data, the Time-Optimal Trajectory Optimization (TOPRA) algorithm is used for velocity look-ahead and acceleration smoothing. Finally, the robot's preset trajectory is generated. The temporal consistency between the quantum entanglement feature vector, the robot's real-time position, and the robot's preset trajectory is verified by timestamp alignment, thus completing the core computational preparation.

[0076] The quantum state entanglement feature vector aligned with the timestamp is used in conjunction with the robot's real-time position input meta-reinforcement learning decision-maker to output the expected position correction value at the current moment.

[0077] Furthermore, the meta-reinforcement learning decision-maker is constructed from a quantum state feature adapter layer, a graph attention network layer, a temporal modeling layer, and a decision output layer. The quantum state feature adapter layer is used to match the dimension of the quantum entanglement feature vector. For example, the quantum amplitude encoding input dimension is designed to be 524288, or 2^19, determined by the Hilbert space dimension. The dimension of the quantum entanglement feature vector is consistent with the input dimension of the quantum amplitude encoding, indicating that the quantum entanglement feature vector is a 524288-dimensional vector. Choosing an input dimension of 524288 allows for dimensionality adaptation to the meta-reinforcement learning decision-maker while preserving the integrity of the quantum entanglement feature vector. To avoid insufficient dimensionality and over-design, a graph attention network layer is used to extract the spatial correlation between quantum entanglement feature vectors and dynamic sequence images of the environment. The temporal modeling layer contains LSTM neurons, based on the timestamp-aligned quantum entanglement feature vectors and the robot's real-time position. A Huber loss function and a Nesterov accelerated gradient optimizer are used to iteratively update the network parameters of the meta-reinforcement learning decision-maker. Training terminates when the prediction error of the desired position correction value is consistently lower than the resolution of the application scenario within a predetermined number of consecutive verification periods. For example, training terminates when the prediction error of five consecutive desired position correction values ​​is less than 0.01, which is the resolution of precision assembly. Training is terminated at time m. The network parameters are converted into FPGA executable firmware compliant with IEEE1666, resulting in a deployed meta-reinforcement learning decision-maker. The time-stamp-aligned quantum entanglement feature vector and the robot's real-time position are input into the quantum state feature adapter layer of the meta-reinforcement learning decision-maker, which outputs a classical feature vector. The classical feature vector is input into the graph attention network layer, which outputs a spatiotemporal fusion feature vector. The spatiotemporal fusion feature vector is input into the temporal modeling layer, which outputs a temporal prediction state. The temporal prediction state is input into the decision output layer to obtain the expected position correction value at the current moment.

[0078] The robot's expected position is generated by analyzing the robot's preset movement trajectory and adding the expected position correction value at the current moment. The robot's trajectory error is generated by calculating the difference between the robot's real-time position and the final expected position.

[0079] Furthermore, based on the discrete path point sequence data of the robot's preset movement trajectory, the theoretical expected position corresponding to the current timestamp is calculated by cubic spline interpolation. The expected position correction value at the current moment output by the meta-reinforcement learning decision-maker is loaded, and the element-wise addition operation of the theoretical expected position and the correction value is performed to generate the final expected position. The difference between the robot's real-time position and the final expected position is calculated, and the robot trajectory error is output.

[0080] The formula for calculating robot trajectory error is:

[0081] ;

[0082] In the formula, For robot trajectory error, For the final desired position, This represents the robot's real-time position.

[0083] It should be noted that the final expected position is obtained by adjusting the theoretical expected position and the expected position at the current moment.

[0084] The reconstruction matrix module is used to build a Gaussian mixture model based on dynamic sequence images of the environment, generate dynamic feature distribution of the scene, calculate scene complexity based on robot trajectory error and scene dynamic feature distribution, convert scene complexity into weight configuration vector through nonlinear mapping network, and reconstruct weight configuration vector into weight matrix.

[0085] Perform grayscale conversion on dynamic environmental image sequences to generate a single-channel grayscale intensity matrix, and calculate pixel motion displacement vectors using an optical flow algorithm;

[0086] Based on the pixel motion displacement vector, the Gaussian mixture model is constructed by establishing a three-component Gaussian mixture model mathematical structure for each pixel position.

[0087] Furthermore, an environmental dynamic sequence image is loaded. The environmental dynamic sequence image is an RGB three-channel pixel matrix. A grayscale conversion operation is performed to convert the RGB three-channel pixel matrix into a single-channel grayscale intensity matrix. Based on the single-channel grayscale intensity matrix, the pixel motion displacement vector of each pixel in the horizontal and vertical directions between adjacent frames is calculated using an optical flow algorithm. Based on the pixel motion displacement vector, a Gaussian mixture model is established for each pixel position, which contains three Gaussian components (static background component, medium-speed motion component, and high-speed motion component) and is assigned equal weight coefficients (one-third each).

[0088] The parameters of the Gaussian mixture model are updated online based on the pixel motion displacement vector, and the dynamic feature distribution of the scene is generated by calculating the motion probability.

[0089] Furthermore, the parameters of the Gaussian mixture model are initialized. The zero vector (0,0) is used as the mean of the static background component, the mean of the pixel motion displacement vector is used as the mean of the medium-speed motion component, and a factor of three times the mean of the pixel motion displacement vector is used as the mean of the high-speed motion component. This initialization of the Gaussian mixture model parameters is then completed. Based on the pixel motion displacement vector, the displacement vector of each pixel in the first frame image is obtained, and the overall covariance matrix is ​​calculated. The overall covariance matrix is ​​then configured with component differentiation to obtain the covariance matrices of the three Gaussian components. For example, the covariance matrix of the medium-speed motion component is 1 times the overall covariance matrix, and the covariance matrix of the high-speed motion component is 4 times the overall covariance matrix. The parameters of the Gaussian mixture model are then updated online. Based on the obtained pixel motion displacement vector, the minimum value between the pixel motion displacement vector and the mean vector of each Gaussian component is calculated. Mahalanobis distance, based on the statistical characteristic that pixel motion displacement vectors follow a two-dimensional Gaussian distribution, sets the Gaussian component matching threshold by taking the square root of the critical value of the chi-square distribution at the significance level. If the minimum Mahalanobis distance is less than the Gaussian component matching threshold, the Gaussian component is considered to be successfully matched. For successfully matched Gaussian components, the weight coefficients, component mean, and covariance matrix of the three Gaussian components are updated using an adaptive learning rate; otherwise, the match is unsuccessful. For unmatched Gaussian components, the weight coefficients of the Gaussian components are reduced by a fixed decay rate, and all weight coefficients are normalized. The maximum value is extracted from the weight coefficients of the normalized Gaussian components as the weight value of the static background component, completing the online update of the Gaussian mixture model parameters. Based on the Gaussian mixture model parameters, the probability value of the pixel motion displacement vector is calculated through the probability density function. The probability values ​​of all pixel motion displacement vectors are integrated to generate the scene dynamic feature distribution.

[0090] The Euclidean norm of the robot trajectory error and the motion intensity of the scene dynamic feature distribution are calculated respectively, and the scene complexity is obtained by nonlinear coupling through weighted linear superposition and Sigmoid compression.

[0091] Furthermore, based on the robot trajectory error, the three-dimensional Euclidean norm is calculated as the trajectory deviation. At the same time, the probability values ​​of all pixel motion displacement vectors in the scene dynamic feature distribution are extracted and the arithmetic mean is calculated to generate the scalar form of motion intensity. The trajectory deviation and motion intensity are linearly weighted and superimposed according to a predetermined weight coefficient (for example, the fixed value of the trajectory error weight coefficient is 0.7, and the scene dynamic feature distribution weight coefficient is 0.3). Then, the result is input into a Sigmoid-type nonlinear function to perform interval compression operation and output the standardized scene complexity.

[0092] The expression for exercise intensity is:

[0093] ;

[0094] Where B represents the motion intensity, E represents the image height of the scene dynamic feature distribution (e.g., 720 pixels), and F represents the image width of the scene dynamic feature distribution (e.g., 1280 pixels). For the dynamic feature distribution of the scene, For pixels The probability value of the pixel motion displacement vector.

[0095] The expression for scene complexity is:

[0096] ;

[0097] Where A represents the scene complexity. It is a Sigmoid-type nonlinear function. Let be the Euclidean norm of the robot trajectory error. This is the trajectory error weighting coefficient (with a value range of 0.65 to 0.75). The weight coefficients for the dynamic feature distribution of the scene (within the range of 0.25 to 0.35).

[0098] Perform forward propagation of a nonlinear mapping network on the scene complexity to generate a weight configuration vector.

[0099] Furthermore, the nonlinear mapping network consists of three layers: a first single-neuron input layer to receive scene complexity, a second ten-neuron hidden layer, and a third hundred-neuron linear output layer. Based on scene complexity, an optimal weight vector is generated through an embedded model prediction controller. Based on scene complexity and the optimal weight vector, the network parameters of the nonlinear mapping network are iteratively updated using a mean squared error loss function and an Adam optimizer. Training terminates when the prediction error of the weight configuration vector in multiple consecutive validation cycles is lower than the resolution of the application scenario. For example, training terminates when the prediction error of five consecutive weight configuration vectors is less than the resolution of precision assembly (0.01 m). The network parameters are converted into industry-standard FPGA executable firmware, generating a deployment-ready nonlinear mapping network. The scene complexity is input into the first neuron input layer to perform linear weighted calculation to generate initial feature values. The initial feature values ​​are then nonlinearly transformed using the ReLU activation function and passed to the second ten-neuron hidden layer for weight biasing calculation to generate activation feature vectors. These activation feature vectors are input into the hundred-neuron linear output layer, and the linear transformation results of the third hundred neurons are integrated to generate a weight configuration vector containing one hundred elements.

[0100] The weight configuration vector is filled in row-major order to generate an initial matrix. The initial matrix is ​​then subjected to positive definiteness forced correction and reconstructed into a weight matrix.

[0101] Furthermore, based on the weight configuration vector, the vector elements are filled into the matrix frame in row-major order to generate an initial weight matrix. For example, the first ten elements form the first row, the eleventh to twentieth elements form the second row, and so on, resulting in a ten-row, ten-column initial weight matrix. Eigenvalue decomposition is performed on the initial matrix to obtain an eigenvector matrix, the transpose of the eigenvector matrix, and an eigenvalue diagonal matrix. The smallest effective eigenvalue (positive value) in the eigenvalue diagonal matrix is ​​detected. This smallest effective eigenvalue is used as the upper limit benchmark for the preset minimum positive value. Simultaneously, the lower limit benchmark for the preset minimum positive value is determined based on the joint output torque and safety factor amplification mechanism. The preset minimum positive value is generated through a dual constraint mechanism. When any negative eigenvalue is detected in the eigenvalue diagonal matrix (not specifically the smallest effective eigenvalue), it is replaced with the preset minimum positive value. For example, if a negative eigenvalue is detected, it is replaced with a certain minimum positive value. The modified eigenvalue diagonal matrix is ​​generated. The eigenvector matrix, the modified eigenvalue diagonal matrix, and the transpose of the eigenvector matrix are multiplied together to reconstruct a symmetric positive definite weight matrix.

[0102] The equation solving module is used to construct and solve the robot's dynamic equations based on the weight matrix, generating the robot's joint control torques.

[0103] The correction factor of the inertia matrix is ​​extracted based on the weight matrix, and the robot dynamic equation is constructed. The Newton-Euler iterative algorithm is used to solve the robot dynamic equation and generate the original joint torque.

[0104] Furthermore, the DH parameters in the robot configuration parameters are loaded, the link mass and center of mass position of the robot are obtained, the moment of inertia is calculated, the standard inertia matrix of the robot is obtained, the submatrix in the upper left corner of the weight matrix is ​​extracted as the correction factor of the inertia matrix, and the correction factor is multiplied element-wise with the standard inertia matrix of the robot to generate a weighted inertia matrix.

[0105] The expression for the weighted inertia matrix is:

[0106] ;

[0107] in, For the weighted inertia matrix, For the standard inertia matrix, This is a correction factor.

[0108] The robot dynamic equations are constructed based on the weighted inertia matrix and the joint angles and angular velocities in the robot body data. The joint angular velocities are obtained by differential calculation to obtain the joint angular acceleration. The Newton-Euler iterative solution algorithm is executed based on the robot dynamic equations. The link acceleration is calculated by forward kinematics transfer and the joint torque is recursively derived by backward dynamics to generate the original joint torque.

[0109] The expression for the robot's dynamic equations is:

[0110] ;

[0111] in, Joint angular acceleration, For the Coriolis-centripetal matrix, The joint angular velocity, For gravity compensation, N is the acceleration due to gravity. For joint angle, The original joint torque is the one to be solved.

[0112] The rated torque parameters of the load joint motor and the mechanical transmission safety factor are used to calculate the dynamic safety threshold.

[0113] Furthermore, the rated torque parameters of each joint motor (provided by the motor manufacturer's technical manual) are loaded from the robot body database. At the same time, the safety factor scalar value of the mechanical transmission component (usually 0.8) is called. The rated torque parameters of each joint and the safety factor scalar value are multiplied by a scalar operation to generate the dynamic safety threshold of each joint. For example, in the KUKA KR500 robot, the dynamic safety threshold ranges from 85 to 608 N·m.

[0114] Based on a dynamic safety threshold, the original joint torque is subjected to bidirectional saturation limiting processing to generate the robot's joint control torque.

[0115] Furthermore, the absolute values ​​of the original joint torque and the dynamic safety threshold are compared joint by joint. If the original joint torque is greater than the dynamic safety threshold, a positive safety boundary value is obtained. If the original joint torque is less than the negative dynamic safety threshold, a negative safety boundary value is obtained. If the original joint torque is within the range of the positive and negative safety boundary values, the joint control torque of the robot that meets the hardware safety constraints is generated; otherwise, the original joint torque is maintained.

[0116] The distributed execution module is used to transmit joint control torque to the robot joints through distributed actuators, driving the robot to complete the target motion.

[0117] The joint control torque of the robot is transmitted to the corresponding robot joint, and after decoding and signal conversion, joint torque commands are generated.

[0118] Furthermore, the joint control torque is encoded into data frames via the Industrial Ethernet protocol. These frames are then routed by the distributed actuator to the corresponding robot joint driver based on the built-in physical address of the robot joint. The robot joint driver decodes the data frames to restore the joint control torque and uses a digital-to-analog converter circuit to generate joint torque commands in the form of analog voltages to drive the robot joints.

[0119] The robot converts joint torque commands into target drive current values ​​through its joints, and then generates motor drive current signals through power amplification.

[0120] Furthermore, the robot joint actuator receives joint torque commands, calculates the target drive current value through the torque-current conversion coefficient inside the robot joint actuator, generates a PWM modulation waveform based on the target drive current value using a current loop control algorithm, and drives the power amplifier to output the motor drive current signal.

[0121] The robot body is driven to complete the target motion by electromagnetic conversion of the motor drive current signal.

[0122] Furthermore, the motor drive current signal is input into the stator winding of the joint motor to generate a rotating magnetic field. Based on the rotating magnetic field, the rotor is driven to output electromagnetic torque using the principle of electromagnetic induction. The electromagnetic torque is converted into the joint motor output torque through a mechanical transmission mechanism. All the joint motor output torques work together under the spatiotemporal synchronization constraint to drive the robot body to complete the target motion.

[0123] In summary, this invention reduces data dimensionality and memory usage by voxelizing point clouds; it breaks through the limitation of traditional SLAM that only extracts geometric features by fusing spatial occupancy information and environmental topology through quantum entangled feature vectors; it achieves environmental adaptive compensation by driving a decision-maker with quantum features, making the trajectory error lower than that of traditional PID control; it quantifies the dynamic intensity of the environment by using a motion probability field, coupling trajectory error to generate scene complexity, thereby improving the accuracy of dynamic feature extraction in extreme environments; and it reduces trajectory deviation when the load changes abruptly by correcting dynamic parameters in real time through a weighted inertia matrix.

[0124] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. An artificial intelligence based robot motion control system characterized in that: Comprising, a data acquisition module for converting the collected environmental point cloud data into a voxel grid, collecting robot body data and environmental dynamic sequence images; a quantum encoding module for calculating the real-time position of the robot based on the robot body data through forward kinematics, synchronously constructing a pose transformation matrix, performing coordinate transformation on the voxel grid using the pose transformation matrix, and generating a quantum state entanglement feature vector, the specific steps being as follows, extracting joint angles, body angular velocities and base calibration matrices based on the robot body data; calculating the real-time position of the robot by solving the joint angles through forward kinematics; constructing a pose transformation matrix based on the body angular velocities and the base calibration matrix of the robot; performing coordinate transformation on the voxel grid using the pose transformation matrix, extracting three-dimensional voxel data of all occupancy voxel units based on the transformed voxel grid, and generating a quantum state entanglement feature vector through quantum amplitude encoding; a learning decision module for inputting the quantum state entanglement feature vector into the meta reinforcement learning decision maker, inputting the real-time position of the robot and the preset movement trajectory of the robot at the same time, and generating a robot trajectory error through vector difference operation; a reconstruction matrix module for establishing a mixed Gaussian model based on the environmental dynamic sequence images, generating a scene dynamic feature distribution, calculating the scene complexity based on the robot trajectory error and the scene dynamic feature distribution, converting the scene complexity into a weight configuration vector through a nonlinear mapping network, and reconstructing the weight configuration vector into a weight matrix, the specific steps for generating the scene dynamic feature distribution being as follows, performing grayscale conversion on the environmental dynamic sequence images to generate a single-channel grayscale intensity matrix, and calculating pixel motion displacement vectors through an optical flow algorithm; based on the pixel motion displacement vectors, constructing a three-component mixed Gaussian model mathematical structure for each pixel position to complete the construction of the mixed Gaussian model; updating the parameters of the mixed Gaussian model based on the pixel motion displacement vectors, and generating a scene dynamic feature distribution through motion probability calculation; the specific steps for reconstructing the weight configuration vector into a weight matrix are as follows, calculating the Euclidean norm of the robot trajectory error and the motion intensity of the scene dynamic feature distribution respectively, and obtaining the scene complexity through weighted linear superposition and nonlinear coupling of Sigmoid compression; the motion intensity of the scene dynamic feature distribution refers to extracting the probability values of all pixel motion displacement vectors in the scene dynamic feature distribution, performing arithmetic average calculation, and generating a scalar form of motion intensity; performing forward propagation of the nonlinear mapping network on the scene complexity to generate a weight configuration vector; filling the weight configuration vector to generate an initial matrix in row priority order, performing positive definite forced correction on the initial matrix, and reconstructing it into a weight matrix; an equation solving module for constructing a robot dynamic equation based on the weight matrix and solving it to generate the joint control torque of the robot; a distributed execution module for transmitting the joint control torque to the robot joints through a distributed actuator to drive the robot to complete the target motion.

2. The artificial intelligence based robot motion control system as claimed in claim 1 wherein: perform coordinate system conversion and voxel mapping based on the collected environmental point cloud data, create a three-dimensional voxel grid space, and convert it into a voxel grid through occupancy filling.

3. The artificial intelligence based robot motion control system as claimed in claim 1 wherein: The robot trajectory error is generated, and the specific steps are as follows, Load the quantum state entanglement feature vector, the real-time position of the robot, and the preset moving trajectory of the robot, and align the time stamps; The timestamp-aligned quantum state entanglement feature vector and the real-time position of the robot are input into the meta-reinforcement learning decision maker to output the expected position correction value at the current time; Based on the robot preset moving trajectory, the theoretical expected position is analyzed, and the expected position correction value at the current time is superimposed to generate the final expected position. The robot trajectory error is generated by calculating the difference between the real-time position of the robot and the final expected position.

4. The artificial intelligence based robot motion control system as claimed in claim 1 wherein: The joint control torque of the robot is generated, and the specific steps are as follows, Based on the weight matrix, the correction factor of the inertia matrix is extracted, and the robot dynamic equation is constructed. The Newton-Euler iterative algorithm is used to solve the robot dynamic equation to generate the original joint torque; Load the rated torque parameters of the joint motor and the mechanical transmission safety factor to calculate the dynamic safety threshold; Based on the dynamic safety threshold, the original joint torque is subjected to bidirectional saturation limiting processing to generate the joint control torque of the robot.

5. The artificial intelligence based robot motion control system as claimed in claim 1 wherein: The robot completes the target motion, and the specific steps are as follows, The joint control torque of the robot is transmitted to the corresponding robot joint, and after decoding and signal conversion, the joint torque instruction is generated; Through the robot joint, the joint torque instruction is converted into a target drive current value, and a motor drive current signal is generated through power amplification; Based on the motor drive current signal, electromagnetic conversion is performed to drive the robot to complete the target motion.

6. The artificial intelligence based robotic motion control system as claimed in claim 1 wherein: The scene complexity is obtained, and the specific steps are as follows, The Euclidean norm is calculated based on the robot trajectory error as the trajectory deviation; The trajectory deviation and the motion intensity are linearly weighted and superimposed according to the predetermined weight coefficient, and then input into the Sigmoid nonlinear function to perform interval compression operation, and the standardized scene complexity is output.

7. The artificial intelligence based robotic motion control system as claimed in claim 1 wherein: The pose conversion matrix is constructed, and the specific steps are as follows, Based on the body angular velocity, the attitude angle offset is calculated by integration; Based on the attitude angle offset, the rotation matrix calculation operation is performed to generate the rotation compensation matrix; Load the base calibration matrix of the robot, and construct the pose conversion matrix based on the rotation compensation matrix and the base calibration matrix.

Images