#盘点逻辑

Junjie

2023-12-01 e80cb83c601a9a9a0b3db6d848ea605800d22bc7

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

@@ -205,12 +205,12 @@
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        // led 异常显示
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                        }
//                        // led 异常显示
//                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
//                        if (ledThread != null) {
//                            String errorMsg = "扫码失败，请重试";
//                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
//                        }
                        continue;
                    }

@@ -272,6 +272,7 @@
                                String errorMsg = jsonObject.getString("msg");
                                if (!Cools.isEmpty(errorMsg)) {
                                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                                    ledThread.setLedMk(false);
                                }
                            }
                            News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
@@ -285,6 +286,7 @@
                            if (ledThread != null) {
                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                                ledThread.setLedMk(false);
                            }
                        }
                    } catch (Exception e) {
@@ -414,68 +416,65 @@
                }
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
//                        && (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9999)
//                        && staProtocol.getStaNo().equals(staProtocol.getSiteId().shortValue())
                        && staProtocol.isInEnable()
//                        && (staProtocol.getWorkNo() > 0)
                        && staProtocol.isPakMk()){

                    // 获取条码扫描仪信息
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
                    if (barcodeThread == null) {
                        continue;
                    }
                    String barcode = barcodeThread.getBarcode();

                    WrkMast wrkMast = null;
                    wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
                    if (wrkMast == null) {
                    if (staProtocol.getWorkNo() > 0) {//存在工作号，利用工作号搜索任务
                        wrkMast = wrkMastMapper.selectByWorkNo(staProtocol.getWorkNo().intValue());
                    }else {
                        //不存在工作号，依靠托盘条码搜索
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
                        if (barcodeThread == null) {
                            continue;
                        }
                        String barcode = barcodeThread.getBarcode();
                        if(Cools.isEmpty(barcode)) {
                            continue;
                        }
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            continue;
                        }
                        wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
                    }

                    if (wrkMast == null) {//找不到工作档
                        continue;
                    }
//                    if (staProtocol.getWorkNo() == 9996) {
//                        String barcode = barcodeThread.getBarcode();
//                        if(!Cools.isEmpty(barcode)) {
//                            News.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
//                            if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
//                                staProtocol.setWorkNo((short) 32002);
//                                staProtocol.setStaNo(pickSta.getBackSta().shortValue());
//                                devpThread.setPakMk(staProtocol.getSiteId(), false);
//                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//
//                                // led 异常显示
//                                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
//                                if (ledThread != null) {
//                                    String errorMsg = "扫码失败，请重试";
//                                    MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
//                                }
//                                continue;
//                            }
//                        } else {
//                            staProtocol.setWorkNo((short) 32002);
//                            staProtocol.setStaNo(pickSta.getBackSta().shortValue());
//                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//
//                            // led 异常显示
//                            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
//                            if (ledThread != null) {
//                                String errorMsg = "扫码失败，请重试";
//                                MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
//                            }
//                            continue;
//                        }
//                        wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
//                        if (null == wrkMast) {
//                            News.error("{}条码错误，暂无拣料任务！", barcode);
//                        }
//                    }

                    if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
                        || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
                            || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
                        continue;
                    }

                    //*********************同库位组校验*********************
                    boolean flag = false;
                    String th = "";
                    List<String> innerLoc = Utils.getGroupInnerLoc(wrkMast.getSourceLocNo());
                    for (String loc : innerLoc) {
                        LocMast locMast = locMastService.selectById(loc);
                        if (locMast == null) {
                            continue;
                        }

                        if (!locMast.getLocSts().equals("F")) {
                            flag = true;
                            th = loc + "库位存在未回库任务";
                            break;
                        }
                    }
                    if (flag) {
                        News.info(th);
                        continue;
                    }
                    //*********************同库位组校验*********************

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

                    String sourceLocNo = wrkMast.getSourceLocNo().trim();
@@ -487,7 +486,7 @@
                    // 更新工作档数据状态
                    wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                    wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                    wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
                    wrkMast.setSourceStaNo(pickSta.getBackSta()); // 源站
