一种含有单个不可靠资源的柔性装配系统的鲁棒控制方法

1.本发明属于柔性装配技术领域，具体涉及一种柔性装配系统的鲁棒控制方法。


背景技术：

2.装配操作将多个工件组装成一个产品，是柔性制造系统中最重要的操作之一。在含有装配操作的柔性制造系统(以下简称柔性装配系统)中，死锁不仅可能由于共享资源和交互工件造成，而且可能由于工件的相互等待装配操作造成。一旦发生死锁，系统将陷入停顿，无法完成加工任务，造成经济损失和严重的后果。最近，制造装配系统的死锁控制问题受到了研究人员的广泛关注。文献1(j.c.luo,z.q.liu and m.c. zhou,a petri net-based deadlock avoidance policy for flexible manufacturing systems withassembly operations and multiple resource acquisition,ieee trans.ind.inform.,vol.15,no. 6,pp.3379-3387,2019.)中记载的luo等人基于系统的petri网模型，提出了一种柔性装配系统的死锁避免策略，并与现有的死锁控制方法进行了比较，结果表明该策略具有更高的许可性。
3.柔性装配系统中资源繁多，资源的故障在所难免。在不可靠资源故障后，请求不可靠资源加工的工件的生产会被迫停顿。由于这些被迫停止生产的工件依然占用着资源且不能释放，因此它们可能进一步阻塞不请求故障资源的工件的加工，进而可能导致整个系统陷入停顿。最近，含有不可靠资源的柔性装配制造系统的死锁控制受到了研究人员的广泛关注。文献2(n.du,h.s.hu,m.c.zhou,robust deadlock avoidanceand control of automated manufacturing systems with assembly operations using petrinets,ieee transactions on automation science and engineering,17(4),pp.1961-1975, 2020.)中记载的du等人将一步向前的技术应用到含有不可靠资源的柔性装配系统的鲁棒控制中，提出了首个针对含有不可靠资源的柔性装配制造系统的鲁棒控制策略。该策略试图确保所有不请求不可靠资源的工件持续加工，然而据研究，上述目标在含有不可靠资源的制造装配系统中是不可以实现的。
4.目前的现有技术具有如下缺点：
5.1)由于含有不可靠资源的柔性装配系统的鲁棒控制的复杂性，仅有文献2中个别学者研究了该问题，而文献2中的控制目标在含有不可靠资源的柔性装配系统中是不可以实现的，因此目前尚无成果可以。


技术实现要素：

6.为了克服现有技术的不足，本发明提供了一种含有单个不可靠资源的柔性装配系统的鲁棒控制方法，第一，建立了系统的自动机模型，以表征研究的系统。第二，基于建立的模型，提出了鲁棒控制策略需要满足的四条特性。第三，基于改进的银行家算法，提出了一个能够满足提出的四条特性的鲁棒控制策略。本发明是唯一一个能满足以上四条特性的鲁棒控制策略。本发明提出的死锁避免策略具有多项式时间复杂度，因此可以广泛应用于大
规模的柔性制造系统。
7.本发明解决其技术问题所采用的技术方案包括如下步骤：
8.步骤1：柔性装配系统建模；
9.步骤1-1：所述柔性装配系统含有一个不可靠资源，且具备以下三个典型的特征：首先，每一个资源都是一个工作站，包含一个用于加工工件的机器和若干用于存储工作的缓冲槽；其次，仅仅不可靠资源的机器能够发生故障，其故障发生在机器工作或空闲的时候；最后，每一个工件只有一条加工路径，每一个操作仅请求一个资源；
10.步骤1-2：用自动机对柔性装配系统建模；
11.模型用八元组s＝{r,ψ,p,ρ,q,σ,ξ,δ}表示，其中r＝{r1,r2,
…
,rm}是资源的集合，m表示系统中资源的个数；令ru表示系统中的不可靠资源；令ψi∈z

表示ri∈r 的缓冲空间的容量，z

为正整数；
12.p＝{p1,p2,
…
,pn}是工件类型的集合，其中n表示系统中工件的种类数量，令lj表示pj的操作数量，p
jk
表示pj的第k个操作；对于每类工件pj∈p，令p
jb
和p
je
分别表示pj的开始阶段和结束阶段；令pb＝{p
1b
,p
2b
,
…
,p
nb
}和pe＝{p
1e
,p
2e
,
…
,p
ne
}，令ρ(p
jk
)表示p
jk
的每个实例，即p
jk
请求的资源；令ω(ri)＝{p
jk
:ρ(p
jk
)＝ri}表示请求ri∈r 的操作的集合；
13.由于不同的工件可能包含一些相同的操作，因此令pi和pj表示两类工件，p
i(k-1)
和 p
ik
是pi的两个连续的操作，p
j(o-1)
和p
jo
是pj的两个连续的操作，如果p
i(k-1)
和p
j(o-1)
是不同的操作，而p
ik
和p
jo
是相同的操作，则p
ik
或p
jo
是将p
i(k-1)
的一个实例和p
j(o-1)
的一个实例装配到一起的装配操作；令pa表示系统中装配操作的集合，令p
jk
∈pa表示一个装配操作，π(p
jk
)表示由该装配操作组装起来的操作的集合，表示为：π(p
ik
)＝π(p
jo
) ＝{p
i(k-1)
,p
j(o-1)
}；
14.q表示系统状态的集合，一个状态q＝《λ,x
jk
,y
jk
:j＝1,
…
,n,k＝1,
…
,lj》，其中λ＝ 0或者1表示ru是故障或正常工作；x
jk
、y
jk
分别表示在阶段p
jk
上已完成或未完成的工件的数量；q0是系统的初始状态，其中x
jk
＝y
jk
＝0，k＝1,
…
,lj，λ＝ 1；给定状态q，若q(λ)＝1，q(x
11
)＝1，q(y
21
)＝2，且其它的元素都为0，则q能表示为q＝1 x
11
2y
21
；
15.∑＝∑c∪∑u，其中∑c＝{α
jk
:j＝1,2,
…
,n,k＝1,
…
,lj 1}为可控事件的集合，α
jk
,k ≤lj表示将ρ(p
jk
)分配给p
jk
，α
j(lj 1)
表示一个完工的pj离开系统；令令表示系统中装配事件的集合，∑u＝∑
u1
∪{κ,η}是系统中不可控事件的集合其中∑
u1
＝ {β
jk
:j＝1,
…
,n,k＝1,...,lj}，β
jk
表示在p
jk
的工件完成加工，κ、η分别表示不可控资源的故障或修复；
16.给定状态q∈q，ξ(q)是在q下使能事件的集合，定义如下：
17.a)p
j1
∈ω(ri)，如果那么α
j1
∈ξ(q)；
18.b)如果ri＝ru，那么q(λ)＝1是必要的，如果q(y
jk
)》0，那么β
jk
∈ξ(q)；
19.c)如果λ＝1，那么κ∈ξ(q)；
20.d)如果q(λ)＝0，那么η∈ξ(q)；
21.e)其中1《k≤|pj|并且如果q(x
j(k-1
)》0且)》0且λi＝0，那么α
jk
∈ξ(q)；
22.f)其中1《k≤|pj|并且α
jk
∈∑a，如果q(x
vw
)》 0并且那么α
jk
∈ξ(q)；
23.g)如果q(x
j|wj|
)》0，那么α
j(lj 1)
∈ξ(q)；
24.δ:q
×
∑
→
q是状态转移方程，对于状态q∈q和使能事件π∈ξ(q)，令δ(q,π)表示从状态q使能事件π后得到的状态；
25.令σ＝π1π2...πk∈∑*表示一个事件串，给定q∈q，如果q2＝δ(q1, π2)∈q，
…
，且qk＝δ(q
k-1
,πk)∈q，那么σ是从q可以发生的，q
1-qk是从q可达的状态；qr(q)表示从q可达的状态的集合；令δ(q,σ)表示从状态q依次使能σ中的事件后得到的状态；给定控制策略
△
，令qr(q,
△
)表示从q在
△
监督下可达的状态的集合；
26.步骤2：鲁棒控制策略的特性；
27.含有单个不可靠资源的自动制造系统的鲁棒监督控制策略需要确保：1)当不可靠资源故障时，不请求故障资源的工件持续加工；2)当不可靠资源正常工作时，所有工件持续加工；对于含有单个不可靠资源和装配操作的自动制造系统，特性1)不能满足；
28.对于虚拟不可靠资源，具体定义如下；
29.定义1：给定操作p
jk
，令θ(p
jk
)表示在p
jk
前面的包含虚拟操作的操作的集合，θ(p
jk
) ＝θ(p
jk
)∪{p
jk
}；资源ri∈r是虚拟不可靠资源如果且且且
30.定义2：资源ri∈r是二阶虚拟不可靠资源如果且且且是一个虚拟不可靠资源；
31.引理1：p
jk
和p
j(k c)
表示pj的两个阶段，其中c∈z

