Method of controlling industrial machine

Abstract

The invention relates to a method of controlling an industrial machine comprising a control unit, such as a PLC, and at least one actuator and / or sensor controlled by the control unit, in which:-a language model is provided,-a language model interface is provided,-a context information base is provided, which stores information about the industrial machine, and-a control unit is provided, wherein-the language model interface provides information about the industrial machine from the context information base to the language model,-the language model sends the command to be executed by the industrial machine to the language model interface, and-the language model interface sends the command to be executed by the industrial machine. -the language model interface translates commands received from the language model into machine commands for the control unit.

Description

Technical Field

[0001] The present invention relates to a method for controlling an industrial machine, which includes a control unit, such as a PLC, and at least one actuator and / or one sensor controlled by the control unit. Background Art

[0002] Industrial machines are used in a variety of applications, such as for sorting, packing, filling, or manufacturing of goods. Usually, industrial machines are programmed by engineers, who will have to repeatedly modify the programming to achieve an optimized operation of the industrial machine.

[0003] This programming and programming optimization of industrial machines can be time-consuming. Summary of the Invention

[0004] Therefore, an object of the present invention is to provide a method for controlling an industrial machine, which reduces the time required to operate the industrial machine and / or optimize the operation of the industrial machine.

[0005] This object is achieved by the method according to claim 1.

[0006] The method according to claim 1 relates to controlling an industrial machine, which includes a control unit, such as a PLC, and at least one actuator and / or sensor controlled by the control unit, wherein

[0007] - a language model is provided,

[0008] - a language model interface is provided,

[0009] - a context information library is provided, which stores information about the industrial machine, in particular commands executable by the industrial machine, wherein

[0010] - the language model interface provides information about the industrial machine from the context information library to the language model,

[0011] - the language model sends commands to be executed by the industrial machine to the language model interface,

[0012] - the language model interface translates the commands received from the language model into machine commands for the control unit.

[0013] The present invention is based on the idea of using the problem-solving ability of a language model to automatically generate instructions, i.e., machine commands, so as to operate the industrial machine in a desired manner. The machine commands can, for example, include code (such as source code and / or executable code) and / or can include commands executable by the industrial machine.

[0014] By providing the language model with information about the industrial machine from the context information repository, the language model knows the working principle and settings of the industrial machine and can thus obtain a certain "understanding" of the industrial machine. Preferably, the language model is given the task and / or requirements to be completed, whereupon the language model then uses its knowledge of the industrial machine to provide, for example, a sequence of commands to be executed by the industrial machine. These commands, which can be integrated into human language text, are sent to the language model interface, where the language model interface translates the commands received from the language model into machine commands for the control unit.

[0015] Advantageously, by using the method of the present invention, machine commands for the control unit can be automatically generated in a very short time, where the machine commands are specific to achieve the result desired by the operator.

[0016] The language model can include artificial intelligence, particularly pre-trained artificial intelligence. The language model can preferably be a generative language model. The language model can be a publicly available language model. By employing a pre-trained and / or publicly available language model, it is advantageous that no training of the artificial intelligence is required to control the industrial machine. As previously mentioned, the language model already provides problem-solving capabilities and can also provide, for example, a storage capability that allows the storage of information about the industrial machine from the context information repository, whereupon the language model then has all the necessary information and skills to generate the commands to be executed by the industrial machine.

[0017] The control unit can include one or more PLCs (programmable logic controllers) that control the actuators and sensors of the industrial machine. Accordingly, the industrial machine can include a plurality of actuators, such as motors, pumps, etc. and / or sensors, such as temperature sensors, magnetic sensors, optical sensors, etc., where the control unit and the actuators and / or sensors can be connected via a fieldbus (such as Sercos, EtherCAT, EIP, etc.).

[0018] The language model, the language model interface, and / or the context information repository can be stored and / or executed on the supervision unit. The supervision unit can be a computer connected to the industrial machine via a data link. The supervision unit can also be part of the control unit.

[0019] Preferably, the language model interface is connected to the control unit using a data connection (such as Ethernet and / or a fieldbus). After receiving the machine commands from the language model interface, the control unit can use the actuators and / or sensors of the industrial machine to execute these machine commands.

[0020] The control unit can, for example, include only one PLC or multiple PLCs. If there are multiple PLCs, the same language model interface can be used for more than one or all of the PLCs. Alternatively, different language model interfaces can be used for each PLC. Each different language model interface can be adapted to a specific PLC and can, for example, include an interface that matches the interface of the corresponding PLC.

[0021] Commands sent by the language model and / or machine components can include library functions and / or programming functions that the control unit can use, which will be shown in more detail below.

[0022] Advantageous embodiments of the present invention are disclosed in the description, the drawings, and the dependent claims.

[0023] According to one embodiment, the language model and the language model interface exchange information in human language. The information exchange between the language model and the language model interface can be in electronic form, for example, using a data bus or a data storage device, where the electronically exchanged information includes, for example, text in human language. The exchanged information can be, for example, English, German, or any other human language. In other words, the exchanged information can preferably be understood by a person and / or is preferably semantically and grammatically correct. The information exchange in human language is at least in the direction from the language model interface to the language model. Preferably, the information exchange in human language is two-way, i.e., also from the language model to the language model interface. Advantageously, the information about the industrial machine that already exists in human language can thus be received into the context information library without having to be adapted.

