1

智能 RGV 动态调度决策模型

摘要

本文针对“智能 RGV 的动态调度”决策模型，通过建立规划模型，FIFO 算

法分析，贪心算法分析，遗传算法优化，蒙特卡洛模拟的方法，探究不同参数下

的智能 RGV 动态调度决策策略，并使用题目中给定的参数进行了模拟以及检验。

针对情形一，本文首先通过讨论“先需求先服务”准则，确定一组解。然后

通过贪心算法的思想，使用“就近原则”作为贪心准则，讨论了两种不同的移动

方式所造成的对指令的不同判断模式，并分别计算出再每一个阶段都是局部最优

解的工作序列。接下来通过给出带有判断条件规划模型，提出一系列的约束条件

对调度的规则进行描述，并结合进制编码的方式，来描述整个生产过程的展开。

在得到局部最优解后通过遗传算法逼近全局最优解，逐步收敛到一个更加接近全

局最优解的结果。 针对情形二，面对未知的 CNC 刀具的配比以及位置分布，我们首先通过第

一道工序以及第二道工序的生产效率的比值来解决 CNC 刀具分配的数量问题。

然后基于 CNC 分布的对称性以及第一问中得到的结果中所体现的移动的周期性，

结合每个周期运动的方向性与趋势，来减少位置分布的讨论情况。然后针对不同

的分布情况，使用贪心算法生成满足每一阶段局部最优的初始序列，然后通过遗

传算法从局部最优解逼近全局最优解。对比每一种数量以及分布方式的最优策略

以及效率，得出最优的数量分布，最优的刀具分配以及最优的方案。 针对情形三，考虑到不同故障位置对于整个系统的工作效率的影响不同，并

且故障的情况是以概率的情形给出的，不具有准确预测的特点。针对概率以及无

法准确预测的特点，我们决定采用蒙特卡洛模拟的方法来进行仿真以及探索。对

于一道工序的情形，所以我们采用蒙特卡洛模拟的方法多次对故障情形下的工作

状态进行模拟，选择多次模拟中较优的工作模式；对于两道工序的情况，首先通

过效率对比确定机器数量对比，通过 CNC 布局的对称性来缩小可能的分布范围，

对于不同分配方式分别进行蒙特卡洛模拟，求得所有情况中较优的一种调度方式

以及结果。 在每种情形中，我们通过题目中所给定的三种参数进行了测试，生成每种参

数下的工作序列，并计算工作序列进行时间的计算以及效率。然后通过带入给定

的工作参数进行起始一两个阶段的分析以及推演，发现每次模拟起始时状态相同

的情况下，工作开始阶段的调度方式会逐渐确立起一个周期性的工作模式，印证

了最终结果的合理性。

关键词：RGV、调度策略、贪心算法、遗传算法、动态优化，蒙特卡洛模拟

2

一、问题重述

一个智能加工系统由 8 台计算机数控机床（Computer Number Controller，

CNC）、1 辆轨道式自动引导车（Rail Guide Vehicle，RGV）、1 条 RGV 直线轨道、

1 条上料传送带、1 条下料传送带等附属设备组成。RGV 是一种无人驾驶、能在

固定轨道上根据指令工作的自由运行的智能车。 在上料传送带和下料传送带的两侧各安装 4 台 CNC，等距分配，每台 CNC

同一时间只能安装 1 种刀具加工 1 个物料。如果物料的加工过程需要两道工序，

则需要有不同的 CNC 安装不同的刀具分别加工完成，在加工过程中不能更换刀

具。第一和第二道工序需要在不同的 CNC 上依次加工完成，完成时间也不同，

每台 CNC 只能完成其中的一道工序。

RGV 带有智能控制功能，能够接收和发送指令信号。系统的作业流程满足

一定的规则。如 RGV 在完成一项作业任务后，立即判别执行下一个作业指令。

此时，如果没有接到其他的作业指令，则 RGV 就在原地等待直到下一个作业指

令。 RGV 可以按照预先设计好的行动以及工作路线进行工作，也可以设置某种

判断准则实时的对需求集合进行优劣分析，做出较优的判断。 本文将研究下列四种情况： （1）每台 CNC 安装同样的刀具，物料可以在任一台 CNC 上加工整个流程

（2）每个物料需要在两台不同的 CNC 上进行两个阶段的加工

（3）CNC 在过程中可能因为产生故障而在进行维修前无法工作，物料可在

任一台 CNC 上加工整个流程

（4）CNC 在过程中可能因为产生故障而在进行维修前无法工作，物料需要

在两台不同的 CNC 上进行两个阶段的加工

对这四种情况下的调度模式进行设计，并且通过给定参数来对整个过程进行

仿真，并确定调度模式的效率。

二、问题分析

2.1 情况 1 的分析

在情形 1 中，由于 CNC安装同样的刀具，物料可以在任何一台 CNC上完成，

从理论上来看，只要给定了初始状态的所有参数值，该问题是存在一个最优解的，

类似于完全背包问题：有一个背包，最大载重量为 M，我们要从 n 种物品（每

