2018.2.0版中AGV如何乘升降机？

办法1：从2016版本里面复制相应的代码
; L; {9 r" w3 t9 g: M
! j9 d2 Y% K* R2 }2 O具体代码如下：
9 X9 c9 x! B9 Z' Z

1. treenode agv = param(1);
   
2. treenode currentCP = param(2);
   ( L# }" j- o' h6 w3 J9 U' S. \
3. 
   0 Z% R. i: C, `( N+ p$ G- F$ c
4. { //************* PickOption Start *************\\
   + ?  b$ y7 B+ R# b) Q4 k+ m
5. /***popup:AGV_DivertToElevator*/
   
6. /***tag:Description*//**Divert to Elevator*/
   9 j1 S) W. W( G! k, R' r! S
7. 
   
8. int operation = param(3);
   ' p* A" R5 X' {8 V) E, G
9. 
   * ~. T. Y& O* R
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    ) o& W: D. K- f  l$ Q
12.                 && (/** \nCondition: *//***tag:Condition*//**/fabs(zloc(currentCP) - zloc(agvinfo(agv, AGV_DEST_CP))) > zsize(agv)/**/)) { // if it's a pointer, then do the initial case
    0 L  Q; a# _5 L" `' [: J
13.         // initial trigger execution
    
14.         #define ON_ELEVATOR_START 1
    * w% g, x- S5 s( n) V* j  t# _
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    9 V# l8 h, X- @8 j! ?
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    4 X& w5 l8 T7 N+ @" Q2 E
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    7 @* @9 t1 Z+ j- A' e
19.         #define ON_OPEN_DOOR 6
    
20.         #define ON_CLOSE_DOOR 7
    
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    6 d& R  K5 a9 c- R$ j0 D# p
23.         #define ON_DROPOFF_DOOR_OPENED 10
    1 ~9 @8 H. P5 S" P; z7 _
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    2 p1 \* Z& K/ F; Y5 r& U5 A
25.        
    
26.         #define AGV_STATE_START 0
    . Y' ^! N2 k: \: N$ w$ S
27.         #define AGV_STATE_AT_ENTRY_CP 1
    ! Q* R& j( \5 L
28.         #define AGV_STATE_AT_ELEV_CP 2
    8 s* W1 ~5 h; ]  J9 M
29.         #define AGV_STATE_AT_EXIT_CP 3
    3 X: s6 D; r: N( z# t
30.        
    # [9 N9 A% ]" j% |* U, A* R
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
      U6 j. j0 d( B5 g. v) Y
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    ) ~1 U) x9 G8 y' Z' D
35. 
    # z$ q6 `# Z' |
36. 
    
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    & \$ g) ]  G- M3 b
38.         #define elevator outobject(elevDisp, $iter(1))
    6 @% N  f' D; E5 l) H7 [
39. 
    4 X/ ~+ `  f; Q) F
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    4 n, }2 O& V& z$ b1 k- T- K9 t6 o
42. 
    ; i: [- _7 I* L3 E
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    ( C: [* c+ K- U
44.                 query(
    5 N5 W: ~" b. J7 y$ Q% g7 g) f: h
45.                         /** \nFull Query: */
    % m2 a* X/ w* \0 O
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    ( B% Y1 Y5 c8 ?2 V
47.                         nrop(elevDisp),
    " J. `/ h- j2 S/ B
48.                         elevator
    
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    
51.                         /***/
    8 m& a1 K0 A: H9 Y
52.                         /** \nOrderBy*/
    6 I4 W8 r9 x9 P' H' ]. V$ J* |
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    2 }$ d! w- U8 w' B# ~' z; i  l" Z
55. 
    
