#

TQS

2024-08-16 5430dc3eb2a8490c799298fe6578d55f1992df2b

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

@@ -3,6 +3,7 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
@@ -140,6 +141,24 @@
                            News.error("MainServiceImpl  generateStoreWrkFile"+"203为出库模式，禁止入库，退回入库口。！！！");
                            continue;
                        }
                        if ( inSta.getStaNo()==113 && devpThread.ioModeOf3F == IoModeType.PAKOUT_MODE) {
                            //有出库任务，退库到入库口
                            staProtocol.setWorkNo((short) 9999);
                            staProtocol.setStaNo((short)114);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            News.error("MainServiceImpl  generateStoreWrkFile"+"103为出库模式，禁止入库，退回入库口。！！！");
                            continue;
                        }
                        if ( inSta.getStaNo()==213 && devpThread.ioModeOf4F == IoModeType.PAKOUT_MODE) {
                            //有出库任务，退库到入库口
                            staProtocol.setWorkNo((short) 9999);
                            staProtocol.setStaNo((short)214);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            News.error("MainServiceImpl  generateStoreWrkFile"+"203为出库模式，禁止入库，退回入库口。！！！");
                            continue;
                        }
                    }

                    // 获取条码扫描仪信息
@@ -212,7 +231,7 @@
                            // plc 处理
                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            staProtocol.setStaNo(Utils.getStaNoConvertCentreOther3(dto.getStaNo(),inSta.getStaNo()).shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);

                            ledThread.errorReset();
@@ -238,6 +257,22 @@
                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                            }
                        } else if (code == 1000){
                            if (inSta.getStaNo().equals(103)){
                                staProtocol.setWorkNo((short)9996);
                                staProtocol.setStaNo((short)203);
                            }else {
                                staProtocol.setWorkNo((short)9996);
                                staProtocol.setStaNo((short)103);
                            }
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = barcode + "需要换入库站。目标站："+staProtocol.getStaNo();
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                            }
                        }
@@ -335,8 +370,6 @@
                            staNo = 103;
                            if (basDevps1.size()!=0 && basDevps2.size()!=0){
                                continue;
                            } else if (basDevps1.size()!=0){
                                staNo = 203;
                            }

                            List<WrkMast> wrkMasts1 = wrkMastMapper.selectWrkStsAndIoType((int)staNo);
@@ -359,8 +392,6 @@
                            staNo = 203;
                            if (basDevps1.size()!=0 && basDevps2.size()!=0){
                                continue;
                            } else if (basDevps2.size()!=0){
                                staNo = 103;
                            }

//                            if (basDevps2.size()!=0){
@@ -390,9 +421,17 @@
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(staNo);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    if (staProtocol.getStaNo().equals(300)){
                        BasDevp basDevp = basDevpMapper.selectByDevNo(300);
                        basDevp.setWrkNo1(wrkMast.getWrkNo());
                        basDevpService.selectById(basDevp);
                        News.info("300站去入库站任务下发，更新站点表，[任务号:{}，站点号:{}]", wrkMast.getWrkNo().shortValue(), staNo);
                    }
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    } else {
                        News.info("300站去入库站任务已下发，[任务号:{}，站点号:{}]", wrkMast.getWrkNo().shortValue(), staNo);
                    }
                }
            }
