2018.2.0版中AGV如何乘升降机？

请教一下，2018.2.0版中AGV模块，路径点逻辑里没有乘升降机的选项，该如何实现这个操作？

: x& p, _- G8 c' k( _) k* M

办法1：从2016版本里面复制相应的代码

; [5 C3 q/ v7 Y6 p具体代码如下：
. A# Y. ~. P# f! v" f% D

1. treenode agv = param(1);
   6 I& |) g3 n& t6 x, q; Q: P& I# `
2. treenode currentCP = param(2);
   
3. 
   
4. { //************* PickOption Start *************\\
   % y6 b6 b' E. a4 ]- x$ ?
5. /***popup:AGV_DivertToElevator*/
   
6. /***tag:Description*//**Divert to Elevator*/
   1 f" c4 y5 v$ @
7. 
   : S1 z0 H- G8 }! H- _
8. int operation = param(3);
   5 @) O) W0 f1 ^  e
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    
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
    
13.         // initial trigger execution
    - i' K* S# t/ [9 e
14.         #define ON_ELEVATOR_START 1
    
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    / [  b7 @9 J4 e6 q2 D5 \4 y
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    ; M! A, j# ^9 x- d0 J
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    8 Z# E1 R' Q  p. E6 |
19.         #define ON_OPEN_DOOR 6
    1 ~) J9 w1 N4 A  F8 x1 K; i1 J
20.         #define ON_CLOSE_DOOR 7
    8 T+ n. ?9 _& n% G8 x" v
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    & p( e" `. A2 L4 h! ?6 Y! |
23.         #define ON_DROPOFF_DOOR_OPENED 10
    " y6 u  x: \3 I$ w7 j
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    - Q# k+ [4 S  \! I
25.        
    ' }& t2 y5 x: P1 \# O" D2 H
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    ! ]# E  j% [- ~. w
28.         #define AGV_STATE_AT_ELEV_CP 2
    
