2018.2.0版中AGV如何乘升降机？

请教一下，2018.2.0版中AGV模块，路径点逻辑里没有乘升降机的选项，该如何实现这个操作？
. U- q: ]7 S" C+ P- n7 s
  c$ E3 a* s& s2 z$ I- E& O

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

具体代码如下：

1. treenode agv = param(1);
   / B& k( ]. p! ~" e3 N% `8 O5 ^
2. treenode currentCP = param(2);
   ! z$ V% `* n9 B
3. 
   : k- }9 x7 C5 W. r$ D2 H+ b$ f: O
4. { //************* PickOption Start *************\\
   9 J* C0 r. [: i3 S, P* e4 @) |
5. /***popup:AGV_DivertToElevator*/
   
6. /***tag:Description*//**Divert to Elevator*/
   / n( i) A0 I+ k& H% d! {
7. 
   
8. int operation = param(3);
   5 V8 M, b" R  u% H& b- s6 i( G- Z8 T
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    2 W) ]( @: g1 d/ _
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    8 y% @4 \2 L) Q& e4 V
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
    * k! ]7 t# o' k! n" c) L
13.         // initial trigger execution
    & w- i7 `3 H' g: Q3 c" W
14.         #define ON_ELEVATOR_START 1
    & x) Z9 ?/ Z: Q% g: F: h
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    8 C0 v; ]% N4 W8 A, V  a
17.         #define ON_AGV_AT_CP 4
    ( v& V- S: a5 [& A+ ?" W( u
18.         #define ON_BOTH_AT_PICKUP 5
    ; S) d) r3 h4 @& D, q+ f0 v1 {
19.         #define ON_OPEN_DOOR 6
    
20.         #define ON_CLOSE_DOOR 7
    
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    
23.         #define ON_DROPOFF_DOOR_OPENED 10
    
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    , U5 S$ [! {; C1 F6 k5 B, R  [& G
25.        
    
26.         #define AGV_STATE_START 0
    2 a( y1 T0 @8 I$ f
27.         #define AGV_STATE_AT_ENTRY_CP 1
    3 T% _/ t" n; T- l1 Q$ c5 I9 e
28.         #define AGV_STATE_AT_ELEV_CP 2
    
29.         #define AGV_STATE_AT_EXIT_CP 3
    # V/ H6 M( e% ?+ V6 l7 N( J
30.        
    + q) C1 N$ ]& n* {
31.         #define ELEV_STATE_NONE 0
    / X2 e% L$ y9 }8 e
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    ( k5 F8 _7 l8 r# `  L% B' P
33.         #define ELEV_STATE_OPENING_DOOR 2
    5 j7 Q0 p+ D: u1 ^( v
34.         #define ELEV_STATE_DOOR_OPENED 3
    
35. 
    
36. 
    9 T" C9 V; J  |/ W  U, E
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    
39. 
    : q5 a- ?3 i6 d$ b4 l+ _5 h
40.         if (!objectexists(elevDisp))
    - z* Y5 {( _6 D4 o6 ~
41.                 return 0;
    
42. 
    
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    
44.                 query(
    & D0 L/ E! b: d+ @: h" E, S% p2 a
45.                         /** \nFull Query: */
    3 {9 Z7 p) K' s6 B* Z! }
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    
47.                         nrop(elevDisp),
    - M0 {2 X1 w4 Q$ ~3 J, e
48.                         elevator
    $ p  h/ u; K/ @) L2 z3 Z
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    0 F; B/ P5 U4 X8 L1 \9 y- f* J
51.                         /***/
    
52.                         /** \nOrderBy*/
    
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    " G' G$ Y( A0 X8 q
54.                         /***/);
    
55. 
    5 q; E2 X2 M4 O: [9 i& g
56.                 if (getquerymatchcount() > 0)
    * M$ [3 H0 F% u* T& e0 [
57.                         elevDisp = getqueryvalue(1, 1);
    4 L" H. Y( r  [. }& n" @
58.         }
    ) k4 h" e1 K. Z% w  D$ {) N- e
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    & h8 i6 ?6 E5 R
62. 
    & Z' W7 v8 b0 D  p
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    4 q: A9 S+ k% b' z3 J
64. 
    
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    ' [' Z$ @5 L! \$ L! l5 ^& d
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);
    # `  d! t' B& B. B4 r# ~0 i7 U9 X( n
71.         // travel to the z location of the current control point
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    & X: C; E- M$ K8 z
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    ' n$ Y# L% M0 p7 M  }! _- M
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    % o& m2 u  H1 J  x* G1 Z
75.         // then wait for the agv to get on
    ; m0 d; E; v2 q+ ~6 C4 r
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    
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);
    
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
82.         dispatchtasksequence(ts);
    ! n' W$ D( D- d# e. v' u
83. } else switch (operation) {
    
84.         case ON_ELEVATOR_START: {
    
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    - w- m+ B$ a6 H0 f8 G) u
88. 
    ( M/ i) r) i! k+ h
89.                 // find the closest floor control point
    
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    - }3 z* a- ?* g. @- w! [+ Y
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    . X, i, \* n7 k& u, o
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    * K6 I* v+ B; b9 i+ e: G* k# p+ L2 ^
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
    
96.                         return 0;
    0 g# h  N0 D- s8 h( Y5 G; U
97. 
    
98.                 // get the entry control point
    
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     
101.                 if (!objectexists(curFloorEntryCP))
     
102.                         return 0;
     9 Q$ C& _$ g' @  J3 b+ t& e
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     / Y1 p- g  W: m5 t% S( y
105.                 if (!objectexists(curFloorElevCP))
     
106.                         return 0;
     
107. 
     0 e! O3 Z" U5 i9 d4 I
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     
112.                                                         cpconnection(elev, floorCPCon, count));
     ! x+ P  l% N  P1 T% x. N7 v( U/ Q
113.                                                        
     * ]5 k8 ^9 D! G* c
114.                 floorCP = destFloorCP;
     
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     
118.                 // get the destination exit control point
     ' C* t9 ~) P3 D1 d
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     
120.                 if (!objectexists(destExitCP))
     " M: {. L$ t- W! s
121.                         return 0;
     : [- q: u! u; Y: M4 B
122. 
     9 U, k$ \2 s0 r- G" @( E0 X
123. 
     1 @/ H' W, y  |  V" I% T
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     + F! o" Y' X" K$ X/ E1 J
125.                 // agv arrives at a node. I keep a state on the agv's state label, and then increment it each time
     ; ^& q* m5 {- J$ [3 X
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,
     % `: ^( K% h- w. g& G
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     
129.                
     2 u. g5 j: C; D+ h8 Z9 z' D
130.                 // set the data on the state label
     
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     ! T- O: ~: N8 P; H
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     7 E  k9 q, m: Q- H$ c1 _' _$ R
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     9 p) `' p$ ~8 g/ M# r" t0 F9 t
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     ; T  }8 o+ D& K& M  s
139.                 return 0;
     
140.         }
     
141.         case ON_AGV_AT_CP: {
     + y4 Q# o' s' V
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     4 z- C: h) O8 q2 P/ |$ A' M* {
143.                 treenode agv = param(1);
       a9 ~, P- T, j% y- k, F
144.                 treenode elev = param(2);
     . g) K  D7 z- r
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
146.                 // I increment the state label, and then switch on it
     
147.                 inc(stateLabel, 1);
     : ~! }( w+ E% Q5 O% f! J) ^" c) w
148.                 switch (get(stateLabel)) {
     . c9 E8 d8 ~8 ?& r  A$ ^
149.                         case AGV_STATE_AT_ENTRY_CP: {
       w8 S  j: k# r! I$ i3 ~, Z! j
150.                                 // the agv just arrived at the entry cp
     
151.                                 // so, figure out where the elevator is.
     
152.                                 int elevState = get(node("ElevState", stateLabel));
     ! K* }) \. s5 p% i; Q% s
153.                                 // if he's at the pickup floor with his door closed then open the door.
     " u% n; O5 ]5 i2 Z! h$ Y
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     0 g+ C! `+ @- ~) \! U# \
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     9 f' ~9 H9 z4 D3 c5 q% D
158.                                         // the elevator cp
     
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     - U; Q* q4 h  ^) H. W; Y
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     ) L. A' n. `4 t1 u3 s5 h+ O
161.                                 }
     5 w0 x+ O; A$ m/ w9 ?* S
162.                                 break;
     3 C% l3 k* G* L  T! y
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     / s  `, v1 w& s! e) ]7 m
165.                                 // once the agv is at the elevator cp, close the door
     5 A- N! d1 @5 l) S5 A( L
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     9 |, m( k0 k6 n, N- q- q. g
167.                                 break;
     ! N* _( s; z" C; f
168.                         }
     5 g# f& ~" o( u  B- O
169.                         case AGV_STATE_AT_EXIT_CP: {
     / _6 E! Y7 c8 P: e% c" y  \7 ?; i
170.                                 // the agv is at the exit cp
     6 v# z. k/ n9 m6 Q7 U
171.                                 // destroy the listener node because I'm finished listening
     
172.                                 treenode listenerNode = param(4);
     
173.                                 destroyobject(listenerNode);
     
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
     + E3 E9 v0 E/ Y+ }! ^
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     3 V! I  l6 w- }
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     - `! D3 S6 X# E7 T" p1 u0 c
179.                                 }
     : D& H, h( R) b4 P8 R1 E
180.                                 // close the door
     
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.
     . d# F0 L1 @1 N- r# _4 g
183.                                 destroyobject(stateLabel);
     . i8 \: D* S- t7 l  ^9 I6 j& W: a
184.                                 break;
     
185.                         }
     # n5 b9 q% s5 k" m+ Y
186.                 }
     ! ~6 n1 u3 Q2 Y5 Y
