2018.2.0版中AGV如何乘升降机？

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

办法1：从2016版本里面复制相应的代码
; E9 X/ p& X4 l6 M) r! D5 V9 V
具体代码如下：
: U8 \9 w* a. L# v$ t! [5 `

1. treenode agv = param(1);
   * n+ s) q6 v, A! D. w9 I
2. treenode currentCP = param(2);
   : R  n& H# j1 L' p. s
3. 
   " ?1 k5 H* [+ \( @- T
4. { //************* PickOption Start *************\\
     W. ]" d, @  \: g. @! p+ n: t( x
5. /***popup:AGV_DivertToElevator*/
   5 o/ p, e' k' A2 r/ f8 ^+ o
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   
8. int operation = param(3);
   
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    0 ^9 i4 c( t4 u9 }$ S4 |7 }5 w
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
    ) d% |- @* f' Z; X- [+ M; [+ A
13.         // initial trigger execution
    ' S1 Z  ^, d3 v  _$ I1 w
14.         #define ON_ELEVATOR_START 1
    2 ]( E3 k7 o$ {! n, ]% E9 `
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    2 t7 R" c0 j5 B- J( M
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    
19.         #define ON_OPEN_DOOR 6
    
20.         #define ON_CLOSE_DOOR 7
    + j. B/ Z; P+ c8 J1 C# i
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    / N, G) ^1 S/ s/ q
23.         #define ON_DROPOFF_DOOR_OPENED 10
    
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    $ V$ |5 F5 Q% n5 k1 c
25.        
    
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    % t+ \* _  r* S1 P, ^3 B* l" A( e0 W# {
28.         #define AGV_STATE_AT_ELEV_CP 2
    
29.         #define AGV_STATE_AT_EXIT_CP 3
    
30.        
    2 B2 C' y2 r/ ^! |
31.         #define ELEV_STATE_NONE 0
    ( v) G# Q2 {1 u2 T4 [  }8 n8 o
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    
35. 
    / z9 ^: L3 x8 N
36. 
    5 X* l3 R7 W! q' }& u6 p' @$ x. X3 y
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    ! z' v+ z& v; x1 K- Y4 Z
39. 
    
40.         if (!objectexists(elevDisp))
    9 D% b) N) X+ E# ]
41.                 return 0;
    # B2 r7 R8 D$ S8 Q" a
42. 
    ( q* I9 h. C9 p; b, f* O
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    3 v' v8 ~& B) V6 S
44.                 query(
    / b9 W2 p) z1 F1 o
45.                         /** \nFull Query: */
    
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    & w/ K- Y# v: j# V: p' p
47.                         nrop(elevDisp),
    
48.                         elevator
    . A* ]! S' D1 E+ i( R$ ~
49.                         /** \nWhere*/
    4 w3 i, u: z% \! Z5 j; d8 D
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    
51.                         /***/
    
52.                         /** \nOrderBy*/
    0 q& d' i: P& T. t( i) v% i. {
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    5 y' _, E* G+ U4 j4 a
54.                         /***/);
    & a6 p, g3 u1 s5 s
55. 
    
56.                 if (getquerymatchcount() > 0)
    
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    
59.         if (!objectexists(elevDisp))
      @1 I/ s* j- P$ x0 T8 i
60.                 return 0;
    5 G0 r: k' T, J8 @. F7 m" r
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    " S% R: l2 L. H) e* {
62. 
    * R, w  }5 {6 P9 A- ?; M5 ~
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    ; \3 b8 H- x! x0 i1 r" U
64. 
    1 k& ~8 I8 e7 {. j1 t
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    . z" e1 J0 a) J- c
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    
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);
    
71.         // travel to the z location of the current control point
    ; M' J# K8 V% w( b( t% h5 ?
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    8 V* g8 ~6 r2 a  H+ c2 J+ M
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    ; l- S  W8 }* x8 A+ Q, O) _
75.         // then wait for the agv to get on
    * X. r; k3 {& Z( e( Q
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    / i4 y; S# x" U* A0 F: W6 @
77.         // then travel to the destination z location
    ; u3 F; y, _. O) Q! d* C2 Q: E% G2 G+ e
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    4 u8 f; G3 l7 |7 w7 g8 Q
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
82.         dispatchtasksequence(ts);
    
83. } else switch (operation) {
    5 X& @, d9 v* L) g3 [: L5 g
84.         case ON_ELEVATOR_START: {
    3 y" e  j- @5 r% f3 H
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    : i# {- R! Q3 ^5 p2 _) V
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    % `" f6 a8 {( b. `
88. 
    6 `, r: A0 v9 m7 c  R
89.                 // find the closest floor control point
    ' Z. e7 J! ~" D7 B: k# p
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    $ @  P0 g( f* X8 n# h' g( L
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    ; d( |, S7 f& V0 J
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
    
96.                         return 0;
    0 I4 c9 O8 y: ^3 V0 Z4 R
97. 
    6 e& {$ I" V! F: n, T6 J
98.                 // get the entry control point
    
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     . b9 I0 g* H$ z4 Z" |
101.                 if (!objectexists(curFloorEntryCP))
     
102.                         return 0;
     
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     
106.                         return 0;
     & H1 l, j# }2 t- Z1 y* q  X
107. 
     . \" @7 n2 v! b# B  y  ^  T2 q
108.                 double destZ = param(4);
     % t& k# W# E) q5 z) h; h' d) F
109.                 // find the floor control point closest to the destination floor
     
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     6 A. ]. U1 n9 t& W5 E
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     
112.                                                         cpconnection(elev, floorCPCon, count));
     ! f8 r) N- o/ p, z
113.                                                        
     . L: a) Z5 L" e/ D& t
114.                 floorCP = destFloorCP;
     5 j& P/ W5 y, T* H8 W
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     9 q/ x/ F7 @! l6 o" t
116.                 if (!objectexists(destFloorElevCP))
     9 Q( P1 s; t/ C% U8 T( M& L
117.                         return 0;
     * {) Y9 v: L2 Y: R' v
118.                 // get the destination exit control point
     4 C$ g  j/ H, c, s  g/ b+ K7 g
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     9 y* P! b" q. K1 p2 [+ x
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     
122. 
     , t1 Z0 C& i/ r1 n
123. 
     
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
     . Y0 P* \% c, S: q) h/ q. C$ f) ~
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,
     : f0 B8 E, d+ T/ k& O+ L
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     ( J. \- f. ^& k8 w. M, h
129.                
     ! c$ {8 S( E9 o, l! ?! ~
130.                 // set the data on the state label
     
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     4 d1 |+ d% g! x' n" J
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     , S4 D, h( W- @% ?: k- F% R
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     2 V  q( y7 W% i4 D" ]
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     7 V3 ~; m* D* ^* U2 f+ _
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     * B+ c2 F9 c- q( i# w
139.                 return 0;
     
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);
     9 d: K5 y( A) i- k+ T% q
144.                 treenode elev = param(2);
     
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
146.                 // I increment the state label, and then switch on it
     
147.                 inc(stateLabel, 1);
     1 K( |. q' S" z
148.                 switch (get(stateLabel)) {
     
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     4 T1 B6 d, ~$ _+ `
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.
     & |- x, P1 t2 t/ `4 m1 n0 N& f9 L$ C1 d0 i
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     3 [6 l# o6 B9 U" _! r& }
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     . G* N: r! C: P4 s, f$ t' l/ Y
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     9 L0 p9 w- n: J8 h( q
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     $ f- J3 |* S9 Q1 m0 u
158.                                         // the elevator cp
     8 n5 z9 D4 G& d, E* A
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     # g* {3 G2 [% B+ @: L8 C
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     ' K- J& Z! T9 Y8 D6 x* q5 V% i
161.                                 }
     . m  e6 i7 N( O: O$ d6 G, p1 I! b
162.                                 break;
     
163.                         }
     ( p/ P- u9 n4 h
164.                         case AGV_STATE_AT_ELEV_CP: {
     
165.                                 // once the agv is at the elevator cp, close the door
     1 [% F% p7 X9 c
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     
168.                         }
     % k. j$ i+ u( i  i% |" o
169.                         case AGV_STATE_AT_EXIT_CP: {
     
170.                                 // the agv is at the exit cp
     ) R# R8 |/ q5 o+ ?% b$ U0 l' z
171.                                 // destroy the listener node because I'm finished listening
     
172.                                 treenode listenerNode = param(4);
     9 |! Y+ W( q8 c! m' ?
173.                                 destroyobject(listenerNode);
     
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     1 U- a( t) p/ M4 s- ]& ], M3 V9 {& C
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);
     & y/ U4 T* E# P- J0 i
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     ( v# [1 j) K3 ?2 d- f
179.                                 }
     
180.                                 // close the door
     % g' l3 R- o4 T; M4 D5 L
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);
     
184.                                 break;
     # O6 `% `- P7 t/ F1 F
185.                         }
     " c% r9 w* E1 e& p* W: \
186.                 }
     
187.                 return 0;
     
188.         }
     : ?* ?' {3 e* x5 c
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     2 e; C# D  f0 Q# k( u( c
190.                 // the elevator has arrived at the pick floor
     
191.                 treenode elev = param(1);
     
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     : q! E; w8 L3 v6 _' |3 P, `# @
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
194.                 treenode elevState = node("ElevState", stateLabel);
     : D8 {% p1 t$ Z- |# F
195.                 // set the elevator state to at-pickup-floor
     . {% j8 p% J, f: m, \+ t
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     
197.        
     
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     2 s, o" f- \3 w: w
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     + L3 [  B$ X7 ]& S9 K* B
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     ' p- |$ p" O$ m) p7 ~' E# S
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     3 t* J% Y! p( @, j
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     5 E8 Q; h) m2 ?" c7 k* o
204.                 }
     
205.                 return 0;
     4 `6 s9 z3 Y/ N. S, n! Q
206.         }
     
207.         case ON_OPEN_DOOR: {
     : |. p1 U* g* N
208.                 treenode agv = param(1);
     ) G  P8 A9 p# D% d1 F- |) f
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     
211.                 // open the door based on the time to open the door
     7 V5 D3 r8 n2 A- z; W5 |
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     . z4 `  q& Y2 {4 t0 X+ B2 k1 Y- h# H
214.                 return 0;
     6 E: i4 S8 c$ k" f
215.         }
     5 X7 O' t. N; ^2 t
216.         case ON_CLOSE_DOOR: {
     ) \$ O6 o; m" @: W8 A) j4 C
217.                 treenode agv = param(1);
     2 Q4 Q9 D  F  p, i% ]* C3 V
218.                 treenode elev = param(2);
     
219.                 int nextStep = param(4);
     6 v, a( x  K7 S- N2 w% R
220.                 // close the door base on the time to close the door
     1 F! G" @) {, z; |3 ^
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     0 n2 A9 m, d) L7 l1 V
224.         }
     + F% E7 ?. J; [. L6 U
225.         case ON_PICKUP_DOOR_OPENED: {
     1 r# ^- u( y, }6 f
226.                 // the elevator door has been opened on the pickup floor
     1 S4 n8 m5 X7 T/ d
227.                 treenode elev = param(1);
     + X, _) g3 J  C
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
229.                 treenode entryCP = cp(agv);
     / j" j  b5 [9 {1 r2 `& v! Q$ u+ t. @
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     " _0 p* ^# N3 F- m, q" W$ h  }
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
232.                 treenode elevState = node("ElevState", stateLabel);
     
