zy-wcs.git - Gitblit

parent: d9c90663 | 补丁 | 提交 | ignore whitespace

zhang

2025-07-10 b8feb2880cc44d8408627db431eb9cf31967f393

5个文件已修改

1个文件已添加

	src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java	505 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/main/java/com/zy/core/MainProcess.java	7 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/main/java/com/zy/core/model/protocol/StaProtocol.java	26 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/main/java/com/zy/core/thread/SiemensDevpThread.java	120 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/main/resources/application-wcs.yml	77 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/main/resources/application.yml	79 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史

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

@@ -95,7 +95,7 @@
     * 组托
     * 入库站，根据条码扫描生成入库工作档，工作状态 2
     */
    public synchronized void generateStoreWrkFile(Integer mark) {
    public synchronized void generateStoreWrkFile(Integer mark) throws InterruptedException {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
@@ -115,68 +115,26 @@
                    staProtocol = staProtocol.clone();
                }

                //LED
                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                // 入出库模式判断
//                if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
//                if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
//                    continue;
//                }

                // 判断是否满足入库条件
                if (!staProtocol.isLoading()){
                //调用外形检测
                if (!shape(devp, staProtocol, devpThread, inSta)) {
                    continue;
                }
                String barcode11 = barcodeThread.getBarcode();
                if (Cools.isEmpty(barcode11)){
                    if (staProtocol.isAutoing()&& !staProtocol.isEmptyMk() && staProtocol.getWorkNo() == 9999 && staProtocol.isPakMk() && staProtocol.getStamp()==2){
                        staProtocol.setStamp(3);
                        News.info(""+mark+" - 7"+" - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode11, inSta.getStaNo());
                        staProtocol.setWorkNo((short) 9989);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                        }
                        continue;
                    }
                }
                if (staProtocol.isAutoing() && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && staProtocol.getWorkNo() > 9990
                        && staProtocol.getWorkNo()!=9999 && staProtocol.getWorkNo()!=9992 && staProtocol.getWorkNo()!=0
                        && staProtocol.isPakMk() && staProtocol.getStamp()>=2 && staProtocol.getStamp()!=3) {// && !Cools.isEmpty(barcode)) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行");
//                    try {
//                        Thread.sleep(300);
//                    }catch (Exception e){}

                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            staProtocol.setWorkNo((short) 9992);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                //LED
                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());

                            News.info(""+mark+" - 2"+" - 扫码失败1 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode, inSta.getStaNo());
                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = "扫码失败，请重试";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                            }
                            continue;
                        }
                    } else {


                String barcode = barcodeThread.getBarcode();
                if (!Cools.isEmpty(barcode)) {
                    News.info("" + mark + " - 1" + " - {}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                    if ("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                        staProtocol.setWorkNo((short) 9992);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        News.info(""+mark+" - 3"+" - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode, inSta.getStaNo());
                        News.info("" + mark + " - 2" + " - 扫码失败1 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode, inSta.getStaNo());
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
@@ -184,19 +142,38 @@
                        }
                        continue;
                    }
                } else {
                    staProtocol.setWorkNo((short) 9992);
                    staProtocol.setStaNo(inSta.getBackSta().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                    News.info("" + mark + " - 3" + " - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode, inSta.getStaNo());
                    // led 异常显示
                    if (ledThread != null) {
                        String errorMsg = "扫码失败，请重试";
                        MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                    }
                    continue;
                }
                if (staProtocol.isAutoing() && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && staProtocol.getWorkNo() > 9990
                        && staProtocol.getWorkNo() != 9999 && staProtocol.getWorkNo() != 9992 && staProtocol.getWorkNo() != 0
                        && staProtocol.isPakMk()) {
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行");

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    //过滤判断，防止拣料再入库货物，经过入库站再入库时，被退回到退库站
                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStepBarcode(barcode);
                    if (wrkMast1 !=null){
                        if (wrkMast1.getIoType()==103 || wrkMast1.getIoType()==107 || wrkMast1.getIoType()==104){
                    if (wrkMast1 != null) {
                        if (wrkMast1.getIoType() == 103 || wrkMast1.getIoType() == 107 || wrkMast1.getIoType() == 104) {
                            continue;
                        }
                    }
                    if (wrkMast != null) {
                        News.error(""+mark+" - 4"+" - 工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        staProtocol.setWorkNo((short)9992);
                        News.error("" + mark + " - 4" + " - 工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        staProtocol.setWorkNo((short) 9992);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -255,8 +232,8 @@
//                                ledThread.errorReset();
                            }
                        } else {
                            News.error(""+mark+" - 5"+" - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            staProtocol.setWorkNo((short)9992);
                            News.error("" + mark + " - 5" + " - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            staProtocol.setWorkNo((short) 9992);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -276,15 +253,15 @@
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }

                }else {
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isAutoing()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk()+"、入库印记：" + staProtocol.getStamp());
                } else {
                    News.errorNoLog("" + mark + " - 6" + " - 站点信息不符合入库条件！！！" + " 自动信号：" + staProtocol.isAutoing() + "、可入信号：" + staProtocol.isInEnable()
                            + "、空板信号：" + staProtocol.isEmptyMk() + "、工作号：" + staProtocol.getWorkNo()
                            + "、锁定标记" + staProtocol.isPakMk());
                }

            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 组托  ===》执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 组托  ===》执行完成");

    }

@@ -312,13 +289,13 @@
                }

                // 判断是否满足入库条件
                if (!staProtocol.isLoading()){
                if (!staProtocol.isLoading()) {
                    continue;
                }
                if (staProtocol.isAutoing() && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() == 9999)
                        && staProtocol.isPakMk()) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行");
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行");
                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep11(inSta.getStaNo());
                    if (wrkMast == null) {
@@ -337,20 +314,20 @@
                        wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            News.error(""+mark+" - 1"+" - 更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                            News.error("" + mark + " - 1" + " - 更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                        }
                    } else {
                        News.error(""+mark+" - 2"+" - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        News.error("" + mark + " - 2" + " - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

                }else {
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isLoading()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk()+"、入库印记：" + staProtocol.getStamp());
                } else {
                    News.errorNoLog("" + mark + " - 6" + " - 站点信息不符合入库条件！！！" + " 自动信号：" + staProtocol.isLoading() + "、可入信号：" + staProtocol.isInEnable()
                            + "、空板信号：" + staProtocol.isEmptyMk() + "、工作号：" + staProtocol.getWorkNo()
                            + "、锁定标记" + staProtocol.isPakMk());
                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - wms入库  ===》执行完成");
        News.infoNoLog("" + mark + " - 0" + " - wms入库  ===》执行完成");

    }

@@ -367,9 +344,9 @@
                    continue;
                }
                String barcode = barcodeThread.getBarcode();
                if(!Cools.isEmpty(barcode)) {
                    News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
                    if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                if (!Cools.isEmpty(barcode)) {
                    News.info("" + mark + " - 1" + " - {}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
                    if ("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        continue;
                    }
                } else {
@@ -389,7 +366,7 @@
//                if (devpThread.ioMode != IoModeType.PAKIN_MODE) { continue; }

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行");
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行");
                    WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
//                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo().intValue());
                    if (wrkMast == null) {
@@ -417,16 +394,16 @@
                            .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
                    StaDesc staDesc = staDescService.selectOne(wrapper);
                    if (Cools.isEmpty(staDesc)) {
                        News.error(""+mark+" - 2"+" - 入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                        News.error("" + mark + " - 2" + " - 入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                        staProtocol.setWorkNo((short) 9989);
                        staProtocol.setStaNo((short) (pickSta.getStaNo().shortValue()-(short)1));
                        staProtocol.setStaNo((short) (pickSta.getStaNo().shortValue() - (short) 1));
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        //LED
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "此为拣料、并板、盘点再入库.请放在"+pickSta.getBackSta().shortValue()+"站点";
                            String errorMsg = "此为拣料、并板、盘点再入库.请放在" + pickSta.getBackSta().shortValue() + "站点";
                            MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(5, errorMsg));
                        }
                        continue;
@@ -478,18 +455,18 @@
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        News.error(""+mark+" - 3"+" - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        News.error("" + mark + " - 3" + " - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

                }else {
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isLoading()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk());
                } else {
                    News.errorNoLog("" + mark + " - 6" + " - 站点信息不符合入库条件！！！" + " 自动信号：" + staProtocol.isLoading() + "、可入信号：" + staProtocol.isInEnable()
                            + "、空板信号：" + staProtocol.isEmptyMk());
                }

            }

        }
        News.infoNoLog(""+mark+" - 0"+" - 拣料、并板、盘点再入库  ===》执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 拣料、并板、盘点再入库  ===》执行完成");
    }

    /**
@@ -529,7 +506,7 @@
                    if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
                            && crnProtocol.statusType == CrnStatusType.WAITING
                            && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                        News.warnNoLog(""+mark+" - 0"+" - 开始执行");
                        News.warnNoLog("" + mark + " - 0" + " - 开始执行");

                        // 命令下发区 --------------------------------------------------------------------------

@@ -547,21 +524,21 @@
                            // 复位堆垛机
                            crnThread.setResetFlag(true);
                        } else {
                            News.error(""+mark+" - 1"+" - 更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                            News.error("" + mark + " - 1" + " - 更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }

                    }else {
                        News.errorNoLog(""+mark+" - 6"+" - 堆垛机信息不符合入库条件！！！"
                                +" 堆垛机状态："+crnProtocol.modeType+"==自动AUTO：" + CrnModeType.AUTO
                                +"、堆垛机任务号："+crnProtocol.getTaskNo()+"==工作档任务号：" + wrkMast.getWrkNo().shortValue()
                                +"、状态枚举："+crnProtocol.statusType+"==WAITING：90 //任务完成等待WCS确认)：" + CrnStatusType.WAITING
                                +"、货叉位置："+crnProtocol.forkPosType+"==HOME：0  // 货叉原位：" + CrnForkPosType.HOME);
                    } else {
                        News.errorNoLog("" + mark + " - 6" + " - 堆垛机信息不符合入库条件！！！"
                                + " 堆垛机状态：" + crnProtocol.modeType + "==自动AUTO：" + CrnModeType.AUTO
                                + "、堆垛机任务号：" + crnProtocol.getTaskNo() + "==工作档任务号：" + wrkMast.getWrkNo().shortValue()
                                + "、状态枚举：" + crnProtocol.statusType + "==WAITING：90 //任务完成等待WCS确认)：" + CrnStatusType.WAITING
                                + "、货叉位置：" + crnProtocol.forkPosType + "==HOME：0  // 货叉原位：" + CrnForkPosType.HOME);
                    }

                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 堆垛机站出库到出库站  ===》执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 堆垛机站出库到出库站  ===》执行完成");
    }

    /**
@@ -578,7 +555,7 @@
            }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                News.error(""+mark+" - 1"+" - {}号堆垛机尚未在数据库进行维护！", crn.getId());
                News.error("" + mark + " - 1" + " - {}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

@@ -590,38 +567,38 @@
            // 只有当堆垛机空闲 并且 无任务时才继续执行
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
                    && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行堆垛机入出库作业下发");
                News.warnNoLog("" + mark + " - 0" + " - 开始执行堆垛机入出库作业下发");
                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
                        //mark - 1 - ....
                        this.crnStnToLoc(crn, crnProtocol,mark); //  入库
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                        crnProtocol.setLastIo("O");
                    } else if (basCrnp.getOutEnable().equals("Y")) {
                        //mark - 2 - ....
                        this.locToCrnStn(crn, crnProtocol,mark); //  出库
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                        crnProtocol.setLastIo("I");
                    }
                }
                // 如果最近一次是出库模式
                else if (crnProtocol.getLastIo().equals("O")) {
                    if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrnStn(crn, crnProtocol,mark); //  出库
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                        crnProtocol.setLastIo("I");
                    } else if (basCrnp.getInEnable().equals("Y")) {
                        this.crnStnToLoc(crn, crnProtocol,mark); //  入库
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                        crnProtocol.setLastIo("O");
                    }
                }
            }
            // 库位移转
            //mark - 3 - ....
            this.locToLoc(crn, crnProtocol,mark);
            this.locToLoc111(crn, crnProtocol,mark);
            this.locToLoc(crn, crnProtocol, mark);
            this.locToLoc111(crn, crnProtocol, mark);
//            this.crnRebackHp(crnProtocol, crnThread);

        }
        News.infoNoLog(""+mark+" - 0"+" - 堆垛机入出库作业下发执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 堆垛机入出库作业下发执行完成");
    }

    /**
@@ -683,15 +660,15 @@
    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol,Integer mark) {
        News.warnNoLog(""+mark+" - 1"+" - 0"+" - 堆垛机入出库作业下发：执行入库");
    public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol, Integer mark) {
        News.warnNoLog("" + mark + " - 1" + " - 0" + " - 堆垛机入出库作业下发：执行入库");
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            boolean flag = false;
            // 获取堆垛机入库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
            if (staProtocol == null) {
                News.infoNoLog(""+mark+" - 1"+" - 1"+" - 堆垛机入库站信息(staProtocol!=null继续执行)：staProtocol="+staProtocol);
                News.infoNoLog("" + mark + " - 1" + " - 1" + " - 堆垛机入库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                continue;
            } else {
                staProtocol = staProtocol.clone();
@@ -699,7 +676,7 @@
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                News.error(""+mark+" - 1"+" - 2"+" - 入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                News.error("" + mark + " - 1" + " - 2" + " - 入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
@@ -707,27 +684,27 @@
                flag = true;
            }
            if (!flag) {
                News.errorNoLog(""+mark+" - 1"+" - 3"+" - 堆垛机入库站信息(以下需要全true):"
                        +"自动信号"+staProtocol.isAutoing()+"有物信号"+staProtocol.isLoading()
                        +"工作号>0"+staProtocol.getWorkNo()+"可入信号"+staProtocol.isInEnable()
                        +"能入信号（wms设置）.equals(\"Y\")"+staDetl.getCanining());
                News.errorNoLog("" + mark + " - 1" + " - 3" + " - 堆垛机入库站信息(以下需要全true):"
                        + "自动信号" + staProtocol.isAutoing() + "有物信号" + staProtocol.isLoading()
                        + "工作号>0" + staProtocol.getWorkNo() + "可入信号" + staProtocol.isInEnable()
                        + "能入信号（wms设置）.equals(\"Y\")" + staDetl.getCanining());
                continue;
            }
            // 获取工作状态为2（设备上走）的入库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
            if (null == wrkMast) {
                News.infoNoLog(""+mark+" - 1"+" - 4"+" - 查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
                News.infoNoLog("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
//                log.error("查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
                continue;
            }
            // 获取库位信息
            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
            if (locMast == null) {
                News.error(""+mark+" - 1"+" - 5"+" - 查询库存无数据--库位号{}", wrkMast.getLocNo());
                News.error("" + mark + " - 1" + " - 5" + " - 查询库存无数据--库位号{}", wrkMast.getLocNo());
                continue;
            }
            if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
                News.error(""+mark+" - 1"+" - 6"+" - 入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                News.error("" + mark + " - 1" + " - 6" + " - 入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                continue;
            }

@@ -744,29 +721,29 @@

            // 双深库位且浅库位有货，则需先对浅库位进行库位移转
            if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) {
                News.warnNoLog(""+mark+" - 1"+" - 8"+" - 双深库位且浅库位有货，则需先对浅库位进行库位移转 : 开始执行 任务号={}",wrkMast.getWrkNo());
                News.warnNoLog("" + mark + " - 1" + " - 8" + " - 双深库位且浅库位有货，则需先对浅库位进行库位移转 : 开始执行 任务号={}", wrkMast.getWrkNo());
                String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo());
                LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                    News.warnNoLog(""+mark+" - 1"+" - 9"+" - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位状态={}",shallowLoc.getLocSts());
                    News.warnNoLog("" + mark + " - 1" + " - 9" + " - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位状态={}", shallowLoc.getLocSts());
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                    if (null == waitWrkMast) {
                        News.error(""+mark+" - 1"+" - 10"+" - {}库位异常，未检索到相应工作档！", shallowLocNo);
                        News.error("" + mark + " - 1" + " - 10" + " - {}库位异常，未检索到相应工作档！", shallowLocNo);
                    } else {
                        waitWrkMast.setIoPri(15D);
                        waitWrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                            News.error(""+mark+" - 1"+" - 11"+" - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                            News.error("" + mark + " - 1" + " - 11" + " - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                        }
                        continue;
                    }

                } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                    News.warnNoLog(""+mark+" - 1"+" - 12"+" - // F、D  库位状态={}",shallowLoc.getLocSts());
                    News.warnNoLog("" + mark + " - 1" + " - 12" + " - // F、D  库位状态={}", shallowLoc.getLocSts());
                    // 此标记避免多次执行移库任务
                    if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())) {
                        if (moveLocForDeepLoc(slave, shallowLoc,mark)){
                        if (moveLocForDeepLoc(slave, shallowLoc, mark)) {
                            wrkMast.setUpdMk("Y");
                            wrkMast.setIoPri(14D);
                            wrkMastMapper.updateById(wrkMast);
@@ -781,17 +758,17 @@
                    }
                    continue;
                } else if (shallowLoc.getLocSts().equals("Q")) {
                    News.warnNoLog(""+mark+" - 1"+" - 13"+" - // Q  库位状态={}",shallowLoc.getLocSts());
                    News.warnNoLog("" + mark + " - 1" + " - 13" + " - // Q  库位状态={}", shallowLoc.getLocSts());
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                    if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                        News.infoNoLog(""+mark+" - 1"+" - 14"+" - // F、D  工作状态(判断条件为==4)={}",waitWrkMast.getWrkSts());
                        News.infoNoLog("" + mark + " - 1" + " - 14" + " - // F、D  工作状态(判断条件为==4)={}", waitWrkMast.getWrkSts());
                        continue;
                    }
                }
            }
            News.warnNoLog(""+mark+" - 1"+" - 15"+" - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}",wrkMast.getWrkNo().shortValue()
                    ,crnStn.getRow().shortValue(),crnStn.getBay().shortValue(),crnStn.getLev().shortValue()
                    ,locMast.getRow1().shortValue(),locMast.getBay1().shortValue(),locMast.getLev1().shortValue());
            News.warnNoLog("" + mark + " - 1" + " - 15" + " - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}", wrkMast.getWrkNo().shortValue()
                    , crnStn.getRow().shortValue(), crnStn.getBay().shortValue(), crnStn.getLev().shortValue()
                    , locMast.getRow1().shortValue(), locMast.getBay1().shortValue(), locMast.getLev1().shortValue());

            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
@@ -806,7 +783,7 @@
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                News.error(""+mark+" - 1"+" - 16"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                News.error("" + mark + " - 1" + " - 16" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {

//                long startTime = System.currentTimeMillis();
@@ -827,19 +804,19 @@
                wrkMast.setCrnStrTime(now);
                wrkMast.setModiTime(now);
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    News.error(""+mark+" - 1"+" - 17"+" - 修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    News.error("" + mark + " - 1" + " - 17" + " - 修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                }
            }
        }
        News.infoNoLog(""+mark+" - 1"+" - 0"+" - 堆垛机入出库作业下发 ： 入库执行完毕");
        News.infoNoLog("" + mark + " - 1" + " - 0" + " - 堆垛机入出库作业下发 ： 入库执行完毕");
    }

    /**
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public synchronized void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol,Integer mark) {
        News.warnNoLog(""+mark+" - 2"+" - 0"+" - 堆垛机入出库作业下发：执行出库");
    public synchronized void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol, Integer mark) {
        News.warnNoLog("" + mark + " - 2" + " - 0" + " - 堆垛机入出库作业下发：执行出库");
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
//            WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
@@ -850,20 +827,20 @@
                }
                // 工作档状态判断
                if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null) {
                    News.error(""+mark+" - 2"+" - 1"+" - 查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                    News.error("" + mark + " - 2" + " - 1" + " - 查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                    continue;
                }
                // 获取源库位信息
                LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
                if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("P")) {
                    News.error(""+mark+" - 2"+" - 2"+" - 出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                    News.error("" + mark + " - 2" + " - 2" + " - 出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                    continue;
                }
                // 获取堆垛机出库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    News.infoNoLog(""+mark+" - 2"+" - 3"+" - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol="+staProtocol);
                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol);
                    break;
//                    continue;
                } else {
@@ -880,7 +857,7 @@
                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    News.error("" + mark + " - 2" + " - 5" + " - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
@@ -897,12 +874,12 @@

                    // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                    if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
                        News.warnNoLog(""+mark+" - 2"+" - 6"+" - 双深库位且浅库位有货，则需先对浅库位进行库位移转 : 开始执行 任务号={}",wrkMast.getWrkNo());
                        News.warnNoLog("" + mark + " - 2" + " - 6" + " - 双深库位且浅库位有货，则需先对浅库位进行库位移转 : 开始执行 任务号={}", wrkMast.getWrkNo());
                        String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            News.warnNoLog(""+mark+" - 2"+" - 7"+" - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位状态={}",shallowLoc.getLocSts());
                            News.warnNoLog("" + mark + " - 2" + " - 7" + " - // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！库位状态={}", shallowLoc.getLocSts());
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null == waitWrkMast) {
                                News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
@@ -911,7 +888,7 @@
                                    waitWrkMast.setIoPri(15D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        News.error(""+mark+" - 2"+" - 8"+" - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                        News.error("" + mark + " - 2" + " - 8" + " - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    continue;
                                } else {
@@ -919,7 +896,7 @@
                                }
                            }
                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            News.warnNoLog(""+mark+" - 2"+" - 9"+" - // F、D  库位状态={}",shallowLoc.getLocSts());
                            News.warnNoLog("" + mark + " - 2" + " - 9" + " - // F、D  库位状态={}", shallowLoc.getLocSts());
//                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            //2022-08-16 modify,不根据updmk标记移库任务(容易被取消导致堵塞)，查询工作档是否存在任务
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
@@ -927,7 +904,7 @@
//                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
//                                || Cools.isEmpty(waitWrkMast)) {
                            if (Cools.isEmpty(waitWrkMast)) {
                                if (moveLocForDeepLoc(slave, shallowLoc,mark)){
                                if (moveLocForDeepLoc(slave, shallowLoc, mark)) {
                                    wrkMast.setUpdMk("Y");
//                                    wrkMast.setIoPri(14D);
                                    wrkMastMapper.updateById(wrkMast);
@@ -940,10 +917,10 @@
                            News.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo);
                            continue;
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                            News.warnNoLog(""+mark+" - 2"+" - 10"+" - // Q、S  库位状态={}",shallowLoc.getLocSts());
                            News.warnNoLog("" + mark + " - 2" + " - 10" + " - // Q、S  库位状态={}", shallowLoc.getLocSts());
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                            if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                                News.infoNoLog(""+mark+" - 2"+" - 11"+" - // F、D  工作状态(判断条件为==4)={}",waitWrkMast.getWrkSts());
                                News.infoNoLog("" + mark + " - 2" + " - 11" + " - // F、D  工作状态(判断条件为==4)={}", waitWrkMast.getWrkSts());
                                continue;
                            }
                        }
@@ -955,9 +932,9 @@
//                        return;
                    }

                    News.warnNoLog(""+mark+" - 2"+" - 12"+" - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}",wrkMast.getWrkNo().shortValue()
                            ,sourceSta.getRow1().shortValue(),sourceSta.getBay1().shortValue(),sourceSta.getLev1().shortValue()
                            ,crnStn.getRow().shortValue(),crnStn.getBay().shortValue(),crnStn.getLev().shortValue());
                    News.warnNoLog("" + mark + " - 2" + " - 12" + " - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}", wrkMast.getWrkNo().shortValue()
                            , sourceSta.getRow1().shortValue(), sourceSta.getBay1().shortValue(), sourceSta.getLev1().shortValue()
                            , crnStn.getRow().shortValue(), crnStn.getBay().shortValue(), crnStn.getLev().shortValue());

                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
@@ -972,7 +949,7 @@
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        News.error(""+mark+" - 2"+" - 13"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
@@ -980,14 +957,14 @@
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            News.error(""+mark+" - 2"+" - 14"+" - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        break;
                    }
                }
            }
        }
        News.infoNoLog(""+mark+" - 2"+" - 0"+" - 堆垛机入出库作业下发 ： 出库执行完毕");
        News.infoNoLog("" + mark + " - 2" + " - 0" + " - 堆垛机入出库作业下发 ： 出库执行完毕");
    }

//    /**
@@ -1110,17 +1087,17 @@
    /**
     * 库位移转
     */
    public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol,Integer mark) {
    public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol, Integer mark) {
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
            return;
        }
        News.warnNoLog(""+mark+" - 3"+" - 0"+" - 堆垛机入出库作业下发：执行库位移转");
        News.warnNoLog("" + mark + " - 3" + " - 0" + " - 堆垛机入出库作业下发：执行库位移转");
        // 获取源库位信息
        LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceSta) {
            News.error(""+mark+" - 3"+" - 1"+" - 工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            News.error("" + mark + " - 3" + " - 1" + " - 工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
@@ -1130,7 +1107,7 @@
        // 获取目标库位信息
        LocMast sta = locMastService.selectById(wrkMast.getLocNo());
        if (null == sta) {
            News.error(""+mark+" - 3"+" - 2"+" - 工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            News.error("" + mark + " - 3" + " - 2" + " - 工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
@@ -1149,9 +1126,9 @@
            return;
        }

        News.warnNoLog(""+mark+" - 3"+" - 3"+" - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}",wrkMast.getWrkNo().shortValue()
                ,sourceSta.getRow1().shortValue(),sourceSta.getBay1().shortValue(),sourceSta.getLev1().shortValue()
                ,sta.getRow1().shortValue(),sta.getBay1().shortValue(),sta.getLev1().shortValue());
        News.warnNoLog("" + mark + " - 3" + " - 3" + " - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}", wrkMast.getWrkNo().shortValue()
                , sourceSta.getRow1().shortValue(), sourceSta.getBay1().shortValue(), sourceSta.getLev1().shortValue()
                , sta.getRow1().shortValue(), sta.getBay1().shortValue(), sta.getLev1().shortValue());

        // 命令下发区 --------------------------------------------------------------------------
        CrnCommand crnCommand = new CrnCommand();
@@ -1166,7 +1143,7 @@
        crnCommand.setDestinationPosY(sta.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(sta.getLev1().shortValue());     // 目标库位层
        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            News.error(""+mark+" - 3"+" - 4"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            News.error("" + mark + " - 3" + " - 4" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
        } else {
            // 修改工作档状态 11.生成出库ID => 12.吊车出库中
            Date now = new Date();
@@ -1174,36 +1151,36 @@
            wrkMast.setCrnStrTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                News.error(""+mark+" - 3"+" - 5"+" - 【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                News.error("" + mark + " - 3" + " - 5" + " - 【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
            }
        }
        News.infoNoLog(""+mark+" - 3"+" - 0"+" - 堆垛机入出库作业下发：库位移转完成");
        News.infoNoLog("" + mark + " - 3" + " - 0" + " - 堆垛机入出库作业下发：库位移转完成");

    }

    /**
     * 库位移转
     */
    public synchronized void locToLoc111(CrnSlave slave, CrnProtocol crnProtocol,Integer mark) {
    public synchronized void locToLoc111(CrnSlave slave, CrnProtocol crnProtocol, Integer mark) {
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove111(slave.getId());
        if (null == wrkMast) {
            return;
        }
        News.warnNoLog(""+mark+" - 3"+" - 0"+" - 堆垛机入出库作业下发：执行库位移转");
        News.warnNoLog("" + mark + " - 3" + " - 0" + " - 堆垛机入出库作业下发：执行库位移转");
        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            News.error(""+mark+" - 3"+" - 1"+" - 工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            News.error("" + mark + " - 3" + " - 1" + " - 工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
        if (!sourceLoc.getLocSts().equals("R")) {
            News.error(""+mark+" - 3"+" - 11"+" - 工作档库位移转失败，原因：源库位状态不为R！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            News.error("" + mark + " - 3" + " - 11" + " - 工作档库位移转失败，原因：源库位状态不为R！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }

        if(wrkMast.getIoType() != 111) {
        if (wrkMast.getIoType() != 111) {
            // 获取目标库位信息
            LocMast loc = locMastService.selectById(wrkMast.getLocNo());
            if (null == loc) {
@@ -1212,7 +1189,7 @@
            }
            // 源库位  库位状态判断
            if (!loc.getLocSts().equals("S")) {
                News.error(""+mark+" - 3"+" - 21"+" - 工作档库位移转失败，原因：目标库位状态不为R！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
                News.error("" + mark + " - 3" + " - 21" + " - 工作档库位移转失败，原因：目标库位状态不为R！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
                return;
            }
        }
@@ -1232,9 +1209,9 @@
            return;
        }

        News.warnNoLog(""+mark+" - 3"+" - 3"+" - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}",wrkMast.getWrkNo().shortValue()
                ,sourceLoc.getRow1().shortValue(),sourceLoc.getBay1().shortValue(),sourceLoc.getLev1().shortValue()
                ,sourceLoc.getRow1().shortValue(),sourceLoc.getBay1().shortValue(),sourceLoc.getLev1().shortValue());
        News.warnNoLog("" + mark + " - 3" + " - 3" + " - 命令下发 : 工作号={},源排={},源列={},源层={},目标排={},目标列={},目标层={}", wrkMast.getWrkNo().shortValue()
                , sourceLoc.getRow1().shortValue(), sourceLoc.getBay1().shortValue(), sourceLoc.getLev1().shortValue()
                , sourceLoc.getRow1().shortValue(), sourceLoc.getBay1().shortValue(), sourceLoc.getLev1().shortValue());

        // 命令下发区 --------------------------------------------------------------------------
        CrnCommand crnCommand = new CrnCommand();
@@ -1249,7 +1226,7 @@
        crnCommand.setDestinationPosY(sourceLoc.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(sourceLoc.getLev1().shortValue());     // 目标库位层
        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            News.error(""+mark+" - 3"+" - 4"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            News.error("" + mark + " - 3" + " - 4" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
        } else {
            // 修改工作档状态 11.生成出库ID => 12.吊车出库中
            Date now = new Date();
@@ -1257,10 +1234,10 @@
            wrkMast.setCrnStrTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                News.error(""+mark+" - 3"+" - 5"+" - 【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                News.error("" + mark + " - 3" + " - 5" + " - 【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
            }
        }
        News.infoNoLog(""+mark+" - 3"+" - 0"+" - 堆垛机入出库作业下发：库位移转完成");
        News.infoNoLog("" + mark + " - 3" + " - 0" + " - 堆垛机入出库作业下发：库位移转完成");

    }

@@ -1278,7 +1255,7 @@
            }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行对工作档的完成操作");
                News.warnNoLog("" + mark + " - 0" + " - 开始执行对工作档的完成操作");
                if (crnProtocol.getTaskNo() == 9999) {
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
@@ -1286,11 +1263,11 @@
                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
                    if (wrkMast == null) {
                        News.error(""+mark+" - 1"+" - 堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        News.error("" + mark + " - 1" + " - 堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    }
                    // 入库 + 库位转移  ==> 4.入库完成
                    if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && (wrkMast.getIoType() == 11 || wrkMast.getIoType()==111))) {
                    if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && (wrkMast.getIoType() == 11 || wrkMast.getIoType() == 111))) {
                        wrkMast.setWrkSts(4L);
                    } else {
                        continue;
@@ -1301,14 +1278,14 @@
                    // 修改成功后复位堆垛机
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        // 堆垛机复位
                        News.warnNoLog(""+mark+" - 2"+" - 修改成功后复位堆垛机 : 堆垛机号={}",crnThread.getCrnProtocol().getCrnNo());
                        News.warnNoLog("" + mark + " - 2" + " - 修改成功后复位堆垛机 : 堆垛机号={}", crnThread.getCrnProtocol().getCrnNo());
                        crnThread.setResetFlag(true);
                    }
                }

            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 对工作档的完成操作执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 对工作档的完成操作执行完成");
    }

    /**
@@ -1331,7 +1308,7 @@
                    BasErrLog latest = basErrLogService.findLatestByTaskNo(crn.getId(), crnProtocol.getTaskNo().intValue());
                    // 有异常
                    if (latest == null) {
                        News.warnNoLog(""+mark+" - 1"+" - 开始执行：堆垛机异常信息记录 ： 有任务，有异常");
                        News.warnNoLog("" + mark + " - 1" + " - 开始执行：堆垛机异常信息记录 ： 有任务，有异常");
                        if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) {
                            WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
                            if (wrkMast == null) {
@@ -1363,7 +1340,7 @@
                                    "任务中异常"    // 备注
                            );
                            if (!basErrLogService.insert(basErrLog)) {
                                News.error(""+mark+" - 2"+" - 堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                                News.error("" + mark + " - 2" + " - 堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                            }
                        }
                    } else {
@@ -1373,7 +1350,7 @@
                            latest.setUpdateTime(now);
                            latest.setStatus(2);
                            if (!basErrLogService.updateById(latest)) {
                                News.error(""+mark+" - 3"+" - 堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                                News.error("" + mark + " - 3" + " - 堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                            }
                        }
                    }
@@ -1382,7 +1359,7 @@
                    BasErrLog latest = basErrLogService.findLatest(crn.getId());
                    // 有异常
                    if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) {
                        News.warnNoLog(""+mark+" - 4"+" - 开始执行：堆垛机异常信息记录 ： 无任务，有异常");
                        News.warnNoLog("" + mark + " - 4" + " - 开始执行：堆垛机异常信息记录 ： 无任务，有异常");
                        // 记录新异常
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
@@ -1411,7 +1388,7 @@
                                    "无任务异常"    // 备注
                            );
                            if (!basErrLogService.insert(basErrLog)) {
                                News.error(""+mark+" - 5"+" - 堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                                News.error("" + mark + " - 5" + " - 堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                            }
                        }
                        // 无异常
@@ -1422,7 +1399,7 @@
                            latest.setUpdateTime(now);
                            latest.setStatus(2);
                            if (!basErrLogService.updateById(latest)) {
                                News.error(""+mark+" - 6"+" - 堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                                News.error("" + mark + " - 6" + " - 堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                            }
                        }
                    }
@@ -1430,7 +1407,7 @@
            }

        }
        News.infoNoLog(""+mark+" - 0"+" - 堆垛机异常信息记录执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 堆垛机异常信息记录执行完成");
    }


@@ -1454,11 +1431,11 @@
                }

                LedThread ledThread = null;
                if (!Cools.isEmpty(emptyInSta.getLed()))  {
                if (!Cools.isEmpty(emptyInSta.getLed())) {
                    ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());
                }

                if (!staProtocol.isLoading()){
                if (!staProtocol.isLoading()) {
                    continue;
                }

@@ -1467,8 +1444,8 @@
                        && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk()
                        && (staProtocol.getWorkNo() > 9990 && staProtocol.getWorkNo() <= 9999)
                        && staProtocol.isPakMk()&& staProtocol.getStamp()>=2) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行：空栈板初始化入库,叉车入库站放货");
                        && staProtocol.isPakMk()) {
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行：空栈板初始化入库,叉车入库站放货");

                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
@@ -1493,7 +1470,7 @@
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.errorNoLog(""+mark+" - 1"+" - 更新plc站点信息失败");
                                News.errorNoLog("" + mark + " - 1" + " - 更新plc站点信息失败");
                                throw new CoolException("更新plc站点信息失败");
                            }

@@ -1512,12 +1489,12 @@
//                                ledThread.errorReset();
                            }
                        } else {
                            staProtocol.setWorkNo((short)9992);
                            staProtocol.setWorkNo((short) 9992);
                            staProtocol.setStaNo(emptyInSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.errorNoLog(""+mark+" - 2"+" - 更新plc站点信息失败");
                                News.errorNoLog("" + mark + " - 2" + " - 更新plc站点信息失败");
                                throw new CoolException("更新plc站点信息失败");
                            }

@@ -1527,7 +1504,7 @@
                                    MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
                                }
                            }
                            News.error(""+mark+" - 3"+" - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            News.error("" + mark + " - 3" + " - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
@@ -1535,13 +1512,13 @@
                    }

                } else {
                    News.errorNoLog(""+mark+" - 4"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isAutoing()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk());
                    News.errorNoLog("" + mark + " - 4" + " - 站点信息不符合入库条件！！！" + " 自动信号：" + staProtocol.isAutoing() + "、可入信号：" + staProtocol.isInEnable()
                            + "、空板信号：" + staProtocol.isEmptyMk() + "、工作号：" + staProtocol.getWorkNo()
                            + "、锁定标记" + staProtocol.isPakMk());
                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 空栈板初始化入库,叉车入库站放货执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 空栈板初始化入库,叉车入库站放货执行完成");
    }

    /**
@@ -1570,7 +1547,7 @@
                if (null == wrkMast) {
                    continue;
                }
                News.warnNoLog(""+mark+" - 0"+" - 开始执行:出库  ===>> 工作档信息写入led显示器");
                News.warnNoLog("" + mark + " - 0" + " - 开始执行:出库  ===>> 工作档信息写入led显示器");
                wrkMasts.add(wrkMast);
                // 组装命令
                LedCommand ledCommand = new LedCommand();
@@ -1610,7 +1587,7 @@
                        ledCommand.setTitle("并板入库");
                        break;
                    default:
                        News.error(""+mark+" - 1"+" - 任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        News.error("" + mark + " - 1" + " - 任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        break;
                }
                ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
@@ -1619,21 +1596,21 @@
//                ledCommand.setSourceStaNo(wrkMast.getSourceStaNo());
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    try{
                        if (wrkMast.getIoType()>100){
                            for (WrkDetl wrkDetl : wrkDetls){
                    try {
                        if (wrkMast.getIoType() > 100) {
                            for (WrkDetl wrkDetl : wrkDetls) {
                                LocDetl locDetl = locDetlService.selectMatnrSpecs(wrkDetl.getMatnr(), wrkDetl.getSpecs(), wrkMast.getSourceLocNo());
                                wrkDetl.setWeight(locDetl.getAnfme());
                            }
                        }else {
                            for (WrkDetl wrkDetl : wrkDetls){
                        } else {
                            for (WrkDetl wrkDetl : wrkDetls) {
                                wrkDetl.setWeight(wrkDetl.getAnfme());
                            }
                        }
                    }catch (Exception e){
                        log.error("工作档案明细输入电视机失败1：异常信息==》"+e);
                    } catch (Exception e) {
                        log.error("工作档案明细输入电视机失败1：异常信息==》" + e);
                    }
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(),wrkDetl.getWeight(),wrkDetl.getSpecs(),wrkDetl.getSku())));
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(), wrkDetl.getWeight(), wrkDetl.getSpecs(), wrkDetl.getSku())));
                }
                commands.add(ledCommand);
            }
@@ -1644,31 +1621,13 @@
            if (CollectionUtils.equals(ledThread.getWorkNos(), workNos)) {
                continue;
            }
//             命令下发 -------------------------------------------------------------------------------
//            if (!commands.isEmpty()) {
//                if (led.getId() < 7) {
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(3, commands))) {
//                        News.error(""+mark+" - 2"+" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                        continue;
//                    } else {
//                        ledThread.setLedMk(false);
//                    }
//                } else {
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
//                        News.error(""+mark+" - 3"+" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                        continue;
//                    } else {
//                        ledThread.setLedMk(false);
//                    }
//                }
//
//            }

            // 命令下发 -------------------------------------------------------------------------------
            if (!commands.isEmpty()) {
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(3, commands))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    continue;
                }else {
                } else {
                    ledThread.setLedMk(false);
                }
            }
@@ -1679,7 +1638,7 @@
                    wrkMast.setOveMk("Y");
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        News.errorNoLog(""+mark+" - 4"+" - 更新工作档失败");
                        News.errorNoLog("" + mark + " - 4" + " - 更新工作档失败");
                        throw new CoolException("更新工作档失败");
                    }
                }
@@ -1693,7 +1652,7 @@
            }

        }
        News.infoNoLog(""+mark+" - 0"+" - 出库  ===>> 工作档信息写入led显示器执行完成");
        News.infoNoLog("" + mark + " - 0" + " - 出库  ===>> 工作档信息写入led显示器执行完成");
    }

    /**
@@ -1701,7 +1660,7 @@
     */
    public synchronized void ledReset(Integer mark) {

        News.warnNoLog(""+mark+" - 0"+" - 开始执行:其他  ===>> LED显示器复位，显示默认信息");
        News.warnNoLog("" + mark + " - 0" + " - 开始执行:其他  ===>> LED显示器复位，显示默认信息");
        for (LedSlave led : slaveProperties.getLed()) {

            // 获取输送线plc线程
@@ -1725,13 +1684,13 @@
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(4, new ArrayList<>()))) {
                    News.error(""+mark+" - 1"+" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    News.error("" + mark + " - 1" + " - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                } else {

                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - 执行完成：其他  ===>> LED显示器复位，显示默认信息");
        News.infoNoLog("" + mark + " - 0" + " - 执行完成：其他  ===>> LED显示器复位，显示默认信息");
    }

    /**
@@ -1814,10 +1773,10 @@
     * 因双深库位阻塞，对浅库位进行移转（立即执行版)
     * tip：同步
     */
    private synchronized boolean moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc,Integer mark) {
    private synchronized boolean moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc, Integer mark) {

        try {
            News.warnNoLog(""+mark+"moveLocForDeepLoc"+" - 0"+" - 开始执行:因双深库位阻塞，对浅库位进行移转（立即执行版)");
            News.warnNoLog("" + mark + "moveLocForDeepLoc" + " - 0" + " - 开始执行:因双深库位阻塞，对浅库位进行移转（立即执行版)");
            List<Integer> rows = locMastService.queryDistinctRow(crn.getId());
            LocMast loc = null;
            for (Integer row : rows) {
@@ -1859,7 +1818,7 @@
            }

            if (null == loc) {
                News.error(""+mark+"moveLocForDeepLoc"+" - 1"+" - 双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                News.error("" + mark + "moveLocForDeepLoc" + " - 1" + " - 双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                return false;
//                throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
            } else {
@@ -1887,7 +1846,7 @@
                    wrkMast.setModiTime(new Date());
                    int res = wrkMastMapper.insert(wrkMast);
                    if (res == 0) {
                        News.errorNoLog(""+mark+"moveLocForDeepLoc"+" - 2"+" - 保存工作档失败");
                        News.errorNoLog("" + mark + "moveLocForDeepLoc" + " - 2" + " - 保存工作档失败");
//                        throw new CoolException("保存工作档失败");
                        return true;
                    }
@@ -1904,7 +1863,7 @@
                            wrkDetl.setAppeTime(new Date());
                            wrkDetl.setModiTime(new Date());
                            if (!wrkDetlService.insert(wrkDetl)) {
                                News.errorNoLog(""+mark+"moveLocForDeepLoc"+" - 3"+" - 保存工作档明细失败");
                                News.errorNoLog("" + mark + "moveLocForDeepLoc" + " - 3" + " - 保存工作档明细失败");
//                                throw new CoolException("保存工作档明细失败");
                                return true;
                            }
@@ -1915,12 +1874,12 @@
                        shallowLoc.setLocSts("R"); // R.出库预约
                        shallowLoc.setModiTime(new Date());
                        if (!locMastService.updateById(shallowLoc)) {
                            News.errorNoLog(""+mark+"moveLocForDeepLoc"+" - 4"+" - 更新源库位状态失败");
                            News.errorNoLog("" + mark + "moveLocForDeepLoc" + " - 4" + " - 更新源库位状态失败");
//                            throw new CoolException("更新源库位状态失败");
                            return true;
                        }
                    } else {
                        News.errorNoLog(""+mark+"moveLocForDeepLoc"+" - 5"+" - 源库位出库失败");
                        News.errorNoLog("" + mark + "moveLocForDeepLoc" + " - 5" + " - 源库位出库失败");
//                        throw new CoolException("源库位出库失败");
                        return true;
                    }
@@ -1929,23 +1888,23 @@
                        loc.setLocSts("S"); // S.入库预约
                        loc.setModiTime(new Date());
                        if (!locMastService.updateById(loc)) {
                            News.errorNoLog(""+mark+"moveLocForDeepLoc"+" - 6"+" - 更新目标库位状态失败");
                            News.errorNoLog("" + mark + "moveLocForDeepLoc" + " - 6" + " - 更新目标库位状态失败");
//                            throw new CoolException("更新目标库位状态失败");
                            return true;
                        }
                    } else {
                        News.errorNoLog(""+mark+"moveLocForDeepLoc"+" - 7"+" - 移转失败");
                        News.errorNoLog("" + mark + "moveLocForDeepLoc" + " - 7" + " - 移转失败");
//                        throw new CoolException("移转失败");
                        return true;
                    }
                } catch (Exception e){
                    News.error(""+mark+"moveLocForDeepLoc"+" - 8"+" - 双深库位阻塞，对浅库位进行移转失败", e);
                } catch (Exception e) {
                    News.error("" + mark + "moveLocForDeepLoc" + " - 8" + " - 双深库位阻塞，对浅库位进行移转失败", e);
                }
            }


        } catch (Exception e) {
            News.error(""+mark+"moveLocForDeepLoc"+" - 8"+" - 双深库位阻塞，对浅库位进行移转失败", e);
            News.error("" + mark + "moveLocForDeepLoc" + " - 8" + " - 双深库位阻塞，对浅库位进行移转失败", e);
//            e.printStackTrace();
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
@@ -2151,18 +2110,18 @@
    public synchronized void outOfDevp(Integer mark) {

        List<WrkMast> wrkMasts = wrkMastMapper.selectPick();
        if (wrkMasts.size()!=0){
            News.warnNoLog(""+mark+" - 0"+" - 开始执行outOfDevp");
        if (wrkMasts.size() != 0) {
            News.warnNoLog("" + mark + " - 0" + " - 开始执行outOfDevp");
        }
        for (WrkMast wrkMast : wrkMasts) {
            if (basDevpService.selectCount(new EntityWrapper<BasDevp>().eq("wrk_no", wrkMast.getWrkNo())) == 0) {
                wrkMast.setCtnNo("Y");
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    News.error(""+mark+" - 1"+" - 修改{}工作档失败，ctn_no", wrkMast.getWrkNo());
                    News.error("" + mark + " - 1" + " - 修改{}工作档失败，ctn_no", wrkMast.getWrkNo());
                }
            }
        }
        News.infoNoLog(""+mark+" - 0"+" - outOfDevp执行完成");
        News.infoNoLog("" + mark + " - 0" + " - outOfDevp执行完成");
    }


@@ -2196,7 +2155,7 @@
                    JSONObject data = (JSONObject) jsonObject.get("data");
                    News.info((String) data.get("msg"));
                } else {
                    News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1","", response);
                    News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1", "", response);
                }
            } catch (Exception e) {
                e.printStackTrace();
@@ -2242,4 +2201,58 @@
            }
        }
    }

    public short wrkNo = 9999;


    private boolean shape(DevpSlave devp, StaProtocol staProtocol, DevpThread devpThread, DevpSlave.Sta sta) throws InterruptedException {
        // 尺寸检测异常
        boolean back = false;
        String errMsg = "";
        if (staProtocol.isFrontErr()) {
            errMsg = "前超限";
            back = true;
        }
        if (!back && staProtocol.isBackErr()) {
            errMsg = "后超限";
            back = true;
        }
        if (!back && staProtocol.isHighErr()) {
            errMsg = "高超限";
            back = true;
        }
        if (!back && staProtocol.isLeftErr()) {
            errMsg = "左超限";
            back = true;
        }
        if (!back && staProtocol.isRightErr()) {
            errMsg = "右超限";
            back = true;
        }
        if (!back && staProtocol.isWeightErr()) {
            errMsg = "超重";
            back = true;
        }
        if (!back && staProtocol.isBarcodeErr()) {
            errMsg = "扫码失败";
            back = true;
        }
        // 退回
        if (back) {
            if (!staProtocol.isLoading()) {
                return true;
            }
            if (!staProtocol.isPakMk()) {
                return true;
            }
            staProtocol.setWorkNo(wrkNo);
            News.warn("{}入库回退：{}，任务号：{}", sta.getStaNo(), errMsg, wrkNo);
            staProtocol.setStaNo(sta.getBackSta().shortValue());
            devpThread.setPakMk(staProtocol.getSiteId(), false);
            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
            MessageQueue.offer(SlaveType.Led, sta.getLed(), new Task(5, errMsg));
            Thread.sleep(500);
        }
        return true;
    }
}

 src/main/java/com/zy/core/MainProcess.java

@@ -44,9 +44,7 @@
                    }

                    // 演示
                    mainService.crnDemoOfLocMove1();
                    // 入出库模式切换函数
//                    mainService.ioConvert();
//                    mainService.crnDemoOfLocMove1();
                    // 入库  ===>> 入库站到堆垛机站，根据条码扫描生成入库工作档
                    mainService.generateStoreWrkFile(1); // 组托
                    mainService.generateStoreWrkFile0(2); // WMS入库
@@ -72,6 +70,9 @@

                    mainService.outOfDevp(11);

                    // 堆垛机回原点
                    //mainService.crnRebackHp();

                    //空托盘自动出库
//                    mainService.autoEmptyOut();
//                    //空托盘自动入库

 src/main/java/com/zy/core/model/protocol/StaProtocol.java

@@ -56,8 +56,30 @@
    private String nearbySta;
    private String barcode;

    //lfd入库印记  当stamp>=2时才入库
    private Integer stamp = 0;
    // 外形检测 ------------------------------------------------------------------------

    // 前超限
    private boolean frontErr = false;

    // 后超限
    private boolean backErr = false;

    // 高超限
    private boolean highErr = false;

    // 左超限
    private boolean leftErr = false;

    // 右超限
    private boolean rightErr = false;

    // 超重
    private boolean weightErr = false;

    // 扫码失败
    private boolean barcodeErr = false;

    private boolean weight = false;

    public BasDevp toSqlModel(){
        BasDevp basDevp = new BasDevp();

 src/main/java/com/zy/core/thread/SiemensDevpThread.java

@@ -43,15 +43,16 @@
    private SiemensS7Net siemensS7Net;
    private Map<Integer, StaProtocol> station = new ConcurrentHashMap<>();
    private short heartBeatVal = 1;
//    public static final ArrayList<Integer> staNos = new ArrayList<Integer>() {{
    //    public static final ArrayList<Integer> staNos = new ArrayList<Integer>() {{
//
//    }};
    public static final ArrayList<Integer> staNos1 = new ArrayList<Integer>() {{
        add(101);add(102);
        add(101);
        add(102);
    }};


    private Integer count=0;
    private Integer count = 0;

    /**
     * 条码数量
@@ -67,7 +68,7 @@
     * 4.出库模式
     */
    public IoModeType ioModeOf2F = IoModeType.NONE;
//    public IoModeType ioMode = IoModeType.NONE;
    //    public IoModeType ioMode = IoModeType.NONE;
    public IoModeType ioModeOf4F = IoModeType.NONE;
//    public IoModeType ioMode = IoModeType.NONE;

@@ -102,7 +103,7 @@
                        break;
                    // 写数据 ID+目标站
                    case 2:
                        write((StaProtocol)task.getData());
                        write((StaProtocol) task.getData());
                        break;
                    default:
                        break;
@@ -116,13 +117,14 @@

        }
    }

    /**
     * 初始化站点状态
     */
    private void initSite() {
        count ++;
        count++;
        ArrayList<Integer> staNos = getStaNo();
        if(count > 77) {
        if (count > 77) {
            // 站点编号
            for (Integer siteId : staNos) {
                StaProtocol staProtocol = station.get(siteId);
@@ -154,13 +156,13 @@
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
        if (connect.IsSuccess) {
            result = true;
            OutputQueue.DEVP.offer(MessageFormat.format( "【{0}】输送线plc连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.info("SiemensDevp"+" - 1"+" - 输送线plc连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线plc连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.info("SiemensDevp" + " - 1" + " - 输送线plc连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format( "【{0}】输送线plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.error("SiemensDevp"+" - 2"+" - 输送线plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.error("SiemensDevp" + " - 2" + " - 输送线plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        }
        siemensS7Net.ConnectClose();
        initSite();
@@ -175,8 +177,8 @@
//        updateIoMode();
        ArrayList<Integer> staNos = getStaNo();
        int staNoSize = staNos.size();
        OperateResultExOne<byte[]> result = siemensS7Net.Read("DB100.0", (short) (staNoSize*2));
        OperateResultExOne<byte[]> result4 = siemensS7Net.Read("DB101.0", (short) (staNoSize*2));
        OperateResultExOne<byte[]> result = siemensS7Net.Read("DB100.0", (short) (staNoSize * 2));
        OperateResultExOne<byte[]> result4 = siemensS7Net.Read("DB101.0", (short) (staNoSize * 2));
        if (result.IsSuccess && result4.IsSuccess) {
            for (int i = 0; i < staNoSize; i++) {
                Integer siteId = staNos.get(i); // 站点编号
@@ -187,38 +189,38 @@
                    station.put(siteId, staProtocol);
                }
                staProtocol.setSiteId(siteId);
                staProtocol.setWorkNo(siemensS7Net.getByteTransform().TransInt16(result.Content, i*2));     // 工作号
                staProtocol.setWorkNo(siemensS7Net.getByteTransform().TransInt16(result.Content, i * 2));     // 工作号

                staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result4.Content, i*2));   // 目标站
                staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result4.Content, i * 2));   // 目标站
            }
        }
//        Thread.sleep(200);
//        OperateResultExOne<byte[]> result0 = siemensS7Net.Read("DB101.0", (short) 186);
//        if (result0.IsSuccess) {
//            for (int i = 0; i < 93; i++) {
//                Integer siteId = staNos.get(i); // 站点编号
//                StaProtocol staProtocol = station.get(siteId);
//                if (null == staProtocol) {
//                    staProtocol = new StaProtocol();
//                    staProtocol.setSiteId(siteId);
//                    station.put(siteId, staProtocol);
//                }
//                staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result0.Content, i*2));   // 目标站
//            }
//        }

        //条码扫描器
        Thread.sleep(200);
        OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB100.200",(short)(barcodeSize*8));
        OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB100.200", (short) (barcodeSize * 8));
        if (result2.IsSuccess) {
            for (int i = 0; i < barcodeSize; i++) {
                String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,i*8,8, "UTF-8");
                String barcode = siemensS7Net.getByteTransform().TransString(result2.Content, i * 8, 8, "UTF-8");
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, i + 1);
                if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)){
                if (!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
//                            && !Cools.isEmpty(barcode) && Cools.isEmpty(barcodeThread.getBarcode())) {
                    barcodeThread.setBarcode(barcode);
                }
            }
        }

        //外形检测
        OperateResultExOne<byte[]> resultErr = siemensS7Net.Read("DB101.42", (short) 8);
        if (resultErr.IsSuccess) {
            boolean[] status = siemensS7Net.getByteTransform().TransBool(resultErr.Content, 0, 1);
            StaProtocol staProtocol = station.get(304);
            staProtocol.setFrontErr(status[0]);
            staProtocol.setBackErr(status[1]);
            staProtocol.setHighErr(status[2]);
            staProtocol.setLeftErr(status[3]);
            staProtocol.setRightErr(status[4]);
            staProtocol.setWeightErr(status[5]);
            staProtocol.setBarcodeErr(status[6]);
        }

        Thread.sleep(200);
@@ -226,7 +228,7 @@
        if (result1.IsSuccess) {
            for (int i = 0; i < staNoSize; i++) {
                Integer siteId = staNos.get(i); // 站点编号
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result1.Content, i*2, 1);
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result1.Content, i * 2, 1);
                StaProtocol staProtocol = station.get(siteId);
                staProtocol.setAutoing(status[0]);  // 自动
                staProtocol.setLoading(status[1]);  // 有物
@@ -240,21 +242,12 @@
                if (!staProtocol.isPakMk() && !staProtocol.isLoading()) {
                    staProtocol.setPakMk(true);
                }

                if (staProtocol.getStamp()>=2 && !staProtocol.isLoading()){
                    staProtocol.setStamp(0);
                }else if (staProtocol.getStamp()<2 && staProtocol.isLoading()){
                    //lfd入库印记  当stamp>=2时才入库
                    staProtocol.setStamp(staProtocol.getStamp()+1);
                }

            }
        }

        if (result.IsSuccess && result1.IsSuccess) {

            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));

            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功", DateUtils.convert(new Date()), slave.getId()));
            // 根据实时信息更新数据库
            try {
                List<BasDevp> basDevps = new ArrayList<>();
@@ -271,7 +264,7 @@
                initSite();
                e.printStackTrace();
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】更新数据库数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
                News.error("SiemensDevp"+" - 3"+" - 更新数据库数据失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
                News.error("SiemensDevp" + " - 3" + " - 更新数据库数据失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
            }

        } else {
@@ -298,17 +291,17 @@
        //任务下发次数
        int writeCount = 0;
        do {
            write = siemensS7Net.Write("DB100." + index*2, staProtocol.getWorkNo());    // 工作号
            write = siemensS7Net.Write("DB100." + index * 2, staProtocol.getWorkNo());    // 工作号
            Thread.sleep(500);
            write1 = siemensS7Net.Write("DB101." + index*2, staProtocol.getStaNo());    // 目标站
            if(write.IsSuccess || write1.IsSuccess){
            write1 = siemensS7Net.Write("DB101." + index * 2, staProtocol.getStaNo());    // 目标站
            if (write.IsSuccess || write1.IsSuccess) {
                Thread.sleep(200);
                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*2, (short) 2);
                OperateResultExOne<byte[]> readResult1 = siemensS7Net.Read("DB101." + index*2, (short) 2);
                if(readResult.IsSuccess && readResult1.IsSuccess){
                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index * 2, (short) 2);
                OperateResultExOne<byte[]> readResult1 = siemensS7Net.Read("DB101." + index * 2, (short) 2);
                if (readResult.IsSuccess && readResult1.IsSuccess) {
                    short workNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
                    short staNo = siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 0);
                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
                    if (staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)) {
                        //任务命令写入成功
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        break;
@@ -320,23 +313,22 @@
                    writeCount++;
                    log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                }
            }
            else {
            } else {
                writeCount++;
                log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
            }
        }while (writeCount<5);
        } while (writeCount < 5);

        if (!write.IsSuccess || !write1.IsSuccess) {
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() == 0) {
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            News.error("SiemensDevp"+" - 4"+" - 写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
            News.error("SiemensDevp" + " - 4" + " - 写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
            News.info("SiemensDevp"+" - 5"+" - 输送线命令下发 [id:{}] >>>>> 命令下发： {}",  slave.getId(), JSON.toJSON(staProtocol));
            News.info("SiemensDevp" + " - 5" + " - 输送线命令下发 [id:{}] >>>>> 命令下发： {}", slave.getId(), JSON.toJSON(staProtocol));
        }
    }

@@ -345,7 +337,7 @@
        if (this.ioModeOf2F != IoModeType.NONE) {
            if (!siemensS7Net.Write("DB100.180", this.ioModeOf2F.id).IsSuccess) {
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线2F入出库模式失败。输送线plc编号={1}", slave.getId()));
                News.error("SiemensDevp"+" - 6"+" - 写入输送线2F入出库模式失败。输送线plc编号={}", slave.getId());
                News.error("SiemensDevp" + " - 6" + " - 写入输送线2F入出库模式失败。输送线plc编号={}", slave.getId());
            }
        }
    }
