Electronic shaft printing machine control method and system based on Internet of Things

Abstract

The invention discloses an electronic shaft printing machine control method and system based on the Internet of Things, and the method comprises the steps: collecting a printing tension value, a color register deviation image and motor rotating speed data in the operation process of an electronic shaft printing machine in real time, and generating a multi-source synchronous data set with a timestamp; performing sub-pixel-level edge extraction on the color register deviation image, and outputting a color register error feature vector; uploading the multi-source synchronous data set and the color register error feature vector to a cloud Internet of Things platform, and generating a cooperative control parameter packet containing a tension compensation coefficient and a color register correction amount by associating a historical fault database with a material characteristic parameter; generating a rotating speed adjustment instruction set of the servo motor based on the cooperative control parameter packet; and the rotating speed adjusting instruction set is issued to the PLC control system, and rotating speed closed-loop control is executed through the servo driver. According to the embodiment of the invention, high-precision self-adaptive adjustment in the printing process can be realized.

Description

Technical Field

[0001] This invention belongs to the field of Internet of Things (IoT) technology, specifically an IoT-based electronic shaft printing machine control method and system. Background Technology

[0002] Traditional electronic shaft printing presses often employ localized, independent control methods, separating tension control from color registration correction. This results in lag in dynamic response and poor coordination of multi-source data. Especially in high-speed printing, existing technologies struggle to achieve real-time compensation for sub-pixel-level color registration errors and lack adaptive optimization capabilities based on historical data, making them susceptible to cumulative errors caused by changes in material properties or mechanical wear. Furthermore, traditional PLC control relies on fixed parameters, hindering global optimization through cloud-based collaboration and limiting further improvements in printing accuracy. The introduction of IoT technology offers new avenues for multi-source data fusion and remote collaborative control; however, existing solutions still have technological gaps in areas such as tension-color registration coupling control and model predictive optimization. Summary of the Invention

[0003] The purpose of this invention is to provide an electronic shaft printing machine control method and system based on the Internet of Things, so as to overcome the shortcomings of the prior art and achieve high-precision adaptive adjustment of the printing process.

[0004] One embodiment of this application provides an IoT-based electronic shaft printing machine control method, the method comprising: The printing tension value, color registration deviation image and motor speed data of the electronic shaft printing machine are collected in real time during operation. Data filtering and timestamp alignment are performed to generate a multi-source synchronous dataset with timestamps. Subpixel-level edge extraction is performed on the color mismatch image. Combined with preset vertical / horizontal tolerance thresholds, the real-time offset of each color group in the machine direction and horizontal direction is calculated, and the color mismatch feature vector is output. The multi-source synchronous dataset and the color matching error feature vector are uploaded to the cloud IoT platform. By associating the historical fault database and material property parameters, a collaborative control parameter package containing tension compensation coefficient and color matching correction amount is generated. Based on the aforementioned collaborative control parameter package, a model predictive control algorithm is used to optimize tension stability and color matching accuracy targets in parallel, generating a set of speed adjustment instructions for the servo motor. The color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. The speed adjustment instruction set is sent to the PLC control system, and the speed closed-loop control is executed through the servo driver.

[0005] Optionally, the real-time acquisition of printing tension values, color registration deviation images, and motor speed data during the operation of the electronic shaft printing machine, followed by data filtering and timestamp alignment, generates a multi-source synchronized dataset with timestamps, including: The printing tension value is acquired in real time by a fiber Bragg grating sensor array, and the mechanical vibration interference is eliminated by wavelength demodulation technology to output the original anti-interference tension signal. High-speed industrial cameras are used to capture color-marked images, and LED strobe synchronization technology is used to freeze motion blur, outputting original images without blurring or color-marking deviation. A Hall effect encoder is used to acquire motor speed pulse signals, and an adaptive sliding window filter is used to suppress electromagnetic noise, outputting a smooth digital speed sequence. The original anti-disturbance tension signal, the original image without blurring color deviation, and the smoothed speed digital sequence are input into the hardware time synchronization module. Based on the IEEE 1588 precise clock protocol, the timestamps are aligned to generate a multi-source synchronization dataset with nanosecond-level time tags.

[0006] Optionally, the step of performing sub-pixel-level edge extraction on the color mismatch image, combined with preset vertical / horizontal tolerance thresholds, calculating the real-time offset of each color group in the machine direction and horizontal direction, and outputting a color mismatch feature vector includes: The Zernike moment subpixel edge detection algorithm is applied to the original image without blurring or color misalignment to locate the color-marked edges with a precision of 0.1 pixels and output the subpixel edge coordinate sequence. Based on the sub-pixel edge coordinate sequence, the center point of each color group marker is fitted by the least squares method, and the coordinate matrix of the color group center point is output. The coordinate matrix of the color group center point is compared with the preset reference template. The machine direction and the instantaneous offset of the horizontal direction are calculated by combining the vertical / horizontal tolerance thresholds, and the original offset vector is output. The original offset vector is dynamically corrected by Kalman filtering to suppress measurement jitter error, and the filtered offset sequence is output. The offset sequences after filtering of each color group are integrated and normalized into machine orientation offset components and lateral offset components to generate a color registration error feature vector.

[0007] Optionally, the step of uploading the multi-source synchronous dataset and the color matching error feature vector to the cloud-based IoT platform, and generating a collaborative control parameter package containing tension compensation coefficients and color matching correction amounts by associating it with historical fault databases and material property parameters, includes: The multi-source synchronized dataset and the color matching error feature vector are encapsulated into an IoT message, which is then encrypted and uploaded to the cloud IoT platform via the MQTT protocol, outputting an encrypted data stream. After the cloud-based IoT platform parses the encrypted data stream, it associates the material property parameter library and the historical fault database, and outputs the environment-history joint feature matrix. The environmental-historical joint feature matrix is ​​input into the digital twin engine, and the initial values ​​of tension compensation coefficient and color correction amount are calculated through the physical simulation model, and the initial control parameter set is output. The initial control parameter set is verified under real-time operating conditions to generate a cooperative control parameter package that meets the safety boundaries.

[0008] Optionally, based on the collaborative control parameter package, a model predictive control algorithm is used to optimize tension stability and color matching accuracy targets in parallel, generating a servo motor speed adjustment instruction set. The color matching accuracy control satisfies that both longitudinal and lateral errors do not exceed tolerance thresholds, including: Tension compensation coefficients and color correction values ​​are extracted from the collaborative control parameter package to construct a multi-objective optimization cost function. The tension stability objective is to minimize the tension value variance, and the color accuracy objective is to constrain the longitudinal / lateral error to be less than or equal to the tolerance threshold. Establish a state-space model of the servo motor, discretize the cost function into a rolling time-domain optimization problem, and output the predictive control equations; The predictive control equations are solved in parallel using a particle swarm optimization algorithm, and the tension and color matching targets are optimized simultaneously to output the speed adjustment sequence for the next 5 control cycles. The speed adjustment sequence is subjected to S-curve acceleration and deceleration constraint processing to output a smooth speed command sequence; The smooth speed command sequence is grouped by color group to generate a servo motor speed adjustment command set.

[0009] Optionally, the step of sending the speed adjustment instruction set to the PLC control system and executing closed-loop speed control through the servo driver includes: The servo motor speed adjustment instruction set is encoded into an industrial Ethernet EtherCAT frame structure, embedded with a time-sensitive network scheduling tag, and outputs a time-deterministic control instruction stream. The control command stream is sent to the PLC control system through the OPC UA protocol, and the real-time data pipeline is used to ensure that the command transmission delay is less than 1ms, and the synchronous command set is output. After parsing the synchronization instruction set, the PLC drives the servo driver to enable the servo driver to perform closed-loop speed control.

[0010] Another embodiment of this application provides an Internet of Things-based electronic shaft printing machine control system, the system comprising: The acquisition module is used to acquire printing tension values, color registration deviation images, and motor speed data in real time during the operation of the electronic shaft printing machine, and to perform data filtering and timestamp alignment to generate a multi-source synchronous dataset with timestamps. The extraction module is used to perform sub-pixel level edge extraction on the color mismatch image, and calculate the real-time offset of each color group in the machine direction and the horizontal direction by combining the preset vertical / horizontal tolerance thresholds, and output the color mismatch feature vector. The upload module is used to upload the multi-source synchronous dataset and the color matching error feature vector to the cloud IoT platform, and generate a collaborative control parameter package containing tension compensation coefficient and color matching correction amount by associating the historical fault database and material property parameters. The optimization module is used to optimize the tension stability and color matching accuracy targets in parallel using a model predictive control algorithm based on the cooperative control parameter package, and generate a set of speed adjustment instructions for the servo motor. The color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. The control module is used to send the speed adjustment instruction set to the PLC control system and execute closed-loop speed control through the servo driver.

[0011] Another embodiment of this application provides a storage medium storing a computer program, wherein the computer program is configured to execute the method described in any of the preceding claims when running.

[0012] Another embodiment of this application provides an electronic device including a memory and a processor, wherein the memory stores a computer program and the processor is configured to run the computer program to perform the method described in any of the preceding claims.

[0013] Compared with existing technologies, this invention provides an IoT-based electronic shaft printing machine control method that collects printing tension values, color registration deviation images, and motor speed data in real time during the operation of the electronic shaft printing machine, generating a timestamped multi-source synchronous dataset; performs sub-pixel-level edge extraction on the color registration deviation images, outputting a color registration error feature vector; uploads the multi-source synchronous dataset and the color registration error feature vector to a cloud-based IoT platform, and generates a collaborative control parameter package containing tension compensation coefficients and color registration correction amounts by associating it with a historical fault database and material characteristic parameters; generates a servo motor speed adjustment instruction set based on the collaborative control parameter package; and sends the speed adjustment instruction set to the PLC control system, which executes closed-loop speed control through the servo driver, thereby achieving high-precision adaptive adjustment of the printing process. Attached Figure Description

[0014] Figure 1 A hardware structure block diagram of a computer terminal for an IoT-based electronic shaft printing machine control method provided in an embodiment of the present invention; Figure 2 A flowchart illustrating an IoT-based electronic shaft printing machine control method provided in an embodiment of the present invention; Figure 3This is a schematic diagram of the structure of an electronic shaft printing machine control system based on the Internet of Things, provided as an embodiment of the present invention. Detailed Implementation