//                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
//                            wrkMast.setCrnNo(dto.getCrnNo());
                    wrkMast.setStaNo(liftStaProtocol.getStaNo());//目标站
@@ -496,10 +495,12 @@
                    wrkMast.setLiftNo(null);// 提升机清空
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                        News.info(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                        continue;
                    }
                    if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
                        throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                        News.info(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                        continue;
                    }

                    // 修改库位状态 Q.拣料/盘点/并板再入库
@@ -507,127 +508,254 @@
                    locMast.setLocSts("Q");
                    locMast.setModiTime(new Date());
                    if (!locMastService.updateById(locMast)) {
                        throw new CoolException("修改库位状态失败");
                        News.info("修改库位状态失败");
                        continue;
                    }
                    barcodeThread.setBarcode("");//清理条码

//                    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);
//
////                            // 获取目标站
////                            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();
//                            LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(pickSta.getLiftNo(), Utils.getLev(sourceLocNo));//获取回库提升机目标站
//                            if (liftStaProtocol == null) {
//                                continue;
//                            }
//
//                            // 更新工作档数据状态
//                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
//                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
//                            wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
////                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
////                            wrkMast.setCrnNo(dto.getCrnNo());
//                            wrkMast.setStaNo(liftStaProtocol.getStaNo());//目标站
//                            wrkMast.setLocNo(sourceLocNo); // 目标库位 = 出库时的源库位
//                            wrkMast.setShuttleNo(null); // 穿梭车清空
//                            wrkMast.setLiftNo(null);// 提升机清空
//                            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() + "更新工作档数据状态失败");
//                            }
//
//                            // 修改库位状态 Q.拣料/盘点/并板再入库
//                            LocMast locMast = locMastService.selectById(sourceLocNo);
//                            locMast.setLocSts("Q");
//                            locMast.setModiTime(new Date());
//                            if (!locMastService.updateById(locMast)) {
//                                throw new CoolException("修改库位状态失败");
//                            }
//
////                            // 更新站点信息 且 下发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());
////                            }
//
//                            barcodeThread.setBarcode("");//清理条码
//
//                        } 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) 32002);
////                            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();
//                    }

                    if (pickSta.getBackSta() == 325 || pickSta.getBackSta() == 331 || pickSta.getBackSta() == 333 || pickSta.getBackSta() == 339) {
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());//写入工作号
                        staProtocol.setStaNo(pickSta.getBackSta().shortValue());//写入目标站
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    }
                }
            }

        }
    }