@@ -484,136 +523,231 @@
                        continue;
                    }

                    try {
                        // 访问 WMS 获取入库库位
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
                        SearchLocParam param = new SearchLocParam();
                        param.setWrkNo(wrkMast.getWrkNo());
                        param.setIoType(wrkMast.getIoType());
                        param.setSourceStaNo(pickSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
                                .setJson(JSON.toJSONString(param))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                    // 获取目标站
                    Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                            .eq("type_no", wrkMast.getIoType() - 50)
                            .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
                            .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
                    StaDesc staDesc = staDescService.selectOne(wrapper);
                    if (Cools.isEmpty(staDesc)) {
                        // led 异常显示
                        String errorMsg = "";
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
                        Integer code = jsonObject.getInteger("code");
                        if (code.equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            News.info("再入库获取新库位成功，返回数据===>>", JSON.toJSON(dto));
//                            // 获取目标站
//                            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
//                                    .eq("type_no", wrkMast.getIoType() - 50)
//                                    .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
//                                    .eq("crn_no", dto.getCrnNo()); // 堆垛机号
//                            StaDesc staDesc = staDescService.selectOne(wrapper);
//                            if (Cools.isEmpty(staDesc)) {
//                                News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
//                                continue;
//                            }
//                            // 堆垛机站点(目标站)
//                            Integer staNo = staDesc.getCrnStn();

                            // 保存工作明细档历史档
//                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
//                            throw new CoolException("保存工作明细档历史档失败");
//                        }
                            // 保存工作主档历史档
                            if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
                            }

                            String sourceLocNo = wrkMast.getSourceLocNo().trim();

                            // 更新工作档数据状态
                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                            wrkMast.setIoPri(13D);
                            wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
                            wrkMast.setCrnNo(dto.getCrnNo());
                            wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
                            wrkMast.setSourceLocNo(""); // 源库位清空
                            wrkMast.setModiTime(new Date());
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                            }
                            if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                            }

                            LocMast locMast = null;
                            // 修改目标库位状态 Q.拣料/盘点/并板再入库
                            locMast = locMastService.selectById(wrkMast.getLocNo());
                            locMast.setLocSts("Q");
                            locMast.setModiTime(new Date());
                            if (!locMastService.updateById(locMast)) {
                                throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
                            }
                            // 源库位库存明细转移到目标库位
                            if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
                                throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
                            }

                            // 修改源库位状态 O.空库位
                            LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
                            if (sourceLocMast.getLocSts().equals("P")) {
                                sourceLocMast.setLocSts("O");
                                sourceLocMast.setBarcode("");
                                sourceLocMast.setModiTime(new Date());
                                if (!locMastService.updateById(sourceLocMast)) {
                                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
                                }
                                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
                            }

                            // 条码设备处理
                            barcodeThread.setBarcode("");

                            ledThread.errorReset();

                            if(wrkMast.getIoType()>100){
                                throw new CoolException("再入库更新工作档失败，不能给PLC下发任务===>>" + wrkMast.getWrkNo());
                            }
                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                            }

                        } else if (code == 500){
                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
                                if (!Cools.isEmpty(errorMsg)) {
                                    MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
                                }
                            }
                            News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        if (wrkMast.getIoType() == 103) {
                            errorMsg = "当前拣料任务请移动至203站";
                        } else {
                            staProtocol.setWorkNo((short) 9995);
                            staProtocol.setStaNo(pickSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
//                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
                                MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
                            }
                            errorMsg = "当前拣料任务请移动至103站";
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        continue;
                        if (ledThread != null) {MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));}
                        News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                        continue;
                    }
                    // 堆垛机站点(目标站)
                    Integer staNo = staDesc.getCrnStn();

                    // 保存工作明细档历史档
                    if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                        throw new CoolException("保存工作明细档历史档失败");
                    }
                    // 保存工作主档历史档
                    if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                        throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
                    }

                    String sourceLocNo = wrkMast.getSourceLocNo().trim();

                    // 更新工作档数据状态
                    wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                    wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                    wrkMast.setIoPri(13D);
                    wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
                    wrkMast.setStaNo(staNo); // 目标站
                    wrkMast.setCrnNo(wrkMast.getCrnNo());
                    wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
                    wrkMast.setSourceLocNo(""); // 源库位清空
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                    }
                    if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
                        throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                    }

                    LocMast locMast = null;
                    // 修改目标库位状态 Q.拣料/盘点/并板再入库
                    locMast = locMastService.selectById(wrkMast.getLocNo());
                    locMast.setLocSts("Q");
                    locMast.setModiTime(new Date());
                    if (!locMastService.updateById(locMast)) {
                        throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
                    }
                    // 源库位库存明细转移到目标库位
                    if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
                        throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
                    }

                    // 修改源库位状态 O.空库位
                    LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
                    if (sourceLocMast.getLocSts().equals("P")) {
                        sourceLocMast.setLocSts("O");
                        sourceLocMast.setBarcode("");
                        sourceLocMast.setModiTime(new Date());
                        if (!locMastService.updateById(sourceLocMast)) {
                            throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
                        }
                        locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
                    }

                    // 条码设备处理
                    barcodeThread.setBarcode("");

                    if(wrkMast.getIoType()>100){
                        throw new CoolException("再入库更新工作档失败，不能给PLC下发任务===>>" + wrkMast.getWrkNo());
                    }
                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    if (staProtocol.getStaNo().equals(300)){
                        BasDevp basDevp = basDevpMapper.selectByDevNo(300);
                        basDevp.setWrkNo1(wrkMast.getWrkNo());
                        basDevpService.selectById(basDevp);
                    }
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

