KR102870758B1 - Apparatus and method to control real-time multiple task using python language - Google Patents

Abstract

A device for controlling real-time multi-tasks using the Python language, comprising: a module (120, 102) for patching Linux into an operating system capable of supporting real-time; a first Python module (100) for generating a real-time task with real-time constraints based on the Python language; a second Python module (110) for controlling an EtherCAT network by interworking with the EtherCAT master core based on the Python language; an EtherCAT master core (112) interworking with an IgH EtherCAT (Ethernet for Control Automation Technology) master module (114) for a real-time fieldbus interface; and an FFI (130) implemented to load a library for driving the first Python module and the second Python module through a preset language module.

Description

Apparatus and method for controlling real-time multiple tasks using Python language {APPARATUS AND METHOD TO CONTROL REAL-TIME MULTIPLE TASK USING PYTHON LANGUAGE}

The present invention relates to a device and method for controlling real-time multi-tasks using the Python language.

Recently, artificial intelligence technology has been applied across social and industrial facilities, including robots, the Internet of Things (IoT), and self-driving cars. Research and development for the implementation of these technologies are primarily based on the Python language.

The Python language offers an intuitive syntax, a low barrier to entry, and a variety of libraries for data processing, and is particularly widely used for artificial intelligence and machine learning libraries such as TensorFlow, PyTorch, and Keras.

However, due to its interpreted nature, Python's processing performance can be relatively low compared to compiled languages like C/C++, which can lead to performance issues in some cases. To address these issues, various approaches can be utilized, including C-based extension modules, Just-in-Time (JIT) compilers, and code optimization.

Python also has the problem of not guaranteeing real-time constraints. Real-time constraints are constraints that require a system to operate within a given target time, and are essential for control devices. This means responding quickly to external conditions or user requests and achieving the desired results within a given target time. These real-time constraints play a crucial role in various industries, such as medical devices, automotive safety systems, manufacturing processes, robotic control systems, and military equipment. However, Python struggles to meet real-time constraints, limiting its application as a language for real-time control systems.

In addition, EtherCAT, which is used as a serial communication means for real-time control as an industrial field bus, is mainly implemented in PLC (Programmable Logic Controller) or C/C++ language, and PLC or C/C++ language has the problem that it is difficult to use directly in Python.

Although the Python language is widely used in the fields of artificial intelligence and machine learning, it has limitations in control systems for mechanical devices that must meet real-time constraints or in integration with some industrial field buses, and its use in control systems that integrate artificial intelligence applications is limited.

Korean Patent Publication No. 10-2006211

The present invention has been devised to solve the above problems, and the purpose of the present invention is to provide a device and method for controlling real-time multi-tasks using the Python language.

According to one embodiment of the present invention for achieving the above object, a device for controlling real-time multi-tasks using the Python language includes a module (120, 102) for patching Linux into an operating system capable of supporting real-time performance; a first Python module (100) for generating a real-time task with real-time constraints based on the Python language; a second Python module (110) for controlling an EtherCAT network by interworking with the EtherCAT master core based on the Python language; an EtherCAT master core (112) interworking with an IgH EtherCAT (Ethernet for Control Automation Technology) master module for a real-time fieldbus interface, and an FFI (130) implemented to load a library for driving the first Python module and the second Python module through a preset language module.

A method for controlling real-time multi-tasks using the Python language according to one embodiment of the present invention for achieving the above object includes: a step in which a first Python module (100) loads an RT-POSIX library through an FFI (130); a step in which a real-time task having real-time constraints is created by calling functions written in the C language using the loaded RT-POSIX library; a step in which a second Python module (110) loads an EtherCAT master core library through the FFI; and a step in which an EtherCAT network is controlled by calling functions written in the C language using the loaded EtherCAT master core library.

According to one aspect of the present invention described above, by providing a device and method for controlling real-time multi-tasks using the Python language, the difficulty of developing a control system is improved by utilizing the intuitive grammar, low entry barrier, and various libraries of the Python language, thereby simplifying the process of building a real-time control system and improving efficiency.

In addition, the Python language is already widely used in various fields, making it easy to integrate with libraries related to artificial intelligence and data processing, making it highly feasible. It also allows for fast and flexible development, helping to improve the productivity and maintainability of control system development.

FIG. 1 is a diagram showing a software architecture for controlling real-time multi-tasks using the Python language according to an embodiment of the present invention;
Figure 2 is a diagram showing a list of functions that implement Python functions through function wrappers.
FIG. 3 is a drawing showing a class diagram of an EtherCAT master core according to an embodiment of the present invention;
And, Fig. 4 is a flowchart showing the operation of a device for controlling real-time multi-tasks using the Python language according to an embodiment of the present invention.