//    /**
//     * 拣料、并板、盘点再入库
//     */
//    @Transactional
//    public synchronized void stnToCrnStnPick(){
//        for (DevpSlave devp : slaveProperties.getDevp()) {
//            // 遍历拣料入库口
//            for (DevpSlave.Sta pickSta : devp.getPickInSta()) {
//
//                // 获取拣料入库站信息
//                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
//                StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
//                if (staProtocol == null) {
//                    continue;
//                } else {
//                    staProtocol = staProtocol.clone();
//                }
//                if (staProtocol.isAutoing()
//                        && staProtocol.isLoading()
////                        && (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9999)
////                        && staProtocol.getStaNo().equals(staProtocol.getSiteId().shortValue())
//                        && staProtocol.isPakMk()){
//
//                    // 获取条码扫描仪信息
//                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
//                    if (barcodeThread == null) {
//                        continue;
//                    }
//                    String barcode = barcodeThread.getBarcode();
//
//                    WrkMast wrkMast = null;
//                    wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
//                    if (wrkMast == null) {
//                        continue;
//                    }
////                    if (staProtocol.getWorkNo() == 9996) {
////                        String barcode = barcodeThread.getBarcode();
////                        if(!Cools.isEmpty(barcode)) {
////                            News.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
////                            if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
////                                staProtocol.setWorkNo((short) 32002);
////                                staProtocol.setStaNo(pickSta.getBackSta().shortValue());
////                                devpThread.setPakMk(staProtocol.getSiteId(), false);
////                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
////
////                                // led 异常显示
////                                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
////                                if (ledThread != null) {
////                                    String errorMsg = "扫码失败，请重试";
////                                    MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
////                                }
////                                continue;
////                            }
////                        } else {
////                            staProtocol.setWorkNo((short) 32002);
////                            staProtocol.setStaNo(pickSta.getBackSta().shortValue());
////                            devpThread.setPakMk(staProtocol.getSiteId(), false);
////                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
////
////                            // led 异常显示
////                            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
////                            if (ledThread != null) {
////                                String errorMsg = "扫码失败，请重试";
////                                MessageQueue.offer(SlaveType.Led, pickSta.getLed(), new Task(3, errorMsg));
////                            }
////                            continue;
////                        }
////                        wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
////                        if (null == wrkMast) {
////                            News.error("{}条码错误，暂无拣料任务！", barcode);
////                        }
////                    }
//
//                    if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
//                        || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
//                        continue;
//                    }
//
//                    // 保存工作主档历史档
//                    if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
//                        throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
//                    }
//
//                    String sourceLocNo = wrkMast.getSourceLocNo().trim();
//                    LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(pickSta.getLiftNo(), Utils.getLev(sourceLocNo));//获取回库提升机目标站
//                    if (liftStaProtocol == null) {
//                        continue;
//                    }
//
//                    // 更新工作档数据状态
//                    wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
//                    wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
//                    wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
////                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
////                            wrkMast.setCrnNo(dto.getCrnNo());
//                    wrkMast.setStaNo(liftStaProtocol.getStaNo());//目标站
//                    wrkMast.setLocNo(sourceLocNo); // 目标库位 = 出库时的源库位
//                    wrkMast.setShuttleNo(null); // 穿梭车清空
//                    wrkMast.setLiftNo(null);// 提升机清空
//                    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() + "更新工作档数据状态失败");
//                    }
//
//                    // 修改库位状态 Q.拣料/盘点/并板再入库
//                    LocMast locMast = locMastService.selectById(sourceLocNo);
//                    locMast.setLocSts("Q");
//                    locMast.setModiTime(new Date());
//                    if (!locMastService.updateById(locMast)) {
//                        throw new CoolException("修改库位状态失败");
//                    }
//                    barcodeThread.setBarcode("");//清理条码
//
////                    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);
////
//////                            // 获取目标站
//////                            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();
////                            LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(pickSta.getLiftNo(), Utils.getLev(sourceLocNo));//获取回库提升机目标站
////                            if (liftStaProtocol == null) {
////                                continue;
////                            }
////
////                            // 更新工作档数据状态
////                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
////                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
////                            wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
//////                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
//////                            wrkMast.setCrnNo(dto.getCrnNo());
////                            wrkMast.setStaNo(liftStaProtocol.getStaNo());//目标站
////                            wrkMast.setLocNo(sourceLocNo); // 目标库位 = 出库时的源库位
////                            wrkMast.setShuttleNo(null); // 穿梭车清空
////                            wrkMast.setLiftNo(null);// 提升机清空
////                            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() + "更新工作档数据状态失败");
////                            }
////
////                            // 修改库位状态 Q.拣料/盘点/并板再入库
////                            LocMast locMast = locMastService.selectById(sourceLocNo);
////                            locMast.setLocSts("Q");
////                            locMast.setModiTime(new Date());
////                            if (!locMastService.updateById(locMast)) {
////                                throw new CoolException("修改库位状态失败");
////                            }
////
//////                            // 更新站点信息 且 下发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());
//////                            }
////
////                            barcodeThread.setBarcode("");//清理条码
////
////                        } 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) 32002);
//////                            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();
////                    }
//
//                }
//            }
//
//        }
//    }

    /**
     * 初始化实时地图
@@ -737,6 +865,7 @@

            // 判断是否满足入库条件，自动、空闲、有物
            if (!(liftStaProtocol.getModel() && !liftStaProtocol.getBusy() && liftStaProtocol.getHasTray())) {
                News.info("{}任务，输送站点状态不满足入库。输送站点:{}", wrkMast.getWrkNo(), JSON.toJSONString(liftStaProtocol));
                continue;
            }

@@ -797,7 +926,8 @@
    public boolean shuttleInExecuteStep1(WrkMast wrkMast, LiftStaProtocol liftStaProtocol) {
        if (wrkMast.getWrkSts() == 4) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo());//调度小车到货物所在输送站点进行取货
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo());//调度小车到货物所在输送站点进行取货
                News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }

@@ -811,16 +941,19 @@
                return false;
            }
            if (!shuttleProtocol.isIdle()) {
                News.info("{}任务，{}小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            //判断小车令牌是否未被占领
            if (shuttleProtocol.getToken() != 0) {
                News.info("{}任务，{}小车，令牌已被独占，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//小车已被独占，禁止再派发任务
            }

            //判断小车是否存在移动任务
            WrkMast hasMoveWorking = wrkMastMapper.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if (hasMoveWorking != null) {
                News.info("{}任务，{}小车，存在移动任务，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//存在移动任务，禁止执行入库任务
            }

@@ -828,12 +961,14 @@
            if (!shuttleProtocol.getCurrentLocNo().equals(liftStaProtocol.getLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在输送站点进行取货
                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //小车已抵达输送站点位置，进行搬运货物
            NyShuttleOperaResult result = NyShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo());
            if (result == null) {//路径计算失败
                News.info("{}任务，{}小车，路径计算失败，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -884,6 +1019,7 @@
            wrapper.eq("stn_no", wrkMast.getStaNo());//出库站点编号
            StaDesc staDesc = staDescService.selectOne(wrapper);
            if (staDesc == null) {
                News.info("{}任务，出库路径不存在", wrkMast.getWrkNo());
                return false;//出库路径不存在
            }

@@ -894,17 +1030,28 @@
            }

            if (!basDevp.getAutoing().equals("Y")) {
                News.info("{}任务，{}站点，不是自动状态",wrkMast.getWrkNo(),basDevp.getDevNo());
                return false;//不是自动状态
            }

            if (!basDevp.getOutEnable().equals("Y")) {
                News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), basDevp.getDevNo());
                return false;//出库站点不可出
            }

            Integer liftNo = basDevp.getLiftNo();//搜索出库提升机是否存在入库任务，如存在禁止出库
            List<WrkMast> liftWrkMasts = wrkMastMapper.selectInWrkMastByLiftNo(liftNo);
            if (!liftWrkMasts.isEmpty()) {
                News.info("{}任务，{}号提升机，存在入库任务，系统禁止出库", wrkMast.getWrkNo(), liftNo);
                return false;//存在入库任务，禁止出库
            }

            //同库位组校验
            List<String> outerLoc = Utils.getGroupOuterLoc(wrkMast.getSourceLocNo());
            List<LocMast> outerLocMasts = locMastService.selectNotEmptyLocNos(outerLoc);
            if (!outerLocMasts.isEmpty()) {
                News.info("{}任务，浅库位存在货物，系统等待中", wrkMast.getWrkNo());
                return false;//浅库位存在未执行任务
            }

            //获取源站
@@ -914,11 +1061,13 @@
            }

            if (!(liftStaProtocol.getModel() && !liftStaProtocol.getBusy() && !liftStaProtocol.getHasTray())) {
                News.info("{}任务，{}内部输送站，不满足自动、空闲、无托盘状态", wrkMast.getWrkNo(), liftStaProtocol.getStaNo());
                return false;//站点必须自动、空闲、没有托盘
            }

            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                News.info("{}任务，调度小车{}系统等待中。", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }

@@ -932,10 +1081,12 @@
                return false;
            }
            if (!shuttleProtocol.isIdle()) {
                News.info("{}任务，{}小车，忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            //判断小车令牌是否未被占领
            if (shuttleProtocol.getToken() != 0) {
                News.info("{}任务，{}小车，令牌已被独占，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//小车已被独占，禁止再派发任务
            }

@@ -943,12 +1094,14 @@
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //小车已抵达货物位置，进行搬运货物
            NyShuttleOperaResult result = NyShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), liftStaProtocol.getLocNo());//将货物搬运至提升机输送站点
            if (result == null) {//出库路径计算失败
                News.info("{}任务，{}小车，路径计算失败，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -986,8 +1139,6 @@
            }

            //四向穿梭车状态为等待确认、小车处于空闲状态


            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
                    && shuttleProtocol.getTaskNo() != 0
                    && shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
@@ -1097,11 +1248,13 @@
            }

            if (!liftProtocol.isIdle()) {
                News.info("{}号提升机，忙碌中", liftSlave.getId());
                continue;
            }

            //判断提升机令牌是否被占用
            if (liftProtocol.getToken() != 0) {
                News.info("{}号提升机，令牌已被独占", liftSlave.getId());
                continue;
            }

@@ -1115,6 +1268,7 @@
                //搜索是否有其他任务占用了提升机，如果占用提升机的任务和当前任务相同，则运行执行
                WrkMast wrkMast1 = wrkMastMapper.selectLiftWrkMast(liftProtocol.getLiftNo().intValue());
                if (wrkMast1 != null && wrkMast1.getWrkNo().intValue() != wrkMast.getWrkNo().intValue()) {
                    News.info("{}号提升机，被其他任务{}占用且和当前任务{}不相同，禁止派发", liftSlave.getId(), wrkMast1.getWrkNo(), wrkMast.getWrkNo());
                    continue;
                }

@@ -1150,7 +1304,30 @@
            }

            if (!sourceBasDevp.getInEnable().equals("Y")) {
                News.info("{}任务，{}源站，没有可入信号", wrkMast.getWrkNo(), sourceBasDevp.getDevNo());
                return false;//站点不可入
            }

            Integer barcodeId = Utils.getBarcodeIdByStaNo(wrkMast.getSourceStaNo());
            if (barcodeId == null) {
                News.info("{}任务，{}源站，找不到可用条码器ID", wrkMast.getWrkNo(), sourceBasDevp.getDevNo());
                return false;//站点不可入
            }

            BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, barcodeId);
            if (barcodeThread == null) {
                News.info("{}任务，{}源站，条码器{}线程为空", wrkMast.getWrkNo(), sourceBasDevp.getDevNo(), barcodeId);
                return false;//站点不可入
            }
            String barcode = barcodeThread.getBarcode();
            if(!Cools.isEmpty(barcode)) {
                if(!("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode))) {
                    //存在条码值，判断是否和当前工作档一致
                    if (!barcode.equals(wrkMast.getBarcode())) {
                        News.info("{}任务，条码器{}值{}与工作档条码值不一致，系统跳过执行", wrkMast.getWrkNo(), sourceBasDevp.getDevNo(), barcodeId, barcode);
                        return false;//站点不可入
                    }
                }
            }

            //判断提升机整个三楼是否都处于入库模式
@@ -1158,10 +1335,12 @@
            Integer outInModel2 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 5);
            Integer outInModel3 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 8);
            if (outInModel1 == null || outInModel2 == null || outInModel3 == null) {
                News.info("{}任务，没有出入库模式", wrkMast.getWrkNo());
                return false;//不存在出入库模式
            }

            if (outInModel1 == 2 || outInModel2 == 2 && outInModel3 == 2) {
                News.info("{}任务，有站点处于出库模式，禁止入库", wrkMast.getWrkNo());
                return false;//只要有一个处于出库模式，禁止入库
            }

@@ -1174,26 +1353,31 @@
                return false;
            }
            if (!liftProtocol.isIdle()) {
                News.info("{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
            //判断提升机令牌是否未被占领
            if (liftProtocol.getToken() != 0) {
                News.info("{}任务，{}号提升机，令牌已被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机已被独占，禁止再派发任务
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内部有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//有小车，禁止派发
            }

            //判断提升机内是否有托盘
            if (liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内部有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//有托盘，禁止派发
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，当前提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

@@ -1206,6 +1390,7 @@
            }

            if (targetStaProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，{}站点，提升机站点有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo(), targetStaProtocol.getStaNo());
                return false;//提升机站点有托盘，禁止派发
            }

@@ -1213,7 +1398,7 @@

            //获取提升机命令
            NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftProtocol.getLiftNo().intValue(), NyLiftTaskModelType.MOVE_TRAY.id, startSta, targetSta, wrkMast.getWrkNo());
            if (wrkMast.getIoType() == 53) {
            if (wrkMast.getIoType() == 53 || wrkMast.getIoType() == 57) {
                //拣料再回库，重新分配设备工作号
                Random random = new Random();
                int deviceWrk = Math.abs((liftCommand.getTaskNo().intValue() + random.nextInt(9999)));//获取设备工作号
@@ -1262,12 +1447,14 @@
            //获取出库站点(目标站)
            BasDevp basDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (basDevp == null) {
                News.info("{}任务，出库站点不存在，禁止派发", wrkMast.getWrkNo());
                return false;//出库站点不存在
            }

            //获取源站对应的牛眼提升机站点编号(起点编号)
            LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(basDevp.getLiftNo(), Utils.getLev(wrkMast.getSourceLocNo()));
            if (liftStaProtocol == null) {
                News.info("{}任务，找不到站点，禁止派发", wrkMast.getWrkNo());
                return false;//找不到站点
            }
            Integer startSta = liftStaProtocol.getStaNo();
@@ -1278,11 +1465,13 @@
                //调度小车避让
                boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkMast.getSourceLocNo()), wrkMast.getShuttleNo(), shuttleThread);
                if (!result) {
                    News.info("{}任务，{}小车，小车在输送站点调度小车避让失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                    return false;
                }
            }

            if (!basDevp.getOutEnable().equals("Y")) {
                News.info("{}任务，{}站点，没有可出信号，禁止派发", wrkMast.getWrkNo(), basDevp.getDevNo());
                return false;//出库站点不可出
            }

@@ -1296,21 +1485,25 @@
            }

            if (!liftProtocol.isIdle()) {
                News.info("{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
            //判断提升机令牌是否未被占领
            if (liftProtocol.getToken() != 0) {
                News.info("{}任务，{}号提升机，令牌已被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机已被独占，禁止再派发任务
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，当前提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            //获目标站源站对应的输送站点
            BasDevp targetBasDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (targetBasDevp == null) {
                News.info("{}任务，{}站点，站点不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getStaNo());
                return false;//站点不存在
            }
            //获取牛眼提升机站点编号(目标编号)
@@ -2276,6 +2469,7 @@
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);
            log.info("悬挂线，wms返回结果：" + jsonObject);
            Integer code = jsonObject.getInteger("code");
            if (code.equals(200)) {//呼叫AGV
                return true;
@@ -2285,6 +2479,40 @@
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return false;
    }

    /**
     * AGV补货(悬挂线通知AGV取货)
     */
    public void agvRestockIntoByHangingWire() {
        //检测350和351扫码器
        int[] barcodeStaNo = {11, 12};//11 => 350站扫码器,12 => 351站扫码器
        for (int staNo : barcodeStaNo) {
            // 获取条码扫描仪信息
            BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, staNo);
            if (barcodeThread == null) {
                continue;
            }
            String barcode = barcodeThread.getBarcode();
            if(!Cools.isEmpty(barcode)) {
                if (barcode.contains("NoRead")) {
                    continue;
                }

                String agvStaNo = null;
                if (staNo == 11) {
                    agvStaNo = "303-1";
                }else {
                    agvStaNo = "304-1";
                }
                //通知AGV取货
                boolean result = agvRestockCall(agvStaNo, barcode);
                if (result) {
                    barcodeThread.setBarcode("");
                }
                log.info(barcodeThread.getSlave().getId() + "号扫码器，通知AGV取货，条码号：" + barcode);
            }
        }
    }

    // 300站拣料