//                    try {
//                        // 访问 WMS 获取入库库位
//                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//                        SearchLocParam param = new SearchLocParam();
//                        param.setWrkNo(wrkMast.getWrkNo());
//                        param.setIoType(wrkMast.getIoType());
//                        param.setSourceStaNo(pickSta.getStaNo());
//                        param.setLocType1(locTypeDto.getLocType1());
//                        String response = new HttpHandler.Builder()
//                                .setUri(wmsUrl)
//                                .setPath("/rpc/pakin/loc/v1")
//                                .setJson(JSON.toJSONString(param))
//                                .build()
//                                .doPost();
//                        JSONObject jsonObject = JSON.parseObject(response);
//                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
//                        Integer code = jsonObject.getInteger("code");
//                        if (code.equals(200)) {
//                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
//                            News.info("再入库获取新库位成功，返回数据===>>", JSON.toJSON(dto));
////                            // 获取目标站
////                            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
////                                    .eq("type_no", wrkMast.getIoType() - 50)
////                                    .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
////                                    .eq("crn_no", dto.getCrnNo()); // 堆垛机号
////                            StaDesc staDesc = staDescService.selectOne(wrapper);
////                            if (Cools.isEmpty(staDesc)) {
////                                News.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
////                                continue;
////                            }
////                            // 堆垛机站点(目标站)
////                            Integer staNo = staDesc.getCrnStn();
//
//                            // 保存工作明细档历史档
////                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
////                            throw new CoolException("保存工作明细档历史档失败");
////                        }
//                            // 保存工作主档历史档
//                            if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
//                                throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
//                            }
//
//                            String sourceLocNo = wrkMast.getSourceLocNo().trim();
//
//                            // 更新工作档数据状态
//                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
//                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
//                            wrkMast.setIoPri(13D);
//                            wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
//                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
//                            wrkMast.setCrnNo(dto.getCrnNo());
//                            wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
//                            wrkMast.setSourceLocNo(""); // 源库位清空
//                            wrkMast.setModiTime(new Date());
//                            if (wrkMastMapper.updateById(wrkMast) == 0) {
//                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
//                            }
//                            if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
//                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
//                            }
//
//                            LocMast locMast = null;
//                            // 修改目标库位状态 Q.拣料/盘点/并板再入库
//                            locMast = locMastService.selectById(wrkMast.getLocNo());
//                            locMast.setLocSts("Q");
//                            locMast.setModiTime(new Date());
//                            if (!locMastService.updateById(locMast)) {
//                                throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
//                            }
//                            // 源库位库存明细转移到目标库位
//                            if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
//                                throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
//                            }
//
//                            // 修改源库位状态 O.空库位
//                            LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
//                            if (sourceLocMast.getLocSts().equals("P")) {
//                                sourceLocMast.setLocSts("O");
//                                sourceLocMast.setBarcode("");
//                                sourceLocMast.setModiTime(new Date());
//                                if (!locMastService.updateById(sourceLocMast)) {
//                                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
//                                }
//                                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
//                            }
//
//                            // 条码设备处理
//                            barcodeThread.setBarcode("");
//
//                            ledThread.errorReset();
//
//                            if(wrkMast.getIoType()>100){
//                                throw new CoolException("再入库更新工作档失败，不能给PLC下发任务===>>" + wrkMast.getWrkNo());
//                            }
//                            // 更新站点信息 且 下发plc命令
//                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
//                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
//                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                            if (!result) {
//                                News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
//                            }
//
//                        } else if (code == 500){
//                            if (ledThread != null) {
//                                String errorMsg = jsonObject.getString("msg");
//                                if (!Cools.isEmpty(errorMsg)) {
//                                    MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
//                                }
//                            }
//                            News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
//                        } else {
//                            staProtocol.setWorkNo((short) 9995);
//                            staProtocol.setStaNo(pickSta.getBackSta().shortValue());
//                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//
//                            // led 异常显示
//                            if (ledThread != null) {
//                                String errorMsg = jsonObject.getString("msg");
////                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
//                                MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
//                            }
//                        }
//
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
////                        continue;
//                    }

                }
            }
@@ -728,6 +862,67 @@
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep16(staProtocol.getSiteId());
                    if (wrkMast == null) {
                        try{
                            if (crnSlave.getId()!=2){
                                // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnSlave.getId());
                                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                                if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                                    // 移动中
                                    continue;
                                }
                                WrkMast onlyWrkNo = wrkMastMapper.selectByOnlyWrkNo(crnProtocol.getTaskNo().intValue());
                                if (Cools.isEmpty(onlyWrkNo) && (crnStn.getStaNo()  == 112 || crnStn.getStaNo() == 212)){
                                    //  判断堆垛机状态等待确认
                                    if (crnProtocol.modeType == CrnModeType.AUTO
                                            && crnProtocol.statusType == CrnStatusType.WAITING
                                            && crnProtocol.forkPosType == CrnForkPosType.HOME
                                            && crnProtocol.getBay().equals(crnStn.getBay().shortValue()) && crnProtocol.getLevel().equals(crnStn.getLev().shortValue())) {
                                        News.info("堆垛机接驳任务完成，工作号："+crnProtocol.getTaskNo()+"；执行堆垛机号："+crnSlave.getId()+"；接驳放货位："+crnStn.getStaNo()+"；接驳行走目标站："+Utils.getStaNoConvertCentreOther2(crnStn.getStaNo()));
                                        // 下发站点信息
                                        News.error("new867===>"+crnProtocol.getTaskNo());
                                        News.error("new867===>"+Utils.getStaNoConvertCentreOther2(crnStn.getStaNo()).toString());
                                        staProtocol.setWorkNo(crnProtocol.getTaskNo());
                                        staProtocol.setStaNo(Utils.getStaNoConvertCentreOther2(crnStn.getStaNo()).shortValue());
                                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                                            continue;
                                        }
                                        // 复位堆垛机
                                        crnThread.setResetFlag(true);
                                        continue;
                                    }
                                }
                                if (Cools.isEmpty(onlyWrkNo) ||
                                        ((onlyWrkNo.getStaNo()!=114 && onlyWrkNo.getStaNo()!=214 &&
                                                onlyWrkNo.getSourceStaNo()!=114 && onlyWrkNo.getSourceStaNo()!=214)
                                                &&
                                                (onlyWrkNo.getStaNo()!=113 && onlyWrkNo.getStaNo()!=213 &&
                                                        onlyWrkNo.getSourceStaNo()!=113 && onlyWrkNo.getSourceStaNo()!=213))
                                ){
                                    continue;
                                }
                                //  判断堆垛机状态等待确认
                                if (crnProtocol.modeType == CrnModeType.AUTO
                                        && crnProtocol.statusType == CrnStatusType.WAITING
                                        && crnProtocol.forkPosType == CrnForkPosType.HOME
                                        && crnProtocol.getBay().equals(crnStn.getBay().shortValue()) && crnProtocol.getLevel().equals(crnStn.getLev().shortValue())) {
                                    News.info("堆垛机接驳任务完成，工作号："+crnProtocol.getTaskNo()+"；执行堆垛机号："+crnSlave.getId()+"；接驳放货位："+crnStn.getStaNo()+"；接驳行走目标站："+Utils.getStaNoConvertCentreOther2(crnStn.getStaNo()));
                                    // 下发站点信息
                                    News.error("new867===>"+crnProtocol.getTaskNo());
                                    News.error("new867===>"+Utils.getStaNoConvertCentreOther2(crnStn.getStaNo()).toString());
                                    staProtocol.setWorkNo(crnProtocol.getTaskNo());
                                    staProtocol.setStaNo(Utils.getStaNoConvertCentreOther2(crnStn.getStaNo()).shortValue());
                                    if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                                        continue;
                                    }
                                    // 复位堆垛机
                                    crnThread.setResetFlag(true);
                                    continue;
                                }
                            }
                        } catch (Exception e){
                            News.info("堆垛机接驳任务完成，异常："+e.getMessage());
                        }
                        continue;
                    }
                    // 判断工作档条件
