2018.2.0版中AGV如何乘升降机？

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

; r5 T- ~1 {5 `$ y

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

( a: R, A: z$ {# H4 I! w# |! _$ g/ z具体代码如下：
& ~4 \- L- `0 h' d+ x* s: R

1. treenode agv = param(1);
   % f( V/ S3 z3 W6 }( J4 V9 m
2. treenode currentCP = param(2);
   
3. 
   $ q/ s2 N% V! v* |; V' B8 d
4. { //************* PickOption Start *************\\
   
5. /***popup:AGV_DivertToElevator*/
   : `3 i2 [) n$ F' R( J1 s$ _
6. /***tag:Description*//**Divert to Elevator*/
   ! u  O6 K' H: \' H( z1 n: r7 ~. {
7. 
   
8. int operation = param(3);
   ; t; ~9 g3 r$ C2 C7 M
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
    
14.         #define ON_ELEVATOR_START 1
    : x0 c$ {- S  a1 g
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
    " A# t  z! x: ]9 ?9 x
19.         #define ON_OPEN_DOOR 6
    ' I- A+ B0 d5 `1 z/ [4 F6 ~* p
20.         #define ON_CLOSE_DOOR 7
    5 C* }! O1 a4 q7 z$ O) k
21.         #define ON_PICKUP_DOOR_OPENED 8
    & b! j" f/ s' P# e8 _6 `: z
22.         #define ON_PICKUP_DOOR_CLOSED 9
    
23.         #define ON_DROPOFF_DOOR_OPENED 10
    / |4 b% d! Z/ b) h
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    
25.        
    
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    
28.         #define AGV_STATE_AT_ELEV_CP 2
    
29.         #define AGV_STATE_AT_EXIT_CP 3
    ) N0 l- l* M/ B% h/ \  _5 g
30.        
    
31.         #define ELEV_STATE_NONE 0
    . D3 f& G* j) p" U# H- v+ o* d
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    3 H: p$ B/ O# `1 {* c- B8 F  e
33.         #define ELEV_STATE_OPENING_DOOR 2
    + c7 K3 v$ K( v) @  t* N' S, G- t
34.         #define ELEV_STATE_DOOR_OPENED 3
    8 J/ _: Z: i; y' M+ F4 Y
35. 
    7 M/ ?% M* U3 \2 {' p
36. 
    
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    3 H2 n/ G1 }5 X' S: J
38.         #define elevator outobject(elevDisp, $iter(1))
    + P' C% r7 U+ b
39. 
    
40.         if (!objectexists(elevDisp))
    8 W5 ?% O7 V6 |; m% O" }
41.                 return 0;
    