56.                 if (getquerymatchcount() > 0)
    4 W( D# \* C0 ^; f
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    + [% U5 d% v9 h# T" U" E( E% z8 W1 F
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    9 h5 C- i7 i1 {
62. 
    + ], v$ f; t3 M, I5 M
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    
64. 
    
65.         // Create the task sequence for the elevator
    ( E  U' E9 S( W: S% D
66.         double destZ = zloc(destCP);
    
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    ! S+ ?( j  [2 R( S
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    
69.         // immediately when the elevator starts the task sequence, I call ON_ELEVATOR_START
    
70.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_START, destZ);
    2 V- {" G% e8 b9 G, P- C' e
71.         // travel to the z location of the current control point
    6 R$ [# J2 A8 l; u
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    9 n. ^& f/ ~/ ?7 ?/ Q4 a# o0 M7 `
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    
75.         // then wait for the agv to get on
    
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    ! j) }0 O5 y( a, t# O; P
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    . u* e% i6 |3 x2 s- o2 c9 m! F. o
82.         dispatchtasksequence(ts);
    
83. } else switch (operation) {
    3 i# r) {$ U( |& @1 M6 P! g
84.         case ON_ELEVATOR_START: {
    3 W" Z3 \6 Y" E+ w: s! g2 w
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    + O# r$ |! {5 ]( |6 S, o
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    7 H  X! ~% T! @
88. 
    
89.                 // find the closest floor control point
      H. X$ `2 x% r, R% K: _4 ~- I, ]
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    * g' w* I" H0 u5 b6 R' B$ i) O! \1 }1 U
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    2 k/ n8 }( a. b6 O) V- X* \
95.                 if (!objectexists(curFloorCP))
    6 p  g0 {$ v& p
96.                         return 0;
    6 {" ~, B% ?- x$ K, |
97. 
    
98.                 // get the entry control point
    
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     3 G# d# N  o4 i# [: O
101.                 if (!objectexists(curFloorEntryCP))
     8 O2 C! s0 C# u5 a
102.                         return 0;
     1 s; j; O* T( J4 f' e4 o' w
103.                 treenode floorEntryCP = curFloorEntryCP;
     8 t! b" [2 w* Y9 I8 B) |
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     6 Y2 W/ E5 _5 y: y
106.                         return 0;
     2 c4 ^4 X6 i! E7 ^' D
107. 
     % q# p: [( @' r4 r% D! D# Y
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     9 ]' ~) a/ w1 p! s* h
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     % v6 p5 o$ k. Q. Q7 b4 J
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     % C( B8 M% s; C. j: X/ R4 l  y
112.                                                         cpconnection(elev, floorCPCon, count));
     % n" A' d8 w9 k! C+ _
113.                                                        
     
114.                 floorCP = destFloorCP;
     7 Y! K0 C) B' F" K
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     - j! j3 t/ w& h7 V, Y
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     
118.                 // get the destination exit control point
     & G% n4 t" H/ \6 z
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     # w% v8 J$ {1 P) T6 G% k5 k
122. 
     
123. 
     ; l7 L1 u) q& U- G& c4 T
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     
125.                 // agv arrives at a node. I keep a state on the agv's state label, and then increment it each time
     0 Z4 I8 }' y2 d' |/ [; n  I; r
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     " e# g& Z# @' Y# j! r
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     . m* s% q6 h& R0 f
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     : l+ J' n0 X5 K7 S
129.                
     
130.                 // set the data on the state label
     3 P8 h- x5 b' U& S- `6 G8 }
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     ' m" x1 m$ ]" ?0 P
132.                 switch_destroyonreset(stateLabel, 1);
     $ h7 z/ t& e! j. ~
133.                 set(stateLabel, AGV_STATE_START);
     2 B% W6 J* U/ M9 h/ R. \2 v$ C; O
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     + I$ [. s+ y& ]% ?0 g
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     ( [4 Q! {! o' M% F: {* V
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     
139.                 return 0;
     " L* o  t2 P* B8 g
140.         }
     
141.         case ON_AGV_AT_CP: {
     
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     
143.                 treenode agv = param(1);
     ' c! Q$ h9 x" S/ D
144.                 treenode elev = param(2);
     
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
146.                 // I increment the state label, and then switch on it
     , a; C5 H: B8 D* U0 O8 Q
147.                 inc(stateLabel, 1);
     
148.                 switch (get(stateLabel)) {
     
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     * z; ~* z" y7 S& j! E3 v& J
151.                                 // so, figure out where the elevator is.
     
152.                                 int elevState = get(node("ElevState", stateLabel));
     
153.                                 // if he's at the pickup floor with his door closed then open the door.
     8 b2 q, Z4 b. D8 o" ?
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     * Q+ P$ l+ [  T$ p$ w+ U; F4 p' `
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     7 F9 F- x& S2 i0 c* M
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     8 V& y0 ^" e0 W  g+ v+ n" P6 r# b
158.                                         // the elevator cp
     
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     ; u$ c/ a' M0 @8 I
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     * @. ]# n9 e& a" B8 c
162.                                 break;
     
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     
165.                                 // once the agv is at the elevator cp, close the door
     
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     " T: Y, T3 @  J1 T4 V- ?- S
168.                         }
     : Q* X9 H1 k6 M+ d
169.                         case AGV_STATE_AT_EXIT_CP: {
     1 Z1 ]" V% ?: C) f/ {4 ]8 J+ a
170.                                 // the agv is at the exit cp
     / G1 s- e3 j2 X, Z) @
171.                                 // destroy the listener node because I'm finished listening
     
172.                                 treenode listenerNode = param(4);
     1 [/ \* z4 b( S4 V( x
173.                                 destroyobject(listenerNode);
     & N9 B0 A1 E+ Y/ ?8 R9 x
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     $ ?, c! c( F( B8 S5 W/ ]2 H
175.                                 if (!agvWait) {
     
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     ) u: [9 }1 c2 Y' K
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     . X# b6 l! Y0 [  _3 M
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     
179.                                 }
     
180.                                 // close the door
     
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     
182.                                 // and I'm finished with the state label so I can destroy it.
     
183.                                 destroyobject(stateLabel);
       b( y# ^' B& o3 ^: t
184.                                 break;
     7 }3 {* A  e6 y
185.                         }
     % ^7 ~7 m( L& Q% M) }: j
186.                 }
     
187.                 return 0;
     
188.         }
     
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     2 A& `, O0 t9 z5 j. w+ Z  \
190.                 // the elevator has arrived at the pick floor
     & [' p: g3 e7 F1 J2 h6 z9 B. W0 c% w( W
191.                 treenode elev = param(1);
     
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     # L: f/ g5 B0 V+ ?1 W3 I2 B4 R/ C2 J  |
194.                 treenode elevState = node("ElevState", stateLabel);
     
195.                 // set the elevator state to at-pickup-floor
     6 [3 X2 }0 }1 t3 Y: p
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     
197.        
     
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     
199.                
     : {& j8 O' {. c+ d
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     0 a0 F9 E. p* q' y5 ]
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     7 f4 A! }. y" e
204.                 }
     + O$ c: |" u, }2 Z9 x
205.                 return 0;
     
206.         }
     % @+ g4 t" ]* x" e2 ?0 F5 n
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     : Z" d2 B7 S6 U7 S3 o
209.                 treenode elev = param(2);
     & B3 Q$ {6 c5 O
210.                 int nextStep = param(4);
     
211.                 // open the door based on the time to open the door
     
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     ; d5 Q) w+ h+ K$ v6 H
214.                 return 0;
     * @$ V8 }* b+ g- ~4 c
215.         }
     6 F5 u5 v( ]; M. N' K
216.         case ON_CLOSE_DOOR: {
     , `/ M1 ^' v& I' ]
217.                 treenode agv = param(1);
     
218.                 treenode elev = param(2);
     
219.                 int nextStep = param(4);
     $ ?8 _# p% o9 S* C5 f
220.                 // close the door base on the time to close the door
     6 H" v8 q) b! _) \
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     - k; e; Q1 h* g! E$ G
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     
224.         }
     0 p, v2 ]! d7 v' @
225.         case ON_PICKUP_DOOR_OPENED: {
     ! D: E8 Z+ A( b5 ^* C2 w" ~2 _; E
226.                 // the elevator door has been opened on the pickup floor
     
227.                 treenode elev = param(1);
     - a( ?; i8 j8 p9 b
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
229.                 treenode entryCP = cp(agv);
     & l0 C+ _5 |# F- j/ u
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     * o/ e, S0 W  p- w; ?
232.                 treenode elevState = node("ElevState", stateLabel);
     
233.                 // set the elevator state
     : w, s1 c4 n- W# R$ ?; W
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     
235.                 // if the agv is at the entry control point, move him to the elevator control point
     
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     * v$ p: D3 I' E6 W
239.         }
     
240.         case ON_PICKUP_DOOR_CLOSED: {
     1 ?; T5 y8 k$ X  y  v, H
241.                 treenode elev = param(1);
     5 V& Z  T( ~0 a" p! S
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
243.                 // assign the agv to "no control point"
     
244.                 agvreassigncp(agv, 0);
     
245.                 // move the agv into the elevator
     - \- n8 p9 ^4 W
246.                 moveobject(agv, elev);
     
247.                 setrot(agv, 0, 0, 0);
     / {$ E0 {. u2 k( y
248.                 // release the elevator to continue to the destination floor
     * A( l# M$ x6 d' |$ v! i8 `
249.                 freeoperators(elev, agv);
     ( m! N* E: E. u3 ?2 H8 v) Q
250.                 return 0;
     
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     1 B( X$ H, |5 q6 k. [' t6 c
253.                 treenode elev = param(1);
     
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     & {$ ~) |- O" G5 z2 E  t
255.                 // when the elevator arrives at the destination floor
     7 B5 p4 [4 s% w8 `9 ~7 h
256.                 // move the agv back into the model
     
257.                 moveobject(agv, model());
     # D; {7 y- G- S. y7 {: ^2 O
258.                 // reassign it to the destination floor control point
     
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     
262.                 return 0;
     1 d+ y7 L' T; j! z2 b3 R, u
263.         }
     ) v  |+ D9 u" V6 O, v" r, Q
264.         case ON_DROPOFF_DOOR_OPENED: {
     7 G6 V% b3 W# `, a- ]
265.                 treenode elev = param(1);
     
266.                 treenode agv = param(2);
     ( K# v3 j$ |* O* h- D% N$ h
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     * o" f8 o0 d3 D9 E, r, T
268.                 // once the elevator door is opened on the destination floor,
     1 i3 w3 T% c1 D* a% j4 |( E* F
269.                 // redirect the agv to the exit control point
     
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     ! f0 D: q8 C6 v- x: s) S1 p0 r( p
271.                 return 0;
     
272.         }
     , J) c) _4 h- m' Z2 ?) N
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     
275.                 treenode agv = param(2);
     * u4 e3 U! u: M: v& W; N- y
276.                 int isAGVWaiting = param(4);
     : ~. X6 X0 {( C( N6 ?
277.                 // once the door is closed at the destination floor,
     
278.                 // if the agv is waiting, then send him to the final destination
     ' L' F# D2 A' o) B$ V3 T$ f+ O* [
279.                 if (isAGVWaiting)
     
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     * Z1 A- v. {/ Y! J+ k" ?
281.                 // release the elevator to finish his task sequence
     
282.                 freeoperators(elev, agv);
     
283.                 return 0;
     
284.         }
     1 {0 H& S+ q2 `# \; p+ V1 D& o) R
285. }
     ) @/ ?* C1 i' ~5 v
286. } //******* PickOption End *******\\
     & Z1 e- c0 x: ?! @" c2 e
287. 
     

复制代码

5 Z" q* {5 \8 N3 [9 \7 t

! `1 f' E7 C% n  ?1 q办法2：使用工艺流程模块完成