@@ -2384,8 +2612,65 @@
                ledCommand.setLocNo(wrkMast.getLocNo());
                ledCommand.setStaNo(wrkMast.getStaNo());
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(),wrkDetl.getSpecs())));
                    //for (WrkDetl wrkDetl : wrkDetls) {
                    //    LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("zpallet", wrkDetl.getZpallet()).eq("matnr", wrkDetl.getMatnr()));
                    //
                    //    locDetls.forEach(locDetl1 -> {
                    //        //工作档中存在该物料则跳过
                    //        String suppCode = "";
                    //
                    //        if (wrkDetl.getMatnr().equals(locDetl1.getMatnr())) {
                    //            Double anfme = 0D;
                    //            if (locDetl != null) {
                    //                anfme = locDetl.getAnfme();
                    //            }
                    //            if (wrkDetl.getSuppCode() != null) {
                    //                suppCode = wrkDetl.getSuppCode();
                    //            }
                    //            ledCommand.getMatDtos()
                    //                    .add(new MatDto(wrkDetl.getMatnr()
                    //                            , wrkDetl.getMaktx()
                    //                            , wrkDetl.getAnfme()
                    //                            , (wrkDetl.getAnfme()-anfme)
                    //                            , wrkDetl.getSpecs()
                    //                            , suppCode));
                    //        } else {
                    //            if (locDetl1.getSuppCode() != null) {
                    //                suppCode = locDetl1.getSuppCode();
                    //            }
                    //            ledCommand.getMatDtos()
                    //                    .add(new MatDto(locDetl1.getMatnr()
                    //                            , locDetl1.getMaktx()
                    //                            , 0D
                    //                            , locDetl1.getAnfme()
                    //                            , locDetl1.getSpecs()
                    //                            , suppCode));
                    //        }
                    //    });
                    //    //LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("zpallet", wrkDetl.getZpallet()).eq("matnr", wrkDetl.getMatnr()));
                    //}
                    List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
                    locDetls.forEach(locDetl -> {
                        Wrapper<WrkDetl> wrapper = new EntityWrapper<WrkDetl>().eq("matnr", locDetl.getMatnr()).eq("wrk_no",wrkMast.getWrkNo());
                        Utils.wapperSetCondition(wrapper,"batch",locDetl.getBatch());
                        Utils.wapperSetCondition(wrapper,"three_code",locDetl.getThreeCode());
                        Utils.wapperSetCondition(wrapper,"dead_time",locDetl.getDeadTime());
                        Utils.wapperSetCondition(wrapper,"supp_code",locDetl.getSuppCode());//料箱码
                        WrkDetl detl = wrkDetlService.selectOne(wrapper);
                        if (Cools.isEmpty(detl)) {
                            String suppCode = "";
                            if (locDetl.getSuppCode() != null) {
                                suppCode = locDetl.getSuppCode();
                            }
                            ledCommand.getMatDtos().add(new MatDto(locDetl.getMatnr(), locDetl.getMaktx(), 0D, locDetl.getAnfme(), locDetl.getSpecs(), suppCode));
                        } else {
                            String suppCode = "";
                            if (detl.getSuppCode() != null) {
                                suppCode = detl.getSuppCode();
                            }
                            ledCommand.getMatDtos().add(new MatDto(detl.getMatnr(), detl.getMaktx(), detl.getAnfme(), (locDetl.getAnfme() - detl.getAnfme()), detl.getSpecs(), suppCode));
                        }
                    });
                }
                commands.add(ledCommand);
            }
