JP2024002676A - Controller, data management system, data management program, and data management method - Google Patents

Abstract

To provide a controller, a data management system, a data management program, and a data management method that can easily share data between devices.SOLUTION: A controller includes a processor 11, a storage unit 12, and a communication unit 17, and functions as a first controller 10. The communication unit 17 is communicably connected to at least one other controller functioning as a second controller 20. The processor 11 generates an address space 16 in the storage unit 12 for storing a node 30-1 corresponding to data of the first controller 10 and nodes 30-2 to N corresponding to data shared with the second controller 20.SELECTED DRAWING: Figure 2

Description

The present disclosure relates to a controller, a data management system, a data management program, and a data management method.

2. Description of the Related Art Conventionally, electronic devices have been known that have a server function that records actual data and responds to actual data read requests from clients (see, for example, Patent Document 1).

JP 2017-84143 Publication

When a controller acting as a client reads data from a server, it is difficult to share data between controllers.

The present disclosure has been made in view of the above points, and aims to provide a controller, a data management system, a data management program, and a data management method that can easily share data between devices.

A controller according to some embodiments includes a processor, a storage unit, and a communication unit. The controller functions as a first controller. The communication unit is communicably connected to at least one other controller functioning as a second controller. The processor generates, in the storage unit, an address space for storing a node corresponding to data of the first controller and a node corresponding to data shared with the second controller. By doing so, the communication time required for sharing data between controllers can be reduced. As a result, data can be easily shared between controllers.

In the controller according to one embodiment, when the processor changes at least one data shared with the second controller, the processor may output the changed data to the second controller. By doing so, the amount of data to be shared can be reduced. As a result, data can be easily shared between controllers.

In the controller according to one embodiment, when the processor acquires at least one data shared with the second controller from the second controller, the processor may update an address space of a node corresponding to the acquired data. . By doing so, the amount of data to be shared can be reduced. As a result, data can be easily shared between controllers.

In the controller according to one embodiment, the processor may associate a sharing flag with a node corresponding to data shared with the second controller. By doing so, it can be easily determined whether the data needs to be shared. As a result, data can be easily shared between controllers.

A data management system according to some embodiments includes multiple controllers. Each of the controllers includes a processor, a storage section, and a communication section. The communication unit is connected to enable communication between the controllers. The processor generates an address space in the storage unit for storing a node corresponding to data of a controller including the processor and a node corresponding to data shared with other controllers. By doing so, the communication time required for sharing data between controllers can be reduced. As a result, data can be easily shared between controllers.

The data management program according to some embodiments includes operations that are caused to be executed by the processor of the first controller. The data management program includes causing a processor of the first controller to communicate with a second controller. The data management program stores, in the processor of the first controller, a node corresponding to data of the first controller and a node corresponding to data shared with the second controller in a storage unit of the first controller. This includes creating an address space for By doing so, the communication time required for sharing data between controllers can be reduced. As a result, data can be easily shared between controllers.

A data management method according to some embodiments is executed by a processor of a first controller. The data management method includes a processor of the first controller communicating with a second controller. In the data management method, the processor of the first controller stores, in a storage unit of the first controller, a node corresponding to data of the first controller and a node corresponding to data shared with the second controller. This includes creating an address space for By doing so, the communication time required for sharing data between controllers can be reduced. As a result, data can be easily shared between controllers.

According to the present disclosure, a controller, a data management system, a data management program, and a data management method that can easily share data between devices are provided.

FIG. 2 is a block diagram showing the configuration of a system according to a comparative example. FIG. 1 is a block diagram illustrating a configuration example of a data management system according to an embodiment. FIG. 3 is a block diagram illustrating a configuration example of an address space of a first controller. FIG. 3 is a block diagram illustrating a configuration example of an address space of a second controller. 3 is a flowchart illustrating an example of a procedure of a data management method according to an embodiment.

