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; }