[0015] The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0016] The present invention first provides an Internet of Things-based electronic shaft printing machine control method, which can be applied to electronic devices, such as computer terminals, specifically ordinary computers.

[0017] The following detailed explanation uses a computer terminal as an example. Figure 1 This is a hardware structure block diagram of a computer terminal for an IoT-based electronic shaft printing press control method provided in an embodiment of the present invention. (See diagram below.) Figure 1 As shown, the computer device includes a processor, memory, and network interface connected via a system bus, wherein the memory may include non-volatile storage media and internal memory.

[0018] The non-volatile storage medium can store an operating system and a computer program. This computer program includes program instructions that, when executed, cause the processor to perform any Internet of Things-based electronic shaft printing press control method.

[0019] The processor provides computing and control capabilities, supporting the operation of the entire computer device.

[0020] The internal memory provides an environment for the execution of computer programs in non-volatile storage media. When the computer program is executed by the processor, it enables the processor to execute any Internet of Things-based electronic shaft printing press control method.

[0021] This network interface is used for network communication, such as sending assigned tasks. Those skilled in the art will understand that... Figure 1 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0022] It should be understood that the processor can be a Central Processing Unit (CPU), but it can also be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Among these, a general-purpose processor can be a microprocessor or any conventional processor.

[0023] See Figure 2 The present invention provides an Internet of Things-based electronic shaft printing machine control method, which may include the following steps: S201 collects printing tension values, color registration deviation images, and motor speed data in real time during the operation of the electronic shaft printing machine, and performs data filtering and timestamp alignment to generate a multi-source synchronous dataset with timestamps. Specifically, the printing tension value can be acquired in real time through a fiber Bragg grating sensor array, and wavelength demodulation technology can be used to eliminate mechanical vibration interference and output the original anti-interference tension signal. Deployment and Data Acquisition of Fiber Bragg Grating Sensor Arrays In critical tension control areas of the electronic shaft printing press (such as the unwinding unit, traction rollers between color groups, and the rewinding unit), a fiber Bragg grating sensor array (FBG array) is installed. This array consists of multiple cascaded fiber Bragg grating sensors. Each sensor uses an ultraviolet laser to etch a periodic refractive index modulation structure into the fiber core, forming a specific reflection wavelength (e.g., 1550 nm). When the tension of the printing material (e.g., film, paper) changes, the stress exerted on the sensor causes periodic deformation of the grating, resulting in a wavelength shift (WS). Each FBG sensor in the array is preset with a different initial reflection wavelength (e.g., 1520 nm, 1540 nm, 1560 nm), and multiple signals are transmitted in a single fiber using wavelength division multiplexing (WDM) technology. During printing, the Broadband Light Source (BLS) emits light signals into the optical fiber. The High-Speed ​​Spectrometer (HSS) captures the reflection spectra of all FBG sensors in real time at a sampling rate (SR) of thousands of times per second, resolving the wavelength shift Δλ of each sensor. Based on the stress-wavelength linear relationship of the fiber Bragg grating (sensitivity coefficient approximately 1.2 picometers / microstrain pm / με), Δλ is converted into a microstrain value (με), and then combined with the material's elastic modulus to calculate the Printing Tension Raw Value (PTRV), in units of Newtons (N) or Newtons per meter (N / m).

[0024] Wavelength demodulation technology eliminates mechanical vibration interference When a printing press operates at high speed, mechanical vibrations such as the meshing of roller gears and the rotation of bearings generate high-frequency interference signals (frequency range 5-200 Hz), which are superimposed on the actual tension signal. To eliminate this interference, Dynamic Wavelength Demodulation (DWD) technology is employed. The core of this technology is the design of a dual-channel demodulation algorithm: the main channel analyzes the peak wavelength (PW) of the FBG reflection spectrum; the auxiliary channel simultaneously acquires data from a vibration accelerometer (VA) sensor (such as a triaxial accelerometer mounted on the printing press frame). The demodulation system incorporates an Adaptive Vibration Filter (AVF), which analyzes the spectral characteristics of the accelerometer signal using a Fast Fourier Transform (FFT) to identify the dominant vibration frequency (DVF) and amplitude (AMP). For example, if the fundamental frequency of gear meshing is detected to be 85Hz with an amplitude of 0.3g (g is the acceleration due to gravity), a corresponding band-stop filter (BSF) is generated to subtract the wavelength jitter caused by this frequency component (typical interference amplitude ±0.05nm) in real time during wavelength demodulation. Simultaneously, the spatial correlation (SC) of adjacent FBG sensors is used to verify outliers: if a sensor's data changes abruptly but adjacent points remain unchanged, it is determined to be local interference and is removed. Finally, the vibration-immmune tension raw signal (VITRS) after removing vibration noise is output, with a signal accuracy of ±0.5% of full scale (FS).

[0025] Anti-interference signal output and real-time performance guarantee The demodulated VITRS signal is processed in real-time via a Field-Programmable Gate Array (FPGA). The FPGA incorporates a Signal Integrity Check Module (SIMM) to perform triple verification of the validity of each sampling point: whether the wavelength drift is within a physically reasonable range (e.g., ±2nm), whether the signal rate of change exceeds the material fracture threshold (e.g., 500N / s), and whether there is residual high-frequency noise in the spectral energy (analyzed via Short-Time Fourier Transform (STFT)). Verified data is appended with a Device ID (DID) and a preliminary timestamp (TS1) and transmitted to the central processing unit via Gigabit Ethernet (GbE). The entire process latency is controlled within 200 microseconds (μs) to ensure the real-time performance of the tension signal meets the requirements of high-speed printing control (typical control cycle 1 millisecond (ms)).

[0026] High-speed industrial cameras are used to capture color-marked images, and LED strobe synchronization technology is used to freeze motion blur, outputting original images without blurring or color-marking deviation. High-speed industrial cameras and color marking imaging systems A high-speed industrial camera (HSIC) is installed downstream of each color unit (CU) on the printing press. Typical models feature a capture rate of 500 frames per second (FPS) and 4K resolution (4096×2160 pixels). The camera lens is equipped with a telecentric design to ensure perspective-free imaging even with material jitter or thickness variations. The target is the pre-defined register mark (RM) on the edge of the printed material, typically a crosshair or L-shaped pattern (0.5 mm line width), printed with high-contrast inks (such as black). The camera is mounted perpendicular to the material plane, and a high-brightness coaxial light source (CLS) is used to reduce surface reflection interference. The camera trigger mode is set to Position Trigger (PT): When the photo-electric marker (PEM) on the material passes the color group photoelectric sensor, a trigger pulse (TP) is generated. The camera starts the exposure after a preset delay (such as 10 milliseconds ms) to ensure that the marker is in the center of the field of view.

[0027] LED strobe synchronization technology eliminates motion blur. When printing materials move at high speeds (typically 300 m / min), motion blur (MB) occurs if the camera exposure time (ET) exceeds 0.1 ms. To address this issue, a nanosecond LED strobe light (NSL) is used as the main illumination. The strobe controller (SC) receives the real-time position signal (PS) from the printing press main shaft encoder (MSE) and uses phase-locked loop (PLL) technology to ensure strict synchronization between the LED pulses and the material movement. The strobe parameters are dynamically adjusted: the required strobe duration (SD) is calculated based on the material speed (MS), for example, setting SD to 5 microseconds (μs) at a speed of 300 m / min (equivalent to a material movement of 0.025 mm); the strobe intensity (SI) is controlled via a photodiode (PD) feedback closed-loop to ensure constant image brightness. The camera exposure time is set slightly longer than SD (e.g., 10μs) to complete the imaging in the instant of stroboscopic movement, which is equivalent to "freezing" the high-speed moving marker, and the image spatial resolution error is less than 0.01 mm.

[0028] Generation of original images without blurring or color misregistration The raw image (RI) captured by the camera is transmitted to the Image Preprocessing Unit (IPU). The IPU performs a three-step optimization: first, flat-field correction (FFC) is applied to eliminate lens vignetting and uneven lighting using a reference whiteboard image; second, dynamic background segmentation (DBS) is performed, adaptively thresholding the marker region based on the difference in grayscale histograms between the marker and the background; finally, pixel-level sharpening (PLS) is performed, using the Laplacian operator to enhance edge contrast. The processed image achieves a marker edge sharpness (ES) of over 90% (based on a modulation transfer function (MTF) > 0.9), and a marker centering accuracy of ±1 pixel. The final output is a blur-free registered deviance raw image (BFRDRI), stored as a 12-bit grayscale bitmap (BMP) format, with an appended camera ID (CID) and a precise trigger timestamp TS2.

[0029] A Hall effect encoder is used to acquire motor speed pulse signals, and an adaptive sliding window filter is used to suppress electromagnetic noise, outputting a smooth digital speed sequence. Signal acquisition mechanism of Hall effect encoder Each servo motor (SM) of the electronic shaft printer is equipped with a Hall Effect Encoder (HEE) at its shaft end, typically with a resolution of 17 bits (131,072 pulses / revolution). The encoder consists of a magnetic ring (MR) and a Hall sensor array (HSA). As the motor rotates, the north and south poles of the magnetic ring alternately pass through the sensor, and the Hall element generates a sine / cosine analog signal (SCAS) based on the magnetoresistive effect. After common-mode noise is eliminated by a differential amplifier (DA), the signal is input to a high-speed analog-to-digital converter (ADC) to be converted into a digital pulse sequence (DPS). Each pulse corresponds to a fixed angular displacement (e.g., 0.0027 degrees / pulse). The pulse frequency (PF) is proportional to the motor speed (MS): MS (rpm) = (PF × 60) / encoder resolution (PPR).

[0030] Adaptive sliding window filtering suppresses electromagnetic noise The power device switching of a servo drive (SD) (typically 8 kHz) generates strong electromagnetic interference (EMI), causing glitches or signal loss in the pulse signal. An adaptive sliding window filter (ASWF) is used to address this. Dynamic window width adjustment: The initial window width (WW) is set to 10 pulse periods (PP). The frequency change rate (FCR) is calculated in real time. If the FCR exceeds a threshold (e.g., 500 rpm / s), WW is dynamically reduced to 5 PP to improve response speed; if the FCR is below the threshold, WW is increased to 20 PP to enhance the filtering effect.

[0031] Pulse validity verification: Within a window, a two-out-of-three voting process (TTV) is performed on the pulse timing. For example, if the interval time (IT) of three consecutive pulses is T1, T2, and T3, and |T2-T1| > the tolerance (e.g., ±10%), and |T3-T2| ≤ the tolerance, then T2 is determined to be an interference pulse and is discarded.