[0024] Communicating with the language model using human language allows the full potential of the language model to be exploited because the language model is particularly suitable for processing inputs based on human language and outputting information in human language.

[0025] According to another embodiment, the language model includes a large language model, particularly a publicly available large language model, where the large language model is preferably suitable for context understanding and / or includes knowledge representation capabilities. The large language model can be based on deep learning techniques and can have a large number of parameters internally, preferably more than ten million, further preferably more than one hundred million.

[0026] It should be emphasized that neither the language model nor the large language model has to be specifically trained for controlling an industrial machine. Instead, off-the-shelf language models or large language models can be used. For example, AutoGPT can be adopted, where AutoGPT uses GPT from OpenAI to autonomously complete tasks and / or user requirements. Since the overall problem-solving ability of the language model or the large language model is high enough, no specific training for controlling an industrial machine is required.

[0027] Specifically, a language model and / or a large language model can have the following capabilities, where the large language model preferably differs from the language model in the number of internal parameters (the internal parameters of the large language model can be 10 times or 100 times higher than those of the language model).

[0028] The following statements about the language model also apply to the large language model.

[0029] The language model can have context understanding. The language model is good at understanding context. The language model can be adapted to process and / or understand complex information, such as details about machinery, electricity, available functions executed on a control unit, and application and target requirements of industrial machines. Therefore, the language model can be adapted to generate plans that meet the specific requirements and / or constraints of industrial machines.

[0030] The language model can have knowledge representation capabilities. The language model can be adapted to store and call (a large amount of) information, allowing the language model to access relevant data about industrial machines, their components, and expected results. The language model can be adapted to utilize knowledge in formulating plans that optimize performance and achieve the tasks and / or requirements received by the operator.

[0031] In addition, the language model can have sequence generation capabilities. The language model can be adapted to generate coherent and / or meaningful sequences of actions and / or instructions (i.e., commands to be executed by an industrial machine). For example, given information from a context information repository, which can include functions executable by an industrial machine, i.e., context information, the language model can generate a plan that outlines a sequence of actions to control the industrial machine. For this purpose, the language model can be adapted to consider the dependencies, timing, and / or specific requirements of each step in the sequence.

[0032] The language model can also include problem-solving and / or optimization capabilities. In other words, the language model can include problem-solving capabilities for proposing optimized plans. The language model can be adapted to analyze context information and / or given tasks and / or requirements to be completed, and then can suggest actions and / or strategies, such as maximizing efficiency, minimizing energy consumption, reducing downtime, and / or achieving other desired goals. The language model can be used to measure different options and propose the most suitable course of action.

[0033] The language model can be configured to adapt to new situations and learn from feedback. As will be described in more detail later, when the language model generates plans and controls an industrial machine, it can incorporate (real-time) feedback data and adjust its strategy accordingly. This adaptability can enable the language model to continuously improve its plans and performance over time, thus ensuring optimal control and response to changing conditions.

[0034] According to another embodiment, the language model receives an input from an operator, the input including a task and / or requirement to be performed by an industrial machine, where the input is preferably in human language. Thus, the input can set a goal for the language model, where the language model can then use information about the industrial machine (i.e., context information) from, for example, a context information repository to provide commands to be executed by the industrial machine that performs the task and / or requirement. For example, in a parcel sorting application, the task could simply be: "Sort all parcels weighing more than 5 kilograms to exit 1 and sort all parcels weighing equal to or less than 5 kilograms to exit 2". The context information can then include information about the conveyor belt of the industrial machine, information about the location of the weight sensors, and information about the library functions executable by the control unit. Additionally, the context information can include information about the mechanical structure of the industrial machine. Based on this input information, the language model can then output commands to be executed by the industrial machine that performs the given task.

[0035] In another example, the operator can simply ask the language model: "Achieve maximum throughput", for example, for a pipe filling application. This example will be further elaborated below.

[0036] According to another embodiment, preferably through a language model interface, the input from the operator is supplemented by including information about the industrial machine from a context information repository. Further preferably, when supplementing the input from the operator, a set of functions executable by the control unit is (added to the included information and thus) presented to the language model.

[0037] For example, the operator's input could be: "The overall goal to be achieved is: Achieve maximum throughput for a pipe filling application".

[0038] The pipe filling application can be carried out on a multi-carrier system having different carriers that can move independently of each other along a track, where the multi-carrier system includes several stations at which, for example, pipes can be placed or filled. This information about the multi-carrier system can be included in the context information repository, where the language model interface can then, for example, provide the following hints to the language model:

[0039] "The overall goal to be achieved is: Achieve maximum throughput for a pipe filling application.

[0040] This application should be implemented using the Lexium MC12 multi-carrier product.

[0041] Lexium MC12 is a multi-carrier system consisting of a linear motor, a carriage, and a magnetic track.

[0042] The linear motor is responsible for generating the movement of the carriage, which moves along the magnetic track.

[0043] Depending on the application requirements, the carriage can be equipped with different types of carriers, such as trays, pallets or fixtures.

