Fault Diagnosis of Industrial Robots Using a Digital Twin and

GRU-Based Deep Learning

Ilhem Ben Hnaien

1 a

, Eric Gascard

2 b

, Zineb Simeu-Abazi

2 c

and Hedi Dhouibi

NOCCS Laboratory, Natl. Engr. School of Sousse, University of Sousse, Sousse, Tunisia

Univ. Grenoble Alpes, CNRS, Grenoble INP, G-SCOP, Grenoble, France

LARATSI Laboratory, High. Inst. of Appl. Sci. Technol. of Kairouan, University of Kairouan, Kairouan, Tunisia

Keywords:

Digital Twin, Fault Diagnosis, GRU Neural Network, Industrial Robot, Time-Series Classiﬁcation.

Abstract:

This paper proposes a fault diagnosis method for industrial robots based on the combination of a digital twin

and a GRU-based deep learning model. A high-ﬁdelity digital replica of the 6-DOF St

aubli TX60 robot was

developed using MATLAB Simulink and Simscape Multibody to simulate both normal and faulty behaviors.

A dedicated fault injection module was used to generate motor blockage scenarios at different time instants,

creating a labeled dataset of 49 classes. The time-series data were then used to train a Gated Recurrent Unit

(GRU) neural network, which is efﬁcient for modeling temporal patterns. The trained model achieved an

accuracy of 87.35%, with strong performance across different fault types. This approach enables reliable,

non-invasive, and repeatable fault diagnosis and provides a solid foundation for future work on predictive

maintenance and deployment on real robotic platforms.

1 INTRODUCTION

The increasing integration of industrial robots in man-

ufacturing systems has raised new challenges in terms

of reliability, safety, and maintenance. Joint-level fail-

ures, particularly actuator blockages, are among the

most common and disruptive fault types, often lead-

ing to performance degradation or production down-

time (Liu et al., 2021), (She et al., 2022). As produc-

tion lines become more automated, there is a pressing

need for intelligent diagnostic systems capable of de-

tecting, isolating, and identifying such faults in real

time, while minimizing the reliance on additional in-

trusive sensors or manual intervention. Our method-

ology can be seamlessly integrated with existing sen-

sory feedback to enhance mission-critical decision-

making and predictive maintenance capabilities (Yin

and Kaynak, 2015), (Lee et al., 2015), (Sabry and

Amirulddin, 2024). In this context, the digital twin

paradigm has emerged as a powerful framework for

predictive maintenance and fault diagnosis. A digital

twin is a virtual replica of a physical system that en-

ables real-time simulation and monitoring of system

https://orcid.org/0009-0003-9972-2213

https://orcid.org/0000-0003-4332-0752

https://orcid.org/0000-0002-1660-3960

behavior under varying operating conditions (Grieves,

2022). Combined with artiﬁcial intelligence (AI), it

facilitates the generation of realistic training data and

enables non-destructive experimentation—two criti-

cal aspects for the development of robust diagnostic

models.

Related Work. Previous studies have explored

data-driven fault diagnosis in robotic systems us-

ing traditional classiﬁers, support vector machines

(SVM), or statistical models. For example, Liu et

al. (Liu et al., 2021) proposed sensorless force es-

timation using disturbance observers, while Sabry

and Amirulddin (Sabry and Amirulddin, 2024) pro-

vided a comprehensive review of robot fault detection

techniques. Our contribution differs by integrating a

physics-based digital twin with temporal deep learn-

ing models, enabling non-invasive and repeatable di-

agnosis under complex dynamic conditions. Com-

pared to conventional thresholding or signal mod-

eling approaches, our method leverages simulation-

driven data generation and time-series classiﬁcation,

providing higher scalability and adaptability to future

robotic platforms.

The main objective of this study is to propose

an integrated methodology that leverages a high-

Ben Hnaien, I., Gascard, E., Simeu-Abazi, Z. and Dhouibi, H.

