1

zhang

2025-08-29 c6ac196d7207e64b8591f84932439214561fc446

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

@@ -163,6 +163,13 @@
     */
    public synchronized void generateInboundWrk() {
        try {
//            //检测是否存在调拨任务，不执行入库
//            boolean checkTransferWrkMast = wrkMastService.checkTransferWrkMast();
//            if (checkTransferWrkMast) {
//                News.error("存在调拨任务，不执行入库");
//                return;
//            }

            // 遍历入库口
            for (DevpSlave.Sta inSta : slaveProperties.getDevp().get(0).getInSta()) {
                if (inSta.getStaNo() == 1014 || inSta.getStaNo() == 1025) {
@@ -217,6 +224,22 @@
                        if (Cools.isEmpty(barcode) || "?".endsWith(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                            continue;
                        }

                        //检测是否存在出库任务
                        List<WrkMast> wrkMastOutList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                                .in("sta_no", 1024, 1013)
                                .eq("io_type", 101));
                        if (!wrkMastOutList.isEmpty()) {
                            Object o = redisUtil.get(RedisKeyType.DEVP_ERROR_FLAG.key + staProtocol.getSiteId());
                            if (o == null) {
                                redisUtil.set(RedisKeyType.DEVP_ERROR_FLAG.key + staProtocol.getSiteId(), "lock", 15);
                                MessageQueue.offer(SlaveType.Devp, 1, new Task(3, staProtocol.getSiteId()));
                                setLedErrorData(staProtocol.getSiteId(), "任务冲突");
                            }
                            News.error("站点存在出库任务,禁止入库,站点={}", staProtocol.getSiteId());
                            continue;
                        }

                        // 判断重复工作档
                        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_sta_no", inSta.getStaNo()).eq("barcode", barcode));
                        if (wrkMast != null && wrkMast.getWrkSts() == WrkStsType.NEW_INBOUND.sts) {
@@ -225,7 +248,7 @@
                            staProtocol.setWorkNo(Short.parseShort(String.valueOf(wrkMast.getWrkNo())));
                            staProtocol.setStaNo(Short.parseShort(String.valueOf(inSta.getStaNo() + 1)));
                            MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                            News.taskInfo(wrkMast.getWrkNo(), "输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                            News.info("输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                            wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
                            wrkMast.setModiTime(new Date());
                            wrkMastService.updateById(wrkMast);
@@ -346,6 +369,22 @@
                    Short workNo = staProtocol.getWorkNo();
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && isInEnable(devpThread, inSta.getStaNo()) && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999)) && staProtocol.isPakMk()) {
                        String barcode = staProtocol.getBarcode();

                        //检测是否存在出库任务
                        List<WrkMast> wrkMastOutList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                                .in("sta_no", 1011, 1021)
                                .eq("io_type", 101));
                        if (!wrkMastOutList.isEmpty()) {
                            Object o = redisUtil.get(RedisKeyType.DEVP_ERROR_FLAG.key + staProtocol.getSiteId());
                            if (o == null) {
                                redisUtil.set(RedisKeyType.DEVP_ERROR_FLAG.key + staProtocol.getSiteId(), "lock", 15);
                                MessageQueue.offer(SlaveType.Devp, 1, new Task(3, staProtocol.getSiteId()));
                                setLedErrorData(staProtocol.getSiteId(), "任务冲突");
                            }
                            News.error("站点存在出库任务,禁止入库,站点={}", staProtocol.getSiteId());
                            continue;
                        }

                        // 判断重复工作档
                        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_sta_no", inSta.getStaNo()).eq("barcode", barcode));
                        if (wrkMast == null) {
@@ -470,6 +509,13 @@


    public void outFirst() {
//        //检测是否存在调拨任务，存在不执行出库
//        boolean checkTransferWrkMast = wrkMastService.checkTransferWrkMast();
//        if (checkTransferWrkMast) {
//            News.error("存在调拨任务，不执行出库");
//            return;
//        }

        DevpSlave devpSlave = slaveProperties.getDevp().get(0);
        // 遍历堆垛机出库站
        Date now = new Date();
@@ -479,6 +525,31 @@
            if (devpThread == null) {
                continue;
            }

            //检测是否存在入库任务
            Integer checkInSourceStaNo = null;
            if (wrkMast.getStaNo() == 1013) {
                checkInSourceStaNo = 1014;
            } else if (wrkMast.getStaNo() == 1024) {
                checkInSourceStaNo = 1025;
            } else {
                continue;
            }
            List<WrkMast> wrkMastInList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .eq("source_sta_no", checkInSourceStaNo)
                    .eq("io_type", 1));
            if (!wrkMastInList.isEmpty()) {
                Object o = redisUtil.get(RedisKeyType.DEVP_ERROR_FLAG.key + wrkMast.getStaNo());
                if (o == null) {
                    redisUtil.set(RedisKeyType.DEVP_ERROR_FLAG.key + wrkMast.getStaNo(), "lock", 15);
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, wrkMast.getStaNo()));
                    setLedErrorData(wrkMast.getStaNo(), "任务冲突");
                }
                News.error("站点存在入库任务,禁止出库,站点={}", wrkMast.getStaNo());
                continue;
            }


            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getStaNo());
            if (staProtocol == null) {
@@ -531,7 +602,7 @@
    /**
     * 出库到出库口
     */
    public synchronized void stnToOutStn() {
    public synchronized void stnToOutStn(int i) {
        ShuttleThread shuttleThread1 = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, 1);
        ShuttleThread shuttleThread2 = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, 2);
        ShuttleProtocol status1 = shuttleThread1.getStatus();
@@ -562,19 +633,35 @@
                        if (wrkMast == null) {
                            continue;
                        }

                        String sourceLocNo = "1200305";
                        String locNo = "1300105";
                        if (wrkMast.getStaNo() == 1013) {
                            sourceLocNo = "1200301";
                            locNo = "1300101";
                            if (loc.contains(locNo)) {
                        String locNo = "1100105";
                        if (wrkMast.getShuttleNo() == 1) {
                            if (wrkMast.getStaNo() == 1013) {
                                sourceLocNo = "1200301";
                                locNo = "1100101";
                                if (loc.contains(locNo)) {
                                    locNo = "1100101";
                                }
                            } else {
                                if (loc.contains(locNo)) {
                                    locNo = "1100105";
                                }
                            }
                        } else {
                            if (loc.contains(locNo)) {
                                locNo = "1100105";
                            if (wrkMast.getStaNo() == 1013) {
                                sourceLocNo = "1200301";
                                locNo = "1000101";
                                if (loc.contains(locNo)) {
                                    locNo = "1000101";
                                }
                            } else {
                                if (loc.contains(locNo)) {
                                    locNo = "1000105";
                                }
                            }
                        }
                        if (loc.contains(locNo)) {
                            locNo = "0900105";
                        }

                        boolean dispatchShuttle = shuttleDispatchUtils.shuttleMoveGenerate(wrkMast.getWrkNo(), sourceLocNo, locNo, wrkMast.getShuttleNo(), null, false);
@@ -619,6 +706,33 @@
                log.info("电视机数据设置：{},{}", staNo, data);
            } else {
                log.info("电视机数据设置异常：{},{}", wrkNo, response);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void setLedErrorData(Integer staNo, String msg) {
        try {
            HashMap<String, String> hashMap = new HashMap<>();
            hashMap.put("msg", msg);
            hashMap.put("sta", String.valueOf(staNo));
            String response = null;
            response = new HttpHandler.Builder()
                    .setUri(wmsUrl)
                    .setPath("/rpc/led/getError")
                    .setJson(JSON.toJSONString(hashMap))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);
            Integer code = jsonObject.getInteger("code");
            if (code.equals(200)) {
                String data = jsonObject.getString("data");
                List<LedCommand> wrkDetls = JSONArray.parseArray(data, LedCommand.class);
                redisUtil.set("LED_" + staNo, wrkDetls, 30);
                log.info("电视机数据设置：{},{}", staNo, data);
            } else {
                log.info("电视机数据设置异常：{},{}", staNo, response);
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -994,6 +1108,11 @@
            if (wrkMast.getSourceStaNo() == 1022) {
                led = 3;
            } else if (wrkMast.getSourceStaNo() == 1031) {
                //工作号一致判断
                if (!String.valueOf(staProtocol.getFinishWorkNo()).equals(wrkMast.getWmsWrkNo2())) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}工作号1，{}工作号2，1135过来的托盘，为将工作号写到至1031", staProtocol.getFinishWorkNo(), wrkMast.getWmsWrkNo2());
                    return false;
                }
            }
            // 尺寸检测异常
            boolean back = false;
@@ -1066,6 +1185,12 @@
                staNo = 1023;
            } else if (wrkMast.getSourceStaNo() == 1031) {
                staNo = 1032;
                //检测1135货物是否到达1031，到达才允许走到1032
                if (!(staProtocol.isAutoing()
                        && staProtocol.isLoading())
                ) {
                    return false;
                }
            }

            staProtocol = staProtocol.clone();
@@ -1104,12 +1229,13 @@
                return false;
            }


            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }
//            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
//            if (liftWrkMast != null) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//当前提升机存在未完成任务，等待下一次轮询
//            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
@@ -1166,6 +1292,23 @@
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }

                //调拨任务执行时，不允许有其他入出库任务工作
                boolean checkNoTransferWorking = wrkMastService.checkNoTransferWorking();
                if (checkNoTransferWorking) {
                    News.error("调拨任务执行时，不允许有其他入出库任务工作");
                    return false;
                }

            }

            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!wrkMast.getWrkNo().equals(liftWrkMast.getMainWrkNo())) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            String locNo = "0200305";