[0044] The system can be integrated with Schneider Electric's PacDrive 3 motion controller to provide a complete automation solution.

[0045] The PacDrive 3 controller provides advanced functions such as motion control, logic control and robot control.

[0046] The multi-carrier application will have 4 stations: loading empty tubes, filling tubes, closing tubes, unloading filled tubes.

[0047] The loading and unloading time is 700 milliseconds.

[0048] Acceleration and speed: the possible maximum values.

[0049] The complete track length is 6544 millimeters.

[0050] The possible positions of the carriers on the track are within (0, 6544) with an accuracy of 1 millimeter.

[0051] Now, let's delve into the details of the application:

[0052] The track is described by the track_description_string "sssssssccsscssssscsscc", which is composed of a combination of straight segments (S) and curved segments (C).

[0053] The application includes different entities, starting with the carriers. 12 carrier positions are defined along the track, with specific distances from the starting point as: [1750, 1600, 1450, 1300, 1150, 1000, 850, 700, 550, 400, 250, 50].

[0054] The application also includes several general stations:

[0055] The first general station is located at position 2060 on the track. When the carriers reach this station, they need to wait for 0.680 seconds before they can perform further operations. At least four carriers are required to trigger the station action. After completing the station action, the carrier status is set to 1.

[0056] The second general station is located at 3800 on the track. The carriers arriving at this station must wait for 0.550 seconds before they can continue. Similar to the previous station, four carriers are required, and after completion, the carrier status is set to 2.

[0057] The third general station is located at 5600 on the track. The carriers arriving at this station need to wait for 2.0 seconds. However, in this case, at least twelve carriers are required. After completion, the carrier status is set to 3.

[0058] The fourth and final general station is located at 1500 on the track. Carriers arriving at this station must wait 0.680 seconds before proceeding. Four carriers are required, and upon completion, the carrier status is set back to 0.

[0059] The LLM interface can interact with the multi-carrier system using the following library functions (this information can also be provided by the LLM interface component):

[0060] class OPCMultiCarrierTrack

[0061] func __init__

[0062] func __init_carriers

[0063] func __init_stations

[0064] func connect

[0065] func disconnect

[0066] func init_carrier_parameters

[0067] func init_carrier_positions

[0068] func get_next_carrier_behind_pos

[0069] func get_carrier_positions

[0070] func get_carrier_front_gaps

[0071] func get_front_gap

[0072] func get_station_observations

[0073] func apply_station_actions_group_command

[0074] func get_action_mask

[0075] func send_carriers_to_initial_station

[0076] func move_carrier

[0077] func move_carriers

[0078] func move_carriers_by_idfunc reset_carriers

[0079] func get_track_length

[0080] func get_carrier_at_positionclass OPCStationfunc__init__

[0081] func__init_carrier_standing_positionsfunc__apply_action

[0082] func apply_action_optimizedfunc__step_carriers_waitfunc__step_carriers_constant_speed_startfunc__step_carriers_constant_speed_stopfunc__step_carrier_clamp_startfunc__step_carrier_clamp_stopfunc__step_carrier_unclamp_startfunc get_next_free_standing_positionfunc get_observation

[0083] func get_carriers_in_stationfunc get_carriers_in_station_constant_speedfunc get_carrier_in_stationfunc get_carriers_processedfunc__get_carriers_stateclass OPCCarrierfunc__init__

[0084] func connect

[0085] func unsubscribe

[0086] func subscribe_to_data

[0087] func set_parameters

[0088] func move

[0089] func reset”

[0090] It can be seen that the context information included in the prompt includes structural information about the multi-carrier, such as straight segments and curved segments, the mechanical positions of the stations, and a list of functions executable by the control unit. These functions preferably have self-explanatory names. Since the language model can also be adapted to understand programming code, such as source code, the language model can adopt the given functions to meet the proposed tasks. For example, the function move_carrier can be understood by the language model as a function that can be used to move the carrier along the track to a specific position.

[0091] In addition, the prompt (i.e., information about the industrial machine and the task) can also include technical documentation about the industrial machine, which can disclose details about the industrial machine and the functions that can be used to control the industrial machine. For simplicity, the example given here omits the prompt part that references the technical documentation.

[0092] The input from the operator can be supplemented by the task specification part. The task specification part can include commands to instruct the language model to consider the provided context information and / or output detailed instructions on how to use the provided functions. It can also include a request for the language model to provide output in a given structure, which for example includes "Thought", "Reasoning", "Plan", "Criticism", "Speech".

[0093] The task specification part can be pre-programmed and / or fixed, for example. For the above example, the task specification part can be as follows and can be appended to the prompt given above:

[0094] "Now please perform the plan generation step.

[0095] Please carefully consider the provided context information.

[0096] Please ensure that the plan is expressed by providing detailed instructions on how to use the provided functions.

[0097] Please express the plan with reference to the functions, application descriptions, overall requirements, etc. described in the context information.

[0098] Ensure that your plan provides actual values for the target position, speed, acceleration, wait / processing time, etc.

[0099] The overall output should be in the following format:

[0100] Thought:

[0101] Reasoning:

[0102] Plan:

[0103] Criticism:

[0104] Speak: "

