void theMultishuttle_OnArrivedAtOutfeedRackConvPosB(object sender, RackConveyorArrivalEventArgs e)
{
//e._caseLoad.Stop();
IATCCaseLoadType atcLoad = e._caseLoad as IATCCaseLoadType;
//If destination is a drop station ("D") there will be no new StartTransportTelegram so continue and create a elevator task
if (BaseATCController.GetLocFields(atcLoad.Destination, PSDSRackLocFields.ConvType) == "D")
{
if (e._elevator.CurrentTask == null || (e._elevator.CurrentTask != null && !e._elevator.CurrentTask.RelevantElevatorTask(e._caseLoad)))
{
string level = BaseATCController.GetPSDSLocFields(((IATCCaseLoadType)e._caseLoad).Destination, PSDSRackLocFields.Level);
// create an elevator task
string aisle = e._locationName.AisleNumber().ToString().PadLeft(2, '0');
char side = (char)e._locationName.Side();
ElevatorTask et = new ElevatorTask(null, e._caseLoad.Identification)
{
SourceLoadB = e._locationName,
DestinationLoadB = string.Format("{0}{1}{2}{3}A", aisle, side, level, (char)ConveyorTypes.Drop), // aasyyxz: a=aisle, s = side, yy = level, x = input or output, Z = loc A or B e.g. 01R05OA
DropIndexLoadB = atcLoad.DropIndex,
LoadCycle = Cycle.Single,
UnloadCycle = Cycle.Single,
Flow = TaskType.Outfeed
};
string elevatorName = string.Format("{0}{1}", side, aisle);
theMultishuttle.elevators.First(x => x.ElevatorName == elevatorName).ElevatorTasks.Add(et);
}
}
}
public void ap_Enter(DematicCommunicationPoint sender, Load load)
{
IATCCaseLoadType caseLoad = load as IATCCaseLoadType;
if (caseLoad == null)
{
return;
}
caseLoad.Location = commPoint.Name; //Update the caseload location
switch (CommPointType)
{
case CommPointATCInfo.CommPointATCTypes.None: break;
case CommPointATCInfo.CommPointATCTypes.LocationArrived: LocationArrived(CommPoint, caseLoad); break;
case CommPointATCInfo.CommPointATCTypes.LocationLeft: LocationLeft(commPoint, caseLoad); break;
case CommPointATCInfo.CommPointATCTypes.TransportRequest: TransportRequest(commPoint, caseLoad); break;
case CommPointATCInfo.CommPointATCTypes.TransportFinished: TransportFinished(commPoint, caseLoad); break;
case CommPointATCInfo.CommPointATCTypes.TransportRequestOrFinished: TransportRequestOrFinished(commPoint, caseLoad); break;
default: break;
}
}
public void SendTransportRequestTelegram(IATCCaseLoadType load)
{
string telegram = CreateTelegramFromLoad(TelegramTypes.TransportRequestTelegram, load);
telegram = telegram.InsertField("dropIndex", load.DropIndex.ToString().PadLeft(4, '0')); //Additional drop index added to build sequencing into ATC
SendTelegram(telegram, true);
}
void theMultishuttle_OnArrivedAtDropStationConvPosB(object sender, PickDropStationArrivalEventArgs e)
{
IATCCaseLoadType load = (IATCCaseLoadType)e._caseLoad;
if (e._numberOfLoads == 2 && e._elevator.ElevatorConveyor.Route.Loads.Count == 0) // Double dropoff received
{
e._elevator.SetNewElevatorTask();
}
}
void theTransfer_OnTransferStatusChangedController(object sender, EventArgs e)
{
//ReleaseDelayTimer on transfer has timed out, or one of the next conveyors routes has become available,
//check if there are any loads that can be released
if (theTransfer.mergeQueue.Count > 0) //There is something waiting to transfer in
{
List <Side> priorityQueue = new List <Side>();
if (theTransfer.mergeQueue.Count == 1 || LoadReleasePriority == ReleasePriority.FIFO)
{
priorityQueue = theTransfer.mergeQueue.ToList();
}
else if (LoadReleasePriority == ReleasePriority.Left)
{
priorityQueue.Add(Side.Left);
priorityQueue.Add(Side.Right);
}
else if (LoadReleasePriority == ReleasePriority.Right)
{
priorityQueue.Add(Side.Right);
priorityQueue.Add(Side.Left);
}
foreach (Side side in priorityQueue)
{
IATCCaseLoadType atcLoad = theTransfer.SideLoadWaitingStatus(side).WaitingLoad as IATCCaseLoadType;
if (atcLoad != null)
{
bool routeLoadLeft = LeftRoutes.Contains(atcLoad.Destination) ? true : false;
bool routeLoadRight = RightRoutes.Contains(atcLoad.Destination) ? true : false;
if (routeLoadLeft && theTransfer.RouteAvailable(Side.Left))
{
//Load can travel left
ReleaseLoad(side, Side.Left, (Load)atcLoad);
return;
}
else if (routeLoadRight && theTransfer.RouteAvailable(Side.Right))
{
//Load can travel right
ReleaseLoad(side, Side.Right, (Load)atcLoad);
return;
}
else
{
return;
}
}
else
{
Log.Write(string.Format("Error: {0} load null un expected! theTransfer_OnTransferStatusChangedController", side.ToString()));
return;
}
}
}
}
private void LocationLeft(CommunicationPoint commPoint, IATCCaseLoadType caseLoad)
{
if (AlwaysArrival || caseLoad.Location == caseLoad.Destination)
{
caseLoad.Location = commPoint.Name;
//caseLoad.MTS = commPoint.ControllerName;
casePLC.SendLocationLeftTelegram(caseLoad as IATCCaseLoadType);
}
}
/// <summary>
/// Send a Location Left Telegram
/// </summary>
/// <param name="load">The load</param>
/// <param name="weight">default null: Should Location Left Contain Weight</param>
public void SendLocationArrivedTelegram(IATCCaseLoadType load, string weight = null)
{
string telegram = CreateTelegramFromLoad(TelegramTypes.LocationArrivedTelegram, load);
if (weight != null)
{
telegram = telegram.InsertField("weight", weight);
}
SendTelegram(telegram, true);
}
void theMultishuttle_OnArrivedAtRackLocation(object sender, TaskEventArgs e)
{
IATCCaseLoadType ATCload = (IATCCaseLoadType)e._load;
string sendTelegram = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.MultishuttleTransportFinishedTelegram, ATCload);
string[] sendTelegramSplit = sendTelegram.Split(',');
sendTelegramSplit.SetFieldValue(TelegramFields.location, ATCload.Destination);
sendTelegramSplit.SetFieldValue(TelegramFields.stateCode, ATCload.PresetStateCode);
mheController_Multishuttle.SendTelegram(string.Join(",", sendTelegramSplit), true);
}
private void SendTransportFinishedTelegram(Case_Load caseLoad, string Location, string status)
{
IATCCaseLoadType atcLoad = caseLoad as IATCCaseLoadType;
atcLoad.Location = Location;
if (status != null)
{
atcLoad.PresetStateCode = status;
}
casePLC.SendTransportFinishedTelegram(caseLoad as IATCCaseLoadType);
}
public void SendMultipleTransportFinishedTelegram(IATCCaseLoadType load1, IATCCaseLoadType load2)
{
string telegram1 = CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, load1);
string telegram2 = CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, load2);
string telegram = Telegrams.CreateMultipalMessage(new List <string>()
{
telegram1, telegram2
}, TelegramTypes.MultipleTransportFinishedTelegram, Name);
SendTelegram(telegram, true);
}
private void TransportFinished(CommunicationPoint commPoint, IATCCaseLoadType caseLoad)
{
if (AlwaysArrival || caseLoad.Location == caseLoad.Destination)
{
caseLoad.Location = commPoint.Name;
casePLC.SendTransportFinishedTelegram(caseLoad);
if (LoadWait)
{
caseLoad.LoadWaitingForWCS = true;
caseLoad.Stop();
}
}
}
void theMultishuttle_OnArrivedAtElevatorConvPosA(object sender, ArrivedOnElevatorEventArgs e)
{
if (e._loadB == null) //Only send the arrival for the load once when it arrves at position A - Do not send again if a double pick is detected (LoadB is populated)
{
IATCCaseLoadType load = (IATCCaseLoadType)e._loadA;
load.Location = string.Format("MSAI{0}E{1}01LO00", e._elevator.AisleNumber.ToString().PadLeft(2, '0'), (char)e._elevator.Side);
string sendMessage = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.LocationArrivedTelegram, load);
mheController_Multishuttle.SendTelegram(sendMessage, true);
if (((ElevatorTask)e._task).NumberOfLoadsInTask == 1 && ((ElevatorTask)e._task).Flow == TaskType.Outfeed)
{
((ElevatorTask)e._task).OptimiseTask(e._elevator);
}
}
}
private void SendConfirmationTelegram(Case_Load caseLoad, string Location)
{
IATCCaseLoadType atcLoad = caseLoad as IATCCaseLoadType;
atcLoad.Location = Location;
switch (DivertMessageType)
{
case DivertTelegram.LocationArrived: casePLC.SendLocationArrivedTelegram(caseLoad as IATCCaseLoadType); break;
case DivertTelegram.LocationLeft: casePLC.SendLocationLeftTelegram(caseLoad as IATCCaseLoadType); break;
case DivertTelegram.TransportFinished: casePLC.SendTransportFinishedTelegram(caseLoad as IATCCaseLoadType); break;
case DivertTelegram.TransportRequest: casePLC.SendTransportRequestTelegram(caseLoad as IATCCaseLoadType); break;
}
}
//TODO: For the loads that are stopping on the case conveyor at these communication points it
//has to be placed in the correct position otherwise its can be an issue (I have found that placing
//them in exactly the correct place compaired to a accumulation sensor is a good position as all atction point are triggered
private void TransportRequest(CommunicationPoint commPoint, IATCCaseLoadType caseLoad)
{
if (AlwaysArrival || caseLoad.Location == caseLoad.Destination || string.IsNullOrEmpty(caseLoad.Destination))
{
caseLoad.Location = commPoint.Name;
//caseLoad.MTS = commPoint.ControllerName;
casePLC.SendTransportRequestTelegram(caseLoad);
if (LoadWait)
{
//[BG] Not happy with this, if this is used then it needs to be understood what the issues are with it
//(Like stopping on a belt is bad and you need to put the Comm Point in the right place on accumulation conveyor)
caseLoad.LoadWaitingForWCS = true;
caseLoad.Stop();
}
}
}
void theMultishuttle_OnArrivedAtPickStationConvPosA(object sender, PickDropStationArrivalEventArgs e)
{
IATCCaseLoadType caseloadA = (IATCCaseLoadType)(e._caseLoad);
caseloadA.Location = FormatPickDropLocation(e._locationName, ConveyorTypes.Pick); //Update the location
caseloadA.Destination = caseloadA.Location;
string tlg = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.TransportRequestTelegram, caseloadA);
string[] tlgSplit = tlg.Split(',');
tlgSplit.SetFieldValue(TelegramFields.stateCode, "OK");
caseloadA.UserData = string.Join(",", tlgSplit); //putting it in user data alows easer message creation for the ATC multipal messages , the load reference is held on the conveyor see below
var loc = theMultishuttle.ConveyorLocations.Find(x => x.LocName == e._locationName);
var conv = loc.Parent.Parent.Parent as PickStationConveyor;
if (e._numberOfLoads == 2)
{
var caseLoadB = (IATCCaseLoadType)conv.TransportSection.Route.Loads.Last.Value; //Front load
if (caseLoadB == caseloadA)
{
Core.Environment.Log.Write($"{this.theMultishuttle.Name} Error: theMultishuttle_OnArrivedAtPickStationConvPosA LoadA == LoadB!!");
Core.Environment.Scene.Pause();
}
mheController_Multishuttle.RemoveIgnoreCase(caseLoadB);
string bodyB = (string)(caseLoadB.UserData); //Grab the already created message from the load using the load reference
string bodyA = (string)(caseloadA.UserData);
if (MultiPSTelegrams)
{
string sendTelegram = Telegrams.CreateMultipalMessage(new List <string>()
{
bodyB, bodyA
},
TelegramTypes.MultipleTransportRequestTelegram, mheController_Multishuttle.Name);
mheController_Multishuttle.SendTelegram(sendTelegram, true);
}
else
{
mheController_Multishuttle.SendTelegram(bodyB, true);
//MRP 24-10-2018. Wait until transport telegram is received for load B. mheController_Multishuttle.SendTelegram(bodyA, true); //position A load
}
mheController_Multishuttle.PickStationLock(caseLoadB);
}
}
void theMultishuttle_OnArrivedAtDropStationConvPosA(object sender, PickDropStationArrivalEventArgs e)
{
IATCCaseLoadType load = (IATCCaseLoadType)e._caseLoad;
load.Location = load.Destination;
load.UserData = null;
string sendMessage;
sendMessage = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.MultishuttleTransportFinishedTelegram, load);
sendMessage = sendMessage.SetFieldValue(TelegramFields.dropIndex, load.DropIndex.ToString());
mheController_Multishuttle.SendTelegram(sendMessage, true);
if (e._elevator.CurrentTask != null && e._elevator.CurrentTask.RelevantElevatorTask(e._caseLoad))
{
e._elevator.SetNewElevatorTask();
}
}
bool divertArrival(Load load)
{
IATCCaseLoadType atcLoad = load as IATCCaseLoadType;
if (LoadDestination && mergeDivertConveyor.Name == atcLoad.Destination && !atcLoad.LoadWaitingForWCS)
{
atcLoad.Stop();
atcLoad.LoadWaitingForWCS = true;
atcLoad.Location = mergeDivertConveyor.Name;
casePLC.SendTransportFinishedTelegram(atcLoad);
return(true);
//Send a message to WMS and wait for the routing
}
List <Direction> validRoutes = new List <Direction>();
Case_Load caseload = load as Case_Load;
if (atcLoad.Destination != null && mergeDivertConveyor.LeftMode == Modes.Divert && LeftRoutes != null && LeftRoutes.Contains(atcLoad.Destination))
{
validRoutes.Add(Direction.Left);
}
if (atcLoad.Destination != null && mergeDivertConveyor.RightMode == Modes.Divert && RightRoutes != null && RightRoutes.Contains(atcLoad.Destination))
{
validRoutes.Add(Direction.Right);
}
if (atcLoad.Destination != null && mergeDivertConveyor.StraightMode == Modes.Divert && StraightRoutes != null && StraightRoutes.Contains(atcLoad.Destination))
{
validRoutes.Add(Direction.Straight);
}
//Check if the load has the priority bit set
bool priority = false;
if (atcLoad.Destination != null && PriorityRoutes != null && PriorityRoutes.Contains(atcLoad.Destination))
{
priority = true;
}
mergeDivertConveyor.RouteLoad(load, validRoutes, priority);
return(true); //returns true if handled by this controller
}
void theMultishuttle_OnArrivedAtInfeedRackConvPosA(object sender, RackConveyorArrivalEventArgs e)
{
ShuttleTask st = new ShuttleTask();
string destination = ((IATCCaseLoadType)e._caseLoad).Destination;
if (destination.LocationType() == LocationTypes.RackConv)
{
IATCCaseLoadType atcLoad = e._caseLoad as IATCCaseLoadType;
atcLoad.Location = atcLoad.Destination;
string sendTelegram = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.MultishuttleTransportFinishedTelegram, atcLoad);
mheController_Multishuttle.SendTelegram(sendTelegram, true);
//return;
}
if (e._elevator.ElevatorConveyor.Route.Loads.Count == 0)
{
e._elevator.SetNewElevatorTask();
}
}
private void TransportRequestOrFinished(CommunicationPoint commPoint, IATCCaseLoadType caseLoad)
{
if (caseLoad.Location == caseLoad.Destination)
{
//Send TransportFinishedTelegram
caseLoad.Location = commPoint.Name;
casePLC.SendTransportFinishedTelegram(caseLoad);
}
else
{
//Send TransportRequestTelegram
caseLoad.Location = commPoint.Name;
casePLC.SendTransportRequestTelegram(caseLoad);
}
if (LoadWait)
{
caseLoad.LoadWaitingForWCS = true;
caseLoad.Stop();
}
}
void transfer_OnArrivedAtTransferController(object sender, TransferArrivalArgs e)
{
IATCCaseLoadType atcLoad = e._load as IATCCaseLoadType;
//Load has arrived at one of entry points to the transfer
//Calculate the preferred route for the load and save
if (!theTransfer.PreferredLoadRoutes.ContainsKey((Case_Load)e._load))
{
if (LeftRoutes.Contains(atcLoad.Destination))
{
theTransfer.PreferredLoadRoutes.Add((Case_Load)e._load, Side.Left);
}
else if (RightRoutes.Contains(atcLoad.Destination))
{
theTransfer.PreferredLoadRoutes.Add((Case_Load)e._load, Side.Right);
}
}
//bool LoadRouted = false;
if (!theTransfer.ReleaseDelayTimerRunning) //Timer not running can i release a load
{
if (LeftRoutes.Contains(atcLoad.Destination) && theTransfer.RouteAvailable(Side.Left))
{
ReleaseLoad(e._fromSide, Side.Left, e._load);
//LoadRouted = true;
}
else if (RightRoutes.Contains(atcLoad.Destination) && theTransfer.RouteAvailable(Side.Right))
{
ReleaseLoad(e._fromSide, Side.Right, e._load);
//LoadRouted = true;
}
else if (!LeftRoutes.Contains(atcLoad.Destination) && !RightRoutes.Contains(atcLoad.Destination) && theTransfer.RouteAvailable(e._defaultDirection))
{
ReleaseLoad(e._fromSide, e._defaultDirection, (Case_Load)e._load);
//LoadRouted = true;
}
}
}
void theMultishuttle_OnArrivedAtOutfeedRackConvPosA(object sender, RackConveyorArrivalEventArgs e)
{
IATCCaseLoadType caseload = (IATCCaseLoadType)(e._caseLoad);
caseload.Location = FormatRackConvLocation(e._locationName, ConveyorTypes.OutfeedRack); //Update the location
if (BaseATCController.GetLocFields(caseload.Destination, PSDSRackLocFields.ConvType) == "D")
{
string sendMessage = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.LocationArrivedTelegram, caseload);
mheController_Multishuttle.SendTelegram(sendMessage, true); //Always Send a notification at location A
//Combine a task with an existing task but only if the final destination is a drop station because if destination is the rack conveyor then we need to wait for another message from the WMS
if (e._elevator.CurrentTask != null && e._rackConveyor.LocationB.Active && !e._elevator.CurrentTask.RelevantElevatorTask(e._rackConveyor.LocationB.ActiveLoad))
{
string aisle = e._elevator.AisleNumber.ToString().PadLeft(2, '0');
string level = BaseATCController.GetLocFields(((IATCCaseLoadType)e._caseLoad).Destination, PSDSRackLocFields.Level);
string destLoadA = string.Format("{0}{1}{2}{3}A", aisle, (char)e._locationName.Side(), level, (char)ConveyorTypes.Drop);
//Create the task but do not add it to elevator tasks list
ElevatorTask et = new ElevatorTask(e._caseLoad.Identification, null)
{
SourceLoadA = e._locationName,
DestinationLoadA = destLoadA,
SourceLoadAConv = theMultishuttle.GetConveyorFromLocName(e._locationName),
DestinationLoadAConv = theMultishuttle.GetConveyorFromLocName(destLoadA),
Elevator = e._elevator
};
//This task should just be added and not combined as the combining is now done later
//TODO: Make it so that direct outfeed loads still work
et.CreateNewDoubleLoadCycleTask(et, e._rackConveyor.LocationB.ActiveLoad.Identification);
}
}
else
{
string sendMessage = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.MultishuttleTransportFinishedTelegram, caseload);
mheController_Multishuttle.SendTelegram(sendMessage, true); //Always Send a notification at location A
}
}
private void CancelTransportTelegramReceived(string[] telegramFields)
{
//If cancel telegram is received, find the load in the model, delete it and send a Confirm
string tuIdent = telegramFields.GetFieldValue(TelegramFields.tuIdent);
IATCCaseLoadType atcLoad = (IATCCaseLoadType)Case_Load.GetCaseFromIdentification(tuIdent);
if (atcLoad != null)
{
//string telegram = string.Empty.InsertType(TelegramTypes.ConfirmCancelTelegram);
//telegram = telegram.AppendField(TelegramFields.tuIdent, atcLoad.TUIdent);
//telegram = telegram.AppendField(TelegramFields.mts, telegramFields.GetFieldValue(TelegramFields.mts));
//telegram = telegram.AppendField(TelegramFields.stateCode, telegramFields.GetFieldValue(TelegramFields.presetStateCode));
//telegram = telegram.AppendField(TelegramFields.location, atcLoad.Location);
//SendTelegram(telegram, true);
atcLoad.Dispose();
}
else
{
//Could not find the load, it has not been deleted
Log.Write(string.Format("ATC Error {0}: Could not find load {1} in CancelTransportTelegram, load has not been deleted", Name, tuIdent), Color.Red);
}
}
void theMultishuttle_OnArrivedAtShuttle(object sender, TaskEventArgs e)
{
IATCCaseLoadType load = (IATCCaseLoadType)e._load;
//load.Location = string.Format("MSAI{0}LV{1}SH01", BaseATCController.GetRackLocFields(load.Destination, PSDSRackLocFields.Aisle), BaseATCController.GetRackLocFields(load.Destination, PSDSRackLocFields.Level));
string aisle = BaseATCController.GetBinLocField(load.Source, BinLocFields.Aisle);
if (aisle == "" && ((ShuttleTask)e._task).Source.Length > 2) //If you cannot get the aisle from the bin location, then get from the task instead
{
string checkAisle = ((ShuttleTask)e._task).Source.Substring(0, 2);
int result;
if (int.TryParse(checkAisle, out result))
{
aisle = checkAisle;
}
}
//load.Location = string.Format("MSAI{0}LV{1}SH01", BaseATCController.GetBinLocField(load.Source, BinLocFields.Aisle), ((ShuttleTask)e._task).Level.ToString().PadLeft(2, '0'));
load.Location = string.Format("MSAI{0}LV{1}SH01", aisle, ((ShuttleTask)e._task).Level.ToString().PadLeft(2, '0'));
string sendMessage = mheController_Multishuttle.CreateTelegramFromLoad(TelegramTypes.LocationArrivedTelegram, load);
mheController_Multishuttle.SendTelegram(sendMessage, true);
}
private void StartTransportTelegramReceived(string[] telegramFields)
{
//Look for the load somewhere in the model, if the load is found then change it's status, if not create it at the source location
//ATCCaseLoad caseLoad = (ATCCaseLoad)Case_Load.GetCaseFromIdentification(telegramFields.GetFieldValue(TelegramFields.tuIdent));
IATCCaseLoadType caseLoad = (IATCCaseLoadType)Case_Load.GetCaseFromIdentification(telegramFields.GetFieldValue(TelegramFields.tuIdent));
if (caseLoad != null) //The load has been found so some attributes need to be changed (Cannot change the dimensions of the load however)
{
caseLoad.TUType = telegramFields.GetFieldValue(TelegramFields.tuType);
caseLoad.Source = telegramFields.GetFieldValue(TelegramFields.source);
caseLoad.Destination = telegramFields.GetFieldValue(TelegramFields.destination);
caseLoad.PresetStateCode = telegramFields.GetFieldValue(TelegramFields.presetStateCode);
caseLoad.Color = LoadColor(telegramFields.GetFieldValue(TelegramFields.color));
float weight;
float.TryParse(telegramFields.GetFieldValue(TelegramFields.weight), out weight);
caseLoad.CaseWeight = weight / 1000;
//Deal with additional project specific fields
foreach (string field in ProjectFields)
{
string fieldValue = telegramFields.GetFieldValue(field);
if (fieldValue != null)
{
if (caseLoad.ProjectFields.ContainsKey(field))
{
caseLoad.ProjectFields[field] = fieldValue;
}
else
{
caseLoad.ProjectFields.Add(field, fieldValue);
}
}
}
//The load may be at a request location and the load will need to be released
if (caseLoad.LoadWaitingForWCS && caseLoad.Stopped)
{
//Load may be waiting on a transfer so call the mergeDivert
if (caseLoad.Route.Parent.Parent is MergeDivertConveyor)
{
MergeDivertConveyor mergeDivert = caseLoad.Route.Parent.Parent as MergeDivertConveyor;
//if (mergeDivert.divertArrival != null)
//{
// mergeDivert.divertArrival(caseLoad);
//}
mergeDivert.ControlDivertPoint((Load)caseLoad);
}
caseLoad.LoadWaitingForWCS = false;
caseLoad.ReleaseLoad();
}
}
else //The load has not been found but should one be created? Normally created through the Emulation Control Telegrams
{
if (Core.Assemblies.Assembly.Items.ContainsKey(telegramFields.GetFieldValue(TelegramFields.source)) &&
Core.Assemblies.Assembly.Items[telegramFields.GetFieldValue(TelegramFields.source)] is StraightConveyor)
{
caseLoad = CreateCaseLoad(TelegramTypes.StartTransportTelegram, telegramFields);
StraightConveyor sourceConv = Core.Assemblies.Assembly.Items[telegramFields.GetFieldValue(TelegramFields.source)] as StraightConveyor;
caseLoad.SetYaw(sourceConv.Width, sourceConv.CaseOrientation);
float position = 0;
if (caseLoad.Yaw == 0)
{
position = position + (caseLoad.Length / 2);
}
else
{
position = position + (caseLoad.Width / 2);
}
sourceConv.TransportSection.Route.Add((Load)caseLoad, position);
}
else
{
Log.Write(string.Format("ATC Error {0}: Cannot create load at location from StartTransportTelegram, location {1} does not exist, message ignored", Name, telegramFields.GetFieldValue(TelegramFields.source)), Color.Red);
}
}
}
public void SendTransportFinishedTelegram(IATCCaseLoadType load)
{
string telegram = CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, load);
SendTelegram(telegram, true);
}
public void SendLocationLeftTelegram(IATCCaseLoadType load)
{
string telegram = CreateTelegramFromLoad(TelegramTypes.LocationLeftTelegram, load);
SendTelegram(telegram, true);
}