。如果p
jk
∈πa，p
j(k c)
∈πa，且ρ(p
jk
)∈γ(s)，那么ρ(p
j(k c)
)∈γ(s)；
32.根据上述过程可知，当ru故障时，请求ru或虚拟不可靠资源的工件无法继续加工；因此，一个鲁棒控制策略应该确保那些不请求ru∪γ(s)的工件的连续加工；具体地，鲁棒控制策略需要满足的特性如下：
33.定义3：如果系统中所有不请求ru∪γ(s)的工件都能在某个状态下连续加工，那么称该状态为s的合适状态，简称fs；如果1)当λ＝1时，所有工件都能持续加工；
34.2)如果κ∈ξ(q)，那么δ(q,κ)是fs；3)当λ＝0时，所有不请求的工件的能够连续加工；4)如果η∈ξ(q)，那么δ(q,η)是fs；则称控制策略
△
对于s是鲁棒的；
35.步骤3：鲁棒控制策略；
36.步骤3-1：分枝策略cnr算法；
37.cnr算法的输入包括状态q、考虑的工件所在的阶段集合d1、阶段集合d1的工件的数量集合d2、工件数量集合d2的目标位置集合d3以及研究的系统s；给定操作阶段p
jk
，令表示其剩余的操作的集合；
38.cnr在计算过程中不考虑资源的容量和状态；因此，cnr首先将资源容量设置为无穷，将不可靠资源的状态设置为运行；不在d1中的阶段上的工件不被考虑，因此 cnr清除这
些工件以避免干扰；将之后的状态赋予q；接着cnr将所有在d1上的工件顺序地移动到它们的目标位置，并同步更新d1和d2；再将经过以上操作后的状态赋予q；由于资源的容量假设为无穷，剩下不能被移动到目标位置的工件只能是因为需要和它们一起完成装配的工件不在待装配阶段而阻塞；接着，cnr将在阶段p
jk
∈ d1的工件移动到中具有最小下标的位置，并同步更新d1，将经过以上操作后的状态赋予q；接着，cnr计算需要的未加工的工件数量；为了完成计算，需要下面的定义：
39.一个工件有多个装配阶段，有些装配阶段需要依赖于其它装配阶段以完成其装配操作；不同的装配阶段的分类如下；
40.定义4：令p
je
为系统的一个虚拟的结束阶段，pa(p
je
)＝θ(p
je
)∩pa为在p
je
前面的所有装配阶段的集合；一个装配操作p
jk
∈pa(p
je
)如果满足则称其为一阶装配操作；令p
a1
(p
je
)表示在pa(p
je
)中的一阶装配操作的集合；一个装配操作p
jk
∈ {pa(p
je
)\p
a1
(p
je
)}如果满足则称其为二阶装配操作；令 p
a2
(p
je
)表示在pa(p
je
)中的二阶装配操作的集合；正式地，一个装配操作p
jk
∈ {pa(p
je
)\p
a1
(p
je
)\p
a2
(p
je
)\...\p
av
(p
je
)}如果满足)}如果满足则称其为(v 1)阶装配操作；假设最大的装配阶段为c
max
。令p
a1
＝{p
a1
(p
je
):j＝1,2,
…
, n},
41.令φ[j]存储需要的p
jb
∈pb未被加工的工件；初始时，对于p
jb
∈pb令φ[j]＝0， cnr从一阶装配操作开始计算，给定p
jk
∈p
a1
，如果令z＝max{q(x
vw
) q(y
vw
):p
vw
∈π(p
jk
)}；对于每个p
vw
∈π(p
jk
)，令表示在p
vw
前面的虚拟开始阶段的集合，对于每个令φ[o]＝φ[o] z-q(x
vw
)-q(y
vw
)；令 q(x
vw
)＝z，q(y
vw
)＝0；接着，装配在阶段π(p
jk
)的工件z次，更新d1和d2，将得到的状态赋值给q；如果装配后得到的工件能够被移动到d3[i]，那么将它们一个一个地移动到d3[i]，直到所有工件移动完成或者不再可移动为止，更新d1和d2，将得到的状态赋值给q；如果装配后得到的工件不能够被移动到d3[i]，将z个在p
jk
的工件移动到 p
j(k v)
，其中v∈z，p
j(k v)
∈πa，更新d1和d2，将得到的状态赋值给q；在所有p
jk
∈p
a1
的阶段处理完成后，cnr开始二阶装配操作开始计算；二阶装配操作的计算过程与一阶段装配操作的计算过程；重复执行本段直到所有都处理完成；
[0042]
定理1：给定q∈qr(q0)，d1，d2，d3，s，令φ
min
表示将所有在d1阶段上的工件移动到d3的目标阶段上需要的未加工的工件的最小数量。那么，φ＝cnr(q,d1,d2,d3, s)＝φ
min
；
[0043]
步骤3-2：第一个改进银行家算法mba1；
[0044]
令p表示系统中所有操作的集合，即即给定p
jk
∈p，令表示p
jk
的剩余路径的；令的剩余路径的；令表示未来不请求γ(s)中资源的操作位置的集合；令令且表示未来请求γ(s)中资源但是不在γ(s)资源上的操作位置的集合；令 p3＝{p
jk
:ρ(p
jk
)∈γ(s)}表示在γ(s)资源上的操作位置的集合；令p4＝{p
ib
|i∈{1,
2,
…
, n}}；
[0045]
给定一个状态q，mba1将所有在阶段p
jk
∈p1上的工件移出系统，所有在阶段p
jk
∈p2上的工件移动到ρ(p
j(k v)
)上，其中v∈z

，ρ(p
j(k v)
)∈γ
jk
，ρ(p
j(k v)
)∈γ(s)，)∈γ(s)，令p1(q)＝{p
jk
∈p1:q(x
jk
) q(y
jk
)≥0}，p2(q)＝{p
jk
∈p2: q(x
jk
) q(y
jk
)≥0}，p3(q)＝{p
jk
∈p3:q(x
jk
) q(y
jk
)≥0}分别表示在状态q在阶段p1，p2， p3上有工件的阶段集合；由于装配操作的存在，将在阶段p1∪p2上的工件移动到目标位置可能需要未被加工的工件；需要的工件的数量由cnr计算；令φ表示需要的未被加工的工件的数量，p4(q)＝{p
ib
|i∈{1,2,
…
,n}且φ[i]》0}；
[0046]
mba1包含两个部分，即和试图将在阶段p1∪p2上的工件移动到目标阶段，试图将在阶段p
jk
∈p1∪p2∪p4上的工件移动到ρ(p
j(k v)
)上，其中 v∈z