187.                 return 0;
     # S+ m6 [0 @4 P1 g" ?6 L
188.         }
     5 H" \9 x) f: V* y4 Y9 x
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     
190.                 // the elevator has arrived at the pick floor
     % z) `$ t( T, F4 y3 M# c7 U
191.                 treenode elev = param(1);
     : m: H# E9 ~, D: T9 y9 K0 n
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     & D+ g" m  M" y2 E- P! a
194.                 treenode elevState = node("ElevState", stateLabel);
     
195.                 // set the elevator state to at-pickup-floor
     ! _, Z6 T8 k6 z3 G
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
       ^/ ?6 J+ n5 g( k2 V
197.        
     0 H! k+ F& A$ j' O
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     6 v. x7 X! H# P: x' _# Z9 _
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     6 F' ~; M. c0 e# F6 b
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     . h0 P* ~# J" O* P
204.                 }
     ( p1 s8 C6 I. o
205.                 return 0;
     
206.         }
     * ^: u3 ^, J. k# A+ g
207.         case ON_OPEN_DOOR: {
     ; A4 r' @+ ?6 M- r+ v( g2 X
208.                 treenode agv = param(1);
     
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     * A( p3 z% {1 X1 o6 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;
     . t  [, y+ H# t# O: d! \8 m( T
215.         }
     
216.         case ON_CLOSE_DOOR: {
     6 W$ _5 u3 l8 m  F1 G. l
217.                 treenode agv = param(1);
     
218.                 treenode elev = param(2);
     $ C( `6 o5 u" x
