#

lsh

2024-05-16 c41b0d4083a7d67b85a895dcda535f3bcf7c0272

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -1364,6 +1364,67 @@
    }

    /**
     * 堆垛机站出库到出库站
     */
    public synchronized void crnStnToOutStnTwo() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                // 获取堆垛机出库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId());
                    if (wrkMast == null) {
                        continue;
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                    CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
                    CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                    if (crnProtocol.statusTypeTwo == CrnStatusType.FETCHING || crnProtocol.statusTypeTwo == CrnStatusType.PUTTING) {
                        // 移动中
                        continue;
                    }

                    //  判断堆垛机状态等待确认
                    if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNoTwo().equals(wrkMast.getWrkNo().shortValue())
                            && crnProtocol.statusTypeTwo == CrnStatusType.WAITING
                            && crnProtocol.forkPosTypeTwo == CrnForkPosType.HOME) {

                        // 命令下发区 --------------------------------------------------------------------------
                        // 下发站点信息
                        staProtocol.setWorkNo(wrkMast.getWrkNo());
                        staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo()));
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                            continue;
                        }

                        // 更新工作档状态为14失败
                        wrkMast.setWrkSts(14L);
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
                            crnThread.setResetFlagTwo(true);
                        } else {
                            log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }
                    }
                }
            }
        }
    }

    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecute() {
@@ -1395,8 +1456,12 @@
                                case 2:
                                    this.crnStnToLoc1Single(crn, crnProtocol); //  入库
                                    break;
                                case 3:
                                case 4:
                                case 5:
                                    break;
                                default:
                                    this.crnStnToLoc1(crn, crnProtocol); //  入库
                                    this.crnStnToLoc1(crn, crnProtocol,1); //  入库
                            }
                            crnProtocol.setLastIo("O");
                        } else if (basCrnp.getOutEnable().equals("Y")) {
@@ -1405,8 +1470,12 @@
                                case 2:
                                    this.locToCrnStn1Single(crn, crnProtocol); //  出库
                                    break;
                                case 3:
                                case 4:
                                case 5:
                                    break;
                                default:
                                    this.locToCrnStn1(crn, crnProtocol); //  出库
                                    this.locToCrnStn1(crn, crnProtocol,1); //  出库
                            }
                            crnProtocol.setLastIo("I");
                        }
@@ -1419,8 +1488,12 @@
                                case 2:
                                    this.locToCrnStn1Single(crn, crnProtocol); //  出库
                                    break;
                                case 3:
                                case 4:
                                case 5:
                                    break;
                                default:
                                    this.locToCrnStn1(crn, crnProtocol); //  出库
                                    this.locToCrnStn1(crn, crnProtocol,1); //  出库
                            }
                            crnProtocol.setLastIo("I");
                        } else if (basCrnp.getInEnable().equals("Y")) {
@@ -1429,13 +1502,120 @@
                                case 2:
                                    this.crnStnToLoc1Single(crn, crnProtocol); //  入库
                                    break;
                                case 3:
                                case 4:
                                case 5:
                                    break;
                                default:
                                    this.crnStnToLoc1(crn, crnProtocol); //  入库
                                    this.crnStnToLoc1(crn, crnProtocol,1); //  入库
                            }
                            crnProtocol.setLastIo("O");
                        }
                    }
                }
                // 库位移转
                this.locToLoc(crn, crnProtocol);
