智能RGV的动态调度策略

杨利霞

  问题B    智能RGV的动态调度策略

/ ~% i" k1 B' W7 C# S, u: T1 U图1是一个智能加工系统的示意图，由8台计算机数控机床（Computer Number Controller，CNC）、1辆轨道式自动引导车（Rail Guide Vehicle，RGV）、1条RGV直线轨道、1条上料传送带、1条下料传送带等附属设备组成。RGV是一种无人驾驶、能在固定轨道上自由运行的智能车。它根据指令能自动控制移动方向和距离，并自带一个机械手臂、两只机械手爪和物料清洗槽，能够完成上下料及清洗物料等作业任务（参见附件1）。



: U0 Y( `, j' n
$ A4 u: f4 Z8 y6 s8 N9 I                                                                   图1：智能加工系统示意图
. B$ O# l( w5 ^$ ?( M8 O& t) N
' K9 V0 c3 x  d6 e8 ^6 w' H9 {
; J4 l% i' u3 a4 T; ^
针对下面的三种具体情况：
9 \$ S: d3 j6 T  a0 w
（1）一道工序的物料加工作业情况，每台CNC安装同样的刀具，物料可以在任一台CNC上加工完成；
- p3 R4 j1 v- C2 T# h, a
（2）两道工序的物料加工作业情况，每个物料的第一和第二道工序分别由两台不同的CNC依次加工完成；
; p3 t+ L5 x: }$ {
  a7 R6 d/ A: E' o: m; T7 c) p7 J' |（3）CNC在加工过程中可能发生故障（据统计：故障的发生概率约为1%）的情况，每次故障排除（人工处理，未完成的物料报废）时间介于10~20分钟之间，故障排除后即刻加入作业序列。要求分别考虑一道工序和两道工序的物料加工作业情况。
8 u8 _$ l: B" `% e. w
3 [* `0 l5 }" [' R9 |% q& Q请你们团队完成下列两项任务：
" [/ c: {1 ]7 P/ u: ]
任务1：对一般问题进行研究，给出RGV动态调度模型和相应的求解算法；

2 B# S! h/ V1 Y( [任务2：利用表1中系统作业参数的3组数据分别检验模型的实用性和算法的有效性，给出RGV的调度策略和系统的作业效率，并将具体的结果分别填入附件2的EXCEL表中。
& @; q, a, V+ z% j1 A$ h
& X8 {3 o% K# g3 x0 m                                    表1：智能加工系统作业参数的3组数据表                                时间单位：秒
1 d5 B: a+ L, p
系统作业参数
% Y/ y' \$ [. P3 p& W( @* U第1组
# C2 m- Y' p) g0 m% v4 Q* P第2组
第3组
- S7 g; ]1 ^2 L; G- {; ]1 [RGV移动1个单位所需时间
20
/ G5 ]7 `5 O3 @. V8 D" q6 ?( H" t3 _23
, i1 V( V5 ?& v/ Q, o& {. u+ L18
RGV移动2个单位所需时间
33
41
; E4 ^  I" ~& X! q7 l- Q) |# `! Y6 r32
RGV移动3个单位所需时间
46
59
: o" s9 C& _* L& i$ |6 F6 k& N46
CNC加工完成一个一道工序的物料所需时间
- A% w& H( m, Y& Z* I. d0 L. Q8 v& f560
8 B9 O- ~; P  k/ m580
545
CNC加工完成一个两道工序物料的第一道工序所需时间
400
280
, v4 s6 D4 K0 s- _/ g3 s: x- ?, p  ?. f455
- ]6 J) t9 m" b! ^3 ^% ^5 RCNC加工完成一个两道工序物料的第二道工序所需时间
) D3 O9 I4 }! y( Y378
500
182
) }" O- c+ a+ ]& t$ [RGV为CNC1#，3#，5#，7#一次上下料所需时间
% V& E  P: z2 @& V* O3 H$ v2 M28
30
27
RGV为CNC2#，4#，6#，8#一次上下料所需时间
31
9 l, h! B' V. M$ S" N" o0 n35
32
( v6 h8 F3 E* Y; aRGV完成一个物料的清洗作业所需时间
25
30
25
注：每班次连续作业8小时。
4 ~' [% Y3 A3 W* q


8 h) e: j% q  m#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main(){
        int M[4]={0,18,32,46};
        int T1=27; //CNC1，3，5，7一次上下料所需时间
        int T2=32; //CNC2，4，6，8一次上下料所需时间
        int W11=545; //加工完成一个一道工序的物料所需时间
