123

zc

2025-05-14 93cf1a27f5d4ff504d691d68c40a622a6424e782

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

@@ -1,6 +1,7 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
@@ -21,14 +22,8 @@
import com.zy.core.cache.SlaveConnection;
import com.zy.core.dispatcher.ShuttleDispatchUtils;
import com.zy.core.enums.*;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.LiftSlave;
import com.zy.core.model.ShuttleSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.LiftAssignCommand;
import com.zy.core.model.command.LiftCommand;
import com.zy.core.model.command.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.*;
import com.zy.core.model.command.*;
import com.zy.core.model.protocol.ForkLiftStaProtocol;
import com.zy.core.model.protocol.LiftProtocol;
import com.zy.core.model.protocol.ShuttleProtocol;
@@ -39,6 +34,7 @@
import com.zy.core.thread.LiftThread;
import com.zy.core.thread.ShuttleThread;
import com.zy.core.thread.impl.FyDevpThread;
import com.zy.core.thread.impl.NormalLedThread;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -184,32 +180,33 @@
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    String errMsg = "";
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "超宽异常";
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "超高异常";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "超长异常";
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重异常";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重";
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码异常";
                        back = true;
                    }
                    // 退回
                    if (back) {
                        if (!staProtocol.isLoading()) {
                            continue;
                        }
                        if (!staProtocol.isPakMk()) {
                            continue;
                        }
                        // led 异常显示
                        if (ledThread != null) {
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
                            ledThread.error(errMsg);
                        }
                    }
@@ -266,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<>();
@@ -292,6 +289,9 @@
                                        .setJson(JSON.toJSONString(hashMap))
                                        .build()
                                        .doPost();
                                if (!Cools.isEmpty(msg) && "请先组托".equalsIgnoreCase(msg)) {
                                    ledThread.error(msg);
                                }
                                News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                            }
                        } catch (Exception e) {
@@ -307,6 +307,42 @@
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    String errMsg = "";
                    boolean back = false;
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "超高异常";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重异常";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码异常";
                        back = true;
                    }
                    // 退回
                    if (back) {

                        // led 异常显示
                        if (ledThread != null) {
                            ledThread.error(errMsg);
                        }
                    }

                    Short workNo = staProtocol.getWorkNo();
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && isInEnable(devpThread, inSta.getStaNo()) && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999)) && staProtocol.isPakMk()) {
                        String barcode = staProtocol.getBarcode();
@@ -340,6 +376,9 @@
                                            .setJson(JSON.toJSONString(hashMap))
                                            .build()
                                            .doPost();
                                    if (!Cools.isEmpty(msg) && "请先组托".equalsIgnoreCase(msg)) {
                                        ledThread.error(msg);
                                    }
                                    News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                                }
                            } catch (Exception e) {
@@ -386,19 +425,44 @@
                if (wrkMast.getStaNo() == 1026) {
                    locNo = "1200305";
                }
                //获取提升机信息
                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
                if (liftThread == null) {
                    continue;
                }

                LiftProtocol liftProtocol = liftThread.getStatus();
                if (liftProtocol == null) {
                    continue;
                }

                if (!liftThread.isIdle()) {
                    continue;
                }


                //判断提升机内是否有托盘
                if (liftProtocol.getHasTray()) {
                    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());
                }
            }
        }
@@ -420,33 +484,46 @@
            if (staProtocol == null) {
                continue;
            }

            List<WrkMast> wrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.OUTBOUND_SHUTTLE_RUN.sts, WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts).in("sta_no", 1013, 1024));
            if (wrkMastList != null && wrkMastList.size() >= 2) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，跳过，存在2条工作档", wrkMast.getWrkNo());
                continue;
            }
            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                continue;
            }
            if (!isOutEnable(devpThread, wrkMast.getStaNo())) {
                News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                continue;
            }
            StaProtocol staProtocol2 = station.get(wrkMast.getStaNo() + 2);
            if (staProtocol2.isLoading()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线有物222", wrkMast.getWrkNo(), wrkMast.getStaNo() + 2);
                continue;
            }
            String locNo = "1200301";
            if (wrkMast.getStaNo() == 1024) {
                locNo = "1200305";
            }

            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleNoLift(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), locNo, "TRANSPORT_DEVP");
            if (!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失败", wrkMast.getWrkNo());
                continue;
            }

            WrkMast wrkMast2 = wrkMastService.selectByMainWrkNo(wrkMast.getWrkNo());
            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMast2 != null) {
                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());
            }
        }
    }
@@ -509,17 +586,44 @@
                        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);
                        wrkMastService.updateById(wrkMast);
                        setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                    }
                }
            }
        }
    }


    private void setLedData(Integer wrkNo, Integer staNo) {
        try {
            Map<String, Object> param = new HashMap<>();
            param.put("taskNo", wrkNo);
            String response = null;
            response = new HttpHandler.Builder()
                    .setUri(wmsUrl)
                    .setPath("/rpc/led/getTask2")
                    .setJson(JSON.toJSONString(param))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);
            Integer code = jsonObject.getInteger("code");
            if (code.equals(200)) {
                String data = jsonObject.getString("data");
                List<LedCommand> wrkDetls = JSONArray.parseArray(data, LedCommand.class);
                redisUtil.set("LED_" + staNo, wrkDetls, 30);
                log.info("电视机数据设置：{},{}", staNo, data);
            } else {
                log.info("电视机数据设置异常：{},{}", wrkNo, response);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始化实时地图
@@ -629,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;
            }

@@ -855,17 +959,17 @@
            for (WrkMast wrkMast : wrkMasts) {
                boolean step0 = this.liftInExecuteStep0(wrkMast);//设备上走
                if (!step0) {
                    return;
                    continue;
                }

                boolean step1 = this.liftInExecuteStep1(wrkMast);//提升机搬运
                if (!step1) {
                    return;
                    continue;
                }

                boolean step2 = this.liftInExecuteStep2(wrkMast);//触发搬运任务
                if (!step2) {
                    return;
                    continue;
                }
            }
        } catch (Exception e) {
@@ -896,19 +1000,27 @@
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led);
            String errMsg = "";
            if (!back && staProtocol.isBackErr()) {
                errMsg = "超宽异常";
                errMsg = "后超限";
                back = true;
            }
            if (!back && staProtocol.isHighErr()) {
                errMsg = "超高异常";
                back = true;
            }
            if (!back && staProtocol.isRightErr()) {
                errMsg = "超长异常";
            if (!back && staProtocol.isWeightErr()) {
                errMsg = "超重异常";
                back = true;
            }
            if (!back && staProtocol.isWeightErr()) {
                errMsg = "超重";
            if (!back && staProtocol.isRightErr()) {
                errMsg = "右超限";
                back = true;
            }
            if (!back && staProtocol.isLeftErr()) {
                errMsg = "左超限";
                back = true;
            }
            if (!back && staProtocol.isBarcodeErr()) {
                errMsg = "扫码异常";
                back = true;
            }
            // 退回
@@ -920,21 +1032,22 @@
                }
            }
            String barcode = staProtocol.getBarcode();
            if (Cools.isEmpty(barcode) || "?".endsWith(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                return false;
            }
            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", 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 (wrkMast.getSourceStaNo() != 1031) {
                if (!staProtocol.isAutoing()) {
                    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;
                }
            }
@@ -957,13 +1070,14 @@

            staProtocol = staProtocol.clone();
            staProtocol.setStaNo(staNo);
            staProtocol.setWorkNo(wrkMast.getMainWrkNo().shortValue());
            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
            boolean result = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));

            wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                return false;
            }
            return false;
@@ -990,22 +1104,23 @@
                return false;
            }


            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }
//            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
//            if (liftWrkMast != null) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.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;
            }

@@ -1029,28 +1144,37 @@
            }

            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.getWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    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;
                }
            }

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

@@ -1060,9 +1184,9 @@
            } else if (wrkMast.getSourceStaNo() == 1032) {
                locNo = "0200308";
            }
            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleS(wrkMast.getWrkNo(), locNo, wrkMast.getLocNo(), "TRANSPORT_LIFT");
            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;
            }

@@ -1088,6 +1212,7 @@
            assignCommand.setLiftNo(liftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.PALLET_IN.id.shortValue());


            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
@@ -1124,13 +1249,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";
@@ -1139,7 +1264,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;
//            }

@@ -1163,12 +1288,12 @@
            for (WrkMast wrkMast : wrkMasts) {
                boolean step1 = this.liftOutExecuteStep1(wrkMast);//触发搬运任务
                if (!step1) {
                    return;
                    continue;
                }

                boolean step2 = this.liftOutExecuteStep2(wrkMast);//提升机搬运
                if (!step2) {
                    return;
                    continue;
                }
            }
        } catch (Exception e) {
@@ -1191,17 +1316,14 @@
            }

            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());
//                    return false;
//                }

            } else {
                if (!isOutEnable(devpThread, wrkMast.getStaNo())) {
                    News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            }
@@ -1214,10 +1336,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);
@@ -1258,13 +1380,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;
            }

@@ -1280,21 +1402,17 @@
            }

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

            Integer sourceLev = liftThread.getLevToStaNo(Utils.getLev(wrkMast.getSourceLocNo()));

            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getPalletOutCommand(wrkMast.getMainWrkNo(), sourceLev, wrkMast.getStaNo());
            List<LiftCommand> liftCommands = liftThread.getPalletOutCommand(wrkMast.getWrkNo(), sourceLev, wrkMast.getStaNo());
            LiftCommand liftCommand = liftCommands.get(0);
//            if (wrkMast.getMainWrkNo() != null) {
            liftCommand.setTaskNo(wrkMast.getMainWrkNo());
//            } else {
//                int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
//                liftCommand.setTaskNo(deviceWrk);//更换随机任务号
//            }
            int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
            liftCommand.setTaskNo(deviceWrk);//更换随机任务号

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);
@@ -1303,7 +1421,7 @@
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getMainWrkNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.PALLET_OUT.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);
@@ -1312,6 +1430,7 @@
            wrkMast.setModiTime(now);

            if (wrkMastService.updateById(wrkMast)) {
                setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                return false;
@@ -1363,6 +1482,7 @@
                                continue;//小车未到达目标层
                            }
                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
                            wrkMast.setLiftNo(null);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SHUTTLE.sts) {
                            //310.小车移动中 ==> 311.小车移动完成
@@ -1427,6 +1547,11 @@
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_12.sts) {
                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_13.sts);
                            WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
                            if (wrkMast1 != null) {
                                wrkMast1.setShuttleNo(wrkMast.getShuttleNo());
                                log.info("对主工作档进行绑定小车，为了小车进行移车,{},{}", wrkMast1.getWrkNo(), wrkMast.getShuttleNo());
                            }
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_10.sts) {
@@ -1457,7 +1582,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());
                        }
@@ -1471,7 +1596,7 @@
                                shuttleThread.setTaskNo(0);
                                //设置四向穿梭车为空闲状态
                                shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                                News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                                News.taskInfo(wrkMast.getWrkNo(), "四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                            }
                        }
                    }
@@ -1525,7 +1650,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.小车取货中
@@ -1569,7 +1694,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.小车放货中
@@ -1687,7 +1812,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());
                        }
@@ -1714,7 +1839,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());
                        }
@@ -1725,11 +1850,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());
                        }
@@ -1748,6 +1873,14 @@
        try {
            this.recShuttleErr();
            this.recLiftErr();
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, 1);
            ledThread.errorReset();
            ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, 2);
            ledThread.errorReset();
            ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, 3);
            ledThread.errorReset();
            ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, 4);
            ledThread.errorReset();
        } catch (Exception e) {
            News.error("recErr fail", e);
        }
@@ -1990,7 +2123,7 @@
                    continue;
                }

                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
                News.taskInfo(wrkMast.getWrkNo(), "保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -2271,6 +2404,10 @@
     * 入出库模式切换函数
     */
    public synchronized void ioConvert() {
        for (LedSlave led : slaveProperties.getLed()) {
            NormalLedThread ledThread = (NormalLedThread) SlaveConnection.get(SlaveType.Led, led.getId());
            ledThread.reset();
        }
        try {
            // 根据输送线plc遍历
            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);