2018.2.0版中AGV如何乘升降机？

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

  a- b7 R( J% V/ T

办法1：从2016版本里面复制相应的代码
' n( q2 W1 K3 |
; \# w  r- M1 ?2 ]具体代码如下：
0 \1 L' k+ I% Q: z

1. treenode agv = param(1);
   
2. treenode currentCP = param(2);
   
3. 
   7 B, C4 n' f# M  C
4. { //************* PickOption Start *************\\
     C  z! z8 r% l, j& \! D
5. /***popup:AGV_DivertToElevator*/
   
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   
8. int operation = param(3);
   - N- _4 G: M  Q- B% G* K& i
9. 
   ; ~! x8 _6 x, }! n  h
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    # u) f+ w8 j& g: V, z. e4 L7 J  A" O6 b
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
    . V4 |! H( w: R1 W- s. S
14.         #define ON_ELEVATOR_START 1
    
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    + W8 `! a& a2 ~4 b( J
17.         #define ON_AGV_AT_CP 4
    ( H( m* Y: q4 S- v! _; x
18.         #define ON_BOTH_AT_PICKUP 5
    ! d5 T0 M! u. c' o2 t8 d
19.         #define ON_OPEN_DOOR 6
    1 s+ r0 O! c0 o" c/ \
20.         #define ON_CLOSE_DOOR 7
    4 U/ B. @$ c0 F) J
21.         #define ON_PICKUP_DOOR_OPENED 8
    / L& }- `  P. Z: n. \
22.         #define ON_PICKUP_DOOR_CLOSED 9
    
23.         #define ON_DROPOFF_DOOR_OPENED 10
    0 w: V$ T+ Q1 S! y, T; b
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
    
30.        
    
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    
33.         #define ELEV_STATE_OPENING_DOOR 2
    - E( C5 r' w3 z* z2 F' m: r
34.         #define ELEV_STATE_DOOR_OPENED 3
    $ {& h- ~" c9 J; x
35. 
    
36. 
    3 f/ B8 O8 D/ B. s% P0 g
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    
39. 
    
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    + L( A$ h4 B$ [9 N! [, [
42. 
    2 V/ }# X* f0 a" @5 t1 m, i4 ~
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    
44.                 query(
    0 k4 l+ I" s9 {$ B- }
45.                         /** \nFull Query: */
    
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    
47.                         nrop(elevDisp),
    
48.                         elevator
    
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    ' U2 j: ~% ~( G8 Y
51.                         /***/
    
52.                         /** \nOrderBy*/
    + d+ r7 P6 O0 }
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    
55. 
    , w$ j% _7 Y* Q* d8 d' O; O
56.                 if (getquerymatchcount() > 0)
    
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    6 K- b( F/ u: l7 {5 i
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    0 B! G0 N$ l0 t, L3 m8 |$ D% w" e1 Q
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    
62. 
    
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    7 Q/ W( u1 i7 t8 {( o3 |7 s
64. 
    ' p: I& S0 `; g0 ?3 R7 ~
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    # V' R6 A9 p8 E6 ~
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
    # a, n* _1 K* e, V" {$ N% P8 o
70.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_START, destZ);
    
71.         // travel to the z location of the current control point
    2 a2 z/ w' @1 L# O4 s
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    $ l5 R9 u5 ^; J- f: Y
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    8 U' r( F' O2 U! X2 S5 y
75.         // then wait for the agv to get on
    : _% o) N/ }3 Y9 }
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    8 i  v& q; {( `  n/ B5 J# O# m
77.         // then travel to the destination z location
    0 e/ X& G! q# E( C1 d- V! B0 Y
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    ' m) Y" o, `: t) @( `
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    + l, N7 ~% P* p" b
82.         dispatchtasksequence(ts);
    ! W+ w3 m: r9 ~$ U
83. } else switch (operation) {
    0 D0 j: Z* _; Y( M# X# w
84.         case ON_ELEVATOR_START: {
    6 o6 t( `1 K# a
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    . d2 b6 j) c4 j: h1 p( K
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    8 ^- x  R+ @4 A* f  n
88. 
      P4 N) O3 H) @! J8 ~8 w9 A
89.                 // find the closest floor control point
    
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    ! v$ I& f# @* u& }0 {! s- {
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
    
96.                         return 0;
    
97. 
    
98.                 // get the entry control point
    
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     ' r' Y/ p2 z: |- z7 d. u8 w; N8 Y
101.                 if (!objectexists(curFloorEntryCP))
     
102.                         return 0;
     
103.                 treenode floorEntryCP = curFloorEntryCP;
     0 v9 Z# k! S+ N  [2 E
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     ( O0 P' i$ ~8 X; s; _; C
106.                         return 0;
       \6 B- E% n' F4 ]+ ]- Y4 C* ~
107. 
     
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
       H5 O4 a/ J' _: P3 X2 T
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     & [2 H8 H. D1 u9 m! W. L- m8 g
112.                                                         cpconnection(elev, floorCPCon, count));
     9 M# e: e- f2 T/ F2 i
113.                                                        
     
114.                 floorCP = destFloorCP;
     5 r( p4 i& Z& ?2 {' \8 @1 K
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     3 t! j+ b- u7 u$ C  t
116.                 if (!objectexists(destFloorElevCP))
     5 X- E; F0 q4 @: ^2 k% @
117.                         return 0;
     / ^, `; ^1 C  l! D) ~
118.                 // get the destination exit control point
     
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     ! R8 i3 f2 P, R7 N
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     , `9 c7 x% q2 e, \# A3 n& w- L0 I
122. 
     
123. 
     ! A0 z/ U0 }, k) _
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     8 U7 o# o! Y; ]
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.
     
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     8 F. Z3 ]; X% j5 x1 r
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     & k* ?( T# v% p) s7 _! r
129.                
     ; P' x6 D  l) v: V
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);
     2 }, ~8 y# u  b  C& n
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     & R6 R9 N& Y; {
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     / a) ^8 |# L+ K% M
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     & p! z, I( ^4 A+ n$ x8 X2 g
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     
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.
     % m4 O% D  e5 E# V" ?8 i: t- b
143.                 treenode agv = param(1);
     ' `& r# @" x* n
144.                 treenode elev = param(2);
     
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
146.                 // I increment the state label, and then switch on it
     & W  _3 l/ G& e3 B9 X" N) [& E7 N
147.                 inc(stateLabel, 1);
     & S, S2 y9 d4 n( Q! o5 C9 P
148.                 switch (get(stateLabel)) {
     ) Q6 l6 j$ X( k! Z
149.                         case AGV_STATE_AT_ENTRY_CP: {
     ( M& l# l, |" S* \
150.                                 // the agv just arrived at the entry cp
     4 Z5 f/ `5 h* l* p7 G
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.
     . e( |0 ?, j8 w0 w1 B
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     " {; |  X% Y$ x' I( |' U: u4 e7 o
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     & C0 A3 B  N( o$ \! U7 z" c9 S
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     ! s- T2 {8 G1 f1 T
158.                                         // the elevator cp
     
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     * z/ b) o& H+ Q. `: u0 ]
162.                                 break;
     
163.                         }
     " U5 c0 E) U) l% T# `: z0 W
164.                         case AGV_STATE_AT_ELEV_CP: {
     ! j/ c, S/ }6 i7 K* s# A& Q- j5 H
165.                                 // once the agv is at the elevator cp, close the door
     * |3 o7 t  i/ b- p0 Q& L* H6 J" c
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     # P! s. x, U: `8 x! N
168.                         }
     
169.                         case AGV_STATE_AT_EXIT_CP: {
     
170.                                 // the agv is at the exit cp
     ( i. B; H& ?; l' q) m
171.                                 // destroy the listener node because I'm finished listening
     
172.                                 treenode listenerNode = param(4);
     
173.                                 destroyobject(listenerNode);
     1 ?' u0 h' J5 f. @9 u4 U6 W8 h
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
     ! d$ A( ?$ [1 Q6 S2 i! Z) m" i4 ?
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     
179.                                 }
     ) p/ u/ w' ^1 s, c
180.                                 // close the door
     
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     9 h# o  n3 f. [9 N' m* {- n' }* D
182.                                 // and I'm finished with the state label so I can destroy it.
       g4 o3 ^- ?5 k, \
183.                                 destroyobject(stateLabel);
     - q. H! a' `" U/ V* A
184.                                 break;
     0 p- i! V8 B8 [! U. ?2 R
185.                         }
     " G( F/ i6 E/ N# m) R( j
186.                 }
     
187.                 return 0;
     % V: A4 e6 w  I$ H; g
188.         }
     , J3 d( V2 C+ e" G: t  C4 q
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     8 _. W4 ^; w) v0 a
190.                 // the elevator has arrived at the pick floor
     6 N  i' b, {' l6 g2 ^; w
191.                 treenode elev = param(1);
     6 t, U& T4 b- p; Q# g. C! ?
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
     & Y1 U4 Z" F/ |2 ?, F0 B* m7 ]
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     6 ?5 b3 n& v% P7 O8 \' h
197.        
     
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     2 n) Z  `6 ^0 b. B- A
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     1 f1 v3 }5 t, g1 k2 N! e+ v( T5 V( r
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     " ]/ V3 v$ Y+ i  y  ]; U5 J, z# ?
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     7 D& C5 U% p- I) y9 ~4 \  _) \
204.                 }
     : n9 H; I( ]& k/ h& K  |7 V
205.                 return 0;
     
206.         }
     : X/ B; b4 h) C7 V- Q& I; S
207.         case ON_OPEN_DOOR: {
     ; y. E9 M& b+ l1 x. X5 ]. ~  {3 g8 x
208.                 treenode agv = param(1);
     
209.                 treenode elev = param(2);
     ; u. n7 C) \' f# t  R+ ^( ^
210.                 int nextStep = param(4);
     
211.                 // open the door based on the time to open the door
     - }/ I1 y* B7 P. r9 u6 m# o% V9 Y, Q
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     ( x. r7 A+ w% H, H0 Q9 w, e4 M, ^: X
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     9 m# g; w5 Z9 I( F, Y) _# K' \% q/ k) ]
214.                 return 0;
     
215.         }
     
216.         case ON_CLOSE_DOOR: {
     
217.                 treenode agv = param(1);
     4 F7 s$ T; l( y8 g- t% }
218.                 treenode elev = param(2);
     & n+ i  W- v4 V
219.                 int nextStep = param(4);
     
220.                 // close the door base on the time to close the door
     & \: z4 ?; ]% r$ ~' ]( W8 X3 {+ ?- Q
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     ! W% k$ B3 \' l  k, O/ l: O6 g
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     / h5 x0 S3 T) z- D3 E7 f) p0 F2 E& |
223.                 return 0;
     / a+ D8 ~% j* P/ x% ^; I& i2 f
224.         }
     ( J( O# ]) y! i7 C/ z  S
225.         case ON_PICKUP_DOOR_OPENED: {
     7 j6 U9 |( v9 b) m+ U1 z
226.                 // the elevator door has been opened on the pickup floor
     % J& d& j0 ~' L: z" x3 R5 f" r5 W
227.                 treenode elev = param(1);
     
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
       u! Z9 K" P# _/ P# d& {
229.                 treenode entryCP = cp(agv);
     
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     0 K9 _% s3 i2 p+ a/ n7 [
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
     : |2 ~) e5 w6 p+ w- l' ~
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     - Z" s' |" Q- T, c7 a6 M
238.                 return 0;
     
239.         }
     
240.         case ON_PICKUP_DOOR_CLOSED: {
     
241.                 treenode elev = param(1);
     
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
243.                 // assign the agv to "no control point"
     3 B1 n6 @2 ?) o, N. e8 V
244.                 agvreassigncp(agv, 0);
     
245.                 // move the agv into the elevator
     , d$ a# Y( T- _$ r7 j/ T, o4 Y3 R
246.                 moveobject(agv, elev);
     
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     
249.                 freeoperators(elev, agv);
     ! k, r0 f: X1 G6 @* D4 U, F
250.                 return 0;
     + `5 ]( T" R/ c& Y2 q( L
251.         }
     + y6 L7 w6 \$ m% ]
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     
253.                 treenode elev = param(1);
     + D& [" M+ R9 C  k5 V. V* g0 W& n$ \
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
255.                 // when the elevator arrives at the destination floor
     . @8 @. x1 c+ c4 u0 U# g7 y
256.                 // move the agv back into the model
     
257.                 moveobject(agv, model());
     
258.                 // reassign it to the destination floor control point
     3 i9 N! S- z/ o% o/ `; s
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;
     ; M6 [) k8 y( v- ^8 u
263.         }
     6 z' V. I# [4 M# e
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
       A/ t1 g4 M# v& t
266.                 treenode agv = param(2);
     * b; v* I  G4 G8 J8 O6 b- [' c: ]
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     % {+ ]5 f8 ?" J' n
268.                 // once the elevator door is opened on the destination floor,
     
269.                 // redirect the agv to the exit control point
     ) m7 G1 p3 G4 \. A  i* V
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     
271.                 return 0;
     
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
     : k4 x' V: \- L# I: j
277.                 // once the door is closed at the destination floor,
     1 I! z8 _$ N7 }0 Y0 V0 E8 @) C: X
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
     
282.                 freeoperators(elev, agv);
     
283.                 return 0;
     
284.         }
     7 o" c0 R% c) Q: L) S  N
285. }
     
286. } //******* PickOption End *******\\
     
287. 
     

复制代码

  t$ B" p" c' R

: _- S4 N* G0 A  B办法2：使用工艺流程模块完成

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

0 A8 G/ E1 [! M7 F1 U具体代码如下：

. F) q+ D# S% G0 F5 v好的，非常感谢陈老师的解答~