" j" |8 B' u, K% P" u+ D3 N        int C=25; //完成一个物料的清洗作业所需时间
3 W" w: P& N5 z/ u4 N/ u        int T=0;
        int RGV_X=0;  //RGV在第一个位置
6 b2 s4 G4 l. d5 a5 x7 r3 _        int CNC_Flag[8];  //0表示没有在加工，1表示正在加工，2表示加工完成
% A4 [2 X, s' e- i# D        int CNC_WT[8]; //记录CNC已工作时间
        int CNC_X[4]; //CNC_X=1表示GRV要去第i个位置
        int i;
        int length=-1; //记录路径长度
  H3 b, F5 @4 v+ c3 W1 A, i2 S; a        int min1=5; //记录最短路径
1 W% D0 |+ x. f* @) g* X$ v        int min2=-1; //记录要去的最短的点
2 E9 q, c! ?% ^. d        int count=0; //记录成件
        int count2=0;
5 m' C* U+ b5 r9 H2 Q        for(i=0;i<8;i++){
4 F- r0 k5 t. E, S& R; i                CNC_Flag=0;  //一开始CNC都处于没有加工状态
                CNC_WT=0;       //一开始CNC已工作时间都是0
9 s9 Z) v. p/ a" x8 B9 x        }
, I+ d) q" z' A* A& P+ ^1 _        for(i=0;i<4;i++){
                CNC_Flag=0;  //一开始RGV那里都不用去
        }
7 r  @  @  m- j' K% b+ @1 ?8 I        while(T<28800){  //时间未到时
                if(CNC_Flag[0]==0 || CNC_Flag[1]==0 || CNC_Flag[0]==2 || CNC_Flag[0]==2){ //CNC1或2发信号
& G- g& B1 _7 A2 K; f% a5 |8 N                        CNC_X[0]=1;
                }
                if(CNC_Flag[2]==0 || CNC_Flag[3]==0 || CNC_Flag[2]==2 || CNC_Flag[3]==2){ //CNC3或4发信号
                        CNC_X[1]=1;
                }