[0032] Frequency smoothing algorithm: The instantaneous frequency (IF) is calculated based on the effective pulse, and then filtered by the exponentially weighted moving average (EWMA). The smoothing factor (SF) is adaptively adjusted according to the fluctuation of the rotational speed: SF=0.8 (strong tracking) when the fluctuation is high, and SF=0.3 (strong smoothing) when the fluctuation is low.

[0033] Smooth speed digital sequence output The filtered pulse sequence is input to the Angle-Velocity Conversion Module (AVCM). This module uses a Time-to-Digital Converter (TDC) to measure the time interval Δt between adjacent valid pulses (accuracy ±1 nanosecond ns), and calculates the instantaneous rotational speed using the formula: Instantaneous Speed ​​(IS) = (60 × number of pulses per encoder revolution) / (Δt × resolution).

[0034] The calculation results are packaged into a Smoothed Speed ​​Digital Sequence (SSDS) according to the control cycle (e.g., 1ms), with the data format being 32-bit floating-point numbers (Float 32) in rpm. The sequence is appended with a Motor ID (MID) and a synchronization timestamp TS3, and transmission integrity is ensured through Cyclic Redundancy Check (CRC). Ultimately, the Speed ​​Fluctuation Ratio (SFR) of the SSDS is controlled within ±0.05% (at rated speed).

[0035] The original anti-disturbance tension signal, the original image without blurring color deviation, and the smoothed speed digital sequence are input into the hardware time synchronization module. Based on the IEEE 1588 precise clock protocol, the timestamps are aligned to generate a multi-source synchronization dataset with nanosecond-level time tags.

[0036] Time synchronization architecture of the IEEE 1588 protocol Deploying a Precision Clock Synchronization System (PCSS) in the printing press control cabinet includes: Grandmaster Clock (GC): Employs a temperature-compensated crystal oscillator (TCXO) or an oven-controlled crystal oscillator (OCXO) with a time accuracy of ±100 nanoseconds.

[0037] Boundary Clock (BC): Integrated into the switch, supporting the IEEE 1588v2 protocol (i.e., PTPv2).

[0038] Slave Clock (SC): Embedded in the FPGA of various sensors and PLCs (Programmable Logic Controllers).

[0039] The synchronization process uses a two-step timestamping mode: the master clock periodically sends a synchronization message and records the sending time t1; the slave clock records the receiving time t2; the master clock then sends a follow-up message carrying t1; the slave clock calculates the network delay (ND) = (t2-t1) - (clock offset) and finally corrects the local clock.

[0040] Time alignment of multi-source data The hardware time synchronization module (HTSM) for each sensor data input is an FPGA-implemented PTP slave clock. Data reception and buffering: VITRS (tension), BFRDRI (image), and SSDS (speed) are stored in a FIFO (First In First Out) queue with a timestamped register (TR).

[0041] Precise timestamp marking: When a data packet arrives at the HTSM, a hardware interrupt (HI) is triggered. The FPGA reads the current PTP slave clock time (accuracy ±50ns) as the arrival timestamp (ATS).

[0042] Delay compensation: Calculate the fixed latency (FL) of each transmission path, including: Sensor internal processing delay (e.g., camera image transmission delay of 300μs); cable transmission delay (5ns / meter); switch queuing delay (≤100ns); subtract FL from ATS to obtain the exact occurrence timestamp (EOTS).

[0043] Multi-source synchronous dataset generation HTSM performs Cross-Source Time Alignment (CSTA): Time window alignment: The time window (TW) is based on the control period (e.g., 1ms), and the window length can be dynamically adjusted (±10%).

[0044] Data interpolation processing: If sensor data is missing within a time period (e.g., camera not triggered), linear interpolation or history data replication is used to fill the gap. For example, if the tension signal is missing, the average value of the previous two periods' data is used to fill the gap.

[0045] Dataset encapsulation: At the end of each TW (Time-of-War), all EOTS (Extended Time Strategies) within the window are aligned to the same baseline time (e.g., window start time + 500 μs) and encapsulated into a Multi-Source Synchronized Dataset (MSSD). The data format is a structured array, containing: Tension data: timestamp (nanoseconds), tension value (newtons), sensor location ID; Image data: timestamp, image pointer (memory address), camera ID, estimated coordinates of marker center; Speed ​​data: timestamp, speed (rpm), motor ID; The dataset is appended with a Global Sequence Number (GSN) and a Check Code (CC) and uploaded to the control center via Real-Time Ethernet (RTE). The final time synchronization accuracy is ≤200 nanoseconds (ns), meeting the timing consistency requirements of high-speed printing control.

[0046] S202, perform sub-pixel level edge extraction on the color mismatch image, combine with preset vertical / horizontal tolerance thresholds, calculate the real-time offset of each color group in the machine direction and horizontal direction, and output the color mismatch feature vector. Specifically, the Zernike moment subpixel edge detection algorithm can be applied to the original image without blurring or color misalignment to locate the color-marked edges with a precision of 0.1 pixels and output a subpixel edge coordinate sequence. Image preprocessing and feature enhancement The system receives a motion-blur-free registration mark image from a high-speed industrial camera. Motion blur has been eliminated during acquisition using LED strobe synchronization technology to ensure the registration marks (typically crosshairs, L-shaped, or circular targets) are clearly visible. Image preprocessing is performed first: Grayscale conversion: Converts RGB color images to 8-bit grayscale images (grayscale range 0-255) to simplify subsequent calculations.

[0047] Adaptive Contrast Enhancement: The CLAHE (Contrast Limited Adaptive Histogram Equalization) algorithm is used to improve the contrast between the marker and the background, especially in low-light areas. For example, the clip limit is set to 2.0 and the tile size to 8×8 pixels to prevent noise amplification.

[0048] Gaussian smoothing filter: Convolves the image with a 2D Gaussian kernel with a standard deviation (SD) of 0.8 pixels to suppress high-frequency noise (such as paper texture or ink splatter) while preserving the marked edge structure.

[0049] Zernike's core process for edge detection The core of the Zernike Moment Subpixel Edge Detection algorithm is to use orthogonal moments to mathematically model local regions of an image. Sliding window scanning: A local window (Window Size, WS) of 11×11 pixels is taken centered on the target edge point. For each pixel within the window, the three key components of the Zernike moment are calculated: the real part of the moment with order n=3 and repetition m=0 (Zernike moment). 30 ), imaginary moment (Z) 31p and Z 31 These moment values ​​are obtained by weighted summation of discrete Zernike polynomial basis functions and window gray values, reflecting the geometric features of the edges.