种物品有其重量与价值）中选取若干件(同一种物品可以多次选取，数目不限)，

使其重量的和小于等于 M，而价值的和为最大，在本情形的场景下即为：RGV

在每个位置都有 n（可服务 8 个 CNC，n=8）种选择，我们如何规划选择的次序

3

才能使在限定时间 T 内能完成的成料最多。然而该问题在工作时间长，任务数目

多的场景下是难以快速求得最优解甚至超出了计算机的求解能力的，用通法求出

最优解几乎不可能，但是我们可以用迭代优化的方法生成一个较优的解，以上是

RGV 根据给定序列执行指令的方法。

我们也可以根据系统当前状态进行决策，首先能够想到的是两种调配方法，

其一是先需求先服务（FCFS，First Come First Serve）,即 RGV 每次都响应最早到

达的需求指令（若当前没有需求指令则提前移动到将最早发出需求指令的位置），

然后在新的位置上进行下一步的判断，该方法在任务数较小时较适用，在任务数

较大时可能会使得 RGV 进行了多余的移动而降低效率；其二是就“近”服务（NJA，

Nearest Job Assign），即 RGV 做用最少的时间能做完的任务。我们还可以在每一

次执行指令完毕后根据系统当前状态生成一个较短时间段内的最佳序列（递归深

度不深），在此后的几步按照该序列执行，并不断更新序列，这只能说是一个局

部最优解。此外还有就“远”服务以及规定优先级服务等。 本文采用先到先服务模型、就近服务模型、实时局部最优序列模型与遗传算

法优化模型组合来计算并优化可能的解，综合求出相对较优结果。

2.2 情况 2 的分析

为研究两道工序的物料加工作业情况，使效率达到最高，首先要研究做第一

道与做第二道工序 CNC 的个数以及两种 CNC 的位置分配，这两者互相之间是相

关的，通过分析，利用对称性和期望值等可以确定最优的两种 CNC 个数范围和

分配的形式组合，但是无法迅速锁定最佳解，故我们选择在这个范围中进行枚举，

最终确定最佳解。与情形 1 类似，本文仍采用模型组合来求出相对最佳结果，由

于贪心算法的速度较快，故我们采取就近模型来配合枚举进行 CNC 最佳分配的

搜索，此后再用组合模型多次计算比较得到相对最佳结果。

2.3 情况 3 的分析

为研究可能有 CNC 发生故障的情况，由于 CNC 的位置不同，被使用到的概

率也许会不同，发生故障的位置不同对整个系统的效率影响也不同，故障台数对

整个系统的效率也有很大的影响（例如在两道工序的情况下某一道工序的 CNC

如果都发生了故障，那么整个系统在相当长的一段时间内是无法产生成料的），

此外还有每次故障时间等因素，各种因素耦合在一起，很难用解耦的方式将它们

独立出来分析，本文拟采取蒙特卡洛方法，尽可能多次实验，在一道工序的情况

下求得组合模型中的各模型的平均效率，将平均效率最高的模型的一个结果作为

检验结果；在两道工序的情况下，求得各种 CNC 分配方式的稳定性，并将平均

效率最高的 CNC 分配方式和模型组合的一个结果作为验证结果。

如果决策序列给定了，则无法实时地依据发生故障的 CNC 位置进行更新决

策，可能会导致效率大幅度下降，灵活性不够，故针对情况三我们将不使用根据

给定序列执行指令的方法，而使用根据当前状态进行决策的方法。

4

三、模型假设

（1）在操作过程中，RGV 只有在单次操作停止后才能对指令做出判断，也

就是说认为 RGV 在运动过程中，不可改变其运动状态。

（2）不在运行的 CNC 不发生故障。

（3）CNC 发生故障的时刻为 0 到该工序总时间（s）的随机数。

（4）CNC 发生故障的时间为 6000s 到 12000s 的随机数。

（5）RGV 不会出现机械手爪抓取两个物料同时并移动的情况，否则上下料

时间会不同。 （6）单次上料所需时间，单次下料所需时间以及单次上下料所需时间不进

行区分，认为是相同的。 （7）作业指令分为需求指令、移动指令、上下料指令、清洗指令、无指令

（等待），如果没有接到其他的作业指令，则 RGV 就在原地等待直到下一个作业

指令。故我们假设 RGV 应该有绝对的控制权

四、符号说明

Pos RGV 所在的位置，取值为 1，2，3，4

C 所有 CNC 组成的集合

𝐶 第一道工序 CNC 组成的集合

𝐶 第二道工序 CNC 组成的集合

𝑁 第一道工序 CNC 的数目

𝑁 第二道工序 CNC 的数目

D 需求指令集，即对 RGV 发出需求指令的 CNC 位置集合

𝐷 可行需求集，用在两道工序情况中，与 RGV 的状态有关

S 决策序列，RGV 对 8 台 CNC 进行操作的顺序

T 智能加工系统开始运行的总时间

𝑇 RGV 移动的时间，每种移动格数对应一个取值

𝑇 CNC 接受 RGV 上下料的时间

