question

Hey @Ankith T, I've got a possible solution. It's a simplified version, but maybe it could translate to your model.

I I have two parallel lines of work. I only want the smaller AGVs to use the lane when the Forklift isn't using it (and vice versa). I setup the Control Points (CPs) to have several labels on them:

• LaneEnd - a reference to the CP that denotes the other end of the lane (in this case CP3; if you look at CP3, it will have this CP as its LaneEnd reference).
• NeighborCP - a reference to the CP in the other lane at the same position as this CP.
• Occupants - an array that keeps track of how many AGVs are currently in this lane

I added a label on each AGV; a "Type" label for either "small" or "large" to help distinguish whether an AGV needed to occupy both lanes.

I added these CPs to a group "LaneEnds" and made a small Process Flow to activate some traffic controlling when an AGV arrives at a CP.

Here is the code for the Traffic Controller Custom Code:

/**Custom Code*/
Object current = param(1);
treenode activity = param(2);
Token token = param(3);
treenode processFlow = ownerobject(activity);

Object currentCP = token.currentCP;
Object trafficManager = Model.find("TrafficManager");
AGV agv = AGV(token.agv);
token.labels.assert("Stopped", 0);

treenode laneEnd = currentCP.labels["LaneEnd"].value;
treenode neighborCP = currentCP.labels["NeighborCP"].value;
Array curTEs = currentCP.labels["Occupants"].value;

// I (TE) arrive at CP
// Check to see if I am leaving the lane
int isLeavingLane = 0;
for (int i = 1; i <= curTEs.length; i++) {
  if (curTEs[i].name == agv.object.name) {
    isLeavingLane = 1;
    break;
  }
}

if (isLeavingLane) {
  curTEs = curTEs.splice(1, 1);
  currentCP.labels["Occupants"].value = curTEs;
  laneEnd.labels["Occupants"].value = curTEs;
  sendmessage(trafficManager, currentCP);
  return 0;
}

// Check to see if the neighbor has occupants
Array neighborTEs = neighborCP.labels["Occupants"].value;

// If there are no occupants in the neighbor lane, then proceed normally
if (neighborTEs.length == 0) {
  curTEs.push(agv.object);
  currentCP.labels["Occupants"].value = curTEs;
  laneEnd.labels["Occupants"].value = curTEs;
  return 0;
}

// The neighbor lane has occupants; do I need to wait? (Yes if either TE is "large")
int curTEIsLarge = agv.object.labels["Type"].value == "large" ? 1 : 0;
int neighborIsLarge = 0;
for (int i = 1; i <= neighborTEs.length; i++) {
  TaskExecuter neighborTE = neighborTEs[i];
  if (neighborTE.labels["Type"].value == "large") {
    neighborIsLarge = 1;
    break;
  }
}

// If you don't need to wait, then proceed normally
if (!curTEIsLarge && !neighborIsLarge) {
  curTEs.push(agv.object);
  currentCP.labels["Occupants"].value = curTEs;
  laneEnd.labels["Occupants"].value = curTEs;
  return 0;
}

// Either I'm large or my neighbor has a large occupant;
// Stop traveling until I get a message saying the neighbor is clear
agv.object.stop(STATE_STOPPED, 1);
token.labels["Stopped"].value = 1;
trafficManager.labels["stoppedAGVs"].value.as(Array).push(agv.object);

return 1;

I hope the comments I have help you understand what's happening. Basically, I'm running checks on each CP and lane to make sure it's okay for them to travel. If not, I stop them.

If an AGV is stopped, it will need to resume somehow. That's where the "TrafficManager" comes in. If an AGV is leaving the area, it will send a message to the "TrafficManager" fixed resource - just a cube I used to send a message to. It has an OnMessage trigger that fires this code when it gets a message from a CP:

/**Custom Code*/
Object current = ownerobject(c);
Object fromObject = param(1);
Variant msgparam1 = param(2);
Variant msgparam2 = param(3);
Variant msgparam3 = param(4);

Array stoppedAGVs = current.labels["stoppedAGVs"].value;
if (stoppedAGVs.length == 0) {
  return 0;
}

AGV agv = AGV(stoppedAGVs[1]);
Object currentLaneCP1 = fromObject.labels["NeighborCP"].value;
Object currentLaneCP2 = currentLaneCP1.labels["LaneEnd"].value;

agv.object.resume(1);
stoppedAGVs.pop();
//current.labels["stoppedAGVs"].value = stoppedAGVs;
currentLaneCP1.labels["Occupants"].value = [agv.object];
currentLaneCP2.labels["Occupants"].value = [agv.object];

return 1;

Basically, it resumes the stopped AGV and sets the Occupants to contain the newly resumed AGV.

This is what it looks like in action:

blocking-traffic.fsm