，ρ(p
j(k v)
)∈γ
jk
，p
j(k v)
∈πa，
[0047]
定理2：具有多项式时间复杂度；
[0048]
定理3：具有多项式时间复杂度；
[0049]
mba1查找一个p1∪p2的阶段的顺序，按照这个顺序所有在p1∪p2阶段上的工件都能移动到目标位置；如果能找到这个顺序，mba1返回(true,q1)，表示q是被mba1接受的并且按照这个顺序移动所有的工件后得到的状态为q1；否则，mba1返回(false, q1)；
[0050]
mba1交替执行和直到所有在p1∪p2阶段上的工件都移动到目标位置；令d1,d2,d3表示三个集合分别用于存储考虑的阶段，在这些阶段上的工件数量，以及考虑的这些阶段的目标位置；
[0051]
定理4：mba1具有多项式时间复杂度；
[0052]
步骤3-3：第二个改进银行家算法mba2；
[0053]
mba2在假设λ＝1的情况下，试图将执行mba1后系统中剩下的工件全部移出系统；由于系统中存在装配操作，将系统中剩余的工件移出系统可能需要未被加工的工件；需要的工件的数量由cnr计算；
[0054]
mba2包含两个部分，分别是和试图将在阶段p1∪p2∪p3∪p4上的工件移出系统，试图将一个在阶段p
jk
∈p1∪p2∪p3∪p4上的工件移动到ρ(p
j(k v)
)，其中v∈{1,2,
…
,l
j-k}，ρ(p
j(k v)
)∈γ
jk
,p
j(k v)
∈πa，
[0055]
定理5：具有多项式时间复杂度。
[0056]
处理的阶段p1∪p2∪p3∪p4上的工件，而处理的阶段p1∪p2∪p4上的工件，除此之外，与的作用是一样；
[0057]
定理6：具有多项式时间复杂度；
[0058]
mba2交替执行和直到所有在p1∪p2∪p3阶段上的工件都移出系统；令d1,d2,d3表示三个集合分别用于存储考虑的阶段，在这些阶段上的工件数量，以及考虑的这些阶段的目标位置；
[0059]
定理7：mba2具有多项式时间复杂度；
[0060]
步骤3-4：系统的鲁棒监督控制策略；
[0061]
所述鲁棒监督控制策略为
△
lzz
:q
×
∑
→
{0,1}，其具体定义如下：令q∈qr(q0)为系统的状态π∈ξ(q)为状态q下的使能事件，如果π∈∑u，那么
△
lzz
(q,π)＝1；否则，令q1＝δ(q,π)，当且仅当mba1(q1)＝(true,q2)且mba2(q2)＝true时，
△
lzz
(q,π)＝1；
[0062]
引理2：且q(λ)＝1，假设σ∈{∑c∪∑
u1
}*为mba1在q找到的事件序列，那么从q执行σ不会违背mba2；
[0063]
引理3：且q(λ)＝1，假设mba1(q)＝(true,q1)，σ∈{∑c∪∑
u1
}* 为mba2在q1找到的事件序列，那么从q1执行σ不会违背mba1；
[0064]
定理8：且q(λ)＝1,δ(q, σ
[i]
)∈qr(q0,
△
lzz
),且q0＝δ(q,σ)；
[0065]
定理9：如果κ∈ξ(q)，那么q1＝δ(q,κ)是一个fs；
[0066]
推论1：且λ＝0，所有不请求γ(s)中资源的工件都能够从q持续加工；
[0067]
定理10：如果η∈ξ(q)，那么q1＝δ(q,η)是fs；
[0068]
定理6-1：最终得到
△
lzz
是系统的鲁棒监督控制策略。
[0069]
进一步地，所述cnr的步骤如下所示：
[0070]
输入：系统的状态q∈qr(q0),d1,d2,d3,和系统s；
[0071]
输出：存储需要的每类工件未加工的工件的数量φ；
[0072]
步骤3.1.1：令q(λ)＝1；
[0073]
步骤3.1.2：令j＝1；
[0074]
步骤3.1.3：如果j《＝n，那么循环执行步骤3.1.3.1和3.1.3.2，否则结束循环，跳转至步骤3.1.4；
[0075]
步骤3.1.3.1：φ[j]＝0；
[0076]
步骤3.1.3.2：令j加1；
[0077]
步骤3.1.4：令i＝1；
[0078]
步骤3.1.5：如果i《＝m，那么循环执行步骤3.1.5.1和3.1.5.2，否则结束循环，跳转至步骤3.1.6；
[0079]
步骤3.1.5.1：ψi＝inf；
[0080]
步骤3.1.5.2：令i加1；
[0081]
步骤3.1.6：令i＝1；
[0082]
步骤3.1.7：如果i《＝n，那么循环执行步骤3.1.7.1～3.1.7.3，否则结束循环，跳转至步骤3.1.8；
[0083]
步骤3.1.7.1:令j＝1；
[0084]
步骤3.1.7.2:如果j《＝li，那么循环执行步骤3.1.7.2.1和步骤3.1.7.2.2，否则结束循环，跳转至步骤3.1.7.3；
[0085]
步骤3.1.7.2.1:如果那么令q(x
ij
)＝0和q(y
ij
)＝0；否则令q(x
ij
)＝q(x
ij
) q(y
ij
)和q(y
ij
)＝0；
[0086]
步骤3.1.7.2.2:令j加1；
[0087]
步骤3.1.7.3:令j加1
[0088]
步骤3.1.8：令i＝1；
[0089]
步骤3.1.9：如果i《＝|d1|，那么循环执行步骤3.1.9.1～3.1.9.3，否则结束循环，跳转至步骤3.1.10；
[0090]
步骤3.1.9.1：假设d1[i]＝p
jk
,d3[i]＝p
vw
；
[0091]
步骤3.1.9.2：循环执行步骤3.1.9.2.1～3.1.9.2.4，直到d2[i]《＝0；
[0092]
步骤3.1.9.2.1：如果在阶段d1[i]上的工件能够被移动到d3[i]上，那么执行步骤3.1.9.2.1.1～3.1.9.2.1.4，否则跳转到步骤3.1.9.2.2；
[0093]
步骤3.1.9.2.1.1：令ζ表示从d1[i]到d3[i]经过的阶段的序列；
[0094]
步骤3.1.9.2.1.2：将1个工件从d1[i]移动到d3[i]上；
[0095]
步骤3.1.9.2.1.3：令t＝1；
[0096]
步骤3.1.9.2.1.4：如果t《＝c
max
，那么执行步骤3.1.9.2.1.4.1～3.1.9.2.1.4.6，否则跳转到步骤3.1.9.2.2；
[0097]
步骤3.1.9.2.1.4.1：令ξ＝p
at
∩ζ；
[0098]
步骤3.1.9.2.1.4.2：如果存在p
ef
∈ξ，那么执行步骤3.1.9.2.1.4.2.1和步骤 3.1.9.2.1.4.2.2，否则跳转到步骤3.1.9.2.1.4.3；
[0099]
步骤3.1.9.2.1.4.2.1：从ξ中删除p
ef
；
[0100]
步骤3.1.9.2.1.4.2.2：如果存在p
gh
∈{π(p
ef
)\ζ}，那么执行步骤 3.1.9.2.1.4.2.2.1～3.1.9.2.1.4.2.2.5，否则跳转到步骤3.1.9.2.1.4.2.1；
[0101]
步骤3.1.9.2.1.4.2.2.1：q(x
gh
)＝q(x
gh
)
–
1；
[0102]
步骤3.1.9.2.1.4.2.2.2：查找d∈{1,2,
…
,|d1|}使得p
gh
＝d1[d]；
[0103]
步骤3.1.9.2.1.4.2.2.3：令d2[d]＝d2[d]
–
1；
[0104]
步骤3.1.9.2.1.4.2.2.4：如果d2[d]等于0，那么令d1[d]＝p
vw
，否则跳转到步骤 3.1.9.2.1.4.2.2.5；
[0105]
步骤3.1.9.2.1.4.2.2.5：从{π(p
ef
)\ζ}中删除p
gh
；
[0106]
步骤3.1.9.2.1.4.3：令q(x
jk
)＝q(x
jk
)
–
1，q(x
vw
)＝q(x
vw
) 1；
[0107]
步骤3.1.9.2.1.4.4：令d2[i]＝d2[i]
–
1；
[0108]
步骤3.1.9.2.1.4.5：如果d2[i]＝0，那么令d1[i]＝p
vw
；
[0109]
步骤3.1.9.2.1.4.6：令t加1；
[0110]
步骤3.1.9.2.2：查找c∈{1,2,
…
,l
j-k}使得p
j(k c)
∈πa且且
[0111]
步骤3.1.9.2.3：d1[i]＝p
j(k c)
；
[0112]
步骤3.1.9.2.4：令q(x
jk
)＝q(x
jk
)
–
d2[i]，q(x
j(k c)
)＝q(x
j(k c)
) d2[i]，跳转到步骤3.1.9.3；
[0113]
步骤3.1.9.3：令i加1；
[0114]
步骤3.1.10：令i＝1；
[0115]
步骤3.1.11：如果i《＝c
max
，那么循环执行步骤3.1.11.1～步骤3.1.11.3，否则跳
转到步骤3.1.12；
[0116]
步骤3.1.11.1：如果存在p
jk
∈p
ai
，那么循环执行步骤3.1.11.1.1～3.1.11.1.2，否则跳转到步骤3.1.11.1.3；
[0117]
步骤3.1.11.1.1：令t＝1；
[0118]
步骤3.1.11.1.2：如果t《＝|d1|，那么执行循环执行步骤3.1.11.1.2.1.1～3.1.11.1.2.1.7，否则跳转到步骤3.1.11.2；
[0119]
步骤3.1.11.1.2.1：如果d1[t]∈π(p
jk
)，那么执行步骤3.1.11.1.2.1.1～3.1.11.1.2.1.6，否则跳转到步骤3.1.11.1.2.1.7；
[0120]
步骤3.1.11.1.2.1.1：令z＝max{q(x
vw
) q(y
vw
):p
vw
∈π(p
jk
)}；
[0121]
步骤3.1.11.1.2.1.2：如果存在p
vw
∈π(p
jk
)，循环执行步骤 3.1.11.1.2.1.2.1～3.1.11.1.2.1.2.6，否则跳转到；
[0122]
步骤3.1.11.1.2.1.2.1：令
[0123]
步骤3.1.11.1.2.1.2.2：对每一个令φ[o]＝φ[o] z-q(x
vw
)-q(y
vw
)；
[0124]
步骤3.1.11.1.2.1.2.3：令q(x
vw
)＝0；
[0125]
步骤3.1.11.1.2.1.2.4：令f＝1；
[0126]
步骤3.1.11.1.2.1.2.5：如果f《＝|d1|，那么循环执行步骤3.1.11.1.2.1.2.5.1和 3.1.11.1.2.1.2.5.2，否则跳转到步骤3.1.11.1.2.1.2.6；
[0127]
步骤3.1.11.1.2.1.2.5.1：如果f≠t且d1[f]∈π(p
jk
)，那么令d2[f]＝0，d1[f]＝d3[f]；
[0128]
步骤3.1.11.1.2.1.2.5.2：f＝f 1；
[0129]
步骤3.1.11.1.2.1.2.6：从π(p
jk
)中删除p
vw
；
[0130]
步骤3.1.11.1.2.1.3：q(x
jk
)＝q(x
jk
) z；
[0131]
步骤3.1.11.1.2.1.4：d1[t]＝p
jk
；
[0132]
步骤3.1.11.1.2.1.5：令d2[t]＝z；
[0133]
步骤3.1.11.1.2.1.6：如果d2[t]》0，那么循环执行步骤 3.1.11.1.2.1.6.1～3.1.11.1.2.1.6.13，否则跳转到步骤3.1.11.1.2.1.7；
[0134]
步骤3.1.11.1.2.1.6.1：假设d3[t]＝p
vw
；
[0135]
步骤3.1.11.1.2.1.6.2：如果在阶段d1[t]上的工件能够被移动到d3[t]上，那么执行步骤3.1.11.1.2.1.6.3～3.1.11.1.2.1.6.8，否则跳转到步骤3.1.11.1.2.1.6.9；
[0136]
步骤3.1.11.1.2.1.6.3：令ζ表示从d1[t]到d3[t]经过的阶段的序列；
[0137]
步骤3.1.11.1.2.1.6.4：令d＝1；
[0138]
步骤3.1.11.1.2.1.6.5：如果d《＝c
max
，那么循环执行步骤 3.1.11.1.2.1.6.5.1～3.1.11.1.2.1.6.5.3，否则跳转至步骤3.1.11.1.2.1.6.6；
[0139]
步骤3.1.11.1.2.1.6.5.1：令ξ＝{p
ad
∩ζ}；
[0140]
步骤3.1.11.1.2.1.6.5.2：如果存在p
ef
∈ξ，那么执行步骤3.1.11.1.2.1.6.5.2.1和步骤3.1.11.1.2.1.6.5.2.2，否则跳转到步骤3.1.11.1.2.1.6.5.3；
[0141]
步骤3.1.11.1.2.1.6.5.2.1：如果存在p
gh
∈{π(p
ef
)\ζ}，那么执行步骤 3.1.11.1.2.1.6.5.2.1.1～3.1.11.1.2.1.6.5.2.1.5，否则跳转到步骤
3.1.11.1.2.1.6.5.2.2；
[0142]
步骤3.1.11.1.2.1.6.5.2.1.1：q(x
gh
)＝q(x
gh
)
–
1；
[0143]
步骤3.1.11.1.2.1.6.5.2.1.2：查找o∈{1,2,
…
,|d1|}使得p
gh
＝d1[o]；
[0144]
步骤3.1.11.1.2.1.6.5.2.1.3：令d1[o]＝d1[o]
–
1；
[0145]
步骤3.1.11.1.2.1.6.5.2.1.4：如果d2[o]等于0，那么令d1[o]＝d3[t]，否则跳转到步骤3.1.11.1.2.1.6.5.2.1.5；
[0146]
步骤3.1.11.1.2.1.6.5.2.1.5：从{π(p
ef
)\ζ}中删除p
gh
；
[0147]
步骤3.1.11.1.2.1.6.5.2.2：从ξ中删除p
ef
；
[0148]
步骤3.1.11.1.2.1.6.5.3：i＝-1令i减1；
[0149]
步骤3.1.11.1.2.1.6.6：q(x
jk
)＝q(x
jk
)
–
1and q(x
vw
)＝q(x
vw
) 1；
[0150]
步骤3.1.11.1.2.1.6.7：d2[t]＝d2[t]
–
1；
[0151]
步骤3.1.11.1.2.1.6.8：如果d2[t]＝0，那么令d1[t]＝d3[t]，否则跳转到步骤 3.1.11.1.2.1.6.9；
[0152]
步骤3.1.11.1.2.1.6.9：查找c∈{1,2,
…
,l
j-k}使得p
j(k c)
∈πa且且
[0153]
步骤3.1.11.1.2.1.6.10：令d1[t]＝p
j(k c)
；
[0154]
步骤3.1.11.1.2.1.6.11：令q(x
jk
)＝q(x
jk
)
–
d2[t]；
[0155]
步骤3.1.11.1.2.1.6.12：q(x
j(k c)
)＝q(x
j(k c)
) d2[t]；
[0156]
步骤3.1.11.1.2.1.6.13：跳转到步骤3.1.11.1.2.1.7；
[0157]
步骤3.1.11.1.2.1.7：令t加1；
[0158]
步骤3.1.11.2：从p
ai
中删除p
jk
；
[0159]
步骤3.1.11.3：令i加1；
[0160]
步骤3.1.12：返回φ。
[0161]
进一步地，所述的步骤如下：
[0162]
输入：系统的状态q∈qr(q0),和系统s；
[0163]
输出：将一些工件移动到合适位置后得到的状态q1；
[0164]
步骤3.2.1：令flag＝true；
[0165]
步骤3.2.2：如果flag＝true，那么循环执行步骤，否则执行步骤；
[0166]
步骤3.2.2.1：令flag＝false；
[0167]
步骤3.2.2.2：如果存在p
jk
∈p1，那么循环执行步骤3.2.2.2.1和步骤3.2.2.2.2，否则跳转到步骤3.2.2.3；
[0168]
步骤3.2.2.2.1：如果q(x
jk
) q(y
jk
)》0且存在一个在阶段p
jk
上的工件能够被移出系统，那么令σ表示与这一移动相关的事件序列，q＝δ(q,σ)，和flag＝true，否则跳转到步骤3.2.2.2.2；
[0169]
步骤3.2.2.2.2：从p1中删除p
jk
；
[0170]
步骤3.2.2.3：如果存在p
jk
∈p2，那么循环执行步骤3.2.2.3.2和步骤3.2.2.3.2，否则跳转到步骤3.2.3；
[0171]
步骤3.2.2.3.1：如果q(x
jk
) q(y
jk
)》0，那么执行步骤3.2.2.3.1.1和步骤
3.2.2.3.1.2，否则跳转到步骤3.2.2.3.2；
[0172]
步骤3.2.2.3.1.1：查找c∈{1,2,
…
,l
j-k}使得ρ(p
j(k v)
)∈γ
jk
,p
j(k c)
∈γ(s)，且且
[0173]
步骤3.2.2.3.1.2：如果存在一个在阶段p
jk
上的工件能够被移动到阶段p
j(k c)
，那么令σ表示与这一移动相关的事件序列，q＝δ(q,σ)，和flag＝true，否则跳转到步骤3.2.2.3.2；
[0174]
步骤3.2.2.3.2：从p2中删除p
jk
；
[0175]
步骤3.2.3：返回q。
[0176]
进一步地，所述的步骤如下：
[0177]
输入：系统的状态q∈qr(q0)，系统s，和存储需要的未加工的工件的数量的φ；
[0178]
输出：flag(表示是否存在可以移动到剩余路径上的第一个在πa上的阶段)，移动该工件后的状态q1，和φ；
[0179]
步骤3.2.4：flag＝false；
[0180]
步骤3.2.5：如果存在p
jk
∈p1∪p2，那么循环执行步骤3.2.5.1和步骤3.2.5.2，否则跳转到步骤3.2.6；
[0181]
步骤3.2.5.1：如果q(x
jk
) q(y
jk
)》0，那么执行步骤3.2.5.1.1和步骤3.2.5.1.2，否则跳转到步骤3.2.5.2；
[0182]
步骤3.2.5.1.1：查找c∈{1,2,
…
,l
j-k}使得ρ(p
j(k v)
)∈γ
jk
,p
j(k c)
∈πa，且且
[0183]
步骤3.2.5.1.2：如果存在一个在阶段p
jk
上的工件能够被移动到阶段p
j(k c)
，那么令σ表示与这一移动相关的事件序列，q＝δ(q,σ)，和flag＝true，跳转到步骤3.2.5.2，否则跳转到步骤3.2.6；
[0184]
步骤3.2.5.2：从p1∪p2中删除p
jk
；
[0185]
步骤3.2.6：如果flag＝false,那么执行步骤，否则执行步骤；
[0186]
步骤3.2.6.1：如果存在p
jb
∈p4，那么循环执行步骤3.2.6.1.1和步骤3.2.6.1.1.2，否则跳转到步骤3.2.7；
[0187]
步骤3.2.6.1.1：如果φ[j]》0，那么执行步骤3.2.6.1.1.1和步骤3.2.6.1.1.2，否则跳转到步骤3.2.6.1.2；
[0188]
步骤3.2.6.1.1.1：查找c∈{1,2,
…
,lj}使得p
jc
∈γ
jb
,p
jc
∈πa，且且
[0189]
步骤3.2.6.1.1.2：如果存在一个在阶段p
jb
上的工件能够被移动到阶段p
jc
，那么令σ表示与这一移动相关的事件序列，q＝δ(q,σ)，φ[j]＝φ[j]
–
1，和flag＝true，否则跳转到步骤3.2.7；
[0190]
步骤3.2.6.1.2：从p4中删除p
jb
；
[0191]
步骤3.2.7：返回flag，q1，和φ。
[0192]
进一步地，所述mba1的步骤如下：
[0193]
输入：系统的状态q∈qr(q0)；
[0194]
输出：移动该工件后的状态q1，flag，表示状态是否被mba1接受；
[0195]
步骤3.2.8：令t＝|p1(q)∪p2(q)|，i＝1；
[0196]
步骤3.2.9：如果存在p
jk
∈p1(q)，那么循环执行步骤3.2.9.1～步骤3.2.9.5，否则跳转到步骤3.2.10；
[0197]
步骤3.2.9.1：d1[i]＝p
jk
；
[0198]
步骤3.2.9.2：d2[i]＝q(x
jk
) q(y
jk
)；
[0199]
步骤3.2.9.3：d3[i]＝p
je
；
[0200]
步骤3.2.9.4：令i加1；
[0201]
步骤3.2.9.5：从p1(q)中删除p
jk
；
[0202]
步骤3.2.10：如果存在p
jk
∈p2(q)，那么循环执行步骤3.2.10.1～步骤3.2.10.6，否则跳转到步骤3.2.11；
[0203]
步骤3.2.10.1：d1[i]＝p
jk
；
[0204]
步骤3.2.10.2：d2[i]＝q(x
jk
) q(y
jk
)；
[0205]
步骤3.2.10.3：查找c∈{1,2,
…
,l
j-k}使得ρ(p
j(k v)
)∈γ
jk
,p
j(k c)
∈γ(s)，且且
[0206]
步骤3.2.10.4：d3[i]＝p
j(k c)
；
[0207]
步骤3.2.10.5：令i加1；
[0208]
步骤3.2.9.6：从p2(q)中删除p
jk
；
[0209]
步骤3.2.11：φ＝cnr(q,d1,d2,d3,s)；
[0210]
步骤3.2.12：flag＝true；
[0211]
步骤3.2.13：如果flag＝true，那么循环执行步骤3.2.13.1～3.2.13.3，否则跳转到步骤3.2.14；
[0212]
步骤3.2.13.1：
[0213]
步骤3.2.13.2：
[0214]
步骤3.2.13.3：q＝q2；
[0215]
步骤3.2.14：如果存在p
jk
∈p1∪p2，那么循环执行步骤步骤3.2.14.1和步骤3.2.14.2，否则跳转到步骤3.2.15；
[0216]
步骤3.2.14.1：如果q(x
jk
) q(y
jk
)》0，那么返回(q,false)，否则跳转到步骤；
[0217]
步骤3.2.14.2：从p1∪p2中删除p
jk
；
[0218]
步骤3.2.15：返回(q,true)。
[0219]
进一步地，所述的步骤如下：
[0220]
输入：系统的状态q∈qr(q0)，系统s；
[0221]
输出：移动该工件后的状态q1；
[0222]
步骤3.3.1：flag＝true；
[0223]
步骤3.3.2：如果flag＝true，那么循环执行步骤3.3.2.1和步骤3.3.2.2，否则跳转到步骤3.3.3；
[0224]
步骤3.3.2.1：flag＝false；
[0225]
步骤3.3.2.2：如果存在p
jk
∈p1∪p2∪p3∪p4，那么循环执行步骤步骤3.3.2.2.1和步骤3.3.2.2.2，否则跳转到步骤3.3.3；
[0226]
步骤3.3.2.2.1：如果q(x
jk
) q(y
jk
)》0且存在在阶段p
jk
上的工件能够被移出系统，那么令σ表示与这一移动相关的事件序列，q＝δ(q,σ)，和flag＝true，否则跳转到步骤 3.2.7；
[0227]
步骤3.3.2.2.2：从p1∪p2∪p3∪p4中删除p
jk
；
[0228]
步骤3.3.3：返回q。
[0229]
进一步地，所述mba2的步骤如下：
[0230]
输入：系统的状态q∈qr(q0)；
[0231]
输出：flag，表示q是否被mba2拒绝；
[0232]
步骤3.3.4：令t＝|p1(q)∪p2(q)∪p3(q)|,i＝1,q(λ)＝1；
[0233]
步骤3.3.5：如果存在p
jk
∈p1(q)∪p2(q)∪p3(q)，那么循环执行步骤3.3.5.1～3.3.5.5，否则跳转到步骤3.3.6；
[0234]
步骤3.3.5.1：d1[i]＝p
jk
；
[0235]
步骤3.3.5.2：d2[i]＝q(x
jk
) q(y
jk
)；
[0236]
步骤3.3.5.3：d3[i]＝p
je
；
[0237]
步骤3.3.5.4：令i加1；
[0238]
步骤3.3.5.5：从p1(q)∪p2(q)∪p3(q)中删除p
jk
；
[0239]
步骤3.3.6：φ＝cnr(q,d1,d2,d3,s)；
[0240]
步骤3.3.7：flag＝true；
[0241]
步骤3.3.8：如果flag＝true，那么循环执行步骤3.3.8.1～步骤3.3.8.3，否则跳转到步骤3.3.9；
[0242]
步骤3.3.8.1：
[0243]
步骤3.3.8.2：
[0244]
步骤3.3.8.3：q＝q2；
[0245]
步骤3.3.9：如果存在p
jk
∈p1∪p2∪p3，那么循环执行步骤3.3.9.1，否则跳转到步骤3.3.10；
[0246]
步骤3.3.9.1：如果q(x
jk
) q(y
jk
)》0，那么返回false；
[0247]
步骤3.3.10：返回true。
[0248]
本发明的有益效果如下：
[0249]
(1)由于本发明提出的死锁避免策略具有多项式时间复杂度，因此可以广泛应用于大规模的柔性制造系统；
[0250]
(2)本发明首次提出了含有不可靠资源的柔性装配系统的鲁棒控制策略需要满足的特性，并提出了满足该特性的鲁棒监督控制策略，因此本发明的方法具有唯一性；
[0251]
(3)由于该发明试图将尽可能多的工件移出系统以确保受控系统的许可性，因此本发明的方案许可性较高。
附图说明
[0252]
图1为本发明实施例用于说明现有特性不能被满足的实例。
[0253]
图2为本发明实施例用于说明虚拟不可靠资源应该进一步被扩展的实例。
[0254]
图3为本发明实施例装配阶段分类的说明。
具体实施方式
[0255]
下面结合附图和实施例对本发明进一步说明。
[0256]
一种含有单个不可靠资源的柔性装配系统的鲁棒控制方法，包括如下步骤：
[0257]
步骤1：柔性装配系统建模；
[0258]
本发明针对的柔性装配系统含有一个不可靠资源，且具备以下三个典型的特征。首先，每一个资源都是一个工作站，包含一个用于加工工件的机器和若干用于存储工作的缓冲槽。其次，仅仅不可靠资源的机器能够发生故障，其故障可能发生在机器工作或空闲的时候。最后，每一个工件只有一条加工路径，每一个操作仅请求一个资源；
[0259]
用自动机对研究的系统建模。模型可以用八元组s＝{r,ψ,p,ρ,q,σ,ξ,δ}表示。
[0260]
步骤2：鲁棒控制策略的特性；
[0261]
具体例子如下；
[0262]
如图1所示，例1：考虑自动制造系统s，假设r＝{r1,r2,
…
,r8}，p＝{p1,p2,
…
, p4}，l1＝4，l2＝5，l3＝5，l4＝4。p1的操作为p
11
，p
12
，p
13
，p
14
，p2的操作为p
21
，p
22
， p
23
，p
24
，p
25
，p3的操作为p
31
，p
32
，p
33
(p
23
)，p
34
(p
24
)，p
35
(p
25
)，p4的操作为p
41
，p
42
， p
43
，p
44
。注意到，p
33
和p
23
，p
34
和p
24
，以及p
35
和p
25
是相同的操作。p
23
是装配操作， π(p
23
)＝{p
22
,p
32
}。ρ(p
11
)＝r1，ρ(p
12
)＝r2，ρ(p
13
)＝r3，ρ(p
14
)＝r4，ρ(p
21
)＝r4，ρ(p
22
) ＝r3，ρ(p
23
)＝r2，ρ(p
24
)＝r1，ρ(p
25
)＝r3，ρ(p
31
)＝r5，ρ(p
32
)＝r6，ρ(p
41
)＝r7，ρ(p
42
)＝ r8，ρ(p
43
)＝r7，ρ(p
44
)＝r5。ψ1＝ψ3＝ψ4＝ψ5＝ψ6＝ψ7＝ψ8＝1，ψ2＝2。系统的概览图 如图1。假设r6是不可靠资源。如果事件序列α
21
β
21
α
22
β
22
允许发生，那么从q0使能该事件 序列得到δ(q0,α
21
β
21
α
22
β
22
)＝q1＝1 y
22
。如果r6在状态q1下故障，所有在r6上的p3工件 都无法完成加工。因此，在r3上的已完成的工件直到r6被修复才能完成其装配操作。在 这种情况下，p1类工件虽然不请求不可靠资源但是因为它们请求的资源r3被占用且在r6修复前都不能被释放，故p1类工件不能持续加工。如果事件序列α
21
β
21
α
22
β
22
不允许发生， p2类和p3类工件永远不能被持续加工。因此，特性2)不能被满足。因此，对于这类系 统，特性1)和特性2)不能同时被满足；
[0263]
由例1可知，特性1)的违背是由于资源r3造成的。本文称r3为虚拟不可靠资源，其具体定义如下；
[0264]
定义5：给定操作p
jk
，令θ(p
jk
)表示在p
jk
前面的包含虚拟操作的操作的集合，θ(p
jk
) ＝θ(p
jk
)∪{p
jk
}。资源ri∈r是虚拟不可靠资源如果且且且
[0265]
如图2所示，例2：考虑自动制造系统s，假设r＝{r1,r2,
…
,r5}，p＝{p1,p2,
…
, p5},l1＝l2＝l3＝l4＝2，l5＝1。p1的操作为p
11
,p
12
,p
13
，p2的操作为p
21
,p
22
,p
23
(p
13
)， p3的操作为p
31
,p
32
,p
33
，p4的操作为p
41
,p
42
,p
43
(p
33
)，p5的操作为p
51
。注意到，p
13
和 p
23
，p
33
和p
43
是相同的操作。ρ(p
11
)＝r2,ρ(p
12
)＝r3,ρ(p
21
)＝r1,ρ(p
22
)＝r3,ρ(p
31
)＝r2, ρ(p
32
)＝r5,ρ(p
41
)＝r4,ρ(p
42
)＝r5,ρ(p
51
)＝r4.ψ1＝ψ2＝ψ3＝ψ4＝ψ5＝1。假设r1是不可靠资源。π(p
12
)＝{p
11
,p
21
},π(p
32
)＝{p
31
,p
41
},πa＝{p
11
,p
21
,p
31
,p
41
},θ(p
12
)＝{p
1b
,p
11
, p
12
,p
21
},θ(p
32
)＝{p
3b
,p
31
,p
32
,p
41
}。因为且所
以r2是虚拟不可靠资源。考虑系统的可达状态q＝1 x
11 x
41
，如图2所示。如果r1在q故障，p5类工件虽然不请求不可靠资源但是因为它们请求的资源r4被占用且在r1修复前都不能被释放，故p5类工件不能持续加工。这表明虚拟不可靠资源r2也可能阻塞不请求不可靠的工件的加工。因此，需要定义可能被虚拟不可靠资源阻塞的资源；
[0266]
定义6：资源ri∈r是二阶虚拟不可靠资源如果且且且是一个虚拟不可靠资源；
[0267]
以图2中的自动制造系统为例，因为且是虚拟不可靠资源，r4是二阶不可靠资源。注意到定义2 可以扩展到三阶虚拟不可靠资源，依次类推。为了节省空间，沈略了这样的扩展。为了简便起见，虚拟不可靠资源、二阶虚拟不可靠资源、三阶虚拟不可靠资源等等统称为虚拟不可靠资源。给定自动制造系统s，令λ(s)表示系统中虚拟不可靠资源的集合，γ(s)＝λ(s)∪{ru}；
[0268]
引理4：p
jk
和p
j(k c)
表示pj的两个阶段，其中c∈z