[0050] Subpixel edge localization: Based on moment theory, the true position of the edge (x... s , y s This can be solved using the following relationship: Calculate the edge angle θ = arctan(Imaginary Part / Real Part), which is the arctangent of the ratio of the imaginary moment to the real moment.

[0051] Calculate the subpixel offset Δx = (Z 31p × cosθ + Z 31 ᵥ × sinθ) / Z 30 × Window radius.

[0052] The final edge point coordinates are corrected to (x p + Δx, y p + Δy), where (x p , y p () represents an integer pixel position. Through iterative optimization, the positioning accuracy reaches 0.1 pixels (e.g., the actual edge is located at [105.3, 207.7] in the pixel coordinate system instead of the integer [105, 208]).

[0053] Edge chain topology construction and output Perform topological connections on all detected edge points: Non-Maximum Suppression (NMS): Preserves local maxima along the edge gradient direction, eliminating redundant responses.

[0054] Edge tracking algorithm: It uses 8-neighborhood connectivity analysis to connect discrete edge points into a continuous curve (such as the crosshair outline of a color-coded marker).

[0055] Coordinate sequence generation: Edge point coordinates are stored according to color group number (e.g., Cyan color group C1, Magenta color group C2), and the subpixel edge coordinate sequence (SECS) is output. The data structure is [color group ID, x coordinate, y coordinate, confidence level]. For example, an edge line of color group C1 contains 200 points, and the coordinate precision of each point is 0.01 pixels.

[0056] Based on the sub-pixel edge coordinate sequence, the center point of each color group marker is fitted by the least squares method, and the coordinate matrix of the color group center point is output. Color group edge data grouping and filtering The subpixel edge coordinate sequence (SECS) is segmented based on the color group ID (e.g., C1 / C2 / C3 / C4). The overlay marker for each color group typically consists of two orthogonal edge lines (e.g., a horizontal line HL and a vertical line VL). Edge line separation: Using Hough Transform or orientation histogram statistics, edge points of the same color group are clustered into different lines. For example, the point set of color group C1 is divided into HL (angle range 85°–95°) and VL (angle range -5°–5°).

[0057] Outlier removal: Outliers (such as false edges caused by ink stains) are removed based on the RANSAC (Random Sample Consensus) algorithm. A distance threshold (DT) of 0.5 pixels is set, and the algorithm iterates 100 times, retaining the inlier set.

[0058] Least squares method fitting center point The Least Squares Method (LSM) solves for the optimal line equation by minimizing the sum of squared errors. Line equation fitting: Fit a straight line to the set of interior points of each edge line. Taking the horizontal line HL as an example, its equation is y = kx + b. The parameters k (slope) and b (intercept) are solved by the following matrix equation:

[0059] Where n is the number of interior points, and x_i and y_i are the coordinates of the points. The actual solution uses QR decomposition to avoid ill-conditioned matrices.

[0060] Intersection at center point: Solve the equations of the two fitted lines (HL and VL) of the same color group to find their intersection point. For example: HL equation: y = k1x + b1; VL equation: x = k2y + b2 (Since the slope of the vertical line is infinite, it needs to be converted into the form of x); The intersection point (x_c, y_c) is the sub-pixel center point of the color group mark.

[0061] Coordinate matrix construction and fault tolerance mechanism Center point verification: Calculate the intersection residual (RES), which is the average distance from all edge points to the fitted line. If RES > 0.2 pixels, trigger refitting or an alarm.

[0062] Matrix generation: Store the center point coordinates in color group order (C1→C4), and output the Color Group Center Coordinate Matrix (CGCCM). Example matrix format: Color group ID, x-coordinate (mm), y-coordinate (mm), timestamp (nanoseconds) C1 102.34 205.78 1690000000000 The coordinate system has been converted to physical scale (mm / pixel) through camera calibration.

[0063] The coordinate matrix of the color group center point is compared with the preset reference template. The machine direction and the instantaneous offset of the horizontal direction are calculated by combining the vertical / horizontal tolerance thresholds, and the original offset vector is output. Baseline template loading and coordinate alignment The Preset Reference Template (PRT) stores the standard positions of the center points of each color group under ideal conditions (such as the coordinates when the calibration is successful), including: Absolute reference coordinates: C1 color group (100.0, 200.0), C2 color group (100.0, 250.0), etc. (unit: millimeters).

[0064] Relative reference relationship: theoretical spacing between color groups (e.g., the longitudinal distance between C1 and C2 is 50.0 mm).

[0065] Coordinate alignment is required before comparison: Origin correction: Using the first color group C1 as the reference point, eliminate the overall translation error.

[0066] Rotational compensation: Corrects minor rotational deviations (<0.1°) caused by roller tilting through affine transformation.

[0067] Offset calculation and tolerance threshold application Calculate the offsets in both directions independently for each color group: Machine Direction Offset (MDO): The difference in displacement along the paper's travel direction (longitudinal). MDO = y_actual - y_reference.

[0068] Cross Direction Offset (CDO): ​​The displacement difference perpendicular to the paper's travel direction (lateral). CDO = x_actual - x_reference.

[0069] The longitudinal / lateral tolerance threshold is set by process requirements: Longitudinal tolerance threshold (LT): e.g., ±0.05 mm (corresponding to ±2 pixels); Transverse tolerance threshold (TT): e.g., ±0.03 mm (corresponding to ±1.2 pixels).

[0070] If |MDO| > LT or |CDO| > TT, mark the color group as "out of tolerance".

[0071] Vectorized output and status marking The offset data is integrated according to color group order, and the raw offset vector (ROV) is output: ROV=[MDO C1 CDO C1 Status C1 MDO C2 CDO C2 Status C2 ,…].

[0072] The Status field contains status flags (0 = normal, 1 = vertical deviation, 2 = horizontal deviation, 3 = two-way deviation). For example: C1 color group: MDO = +0.03 mm, CDO = -0.01 mm → Status=0; C2 color group: MDO = -0.07 mm (out of tolerance), CDO = +0.02 mm → Status=1.

[0073] The original offset vector is dynamically corrected by Kalman filtering to suppress measurement jitter error, and the filtered offset sequence is output. Kalman filter initialization Independent Kalman filters (KF) are established for the machine orientation (MD) and lateral (TD) offsets of each color group. The filter parameters include: State Variable (SV): [position, velocity], such as the MD direction state as [MDO, MDO_velocity].

[0074] Process noise covariance (Q): set according to the vibration characteristics of the printing press (e.g., Q_md = [0.1, 0; 0, 0.01]).

[0075] Measurement noise covariance (R): determined by image detection accuracy (e.g., R_md = 0.05). 2 ).

[0076] State Transition Matrix (F): Based on the sampling time Δt (e.g., 100ms), F = [1, Δt; 0, 1].

[0077] Dynamic filtering execution process Each time a new raw offset vector is received, the filter operates in a "prediction-update" loop: Prediction phase: Predict the current state based on the state at the previous time step: SV_pred = F × SV_prev, error covariance P_pred = F × P_prev × Fᵀ + Q.

[0078] Update phase: Combine the latest measurement value Z (i.e., the original MDO / TDO) to calculate the Kalman gain K = P_pred × Hᵀ / (H × P_pred × Hᵀ + R) (H is the observation matrix [1,0]). Update state: SV_new = SV_pred + K× (Z - H × SV_pred), update covariance P_new = (I - K×H) × P_pred.

[0079] Jitter suppression: The velocity component (e.g., MDO_velocity) automatically filters out high-frequency jitter (e.g., vibrations <5Hz), and the position component (MDO) smooths out abrupt noise (e.g., random jumps of ±0.5 pixels).

[0080] Serialization output and exception handling The position component (i.e., the corrected MDO / TDO) is extracted from the filtered state vector and used to replace the corresponding value in the original offset vector to generate the filtered offset sequence. Simultaneously, filter characteristics are monitored. Convergence determination: If the state change amount is less than 0.02 pixels in 10 consecutive updates, it is marked as a stable state (StableState Flag=1).

[0081] Divergence alarm: If the diagonal elements of the covariance matrix suddenly increase (e.g., P[0,0]>1), the sensor verification process is triggered. Sequence data is stored in chronological order, with a time resolution synchronized with image acquisition (e.g., 10Hz).

[0082] The offset sequences after filtering of each color group are integrated and normalized into machine orientation offset components and lateral offset components to generate a color registration error feature vector.

[0083] Component separation and data reconstruction Iterate through the filtered offset sequence of all color groups, separating the Machine Orientation Offset (MDO) and Lateral Offset (TDO) of each color group into two independent data streams: Machine orientation offset set: [ MDO_c, MDO_m, MDO_y, MDO_k ]; Lateral offset set: [TDO_c, TDO_m, TDO_y, TDO_k]; At this point, each offset value contains timing characteristics (such as the sampled values ​​from the most recent 5 seconds).

[0084] Normalization and Feature Extraction Amplitude normalization: To avoid the absolute value difference between color groups masking the trend, divide the MDO / TDO of each color group by its tolerance threshold (such as MDO_c / LTT_c) and output a dimensionless offset coefficient (OC).

[0085] Dynamic feature calculation: Instant Value (IV): The OC value at the current moment.

[0086] Short-Term Trend (STT): The slope of the linear fit of OC over the past second.

[0087] Fluctuation Intensity (FI): The standard deviation of OC over the past 3 seconds.

[0088] Key color group association: Calculate the relative offset of the associated color groups (e.g., MDO_c - MDO_m represents the cyan-magenta overprinting error).

[0089] Vector construction and output The final generated Register Error Feature Vector structure is shown below: { Timestamp: "2025-04-11T14:30:25.120Z", / / Timestamp MachineDirection: [ / / Machine Direction Feature Group] {Color: "Cyan", IV: 0.3, STT: -0.02, FI: 0.05}, {Color: "Magenta", IV: 0.4, STT: 0.01, FI: 0.07}, ... ], TransverseDirection: [ / / Lateral feature group {Color: "Cyan", IV: -0.1, STT: 0.00, FI: 0.03}, ... ], RelativeErrors: [ / / Critical correlation errors {Pair: "CM", MD_Diff: -0.1, TD_Diff: 0.2}, ... ] }

[0090] The vector is output 10 times per second and uploaded to the cloud control platform via an IoT message queue.

[0091] S203, the multi-source synchronous dataset and the color matching error feature vector are uploaded to the cloud IoT platform, and a collaborative control parameter package containing tension compensation coefficient and color matching correction amount is generated by associating the historical fault database and material property parameters. Specifically, the multi-source synchronized dataset and the color matching error feature vector can be encapsulated into an IoT message, encrypted and uploaded to the cloud IoT platform via the MQTT protocol, and the encrypted data stream can be output. Once the local edge computing node completes the timestamp alignment of the multi-source data, the system initiates the data upload process. First, the multi-source synchronized dataset (containing the original anti-disturbance tension signal with nanosecond-level time stamps, the original image without blurring or color misalignment, and the smoothed rotational speed digital sequence) and the color misalignment feature vector (containing the filtered offset sequence of machine orientation and lateral direction for each color group) are integrated into a structured data packet. This data packet is encapsulated in a lightweight binary format (such as MessagePack), significantly reducing the amount of data transmitted. During encapsulation, a unique device identifier (DID) and a session sequence number (SSN) are added to distinguish the data source and reorder it in the cloud. Subsequently, the system calls the IoT communication middleware to establish a secure connection with the cloud via the MQTT (Message Queuing Telemetry Transport) protocol. This protocol uses a "publish-subscribe" model, where the local device acts as the publisher, pushing data to a specified topic (e.g., " / PressRoom01 / ControlData"), and the cloud-based IoT platform acts as the subscriber, listening to that topic. To ensure transmission security, the communication link uses TLS 1.3 encryption (Transport Layer Security version 1.3) and employs the AES-256-GCM algorithm (Advanced Encryption Standard, 256-bit key length, Galois / Counter Mode authentication) for end-to-end encryption of data packets, generating an Encrypted Data Stream (EDS). This process ensures that even if the data is intercepted, it cannot be decrypted, meeting industrial data security requirements.

[0092] The key to encrypted transmission lies in dynamic key management. The system pre-installs an X.509 digital certificate (X.509C) for authentication. The cloud-based IoT platform verifies the validity of device certificates upon connection establishment to prevent unauthorized access. A unique session key (SK) is generated for each session. This key is negotiated using the ECDH (Elliptic Curve Diffie-Hellman) algorithm, providing high security based on the secp384r1 elliptic curve. The encrypted data stream (EDS) is transmitted in frames. Each frame contains: a frame header (FH, containing data length and checksum), a payload (PL, the encrypted data packet), and a frame trailer (FT, containing the Message Authentication Code (MAC)). The MAC is generated using the HMAC-SHA384 algorithm (Hash-based Message Authentication Code, using the SHA-384 hash function) to ensure data integrity and prevent tampering. The local device has built-in QoS Level 1 transmission guarantee, which means "at least once," and automatically retransmits packets when network fluctuations cause packet loss. All transmission statuses (such as sending timestamps and retransmission counts) are recorded in the local log for fault diagnosis.

[0093] To adapt to complex industrial network environments, the system implements intelligent traffic control: Bandwidth Adaptive: Monitors current network latency (LAT) and packet loss rate (PLR), dynamically adjusts MQTT packet size (PS), and automatically switches to small packet mode (PS < 1KB) when LAT > 50ms or PLR > 5%. Resume transmission after disconnection: If the connection is interrupted, unacknowledged data is temporarily stored in the local ring buffer (RB) and will be retransmitted first after the connection is restored; Data priority marking: Color registration error feature vectors are marked as "Critical," and tension and speed data are marked as "High," ensuring that critical data is uploaded first. The final output encrypted data stream (EDS) is routed and optimized by the Industrial Gateway (IG) before being transmitted to the cloud IoT platform entry node via a 5G private network or fiber optic ring network.

