public JsonResult KoreaIndex(string ethAddress, int parentId = 0, Country country = Country.Korea)
{
var selectEthAddress = db.Telegrams.FirstOrDefault(t => t.EthAddress == ethAddress);
if (selectEthAddress != null)
{
return(Json(new { success = false, selectEthAddress.InviteUrl, selectEthAddress.VerificationCode, msg = "에틸렌 주소 지갑 주소 이미 존재합니다！" }));
}
var telegram = new Telegrams
{
EthAddress = ethAddress,
CreateTime = DateTime.UtcNow,
ParentId = parentId,
InviteUrl = "",
VerificationCode = $"/code {Guid.NewGuid()}",
Country = country
};
db.Telegrams.Add(telegram);
db.SaveChanges();
var data = db.Telegrams.FirstOrDefault(t => t.EthAddress == ethAddress);
data.InviteUrl = $"https://www.soft2b.com/telegram/IndexKP?parentId={data.Id}";
db.SaveChanges();
return(Json(new { success = true, data.InviteUrl, data.VerificationCode, msg = "등록 성공！~" }));
}
public JsonResult Index(string ethAddress, int parentId = 0, Country country = Country.Us)
{
var selectEthAddress = db.Telegrams.FirstOrDefault(t => t.EthAddress == ethAddress);
if (selectEthAddress != null)
{
return(Json(new { success = false, selectEthAddress.InviteUrl, selectEthAddress.VerificationCode, msg = "钱包地址已存在！" }));
}
var telegram = new Telegrams
{
EthAddress = ethAddress,
CreateTime = DateTime.UtcNow,
ParentId = parentId,
InviteUrl = "",
VerificationCode = $"/code {Guid.NewGuid()}",
Country = country
};
db.Telegrams.Add(telegram);
db.SaveChanges();
var data = db.Telegrams.FirstOrDefault(t => t.EthAddress == ethAddress);
data.InviteUrl = $"{Configs.Domain}/telegram/index?parentId={data.Id}";
db.SaveChanges();
return(Json(new { success = true, data.InviteUrl, data.VerificationCode, msg = "注册成功！~" }));
}
void miniloadPickStation_OnPickStationStatusUpdate(object sender, PickStationStatusUpdateEventArgs e)
{
string load1 = e._LoadPosOutside == null ? "Empty" : e._LoadPosOutside.Identification;
string load2 = e._LoadPosInside == null ? "Empty" : e._LoadPosInside.Identification;
if (e._LoadPosOutside != null && e._LoadPosInside != null)
{
string telegram1 = casePLC.CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, (ATCCaseLoad)e._LoadPosOutside);
string telegram2 = casePLC.CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, (ATCCaseLoad)e._LoadPosInside);
telegram1 = telegram1.SetFieldValue(TelegramFields.location, OutsidePSName);
telegram2 = telegram2.SetFieldValue(TelegramFields.location, InsidePSName);
telegram1 = telegram1.SetFieldValue(TelegramFields.stateCode, ((ATCCaseLoad)e._LoadPosOutside).PresetStateCode);
telegram2 = telegram2.SetFieldValue(TelegramFields.stateCode, ((ATCCaseLoad)e._LoadPosInside).PresetStateCode);
string telegram = Telegrams.CreateMultipalMessage(new List <string>()
{
telegram1, telegram2
}, TelegramTypes.MultipleTransportFinishedTelegram, casePLC.Name);
casePLC.SendTelegram(telegram, true);
}
else
{
//string telegram = casePLC.CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, (ATCCaseLoad)e._LoadPosOutside);
//telegram = telegram.SetFieldValue(TelegramFields.location, OutsidePSName);
//telegram = telegram.SetFieldValue(TelegramFields.stateCode, ((ATCCaseLoad)e._LoadPosOutside).PresetStateCode);
//casePLC.SendTelegram(telegram, true);
string telegram = casePLC.CreateTelegramFromLoad(TelegramTypes.TransportFinishedTelegram, (ATCCaseLoad)e._LoadPosInside);
telegram = telegram.SetFieldValue(TelegramFields.location, InsidePSName);
telegram = telegram.SetFieldValue(TelegramFields.stateCode, ((ATCCaseLoad)e._LoadPosInside).PresetStateCode);
casePLC.SendTelegram(telegram, true);
}
}
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);
}
public IPTConfigReader(string path)
{
var xmlSerializer = new XmlSerializer(typeof(cpu));
var deserialize = (cpu)xmlSerializer.Deserialize(File.OpenRead(path));
foreach (cpuBusinterfacelist o in deserialize.Items.Where(i => i is cpuBusinterfacelist))
{
foreach (cpuBusinterfacelistBusinterface businterface in o.Businterface)
{
Telegrams.AddRange(businterface.Telegram);
}
}
foreach (cpuDatasetlist cpuDatasetlist in deserialize.Items.Where(i => i is cpuDatasetlist))
{
Datasets.AddRange(cpuDatasetlist.Dataset);
}
}
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 theMiniload_OnMiniloadTaskComplete(object sender, MiniloadTaskCompleteEventArgs e)
{
if (TaskList[0].HalfCycles[0] == e._miniloadTask) //TaskLis[0].HalfCycle[0] Should be the current task
{
//Need to send a message to the WMS at this point depending on the cycle
if (e._miniloadTask.Cycle == MiniloadCycle.DropRack || e._miniloadTask.Cycle == MiniloadCycle.DropDS)
{
//Log.Write(string.Format("A load has been dropped in the rack"));
//string[] index = new string[] {null, null};
int?[] index = new int?[] { null, null };
if (!string.IsNullOrEmpty(e._miniloadTask.TuIdentPos1))
{
index[0] = GetIndex(TaskList[0].MissionData, e._miniloadTask.TuIdentPos1);
}
if (!string.IsNullOrEmpty(e._miniloadTask.TuIdentPos2))
{
index[1] = GetIndex(TaskList[0].MissionData, e._miniloadTask.TuIdentPos2);
}
if (index[0] != null && index[1] != null) //Multiple drop to drop station
{
string blah = ((string[])TaskList[0].MissionData[(int)index[0]]).CreateTelegramFromTelegram(TelegramTypes.TransportFinishedTelegram, true);
List <string> telegrams = new List <string> {
((string[])TaskList[0].MissionData[(int)index[0]]).CreateTelegramFromTelegram(TelegramTypes.TransportFinishedTelegram, true),
((string[])TaskList[0].MissionData[(int)index[1]]).CreateTelegramFromTelegram(TelegramTypes.TransportFinishedTelegram, true)
};
for (int i = 0; i < 2; i++)
{
telegrams[i] = telegrams[i].SetFieldValue(TelegramFields.source, ((string[])TaskList[0].MissionData[(int)index[i]]).GetFieldValue(TelegramFields.source));
telegrams[i] = telegrams[i].SetFieldValue(TelegramFields.location, ((string[])TaskList[0].MissionData[(int)index[i]]).GetFieldValue(TelegramFields.destination));
telegrams[i] = telegrams[i].SetFieldValue(TelegramFields.stateCode, ((string[])TaskList[0].MissionData[(int)index[i]]).GetFieldValue(TelegramFields.presetStateCode));
}
string telegram = Telegrams.CreateMultipalMessage(telegrams, TelegramTypes.MultipleTransportFinishedTelegram, controller.Name);
//telegram = telegram.SetFieldValue(TelegramFields.mts, controller.Name);
controller.SendTelegram(telegram, true);
}
else if (index[0] != null || index[1] != null) //Single drop from multiple pick
{
foreach (int?dex in index) //Double loads being dropped
{
if (dex != null)
{
string telegram = ((string[])TaskList[0].MissionData[(int)dex]).CreateTelegramFromTelegram(TelegramTypes.TransportFinishedTelegram, true);
telegram = telegram.SetFieldValue(TelegramFields.mts, controller.Name);
telegram = telegram.SetFieldValue(TelegramFields.source, ((string[])TaskList[0].MissionData[(int)dex]).GetFieldValue(TelegramFields.source));
telegram = telegram.SetFieldValue(TelegramFields.location, ((string[])TaskList[0].MissionData[(int)dex]).GetFieldValue(TelegramFields.destination));
telegram = telegram.SetFieldValue(TelegramFields.stateCode, ((string[])TaskList[0].MissionData[(int)dex]).GetFieldValue(TelegramFields.presetStateCode)); //May need to be changed when dealing with exceptions
controller.SendTelegram(telegram, true);
}
}
}
else //Single load being droppped from single pick
{
string telegram = ((string[])TaskList[0].MissionData[0]).CreateTelegramFromTelegram(TelegramTypes.TransportFinishedTelegram, true);
telegram = telegram.SetFieldValue(TelegramFields.mts, controller.Name);
telegram = telegram.SetFieldValue(TelegramFields.source, ((string[])TaskList[0].MissionData[0]).GetFieldValue(TelegramFields.source));
telegram = telegram.SetFieldValue(TelegramFields.location, ((string[])TaskList[0].MissionData[0]).GetFieldValue(TelegramFields.destination));
telegram = telegram.SetFieldValue(TelegramFields.stateCode, ((string[])TaskList[0].MissionData[0]).GetFieldValue(TelegramFields.presetStateCode)); //May need to be changed when dealing with exception
controller.SendTelegram(telegram, true);
}
}
else if ((e._miniloadTask.Cycle == MiniloadCycle.PickPS && SendPSArrival) || e._miniloadTask.Cycle == MiniloadCycle.PickRack)
{
//Log.Write(string.Format("A load or loads have been picked from the Pick Station"));
if (!string.IsNullOrEmpty(e._miniloadTask.TuIdentPos1))
{
string telegram = ((string[])TaskList[0].MissionData[(int)GetIndex(TaskList[0].MissionData, e._miniloadTask.TuIdentPos1)]).CreateTelegramFromTelegram(TelegramTypes.LocationArrivedTelegram, true);
telegram = telegram.SetFieldValue(TelegramFields.location, string.Format("{0}11", LHDName));
telegram = telegram.SetFieldValue(TelegramFields.mts, controller.Name);
controller.SendTelegram(telegram, true);
}
if (!string.IsNullOrEmpty(e._miniloadTask.TuIdentPos2))
{
string telegram = ((string[])TaskList[0].MissionData[(int)GetIndex(TaskList[0].MissionData, e._miniloadTask.TuIdentPos2)]).CreateTelegramFromTelegram(TelegramTypes.LocationArrivedTelegram, true);
telegram = telegram.SetFieldValue(TelegramFields.location, string.Format("{0}12", LHDName));
telegram = telegram.SetFieldValue(TelegramFields.mts, controller.Name);
controller.SendTelegram(telegram, true);
}
}
TaskList[0].HalfCycles.RemoveAt(0);
if (TaskList[0].HalfCycles.Count == 0) //All half cycles for this task are complete
{
TaskList.RemoveAt(0);
StartNewTask();
}
else //Or just send the next half cycle to the miniload
{
theMiniload.StartMiniloadHalfCycle(TaskList[0].HalfCycles[0]);
}
StartNewTask();
}
else
{
Log.Write(string.Format("Miniload {0}: Cycle error controller and Miniload tasks are not aligned", theMiniload.Name));
}
}
public void StartMultipleTransportTelegramReceived(string[] telegramFields)
{
//Create miniload tasklist from message
List <string> indexMatches = new List <string>();
List <string> telegrams = Telegrams.DeMultaplise(telegramFields, TelegramTypes.StartMultipleTransportTelegram, out indexMatches);
for (int i = 0; i < telegrams.Count; i++)
{
telegrams[i] = telegrams[i].Replace(string.Format("s{0}", indexMatches[i]), "");
}
MiniloadTask newTasks = new MiniloadTask(new List <object> {
telegrams[0].Split(','), telegrams[1].Split(',')
}); //Convert telegram to TelegramData
//MiniloadTask newTasks = new MiniloadTask(telegramFields);
int telegramCount = telegramFields.ArrayCount();
if (telegramCount == 2)
{
//is it a storage, retreival, relocation or reject task type
string source = telegramFields.GetFieldValue(TelegramFields.sources, "[0]");
string destination = telegramFields.GetFieldValue(TelegramFields.destinations, "[0]");
newTasks.TaskType = GetTaskType(source, destination);
if (newTasks.TaskType == MiniloadTaskType.Storage || newTasks.TaskType == MiniloadTaskType.Reject) //Store 2 in the racking from pick station
{
ATCCaseLoad LoadPos1 = theMiniload.Position1Load() as ATCCaseLoad;
ATCCaseLoad LoadPos2 = theMiniload.Position2Load() as ATCCaseLoad;
//Check that the load in Pos 1 matches one of the messages, what is the index??
if ((LoadPos1 != null && LoadPos2 != null) && LoadPos1.TUIdent == telegramFields.GetFieldValue(TelegramFields.tuIdents, "[0]") && LoadPos2.TUIdent == telegramFields.GetFieldValue(TelegramFields.tuIdents, "[1]"))
{
//Now we know what data to put onto what load
controller.UpDateLoadParameters(telegramFields, LoadPos1, "[0]");
controller.UpDateLoadParameters(telegramFields, LoadPos2, "[1]");
}
else if ((LoadPos1 != null && LoadPos2 != null) && LoadPos1.TUIdent == telegramFields.GetFieldValue(TelegramFields.tuIdents, "[1]") && LoadPos2.TUIdent == telegramFields.GetFieldValue(TelegramFields.tuIdents, "[0]"))
{
//Also here we know what data to put on what load
controller.UpDateLoadParameters(telegramFields, LoadPos1, "[1]");
controller.UpDateLoadParameters(telegramFields, LoadPos2, "[0]");
}
else
{
//There is a problem
Log.Write(string.Format("Miniload {0}: Loads at pick station and 'MultipleStartTransportTelegram' from ATC do not match, telegram ignored", theMiniload.Name));
return;
}
MiniloadHalfCycle pickFromPS = new MiniloadHalfCycle() //Pick from pick station
{
Cycle = MiniloadCycle.PickPS,
TuIdentPos1 = LoadPos1.TUIdent,
TuIdentPos2 = LoadPos2.TUIdent
};
newTasks.HalfCycles.Add(pickFromPS);
if (newTasks.TaskType == MiniloadTaskType.Storage)
{
//Create the half cycles first, then decide which one the miniload performs fisrt
MiniloadHalfCycle pos1Drop = new MiniloadHalfCycle() //Drop the first load
{
Cycle = MiniloadCycle.DropRack,
LHD = 1,
Length = GetXLoc(telegramFields, LoadPos1),
Height = GetYLoc(telegramFields, LoadPos1),
Depth = GetDepth(telegramFields, LoadPos1),
RackSide = GetSide(telegramFields, LoadPos1),
TuIdentPos1 = LoadPos1.TUIdent
};
MiniloadHalfCycle pos2Drop = new MiniloadHalfCycle() //Drop the second load
{
Cycle = MiniloadCycle.DropRack,
LHD = 2,
Length = GetXLoc(telegramFields, LoadPos2),
Height = GetYLoc(telegramFields, LoadPos2),
Depth = GetDepth(telegramFields, LoadPos2),
RackSide = GetSide(telegramFields, LoadPos2),
TuIdentPos2 = LoadPos2.TUIdent
};
if (pos1Drop.RackSide == null || pos2Drop.RackSide == null)
{
Log.Write(string.Format("Miniload {0}: 'MultipleStartTransportTelegram' cannot resolve drop side, telegram ignored", theMiniload.Name));
return;
}
else if (pos1Drop.RackSide == Side.Right && pos2Drop.RackSide == Side.Left)
{
Log.Write(string.Format("Miniload {0}: 'MulipleStartTransportTelegram' cannot perform drop, left load drop right and right load drop left not possible", theMiniload.Name));
}
else //We now know which loads are being sent to which side so that we can schedule the miniload accordingly
{
if ((pos1Drop.RackSide == Side.Left && pos2Drop.RackSide == Side.Left) || (pos1Drop.RackSide == Side.Left && (pos1Drop.Length < pos2Drop.Length))) //Both are going left or pos1 is going left, pos2 is going right and pos1 is the closest to the p/d
{
newTasks.HalfCycles.Add(pos1Drop);
newTasks.HalfCycles.Add(pos2Drop);
}
else
{
newTasks.HalfCycles.Add(pos2Drop);
newTasks.HalfCycles.Add(pos1Drop);
}
}
}
else if (newTasks.TaskType == MiniloadTaskType.Reject)
{
MiniloadHalfCycle dropToDS = new MiniloadHalfCycle() //Drop to the drop Station
{
Cycle = MiniloadCycle.DropDS,
TuIdentPos1 = LoadPos1.TUIdent,
TuIdentPos2 = LoadPos2.TUIdent
};
newTasks.HalfCycles.Add(dropToDS);
}
}
else if (newTasks.TaskType == MiniloadTaskType.Retreival)
{
//Initially i need to know which load i am going to pick first
string posASource = telegramFields.GetFieldValue(TelegramFields.sources, "[0]");
string posBSource = telegramFields.GetFieldValue(TelegramFields.sources, "[1]");
string posATuIdent = telegramFields.GetFieldValue(TelegramFields.tuIdents, "[0]");
string posBTuIdent = telegramFields.GetFieldValue(TelegramFields.tuIdents, "[1]");
Side? posASide = GetSide(posASource);
Side? posBSide = GetSide(posBSource);
float posAXLoc = GetXLoc(posASource);
float posBXLoc = GetXLoc(posBSource);
if (posASide == null || posBSide == null || posATuIdent == null || posBTuIdent == null)
{
//There is a problem
Log.Write(string.Format("Miniload {0}: Error processing drop missions from 'MultipleStartTransportTelegram', telegram ignored", theMiniload.Name));
return;
}
//Create the case data, this will be used by the miniload to create the load (from the controller)
ATCCaseData pos1CaseData = controller.CreateATCCaseData(telegramFields, "[0]");
ATCCaseData pos2CaseData = controller.CreateATCCaseData(telegramFields, "[1]");
int LHDposA = 0, LHDposB = 0;
bool?AthenB = null;
if (posASide == Side.Left && posBSide == Side.Left)
{
if (posAXLoc > posBXLoc)
{
LHDposA = 2; LHDposB = 1; AthenB = true;
}
else
{
LHDposA = 1; LHDposB = 2; AthenB = false;
}
}
else if (posASide == Side.Right && posBSide == Side.Right)
{
if (posAXLoc > posBXLoc)
{
LHDposA = 1; LHDposB = 2; AthenB = true;
}
else
{
LHDposA = 2; LHDposB = 1; AthenB = false;
}
}
else if (posASide == Side.Left && posBSide == Side.Right)
{
LHDposA = 1; LHDposB = 2;
AthenB = posAXLoc > posBXLoc ? true : false;
}
else if (posASide == Side.Right && posBSide == Side.Left)
{
LHDposA = 2; LHDposB = 1;
AthenB = posAXLoc > posBXLoc ? true : false;
}
if (LHDposA == 0 || LHDposB == 0 || AthenB == null)
{
Log.Write(string.Format("Miniload {0}: Error calculating pickup order or LHD assignment", theMiniload.Name), Color.Red);
return;
}
MiniloadHalfCycle posAPick = new MiniloadHalfCycle()
{
Cycle = MiniloadCycle.PickRack,
LHD = LHDposA,
Length = GetXLoc(posASource),
Height = GetYLoc(posASource),
Depth = GetDepth(posASource),
RackSide = posASide,
TuIdentPos1 = posATuIdent,
CaseData = pos1CaseData
};
MiniloadHalfCycle posBPick = new MiniloadHalfCycle()
{
Cycle = MiniloadCycle.PickRack,
LHD = LHDposB,
Length = GetXLoc(posBSource),
Height = GetYLoc(posBSource),
Depth = GetDepth(posBSource),
RackSide = posBSide,
TuIdentPos2 = posBTuIdent,
CaseData = pos2CaseData
};
if (AthenB == true)
{
newTasks.HalfCycles.Add(posAPick);
newTasks.HalfCycles.Add(posBPick);
}
else
{
newTasks.HalfCycles.Add(posBPick);
newTasks.HalfCycles.Add(posAPick);
}
MiniloadHalfCycle dropToDS = new MiniloadHalfCycle() //Drop to the drop Station
{
Cycle = MiniloadCycle.DropDS,
TuIdentPos1 = posATuIdent,
TuIdentPos2 = posBTuIdent
};
newTasks.HalfCycles.Add(dropToDS);
}
else if (newTasks.TaskType == MiniloadTaskType.Relocation)
{
Log.Write(string.Format("Miniload {0}: cannot generate double relocation missions from 'MultipleStartTransportTelegram', telegram ignored", theMiniload.Name), Color.Red);
return;
}
}
else if (telegramCount == 1)
{
//Not sure if this is needed or not, why send a multiple message with only 1 load in it?
}
AddNewTasks(newTasks);
}
