Decomposition of a Petri Net-Based Cyber-Physical System toward Implementation as an Integrated System within FPGA

Featured Application

The proposed technique is strictly oriented on practical application. The decomposed Petri net-based cyber-physical system can be easily implemented within the integrated device such as FPGA. An exemplary decomposition of a real-life CPS—beverage production and distribution machine—is shown in the paper. The system is modelled by a Petri net, decomposed with the proposed technique, and finally implemented within an FPGA device.

Abstract

Decomposition is one of the commonly used techniques applied in the design of Petri net-based cyber-physical systems. Such an operation permits the splitting of the initial system into sequential components that can be further implemented as an integrated or distributed system. This paper is focused on the decomposition of the modelled CPS toward its further implementation as an integrated system, namely an FPGA device. The adequate decomposition method is presented and explained in detail. Moreover, the proposed idea is explained by the real-life example of the beverage production and distribution system. The results of the experiments are presented and discussed.

1. Introduction

Petri nets are a mathematical modelling tool that is used to specify and verify concurrent control systems [1]. They were proposed in the 1960s by Carl Adam Petri in his dissertation [2] and have since observed extensive use in areas such as computer science [3], mechanical engineering [4], and others [5]. Essentially, Petri nets consist of two types of nodes: places and transitions [6]. Places form states of the system, while transitions represent actions that can occur in the system [7]. Places and transitions are connected by arcs, which can show the direction of the flow of tokens representing the behaviour of the specified system [8]. Petri nets are especially suitable for modelling systems with complex interactions between multiple concurrent processes such as popular nowadays cyber-physical systems [9]. By representing these interactions graphically, Petri nets can provide easy insight into the behaviour of the system [3]. Furthermore, Petri nets can be analysed using formal methods to verify properties such as boundedness, safeness, or liveness and help identify potential problems or areas for improvement [10]. Boundedness [11] property shortly ensures a finite number of reachable states in the modelled system, safeness [12] makes binary behaviour of a Petri net for logical control while liveness is key in avoiding deadlocks or unwanted states [13].

A cyber-physical system (CPS) integrates computation with physical processes [14]. Its behaviour is defined by cyber and physical parts of the system [15,16]. The first one (cyber) controls the objects and makes decisions, while the physical part refers to the real world and is disposed to environmental influences. The design techniques of CPS include the joint dynamics of computers, software, networks, as well as physical processes. Such a system is used in a variety of domains, including manufacturing systems, vehicular and transportation systems, medical and health-care systems, smart homes and buildings, social networks and gaming, etc. [17,18,19,20]. A Petri net is one of the popular specification approaches of a CPS [12,13,18,21]. Due to its concurrent nature and wide support of verification and validation techniques, a Petri net suits flawlessly the modelling of a CPS [22]. Moreover, the system can be easily and intuitively modelled by a graphical representation, while further designing steps are supported by mathematical techniques [23,24].

One of the crucial steps of the design flow of Petri net-based CPS is the decomposition of the system. In short, this is a technique that is used in order to divide a large system into smaller, sub-systems. In the case of a Petri net, the system is usually split into sequential modules (sequential automata), called state machine components (SMCs). Decomposition is especially useful in the case of distributed CPS. In such systems each module can be implemented in a separate device [25,26,27,28,29]. Furthermore, decomposition plays an important role in the case of integrated systems, implemented within digital devices such as field programmable gate arrays (FPGAs). Recent FPGAs offer a very useful possibility of dynamic partial reconfiguration of the system. This technique permits for the replacement of a portion of the already implemented CPS without stopping the device [7,19,30,31,32]. This means that the functionality of the selected components of the system is modified while the remaining part of the CPS is still working. It is especially useful in the case of concurrent CPS that executes crucial operations that cannot be interrupted. Moreover, the decomposed modules analysed separately can simplify the analysis of complex cyber-physical systems [33].

There exist several popular decomposition techniques of the Petri net-based systems, each of which has its own advantages and disadvantages. In [34], a method based on shared places and/or shared transitions is presented. The paper shows that place invariants of the global model are the same as those of the decomposed model. However, the resulting components cannot be executed in a distributed way. The linear algebra is also applied in the algorithm shown in [33]. The method searches for the place invariants, which are further transformed into sequential components. The main bottleneck of the presented idea relies on the computational complexity, which is exponential in the general case. On the other hand, the proposed method terminates once the decomposition is found, which extremely reduces the computation process.