[0094] After the cloud-based IoT platform parses the encrypted data stream, it associates the material property parameter library and the historical fault database, and outputs the environment-history joint feature matrix. After receiving the encrypted data stream (EDS) on the cloud-based IoT platform, it is first processed by the Security Access Layer (SAL): the session key (SK) is used to decrypt the data packets, the validity of the Message Authentication Code (MAC) is verified, and after confirming that there has been no tampering, the transmission frame structure is stripped to restore the original structured data. The parsing engine extracts the Device Identifier (DID) and Session Sequence Number (SSN), and reassembles the multi-source synchronized dataset and color error feature vector according to the timestamp (nanosecond precision). Subsequently, the Data Correlation Engine (DCE) is started to query the binding information based on the DID. Material Property Database (MPDB): Stores the substrate properties for the current printing job, such as paper weight (unit: g / m³). 2 ), tensile strength (unit: N / m), coefficient of hygroscopic expansion (unit: %RH) -1 Ink absorption rate (unit: mL / m) 2 )wait; Historical Fault Database (HFDB): Records abnormal events of the equipment over the past 30 days, such as tension change records (timestamp, amplitude, duration), color matching error events (color group, offset direction, maximum deviation value), and motor overload alarms (motor number, load rate, temperature).

[0095] The association operation employs multi-dimensional feature fusion technology: Real-time operating condition matching: Using the current tension value, color registration error, and rotation speed as indexes, it retrieves fault records in HFDB under similar operating conditions (similarity threshold > 85%). For example, when a sudden increase in the lateral offset of the third color group is detected, it associates similar offset cases in the same color group caused by ink accumulation on the guide roller in the history. Material response modeling: Based on the substrate humidity expansion coefficient in MPDB, combined with the current ambient temperature and humidity sensor data (such as temperature 25°C and humidity 60%RH), calculate the influence weight of paper shrinkage rate on color registration error (for example, lateral shrinkage of 0.015mm for every 1%RH increase in humidity). Temporal feature extension: Extract statistical features from historical fault data (such as the standard deviation of tension fluctuations and the moving average of color offset), and combine them with real-time data to form a temporal feature window (typical window length: 10 seconds).

[0096] The resulting Environment-History Joint Feature Matrix (EHJFM) is a two-dimensional data structure: Row dimension: Represents feature categories, including: Real-time data: current tension value, lateral / vertical offset of each color group, motor speed; Material properties: substrate weight, shrinkage rate, ink viscosity; Historical characteristics: recent tension variance, failure frequency under the same working conditions, and guide roller health index (estimated based on historical wear data).

[0097] Column dimension: Represents the time series, sampled at 100-millisecond intervals, with a matrix width typically of 100 columns (covering a 10-second window). This matrix deeply integrates dynamic operating conditions, static material properties, and historical experience, providing complete input for subsequent digital twin simulations.

[0098] The environmental-historical joint feature matrix is ​​input into the digital twin engine, and the initial values ​​of tension compensation coefficient and color correction amount are calculated through the physical simulation model, and the initial control parameter set is output. The Digital Twin Engine (DTE) is the core cloud-based computing module. After the Environment-History Joint Feature Matrix (EHJFM) is input, the engine loads the Virtual Entity Model (VEM) corresponding to the printing press. This model contains three layers of physical simulation: Mechanical transmission model: Based on multi-body dynamics (MBD), the influence of guide roller inertia, belt elasticity, and bearing friction on tension propagation is simulated; Fluid dynamics model: The finite volume method (FVM) is used to simulate the color mixing fluctuations caused by viscosity changes during ink transfer. Motor electromagnetic model: Based on the principle of field-oriented control (FOC), the interference of servo motor torque pulsation on speed stability is calculated.

[0099] The simulation process performs two key calculations: Tension Compensation Coefficient (TCC): The current measured tension value is injected into the virtual model to drive the dynamics simulation of the transmission chain. Compare the root mean square error (RMSE) between the simulated tension curve and the actual tension curve. The damping parameters of each guide roller in the virtual model are adjusted using the gradient descent (GD) method until RMSE < 0.5N; The parameter adjustment is mapped to the proportional-integral gain correction value of the tension control loop, i.e., TCC (e.g., proportional gain +8%, integral time -12%).

[0100] Register Correction Initial Value (RCIV): Based on the material's shrinkage rate and historical color registration error, predict the color mark position shift trend for the next 3 seconds; The effect of ink viscosity changes (e.g., from 50 cP to 55 cP) on marking overlap was simulated in a fluid model. Output the pre-compensation amount (in μm) for each color group in the machine direction (MD) and the horizontal direction (CD). For example, the second color group needs to be advanced by 0.3 μm in the MD direction and shifted to the right by 0.2 μm in the CD direction.

[0101] The simulation results were verified by the Confidence Assessment Module (CAM): The model accuracy was verified using backtesting with historical data, requiring tension prediction error < 3% and color mismatch prediction error < 0.5 pixels; If the confidence level is less than 90%, an online model update will be triggered (e.g., recalibrating the guide roller friction coefficient). The final output Initial Control Parameter Set (ICPS) includes: TCC: Tension controller gain adjustment coefficient (Kp_adjust, Ki_adjust); RCIV: MD / CD correction value array for each color group (e.g., [+0.3μm, -0.1μm, +0.2μm, ...]); Model confidence level (CL, range 0-100%).

[0102] The initial control parameter set is verified under real-time operating conditions to generate a cooperative control parameter package that meets the safety boundaries.

[0103] After receiving the initial set of control parameters (ICPS), the Constraint Validation Engine (CVE) performs security checks from three dimensions: Equipment physical limits: Query the Equipment Archive (EA) to obtain hard limits such as the maximum speed of the servo motor (e.g., 3000 RPM), the maximum acceleration (1000 RPM / s), and the maximum offset stroke of the guide roller (e.g., ±5mm); Process stability constraints: Soft boundaries are set based on control theory, such as the allowable range of tension fluctuation (20±1.5N) and the threshold for color correction step size (single adjustment ≤0.5μm). Material tolerance boundary: Combined with the Material Property Parameter Library (MPDB), ensure that correction operations do not damage the substrate (e.g., maximum tensile deformation of paper < 0.1%).

[0104] The verification process employs a layered approach: Parameter range clamping: Forcefully truncates parameters that exceed hard boundaries. For example, if the initial value of the CD direction correction for a certain color group in RCIV is +0.6μm, but the guide roller travel margin is only 0.4μm, then the value will be clamped to +0.4μm. Dynamic sensitivity adjustment: The adjustment range is scaled based on the model confidence level (CL). If CL > 95%, the parameter is applied in full; if 80% < CL < 95%, the sensitivity is reduced proportionally (e.g., correction amount × 0.8). Conflict resolution arbitration: When tension compensation and color correction objectives conflict (e.g., improving tension stability requires slowing down, but color correction requires speeding up), Pareto optimization is used to find a set of non-dominated solutions and select the solution with the minimum overall cost (overall cost = tension variance weight × 0.7 + color error weight × 0.3).

[0105] The final generated Collaborative Control Parameter Package (CCPP) includes: Tension Compensation Coefficient (TCC): Gain adjustment coefficient after clamping; Register Correction Value (RCV): The final offset instruction within the safe range for each color group; Priority Tag (PT): Indicates the urgency of a parameter (e.g., "Immediate" requires execution within 10ms, "High" requires execution within 100ms). Safety Audit Log (SAL): Records all constraint verification operations and the basis for corrections. This parameter package is encapsulated in JSON format and is ready to be sent to the local control system.

[0106] S204, based on the aforementioned collaborative control parameter package, a model predictive control algorithm is used to optimize the tension stability and color matching accuracy targets in parallel, generating a set of speed adjustment instructions for the servo motor, wherein the color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. Specifically, tension compensation coefficients and color correction values ​​can be extracted from the collaborative control parameter package to construct a multi-objective optimization cost function. The tension stability objective is to minimize the tension value variance, and the color accuracy objective is to constrain the longitudinal / lateral error to be less than or equal to the tolerance threshold. Parameter extraction and target definition: The control system first parses the collaborative control parameter package sent from the cloud (containing the tension compensation coefficient TCC and the color correction range CR). TCC is a dimensionless coefficient (typically ranging from 0.8 to 1.2) used to quantify the compensation intensity for the impact of different paper types (such as coated paper and offset paper) or environmental humidity on tension; CR contains the suggested correction magnitude (in micrometers) for each printing color group (such as CMYK four colors) in the machine direction (MD) and cross direction (CD). Based on these parameters, the system constructs a multi-objective cost function. This function defines two core objectives: Tension stability target: defined as minimizing the variance (VAR) of the printing tension value (unit: Newtons N). Variance calculation is based on real-time tension sensor data streams, statistically analyzing tension fluctuations through a sliding window (e.g., a 10-second window). For example, if the current average tension is 200 N, the variance should be reduced from 50 N. 2 Reduced to 20N 2 the following.

[0107] Color registration accuracy target: A hard constraint requires that the longitudinal (MD) and transverse (CD) color registration errors (in micrometers, μm) of all color groups must be less than a preset tolerance threshold (TT, e.g., MD_TT = 15μm, CD_TT = 10μm). This means that the optimization results must forcibly satisfy: |MD_Error| ≤ MD_TT and |CD_Error| ≤ CD_TT.

[0108] Cost function structured design: The cost function is a weighted combination: Total cost = W_Tension × Tension variance + W_Register × Color matching violation penalty.

[0109] Wherein: W_Tension (Weight for Tension): dynamically adjusted according to TCC. When TCC>1 (indicating that the material is easily stretched), W_Tension is increased to preferentially suppress tension fluctuations.

[0110] W_Register (Weight for Register): Set according to the correction amount in CR. The greater the correction requirement, the higher the weight.

[0111] Color matching violation penalty: A quadratic penalty function is used. If the MD or CD error of a certain color group exceeds TT, the square of the excess (e.g., exceeding 5μm) is multiplied by a large coefficient (e.g., 1000) to form a steep penalty gradient, forcing the optimization results to strictly adhere to the tolerance boundary.

[0112] For example, when the MD error of the cyan group reaches 18μm (exceeding MD_TT=15μm), the penalty term = 1000×(18-15). 2 =9000, significantly increasing the total cost and guiding the optimization algorithm to correct this violation.

[0113] Real-time parameter adaptive mechanism: The weighting coefficients (W_Tension, W_Register) are not fixed, but dynamically adjusted by the FuzzyInference Engine. The engine's input includes: Current tension variance trend (increasing / decreasing); The margin at the TT boundary of the color registration error (e.g., 5μm space remaining for a 15μm MD error). Material property parameters (such as the elastic modulus of paper).

