public void Register(ProcedureItemSelected ProcedureItem, RobotUnity robot, OrderItem orderItem)
{
CleanUp();
switch (ProcedureItem)
{
case ProcedureItemSelected.PROCEDURE_FORLIFT_TO_BUFFER:
{
ProcedureForkLiftToBuffer procfb = new ProcedureForkLiftToBuffer(robot, doorService, trafficService);
procfb.Registry(deviceService);
ProcedureDataItems profbDataItems = new ProcedureDataItems();
profbDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocfb = new RegisterProcedureItem()
{
item = procfb, robot = robot, procedureDataItems = profbDataItems
};
procfb.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procfb.ErrorProcedureHandler += ErrorApprearInProcedureItem;
//RegisterProcedureItemList.Add (itemprocfb);
procfb.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pFB = procfb;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_FORKLIFT_TO_BUFFER;
procfb.Registry(robotManagementService);
procfb.Start();
break;
}
case ProcedureItemSelected.PROCEDURE_BUFFER_TO_MACHINE:
ProcedureBufferToMachine procbm = new ProcedureBufferToMachine(robot, trafficService);
procbm.Registry(deviceService);
ProcedureDataItems prcobmDataItems = new ProcedureDataItems();
prcobmDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocbm = new RegisterProcedureItem()
{
item = procbm, robot = robot, procedureDataItems = prcobmDataItems
};
procbm.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procbm.ErrorProcedureHandler += ErrorApprearInProcedureItem;
//RegisterProcedureItemList.Add (itemprocbm);
procbm.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pBM = procbm;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_BUFFER_TO_MACHINE;
procbm.Registry(robotManagementService);
procbm.Start();
break;
case ProcedureItemSelected.PROCEDURE_BUFFER_TO_RETURN:
ProcedureBufferToReturn procbr = new ProcedureBufferToReturn(robot, trafficService);
ProcedureDataItems prcobrDataItems = new ProcedureDataItems();
prcobrDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocbr = new RegisterProcedureItem()
{
item = procbr, robot = robot, procedureDataItems = prcobrDataItems
};
procbr.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procbr.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocbr);
procbr.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pBR = procbr;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_BUFFER_TO_RETURN;
procbr.Registry(robotManagementService);
procbr.Start();
break;
case ProcedureItemSelected.PROCEDURE_PALLETEMPTY_MACHINE_TO_RETURN:
ProcedureMachineToReturn procmr = new ProcedureMachineToReturn(robot, trafficService);
ProcedureDataItems prcomrDataItems = new ProcedureDataItems();
prcomrDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocmr = new RegisterProcedureItem()
{
item = procmr, robot = robot, procedureDataItems = prcomrDataItems
};
procmr.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procmr.ErrorProcedureHandler += ErrorApprearInProcedureItem;
//RegisterProcedureItemList.Add (itemprocmr);
procmr.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pMR = procmr;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_MACHINE_TO_RETURN;
procmr.Registry(robotManagementService);
procmr.Start();
break;
case ProcedureItemSelected.PROCEDURE_RETURN_TO_GATE:
ProcedureReturnToGate procrg = new ProcedureReturnToGate(robot, doorService, trafficService);
ProcedureDataItems prorgDataItems = new ProcedureDataItems();
prorgDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocrg = new RegisterProcedureItem()
{
item = procrg, robot = robot, procedureDataItems = prorgDataItems
};
procrg.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procrg.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocrg);
procrg.AssignAnOrder(orderItem);
procrg.Registry(robotManagementService);
procrg.Start();
break;
case ProcedureItemSelected.PROCEDURE_ROBOT_TO_CHARGE:
ProcedureRobotToCharger procrc = new ProcedureRobotToCharger(robot, chargerService, robot.properties.ChargeID);
ProcedureDataItems procrcDataItems = new ProcedureDataItems();
procrcDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocrc = new RegisterProcedureItem()
{
item = procrc, robot = robot, procedureDataItems = procrcDataItems
};
procrc.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procrc.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocrc);
robot.proRegistryInRobot.pRC = procrc;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_CHARGE;
procrc.Start();
break;
case ProcedureItemSelected.PROCEDURE_ROBOT_TO_READY:
robot.ShowText(robot.properties.Label + "Add PROCEDURE_ROBOT_TO_READY ----------(--___--)---------------");
ProcedureRobotToReady procrr = new ProcedureRobotToReady(robot, robot.properties.ChargeID, trafficService, chargerService, null);
ProcedureDataItems procrrDataItems = new ProcedureDataItems();
procrrDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocrr = new RegisterProcedureItem()
{
item = procrr, robot = robot, procedureDataItems = procrrDataItems
};
procrr.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procrr.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocrr);
robot.proRegistryInRobot.pRR = procrr;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_READY;
procrr.Registry(deviceService);
procrr.Registry(robotManagementService);
procrr.Registry(assigmentTask);
procrr.Start();
break;
case ProcedureItemSelected.PROCEDURE_ROBOT_READY_TO_READY:
ProcedureRobotToReady procRrr = new ProcedureRobotToReady(robot, robot.properties.ChargeID, trafficService, chargerService, doorService.DoorMezzamineUp.config.PointCheckInGate);
ProcedureDataItems procRrrDataItems = new ProcedureDataItems();
procRrrDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocRrr = new RegisterProcedureItem()
{
item = procRrr, robot = robot, procedureDataItems = procRrrDataItems
};
procRrr.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procRrr.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add(itemprocRrr);
robot.proRegistryInRobot.pRR = procRrr;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_READY;
procRrr.Registry(robotManagementService);
procRrr.Start();
break;
case ProcedureItemSelected.PROCEDURE_FORLIFT_TO_MACHINE:
ProcedureForkLiftToMachine procfm = new ProcedureForkLiftToMachine(robot, doorService, trafficService);
ProcedureDataItems profmDataItems = new ProcedureDataItems();
profmDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocfm = new RegisterProcedureItem()
{
item = procfm, robot = robot, procedureDataItems = profmDataItems
};
procfm.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procfm.ErrorProcedureHandler += ErrorApprearInProcedureItem;
//RegisterProcedureItemList.Add(itemprocfm);
procfm.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pFM = procfm;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_FORKLIFT_TO_MACHINE;
procfm.Registry(robotManagementService);
procfm.Start();
break;
case ProcedureItemSelected.PROCEDURE_BUFFER_TO_BUFFER:
ProcedureBufferReturnToBuffer401 procbb = new ProcedureBufferReturnToBuffer401(robot, trafficService);
ProcedureDataItems prcobbDataItems = new ProcedureDataItems();
prcobbDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocbb = new RegisterProcedureItem()
{
item = procbb, robot = robot, procedureDataItems = prcobbDataItems
};
procbb.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procbb.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocbr);
procbb.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pBB = procbb;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_BUFFER_TO_BUFFER;
procbb.Registry(robotManagementService);
procbb.Start();
break;
case ProcedureItemSelected.PROCEDURE_BUFFER_TO_GATE:
ProcedureBufferToGate procbg = new ProcedureBufferToGate(robot, doorService, trafficService);
ProcedureDataItems probgDataItems = new ProcedureDataItems();
probgDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocbg = new RegisterProcedureItem()
{
item = procbg, robot = robot, procedureDataItems = probgDataItems
};
procbg.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procbg.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocrg);
procbg.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pBG = procbg;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_BUFFER_TO_GATE;
procbg.Registry(robotManagementService);
procbg.Start();
break;
case ProcedureItemSelected.PROCEDURE_MACHINE_TO_GATE:
ProcedureMachineToGate procmg = new ProcedureMachineToGate(robot, doorService, trafficService);
ProcedureDataItems promgDataItems = new ProcedureDataItems();
promgDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocmg = new RegisterProcedureItem()
{
item = procmg, robot = robot, procedureDataItems = promgDataItems
};
procmg.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procmg.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocrg);
procmg.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pMG = procmg;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_MACHINE_TO_GATE;
procmg.Start();
break;
case ProcedureItemSelected.PROCEDURE_MACHINE_TO_BUFFER_RETURN:
ProcedureMachineToBufferReturn procmbr = new ProcedureMachineToBufferReturn(robot, trafficService);
ProcedureDataItems prombrDataItems = new ProcedureDataItems();
prombrDataItems.StartTaskTime = DateTime.Now;
RegisterProcedureItem itemprocmbr = new RegisterProcedureItem()
{
item = procmbr, robot = robot, procedureDataItems = prombrDataItems
};
procmbr.ReleaseProcedureHandler += ReleaseProcedureItemHandler;
procmbr.ErrorProcedureHandler += ErrorApprearInProcedureItem;
// RegisterProcedureItemList.Add (itemprocrg);
procmbr.AssignAnOrder(orderItem);
robot.proRegistryInRobot.pMBR = procmbr;
robot.ProcedureRobotAssigned = ProcedureControlAssign.PRO_MACHINE_TO_BUFFER_RETURN;
procmbr.Registry(robotManagementService);
procmbr.Start();
break;
}
}
public void Procedure(object ojb)
{
ProcedureRobotToCharger RbToChar = (ProcedureRobotToCharger)ojb;
RobotUnity rb = RbToChar.robot;
ErrorCodeCharger result;
rb.properties.enableChage = true;
robot.ShowText(" Start -> " + procedureCode);
while (ProRun)
{
switch (StateRobotToCharge)
{
case RobotGoToCharge.ROBCHAR_IDLE:
//robot.ShowText("ROBCHAR_IDLE");
break;
#if USE_AUTO_CHARGE
// case RobotGoToCharge.ROBCHAR_CHARGER_CHECKSTATUS:
// if(true == chargerCtrl.WaitState(ChargerState.ST_READY,TIME_OUT_WAIT_STATE)){
// StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT;
// }
// break; //kiểm tra kết nối và trạng thái sạc
case RobotGoToCharge.ROBCHAR_ROBOT_GOTO_CHARGER:
//robot.ShowText("ROBCHAR_ROBOT_GOTO_CHARGER");
robot.TurnOnSupervisorTraffic(false);
if (rb.SendCmdLineDetectionCtrl(RequestCommandLineDetect.REQUEST_LINEDETECT_GETIN_CHARGER))
{
//Thread.Sleep(1000);
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT;
robot.ShowText("ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT");
}
break;
case RobotGoToCharge.ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT:
try
{
if (resCmd == ResponseCommand.RESPONSE_FINISH_DETECTLINE_GETIN_CHARGER)
{
if (rb.SendCmdPosPallet(RequestCommandPosPallet.REQUEST_TURNOFF_PC))
{
rb.Dispose();
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_CUTOFF_POWER_PC;
sw.Start();
robot.ShowText("ROBCHAR_ROBOT_WAITTING_CUTOFF_POWER_PC");
}
}
else if (resCmd == ResponseCommand.RESPONSE_ERROR)
{
errorCode = ErrorCode.DETECT_LINE_CHARGER_ERROR;
CheckUserHandleError(this);
}
}
catch (System.Exception)
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
CheckUserHandleError(this);
}
break; //cho phép cắt nguồn robot
case RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_CUTOFF_POWER_PC:
if (true != rb.properties.IsConnected)
{
rb.Dispose();
robot.ShowText("Sleep 30s waitting turnoff power");
Thread.Sleep(30000);
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_START_CHARGE;
sw.Reset();
robot.ShowText("ROBCHAR_ROBOT_START_CHARGE");
}
else
{
if (sw.ElapsedMilliseconds > TIME_OUT_WAIT_TURNOFF_PC)
{
sw.Reset();
errorCode = ErrorCode.CAN_NOT_TURN_OFF_PC;
CheckUserHandleError(this);
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT;
}
}
break;
case RobotGoToCharge.ROBCHAR_ROBOT_START_CHARGE:
try
{
if (true == chargerCtrl.StartCharge())
{
StateRobotToCharge = RobotGoToCharge.ROBCHAR_WAITTING_ROBOT_CONTACT_CHARGER;
robot.ShowText("ROBCHAR_WAITTING_ROBOT_CONTACT_CHARGER");
}
else
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
CheckUserHandleError(this);
}
}
catch (System.Exception)
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
CheckUserHandleError(this);
}
break;
case RobotGoToCharge.ROBCHAR_WAITTING_ROBOT_CONTACT_CHARGER:
try
{
result = chargerCtrl.WaitState(ChargerState.ST_CHARGING, TIME_OUT_WAIT_STATE);
if (ErrorCodeCharger.TRUE == result)
{
StateRobotToCharge = RobotGoToCharge.ROBCHAR_WAITTING_CHARGEBATTERY;
robot.ShowText("ROBCHAR_WAITTING_CHARGEBATTERY");
}
else
{
if (result == ErrorCodeCharger.ERROR_CONNECT)
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
robot.ShowText("CONNECT_CHARGER_ERROR");
}
else
{
errorCode = ErrorCode.CONTACT_CHARGER_ERROR;
robot.ShowText("CONTACT_CHARGER_ERROR");
}
//CheckUserHandleError(this);
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_START_CHARGE;
}
}
catch (System.Exception)
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
robot.ShowText("CONNECT_CHARGER_ERROR");
//CheckUserHandleError(this);
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_START_CHARGE;
}
break; //robot tiep xuc tram sac
//case RobotGoToCharge.ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT:
// rb.SendCmdPosPallet (RequestCommandPosPallet.REQUEST_TURNOFF_PC);
// StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_CUTOFF_POWER_PC;
// //robot.ShowText("ROBCHAR_ROBOT_WAITTING_CUTOFF_POWER_PC");
// sw.Start ();
// break; //cho phép cắt nguồn robot
//case RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_CUTOFF_POWER_PC:
// if (true != rb.properties.IsConnected) {
// StateRobotToCharge = RobotGoToCharge.ROBCHAR_WAITTING_CHARGEBATTERY;
// //robot.ShowText("ROBCHAR_WAITTING_CHARGEBATTERY");
// } else {
// if (sw.ElapsedMilliseconds > TIME_OUT_WAIT_TURNOFF_PC) {
// sw.Stop ();
// errorCode = ErrorCode.CAN_NOT_TURN_OFF_PC;
// CheckUserHandleError (this);
// StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_ALLOW_CUTOFF_POWER_ROBOT;
// }
// }
// break;
#endif
case RobotGoToCharge.ROBCHAR_WAITTING_CHARGEBATTERY:
#if false //for test
StateRobotToCharge = RobotGoToCharge.ROBCHAR_FINISHED_CHARGEBATTERY;
#else
try
{
timeCountGetBatLevel++;
if (timeCountGetBatLevel >= TIME_COUNT_GET_BAT_LEVEL)
{
timeCountGetBatLevel = 0;
result = rb.mcuCtrl.GetBatteryLevel(ref batLevel);
Console.WriteLine("=================****+++++bat level {0}+++++++++++++++++++", batLevel.data[0]);
if (ErrorCodeCharger.TRUE == result)
{
rb.properties.BatteryLevelRb = (float)batLevel.data[0];
#if USE_AUTO_CHARGE
if ((batLevel.data[0] >= BATTERY_FULL_LEVEL) || (rb.properties.enableChage == false))
#else
if (batLevel.data[0] >= BATTERY_NEW_BAT)
#endif
{
//Thread.Sleep((int)TIME_DELAY_RELEASE_CHARGE);
#if USE_AUTO_CHARGE
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_STOP_CHARGE;
#else
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_RECONNECTING;
#endif
robot.ShowText("ROBCHAR_ROBOT_STOP_CHARGE");
}
}
else
{
#if USE_AUTO_CHARGE
if (result == ErrorCodeCharger.ERROR_CONNECT)
{
errorCode = ErrorCode.CONNECT_BOARD_CTRL_ROBOT_ERROR;
}
CheckUserHandleError(this);
#endif
}
}
}
catch (System.Exception e)
{
Console.WriteLine(e);
#if USE_AUTO_CHARGE
errorCode = ErrorCode.CONNECT_BOARD_CTRL_ROBOT_ERROR;
CheckUserHandleError(this);
#endif
}
#endif
break; //dợi charge battery và thông tin giao tiếp server và trạm sạc
#if USE_AUTO_CHARGE
case RobotGoToCharge.ROBCHAR_ROBOT_STOP_CHARGE:
try
{
if (true == chargerCtrl.StopCharge())
{
robot.ShowText("Stop charger success");
StateRobotToCharge = RobotGoToCharge.ROBCHAR_FINISHED_CHARGEBATTERY;
robot.ShowText("ROBCHAR_FINISHED_CHARGEBATTERY");
}
else
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
//CheckUserHandleError(this);
}
}
catch (System.Exception)
{
errorCode = ErrorCode.CONNECT_CHARGER_ERROR;
//CheckUserHandleError(this);
}
break;
case RobotGoToCharge.ROBCHAR_FINISHED_CHARGEBATTERY:
Thread.Sleep(10000);
try
{
if (true == rb.mcuCtrl.TurnOnPcRobot())
{
robot.ShowText("Turn on pc");
Thread.Sleep(60000);
robot.ShowText("Reconnect server");
rb.Start(rb.properties.Url);
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_RECONNECTING;
robot.ShowText("ROBCHAR_ROBOT_WAITTING_RECONNECTING");
}
else
{
errorCode = ErrorCode.CAN_NOT_TURN_ON_PC;
CheckUserHandleError(this);
}
}
catch (System.Exception)
{
errorCode = ErrorCode.CONNECT_BOARD_CTRL_ROBOT_ERROR;
CheckUserHandleError(this);
}
break; //Hoàn Thành charge battery và thông tin giao tiếp server và trạm sạc
#endif
case RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_RECONNECTING:
if (true == CheckReconnectServer(TIME_OUT_ROBOT_RECONNECT_SERVER))
{
#if USE_AUTO_CHARGE
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_GETOUT_CHARGER;
#else
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_RELEASED;
#endif
robot.ShowText("ROBCHAR_ROBOT_GETOUT_CHARGER");
}
else
{
errorCode = ErrorCode.ROBOT_CANNOT_CONNECT_SERVER_AFTER_CHARGE;
CheckUserHandleError(this);
}
break; //Robot mở nguồng và đợi connect lại
#if USE_AUTO_CHARGE
case RobotGoToCharge.ROBCHAR_ROBOT_GETOUT_CHARGER:
if (rb.SendCmdLineDetectionCtrl(RequestCommandLineDetect.REQUEST_LINEDETECT_GETOUT_CHARGER))
{
sw.Restart();
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_GETOUT_CHARGER;
robot.ShowText("ROBCHAR_ROBOT_WAITTING_GETOUT_CHARGER");
}
break;
case RobotGoToCharge.ROBCHAR_ROBOT_WAITTING_GETOUT_CHARGER:
if (resCmd == ResponseCommand.RESPONSE_FINISH_DETECTLINE_GETOUT_CHARGER)
{
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_RELEASED;
robot.ShowText("ROBCHAR_ROBOT_RELEASED");
}
else if (resCmd == ResponseCommand.RESPONSE_ERROR)
{
errorCode = ErrorCode.DETECT_LINE_CHARGER_ERROR;
CheckUserHandleError(this);
}
if (sw.ElapsedMilliseconds >= 30000)
{
sw.Reset();
StateRobotToCharge = RobotGoToCharge.ROBCHAR_ROBOT_GETOUT_CHARGER;
}
break;
#endif
case RobotGoToCharge.ROBCHAR_ROBOT_RELEASED:
robot.robotTag = RobotStatus.IDLE;
rb.PreProcedureAs = ProcedureControlAssign.PRO_READY;
ReleaseProcedureHandler(this);
ProRun = false;
robot.ShowText("RELEASED");
UpdateInformationInProc(this, ProcessStatus.S);
order.endTimeProcedure = DateTime.Now;
order.totalTimeProcedure = order.endTimeProcedure.Subtract(order.startTimeProcedure).TotalMinutes;
KillEvent();
break; // trả robot về robotmanagement để nhận quy trình mới
default:
break;
}
//robot.ShowText("-> " + procedureCode);
Thread.Sleep(100);
}
StateRobotToCharge = RobotGoToCharge.ROBCHAR_IDLE;
}