@@ -1202,6 +1345,7 @@
            assignCommand.setLiftNo(liftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.PALLET_IN.id.shortValue());


            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
@@ -1275,6 +1419,31 @@
        try {
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_OUTBOUND.sts, WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts).in("sta_no", 1011, 1021, 1031));
            for (WrkMast wrkMast : wrkMasts) {

                //检测是否存在入库任务
                Integer checkInSourceStaNo = null;
                if (wrkMast.getStaNo() == 1011) {
                    checkInSourceStaNo = 1012;
                } else if (wrkMast.getStaNo() == 1021) {
                    checkInSourceStaNo = 1022;
                }

                if (checkInSourceStaNo != null) {
                    List<WrkMast> wrkMastInList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                            .eq("source_sta_no", checkInSourceStaNo)
                            .eq("io_type", 1));
                    if (!wrkMastInList.isEmpty()) {
                        Object o = redisUtil.get(RedisKeyType.DEVP_ERROR_FLAG.key + wrkMast.getStaNo());
                        if (o == null) {
                            redisUtil.set(RedisKeyType.DEVP_ERROR_FLAG.key + wrkMast.getStaNo(), "lock", 15);
                            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, wrkMast.getStaNo()));
                            setLedErrorData(wrkMast.getStaNo(), "任务冲突");
                        }
                        News.error("站点存在入库任务,禁止出库,站点={}", wrkMast.getStaNo());
                        continue;
                    }
                }

                boolean step1 = this.liftOutExecuteStep1(wrkMast);//触发搬运任务
                if (!step1) {
                    continue;
@@ -1309,15 +1478,26 @@
                return false;
            }
            if (wrkMast.getStaNo() == 1031) {
//                if (staProtocol.getOutInModel() != 1) {
//                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
//                    return false;
//                }

                //调拨任务执行时，不允许有其他入出库任务工作
                boolean checkNoTransferWorking = wrkMastService.checkNoTransferWorking();
                if (checkNoTransferWorking) {
                    News.error("调拨任务执行时，不允许有其他入出库任务工作-出库");
                    return false;
                }

            } else {
                if (!isOutEnable(devpThread, wrkMast.getStaNo())) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }

//                //检测是否存在调拨任务，存在不执行出库
//                boolean checkTransferWrkMast = wrkMastService.checkTransferWrkMast();
//                if (checkTransferWrkMast) {
//                    News.error("存在调拨任务，不执行出库");
//                    return false;
//                }
            }

            String locNo = "0200305";
@@ -1403,12 +1583,6 @@
            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getPalletOutCommand(wrkMast.getWrkNo(), sourceLev, wrkMast.getStaNo());
            LiftCommand liftCommand = liftCommands.get(0);
//            if (wrkMast.getMainWrkNo() != null) {
            liftCommand.setTaskNo(wrkMast.getWrkNo());
//            } else {
//                int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
//                liftCommand.setTaskNo(deviceWrk);//更换随机任务号
//            }

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);
@@ -1843,16 +2017,18 @@
                } else if (staProtocol.getSiteId() == 1031 && staProtocol.isLoading()) {
                    wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getFinishWorkNo()).eq("wrk_sts", WrkStsType.OUTBOUND_DEVP_RUN_2.sts));
                    if (wrkMast != null) {
                        staProtocol.setWorkNo(Short.parseShort(String.valueOf(wrkMast.getWrkNo())));
                        staProtocol.setWorkNo(Short.parseShort(String.valueOf(wrkMast.getWmsWrkNo())));
                        staProtocol.setStaNo(Short.parseShort(String.valueOf(1135)));
                        MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                        News.taskInfo(wrkMast.getWrkNo(), "输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                        wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            News.taskInfo(wrkMast.getWrkNo(), "输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        } else {
                            News.error("输送线已确认且任务完成状态,复位失败，但未找到工作档。输送线号={}，完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        boolean offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                        if (offer) {
                            News.taskInfo(wrkMast.getWrkNo(), "输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                            wrkMast.setModiTime(new Date());
                            if (wrkMastService.updateById(wrkMast)) {
                                News.taskInfo(wrkMast.getWrkNo(), "输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                            } else {
                                News.error("输送线已确认且任务完成状态,复位失败，但未找到工作档。输送线号={}，完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                            }
                        }
                    }
                }
@@ -2324,6 +2500,22 @@
            if (basShuttleCharge == null) {
                return false;
            }
            try {
                ShuttleThread shuttleThread2 = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo() == 1 ? 2 : 1);
                if (shuttleThread2 == null) {
                    return false;
                }
                ShuttleProtocol shuttleProtocol2 = shuttleThread2.getStatus();
                if (shuttleProtocol2 == null) {
                    return false;
                }
                if (shuttleProtocol2.getCurrentLocNo().equals(basShuttleCharge.getWaitLocNo())) {
                    String locNo = Utils.getLocNo(Utils.getRow(basShuttleCharge.getWaitLocNo()) + 1, Utils.getBay(basShuttleCharge.getWaitLocNo()), Utils.getLev(basShuttleCharge.getWaitLocNo()));
                    basShuttleCharge.setWaitLocNo(locNo);
                }
            } catch (Exception e) {
                log.error("寻找新的待机位,{}", e);
            }

            //调度小车去待机位
            boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), basShuttleCharge.getWaitLocNo(), wrkMast.getShuttleNo());