[0114] The output is the optimized weight value. For example, when the tension variance increases sharply and there is sufficient color matching margin, W_Tension is automatically increased to 0.7 to temporarily weaken the color matching optimization and prioritize preventing paper breakage.

[0115] Establish a state-space model of the servo motor, discretize the cost function into a rolling time-domain optimization problem, and output the predictive control equations; State-space modeling: The dynamic behavior of the servo motor (driving the printing roller) is described using a state-space model: State Variables include motor speed ω (unit: RPM), current torque τ (unit: Nm), and cumulative color registration error integral ∑e (unit: μm·s).

[0116] Input Variables: Speed ​​command increment Δω_cmd (unit: RPM).

[0117] Output Variables: Tension observation value T_obs (N), color registration error e_MD / e_CD (μm).

[0118] The model equations are in the following form: Next state = Matrix A × Current state + Matrix B × Input command; System output = C matrix × current state.

[0119] Among them, matrix A (state transition matrix) contains parameters such as motor electromagnetic time constant and mechanical inertia; matrix B (control input matrix) reflects the gain from command to speed response; matrix C (observation matrix) maps the internal state to measurable parameters (tension, color error).

[0120] Discretization and Rolling Optimization: The continuous-time model is discretized according to the control period (e.g., 100 ms) to obtain difference equations suitable for digital control. Then, a retceding horizontal optimization strategy is employed: At the start of each control cycle, the state vector is initialized based on the current sensor data (tension, color matching error, rotation speed).

[0121] Predict system behavior over future time intervals (e.g., 2 seconds in the future, corresponding to 20 control cycles).

[0122] Transform the cost function into the cumulative cost in the future time domain: Total predicted cost = Σ[W_Tension×VAR(k)+ W_Register×Penalty(k)] (k=1 to 20).

[0123] Where VAR(k) is the predicted value of the tension variance at step k, and Penalty(k) is the predicted value of the color violation penalty at step k.

[0124] Optimization objective: Find the optimal speed command sequence [Δω_cmd(1), Δω_cmd(2), ..., Δω_cmd(20)] to minimize the total prediction cost and satisfy the physical limit of motor speed / torque (e.g., |Δω_cmd| ≤ 50RPM).

[0125] Generation of predictive control equations: The final output, the Predictive Control Equation, is a constrained mathematical programming problem: Minimize: Total prediction cost Subject to: State equations (k=1 to 20); Speed ​​command variation limit |Δω_cmd(k)| ≤ 50 RPM; Hard constraints on color matching error: |e_MD(k)| ≤ MD_TT, |e_CD(k)| ≤ CD_TT (k=1 to 20).

[0126] This equation encapsulates system dynamics, multi-objective costs, and technological constraints, providing an input framework for subsequent optimization solvers.

[0127] The predictive control equations are solved in parallel using a particle swarm optimization algorithm, and the tension and color matching targets are optimized simultaneously to output the speed adjustment sequence for the next 5 control cycles. Particle Swarm Optimization Initialization: Particle Swarm Optimization (PSO) is used to solve predictive governing equations in parallel. When the algorithm starts: Create a particle swarm containing 50 particles (P1-P50). Each particle represents a candidate solution, which is a complete sequence of rotation speed instructions [Δω_cmd(1) to Δω_cmd(20)].

[0128] Particle position initialization: A 20-dimensional vector is randomly generated within a rotational speed limit of [-50 RPM, +50 RPM]. For example, the initial solution for particle P1 is: [+3.2, -1.8, ..., +4.5] RPM.

[0129] Set algorithm parameters: PS_N (Particle Swarm Size) = 50; MaxIter (Maximum Iterations) = 100; ω (Inertia Weight) = 0.7 (controls the inheritance of search direction); c1, c2 (Learning Factors) = 1.5 (which respectively control the weights of individual cognition and social experience).

[0130] Parallel evaluation and iterative updates: In each iteration: Parallel cost evaluation: All 50 candidate solutions are distributed to 50 threads on a multi-core CPU for simultaneous simulation and prediction. Inject the Δω_cmd sequence represented by the particles into the state-space model; Predict the changes in tension and color registration error over the next 20 steps; Calculate the total prediction cost (including tension variance and color mismatch penalty) corresponding to the solution.

[0131] Update individual / group optimality: If the cost of the current solution of a particle is lower than its historical best (PBest, Personal Best), then update PBest; The global best solution (GBest) is the solution with the lowest cost across the entire group.

[0132] Particle position update: Adjust the velocity and position of each particle according to the PSO equations of motion. New velocity = ω × old velocity + c1 × rand() × (PBest - current position) + c2 × rand() × (GBest - current position); New position = current position + new speed.

[0133] Here, rand() is a random number in the range [0,1]. After the position is updated, amplitude limiting is required (to ensure that |Δω_cmd| ≤ 50 RPM).

[0134] Result extraction and truncation output: The iteration terminates when MaxIter (100 times) or GBest cost convergence (change < 0.1%) is reached. The complete 20-step instruction sequence represented by GBest is output, but only the speed adjustment values ​​[Δω_cmd(1) to Δω_cmd(5)] for the first 5 control cycles (i.e., the next 0.5 seconds) are taken as the Speed ​​Adjustment Sequence (SAS). For example: SAS = [+4.1, -2.3, +0.7, -1.5, +3.0] RPM.

[0135] The remaining 15 steps are discarded, as a new sequence will be generated during the next scrolling optimization.

[0136] The speed adjustment sequence is subjected to S-curve acceleration and deceleration constraint processing to output a smooth speed command sequence; The necessity of S-curve constraints: Directly outputting SAS (such as [+4.1, -2.3, +0.7, ...] RPM) includes speed jumps (e.g., a sudden drop from +4.1 to -2.3). Executing this directly would cause abrupt changes in servo motor acceleration, leading to mechanical shock, belt slippage, or vibration. Therefore, an S-curve acceleration / deceleration constraint must be applied to ensure that the first derivative (acceleration) and second derivative (jerk) of the speed command are continuous and smooth.

[0137] Generation of a seven-segment S-curve: The seven-segment S-curve algorithm is used to process SAS: Phase division: Each speed change segment (e.g., from the current speed ω_now to the target Δω_cmd(k)) is decomposed into 7 segments: Increasing Acceleration; Constant acceleration; Decreasing Acceleration; Constant Velocity; Acceleration / Deceleration; Constant deceleration; Decreasing Deceleration.

[0138] Constraint parameter settings: ACC_max (maximum acceleration, such as 50 RPM / s); JERK_max (maximum jerk, e.g., 200 RPM / s) 2 ); Real-time trajectory generation: Taking the first instruction in SAS, Δω_cmd(1) = +4.1 RPM, as an example: The required total displacement is calculated to be Δω = +4.1 RPM; Based on ACC_max and JERK_max, the time allocation for the seven trajectory segments is automatically planned (e.g., 0.1s acceleration to ACC_max, 0.05s constant speed acceleration, 0.1s deceleration to zero acceleration). Generate the smoothed speed command value for each moment within the 500ms (i.e., 5×100ms control cycle).

[0139] Sequence recombination and output: The five command values ​​of SAS are sequentially processed using S-curve techniques to generate a smoothed speed command sequence (SCS) for each control cycle. For example: Original SAS command: [+4.1, -2.3, +0.7] RPM.

[0140] SCS after S-curve processing: Cycle 1: +1.0 RPM (Initial Acceleration); Cycle 2: +2.8 RPM (Accelerates mid-game); Cycle 3: +4.1 RPM (Target Achieved); Cycle 4: +2.5 RPM (initial deceleration); Cycle 5: -0.2 RPM (mid-deceleration phase); Cycle 6: -2.3 RPM (Target Achieved); ... This sequence ensures that the motor speed changes smoothly like an S-curve, eliminating mechanical shock.

[0141] The smooth speed command sequence is grouped by color group to generate a servo motor speed adjustment command set.

[0142] Color group command association mapping: The aforementioned SCS is a global instruction sequence, which needs to be broken down into color group-specific instructions according to printing color groups (such as Cyan, Magenta, Yellow, and Black). The system maintains a Color Unit-Motor Mapping Table to record: Color group name (e.g., "C"); The ID of the servo motor driving the roller of this color group (e.g., "ServoMotor_03"); The base speed setting of the motor (Base Speed, BS, in RPM); The smoothing command (Δω value in SCS) will be superimposed on the corresponding motor's BS to form an absolute speed command: Color group command = BS + Δω.

[0143] Instruction set encapsulation and timing synchronization: Grouping by color group: Packs the instruction values ​​of each color group in the SCS sequence at the same time. For example, at t=500ms: Group C: BS_C + Δω_C = 1500 + 3.2 = 1503.2 RPM; Group M: BS_M + Δω_M = 1500 -1.5 = 1498.5 RPM; Group Y: BS_Y + Δω_Y = 1500 +0.0 = 1500.0 RPM; Group K: BS_K + Δω_K = 1500 +2.1 = 1502.1 RPM.

[0144] Generate instruction set: For each control cycle, create a structured data packet containing: Timestamp (TS): Nanosecond-level synchronization time (from IEEE 1588 clock). Color group instruction array: A list of RPM values ​​indexed by color group ID The data packets from all cycles are arranged in chronological order to form the Servo Motor Speed ​​Adjustment Instruction Set (SMSAIS).

[0145] Instruction verification and fault tolerance mechanisms: Perform three checks on SMSAIS before sending: Range verification: Ensure that all command values ​​are within the motor's safe range (e.g., ±2000 RPM).

[0146] Change rate verification: The difference between adjacent cycle instructions must be less than the ACC_max (50 RPM / s) constrained by the S-curve.

[0147] Conflict checking: Avoid conflicting instructions from different color groups (such as C group accelerating while M group decelerates, leading to tension imbalance).

[0148] If the verification fails, a Command Smooth Transition is triggered: based on the valid instructions of the previous cycle, a safety instruction set is re-interpolated according to the S-curve constraints to ensure control continuity.

[0149] S205, the speed adjustment instruction set is sent to the PLC control system, and the speed closed-loop control is executed through the servo driver.

