初始化

dubin

2026-01-20 f165afcbf9e8837ea49b5c46d47c8b1b3bfb4a03

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

@@ -39,6 +39,7 @@
import com.zy.core.thread.LedThread;
import com.zy.core.thread.RgvThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -139,7 +140,20 @@
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "";
                Integer outCount=wrkMastService.selectOutCount();
                // 检测是否有出库任务 如果有出库任务 入库就停止
                List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no",1).in("wrk_sts", 11, 12));
                // 检测104站（堆垛机出库站 入库站）是否有物 如果有物没有工作号 入库停止 如果有物工作号是出库 入库停止 如果有物工作号是入库 可以入库 如果有物工作号不存在 入库停止
                StaProtocol staProtocol104 = devpThread.getStation().get(104);
                if (staProtocol104 == null){
                    log.error("104站点信息未获取");
                    continue;
                }
                //104站有物 有工作号 判断这个任务的类型
                WrkMast wrkMast1 = new WrkMast();
                if (staProtocol104.isLoading() && staProtocol104.getWorkNo() != 0){
                    wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol104.getWorkNo()));
                }

                if (staProtocol.isFrontErr()) {
                    errMsg = "前超限";
                    back = true;
@@ -168,8 +182,26 @@
                    errMsg = "扫码失败";
                    back = true;
                }
                if (!back && outCount > 0) {
                    errMsg = "当前为出库时段,入库暂停";
                // 判断托盘码格式
                if (!back &&(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode))){
                    errMsg = "托盘码格式有误--->" + barcode;
                    back = true;
                }
                if (!back && (!barcode.startsWith("5") &&  !barcode.startsWith("6") &&  !barcode.startsWith("7") && !barcode.startsWith("8"))) {
                    errMsg = "托盘码格式有误--->" + barcode;
                    back = true;
                }
                if (!back && !wrkMastList.isEmpty()) {
                    errMsg = "有出库任务,入库停止";
                    back = true;
                }if (!back && staProtocol104.isLoading() && staProtocol104.getWorkNo() == 0 && (barcode.startsWith("6") || barcode.startsWith("5"))){
                    errMsg = "104站有物但是无工作号,请检查";
                    back = true;
                }if (!back && (!Cools.isEmpty(wrkMast1) && wrkMast1.getIoType() > 100)){
                    errMsg = "有出库任务,入库停止";
                    back = true;
                }if (!back && (staProtocol104.isLoading() && Cools.isEmpty(wrkMast1)) && (barcode.startsWith("5") || barcode.startsWith("6"))){
                    errMsg = "104站有物但是对应的工作号无工作档,请检查";
                    back = true;
                }

@@ -189,7 +221,7 @@
                    staProtocol.setStaNo(inSta.getBackSta().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    log.error("输送线下发（超限全板退回）：" + wrkNo + "," + inSta.getBackSta());
                    log.error("输送线下发（全板退回）：" + wrkNo + "," + inSta.getBackSta());
                    break;//超限托盘退回不生成工作档
                }

@@ -239,7 +271,7 @@
                        param.setBarcode(barcode);
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        param.setLocType1(locTypeDto.getLocType1()); // 高低
                        param.setWeight(staProtocol.getWeight());
                        String response = new HttpHandler.Builder()
                                .setTimeout(30,TimeUnit.SECONDS)