[0105] After receiving an input from an operator and preferably a supplementary input, the language model considers the complete input and generates an output based on the tasks laid out in the input. The output can include commands to be executed by an industrial machine. The output can be sent to a language model interface.

[0106] In particular, the output can include different parts, namely, thought, reasoning, plan, criticism, and / or speak. The thought part can include an overall summary of the tasks to be executed. The reasoning part can include the main goals identified by the language model along which the language model develops a plan. The plan part can include commands to be executed by an industrial machine, preferably included in the text of a human language. The criticism part can include information on how to further improve the plan. Finally, the speak part can include general information about the plan and how to best implement the plan.

[0107] For the example given above, the output generated by the language model can be as follows:

[0108] "Thought: Based on the provided requirements and available library functions, the plan should focus on optimizing the throughput of the pipeline filling application using the Lexium MC12 multi-carrier system. We need to consider the specific actions and parameters of each station to ensure smooth operation.

[0109] Reasoning: To achieve maximum throughput, we should aim to minimize idle time and optimize the carrier movement between stations. This can be achieved by carefully coordinating the carrier positions, speeds, and actions of each station.

[0110] Plan:

[0111] Initialize the OPC Multi-Carrier Track and OPC Station objects using the provided functions.

[0112] Connect to the multi-carrier system using the connection function.

[0113] Set the carrier parameters and positions using the init_carrier_parameters and init_carrier_positions functions.

[0114] Send the carriers to the initial station using the send_carriers_to_initial_station function.

[0115] Use the move_carriers function to move the carrier to the empty tube loading station (position: 2060) at a speed of 2000 mm / s and an acceleration of 20000 mm / s^2.

[0116] Wait for 680 milliseconds and use the carrier_process_actions.wait function to load the tube.

[0117] Use the move_carriers function to move the carrier to the tube filling station (position: 3800) at a speed of 2000 mm / s and an acceleration of 20000 mm / s^2.

[0118] Wait for 550 milliseconds and use the carrier_process_actions.wait function to fill the tube.

[0119] Use the move_carriers function to move the carrier to the closed tube station (position: 5600) at a speed of 1500 mm / s and an acceleration of 20000 mm / s^2.

[0120] Wait for 2000 milliseconds and use the carrier_process_actions.wait function to close the tube.

[0121] Use the move_carriers function to move the carrier to the station for unloading the filled tube (position: 1500) at a speed of 1700 mm / s and an acceleration of 20000 mm / s^2.

[0122] Wait for 680 milliseconds and use the carrier_process_actions.wait function to unload the filled tube.

[0123] Repeat steps 5 - 12 until the required number of cycles or duration is reached.

[0124] The plan takes into account the specific positions, durations, speeds, and accelerations required for each action. It aims to optimize the throughput of the tube filling application while considering the capabilities of the multi-carrier system. If you have any questions, please feel free to ask!

[0125] Criticism: The plan can be further improved by considering factors such as avoiding collisions, optimizing speeds and accelerations for smoother motion, and incorporating error handling and recovery mechanisms in case of failures or interruptions.

[0126] Speech: The focus of this plan is to utilize the Lexium MC12 multi-carrier system to achieve maximum throughput in pipeline filling applications. It involves initializing necessary objects, connecting to the system, setting carrier parameters and positions, and performing a series of movement and waiting actions at specific stations. Factors such as collision avoidance, smooth movement, and error handling should be considered when implementing the plan.

[0127] Extraction process

[0128] 1. Initialize OPCMultiCarrierTrack and OPCStation objects:

[0129] a. OPCMultiCarrierTrack = initialize_OPCMultiCarrierTrack()

[0130] b. OPCStation = initialize_OPCStation()

[0131] 2. Connect to the multi-carrier system:

[0132] a. connect_to_multi_carrier_system(OPCMultiCarrierTrack)

[0133] 3. Set carrier parameters and positions:

[0134] a. init_carrier_parameters(OPCMultiCarrierTrack)

[0135] b. init_carrier_positions(OPCMultiCarrierTrack)

[0136] 4. Send the carriers to the initial station:

[0137] a. send_carriers_to_initial_station(OPCMultiCarrierTrack)

[0138] 5. Move the carriers to the empty tube loading station:

[0139] a. move_carriers(OPCMultiCarrierTrack, position = 2060, velocity = 2000, acceleration = 20000)

[0140] 6. Wait for 680 milliseconds to load the test tube:

[0141] a.carrier_process_actions.wait(680)

[0142] 7. Move the carrier to the filling tube station:

[0143] a.move_carriers(OPCMultiCarrierTrack,position=3800,velocity=2000,acceleration=20000)

[0144] 8. Wait for 550 milliseconds to fill the tube:

[0145] a.carrier_process_actions.wait(550)

[0146] 9. Move the carrier to the closing tube station:

[0147] a.move_carriers(OPCMultiCarrierTrack,position=5600,velocity=1500,acceleration=20000)

[0148] 10. Wait for 2000 milliseconds to close the tube:

[0149] a.carrier_process_actions.wait(2000)

[0150] 11. Move the carrier to the unloading filled tube station:

[0151] a.move_carriers(OPCMultiCarrierTrack,position=1500,velocity=2000,acceleration=20000)