[0150] Specifically, the servo motor speed adjustment instruction set can be encoded into an industrial Ethernet EtherCAT frame structure, embedded with a time-sensitive network scheduling tag, and output a time-deterministic control command stream. After the system completes the optimization calculation of the model predictive control algorithm, it generates a Speed ​​Adjustment Instruction Set (SAIS) containing five control cycles (each cycle typically 2-10 milliseconds) for each color group of servo motors. This instruction set is essentially a set of structured data, including motor ID (MID), target speed (TS), and acceleration profile parameters (APP). To achieve high-speed and reliable industrial communication, it needs to be converted into an industrial Ethernet EtherCAT frame structure (Ethernet for Control Automation Technology Frame Structure). EtherCAT is a real-time industrial bus protocol based on Ethernet. Its core mechanism is "Processing on the Fly" (PoF): data frames are not interrupted by the receiving node during transmission; instead, each node reads and writes its own data in real time. The control system first encapsulates each instruction in the SAIS in EtherCAT datagram format. Each datagram contains a Service Data Object (SDO) or a Process Data Object (PDO). For example, a motor speed command is encoded as a 16-bit integer TS value (unit: 0.1 rpm) and an 8-bit APP index value, which is then filled into a predefined PDO mapping area.

[0151] To ensure time determinism (TD) in command transmission—meaning commands must reach the target device within a strictly defined timeframe—the system embeds a Time-Sensitive Networking Scheduling Tag (TSN Tag) into the EtherCAT frame. TSN is a network traffic scheduling technique defined by the IEEE 802.1 standard family. It uses a Time-Aware Shaper (TAS) to divide network traffic into different priority queues. Control command flows are marked as the highest priority Scheduled Traffic Class (STC). The scheduling tag contains the following key parameters: Cycle Start Time (CST, accuracy ±50 nanoseconds), Time Slot Length (TSL, e.g., 250 microseconds), and Flow Identifier (FID). The network switch transmits command frames within a pre-allocated Guard Band (GB) based on the TSN tag, preventing other low-priority traffic (such as ordinary TCP / IP data) from preempting bandwidth. For example, within each 1-millisecond communication cycle, the first 300 microseconds are reserved as a dedicated STC window to ensure that the end-to-end transmission delay of the speed command frame remains stable within 50 microseconds.

[0152] After encoding and scheduling are complete, the system outputs a time-deterministic control command stream (TDCCS). This data stream has the following characteristics: Frame structure compliance: Conforms to the EtherCAT standard frame format, including a frame header (HDR), data field (DF), working counter (WCK), and frame check sequence (FCS).

[0153] Scheduling predictability: TSN tags ensure that the instruction flow is buffered at the switch port for ≤10 microseconds, avoiding queuing jitter (QJ).

[0154] Fault tolerance mechanism: A dual-ring network topology is established through the Redundant Path Protocol (RPP). When the primary path fails, it automatically switches to the backup path with a switching time of less than 5 milliseconds. The final generated TDCCS is sent to the industrial network through the fiber optic Ethernet physical layer (e.g., 100BASE-FX).

[0155] The control command stream is sent to the PLC control system through the OPC UA protocol, and the real-time data pipeline is used to ensure that the command transmission delay is less than 1ms, and the synchronous command set is output. TDCCS needs to be securely and reliably delivered to the execution layer devices. The system uses the OPC UA protocol (Open Platform Communications Unified Architecture) as the transmission carrier. OPC UA is a general communication framework in the field of industrial automation, supporting both the Publish-Subscribe Pattern (PSP) and the Client-Server Pattern (CSP). In this scenario, the control server acts as the OPC UA publisher (PUB), encapsulating TDCCS into UA data packets (UDPK). The data packet contains: Security Header (SH): Encrypted with AES-256 and signed with SHA-2 to prevent command tampering.

[0156] Extended Message Header (EMH): Marks the data packet as Realtime Category (RTC).

[0157] Payload (PL): Carries the raw byte stream of TDCCS.

[0158] To achieve the stringent requirement of command transmission latency <1ms, the system establishes a Real-time Data Pipeline (RDP). This pipeline is protected by three layers of technology: Network layer: Based on User Datagram Protocol (UDP) instead of TCP, avoiding the latency introduced by the three-way handshake and retransmission mechanism.

[0159] Transport layer: Enable Priority Channel (PC), configure Quality of Service Class (QoSC) to 6 (highest level), and ensure that the switch prioritizes forwarding.

[0160] Application Layer: Employing Memory-Mapping Technology (MMT), the instruction stream is directly written to the PLC's Shared Memory Area (SMA), without the need for the operating system kernel to relay it. For example, when PUB publishes UDPK, the PLC's OPC UA subscriber (SUB) loads the data directly into the specified address (Address Offset, AO) of the SMA via the DMA (Direct Memory Access) controller, with the entire process taking less than 200 microseconds.

[0161] The Synchronized Instruction Set (SIS) output by the pipeline must meet two core requirements: Time synchronization: The PLC uses the IEEE 1588 Precision Time Protocol (PTP) to align with the controller clock, with a time deviation of <100 nanoseconds. Each instruction in the SIS is appended with an Execution Timestamp (ETS), such as "Increase the speed of motor 3 to 1520 rpm at T=153.205 seconds".

[0162] Instruction Atomicity: A transaction mechanism (TM) ensures that multiple instructions within a control cycle either all take effect or all are discarded. For example, if one of the four color group instructions fails verification, the entire SIS rolls back to the previous state. The final output SIS is stored in the PLC's dual-port RAM (DPRAM) for real-time reading by the servo driver.

[0163] After parsing the synchronization instruction set, the PLC drives the servo driver to enable the servo driver to perform closed-loop speed control.

[0164] The PLC's Central Processing Unit (CPU) starts the parsing process after reading the SIS from the DPRAM: Instruction Decoding (ID): Restores binary instructions to structured parameters. For example, it resolves the motor number MID=0x03 (motor number 3) and the target speed TS=0x05F0 (1520 rpm).

[0165] Temporal Scheduling (TS): Based on the ETS parameters of the instruction, tasks are inserted into the Real-time Task Queue (RTTQ). Queue priorities are divided into three levels: Immediate Level (IL, response time <100 microseconds), Periodic Level (PL), and Background Level (BL). The RPM instruction belongs to the IL level.

[0166] Safety Check (SC): Compares the Sequence Number (SQN) in the command with the servo drive's Expected Receive Number (ERN) to prevent duplicate or lost commands.

[0167] After parsing, the PLC drives the servo drive (SD) through the Fieldbus Interface (FBI). The specific process is as follows: Physical layer: Uses differential signal transmission (DST) technology (such as RS-485 or CANopen), with an electromagnetic interference immunity of up to 1500V / m.

[0168] Protocol layer: Sends motion control messages (MCMs). Taking CANopen as an example, the message includes: Object Dictionary Index (ODI): For example, 0x6040 (control word); Sub-Index (SI): For example, 0x00 (primary index); Data Field (DF): Writes the combined instruction code "Start Servo Enable + Speed ​​Mode + Target Value Take Effect".

[0169] Parameter transmission: The target rotational speed TS and acceleration APP are transmitted in real time via a process data object (PDO).

[0170] The core components of servo drives performing speed closed-loop control (SCLC): Feedback acquisition: The actual speed (AS) of the motor is measured in real time using a high-resolution encoder (HRE, such as a 23-bit absolute encoder) with a sampling frequency ≥10kHz.

[0171] Closed-loop algorithm: Employs Proportional-Integral-Derivative Control (PIDC) combined with Feedforward Compensation (FCC). PID parameters are automatically tuned based on load inertia (LI), for example: Proportional gain (KP) = 0.8 rad / (N·m·s); Integration Time (TI) = 15 ms; Derivative Time (TD) = 0.5 ms.

[0172] Dynamic adjustment: Compare the deviation between TS and AS (Speed ​​Error, SE). If |SE|>2% for more than 5 milliseconds, then Adaptive Sliding Mode Control (ASMC) is triggered to suppress disturbances. Finally, a Pulse Width Modulation Wave (PWM) is output to drive the motor, achieving a speed control accuracy of ±0.02%.

[0173] As can be seen, real-time acquisition of printing tension values, color registration deviation images, and motor speed data during the operation of the electronic shaft printing press generates a multi-source synchronous dataset with timestamps; sub-pixel-level edge extraction is performed on the color registration deviation images to output a color registration error feature vector; the multi-source synchronous dataset and the color registration error feature vector are uploaded to a cloud-based IoT platform, and a collaborative control parameter package containing tension compensation coefficients and color registration correction amounts is generated by associating it with a historical fault database and material characteristic parameters; based on the collaborative control parameter package, a servo motor speed adjustment instruction set is generated; the speed adjustment instruction set is sent to the PLC control system, and the servo driver executes closed-loop speed control, thereby achieving high-precision adaptive adjustment of the printing process.

[0174] Another embodiment of the present invention provides an Internet of Things-based electronic shaft printing machine control system, see [link to relevant documentation]. Figure 3 The system may include: The acquisition module 301 is used to acquire printing tension value, color registration deviation image and motor speed data in real time during the operation of the electronic shaft printing machine, and to perform data filtering and timestamp alignment to generate a multi-source synchronous dataset with timestamps. Extraction module 302 is used to perform sub-pixel level edge extraction on the color mismatch image, and calculate the real-time offset of each color group in the machine direction and the horizontal direction by combining the preset vertical / horizontal tolerance thresholds, and output the color mismatch feature vector. Upload module 303 is used to upload the multi-source synchronous dataset and the color matching error feature vector to the cloud IoT platform, and generate a collaborative control parameter package containing tension compensation coefficient and color matching correction amount by associating historical fault database and material property parameters. The optimization module 304 is used to optimize the tension stability and color matching accuracy targets in parallel using a model predictive control algorithm based on the cooperative control parameter package, and generate a set of speed adjustment instructions for the servo motor. The color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. The control module 305 is used to send the speed adjustment instruction set to the PLC control system and execute closed-loop speed control through the servo driver.

[0175] This invention also provides a storage medium storing a computer program, wherein the computer program is configured to execute the steps in any of the above method embodiments when running.

