2018.2.0版中AGV如何乘升降机？

请教一下，2018.2.0版中AGV模块，路径点逻辑里没有乘升降机的选项，该如何实现这个操作？
5 U9 c( z6 r7 O# x; h! g; G# f
& C* m9 V6 X+ g2 r2 _, G

办法1：从2016版本里面复制相应的代码
" k& P2 g; X! D  P/ j* f) }- k9 j3 \  h
  q# u; x% o! o3 p% w, l3 U" [具体代码如下：
! E; n% e/ y6 _1 `: \% M+ {' C  J

1. treenode agv = param(1);
   4 |; x0 n7 ?! h/ d( h
2. treenode currentCP = param(2);
   
3. 
   8 G1 b7 J+ D  l# d6 ~
4. { //************* PickOption Start *************\\
   
5. /***popup:AGV_DivertToElevator*/
   
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   
8. int operation = param(3);
   " b/ v9 }" y( _# N% W) a( c5 b
9. 
   & f6 a6 J8 m' F5 I. Z
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    6 S: |. F2 T6 h$ Y8 _* N- ?
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
    / |6 c: C/ h: C6 i- ~7 q4 K& m
13.         // initial trigger execution
    & e' p- F; F) H' n0 B6 ^, D
14.         #define ON_ELEVATOR_START 1
    
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    ; j8 i, o0 S4 D; ?% L' ?, O4 r) ~
19.         #define ON_OPEN_DOOR 6
    0 X- g. O$ X/ l8 v5 k3 t
20.         #define ON_CLOSE_DOOR 7
    ! V5 m/ p: ^7 O! h0 k
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    9 {- w/ E- s' S( P  ]9 q
23.         #define ON_DROPOFF_DOOR_OPENED 10
    5 X- x, V; M1 _, ~7 i1 F
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    
25.        
    5 U/ v' p8 \7 {. j6 I: n2 u
26.         #define AGV_STATE_START 0
    0 E2 ~9 h0 v" i0 J
27.         #define AGV_STATE_AT_ENTRY_CP 1
    
28.         #define AGV_STATE_AT_ELEV_CP 2
    3 F: @5 Q4 Z& Y4 B8 g* ~. [' p
29.         #define AGV_STATE_AT_EXIT_CP 3
    
30.        
    
31.         #define ELEV_STATE_NONE 0
    ; `: J( {; \) r4 H0 \( |3 _: m
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    
33.         #define ELEV_STATE_OPENING_DOOR 2
    - `2 N7 v+ Z' T; `+ ?
34.         #define ELEV_STATE_DOOR_OPENED 3
    
35. 
    1 [' t) O! U: P& w8 I7 y
36. 
    
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    ; J1 _$ m7 Z( `
39. 
    * M9 l# ?: M9 |
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    ' D* M# s8 H/ G1 H0 q7 j
42. 
    + o" @- [- Q% A6 w. j, k* g  ?4 v
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    
44.                 query(
    0 H7 z- j* o+ r0 \8 M
45.                         /** \nFull Query: */
    6 v  R) S  i9 w! C, M
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    " j: w6 F7 s4 f
47.                         nrop(elevDisp),
    * z3 L; U8 P* D# i! h# y9 A1 c; n
48.                         elevator
    
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    % e, `: ^8 o7 }- k$ e* G
51.                         /***/
    & u! C+ s( W9 k. T1 I$ Z! L2 f' Z
52.                         /** \nOrderBy*/
    
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    1 S; ?0 y( x1 U
55. 
    5 @- a0 S) k9 n0 D# }* G& k" W
56.                 if (getquerymatchcount() > 0)
    ' E$ t5 M8 r; m7 P( Z
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    0 y. B6 e5 L/ m1 q6 M. D
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    $ O& T9 E: C* J( t4 r! b/ \) t
62. 
    & e4 O1 P- Q8 b& z+ ]$ _9 S9 ]. y
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    
64. 
    
65.         // Create the task sequence for the elevator
    9 G) W5 o6 ]+ ~2 ~2 c
66.         double destZ = zloc(destCP);
    1 _. N' X2 @" ]8 B) Z
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    $ v! x5 F+ V, p
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);
    