(Comparative example)
As a method for sharing data (nodes) between a plurality of controllers, inter-controller communication using FL-net (registered trademark), for example, can be considered. In a system that shares data using FL-net (registered trademark), each controller communicates using a token pass method. In token pass type communication, one controller has a token. As a master, the controller that owns the token communicates with other controllers by broadcasting and updates the contents of the shared memory. By having each controller possess a token in turn, N:N communication is realized in which all controllers communicate with each other. Each controller has a shared memory that stores data shared by all controllers, and shares data by updating the data stored in the shared memory through the above-mentioned N:N communication.

However, in a system that shares data (nodes) using FL-net (registered trademark), it is necessary for all controllers to store data in exactly the same data configuration. In other words, it is not possible to vary the data structure for storing data for each controller. Due to the need to have exactly the same data configuration, data that does not need to be shared between controllers also needs to be shared between controllers. The need to also communicate unnecessary data increases the amount of data in 1:1 communication between two controllers. As a result, it takes time to update data through N:N communication. Furthermore, by communicating using the token pass method, it takes time for all controller communications (N:N communication) to complete one cycle. As a result, it takes time to complete data updating (data updating through N:N communication) in all controllers.

As another method for sharing data (nodes) between a plurality of controllers, inter-controller communication using EtherNet/IP (registered trademark), for example, can be considered. In a system that shares data using EtherNet/IP (registered trademark), one controller functions as a scanner (master) and other controllers function as adapters (slaves). One scanner communicates with other adapters. In other words, communication between the scanner and the adapter is 1:N communication. The scanner will share, send and receive only the data that the adapter needs.

However, in a system that shares data (nodes) using EtherNet/IP (registered trademark), as the number of adapters increases, the time required for communication increases. Therefore, in order to reduce the time required for communication, it is necessary to select adapters. Furthermore, since sharing data among all controllers as in N:N communication is achieved through 1:N communication, problems such as increased communication load and complicated management arise.

As another method for sharing data (nodes) between a plurality of controllers, inter-controller communication using OPC UA (registered trademark), for example, can be considered. A system 9 for sharing data using OPC UA (registered trademark) includes a first controller 90 and a second controller 95, as shown in FIG. The first controller 90 includes a processor 91 and a storage section 92. The storage unit 92 stores a user program 93 and a client 94. The second controller 95 includes a processor 96 and a storage section 97. The storage unit 97 stores a user program 99 and a server 98. Server 98 includes address space 981.

The processor 91 of the first controller 90 executes the user program 93 to call the program of the client 94 and execute the functions of the client 94. The client 94 requests the second controller 95 to send data. The processor 96 of the second controller 95 executes the user program 99 in response to a request from the client 94 of the first controller 90 to call the program of the server 98 and execute the functions of the server 98. The server 98 reads data requested by the client 94 of the first controller 90 from the address space 981 and transmits it. The client 94 of the first controller 90 obtains data stored in the address space 981 of the second controller 95. The server 98 of the second controller 95 can set the data structure to be stored in the address space 981 to a necessary and sufficient structure.

However, in a system 9 that shares data using OPC (Open Platform Communications) and UA (Unified Architecture) (registered trademark), a first controller 90 having a client 94 and a second controller 95 having a server 98 have 1: 1 Execute communication. Therefore, when two or more first controllers 90 having clients 94 are connected to one second controller 95 having a server 98, the data of the clients 94 of each first controller 90 is separated. . As a result, data is less likely to be shared among the clients 94 of each first controller 90.

As mentioned above, in the method of sharing data (nodes) between multiple controllers according to the comparative example, sharing data between controllers takes time and the roles of master and slave are fixed. The problem is that control becomes complicated. It is required to share data at high speed and without fixed roles of master and slave. There is also a need to easily share data.

Therefore, the present disclosure describes a system that can share data quickly and without fixing the roles of master and slave, or easily.

(Embodiment)
As shown in FIG. 2, the data management system 1 according to an embodiment of the present disclosure includes a first controller 10 and a second controller 20.

The first controller 10 includes a processor 11 and a storage section 12. The storage unit 12 stores a server 13, a client 14, and a user program 15. Server 13 includes address space 16 . The user program 15 includes a server API (Application Programming Interface) 151 and a client API 152. The processor 11 executes the server API 151 to call the program of the server 13 and execute the functions of the server 13. The processor 11 executes the client API 152 to call the program of the client 14 and execute the functions of the client 14.