Fault Diagnosis of Industrial Robots Using a Digital Twin and GRU-Based Deep Learning.

DOI: 10.5220/0013705600003982

Paper published under CC license (CC BY-NC-ND 4.0)

In Proceedings of the 22nd International Conference on Informatics in Control, Automation and Robotics (ICINCO 2025) - Volume 2, pages 487-494

ISBN: 978-989-758-770-2; ISSN: 2184-2809

487

ﬁdelity digital twin and a deep learning model to

diagnose actuator-level faults in a 6-DOF industrial

robot (St

aubli TX60). While several works have ex-

plored the use of recurrent neural networks (RNNs)

for time-series classiﬁcation, we focus here on Gated

Recurrent Units (GRU), a variant of RNNs known

for its computational efﬁciency and ability to capture

long-term dependencies in sequential data (Cho et al.,

2014). GRU are particularly suitable for robotic fault

diagnosis, where the temporal evolution of joint tra-

jectories provides essential clues for identifying fail-

ure types and their onset times. The proposed contri-

bution consists in (i) developing a comprehensive dig-

ital twin in MATLAB Simulink and Simscape Multi-

body, capable of replicating both nominal and faulty

dynamics of the TX60 robot; (ii) implementing a

structured fault injection module that introduces ran-

dom motor blockages at selected instants (e.g., 0.1

s, 0.4 s, 0.5 s); (iii) generating a labeled dataset of

time-series responses; and (iv) training a GRU-based

neural network classiﬁer in Python to distinguish be-

tween 49 different scenarios (48 faults + 1 normal

state). Our methodology is illustrated in Figure 1,

which summarizes the full pipeline—from fault sim-

ulation to neural classiﬁcation. The real robot serves

as a validation reference, while the digital twin pro-

duces repeatable scenarios for training and evalua-

tion. Fault signatures extracted from joint trajecto-

ries are used to teach the model how to recognize dis-

tinct fault types and their corresponding time proﬁles.

The remainder of this paper is structured as follows.

Section 2 details the proposed methodology, includ-

ing the digital twin setup, data generation strategy,

and GRU-based classiﬁcation approach. Section 3

presents the digital twin architecture and fault simu-

lation procedures. Section 4 describes the data prepa-

ration pipeline and neural network training. Section 5

discusses the model’s performance through accuracy

plots, confusion matrix, and detailed classiﬁcation

metrics. Finally, conclusions and future directions are

outlined in Section 6.

2 METHODOLOGY

The proposed methodology, illustrated in Figure 1,

combines a physics-based digital twin with a data-

driven deep learning classiﬁer to enable accurate fault

diagnosis on the St

aubli TX60 robotic arm. The real

system serves as a reference for validating the be-

havior of a high-ﬁdelity virtual replica developed in

MATLAB Simulink and Simscape Multibody.

This digital twin replicates both nominal and

faulty conditions and includes a fault injection mod-

ule that simulates motor blockage at predeﬁned in-

stants (e.g., 0.1 s, 0.4 s, 0.5 s) to generate diverse

and controlled fault scenarios. These simulations pro-

duce time series representing joint angles and end-

effector positions, which are then collected and seg-

mented into sequences of 10 time steps. The result-

ing labeled dataset, composed of 49 distinct classes

(48 fault scenarios and one nominal state), is used

to train a Gated Recurrent Unit (GRU) neural net-

work. GRU is a variant of recurrent neural networks

optimized for temporal pattern recognition, offering

a simpliﬁed architecture compared to LSTMs while

maintaining performance in sequence modeling (Cho

et al., 2014). The model is trained in Python over

100 epochs using the Adam optimizer and categor-

ical cross-entropy loss. Stratiﬁed splitting ensures

class balance across training and test sets. This inte-

grated simulation-learning framework provides a re-

producible and non-destructive approach for diagnos-

ing robotic joint faults under dynamic conditions.

3 DIGITAL TWIN AND FAULT

SIMULATION

The concept of the digital twin plays a central role