@@ -2469,8 +2754,10 @@
            for (Integer staNo : led.getStaArr()) {
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) { continue; }
                if (staProtocol.getWorkNo() != 0) {
                if (staProtocol == null) {
                    continue;
                }
                if (staProtocol.isLoading()) {
                    reset = false;
                    break;
                }
@@ -2481,11 +2768,7 @@
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                }else {
//                    News.error("{}号LED命令下发成功！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    MessageQueue.offer(SlaveType.Led, led.getId(), new Task(4, new ArrayList<>()));
                    ledThread.setLedMk(false);
                    log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                }
            }
        }
@@ -2558,7 +2841,7 @@
            wrkCharge.setShuttleNo(shuttle.getId());
            wrkCharge.setCharge(shuttleCharge.id);
            wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
            wrkCharge.setWrkSts(51L);   // 21.准备充电
            wrkCharge.setWrkSts(51L);   // 51.准备充电
            wrkCharge.setIoPri((double) 10);
            wrkCharge.setLocNo(chargeLocNo);
            wrkCharge.setMemo("charge");
@@ -2634,6 +2917,10 @@

                if (shuttleProtocol.getPowerPercent() < maxPower) {
                    continue;
                }

                if (shuttleProtocol.getVoltage() < 5630) {
                    continue;//电压不够继续充电
                }

                //小车满电，结束充电任务