[0152] 12. Wait for 680 milliseconds to unload the filled tube:

[0153] a.carrier_process_actions.wait(680)

[0154] 13. Repeat steps 5 - 12 until the required number of cycles or duration is reached.”

[0155] The language model interface can receive the complete output.

[0156] According to another embodiment, to translate a command received from a language model, the language model interface extracts functions executable by a control unit from the received command. In other words, the language model interface translates the output (especially the commands to be executed by an industrial machine included in the plan section) into a format executable by the control unit, so that it can be executed by the industrial machine. In particular, from the plan section, that is, from the command received from the language model, the language model interface extracts functions executable by the control unit. In the example cited above, the plan section uses different provided functions such as move_carriers, carrier_process_actions.weight, or send_carriers_to_initial_station.

[0157] According to another embodiment, extracting functions executable by a control unit includes at least one of the following:

[0158] - Tokenization,

[0159] - Part-of-speech tagging,

[0160] - Named entity recognition,

[0161] - Syntactic analysis,

[0162] - Lexicalization,

[0163] - Sequence alignment,

[0164] - Information extraction,

[0165] - Language generation,

[0166] - Error handling.

[0167] The above steps can be used to extract functions from the human language text included in the plan section.

[0168] For tokenization, the language model interface can be adapted to break down the (output) original text into individual tokens, such as words, punctuation marks, etc., to analyze their structure and relationships.

[0169] For part-of-speech tagging, the language model interface can be adapted to assign grammatical tags to each token to determine their syntactic roles, such as nouns, verbs, adjectives, and to identify function names, parameters, and other relevant information.

[0170] For named entity recognition, the language model interface can be adapted to identify specific entities in the text, such as function names, e.g., initialize_opcmulticcarriertrack, and variable names, e.g., opcmulticcarriertrack, to understand their meanings and contexts.

[0171] For syntactic analysis, the language model interface can be adapted to analyze the grammatical structure of sentences to identify the relationships between words and phrases. This helps to better understand the order of function calls and their dependencies.

[0172] For lexicalization, the language model interface can be adapted to simplify words to their basic forms, i.e., letters, to handle variations such as tenses, plurals, and conjugations, thereby improving the accuracy of word matching and understanding.

[0173] For sequence alignment, the language model interface can be adapted to compare the original text with the extracted sequence to align the corresponding steps and identify any deviations and / or missing information.

[0174] For information extraction, the language model interface can be adapted to extract key information from the original text, such as function names, parameters, positions, speeds, and / or accelerations, and map them to the corresponding function calls in the extracted sequence.

[0175] For language generation, the language model interface can be adapted to use the identified function names, parameters, and other relevant information to generate a translated version of the extracted sequence to ensure the clarity and consistency of the translation output.

[0176] For error handling, the language model interface can be adapted to identify any errors or inconsistencies in the extracted sequence and provide appropriate feedback or suggestions to improve translation accuracy.

[0177] Thus, the language model interface can provide a series of function calls and / or programming code (e.g., source code and / or executable code) to the control unit, which can guide the control unit to execute the commands generated by the language model.

[0178] An example of the sequence of function calls provided by the language model interface to the control unit is represented by the following pseudocode:

[0179]

[0180] move_carriers(multiCarrierTrack,5600,1500,20000);\ / \ / Move carriers toclose tubes station

[0181] carrier_process_actions.wait(2000);\ / \ / Wait for closing tubes

[0182] move_carriers(multiCarrierTrack,1500,2000,20000);\ / \ / Move carriers to unload filled tubes station

[0183] carrier_process_actions.wait(680);\ / \ / Wait for unloading filled tubes

[0184] }

[0185] The language model interface can also be adapted to directly control the control unit by sending direct commands to the control unit.

[0186] According to another embodiment, the language model interface and the control unit communicate using OPC UA. The OPC Unified Architecture (OPC UA) is an open-source cross-platform IEC 62541 data exchange standard developed by the OPC Foundation.

[0187] By using OPC UA, industrial machines can describe themselves in a semantic way, i.e., the variables and functions presented by the OPC UA server can have well-defined semantics, especially if they follow the accompanying specifications (which describe how OPC UA should be implemented to serve certain target applications in a specific domain). Thus, the language model and / or the language model interface can additionally benefit from all the context that can be derived from the semantic descriptions provided by using OPC UA.

[0188] In short, OPC UA allows for clear semantics that can be used to augment the context information base. If OPC UA is implemented on the control unit, additional context can be "pulled in" from the text description.

[0189] In different examples (similar but not identical to the examples below Figure 2 ), the industrial machine can include a conveyor system. In this example, the operator's input can be:

[0190] "I want the boxes of the color stored at Door 1 to be sorted out at Door 1, the boxes of the color stored at Door 2 to be sorted out at Door 2, and all other boxes should be sorted out in the last basket (sort all other boxes)".

[0191] Based on the above input, the language model interface can then provide the following prompts (considering, for example, library documents, requirements documents, etc.) to the language model:

[0192] "The overall goal to be achieved is: sort out the boxes of the color stored for Gate 1 at Gate 1, sort out the boxes of the color stored for Gate 2 at Gate 2, and all other boxes should be sorted in the final basket.