71.         // travel to the z location of the current control point
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    * T; h1 ~* T/ l* W
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    ) ?" Z5 n9 [  c9 L
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    4 C2 l  C7 E, m( G& p" d- g  B
75.         // then wait for the agv to get on
    
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    / p' B% L& S. d* _* r/ x
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    ' y+ O$ z' X2 ?, {# y
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    6 X  ^  P1 s+ j
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    8 x3 s1 w9 W+ A1 z. b+ `
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
82.         dispatchtasksequence(ts);
    , k' ~# y1 I( [. W  G: K/ Q4 ~1 O
83. } else switch (operation) {
    # X7 b/ h2 w5 n0 U
84.         case ON_ELEVATOR_START: {
    3 ^) a4 t4 l: a4 z. }7 q
85.                 // this is fired when I get a valid elevator
    3 I- T( {) Q0 k7 x
86.                 treenode elev = param(1);
    
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    
88. 
    2 u( _* x& M, \3 c5 t! S6 S# W
89.                 // find the closest floor control point
    2 L5 u' `5 j( W
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    . ~0 E9 K5 J# B4 k) H" ]
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    $ z, S% i; l6 G% z
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    9 }* u7 h: y4 Q" t+ r
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    . M0 y. V& F8 m9 ]% w6 d
95.                 if (!objectexists(curFloorCP))
    , K1 K$ m% x/ i  Y" ]" n. B
96.                         return 0;
    ; R4 G& D0 N3 y
97. 
    
98.                 // get the entry control point
      K- f) l) @7 E5 `6 Y9 Z" L& Q6 T2 y
99.                 treenode floorCP = curFloorCP;
    ) L. ~( J: R' v7 A
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     
101.                 if (!objectexists(curFloorEntryCP))
     
102.                         return 0;
     
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     ! p. {5 k, P; ]- C. N
106.                         return 0;
     ' l; v7 F8 O9 L9 h$ r
107. 
     , b' R0 Z+ o" U/ z5 |
108.                 double destZ = param(4);
     : S. Y3 G! Z1 i; s
109.                 // find the floor control point closest to the destination floor
     $ v3 n  h* y  t  M
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
       d0 I4 u, T# g6 E
112.                                                         cpconnection(elev, floorCPCon, count));
     " i; W# Z) }& P* j
113.                                                        
     + K) L: u; e6 [% P
114.                 floorCP = destFloorCP;
     + Y! N0 Z2 r: a3 O. z' }3 d7 F
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     9 X  i( w' r# C% q3 ^
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     
118.                 // get the destination exit control point
     
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     
122. 
     
123. 
     
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     ! A- s: \# N7 p: @1 F
125.                 // agv arrives at a node. I keep a state on the agv's state label, and then increment it each time
     * U& o/ y+ s( x" E, V1 G9 j; L. V
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     # y  P1 r1 q" X. b
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     / K8 E) \1 c$ D
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     6 x: m. [; v  ^6 H* Q" k4 V
129.                
     + g4 b7 K! g- x" L" _
130.                 // set the data on the state label
     9 Y7 E$ v! b2 m4 `4 w  ^+ n, p
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     3 S/ ~- a0 H- K7 O3 O( P  p6 y+ i
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     - d; B* \* f$ \4 F# e: }! j
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     3 J, K! e  c6 Q9 O& F
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     1 k- _3 H, H# m4 r0 H* i
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     . m) H' U  h' ]# I9 @
139.                 return 0;
     
140.         }
     