//            this.crnRebackHp(crnProtocol, crnThread);

            }
        }catch (Exception e){
            log.error("堆垛机出入库下发报错"+e);
        }
    }

    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecuteTwo() {
        try{
            for (CrnSlave crn : slaveProperties.getCrn()) {
                // 获取堆垛机信息
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) {
                    continue;
                }
                BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
                if (basCrnp == null) {
                    log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                    continue;
                }


                int[] sign = new int[]{0,0};
                // 只有当堆垛机空闲 并且 无任务时才继续执行
                if (crnProtocol.getModeType() == CrnModeType.AUTO) {
                    // 只有当堆垛机工位空闲 并且 无任务时才继续执行
                    if (crnProtocol.getStatusType() == CrnStatusType.IDLE
                            && crnProtocol.getTaskNo() == 0
                            && crnProtocol.getLoaded() == 0
                            && crnProtocol.getForkPos() == 0) {
                        sign[0] = 1;
                        sign[1] = 1;
                    }else if (crnProtocol.getStatusTypeTwo() == CrnStatusType.IDLE
                            && crnProtocol.getTaskNoTwo() == 0
                            && crnProtocol.getLoadedTwo() == 0
                            && crnProtocol.getForkPosTwo() == 0){
                        sign[0] = 1;
                        sign[1] = 2;
                    }
                }

                if (sign[0]==1){
                    // 如果最近一次是入库模式
                    if (crnProtocol.getLastIo().equals("I")) {
                        if (basCrnp.getInEnable().equals("Y")) {
                            switch (crn.getId()){
                                case 3:
                                case 4:
                                case 5:
                                    this.crnStnToLoc1(crn, crnProtocol, sign[1]); //  入库
                                    break;
                                default:
                                    break;
                            }
                            crnProtocol.setLastIo("O");
                        } else if (basCrnp.getOutEnable().equals("Y")) {
                            switch (crn.getId()){
                                case 3:
                                case 4:
                                case 5:
                                    this.locToCrnStn1(crn, crnProtocol, sign[1]); //  出库
                                    break;
                                default:
                                    break;
                            }
                            crnProtocol.setLastIo("I");
                        }
                    }
                    // 如果最近一次是出库模式
                    else if (crnProtocol.getLastIo().equals("O")) {
                        if (basCrnp.getOutEnable().equals("Y")) {
                            switch (crn.getId()){
                                case 3:
                                case 4:
                                case 5:
                                    this.locToCrnStn1(crn, crnProtocol, sign[1]); //  出库
                                    break;
                                default:
                                    break;
                            }
                            crnProtocol.setLastIo("I");
                        } else if (basCrnp.getInEnable().equals("Y")) {
                            switch (crn.getId()){
                                case 3:
                                case 4:
                                case 5:
                                    this.crnStnToLoc1(crn, crnProtocol, sign[1]); //  入库
                                    break;
                                default:
                                    break;
                            }
                            crnProtocol.setLastIo("O");
                        }
                    }
                }

                // 库位移转
                this.locToLoc(crn, crnProtocol);
//            this.crnRebackHp(crnProtocol, crnThread);
@@ -1703,7 +1883,7 @@
     * 入库  ===>>  堆垛机站到库位
     * 2022-12-03 TQS修改，先遍历查询同台堆垛机工作档所有站点入库任务LIST，根据工作档任务排序优先级高于 根据堆垛机入库站点排序
     */
    public synchronized void crnStnToLoc1(CrnSlave slave, CrnProtocol crnProtocol) {
    public synchronized void crnStnToLoc1(CrnSlave slave, CrnProtocol crnProtocol, Integer crnStation) {
        List<WrkMast> wrkMasts = wrkMastMapper.selectPakInStep12(slave.getId());
        for(WrkMast wrkMast : wrkMasts){
            if (wrkMast == null) {
@@ -1755,10 +1935,21 @@
                continue;
            }

            // 堆垛机控制过滤
            if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                continue;
            //工位
            if (crnStation == 1){
                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    break;
                }
            }else if(crnStation == 2){
                // 堆垛机控制过滤
                if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) {
                    break;
                }
            }else {
                break;
            }


            // 已经存在吊车执行任务时，则过滤
            if (wrkMastMapper.selectWorking(slave.getId()) != null) {
@@ -1815,7 +2006,7 @@
            crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 目标库位排
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
                // 修改工作档状态 2.设备上走 => 3.吊车入库中
@@ -1828,7 +2019,6 @@
                }
            }
        }

    }

    /**
@@ -2107,7 +2297,7 @@
     * 出库  ===>>  库位到堆垛机站
     * 2022-12-03 TQS修改，先遍历查询工作档所有站点出库任务LIST，根据工作档任务排序优先级高于 根据堆垛机入库站点排序
     */
    public synchronized void locToCrnStn1(CrnSlave slave, CrnProtocol crnProtocol) {
    public synchronized void locToCrnStn1(CrnSlave slave, CrnProtocol crnProtocol, Integer crnStation) {
        List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep12(slave.getId());
        for (WrkMast wrkMast : wrkMasts) {
            if (wrkMast == null) {
@@ -2171,9 +2361,21 @@
                    && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                // 命令下发区 --------------------------------------------------------------------------

                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {

                //工位
                if (crnStation == 1){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }
                }else if(crnStation == 2){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusTypeTwo().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNoTwo() != 0) {
//                        continue;
                        break;
                    }
                }else {
                    break;
                }

@@ -2239,7 +2441,7 @@
                crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 12.吊车出库中
@@ -2680,6 +2882,48 @@
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        // 堆垛机复位
                        crnThread.setResetFlag(true);
                    }
                }

            }
        }
    }
    /**
     * 执行对工作档的完成操作
     */
    public synchronized void storeFinishedTwo() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) {
                continue;
            }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.statusTypeTwo == CrnStatusType.WAITING && crnProtocol.getTaskNoTwo() != 0) {
                if (crnProtocol.getTaskNoTwo() == 32222) {
                    // 堆垛机复位
                    crnThread.setResetFlagTwo(true);
                } else {
                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNoTwo().intValue());
                    if (wrkMast == null) {
                        log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNoTwo());
                        continue;
                    }
                    // 入库 + 库位转移  ==> 4.入库完成
                    if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) {
                        wrkMast.setWrkSts(4L);
                    } else {
                        continue;
                    }
                    Date now = new Date();
                    wrkMast.setCrnEndTime(now);
                    wrkMast.setModiTime(now);
                    // 修改成功后复位堆垛机
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        // 堆垛机复位
                        crnThread.setResetFlagTwo(true);
                    }
                }

@@ -5220,6 +5464,9 @@
     * 小车地图更新  更新锁
     * */
    public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd){
        if (true){
            return true;
        }

//        List<Integer> integers = RouteUtils.RouteMapCurrentFar(basRgvMapCurrent.getNowRoute(),staStart,staEnd, basRgvMapCurrent.getLockStartRoute());
        //更新当前小车锁