[0193] The conveyor belt machine can sort the boxes according to their colors

[0194] Boxes appear every 10 seconds.

[0195] There is Gate 1 where boxes can be sorted out, and you can configure which color to sort out using the OPC UA variable "gate1_sort_out_color"

[0196] There is Gate 2 where boxes can be sorted out, and you can configure which color to sort out using the OPC UA variable "gate2_sort_out_color"

[0197] All boxes not sorted at Gate 1 or Gate 2 are conveyed to the final basket. You need to find the right time to change the variables on the doors

[0198] The color of the box is only known after passing through Gate 1, so you need to update the color of the current box regularly via OPC UA

[0199] You can use the following methods to read and write OPC UA nodes.

[0200] func read_value(node_name)

[0201] func write_value(node_name,value)

[0202] For the above example, the task specification part can be as follows and can be appended to the hints given above:

[0203] "Now please perform the plan generation step.

[0204] Please carefully consider the provided context information.

[0205] Please ensure to express the plan by providing detailed instructions on how to use the provided functions.

[0206] Please refer to the functions, application descriptions, overall requirements, etc. described in the context information to express the plan.

[0207] Ensure that your plan provides actual values for target location, speed, acceleration, wait / processing time, etc.

[0208] The overall output should be in the following format:

[0209] Idea:

[0210] Reasoning:

[0211] Plan:

[0212] Criticism:

[0213] Speak: "

[0214] For the example given above, the output generated by the language model can be as follows:

[0215] "Idea: To correctly classify the boxes, we need to regularly check the color of each box using OPC UA. Based on the color configured for each gate, we can decide whether to sort the box at Gate 1, Gate 2, or let it pass to the final basket. Time is crucial for changing the variables on the gates to ensure accurate classification.

[0216] Reasoning: By regularly checking the box color using OPC UA, we can make informed classification decisions based on the configured color for each gate. This enables us to sort the boxes effectively without any manual intervention.

[0217] Plan:

[0218] Set up a loop to continuously monitor the appearance of new boxes every 10 seconds.

[0219] Inside the loop, call the read_value method to get the value of the OPC UA variable "gate1_sort_out_color". Store the value in a variable.

[0220] Call the read_value method again to get the value of the OPC UA variable "gate2_sort_out_color". Store the value in a separate variable.

[0221] Call the read_value method to get the current box color.

[0222] Compare the current box color with the value of "gate1_sort_out_color".

[0223] If there is a match, continue with step 6. Otherwise, go to step 8.

[0224] Call the write_value method to set the OPC UA variable for Gate 1 indicating that the box should be sorted out.

[0225] Continue to the next iteration of the loop.

[0226] Compare the current box color with the value of "gate2_sort_out_color".

[0227] If a match is found, continue with step 9. Otherwise, go to step 11.

[0228] Call the write_value method to set the OPC UA variable for Gate 2, indicating that the box is to be sorted.

[0229] Proceed to the next iteration of the loop.

[0230] The box does not match any of the configured colors for sorting. Let it pass to the final basket.

[0231] Proceed to the next iteration of the loop.

[0232] Criticism: The plan assumes that the OPC UA variables used for gate sorting are updated correctly and that the box color can be reliably obtained via OPC UA. It is important to ensure that the OPC UA communication is stable and that the variables are updated as expected.

[0233] Speech: To sort the boxes, we will continuously monitor the appearance of new boxes every 10 seconds. Using OPC UA, we will read the values of the variables "gate1_sort_out_color" and "gate2_sort_out_color". Then, we will periodically read the current box color. If the box color matches the configured color for Gate 1, we will write the corresponding value to the OPC UA variable for Gate 1. If it matches the configured color for Gate 2, we will write the corresponding value to the OPC UA variable for Gate 2. If the box color does not match any of the configured colors, we will let the box pass to the final basket.

[0234] As described above, the language model interface can provide a series of function calls and / or programming code to the control unit, represented as the following pseudocode:

[0235]

[0236] According to a further embodiment, the context information repository stores:

[0237] - Descriptions of actuators and / or sensors, preferably descriptions of all actuators and / or sensors of an industrial machine,

[0238] - Mechanical and / or electrical descriptions of the industrial machine,

[0239] - Spatial descriptions of at least parts of the industrial machine,

[0240] - Graphical representations of at least parts of the industrial machine, and / or

[0241] - Library functions executable by the control unit.

[0242] The description of the actuator and / or sensor, as well as the description of the mechanical structure and the spatial description are shown in the above example of the multi-carrier application. The actuator can also be referred to as an actuator.

[0243] According to another embodiment, the graphical representation of at least part of the industrial machine may include a picture of the industrial machine and / or CAD data. Another artificial intelligence can be used to translate the picture and / or CAD data into a text description in human language, which can then be provided to the language model.

[0244] According to a further embodiment, the context information repository is updated during the operation of the industrial machine. Thus, the context information repository can reflect the current state, for example by including the current sensor values. After updating the context information repository, the information contained in the context information repository can be provided to the language model. The information in the context information repository can be provided to the language model periodically and repeatedly. Thus, the language model can receive feedback from the industrial machine. Then, the language model can send new and / or updated commands to be executed by the industrial machine to the language model interface. In this way, the language model can provide dynamic adjustment. The dynamic adjustment can again include commands to be executed by the industrial machine, which are sent from the language model to the language model interface. The dynamic adjustment / new commands can also be in human language and can then be translated by the language model interface into machine commands for the control unit.

