public bool NearestCmd1(SimpleCraneCommand cmd1, SimpleCraneCommand cmd2, FLocation location)
{
FLocation fpos1 = GetLocation(cmd1.Source);
FLocation fpos2 = GetLocation(cmd2.Source);
return((location - fpos1).Distance() <= (location - fpos2).Distance());
}
public SimpleCraneCommand GetNewCommand(bool remote, SimpleCraneCommand otherDeck)
{
if (Command == null || Command.Status >= SimpleCommand.EnumStatus.Canceled)
{
if (!Warehouse.SteeringCommands.AutomaticMode)
{
Command = Warehouse.DBService.FindFirstSimpleCraneCommand(Crane.Name, false); // for simple commands
}
else
{
Command = Warehouse.DBService.FindFirstSimpleCraneCommand(Crane.Name, true); // for move to work
if (!(Command != null && Command.Task == SimpleCommand.EnumTask.Move))
{
if (Crane.Place != null)
{
Command = GetCommandFromOccupiedState(Crane.Place.Material, remote);
}
else
{
Command = GetCommandFromFreeState(PrefferedInput, remote, BannedPlaces, otherDeck);
}
}
}
return(Command);
}
if (BufferCommand == null || BufferCommand.Status >= SimpleCommand.EnumStatus.Canceled)
{
if (Warehouse.SteeringCommands.AutomaticMode)
{
if (Command.Task == SimpleCommand.EnumTask.Move)
{
// check for outbound
if (Crane.Place != null)
{
BufferCommand = GetCommandFromOccupiedState(Crane.Place.Material, remote);
}
else
{
BufferCommand = GetCommandFromFreeState(PrefferedInput, remote, BannedPlaces, otherDeck);
}
}
else if (Command.Task == SimpleCommand.EnumTask.Pick)
{
BufferCommand = GetCommandFromOccupiedState(Command.Material.Value, remote);
}
else if (Command.Task == SimpleCommand.EnumTask.Drop)
{
BufferCommand = GetCommandFromFreeState(PrefferedInput, remote, BannedPlaces, otherDeck);
}
}
return(BufferCommand);
}
return(null);
}
public void WriteCommandToPLC(SimpleCraneCommand cmd, bool fastCommand = false)
{
if (cmd != null && cmd.Status <= SimpleCommand.EnumStatus.NotActive)
{
Crane.WriteCommandToPLC(cmd, fastCommand);
if (cmd.Task == SimpleCommand.EnumTask.Pick)
{
PickAction = cmd;
}
if (cmd.Task == SimpleCommand.EnumTask.Drop)
{
DropAction = cmd;
}
}
}
public string CraneCommandToString(SimpleCraneCommand cmd)
{
if (cmd != null)
{
switch (cmd.Task)
{
case EnumTask.Cancel:
case EnumTask.Create:
case EnumTask.Delete: return(String.Format("{0}: {1} {2} {3} {4}", cmd.ID, cmd.Task, cmd.Material, ResourceReader.GetString("From"), cmd.Source));
case EnumTask.Move: return(String.Format("{0}: {1} {2} {3}", cmd.ID, cmd.Task, ResourceReader.GetString("To"), cmd.Source));
case EnumTask.Drop:
case EnumTask.Pick: return(String.Format("{0}: {1} {2} {3} {4}", cmd.ID, ResourceReader.GetString(cmd.Task.ToString()), cmd.Material,
ResourceReader.GetString(cmd.Task == EnumTask.Drop ? "To" : "From"), cmd.Source));
}
}
return("");
}
private void AddCommandToPLC(SimpleCraneCommand cmd)
{
LPosition pos = LPosition.FromString(cmd.Source);
if (!pos.IsWarehouse())
{
if (cmd.Task == EnumSimpleCraneCommandTask.Pick)
{
pos = FindInTransport(cmd.Source).CraneAdress;
}
else if (cmd.Task == EnumSimpleCraneCommandTask.Drop)
{
pos = FindOutTransport(cmd.Source).CraneAdress;
}
else if (cmd.Task == EnumSimpleCraneCommandTask.Goto)
{
pos = FindInOutTransport(cmd.Source).CraneAdress;
}
}
Communicator.AddSendTelegram(
new Telegrams.TelegramCraneTO
{
Sender = PLC_ID,
MFCS_ID = cmd.ID,
Order = (short)cmd.Task,
Position = new Telegrams.Position {
R = (short)pos.Shelve, X = (short)pos.Travel, Y = (short)pos.Height, Z = (short)pos.Depth
},
Palette = new Telegrams.Palette {
Barcode = Convert.ToUInt32(cmd.Material)
}
});
using (var dc = new MFCSEntities())
{
dc.SimpleCraneCommands.Attach(cmd);
cmd.Status = EnumSimpleCraneCommandStatus.Written;
dc.SaveChanges();
}
}
private SimpleCraneCommand GetCommandFromOccupiedState(int material, bool automatic)
{
try
{
SimpleCraneCommand res = null;
// check if outbound
var target = Warehouse.DBService.FindFirstCommand(material, automatic);
if (target != null)
{
LPosition position = LPosition.FromString(target.Target);
if (!position.IsWarehouse() || (!Crane.Shelve.Contains((short)position.Shelve)))
{
res = Crane.FindBestOutput(target);
// if (res != null)
// Warehouse.DBService.AddSimpleCommand(res);
}
else
{
// Warehouse.DBService.AddSimpleCommand(
res = new SimpleCraneCommand
{
Unit = Crane.Name,
Command_ID = target.ID,
Material = material,
Task = SimpleCommand.EnumTask.Drop,
Source = target.Target,
Status = SimpleCommand.EnumStatus.NotInDB,
Time = DateTime.Now
}
};
}
return(res);
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new StrategyCraneException(String.Format("{0} GetCommandFromOccupiedState failed ({1})", Name, material));
}
}
public void WriteCommandToPLC(SimpleCraneCommand cmd, bool fastCommand = false)
{
try
{
// if (Automatic())
if (Remote() && cmd != null)
{
if ((Automatic() || fastCommand) && cmd != null && cmd.Status <= SimpleCommand.EnumStatus.NotActive) // dodano: automatic
{
if (cmd.Status == SimpleCommand.EnumStatus.NotInDB)
{
cmd.Status = SimpleCommand.EnumStatus.NotActive;
Warehouse.DBService.AddSimpleCommand(cmd);
}
CreateAndSendTOTelegram(cmd);
if (fastCommand)
{
FastCommand = cmd;
}
else if (Command == null)
{
Command = cmd;
}
else if (BufferCommand == null)
{
BufferCommand = cmd;
}
}
}
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new CraneException(String.Format("{0} WriteCommandToPLC failed", Name));
}
}
public override void Strategy()
{
try
{
if (!Warehouse.StrategyActive)
{
return;
}
if (!Strategy1.Crane.Communicator.Online())
{
return;
}
bool remote = Warehouse.SteeringCommands.RemoteMode;
LinkedConveyor lc = null;
Strategy2.PrefferedInput = Strategy1.PrefferedInput;
Strategy1.Command = Strategy1.Crane.Command;
Strategy1.BufferCommand = Strategy1.Crane.BufferCommand;
Strategy2.Command = Strategy2.Crane.Command;
Strategy2.BufferCommand = Strategy2.Crane.BufferCommand;
if (Strategy1.Crane.FastCommand == null)
{
Strategy1.Crane.FastCommand = Warehouse.DBService.FindFirstFastSimpleCraneCommand(Strategy1.Crane.Name, Warehouse.SteeringCommands.AutomaticMode);
}
if (Strategy2.Crane.FastCommand == null)
{
Strategy2.Crane.FastCommand = Warehouse.DBService.FindFirstFastSimpleCraneCommand(Strategy2.Crane.Name, Warehouse.SteeringCommands.AutomaticMode);
}
Strategy1.WriteCommandToPLC(Strategy1.Crane.FastCommand, true);
Strategy2.WriteCommandToPLC(Strategy2.Crane.FastCommand, true);
if (!Warehouse.SteeringCommands.Run)
{
return;
}
if ((!Strategy1.Crane.Remote() || Strategy1.Crane.LongTermBlock()))
{
return;
}
if (!Strategy1.Crane.Automatic())
{
return;
}
SimpleCraneCommand c1c = Warehouse.DBService.CheckIfPlaceBlocked(Strategy1.Crane.Name) ? null : Strategy1.GetNewCommand(remote, null);
// SimpleCraneCommand c1b = Strategy1.GetNewCommand(remote);
Strategy2.BannedPlaces.AddRange(Strategy1.BannedPlaces);
SimpleCraneCommand c2c = Warehouse.DBService.CheckIfPlaceBlocked(Strategy2.Crane.Name) ? null : Strategy2.GetNewCommand(remote, c1c);
// SimpleCraneCommand c2b = Strategy2.GetNewCommand(remote);
if (c1c != null && c2c != null && c1c.Task == c2c.Task)
// && ((Strategy1.Crane.Command == null && Strategy2.Crane.Command == null) ||
// (Strategy1.Crane.Command != null && Strategy2.Crane.Command != null)))
{
if (c1c.Task == SimpleCommand.EnumTask.Pick)
{
Strategy1.PrefferedInput = !Strategy1.PrefferedInput;
}
// new both Execute command with same task
bool opposite = false;
FLocation lastloc = null;
if (Strategy1.Crane.Command != null && Strategy2.Crane.Command != null)
{
lastloc = Strategy1.Crane.Command.Command_ID > Strategy2.Crane.Command.ID ? GetLocation(Strategy1.Crane.Command.Source) : GetLocation(Strategy2.Crane.Command.Source);
}
else if (Strategy1.Crane.Command != null)
{
lastloc = GetLocation(Strategy1.Crane.Command.Source);
}
else if (Strategy2.Crane.Command != null)
{
lastloc = GetLocation(Strategy2.Crane.Command.Source);
}
else
{
lastloc = Strategy1.Crane.FLocation;
}
if (c1c != null && c2c != null && c1c.Task == c2c.Task &&
c1c.Source.StartsWith("W") && c2c.Source.StartsWith("W") &&
c1c.Source.Substring(0, c1c.Source.Length - 1) == c2c.Source.Substring(0, c2c.Source.Length - 1))
{
opposite = (c1c.Task == SimpleCommand.EnumTask.Pick && c1c.Source.EndsWith("2") && c2c.Source.EndsWith("1")) ||
(c1c.Task == SimpleCommand.EnumTask.Drop && c1c.Source.EndsWith("1") && c2c.Source.EndsWith("2"));
}
else
{
opposite = (c1c.Task == SimpleCommand.EnumTask.Drop && GetLocation(c1c.Source).X > GetLocation(c2c.Source).X) ||
(c1c.Task == SimpleCommand.EnumTask.Pick && GetLocation(c1c.Source).X < GetLocation(c2c.Source).X);
}
if (!opposite)
{
Strategy1.WriteCommandToPLC(c1c);
Strategy2.WriteCommandToPLC(c2c);
}
else
{
Strategy2.WriteCommandToPLC(c2c);
Strategy1.WriteCommandToPLC(c1c);
}
}
else if (c1c != null && c2c != null && c1c.Task != c2c.Task)
{
// only drop if different comands to be done
if (c1c.Task == SimpleCommand.EnumTask.Drop)
{
Strategy1.WriteCommandToPLC(c1c);
}
else
{
Strategy2.WriteCommandToPLC(c2c);
}
}
else if (c1c != null && (Strategy1.Command == null || Strategy1.Command.Status < SimpleCommand.EnumStatus.Written) && (Strategy2.Command == null || (c1c.Task == Strategy2.Command.Task && c1c.Source.StartsWith("T") && Strategy2.Command.Source.StartsWith("T"))))
{
if (c1c.Task == SimpleCommand.EnumTask.Pick)
{
Strategy1.PrefferedInput = !Strategy1.PrefferedInput;
}
Strategy1.WriteCommandToPLC(c1c);
}
else if (c2c != null && (Strategy2.Command == null || Strategy2.Command.Status < SimpleCommand.EnumStatus.Written) && (Strategy1.Command == null || (c2c.Task == Strategy1.Command.Task && c2c.Source.StartsWith("T") && Strategy1.Command.Source.StartsWith("T"))))
{
if (c2c.Task == SimpleCommand.EnumTask.Pick)
{
Strategy1.PrefferedInput = !Strategy1.PrefferedInput;
}
Strategy2.WriteCommandToPLC(c2c);
}
Strategy1.BannedPlaces.Clear();
Strategy2.BannedPlaces.Clear();
// logic for prefferable double pick
if (Strategy1.PickAction != null && Strategy1.ForcedInput == null)
{
Strategy2.ForcedInput = (lc = LinkedInputConveyors.FirstOrDefault(prop => prop.ConveyorCrane1.Name == Strategy1.PickAction.Source)) != null ? lc.ConveyorCrane2 : null;
}
// logic for prefferable double pick
if (Strategy2.PickAction != null && Strategy2.ForcedInput == null)
{
Strategy1.ForcedInput = (lc = LinkedInputConveyors.FirstOrDefault(prop => prop.ConveyorCrane2.Name == Strategy2.PickAction.Source)) != null ? lc.ConveyorCrane1 : null;
}
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new StrategyDoubleForkCraneException(String.Format("{0} StrategyDoubleForkCrane.Refresh failed", Name));
}
}
public SimpleCraneCommand FindBestWarehouse(bool automatic, List <string> bannedPlaces, SimpleCraneCommand otherDeck)
{
try
{
CommandMaterial cmd = Warehouse.DBService.FindFirstCommandStillInWarehouse(Shelve, automatic, bannedPlaces);
bool found = false;
if (cmd != null)
{
foreach (var route in OutRouteDef.FinalRouteCost)
{
if (route.Items.Last().Final.Compatible(cmd.Target)) // && route.Items[0].Final.Place == null)
{
int cnt = Warehouse.CountSimpleCommandToAcumulation(route.Items[0].Final, new List <ConveyorBasic>(), otherDeck);
if (Warehouse.FreePlaces(route.Items[0].Final) > cnt ||
route.Items[0].Final is Crane)
{
int a = Warehouse.FreePlaces(route.Items[0].Final);
int b = Warehouse.DBService.CountSimpleCraneCommandForTarget(route.Items[0].Final.Name, true);
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Program, String.Format("FindBestWarehouse On {0} Free places {1} Incoming commands {2}", route.Items[0].Final.Name, a, b));
found = true;
break;
}
}
}
if (found)
{
return new SimpleCraneCommand
{
Command_ID = cmd.ID,
Material = (int)cmd.Material,
Source = cmd.Source,
Unit = Name,
Task = SimpleCommand.EnumTask.Pick,
Status = SimpleCommand.EnumStatus.NotInDB,
Time = DateTime.Now
}
}
;
}
return(null);
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new CraneException(String.Format("{0} Crane.FindBestWarehouse failed ({1})", Name, automatic));
}
}
public override void CreateAndSendTOTelegram(SimpleCommand cmd)
{
try
{
if (!(cmd is SimpleCraneCommand))
{
throw new CraneException(String.Format("{0} is not SimpleCraneCommand.", cmd.ToString()));
}
SimpleCraneCommand Cmd = cmd as SimpleCraneCommand;
MaterialID matID = null;
if (Cmd.Material.HasValue)
{
matID = Warehouse.DBService.FindMaterialID((int)Cmd.Material, true);
}
LPosition pos = LPosition.FromString(Cmd.Source);
if (!pos.IsWarehouse())
{
if (cmd.Task == SimpleCommand.EnumTask.Pick)
{
pos = FindInConveyor(cmd.Source).CraneAddress;
}
else if (cmd.Task == SimpleCommand.EnumTask.Drop)
{
pos = FindOutConveyor(cmd.Source).CraneAddress;
}
else if (cmd.Task == SimpleCommand.EnumTask.Move)
{
pos = FindInOutConveyor(cmd.Source).CraneAddress;
}
else if (cmd.Task == SimpleCommand.EnumTask.Cancel)
{
pos = CraneAddress;
if (!cmd.CancelID.HasValue)
{
throw new CraneException(String.Format("{0} Parameter null", cmd != null ? cmd.ToString() : "null"));
}
}
else if (cmd.Task >= SimpleCommand.EnumTask.Delete)
{
pos = CraneAddress;
}
}
if (matID == null && cmd.Task != SimpleCommand.EnumTask.Move && cmd.Task != SimpleCommand.EnumTask.Cancel)
{
throw new CraneException(String.Format("Command validity fault ({0})", cmd.ToString()));
}
Communicator.AddSendTelegram(
new Telegrams.TelegramCraneTO
{
Sender = Communicator.MFCS_ID,
Receiver = Communicator.PLC_ID,
MFCS_ID = cmd.ID,
Order = (short)cmd.Task,
Buffer_ID = (cmd.Task != SimpleCommand.EnumTask.Cancel) ? (matID != null ? matID.ID : 0) : cmd.CancelID.Value,
Position = new Telegrams.Position {
R = (short)pos.Shelve, X = (short)pos.Travel, Y = (short)pos.Height, Z = (short)pos.Depth
},
Palette = new Telegrams.Palette {
Barcode = Convert.ToUInt32(matID != null ? matID.ID : 0), Type = (Int16)(matID != null ? matID.Size : 0), Weight = (UInt16)(matID != null ? matID.Weight : 0)
},
ID = PLC_ID
});
cmd.Status = SimpleCommand.EnumStatus.Written;
Warehouse.DBService.UpdateSimpleCommand(cmd);
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Command, cmd.ToString());
// check for blocked locations
LPosition p = LPosition.FromString(cmd.Source);
string frontLoc;
if (p.Shelve > 0 && p.Depth == 2)
{
LPosition pOther = new LPosition {
Shelve = p.Shelve, Travel = p.Travel, Height = p.Height, Depth = 1
};
frontLoc = pOther.ToString();
}
else
{
frontLoc = cmd.Source;
}
if (Warehouse.DBService.FindPlaceID(cmd.Source) != null &&
(Warehouse.DBService.FindPlaceID(cmd.Source).Blocked || Warehouse.DBService.FindPlaceID(frontLoc).Blocked))
{
Warehouse.Segment[Segment].AlarmRequest(0);
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Command, string.Format("Location blocked. Command: {0}", cmd.ToString()));
}
if (cmd.Command_ID.HasValue)
{
Command command = Warehouse.DBService.FindCommandByID(cmd.Command_ID.Value);
if (command == null)
{
throw new ConveyorException($"Command {command.ToString()} null.");
}
if (command.Status < Database.Command.EnumCommandStatus.Active)
{
command.Status = Database.Command.EnumCommandStatus.Active;
Warehouse.DBService.UpdateCommand(command);
Warehouse.OnCommandFinish?.Invoke(command);
}
}
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new CraneException(String.Format("{0} Crane.CreateAndSendTOTelegram failed. ({1})", Name, cmd != null ? cmd.ToString() : "null"));
}
}
public override void FinishCommand(Int32 id, SimpleCommand cmd, SimpleCommand.EnumStatus s)
{
try
{
if (cmd == null)
{
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Program, String.Format("Crane.FinishCommand ({0},{1},{2}) ", id, "null", s));
}
SimpleCraneCommand cOld = null;
if (cmd == null || cmd.ID != id)
{
if (id != 0)
{
cOld = Warehouse.DBService.FindSimpleCraneCommandByID(id);
}
}
if (cmd == null)
{
cmd = cOld;
}
if (cmd == null && id != 0)
{
throw new CraneException("Can't find command by Id");
}
if (cmd != null && cOld == null && cmd.ID != id && id != 0)
{
throw new CraneException("Can't find command by Id");
}
if (cmd != null && cOld != null && cmd.ID != id && cOld.ID != id)
{
throw new CraneException("Can't find command by Id");
}
cmd.Status = s;
Warehouse.DBService.UpdateSimpleCommand(cmd);
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Command, cmd.ToString());
if (cmd.Status == SimpleCommand.EnumStatus.Finished || cmd.Status == SimpleCommand.EnumStatus.Canceled)
{
OnSimpleCommandFinish(cmd);
}
if (cOld != null && cOld.Status < SimpleCommand.EnumStatus.Canceled)
{
cOld.Reason = SimpleCommand.EnumReason.MFCS;
cOld.Status = SimpleCommand.EnumStatus.Canceled;
Warehouse.DBService.UpdateSimpleCommand(cOld);
OnSimpleCommandFinish(cOld);
Warehouse.AddEvent(Event.EnumSeverity.Event, Event.EnumType.Command, cOld.ToString());
}
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new CraneException(String.Format("{0} ConveyorBasic.FinishCommand failed ({1},{2},{3})", Name, id, cmd != null ? cmd.ToString() : "null", s));
}
}
// proces incoming TO telegram connected to command
// proces incoming TO telegram connected to command
private void WorkCommand(TelegramCraneTO tel, SimpleCraneCommand cmd, bool fastCommand)
{
try
{
if (tel.Confirmation == TelegramCraneTO.CONFIRMATION_OK)
{
try
{
if (fastCommand && cmd.Task < SimpleCommand.EnumTask.Delete && fastCommand)
{
throw new CraneException(String.Format("Crane.WorkCommand {0} FastCommand{1} has wrong task {2}", Name, cmd.ID, cmd.Task));
}
if (cmd.Task == SimpleCommand.EnumTask.Pick)
{
Pick(tel.Palette.Barcode, cmd.Source);
}
else if (cmd.Task == SimpleCommand.EnumTask.Drop)
{
Drop(tel.Palette.Barcode, cmd.Source);
}
else if (cmd.Task == SimpleCommand.EnumTask.Create)
{
MaterialCreate(tel.Palette.Barcode);
}
else if (cmd.Task == SimpleCommand.EnumTask.Delete)
{
MaterialDelete(tel.Palette.Barcode);
}
FinishCommand(tel.MFCS_ID, cmd, SimpleCommand.EnumStatus.Finished);
}
catch
{
cmd.Reason = SimpleCommand.EnumReason.MFCS;
FinishCommand(tel.MFCS_ID, cmd, SimpleCommand.EnumStatus.Canceled);
throw;
}
finally
{
AssignCommandsAfterFinish();
}
}
else if (tel.Confirmation == TelegramCraneTO.CONFIRMATION_DIMENSIONCHECKERROR)
{
cmd.Reason = SimpleCommand.EnumReason.DimensionCheck;
FinishCommand(tel.MFCS_ID, cmd, SimpleCommand.EnumStatus.Canceled);
Command Command = Warehouse.DBService.FindCommandByID(cmd.Command_ID.Value);
if (Command != null)
{
Command.Status = Database.Command.EnumCommandStatus.Canceled;
Warehouse.DBService.UpdateCommand(Command);
Warehouse.OnCommandFinish?.Invoke(Command);
}
else
{
throw new ConveyorBasicException(String.Format("{0} has no corresponding Command", cmd != null ? cmd.ToString() : "null"));
}
}
else if (tel.Confirmation == TelegramCraneTO.CONFIRMATION_CANCELBYWAREHOUSE ||
tel.Confirmation == TelegramCraneTO.CONFIRMATION_FAULT ||
tel.Confirmation == TelegramCraneTO.CONFIRMATION_CANCELBYMFCS)
{
bool finish = false;
if (tel.Confirmation == TelegramCraneTO.CONFIRMATION_CANCELBYWAREHOUSE)
{
cmd.Reason = SimpleCommand.EnumReason.Warehouse;
}
else if (tel.Confirmation == TelegramCraneTO.CONFIRMATION_FAULT)
{
cmd.Reason = (Database.SimpleCommand.EnumReason)tel.Fault;
if (tel.Fault == TelegramCraneTO.FAULT_CANCEL_NOCMD)
{
FinishCommand(tel.Buffer_ID, null, SimpleCommand.EnumStatus.Canceled);
finish = true;
}
}
else if (tel.Confirmation == TelegramCraneTO.CONFIRMATION_CANCELBYMFCS)
{
cmd.Reason = SimpleCommand.EnumReason.MFCS;
}
if (finish)
{
FinishCommand(tel.MFCS_ID, cmd, SimpleCommand.EnumStatus.Finished);
}
else
{
FinishCommand(tel.MFCS_ID, cmd, SimpleCommand.EnumStatus.Canceled);
}
if (BufferCommand != null)
{
BufferCommand.Reason = SimpleCommand.EnumReason.MFCS;
FinishCommand(tel.MFCS_ID, BufferCommand, SimpleCommand.EnumStatus.Canceled);
}
AssignCommandsAfterFinish();
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Command,
String.Format("{0} Confirmation({1}), Fault({2})",
cmd.ToString(), tel.Confirmation, tel.Fault));
Warehouse.SteeringCommands.Run &= tel.Confirmation == TelegramCraneTO.CONFIRMATION_CANCELBYMFCS ||
tel.Confirmation == TelegramCraneTO.CONFIRMATION_CANCELBYWAREHOUSE ||
(tel.Confirmation == TelegramCraneTO.CONFIRMATION_FAULT &&
(tel.Fault == TelegramCraneTO.FAULT_CANCEL_NOCMD || tel.Fault > TelegramCraneTO.FAULT_REPEATORDER));
}
else if (cmd.Status <= SimpleCommand.EnumStatus.InPlc)
{
cmd.Status = SimpleCommand.EnumStatus.InPlc;
Warehouse.DBService.UpdateSimpleCommand(Command);
}
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new CraneException(String.Format("{0} Crane.WorkCommand failed", Name));
}
}
public int CountSimpleCommandToAcumulation(ConveyorBasic cb, List <ConveyorBasic> visited, SimpleCraneCommand otherDeck)
{
int res = 0;
if ((cb == null) || visited.Contains(cb) || !(cb is Conveyor) || (cb is Conveyor && (cb as Conveyor).AcumulationMark))
{
return(0);
}
res = DBService.CountSimpleCraneCommandForTarget(cb.Name, true);
if (otherDeck != null && cb.Name == otherDeck.Source && otherDeck.Task == SimpleCommand.EnumTask.Drop)
{
res++;
}
visited.Add(cb);
if (cb is ConveyorJunction)
{
foreach (var item in (cb as ConveyorJunction).RouteDef.Node)
{
res += CountSimpleCommandToAcumulation(item.Next, visited, otherDeck);
}
}
else if (cb.Route != null)
{
res += CountSimpleCommandToAcumulation(cb.Route.Next, visited, otherDeck);
}
return(res);
}
public void CreateMaterial(UInt32 material, string place, int?mfcs_id, bool ignoreMaterialExsists, bool ignorePlaceExsists)
{
try
{
SimpleCommand c = null;
DBService.FindMaterialID((int)material, true);
Place pm = DBService.FindMaterial((int)material);
Place pp = DBService.FindPlace(place);
PlaceID pid = DBService.FindPlaceID(place);
//if(pm != null && pm.Place1 == "W:out")
//{
// DBService.MaterialDelete(pm.Place1, (int)material);
// pm = null;
//}
if (!ignoreMaterialExsists && pm != null) // material exists
{
if (mfcs_id.HasValue)
{
Command cmd = DBService.FindCommandByID(mfcs_id.Value);
cmd.Reason = Command.EnumCommandReason.MFCS;
cmd.Status = Command.EnumCommandStatus.Canceled;
DBService.UpdateCommand(cmd);
OnCommandFinish?.Invoke(cmd);
}
}
else if (!ignorePlaceExsists && pp != null && pid.Size != 999) // place is full
{
if (mfcs_id.HasValue)
{
Command cmd = DBService.FindCommandByID(mfcs_id.Value);
cmd.Reason = Command.EnumCommandReason.LocationFull;
cmd.Status = Command.EnumCommandStatus.Canceled;
DBService.UpdateCommand(cmd);
OnCommandFinish?.Invoke(cmd);
}
}
else
{
LPosition loc = LPosition.FromString(place);
if (!loc.IsWarehouse())
{
ConveyorBasic cb = FindConveyorBasic(place);
if (cb is Conveyor)
{
DBService.AddSimpleCommand(c = new SimpleConveyorCommand
{
Command_ID = mfcs_id,
Material = (int)material,
Source = place,
Status = SimpleCommand.EnumStatus.NotActive,
Target = place,
Task = SimpleCommand.EnumTask.Create,
Time = DateTime.Now
});
}
else if (cb is Crane)
{
DBService.AddSimpleCommand(c = new SimpleCraneCommand
{
Command_ID = mfcs_id,
Material = (int)material,
Source = place,
Status = SimpleCommand.EnumStatus.NotActive,
Task = SimpleCommand.EnumTask.Create,
Time = DateTime.Now,
Unit = cb.Name
});
}
}
else
{
DBService.MaterialCreate(place, (int)material, true);
OnMaterialMove?.Invoke(new Place {
Place1 = place, Material = (int)material
}, EnumMovementTask.Create);
if (mfcs_id.HasValue)
{
Command cmd = DBService.FindCommandByID(mfcs_id.Value);
cmd.Status = Command.EnumCommandStatus.Finished;
DBService.UpdateCommand(cmd);
OnCommandFinish?.Invoke(cmd);
}
}
}
}
catch (Exception ex)
{
AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, String.Format("BasicWarehouse.CreateMaterial material({0}),place({1}) failed. Reason :{2}", material, place, ex.Message));
}
}
private SimpleCraneCommand GetCommandFromFreeState(bool inputPreference, bool automatic, List <string> bannedPlaces, SimpleCraneCommand otherDeck)
{
try
{
// pick pallet from input line
var cmdInput = Crane.FindBestInput(automatic, ForcedInput);
var CmdWarehouse = Crane.FindBestWarehouse(automatic, bannedPlaces, otherDeck);
if ((inputPreference && cmdInput != null) || (cmdInput != null && CmdWarehouse == null))
{
// Warehouse.DBService.AddSimpleCommand(cmdInput);
ForcedInput = null;
return(cmdInput);
}
else if (CmdWarehouse != null)
{
bannedPlaces.Add(CmdWarehouse.Source);
// Warehouse.DBService.AddSimpleCommand(CmdWarehouse);
return(CmdWarehouse);
}
return(null);
}
catch (Exception ex)
{
Warehouse.AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
throw new StrategyCraneException(String.Format("{0} GetCommandFreeState failed", Name));
}
}