@@ -750,7 +945,9 @@

                        // 下发站点信息
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                        staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                        News.error("new902===>"+crnProtocol.getCrnNo().toString());
                        News.error("new902===>"+wrkMast.getStaNoConvert(crnProtocol.getCrnNo()).toString());
                        staProtocol.setStaNo(wrkMast.getStaNoConvert(crnProtocol.getCrnNo()).shortValue());
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                            continue;
                        }
@@ -853,15 +1050,91 @@

            // 获取工作状态为 2,3,4,5,6 的入库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakInStep23456(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
            if(null == wrkMast) {
//                News.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
            if(null == wrkMast){
                try{
                    WrkMast onlyWrkNo = wrkMastMapper.selectByOnlyWrkNo(staProtocol.getWorkNo().intValue());
                    if (!Cools.isEmpty(onlyWrkNo) && onlyWrkNo.getCrnNo()==2 && onlyWrkNo.getWrkSts()==2 && crnProtocol.getCrnNo()!=2 && (onlyWrkNo.getIoType()==1 || onlyWrkNo.getIoType()==10)){
                        //                News.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
                        // 已经存在吊车执行任务时，则过滤
                        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                            continue;
                        }
                        if (Cools.isEmpty(staProtocol.getWorkNo()) || !staProtocol.isLoading()){
                            continue;
                        }
                        //  判断堆垛机状态等待确认
                        if (crnProtocol.modeType == CrnModeType.AUTO
                                && crnProtocol.statusType == CrnStatusType.IDLE
                                && crnProtocol.forkPosType == CrnForkPosType.HOME && crnStn.getBay()!=(short)4) {
                            News.info("堆垛机接驳任务执行，工作号："+staProtocol.getWorkNo()+"；执行堆垛机号："+slave.getId()+"；接驳取货位："+crnStn.getStaNo()+"；接驳放货位："+staProtocol.getSiteId());
                            // 堆垛机接驳任务命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(onlyWrkNo.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getRow(staProtocol.getSiteId()));     // 目标库位排
                            crnCommand.setDestinationPosY(Utils.getBay(staProtocol.getSiteId()));     // 目标库位列
                            crnCommand.setDestinationPosZ(Utils.getLev(staProtocol.getSiteId()));     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, slave.getId(), new Task(2, crnCommand))) {
                                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", slave.getId(), JSON.toJSONString(crnCommand));
                            }
                            return true;
                        }
                    } else if (!Cools.isEmpty(onlyWrkNo) && onlyWrkNo.getCrnNo()==2 && onlyWrkNo.getWrkSts()>16 && crnProtocol.getCrnNo()!=2 && onlyWrkNo.getIoType()>100){
                        //                News.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
                        // 已经存在吊车执行任务时，则过滤
                        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                            continue;
                        }
                        if (Cools.isEmpty(staProtocol.getWorkNo()) || !staProtocol.isLoading()){
                            continue;
                        }
                        //  判断堆垛机状态等待确认
                        if (crnProtocol.modeType == CrnModeType.AUTO
                                && crnProtocol.statusType == CrnStatusType.IDLE
                                && crnProtocol.forkPosType == CrnForkPosType.HOME && crnStn.getBay()==(short)4) {
                            News.info("堆垛机接驳任务执行，工作号："+staProtocol.getWorkNo()+"；执行堆垛机号："+slave.getId()+"；接驳取货位："+crnStn.getStaNo()+"；接驳放货位："+staProtocol.getSiteId());
                            // 堆垛机接驳任务命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(onlyWrkNo.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getRow(staProtocol.getSiteId()));     // 目标库位排
                            crnCommand.setDestinationPosY(Utils.getBay(staProtocol.getSiteId()));     // 目标库位列
                            crnCommand.setDestinationPosZ(Utils.getLev(staProtocol.getSiteId()));     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, slave.getId(), new Task(2, crnCommand))) {
                                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", slave.getId(), JSON.toJSONString(crnCommand));
                            }
                            return true;
                        }
                    }
                        continue;
                } catch (Exception e){
                    News.info("堆垛机接驳任务执行，异常："+e.getMessage());
                }
                continue;
            }

            // 入库深库位是否有非F、D库位进行校验
            // 入库深库位是否有非F、D、X库位进行校验 （ Q、P、R、S）
            if (wrkMastMapper.selectShallowLoc(Integer.parseInt(wrkMast.getLocNo().substring(0, 2)),Integer.parseInt(wrkMast.getLocNo().substring(2, 5)),Integer.parseInt(wrkMast.getLocNo().substring(5, 7)))!=null){
                continue;
                //检查入库库位是否是在堆垛机边库位
                ArrayList<Integer> outLoc = new ArrayList<>();
                outLoc.add(3);outLoc.add(4);outLoc.add(11);outLoc.add(12);outLoc.add(18);outLoc.add(19);
                if (!outLoc.contains(Integer.parseInt(wrkMast.getLocNo().substring(0, 2)))) {
                    continue;
                }
            }


            //加强判断，只要存在移库任务，说明出库任务未完全结束，不执行入库任务
            WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
