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;
            }
        }
예제 #2
0
        public void Procedure(object ojb)
        {
            ProcedureRobotToReady    RbToRd  = (ProcedureRobotToReady)ojb;
            RobotUnity               rb      = RbToRd.robot;
            DataRobotToReady         p       = RbToRd.points;
            TrafficManagementService Traffic = RbToRd.Traffic;

            robot.ShowText(" start -> " + procedureCode + "_________________0000000000000000000_____________________");
            while (ProRun)
            {
                switch (StateRobotGoToReady)
                {
                case RobotGoToReady.ROBREA_IDLE:
                    //robot.ShowText("ROBREA_IDLE");
                    break;

                case RobotGoToReady.ROBREA_SELECT_BEHAVIOR_ONZONE:
                    robot.ShowText("ROBREA_SELECT_BEHAVIOR_ONZONE");
                    if (Traffic.RobotIsInArea("READY", robot.properties.pose.Position, TypeZone.OPZS))
                    {
                        robot.ShowText("ROBREA_ROBOT_RELEASED");
                        StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_RELEASED;
                    }
                    if (rb.SendPoseStamped(p.PointFrontLine))
                    {
                        StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_WAITTING_GOTO_READYSTATION_REG;
                        robot.ShowText("ROBREA_ROBOT_GOTO_FRONTLINE_READYSTATION");
                        registryRobotJourney.startPlaceName = Traffic.DetermineArea(robot.properties.pose.Position);
                        registryRobotJourney.startPoint     = robot.properties.pose.Position;
                        registryRobotJourney.endPoint       = p.PointFrontLine.Position;
                    }
                    break;

                case RobotGoToReady.ROBREA_ROBOT_WAITTING_GOTO_READYSTATION_REG:     // Robot dang di toi dau line ready station
                    if (TrafficRountineConstants.DetetectInsideStationCheck(registryRobotJourney))
                    {
                        if (DetermineHasTaskWaitingAnRobotAvailable())
                        {
                            StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_WAITINGREADY_FORCERELEASED;
                            robot.ShowText("ROBREA_ROBOT_WAITINGREADY_FORCERELEASED");
                            break;
                        }
                    }
                    else
                    {
                        StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_WAITTING_GOTO_READYSTATION;
                    }
                    break;

                case RobotGoToReady.ROBREA_ROBOT_WAITTING_GOTO_READYSTATION:     // Robot dang di toi dau line ready station

                    if (resCmd == ResponseCommand.RESPONSE_LASER_CAME_POINT)
                    {
                        TrafficRountineConstants.DetectRelease(registryRobotJourney);
                        resCmd = ResponseCommand.RESPONSE_NONE;
                        StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_WAIITNG_DETECTLINE_TO_READYSTATION;
                        robot.ShowText("ROBREA_ROBOT_WAIITNG_DETECTLINE_TO_READYSTATION");
                    }
                    break;

                case RobotGoToReady.ROBREA_ROBOT_WAIITNG_DETECTLINE_TO_READYSTATION:     // đang đợi dò line để đến vị trí line trong buffer
                    if (rb.SendCmdAreaPallet(RbToRd.points.PointOfCharger))
                    {
                        StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_WAITTING_CAME_POSITION_READYSTATION;
                        robot.ShowText("ROBREA_ROBOT_WAITTING_CAME_POSITION_READYSTATION");
                    }
                    break;

                case RobotGoToReady.ROBREA_ROBOT_WAITTING_CAME_POSITION_READYSTATION:     // đến vị trả robot về robotmanagement để nhận quy trình mới
                    if (resCmd == ResponseCommand.RESPONSE_FINISH_GOTO_POSITION)
                    {
                        //rb.prioritLevel.OnAuthorizedPriorityProcedure = false;
                        StateRobotGoToReady = RobotGoToReady.ROBREA_ROBOT_RELEASED;
                        TrafficRountineConstants.RegIntZone_READY.Release(robot);
                        robot.robotTag = RobotStatus.IDLE;
                        robot.SetSafeYellowcircle(false);
                        robot.SetSafeBluecircle(false);
                        robot.SetSafeSmallcircle(false);
                        robot.TurnOnSupervisorTraffic(false);
                        rb.mcuCtrl.lampRbOff();
                        robot.ShowText("ROBREA_ROBOT_RELEASED");
                    }
                    else if (resCmd == ResponseCommand.RESPONSE_ERROR)
                    {
                        errorCode = ErrorCode.DETECT_LINE_ERROR;
                        CheckUserHandleError(this);
                    }
                    break;

                case RobotGoToReady.ROBREA_ROBOT_RELEASED:
                    Global_Object.cntGoready++;
                    rb.PreProcedureAs = ProcedureControlAssign.PRO_READY;
                    // if (errorCode == ErrorCode.RUN_OK) {
                    ReleaseProcedureHandler(this);
                    // } else {
                    //     ErrorProcedureHandler (this);
                    // }
                    robot.setColorRobotStatus(RobotStatusColorCode.ROBOT_STATUS_OK);
                    ProRun = false;
                    //robot.ShowText("RELEASED");
                    UpdateInformationInProc(this, ProcessStatus.S);
                    order.endTimeProcedure   = DateTime.Now;
                    order.totalTimeProcedure = order.endTimeProcedure.Subtract(order.startTimeProcedure).TotalMinutes;
                    KillEvent();
                    break;

                case RobotGoToReady.ROBREA_ROBOT_WAITINGREADY_FORCERELEASED:
                    // add to wait task;
                    //robot.robotTag = RobotStatus.IDLE;

                    robot.setColorRobotStatus(RobotStatusColorCode.ROBOT_STATUS_OK);
                    procedureCode = ProcedureControlServices.ProcedureCode.PROC_CODE_ROBOT_WAITINGTO_READY;
                    ProRun        = false;
                    robot.ShowText("RELEASED WHEN WAITTING TO READY, HAS AN NEW TASK");
                    UpdateInformationInProc(this, ProcessStatus.S);
                    order.endTimeProcedure   = DateTime.Now;
                    order.totalTimeProcedure = order.endTimeProcedure.Subtract(order.startTimeProcedure).TotalMinutes;

                    rb.PreProcedureAs = ProcedureControlAssign.PRO_WAIT_TASK;
                    ReleaseProcedureHandler(this);
                    KillEvent();
                    break;
                }
                Thread.Sleep(700);
            }
            StateRobotGoToReady = RobotGoToReady.ROBREA_IDLE;
        }