In the opposite, a polynomial decomposition algorithm is shown in [35]. The idea is based on the graph theory, involving unique properties of perfect graphs. In particular, the colouring of comparability graphs is applied, which is executed polynomial. Although the method permits for optimal decomposition of the system (into the minimal possible number of components), it cannot be applied to all systems. Moreover, the achieved components do not always reflect the designer’s needs. The alternate technique of SMCs computation is shown in [36]. The idea is also based on the graph theory, but it applies an approximate algorithm. Therefore, the result is always achieved, however, it may not be optimal. Furthermore, the technique is not strictly oriented on the decomposition of the system, since it searches for the SMCs covering of the Petri net.

Aybar and Iftar [37] introduced a method based on net structure analysis identifying overlapped sections. Overlapped transitions and places are repeated in all resulting components. Other decomposition ideas use input and output places for communication between the decomposed models [38,39,40]. In [41], a functional splitting method is proposed, based on the definition of a cutting set. The main concern of this idea is to achieve the same behaviour before and after decomposition. The interface among the decomposed components is composed of transitions, which communicate through output and input events, while the common firing rules are also preserved.

Finally, it is worth mentioning that there exist other decomposition methods not only oriented on the implementation of integrated systems. Such techniques can be applied to other important tasks, e.g., analysis of Petri net properties [42], deadlock detection [43], decomposition into automata [44], or decentralised control of Petri nets [45].

To summarise the discussion above, it can be noticed that the decomposition of the Petri net-based systems is an important step in the designing flow of CPS. However, there are several important issues related to this process, including obtaining adequate components (that is, expected by the designer), computational time (due to the exponential computational complexity of several algorithms), as well as proper synchronisation of the decomposed components. In this paper, we propose a decomposition method oriented on the integrated system. Moreover, the presented technique is illustrated by a real-life example of the beverage production machine implemented within an FPGA device. Let us underline that the proposed solution significantly differs from previous techniques presented by authors in [29,33]. Contrary to the already published ideas, the proposed technique is oriented toward the rapid decomposition process. Therefore, the achieved number of components are examined at each step of the algorithm. Moreover, the designer is able to select the required components manually, which makes the whole process much more flexible and comfortable. Note that this paper is purely focused on the decomposition aspects, while the remaining aspects of the prototyping flow (such as analysis and verification of the CPS, as well as modelling of the decomposed components) can be found in other authors’ works including [7,11,12,13,21,22,32,33,35].

The main contributions of this work are summarised as follows:

• Proposition of a novel decomposition technique of Petri net-based cyber-physical systems oriented on the further realisation within integrated systems;
• Illustration of the proposed idea by a real-life cyber-physical system of beverage production and distribution system;
• Experimental validation of the proposed method by a physical implementation of the integrated system within an FPGA.

2. Definitions and Notations

This section presents definitions and notations used in the paper [1,2,3,4,6,7,8,10,46].

Definition 1.

A Petri net$N$is a 4-tuple:$N=\left(P,T,F,M_0\right)$, where:

• $P=\left\{p_1,p_2,\dots , p_n\right\}$is a finite set of places,
• $T=\left\{t_1,t_2,\dots , t_m\right\}$is a finite set of transitions,
• $F\subseteq \left(P\times T\right)\cup \left(T\times P\right)$is a finite set of arcs,
• ${\mathrm{M}}_0:P\to \mathbb{N}$is an initial marking (state).

Definition 2.

A marking (state)$M$of a Petri net$N=\left(P,T,F,M_0\right)$is defined as a subset of its places:$M\subset P$. A place belonging to a marking is called a marked place. A marking can be changed by transition firings. Firing of a transition$t$changes marking by removing a token from each input places of$t$, and adds a token to each output place of$t$.

Definition 3.

Incidence matrix of a Petri net$N=\left(P,T,F,M_0\right)$with$n$places and$m$transitions is a matrix$A_{\left|T\right|\times \left|P\right|}$of integers, given by:

