2018.2.0版中AGV如何乘升降机？

请教一下，2018.2.0版中AGV模块，路径点逻辑里没有乘升降机的选项，该如何实现这个操作？
: l. C7 v" m7 I3 K0 b

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

' F! M( D  B7 e( i$ f具体代码如下：

1. treenode agv = param(1);
   
2. treenode currentCP = param(2);
   
3. 
   
4. { //************* PickOption Start *************\\
   
5. /***popup:AGV_DivertToElevator*/
   
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   
8. int operation = param(3);
   
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    + i' T# Q# b# ^5 w' d
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    / t9 M2 L. P" X" d7 m! j
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
    + a1 {' R* w% k, w
13.         // initial trigger execution
    8 M( ?; u3 ^9 E, q/ _
14.         #define ON_ELEVATOR_START 1
    
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    # [- l* C! Q9 K2 Y: @% v
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
    3 x  d4 ?2 d8 W
21.         #define ON_PICKUP_DOOR_OPENED 8
    . f2 B6 `  q8 U) G7 T
22.         #define ON_PICKUP_DOOR_CLOSED 9
    
23.         #define ON_DROPOFF_DOOR_OPENED 10
    8 r/ c; o0 b; C4 D3 n
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    
25.        
    
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    ( ~: f  X3 n, Y4 u2 C  r
28.         #define AGV_STATE_AT_ELEV_CP 2
    ) a  V1 y6 D* u3 H
29.         #define AGV_STATE_AT_EXIT_CP 3
    ) X8 q, c, r/ U  h& N3 Z
30.        
    
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    5 T8 }6 N) \0 ~6 c- c
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    
35. 
    
36. 
    ' H; g; _2 ?4 ?, _, S! W
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    4 n* D/ h& s( i! y0 c6 s. G
38.         #define elevator outobject(elevDisp, $iter(1))
    6 a; ]. n0 ~9 o
39. 
    
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    " w+ r$ F, Q! b6 S
42. 
    ; Q- Y$ Z/ t6 V4 y) t, d7 j
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    
44.                 query(
    
45.                         /** \nFull Query: */
    / V; {4 B" ~  B* l5 G; d
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    7 S( G& x) ~" a6 ^; \
47.                         nrop(elevDisp),
    
48.                         elevator
    
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    - X) W% }2 [4 t$ k* _
51.                         /***/
    
52.                         /** \nOrderBy*/
    
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    # r! X4 a" N& o
55. 
    
56.                 if (getquerymatchcount() > 0)
    
57.                         elevDisp = getqueryvalue(1, 1);
      G# e6 X6 M( O0 v. e1 T+ t4 b; Q
58.         }
    " E  z' K/ A+ j8 [/ M3 ~) N2 @
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    6 {1 V4 S: Q- H. Q/ |
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    
62. 
    2 ^; L' s4 J4 [& S
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    
64. 
    
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    $ @1 ^2 W0 d3 _6 @5 [5 f( Q* j
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    ) d- c3 V' \9 D" t; g
69.         // immediately when the elevator starts the task sequence, I call ON_ELEVATOR_START
    $ ^' W# w1 e$ ]5 I2 f7 W
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);
    7 Y- S; u: p' s
75.         // then wait for the agv to get on
    8 K! T8 N' h, m5 S' B1 A
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    & }2 X+ m. C) i' }
77.         // then travel to the destination z location
    
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    ; @  \. ]* h9 J
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    4 u2 @4 y  S! n3 C8 c! r7 b
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    + d6 _8 F- ]9 b7 E, Q# U! M
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
82.         dispatchtasksequence(ts);
    " Z3 U4 R2 g9 ?1 u' E+ A. {
83. } else switch (operation) {
    
84.         case ON_ELEVATOR_START: {
    
85.                 // this is fired when I get a valid elevator
    * Y9 T+ w! z% r+ A% c) Q
86.                 treenode elev = param(1);
    
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);
    1 A5 Y5 b9 ~) h3 {9 t& [
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    & n! m" k! Y. G4 ~2 |2 c0 i8 h
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    1 S2 ?. A5 F/ Z$ a  u5 g' J
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
      r5 p& G9 _/ A  G
96.                         return 0;
    
97. 
    ( G& @6 m2 k1 u$ S$ J" `
98.                 // get the entry control point
    
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     # k7 q- Y1 y  n% W: s) @, L, u
101.                 if (!objectexists(curFloorEntryCP))
     5 W( f, X. v! `$ Y4 s: P6 k7 P  G
102.                         return 0;
     
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     
106.                         return 0;
     ) n) |' b8 ^) j2 m* s" T6 O
107. 
     
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     / m; H2 [$ B5 H% F1 P
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     * j( D( ]2 H6 ^. f$ H
112.                                                         cpconnection(elev, floorCPCon, count));
     ' i9 ^! U  Z& m5 L
113.                                                        
     
114.                 floorCP = destFloorCP;
     , j1 P% H7 u7 D) E
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     ; f4 l& m& f/ ]1 a1 c! ~
116.                 if (!objectexists(destFloorElevCP))
     # T- m9 J' S4 N% |
117.                         return 0;
     
118.                 // get the destination exit control point
     
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     7 p$ y% U( \) ~  h; a6 O
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     
122. 
     9 H$ A# r( v4 F* ]
123. 
     # g1 o7 W: ]8 C9 ]' ?
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
     1 ^% G1 `5 j9 F$ f  X/ O- k/ n
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     5 \. r* S' M% w/ H* \# p
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     : x" b7 l' k- j  x! F/ r& J! ?: m) Y
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     
129.                
     
130.                 // set the data on the state label
     
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     7 d% ~& c. C- x7 p
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
       z9 W0 V; r# _, u( i0 Z# {$ c
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     , Y) g' m4 y4 l* g4 r
139.                 return 0;
     4 J8 `5 |9 u7 y+ B6 }
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);
     
144.                 treenode elev = param(2);
     9 a; i# S' O8 _: K% _, V+ A" r
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     - u( d  c' G- t1 Z, C9 H% a
146.                 // I increment the state label, and then switch on it
     
147.                 inc(stateLabel, 1);
     ' C! @1 W, h. E2 X$ W" r
148.                 switch (get(stateLabel)) {
     ) y  H: g8 y. e5 Z: ?1 S
149.                         case AGV_STATE_AT_ENTRY_CP: {
     7 e: ]5 A% N! U
150.                                 // the agv just arrived at the entry cp
     
151.                                 // so, figure out where the elevator is.
     # U0 O2 a& B1 i
152.                                 int elevState = get(node("ElevState", stateLabel));
     + w# D$ ~0 ]4 ~
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);
     
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
     
158.                                         // the elevator cp
     7 o9 Z& y! [" x* r4 S
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     9 w3 f% W- U5 s. _# D" M; ^
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     : U' Y% P4 ?3 B' s, `4 J
162.                                 break;
     
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
     
165.                                 // once the agv is at the elevator cp, close the door
     
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     
168.                         }
     ( e+ o. O5 `5 r2 l# D7 h/ g& V
169.                         case AGV_STATE_AT_EXIT_CP: {
     
170.                                 // the agv is at the exit cp
     3 D3 y) o$ X, y
171.                                 // destroy the listener node because I'm finished listening
     3 A4 Q1 Q* G, G1 i
172.                                 treenode listenerNode = param(4);
     7 X) `: ^& ]3 ?
173.                                 destroyobject(listenerNode);
     
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     
175.                                 if (!agvWait) {
     . Q) x/ o5 q! w6 T" |
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     # ]5 h, n* [9 s0 o7 q) T
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     
179.                                 }
     " ~9 @( o" Q6 a8 F5 t/ W7 z& j
180.                                 // close the door
     
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     ) [9 E# s0 n, V
182.                                 // and I'm finished with the state label so I can destroy it.
     1 d# Y! `- {; m( o% ?: M
183.                                 destroyobject(stateLabel);
     9 P" K  ^4 I3 w
184.                                 break;
     
185.                         }
     