。如果p
jk
∈πa，p
j(k c)
∈πa，且ρ(p
jk
)∈γ(s)，那么ρ(p
j(k c)
)∈γ(s)；
[0269]
证明：因为p
j(k c)
∈πa并且所以所以ρ(p
st
)∈γ(s)。因为p
j(k c)
∈πa，且且所以ρ(p
j(k c)
)∈γ(s)；
[0270]
定义7：是如果系统中所有不请求ru∪γ(s)的工件都能在某个状态下连续加工，那么陈该状态为s的合适状态(feasible state，以下简称fs)。如果1)当λ＝1时，所有工件都能持续加工；2)如果κ∈ξ(q)，那么δ(q,κ)是fs；3)当λ＝ 0时，所有不请求的工件的能够连续加工；4)如果η∈ξ(q)，那么δ(q, η)是fs则称控制策略
△
对于s是鲁棒的；
[0271]
步骤3：鲁棒控制策略；
[0272]
为了提出一个满足定义3中特性的死锁避免策略，本发明提出了两个控制策略。它们都基于改机银行家算法。尽管它们都不满足定义3中的特性，但是它们的组合是一个鲁棒监督控制策略；
[0273]
这两种策略都试图找到一个事件序列，引发此序列能够使得系统中的工件移动到对应的合适位置。由于装配操作的存在，将某些工件移动到合适的位置可能请求一些未被加工的工件。为了计算请求的未被加工的工件的数量，本发明首先提出了一个用于该计算的算法cnr(compute the number of required raw parts)。接着，第一改进银行家算法(mba1)、第二个改进银行家算法(mba2)和鲁棒监督控制策略被依次提出；
[0274]
步骤3.1：分枝策略cnr算法
[0275]
cnr算法的输入包括状态q，考虑的工件所在的阶段集合d1，这些阶段的工件的数量集合d2，这些工件的目标位置集合d3，以及研究的系统s。给定操作阶段p
jk
，令表示其剩余的操作的集合；
[0276]
一个工件可能有多个装配阶段。有些装配阶段可能依赖于其它装配阶段以完成其
装配操作。不同的装配阶段的分类如下；
[0277]
定义8：令p
je
为系统的一个虚拟的结束阶段，pa(p
je
)＝θ(p
je
)∩pa为在p
je
前面的所有装配阶段的集合。一个装配操作p
jk
∈pa(p
je
)如果满足则称其为一阶装配操作。令p
a1
(p
je
)表示在pa(p
je
)中的一阶装配操作的集合。一个装配操作p
jk
∈ {pa(p
je
)\p
a1
(p
je
)}如果满足则称其为二阶装配操作。令 p
a2
(p
je
)表示在pa(p
je
)中的二阶装配操作的集合。正式地，一个装配操作p
jk
∈ {pa(p
je
)\p
a1
(p
je
)\p
a2
(p
je
)\...\p
av
(p
je
)}如果满足)}如果满足则称其为(v 1)阶装配操作。假设最大的装配阶段为c
max
。令p
a1
＝{p
a1
(p
je
):j＝1,2,
…
, n},
[0278]
装配阶段分类的例子如下；
[0279]
例3：考虑自动制造系统s，假设r＝{r1,r2,
…
,r6},p＝{p1,p2,
…
,p4},l1＝l2＝l3＝l4＝3。p1的操作为p
11
,p
12
,p
13
，p2的操作为p
21
,p
22
(p
12
),p
23
(p
13
)，p3的操作为p
31
, p
32
,p
33
(p
13
)，p4的操作为p
41
,p
42
(p
32
),p
43
(p
13
)。ρ(p
11
)＝r1,ρ(p
12
)＝r3,ρ(p
13
)＝r6,ρ(p
21
) ＝r2,ρ(p
31
)＝r2,ρ(p
32
)＝r5,ρ(p
41
)＝r4.ψ1＝ψ2＝ψ3＝ψ4＝ψ5＝ψ6＝4。假设r6是不可靠资源。系统的概览图如图3。pa＝{p
12
,p
32
,p
13
}。pa(p
1e
)＝θ(p
1e
)∩pa＝{p
11
,p
12
,p
13
}∩pa＝{p
12
,p
13
}。因为p
12
∈p
a1
(p
1e
)。因为θ(p
13
)∩pa＝{p
11
,p
12
}∩{p
12
,p
32
,p
13
}＝p
12
,因此，p
a1
(p
1e
)＝{p
12
}。因为，因为，p
a2
(p
1e
)＝{p
13
}。因为}。因为所以p
32
∈p
a1
(p
3e
)。因为所以p
a1
(p
3e
)＝{p
32
}。类似地，可以得到p
a1
(p
2e
)＝{p
12
},p
a1
(p
4e
)＝{p
32
},p
a2
(p
2e
)＝p
a2
(p
3e
)＝p
a2
(p
4e
)＝{p
13
}。因此，p
a1
＝p
a1
(p
1e
)∪p
a1
(p
2e
)∪p
a1
(p
3e
)∪p
a1
(p
4e
)＝{p
12
,p
32
}，p
a2
＝p
a2
(p
1e
)∪p
a2
(p
2e
) ∪p
a2
(p
3e
)∪p
a2
(p
4e
)＝{p
13
}；
[0280]
一个用于阐明如何计算需要的未加工的工件的数量的例子如下；
[0281]
例4：考虑图3中的自动制造系统。假设系统的当前状态为q＝1 x
11
x
12
x
31
, d1＝{p
11
,p
12
,p
31
},d2＝{1,1,1},d3＝{p
13
,p
13
,p
13
}。初始时，φ[1]＝φ[2]＝φ[3]＝φ[4] ＝0；
[0282]
给定p
12
∈p
a1
,π(p
12
)＝{p
11
,p
21
},d1[1]＝p
11
∈π(p
12
),令z＝max{q(x
11
) q(y
11
), q(x
21
) q(y
21
)}＝1。)}＝1。那么，φ[1]＝0 1
–
1＝0, φ[2]＝0 1
–
0＝1。设置q(x
21
)＝1，得到q＝1 x
11
x
12
x
21
x
31
。装配在阶段p
11
和 p
21
的工件1次，得到q＝1 2x
12
x
31
。由于没有工件在阶段p
32
上，所以装配得到的在阶段p
12
上的工件不能被移动到p
13
上。因为p
12
∈γ
12
且p
12
∈πa，装配得到的在阶段p
12
上的工件暂时没有被移动。令d1[1]＝p
12
；
[0283]
给定p
32
∈p
a1
,π(p
32
)＝{p
31
,p
41
},d1[3]＝p
31
∈π(p
32
)},令z＝max{q(x
31
) q(y
31
), q(x
41
) q(y
41
)}＝1。)}＝1。那么，φ[3]＝0 1
–
1 ＝0，φ[4]＝0 1
–
0＝1。设置q(x
41
)＝1，得到q＝1 2x
12
x
31
x
41
。装配在阶段p
31
和p
41
的工件1
次，得到q＝1 2x
12
x
32
。因为d3[3]＝p
13
，所以装配得到的在阶段 p
32
上的工件应该被移动到p
13
。将一个工件从p
32
移动到p
13
，将一个工件从p
12
移动到p
13
，得到q＝1 x
12
x
13
。设置d1[3]＝p
13
，d1[1]＝p
13
；
[0284]
给定p
13
∈p
a2
,π(p
13
)＝{p
12
,p
32
},d1[2]＝p
12
∈{p
12
,p
32
},令z＝max{q(x
12
) q(y
12
), q(x
32
) q(y
32
)}＝1。)}＝1。那么，φ[1]＝0 1
–
1＝0，φ[2]＝1 1
–
1＝1。1＝1。那么，φ[3]＝0 1
–
0＝1,φ[4]＝ 1 1
–
0＝2。设置q(x
32
)＝1，得到q＝1 x
12
x
32
y
13
。装配在阶段p
12
和p
32
的工件 1次，得到q＝1 2x
13
。因为d3[2]＝p
13
，所以装配得到的在阶段p
13
上的工件应该被移动到p
13
。设置d1[2]＝p
13
。因为所有在p
a2
中的工件都被处理完成，所以最后得到φ[1]＝0,φ[2]＝1,φ[3]＝1,φ[4]＝2；
[0285]
定理1：给定q∈qr(q0)，d1，d2，d3，s，令φ
min
表示将所有在d1阶段上的工件移动到d3的目标阶段上需要的未加工的工件的最小数量。那么，φ＝cnr(q,d1,d2, d3,s)＝φ
min
。
[0286]
证明：下面用数学归纳法证明当c
max
为任意自然数时，都有φ＝φ
min
。
[0287]
当c
max
＝0时，系统中不存在装配操作。所有在d1中阶段上的工件都能被移动到对应的d3阶段上而不需要任何未加工的工件。因此，φ[i]＝φ
min
[i] ＝0。
[0288]
当c
max
＝1时，执行完步骤3.1.1～步骤3.1.9.3后，系统中剩余的工件都在上π(p
jk
)，其中p
jk
∈p
a1
。为了把所有在阶段p
vw
∈π(p
jk
)的工件移动到目标位置上，p
jk
必须要经过。因此，对于阶段p
vw
∈π(p
jk
)，至少需要有z＝max{q(x
vw
) q(y
vw
):p
vw
∈π(p
jk
)}个工件。因为没有在{θ(p
vw
)\p
vb
}上的工件，故缺少的工件智能来着于开始位置的未加工工件。因此，φ[i]＝φ
min
[i]。
[0289]
假设当c
max
＝h∈z