𝑇 CNC 加工的时间

𝑇 CNC 加工第一道工序的时间

𝑇 CNC 加工第二道工序的时间

𝑇 每个 CNC 距离下次发出信号的时间（单位 s），小于等于 0 则发

出信号

𝑇 ℎ 一台 CNC 发生故障的时刻

𝑇 一台 CNC 维修所花费的时间

5

五、模型建立与检验

5.1 情况一的模型建立与检验

首先我们设计了一种方式来描述整个调动流程。很多资料中提到使用 0-1

码或者二进制码进行整个过程的描述，通过所代表位数的 0-1 状态或者二进制码

所代表的十进制数值来表明零件所生产的位置，如果需要对很长时间的过程进行

模拟，会导致数据串过于冗长，并且结果不易阅读。我们选择九进制码进行描述，

建立序列集 S,S 的每一位为范围在 1-8 之间的数字，也就是说，S具有如下的意

义：

S(i) = j 表明第i个工件在第j个 CNC 制造

我们将 RGV 的运行模式分为如下类别：

1.根据给定序列执行指令

2.根据当前状态进行决策

⎩⎪⎨

⎪⎧先需求先服务（FCFS）

就“近”服务

实时局部最优序列

规定优先级服务

我们使用根据当前状态进行决策的方法： 对先需求先服务的方法进行设计也就是说建立一个依照需求发出的先后顺

序存放需求的队列，每次所做的决策就是从队列中取出最早放入的需求指令进行

执行，当执行完毕后将这个指令移出队列。当队列空的时候则选择在原地等待。 利用贪心算法，在每次移动中选择可以在最短时间内完成的指令，使每一次

决定都是在这一步中的局部最优解。同时在移动的过程中，移动的模式都是直接

达到模式。 实时局部最优:考虑到在向较远的目标处移动的时候，可能在移动过程中有

新的指令出现使操作时间最短，所以我们在使用贪心算法时都先使移动为每次一

个步进进行移动，同时在每次移动之后重新使用贪心算法对目前的指令进行判断。 同样我们可以看到，在每次判断时，我们选择的以上三种做法所能达到的最

好效果为局部最优解，局部最优解的组合不一定为全局最优解，所以我们需要设

计某种方式进行全局最优的设计，或者通过优化逼近全局最优。我们采取了如下

的两种思考模式： 利用动态规划的方式：在这个过程中有着明显的阶段性以及状态转移特性，

我们渴望通过限制合适的约束条件来将之转化为动态规划的模型进行求解。 但是在建立动态规划模型中我们发现，这个问题不具有显著的最优子结构特

点。对于每一次移动上下料后所处的状态，我们无法简单的通过此时所经历的时

间长短作为优劣的判据，因为诸如各个工位所剩余的时间之类的参数会影响到后

面的进行，同时这个影响时难以考量的。 对某一已知的序列进行优化的方法。对于优化的过程，我们选择了遗传算法

进行优化，我们通过对先需求先服务、贪心算法以及实时局部最优三种算法所得

到的最初序列进行遗传算法优化。遗传算法的算法流程如下：

6

①生成大量的工作序列作为不同个体 ②在众多工作序列中按照时间尽可能短的原则择优挑选一定量的工作序

列作为初始种群 ③随机选择初始种群中的两个序列进行交叉操作，交叉的具体操作，随

机选择序列上的一个点进行，对这个点两端的序列进行交叉换位，生成新的

基因 ④对 3 中生成的个体，随机进行一些基因片段的变异操作

⑤不断重复 3、4 中的操作，生成大量的新的个体

⑥将 4、5 中比原种群中最差个体更优新基因加入原有种群

重复③-⑥的操作，直至种群中的最优时间趋于收敛或者生成子代数接近

预先设置的上限，结束操作。 我们对于初始种群的选择，分别使用了随机出现，基于 FCFS 原则并变异生

成，基于就近服务序列并变异进行生成，基于实时局部最优所的序列变异进行生

成的方式。

图 5.1 以随机序列为初始种群遗传算法训练过程（参数 3）

0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000

迭代次数

3.5

4

4.5

5

5.5

6

6.5

7

7.5

8

8.5104

最优个体时间

最差个体时间

7

图 5.2 以就近模型所得序列片段组成初始种群遗传算法训练过程（参数 1）

图 5.2 以就近模型所得序列片段组成初始种群遗传算法训练过程（参数 2）

时间

时间

8

图 5.2 以就近模型所得序列片段组成初始种群遗传算法训练过程（参数 3）

5.1.2 数据的代入与结果仿真

将题目中的三组参数代入进行仿真。 首先可以得到根据当前状态进行决断的策略下的结果，发现三组没有较大的

差别，于是采用事先设计好的遗传算法进行优化，最终结果仍然无法超过前两者。

0 200 400 600 800 1000 1200 1400 1600 1800 2000

迭代次数

2

3

4

5

6

7

8

9104

就近算法结果

遗传算法最优解

9

表 5.1 结果比较表