The second controller 20 includes a processor 21 and a storage section 22. The storage unit 22 stores a server 23, a client 24, and a user program 25. Server 23 includes address space 26 . The user program 25 includes a server API 251 and a client API 252. The processor 21 executes the server API 251 to call the program of the server 23 and execute the functions of the server 23. The processor 21 executes the client API 252 to call the program of the client 24 and execute the functions of the client 24.

The servers 13 and 23 manage data required by the first controller 10 and the second controller 20, respectively. The server 13 manages data in an address space 16. The server 23 manages data in an address space 26.

The client 14 communicates with the server 23 of the second controller 20 to obtain data managed in the address space 26 of the server 23 and output data of the first controller 10 to the server 23. The client 24 communicates with the server 13 of the first controller 10 , acquires data managed in the address space 16 of the server 13 , and outputs data of the second controller 20 to the server 13 .

The first controller 10 may further include a communication section 17. The second controller 20 may further include a communication section 27. The first controller 10 and the second controller 20 may be communicably connected to each other via the communication section 17 and the communication section 27.

The first controller 10 and the second controller 20 may operate with their roles switched. The first controller 10 and the second controller 20 may have the same configuration. The first controller 10 and the second controller 20 are simply referred to as controllers unless they need to be distinguished. The number of controllers included in the data management system 1 is not limited to two, but may be three or more.

As illustrated in FIG. 3A, the server 13 of the first controller 10 sets the data structure of each controller as the address space 16. Further, as illustrated in FIG. 3B, the server 23 of the second controller 20 sets the data structure of each controller as the address space 26. Address spaces 16 and 26 include a root node 30 and nodes 30-1 to 30-N. The root node 30 represents the entire data managed in the data management system 1. It is assumed that the data management system 1 includes N controllers. Nodes 30-1 to 30-N correspond to data of each controller.

The node 30-1 corresponds to the data of the first controller 10. The node 30-2 corresponds to the data of the second controller 20. Nodes 30-3 to 30-N correspond to data of other controllers. In the address space 16 of the first controller 10 shown in FIG. 3A, a node 30-1 represents data of the first controller 10 itself, and is also referred to as its own node. In the address space 16 of the first controller 10, nodes 30-2 to 30-N represent data of other controllers and are also referred to as other nodes. In the address space 26 of the second controller 20 shown in FIG. 3B, the node 30-2 represents the data of the second controller 20 itself, and is also referred to as its own node. In the address space 26 of the second controller 20, nodes 30-1 and 30-3 to N represent data of other controllers and are also referred to as other nodes. Address spaces 16 and 26 may specify addresses of actual hardware (such as storage) where data corresponding to each node is stored.

Hereinafter, an operation in which the first controller 10 shares data with the second controller 20 or other controllers will be described.

The processor 11 of the first controller 10 executes the server API 151 of the user program 15 stored in the storage unit 12. The processor 11 calls and executes the program of the server 13 by executing the server API 151, thereby causing the server 13 to function. Server 13 manages address space 16.

The server 13 creates a node 30-1 representing the data of the first controller 10 itself under the root node 30 of the address space 16. The server 13 updates the node 30-1 when the data of the first controller 10 itself is changed. Further, the server 13 creates a node 30-2 representing data to be shared with the second controller 20 under the root node 30 of the address space 16. Further, the server 13 creates nodes 30-3 to 30-N representing data shared with other controllers under the root node 30 of the address space 16.

The processor 21 of the second controller 20 executes the client API 252 of the user program 25 stored in the storage unit 22. The processor 21 calls and executes the program of the client 24 by executing the client API 252, thereby causing the client 24 to function. The client 24 outputs data shared with the first controller 10 out of the data of the second controller 20 to the server 13 of the first controller 10. When at least one data shared with the first controller 10 is changed, the client 24 may output the changed data to the server 13 of the first controller 10. When the server 13 acquires data to be shared from the client 24 of the second controller 20, it updates the node 30-2. When the server 13 acquires data to be shared from a client of another controller, it updates the node corresponding to the controller that outputs the data to be shared among the nodes 30-3 to 30-N.