$$a_{ij}=\left\{\begin{array}{c}-1, \left(p_j,t_i\right)\in F\\ 1, \left(t_i,p_j\right)\in F\\ 0, \mathrm{otherwise}\end{array}\right..$$

(1)

A cell$a_{ij}$of matrix$A$refers to transition$t_i$and place$p_j$. The columns of the matrix correspond to places, while the rows refer to transitions of a Petri net.

Definition 4.

A place invariant (p-invariant) of a Petri net$N=\left(P,T,F,M_0\right)$is a$n$-vector$\overrightarrow{x}$of integers such that$A\overrightarrow{x}=0$. The set of places corresponding to nonzero entries in a p-invariant$\overrightarrow{x}\ge 0$is a support of the p-invariant. A net is covered by p-invariants if every place$p\in P$belongs to at least one support of a p-invariant.

Definition 5.

A state machine is a Petri net for which every transition has exactly one input place and exactly one output place, i.e., $\forall t\in T:\left|•t\right|=\left|t•\right|=1$.

Definition 6.

A state machine component (SMC) of a Petri net$N=\left(P,T,F,M_0\right)$is a subnet$S=\left(P’,T’,F’,M_0’\right)$generated by$P’\subseteq P$such that:

• $S$is a state machine;
• $P^{\prime }\in P$,$T^{\prime }\in T$,$F^{\prime }\in F\cap \left(P^{\prime }\times T^{\prime }\right)\cup \left(T^{\prime }\times P^{\prime }\right)$;
• $S$is strongly connected and has exactly one token in initial marking.

Definition 7.

A state machine decomposition (S-decomposition) of a Petri net$N=\left(P,T,F,M_0\right)$is a set$𝒮=\left\{S_1,\dots ,S_n\right\}$such that each component$S_j\in 𝒮$is an SMC and each place$p_i\in P$belongs to exactly one component$S_j\in 𝒮$. If place$p_i\in P$exists in more than one$S_j\in 𝒮$, it is replaced in all remaining components (except one) by a non-operational place (NOP).

3. The Proposed Decomposition Method

This section introduces a decomposition technique of a Petri net-based CPS oriented toward realization as an integrated system, e.g., An FPGA device. The proposed decomposition technique is shown in Algorithm 1. The method involves the linear algebra technique. The sequential components are obtained by computation of the place invariants with further manual selection of required SMCs.

Algorithm 1 Decomposition of a Petri net-based integrated system

Data: Incidence matrix $A_{\left|T\right|\times \left|P\right|}$ of Petri net $N=\left(P,T,F,M_0\right)$ Result: S-decomposition $𝒮$ of $N=\left(P,T,F,M_0\right)$ Initialisation: (a) form a unit matrix $Q=[D|A]$ and initialise $D$ as an identity matrix; (b) initialise: $𝒮=\varnothing$; For each column $t$ of matrix $A$: (a) find row pairs that annul the $t$-th column of $A$ and append it to matrix $Q$; (b) delete rows of $Q$ whose intersection with the $t$-th column is not equal to 0; (c) reduce the redundant rows of $Q$ (rows that binary cover to the other ones).; For each row $r$ of $A$ whose all elements are equal to 0: (a) obtain support $I_r$ of place invariant from matrix $D$; (b) construct a subnet $S_r$ of $N$ according to Definition 5. If $S_t$ forms a proper SMC, add $S_r$ to the Sdecomposition-: $𝒮=𝒮\cup S_r$; (c) remove $r$ from Q. Examine whether $𝒮$ fulfils the designer needs: (a) if $𝒮$ fulfils the needs: manually select the most suitable SMCs, according to the requirements (the redundant components are removed from $𝒮$); search for places that occur in more than one SMC and manually replace them by NOPs according to Def. 7. (subsequent replaced places can be joined). (b) otherwise: if $t<\left|T\right|$ go to the step 2; else return $𝒮=\varnothing$ with information that the system cannot be decomposed. Synchronisation: for each transition $t\in T$ shared by two or more components $𝒮’\in 𝒮$: (a) add a synchronisation signal $z_{ti}$ to input place of $t$ in each component $S_i\in 𝒮’$; (b) assign a logical conjunction of all synchronisation signals $z_{ti}$ to $t$. Return the set of decomposed and synchronised components $𝒮.$

It should be noted that the general idea was initially shown in our previous papers [29,33]. However, the technique proposed in this paper is significantly modified in order to adjust the obtained components to the designer’s requirements. In particular, the components are obtained subsequently and examined at each step of the algorithm, whether they fulfil the designer requirements. Therefore, there is no need to apply an additional selection process. The main advantage of such a proposition is the obtained set of components, which is strictly adjusted to the designer’s needs.

The proposed algorithm consists of six main stages. As the input data, an incidence matrix of a Petri net is read. The main operations are executed on the unit matrix $Q$ that unifies the resulting matrix $D$ (initially set as an identity matrix), and incidence matrix $A$ of a Petri net. The first three steps of the method are aimed at searching for subsequent sequential components in the system. The presented algebraic operations transform the unity matrix by annulling the subsequent transitions (columns). After each such operation, matrix $A$ is examined in accordance with the rows that contain entirely zeros. The existence of such values means that place invariants are found (whose supports can be read from $D$). Moreover, step 3b verifies whether the obtained invariants form proper SMCs and includes them in the temporal set of decomposed components $𝒮$. At the fourth stage the designer manually examines whether obtained SMCs fulfil the assumed requirements. If the result satisfies the needs, the redundant components are removed from the set $𝒮$. Otherwise, the procedure is repeated, and subsequent invariants are searched (from step 2). There is also a possibility that the system cannot be decomposed to the state machine components. If such a situation holds (that is, all transitions are examined and components included in set $𝒮$ do not cover all Petri net places), adequate information is returned to the designer. Let us note that such a situation is rare, and in most cases, indicates errors or mistakes in the model. Finally, the fifth step performs synchronisation of the decomposed components. It is assumed that all SMCs work in the same time domain (the same clock signal is shared among components, with the same frequency), thus such a process is much easier in comparison to the distributed systems (where particular components strictly depend on the destination device and its time domain). In the proposed algorithm the synchronisation is simply executed by applying additional signals to the transitions and places preceding them. Eventually, the decomposed and synchronised system is returned as an output within step 6.

Moving on to the computational complexity of the proposed method, it should be noted that it is exponential in the general case. It is possible that the number of invariants grows exponentially at each operation (step 2), hence the method may not find the result in the assumed time. On the other hand, the improvements applied to the presented solution highly reduce such a risk. In particular, invariants are examined at each operation (step 4), thus the computation process can be safely terminated.

4. Case study Example—Beverage Production and Distribution Machine

The proposed decomposition method is illustrated by a real-life example of a cyber-physical system. Firstly, the description of the Petri net model is presented. Next, the proposed decomposition technique is applied. Finally, the decomposed system is implemented within the FPGA device.

4.1. Description of the System

Figure 1 presents a beverage production and distribution machine. To explain the decomposition process, we a modified version of a beverage production and distribution machine (previously shown in [35]) is used. The presented system works as follows. The machine starts in an idle state and pressing a button on the operator console (input signal x1) initiates the production process. Two valves (output signal y1 and y2) open, and two containers (1st container and 2nd container) are filled with liquid ingredients. Sensors x2 and x3 signal when the upper limit of each container has been reached, respectively.

At that point, the liquid in two containers is warmed up (y4 and y5, respectively) and a cup is being loaded on the trolley (y3). The charged cart (x4) moves to the left edge (y10) until it reaches the leftmost position (x11), and the liquid in containers is warmed until it reaches the required temperature (x5 and x6). The output valves of the two containers are opened (y6 and y7), and the ready ingredients from both containers are mixed (y8) in the main (third) container. When both upper containers (the first and second one) are empty (x7 and x8), the beverage is ready for distribution (x9). Then, the output valve of the main container opens (y9), and the liquid is poured into the cup on the trolley. Once the main container is empty (x10) and thus the cup is full, the trolley moves to the right (y11), and after it reaches the appropriate position (x12), the cup is removed from the trolley, and the system returns to its initial state.

Figure 2 shows a Petri net model of the discussed CPS. The Petri net-based specification contains twenty places and sixteen transitions. Moreover, there are twelve input signals associated with sensors (for instance liquid level sensor) and twelve output signals assigned to physical parts of the beverage machine. The association between transitions and input signals is presented in

Table 1. Association between transitions and inputs.

Transition	Input	Condition
t1	x1	Pressed start button
t2	x2	First container filled
t3	x3	Second container filled
t4	x4	Cup is put on trolley
t5	x5	First ingredients ready
t6	x6	Second ingredients ready
t7	x11	Trolley at left edge
t8	-	-
t9	x7	First container empty
t10	x8	Second container empty
t11	x9	Mixing ended
t12, t13	-	-
t14	x10	Main container empty
t15	x12	Trolley at right edge
t16	!x4	Cup is removed from trolley

, while

Table 2. Association between places and outputs.

Place	Output	Task
p1	-	-
p2	y1	Fill up first container
p3	y2	Fill up second container
p4	y3	Load cup
p5	y4	Warm up 1st container
p6	y5	Warm up 2nd container
p7	y10	Move trolley to left
p8, …, p10	-	-
p11	y6	Open first valve
p12	y7	Open second valve
p13	y8	Mix ingredients
p14, …, p17	-	-
p18	y9	Open main valve
p19	y11	Move trolley to right
p20	y12	Unload cup

exposes the relations between places and output signals. For example, sensor x1 (pressing of the start button) is assigned to the transition t1, while filling up of the first container is signalized by output y1 (associated with place p2).

4.2. Decomposition of the System

Let us now decompose the above system according to the second decomposition technique. This time the CPS is oriented into the implementation within integrated device. Let us apply Algorithm 1 in order to decompose the system. Firstly, an incidence matrix $A_1$ of a Petri net $N_1$ is read. The matrix consists of $\left|T\right|=16$ rows and $\left|P\right|=20$ columns, as shown in Figure 3.

At the first step of the algorithm a unit matrix $Q$ given as $[D|A_1]$ is formed, while $D$ is equal to the identity matrix. During the subsequent stages, algorithm searches for the place invariants that form proper SMCs. Such operations are executed within steps 2–4, until set $𝒮$ (of all found SMCs) cover all places of the Petri net. For the given example, this condition is fulfilled at the 15th iteration (examination of 15th transition). The following place invariants are obtained:

• $I_1=\left[10010010010000000111\right]$, with support: {$p_1, p_4, p_7, p_{10}, p_{18}, p_{19}, p_{20}\}$,
• $I_2=\left[11001001001001001111\right]$, with support: {$p_1, p_2, p_5, p_8, p_{11}, p_{14}, p_{17}, p_{18}, p_{19}, p_{20}\}$,
• $I_3=\left[10100100101001001111\right]$, with support: $\left\{p_1, p_3, p_6, p_9, p_{11}, p_{14}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $I_4=\left[11001001000100101111\right]$, with support: $\left\{p_1, p_2, p_5, p_8, p_{12}, p_{15}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $I_5=\left[10100100100100101111\right]$, with support: $\left\{p_1, p_3, p_6, p_9, p_{12}, p_{15}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $I_6=\left[11001001000010011111\right]$, with support: $\left\{p_1, p_2, p_5, p_8, p_{13}, p_{16}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $I_7=\left[10100100100010011111\right]$, with support: $\left\{p_1, p_3, p_6, p_9, p_{13}, p_{16}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$.

All the above invariants form proper SMCs, thus set $𝒮$ consists of seven components $𝒮=\left\{S_1,\dots ,S_7\right\}$, as follows:

• $S_1=\left\{p_1, p_4, p_7, p_{10}, p_{18}, p_{19}, p_{20}\right\}$,
• $S_2=\left\{p_1, p_2, p_5, p_8, p_{11}, p_{14}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $S_3=\left\{p_1, p_3, p_6, p_9, p_{11}, p_{14}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $S_4=\left\{p_1, p_2, p_5, p_8, p_{12}, p_{15}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $S_5=\left\{p_1, p_3, p_6, p_9, p_{12}, p_{15}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $S_6=\left\{p_1, p_2, p_5, p_8, p_{13}, p_{16}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$,
• $S_7=\left\{p_1, p_3, p_6, p_9, p_{13}, p_{16}, p_{17}, p_{18}, p_{19}, p_{20}\right\}$.

Since the above SMCs cover all places of the Petri net, the designer manually selects the most suitable components and checks, whether obtained solution fulfils the needs. In the presented example, four SMCs are selected as a final result: $\left\{S_1,S_2,S_5,S_6\right\}$, while the redundant three $\left\{S_3,S_4,S_7\right\}$, are reduced from the final solution. At the subsequent step, all places that occur in more than one SMC are manually replaced NOPs. This operation simply substitutes places that belong to multiple components by no-operational ones in order to avoid doubled actions performed by the decomposed controller. In the discussed example, the following result is obtained after this operation:

• $S_1=\left\{p_1, p_4, p_7, p_{10}, NO{P}_1, p_{19}, p_{20}\right\}$,
• $S_2=\left\{{\mathrm{NOP}}_2,{ \mathrm{p}}_2,{\mathrm{p}}_5,{\mathrm{p}}_8,{\mathrm{p}}_{11},{\mathrm{p}}_{14},{\mathrm{NOP}}_3\right\}$
• $S_5=\left\{{\mathrm{NOP}}_4, p_3, p_6, p_9, p_{12},{ \mathrm{p}}_{15},{\mathrm{NOP}}_5\right\}$,
• $S_6=\left\{{\mathrm{NOP}}_6,{\mathrm{p}}_{13},{\mathrm{p}}_{16},{\mathrm{p}}_{17},{\mathrm{p}}_{18},{\mathrm{NOP}}_7\right\}$.

The applied NOPs strictly refer to the functionality of the system. For example, $p_{18}$ in the first component is replaced by $NO{P}_1$, since operation assigned to this place is executed within $S_6$. Similarly, $p_1$ occurs only within $S_1$, while in all remaining components it is replaced by NOPs ($NO{P}_2$ in $S_2$, $NO{P}_4$ in $S_5$, and $NO{P}_6$ in $S_6$), etc. Note that enumeration of NOPs does not influence on the final result (it is just an indexation), thus designers can do it according to their needs. In the presented example, three NOPs are initially marked: $NO{P}_2$, $NO{P}_4$, and $NO{P}_6$ since they refer to the initially marked place $p_1.$ Furthermore, there are NOPs that replace more than one place. For example, $NO{P}_3$ replaces four subsequent places: $p_{17},p_{18},p_{19},p_{20}$. Such a joining of NOPs is not necessary (the system can be decomposed by replacing a place per one NOP) but may reduce the utilised area of the FPGA.

Figure 4 illustrates the decomposed Petri net. It should be underlined that obtained four components strictly refer to the functionality of the CPS. The first SMC is in charge of managing the trolley (with all associated conditions and actions). Components $S_2$ and $S_5$ control containers (first and second, respectively). Finally, actions assigned to $S_6$ are related to the third container.

4.3. Experimental Validation of the Proposed Method

This section presents the experimental validation of the proposed decomposition technique. The obtained model of the beverage production and distribution system was implemented in the real FPGA device. In particular, Nexys 4 DDR prototyping board with the FPGA device xc7a100tcsg324-2 from Artix 7 family was used to perform hardware validation. Firstly, the decomposed modules were described in the Verilog hardware language. The applied encoding style is based on the rules shown in other authors’ works, e.g., [7,33]. In particular, each of decomposed SMCs is described as a sequential module. An exemplary description of $S_1$ is shown in Listing 1. There are three main sections within this module. The first one triggers switching states in the system. It is described by an always block, and it is activated by a positive clock signal (common oscillator for all components) or asynchronous reset. The second section prepares adequate switching values for the next state. It is also described by an always block; however, the sensitivity list includes input signals (and the value of the current state). Finally, the last block associates outputs with particular states by continuous assignments.

Listing 1. Description of exemplary S-component (S1) (actions performed by a trolley).

// Description of S1

module s1 (

output y3, y10, y11, y12,

output z1,

input x1, x4, x11, x12,

input z2, z8,

input clk, reset

);

reg [2:0] state, next;

parameter P1 = 3’b000, P4 = 3’b001, P7 = 3’b011, P10 = 3’b010,          NOP1 = 3’b110, P19 = 3’b111, P20 = 3’b101;

always @(posedge clk or posedge reset) begin

if (reset) state <= P1;

else state <= next;

end

always @ (state or x1 or x4 or x11 or x12 or z2 or z8) begin

case (state)

P1: next <= (x1) ? P4 : P1;

P4: next <= (x4) ? P7 : P4;

P7: next <= (x11) ? P10 : P7;

P10: next <= (z2) ? NOP1 : P10;

NOP1: next <= (z8) ? P19 : NOP1;

P19: next <= (x12) ? P20 : P19;

P20: next <= (!x4) ? P1 : P20;

default: next <= P1;

endcase

end

assign y3 = (state == P4) ? 1’b1 : 1’b0;

assign y10 = (state == P7) ? 1’b1 : 1’b0;

assign y11 = (state == P19) ? 1’b1 : 1’b0;

assign y12 = (state == P20) ? 1’b1 : 1’b0;

assign z1 = (state == P10) ? 1’b1 : 1’b0;

endmodule

All the SMCs are controlled by the top-level module. This module simply includes an instance of each component. Listing 2 shows the Verilog code for the presented beverage production and distribution machine. Note that the top-level module contains twelve input and twelve output signals that are directly used in the modelled CPS. The internal signals (vector z) are applied to synchronise the decomposed components. Additional clk and reset signals are used for synchronisation (clock) and restarting the system, respectively.

Listing 2. Description of the top-level module.

// Description of top-level module bevarege_decomposed (

output [1:12] y,

input [1:12] x,

input clk, reset

);

wire z[1:8];

s1 trolley   (y[3],y[10],y[11],y[12],z[1],z[8],x[1],x[4],           x[11],x[12],z[2],z[8],clk,reset);

s2 container1 (y[1],y[4],y[6],z[3],z[4],x[1],x[2],x[5],x[7],           z[5],z[6],z[7],clk,reset);

s5 container2 (y[2],y[5],y[7],z[5],z[6],x[1],x[3],x[6],x[8],           z[3],z[4],z[7],clk,reset);

s6 container3 (y[8],y[9],z[2],z[7],z[8],x[9],x[10],z[1],           z[3],z[4],z[5],z[6],clk,reset);

endmodule

The modelled system was logically synthesised and implemented with Xilinx Vivado 2022.1.2 software.

Table 3. Utilization of FPGA device resources.

Device Resources	Utilization
LUTs blocks	25 of 63,400 (<1%)
Flip-flops	27 of 126,800 (<1%)
IO blocks	26 of 210 (12%)

presents the utilisation of an FPGA. The decomposed CPS consumes just a fraction of the device’s resources. It requires 25 LUTs blocks (<1%) and 27 flip-flops (<1%). Moreover, the system utilises 12% of IO blocks (they are used for validation of the CPS).

Finally, the functionality of the system was tested within the physical FPGA. The validation was performed with the use of switches and LEDs available on the Nexys 4 DDR prototyping board (Figure 5 right). In particular, input signals were assigned to switches, while output signals were connected with diodes to visualise the operation of the real-life system in an accessible way.

5. Conclusions

A novel decomposition method of Petri net-based CPS aimed at the integrated systems was proposed in the paper. The presented technique is based on linear algebra and involves place invariants computation in order to obtain sequential components (SMCs). Contrary to the existing decomposition methods, the proposed algorithm is strictly aimed at the designer’s needs. Therefore, the selection of particular components is executed manually. The proposed idea was validated experimentally, with the use of integrated device. In particular, a beverage production and distribution cyber-physical system was modelled by a Petri net, decomposed with the presented concept, and finally implemented within an FPGA device.

Besides the benefits mentioned above, there are also limitations to the proposed technique. First of all, obtaining the sequential components can be exponential in the worst case. This means, that in the case of extremely complex systems, decomposition may take a long time. On the other hand, introduced manual selection may essentially speed-up this process, since the designer is able to interrupt the process once the obtained components cover all places of the modelled CPS. Furthermore, the proposed method is strictly oriented on integrated systems. Nevertheless, since the decomposed components form sequential automata, they can be applied to distributed systems. However, in such a case, more advanced synchronisation mechanisms ought to be provided, since components may work in different time-domains. Therefore, this is an excellent starting point for future works.

In particular, plans for the future include the development of the decomposition algorithm oriented on the distributed systems. This means that the CPS can be implemented within several devices, e.g., a set of connected microprocessors such as Arduinos, PLCs, etc. Besides splitting the system into sequential components, such a method ought to include proper synchronisation between devices in order to assure proper functionality of the whole CPS.