时，φ[i]＝φ
min
[i]。下面证明当c
max
＝h 1 时，φ[i]＝φ
min
[i]。注意到，cnr从低阶装配操作到高阶装配操作的计算未加工的工件的数量。由装配操作得到的工件要么被移动到目标位置，要么被移动到下一个装配阶段。也就是说，在cnr为p
jk
∈p
a(h 1)
计算需要的未加工工件前，所有系统中的工件在π(p
jk
)上。为了把所有在阶段p
vw
∈π(p
jk
)的工件移动到目标位置上，p
jk
必须要经过。因此，对于阶段p
vw
∈π(p
jk
)，至少需要有z＝max{q(x
vw
) q(y
vw
): p
vw
∈π(p
jk
)}个工件。因为都不存在在{θ(p
vw
)\p
vb
}上的工件，故缺少的工件智能来着于开始位置的未加工工件。因此，cnr为p
a(h 1)
计算的需要的未加工的工件数量是最小的。由假设可知，cnr为p
ai
计算的需要的未加工的工件数量是最小的。因此当c
max
＝h 1时，φ[i]＝φ
min
[i]成立。
[0290]
步骤3.2：第一个改进银行家算法
[0291]
下面给出第一个改进银行家算法(mba1)。令p表示系统中所有操作的集合，即给定p
jk
∈p，令
表示p
jk
的剩余路径的。令表示未来不请求γ(s)中资源的操作位置的集合。令且表示未来请求γ(s)中资源但是不在γ(s)资源上的操作位置的集合。令p3＝{p
jk
:ρ(p
jk
)∈γ(s)}表示在γ(s)资源上的操作位置的集合。令p4＝{p
ib
|i∈{1,2,
…
,n}}。
[0292]
mba1包含两个部分，即和试图将在阶段p1∪p2上的工件移动到目标阶段，试图将在阶段p
jk
∈p1∪p2∪p4上的工件移动到ρ(p
j(k v)
)上，其中 v∈z