in modern fault detection strategies. It enables real-

time simulation, fault injection, and behavioral anal-

ysis without relying on physical hardware. In this

work, a digital twin of the St

aubli TX60 industrial

robot was developed to replicate both its nominal and

faulty operations. This twin was used to generate rep-

resentative data under different scenarios for training

and evaluating a neural network-based diagnoser.

3.1 Digital Model of the Robotic System

To accurately represent the behavior of the St

aubli

TX60 robot, a high-ﬁdelity digital twin was devel-

oped using MATLAB Simulink and Simscape Multi-

body (Boschetti and Sinico, 2024). This digital model

reproduces the kinematic and dynamic characteristics

of the robot under nominal conditions and serves as

a reference for fault diagnosis. The CAD structure of

the robot was imported in STEP format and integrated

into the Simscape environment via the Simulink in-

terface. The kinematic chain was reconstructed, and a

dynamic model was built using polynomial trajectory

generation, inverse and forward kinematics, and joint

actuation. Each joint is actuated by a dedicated motor,

and the control architecture relies on feedback loops

to track desired trajectories. The model simulates the

3D motion of the end-effector as it follows prede-

ﬁned paths, such as square trajectories in Cartesian

ICINCO 2025 - 22nd International Conference on Informatics in Control, Automation and Robotics

488

Figure 1: Overview of the Developed Digital Twin Architecture for Fault Diagnosis of the St

aubli TX60 Robot.

Figure 2: Cartesian End-Effector Trajectories: Two Square

Paths Executed by the Robot.

space. An overview of the developed digital twin is

illustrated in Figure 1, where the virtual model of the

aubli TX60 highlights the overall diagnostic frame-

work, including simulation and data extraction mod-

ules.

As shown in Figure 2, the robot executes two

square trajectories. The ﬁrst trajectory spans from

t = 0 s to t = 0.4 s, and the second trajectory starts

from t = 0.5 s to t = 0.9 s. These paths are designed

to test the system’s behavior under both normal and

faulty conditions. The corresponding joint angles for

both trajectories are presented in Figure 3, which pro-

vides insights into the coordinated movements of the