@@ -911,18 +1184,22 @@
                                    }

                                }
                            } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                                News.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
//                            } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
//                                News.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
//                                flag = true;
//                                break;
                            } else if (shallowLoc.getLocSts().equals("R") || shallowLoc.getLocSts().equals("P")) {
                                News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                                flag = true;
                                break;
                            }

                            //20230307 ADD，再加一次判断，当浅库位状态不为O时，不执行当前出库任务
                            if (shallowLoc != null && !shallowLoc.getLocSts().equals("O")) {
                                News.error("做了浅库位阻塞处理后反复判断，浅库位状态不为O ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", wrkMast.getSourceLocNo(), shallowLoc.getLocNo());
                                flag = true;
                                break;
                            }
//                            //20230307 ADD，再加一次判断，当浅库位状态不为O时，不执行当前出库任务
//                            if (shallowLoc != null && !shallowLoc.getLocSts().equals("O")) {
//                                News.error("做了浅库位阻塞处理后反复判断，浅库位状态不为O ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", wrkMast.getSourceLocNo(), shallowLoc.getLocNo());
//                                flag = true;
//                                break;
//                            }
                        }
                    }
                }
@@ -1063,6 +1340,7 @@
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
                        if (steProtocol.loca==0) continue;
                        if (steProtocol.isIdle()) {

                            // 已经存在吊车执行任务时，则过滤
@@ -1112,6 +1390,10 @@
                    }
                    // 堆垛机搬运小车
                    if (wrkMast.getWrkSts() == 3L) {
                        if (Cools.isEmpty(wrkMast.getSteNo()) || wrkMast.getSteNo()==0){
                            News.error("工作号={}即将开始搬运小车但是工作档没有小车号",wrkMast.getWrkNo());
                            return false;
                        }
                        this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                    }
                }
@@ -1125,11 +1407,23 @@
     * 出库  ===>>  库位到堆垛机站
     */
    public synchronized boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        Collections.shuffle(slave.getCrnOutStn());
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
            // 获取工作状态为11,12,13,14,15, 16（生成出库ID）的出库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
            if (wrkMast == null) {
                continue;
            }

            /*
             * 100、200存在进行中的盘点任务，则不执行盘点任务
             * */
            if (wrkMast.getIoType().equals(107)){
                Integer countPan = wrkMastMapper.selectWrkStsAndIoType107Count(wrkMast.getSourceStaNo(),wrkMast.getWrkNo());
                if (countPan > 0){
                    News.error("MainServiceImpl  locToCrnStn 1271行"+"盘点出库跳过，存在进行中可能堵塞任务数{}个",countPan);
                    continue;
                }
            }

            // 获取堆垛机出库站信息
