2018.2.0版中AGV如何乘升降机？

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

办法1：从2016版本里面复制相应的代码
8 E. m8 m7 \  b- H- z$ K
7 {# d2 ~/ K! i3 z具体代码如下：
7 q$ R  `1 P( c- Z

1. treenode agv = param(1);
   9 F% H8 c& L- S0 k9 p. a
2. treenode currentCP = param(2);
   ' f3 V0 D; l8 m- X4 y7 E
3. 
   
4. { //************* PickOption Start *************\\
   / B0 f( }5 K3 @' v& `
5. /***popup:AGV_DivertToElevator*/
   . |% d1 R- _" U" V4 F* e( ]
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   & |0 \# ?$ {! j) R- I
8. int operation = param(3);
   
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    ' O2 S( B  K1 r5 [* ^; e
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
    : w0 U8 i0 _' m' m7 j6 Q" x7 A
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    ( {) {( h* n% M
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    & o2 K" W4 k& J% u' O! p% V- j
19.         #define ON_OPEN_DOOR 6
    % ?4 a+ ^) [- R! X7 u/ u3 h
20.         #define ON_CLOSE_DOOR 7
    
21.         #define ON_PICKUP_DOOR_OPENED 8
    * T4 \8 P4 V- e
22.         #define ON_PICKUP_DOOR_CLOSED 9
    
23.         #define ON_DROPOFF_DOOR_OPENED 10
    
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    
25.        
    . o* G0 }1 L% h
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    5 }* q" B% h1 Y: `$ s5 [
28.         #define AGV_STATE_AT_ELEV_CP 2
    $ A- r+ i5 @# Q5 N3 y) m
29.         #define AGV_STATE_AT_EXIT_CP 3
    ; g9 @* N% g0 n4 [9 k, V- M0 V
30.        
    3 X3 b( y. N7 q
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    . q, l5 j! C5 x& ^+ b2 d, b
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    
35. 
    
36. 
    
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    ' X! t% w% u/ ]
38.         #define elevator outobject(elevDisp, $iter(1))
    * R' [1 B6 p% B. Q0 o+ Q
39. 
    6 C' o4 f6 f2 f& T. P3 N
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    
42. 
    ; a. o' l  o2 ~! S
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    
44.                 query(
    
45.                         /** \nFull Query: */
    3 F+ h" Z. P/ S0 k
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    & d4 b$ k* x% l0 [! x7 f4 Z
47.                         nrop(elevDisp),
    " G" ~0 [& m6 E  p- w$ m, `$ P
48.                         elevator
    7 V$ y+ e2 ^. U9 v
49.                         /** \nWhere*/
    1 b4 }0 w( q! k3 I
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
      O6 I$ O5 i* c7 W' n$ J# d4 H
51.                         /***/
    7 F: g( T$ ?* \1 C8 U, u
52.                         /** \nOrderBy*/
    
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    , ^8 S* L( H" E7 I3 Z& E
54.                         /***/);
    
55. 
    / G- U' w" x6 n( }5 p
56.                 if (getquerymatchcount() > 0)
    6 j1 ]6 e) D: F" C1 W
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
      b4 S, t0 W$ _' H+ A
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    % Y" u1 @, _3 g0 p
62. 
    
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    ( E8 a& v2 F; a1 S; d' v& j+ B3 h+ {
64. 
    
65.         // Create the task sequence for the elevator
    4 E  X( @% i- Q6 x2 E* o2 {2 h7 n0 X
66.         double destZ = zloc(destCP);
    + h+ i0 ~9 N# t6 T9 ?, P2 u, \; P
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
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    + Q  \! A" M4 q$ \
75.         // then wait for the agv to get on
    # E3 Z9 c6 t& u- w
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    2 f5 Q) q) F" f# X5 u
77.         // then travel to the destination z location
    8 a1 ~% V) q7 Q5 S2 ^/ f
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
      P; [7 A3 X7 I# L# n3 h
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) {
    : v$ a' r9 F. h9 W
84.         case ON_ELEVATOR_START: {
    9 d) B/ M4 A7 W% x, g& r" i
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    8 Z5 d1 p3 f; R0 ]) W/ S4 u
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    
88. 
    
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),
    7 S/ b3 u! n5 n/ J7 w; F9 v3 x
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    : K$ n6 r1 I2 m  x$ \; D0 k: {
93.                                                         cpconnection(elev, floorCPCon, count));
    7 k' |$ g% z, I  N1 A
94.                 // return if there is none
    " ^% U  {3 e9 ]- }: e1 {3 m2 h
95.                 if (!objectexists(curFloorCP))
    
96.                         return 0;
    
97. 
    
98.                 // get the entry control point
    & O' b8 t2 i/ ^0 {3 u
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     
101.                 if (!objectexists(curFloorEntryCP))
     8 ]9 s8 N3 I8 \( f5 {7 S
102.                         return 0;
     
103.                 treenode floorEntryCP = curFloorEntryCP;
     2 T, j0 L2 r# B4 {" x5 Z1 W% I
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     & K8 C7 D" ?& ^
106.                         return 0;
     , ^8 k4 a" R$ _
107. 
     
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     ( u& C" W7 x! X, G
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
       c% T% }- }& D1 o( ~# a/ e
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     + g) t3 p3 g& y3 I! n
112.                                                         cpconnection(elev, floorCPCon, count));
     5 t3 P$ ^. Q5 k9 z2 v% A
113.                                                        
     
114.                 floorCP = destFloorCP;
     
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     $ D7 K7 J# T3 }
116.                 if (!objectexists(destFloorElevCP))
     1 _3 w6 T: i5 P; ~: f- }& H5 t- I! p" q* S
117.                         return 0;
     2 o8 B/ }0 A; x; x6 E
118.                 // get the destination exit control point
     # {9 M# J% k0 w6 P
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     / m' ?7 N8 ], `8 V  i2 f
120.                 if (!objectexists(destExitCP))
     & r4 B/ s) J9 F& Q& v0 [
121.                         return 0;
     % m# L* Y! |6 _7 p
122. 
     - o% T$ ?% N6 U' u
123. 
     7 W$ S6 |$ h- M6 ^
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     & @7 b0 H! n# k, T
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.
     " I# u/ j+ o3 l# e. V
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     % E* N1 ^& Y/ R" P5 K! L$ A; d
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     
129.                
     ( @* k2 `$ F6 h6 x; _' R" u
130.                 // set the data on the state label
     ( I5 l& Z. n; f" p+ [* Z
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     , J, L+ K! Z0 H; {+ J# I
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     - a7 p7 q  c  @; a1 [2 M1 u* E8 i
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     " c, k! l, @" s, L0 f
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     : j8 d* f: x) G) ^
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;
     : F- w& d8 j8 C2 h" m& H, f! }
140.         }
     
141.         case ON_AGV_AT_CP: {
     ; e4 y( d6 w0 I& u
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     
143.                 treenode agv = param(1);
     
144.                 treenode elev = param(2);
     ' {2 Q) P; b0 {% d5 l+ v
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     & {1 i$ d2 l  o+ Y. Y5 \
146.                 // I increment the state label, and then switch on it
     3 Y* f9 A0 T! K  ]5 r1 p" ^
147.                 inc(stateLabel, 1);
     
148.                 switch (get(stateLabel)) {
     
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     
151.                                 // so, figure out where the elevator is.
     . b) o/ j* `& d5 h+ t
152.                                 int elevState = get(node("ElevState", stateLabel));
     6 ?' `6 o3 O$ p
153.                                 // if he's at the pickup floor with his door closed then open the door.
     
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     8 ^0 K5 |* i/ C$ d% r, n
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     ! G6 o' d: [9 M
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)));
     
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     
162.                                 break;
     ! U/ |5 X* G. b: V! c
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     
165.                                 // once the agv is at the elevator cp, close the door
     ) d0 F3 ~$ j' r% V- `
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     
168.                         }
     2 i8 T/ [5 f: A" X
169.                         case AGV_STATE_AT_EXIT_CP: {
     + m) K7 Q. ]% C% z  ?, ?- R
170.                                 // the agv is at the exit cp
     $ w5 D$ v  I( V; s
171.                                 // destroy the listener node because I'm finished listening
       s; k/ C+ d3 }8 K8 q
172.                                 treenode listenerNode = param(4);
     ' V$ l1 ^/ Z/ `4 v1 l2 ^* o: m; @) |
173.                                 destroyobject(listenerNode);
     ) P" ?' w. d' S7 s- ?6 J  F
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     
175.                                 if (!agvWait) {
     / a/ o1 r4 f& D$ s# d
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);
     
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     
179.                                 }
     ' o; O4 i8 I) C' e3 ~
180.                                 // close the door
     3 f; l5 `6 [! d( ^( y
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     ! ^4 D$ N- D% s8 \) ?
182.                                 // and I'm finished with the state label so I can destroy it.
     
183.                                 destroyobject(stateLabel);
     
184.                                 break;
     
185.                         }
     $ {0 K+ w; f& r/ c. r! ]7 W3 z& ]
186.                 }
     
187.                 return 0;
     / o  r8 W8 W* I* M- P' j7 `
188.         }
     5 V: w; v* @* F+ y  ?: M
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     
190.                 // the elevator has arrived at the pick floor
     