186.                 }
     - i) R! I7 I, b+ _4 H) [+ Q$ Q
187.                 return 0;
     
188.         }
     
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     " }/ M7 a# z5 X# ~- r* S! k$ l
190.                 // the elevator has arrived at the pick floor
     
191.                 treenode elev = param(1);
     + J, Y4 c5 N; k: z% q  S
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);
     
197.        
     
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
     6 K# j; x2 ^5 t: N1 @
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     5 b# j) Z' U& \- @- u
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     ; ?& e: ~& q, V9 {. ?
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     / V4 E/ H) ^1 s/ H
204.                 }
     
205.                 return 0;
     
206.         }
     % L0 S7 d) [+ V/ b' _1 q' \
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     ! V# H2 J& K% i% L3 a
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     
211.                 // open the door based on the time to open the door
     ' D$ U1 z' u- c% v
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     
214.                 return 0;
     ( d0 u3 v  V  `% O  \( G
215.         }
     1 P+ L) X3 I" X; ~- s& j
216.         case ON_CLOSE_DOOR: {
     
217.                 treenode agv = param(1);
     " u$ z. V& i& U( j
218.                 treenode elev = param(2);
     % i1 V4 z; }0 T( Z8 B
219.                 int nextStep = param(4);
     
220.                 // close the door base on the time to close the door
     4 L, Q) T! u0 o0 K+ g, }! w
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     3 C( r: t2 j' x4 Q' X
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     
224.         }
     & R( M: }$ ]( ?4 }. F  u5 w* a/ Y
225.         case ON_PICKUP_DOOR_OPENED: {
     1 v. y. ]) k. O8 A6 K. D
226.                 // the elevator door has been opened on the pickup floor
     
227.                 treenode elev = param(1);
     
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
229.                 treenode entryCP = cp(agv);
     4 r8 E% c/ [2 @) F" k/ C- V
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     : H1 l% G4 ^1 ?
232.                 treenode elevState = node("ElevState", stateLabel);
     * T% T5 z$ k- H1 C# h5 k/ K
233.                 // set the elevator state
     
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     . D7 k3 \0 ~* D7 |
235.                 // if the agv is at the entry control point, move him to the elevator control point
     % c! {( c" x  \* X+ X3 p$ P! }3 {
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     3 ~7 |9 z  r6 a! f" K, B& f
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     5 O  x5 G4 B5 s6 k! {
238.                 return 0;
     2 `' Z2 ?# Q( w) O
239.         }
     
240.         case ON_PICKUP_DOOR_CLOSED: {
     . Y7 P: A2 g& N& C) k! p
241.                 treenode elev = param(1);
     , t8 I3 c! ^* V' v+ T
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     : z: k7 d9 f' g) ?5 G
243.                 // assign the agv to "no control point"
     
244.                 agvreassigncp(agv, 0);
     
245.                 // move the agv into the elevator
     & ?) p# X% e4 H5 ?" S  S