三组的仿真结果都是按照 1-2-3-4-5-6-7-8 的方式进行循环，这个结果看

着十分奇怪，但是进行分析之后发现这是十分合理的。三组参数中，单步移动的

平均时间均短于上下料所需的时间，加工一个零件所需时间远长于上下料时间以

及单步移动所需时间。从工作开始时，所有 CNC 都对 RGV 进行呼叫，这时的抉

择时按照顺序将 CNC 依次进行响应，当 CNC8 开始工作时，CNC1 还没有进入

空间状态，但是具有距离空闲状态最短的时间间距。基于整个流程设计的时候，

最优选择就是移动到 CNC1 处等待其完成。

参数的低移动时间，低上下料时间，高生产时间保证了 1-2-3-4-5-6-7-8

的合理性。同样可以设想，如果增加移动所需时间，上下料所需时间，减少生产

时间，则可能会出现在 RGV 处于某个位置时，同时有低位的 CNC 或者高位的

CNC 进行呼叫的情况，并通过进一步的判断跳出这个序列循环的情况。

5.2 情况二的模型建立与检验

5.2.1 两道工序的 CNC 数目与分配

第一步：若每台 CNC 被服务的概率基本相同，则两道工序的 CNC 数目应满

足如下关系才能保证效率达到最高： 𝑁1

𝑁2=

𝑇𝑗𝑔1

𝑇𝑗𝑔2

且

方法 FCFS 就近模型 实时局部 遗传算法

1 1 1 1

2 2 2 2

3 3 3 3

4 4 4 4

5 5 5 5

6 6 6 6

7 7 7 7

8 8 8 8

1 1 1 1

2 2 2 2

3 3 3 3

4 4 4 4

5 5 5 5

6 6 6 6

7 7 7 7

8 8 8 8

结果（参数1） 382 382 356 382

结果（参数2） 359 359 327 359

结果（参数3） 392 392 379 392

前16个数

（三组相同）

10

𝑁 + 𝑁 = 8 则

𝑁 ≈ 8 ∗𝑇

𝑇 + 𝑇

𝑁 ≈ 8 ∗𝑇

𝑇 + 𝑇

然而实际上每台 CNC 被服务的概率在不同情况下都不一样，所以这个算式

只能缩小到一个大致的取值范围。

𝑁 ϵ[ 8 ∗𝑇

𝑇 + 𝑇− 1， 8 ∗

𝑇

𝑇 + 𝑇+ 1]

𝑁 ϵ[ 8 ∗𝑇

𝑇 + 𝑇− 1， 8 ∗

𝑇

𝑇 + 𝑇+ 1]

第二步：我们观察这 8 个 CNC，由于奇数位和偶数位的上下料所需时间不

同，所以 8 个位置上下是不对称的，而左右是对称的如图所示：

图 5.2 CNC 对称关系示意图

当确定了两道工序 CNC 的个数𝑁 、𝑁 后总共的情况数如下：

𝐶 𝐶 若𝑁 ≤ 4

或

𝐶 𝐶 若𝑁 ≤ 4

若此以来便缩小了搜索范围，节约了搜索时间。由就近模型的较优性质，我

们选择就近模型来获取最优分配。确定了分配之后再用各种模型综合求最优方案。

11

5.2.2 情况二的结果计算

利用以上模型对三组参数进行分析，结果如下：

表 5.2 三组参数的最佳分配和最佳成料个数

（模型的检验结果见附件）

5.3 情况三的模型建立与检验

在问题分析中，我们分析认为由于 CNC 的位置不同，被使用到的概率也许

会不同，发生故障的位置不同对整个系统的效率影响也不同，故障台数对整个系

统的效率也有很大的影响，此外还有每次故障时间等因素，各种因素耦合在一起，

很难用解耦的方式将它们独立出来分析。故我们分别对一道工序和两道工序的情

况进行蒙特卡洛实验，并取平均效率进行分析。 如果决策序列给定了，则无法实时地依据发生故障的 CNC 位置进行更新决

策，可能会导致效率大幅度下降，灵活性不够，故针对情况三本文将不使用根据

给定序列执行指令的方法，而使用根据当前状态进行决策的方法。

5.3.1 一道工序的情况

我们进行 N=10000 次的实验，每次实验的步骤如下：

①首先进行初始化，令Pos = 1，D = 1，2，3，4，5，6，7，8 ，T =

0，𝑇 = {0，0，0，0，0，0，0，0} ②RGV 根据当前位置Pos、需求指令集D与剩余时间矩阵𝑇 ，使用一种

模型来决策并执行，计算消耗时间∆T，更新T。 ③更新当前位置Pos、需求指令集D与剩余时间矩阵𝑇 ：若集D包含当

前目标则排除目标，剩余时间矩阵𝑇 中该 CNC 所对应的剩余时间t赋

值为𝑇 ；若集D不包含当前目标，则T加上剩余时间矩阵𝑇 中该 CNC

所对应的剩余时间t，t赋值为𝑇 。

④在上料之前，生成随机数判断所服务的 CNC 在此次上料后的加工中是否