191.                 treenode elev = param(1);
     5 d3 b8 u% Q' j& ~' Q7 Q
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     9 A$ |% D9 z/ c7 f% j! m/ ]2 j
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     & @+ O/ N: I: E% @, `" D, k
194.                 treenode elevState = node("ElevState", stateLabel);
     
195.                 // set the elevator state to at-pickup-floor
     
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     
197.        
     ! N& }5 n+ r8 {0 K, d
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     3 O- l' _) j5 ]2 y+ o% `
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     ; e9 S+ O) D: A9 F* r  Z: E
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     + w+ q! g, M& x1 [5 f, {. X' w! E
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     ' O  \- l) V; c3 N' C9 ]3 `
204.                 }
     
205.                 return 0;
     ( d- D. D9 Y  X3 Z; A5 q$ l
206.         }
     
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     
209.                 treenode elev = param(2);
     9 e- ^) F: H9 S. C& c* E
210.                 int nextStep = param(4);
     
211.                 // open the door based on the time to open the door
     3 f/ i" F5 c* h9 c. |
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     $ t: j5 x$ e* o( ^* @6 N! @2 W
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     4 s3 a/ q; d9 N0 d* r. r
214.                 return 0;
     7 {& ~* U: W& S6 X
215.         }
     % `) ?2 n5 q" U- S6 r( S