robot’s six joints (θ

to θ

In our previous work (Hnaien et al., 2024), the

TX60 was used as a physical reference model for de-

veloping a digital twin focused speciﬁcally on the arm

and shoulder subsystems, with an emphasis on a fault

scenario involving the position sensor. Building on

that foundation, this study extends the digital twin to

the full robot structure and explores motor-level faults

under dynamic conditions.

Figure 3: Joint Angle Responses (θ

to θ

) During Nominal

Operation for Two Square Trajectories.

3.2 Fault Injection and Signature

Generation

To simulate fault conditions, a dedicated fault injec-

tion module was integrated into the Simulink-based

digital twin. This module enables the insertion of spe-

ciﬁc motor faults—namely, blockage of one of the six

actuators—at controlled time instants. Each fault sce-

nario corresponds to one motor being locked (from

motor 1 to motor 6), allowing the system to exhibit

a distinct dynamic deviation in its joint trajectory.

These predeﬁned scenarios were injected both man-

ually and randomly through a centralized subsystem

managing all fault modes. This ensures consistency

across simulations and enables capturing the tempo-

ral evolution of joint responses after fault injection.

As illustrated in Figure 4, the angular trajectory of

joint 4 (θ

) deviates noticeably when a blockage fault

is introduced at t = 0.2 s, showcasing a fault-induced

divergence from the nominal behavior. This approach

ensures temporal diversity essential for training a ro-

bust classiﬁcation model. The labeled time series

Fault Diagnosis of Industrial Robots Using a Digital Twin and GRU-Based Deep Learning

489

Figure 4: Variation of Joint 4 Angular Trajectory Under

Normal Conditions and Following a Motor Blockage at t

= 0.2 s.

formed the input to the GRU-based neural network.

Although the fault injection times were discretely se-

lected (from 0.1 s to 0.8 s), this strategy provides a

structured dataset with consistent fault labels. How-

ever, it inherently limits the realism of fault onset be-

havior, as real-world faults may appear gradually or

at arbitrary times. This constraint will be addressed

in future work through continuous-time fault injection

mechanisms or stochastic fault onset modeling to bet-

ter reﬂect practical scenarios.

4 DATA PREPARATION AND

DEEP LEARNING MODEL

The success of a data-driven fault classiﬁcation sys-

tem critically depends on the quality of the dataset

and the architecture of the learning model. This sec-

tion describes the procedures followed for generating,

preprocessing, and structuring the data, as well as the

design and training of the GRU-based neural network

classiﬁer.

4.1 Data Collection and Preprocessing

The dataset was generated entirely from simulations

conducted within the digital twin environment of the

6-degree-of-freedom (6-DOF) St

aubli TX60 robot.

The resulting labeled dataset was composed of 49 dis-

tinct classes—including 48 fault scenarios generated

by injecting motor blockage at 8 time instants for each

of the 6 actuators (6 × 8), plus one nominal condition

(see Section 4 for details). In each simulation run,

a single fault was injected into one of the six joints

(θ

to θ

) by applying a motor blockage at speciﬁc

time instants ranging from 0.1 to 0.8 seconds. This

strategy led to 48 distinct faulty conﬁgurations, each

corresponding to a unique (joint, time) pair, in addi-

tion to a nominal operating state—resulting in a total

of 49 target classes.

Each simulation produced continuous multivariate

time series of joint angles and end-effector positions.

These signals were segmented into overlapping se-

quences of 10 consecutive time steps to capture the

temporal patterns associated with fault dynamics. In

order to ensure label consistency within each seg-

ment, only sequences for which at least 80% of the

samples belonged to the same class were retained.

This criterion reduced label noise and improved the

robustness of the classiﬁer.

The resulting dataset was composed of samples

shaped as 3D tensors of size (number of sequences,

10, number of features). All features were normalized

using the StandardScaler method, which standardizes

input values to have zero mean and unit variance. This

step mitigates the effect of scale differences among

input signals and facilitates faster convergence during

training. The categorical class labels were converted

into one-hot encoded vectors to be compatible with

the softmax output layer used in the GRU network.

To ensure fair and balanced evaluation, the dataset

was split into training and testing subsets using strat-

iﬁed sampling with an 80/20 ratio. This maintained

an even distribution of all fault types across the splits

and prevented class imbalance from biasing the learn-

ing process.

4.2 GRU-Based Fault Classiﬁer

To classify the fault scenarios from sequential input

data, a deep learning model based on Gated Recur-

rent Units (GRU) was adopted. GRU is a class of

Recurrent Neural Networks (RNNs) that have been

speciﬁcally designed to overcome the vanishing gra-

dient problem often encountered in traditional RNNs

during long sequence learning. They achieve this by

incorporating update and reset gates, which allow the

model to adaptively control the ﬂow of information

over time without the complexity of Long Short-Term

Memory (LSTM) cells (Cho et al., 2014). The de-

tailed architecture of the model is presented in the Ta-

ble 1.

The architecture was designed based on prelim-

inary experiments and insights from prior literature,

with the goal of balancing model complexity and rep-

resentational capacity. Speciﬁcally, the network com-

prises two successive GRU layers with 64 and 32

units, respectively. This conﬁguration was found to

be sufﬁcient for capturing temporal dependencies in

the data while mitigating the risk of overﬁtting.

ICINCO 2025 - 22nd International Conference on Informatics in Control, Automation and Robotics

490

Table 1: Details of each layer.

Layer Type Conﬁguration

GRU 64 units, return sequences, input

shape = (10, n

features

)

GRU 32 units

Dense 64 neurons, ReLU activation

Dense Output layer with 49 neurons, Soft-

max activation

A fully connected dense layer with 64 neurons and

a ReLU activation function was added following the

GRU layers to enhance non-linear feature extraction

before classiﬁcation. The ﬁnal output layer was tai-

lored to the multi-class classiﬁcation task using a soft-

max activation.

The model was implemented in Python using

the TensorFlow/Keras framework. Training was per-

formed using the Adam optimizer, which adaptively

adjusts learning rates to accelerate convergence. Cat-

egorical cross-entropy was employed as the loss func-

tion, suitable for multi-class scenarios. The batch size

was set to 32, considering both empirical performance

and hardware constraints. Training proceeded for a

maximum of 100 epochs.

To promote generalization and prevent overﬁtting,

an early stopping strategy was applied. In particular,

20% of the training set was reserved as a validation

set, stratiﬁed to preserve the class distribution. The

model’s validation loss was monitored during each

epoch, and training was halted if no improvement was

observed for 10 consecutive epochs. This regular-

ization technique effectively reduced overﬁtting and

improved the model’s ability to generalize to unseen

fault conditions.

Overall, the proposed architecture and training

strategy achieve a compromise between model com-

plexity, classiﬁcation accuracy, and computational

efﬁciency, enabling robust detection of ﬁne-grained

fault patterns in short time-series data.

While the current architecture was selected based

on preliminary experiments and literature insights,

a formal ablation study on GRU units, sequence

lengths, and dense layers will be conducted in future

work to assess model sensitivity and optimize perfor-

mance.

5 RESULTS AND

PERFORMANCE EVALUATION

To assess the effectiveness of the proposed GRU-

based diagnostic model, a comprehensive evaluation

was conducted using training history analysis, con-

fusion matrix interpretation, and class-wise classiﬁ-

cation metrics. These analyses provide insights into

the model’s ability to generalize, its robustness across

fault classes, and its performance consistency on un-

seen data.

5.1 Training and Validation Accuracy

The model’s learning behavior throughout the train-

ing process is depicted in Figure 5, which shows the

evolution of training accuracy (blue), validation ac-

curacy (red), and ﬁnal test accuracy (green). The

training curve exhibits a rapid rise in accuracy during

the early epochs, reaching a plateau at approximately

87.3%, indicating that the model effectively learned

the temporal patterns of the input sequences. The

validation curve closely follows the training curve,

with minimal divergence, suggesting that the model

exhibits low overﬁtting and strong generalization ca-

pabilities. Notably, the test accuracy—calculated on

a separate held-out dataset—remained consistent at

87.3%, further reinforcing the model’s robustness on

unseen fault scenarios.

Figure 5: Training, Validation, and Test Accuracy Evolution

Over Epochs.

5.2 Confusion Matrix and Class

Performance

The classiﬁcation outcomes for all 49

classes—comprising 48 distinct fault cases gen-

erated by blocking one of six motors at eight time

steps (0.1 s to 0.8 s), along with one nominal

class—are visualized in Figure 6 via the confusion

matrix. A strong diagonal dominance is observed,

reﬂecting high precision and recall for most fault

categories. The limited misclassiﬁcations that occur

are primarily concentrated between neighboring

time instances within the same joint, which can be

attributed to the natural similarity in system dynam-

ics for temporally adjacent faults. For example, a

blockage introduced at 0.3 s may produce a response

signal closely resembling that of a blockage at 0.4

s for the same joint. Despite these inherent chal-

Fault Diagnosis of Industrial Robots Using a Digital Twin and GRU-Based Deep Learning

491

Figure 6: Confusion Matrix of the GRU-Based Fault Classiﬁcation Model.

lenges, the classiﬁer maintained a high level of class

discrimination, even for closely spaced temporal

faults.

5.3 Classiﬁcation Metrics

The quantitative evaluation of the model’s predic-

tive performance is summarized in Table 2, which

reports the overall and average classiﬁcation met-

rics. The model achieved a macro-average F1-score

of 86.85%, indicating balanced performance across

all classes without bias toward more frequent labels.

Precision and recall values exceeded 91% and 87%

respectively in their weighted averages, highlighting

the model’s effectiveness in both correctly identify-

ing fault types and minimizing false negatives. Im-

portantly, the model reached perfect classiﬁcation for

the nominal (fault-free) class, afﬁrming its capability

to distinguish between healthy and faulty states with

high reliability.

Slightly lower performance was observed in a few

fault classes, notably involving motor 1 and motor 4,

particularly at mid-range fault injection instants (e.g.,

0.4 s or 0.5 s). This degradation is likely due to over-

laps in the fault signatures at these time intervals.

A deeper analysis using attention or saliency maps

could help understand which features contribute most

to confusion in these speciﬁc fault classes. Moreover,

data augmentation or multi-modal inputs (e.g., torque

or velocity signals) could improve discriminability.

Nonetheless, the model consistently produced

high-quality predictions and maintained overall accu-

racy at 87.35%, which is considered competitive for

high-resolution multi-class time-series classiﬁcation.

Table 2: Classiﬁcation Report.

Metric Value

Accuracy 87.35%

Macro Avg Precision 91.64%

Macro Avg Recall 87.35%

Macro Avg F1-Score 86.85%

Weighted Avg Precision 91.64%

Weighted Avg Recall 87.35%

Weighted Avg F1-Score 86.85%

5.4 Comparison with LSTM Baseline

To contextualize the GRU model’s performance, we

trained a baseline Long Short-Term Memory (LSTM)

model using the same dataset, sequence length, and

preprocessing pipeline. The LSTM model achieved a

higher test accuracy of 90.51%, slightly outperform-

ing the GRU classiﬁer.

Classiﬁcation metrics—including precision, re-

ICINCO 2025 - 22nd International Conference on Informatics in Control, Automation and Robotics

492

Figure 7: Confusion Matrix of the LSTM-Based Fault Classiﬁcation Model.

Figure 8: Training, Validation, and Test Accuracy of the

LSTM Model Across Epochs.

call, and F1-score—were consistently high across

most of the 49 classes, and the model particularly ex-

celled in handling overlapping temporal patterns. The

confusion matrix of the LSTM classiﬁer (Figure 7)

demonstrates strong diagonal dominance, indicating

excellent class separability. In parallel, Figure 8 illus-

trates the evolution of training, validation, and test ac-

curacy over epochs, revealing stable convergence and

effective generalization.

These results highlight that LSTMs, with their so-

phisticated memory mechanisms, offer improved ca-

pacity to capture long-term dependencies in sequen-

tial joint signals. However, despite this marginal gain

in accuracy, GRUs remain advantageous due to their

lower computational complexity and fewer parame-

ters, which make them more suitable for real-time de-

ployment, especially in embedded systems with con-

strained resources.

Overall, the inclusion of this LSTM baseline con-

ﬁrms the robustness of recurrent architectures for

robotic fault classiﬁcation and reinforces the validity

of the GRU-based approach adopted in this study.

These results validate the efﬁcacy of combin-

ing a simulation-based data generation approach with

GRU neural networks for robotic fault classiﬁcation.

The methodology demonstrates strong potential for

deployment in real-time monitoring systems where

early and accurate fault detection is critical.

6 CONCLUSION

This work presented a hybrid methodology that com-

bines a high-ﬁdelity digital twin with a GRU-based

deep learning architecture for real-time fault diagno-

sis of the St

aubli TX60 industrial robot. The proposed

approach enables the simulation of realistic motor

Fault Diagnosis of Industrial Robots Using a Digital Twin and GRU-Based Deep Learning

493

blockage faults and the generation of large-scale la-

beled datasets under controlled conditions. These

data were used to train a Gated Recurrent Unit (GRU)

classiﬁer capable of recognizing 49 distinct operat-

ing states, including both nominal and faulty behav-

iors. The model achieved high classiﬁcation accuracy

(87.35%) and strong generalization across multiple

fault scenarios, demonstrating the relevance of tem-

poral features captured through joint trajectories.

The digital twin not only ensured repeatability and

cost-effective experimentation but also allowed for

ﬁne-grained control over fault injection, improving

the quality of diagnostic data. Our ﬁndings highlight

the effectiveness of combining physics-based simu-

lation and data-driven learning for complex fault di-

agnosis tasks in robotics. Unlike traditional methods

relying on thresholding or signal modeling, this ap-

proach enables the automatic identiﬁcation of fault

type, location, and onset timing using only sequential

joint data.

While the current GRU classiﬁer was trained

on isolated motor jamming faults at discrete time

points, this work lays the foundation for future exten-

sions. We acknowledge that compound, cascading,

and evolving faults were not covered, and that fault

realism was limited by predeﬁned injection times.

To enhance generalization, future research will ex-

plore (i) dynamic fault injection mechanisms, (ii)

extended fault types such as sensor degradation or

torque anomalies, and (iii) learning from mixed-fault

conditions.

Additionally, although the digital twin offers con-

trolled and repeatable experimentation, validation

solely in simulation restricts real-world applicability.

We plan to implement hardware-in-the-loop valida-

tion and on-site robotic tests to evaluate robustness

under physical uncertainties and sensor noise.

In terms of learning architecture, beyond re-

current models like GRU and LSTM, we will in-

vestigate more recent temporal models such as

Transformer-based encoders and State-Space Se-

quence Models (SSSM). In particular, the Mamba

architecture—which captures temporal dynamics

through continuous-time formulations inspired by or-

dinary differential equations—presents a promising

direction. Its alignment with the physics-based nature

of robotic systems could enable better interpretability

and improved generalization under varying time res-

olutions.

Overall, this work represents a promising step to-

ward deploying intelligent, real-time fault detection

and predictive maintenance in industrial robotic sys-

tems.

REFERENCES

Boschetti, G. and Sinico, T. (2024). Designing digital

twins of robots using simscape multibody. Robotics,

13(4):62.

Cho, K., Van Merri

enboer, B., Gulcehre, C., Bahdanau, D.,

Bougares, F., Schwenk, H., and Bengio, Y. (2014).

Learning phrase representations using rnn encoder-

decoder for statistical machine translation. arXiv

preprint arXiv:1406.1078.

Grieves, M. (2022). Digital twin: manufacturing excellence

through virtual factory replication. 2014. White Paper.

Hnaien, I. B., Gascard, E., Simeu-Abazi, Z., and Dhouibi,

H. (2024). Methodology of construction of a digital

twin: Application to the st

aubli robot’s arm and shoul-

der. In 2024 IEEE International Conference on Arti-

ﬁcial Intelligence & Green Energy (ICAIGE), pages

1–6. IEEE.

Lee, J., Bagheri, B., and Kao, H.-A. (2015). A cyber-

physical systems architecture for industry 4.0-based

manufacturing systems. Manufacturing letters, 3:18–

23.

Liu, S., Wang, L., and Wang, X. V. (2021). Sensor-

less force estimation for industrial robots using distur-

bance observer and neural learning of friction approx-

imation. Robotics and Computer-Integrated Manufac-

turing, 71:102168.

Sabry, A. H. and Amirulddin, U. A. B. U. (2024). A review

on fault detection and diagnosis of industrial robots

and multi-axis machines. Results in Engineering, page

102397.

She, J., Miyamoto, K., Han, Q.-L., Wu, M., Hashimoto,

H., and Wang, Q.-G. (2022). Generalized-extended-

state-observer and equivalent-input-disturbance meth-

ods for active disturbance rejection: Deep observation

and comparison. IEEE/CAA Journal of Automatica

Sinica, 10(4):957–968.

Yin, S. and Kaynak, O. (2015). Big data for modern indus-

try: challenges and trends [point of view]. Proceed-

ings of the IEEE, 103(2):143–146.

ICINCO 2025 - 22nd International Conference on Informatics in Control, Automation and Robotics

494