，ρ(p
j(k v)
)∈γ
jk
，p
j(k v)
∈πa，
[0293]
定理2：具有多项式时间复杂度。
[0294]
证明：步骤3.2.2循环每次至少将一个在阶段p1(q)∪p2(q)上的工件移动到目标阶段。每个工件至少占用一个资源，因此|p1(q)∪p2(q)|≤ψ
sum
＝σ
i∈{1,2,
…
,m}
ψi。因此，步骤3.2.2循环至多执行ψ
sum
次。在每次步骤3.2.2循环中，步骤3.2.2.2和步骤3.2.2.3的循环各执行一次。因为从p
jk
到p
je
的阶段数不超过l
max
＝max{lj|j∈{1,2,
…
,n}}，所以将一个工件移出系统的复杂度不高于l
max
。因此，步骤3.2.2.2的循环的复杂度为 o(|p1(q)|
×
l
max
)。因为c∈{1,2,
…
,l
j-k}≤l
max
，步骤3.2.2.3.1.1或步骤3.2.2.3.1.2的复杂度不超过l
max
。因此，步骤3.2.2.3的循环的复杂度为o(|p2(q)|
×
l
max
)。因为|p2(q)| |p1(q)|≤ψ
sum
，所以的复杂度为o(ψ
sum
×
(|p1(q)| |p2(q)|)
×
l
max
)＝o(ψ
sum2
×ꢀ
l
max
)。
[0295]
定理3：具有多项式时间复杂度。
[0296]
证明：因为c∈{1,2,
…
,lj}≤l
max
，步骤3.2.5.1.1，步骤3.2.5.1.2，步骤3.2.6.1.1.1 的复杂度不超过l
max
。因此，步骤3.2.5的循环的复杂度为o(|p1∪p2|
×
l
max
)，步骤3.2.6.1 的循环的复杂度为o(|p4|
×
l
max
)。因为|p1∪p2|≤l且|p4|＝n，所以的复杂度为 o((l n)
×
l
max
)。
[0297]
定理4：mba1具有多项式时间复杂度。
[0298]
证明：步骤3.2.9的循环的复杂度为o(|p1|)。因为c∈{1,2,
…
,l
j-k}≤l
max
，所以 11行的复杂度不超过l
max
。因此，步骤3.2.10的循环的复杂度为o(|p2|
×
l
max
)。因为一个工件占用一个缓冲空间，所以系统中的工件数量不超过ψ
sum
＝σ
i∈{1,2,m}
ψi。每个工件最多需要n个未加工的工件来完成装配操作。因此，φ[1] φ[2]
…
φ[n]≤n
×
ψ
sum
。步骤3.2.13循环每次由至少将一个在阶段p
jk
∈p1(q)∪p2(q)∪p4(q)上的工件移动到ρ(p
j(k v)
)，其中v∈z