216.         case ON_CLOSE_DOOR: {
     / Y9 g- y; k+ V
217.                 treenode agv = param(1);
     
218.                 treenode elev = param(2);
     ; B8 j  i  G) d& d! `. ~/ c& s
219.                 int nextStep = param(4);
     : h% C/ s' u+ u9 @( V
220.                 // close the door base on the time to close the door
     0 q0 \1 o: S7 [
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     9 d- Y. X2 m( w6 O, x7 v- X
224.         }
     
225.         case ON_PICKUP_DOOR_OPENED: {
     
226.                 // the elevator door has been opened on the pickup floor
     ! c$ a1 f" b9 i8 d7 N
227.                 treenode elev = param(1);
     
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
229.                 treenode entryCP = cp(agv);
     4 |' U6 f  U- i- h3 j5 R
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     + `1 r) k* P$ `3 C1 G8 ~
232.                 treenode elevState = node("ElevState", stateLabel);
     
233.                 // set the elevator state
     
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     ! S  g; g& Z2 F, m! D  x
235.                 // if the agv is at the entry control point, move him to the elevator control point
     ! g8 Q  M2 m" s, a( Y! m
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     : L  W1 h* V8 z
239.         }
     4 _/ f% d' |$ O$ p. D
240.         case ON_PICKUP_DOOR_CLOSED: {
     
241.                 treenode elev = param(1);
     
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     : r3 R$ A6 D; E& Z. C
243.                 // assign the agv to "no control point"
     
244.                 agvreassigncp(agv, 0);
     0 u) ~5 L% c) M- Q5 W- B; R/ M
245.                 // move the agv into the elevator
     . j0 x0 q2 u$ G, f
246.                 moveobject(agv, elev);
     9 D( @+ u" u9 e/ w% n$ w# u) v6 R
247.                 setrot(agv, 0, 0, 0);
     : X) m7 Y6 A5 _: P
248.                 // release the elevator to continue to the destination floor
     
249.                 freeoperators(elev, agv);
     
250.                 return 0;
     
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     
253.                 treenode elev = param(1);
     
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     8 d6 Y6 B7 `5 f+ ^/ t
255.                 // when the elevator arrives at the destination floor
     / W5 [  B- m. b7 o% p: {
256.                 // move the agv back into the model
     
257.                 moveobject(agv, model());
     
258.                 // reassign it to the destination floor control point
     
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     0 q. A! g& b* k$ r* N( |
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     8 _2 U* _5 j5 L5 j/ D* @' _
262.                 return 0;
     
263.         }
     
264.         case ON_DROPOFF_DOOR_OPENED: {
     ) z1 B( Z# g2 B3 z; I
265.                 treenode elev = param(1);
     " u. u& I8 G1 a, A. `. I& o
266.                 treenode agv = param(2);
     2 t* d: \# H1 M1 b9 c1 O( ^
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     # d; m0 ?! v5 d* H( }
268.                 // once the elevator door is opened on the destination floor,
     / T8 `" V3 m; V- C7 H8 j& a, D
269.                 // redirect the agv to the exit control point
     
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     
271.                 return 0;
     $ F- S0 g/ m6 @% r6 u+ J! I
272.         }
     : @7 j4 R$ I7 E- G/ r% |8 H$ Q/ T
273.         case ON_DROPOFF_DOOR_CLOSED: {
     1 l& B$ J5 F( @3 {: p
274.                 treenode elev = param(1);
     8 ?; w8 ^1 g0 h) p( \4 Q$ @; ?
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
     & v2 w  d( m9 f" d
279.                 if (isAGVWaiting)
     3 j7 ], `% q$ \( z! H, z2 ?
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);
       Q! R- n; \5 e1 e) P% `: K9 W
283.                 return 0;
     
284.         }
     2 e0 d* x! A' L. c9 t' C6 ~
285. }
     9 i8 u; ~* Y- r' o* x, n% g" ]! R
286. } //******* PickOption End *******\\
     ( D3 g& g  x2 k6 v
287. 
     

复制代码

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

慧娴亚伦 发表于 2018-11-4 19:12
' w+ X1 v9 \" W/ ^. j办法1：从2016版本里面复制相应的代码

9 e9 M8 K9 P) G7 u  u具体代码如下：

3 z+ a# l% G* w+ A9 S好的，非常感谢陈老师的解答~