@@ -1150,12 +1444,20 @@
                    News.error("MainServiceImpl  locToCrnStn"+"203非出库模式，禁止出库。任务号:{}！！！",wrkMast.getWrkNo());
                    return false;
                }
                if (wrkMast.getStaNo() == 113 && devpThread.ioModeOf3F != IoModeType.PAKOUT_MODE) {
                    News.error("MainServiceImpl  locToCrnStn"+"113非出库模式，禁止出库。任务号:{}！！！",wrkMast.getWrkNo());
                    return false;
                }
                if (wrkMast.getStaNo() == 213 && devpThread.ioModeOf4F != IoModeType.PAKOUT_MODE) {
                    News.error("MainServiceImpl  locToCrnStn"+"213非出库模式，禁止出库。任务号:{}！！！",wrkMast.getWrkNo());
                    return false;
                }

                if (wrkMast.getWrkSts() == 11 && (wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107)){
                    Integer sour = wrkMast.getSourceStaNo();
                    List<WrkMast> wrkMasts = wrkMastMapper.selectWrkStsAndIoType0(sour);
                    if (wrkMasts.size() > 0){
                        News.error("MainServiceImpl  1028行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
                        News.error("MainServiceImpl  1300行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
                        return false;
                    }

@@ -1164,7 +1466,7 @@
                            .eq("sta_no",300)
                            .last(" and wrk_sts>11 and io_type in (103,107) "));
                    if(!Cools.isEmpty(one)){
                        News.error("MainServiceImpl  1099行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
                        News.error("MainServiceImpl  1309行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
                        continue;
                    }
                }
@@ -1228,7 +1530,34 @@
                        for (String shallowLocNo : shallowLocs) {
                            LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                                if (Cools.isEmpty(waitWrkMast)){
                                    News.error("库位异常");
                                }else {
                                    if (waitWrkMast.getIoType() != 11 || waitWrkMast.getWrkSts() != 17){
                                        if(waitWrkMast.getIoPri()<=9980.0){
                                            waitWrkMast.setIoPri(waitWrkMast.getIoPri()+10.0);
                                        }else {
                                            waitWrkMast.setIoPri(9999d);
                                        }
//                                        if (wrkMast.getIoPri()>23.0){
//                                            wrkMast.setIoPri(wrkMast.getIoPri()-10.0);
//                                        }else {
                                            wrkMast.setIoPri(15.0d);
//                                        }
                                        if (wrkMastMapper.updateById(wrkMast)==0){
                                            News.error("调整优先级失败");
                                        }
                                        if (wrkMastMapper.updateById(waitWrkMast)==0){
                                            News.error("调整优先级失败");
                                        }else if (waitWrkMast.getWrkSts() != 17){
                                            flag = true;
                                        }

                                        break;
                                    }
                                }
                            }else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                                if (null == waitWrkMast) {
                                    // 生成一笔移库任务工作档、改变浅库位的源库/目标库 库位状态
                                    // 没有作业中的出库任务时，才能生成移库任务
@@ -1356,6 +1685,7 @@
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
                            if (steProtocol.loca==0) continue;
                            if (steProtocol.isIdle()) {

                                //小车只能绑定一笔作业中任务
@@ -1456,6 +1786,10 @@
                        }
                        // 堆垛机搬运小车
                        if (wrkMast.getWrkSts() == 12L) {
                            if (Cools.isEmpty(wrkMast.getSteNo()) || wrkMast.getSteNo()==0) {
                                News.error("工作号={}即将开始搬运小车但是工作档没有小车号",wrkMast.getWrkNo());
                                return false;
                            }
                            this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                        }
                    }
@@ -2354,6 +2688,10 @@
                }
                // 堆垛机搬运小车
                if (wrkMast.getWrkSts() == 12L) {
                    if (Cools.isEmpty(wrkMast.getSteNo()) || wrkMast.getSteNo()==0) {
                        News.error("工作号={}即将开始搬运小车但是工作档没有小车号",wrkMast.getWrkNo());
                        return;
                    }
                    this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                }
            }
@@ -2369,6 +2707,7 @@
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (steProtocol.loca==0) continue;
            if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
                return steProtocol.getSteNo().intValue();
            }
@@ -2385,6 +2724,7 @@
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (steProtocol.loca==0) continue;
            if (steProtocol.isIdle()) {
                if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
                    return steProtocol.getSteNo().intValue();
@@ -2803,6 +3143,7 @@
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
//                            if (steProtocol.loca==0) continue;
                            if (steProtocol.isIdle()) {
                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
@@ -2895,6 +3236,7 @@
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
//                        if (steProtocol.loca==0) continue;
                        // 穿梭车重新定位排列层
                        if (!steThread.confirmPos()) {
                            News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
@@ -2967,6 +3309,7 @@
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
//                            if (steProtocol.loca==0) continue;
                            if (steProtocol.isIdle()) {
                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
@@ -3163,6 +3506,7 @@
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
                            if (steProtocol.loca==0) continue;
                            if (steProtocol.isIdle()) {
                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
@@ -3192,6 +3536,7 @@
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
                        if (steProtocol.loca==0) continue;
                        // 穿梭车重新定位排列层
                        if (!steThread.confirmPos()) {
                            News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
@@ -3233,6 +3578,7 @@
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (steProtocol.loca==0) continue;
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() == 0){
                News.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
            }
@@ -3298,6 +3644,10 @@
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 2:
                            // 修改工作档状态 2.设备上走 => 3.小车待搬
                            if (Cools.isEmpty(wrkMast.getSteNo()) || wrkMast.getSteNo()==0){
                                News.error("修改工作档状态 2.设备上走 => 3.小车待搬 失败！！，工作号={}   原因：工作号没小车", wrkMast.getWrkNo());
                                break;
                            }
                            wrkMast.setWrkSts(3L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
@@ -3645,6 +3995,24 @@
                        News.error("MainServiceImpl  storeEmptyPlt"+"203为出库模式，禁止入库，退回入库口。！！！");
                        continue;
                    }
                    if ( emptyInSta.getStaNo()==113 && devpThread.ioModeOf3F == IoModeType.PAKOUT_MODE) {
                        //有出库任务，退库到入库口
                        staProtocol.setWorkNo((short) 9999);
                        staProtocol.setStaNo((short)100);
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        News.error("MainServiceImpl  storeEmptyPlt"+"113为出库模式，禁止入库，退回入库口。！！！");
                        continue;
                    }
                    if ( emptyInSta.getStaNo()==213 && devpThread.ioModeOf4F == IoModeType.PAKOUT_MODE) {
                        //有出库任务，退库到入库口
                        staProtocol.setWorkNo((short) 9999);
                        staProtocol.setStaNo((short)200);
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        News.error("MainServiceImpl  storeEmptyPlt"+"213为出库模式，禁止入库，退回入库口。！！！");
                        continue;
                    }
                }

                // 站点条件判断
@@ -3776,15 +4144,24 @@
                ledCommand.setBarcode(wrkMast.getBarcode());
                if (wrkMast.getIoType() != 110) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());

                    wrkDetls.forEach(wrkDetl -> {
                        Double total = 0.0;
                        EntityWrapper<LocDetl> wrapper = new EntityWrapper<>();
                        LocDetl locDetl = locDetlService.selectOne(wrapper.eq("zpallet", wrkDetl.getZpallet()).eq("matnr", wrkDetl.getMatnr()));
                        if (Cools.isEmpty(locDetl)) {
                            total = wrkDetl.getAnfme();
                        } else {
                            total = locDetl.getAnfme();
                        }
                        if (wrkMast.getIoType() == 101) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
                        }
                        if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() || 0 == wrkDetl.getInspect())) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
                        }
                        if (wrkMast.getIoType() == 107) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
                        }
                    });
                }