，ρ(p
j(k v)
)∈γ
jk
，p
j(k v)
∈πa，因为从p
jb
到p
je
的阶段数不超过l
max
，步骤3.2.13循环最多执行(n 1)
×
ψ
sum
×
l
max
次。因此，mba1的复杂度为o(|p1|) o(|p2|
×
l
max
) o(m l3×
(l ψ
max
)) o((n 1)
×
ψ
sum
×
l
max
×
(((l n)
×
l
max
) ψ
sum2
×
l
max
)) o(|p1| |p2|)。因为|p1|≤l,|p2|≤l,ψ
max
≤ψ
sum
,m≤ψ
sum and n≤l,o(mba1)＝o(l3×
(l ψ
max
) n
×
ψ
sum
×
l
max2
×
(l ψ
sum2
))＝ o(l3×
(l ψ
max
) l3×
ψ
sum
×
(l ψ
sum2
))＝o(l3×
ψ
sum
×
(l ψ
sum2
))。
[0299]
步骤3.3：第二个改进银行家算法
[0300]
下面给出第二个改进银行家算法(mba2)。mba2在假设λ＝1的情况下，试图将执行mba1后系统中剩下的工件全部移出系统。由于系统中存在装配操作，将系统中剩余的工件
移出系统可能需要未被加工的工件。需要的工件的数量由cnr计算。
[0301]
mba2包含两个部分，分别是和试图将在阶段p1∪p2∪p3∪p4上的工件移出系统，试图将一个在阶段p
jk
∈p1∪p2∪p3∪p4上的工件移动到ρ(p
j(k v)
)，其中v∈{1,2,
…
,l
j-k}，ρ(p
j(k v)
)∈γ
jk
,p
j(k v)
∈πa，，
[0302]
定理5：具有多项式时间复杂度。
[0303]
证明：步骤3.3.2循环每次将一个在阶段p1(q)∪p2(q)∪p3(q)∪p4(q)上的工件移出系统。因为一个工件占用一个缓冲空间，所以|p1(q)∪p2(q)∪p3(q)|≤ψ
sum
。每个工件最多需要n个未加工的工件来完成装配操作。因此，在阶段p4(q)上的工件数量不超过(n
ꢀ×
ψ
sum)
。因此，步骤3.3.2循环最多执行((n 1)
×
ψ
sum
)次。因为从p
jk
到p
je
的阶段数不超过l
max
＝max{lj|j∈{1,2,
…
,n}}，将一个在阶段p
jk
上的工件移出系统的复杂度不超过l
max
。因此，3-11行的for循环的复杂度为o((n 1)
×
ψ
sum
×
l
max
)。因此，的复杂度为o((n 1)2×
ψ
sum2
×
l
max
)＝o(n2×
ψ
sum2
×
l
max
)。
[0304]
处理的阶段p1∪p2∪p3∪p4上的工件，而处理的阶段p1∪p2∪p4上的工件，除此之外，与的作用是一样。通过将中的步骤3.2.5“如果存在p
jk
∈p1∪p
2”替换为“如果存在p
jk
∈p1∪p2∪p
3”，即可得到为了节省空间，省略了
[0305]
定理6：具有多项式时间复杂度。
[0306]
证明：因为|p1∪p2∪p3|≤l，由定理4可知，的复杂度与相同，即即
[0307]
定理7：mba2具有多项式时间复杂度。
[0308]
证明：步骤3.3.5的for循环的复杂度为o(|p1∪p2∪p3|)。因为一个工件占用一个缓冲空间，所以系统中的工件数量不超过ψ
sum
＝σ
i∈{1,2,m}
ψi。每个工件最多需要n个未加工的工件来完成装配操作。因此，φ[1] φ[2]
…
φ[n]≤n
×
ψ
sum
。
[0309]
步骤3.3.8的循环每次由至少将一个在阶段p
jk
∈p1(q)∪p2(q)∪p3(q)∪p4(q) 上的工件移动到ρ(p
j(k v)
)，其中v∈{1,2,
…
,l
j-k}，ρ(p
j(k v)
)∈γ
jk
，p
j(k v)
∈πa，，因为从p
jb
到p
je
的阶段数不超过l
max
，步骤3.3.8的循环最多执行(n 1)
×
ψ
sum
×
l
max
次。步骤3.3.8的循环的复杂度为o((n 1)
×
ψ
sum
×
l
max
×
(n2×
ψ
sum2
×
l
max
(l n)
×
l
max
))＝o(n
×
ψ
sum
×
l
max2
×
(n2×
ψ
sum2
l))。步骤3.3.9的循环的复杂度为o(|p1∪p2∪p3|)。因为|p1∪p2∪p3|≤l，ψ
max
≤ψ
sum
,m≤ψ
sum
，n≤l,所以 o(mba2)＝o(|p1∪p2∪p3|) o(m l3×
(l ψ
max
)) o(n
×
ψ
sum
×
l
max2
×
(n2×
ψ
sum2
l)) o(|p1∪p2∪p3|)＝o(l3×
(l ψ
sum
)) o(ψ
sum
×
l3×
(l2×
ψ
sum2
l))＝o(l5×
ψ
sum3
)。
[0310]
步骤3.4：系统的鲁棒监督控制策略
[0311]
本文提出的鲁棒监督控制策略为
△
lzz
:q
×
∑
→
{0,1}，其具体定义如下。令q∈qr(q0) 为系统的状态π∈ξ(q)为状态q下的使能事件，如果π∈∑u，那么
△
lzz
(q,π)＝1；否则，令q1＝δ(q,π)，当且仅当mba1(q1)＝(true,q2)且mba2(q2)＝true时，
△
lzz
(q,π)＝1。
[0312]
下面证明
△
lxw
满足定义3中的特性。
[0313]
引理5：且q(λ)＝1，假设σ∈{∑c∪∑
u1
}*为mba1在q找到的事件序列，那么从q执行σ不会违背mba2。
[0314]
证明：给定i∈{1,2,
…
,|σ|}，令σ
[i]
表示由σ前i个事件组成的事件序列。假设表示由σ前i个事件组成的事件序列。假设且(true,q2)＝mba1(q1)。令π表示第(i 1)个事件，q3＝δ(q1,π)。然而，如果在状态q1发生π，mba2(q4)＝false，其中q4是mba1在q3得到的状态。如果π＝β
jk
∈∑
u1
，那么
△
lzz
(q1,π)＝1。因此，令π＝α
j(k 1)
∈∑c，p
jk
为在阶段p
jk
上的被移动的工件。考虑以下三种情形。
[0315]
情形1：p
jk
∈p1。mba1将p
jk
移出系统。因为所以且p
j(k 1)
∈p1。因此，mba1将p
j(k 1)
移出系统。因此，q2＝q4，mba2(q4)＝mba2(q2)＝ true。
[0316]
情形2：p
jk
∈p2。mba1将p
jk
移动到ρ(p
j(k v)
)，其中v∈{1,2,
…
,l
j-k},ρ(p
j(k v)
)∈γ
jk
,ρ(p
j(k v)
)∈γ(s),因为且且所以如果v＝1，那么p
j(k 1)
∈p3，故mba1将p
j(k 1)
保留在ρ(p
j(k 1)
)中。如果v》1，那么且p
j(k 1)
∈p2。mba1将p
j(k 1)
移动到ρ(p
j(k v)
)。因此，q2＝q4且mba2(q4)＝mba2(q2)＝true。
[0317]
情形3：p
jk
∈p3。mba1不会移动p
jk
，故α
j(k 1)
不会出现在σ中。
[0318]
因此，q执行σ不会违背mba2。
[0319]
引理6：且q(λ)＝1，假设mba1(q)＝(true,q1)，σ∈{∑c∪∑
u1
}* 为mba2在q1找到的事件序列，那么从q1执行σ不会违背mba1。
[0320]
证明：给定i∈{1,2,
…
,|σ|}，令σ
[i]
表示由σ前i个事件组成的事件序列。假设假设令mba1(q2)＝(true,q3)。令π表示第(i 1)个事件，q4＝δ(q2,π)。然而，如果在状态q2发生π，mba1(q4)＝(false,q5)，其中q5为mba1在q4得到的状态。如果π＝β
jk
∈∑
u1
，那么
△
lzz
(q1,π)＝1。因此，令π＝α
j(k 1)
∈∑c，p
jk
为在阶段p
jk
上的被移动的工件，p
j(k 1)
为该工件在阶段p
j(k 1)
上。考虑以下三种情形。
[0321]
情形1：p
j(k 1)
∈p1。mba1将p
j(k 1)
移出系统。因为q∈qr(q0,
△
lzz
)，mba2能够将p
j(k 1)
移出系统。因此，mba1不会阻碍在状态q2下发生事件π。
[0322]
情形2：p
j(k 1)
∈p2。mba2要么将p
j(k 1)
移出系统，要么将它移动到ρ(p
j(k v)
)，其中 v∈z