The following detailed description of the present invention refers to the accompanying drawings, which illustrate specific embodiments in which the present invention may be practiced. These embodiments are described in sufficient detail to enable those skilled in the art to practice the present invention. It should be understood that the various embodiments of the present invention, while different from each other, are not necessarily mutually exclusive. For example, specific shapes, structures, and characteristics described herein may be implemented in other embodiments without departing from the spirit and scope of the present invention. Furthermore, it should be understood that the positions or arrangements of individual components within each disclosed embodiment may be modified without departing from the spirit and scope of the present invention. Accordingly, the following detailed description is not intended to be limiting, and the scope of the present invention is defined only by the appended claims, along with the full scope of equivalents to which such claims are entitled, if properly described. Like reference numerals in the drawings designate the same or similar functionality throughout the several aspects.

The components according to the present invention are defined by functional distinctions rather than physical distinctions, and can be defined by the functions each component performs. Each component may be implemented as hardware or program code and processing units that perform each function, and the functions of two or more components may be implemented by including them in a single component. Therefore, the names given to the components in the following embodiments are not intended to physically distinguish each component, but rather to suggest the representative functions performed by each component, and it should be noted that the technical spirit of the present invention is not limited by the names of the components.

Hereinafter, preferred embodiments of the present invention will be described in more detail with reference to the drawings.

FIG. 1 is a diagram showing the software architecture of a device for controlling real-time multi-tasks using the Python language according to an embodiment of the present invention.

The first Python module, the PyRT (Python-based Real-Time) module (100) and the real-time (RT: Real-Time)-POSIX (Portable Operating System Interface) module (102), represent components required to create and manage real-time tasks, the second Python module, the PyIgH (Python-based IgH) module (110), the EtherCAT (EtherCAT: Ethernet for Control Automation Technology) master core (Core) (112), and the IgH EtherCAT master module (114), represent EtherCAT-related components, and the RT-Preempt kernel (Kernel) (120) is a module that patches Linux into an operating system capable of supporting real-time performance together with the RT-POSIX module (102).

The essential components for developing a real-time application for EtherCAT control are grouped and indicated by dotted lines in Fig. 1, and include the library of the EtherCAT master core (112), the Foreign Function Interface (FFI) (130) that enables the use of dynamic libraries in Python, the Python module PyRT (Python-based Real-Time) module (100), and the Python module PyIgH (Python-based IgH) module (110).

The EtherCAT master core (112) is interoperable with the IgH EtherCAT master module (114) for a real-time fieldbus interface, and was developed to abstract EtherCAT-related system-level routines based on the IgH EtherCAT master API (Application Programming Interface) and library that do not require user attention. The master base (112-1) handles the configuration of the EtherCAT master according to the connected slaves, and each slave must be described by its own slave base (112-4) instance. In its current form, the EtherCAT master core (112) supports servo drives.

The PyRT module (100) creates a real-time task (RT Task) with real-time constraints based on the Python language, and the PyIgH module (110) controls the EtherCAT network by linking with the EtherCAT master core (112) based on the Python language.

FFI (130) can be implemented as a preset language module, for example, CTypes, C Foreign Function Interface (CFFI), or Simplified Wrapper and Interface Generator (SWIG). FFI (130) according to an embodiment of the present invention calls a function for driving PyRT module (100) and PyIgH module (110) through CTypes, releases GIL (Global Interpreter Lock) to prevent unwanted delay or system crash, and loads necessary dynamic libraries, i.e., EtherCAT master core library and RT-POSIX library, into Python.

The PyIgH module (110) uses the shared library libethercat to perform domain activation, slave initialization, distributed clock synchronization, data exchange, and status check functions. Below, these functional wrappers will be described in more detail with reference to FIG. 2.

FIG. 2 is a diagram showing a list of functions that implement Python functions through function wrappers, and FIG. 3 is a diagram showing a class diagram of an EtherCAT master core according to an embodiment of the present invention.

The ecat_init_slave() function is called to initialize an EtherCAT slave and performs several important steps:

First, the ecrt_request_master() function is used to request real-time user-space operations from the EtherCAT master instance, which allows the application to use the EtherCAT system.

Next, the ecrt_master_create_domain() function is used to create a process data domain for process data exchange. The process data domain is important for registering and periodically exchanging PDO (Process data object), a protocol used to transfer data between slaves in real time, and then the ecrt_master_slave_config() function is used to create a slave configuration object. The ecrt_master_slave_config() function takes an alias and a location as input and compares the vendor identifier (ID) and product code of the slave with the specified address with the specified values. If the vendor ID and product code do not match the specified values, the slave is not configured and an error occurs.

The ecrt_slave_config_pdos() function is used to specify the entire PDO mapping configuration for the master, and the PDO entries for the created domain are registered using the ecrt_domain_reg_pdo_entry_list() function. This is a crucial step in the process of initializing an EtherCAT slave.