When the server 13 acquires information that at least one data shared with the second controller 20 has been changed from the client 24 of the second controller 20, the server 13 updates the node 30-2. The processor 11 may change the data of the first controller 10 in response to the update of the node 30-2.

When the server 13 acquires information from another controller that the data of the other controller has been changed, it updates the node corresponding to the controller whose data has been changed among the nodes 30-3 to 30-N. The processor 11 may change the data of the first controller 10 in response to updates of the nodes 30-3 to 30-N.

The processor 11 of the first controller 10 executes the client API 152 of the user program 15 stored in the storage unit 12. The processor 11 calls and executes the program of the client 14 by executing the client API 152, thereby causing the client 14 to function. When the node 30-1 is updated, the client 14 may output information about the updated node 30-1 to the server 23 of the second controller 20 or another controller.

As described above, the first controller 10 can share data with the second controller 20 or other controllers. Conversely, data of the first controller 10 may be shared by the second controller 20 or other controllers. That is, the second controller 20 or other controllers can share the data of the first controller 10 by the same or similar operation as the above-described operation of the first controller 10 sharing data of other controllers.

Specifically, the processor 21 of the second controller 20 executes the server API 251 of the user program 25 stored in the storage unit 22. The processor 21 calls and executes the program of the server 23 by executing the server API 251, thereby causing the server 23 to function. Server 23 manages address space 26.

The server 23 creates a node 30-2 representing the second controller 20's own data under the root node 30 of the address space 26. The server 23 updates the node 30-2 when the data of the second controller 20 itself is changed. Further, the server 23 creates a node 30-1 representing data shared with the first controller 10 under the root node 30 of the address space 26. Further, the server 23 creates nodes 30-3 to 30-N representing data shared with other controllers under the root node 30 of the address space 26.

The processor 11 of the first controller 10 executes the client API 152 of the user program 15 stored in the storage unit 12. The processor 11 calls and executes the program of the client 14 by executing the client API 152, thereby causing the client 14 to function. The client 14 outputs data shared with the second controller 20 out of the data of the first controller 10 to the server 23 of the second controller 20 . When the server 23 acquires data to be shared from the client 14 of the first controller 10, it updates the node 30-1. When the server 23 acquires data to be shared from a client of another controller, it updates the node corresponding to the controller that outputs the data to be shared among the nodes 30-3 to 30-N.

When the server 23 acquires information that the data of the first controller 10 has been changed from the client 14 of the first controller 10, it updates the node 30-1. The processor 21 may change the data of the second controller 20 in response to the update of the node 30-1.

As described above, the second controller 20 can share the data of the first controller 10. With respect to other controllers, the data of the first controller 10 or the second controller 20, or the data of the other controller is can be shared. The first controller 10 or the second controller 20 is a name for convenience of explanation. Descriptions such as "first" and "second" are merely identifiers for distinguishing the configurations. The controller included in the data management system 1 can function as the first controller 10, the second controller 20, or any other controller.

When data is shared between controllers, each controller, as a server function, sets a flag that allows the node representing the data to be shared among the nodes stored in the address space to allow sharing with other controllers. May be associated. A flag that allows sharing is also referred to as a sharing flag.

As a function of the client, each controller notifies other controllers that a shared node has been created or updated when a node to which a shared flag is associated is created or updated. It may be configured as follows. In addition, as a server function, each controller sends a request to a node that is associated with a shared flag when another controller requests transmission to a node stored in the address space managed by the controller. may be configured to send. Each controller may be configured to not transmit nodes that do not have a shared flag associated with them.

<Flowchart example>
Each controller of the data management system 1 may execute a data management method including the steps of the flowchart illustrated in FIG. 4 . The data management method may be realized as a data management program that is executed by a processor of each controller. The data management program may be stored on a non-transitory computer readable medium.

An example of the operation when the processor 11 of the first controller 10 executes the data management method illustrated in FIG. 4 will be described below.