,ρ(p
j(k v)
)∈γ
jk
,p
j(k v)
∈πa,mba1将p
j(k 1)
移动到ρ(p
j(k z)
)，其中z∈{2,
…
,l
j-k},ρ(p
j(k z)
)∈γ
jk
,ρ(p
j(k z)
)∈γ(s),)∈γ(s),
[0323]
如果且p
jw
∈πa，那么由1可知ρ(p
j(k v)
)∈γ(s)。在这种情况下，v≥z。因为将p
j(k 1)
移动到ρ(p
j(k v)
)或者移出系统都能完成，所以将p
j(k 1)
移动到ρ(p
j(k z)
)可以完成。
[0324]
如果不存在且p
jw
∈πa，那么那么否则在mba1前p
jk
将会被移出系统。因为ρ(p
jw
)＝ru，由定义1和定义2 可知，ρ(p
j(k v)
)∈γ(s)。在这种情况下，v≥z。因为将p
j(k 1)
移动到ρ(p
j(k v)
)或者移出系统都能完
成，所以将p
j(k 1)
移动到ρ(p
j(k z)
)可以完成。
[0325]
情形3：p
j(k 1)
∈p3。mba1不会移动p
j(k 1)
。
[0326]
因此，从q1执行σ不会违背mba1。
[0327]
定理8：且q(λ)＝1,δ(q, σ
[i]
)∈qr(q0,
△
lzz
),且q0＝δ(q,σ)。
[0328]
证明：注意到当mba1(q)＝(true,q1)且mba2(q1)＝true时，
△
lzz
才会接收状态q。 mba1(q)＝(true,q1)意味着所有在阶段p
jk
∈p1(q)上工件能够移出系统；所有在p
jk
∈ p2(q)上的工件能够移动到ρ(p
j(k v)
)，其中v∈{1,
…
,l
j-k},ρ(p
j(k v)
)∈γ
jk
,ρ(p
j(k v)
)∈γ(s), 也就是说，mba2(q1) ＝true意味着如果λ＝1，那么在状态q1系统中的工件都能被移出系统，也就是说因此，下面只需要证明δ(q,σ1σ
2[i]
)∈qr(q0,
△
lzz
)。由引理2可知，从q执行σ1不会违背mba2，故δ(q,σ
1[i]
)∈qr(q0,
△
lzz
)。由引理3可知，从q1执行σ2不会违背mba1。因此，δ(q1,σ
2[i]
)∈qr(q0,
△
lzz
)。
[0329]
定理9：如果κ∈ξ(q)，那么q1＝δ(q,κ)是一个fs。
[0330]
证明：因为q∈qr(q0,
△
lzz
)，所以mba1(q)＝(true,q1)。也就是说，所有在阶段p
jk
∈p1(q)上工件能够移出系统；所有在p
jk
∈p2(q)上的工件能够移动到ρ(p
j(k v)
)，其中v ∈{1,
…
,l
j-k},ρ(p
j(k v)
)∈γ
jk
,ρ(p
j(k v)
)∈γ(s),令σ表示由mba1在状态q找到的事件序列且δ(q,σ)＝q2。
[0331]
如果p
jk
∈p1(q)，那么如果p
jk
∈p2(q)，那么其中v∈z

,ρ(p
j(k v)
)∈γ
jk
,ρ(p
j(k v)
)∈γ(s)。因此，mba1找到的事件序列不包含在ru上的完成事件。因此，σ是从q1可执行的。令δ(q1,σ)＝q2。那么，在状态q2下ri上没有工件。因此，从状态q2开始系统能够持续加工不请求γ(s)中资源的工件。
[0332]
推论2：且λ＝0，所有不请求γ(s)中资源的工件都能够从q持续加工。
[0333]
定理10：如果η∈ξ(q)，那么q1＝δ(q,η)是fs。
[0334]
证明：因为q∈qr(q0,
△
lzz
)，所以存在从q可执行的事件序列σ使得所有在阶段p
jk
∈p1(q)上工件能够移出系统；所有在p
jk
∈p2(q)上的工件能够移动到ρ(p
j(k v)
)，其中v ∈{1,
…
,l
j-k},ρ(p
j(k v)
)∈γ
jk
,ρ(p
j(k v)
)∈γ(s),由定理9可知，σ也是从q1可执行。令δ(q1,σ)＝q2∈qr(q0,
△
lzz
)。由定理8可知，)。由定理8可知，δ(q,σ
[i]
)∈qr(q0,
△
lzz
),q0＝δ(q2,σ)。
[0335]
定理6-2：
△
lzz
是系统的鲁棒监督控制策略。
[0336]
证明：由定理8可知，
△
lzz
满足定义3中的特性1。由定理9可知，
△
lzz
满足定义3中的
特性2。由推论1可知，
△
lzz
满足定义3中的特性3。由定理10可知，
△
lzz
满足定义3中的特性4。
[0337]
对比研究
[0338]
针对含有不可靠资源的自动制造系统，文献中提出了许多控制策略c
2006
(chewsf,lawley ma.robust supervisory control for production systems with multiple resourcefailures[j].ieee transactions on automation science and engineering,2006,3(3):309
‑ꢀ
323.)，c
2009
(chew sf,wang sy,lawley ma.robust supervisory control for productroutings with multiple unreliable resources[j].ieee transactions on automation science andengineering,2009,6(1):195-200.)，c
2011
(chew sf,wang s,lawley ma.resource failureand blockage control for production systems[j].international journal of computer integratedmanufacturing,2011,24(3):229-241.)，d
2019
(du n,hu hs.robust deadlock avoidancecontrol for amss with assembly operations embedded in flexible routes using petri nets[j]. iet control theory application,2019,13(11):1579-1590.)，l1
2002
(lawley ma.controlof deadlock and blocking for production systems with unreliable workstations[j]. international journal of production research,2002,40(17):4563-4582.)，l2
2002
(lawleyma,sulistyono w.robust supervisory control policies for manufacturing systems withunreliable resources[j].ieee transactions on robotics and automation,2002,18(3):346
‑ꢀ
359.)，l
2013
(liu gy,li zw,barkaoui k,et al.robustness of deadlock control for a classof petri nets with unreliable resources.information sciences,2013,235(6):259-279.)，l
2017 (luo jc,xing ky,wu yc.robust supervisory control policy for automated manufacturingsystems with a single unreliable resource.transactions of the institute of measurement andcontrol,2017,39(6):793-806.)，l
2019
(luo jc,liu zq,zhou mc,et al.robust deadlockcontrol of automated manufacturing systems with multiple unreliable resources.informationsciences,2019,479:401-415.)，w
2016
(wang f,xing ky,zhou mc,et al.a robust deadlockprevention control for automated manufacturing systems with unreliable resources. information sciences,2016,345:243-256.)，w
2008
(wang sy,chew sf,lawley ma. using shared-resource capacity for robust control of failure-prone manufacturing systems[j]. ieee transactions on systems,man and cybernetics,part a:systems and humans,2008, 38(3):605-627.)，w
2016
(wu yc,xing ky,luo jc,et al.robust deadlock control forautomated manufacturing systems with an unreliable resource.information sciences,2016, 346:17-28.)，y1
2014
(yue h,xing ky.robust supervisory control for avoiding deadlocksin automated manufacturing systems with one specified unreliable resource[j].transactionsof the institute of measurement and control,2014,36:435-444.)，y2
2014
(yue h,xingk,hu z.robust supervisory control policy for avoiding deadlock in automatedmanufacturing systems with unreliable resources[j].international journal of productionresearch,2013,52(6):1573-1591.)，y
2018
(yue h,xing ky,hu hs,et al.resource
failure and buffer space allocation control for automated manufacturing systems.informationsciences,2018,450:392-408.)。它们与本文的控制策略的对比见表1。
[0339]
表1与现有控制策略的对比
[0340][0341][0342]
由表1可知，在所有针对含有不可靠资源的自动制造系统的控制策略中，仅有 d
2019
，d
2020
，和
△
lzz
能够处理含有装配操作的自动制造系统。然而，d
2019
和d
2020
的控制目标均为确保不请求故障资源的工件持续加工。由例2可知，这样的目标对于含有不可靠和装配操作的系统来讲是不可能实现的。因此，仅有
△
lzz
能够处理含有不可靠资源和装配操作的自动制造系统并且满足定义3中的特性。
[0343]
本发明的创新点在于：
[0344]
(1)首次提出了含有不可靠资源的柔性装配操作系统的鲁棒监控策略需要满足的四条特性；(2)提出了2个改进银行家算法，并证明了它们的结合是唯一一个能够满足提出的四条特性的鲁棒监督控制策略。
[0345]
总之，本发明具有如下优点：
[0346]
(1)首次提出了含有不可靠资源的柔性装配操作系统的鲁棒监控策略需要满足的四条特性；
[0347]
(2)提出了2个改进银行家算法，并证明了它们的结合是唯一一个能够满足提出的四条特性的鲁棒监督控制策略；
[0348]
(3)提出的鲁棒监督控制策略被证明是多项式时间复杂度的，故可以广泛应用于大规模的柔性制造系统；。