42. 
    
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    ( h2 @4 N1 [2 i' t6 ~& G) y
44.                 query(
    % J& ~6 j- K7 x4 @1 L0 P7 ?/ m
45.                         /** \nFull Query: */
    * Y1 z( J' W( H! W7 ~
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    + M9 V4 U3 Z6 i0 N
47.                         nrop(elevDisp),
    6 [$ K0 M$ c' \0 ]( Z$ G
48.                         elevator
    
49.                         /** \nWhere*/
    ' Z# E/ c. o. m9 G
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    2 g' l( y5 d5 m5 g9 B/ n! O* j
51.                         /***/
    # N; D. Z  f8 ~& M9 J, b; K* {9 }
52.                         /** \nOrderBy*/
    # G$ Q; W) A8 A8 P8 X4 Q* @6 J
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    2 U% G# D% A8 z
55. 
    
56.                 if (getquerymatchcount() > 0)
    
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    8 ]; w1 r( n- H9 v2 N% B' M) N( M2 \
59.         if (!objectexists(elevDisp))
    ' C+ Q0 n- J4 C* m0 J
60.                 return 0;
    
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    1 @5 P8 b2 b  j% D6 U2 e5 j/ h
62. 
    
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    
64. 
    1 w- i* w" E3 O) F- E. j
65.         // Create the task sequence for the elevator
    8 U1 p6 L6 n* u4 y, v- {1 C' k/ }
66.         double destZ = zloc(destCP);
    " g, u. V& o4 k: g/ ~+ |6 d
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);
    / j6 f$ ?* ]5 O  J  q2 A1 u
71.         // travel to the z location of the current control point
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    1 H& h7 Z+ n5 o; T& D8 C* e0 ~+ T
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    ) z0 f9 e! e' o" g; `
75.         // then wait for the agv to get on
    
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    : x1 H- U3 c& A1 G5 G3 W. K7 s
77.         // then travel to the destination z location
    
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    1 a( k. m" S: K, B/ T: n
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    0 R3 U9 a- O: a0 B: a
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    $ M$ s0 K0 c: b* R1 }
82.         dispatchtasksequence(ts);
    
83. } else switch (operation) {
    
84.         case ON_ELEVATOR_START: {
    ! b, Z8 _, j  J1 b/ c8 x
85.                 // this is fired when I get a valid elevator
    8 f% q, a0 E5 z6 ]
86.                 treenode elev = param(1);
    ! _; M. R8 N% y+ J9 L* t
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    + k' N: N( X* F) F, `
88. 
    
89.                 // find the closest floor control point
    + d- Q) U2 u- [3 h( g
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    . R. y! z. r* g, _4 W' K# `
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
    
96.                         return 0;
    
97. 
    5 R0 u4 i4 C" a: g/ u; a5 A% w! _/ U5 G
98.                 // get the entry control point
    
99.                 treenode floorCP = curFloorCP;
    - m" `; Q7 Q2 \" v
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     
101.                 if (!objectexists(curFloorEntryCP))
       _! F3 s$ k0 }+ l; T
102.                         return 0;
     * P- r3 v" i( v: \9 @
103.                 treenode floorEntryCP = curFloorEntryCP;
     & _4 t- m0 q% E/ H5 d
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     $ A$ W- C5 ?" P% q3 U
105.                 if (!objectexists(curFloorElevCP))
     
106.                         return 0;
     ( @! r9 r3 X# ?  f3 E7 f6 L% O( l
107. 
     & u/ Z. M3 A  h/ ~2 G  V  w
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     , h/ p% g6 b$ ]- ?# t
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     
112.                                                         cpconnection(elev, floorCPCon, count));
     " ^8 Q0 j& _% u: h. l# w4 z
113.                                                        
     
114.                 floorCP = destFloorCP;
     
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     2 H- M! a- U7 b5 t1 Z: p: F
118.                 // get the destination exit control point
     
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     
120.                 if (!objectexists(destExitCP))
     7 n- j6 q( o3 s$ R
121.                         return 0;
     
122. 
     - [3 u& q2 ?! O) ^' r
123. 
     7 o' I4 X& T4 M8 D' a" x# D
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
     
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     9 d( u9 P6 n( ^7 `( Z' N5 D6 a' P
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     
129.                
     
130.                 // set the data on the state label
     & i" T& d) ^" a9 k$ G' }  K, ^
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     0 v. u% v8 G! S1 r
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     5 H5 D( b* v# Z" @
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     
139.                 return 0;
     ( |1 K7 i8 m( ?0 h1 q, R) _7 l5 }
140.         }
     % M/ W7 N$ R+ L7 V) N
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);
       A! N& E# W" a3 [, w" I
144.                 treenode elev = param(2);
     $ {9 z% J3 ?$ ~, b, k2 u
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     / h! b. B# J1 `7 ?  w4 T
146.                 // I increment the state label, and then switch on it
     0 x9 H) N& r* B: B  [4 }: @
147.                 inc(stateLabel, 1);
     $ V1 Y- c& C/ e" \5 v3 j9 _
148.                 switch (get(stateLabel)) {
     ( Z6 y- d+ D% k4 g. D9 P& g
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     % Z% L- ]0 o# W5 P' `2 S7 ~; U2 y
151.                                 // so, figure out where the elevator is.
     " L2 X3 U: y7 _+ y1 o
152.                                 int elevState = get(node("ElevState", stateLabel));
     
153.                                 // if he's at the pickup floor with his door closed then open the door.
     0 y0 U  K  D* i+ {7 I  V& ^! G& H
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     7 o2 l% p& d4 Q' |" {
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     6 P1 V: n0 ]  N: e6 z8 _( p" E
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     
158.                                         // the elevator cp
     ' v: U1 G; e  r% y& x0 V. O: U
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     % h, H/ U  m- F. R8 @
161.                                 }
     
162.                                 break;
       k9 M2 N* h6 o9 Z) ]
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     ( T/ t. x, [* e+ U! b# s
165.                                 // once the agv is at the elevator cp, close the door
     
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     / Z# t8 B6 j) j$ R) j) ?
167.                                 break;
     ' j. ~; [5 T8 C/ o6 G' G
168.                         }
     
169.                         case AGV_STATE_AT_EXIT_CP: {
     # J9 \9 R2 p2 H* h# i! B/ P
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);
     9 |9 w' q5 Z- T
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     9 J+ G9 c& @- j+ j! _
175.                                 if (!agvWait) {
     7 @* f4 s3 H' }7 P& `
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     3 Y5 k( a" s! _: t" b! ~
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     ( G% o8 ?! m$ Y" h# r" A1 A
179.                                 }
     1 D. }& y) I8 X! h; e1 e8 \
180.                                 // close the door
     
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     ! u8 F: F" S7 F4 t7 z
182.                                 // and I'm finished with the state label so I can destroy it.
     9 ^- b3 B- W) k4 m8 w
183.                                 destroyobject(stateLabel);
     6 I1 N8 o1 y) K5 d- j7 E# x$ h* K
184.                                 break;
     $ J4 h; {9 I/ E
185.                         }
     3 }* t! |& f+ _4 P# R* I  m
186.                 }
     : E4 i$ }: J$ v9 ~  b