[0245] According to a further embodiment, during the operation of the industrial machine, the context information repository is updated using the error messages of the industrial machine. The error message can preferably be in human language. The error message is usually displayed to the operator of the industrial machine. Instead of or in addition to displaying the error message to the human operator, the error message is stored in the context information repository and is thus accessible to the language model and / or transmitted to the language model.

[0246] According to another embodiment, the language model receives the error message and provides commands to fix the error. For example, if the error message indicates that the motor is jammed, the language model can provide commands in human language, i.e., the motor should be turned off or the motor should be operated in reverse.

[0247] According to another embodiment, in order to provide commands to fix the error, the language model receives at least the online help of the industrial machine, support cases of the industrial machine, and / or extracts from technical publications, preferably on the industrial machine. The additional information of the online help, support cases, and / or technical publications can also be stored in the context information repository. The language model interface can then perform a semantic search in this additional information based on the error message and can then provide the data found during the semantic search to the language model. Thus, only the relevant data for a specific error can be found.

[0248] For example, in the case of a jammed motor, the support case can indicate that in previous similar cases, activating an adjacent motor was helpful. The language model can then output a command to be executed by the industrial machine that guides the industrial machine to activate the adjacent motor. Thus, again, the problem-solving ability and context understanding of the language model can be utilized to automatically solve errors in the industrial machine, preferably based on previous similar errors.

[0249] According to another embodiment, the industrial machine includes at least two conveyor belts, which are preferably arranged such that an object transported on one conveyor belt can be moved to another conveyor belt. Alternatively or additionally, the industrial machine can include a multi-carrier having a continuous track on which a plurality of carriers can move independently. The carriers can be moved by a linear motor forming the track. The track can form a closed loop. The carriers can be used to transport goods.

[0250] On the other hand, the present invention also relates to an industrial machine that includes a control unit, such as a PLC, and at least one actuator and / or sensor controlled by the control unit, wherein the industrial machine includes a supervision unit that is adapted to:

[0251] - Provide a language model,

[0252] - Provide a language model interface,

[0253] - Provide a context information library that stores information about the industrial machine, particularly commands executable by the industrial machine,

[0254] wherein,

[0255] - The language model interface is adapted to provide information about the industrial machine to the large language model from the context information library,

[0256] - The language model is adapted to send commands to be executed by the industrial machine to the language model interface,

[0257] - The language model interface is adapted to translate the commands received from the language model into machine commands for the control unit.

[0258] The disclosure of the method of the present invention included herein also applies to the industrial machine of the present invention. This particularly applies to the embodiments disclosed for the method of the present invention. It should also be noted that the features disclosed herein can be combined with each other if not explicitly stated to the contrary. BRIEF DESCRIPTION OF THE DRAWINGS

[0259] From the following exemplary descriptions and examples shown in the drawings, various features and advantages of the present invention will become more apparent, wherein:

[0260] Figure 1Schematically shows a language model, a language model interface, and a control unit;

[0261] Figure 2 Shows a first example of an industrial machine, namely a conveyor system;

[0262] Figure 3 Displays a second example of an industrial machine, namely a multi-carrier system. Detailed implementation

[0263] Figure 1 Shows a schematic diagram of an industrial machine 10 including a control unit, which includes three PLCs 12 and actuators 14 and sensors 16 connected to each PLC 12.

[0264] The industrial machine 10 is thus divided into three modules 18. For each module 18, there is a context information library 20, which includes library information ("Libs") and current state data ("data") of the corresponding module 18 of the industrial machine 10.

[0265] The language model interface 22 is connected to the PLC 12 of each module 18. The language model interface 22 is communicatively connected to the language model, which in this example is in the form of a large language model 24.

[0266] During the operation of the industrial machine 10, the large language model 24 receives tasks and / or requirements ("goals") to be completed. The goal can be set by the operator of the industrial machine. Then, the language model interface 22 supplements the goal with information from the context information library 20. The information given to the large language model 24 is in human language and includes information about the spatial and functional settings of the industrial machine and information about how to use library functions such as those of the PLC 12 to control the structure of the industrial machine.

[0267] Based on this information, the large language model 24 generates a plan to achieve the goal by using the library functions presented by the language model interface 22.

[0268] The plan generated by the large language model 24 can be in human language and can be translated by the language model interface 22 into commands for the PLC 12, so that the PLC 12 can control the actuators and correctly process the sensor data in order to operate the industrial machine 10 as expected by the plan generated by the large language model 24. Each PLC 12 can only receive commands related to itself and the actuators / sensors 14, 16 connected to it.

[0269] Figure 2 Shows a first example of the industrial machine 10. Figure 2The example of FIG. 1 shows a conveyor belt system including a plurality of conveyor belts 26. The conveyor belt system includes two scanning entrances 28, i.e., sensors 16. The conveyor belts 26 are actuators 14. The conveyor belt system includes two input belts 30 and three output belts 32.