@@ -4216,6 +4593,75 @@
                    break;
            }
            LocMast loc = null;

            if(shallowLoc.getLocType2() == 3){ //低频混直接出库
                // 获取工作号
                int workNo = commonService.getWorkNo(0);
                Date now = new Date();
                // 保存工作档
                WrkMast wrkMast = new WrkMast();
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
                wrkMast.setIoType(101); // 入出库状态： 101.全板出库
                wrkMast.setIoPri((double) 9999);
                wrkMast.setCrnNo(crn.getId());
                wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
                if (shallowLoc.getCrnNo()==1){
                    wrkMast.setStaNo(100);
                    wrkMast.setSourceStaNo(108);
                }else if (shallowLoc.getCrnNo()==2){
                    wrkMast.setStaNo(100);
                    wrkMast.setSourceStaNo(104);
                }else {
                    wrkMast.setStaNo(200);
                    wrkMast.setSourceStaNo(208);
                }


//                wrkMast.setLocNo(loc.getLocNo()); // 目标库位
                wrkMast.setFullPlt("Y"); // 满板
                wrkMast.setPicking("N"); // 拣料
                wrkMast.setExitMk("N"); // 退出
                wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
                wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
                wrkMast.setLinkMis("N");
                wrkMast.setAppeTime(now);
                wrkMast.setModiTime(now);
                int res = wrkMastMapper.insert(wrkMast);
                if (res == 0) {
                    throw new CoolException("保存工作档失败");
                }
                // 工作档明细保存
                if (shallowLoc.getLocSts().equals("F")) {
                    List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
                    for (LocDetl locDetl : locDetls) {
                        WrkDetl wrkDetl = new WrkDetl();
                        wrkDetl.sync(locDetl);
                        wrkDetl.setWrkNo(workNo);
                        wrkDetl.setIoTime(new Date());
                        wrkDetl.setAnfme(locDetl.getAnfme());
                        wrkDetl.setAppeTime(new Date());
                        wrkDetl.setModiTime(new Date());
                        if (!wrkDetlService.insert(wrkDetl)) {
                            throw new CoolException("保存工作档明细失败");
                        }
                    }
                }
                // 修改源库位状态
                if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
                    shallowLoc.setLocSts("R"); // R.出库预约
                    shallowLoc.setModiTime(now);
                    if (!locMastService.updateById(shallowLoc)) {
                        throw new CoolException("更新源库位状态失败");
                    }
                } else {
                    throw new CoolException("源库位出库失败");
                }

                return;
            }

            List<LocMast> locs = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no",crn.getId())
                                                .eq("loc_type1",shallowLoc.getLocType1())
                                                .eq("loc_type2",shallowLoc.getLocType2())
@@ -4226,6 +4672,24 @@
                    || Utils.getBay(one.getLocNo()) != Utils.getBay(shallowLoc.getLocNo())
                    || Utils.getLev(one.getLocNo()) != Utils.getLev(shallowLoc.getLocNo())){

                    Integer steNo = this.hasCar(one.getLocNo());
                    if (steNo != null) {
                        //有小车
                        continue;
                    }

//                    //检测当前库位内侧其他库位是否为D、F、X
//                    if (Utils.checkInsideLocIsDFX(one.getLocNo())) {
//                        //内侧其他库位不是D、F、X。不能选取该库位
//                        continue;
//                    }

                    //检测当前库位内侧其他库位是否为D、F、X、O
                    if (Utils.checkInsideLocIsDFXO(one.getLocNo())) {
                        //内侧其他库位不是D、F、X、O。不能选取该库位
                        continue;
                    }

                    loc = one;
                    break;
                }