Finally, the ecrt_slave_config_dc() function is used to enable and configure the distributed clock. This ensures synchronous communication between EtherCAT slave devices, and data is received in a sequence that must be followed during cyclic operation. This involves retrieving stored datagrams from the Ethernet device buffer and determining the status or operation counter of the EtherCAT frame.

This process is performed immediately after checking the status of the master and slave using the ecat_master_receive() function, followed by the ecat_domain_process() function. The data is transmitted after processing the datagram and creating the next set of commands, which are then copied back to the device's buffer and transmitted back to the slave using the ecat_domain_queue() function. The ecat_domain_queue() function enqueues the datagram so that it can be exchanged in the next call to the cat_master_send() function, which transmits all datagrams in the queue.

Distributed clock synchronization is implemented to match the DC synchronization of slave devices using the ecat_write_apptime() function. Status checks are used to determine specific information and status, such as the master's status, the slave device's product code, and the vendor ID. These functions are ecat_get_slave_info() , get_master_status() , and check_slave_state() .

These functions are implemented as methods of the master base class (112-1) and slave base class (112-4) of FIG. 3.

Enabling EtherCAT communication requires manually registering PDO domain mappings. To facilitate this task, a slave base class (112-4) is implemented. Furthermore, to facilitate EtherCAT domain management and debugging, two domains are created to distinguish data transmission and reception tasks for each slave.

The slave base class (112-4) is configured to perform a master-slave relationship establishment function, and the master-slave relationship establishment function may be, for example, PDO mapping, DC activation, slave status check, etc.

The slave servo class (112-2) is a child class inherited from the slave base class (112-4) and functions as a class for a servo driver using CANOpen-over-EtherCAT (CoE). On the other hand, the slave IO (Input/Output) class is another child class responsible for controlling digital or analog input/output devices.

FIG. 4 is a flowchart showing the operation of a device for controlling real-time multi-tasks using the Python language according to an embodiment of the present invention.

The PyRT module, which is the first Python module of the real-time multi-task control device according to an embodiment of the present invention, loads the RT-POSIX library through FFI (S402), and calls functions written in the C language using the library loaded in S402 to create a real-time task with real-time constraints (S404).

The PyIgH module, which is the second Python module of the above real-time multi-task control device, loads the EtherCAT master core library through FFI (S406) and controls the EtherCAT network by calling functions written in C using the library loaded in S406 (S408).

The real-time multi-task control method of the present invention using the Python language as described above may be implemented in the form of program commands that can be executed by various computer components and recorded on a computer-readable recording medium. The computer-readable recording medium may include program commands, data files, data structures, etc., either singly or in combination.

The program commands recorded on the above computer-readable recording medium may be specially designed and configured for the present invention or may be known and available to those skilled in the art of computer software.

Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, and flash memory.

Examples of program instructions include not only machine language codes, such as those generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter or the like. The hardware device may be configured to operate as one or more software modules to perform processing according to the present invention, and vice versa.

Although various embodiments of the present invention have been illustrated and described above, the present invention is not limited to the specific embodiments described above, and various modifications can be made by a person having ordinary skill in the art to which the present invention pertains without departing from the gist of the present invention as claimed in the claims, and such modifications should not be understood individually from the technical idea or prospect of the present invention.

Claims (5)

In a device that controls real-time multi-tasks using the Python language,
A module (120, 102) that patches Linux into an operating system capable of supporting real-time;
A first Python module (100) that creates a real-time task with real-time constraints based on the above Python language;
A second Python module (110) that controls the EtherCAT network by linking with the EtherCAT master core based on the above Python language;
An EtherCAT master core (112) linked to an IgH EtherCAT (Ethernet for Control Automation Technology) master module (114) for a real-time fieldbus interface; and
Includes an FFI (Foreign Function Interface) (130) implemented to load a library for driving the first Python module and the second Python module through a preset language module,
A real-time multi-task control device characterized in that the first Python module loads a real-time (RT: Real-Time)-POSIX (Portable Operating System Interface) library through the FFI and calls functions written in the C language using the loaded library.
delete In the first paragraph,
A real-time multi-task control device characterized in that the second Python module loads the EtherCAT master core library through the FFI and calls functions written in the C language using the loaded library.
In the first paragraph,
A real-time multi-task control device, characterized in that the above preset language module includes a C-type (CTypes) language module, and the FFI is implemented with the C-type language module.
A method for controlling real-time multi-tasks using the Python language,
A step in which the first Python module (100) loads a real-time (RT)-POSIX (Portable Operating System Interface) library through FFI (Foreign Function Interface) (130);
A step of creating a real-time task with real-time constraints by calling functions written in C language using the above-loaded RT-POSIX library;
A step in which the second Python module (110) loads the EtherCAT (Ethernet for Control Automation Technology) master core library through the FFI; and
A real-time multi-task control method, comprising: a step of controlling an EtherCAT network by calling functions written in C language using the above-mentioned loaded EtherCAT master core library.