5 a+ `. m' [" v- z                if(CNC_Flag[4]==0 || CNC_Flag[5]==0 || CNC_Flag[4]==2 || CNC_Flag[5]==2){ //CNC5或6发信号
7 R, ]* _$ H) V" B3 c                        CNC_X[2]=1;
6 y$ z0 p5 l4 g4 o- ^5 s! \7 t- M                }
1 `  u% l5 d- D/ z' B4 }                if(CNC_Flag[6]==0 || CNC_Flag[7]==0 || CNC_Flag[6]==2 || CNC_Flag[7]==2){ //CNC7或8发信号
                        CNC_X[3]=1;
                }
                for(i=0;i<4;i++){   //找到哪个地方是最近的
                        if(CNC_X==1){
, s7 R5 E4 j1 U/ z                                length=abs(RGV_X-i);
                                if(length<min1){
, p1 A. F: c  d5 A' K4 r$ R                                        min1=length;
                                        min2=i;
                                }
                        }
* Q( q0 c3 v. }* g% K                }
                if(T+M[length]>28800)
                        break;
                else if(min1>=0 && min1<=3){
1 l* Y8 I6 p- i0 F# U+ v8 ?                        T=T+M[min1];   //时间增加
  a  o1 D# e& O! ^( N                        CNC_X[min2]=0;   
                        RGV_X=min2;      //RGV移动到最近点
9 _8 h0 N! Z, _- e///////////////////////////////////////////////////////
                        for(i=0;i<8;i++){
                                if(CNC_Flag==1){    //已加工时间增加
" t# B: C& |, m# I! J9 X                                        CNC_WT=CNC_WT+M[min1];
3 n2 D8 U4 N: m' ]! S                                }
! J  u' X! `9 e/ }+ n1 d. W                                if(CNC_WT>=W11){    //加工完成
                                        CNC_Flag=2;
& x/ x% ~5 w$ A6 a7 H( W4 F                                        CNC_WT=0;
; e7 H+ M; c6 P' y. i  A                                }
, B4 v7 o7 t6 D" j7 ~" ?0 S                        }
0 B) U( b# O2 Y2 L% s5 c- [8 R///////////////////////////////////////////////////////
5 K2 [5 [1 N+ Z! ]7 b, H8 g                }
                if(min2==0){
4 y: L% G7 H2 O                        if(CNC_Flag[0]==0){ //如果CNC1没有在加工，CNC1完成一次上下料 ,置CNC1处于加工状态
/ V4 H8 g% T; [8 b5 S7 e                                if(T+T1>28800)
                                        break;
                                else{
                                        printf("（上料时间：%d）",T);
                                        T=T+T1;
                                        for(i=0;i<8;i++){
0 U  Z" B+ A7 T% s  a                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T1;
                                                }
                                                if(CNC_WT>=W11){    //加工完成
+ k4 w- b* z- g- @' H- x+ w& I                                                        CNC_Flag=2;
                                                        CNC_WT=0;
                                                }
! u* d) K6 `8 q# t  |                                        }
                                        CNC_Flag[0]=1;
9 @+ S* D, c! c. y                                        printf("1 ");
                                        count2++;
                                        if(count2==30){
' O4 n) {/ s5 z  P% I% H- z                                                printf("\n");
* m* I, ]5 h9 [2 w1 K% v                                                count2=0;
* R8 h$ c+ w  ?4 n7 ]2 o                                        }
5 W& f* K" _* d. y! `( x3 E: L9 L                                }
4 N& g2 |6 E5 h8 q  a                        }
  G# H. Q1 C, U- {- y) [! f& f                        if(CNC_Flag[0]==2){ //如果CNC1在加工，CNC1完成一次上下料，再完成一次清洗工作，置CNC1处于加工状态
$ U2 _) x0 B; |* \+ t                                if(T+T1+C>28800)
* C5 T- o) x0 ~9 r1 G' w2 ~                                        break;
- y4 t% M4 |+ T, C) w+ G* j                                else{
, t  W5 Z8 [7 A2 ~2 J$ r/ t                                        printf("（上下料时间：%d）",T);
                                        T=T+T1+C;
                                        for(i=0;i<8;i++){
. E3 j6 C4 V* D6 B3 V" t                                                if(CNC_Flag==1){    //已加工时间增加
' U' n: Q: }9 `2 ]: B/ C4 V, z' i) R                                                        CNC_WT=CNC_WT+T1+C;
3 G5 w2 W4 f9 J/ `$ D% ~6 G. N: ~                                                }
. y: {: X# ^  [                                                if(CNC_WT>=W11){    //加工完成
- [  s6 |$ S, h# P' p: d$ B                                                        CNC_Flag=2;
) z- S. l* q$ [( b9 d, d' J4 [/ O                                                        CNC_WT=0;
9 k  ^' `' q! G! |+ H! B( p0 j                                                }
. Q  }# h3 H( Z                                        }
5 H0 c' i% F$ }& B                                        CNC_Flag[0]=1;
# t, c" A2 a# o! p7 W                                        count++;
6 Q4 z1 r; r# O& F                                        printf("1 ");
1 Q* T0 C3 _) J! y9 F. m7 W3 o                                        count2++;
                                        if(count2==30){
; f( \* b0 U; H/ a2 f8 n3 x; _+ [& Z                                                printf("\n");
" d: [8 s+ C% A# i3 }, n& P                                                count2=0;
                                        }
                                }
                        }
                        if(CNC_Flag[1]==0){ //如果CNC2没有在加工，CNC2完成一次上下料，置CNC2处于加工状态
                                if(T+T2>28800)
                                        break;
                                else{
0 L& G* h+ Y( F8 Y  w                                        printf("（上料时间：%d）",T);
9 Y, A: x1 o, K6 V* Y                                        T=T+T2;
                                        for(i=0;i<8;i++){
                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T2;
. u& F- K: x- A4 O3 l( G' J                                                }
                                                if(CNC_WT>=W11){    //加工完成
% m: W; S4 s/ h: X+ d: w/ C                                                        CNC_Flag=2;
6 I4 j/ x# p. M- }! w                                                        CNC_WT=0;
" P' D$ t7 S  Z, H                                                }
                                        }
6 {- O# M8 T) M: P                                        CNC_Flag[1]=1;
                                        printf("2 ");
                                        count2++;
7 C6 s, g! x$ r9 Q                                        if(count2==30){
                                                printf("\n");
                                                count2=0;
# ]# |: v, Z) K6 V+ I% \                                        }
                                }
- J. }. R6 k' G) R0 z                        }
                        if(CNC_Flag[1]==2){ //如果CNC2在加工，CNC2完成一次上下料，再完成一次清洗工作，置CNC2处于加工状态
                                if(T+T2+C>28800)
                                        break;
4 o1 v3 {% S* R8 O/ p; h' o4 q                                else{
; w" u. q# U, Y! H1 |) {6 \                                        printf("（上下料时间：%d）",T);
" l& L/ q% z$ T4 n* a' ^/ W                                        T=T+T2+C;
, k: n! e% B0 }$ N! i. Z                                        for(i=0;i<8;i++){
                                                if(CNC_Flag==1){    //已加工时间增加
3 a$ h% C( Q( N' f$ d                                                        CNC_WT=CNC_WT+T2+C;
& q( H; ?! Y! V* u! y! z                                                }
                                                if(CNC_WT>=W11){    //加工完成
/ e. K) k' R# |                                                        CNC_Flag=2;
                                                        CNC_WT=0;
                                                }
/ x1 a& U8 m% ?9 N) N                                        }
                                        CNC_Flag[1]=1;
: F* @9 O4 X$ E. e: t- M; |9 {) [6 j* a                                        count++;
4 L( [3 `8 k$ `, F: N: C                                        printf("2 ");
                                        count2++;
                                        if(count2==30){
6 L" L) ~* b1 A; ^1 ?, O                                                printf("\n");
                                                count2=0;
                                        }
( l' r8 X$ E8 p* H/ y7 R4 B8 R- J                                }
! q6 _* G3 i4 I2 ^% J2 N) Y$ K                        }
6 S# R+ }9 @% G* u1 C                }
. ?+ s6 o5 y  E4 q: T7 \- A$ t//////////////////////////////////////////////////////////////////////////////////////////////
" s# C- o7 {& N: w: u; E% h                else if(min2==1){
% P$ t! j$ T+ I                        if(CNC_Flag[2]==0){ //如果CNC3没有在加工，CNC3完成一次上下料 ,置CNC3处于加工状态
                                if(T+T1>28800)
4 K7 z* J" j; R1 ?, f9 w                                        break;
( G7 E5 b/ t+ ~% F& P" z                                else{
+ l6 I+ W7 t; ~! a                                        printf("（上料时间：%d）",T);
                                        T=T+T1;
                                        for(i=0;i<8;i++){
- |4 {3 ?: S; ^& V7 J                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T1;
                                                }
                                                if(CNC_WT>=W11){    //加工完成
: h5 I# h1 [, _5 m3 ~, T( _+ j                                                        CNC_Flag=2;
                                                        CNC_WT=0;
1 @( a" y2 @& M: e8 D                                                }
                                        }
                                        CNC_Flag[2]=1;
5 |5 w! `$ U8 O; T: F" {  U                                        printf("3 ");
  i6 |; [; J& d2 N. y# t3 f0 p                                        count2++;
( i# l& Y3 l9 f' s                                        if(count2==30){
                                                printf("\n");
                                                count2=0;
                                        }
$ w; _0 E7 Z' {$ O3 h                                }
+ s! {$ I4 q. Y  Y1 k% e9 e6 x, W: U                        }
                        if(CNC_Flag[2]==2){ //如果CNC3在加工，CNC3完成一次上下料，再完成一次清洗工作，置CNC3处于加工状态
                                if(T+T1+C>28800)
                                        break;
                                else{
                                        printf("（上下料时间：%d）",T);
                                        T=T+T1+C;
. v; g3 @: a2 ]                                        for(i=0;i<8;i++){
2 V, U7 F, \' p                                                if(CNC_Flag==1){    //已加工时间增加
% F9 B; L$ {& O, V/ _0 r                                                        CNC_WT=CNC_WT+T1+C;
                                                }
                                                if(CNC_WT>=W11){    //加工完成
6 @. s6 {% Z0 E% U                                                        CNC_Flag=2;
2 e: ?# S! i' \& r                                                        CNC_WT=0;
                                                }
                                        }
8 i' v+ I) |' {8 x, u; ~- \1 H                                        CNC_Flag[2]=1;
0 d; T  |  p9 q1 V                                        count++;
                                        printf("3 ");
  |) _- \" T0 T( h( C4 i                                        count2++;
' V7 |0 h8 o0 s8 b3 s# F                                        if(count2==30){
3 A+ K' u/ ?# ^7 m/ L/ x                                                printf("\n");
9 h  Z/ ]9 d# E1 Y$ k                                                count2=0;
                                        }
                                }
                        }
                        if(CNC_Flag[3]==0){ //如果CNC4没有在加工，CNC4完成一次上下料，置CNC4处于加工状态
$ {! y+ M* f4 C                                if(T+T2>28800)
7 j, a5 i. [5 @                                        break;
                                else{
                                        printf("（上料时间：%d）",T);
                                        T=T+T2;
                                        for(i=0;i<8;i++){
                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T2;
" t4 {5 G5 i. ]( E- ~- S; J6 b                                                }
# S) v) f; r( c: ]. }7 z  w                                                if(CNC_WT>=W11){    //加工完成
' l) _% U/ r/ X$ j% \/ m' Q                                                        CNC_Flag=2;
                                                        CNC_WT=0;
  f! e" t6 R- m; m. d) z                                                }
4 g* N! ?7 X5 ]: o  e+ w                                        }
                                        CNC_Flag[3]=1;
5 D( d8 N! W7 ?4 Z                                        printf("4 ");
                                        count2++;
                                        if(count2==30){
% g2 j( h5 y5 E* ~9 a& F; ^                                                printf("\n");
9 y8 N( ~5 J. ?6 L" m& p& ?2 X                                                count2=0;
9 ^0 c$ C- {( h                                        }
' t5 t7 i8 I+ a+ S1 r  \  z                                }
                        }
& F: m( P0 I) S$ K$ J+ O                        if(CNC_Flag[3]==2){ //如果CNC4在加工，CNC4完成一次上下料，再完成一次清洗工作，置CNC4处于加工状态
                                if(T+T2+C>28800)
                                        break;
                                else{
; U; d: z- ~, u3 y3 C                                        printf("（上下料时间：%d）",T);
                                        T=T+T2+C;
' k3 Z: l8 v1 Z9 o; b; a                                        for(i=0;i<8;i++){
$ L4 k$ d$ D+ f% X                                                if(CNC_Flag==1){    //已加工时间增加
! q  U9 f* F. E- E: m                                                        CNC_WT=CNC_WT+T2+C;
                                                }
6 q" u2 m4 l* g' Z5 v; Y2 |0 Y                                                if(CNC_WT>=W11){    //加工完成
                                                        CNC_Flag=2;
                                                        CNC_WT=0;
( p! t& R, C* Y/ A( g                                                }
                                        }
7 l1 m* M9 S! d: ~( ?& L8 J8 o6 A                                        CNC_Flag[3]=1;
                                        count++;
                                        printf("4 ");
                                        count2++;
                                        if(count2==30){
: P, V# x5 _* T) F                                                printf("\n");
7 Y; Q6 Q( [, K1 _4 c7 S# n                                                count2=0;
                                        }
                                }
                        }
                }
/////////////////////////////////////////////////////////////////////////////////////////////////
- V9 R: B3 }+ N" y- j8 D! o                else if(min2==2){
, E4 Z' ?; g  s6 K: {! F                        if(CNC_Flag[4]==0){ //如果CNC5没有在加工，CNC5完成一次上下料 ,置CNC5处于加工状态
8 O1 w$ p5 }1 R# s9 X# g- `                                if(T+T1>28800)
! E- {: S! |+ R4 L$ @* b                                        break;
                                else{
                                        printf("（上料时间：%d）",T);
                                        T=T+T1;
                                        for(i=0;i<8;i++){
4 \# Y2 Y0 Y+ H; M6 O                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T1;
! H6 c1 }. N% {' l                                                }
                                                if(CNC_WT>=W11){    //加工完成
7 G! z0 R8 }/ c% o; ]                                                        CNC_Flag=2;
                                                        CNC_WT=0;
                                                }
: W  o" L+ w  a% e1 @. Q                                        }
                                        CNC_Flag[4]=1;
                                        printf("5 ");
                                        count2++;
                                        if(count2==30){
' u( K& Z  ?( A' \                                                printf("\n");
# y" W  d" u" s$ C1 `+ z                                                count2=0;
                                        }
                                }
: W, P2 t  @3 h                        }
                        if(CNC_Flag[4]==2){ //如果CNC5在加工，CNC5完成一次上下料，再完成一次清洗工作，置CNC5处于加工状态
                                if(T+T1+C>28800)
0 B9 ?& r% `$ q- }" W5 u                                        break;
  ?  l7 _+ }" z, o. E3 d2 G                                else{
4 M: Y2 f# I1 r/ Z! w                                        printf("（上下料时间：%d）",T);
                                        T=T+T1+C;
! o. _. h+ r* c* t. J                                        for(i=0;i<8;i++){
3 z  m4 Q2 {* h, ]% u  S                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T1+C;
- X+ y# b5 T. y' [7 N: O9 L1 x                                                }
, u' q7 Z, R! h* F( Z5 ]                                                if(CNC_WT>=W11){    //加工完成
: x. @# Z) E+ X3 D' Z6 d3 v# z9 H. I                                                        CNC_Flag=2;
/ f+ ?3 g  t2 h  m' {                                                        CNC_WT=0;
9 I. o" U& v6 [: O2 L' H                                                }
8 p; D& O8 j: u6 I                                        }
                                        CNC_Flag[4]=1;
                                        count++;
                                        printf("5 ");
                                        count2++;
                                        if(count2==30){
. q- j. F2 Y2 V5 R7 A                                                printf("\n");
: J4 x8 M4 U8 {- v3 u5 B% v                                                count2=0;
                                        }
1 M1 y  r0 K0 D+ I                                }
. [" n( g4 V" j' S( s4 A3 Y8 y8 Q                        }
7 W) X; j- v2 b& T) ]; b: s                        if(CNC_Flag[5]==0){ //如果CNC6没有在加工，CNC6完成一次上下料，置CNC6处于加工状态
6 O+ h$ q  w" G+ L5 z, p                                if(T+T2>28800)
                                        break;
* A3 Z8 q. h# ^( j- c                                else{
                                        printf("（上料时间：%d）",T);
                                        T=T+T2;
                                        for(i=0;i<8;i++){
4 K3 p; t6 F/ B$ Z& b0 {4 q                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T2;
1 b, i  G7 H$ G- ?. t" _' h4 a$ i; Z                                                }
                                                if(CNC_WT>=W11){    //加工完成
                                                        CNC_Flag=2;
# ~( ?. K  z) M5 l+ M                                                        CNC_WT=0;
                                                }
                                        }
& ]6 l& l) p6 A, }                                        CNC_Flag[5]=1;
/ \, V  C8 u# l; W) o                                        printf("6 ");
# O8 E  n( ]3 I7 [0 f( g: x* j% K' }                                        count2++;
                                        if(count2==30){
                                                printf("\n");
  S0 f7 s. S6 x6 c% [3 M8 H" t                                                count2=0;
9 ^% D: ^/ c! g' I4 A4 Y+ L                                        }
1 T1 P8 y! C1 _$ V- r+ p# m. i                                }
5 v7 v; l; r$ u. s+ K- G% w                        }
* R& I9 H3 p- s0 I                        if(CNC_Flag[5]==2){ //如果CNC6在加工，CNC6完成一次上下料，再完成一次清洗工作，置CNC6处于加工状态
                                if(T+T2+C>28800)
7 `$ E9 ^9 X7 Q+ ~8 w/ d" F                                        break;
. z! h$ @* s2 J! I2 U: {! L                                else{
                                        printf("（上下料时间：%d）",T);
# T; `& Y% q, u% i  }                                        T=T+T2+C;
                                        for(i=0;i<8;i++){
                                                if(CNC_Flag==1){    //已加工时间增加
6 a" t& L$ b; d                                                        CNC_WT=CNC_WT+T2+C;
                                                }
5 C% Y  e5 `3 e                                                if(CNC_WT>=W11){    //加工完成
2 T7 v+ Q1 V! o% M6 y0 ?/ x. G                                                        CNC_Flag=2;
( t( Y. u: X! p5 L8 J                                                        CNC_WT=0;
9 A* z  X- _$ _- M, W* B; K                                                }
                                        }
# V% u+ C; \) F) v2 ^                                        CNC_Flag[5]=1;
( U9 [" v$ l% X                                        count++;
                                        printf("6 ");
/ G' \3 D' }2 {3 E# `5 S8 @8 s7 p5 Z                                        count2++;
                                        if(count2==30){
/ U$ S( J$ S) p+ f, e* j+ F  V                                                printf("\n");
                                                count2=0;
                                        }
/ f' l4 ^2 _( \( C0 a                                }
                        }
6 u3 X$ @" D* k; T6 R                }
/////////////////////////////////////////////////////////////////////////////////////////////////
% J2 g! I3 ~- j( v/ {: o                else if(min2==3){
9 L7 q1 m* z8 P7 f$ m( ^2 P                        if(CNC_Flag[6]==0){ //如果CNC7没有在加工，CNC7完成一次上下料 ,置CNC7处于加工状态
                                if(T+T1>28800)
" C3 j, v$ E8 c3 r                                        break;
                                else{
- a" I# \$ {  V                                        printf("（上料时间：%d）",T);
                                        T=T+T1;
                                        for(i=0;i<8;i++){
1 W5 V" B. M) _! \1 X6 u+ y% R                                                if(CNC_Flag==1){    //已加工时间增加
  {, e, ^, V3 O/ d. p                                                        CNC_WT=CNC_WT+T1;
% v, j9 w' J  H& p: @8 q                                                }
* |4 g) l) g- E                                                if(CNC_WT>=W11){    //加工完成
2 L# ~" E& _8 H/ R7 Y                                                        CNC_Flag=2;
2 c' u$ s  T3 E' d# ~                                                        CNC_WT=0;
                                                }
                                        }
* }2 \8 l5 F# f( ^& D( C7 @) G. V                                        CNC_Flag[6]=1;
                                        printf("7 ");
                                        count2++;
                                        if(count2==30){
                                                printf("\n");
. `" G+ n9 L3 V7 [                                                count2=0;
2 I6 q# g: A$ c                                        }
. ^( C" f9 a: L/ P# \                                }
  K% N" `+ N! @: f- z% l                        }
                        if(CNC_Flag[6]==2){ //如果CNC7在加工，CNC7完成一次上下料，再完成一次清洗工作，置CNC7处于加工状态
                                if(T+T1+C>28800)
                                        break;
                                else{
                                        printf("（上下料时间：%d）",T);
+ l4 D+ w% X9 q& X$ R                                        T=T+T1+C;
                                        for(i=0;i<8;i++){
" ~. z7 l% x: v( O+ O                                                if(CNC_Flag==1){    //已加工时间增加
! U5 _" m. |; G: G( R                                                        CNC_WT=CNC_WT+T1+C;
1 @9 T# V* [% Z) d4 {                                                }
5 B/ x' d# n0 K6 j# {0 b                                                if(CNC_WT>=W11){    //加工完成
                                                        CNC_Flag=2;
- ~6 ^% V' h; ]! e" n4 J! o: W                                                        CNC_WT=0;
                                                }
4 q& O3 _- J% }! R7 A& @                                        }
                                        CNC_Flag[6]=1;
5 a" p# ^) T" i+ h. j5 ~3 }                                        count++;
' F, z0 t' v- ?8 ~                                        printf("7 ");
                                        count2++;
                                        if(count2==30){
                                                printf("\n");
                                                count2=0;
2 {  S0 Y" G0 ~( o& I* t- d3 N" f                                        }
, I% ^1 q  i% I, T1 d9 R) g, W1 _                                }
                        }
                        if(CNC_Flag[7]==0){ //如果CNC8没有在加工，CNC8完成一次上下料，置CNC8处于加工状态
1 ~* v# j( Y. j+ i9 w) p4 f  g                                if(T+T2>28800)
                                        break;
                                else{
                                        printf("（上料时间：%d）",T);
+ h3 G7 m# g0 Y# ]  a5 ?4 W1 m, I                                        T=T+T2;
' ?# Y% C* H2 K. q5 y                                        for(i=0;i<8;i++){
                                                if(CNC_Flag==1){    //已加工时间增加
                                                        CNC_WT=CNC_WT+T2;
0 [% G. _7 k; i; d$ R                                                }
                                                if(CNC_WT>=W11){    //加工完成
                                                        CNC_Flag=2;
7 w; m# |5 r: a  Q' b! U& L                                                        CNC_WT=0;
                                                }
                                        }
                                        CNC_Flag[7]=1;
' v' X" f# ^8 }6 j) B                                        printf("8 ");
                                        count2++;
5 K/ e3 Y% ]! |8 J6 u                                        if(count2==30){
) r# U( p/ ?0 \                                                printf("\n");
                                                count2=0;
                                        }
$ w: x% `9 F- v+ A5 c- O                                }
                        }
                        if(CNC_Flag[7]==2){ //如果CNC8在加工，CNC8完成一次上下料，再完成一次清洗工作，置CNC8处于加工状态
" o) g9 q- W" U8 l8 k                                if(T+T2+C>28800)
1 g/ P6 d3 {5 }. v! ^0 E3 W                                        break;
* g6 o1 b. S: v% Z                                else{
1 w8 f& i# R# w9 |7 ~                                        printf("（上下料时间：%d）",T);
                                        T=T+T2+C;
                                        for(i=0;i<8;i++){
# n2 M0 G" F5 W( o% p                                                if(CNC_Flag==1){    //已加工时间增加
  G: D, `% C  q3 V                                                        CNC_WT=CNC_WT+T2+C;
                                                }
$ @# \3 V+ l) A: L                                                if(CNC_WT>=W11){    //加工完成
                                                        CNC_Flag=2;
                                                        CNC_WT=0;
                                                }
                                        }
# e! {7 }  T8 J1 ~                                        CNC_Flag[7]=1;
9 Y% b2 _' M8 `, i  Q" E                                        count++;
) k0 Z  x6 e, T, @( s+ U8 v' _                                        printf("8 ");
                                        count2++;
3 T6 q" \/ Q. h6 c6 f3 K# R, ~                                        if(count2==30){
                                                printf("\n");
                                                count2=0;
                                        }
1 f  y4 M7 X# k( [                                }
                        }
- \3 N# R" H$ t                }
//////////////////////////////////////////////////////////////////////////
                else{    //否则等待,等待过程中RGV先移动到要完成加工的CNC那里
                        int min3=600;
                        min1=5;
; W. I! \2 q1 E, v9 d. K$ d: z6 Z$ R                        min2=-1;
0 ?  ?$ N* Y& r/*                        T=T+1;
( Z+ p2 s! r2 N) h$ U/ x, ?                        for(i=0;i<8;i++){
                                if(CNC_Flag==1){    //已加工时间增加
* y" B, q7 U  `+ l0 w- k& V/ }6 |                                        CNC_WT=CNC_WT+1;
                                }
* o# U: W3 O7 h$ O; M3 C                                if(CNC_WT>=W11){    //加工完成
0 _8 q( u. g" V: j                                        CNC_Flag=2;
: E7 q* M9 S( d# Z                                        CNC_WT=0;
                                }
4 l+ ]! O+ q7 V  k                        }
*/
                        for(i=0;i<8;i++){
1 ^. s' h3 _7 h* o) ~6 ]- k( ~2 a                                if(CNC_Flag<min3){
                                        min3=CNC_Flag;
                                        if(i==0 || i==1){
8 W- B( f' u3 K; D: E0 B                                                min2=0;
/ ?4 I) x+ R# L" O                                        }
; F3 P* O5 ?. @  Q) q( L" Z; f                                        else if(i==2 || i==3){
1 b/ a1 X+ A2 s- B                                                min2=1;
7 l8 D. A, n1 F& d2 q                                        }
) g3 N4 P7 S6 I                                        else if(i==4 || i==5){
" e* O- M! I& \$ Z0 d* z: N1 [                                                min2=2;
6 b/ b' \1 @9 V( Z% F" j0 _1 i                                        }
- X. m' F1 S+ t$ a                                        else if(i==6 || i==7){
, {4 l6 ]& B9 `6 S  X                                                min2=3;
: [. R' w! x% z- q# A$ ?0 q; r" X                                        }
# P7 s" @! d7 S4 Z9 Q0 P" |% h) U                                }
                        }
$ o0 C0 z5 b! o8 x                        if(T+M[abs(min2-RGV_X)]>28800)
7 E! R4 [# M1 \. G. J' E, z                                break;
                        else if(min2>=0 && min2<=3 && M[abs(min2-RGV_X)]!=0){
3 ?, y4 o4 ^1 c5 F" U3 m                                T=T+M[abs(min2-RGV_X)];   //时间增加  
0 w. z" B# m) J4 q) R, ]! I                                for(i=0;i<8;i++){
; K4 y7 t* X  E1 B, D                                        if(CNC_Flag==1){    //已加工时间增加
# O; P8 `& b4 Q. p( [. s                                                CNC_WT=CNC_WT+M[abs(min2-RGV_X)];
                                        }
/ O& v" D  ~) X                                        if(CNC_WT>=W11){    //加工完成
+ h1 V1 \) E  W, k2 ?; X& |                                                CNC_Flag=2;
7 H! {; t& E$ x! I* V1 y8 l1 [                                                CNC_WT=0;
                                        }
: g& \- Q1 h: v# ?* C1 i9 U1 u& a                                }
7 {/ F) P7 v- H! M: h                                RGV_X=min2;      //RGV移动到最近点
2 M4 v3 o+ i& c6 |7 y" G//                                printf("%d ",min2+1);
1 ]' P# }8 r9 T7 @4 F# p7 X, P                                count2++;
                                        if(count2==30){
4 N, r7 S) E- z2 y, H! }//                                                printf("\n");
+ d3 Y) [  b9 o( j                                                count2=0;
, n6 v8 J/ N- C: y+ u. d                                        }
. }( w# V$ E" o' D4 i! u                        }
                        else{
                                T=T+1;
                                for(i=0;i<8;i++){
                                        if(CNC_Flag==1){    //已加工时间增加
                                                CNC_WT=CNC_WT+1;
& y' w7 {7 g! q& v; W/ F                                        }
                                        if(CNC_WT>=W11){    //加工完成
$ v- z2 p" g" M% T# p                                                CNC_Flag=2;
, G8 q9 I0 G9 C( x0 i- g7 w8 R9 }                                                CNC_WT=0;
# }1 _: c- p4 D: f                                        }
                                }
8 q# _0 P4 i. F; V7 w3 k                        }
                        min3=600;
- N4 N' V" {! S6 f  m                }
6 L6 o. a$ I' \- t                min1=5;
4 O' W$ c& m% \: |( z# f- N1 L                min2=-1;
9 d' m  f. h; K) ^        }
, M: ?) T4 E) y3 B8 |        printf("%d\n",count);
. J; J7 [9 \1 q( x        return 0;
2 O! d: V% p0 m! _5 R}
$ p  Y. B8 d/ C) `
. |; L4 }9 R" t' B; h) B( V; ?* a

7 n, t$ P7 h) }, Z0 q2 K% G3 n                                



/ L) T1 m" e& R: U* Q% n





; n: \3 m& @9 Y