@@ -388,10 +420,23 @@
//                    News.error("站点信息未获得");
                    continue;
                }
                // 检测是否有出库任务 如果有出库任务 入库就停止
                List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", 1).in("wrk_sts", 11, 12));
                // 检测104站（堆垛机出库站 入库站）是否有物 如果有物没有工作号 入库停止 如果有物工作号是出库 入库停止 如果有物工作号是入库 可以入库 如果有物工作号不存在 入库停止
                StaProtocol staProtocol104 = devpThread.getStation().get(104);
                if (staProtocol104 == null){
                    log.error("104站点信息未获取");
                    continue;
                }
                //104站有物 有工作号 判断这个任务的类型
                WrkMast wrkMast1 = new WrkMast();
                if (staProtocol104.isLoading() && staProtocol104.getWorkNo() != 0){
                    wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol104.getWorkNo()));
                }
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "";
                if (!back && staProtocol.isFrontErr()) {
                if (staProtocol.isFrontErr()) {
                    errMsg = "前超限";
                    back = true;
                }
@@ -419,11 +464,33 @@
                    errMsg = "扫码失败";
                    back = true;
                }
                // 判断托盘码格式
                if (!back &&(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode))){
                    errMsg = "托盘码格式有误--->" + barcode;
                    back = true;
                }
                if (!back && (!barcode.startsWith("5") &&  !barcode.startsWith("6") &&  !barcode.startsWith("7") && !barcode.startsWith("8"))) {
                    errMsg = "托盘码格式有误--->" + barcode;
                    back = true;
                }
                if (!back && !wrkMastList.isEmpty()) {
                    errMsg = "有出库任务,入库停止";
                    back = true;
                }if (!back && staProtocol104.isLoading() && staProtocol104.getWorkNo() == 0 && (barcode.startsWith("6") || barcode.startsWith("5"))){
                    errMsg = "104站有物但是无工作号,请检查";
                    back = true;
                }if (!back && (!Cools.isEmpty(wrkMast1) && wrkMast1.getIoType() > 100)){
                    errMsg = "有出库任务,入库停止";
                    back = true;
                }if (!back && (staProtocol104.isLoading() && Cools.isEmpty(wrkMast1)) && (barcode.startsWith("5") || barcode.startsWith("6"))){
                    errMsg = "104站有物但是对应的工作号无工作档,请检查";
                    back = true;
                }

                // 退回
                if (back) {
                    log.info("errmsg: " + errMsg);
                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", pickSta.getStaNo(), errMsg);
                    News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", pickSta.getStaNo(), errMsg);
                    MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(5, errMsg));
                    if (!staProtocol.isLoading()) {
                        continue;
@@ -864,71 +931,82 @@
                    && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {
                News.warnNoLog("" + mark + " - 0" + " - 开始执行堆垛机入出库作业下发");
                // 如果最近一次是入库模式
//                if (crnProtocol.getLastIo().equals("I")) {
//                    if (basCrnp.getInEnable().equals("Y")) {
//                        //mark - 1 - ....
//                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
//                        crnProtocol.setLastIo("O");
//                    } else if (basCrnp.getOutEnable().equals("Y")) {
//                        //mark - 2 - ....
//                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
//                        crnProtocol.setLastIo("I");
//                    }
//                }
                // 如果最近一次是出库模式
//                else if (crnProtocol.getLastIo().equals("O")) {
//                    if (basCrnp.getOutEnable().equals("Y")) {
//                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
//                        crnProtocol.setLastIo("I");
//                    } else if (basCrnp.getInEnable().equals("Y")) {
//                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
//                        crnProtocol.setLastIo("O");
//                    }
//                }
                if (ioControl==1){
                    //入库优先  先执行入库再执行出库
                    Integer inCount=wrkMastService.selectIn();
                    if (inCount == 0 && basCrnp.getOutEnable().equals("Y")){
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                    }
                    if (basCrnp.getInEnable().equals("Y")){
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                    }
                }else if (ioControl==2){
                    //出库优先 先执行出库再执行入库
                    Integer outCount=wrkMastService.selectOut();
                    if (outCount==0 && basCrnp.getInEnable().equals("Y")){
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                    }
                    if (basCrnp.getOutEnable().equals("Y")){
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                    }
                }else if(ioControl==3){
                    //入出库交替执行 不做限制
                    // 如果最近一次是入库模式
                    if (crnProtocol.getLastIo().equals("I")) {
                        if (basCrnp.getInEnable().equals("Y")) {
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
                        //mark - 1 - ....
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                        crnProtocol.setLastIo("O");
                        } else if (basCrnp.getOutEnable().equals("Y")) {
                    } else if (basCrnp.getOutEnable().equals("Y")) {
                        //mark - 2 - ....
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                        crnProtocol.setLastIo("I");
                        }
                    }
                    // 如果最近一次是出库模式
                    else if (crnProtocol.getLastIo().equals("O")) {
                        if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                        crnProtocol.setLastIo("I");
                        } else if (basCrnp.getInEnable().equals("Y")) {
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                        crnProtocol.setLastIo("O");
                        }
                    }
                }
                // 如果最近一次是出库模式
                else if (crnProtocol.getLastIo().equals("O")) {
                    if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
                        crnProtocol.setLastIo("I");
                    } else if (basCrnp.getInEnable().equals("Y")) {
                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
                        crnProtocol.setLastIo("O");
                    }
                }