187.                 return 0;
     - u' a* W; q* B! N2 J: G" r
188.         }
     7 x: j  q+ u1 \' j/ E
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
       y5 M  {  _4 T& W7 t
190.                 // the elevator has arrived at the pick floor
     
191.                 treenode elev = param(1);
     : Y( n! {9 z* u" T' g* \
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
194.                 treenode elevState = node("ElevState", stateLabel);
     
195.                 // set the elevator state to at-pickup-floor
     
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     ' g% n2 \1 K. b  l- Q
197.        
     
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     6 d% a; m- S8 D% J3 L8 X
199.                
     5 o9 d( \2 V9 B
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     " m3 l4 h7 [$ ?! l2 ~+ r- @
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     2 h* }, Y; O/ T
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     ! M$ o# I. m  {
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
204.                 }
       L6 [+ v4 |8 J+ {
205.                 return 0;
     5 c" z1 {4 m& t! S: }
206.         }
     
207.         case ON_OPEN_DOOR: {
     3 t/ d2 Q5 g: v* G# r& @
208.                 treenode agv = param(1);
     ; S$ x- N) q' V6 C  V
209.                 treenode elev = param(2);
     
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);
     0 d3 K# d! O$ F! f4 r) j- O
214.                 return 0;
     
215.         }
     
216.         case ON_CLOSE_DOOR: {
     ' S) v5 j/ \2 [# _2 F, C0 ?7 |
217.                 treenode agv = param(1);
     
218.                 treenode elev = param(2);
     
219.                 int nextStep = param(4);
     
220.                 // close the door base on the time to close the door
     
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     ! R6 v, E" ~! |) `% ^
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     ( f4 E+ c; B" ~, v
224.         }
     0 D% P' W- G+ L8 p' [7 i$ W
225.         case ON_PICKUP_DOOR_OPENED: {
     
226.                 // the elevator door has been opened on the pickup floor
     + c- l1 t+ a5 @7 l
227.                 treenode elev = param(1);
     , p- K) M; |7 L7 k. ?& W6 r
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     ! x- U4 G+ n) x' v" e( o# D
229.                 treenode entryCP = cp(agv);
     / O* ^6 b' s8 {7 Z, ^
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     8 j4 u( g* s+ c
232.                 treenode elevState = node("ElevState", stateLabel);
     : I7 Y3 L* ]# O& k! E2 X
233.                 // set the elevator state
     & ~4 b9 Z  o$ O  x* X: C
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);
     ) F/ P8 H. ?: X& T. r
238.                 return 0;
     - J6 w: i/ K( }' V& u5 u
239.         }
     
240.         case ON_PICKUP_DOOR_CLOSED: {
     9 _* D, M1 Z% [% n
241.                 treenode elev = param(1);
     
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     1 z4 _- w6 U. P0 i
243.                 // assign the agv to "no control point"
     
244.                 agvreassigncp(agv, 0);
     % r4 A2 K/ ~& i
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);
     - \1 e2 `7 B; u  {1 C' O3 i
250.                 return 0;
     
251.         }
     # T* G: R6 S5 {8 M
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     0 O+ p: n3 h7 P# m2 s8 }
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
     
257.                 moveobject(agv, model());
     5 _, f' m* w, P2 o) |- F3 T% l. m
258.                 // reassign it to the destination floor control point
     
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
       I+ t% H1 @" I3 w
260.                 // open the elevator door
     4 A; `! F2 O/ x% N$ W- ^! v9 |1 r. r
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     
262.                 return 0;
     & f" p& U* B( N! ~, @+ H# m2 i
263.         }
     7 r% O' z4 L( \4 \5 Z/ d- M
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
     1 ^& M' R* z! f: E
266.                 treenode agv = param(2);
     
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     
268.                 // once the elevator door is opened on the destination floor,
     1 U$ \6 n; h0 U: U- y- `8 ~
269.                 // redirect the agv to the exit control point
     $ g, h9 p. Y  E2 t# |8 Q
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     + W3 J: s9 y( R4 E8 O
271.                 return 0;
     
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     6 L0 g. h9 `4 w! j3 q2 X- h2 n* Q# B
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,
     ; c) M: A) @. C# a  ]. H
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
     $ t" Z! N& L- i1 f3 E
282.                 freeoperators(elev, agv);
     
283.                 return 0;
     
284.         }
     
285. }
     ! J9 i, h3 e: P
286. } //******* PickOption End *******\\
     
287. 
     

复制代码

6 t2 n7 C. L+ n5 o. O0 u
( B+ J( B# D, ^& @% N- p8 J
- S& S+ D$ U: Z2 a2 p* q8 X办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
办法1：从2016版本里面复制相应的代码

具体代码如下：

7 O: X, J2 F) F" Y2 B7 \8 ~) l好的，非常感谢陈老师的解答~