#

zc

2025-04-29 62b1f39e60f64ec4e05b21d11af3e36f5891a91a

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

@@ -1,6 +1,8 @@
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;
import com.zy.asrs.domain.enums.NotifyMsgType;
@@ -9,33 +11,39 @@
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.MapNode;
import com.zy.common.model.SearchLocParam;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.*;
import com.zy.core.News;
import com.zy.core.action.LiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.MessageQueue;
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.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.protocol.*;
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;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.*;
import com.zy.system.entity.Config;
import com.zy.core.thread.DevpThread;
import com.zy.core.thread.LedThread;
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 io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.io.IOException;
import java.util.*;

/**
 * 立体仓库WCS系统主流程业务
@@ -87,14 +95,15 @@
    private NoLiftInServiceImpl noLiftInService;
    @Autowired
    private NoLiftOutServiceImpl noLiftOutService;
    @Autowired
    private LiftAction liftAction;
    @Autowired
    private BasWrkStatusService wrkStatusService;
    @Value("${asrs.wmsUrl}")
    private String wmsUrl;


    public static List<Integer> staNosIn = new ArrayList<Integer>() {{
        add(1015);
        add(1026);
    }};

    private boolean isInEnable(DevpThread devpThread, Integer staNo) {
    public boolean isInEnable(DevpThread devpThread, Integer staNo) {
        if (staNo == null) {
            return false;
        }
@@ -102,31 +111,27 @@
        switch (staNo) {
            case 1011:
            case 1012:
                devpThread.getStation().get(1012).isInEnable();
                break;
                return devpThread.getStation().get(1012).isInEnable();
            case 1021:
            case 1022:
            case 1023:
                devpThread.getStation().get(1022).isInEnable();
                break;
                return devpThread.getStation().get(1022).isInEnable();
            case 1031:
            case 1032:
                devpThread.getStation().get(1032).isInEnable();
                break;
                return devpThread.getStation().get(1032).isInEnable();
            case 1024:
            case 1025:
            case 1026:
                devpThread.getStation().get(1025).isInEnable();
                break;
                return devpThread.getStation().get(1025).isInEnable();
            case 1013:
            case 1014:
            case 1015:
                devpThread.getStation().get(1014).isInEnable();
                break;
                return devpThread.getStation().get(1014).isInEnable();
        }
        return false;
    }

    private boolean isOutEnable(DevpThread devpThread, Integer staNo) {
    public boolean isOutEnable(DevpThread devpThread, Integer staNo) {
        if (staNo == null) {
            return false;
        }
@@ -134,26 +139,22 @@
        switch (staNo) {
            case 1011:
            case 1012:
                devpThread.getStation().get(1012).isOutEnable();
                break;
                return devpThread.getStation().get(1012).isOutEnable();
            case 1021:
            case 1022:
            case 1023:
                devpThread.getStation().get(1022).isOutEnable();
                break;
            case 1031:
            case 1032:
                devpThread.getStation().get(1032).isOutEnable();
                break;
                return devpThread.getStation().get(1022).isOutEnable();
            case 1024:
            case 1025:
            case 1026:
                devpThread.getStation().get(1025).isOutEnable();
                break;
                return devpThread.getStation().get(1025).isOutEnable();
            case 1013:
            case 1014:
            case 1015:
                devpThread.getStation().get(1014).isOutEnable();
                break;
                return devpThread.getStation().get(1014).isOutEnable();
            case 1031:
            case 1032:
                return devpThread.getStation().get(1032).isOutEnable();
        }
        return false;
    }
@@ -164,102 +165,91 @@
     */
    public synchronized void generateInboundWrk() {
        try {
            DevpSlave devpSlave = slaveProperties.getDevp().get(0);
            // 遍历入库口
            for (DevpSlave.Sta inSta : devpSlave.getInSta()) {
                // 获取入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "异常：";
                if (staProtocol.isFrontErr()) {
                    errMsg = errMsg + "前超限；";
                    back = true;
                }
                if (staProtocol.isBackErr()) {
                    errMsg = errMsg + "后超限";
                    back = true;
                }
                if (staProtocol.isHighErr()) {
                    errMsg = errMsg + "高超限";
                    back = true;
                }
                if (staProtocol.isLeftErr()) {
                    errMsg = errMsg + "左超限";
                    back = true;
                }
                if (staProtocol.isRightErr()) {
                    errMsg = errMsg + "右超限";
                    back = true;
                }
                if (staProtocol.isWeightErr()) {
                    errMsg = errMsg + "超重";
                    back = true;
                }
                if (staProtocol.isBarcodeErr()) {
                    errMsg = errMsg + "扫码失败";
                    back = true;
                }
                // 退回
                if (back) {
                    // led 异常显示
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    if (ledThread != null) {
                        ledThread.error(errMsg);
                    }
                    continue;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading() && isInEnable(devpThread, inSta.getStaNo()) && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999)) && staProtocol.isPakMk()) {
                    String barcode = staProtocol.getBarcode();
                    if (!Cools.isEmpty(barcode)) {
                        News.info("条码扫描器检测条码信息：{}", barcode);
                    }
                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_sta_no", inSta.getStaNo()).eq("wrk_sts", WrkStsType.NEW_INBOUND).eq("barcode", barcode));
                    if (wrkMast != null) {
                        News.error("工作档已存在,工作号={}", wrkMast.getWrkNo());
                        if (staProtocol.getWorkNo().intValue() != wrkMast.getWrkNo()) {
                            //判断时提升机侧，还是无提升机测
                            if (inSta.getStaNo() == 1014 || inSta.getStaNo() == 1025) {
                                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));
                                wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
                                wrkMast.setModiTime(new Date());
                                wrkMastService.updateById(wrkMast);
                            } else {

                            }
                        }
            for (DevpSlave.Sta inSta : slaveProperties.getDevp().get(0).getInSta()) {
                if (inSta.getStaNo() == 1014 || inSta.getStaNo() == 1025) {
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    try {
                        /*String wmsUrl = "127.0.0.1:8080/fyxcwms";
                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(barcode);
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(staProtocol.getLocType1().shortValue());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
                                .setJson(JSON.toJSONString(param))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        Integer code = jsonObject.getInteger("code");
                        if (code.equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                    Short workNo = staProtocol.getWorkNo();
                    // 尺寸检测异常
                    boolean back = false;
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    String errMsg = "";
                    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);
                        }
                    }

                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && isInEnable(devpThread, inSta.getStaNo()) && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999)) && staProtocol.isPakMk()) {
                        String barcode = staProtocol.getBarcode();
                        if (Cools.isEmpty(barcode) || "?".endsWith(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                            continue;
                        }
                        // 判断重复工作档
                        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_sta_no", inSta.getStaNo()).eq("barcode", barcode));
                        if (wrkMast != null && wrkMast.getWrkSts() == WrkStsType.NEW_INBOUND.sts) {
                            News.error("工作档已存在,工作号={}", wrkMast.getWrkNo());
                            //判断时提升机侧，还是无提升机测
                            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));
                            wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
                            wrkMast.setModiTime(new Date());
                            wrkMastService.updateById(wrkMast);
                        } else if (wrkMast != null && wrkMast.getWrkSts() != WrkStsType.NEW_INBOUND.sts) {
                            continue;
                        }
                        try {
                            SearchLocParam param = new SearchLocParam();
                            param.setBarcode(barcode);
                            param.setIoType(1);
                            param.setSourceStaNo(inSta.getStaNo());
                            param.setLocType1((short) 1);
                            String response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath("/rpc/pakin/loc/v1")
                                    .setJson(JSON.toJSONString(param))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);
                            Integer code = jsonObject.getInteger("code");
                            if (code.equals(200)) {
                                //StartupDto dto = jsonObject.getObject("data", StartupDto.class);
//                                String wmsLocNo = dto.getLocNo();
//                                int row = Integer.parseInt(wmsLocNo.substring(0, 2));
//                                int bay = Integer.parseInt(wmsLocNo.substring(2, 5));
@@ -290,21 +280,107 @@
//                                }catch (Exception e){
//
//                                }
                        } else {
                            String msg = jsonObject.getString("msg");
                            HashMap<String, String> hashMap = new HashMap<>();
                            hashMap.put("msg", msg);
                            hashMap.put("sta", inSta.getStaNo().toString());
                            new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath("/rpc/led/getError")
                                    .setJson(JSON.toJSONString(hashMap))
                                    .build()
                                    .doPost();
                            News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                        }*/
                    } catch (Exception e) {
                        e.printStackTrace();
                            } else {
                                String msg = jsonObject.getString("msg");
                                HashMap<String, String> hashMap = new HashMap<>();
                                hashMap.put("msg", msg);
                                hashMap.put("sta", inSta.getStaNo().toString());
                                new HttpHandler.Builder()
                                        .setUri(wmsUrl)
                                        .setPath("/rpc/led/getError")
                                        .setJson(JSON.toJSONString(hashMap))
                                        .build()
                                        .doPost();
                                News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                            }
                        } catch (Exception e) {
                            log.error("调用wms报错1，{}", e.getMessage());
                        }
                    }
                } else if (inSta.getStaNo() == 1012 || inSta.getStaNo() == 1022) {
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } 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();
                        // 判断重复工作档
                        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_sta_no", inSta.getStaNo()).eq("barcode", barcode));
                        if (wrkMast == null) {
                            try {
                                SearchLocParam param = new SearchLocParam();
                                param.setBarcode(barcode);
                                param.setIoType(1);
                                param.setSourceStaNo(inSta.getStaNo());
                                param.setLocType1((short) 1);
                                String response = new HttpHandler.Builder()
                                        .setUri(wmsUrl)
                                        .setPath("/rpc/pakin/loc/v1")
                                        .setJson(JSON.toJSONString(param))
                                        .build()
                                        .doPost();
                                JSONObject jsonObject = JSON.parseObject(response);
                                Integer code = jsonObject.getInteger("code");
                                if (code.equals(200)) {

                                } else {
                                    String msg = jsonObject.getString("msg");
                                    HashMap<String, String> hashMap = new HashMap<>();
                                    hashMap.put("msg", msg);
                                    hashMap.put("sta", inSta.getStaNo().toString());
                                    new HttpHandler.Builder()
                                            .setUri(wmsUrl)
                                            .setPath("/rpc/led/getError")
                                            .setJson(JSON.toJSONString(hashMap))
                                            .build()
                                            .doPost();
                                    News.error("入库申请失败，任务数据={}，请求响应={}", JSON.toJSON(param), JSON.toJSON(jsonObject));
                                }
                            } catch (Exception e) {
                                log.error("调用wms报错2，{}", e.getMessage());
                            }
                        }
                    }
                }
            }