29.         #define AGV_STATE_AT_EXIT_CP 3
    $ s. I( Q5 `& q: s( ?( X! x
30.        
    & E1 J9 h5 Y% n4 s3 e1 `2 T
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    ! ?( F- \% S- ~' Q8 F$ `
35. 
    + ]/ |3 y1 _* A0 F
36. 
    
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    
39. 
    & k% L! {) V( y8 j
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    * V! ^% \4 p' h
42. 
    
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
      e0 r, |7 N( ~$ i
44.                 query(
    
45.                         /** \nFull Query: */
    
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    : H, s* n, y# E' N+ Z% \# I9 j
47.                         nrop(elevDisp),
    
48.                         elevator
    
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
      J8 E% X9 ]) e4 d2 _$ {' \
51.                         /***/
    
52.                         /** \nOrderBy*/
    
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    & L) k. t# B1 W- ?
55. 
    
56.                 if (getquerymatchcount() > 0)
    6 U2 ^- i& l9 i; r+ j& H! V
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    
59.         if (!objectexists(elevDisp))
    7 K, W- P. i* l9 K) Y- D+ P
60.                 return 0;
    % V3 ^# n; }  |1 J
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    5 x2 m( O  D2 t. [, w% @0 e3 a# ]
62. 
    
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    # @: A* b$ e1 r! E# Y' `
64. 
    
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    4 `! \+ i* S9 U) k
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    / W" q" O! d/ i! A8 q$ x3 H
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    - |6 g: i6 J  C- \6 [8 X
69.         // immediately when the elevator starts the task sequence, I call ON_ELEVATOR_START
    8 R/ ~9 h# o* Y+ F
70.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_START, destZ);
    : E+ f3 m$ Z0 r; r
71.         // travel to the z location of the current control point
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    $ s9 V$ x9 h) ]0 D+ d8 Y
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    + ]' S' b& B$ `. C- X) D" o7 s9 O* v* D6 n
75.         // then wait for the agv to get on
    ! E( k1 D5 A! X. l- c2 g  K9 O
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    4 V& ?" F! m5 {7 o; Q- A( k
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    - e! v6 e, m. O
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    , F+ X( J1 H  o$ X3 |5 w
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
82.         dispatchtasksequence(ts);
    
83. } else switch (operation) {
    
84.         case ON_ELEVATOR_START: {
    ; U; C8 t6 Q0 n8 H/ k& A
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    # b7 E; W, x: d
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    
88. 
    
89.                 // find the closest floor control point
      r7 j% a/ X' k# H0 n$ J. o
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    - t9 t$ U' B: h. ?5 e4 O
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    0 X& C& @% n& a& Y' o$ |0 v
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
    9 h3 X, t, l1 P1 T* z5 Y- V
96.                         return 0;
    
97. 
    , @( L- f' g, {" [7 [
98.                 // get the entry control point
    & d) F* K6 z5 ^  D$ h- e8 f/ c
99.                 treenode floorCP = curFloorCP;
    9 h! d4 R9 l9 y' q+ n( Z
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     
101.                 if (!objectexists(curFloorEntryCP))
     ; `$ g8 o& y9 ~2 y' i
102.                         return 0;
     & _3 j2 L- l* S9 k  F- I# {
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     0 E+ H$ C: H  x2 N5 G; g
105.                 if (!objectexists(curFloorElevCP))
     
106.                         return 0;
     ) W0 z1 v+ y; ^6 y7 L/ @! j
107. 
     ) g+ j2 A7 F# x9 \
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     ' d6 v9 ], V! s/ [; {0 [7 X
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     
112.                                                         cpconnection(elev, floorCPCon, count));
     
113.                                                        
     ) i$ ]; @2 ?! y, Y' F% t
114.                 floorCP = destFloorCP;
     9 _3 t+ J/ Z! j
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     4 y2 z( s* I: l) Z& V) G& \0 R
118.                 // get the destination exit control point
     & ]0 |) z1 S+ O; ^# X2 Z" O% ^
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     4 C# s# P3 h' \3 y  @
122. 
     ! ^+ A) D5 k; p% j
123. 
     
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     & u6 E3 `  @. F! y  Z
125.                 // agv arrives at a node. I keep a state on the agv's state label, and then increment it each time
     5 @' _$ Q* C6 `( s- D5 {
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     ! Y% J5 J) D4 s- S0 y5 V# X) E6 {
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     ) b, X* ]7 o8 `, u- P$ L) N$ F: U
129.                
     
130.                 // set the data on the state label
     1 a, s3 M: q& ]2 b- Q
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     - `0 b- Z# H3 Q5 M
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     - l* r0 r( M3 B! Z# e+ i( x) e/ M
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     * J9 R3 ?4 c. t  D+ Y8 A
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     & U: x% N- O' s+ Q" B+ o' ]  R
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
       X7 c) x* @5 `9 @& I. T
139.                 return 0;
     - }6 `2 |' h- C
140.         }
     