141.         case ON_AGV_AT_CP: {
     1 R# h' u8 Z% V0 c2 n: w
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     . W6 F3 W- |: }6 J/ ?# N4 W  J
143.                 treenode agv = param(1);
     # j* z; Z& O" c3 N  G, z
144.                 treenode elev = param(2);
     - `" \( V  w4 i" Z7 q4 I& k$ L
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     # O: g; N5 ^% ?4 h
146.                 // I increment the state label, and then switch on it
     
147.                 inc(stateLabel, 1);
     
148.                 switch (get(stateLabel)) {
     % }  k5 M5 _' L/ c* A/ c; q
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     
151.                                 // so, figure out where the elevator is.
     ' I# |' n) x# S2 B9 g4 l
152.                                 int elevState = get(node("ElevState", stateLabel));
     
153.                                 // if he's at the pickup floor with his door closed then open the door.
     * Y% n1 _. ^2 ?* |/ e* `
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     0 P; o  u8 J; Y$ }3 p% W
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     9 w2 Q( a" e1 B9 m' \* C
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     
158.                                         // the elevator cp
     
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
       h0 F' ?$ t7 [( o' B$ v3 G9 b
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     2 p0 n2 t& N: m$ c5 h4 B3 ?
162.                                 break;
     
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     
165.                                 // once the agv is at the elevator cp, close the door
     # k+ w2 {7 J- t6 D1 v  m
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     ) m% }5 z8 K- m+ B; A! Y8 ?5 n
167.                                 break;
     
168.                         }
     
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
     
172.                                 treenode listenerNode = param(4);
     
173.                                 destroyobject(listenerNode);
     / N( _; V; [+ ?: {2 }
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     7 P/ l" ?! P  q0 m& ?
175.                                 if (!agvWait) {
     
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     4 v$ e4 @# V' Z' Z  Y
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     6 `' Z+ n! K  J8 ]0 L5 {& }, C
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     
179.                                 }
     
180.                                 // close the door
     : g" c6 l4 }! f. o5 m% o( T7 v
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     6 p( K$ o: a4 t1 S
182.                                 // and I'm finished with the state label so I can destroy it.
     
183.                                 destroyobject(stateLabel);
     
184.                                 break;
     
185.                         }
     - T, y$ x/ ~2 G* g
186.                 }
     2 w4 p: l& D$ B8 V3 y1 T
187.                 return 0;
     2 w/ E) H! g7 R, f) }" i
188.         }
     ) o2 Q- [/ z9 |6 y  O
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     
190.                 // the elevator has arrived at the pick floor
     ' }1 b# k, U1 U: J! R
191.                 treenode elev = param(1);
     
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     ' W) t& r8 R/ P: `  |
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
194.                 treenode elevState = node("ElevState", stateLabel);
     $ ~' S* F* U7 `
195.                 // set the elevator state to at-pickup-floor
     3 u7 l! B! B& S3 c3 ~
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     
197.        
     
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     . S3 H) n& a3 Y2 F5 @
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     " m& X  `7 {3 C0 r. [
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     4 M& w& Z# u; \
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
       E9 R/ F. h9 A' ?- O2 ]
204.                 }
     6 g5 Y6 C  F5 ~1 p
205.                 return 0;
     
206.         }
       n2 \6 N7 K$ I! Z( U2 b* `
207.         case ON_OPEN_DOOR: {
     1 i/ r$ z- D5 y9 U( f; d) a
208.                 treenode agv = param(1);
     ' \0 L' V; h% i! |, w
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     ) U6 b6 z" m9 w
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);
     
214.                 return 0;
     
215.         }
     ' w( f. m& w8 M4 @8 k7 T
216.         case ON_CLOSE_DOOR: {
     8 Q+ H. f5 D1 s; R
217.                 treenode agv = param(1);
     8 C" N: n; s) J/ _2 n
218.                 treenode elev = param(2);
     
219.                 int nextStep = param(4);
     1 N9 V# P3 X" S0 @3 t) Z
220.                 // close the door base on the time to close the door
     , `- l# h9 G- y
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     7 J) |. m: U9 z  e: d+ n' I
223.                 return 0;
     5 Q2 ^  V" {6 U+ D9 }6 J9 ^4 c