[0270] The task assigned to the large language model 24 may be "sort packages with a height below 10 cm to the first output belt, sort packages with a height of 10 cm to 30 cm to the second output belt, and sort taller packages to the third output belt 32".

[0271] As information from the context information base, the large language model can then receive the settings and arrangements of the different conveyor belts and the settings and placements of the scanning portals 28. In addition, Figure 2 The pictures shown can be translated into human language descriptions using corresponding artificial intelligence.

[0272] The large language model 24 will then provide a plan for how the conveyor belts and scanning portals 26, 28 should be operated to achieve the desired goals.

[0273] Figure 3 Another example of an industrial machine is shown, namely a multi-carrier system. The multi-carrier system comprises a number of linear motors, which together form a continuous track. On the track, a plurality of carriers 38 can be moved independently of each other by linear motors 34, i.e. actuators 14. The position of the carriers 38 is determined by position sensors.

[0274] As described in more detail above, a goal of a multi-carrier system may be to execute pipeline filling applications in an efficient manner. The large language model 24 may then provide a plan as exemplarily shown above, which the PLC 12 may then execute after the plan has been translated by the language model interface 22 .

[0275] By using human language to request the large language model 24 to provide a plan for the operation of the industrial machine 10, time-consuming PLC engineering and programming can be omitted. Since information from the context information library 20 is provided, it is also possible to use off-the-shelf language models that do not have to be specially trained for the operation of a specific industrial machine 10.

[0276] Reference Symbols List

[0277] 10Industrial machinery

[0278] 12PLC

[0279] 14 Actuator

[0280] 16 sensors

[0281] 18 modules

[0282] 20Context Information Library

[0283] 22 Language Model Interface

[0284] 24 Large Language Model

[0285] 26 Conveyor Belt

[0286] 28 Scanning Entrance

[0287] 30 Input Belt

[0288] 32 Output Belt

[0289] 34 Linear Motor

[0290] 36 Track

[0291] 38 Carrier

Claims

1. A method for controlling an industrial machine, the industrial machine comprising a control unit and at least one actuator and / or sensor controlled by the control unit, wherein, - a language model is provided, - a language model interface is provided, - a context information library is provided, which stores information about the industrial machine, wherein, - the language model interface provides information about the industrial machine from the context information library to the language model, - the language model sends a command to be executed by the industrial machine to the language model interface, - the language model interface translates the command received from the language model into a machine command for the control unit.

2. The method according to claim 1, wherein the information about the industrial machine stored in the context information library includes commands that can be executed by the industrial machine.

3. The method according to claim 1, wherein the control unit is a PLC.

4. The method according to claim 1, wherein the language model and the language model interface exchange information in human language.

5. The method according to claim 1, wherein the language model includes a large language model.

6. The method according to claim 5, wherein the large language model is a publicly available large language model.

7. The method according to claim 5, wherein the large language model is suitable for context understanding and / or includes knowledge representation capabilities.

8. The method according to claim 1, wherein the language model receives an input from an operator, the input including a task and / or requirement to be completed by the industrial machine.

9. The method according to claim 8, wherein the input is in human language.

10. The method according to claim 1, wherein the input from the operator is supplemented by including information about the industrial machine from the context information library.

11. The method according to claim 10, wherein when supplementing the input from the operator, a set of functions to be executed by the control unit is presented to the language model.

12. The method according to claim 1, wherein the language model interface and the control unit communicate using OPC UA.

13. The method according to claim 1, wherein in order to translate the command received from the language model, the language model interface extracts functions that can be executed by the control unit from the received command.

14. The method according to claim 13, wherein extracting functions that can be executed by the control unit includes at least one of the following: - tokenization, - part-of-speech tagging, - named entity recognition, - syntactic analysis, - lexicalization, - sequence alignment, - information extraction, - language generation, - error handling.

15. The method according to claim 1, wherein the context information library stores: - descriptions of actuators and / or sensors, - descriptions of the mechanical structure of the industrial machine, - spatial descriptions of at least parts of the industrial machine, - graphical representations of at least parts of the industrial machine, - library functions that can be executed by the control unit.

16. The method according to claim 1, wherein the context information library is updated during the operation of the industrial machine.

17. The method according to claim 1, wherein during the operation of the industrial machine, the context information library is updated using error messages of the industrial machine.

18. The method according to claim 17, wherein the language model receives an error message and provides a command to fix the error.

19. The method according to claim 18, wherein To provide a command to fix the error, the language model receives at least the online help of the industrial machine, support cases of the industrial machine, and / or excerpts from technical publications.

20. The method according to claim 1, wherein the industrial machine comprises at least two conveyor belts, and / or wherein the industrial machine comprises a multi-carrier with a continuous track, and a plurality of carriers move independently on the continuous track.

21. An industrial machine, comprising a control unit and at least one actuator and / or sensor controlled by the control unit, wherein the industrial machine comprises a supervision unit adapted to: - provide a language model, - provide a language model interface, - provide a context information library that stores information about the industrial machine, wherein, - the language model interface is adapted to provide information about the industrial machine from the context information library to the language model, - the language model is adapted to send a command to be executed by the industrial machine to the language model interface, - the language model interface is adapted to translate the command received from the language model into a machine command for the control unit.

Images