233.                 // set the elevator state
     
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     
235.                 // if the agv is at the entry control point, move him to the elevator control point
     * A1 T9 z7 @4 h( G$ x
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     2 r# U7 i+ O# O8 i7 u. l  s
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     ; p" Z- B* z+ t% H8 x7 T
238.                 return 0;
     1 A7 x- O* J; z* q1 G- r% G8 w$ i
239.         }
     # [9 U, }1 E; T( s
240.         case ON_PICKUP_DOOR_CLOSED: {
     : E& p. z0 {9 {' C4 v- l3 ]
241.                 treenode elev = param(1);
     
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
243.                 // assign the agv to "no control point"
     & {: ~' z" E; m6 ~
244.                 agvreassigncp(agv, 0);
     : l) V. r4 d# m; t& @
245.                 // move the agv into the elevator
     
246.                 moveobject(agv, elev);
     
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     
249.                 freeoperators(elev, agv);
     
250.                 return 0;
     
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     " S6 f3 D9 [; \! A; K0 ^
253.                 treenode elev = param(1);
     9 h6 N1 S$ q7 u/ D9 J8 I
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     $ O0 _) l$ m+ I3 x; W. a1 Z! x
255.                 // when the elevator arrives at the destination floor
     
256.                 // move the agv back into the model
     1 U% j- W, `8 i8 _( Q$ ]
257.                 moveobject(agv, model());
     
258.                 // reassign it to the destination floor control point
     , C# }0 [8 V; E* u
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
       [! x  E" W! S! `& ]7 E' y
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     7 s/ J5 c6 t. {* f4 }9 K
262.                 return 0;
     
263.         }
     
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
     1 g( W% R- l; Z) A3 J; K1 x