@@ -313,84 +389,249 @@
        }
    }

    public synchronized void generateInboundWrk2() {
        DevpSlave devpSlave = slaveProperties.getDevp().get(0);
        // 遍历堆垛机出库站
        for (DevpSlave.Sta inSta : devpSlave.getInSta()) {
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocol = devpThread.getStation().get(inSta);
            if (staProtocol == null) {
                return;
            } else {
                staProtocol = staProtocol.clone();
            }
            Short finishWorkNo = staProtocol.getFinishWorkNo();
            WrkMast wrkMast = wrkMastService.selectByWorkNo(Integer.valueOf(finishWorkNo));
            if (wrkMast != null) {
                if (wrkMast.getSourceStaNo() == 1015 || wrkMast.getSourceStaNo() == 1026) {

                    //调度车辆
//                    boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(null, staProtocol.getLocNo(), wrkMast.getLocNo(), param.getShuttleNo(), "TRANSPORT_DEVP");
//                    if (!dispatchShuttle) {
//                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，调度至取货点失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                        return;
//                    }
    public synchronized void noLiftIn() {
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", WrkStsType.INBOUND_DEVICE_RUN.sts).in("source_sta_no", 1014, 1025));
        for (WrkMast wrkMast : wrkMasts) {
            if (wrkMast.getWrkSts() == WrkStsType.INBOUND_DEVICE_RUN.sts) {
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getSourceStaNo() + 1);
                if (staProtocol == null) {
                    continue;
                } else {
                    //判断提升机
                    staProtocol = staProtocol.clone();
                }
                if ((Utils.getLev(wrkMast.getLocNo()) != 1 && wrkMast.getSourceStaNo() == 1014) || (Utils.getLev(wrkMast.getLocNo()) != 5 && wrkMast.getSourceStaNo() == 1025)) {
                    //判断提升机是否有其他任务
                    WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(1, wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
                    if (liftWrkMast != null) {
                        if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                            News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), 1);
                            continue;
                        }
                    }
                    wrkMast.setLiftNo(1);
                }
                Short finishWorkNo = staProtocol.getFinishWorkNo();
                if (finishWorkNo == null) {
                    continue;
                }


                String locNo = "1200301";
                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.info("{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    continue;
                }


                boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleNoLift(wrkMast.getWrkNo(), locNo, wrkMast.getLocNo(), "TRANSPORT_DEVP");
                if (!dispatchShuttle) {
                    News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                    continue;
                } else {
                    News.info("{}任务，调度小车失成功", 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());
                } else {
                    setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                }
            }
        }

    }


    public void outFirst() {
        DevpSlave devpSlave = slaveProperties.getDevp().get(0);
        // 遍历堆垛机出库站
        Date now = new Date();
        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
        List<WrkMast> wrkSts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", WrkStsType.NEW_OUTBOUND.sts).in("sta_no", 1013, 1024));
        for (WrkMast wrkMast : wrkSts) {
            if (devpThread == null) {
                continue;
            }
            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getStaNo());
            if (staProtocol == null) {
                continue;
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                continue;
            }
            if (!isOutEnable(devpThread, wrkMast.getStaNo())) {
                News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                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());
                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());
            } else {
                WrkMast wrkMast1 = wrkMastService.selectByMainWrkNo(wrkMast.getWrkNo());
                News.info("{}任务，移动任务生成成功——1", wrkMast1.getWrkNo());
            }
        }
    }

    /**
     * 出库到出库口
     */
    public synchronized void stnToOutStn() {
        ShuttleThread shuttleThread1 = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, 1);
        ShuttleThread shuttleThread2 = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, 2);
        ShuttleProtocol status1 = shuttleThread1.getStatus();
        ShuttleProtocol status2 = shuttleThread2.getStatus();
        List<String> loc = new ArrayList<>();
        if (status1 != null) {
            loc.add(status1.getCurrentLocNo());
        }
        if (status2 != null) {
            loc.add(status2.getCurrentLocNo());
        }
        DevpSlave devpSlave = slaveProperties.getDevp().get(0);
        // 遍历堆垛机出库站
        for (DevpSlave.Sta inSta : devpSlave.getInSta()) {
            if (inSta.getStaNo() == 1014 || inSta.getStaNo() == 1025) {
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
                List<WrkMast> wrkSts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts));
        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
        for (DevpSlave.Sta outSta : devpSlave.getOutSta()) {
            if (outSta.getStaNo() == 1013 || outSta.getStaNo() == 1024) {
                List<WrkMast> wrkSts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts).eq("sta_no", outSta.getStaNo()));
                for (WrkMast wrkMast : wrkSts) {
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    StaProtocol staProtocol = devpThread.getStation().get(outSta.getStaNo() + 2);
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    if (staProtocol.isAutoing() && !staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {

                    if (staProtocol.isAutoing() && staProtocol.isLoading()) {
                        // 查询工作档
                        if (wrkMast == null) {
                            continue;
                        }

                        String sourceLocNo = "1200305";
                        String locNo = "1300105";
                        if (wrkMast.getStaNo() == 1013) {
                            sourceLocNo = "1200301";
                            locNo = "1300101";
                            if (loc.contains(locNo)) {
                                locNo = "1100101";
                            }
                        } else {
                            if (loc.contains(locNo)) {
                                locNo = "1100105";
                            }
                        }

                        boolean dispatchShuttle = shuttleDispatchUtils.shuttleMoveGenerate(wrkMast.getWrkNo(), sourceLocNo, locNo, wrkMast.getShuttleNo(), null, false);
                        if (!dispatchShuttle) {
                            News.taskInfo(wrkMast.getWrkNo(), "{}小车，挪车调度至取货点失败", wrkMast.getShuttleNo());
                            continue;
                        }

                        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));
                        wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                        wrkMast.setWrkSts(WrkStsType.OUTBOUND_DEVP_RUN.sts);
                        wrkMast.setModiTime(new Date());
                        wrkMast.setShuttleNo(null);
                        wrkMastService.updateById(wrkMast);

                        setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                    }
                }
            } else {

            }
        }
    }


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

    /**
     * 初始化实时地图
     */
    public synchronized void initRealtimeBasMap() {
        //初始化配置
//        WrkStsType[] values = WrkStsType.values();
//        for (int i = 0; i < values.length; i++) {
//            BasWrkStatus basWrkStatus = wrkStatusService.selectById(values[i].sts);
//            if (basWrkStatus == null) {
//                basWrkStatus = new BasWrkStatus();
//                basWrkStatus.setWrkDesc(values[i].sts+"."+values[i].desc);
//                basWrkStatus.setWrkSts(values[i].sts);
//                basWrkStatus.setModiTime(new Date());
//                basWrkStatus.setAppeTime(new Date());
//                basWrkStatus.setAppeUser(9527L);
//                basWrkStatus.setModiUser(9527L);
//                wrkStatusService.insert(basWrkStatus);
//            }
//        }
        try {

            List<BasMap> basMaps = basMapService.selectList(new EntityWrapper<BasMap>().orderBy("lev", true));
            for (BasMap basMap : basMaps) {
                Integer lev = basMap.getLev();
@@ -449,7 +690,7 @@
            }

            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftSta.getLocNo());//调度小车到货物所在输送站点进行取货
                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, liftSta.getLocNo(), null);//调度小车到货物所在输送站点进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }
@@ -530,12 +771,191 @@
    /**
     * 出库  ===>>  四向穿梭车出库作业下发
     */
    public synchronized void shuttleOutExecute() {
//    public synchronized void shuttleOutExecute() {
//        try {
//            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_OUTBOUND.sts));
//            for (WrkMast wrkMast : wrkMasts) {
//                boolean step1 = this.shuttleOutExecuteStep1(wrkMast);//小车搬出库中
//                if (!step1) {
//                    continue;
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

    /**
     * 出库-小车搬出库中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
//    public boolean shuttleOutExecuteStep1(WrkMast wrkMast) {
//        //101.生成出库任务 => 102.小车搬运中
//        if (wrkMast.getWrkSts() == WrkStsType.NEW_OUTBOUND.sts) {
//            Integer liftNo = wrkMast.getLiftNo();
//            if (liftNo == null) {
//                //通过输送线站号获取提升机号
//                liftNo = ForkLiftUtils.getConveyorBindLiftNo(wrkMast.getStaNo());
//                if (liftNo == null) {
//                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
//                    return false;
//                }
//
//                //判断提升机是否有其他任务
//                WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftNo);
//                if (liftWrkMast != null) {
//                    if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
//                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftNo);
//                        return false;
//                    }
//                }
//
//                wrkMast.setLiftNo(liftNo);
//                wrkMast.setModiTime(new Date());
//                wrkMastService.updateById(wrkMast);
//                return false;
//            }
//
//            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
//            if (forkLiftThread == null) {
//                return false;
//            }
//            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
//            if (forkLiftProtocol == null) {
//                return false;
//            }
//
//            //判断提升机是否处于出库模式
//            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于出库模式，禁止出库", wrkMast.getWrkNo());
//                return false;
//            }
//
//            //获取源站
//            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByLev(liftNo, Utils.getLev(wrkMast.getSourceLocNo()));
//            if (liftSta == null) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
//                return false;
//            }
//
//            if (liftSta.getHasCar()) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点存在小车，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
//                return false;
//            }
//
//            if (liftSta.getHasTray()) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点有托盘，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
//                return false;
//            }
//
//            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
//                //强制预留一台小车给入库任务
//                int lev = Utils.getLev(wrkMast.getSourceLocNo());
//                //获取当前楼层有几台可用小车
//                int shuttleCount = shuttleDispatchUtils.getShuttleCountByLev(lev);
//                if (shuttleCount >= 2) {//只有可用小车数量大于2，才进行入库任务预留小车
//                    int shuttleWrkInObligateCount = 1;//预留小车数量
//                    Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "shuttleWrkInObligateCount").eq("status", 1));
//                    if (config != null) {
//                        shuttleWrkInObligateCount = Integer.parseInt(config.getValue());
//                    }
//                    //可用出库小车数量(给入库任务预留一台车)
//                    int useShuttleCount = shuttleCount - shuttleWrkInObligateCount;
//                    //查询楼层已分配车辆的出库任务数量
//                    List<WrkMast> wrkMasts = wrkMastService.selectShuttleOutWrkByLev(lev);
//                    if (wrkMasts.size() >= useShuttleCount) {
//                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，当前楼层可用小车{}台，出库任务已分配{}台，系统等待中。", wrkMast.getWrkNo(), useShuttleCount, wrkMasts.size());
//                        return false;
//                    }
//                }
//                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, wrkMast.getSourceLocNo(), null);//调度小车到货物所在库位进行取货
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中。", wrkMast.getWrkNo(), result ? "成功" : "失败");
//                return false;
//            }
//
//            //获取四向穿梭车线程
//            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
//            if (shuttleThread == null) {
//                return false;
//            }
//            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
//            if (shuttleProtocol == null) {
//                return false;
//            }
//            if (!shuttleThread.isIdle()) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            //判断小车是否到达货物库位
//            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
//                //小车不在输送站点位置
//                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
//            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
//            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
//            assignCommand.setAuto(true);//自动模式
//
//            //获取小车到输送站点行走命令
//            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), liftSta.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
//            if (commands == null) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
//            if (liftCommand == null) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            List<ShuttleCommand> liftCommand2 = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
//            if (liftCommand2 == null) {
//                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取下降命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            commands.add(0, liftCommand.get(0));
//            commands.add(liftCommand2.get(0));
//            assignCommand.setCommands(commands);
//
//            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);//小车搬运中  101.生成出库任务 ==> 102.小车搬运中
//            wrkMast.setSourceStaNo(liftSta.getStaNo());
//            wrkMast.setModiTime(new Date());
//            wrkMast.setSystemMsg("");//清空消息
//            if (wrkMastService.updateById(wrkMast)) {
//                //下发任务
//                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
//                //触发通知
//                notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_TRANSPORT);
//                return false;
//            }
//            return false;
//        }
//        return true;
//    }
    public synchronized void liftInExecute() {
        try {
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_OUTBOUND.sts));
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_INBOUND.sts, WrkStsType.INBOUND_DEVICE_RUN.sts, WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts).in("source_sta_no", 1012, 1022, 1031));
            for (WrkMast wrkMast : wrkMasts) {
                boolean step1 = this.shuttleOutExecuteStep1(wrkMast);//小车搬出库中
                boolean step0 = this.liftInExecuteStep0(wrkMast);//设备上走
                if (!step0) {
                    continue;
                }

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

                boolean step2 = this.liftInExecuteStep2(wrkMast);//触发搬运任务
                if (!step2) {
                    continue;
                }
            }
@@ -544,159 +964,463 @@
        }
    }

    /**
     * 出库-小车搬出库中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    public boolean shuttleOutExecuteStep1(WrkMast wrkMast) {
        //101.生成出库任务 => 102.小车搬运中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_OUTBOUND.sts) {
            Integer liftNo = wrkMast.getLiftNo();
            if (liftNo == null) {
                //通过输送线站号获取提升机号
                liftNo = ForkLiftUtils.getConveyorBindLiftNo(wrkMast.getStaNo());
                if (liftNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
    private boolean liftInExecuteStep0(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.NEW_INBOUND.sts) {
            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getSourceStaNo());
            if (staProtocol == null) {
                return false;
            }
            int led = 1;
            if (wrkMast.getSourceStaNo() == 1022) {
                led = 3;
            } else if (wrkMast.getSourceStaNo() == 1031) {
            }
            // 尺寸检测异常
            boolean back = false;
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led);
            String errMsg = "";
            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) {
                    MessageQueue.offer(SlaveType.Led, led, new Task(3, errMsg));
                    ledThread.error(errMsg);
                }
            }
            String barcode = staProtocol.getBarcode();


            if (!staProtocol.isLoading()) {
                News.info("{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }
            if (wrkMast.getSourceStaNo() != 1031) {
                if (!staProtocol.isAutoing()) {
                    News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }

                //判断提升机是否有其他任务
                WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftNo);
                if (liftWrkMast != null) {
                    if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftNo);
                        return false;
                    }
                if (Cools.isEmpty(barcode) || "?".endsWith(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                    return false;
                }

                wrkMast.setLiftNo(liftNo);
                wrkMast.setModiTime(new Date());
                wrkMastService.updateById(wrkMast);
                return false;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
            if (forkLiftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                return false;
            }

            //判断提升机是否处于出库模式
            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于出库模式，禁止出库", wrkMast.getWrkNo());
                return false;
            }

            //获取源站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByLev(liftNo, Utils.getLev(wrkMast.getSourceLocNo()));
            if (liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;
            }

            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点存在小车，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
                return false;
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点有托盘，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
                return false;
            }

            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                //强制预留一台小车给入库任务
                int lev = Utils.getLev(wrkMast.getSourceLocNo());
                //获取当前楼层有几台可用小车
                int shuttleCount = shuttleDispatchUtils.getShuttleCountByLev(lev);
                if (shuttleCount >= 2) {//只有可用小车数量大于2，才进行入库任务预留小车
                    int shuttleWrkInObligateCount = 1;//预留小车数量
                    Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "shuttleWrkInObligateCount").eq("status", 1));
                    if (config != null) {
                        shuttleWrkInObligateCount = Integer.parseInt(config.getValue());
                    }
                    //可用出库小车数量(给入库任务预留一台车)
                    int useShuttleCount = shuttleCount - shuttleWrkInObligateCount;
                    //查询楼层已分配车辆的出库任务数量
                    List<WrkMast> wrkMasts = wrkMastService.selectShuttleOutWrkByLev(lev);
                    if (wrkMasts.size() >= useShuttleCount) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，当前楼层可用小车{}台，出库任务已分配{}台，系统等待中。", wrkMast.getWrkNo(), useShuttleCount, wrkMasts.size());
                        return false;
                    }
                if (!staProtocol.getBarcode().equals(wrkMast.getBarcode())) {
                    News.info("{}任务，{}站点，托盘码不匹配，站点托盘码：{}，任务托盘码：{}", wrkMast.getWrkNo(), staProtocol.getSiteId(), staProtocol.getBarcode(), wrkMast.getBarcode());
                    return false;
                }
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中。", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }

            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(1, wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), 1);
                    return false;
                }
            }

            //判断小车是否到达货物库位
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            short staNo = 1012;
            if (wrkMast.getSourceStaNo() == 1022) {
                staNo = 1023;
            } else if (wrkMast.getSourceStaNo() == 1031) {
                staNo = 1032;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式
            staProtocol = staProtocol.clone();
            staProtocol.setStaNo(staNo);
            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
            boolean result = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));

            //获取小车到输送站点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), liftSta.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            List<ShuttleCommand> liftCommand2 = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
            if (liftCommand2 == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取下降命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            commands.add(0, liftCommand.get(0));
            commands.add(liftCommand2.get(0));
            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);//小车搬运中  101.生成出库任务 ==> 102.小车搬运中
            wrkMast.setSourceStaNo(liftSta.getStaNo());
            wrkMast.setModiTime(new Date());
            wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                //触发通知
                notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_TRANSPORT);
                setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                return false;
            }
            return false;
        }

        return true;
    }

    private boolean liftInExecuteStep1(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_DEVICE_RUN.sts) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return false;
            }

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

            if (!liftThread.isIdle()) {
                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());
                return false;
            }

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

            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();

            Integer sourceStaNo = wrkMast.getSourceStaNo();
            if (wrkMast.getSourceStaNo() == 1022) {
                sourceStaNo = 1023;
            } else if (wrkMast.getSourceStaNo() == 1031) {
                sourceStaNo = 1032;
            }

            StaProtocol staProtocol = station.get(sourceStaNo);
            if (staProtocol == null) {
                return false;
            }

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

            if (!staProtocol.isLoading()) {
                News.info("{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }
            if (sourceStaNo == 1023) {
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            } else if (sourceStaNo == 1012) {
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            } else if (sourceStaNo == 1032) {
                if (staProtocol.getFinishWorkNo().intValue() != wrkMast.getWrkNo()) {
                    News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                    return false;
                }
            }

            String locNo = "0200305";
            if (wrkMast.getSourceStaNo() == 1012) {
                locNo = "0200301";
            } else if (wrkMast.getSourceStaNo() == 1032) {
                locNo = "0200308";
            }
            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleNoLift(wrkMast.getWrkNo(), locNo, wrkMast.getLocNo(), "TRANSPORT_LIFT");
            if (!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                return false;
            }

            int lev = 101;
            if (wrkMast.getSourceStaNo() == 1021) {
                lev = 100 + Utils.getLev(wrkMast.getLocNo());
            } else if (wrkMast.getSourceStaNo() == 1031) {
                lev = 100 + Utils.getLev(wrkMast.getLocNo());
            }
            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getPalletInCommand(wrkMast.getWrkNo(), sourceStaNo, lev);
            LiftCommand liftCommand = liftCommands.get(0);

            int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
            liftCommand.setTaskNo(deviceWrk);//更换随机任务号

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            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());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }

    private boolean liftInExecuteStep2(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return false;
            }

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

            if (!liftThread.isIdle()) {
                return false;
            }

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

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

            wrkMast.setWrkSts(WrkStsType.INBOUND_SHUTTLE_RUN.sts);
            // TODO 测试中发现不能解禁，因为提升机里存在托盘，就不能解禁，不然另一辆小车可能会近提升机
            //wrkMast.setLiftNo(null);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                return false;
            }
            return false;
        }

        return true;
    }

    public synchronized void liftOutExecute() {
        try {
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_OUTBOUND.sts, WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts).in("sta_no", 1011, 1021, 1031));
            for (WrkMast wrkMast : wrkMasts) {
                boolean step1 = this.liftOutExecuteStep1(wrkMast);//触发搬运任务
                if (!step1) {
                    continue;
                }

                boolean step2 = this.liftOutExecuteStep2(wrkMast);//提升机搬运
                if (!step2) {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private boolean liftOutExecuteStep1(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.NEW_OUTBOUND.sts) {
            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getStaNo());
            if (staProtocol == null) {
                return false;
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", 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());
                    return false;
                }
            }

            String locNo = "0200305";
            if (wrkMast.getStaNo() == 1011) {
                locNo = "0200301";
            } else if (wrkMast.getStaNo() == 1031) {
                locNo = "0200308";
            }
            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttleS(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), locNo, "TRANSPORT_LIFT");
            if (!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                return false;
            } else {
                News.info("{}任务，无提升机处调度小车成功", wrkMast.getWrkNo());
            }

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                return false;
            }
            return false;
        }
        return true;
    }

    private boolean liftOutExecuteStep2(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return false;
            }

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

            if (!liftThread.isIdle()) {
                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());
                return false;
            }

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

            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getStaNo());
            if (staProtocol == null) {
                return false;
            }

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

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

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

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.PALLET_OUT.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);

            if (wrkMastService.updateById(wrkMast)) {
                setLedData(Integer.parseInt(wrkMast.getWmsWrkNo()), wrkMast.getStaNo());
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }

@@ -796,6 +1520,7 @@
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_11.sts) {
                            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_12.sts);
                            wrkMast.setLiftNo(null);
                            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_IN_NO_LIFT_13.sts) {
@@ -808,6 +1533,7 @@
                            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) {
                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_11.sts);
                            wrkMast.setLiftNo(null);
                            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_8.sts) {
@@ -900,7 +1626,7 @@
        //小车移动至站点  501.生成移库任务 ==> 502.小车取货中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_LOC_MOVE.sts) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物点进行取货
                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, wrkMast.getSourceLocNo(), null);//调度小车到货物点进行取货
                News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");

                if (result) {
@@ -1026,10 +1752,13 @@
                        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN.sts) {
                            //3.提升机搬运中 ==> 4.提升机搬运完成
                            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts);
                            wrkMast.setLiftNo(null);//释放提升机
                        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_LIFT_RUN.sts) {
                            //104.提升机搬运中 ==> 109.出库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                            if (wrkMast.getStaNo() == 1031) {
                                wrkMast.setWrkSts(WrkStsType.OUTBOUND_DEVP_RUN_2.sts);
                            } else {
                                wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                            }
                            wrkMast.setLiftNo(null);//释放提升机
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_LIFT_RUN.sts) {
                            //306.提升机搬运中 ==> 307.提升机搬运完成
@@ -1056,7 +1785,6 @@
                            //提升机至小车层 ==> 提升机至小车层完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_5.sts);
                        }

                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            liftThread.setSyncTaskNo(0);
@@ -1074,12 +1802,62 @@
    }

    /**
     * 输送线任务完成
     */
    public synchronized void devpFinished() {
        try {
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            Map<Integer, StaProtocol> station = devpThread.getStation();
            WrkMast wrkMast = null;
            for (StaProtocol staProtocol : station.values()) {
                if ((staProtocol.getSiteId() == 1013 || staProtocol.getSiteId() == 1024) && staProtocol.isLoading()) {
                    wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getFinishWorkNo()).eq("wrk_sts", WrkStsType.OUTBOUND_DEVP_RUN.sts));
                    if (wrkMast != null) {
                        wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            News.info("输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        } else {
                            News.error("输送线已确认且任务完成状态,复位失败，但未找到工作档。输送线号={}，完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        }
                    }
                } else if (staProtocol.getSiteId() == 1031 && staProtocol.isLoading()) {
                    wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getFinishWorkNo()).eq("wrk_sts", WrkStsType.OUTBOUND_DEVP_RUN_2.sts));
                    if (wrkMast != null) {
                        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));
                        wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            News.info("输送线已确认且任务完成状态。输送线号={},完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        } else {
                            News.error("输送线已确认且任务完成状态,复位失败，但未找到工作档。输送线号={}，完结工作号={}", staProtocol.getSiteId(), staProtocol.getFinishWorkNo());
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 异常信息记录
     */
    public void recErr() {
        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);
        }
@@ -1566,11 +2344,17 @@
    }

    private void shuttleMoveExecuteTransportLift(WrkMast wrkMast) {
        LiftThread liftThread = LiftUtils.getRecentLift(wrkMast.getLocNo());
        if (liftThread == null) {
            return;
        WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
        LiftThread liftThread;
        if (wrkMast1 != null && wrkMast1.getLiftNo() != null) {
            liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
        } else {
            liftThread = LiftUtils.getRecentLift(wrkMast.getLocNo());
            if (liftThread == null) {
                return;
            }
        }

        //liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast1.getLiftNo());
        String liftLocNo = liftThread.getLiftLocNo(Utils.getLev(wrkMast.getLocNo()));
        if (Utils.getRow(liftLocNo) == Utils.getRow(wrkMast.getSourceLocNo()) && Utils.getBay(liftLocNo) == Utils.getBay(wrkMast.getSourceLocNo())) {
            //取货位置是提升机
@@ -1582,14 +2366,46 @@
    }

    private void shuttleMoveExecuteTransportNoLift(WrkMast wrkMast) {
        if (12 == Utils.getRow(wrkMast.getSourceLocNo()) && 3 == Utils.getBay(wrkMast.getSourceLocNo())) {
        WrkMast mainWrk = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
        if (mainWrk != null && mainWrk.getIoType() == 1) {
            //入库
            noLiftInService.shuttleMoveExecute(wrkMast);
        } else {
            noLiftInService.shuttleMoveExecute(wrkMast, mainWrk.getStaNo(), Utils.getLev(mainWrk.getLocNo()));
        } else if (mainWrk != null && mainWrk.getIoType() == 101) {
            //出库
            noLiftOutService.shuttleMoveExecute(wrkMast);
            noLiftOutService.shuttleMoveExecute(wrkMast, mainWrk.getStaNo(), Utils.getLev(mainWrk.getSourceLocNo()));
        }
    }


    /**
     * 入出库模式切换函数
     */
    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);
            WrkMast pakout = wrkMastService.selectWorkingPakout(1031);
            if (pakout != null) {
                if (devpThread.ioModeOf2_5 != IoModeType.PAKOUT_MODE) {
                    // 出库切换中
                    WrkMast pakin = wrkMastService.selectWorkingPakin(1032);
                    if (pakin == null && !devpThread.getStation().get(1031).isLoading()
                            && !devpThread.getStation().get(1032).isLoading()) {
                        // 出库模式
                        devpThread.ioModeOf2_5 = IoModeType.PAKOUT_MODE;
                    }
                }
            } else {
                // 入库模式
                devpThread.ioModeOf2_5 = IoModeType.PAKIN_MODE;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}