@@ -2740,11 +3027,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断小车令牌是否未被占领
            if (shuttleProtocol.getToken() != 0) {
                News.info("{}任务，{}小车，令牌已被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//小车已被独占，禁止再派发任务
            }

@@ -2769,6 +3058,7 @@
            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftSta.getLiftNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftSta.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

@@ -2779,11 +3069,13 @@
            }
            boolean checkPathIsAvailable = NavigateUtils.checkPathIsAvailable(targetNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(wrkMast.getLocNo()), null);
            if (!checkPathIsAvailable) {
                News.info("{}任务，{}小车，目标站点路径被占用，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//检测目标站点路径是否未被占用
            }
            //尝试锁定目标站路径
            boolean result2 = navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), targetNodes, true);//所使用的路径进行锁定禁用
            if (!result2) {
                News.info("{}任务，{}小车，路径锁定失败，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径锁定失败
            }
            //*************尝试锁定目标站路径***************
@@ -2844,6 +3136,7 @@
            }

            if (basLift.getPoint() == null) {
                News.info("{}任务，{}号提升机，没有提升机点位坐标，禁止派发", wrkMast.getWrkNo(), basLift.getLiftNo());
                return false;//没有设置提升机点位坐标
            }

@@ -2851,6 +3144,7 @@
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(basLift.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), basLift.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }
@@ -2865,6 +3159,7 @@
            }

            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), basLift.getLiftNo());
                return false;
            }