会发生故障。 若发生故障，则随机生成发生故障的时刻𝑇 ℎ 与维修所花费的时间

𝑇 。对剩余时间矩阵𝑇 中该 CNC 所对应的剩余时间t进行操作：

t = t − 𝑇 + 𝑇 ℎ + 𝑇 ，于是在接下来的 t 时间内该 CNC 都不会向

RGV 发出需求信号，相当于暂时离开系统。

若不发生故障，则跳过该阶段。

⑤执行紧接的上下料、清洗等操作，计算消耗时间∆T，更新剩余时间矩阵

参数组 最佳排列 最佳成料个数

1 1357 253

2 1357 211

3 13467 245

12

𝑇 与总时间T。 重复②~⑤步

（代码见附录） （模型的检验结果见附件）

5.3.2 两道工序的情况

首先我们确定第一道工序 CNC 组成的的集合𝐶 ，第二道工序 CNC 组成的

的集合𝐶 。 接着我们进行 N=10000 次的实验，每次实验的步骤如下：

①首先进行初始化，令

Pos = 1，D = 𝐶 ，T = 0，𝑇 = {0，0，0，0，0，0，0，0} ②RGV 根据当前位置Pos、需求指令集D、可行需求集𝐷 与剩余时间矩阵

𝑇 ，使用一种模型来决策并执行，计算消耗时间∆T，更新T。 ③更新当前位置Pos、需求指令集D、剩余时间矩阵𝑇 与可行需求集𝐷 ：

若集D包含当前目标则排除目标，剩余时间矩阵𝑇 中该 CNC 所对应的

剩余时间t赋值为𝑇 ；若集D不包含当前目标，则T加上剩余时间矩阵𝑇

中该 CNC 所对应的剩余时间t，t赋值为𝑇 。若 RGV 此时为空，第一道工序

的所有 CNC 和第二道工序且有工作或工作完成的 CNC 加入可行需求集𝐷 ；

若 RGV 此时手上有一个第一道工序产物，则只有第二道工序且有工作或工

作完成的 CNC 加入可行需求集𝐷 。

④在上料之前，生成随机数判断所服务的 CNC 在此次上料后的加工中是否

会发生故障。 若发生故障，则随机生成发生故障的时刻𝑇 ℎ 与维修所花费的时间

𝑇 。对剩余时间矩阵𝑇 中该 CNC 所对应的剩余时间t进行操作：

t = t − 𝑇 + 𝑇 ℎ + 𝑇 ，于是在接下来的 t 时间内该 CNC 都不会向

RGV 发出需求信号，相当于暂时离开系统。

若不发生故障，则跳过该阶段。

⑤执行紧接的上下料、清洗等操作，计算消耗时间∆T，更新剩余时间矩阵

𝑇 。 重复②~⑤步

（代码见附录） （模型的检验结果见附件）

六、模型的评价与改进

6.1 模型的评价

6.1.1 模型的优点

13

1.本模型在求解最佳动态调度模型时避免了直接对复杂 NP 问题的求解，而

是建立了两大类模型，用了尽可能多的模型来求解最佳的调度方案，并分析了不

同参数下使用哪一种分模型更优，考虑较周全。 2.本模型在两道工序的场景下以就“近”模型为基础分析了两道工序 CNC

数量和不同分配方式对系统效率的影响，利用数学方法分析缩小搜索范围，总结

了求出最佳排布方式的模型，这是在研究 RGV 动态调度的论文中较少分析的，

是一个创新点。本文并根据三组数据求出了最佳排布方式。 3.本模型在 CNC 可能出现故障的情况下避免了对整个系统进行复杂的解耦

分析，而是用蒙特卡洛方法来确定最优模型和排布方案，并且巧妙地通过增加剩

余时间的方法来表示该 CNC 故障接受维修，保证了每次加工只确认一次是否故

障。

6.1.2 模型的不足

1.本模型无法确保所获得的方案是最优方案，只能获得相对较优的方案。

2.本模型中所使用的遗传算法迭代速度较慢仍有待改进，获得更优解的能力

也有待提升。

6.2 模型的改进

1.在条件允许的情况下能局部地求解最优解，并通过适当的方式利用以更加

接近最优方案。例如以大量的系统当前状态为变量，用简单最优解算法求解一段

时间内的最优解（计算能力范围内），将大量的数据做成训练集来进行机器学习，

搭配聚类算法等。如图所示：

14

图 6.1 模型改进图

2.尝试以系统论的角度对 CNC 可能出现故障的情形进行深入分析，用更加

科学的办法。 3.改进遗传算法，使其收敛速度更快，获得更优解的能力更强。

七、参考文献

[1]司守奎，孙兆亮.数学建模算法与应用[M].国防工业出版社.2015

[2]吴焱明,刘永强,张栋,赵韩.基于遗传算法的 RGV 动态调度研究[J].起重运输

机械,2012(06):20-23.

八、附录

