server commit files

fyxc

2025-05-22 09fcc4ec56a1ce6c0fcb308348d8dd5e2c08d336

 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) {
@@ -619,6 +690,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 +1092,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 +1169,12 @@
                staNo = 1023;
            } else if (wrkMast.getSourceStaNo() == 1031) {
                staNo = 1032;
                //检测1135货物是否到达1031，到达才允许走到1032
                if (!(staProtocol.isAutoing()
                        && staProtocol.isLoading())
                ) {
                    return false;
                }
            }

            staProtocol = staProtocol.clone();
@@ -1167,6 +1276,14 @@
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }

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

            }

            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
@@ -1286,6 +1403,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;
@@ -1321,11 +1463,25 @@
            }
            if (wrkMast.getStaNo() == 1031) {

                //调拨任务执行时，不允许有其他入出库任务工作
                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";
@@ -1411,12 +1567,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);
@@ -1851,16 +2001,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());
                            }
                        }
                    }
                }