[0176] Specifically, in this embodiment, the storage medium can be configured to store a computer program for performing the following steps: S201 collects printing tension values, color registration deviation images, and motor speed data in real time during the operation of the electronic shaft printing machine, and performs data filtering and timestamp alignment to generate a multi-source synchronous dataset with timestamps. S202, perform sub-pixel level edge extraction on the color mismatch image, combine with preset vertical / horizontal tolerance thresholds, calculate the real-time offset of each color group in the machine direction and horizontal direction, and output the color mismatch feature vector. S203, the multi-source synchronous dataset and the color matching error feature vector are uploaded to the cloud IoT platform, and a collaborative control parameter package containing tension compensation coefficient and color matching correction amount is generated by associating the historical fault database and material property parameters. S204, based on the aforementioned collaborative control parameter package, a model predictive control algorithm is used to optimize the tension stability and color matching accuracy targets in parallel, generating a set of speed adjustment instructions for the servo motor, wherein the color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. S205, the speed adjustment instruction set is sent to the PLC control system, and the speed closed-loop control is executed through the servo driver.

[0177] This invention also provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to perform the steps in any of the above method embodiments.

[0178] Specifically, the aforementioned electronic device may further include a transmission device and an input / output device, wherein the transmission device is connected to the aforementioned processor, and the input / output device is connected to the aforementioned processor.

[0179] Specifically, in this embodiment, the processor can be configured to perform the following steps via a computer program: S201 collects printing tension values, color registration deviation images, and motor speed data in real time during the operation of the electronic shaft printing machine, and performs data filtering and timestamp alignment to generate a multi-source synchronous dataset with timestamps. S202, perform sub-pixel level edge extraction on the color mismatch image, combine with preset vertical / horizontal tolerance thresholds, calculate the real-time offset of each color group in the machine direction and horizontal direction, and output the color mismatch feature vector. S203, the multi-source synchronous dataset and the color matching error feature vector are uploaded to the cloud IoT platform, and a collaborative control parameter package containing tension compensation coefficient and color matching correction amount is generated by associating the historical fault database and material property parameters. S204, based on the aforementioned collaborative control parameter package, a model predictive control algorithm is used to optimize the tension stability and color matching accuracy targets in parallel, generating a set of speed adjustment instructions for the servo motor, wherein the color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. S205, the speed adjustment instruction set is sent to the PLC control system, and the speed closed-loop control is executed through the servo driver.

[0180] The above description, based on the embodiments shown in the figures, details the structure, features, and effects of the present invention. The above description is only a preferred embodiment of the present invention, but the present invention is not limited to the scope of implementation shown in the figures. Any changes made in accordance with the concept of the present invention, or equivalent embodiments modified to have equivalent changes, that do not exceed the spirit covered by the specification and figures, should be within the protection scope of the present invention.

Claims

1. A control method for an electronic shaft printing machine based on the Internet of Things, characterized in that, The method includes: The printing tension value, color registration deviation image and motor speed data of the electronic shaft printing machine are collected in real time during operation. Data filtering and timestamp alignment are performed to generate a multi-source synchronous dataset with timestamps. Subpixel-level edge extraction is performed on the color mismatch image. Combined with preset vertical / horizontal tolerance thresholds, the real-time offset of each color group in the machine direction and horizontal direction is calculated, and the color mismatch feature vector is output. The multi-source synchronous dataset and the color matching error feature vector are uploaded to the cloud IoT platform. By associating the historical fault database and material property parameters, a collaborative control parameter package containing tension compensation coefficient and color matching correction amount is generated. Based on the aforementioned collaborative control parameter package, a model predictive control algorithm is used to optimize tension stability and color matching accuracy targets in parallel, generating a set of speed adjustment instructions for the servo motor. The color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. The speed adjustment instruction set is sent to the PLC control system, and the speed closed-loop control is executed through the servo driver.

2. The method according to claim 1, characterized in that, The system acquires printing tension values, color registration deviation images, and motor speed data during the real-time operation of the electronic shaft printing machine, performs data filtering and timestamp alignment, and generates a multi-source synchronized dataset with timestamps, including: The printing tension value is acquired in real time by a fiber Bragg grating sensor array, and the mechanical vibration interference is eliminated by wavelength demodulation technology to output the original anti-interference tension signal. High-speed industrial cameras are used to capture color-marked images, and LED strobe synchronization technology is used to freeze motion blur, outputting original images without blurring or color-marking deviation. A Hall effect encoder is used to acquire motor speed pulse signals, and an adaptive sliding window filter is used to suppress electromagnetic noise, outputting a smooth digital speed sequence. The original anti-disturbance tension signal, the original image without blurring color deviation, and the smoothed speed digital sequence are input into the hardware time synchronization module. Based on the IEEE 1588 precise clock protocol, the timestamps are aligned to generate a multi-source synchronization dataset with nanosecond-level time tags.

3. The method according to claim 2, characterized in that, The process of performing sub-pixel-level edge extraction on the color mismatch image, combined with preset vertical / horizontal tolerance thresholds, calculates the real-time offset of each color group in the machine direction and horizontal direction, and outputs a color mismatch feature vector, including: The Zernike moment subpixel edge detection algorithm is applied to the original image without blurring or color misalignment to locate the color-marked edges with a precision of 0.1 pixels and output the subpixel edge coordinate sequence. Based on the sub-pixel edge coordinate sequence, the center point of each color group marker is fitted by the least squares method, and the coordinate matrix of the color group center point is output. The coordinate matrix of the color group center point is compared with the preset reference template. The machine direction and the instantaneous offset of the horizontal direction are calculated by combining the vertical / horizontal tolerance thresholds, and the original offset vector is output. The original offset vector is dynamically corrected by Kalman filtering to suppress measurement jitter error, and the filtered offset sequence is output. The offset sequences after filtering of each color group are integrated and normalized into machine orientation offset components and lateral offset components to generate a color registration error feature vector.

4. The method according to claim 3, characterized in that, The process involves uploading the multi-source synchronous dataset and the color matching error feature vector to a cloud-based IoT platform. By associating this with a historical fault database and material property parameters, a collaborative control parameter package is generated, including tension compensation coefficients and color matching correction amounts. The multi-source synchronized dataset and the color matching error feature vector are encapsulated into an IoT message, which is then encrypted and uploaded to the cloud IoT platform via the MQTT protocol, outputting an encrypted data stream. After the cloud-based IoT platform parses the encrypted data stream, it associates the material property parameter library and the historical fault database, and outputs the environment-history joint feature matrix. The environmental-historical joint feature matrix is ​​input into the digital twin engine, and the initial values ​​of tension compensation coefficient and color correction amount are calculated through the physical simulation model, and the initial control parameter set is output. The initial control parameter set is verified under real-time operating conditions to generate a cooperative control parameter package that meets the safety boundaries.

5. The method according to claim 4, characterized in that, Based on the aforementioned collaborative control parameter package, a model predictive control algorithm is used to optimize tension stability and color matching accuracy targets in parallel, generating a servo motor speed adjustment instruction set. The color matching accuracy control satisfies that both longitudinal and lateral errors do not exceed tolerance thresholds, including: Tension compensation coefficients and color correction values ​​are extracted from the collaborative control parameter package to construct a multi-objective optimization cost function. The tension stability objective is to minimize the tension value variance, and the color accuracy objective is to constrain the longitudinal / lateral error to be less than or equal to the tolerance threshold. Establish a state-space model of the servo motor, discretize the cost function into a rolling time-domain optimization problem, and output the predictive control equations; The predictive control equations are solved in parallel using a particle swarm optimization algorithm, and the tension and color matching targets are optimized simultaneously to output the speed adjustment sequence for the next 5 control cycles. The speed adjustment sequence is subjected to S-curve acceleration and deceleration constraint processing to output a smooth speed command sequence; The smooth speed command sequence is grouped by color group to generate a servo motor speed adjustment command set.

6. The method according to claim 5, characterized in that, The step of sending the speed adjustment instruction set to the PLC control system and executing closed-loop speed control through the servo driver includes: The servo motor speed adjustment instruction set is encoded into an industrial Ethernet EtherCAT frame structure, embedded with a time-sensitive network scheduling tag, and outputs a time-deterministic control instruction stream. The control command stream is sent to the PLC control system through the OPC UA protocol, and the real-time data pipeline is used to ensure that the command transmission delay is less than 1ms, and the synchronous command set is output. After parsing the synchronization instruction set, the PLC drives the servo driver to enable the servo driver to perform closed-loop speed control.

7. A control system for an electronic shaft printing machine based on the Internet of Things, characterized in that, The system includes: The acquisition module is used to acquire printing tension values, color registration deviation images, and motor speed data in real time during the operation of the electronic shaft printing machine, and to perform data filtering and timestamp alignment to generate a multi-source synchronous dataset with timestamps. The extraction module is used to perform sub-pixel level edge extraction on the color mismatch image, and calculate the real-time offset of each color group in the machine direction and the horizontal direction by combining the preset vertical / horizontal tolerance thresholds, and output the color mismatch feature vector. The upload module is used to upload the multi-source synchronous dataset and the color matching error feature vector to the cloud IoT platform, and generate a collaborative control parameter package containing tension compensation coefficient and color matching correction amount by associating the historical fault database and material property parameters. The optimization module is used to optimize the tension stability and color matching accuracy targets in parallel using a model predictive control algorithm based on the cooperative control parameter package, and generate a set of speed adjustment instructions for the servo motor. The color matching accuracy control satisfies that the longitudinal / lateral errors do not exceed the tolerance threshold. The control module is used to send the speed adjustment instruction set to the PLC control system and execute closed-loop speed control through the servo driver.

8. The system according to claim 7, characterized in that, The acquisition module is specifically used for: The printing tension value is acquired in real time by a fiber Bragg grating sensor array, and the mechanical vibration interference is eliminated by wavelength demodulation technology to output the original anti-interference tension signal. High-speed industrial cameras are used to capture color-marked images, and LED strobe synchronization technology is used to freeze motion blur, outputting original images without blurring or color-marking deviation. A Hall effect encoder is used to acquire motor speed pulse signals, and an adaptive sliding window filter is used to suppress electromagnetic noise, outputting a smooth digital speed sequence. The original anti-disturbance tension signal, the original image without blurring color deviation, and the smoothed speed digital sequence are input into the hardware time synchronization module. Based on the IEEE 1588 precise clock protocol, the timestamps are aligned to generate a multi-source synchronization dataset with nanosecond-level time tags.

9. A storage medium, characterized in that, The storage medium stores a computer program, wherein the computer program is configured to execute the method of any one of claims 1-6 when it is run.

10. An electronic device comprising a memory and a processor, characterized in that, The memory stores a computer program, and the processor is configured to run the computer program to perform the method of any one of claims 1-6.

Images