MATLAB代码： 遗传算法部分： popu=1000; dimension=length(no); maxIterTime=10000; mutationTime=200; crossoverTime=300; All=randi(8,popu,dimension); Alleval=zeros(popu,1); Alleval(1)=evalFunc(All(1,:)); y1=zeros(1,maxIterTime); y2=zeros(1,maxIterTime); for i=2:popu Alleval(i)=evalFunc(All(i,:)); end i = 0;j=0; while i < maxIterTime for j=1:crossoverTime [All,Alleval]=crossover(All,Alleval); end for j=1:mutationTime [All,Alleval]=mutation(All,Alleval); end aa=min(Alleval); bb=max(Alleval); disp([num2str(i+1),'---',num2str(maxIterTime),' ',num2str(aa),' ',num2str(bb)]); i=i+1; y1(i)=aa;

15

y2(i)=bb; if j==100 j=0; mutationTime=mutationTime+2; crossoverTime=crossoverTime-2; end end clear;x=1:maxIterTime; plot(x,y1);hold on; plot(x,y2); legend('×îÓŸöÌåʱ¼ä','×î²î¸öÌåʱ¼ä'); xlabel('µü´ú´ÎÊý'); ylabel('ʱ¼ä'); function t=evalFunc(list)%评估函数 mt=[20,33,46]; ut=560; evodt=[31,28]; cleart=25; n=8; curposi=1; csta=zeros(1,n); finish=zeros(1,n); t=0; taskset=1:n; for i=1:length(list) if ceil(list(i)/2)~=curposi t=t+mt(abs(ceil(list(i)/2)-curposi)); end if t<finish(list(i)) t=finish(list(i)); end curposi=ceil(list(i)/2); t=t+evodt(mod(list(i),2)+1); sat=t; if finish(list(i))~=0 t=t+cleart; end finish(list(i))=sat+ut; end function [All,Alleval]=crossover(All,Alleval)%交叉 popu=size(All,1); dimension=size(All,2); fatherPos=randi(popu); motherPos=randi(popu); while motherPos==fatherPos motherPos=randi(popu); end father=All(fatherPos,:);

16

mother=All(motherPos,:); startend=sort(randi(dimension,1,2)); st=startend(1);ed=startend(2); son1=father; son1(st:ed)=mother(st:ed); son2=mother;son2(st:ed)=father(st:ed); [worstval,worstPos]=min(Alleval); son1val=evalFunc(son1); son2val=evalFunc(son2); if son1val<worstval All(worstPos,:)=son1; Alleval(worstPos)=son1val; end if son2val<worstval All(worstPos,:)=son2; Alleval(worstPos)=son2val; end end function [All,Alleval]=mutation(All,Alleval)%变异 popu=size(All,1); dimension=size(All,2); fatherPos=randi(popu); father=All(fatherPos,:); mutationPos=randi(dimension); son=father; son(mutationPos)=randi(8); [worstval,worstPos]=max(Alleval); sonval=evalFunc(son); if sonval<worstval All(worstPos,:)=son; Alleval(worstPos)=sonval; end end function [no,st,et]=RGV(maxt,mt,ut,ft,st,evodt,cleart,fset) %ÐÞÕý°æ n=8; csta=zeros(1,n); t=0; no=[];st=[];et=[]; curno=1; taskset=1:n; curposi=1; drawback=99999; calltime=zeros(1,n); while t<maxt tasktime=ones(1,n)*drawback; for i=1:length(taskset)

17

tmpt=0; if ceil(taskset(i)/2)~=curposi tmpt=tmpt+max(mt(abs(ceil(taskset(i)/2)-curposi)),calltime(taskset(i))); else tmpt=tmpt+calltime(taskset(i)); end tmpt=tmpt+evodt(mod(taskset(i),2)+1); %About Two? if(csta(taskset(i))~=0&&~(any(fset==taskset(i)))) tmpt=tmpt+cleart; end tasktime(taskset(i))=tmpt; end [mint,index]=min(tasktime); if t+mint>maxt break; end %ÉÏÒ»¸ö no(curno)=index; %!!! if ceil(index/2)~=curposi st(curno)=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); else st(curno)=t+calltime(index); end if(csta(index)~=0&&~(any(fset==index))) et(csta(index))=st(curno); end csta(index)=curno; t=t+mint; curno=curno+1; curposi=ceil(index/2); for i=1:n if csta(i)==0||st(csta(i))+evodt(mod(i,2)+1)+ut<=t calltime(i)=0; else calltime(i)=st(csta(i))+evodt(mod(i,2)+1)+ut-t; end end end function [no1,st1,et1,no2,st2,et2]=RGV_dual(maxt,mt,ut,ft,st,evodt,cleart,fset) %两道工序 n=8; csta=zeros(1,n); %»úÆ÷״̬ t=0;

18