//                if (ioControl==1){
//                    //入库优先  先执行入库再执行出库
//                    Integer inCount=wrkMastService.selectIn();
//                    if (inCount == 0 && basCrnp.getOutEnable().equals("Y")){
//                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
//                    }
//                    if (basCrnp.getInEnable().equals("Y")){
//                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
//                    }
//                }else if (ioControl==2){
//                    //出库优先 先执行出库再执行入库
//                    Integer outCount=wrkMastService.selectOut();
//                    if (outCount==0 && basCrnp.getInEnable().equals("Y")){
//                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
//                    }
//                    if (basCrnp.getOutEnable().equals("Y")){
//                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
//                    }
//                }else if(ioControl==3){
//                    //入出库交替执行 不做限制
//                    // 如果最近一次是入库模式
//                    if (crnProtocol.getLastIo().equals("I")) {
//                        if (basCrnp.getInEnable().equals("Y")) {
//                        //mark - 1 - ....
//                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
//                        crnProtocol.setLastIo("O");
//                        } else if (basCrnp.getOutEnable().equals("Y")) {
//                        //mark - 2 - ....
//                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
//                        crnProtocol.setLastIo("I");
//                        }
//                    }
//                    // 如果最近一次是出库模式
//                    else if (crnProtocol.getLastIo().equals("O")) {
//                        if (basCrnp.getOutEnable().equals("Y")) {
//                        this.locToCrnStn(crn, crnProtocol, mark); //  出库
//                        crnProtocol.setLastIo("I");
//                        } else if (basCrnp.getInEnable().equals("Y")) {
//                        this.crnStnToLoc(crn, crnProtocol, mark); //  入库
//                        crnProtocol.setLastIo("O");
//                        }
//                    }
//                }
            }




            // 库位移转
            //mark - 3 - ....
            this.locToLoc(crn, crnProtocol, mark);
@@ -1218,9 +1296,27 @@
                    break;
//                    continue;
                }

                // 堆垛机出库站可出信号校验参数
                Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "OutStationVerify"));
                boolean out = false;
                if (config != null){
                    if (config.getValue().equals("Y")){
                        if (staProtocol.isOutEnable()){
                            out = true; // 校验堆垛机出库站可出信号  出库站可出
                        }else {
                            out = false; // 校验堆垛机出库站信号 出库站不可出
                        }
                    }else if (config.getValue().equals("N")){
                        out = true; // 不校验堆垛机出库站可出信号
                    }else {
                        throw new CoolException("校验堆垛机出库站可出信号参数异常 请马上检查参数对应的值");
                    }
                }

                // 判断堆垛机出库站状态
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                        && staProtocol.getWorkNo() == 0 && out) {
                    // 命令下发区 --------------------------------------------------------------------------

                    // 堆垛机控制过滤
@@ -1230,53 +1326,53 @@
                    }

                    // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                    if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
                        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());
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null == waitWrkMast) {
                                News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                if (waitWrkMast.getWrkSts() == 11) {
                                    waitWrkMast.setIoPri(15D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        News.error("" + mark + " - 2" + " - 8" + " - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    continue;
                                } else {

                                }
                            }
                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            News.warnNoLog("" + mark + " - 2" + " - 9" + " - // F、D  库位状态={}", shallowLoc.getLocSts());
//                    if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
//                        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());
//                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            //2022-08-16 modify,不根据updmk标记移库任务(容易被取消导致堵塞)，查询工作档是否存在任务
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                            // 此标记避免多次执行移库任务
//                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
//                                || Cools.isEmpty(waitWrkMast)) {
                            if (Cools.isEmpty(waitWrkMast)) {
                                wrkMast.setUpdMk("Y");
                                wrkMastMapper.updateById(wrkMast);
                                // 生成工作档,将浅库位移转到新的库位中
                                moveLocForDeepLoc(slave, shallowLoc, mark);
                            }
                            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());
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                            if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                                News.infoNoLog("" + mark + " - 2" + " - 11" + " - // F、D  工作状态(判断条件为==4)={}", waitWrkMast.getWrkSts());
                                continue;
                            }
                        }
                    }