246.                 moveobject(agv, elev);
     * N1 H8 K" P$ M& v' x8 B. r9 Z
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     * s+ [  F  y) b( |
249.                 freeoperators(elev, agv);
     5 z* ^, V+ A: m6 V' a
250.                 return 0;
     3 f; n; [" D8 B
251.         }
     
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     ; h& Z; b, O  `3 y# k- q2 z
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());
     ; k0 e; X, d$ x; k! e% k
258.                 // reassign it to the destination floor control point
     ! @( _; l3 W! [8 E1 ~3 X
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     / a* }0 }! T' |; b/ Y( c. o
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     7 @! ?9 e: h' Y3 X
262.                 return 0;
     
263.         }
     1 I  K: e  J  G) z+ e/ {7 E
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
     5 j" ^8 s* v& i+ i. m: h+ z8 P
266.                 treenode agv = param(2);
     7 v1 V3 W/ h4 n0 R" F9 I
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     
268.                 // once the elevator door is opened on the destination floor,
       b' N6 P$ i# _/ A6 R9 C
269.                 // redirect the agv to the exit control point
     
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     % \) h2 J( @9 o& N6 w! p, O, D
271.                 return 0;
     
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     $ f; J/ F; \5 i
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
     $ u1 r6 T* q5 F; w
277.                 // once the door is closed at the destination floor,
     
278.                 // if the agv is waiting, then send him to the final destination
     + p. Z. n* V) J( l$ t' _4 T1 ~# l
279.                 if (isAGVWaiting)
     
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     9 U3 }" G! G4 t& m
281.                 // release the elevator to finish his task sequence
     
282.                 freeoperators(elev, agv);
     - w6 G2 `5 G+ {0 f, ?9 x$ a2 d3 @
283.                 return 0;
     
284.         }
     1 o5 G9 z" `7 V! S9 _
285. }
     : s6 _" c" _8 w* q! ^* j
286. } //******* PickOption End *******\\
     8 y8 _2 z& t  O2 v! C. Z
287. 
     

复制代码

& b/ Q7 W" B% G" j) B

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

慧娴亚伦 发表于 2018-11-4 19:12
办法1：从2016版本里面复制相应的代码
) O5 G- ~" `. C$ U0 d+ A$ `: v
' F, h) X" A8 j; c. K具体代码如下：

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