224.         }
     
225.         case ON_PICKUP_DOOR_OPENED: {
     9 `* L" p; v6 T7 H6 k8 x
226.                 // the elevator door has been opened on the pickup floor
     & `6 \- Z( f: z  ~; }+ Z
227.                 treenode elev = param(1);
     
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     " p1 H; y3 u; n/ ]0 p
229.                 treenode entryCP = cp(agv);
     
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
232.                 treenode elevState = node("ElevState", stateLabel);
     & K7 J; i6 F' V9 g* R8 D: E
233.                 // set the elevator state
     
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     ! f: B/ ]2 a5 P$ f
235.                 // if the agv is at the entry control point, move him to the elevator control point
     1 _3 _4 j$ l! d1 k
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     1 d/ M) v. V3 T) m" L+ g/ }: \
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     
239.         }
     9 ]  e" A0 e9 w/ W
240.         case ON_PICKUP_DOOR_CLOSED: {
     
241.                 treenode elev = param(1);
     , ~- F& ], r6 L3 C! o, }
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
243.                 // assign the agv to "no control point"
     + ?1 Q6 D4 @% P. V
244.                 agvreassigncp(agv, 0);
     - \! T: |' [: `9 C* K/ F- V
245.                 // move the agv into the elevator
     ) J  p6 l! J, m0 O
246.                 moveobject(agv, elev);
     ' v# y& y/ b8 \& Z) g
247.                 setrot(agv, 0, 0, 0);
     : w1 |7 }" D: Y. H# w0 @$ a8 a
248.                 // release the elevator to continue to the destination floor
     0 M$ N' z. }( ^4 m
249.                 freeoperators(elev, agv);
     
250.                 return 0;
     % }( Y4 a5 C9 S0 B7 l
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     7 H' f( {. R7 Y9 Y. v( A3 G
253.                 treenode elev = param(1);
     ; O. r7 }( W; h8 T: C
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
     9 q) G4 w  ]/ v! B2 c( _" W
257.                 moveobject(agv, model());
     # ~# v  Q( l  w( M
258.                 // reassign it to the destination floor control point
     6 t6 N' u( x- i, G, u
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     
260.                 // open the elevator door
     $ y6 m/ `' a" r9 X+ g- ]! ^4 N; g5 k
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     
262.                 return 0;
     * g$ H/ S7 \1 `; i. K2 d9 b$ e
263.         }
     
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
     2 W7 S% A  ]* h( i0 }/ M
266.                 treenode agv = param(2);
     - M; G  j- C% }+ _$ p, W+ F
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     
268.                 // once the elevator door is opened on the destination floor,
     
269.                 // redirect the agv to the exit control point
     . K1 S4 h0 C) E) ]( A
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     ; h# c' l3 J/ t) M) M) |
271.                 return 0;
     ( b0 a( u! b; @8 |( H
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
       l2 Z: R! q/ O* y
277.                 // once the door is closed at the destination floor,
     
278.                 // if the agv is waiting, then send him to the final destination
     
279.                 if (isAGVWaiting)
     
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     
281.                 // release the elevator to finish his task sequence
     . z8 H# M- ]0 T9 v$ \0 ?; p
282.                 freeoperators(elev, agv);
     
283.                 return 0;
     % d% O( T. O: Y# @) a$ _- c
284.         }
     
285. }
     
286. } //******* PickOption End *******\\
     
287. 
     6 \( {1 s8 g  c5 ?9 ]

复制代码

办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
办法1：从2016版本里面复制相应的代码
0 K& W  m7 D8 V2 Y
具体代码如下：

9 Q  O9 w, `0 U) V6 B好的，非常感谢陈老师的解答~