//                            if (null == waitWrkMast) {
//                                News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
//                            } else {
//                                if (waitWrkMast.getWrkSts() == 11) {
//                                    waitWrkMast.setIoPri(15D);
//                                    waitWrkMast.setModiTime(new Date());
//                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
//                                        News.error("" + mark + " - 2" + " - 8" + " - 调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
//                                    }
//                                    continue;
//                                } else {
//
//                                }
//                            }
//                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
//                            News.warnNoLog("" + mark + " - 2" + " - 9" + " - // F、D  库位状态={}", shallowLoc.getLocSts());
////                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
//                            //2022-08-16 modify,不根据updmk标记移库任务(容易被取消导致堵塞)，查询工作档是否存在任务
//                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
//                            // 此标记避免多次执行移库任务
////                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
////                                || Cools.isEmpty(waitWrkMast)) {
//                            if (Cools.isEmpty(waitWrkMast)) {
//                                wrkMast.setUpdMk("Y");
//                                wrkMastMapper.updateById(wrkMast);
//                                // 生成工作档,将浅库位移转到新的库位中
//                                moveLocForDeepLoc(slave, shallowLoc, mark);
//                            }
//                            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());
//                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
//                            if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
//                                News.infoNoLog("" + mark + " - 2" + " - 11" + " - // F、D  工作状态(判断条件为==4)={}", waitWrkMast.getWrkSts());
//                                continue;
//                            }
//                        }
//                    }

                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
@@ -1697,6 +1793,12 @@
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历空板入库口
            for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, emptyInSta.getBarcode());
                if (barcodeThread == null) {
                    continue;
                }
                String barcode = barcodeThread.getBarcode();
                // 获取空板入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(emptyInSta.getStaNo());
@@ -1715,6 +1817,64 @@
                    continue;
                }

                // 尺寸检测异常
                boolean back = false;
                String errMsg = "";
                // 检测是否有出库任务 如果有出库任务 入库就停止
                List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no",1).in("wrk_sts", 11, 12));
                // 检测104站（堆垛机出库站 入库站）是否有物 如果有物没有工作号 入库停止 如果有物工作号是出库 入库停止 如果有物工作号是入库 可以入库 如果有物工作号不存在 入库停止
                StaProtocol staProtocol104 = devpThread.getStation().get(104);
                if (staProtocol104 == null){
                    log.error("104站点信息未获取");
                    continue;
                }
                //104站有物 有工作号 判断这个任务的类型
                WrkMast wrkMast1 = new WrkMast();
                if (staProtocol104.isLoading() && staProtocol104.getWorkNo() != 0){
                    wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol104.getWorkNo()));
                }
                // 判断托盘码格式
                if (Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)){
                    errMsg = "托盘码格式有误--->" + barcode;
                    back = true;
                }
                if (!back && (!barcode.startsWith("5") &&  !barcode.startsWith("6") &&  !barcode.startsWith("7") && !barcode.startsWith("8"))) {
                    errMsg = "托盘码格式有误--->" + barcode;
                    back = true;
                }
                if (!back && !wrkMastList.isEmpty()) {
                    errMsg = "有出库任务,入库停止";
                    back = true;
                }if (!back && staProtocol104.isLoading() && staProtocol104.getWorkNo() == 0 && (barcode.startsWith("5") || barcode.startsWith("6"))){ // 104虽然有物没有工作号 但是如果102的货物要进的是2号堆垛机 不能阻拦 （1号堆垛机条码 5xxx 6xxx   2号堆垛机 7xxx 8xxx）
                    errMsg = "104站有物但是无工作号,请检查";
                    back = true;
                }if (!back && (!Cools.isEmpty(wrkMast1) && wrkMast1.getIoType() > 100)){
                    errMsg = "有出库任务,入库停止";
                    back = true;
                }if (!back && (staProtocol104.isLoading() && Cools.isEmpty(wrkMast1)) && (barcode.startsWith("5") || barcode.startsWith("6"))){ // 同上
                    errMsg = "104站有物但是对应的工作号无工作档,请检查";
                    back = true;
                }

                // 退回
                if (back) {
                    log.info("errmsg: " + errMsg);
                    MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(3, errMsg));

                    if (!staProtocol.isLoading()) {
                        continue;
                    }
                    if (!staProtocol.isPakMk()) {
                        continue;
                    }
                    staProtocol.setWorkNo(wrkNo);//退回 工作号:10000
                    News.info("{}PLC入库回退：{}，任务号：{}", emptyInSta.getStaNo(), errMsg, wrkNo);
                    staProtocol.setStaNo(emptyInSta.getBackSta().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    log.error("输送线下发(正在执行出库任务 空板入库暂停)：" + wrkNo + "," + emptyInSta.getBackSta());
                    break;//托盘退回不生成工作档
                }
                // 站点条件判断
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
@@ -1732,6 +1892,7 @@
                        param.setIoType(10);
                        param.setSourceStaNo(emptyInSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        param.setBarcode(barcode); // 空托盘入库需要根据托盘码分库位
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")