141.         case ON_AGV_AT_CP: {
     
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     * Z6 M7 s; z+ \6 X( u
143.                 treenode agv = param(1);
     
144.                 treenode elev = param(2);
     . X; N0 v. W, s4 r
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
146.                 // I increment the state label, and then switch on it
     8 v" |6 J9 Y% w# U3 l
147.                 inc(stateLabel, 1);
     - W) P% P0 \' t) T7 o3 F0 ?6 r
148.                 switch (get(stateLabel)) {
     : n* ~, s6 Y2 o: [& n
149.                         case AGV_STATE_AT_ENTRY_CP: {
     - C5 C0 q% {0 g4 {& l/ p
150.                                 // the agv just arrived at the entry cp
     
151.                                 // so, figure out where the elevator is.
     # b9 R1 E1 L4 G) u9 W( ]
152.                                 int elevState = get(node("ElevState", stateLabel));
     * F6 v  u! u$ r& V* g  b
153.                                 // if he's at the pickup floor with his door closed then open the door.
     ; M9 P% Z; |0 j
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     8 A* q. G  R; Y- R2 y
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     * }6 F/ n4 g- J, m/ z  x
158.                                         // the elevator cp
     * n: o) K* ^7 Q5 `- c
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     7 m& ^8 C+ {: ~% J9 f
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     9 F! m, ^7 U4 p! A0 s) |" y4 K5 {6 F
161.                                 }
     
162.                                 break;
     
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     ! j- }. F1 T1 x( O/ v' w+ E: P6 h8 V
165.                                 // once the agv is at the elevator cp, close the door
     
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     # Z2 j7 m% ?) z( _4 N' |( k# w0 O# T
167.                                 break;
     
168.                         }
     ( p2 l8 o" P2 n
169.                         case AGV_STATE_AT_EXIT_CP: {
     
170.                                 // the agv is at the exit cp
     
171.                                 // destroy the listener node because I'm finished listening
     & Y- k& {/ T. G7 E4 l) C
172.                                 treenode listenerNode = param(4);
     0 N8 i. y0 h+ i9 a6 j
173.                                 destroyobject(listenerNode);
     ) j( P2 n# x  K3 ]: ?: ~2 O
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     
175.                                 if (!agvWait) {
     
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     - m3 x8 B. v2 y, w+ B! p
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     3 z  C- d' k" {1 M( n. }7 J
179.                                 }
     9 ^5 r8 R) {; |8 d
180.                                 // close the door
     * E4 p+ y2 s9 X& {2 V( E
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     % N+ ]2 Y8 l6 G8 `2 _. f: K
182.                                 // and I'm finished with the state label so I can destroy it.
     1 K+ z! x7 }7 v- h
183.                                 destroyobject(stateLabel);
     
184.                                 break;
       G+ L4 m2 M# Q0 m
185.                         }
     
186.                 }
     
187.                 return 0;
     
188.         }
     9 P/ o  y% S/ T: f" s* W7 U
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     
190.                 // the elevator has arrived at the pick floor
     
191.                 treenode elev = param(1);
     ! e: L$ B- x; f8 ?( s
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     . _/ z6 w/ x7 t0 C, I& Q
194.                 treenode elevState = node("ElevState", stateLabel);
     " o( `, x2 b  P
195.                 // set the elevator state to at-pickup-floor
     $ F0 C. w' ^1 ~. [' ?: r1 q
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     + G0 }2 X( Q$ [: P; q3 s" H
197.        
     3 O. f5 X/ @' x7 f' w; Z/ k
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     
199.                
     / O3 T/ T3 `3 |  I0 |9 `. @* |
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     7 C' A: X! a! _4 w# k# ~
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
204.                 }
     ! }" `, ^6 H( N( L
205.                 return 0;
     ' U0 L3 w* g( |8 j6 P
206.         }
     
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     " A5 c3 _! N1 I+ k
211.                 // open the door based on the time to open the door
     
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     . |7 q/ }) I2 p7 {2 Z6 V7 E* w$ O
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     
214.                 return 0;
     
215.         }
     
216.         case ON_CLOSE_DOOR: {
     6 V. r2 o" s# W. g
217.                 treenode agv = param(1);
     . q9 C% J  C  U+ d+ G0 |  n" z
218.                 treenode elev = param(2);
     
219.                 int nextStep = param(4);
     1 Z$ q* ]+ d7 V% O" _0 a
220.                 // close the door base on the time to close the door
     
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     , l* _9 D- V2 ~1 N/ l- r* I
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     + g) R$ k2 M8 c' s( I' e
223.                 return 0;
     1 ?* U5 c4 H5 `7 s$ o; i- d- b8 x
224.         }
     
225.         case ON_PICKUP_DOOR_OPENED: {
     6 L0 `! D/ v3 g( k" q* J5 f
226.                 // the elevator door has been opened on the pickup floor
     3 y, }# a! n% v- ^# j* @. l