no1=[];st1=[];et1=[]; no2=[]; st2=[]; et2=[]; msta=[]; curno=1; taskset=1:n; [c,ia,ib]=intersect(taskset,fset); taskset=taskset(ia); %tasktime=[]; curposi=1; finish=1; iscarry=0; calltime=zeros(1,n); drawback=99999; while t<maxt tasktime=ones(1,n)*drawback; for i=1:length(taskset) tmpt=0; if ceil(taskset(i)/2)~=curposi tmpt=tmpt+max(mt(abs(ceil(taskset(i)/2)-curposi)),calltime(taskset(i))); else tmpt=tmpt+calltime(taskset(i)); end tmpt=tmpt+evodt(mod(taskset(i),2)+1); if(csta(taskset(i))~=0&&~(any(fset==taskset(i)))) tmpt=tmpt+cleart; end tasktime(taskset(i))=tmpt; end [mint,index]=min(tasktime); %ÉÏÒ»¸ö if any(fset==index) no1(curno)=index; if ceil(index/2)~=curposi st1(curno)=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else st1(curno)=t+calltime(index); end if(csta(index)~=0) et1(csta(index))=st1(curno); iscarry=csta(index); else iscarry=0; end csta(index)=curno; curno=curno+1; else

19

if iscarry no2(iscarry)=index; if ceil(index/2)~=curposi st2(iscarry)=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else st2(iscarry)=t+calltime(index); end if(csta(index)~=0) et2(csta(index))=st2(iscarry); end csta(index)=iscarry; iscarry=0; else if csta(index)~=0 if ceil(index/2)~=curposi et2(csta(index))=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else et2(csta(index))=t+calltime(index); end end csta(index)=0; iscarry=0; end end t=t+mint; taskset=[]; %curno=curno+1; curposi=ceil(index/2); waitime=drawback; ftask=0; for i=1:n if i==index continue; end if (any(fset==i)&&~iscarry&&(csta(i)==0||(st1(csta(i))+evodt(mod(i,2)+1)+ft<=t)))||... (~any(fset==i)&&iscarry&&(csta(i)==0||(st2(csta(i))+evodt(mod(i,2)+1)+st<=t)))||... (~any(fset==i)&&~iscarry&&csta(i)~=0&&((st2(csta(i))+evodt(mod(i,2)+1)+st<=t))) taskset=[taskset,i]; calltime(i)=0; else if iscarry&&~any(fset==i)

20

taskset=[taskset,i]; calltime(i)=st2(csta(i))+evodt(mod(i,2)+1)+st-t; elseif iscarry continue; elseif any(fset==i) taskset=[taskset,i]; calltime(i)=st1(csta(i))+evodt(mod(i,2)+1)+ft-t; else if csta(i)~=0 calltime(i)=st2(csta(i))+evodt(mod(i,2)+1)+st-t; taskset=[taskset,i]; end end end end end st1=st1(1:length(et1)); no1=no1(1:length(et1)); st2=st2(1:length(et2)); no2=no2(1:length(et2));

maxkey=0; b=1:8; a=[]; best=[]; for i=1:7 a=nchoosek(b,i); for j=1:length(a) [no1,st1,et1,no2,st2,et2]=RGV_dual(8*3600,[18,32,46],545,455,182,[32,27],25,a(j,:)); if length(et2)>maxkey maxkey=length(et2); best=a(j,:); end end end best maxkey function [no,st,et]=translate(list,mt,ut,evodt,cleart) %由序列生成编号,上料时间,下料时间 no=list; n=8;

21

curposi=1; csta=zeros(1,n); finish=zeros(1,n); t=0; for i=1:length(list) if ceil(list(i)/2)~=curposi t=t+mt(abs(ceil(list(i)/2)-curposi)); end if t<finish(list(i)) t=finish(list(i)); end if csta(list(i))~=0 et(csta(list(i)))=t; end csta(list(i))=i; st(i)=t; curposi=ceil(list(i)/2); t=t+evodt(mod(list(i),2)+1); sat=t; if finish(list(i))~=0 t=t+cleart; end finish(list(i))=sat+ut; end function [no,st,et,brokenlist,brokenmech,brokentime,revivetime]=RGV_pro(maxt,prob,mt,ut,ftime,stime,evodt,cleart,fset) %%一

道工序 有故障 n=8; csta=zeros(1,n); t=0; no=[];st=[];et=[]; msta=[]; curno=1; taskset=1:n; %tasktime=[]; breakdown=zeros(1,n); recovertime=zeros(1,n); brokenlist=[]; brokentime=[]; brokenmech=[]; revivetime=[]; curposi=1; finish=1; iscarry=0; drawback=99999; calltime=zeros(1,n); while t<maxt tasktime=ones(1,n)*drawback;

22

for i=1:length(taskset) tmpt=0; if ceil(taskset(i)/2)~=curposi tmpt=tmpt+max(mt(abs(ceil(taskset(i)/2)-curposi)),calltime(taskset(i))); else tmpt=tmpt+calltime(taskset(i)); end tmpt=tmpt+evodt(mod(taskset(i),2)+1); %About Two? if(csta(taskset(i))~=0&&~(any(fset==taskset(i)))) tmpt=tmpt+cleart; end tasktime(taskset(i))=tmpt; end [mint,index]=min(tasktime); k=rand(); no(curno)=index; %!!! if ceil(index/2)~=curposi st(curno)=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else st(curno)=t+calltime(index); end if(csta(index)~=0&&~(any(fset==index))) et(csta(index))=st(curno); end csta(index)=curno; t=t+mint; if k<=prob revivecost=(rand()+1)*10*60; breakdown(index)=1; recovertime(index)=t+revivecost; brokenlist=[brokenlist,curno]; brokentime=[brokentime,t]; brokenmech=[brokenmech,index]; revivetime=[revivetime,t+revivecost]; csta(index)=0; end for i=1:n if breakdown(i)&&t>=recovertime(i) breakdown(i)=0; end end %taskset=[]; %const here curno=curno+1;