@@ -353,7 +345,7 @@
    /**
     * 心跳
     */
    private void heartbeat(){
    private void heartbeat() {
        if (heartBeatVal == 1) {
            heartBeatVal = 2;
        } else {
@@ -361,7 +353,7 @@
        }
        OperateResult write = siemensS7Net.Write("DB100.50", heartBeatVal);
        if (!write.IsSuccess) {
            News.error("SiemensDevp"+" - 7"+" - 输送线plc编号={} 心跳失败", slave.getId());
            News.error("SiemensDevp" + " - 7" + " - 输送线plc编号={} 心跳失败", slave.getId());
        }
    }

@@ -384,14 +376,14 @@
    public static void main(String[] args) {
        System.out.println(staNos1.indexOf(129));
        System.out.println(staNos1.size());
        for (int i = 0; i<staNos1.size(); i++) {
        for (int i = 0; i < staNos1.size(); i++) {
//            System.out.println(i*2);
//            System.out.println(i*2 + 200);
//            System.out.println(i);
        }
        int index = staNos1.indexOf(128);
        System.out.println(index*2);
        System.out.println(index*2 + 200);
        System.out.println(index * 2);
        System.out.println(index * 2 + 200);
    }

}

 src/main/resources/application-wcs.yml

New file
@@ -0,0 +1,77 @@
# 下位机配置
wcs-slave:
  inSta: 102,104,110,115
  outSta: 101,103,111,116
  # 双深
  doubleDeep: true
  # 双深库位排号
  doubleLocs: 31,34
  # 一个堆垛机负责的货架排数
  groupCount: 4
  # 堆垛机1
  crn[0]:
    id: 1
    ip: 10.10.11.7
    port: 6000
    rack: 0
    slot: 0
    # 偏移量，当堆垛机站点列号=1时，偏移量=2
    offset: 2
    demo: false
    # 堆垛机入库站点
    crnInStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
      row: 33
      bay: 1
      lev: 1
    # 堆垛机出库站点
    crnOutStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
      row: 33
      bay: 1
      lev: 1
  # 输送线1
  devp[0]:
    id: 1
    ip: 10.10.11.10
    port: 102
    rack: 0
    slot: 0
    # 入库口1
    inSta[0]:
      staNo: 102
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 101
      led: ${wcs-slave.led[0].id}
    # 空板入库口1
    emptyInSta[0]:
      staNo: 102
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 101
      led: ${wcs-slave.led[0].id}
    # 拣料入库口1
    pickSta[0]:
      staNo: 102
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 101
      led: ${wcs-slave.led[0].id}

    # 出库口1
    outSta[0]:
      staNo: 102
      led: ${wcs-slave.led[0].id}
  # 条码扫描仪1
  barcode[0]:
    id: 1
    ip: 10.10.10.121
    port: 51236
    # LED1
  led[0]:
    id: 1
    ip: 10.10.11.210
    port: 5005
    devpPlcId: ${wcs-slave.devp[0].id}
    # 入库站和出库站
    staArr: 102,101

 src/main/resources/application.yml

@@ -4,6 +4,8 @@
    context-path: /@pom.build.finalName@

spring:
  profiles:
    active: wcs
  application:
    name: @pom.build.finalName@
  datasource:
@@ -35,80 +37,3 @@

wms:
  url: 127.0.0.1:8080/wms

# 下位机配置
wcs-slave:
  inSta: 102,104,110,115
  outSta: 101,103,111,116
  # 双深
  doubleDeep: true
  # 双深库位排号
  doubleLocs: 31,34
  # 一个堆垛机负责的货架排数
  groupCount: 4
  # 堆垛机1
  crn[0]:
    id: 1
    ip: 10.10.11.7
    port: 6000
    rack: 0
    slot: 0
    # 偏移量，当堆垛机站点列号=1时，偏移量=2
    offset: 2
    demo: false
    # 堆垛机入库站点
    crnInStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
      row: 33
      bay: 1
      lev: 1
    # 堆垛机出库站点
    crnOutStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
      row: 33
      bay: 1
      lev: 1
  # 输送线1
  devp[0]:
    id: 1
    ip: 10.10.11.10
    port: 102
    rack: 0
    slot: 0
    # 入库口1
    inSta[0]:
      staNo: 102
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 101
      led: ${wcs-slave.led[0].id}
    # 空板入库口1
    emptyInSta[0]:
      staNo: 102
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 101
      led: ${wcs-slave.led[0].id}
    # 拣料入库口1
    pickSta[0]:
      staNo: 102
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 101
      led: ${wcs-slave.led[0].id}

    # 出库口1
    outSta[0]:
      staNo: 102
      led: ${wcs-slave.led[0].id}
  # 条码扫描仪1
  barcode[0]:
    id: 1
    ip: 10.10.10.121
    port: 51236
   # LED1
  led[0]:
    id: 1
    ip: 10.10.11.210
    port: 5005
    devpPlcId: ${wcs-slave.devp[0].id}
    staArr: 102

			@@ -44,9 +44,7 @@
			}

			// 演示
			mainService.crnDemoOfLocMove1();
			// 入出库模式切换函数
			// mainService.ioConvert();
			// mainService.crnDemoOfLocMove1();
			// 入库 ===>> 入库站到堆垛机站，根据条码扫描生成入库工作档
			mainService.generateStoreWrkFile(1); // 组托
			mainService.generateStoreWrkFile0(2); // WMS入库
			@@ -72,6 +70,9 @@

			mainService.outOfDevp(11);

			// 堆垛机回原点
			//mainService.crnRebackHp();

			//空托盘自动出库
			// mainService.autoEmptyOut();
			// //空托盘自动入库

			@@ -56,8 +56,30 @@
			private String nearbySta;
			private String barcode;

			//lfd入库印记当stamp>=2时才入库
			private Integer stamp = 0;
			// 外形检测 ------------------------------------------------------------------------

			// 前超限
			private boolean frontErr = false;

			// 后超限
			private boolean backErr = false;

			// 高超限
			private boolean highErr = false;

			// 左超限
			private boolean leftErr = false;

			// 右超限
			private boolean rightErr = false;

			// 超重
			private boolean weightErr = false;

			// 扫码失败
			private boolean barcodeErr = false;

			private boolean weight = false;

			public BasDevp toSqlModel(){
			BasDevp basDevp = new BasDevp();

			@@ -43,15 +43,16 @@
			private SiemensS7Net siemensS7Net;
			private Map<Integer, StaProtocol> station = new ConcurrentHashMap<>();
			private short heartBeatVal = 1;
			// public static final ArrayList<Integer> staNos = new ArrayList<Integer>() {{
			// public static final ArrayList<Integer> staNos = new ArrayList<Integer>() {{
			//
			// }};
			public static final ArrayList<Integer> staNos1 = new ArrayList<Integer>() {{
			add(101);add(102);
			add(101);
			add(102);
			}};


			private Integer count=0;
			private Integer count = 0;

			/**
			* 条码数量
			@@ -67,7 +68,7 @@
			* 4.出库模式
			*/
			public IoModeType ioModeOf2F = IoModeType.NONE;
			// public IoModeType ioMode = IoModeType.NONE;
			// public IoModeType ioMode = IoModeType.NONE;
			public IoModeType ioModeOf4F = IoModeType.NONE;
			// public IoModeType ioMode = IoModeType.NONE;

			@@ -102,7 +103,7 @@
			break;
			// 写数据 ID+目标站
			case 2:
			write((StaProtocol)task.getData());
			write((StaProtocol) task.getData());
			break;
			default:
			break;
			@@ -116,13 +117,14 @@

			}
			}

			/**
			* 初始化站点状态
			*/
			private void initSite() {
			count ++;
			count++;
			ArrayList<Integer> staNos = getStaNo();
			if(count > 77) {
			if (count > 77) {
			// 站点编号
			for (Integer siteId : staNos) {
			StaProtocol staProtocol = station.get(siteId);
			@@ -154,13 +156,13 @@
			siemensS7Net.setRack(slave.getRack().byteValue());
			siemensS7Net.setSlot(slave.getSlot().byteValue());
			OperateResult connect = siemensS7Net.ConnectServer();
			if(connect.IsSuccess){
			if (connect.IsSuccess) {
			result = true;
			OutputQueue.DEVP.offer(MessageFormat.format( "【{0}】输送线plc连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
			News.info("SiemensDevp"+" - 1"+" - 输送线plc连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线plc连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
			News.info("SiemensDevp" + " - 1" + " - 输送线plc连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
			} else {
			OutputQueue.DEVP.offer(MessageFormat.format( "【{0}】输送线plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
			News.error("SiemensDevp"+" - 2"+" - 输送线plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
			News.error("SiemensDevp" + " - 2" + " - 输送线plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
			}
			siemensS7Net.ConnectClose();
			initSite();
			@@ -175,8 +177,8 @@
			// updateIoMode();
			ArrayList<Integer> staNos = getStaNo();
			int staNoSize = staNos.size();
			OperateResultExOne<byte[]> result = siemensS7Net.Read("DB100.0", (short) (staNoSize*2));
			OperateResultExOne<byte[]> result4 = siemensS7Net.Read("DB101.0", (short) (staNoSize*2));
			OperateResultExOne<byte[]> result = siemensS7Net.Read("DB100.0", (short) (staNoSize * 2));
			OperateResultExOne<byte[]> result4 = siemensS7Net.Read("DB101.0", (short) (staNoSize * 2));
			if (result.IsSuccess && result4.IsSuccess) {
			for (int i = 0; i < staNoSize; i++) {
			Integer siteId = staNos.get(i); // 站点编号
			@@ -187,38 +189,38 @@
			station.put(siteId, staProtocol);
			}
			staProtocol.setSiteId(siteId);
			staProtocol.setWorkNo(siemensS7Net.getByteTransform().TransInt16(result.Content, i*2)); // 工作号
			staProtocol.setWorkNo(siemensS7Net.getByteTransform().TransInt16(result.Content, i * 2)); // 工作号

			staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result4.Content, i*2)); // 目标站
			staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result4.Content, i * 2)); // 目标站
			}
			}
			// Thread.sleep(200);
			// OperateResultExOne<byte[]> result0 = siemensS7Net.Read("DB101.0", (short) 186);
			// if (result0.IsSuccess) {
			// for (int i = 0; i < 93; i++) {
			// Integer siteId = staNos.get(i); // 站点编号
			// StaProtocol staProtocol = station.get(siteId);
			// if (null == staProtocol) {
			// staProtocol = new StaProtocol();
			// staProtocol.setSiteId(siteId);
			// station.put(siteId, staProtocol);
			// }
			// staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result0.Content, i*2)); // 目标站
			// }
			// }

			//条码扫描器
			Thread.sleep(200);
			OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB100.200",(short)(barcodeSize*8));
			OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB100.200", (short) (barcodeSize * 8));
			if (result2.IsSuccess) {
			for (int i = 0; i < barcodeSize; i++) {
			String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,i*8,8, "UTF-8");
			String barcode = siemensS7Net.getByteTransform().TransString(result2.Content, i * 8, 8, "UTF-8");
			BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, i + 1);
			if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)){
			if (!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
			// && !Cools.isEmpty(barcode) && Cools.isEmpty(barcodeThread.getBarcode())) {
			barcodeThread.setBarcode(barcode);
			}
			}
			}

			//外形检测
			OperateResultExOne<byte[]> resultErr = siemensS7Net.Read("DB101.42", (short) 8);
			if (resultErr.IsSuccess) {
			boolean[] status = siemensS7Net.getByteTransform().TransBool(resultErr.Content, 0, 1);
			StaProtocol staProtocol = station.get(304);
			staProtocol.setFrontErr(status[0]);
			staProtocol.setBackErr(status[1]);
			staProtocol.setHighErr(status[2]);
			staProtocol.setLeftErr(status[3]);
			staProtocol.setRightErr(status[4]);
			staProtocol.setWeightErr(status[5]);
			staProtocol.setBarcodeErr(status[6]);
			}

			Thread.sleep(200);
			@@ -226,7 +228,7 @@
			if (result1.IsSuccess) {
			for (int i = 0; i < staNoSize; i++) {
			Integer siteId = staNos.get(i); // 站点编号
			boolean[] status = siemensS7Net.getByteTransform().TransBool(result1.Content, i*2, 1);
			boolean[] status = siemensS7Net.getByteTransform().TransBool(result1.Content, i * 2, 1);
			StaProtocol staProtocol = station.get(siteId);
			staProtocol.setAutoing(status[0]); // 自动
			staProtocol.setLoading(status[1]); // 有物
			@@ -240,21 +242,12 @@
			if (!staProtocol.isPakMk() && !staProtocol.isLoading()) {
			staProtocol.setPakMk(true);
			}

			if (staProtocol.getStamp()>=2 && !staProtocol.isLoading()){
			staProtocol.setStamp(0);
			}else if (staProtocol.getStamp()<2 && staProtocol.isLoading()){
			//lfd入库印记当stamp>=2时才入库
			staProtocol.setStamp(staProtocol.getStamp()+1);
			}

			}
			}

			if (result.IsSuccess && result1.IsSuccess) {

			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));

			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功", DateUtils.convert(new Date()), slave.getId()));
			// 根据实时信息更新数据库
			try {
			List<BasDevp> basDevps = new ArrayList<>();
			@@ -271,7 +264,7 @@
			initSite();
			e.printStackTrace();
			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】更新数据库数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
			News.error("SiemensDevp"+" - 3"+" - 更新数据库数据失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
			News.error("SiemensDevp" + " - 3" + " - 更新数据库数据失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
			}

			} else {
			@@ -298,17 +291,17 @@
			//任务下发次数
			int writeCount = 0;
			do {
			write = siemensS7Net.Write("DB100." + index*2, staProtocol.getWorkNo()); // 工作号
			write = siemensS7Net.Write("DB100." + index * 2, staProtocol.getWorkNo()); // 工作号
			Thread.sleep(500);
			write1 = siemensS7Net.Write("DB101." + index*2, staProtocol.getStaNo()); // 目标站
			if(write.IsSuccess \|\| write1.IsSuccess){
			write1 = siemensS7Net.Write("DB101." + index * 2, staProtocol.getStaNo()); // 目标站
			if (write.IsSuccess \|\| write1.IsSuccess) {
			Thread.sleep(200);
			OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*2, (short) 2);
			OperateResultExOne<byte[]> readResult1 = siemensS7Net.Read("DB101." + index*2, (short) 2);
			if(readResult.IsSuccess && readResult1.IsSuccess){
			OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index * 2, (short) 2);
			OperateResultExOne<byte[]> readResult1 = siemensS7Net.Read("DB101." + index * 2, (short) 2);
			if (readResult.IsSuccess && readResult1.IsSuccess) {
			short workNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
			short staNo = siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 0);
			if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
			if (staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)) {
			//任务命令写入成功
			log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
			break;
			@@ -320,23 +313,22 @@
			writeCount++;
			log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
			}
			}
			else {
			} else {
			writeCount++;
			log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
			}
			}while (writeCount<5);
			} while (writeCount < 5);

			if (!write.IsSuccess \|\| !write1.IsSuccess) {
			staProtocol = station.get(staProtocol.getSiteId());
			if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
			if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() == 0) {
			staProtocol.setPakMk(true);
			}
			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
			News.error("SiemensDevp"+" - 4"+" - 写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
			News.error("SiemensDevp" + " - 4" + " - 写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
			} else {
			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】输送线命令下发 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
			News.info("SiemensDevp"+" - 5"+" - 输送线命令下发 [id:{}] >>>>> 命令下发： {}", slave.getId(), JSON.toJSON(staProtocol));
			News.info("SiemensDevp" + " - 5" + " - 输送线命令下发 [id:{}] >>>>> 命令下发： {}", slave.getId(), JSON.toJSON(staProtocol));
			}
			}

			@@ -345,7 +337,7 @@
			if (this.ioModeOf2F != IoModeType.NONE) {
			if (!siemensS7Net.Write("DB100.180", this.ioModeOf2F.id).IsSuccess) {
			OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线2F入出库模式失败。输送线plc编号={1}", slave.getId()));
			News.error("SiemensDevp"+" - 6"+" - 写入输送线2F入出库模式失败。输送线plc编号={}", slave.getId());
			News.error("SiemensDevp" + " - 6" + " - 写入输送线2F入出库模式失败。输送线plc编号={}", slave.getId());
			}
			}
			}
			@@ -353,7 +345,7 @@
			/**
			* 心跳
			*/
			private void heartbeat(){
			private void heartbeat() {
			if (heartBeatVal == 1) {
			heartBeatVal = 2;
			} else {
			@@ -361,7 +353,7 @@
			}
			OperateResult write = siemensS7Net.Write("DB100.50", heartBeatVal);
			if (!write.IsSuccess) {
			News.error("SiemensDevp"+" - 7"+" - 输送线plc编号={} 心跳失败", slave.getId());
			News.error("SiemensDevp" + " - 7" + " - 输送线plc编号={} 心跳失败", slave.getId());
			}
			}

			@@ -384,14 +376,14 @@
			public static void main(String[] args) {
			System.out.println(staNos1.indexOf(129));
			System.out.println(staNos1.size());
			for (int i = 0; i<staNos1.size(); i++) {
			for (int i = 0; i < staNos1.size(); i++) {
			// System.out.println(i*2);
			// System.out.println(i*2 + 200);
			// System.out.println(i);
			}
			int index = staNos1.indexOf(128);
			System.out.println(index*2);
			System.out.println(index*2 + 200);
			System.out.println(index * 2);
			System.out.println(index * 2 + 200);
			}

			}

New file
			@@ -0,0 +1,77 @@
			# 下位机配置
			wcs-slave:
			inSta: 102,104,110,115
			outSta: 101,103,111,116
			# 双深
			doubleDeep: true
			# 双深库位排号
			doubleLocs: 31,34
			# 一个堆垛机负责的货架排数
			groupCount: 4
			# 堆垛机1
			crn[0]:
			id: 1
			ip: 10.10.11.7
			port: 6000
			rack: 0
			slot: 0
			# 偏移量，当堆垛机站点列号=1时，偏移量=2
			offset: 2
			demo: false
			# 堆垛机入库站点
			crnInStn[0]:
			devpPlcId: ${wcs-slave.devp[0].id}
			staNo: 102
			row: 33
			bay: 1
			lev: 1
			# 堆垛机出库站点
			crnOutStn[0]:
			devpPlcId: ${wcs-slave.devp[0].id}
			staNo: 102
			row: 33
			bay: 1
			lev: 1
			# 输送线1
			devp[0]:
			id: 1
			ip: 10.10.11.10
			port: 102
			rack: 0
			slot: 0
			# 入库口1
			inSta[0]:
			staNo: 102
			barcode: ${wcs-slave.barcode[0].id}
			backSta: 101
			led: ${wcs-slave.led[0].id}
			# 空板入库口1
			emptyInSta[0]:
			staNo: 102
			barcode: ${wcs-slave.barcode[0].id}
			backSta: 101
			led: ${wcs-slave.led[0].id}
			# 拣料入库口1
			pickSta[0]:
			staNo: 102
			barcode: ${wcs-slave.barcode[0].id}
			backSta: 101
			led: ${wcs-slave.led[0].id}

			# 出库口1
			outSta[0]:
			staNo: 102
			led: ${wcs-slave.led[0].id}
			# 条码扫描仪1
			barcode[0]:
			id: 1
			ip: 10.10.10.121
			port: 51236
			# LED1
			led[0]:
			id: 1
			ip: 10.10.11.210
			port: 5005
			devpPlcId: ${wcs-slave.devp[0].id}
			# 入库站和出库站
			staArr: 102,101

			@@ -4,6 +4,8 @@
			context-path: /@pom.build.finalName@

			spring:
			profiles:
			active: wcs
			application:
			name: @pom.build.finalName@
			datasource:
			@@ -35,80 +37,3 @@

			wms:
			url: 127.0.0.1:8080/wms

			# 下位机配置
			wcs-slave:
			inSta: 102,104,110,115
			outSta: 101,103,111,116
			# 双深
			doubleDeep: true
			# 双深库位排号
			doubleLocs: 31,34
			# 一个堆垛机负责的货架排数
			groupCount: 4
			# 堆垛机1
			crn[0]:
			id: 1
			ip: 10.10.11.7
			port: 6000
			rack: 0
			slot: 0
			# 偏移量，当堆垛机站点列号=1时，偏移量=2
			offset: 2
			demo: false
			# 堆垛机入库站点
			crnInStn[0]:
			devpPlcId: ${wcs-slave.devp[0].id}
			staNo: 102
			row: 33
			bay: 1
			lev: 1
			# 堆垛机出库站点
			crnOutStn[0]:
			devpPlcId: ${wcs-slave.devp[0].id}
			staNo: 102
			row: 33
			bay: 1
			lev: 1
			# 输送线1
			devp[0]:
			id: 1
			ip: 10.10.11.10
			port: 102
			rack: 0
			slot: 0
			# 入库口1
			inSta[0]:
			staNo: 102
			barcode: ${wcs-slave.barcode[0].id}
			backSta: 101
			led: ${wcs-slave.led[0].id}
			# 空板入库口1
			emptyInSta[0]:
			staNo: 102
			barcode: ${wcs-slave.barcode[0].id}
			backSta: 101
			led: ${wcs-slave.led[0].id}
			# 拣料入库口1
			pickSta[0]:
			staNo: 102
			barcode: ${wcs-slave.barcode[0].id}
			backSta: 101
			led: ${wcs-slave.led[0].id}

			# 出库口1
			outSta[0]:
			staNo: 102
			led: ${wcs-slave.led[0].id}
			# 条码扫描仪1
			barcode[0]:
			id: 1
			ip: 10.10.10.121
			port: 51236
			# LED1
			led[0]:
			id: 1
			ip: 10.10.11.210
			port: 5005
			devpPlcId: ${wcs-slave.devp[0].id}
			staArr: 102