227.                 treenode elev = param(1);
     ' K0 m: p; k8 L. X+ s( _; \
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     1 A2 m$ `+ S& L$ _* n
229.                 treenode entryCP = cp(agv);
     1 s9 ]& ~. X+ w! E1 X
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
232.                 treenode elevState = node("ElevState", stateLabel);
     
233.                 // set the elevator state
     * `! k, B) O5 w
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     5 R/ E/ H+ D7 F% g" E
235.                 // if the agv is at the entry control point, move him to the elevator control point
     * Y7 v/ h$ T) r9 v( O: H0 o1 g; M4 C
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     ( Z9 v0 }8 o* s
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     7 w: @6 @" }+ c. e9 `
238.                 return 0;
     ; k" g/ b$ r9 U  E
239.         }
     
240.         case ON_PICKUP_DOOR_CLOSED: {
     & s  I& v* p- z
241.                 treenode elev = param(1);
     , C% r! O. R, e! V; i
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     $ v0 b9 o4 C) H* s. S7 k0 z
243.                 // assign the agv to "no control point"
     2 {8 a$ N, p- F: S/ W$ u
244.                 agvreassigncp(agv, 0);
     ' B" c' m. m: |
245.                 // move the agv into the elevator
     
246.                 moveobject(agv, elev);
     " J& q  t, K9 B2 H& Z- D
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     % C' c4 R8 x8 a' U  ^) Y
249.                 freeoperators(elev, agv);
     
250.                 return 0;
     ' p' U& i% B; b3 l( t' n2 V5 [
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     
253.                 treenode elev = param(1);
     
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
255.                 // when the elevator arrives at the destination floor
     
256.                 // move the agv back into the model
     8 v0 |5 Z/ k9 l0 k  [4 [
257.                 moveobject(agv, model());
     
258.                 // reassign it to the destination floor control point
     
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     ! {$ ]  U% P  X% c
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     ) Z' g6 z/ s8 D& ^; [5 g
262.                 return 0;
     
263.         }
     
264.         case ON_DROPOFF_DOOR_OPENED: {
     0 ~3 _, t4 Z/ ~  D2 e: O9 N: a2 [
265.                 treenode elev = param(1);
     
266.                 treenode agv = param(2);
     
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     - i- J; U' u3 u% {. F& S3 G- V
268.                 // once the elevator door is opened on the destination floor,
     2 V  J% O" v( X, t" m
269.                 // redirect the agv to the exit control point
     
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     ' W+ u0 w  N" Y, }
271.                 return 0;
     
272.         }
     ; w! E* e) N5 h
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     $ Y1 T9 d3 ^# P. V  M3 A& y
275.                 treenode agv = param(2);
     ( H  I; f' n' \
276.                 int isAGVWaiting = param(4);
     + Y1 v+ C8 A4 s7 W9 E
277.                 // once the door is closed at the destination floor,
     9 H6 P- |& n4 ?) P, t
278.                 // if the agv is waiting, then send him to the final destination
     
279.                 if (isAGVWaiting)
     ( p" h2 s3 A. E& {4 U; h( j0 \
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     
281.                 // release the elevator to finish his task sequence
     
282.                 freeoperators(elev, agv);
     
283.                 return 0;
     
284.         }
     : J# s) ^: J# P) P* w' [3 B
285. }
     / H+ B4 L9 S8 U
286. } //******* PickOption End *******\\
     
287. 
     

复制代码

7 A+ r+ s; E* u/ C8 w3 z
& |( c$ o9 C  B: e9 b7 f, x- ~
办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
办法1：从2016版本里面复制相应的代码
) b* ^2 q$ ]1 m% P' G% G
具体代码如下：

+ E+ d* M. `- K好的，非常感谢陈老师的解答~