219.                 int nextStep = param(4);
     + S8 w! }! Y5 D
220.                 // close the door base on the time to close the door
     ! o/ D! l; e0 y7 X" t# L
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     ' B+ C! u; r( M& b; I$ Q' r) d
223.                 return 0;
     
224.         }
     ) ^7 U* L1 u8 h! n2 H* Y' U* M# w4 Z
225.         case ON_PICKUP_DOOR_OPENED: {
     
226.                 // the elevator door has been opened on the pickup floor
     # k/ ^: X1 j1 l% G1 A
227.                 treenode elev = param(1);
     
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     6 Q# P! K5 N. j7 U
229.                 treenode entryCP = cp(agv);
     8 W" p/ b3 _$ g) x  F
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     . u5 a. X) [+ C- B4 Q5 A
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     $ A: q; q" o% `) r; c2 u
232.                 treenode elevState = node("ElevState", stateLabel);
     : ?0 |' a, F% P
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
     / }( F9 R* I7 f7 s
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     , n) a1 d  p% u2 V2 K2 W! n# w
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     
239.         }
     + r7 M7 T+ h- F
240.         case ON_PICKUP_DOOR_CLOSED: {
     
241.                 treenode elev = param(1);
     2 F1 n. K, @( J8 y4 j& }
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     " }' O* I. p8 \! e
243.                 // assign the agv to "no control point"
     
244.                 agvreassigncp(agv, 0);
     
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
     : r$ y% k4 G6 h6 R1 ?- Y
249.                 freeoperators(elev, agv);
     , U5 j% i8 u+ W9 A: {. f
250.                 return 0;
     
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     
253.                 treenode elev = param(1);
     
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     : H$ |" w5 j1 c& u; p7 ?
255.                 // when the elevator arrives at the destination floor
     
256.                 // move the agv back into the model
     9 F  q' l- A2 Q
257.                 moveobject(agv, model());
     2 y+ D3 z3 a; r
258.                 // reassign it to the destination floor control point
     4 k) |" b/ R9 r! r% F% R
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     
260.                 // open the elevator door
     0 o0 u$ ]3 i( v; `7 }3 C
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     
262.                 return 0;
     
263.         }
     
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
     
266.                 treenode agv = param(2);
     ) T$ F+ g  I4 A+ P0 b# M8 q
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     
268.                 // once the elevator door is opened on the destination floor,
     ) F- A! l2 ~6 H! M' \8 O9 }
269.                 // redirect the agv to the exit control point
     
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     1 P  }6 L) v) F" O! P
271.                 return 0;
     2 N" e6 }9 J  F# ?2 s( u& D
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
     ! j8 ~4 W: s8 W* l
277.                 // once the door is closed at the destination floor,
     3 O2 z' W, m1 Q9 M& A
278.                 // if the agv is waiting, then send him to the final destination
     ! x9 ^* @8 G4 i
279.                 if (isAGVWaiting)
     % h* \4 U' k$ b& _% ?( \8 [
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);
     % p2 p' ?: H: i: T; f; c( t
283.                 return 0;
     ; O6 U) E& l$ r: E. F$ y
284.         }
     
285. }
     4 }! I4 j/ I  G
286. } //******* PickOption End *******\\
     
287. 
     

复制代码

1 r6 d7 T. W; `2 P
5 {  Y+ @  A) J: I0 }- y办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
+ q8 T7 F$ ^5 [& g办法1：从2016版本里面复制相应的代码

# O9 |. E( v1 N+ J( m" ?: p具体代码如下：

好的，非常感谢陈老师的解答~