@@ -2880,11 +3175,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //小车令牌是否被任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -2894,6 +3191,7 @@
                //调度提升机

                if (liftProtocol.getToken() != 0) {
                    News.info("{}任务，{}号提升机，提升机令牌被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//提升机令牌被占用
                }

@@ -2933,11 +3231,13 @@

            //判断提升机令牌是否为当前小车
            if (!liftProtocol.getToken().equals(wrkMast.getShuttleNo())) {
                News.info("{}任务，{}号提升机，提升机令牌被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机已被独占，禁止再派发任务
            }

            //判断小车是否为当前任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -3000,23 +3300,27 @@
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //判断提升机令牌是否为当前小车
            if (!liftProtocol.getToken().equals(wrkMast.getShuttleNo())) {
                News.info("{}任务，{}号提升机，提升机令牌和当前小车不一致，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机令牌和当前小车不一致，禁止派发
            }

            //判断提升机内是否有小车
            if (!liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内无小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

@@ -3032,11 +3336,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            //判断小车是否为当前任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车当前任务未被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -3045,6 +3351,7 @@
            //获取目标站
            LiftStaProtocol liftSta = NyLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (sourceLiftSta == null || liftSta == null) {
                News.info("{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;//缺少站点信息
            }

@@ -3093,6 +3400,7 @@
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

@@ -3100,12 +3408,14 @@
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //判断提升机令牌是否为当前小车
            if (!liftProtocol.getToken().equals(wrkMast.getShuttleNo())) {
                News.info("{}任务，{}号提升机，提升机令牌和当前小车不一致，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机令牌和当前小车不一致，禁止派发
            }

@@ -3121,11 +3431,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge()) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断小车是否为当前任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -3141,6 +3453,7 @@
                return false;//没有提升机数据
            }
            if (basLift.getPoint() == null) {
                News.info("{}任务，{}号提升机，缺少提升机点位坐标，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//没有设置提升机点位坐标
            }

@@ -3200,11 +3513,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断小车令牌是否为当前任务
            if (shuttleProtocol.getToken() != 0 && !shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }