#

zc

2025-05-05 1c06b5c81f4187f1e9b7f4e5aa96a563637c6c12

#

 src/main/java/com/zy/asrs/controller/SiteController.java

@@ -84,6 +84,7 @@
            vo.setPakMk(staProtocol.isPakMk() ? "Y" : "N");       // 入库标记
            vo.setEmptyMk(staProtocol.isEmptyMk() ? "Y" : "N");     // 空板信号
            vo.setStaNo(staProtocol.getStaNo());                // 目标站
            vo.setBarcode(staProtocol.getBarcode());
            vo.setFinishWorkNo(staProtocol.getFinishWorkNo());
//            vo.setLocType1(staProtocol.isHigh() != staProtocol.isLow() && staProtocol.isLow() ? "低" : "高");     //高低库位
            //vo.setLocType1(staProtocol.getWeight() == 1 ? "重" : "轻");

 src/main/java/com/zy/asrs/domain/vo/SiteTableVo.java

@@ -17,6 +17,8 @@
    // 自动
    private String autoing = "-";

    private String barcode = "00000000";

    // 有物
    private String loading = "-";


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

@@ -225,7 +225,7 @@
                            staProtocol.setWorkNo(Short.parseShort(String.valueOf(wrkMast.getWrkNo())));
                            staProtocol.setStaNo(Short.parseShort(String.valueOf(inSta.getStaNo() + 1)));
                            MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                            News.info("输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                            News.taskInfo(wrkMast.getWrkNo(), "输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                            wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
                            wrkMast.setModiTime(new Date());
                            wrkMastService.updateById(wrkMast);
@@ -263,7 +263,7 @@
//                                createInTaskParam.setBarcode(barcode);
//
//                                R result = openUtils.createInTask(createInTaskParam);
//                                News.info("创建入库任务，任务数据={}，WMS响应={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject), JSON.toJSON(result));
//                                 News.taskInfo(wrkMast.getWrkNo(),"创建入库任务，任务数据={}，WMS响应={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject), JSON.toJSON(result));
//                                try{
//                                    String msg = "";
//                                    HashMap<String, String> hashMap = new HashMap<>();
@@ -289,9 +289,9 @@
                                        .setJson(JSON.toJSONString(hashMap))
                                        .build()
                                        .doPost();
//                                if (!Cools.isEmpty(msg)&&"请先组托".equalsIgnoreCase(msg)){
//                                    ledThread.error(msg);
//                                }
                                if (!Cools.isEmpty(msg) && "请先组托".equalsIgnoreCase(msg)) {
                                    ledThread.error(msg);
                                }
                                News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                            }
                        } catch (Exception e) {
@@ -376,9 +376,9 @@
                                            .setJson(JSON.toJSONString(hashMap))
                                            .build()
                                            .doPost();
//                                    if (!Cools.isEmpty(msg)&&"请先组托".equalsIgnoreCase(msg)){
//                                        ledThread.error(msg);
//                                    }
                                    if (!Cools.isEmpty(msg) && "请先组托".equalsIgnoreCase(msg)) {
                                        ledThread.error(msg);
                                    }
                                    News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                                }
                            } catch (Exception e) {
@@ -443,24 +443,24 @@

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


                boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleNoLift(wrkMast.getWrkNo(), locNo, wrkMast.getLocNo(), "TRANSPORT_DEVP");
                if (!dispatchShuttle) {
                    News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失败", wrkMast.getWrkNo());
                    continue;
                } else {
                    News.info("{}任务，调度小车失成功", wrkMast.getWrkNo());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失成功", wrkMast.getWrkNo());
                }
                wrkMast.setWrkSts(WrkStsType.INBOUND_SHUTTLE_RUN.sts);
                wrkMast.setLiftNo(null);
                wrkMast.setSystemMsg("");//清空消息
                wrkMast.setModiTime(new Date());
                if (!wrkMastService.updateById(wrkMast)) {
                    News.info("{}任务，更新工作档失败", wrkMast.getWrkNo());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，更新工作档失败", wrkMast.getWrkNo());
                } else {
                    setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                }
@@ -520,10 +520,10 @@
                wrkMast.setShuttleNo(wrkMast2.getShuttleNo());
            }
            if (!wrkMastService.updateById(wrkMast)) {
                News.info("{}任务，更新工作档失败", wrkMast.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，更新工作档失败", wrkMast.getWrkNo());
            } else {
                WrkMast wrkMast1 = wrkMastService.selectByMainWrkNo(wrkMast.getWrkNo());
                News.info("{}任务，移动任务生成成功——1", wrkMast1.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，移动任务生成成功——1", wrkMast1.getWrkNo());
            }
        }
    }
@@ -586,7 +586,7 @@
                        staProtocol.setWorkNo(Short.parseShort(String.valueOf(wrkMast.getWrkNo())));
                        staProtocol.setStaNo(Short.parseShort(String.valueOf(wrkMast.getStaNo())));
                        MessageQueue.offer(SlaveType.Devp, devpSlave.getId(), new Task(2, staProtocol));
                        News.info("输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                        News.taskInfo(wrkMast.getWrkNo(), "输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                        wrkMast.setWrkSts(WrkStsType.OUTBOUND_DEVP_RUN.sts);
                        wrkMast.setModiTime(new Date());
                        wrkMast.setShuttleNo(null);
@@ -733,7 +733,7 @@
            if (!shuttleProtocol.getCurrentLocNo().equals(liftSta.getLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftSta.getLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在输送站点进行取货
                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -1035,19 +1035,19 @@


            if (!staProtocol.isLoading()) {
                News.info("{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }
            if (wrkMast.getSourceStaNo() != 1031) {
                if (!staProtocol.isAutoing()) {
                    News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
                if (Cools.isEmpty(barcode) || "?".endsWith(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                    return false;
                }
                if (!staProtocol.getBarcode().equals(wrkMast.getBarcode())) {
                    News.info("{}任务，{}站点，托盘码不匹配，站点托盘码：{}，任务托盘码：{}", wrkMast.getWrkNo(), staProtocol.getSiteId(), staProtocol.getBarcode(), wrkMast.getBarcode());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，托盘码不匹配，站点托盘码：{}，任务托盘码：{}", wrkMast.getWrkNo(), staProtocol.getSiteId(), staProtocol.getBarcode(), wrkMast.getBarcode());
                    return false;
                }
            }
@@ -1113,13 +1113,13 @@

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

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

@@ -1143,27 +1143,27 @@
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (!staProtocol.isLoading()) {
                News.info("{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }
            if (sourceStaNo == 1023) {
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            } else if (sourceStaNo == 1012) {
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            } else if (sourceStaNo == 1032) {
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            }
@@ -1176,7 +1176,7 @@
            }
            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleNoLift(wrkMast.getWrkNo(), locNo, wrkMast.getLocNo(), "TRANSPORT_LIFT");
            if (!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失败", wrkMast.getWrkNo());
                return false;
            }

@@ -1238,13 +1238,13 @@

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

            //判断提升机内是否有托盘
            if (!liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
//            String locNo = "0200305";
@@ -1253,7 +1253,7 @@
//            }
//            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleS(wrkMast.getWrkNo(), locNo, wrkMast.getLocNo(), "TRANSPORT_LIFT");
//            if (!dispatchShuttle) {
//                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
//                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，调度小车失败", wrkMast.getWrkNo());
//                return false;
//            }

@@ -1305,17 +1305,17 @@
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }
            if (wrkMast.getStaNo() == 1031) {
//                if (staProtocol.getOutInModel() != 1) {
//                    News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
//                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
//                    return false;
//                }
            } else {
                if (!isOutEnable(devpThread, wrkMast.getStaNo())) {
                    News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            }
@@ -1328,10 +1328,10 @@
            }
            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleS(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), locNo, "TRANSPORT_LIFT");
            if (!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失败", wrkMast.getWrkNo());
                return false;
            } else {
                News.info("{}任务，无提升机处调度小车成功", wrkMast.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，无提升机处调度小车成功", wrkMast.getWrkNo());
            }

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);
@@ -1372,13 +1372,13 @@

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

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

@@ -1394,7 +1394,7 @@
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

@@ -1578,7 +1578,7 @@
                        if (wrkMastService.updateById(wrkMast)) {
                            //设置四向穿梭车为空闲状态
                            shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                            News.taskInfo(wrkMast.getWrkNo(), "四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                        } else {
                            News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                        }
@@ -1592,7 +1592,7 @@
                                shuttleThread.setTaskNo(0);
                                //设置四向穿梭车为空闲状态
                                shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                                News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                                News.taskInfo(wrkMast.getWrkNo(), "四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                            }
                        }
                    }
@@ -1646,7 +1646,7 @@
        if (wrkMast.getWrkSts() == WrkStsType.NEW_LOC_MOVE.sts) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, wrkMast.getSourceLocNo(), null);//调度小车到货物点进行取货
                News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");

                if (result) {
                    wrkMast.setWrkSts(WrkStsType.LOC_MOVE_SHUTTLE_TAKE.sts);//小车搬运中  501.生成移库任务 ==> 502.小车取货中
@@ -1690,7 +1690,7 @@
            }

            boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), null, wrkMast.getLocNo(), wrkMast.getShuttleNo(), "TRANSPORT");//调度小车放货
            News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
            News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");

            if (result) {
                wrkMast.setWrkSts(WrkStsType.LOC_MOVE_SHUTTLE_PUT.sts);//小车搬运中  502.小车取货中 ==> 503.小车放货中
@@ -1808,7 +1808,7 @@
                        if (wrkMastService.updateById(wrkMast)) {
                            liftThread.setSyncTaskNo(0);
                            liftThread.setProtocolStatus(LiftProtocolStatusType.IDLE);
                            News.info("提升机已确认且任务完成状态。提升机号={}", liftProtocol.getLiftNo());
                            News.taskInfo(wrkMast.getWrkNo(), "提升机已确认且任务完成状态。提升机号={}", liftProtocol.getLiftNo());
                        } else {
                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
                        }
@@ -1835,7 +1835,7 @@
                        wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            News.info("输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                            News.taskInfo(wrkMast.getWrkNo(), "输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        } else {
                            News.error("输送线已确认且任务完成状态,复位失败，但未找到工作档。输送线号={}，完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        }
@@ -1846,11 +1846,11 @@
                        staProtocol.setWorkNo(Short.parseShort(String.valueOf(wrkMast.getWrkNo())));
                        staProtocol.setStaNo(Short.parseShort(String.valueOf(1135)));
                        MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                        News.info("输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                        News.taskInfo(wrkMast.getWrkNo(), "输送线入库命令下发，任务数据={}", JSON.toJSON(wrkMast));
                        wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            News.info("输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                            News.taskInfo(wrkMast.getWrkNo(), "输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        } else {
                            News.error("输送线已确认且任务完成状态,复位失败，但未找到工作档。输送线号={}，完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        }
@@ -2119,7 +2119,7 @@
                    continue;
                }

                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
                News.taskInfo(wrkMast.getWrkNo(), "保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
            }
        } catch (Exception e) {
            e.printStackTrace();

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

@@ -211,22 +211,22 @@
            //获取穿梭车最近且空闲的提升机
            LiftThread liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
            if (liftThread == null) {
                News.info("{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                return false;//没有可用且空闲的提升机
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }
            //当1011入库，托盘在提升机里，1014也在入库，待机位被1014占住，去提升机里的任务，小车会卡住
            if (liftProtocol.getHasTray() && liftProtocol.getLev() == 1 && wrkMast.getStaNo() != null && wrkMast.getStaNo() == 1015) {
                News.info("{}任务，{}号提升机，提升机内有托盘且在1层需要小车去接，就不要占住待机位，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机内有托盘且在1层需要小车去接，就不要占住待机位，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }
            if (liftProtocol.getHasTray() && liftProtocol.getLev() == 5 && wrkMast.getStaNo() != null && wrkMast.getStaNo() == 1026) {
                News.info("{}任务，{}号提升机，提升机内有托盘且在5层需要小车去接，就不要占住待机位，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机内有托盘且在5层需要小车去接，就不要占住待机位，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

@@ -289,13 +289,13 @@
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

@@ -305,13 +305,13 @@
                //获取穿梭车最近且空闲的提升机
                liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
                if (liftThread == null) {
                    News.info("{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                    return false;//没有可用且空闲的提升机
                }

                liftProtocol = liftThread.getStatus();
                if (liftProtocol == null) {
                    News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                    return false;
                }

@@ -332,13 +332,13 @@
            } else {
                liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
                if (liftThread == null) {
                    News.info("{}号提升机不存在", wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号提升机不存在", wrkMast.getLiftNo());
                    return false;
                }

                liftProtocol = liftThread.getStatus();
                if (liftProtocol == null) {
                    News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                    return false;
                }
            }
@@ -347,19 +347,19 @@
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

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

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

@@ -422,48 +422,48 @@
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务，未绑定提升机，禁止派发", wrkMast.getWrkNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，未绑定提升机，禁止派发", wrkMast.getWrkNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}号提升机不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机不存在", wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }


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

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

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

@@ -471,7 +471,7 @@
            //判断提升机楼层
            if (liftProtocol.getLev() != Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
                //提升机不在小车楼层
                News.info("{}任务，{}号提升机，提升机与小车不在同一层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机与小车不在同一层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//等待提升机到小车楼层
            }

@@ -479,7 +479,7 @@
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getMainWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }
@@ -527,19 +527,19 @@
        //小车移动到提升机中  小车迁入提升机完成 ==> 提升机至放货层
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_8.sts) {
            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务未绑定提升机", wrkMast.getWrkNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务未绑定提升机", wrkMast.getWrkNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}号提升机不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机不存在", wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

@@ -547,25 +547,25 @@
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

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

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

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

@@ -619,18 +619,18 @@
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务，提升机未绑定，禁止派发", wrkMast.getWrkNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，提升机未绑定，禁止派发", wrkMast.getWrkNo());
                return false;
            }

@@ -638,50 +638,50 @@
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(1, wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}任务，{}号提升机，提升机线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}任务，{}号提升机，提升机对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

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

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

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

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

            //判断提升机楼层
            if (liftProtocol.getLev() != Utils.getLev(wrkMast.getLocNo())) {
                //提升机不在放货层
                News.info("{}任务，{}号提升机，不在放货层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，不在放货层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }


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

@@ -219,13 +219,13 @@
            //获取穿梭车最近且空闲的提升机
            LiftThread liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
            if (liftThread == null) {
                News.info("{}号小车，{}小车库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号小车，{}小车库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                return false;//没有可用且空闲的提升机
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

@@ -284,13 +284,13 @@
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

@@ -301,38 +301,38 @@
            //获取穿梭车最近且空闲的提升机
            liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
            if (liftThread == null) {
                News.info("{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                return false;//没有可用且空闲的提升机
            }

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

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


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

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

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

@@ -367,7 +367,7 @@
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(wrkMast.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

@@ -399,44 +399,44 @@
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getShuttleNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getShuttleNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getShuttleNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getShuttleNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", 1);
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", 1);
                return false;
            }

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

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

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

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


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

@@ -23,7 +23,9 @@
        System.out.println(News.print());
    }

    interface NewsSupport<T> { boolean execute(T t); }
    interface NewsSupport<T> {
        boolean execute(T t);
    }

    private static final NewsQueue<NewsDomain> NEWS_QUEUE = new NewsQueue<>(NewsDomain.class, 1024);

@@ -36,7 +38,10 @@
        private int head;
        private int tail;

        { this.head = 0; this.tail = 0; }
        {
            this.head = 0;
            this.tail = 0;
        }

        public NewsQueue(Class<T> cls, int capacity) {
            this.cls = cls;
@@ -50,7 +55,7 @@
            }
            this.reform();
            this.arr[this.tail] = t;
            this.tail ++;
            this.tail++;
            return true;
        }

@@ -61,7 +66,7 @@
                this.reform();
            }
            this.arr[this.tail] = t;
            this.tail ++;
            this.tail++;
            return true;
        }

@@ -70,14 +75,14 @@
                return null;
            }
            T t = this.arr[this.head];
            this.head ++;
            this.head++;
            this.reform();
            return t;
        }

        private void reform() {
            for (int i = this.head; i < this.tail; i++) {
                this.arr[i-this.head] = this.arr[i];
                this.arr[i - this.head] = this.arr[i];
            }
            this.tail -= this.head;
            this.head = 0;
@@ -180,14 +185,16 @@
        return NEWS_QUEUE.offer(new NewsDomain(level, replace(msg, args), (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date())));
    }

    public static String replace(String str, Object[] objs){
    public static String replace(String str, Object[] objs) {
        if (null == objs || objs.length == 0 || null == str || "".equals(str.trim())) {
            return str;
        } else {
            StringBuilder sb = new StringBuilder(str);
            for (Object obj : objs) {
                int idx = sb.indexOf("{}");
                if (idx == -1) { break; }
                if (idx == -1) {
                    break;
                }
                sb.replace(idx, idx + 2, String.valueOf(obj));
            }
            return sb.toString();
@@ -212,6 +219,7 @@
        ERROR(3),
        ;
        public int idx;

        NewsLevel(int idx) {
            this.idx = idx;
        }

 src/main/java/com/zy/core/action/ForkLiftAction.java

@@ -1,27 +1,18 @@
package com.zy.core.action;

import com.alibaba.fastjson.JSON;
import com.zy.asrs.entity.BasLiftOpt;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasLiftOptService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.ForkLiftTaskModeType;
import com.zy.core.enums.RedisKeyType;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.CommandResponse;
import com.zy.core.model.command.ForkLiftCommand;
import com.zy.core.model.command.LiftAssignCommand;
import com.zy.core.model.command.LiftRedisCommand;
import com.zy.core.model.protocol.ForkLiftProtocol;
import com.zy.core.thread.ForkLiftThread;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;

@Component
public class ForkLiftAction {
@@ -118,7 +109,7 @@
//                News.error("货叉提升机命令下发失败，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
//                return false;
//            } else {
//                News.info("货叉提升机命令下发成功，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
//                 News.taskInfo(wrkMast.getWrkNo(),"货叉提升机命令下发成功，提升机号={}，任务数据={}", command.getLiftNo(), JSON.toJSON(command));
//            }
//
//            commandStep++;

 src/main/java/com/zy/core/thread/impl/LfdZyForkLiftMasterThread.java

@@ -27,7 +27,7 @@
    private ForkLiftProtocol forkLiftProtocol;
    private RedisUtil redisUtil;
    private SiemensS7Net siemensS7Net;
    private List<HashMap<String,Object>> slaveAddressList = null;
    private List<HashMap<String, Object>> slaveAddressList = null;
    private boolean connect = false;

    public LfdZyForkLiftMasterThread(ForkLiftSlave slave, RedisUtil redisUtil) {
@@ -63,12 +63,12 @@
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
        if (connect.IsSuccess) {
            result = true;
            OutputQueue.FORKLIFT.offer(MessageFormat.format( "【{0}】货叉提升机连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】货叉提升机连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.info("货叉提升机连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        } else {
            OutputQueue.FORKLIFT.offer(MessageFormat.format( "【{0}】货叉提升机连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】货叉提升机连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.error("货叉提升机连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        }
        // siemensS7Net.ConnectClose();
@@ -92,7 +92,7 @@
                }

                Thread.sleep(500);
            }catch (Exception e){
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

 src/main/java/com/zy/core/thread/impl/LfdZyForkLiftSlaveThread.java

@@ -2,7 +2,6 @@

import HslCommunication.Core.Types.OperateResult;
import HslCommunication.Core.Types.OperateResultExOne;
import HslCommunication.Profinet.Siemens.SiemensPLCS;
import HslCommunication.Profinet.Siemens.SiemensS7Net;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
@@ -66,7 +65,7 @@
    public boolean connect() {
        boolean result = false;
        LfdZyForkLiftMasterThread masterThread = (LfdZyForkLiftMasterThread) SlaveConnection.get(SlaveType.ForkLiftMaster, masterId);
        if(masterThread != null) {
        if (masterThread != null) {
            result = true;
            this.masterThread = masterThread;
        }
@@ -171,7 +170,7 @@
                InnerForkLiftExtend forkLiftExtend = (InnerForkLiftExtend) forkLiftProtocol.getExtend();
                forkLiftProtocol.setExtend(forkLiftExtend);

            }else {
            } else {
                OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】{1}读取货叉提升机状态信息失败", DateUtils.convert(new Date()), slave.getId()));
            }

@@ -224,7 +223,7 @@
            //设备状态
            basLift.setDeviceStatus(JSON.toJSONString(forkLiftProtocol));
            if (basLiftService.updateById(basLift)) {
                OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), forkLiftProtocol.getLiftNo()));
                OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功", DateUtils.convert(new Date()), forkLiftProtocol.getLiftNo()));
            }

        } catch (Exception e) {
@@ -313,8 +312,7 @@
                && this.forkLiftProtocol.getWrkNo() == 0
                && this.forkLiftProtocol.getTaskNo() == 0
                && this.forkLiftProtocol.getModel() == 2
                && this.forkLiftProtocol.getErrorCode() == 0
                ;
                && this.forkLiftProtocol.getErrorCode() == 0;
        return res;
    }

@@ -343,8 +341,7 @@
        boolean res = this.forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.IDLE.id
                && this.forkLiftProtocol.getWrkNo() == 0
                && this.forkLiftProtocol.getModel() == 2
                && this.forkLiftProtocol.getErrorCode() == 0
                ;
                && this.forkLiftProtocol.getErrorCode() == 0;
        return res;
    }


 src/main/java/com/zy/core/thread/impl/ZyForkLiftThread.java

@@ -17,7 +17,6 @@
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.action.ForkLiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.OutputQueue;
import com.zy.core.enums.ForkLiftIoModeType;
import com.zy.core.enums.ForkLiftProtocolStatusType;
@@ -33,7 +32,10 @@
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.*;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Date;
import java.util.List;

@Slf4j
@SuppressWarnings("all")
@@ -67,12 +69,12 @@
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
        if (connect.IsSuccess) {
            result = true;
            OutputQueue.FORKLIFT.offer(MessageFormat.format( "【{0}】货叉提升机连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】货叉提升机连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.info("货叉提升机连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        } else {
            OutputQueue.FORKLIFT.offer(MessageFormat.format( "【{0}】货叉提升机连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】货叉提升机连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.error("货叉提升机连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        }
        // siemensS7Net.ConnectClose();
@@ -167,7 +169,7 @@
                InnerForkLiftExtend forkLiftExtend = (InnerForkLiftExtend) forkLiftProtocol.getExtend();
                forkLiftProtocol.setExtend(forkLiftExtend);

            }else {
            } else {
                OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】{1}读取货叉提升机状态信息失败", DateUtils.convert(new Date()), slave.getId()));
            }

@@ -220,7 +222,7 @@
            //设备状态
            basLift.setDeviceStatus(JSON.toJSONString(forkLiftProtocol));
            if (basLiftService.updateById(basLift)) {
                OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), forkLiftProtocol.getLiftNo()));
                OutputQueue.FORKLIFT.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功", DateUtils.convert(new Date()), forkLiftProtocol.getLiftNo()));
            }

        } catch (Exception e) {
@@ -309,8 +311,7 @@
                && this.forkLiftProtocol.getWrkNo() == 0
                && this.forkLiftProtocol.getTaskNo() == 0
                && this.forkLiftProtocol.getModel() == 2
                && this.forkLiftProtocol.getErrorCode() == 0
                ;
                && this.forkLiftProtocol.getErrorCode() == 0;
        return res;
    }

@@ -339,8 +340,7 @@
        boolean res = this.forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.IDLE.id
                && this.forkLiftProtocol.getWrkNo() == 0
                && this.forkLiftProtocol.getModel() == 2
                && this.forkLiftProtocol.getErrorCode() == 0
                ;
                && this.forkLiftProtocol.getErrorCode() == 0;
        return res;
    }


 src/main/webapp/views/pipeline.html

@@ -102,6 +102,7 @@
                        <th>出入库模式</th>
                        <th>完结工作号</th>
                        <th>目标站</th>
                        <th>托盘码</th>
<!--                        <th>提升机到位信号</th>-->
<!--                        <th>高低信号</th>-->
                    </tr>
@@ -289,6 +290,7 @@
                        setVal(tr.children("td").eq(6), table[i-1].outInModel);
                        setVal(tr.children("td").eq(7), table[i-1].finishWorkNo);
                        setVal(tr.children("td").eq(8), table[i-1].staNo);
                        setVal(tr.children("td").eq(9), table[i-1].barcode);
                        // setVal(tr.children("td").eq(9), table[i-1].liftArrival);
                        //setVal(tr.children("td").eq(10), table[i-1].locType1);
                    }
@@ -376,7 +378,7 @@
                "       <td></td>\n" +
                "       <td></td>\n" +
                "       <td></td>\n" +
                // "       <td></td>\n" +
                 "       <td></td>\n" +
                "       <td></td>\n" +
                "     </tr>\n";
        }