23

curposi=ceil(index/2); for i=1:n if ~breakdown(i) if csta(i)==0||st(csta(i))+evodt(mod(i,2)+1)+ut<=t %ut!!!! calltime(i)=0; else calltime(i)=st(csta(i))+evodt(mod(i,2)+1)+ut-t; end else calltime(i)=recovertime(i)-t; end end end function [no1,st1,et1,no2,st2,et2,brokenlist,brokenmech,brokentime,revivetime]=RGV_dual_pro(maxt,prob,mt,ut,ft,st,e

vodt,cleart,fset) %两道工序有故障

n=8; csta=zeros(1,n); t=0; no1=[];st1=[];et1=[]; no2=[]; st2=[]; et2=[]; msta=[]; curno=1; taskset=1:n; [c,ia,ib]=intersect(taskset,fset); taskset=taskset(ia); breakdown=zeros(1,n); recovertime=zeros(1,n); brokenlist=[]; brokentime=[]; brokenmech=[]; revivetime=[]; %tasktime=[]; curposi=1; finish=1; iscarry=0; calltime=zeros(1,n); drawback=99999;

24

while t<maxt tasktime=ones(1,n)*drawback; for i=1:length(taskset) tmpt=0; if ceil(taskset(i)/2)~=curposi tmpt=tmpt+max(mt(abs(ceil(taskset(i)/2)-curposi)),calltime(taskset(i))); else tmpt=tmpt+calltime(taskset(i)); end tmpt=tmpt+evodt(mod(taskset(i),2)+1); %About Two? if(csta(taskset(i))~=0&&~(any(fset==taskset(i)))) tmpt=tmpt+cleart; end tasktime(taskset(i))=tmpt; end [mint,index]=min(tasktime); %ÉÏÒ»¸ö k=rand(); if any(fset==index) no1(curno)=index; if ceil(index/2)~=curposi st1(curno)=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else st1(curno)=t+calltime(index); end if(csta(index)~=0) et1(csta(index))=st1(curno); iscarry=csta(index); else iscarry=0; end csta(index)=curno; curno=curno+1; else

25

if iscarry no2(iscarry)=index; if ceil(index/2)~=curposi st2(iscarry)=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else st2(iscarry)=t+calltime(index); end if(csta(index)~=0) et2(csta(index))=st2(iscarry); end csta(index)=iscarry; iscarry=0; else if csta(index)~=0 if ceil(index/2)~=curposi et2(csta(index))=t+max(mt(abs(ceil(index/2)-curposi)),calltime(index)); %!!! else et2(csta(index))=t+calltime(index); end end csta(index)=0; iscarry=0; end end t=t+mint; if k<prob revivecost=(rand()+1)*10*60; breakdown(index)=1; recovertime(index)=t+revivecost; brokenlist=[brokenlist,curno]; brokentime=[brokentime,t]; brokenmech=[brokenmech,index]; revivetime=[revivetime,t+revivecost]; csta(index)=0; end for i=1:n

26

if breakdown(i)&&t>=recovertime(i) breakdown(i)=0; end end taskset=[]; %curno=curno+1; curposi=ceil(index/2); waitime=drawback; ftask=0; for i=1:n if i==index continue; end if ~breakdown(i) if (any(fset==i)&&~iscarry&&(csta(i)==0||(st1(csta(i))+evodt(mod(i,2)+1)+ft<=t)))||... (~any(fset==i)&&iscarry&&(csta(i)==0||(st2(csta(i))+evodt(mod(i,2)+1)+st<=t)))||... (~any(fset==i)&&~iscarry&&csta(i)~=0&&((st2(csta(i))+evodt(mod(i,2)+1)+st<=t))) taskset=[taskset,i]; calltime(i)=0; else if iscarry&&~any(fset==i) taskset=[taskset,i]; calltime(i)=st2(csta(i))+evodt(mod(i,2)+1)+st-t; elseif iscarry continue; elseif any(fset==i) taskset=[taskset,i]; calltime(i)=st1(csta(i))+evodt(mod(i,2)+1)+ft-t; else if csta(i)~=0 calltime(i)=st2(csta(i))+evodt(mod(i,2)+1)+st-t; taskset=[taskset,i]; end

27

end end else taskset=[taskset,i]; calltime(i)=recovertime(i)-t; end end end st1=st1(1:length(et1)); no1=no1(1:length(et1)); st2=st2(1:length(et2)); no2=no2(1:length(et2));