@@ -4233,7 +4697,8 @@

            if (null == loc) {
                News.error("深库位出库 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("深库位出库 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                return;
//                throw new CoolException("深库位出库 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
            }

            // 获取工作号
@@ -4314,10 +4779,10 @@
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());

                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    Integer sourceStaNo = inSta.getStaNo()==103 ? 104 : 204;
                    Integer sourceStaNo = inSta.getStaNo()==103 ? 104 : inSta.getStaNo()==113 ? 104 : 204;
                    WrkMast pakout = wrkMastMapper.selectWorkingPakout(sourceStaNo);
                    switch (inSta.getStaNo()) {
                        case 103://1F
                        case 103://1F1
                            if (pakout != null) {
                                if (devpThread.ioModeOf1F != IoModeType.PAKOUT_MODE) {
                                    // 出库切换中
@@ -4335,7 +4800,7 @@
                                devpThread.ioModeOf1F = IoModeType.PAKIN_MODE;
                            }
                            break;
                        case 203://2F
                        case 203://1F2
                            if (pakout != null) {
                                if (devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) {
                                    // 出库切换中
@@ -4353,6 +4818,42 @@
                                devpThread.ioModeOf2F = IoModeType.PAKIN_MODE;
                            }
                            break;
//                        case 113://2F1
//                            if (pakout != null) {
//                                if (devpThread.ioModeOf3F != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
////                                    devpThread.ioModeOf2F = IoModeType.PAKOUT_BOOTING;
////                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
////                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
////                                            && !devpThread.getStation().get(inSta.getStaNo()-1).isLoading()
////                                            && devpThread.getStation().get(inSta.getStaNo()-1).getWorkNo()==0) {
////                                        // 出库模式
//                                    devpThread.ioModeOf3F = IoModeType.PAKOUT_MODE;
////                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf3F = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                        case 213://2F2
//                            if (pakout != null) {
//                                if (devpThread.ioModeOf4F != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
////                                    devpThread.ioModeOf2F = IoModeType.PAKOUT_BOOTING;
////                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
////                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
////                                            && !devpThread.getStation().get(inSta.getStaNo()-1).isLoading()
////                                            && devpThread.getStation().get(inSta.getStaNo()-1).getWorkNo()==0) {
////                                        // 出库模式
//                                    devpThread.ioModeOf4F = IoModeType.PAKOUT_MODE;
////                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf4F = IoModeType.PAKIN_MODE;
//                            }
//                            break;
                    }
                }

@@ -4362,5 +4863,133 @@
            e.printStackTrace();
        }
    }
    public synchronized void ioConvert2F() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                if (devp.getId() == 1){
                    continue;
                }
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());

                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    Integer staNoEnd = inSta.getStaNo()==113 ? 114 : 214;
                    WrkMast pakout = wrkMastMapper.selectWorkingPakoutTwoF(staNoEnd);
                    boolean sign = true;
                    int[] staNos = new int[3];

                    switch (inSta.getStaNo()) {
                        case 113://2F1
                            staNos = new int[]{112,113,114};
                            for (int staNo : staNos){
                                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                                if (!staProtocol.isAutoing() || staProtocol.isLoading() || staProtocol.getWorkNo()>0){
                                    sign = false;
                                }
                            }
                            if (sign){
                                if (pakout != null) {
                                    if (devpThread.ioModeOf3F != IoModeType.PAKOUT_MODE) {

                                        // 出库切换中
//                                    devpThread.ioModeOf2F = IoModeType.PAKOUT_BOOTING;
//                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getStaNo()-1).isLoading()
//                                            && devpThread.getStation().get(inSta.getStaNo()-1).getWorkNo()==0) {
//                                        // 出库模式
                                        devpThread.ioModeOf3F = IoModeType.PAKOUT_MODE;
//                                    }
                                    }
                                } else {
                                    // 入库模式
                                    devpThread.ioModeOf3F = IoModeType.PAKIN_MODE;

                                }
                            }
                            break;
                        case 213://2F2
                            staNos = new int[]{212,213,214};
                            for (int staNo : staNos){
                                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                                if (!staProtocol.isAutoing() || staProtocol.isLoading()){
                                    sign = false;
                                }
                            }
                            if (sign){
                                if (pakout != null) {
                                    if (devpThread.ioModeOf4F != IoModeType.PAKOUT_MODE) {
                                        // 出库切换中
//                                    devpThread.ioModeOf2F = IoModeType.PAKOUT_BOOTING;
//                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getStaNo()-1).isLoading()
//                                            && devpThread.getStation().get(inSta.getStaNo()-1).getWorkNo()==0) {
//                                        // 出库模式
                                        devpThread.ioModeOf4F = IoModeType.PAKOUT_MODE;
//                                    }
                                    }
                                } else {
                                    // 入库模式
                                    devpThread.ioModeOf4F = IoModeType.PAKIN_MODE;
                                }
                            }
                            break;
                    }
                }

            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized void automaticallyTurnOffCharging() {
        // 获取当前时间戳
        long timestamp = System.currentTimeMillis();
        Date date = new Date(timestamp);
        TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai");
        java.util.Calendar calendar = java.util.Calendar.getInstance(timeZone);
        calendar.setTime(date);
        int hour = calendar.get(java.util.Calendar.HOUR_OF_DAY);
        if (hour>8 && hour<18){
            for (SteSlave ste : slaveProperties.getSte()) {
                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
                SteProtocol steProtocol = steThread.getSteProtocol();
                BasSte basSte = basSteService.selectById(ste.getId());
                if (Cools.isEmpty(steProtocol, basSte)) { continue; }
                try{
                    // 在线 空闲   无作业标记   不在充电
                    if (steProtocol.getMode() == 0
                            || !steProtocol.statusType.equals(SteStatusType.IDLE)
                            || basSte.getPakMk().equals("Y")
                            || steProtocol.getChargeStatus() == 0
                    ) {
                        continue;
                    }
                    if (!steProtocol.isEnable()) {
                        continue;
                    }
                    if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                        WrkCharge wrkCharge = wrkChargeService.selectWorking(steProtocol.getSteNo().intValue());
                        if (wrkCharge == null) {
                            if (steProtocol.getChargeStatus() == 1){
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(ste.getId()); // 穿梭车编号
                                steCommand.setTaskNo(9999); // 工作号
                                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE);
                                if (!MessageQueue.offer(SlaveType.Ste, ste.getId(), new Task(2, steCommand))) {
                                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", ste.getId(), JSON.toJSON(steCommand));
                                }
                            }
                        }
                    }
                }catch (Exception e){
                    News.error("自动关闭充电出错，联系管理员！"+hour+"点;"+ste.getId()+"号小车;");
                }
            }
        }
    }

}