As a function of the server 13, the processor 11 has an address space 16 that stores nodes corresponding to data of its own device (first controller 10) and nodes corresponding to data shared with other controllers such as the second controller 20. (Step S1). Specifically, the processor 11 functions as the server 13 by calling the program of the server 13 by executing the user program 15, and generates the address space 16. When generating the address space 16, the processor 11 may associate a shared flag with a node corresponding to data shared with other controllers.

The processor 11 acquires data to be shared with other controllers as a function of the client 14 (step S2). Specifically, the processor 11 calls the program of the client 14 by executing the user program 15, functions as the client 14, and acquires data to be shared with the processor 11 from other controllers.

As a function of the server 13, the processor 11 updates the address space 16 storing the node corresponding to the acquired data (step S3). After executing the procedure of step S3, the processor 11 ends the execution of the procedure of the flowchart of FIG. Note that the flowchart in FIG. 4 is a procedure for the case where the processor 11 functions as the server 13, in which when the processor 11 changes at least one piece of data shared with the second controller 20, the changed data is transferred to the second controller 20. It may also include a procedure for outputting.

As described above, in the data management system 1 according to the present embodiment, each controller includes an address space for storing its own data and data shared with other controllers. By doing so, the communication time required for sharing data between controllers can be reduced. As a result, data can be easily shared between controllers.

In the data management system 1 according to this embodiment, each controller stores only data that needs to be shared in the address space. In other words, the structure of the data that a controller stores in its address space may differ from controller to controller. Furthermore, each controller outputs data to other controllers when data that needs to be shared is added or updated. By doing so, the amount of data can be reduced. As a result, data can be easily shared between controllers.

Furthermore, by using the sharing flag, it can be easily determined whether data needs to be shared. As a result, data can be easily shared between controllers.

In the data management system 1 according to this embodiment, each controller functions as both a server and a client. By doing so, N:N communication between a large number of controllers can be easily realized. As a result, data can be easily shared between controllers.

In the data management system 1 according to the present embodiment, each controller may be configured as an OPC UA (registered trademark) controller, but is not limited to this, and may be configured as a controller of another communication method.

Although the embodiments of the present disclosure have been described above with reference to the drawings, the specific configuration is not limited to these embodiments, and various changes may be made without departing from the spirit of the present disclosure. included.

1 Data management system 10 First controller (11: processor, 12: storage unit, 13: server, 14: client, 15: user program, 151: server API, 152: client API, 16: address space, 17: communication unit )
20 Second controller (21: processor, 22: storage unit, 23: server, 24: client, 25: user program, 251: server API, 252: client API, 26: address space, 27: communication unit)
30, 30-1~N node

Claims (7)

A controller comprising a processor, a storage unit, and a communication unit and functioning as a first controller,
The communication unit is communicably connected to at least one other controller functioning as a second controller,
The processor generates, in the storage unit, an address space for storing a node corresponding to data of the first controller and a node corresponding to data shared with the second controller.
controller. The controller according to claim 1, wherein when the processor changes at least one data shared with the second controller, the processor outputs the changed data to the second controller. The controller according to claim 1, wherein the processor updates an address space of a node corresponding to the acquired data when at least one data shared with the second controller is acquired from the second controller. The controller according to any one of claims 1 to 3, wherein the processor associates a sharing flag with a node corresponding to data shared with the second controller. A data management system comprising multiple controllers,
Each of the controllers includes a processor, a storage unit, and a communication unit,
The communication unit is communicably connected between the controllers,
The processor generates, in the storage unit, an address space for storing a node corresponding to data of a controller including the processor and a node corresponding to data shared with other controllers. A data management program that is executed by a processor of a first controller,
communicating with a second controller;
A data management program that causes a storage unit of the first controller to generate an address space for storing a node corresponding to data of the first controller and a node corresponding to data shared with the second controller. . a processor of the first controller in communication with a second controller;
A processor of the first controller generates an address space in a storage unit of the first controller to store a node corresponding to data of the first controller and a node corresponding to data shared with the second controller. Data management methods including.

Images