266.                 treenode agv = param(2);
     
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
     " Q& h3 X8 Y( L" Z8 U
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     
271.                 return 0;
     7 n- X0 N9 _/ C
272.         }
     - |% k; u$ o3 T4 E, ~5 M
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
     
277.                 // once the door is closed at the destination floor,
     
278.                 // if the agv is waiting, then send him to the final destination
     7 m$ x& u/ e7 k
279.                 if (isAGVWaiting)
     
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     - v" \  J- P  v) k, F: }8 B% U
281.                 // release the elevator to finish his task sequence
     
282.                 freeoperators(elev, agv);
     ' o0 u( u: C" z5 B2 r1 A& d
283.                 return 0;
     5 m/ o1 B' h+ P
284.         }
     
285. }
     # ?! D7 I- x. w3 L
286. } //******* PickOption End *******\\
     
287. 
     ( S1 [/ I8 k( i. ?' |

复制代码

! H( I8 u5 `3 M( t- J- I
! d8 L+ L2 j! v: i9 c% k办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
  y4 r" M2 z9 b办法1：从2016版本里面复制相应的代码
# f3 Z; P( R+ C
. d# P# w8 x# D% ^" Y: Z: l. L具体代码如下：

9 J+ J8 K6 w" A8 `& E( v. z2 ]5 S. S好的，非常感谢陈老师的解答~