#

Junjie

2025-02-13 1d6c5111cf4aafc076aa3f8ddf488f6cc3cf6cb1

#

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

@@ -101,7 +101,7 @@

    @GetMapping("/test")
    public R test() {
        notifyUtils.notify(String.valueOf(SlaveType.Shuttle), 1, "9999", NotifyMsgType.SHUTTLE_MOVING);
        notifyUtils.notify("task", 1, "9999", NotifyMsgType.SHUTTLE_MOVING, "data");
        notifyUtils.notify(String.valueOf(SlaveType.Shuttle), 2, "9999", NotifyMsgType.SHUTTLE_MOVE_COMPLETE);
        return R.ok();
    }

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

@@ -4,7 +4,6 @@
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.zy.asrs.domain.enums.NotifyMsgType;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
@@ -23,6 +22,7 @@
import com.zy.core.model.protocol.*;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.*;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -46,12 +46,6 @@
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkMastLogMapper wrkMastLogMapper;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private BasShuttleErrLogService basShuttleErrLogService;
    @Autowired
    private BasLiftErrLogService basLiftErrLogService;
@@ -64,13 +58,9 @@
    @Autowired
    private BasMapService basMapService;
    @Autowired
    private BasLiftService basLiftService;
    @Autowired
    private ShuttleDispatchUtils shuttleDispatchUtils;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private BasLiftOptService basLiftOptService;
    @Autowired
    private ConfigService configService;
    @Autowired
@@ -87,441 +77,6 @@
    private ForkLiftAction forkLiftAction;
    @Autowired
    private NotifyUtils notifyUtils;


//    /**
//     * 组托
//     * 入库站，根据条码扫描生成入库工作档，工作状态 2
//     */
//    public void generateStoreWrkFile() {
//        try {
//            // 根据输送线plc遍历
//            for (DevpSlave devp : slaveProperties.getDevp()) {
//                // 遍历入库口
//                for (DevpSlave.Sta inSta : devp.getInSta()) {
//                    // 获取入库站信息
//                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.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) {
//                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
//                        }
//                        continue;
//                    }
//
//                    // 判断是否满足入库条件
//                    if (staProtocol.isAutoing() && staProtocol.isLoading()
//                            && staProtocol.isInEnable()
//                            && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999))
//                    ) {
//
//                        // 获取条码扫描仪信息
//                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
//                        if (barcodeThread == null) {
//                            continue;
//                        }
//                        String barcode = barcodeThread.getBarcode();
//                        if (!Cools.isEmpty(barcode)) {
////                        News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
//                            if ("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode) || "00000000".equals(barcode)) {
////                            staProtocol.setWorkNo((short) 32002);
////                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
////                            devpThread.setPakMk(staProtocol.getSiteId(), false);
////                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//
//                                // led 异常显示
//                                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
//                                if (ledThread != null) {
//                                    String errorMsg = "扫码失败，请重试";
//                                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
//                                }
//                                continue;
//                            }
//                        } else {
////                        staProtocol.setWorkNo((short) 32002);
////                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
////                        devpThread.setPakMk(staProtocol.getSiteId(), false);
////                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//
////                        // led 异常显示
////                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
////                        if (ledThread != null) {
////                            String errorMsg = "扫码失败，请重试";
////                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
////                        }
//                            continue;
//                        }
//
//                        // 过滤盘点/拣料/并板任务
//                        WrkMast wrkMast1 = wrkMastMapper.selectPickStepByBarcode(barcode);
//                        if (null != wrkMast1) {
//                            continue;
//                        }
//
//                        // 判断重复工作档
//                        WrkMast wrkMast2 = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
//                        if (wrkMast2 != null) {
//                            News.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast2.getWrkNo());
//                            continue;
//                        }
//
//                        try {
//                            LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//                            SearchLocParam param = new SearchLocParam();
//                            param.setBarcode(barcode);
//                            param.setIoType(1);
//                            param.setSourceStaNo(inSta.getStaNo());
//                            param.setLocType1(locTypeDto.getLocType1());
//                            String response = new HttpHandler.Builder()
//                                    .setUri(wmsUrl)
//                                    .setPath("/rpc/pakin/loc/v2")
//                                    .setJson(JSON.toJSONString(param))
//                                    .build()
//                                    .doPost();
//                            JSONObject jsonObject = JSON.parseObject(response);
//                            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
//                            Integer code = jsonObject.getInteger("code");
//                            if (code.equals(200)) {
//                                StartupDto dto = jsonObject.getObject("data", StartupDto.class);
//                                // plc 处理
//                                barcodeThread.setBarcode("");
////                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
////                            staProtocol.setStaNo(dto.getStaNo().shortValue());
////                            devpThread.setPakMk(staProtocol.getSiteId(), false);
////
////                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
////                            if (!result) {
////                                throw new CoolException("更新plc站点信息失败");
////                            }
//
//                                // 判断重复工作档
//                                WrkMast wrkMast = wrkMastMapper.selectPakInStep11(inSta.getStaNo());
//                                if (wrkMast == null) {
//                                    continue;
//                                }
//
//                                // 更新工作主档
//                                wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
//                                wrkMast.setModiTime(new Date());
//                                if (wrkMastMapper.updateById(wrkMast) == 0) {
//                                    News.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
//                                }
//
//                            } else if (code == 500) {
//                                if (ledThread != null) {
//                                    String errorMsg = jsonObject.getString("msg");
//                                    if (!Cools.isEmpty(errorMsg)) {
//                                        MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
//                                        ledThread.setLedMk(false);
//                                    }
//                                }
//                                News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v2", JSON.toJSONString(param), response);
//                            } else if (code == 700) {
////                            staProtocol.setWorkNo((short) 32002);
////                            staProtocol.setRollback102(1);//102站回退信号
////                            devpThread.setPakMk(staProtocol.getSiteId(), false);
////                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(5, staProtocol));
//
//                                // led 异常显示
//                                if (ledThread != null) {
//                                    String errorMsg = barcode + "托盘识别异常，请先进行组托！";
//                                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
//                                    ledThread.setLedMk(false);
//                                }
//                            }
//                        } catch (Exception e) {
//                            e.printStackTrace();
//                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        }
//                    }
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

//    /**
//     * 拣料、并板再入库
//     */
//    @Transactional
//    public synchronized void stnToCrnStnPick(){
//        try {
//            for (DevpSlave devp : slaveProperties.getDevp()) {
//                // 遍历拣料入库口
//                for (DevpSlave.Sta pickSta : devp.getPickInSta()) {
//                    // 获取拣料入库站信息
//                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
//                    StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
//                    if (staProtocol == null) {
//                        continue;
//                    } else {
//                        staProtocol = staProtocol.clone();
//                    }
//                    if (staProtocol.isAutoing()
//                            && staProtocol.isLoading()
//                            && staProtocol.isInEnable()
////                        && (staProtocol.getWorkNo() > 0)
//                            && staProtocol.isPakMk()) {
//
//                        // 获取条码扫描仪信息
//                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
//                        if (barcodeThread == null) {
//                            continue;
//                        }
//                        String barcode = barcodeThread.getBarcode();
//                        if (Cools.isEmpty(barcode)) {
//                            continue;
//                        }
//                        if ("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
//                            continue;
//                        }
//
//                        WrkMast wrkMast = wrkMastMapper.selectPickStepByBarcode(barcode);
//                        if (wrkMast == null) {//找不到工作档
//                            continue;
//                        }
//
//                        if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104)
//                                || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo())) {
//                            continue;
//                        }
//
////                        //*********************同库位组校验*********************
////                        boolean flag = false;
////                        String th = "";
////                        List<String> innerLoc = Utils.getGroupInnerLoc(wrkMast.getSourceLocNo());
////                        for (String loc : innerLoc) {
////                            LocMast locMast = locMastService.selectById(loc);
////                            if (locMast == null) {
////                                continue;
////                            }
////
////                            if (!locMast.getLocSts().equals("F")) {
////                                flag = true;
////                                th = loc + "库位存在未回库任务";
////                                break;
////                            }
////                        }
////                        if (flag) {
////                            News.info(th);
////                            continue;
////                        }
////                        //*********************同库位组校验*********************
//
////                        // 保存工作主档历史档
////                        if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
////                            News.info(wrkMast.getWrkNo() + "保存工作主档历史档失败");
////                            continue;
////                        }
//
//                        try {
//                            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());//源库位
//                            SearchLocParam param = new SearchLocParam();
//                            param.setWrkNo(wrkMast.getWrkNo());
//                            param.setBarcode(wrkMast.getBarcode());
//                            param.setIoType(wrkMast.getIoType());
//                            param.setSourceStaNo(pickSta.getStaNo());
//                            param.setLiftNo(pickSta.getLiftNo());
//                            param.setLocType1(locMast.getLocType1());
//                            String response = new HttpHandler.Builder()
//                                    .setUri(wmsUrl)
//                                    .setPath("/rpc/pakin/loc/v2")
//                                    .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);
//
////                                //获取回库提升机目标站
////                                LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(pickSta.getLiftNo(), Utils.getLev(dto.getLocNo()));
////                                if (liftStaProtocol == null) {
////                                    News.info(wrkMast.getWrkNo() + "获取回库提升机目标站失败");
////                                    continue;
////                                }
////
////                                // 更新工作档数据状态
////                                wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54
////                                wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
////                                wrkMast.setSourceStaNo(dto.getSourceStaNo()); // 源站
////                                wrkMast.setStaNo(liftStaProtocol.getStaNo());//目标站
////                                wrkMast.setLocNo(dto.getLocNo()); // 目标库位
////                                wrkMast.setShuttleNo(null); // 穿梭车清空
////                                wrkMast.setLiftNo(null);// 提升机清空
////                                wrkMast.setModiTime(new Date());
////                                if (wrkMastMapper.updateById(wrkMast) == 0) {
////                                    News.info(wrkMast.getWrkNo() + "更新工作档数据状态失败");
////                                    continue;
////                                }
//                            } else if (code == 500) {
//                                News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v2", JSON.toJSONString(param), response);
//                            }
//                        } catch (Exception e) {
//                            e.printStackTrace();
//                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        }
//                    }
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

//    /**
//     * 盘点再入库
//     */
//    @Transactional
//    public synchronized void stnToCrnStnPlate(){
//        try {
//            for (DevpSlave devp : slaveProperties.getDevp()) {
//                // 遍历拣料入库口
//                for (DevpSlave.Sta pickSta : devp.getPickInSta()) {
//                    // 获取拣料入库站信息
//                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
//                    StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
//                    if (staProtocol == null) {
//                        continue;
//                    } else {
//                        staProtocol = staProtocol.clone();
//                    }
//                    if (staProtocol.isAutoing()
//                            && staProtocol.isLoading()
//                            && staProtocol.isInEnable()
////                            && (staProtocol.getWorkNo() > 0)
//                            && staProtocol.isPakMk()) {
//
//                        // 获取条码扫描仪信息
//                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, pickSta.getBarcode());
//                        if (barcodeThread == null) {
//                            continue;
//                        }
//                        String barcode = barcodeThread.getBarcode();
//                        if (Cools.isEmpty(barcode)) {
//                            continue;
//                        }
//                        if ("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
//                            continue;
//                        }
//                        WrkMast wrkMast = wrkMastMapper.selectByBarcode(barcode);
//                        if (wrkMast == null) {//找不到工作档
//                            continue;
//                        }
//
//                        if ((wrkMast.getIoType() != 107)
//                                || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo())) {
//                            continue;
//                        }
//
////                        // 保存工作主档历史档
////                        if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
////                            News.info(wrkMast.getWrkNo() + "保存工作主档历史档失败");
////                            continue;
////                        }
//
//                        //盘点找新库位
//                        try {
//                            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());//源库位
//                            SearchLocParam param = new SearchLocParam();
//                            param.setWrkNo(wrkMast.getWrkNo());
//                            param.setBarcode(wrkMast.getBarcode());
//                            param.setIoType(107);//盘点
//                            param.setSourceStaNo(pickSta.getStaNo());
//                            param.setLiftNo(pickSta.getLiftNo());
//                            param.setLocType1(locMast.getLocType1());
//                            String response = new HttpHandler.Builder()
//                                    .setUri(wmsUrl)
//                                    .setPath("/rpc/pakin/loc/v2")
//                                    .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);
//
////                                //获取回库提升机目标站
////                                LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(pickSta.getLiftNo(), Utils.getLev(dto.getLocNo()));
////                                if (liftStaProtocol == null) {
////                                    News.info(wrkMast.getWrkNo() + "获取回库提升机目标站失败");
////                                    continue;
////                                }
////
////                                // 更新工作档数据状态
////                                wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 107->57
////                                wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
////                                wrkMast.setSourceStaNo(dto.getSourceStaNo()); // 源站
////                                wrkMast.setStaNo(liftStaProtocol.getStaNo());//目标站
////                                wrkMast.setLocNo(dto.getLocNo()); // 目标库位
////                                wrkMast.setShuttleNo(null); // 穿梭车清空
////                                wrkMast.setLiftNo(null);// 提升机清空
////                                wrkMast.setModiTime(new Date());
////                                if (wrkMastMapper.updateById(wrkMast) == 0) {
////                                    News.info(wrkMast.getWrkNo() + "更新工作档数据状态失败");
////                                    continue;
////                                }
//
////                                staProtocol.setStaNo(dto.getSourceStaNo().shortValue());//写入目标站
////                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//
//                            } else if (code == 500) {
//                                News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v2", JSON.toJSONString(param), response);
//                            }
//                        } catch (Exception e) {
//                            e.printStackTrace();
//                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        }
//
//                    }
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

    /**
     * 初始化实时地图
@@ -558,271 +113,294 @@
        }
    }

//    /**
//     * 入库  ===>>  四向穿梭车入库作业下发
//     */
//    public synchronized void shuttleInExecute() {
//        try {
//            List<WrkMast> wrkMasts = wrkMastMapper.selectInStep4();
//            for (WrkMast wrkMast : wrkMasts) {
//                //获取源站
//                BasDevp sourceBasDevp = basDevpService.selectById(wrkMast.getSourceStaNo());
//                if (sourceBasDevp == null) {
//                    continue;//站点不存在
//                }
//
//                //获取目标站
//                LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(sourceBasDevp.getLiftNo(), Utils.getLev(wrkMast.getLocNo()));
//                if (liftStaProtocol == null) {
//                    continue;//站点不存在
//                }
//
//                // 判断是否满足入库条件，自动、空闲、有物
//                if (!(liftStaProtocol.getModel() && !liftStaProtocol.getBusy() && liftStaProtocol.getHasTray())) {
//                    News.info("{}任务，输送站点状态不满足入库。输送站点:{}", wrkMast.getWrkNo(), JSON.toJSONString(liftStaProtocol));
//                    continue;
//                }
//
//                boolean step1 = this.shuttleInExecuteStep1(wrkMast, liftStaProtocol);//小车搬入库中
//                if (!step1) {
//                    continue;
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    /**
     * 入库  ===>>  四向穿梭车入库作业下发
     */
    public synchronized void shuttleInExecute() {
        try {
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .in("wrk_sts"
                            , WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts
                    ));
            for (WrkMast wrkMast : wrkMasts) {
                boolean step1 = this.shuttleInExecuteStep1(wrkMast);//小车搬入库中
                if (!step1) {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 入库-小车搬入库中
//     * 如需主方法执行continue，请返回false
//     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
//     */
//    public boolean shuttleInExecuteStep1(WrkMast wrkMast, LiftStaProtocol liftStaProtocol) {
//        if (wrkMast.getWrkSts() == 4) {
//            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
//                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo());//调度小车到货物所在输送站点进行取货
//                News.info("{}任务，调度小车{}系统等待中", 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.info("{}任务，{}小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
////            //判断小车令牌是否未被占领
////            if (shuttleProtocol.getToken() != 0) {
////                News.info("{}任务，{}小车，令牌已被独占，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
////                return false;//小车已被独占，禁止再派发任务
////            }
//
//            //判断小车是否存在移动任务
//            WrkMast hasMoveWorking = wrkMastMapper.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
//            if (hasMoveWorking != null) {
//                News.info("{}任务，{}小车，存在移动任务，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;//存在移动任务，禁止执行入库任务
//            }
//
//            //判断小车是否到达输送站点库位
//            if (!shuttleProtocol.getCurrentLocNo().equals(liftStaProtocol.getLocNo())) {
//                //小车不在输送站点位置
//                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在输送站点进行取货
//                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            //小车已抵达输送站点位置，进行搬运货物
//            ShuttleOperaResult result = ShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo());
//            if (result == null) {//路径计算失败
//                News.info("{}任务，{}小车，路径计算失败，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            //创建分配命令
//            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
//            assignCommand.setTaskMode(ShuttleTaskModeType.PAK_IN.id);//入库模式
//            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//            assignCommand.setCommands(result.getCommands());//运行命令
//            assignCommand.setNodes(result.getNodes());//路径节点
//
//            wrkMast.setWrkSts(5L);//4.提升机搬运完成 => 5.小车搬运中
//            wrkMast.setModiTime(new Date());
////            shuttleProtocol.setToken(wrkMast.getWrkNo());//独占小车令牌
//            if (wrkMastMapper.updateById(wrkMast) > 0) {
//                //下发任务
//                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//            }
//
//            return false;
//        }
//        return true;
//    }
    /**
     * 入库-小车搬入库中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    public boolean shuttleInExecuteStep1(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts) {
            //获取目标站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;
            }

//    /**
//     * 出库  ===>>  四向穿梭车出库作业下发
//     */
//    public synchronized void shuttleOutExecute() {
//        try {
//            for (WrkMast wrkMast : wrkMastMapper.selectBy2125()) {
//                boolean step1 = this.shuttleOutExecuteStep1(wrkMast);//小车搬出库中
//                if (!step1) {
//                    continue;
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
//    /**
//     * 出库-小车搬出库中
//     * 如需主方法执行continue，请返回false
//     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
//     */
//    public boolean shuttleOutExecuteStep1(WrkMast wrkMast) {
//        //21.生成出库任务 => 22.小车搬运中
//        if (wrkMast.getWrkSts() == 21) {
//            EntityWrapper<StaDesc> wrapper = new EntityWrapper<>();
//            wrapper.eq("type_no", wrkMast.getIoType());//路径类型
//            wrapper.eq("stn_no", wrkMast.getStaNo());//出库站点编号
//            StaDesc staDesc = staDescService.selectOne(wrapper);
//            if (staDesc == null) {
//                News.info("{}任务，出库路径不存在", wrkMast.getWrkNo());
//                return false;//出库路径不存在
//            }
//
//            //获取出库站点
//            BasDevp basDevp = basDevpService.selectById(wrkMast.getStaNo());
//            if (basDevp == null) {
//                return false;//出库站点不存在
//            }
//
////            if (!basDevp.getAutoing().equals("Y")) {
////                News.info("{}任务，{}站点，不是自动状态",wrkMast.getWrkNo(),basDevp.getDevNo());
////                return false;//不是自动状态
////            }
////
////            if (!basDevp.getOutEnable().equals("Y")) {
////                News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), basDevp.getDevNo());
////                return false;//出库站点不可出
////            }
//
//            Integer liftNo = basDevp.getLiftNo();//搜索出库提升机是否存在入库任务，如存在禁止出库
//            List<WrkMast> liftWrkMasts = wrkMastMapper.selectInWrkMastByLiftNo(liftNo);
//            if (!liftWrkMasts.isEmpty()) {
//                News.info("{}任务，{}号提升机，存在入库任务，系统禁止出库", wrkMast.getWrkNo(), liftNo);
//                return false;//存在入库任务，禁止出库
//            }
//
//            //同库位组校验
//            List<String> outerLoc = Utils.getGroupOuterLoc(wrkMast.getSourceLocNo());
//            List<LocMast> outerLocMasts = locMastService.selectNotEmptyLocNos(outerLoc);
//            if (!outerLocMasts.isEmpty()) {
//                News.info("{}任务，浅库位存在货物，系统等待中", wrkMast.getWrkNo());
//                return false;//浅库位存在未执行任务
//            }
//
//            //获取源站
//            LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(basDevp.getLiftNo(), Utils.getLev(wrkMast.getSourceLocNo()));
//            if (liftStaProtocol == null) {
//                return false;//找不到站点
//            }
//
//            if (!(liftStaProtocol.getModel() && !liftStaProtocol.getBusy() && !liftStaProtocol.getHasTray())) {
//                News.info("{}任务，{}内部输送站，不满足自动、空闲、无托盘状态", wrkMast.getWrkNo(), liftStaProtocol.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.info("{}任务，当前楼层可用小车{}台，出库任务已分配{}台，系统等待中。", wrkMast.getWrkNo(), useShuttleCount, wrkMasts.size());
//                        return false;
//                    }
//                }
//                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
//                News.info("{}任务，调度小车{}系统等待中。", wrkMast.getWrkNo(), result ? "成功" : "失败");
//                return false;
//            }
//
//            //获取四向穿梭车线程
//            NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
//            if (shuttleThread == null) {
//                return false;
//            }
//            NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//            if (shuttleProtocol == null) {
//                return false;
//            }
//            if (!shuttleProtocol.isIdle()) {
//                News.info("{}任务，{}小车，忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//            //判断小车令牌是否未被占领
//            if (shuttleProtocol.getToken() != 0) {
//                News.info("{}任务，{}小车，令牌已被独占，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;//小车已被独占，禁止再派发任务
//            }
//
//            //判断小车是否到达货物库位
//            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
//                //小车不在输送站点位置
//                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
//                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            //小车已抵达货物位置，进行搬运货物
//            ShuttleOperaResult result = ShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), liftStaProtocol.getLocNo());//将货物搬运至提升机输送站点
//            if (result == null) {//出库路径计算失败
//                News.info("{}任务，{}小车，路径计算失败，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                return false;
//            }
//
//            //创建分配命令
//            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());//任务号
//            assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());//出库模式
//            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//            assignCommand.setCommands(result.getCommands());//运行命令
//            assignCommand.setNodes(result.getNodes());//路径节点
//
//            wrkMast.setWrkSts(22L);//21.生成出库任务 => 22.小车搬运中
//            wrkMast.setModiTime(new Date());
//            shuttleProtocol.setToken(wrkMast.getWrkNo());//独占小车令牌
//            if (wrkMastMapper.updateById(wrkMast) > 0) {
//                //下发任务
//                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//            }
//            return false;
//        }
//        return true;
//    }
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftSta.getLocNo());//调度小车到货物所在输送站点进行取货
                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 hasMoveWorking = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if (hasMoveWorking != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}号小车，存在移动任务，禁止派发任务", wrkMast.getShuttleNo());
                return false;//存在移动任务，禁止执行入库任务
            }

            //判断小车是否到达输送站点库位
            if (!shuttleProtocol.getCurrentLocNo().equals(liftSta.getLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftSta.getLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在输送站点进行取货
                News.info("{}任务，{}小车，未到达输送站点，系统等待中", 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(liftSta.getLocNo(), wrkMast.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.INBOUND_SHUTTLE_RUN.sts);//小车搬运中  4.提升机搬运完成 ==> 5.小车搬运中
            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()), NotifyMsgType.SHUTTLE_TRANSPORT);
                return false;
            }
            return false;
        }
        return true;
    }

    /**
     * 出库  ===>>  四向穿梭车出库作业下发
     */
    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(), wrkMast.getLiftNo());
                        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.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;
            }

            //判断小车是否到达货物库位
            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()), NotifyMsgType.SHUTTLE_TRANSPORT);
                return false;
            }
            return false;
        }
        return true;
    }

    /**
     * 四向穿梭车任务完成
@@ -844,7 +422,15 @@
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
                    if (wrkMast != null) {
                        if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE.sts) {
                        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_SHUTTLE_RUN.sts) {
                            //5.小车搬运中 ==> 9.入库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_INBOUND.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN.sts) {
                            //102.小车搬运中 ==> 103.小车搬运完成
                            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE.sts) {
                            //302.小车移动至站点 ==> 303.小车移动至站点完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
@@ -870,32 +456,6 @@
                        } else {
                            continue;
                        }
//                        switch (wrkMast.getWrkSts().intValue()) {
////                            case 5://5.小车搬运中 ==> 9.入库完成
////                                wrkMast.setWrkSts(9L);
////                                shuttleProtocol.setTaskNo(0);
////                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
////                                    //释放小车令牌
////                                    shuttleProtocol.setToken(0);
////                                }
////                                break;
////                            case 22://22.小车搬运中 ==> 23.小车搬运完成
////                                wrkMast.setWrkSts(23L);
////                                shuttleProtocol.setTaskNo(0);
////                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
////                                    //释放小车令牌
////                                    shuttleProtocol.setToken(0);
////                                }
////                                break;
//                            case 302:
//                                wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
//                                break;
//                            case WrkStsType.MOVE_SHUTTLE.sts:
//                                wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
//                                shuttleThread.setSyncTaskNo(0);
//                                break;
//                            default:
//                        }

                        if (wrkMastService.updateById(wrkMast)) {
                            //设置四向穿梭车为空闲状态
@@ -1021,329 +581,300 @@
        return true;
    }

//    /**
//     * 提升机任务
//     */
//    public synchronized void liftIoExecute() {
//        try {
//            for (LiftSlave liftSlave : slaveProperties.getLift()) {
//                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
//                if (liftThread == null) {
//                    continue;
//                }
//                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//                if (liftProtocol == null) {
//                    continue;
//                }
//
//                if (!liftProtocol.isIdle()) {
//                    News.info("{}号提升机，忙碌中", liftSlave.getId());
//                    continue;
//                }
//
//                //判断提升机令牌是否被占用
//                if (liftProtocol.getToken() != 0) {
//                    News.info("{}号提升机，令牌已被独占", liftSlave.getId());
//                    continue;
//                }
//
//                //搜索是否有待处理的任务
//                List<WrkMast> wrkMasts = wrkMastMapper.selectLiftStep223103();
//                if (wrkMasts.isEmpty()) {
//                    continue;
//                }
//
//                for (WrkMast wrkMast : wrkMasts) {
//                    //搜索是否有其他任务占用了提升机，如果占用提升机的任务和当前任务相同，则运行执行
//                    WrkMast wrkMast1 = wrkMastMapper.selectLiftWrkMast(liftProtocol.getLiftNo().intValue());
//                    if (wrkMast1 != null && wrkMast1.getWrkNo().intValue() != wrkMast.getWrkNo().intValue()) {
//                        News.info("{}号提升机，被其他任务{}占用且和当前任务{}不相同，禁止派发", liftSlave.getId(), wrkMast1.getWrkNo(), wrkMast.getWrkNo());
//                        continue;
//                    }
//
//                    boolean stepIn = this.liftIoExecuteStepIn(wrkMast);//提升机入库
//                    if (!stepIn) {
//                        continue;
//                    }
//
//                    boolean stepOut = this.liftIoExecuteStepOut(wrkMast);//提升机出库
//                    if (!stepOut) {
//                        continue;
//                    }
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
//    /**
//     * 提升机入库
//     * 如需主方法执行continue，请返回false
//     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
//     */
//    private boolean liftIoExecuteStepIn(WrkMast wrkMast) {
//        //--------------------------------------提升机入库-----------------------------------------//
//        Date now = new Date();
//
//        //2.设备上走 ==> 3.提升机搬运中
//        if (wrkMast.getWrkSts() == 2) {
//            //获取源站
//            BasDevp sourceBasDevp = basDevpService.selectById(wrkMast.getSourceStaNo());
//            if (sourceBasDevp == null) {
//                return false;//找不到站点
//            }
//
//            if (!sourceBasDevp.getInEnable().equals("Y")) {
//                News.info("{}任务，{}源站，没有可入信号", wrkMast.getWrkNo(), sourceBasDevp.getDevNo());
//                return false;//站点不可入
//            }
//
//            Integer barcodeId = Utils.getBarcodeIdByStaNo(wrkMast.getSourceStaNo());
//            if (barcodeId == null) {
//                News.info("{}任务，{}源站，找不到可用条码器ID", wrkMast.getWrkNo(), sourceBasDevp.getDevNo());
//                return false;//站点不可入
//            }
//
//            BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, barcodeId);
//            if (barcodeThread == null) {
//                News.info("{}任务，{}源站，条码器{}线程为空", wrkMast.getWrkNo(), sourceBasDevp.getDevNo(), barcodeId);
//                return false;//站点不可入
//            }
//            String barcode = barcodeThread.getBarcode();
//            if(!Cools.isEmpty(barcode)) {
//                if(!("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode))) {
//                    //存在条码值，判断是否和当前工作档一致
//                    if (!barcode.equals(wrkMast.getBarcode())) {
//                        News.info("{}任务,{}站点，条码器{}值{}与工作档条码值{}不一致，系统跳过执行", wrkMast.getWrkNo(), sourceBasDevp.getDevNo(), barcodeId, barcode,wrkMast.getBarcode());
//                        return false;//站点不可入
//                    }
//                }
//            }else {
//                return false;
//            }
//
//            //判断提升机整个三楼是否都处于入库模式
//            Integer outInModel1 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 1);
//            Integer outInModel2 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 5);
//            Integer outInModel3 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 8);
//            if (outInModel1 == null || outInModel2 == null || outInModel3 == null) {
//                News.info("{}任务，没有出入库模式", wrkMast.getWrkNo());
//                return false;//不存在出入库模式
//            }
//
//            if (outInModel1 == 2 || outInModel2 == 2 && outInModel3 == 2) {
//                News.info("{}任务，有站点处于出库模式，禁止入库", wrkMast.getWrkNo());
//                return false;//只要有一个处于出库模式，禁止入库
//            }
//
//            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, sourceBasDevp.getLiftNo());
//            if (liftThread == null) {
//                return false;
//            }
//            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//            if (liftProtocol == null) {
//                return false;
//            }
//            if (!liftProtocol.isIdle()) {
//                News.info("{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;
//            }
//            //判断提升机令牌是否未被占领
//            if (liftProtocol.getToken() != 0) {
//                News.info("{}任务，{}号提升机，令牌已被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//提升机已被独占，禁止再派发任务
//            }
//
//            //判断提升机内是否有小车
//            if (liftProtocol.getHasCar()) {
//                News.info("{}任务，{}号提升机，提升机内部有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//有小车，禁止派发
//            }
//
//            //判断提升机内是否有托盘
//            if (liftProtocol.getHasTray()) {
//                News.info("{}任务，{}号提升机，提升机内部有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//有托盘，禁止派发
//            }
//
//            //判断提升机是否有其他任务
//            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
//            if (liftWrkMast != null) {
//                News.info("{}任务，{}号提升机，当前提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//当前提升机存在未完成任务，等待下一次轮询
//            }
//
//            //获取源站对应的牛眼提升机站点编号(起点编号)
//            Integer startSta = Integer.parseInt(sourceBasDevp.getQrCodeValue());
//            //获取提升机站点
//            LiftStaProtocol targetStaProtocol = NyLiftUtils.getLiftStaByLev(liftThread.getSlave().getId(), Utils.getLev(wrkMast.getLocNo()));
//            if (targetStaProtocol == null) {
//                return false;//站点不存在
//            }
//
//            if (targetStaProtocol.getHasTray()) {
//                News.info("{}任务，{}号提升机，{}站点，提升机站点有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo(), targetStaProtocol.getStaNo());
//                return false;//提升机站点有托盘，禁止派发
//            }
//
//            Integer targetSta = targetStaProtocol.getStaNo();
//
//            //获取提升机命令
//            NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftProtocol.getLiftNo().intValue(), NyLiftTaskModelType.MOVE_TRAY.id, startSta, targetSta, wrkMast.getWrkNo());
//            if (wrkMast.getIoType() == 53 || wrkMast.getIoType() == 57) {
//                //拣料再回库，重新分配设备工作号
//                int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
//                BasLiftOpt basLiftOpt = basLiftOptService.selectByDeviceWrk(String.valueOf(deviceWrk), liftThread.getSlave().getId());
//                if (basLiftOpt != null) {
//                    News.info("{}任务，{}号提升机，设备工作号出现重复情况，请联系技术人员支持。", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                    return false;
//                }
//                liftCommand.setTaskNo((short) deviceWrk);
//            }
//            ArrayList<NyLiftCommand> commands = new ArrayList<>();
//            commands.add(liftCommand);
//
//            //提交到线程去工作
//            LiftAssignCommand assignCommand = new LiftAssignCommand();
//            assignCommand.setCommands(commands);
//            assignCommand.setLiftNo(liftProtocol.getLiftNo());
//            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
//            assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_TRAY.id.shortValue());
//
//            wrkMast.setWrkSts(3L);//2.设备上走 ==> 3.提升机搬运中
//            wrkMast.setLiftNo(liftThread.getSlave().getId());//任务档绑定提升机号
//            wrkMast.setModiTime(now);
//            liftProtocol.setToken(wrkMast.getWrkNo());//独占提升机令牌
//            if (wrkMastMapper.updateById(wrkMast) > 0) {
//                //下发任务
//                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
//            }
//
//            return false;
//        }
//        return true;
//    }
//
//    /**
//     * 提升机出库
//     * 如需主方法执行continue，请返回false
//     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
//     */
//    private boolean liftIoExecuteStepOut(WrkMast wrkMast) {
//        //--------------------------------------提升机出库-----------------------------------------//
//        Date now = new Date();
//
//        //23.小车搬运完成 ==> 24.提升机搬运中
//        if (wrkMast.getWrkSts() == 23) {
//            NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
//            if (shuttleThread == null) {
//                return false;
//            }
//
//            //获取出库站点(目标站)
//            BasDevp basDevp = basDevpService.selectById(wrkMast.getStaNo());
//            if (basDevp == null) {
//                News.info("{}任务，出库站点不存在，禁止派发", wrkMast.getWrkNo());
//                return false;//出库站点不存在
//            }
//
//            //获取源站对应的牛眼提升机站点编号(起点编号)
//            LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(basDevp.getLiftNo(), Utils.getLev(wrkMast.getSourceLocNo()));
//            if (liftStaProtocol == null) {
//                News.info("{}任务，找不到站点，禁止派发", wrkMast.getWrkNo());
//                return false;//找不到站点
//            }
//            Integer startSta = liftStaProtocol.getStaNo();
//
//            NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//            if (shuttleProtocol.getCurrentLocNo().equals(liftStaProtocol.getLocNo())) {
//                //小车还在输送站点
//                //调度小车避让
//                boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkMast.getSourceLocNo()), wrkMast.getShuttleNo(), shuttleThread);
//                if (!result) {
//                    News.info("{}任务，{}小车，小车在输送站点调度小车避让失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
//                    return false;
//                }
//            }
//
//            if (!basDevp.getAutoing().equals("Y")) {
//                News.info("{}任务，{}站点，没有自动信号，禁止派发", wrkMast.getWrkNo(), basDevp.getDevNo());
//                return false;//出库站点不可出
//            }
//
//            if (basDevp.getLoading().equals("Y")) {
//                News.info("{}任务，{}站点，存在有物信号，禁止派发", wrkMast.getWrkNo(), basDevp.getDevNo());
//                return false;//出库站点不可出
//            }
//
//            if (!basDevp.getOutEnable().equals("Y")) {
//                News.info("{}任务，{}站点，没有可出信号，禁止派发", wrkMast.getWrkNo(), basDevp.getDevNo());
//                return false;//出库站点不可出
//            }
//
//            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, basDevp.getLiftNo());
//            if (liftThread == null) {
//                return false;
//            }
//            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//            if (liftProtocol == null) {
//                return false;
//            }
//
//            if (!liftProtocol.isIdle()) {
//                News.info("{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;
//            }
//            //判断提升机令牌是否未被占领
//            if (liftProtocol.getToken() != 0) {
//                News.info("{}任务，{}号提升机，令牌已被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//提升机已被独占，禁止再派发任务
//            }
//            //判断提升机是否有其他任务
//            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
//            if (liftWrkMast != null) {
//                News.info("{}任务，{}号提升机，当前提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
//                return false;//当前提升机存在未完成任务，等待下一次轮询
//            }
//
//            //获目标站源站对应的输送站点
//            BasDevp targetBasDevp = basDevpService.selectById(wrkMast.getStaNo());
//            if (targetBasDevp == null) {
//                News.info("{}任务，{}站点，站点不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getStaNo());
//                return false;//站点不存在
//            }
//            //获取牛眼提升机站点编号(目标编号)
//            Integer targetSta = Integer.parseInt(targetBasDevp.getQrCodeValue());
//
//            //获取提升机命令
//            NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftThread.getSlave().getId(), NyLiftTaskModelType.MOVE_TRAY.id, startSta, targetSta, wrkMast.getWrkNo());
//
//            ArrayList<NyLiftCommand> commands = new ArrayList<>();
//            commands.add(liftCommand);
//
//            //提交到线程去工作
//            LiftAssignCommand assignCommand = new LiftAssignCommand();
//            assignCommand.setCommands(commands);
//            assignCommand.setLiftNo(liftProtocol.getLiftNo());
//            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
//            assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_TRAY.id.shortValue());
//
//            wrkMast.setWrkSts(24L);//23.小车搬运完成 ==> 24.提升机搬运中
//            wrkMast.setLiftNo(liftThread.getSlave().getId());//任务档绑定提升机号
//            wrkMast.setModiTime(now);
//            liftProtocol.setToken(wrkMast.getWrkNo());//独占提升机令牌
//            if (wrkMastMapper.updateById(wrkMast) > 0) {
//                //下发任务
//                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
//            }
//
//            return false;
//        }
//        return true;
//    }
//
    /**
     * 货叉提升机任务
     */
    public synchronized void forkLiftIoExecute() {
        try {
            //搜索是否有待处理的任务
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .in("wrk_sts", WrkStsType.NEW_INBOUND.sts, WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts));
            if (wrkMasts.isEmpty()) {
                return;
            }

            for (WrkMast wrkMast : wrkMasts) {
                Integer liftNo = wrkMast.getLiftNo();
                if (liftNo == null) {
                    //未分配提升机
                    Integer staNo = wrkMast.getIoType() == WrkIoType.IN.id ? wrkMast.getSourceStaNo() : wrkMast.getStaNo();
                    liftNo = ForkLiftUtils.getConveyorBindLiftNo(staNo);
                    if(liftNo == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                        continue;
                    }

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

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

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

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

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

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

                boolean stepIn = this.liftIoExecuteStepIn(wrkMast);//提升机入库
                if (!stepIn) {
                    continue;
                }

                boolean stepOut = this.liftIoExecuteStepOut(wrkMast);//提升机出库
                if (!stepOut) {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 提升机入库
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean liftIoExecuteStepIn(WrkMast wrkMast) {
        //--------------------------------------提升机入库-----------------------------------------//
        Date now = new Date();

        //1.生成入库任务 ==> 3.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_INBOUND.sts) {
            //获取目标输送站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftSta == null) {
                return false;//找不到站点
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘", wrkMast.getWrkNo());
                return false;
            }

            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在小车", wrkMast.getWrkNo());
                return false;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftSta.getLiftNo());
            if (forkLiftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                return false;
            }
            if (!forkLiftThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftSta.getLiftNo());
                return false;
            }

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

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

            //检测楼层是否有穿梭车
            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(liftSta.getLev());
            if (!checkLevHasShuttle) {
                if (wrkMast.getShuttleNo() != null) {
                    return false;
                }

                //获取小车待机位
                String standbyLocNo = Utils.getShuttleStandbyLocNo(liftSta.getLocNo());
                if (standbyLocNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，获取小车待机位失败", wrkMast.getWrkNo());
                    return false;
                }

                //调度小车去待机位
                boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), standbyLocNo);
                if (!dispatchShuttle) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失败", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            //获取提升机命令
            List<ForkLiftCommand> liftCommands = forkLiftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getLev());
            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
            commands.addAll(liftCommands);

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

            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);//提升机搬运中  1.生成入库任务 ==> 3.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
            }
            return false;
        }
        return true;
    }

    /**
     * 提升机出库
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean liftIoExecuteStepOut(WrkMast wrkMast) {
        //--------------------------------------提升机出库-----------------------------------------//
        //103.小车搬运完成 ==> 104.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if(shuttleProtocol == null) {
                return false;
            }

            //获取源站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            if (liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，找不到站点，禁止派发", wrkMast.getWrkNo());
                return false;//找不到站点
            }

            if (shuttleProtocol.getCurrentLocNo().equals(liftSta.getLocNo())) {
                //小车还在输送站点
                //获取小车待机位
                String standbyLocNo = Utils.getShuttleStandbyLocNo(liftSta.getLocNo());
                if(standbyLocNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，获取小车待机位失败", wrkMast.getWrkNo());
                    return false;
                }
                //调度小车去待机位
                boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), standbyLocNo, wrkMast.getShuttleNo());
                if (!dispatchShuttle) {
                    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;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftSta.getLiftNo());
            if (forkLiftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                return false;
            }
            if (!forkLiftThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftSta.getLiftNo());
                return false;
            }

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

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

            //请求上级系统，是否允许出库
            boolean outMission = ForkLiftUtils.queryOutMission(wrkMast.getStaNo());
            if (!outMission) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，上级系统不允许出库", wrkMast.getWrkNo());
                return false;
            }

            //获取提升机命令
            List<ForkLiftCommand> liftCommands = forkLiftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getLev(), wrkMast.getStaNo());
            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
            commands.addAll(liftCommands);

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

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);//提升机搬运中  103.生成入库任务 ==> 104.提升机搬运中
            wrkMast.setShuttleNo(null);//释放小车
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
            }
            return false;
        }
        return true;
    }

    /**
     * 货叉提升机任务完成
     */
@@ -1364,34 +895,20 @@
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
                    if (wrkMast != null) {
                        switch (wrkMast.getWrkSts().intValue()) {
//                            case 3://3.提升机搬运中 ==> 4.提升机搬运完成
//                                wrkMast.setWrkSts(4L);
//                                wrkMast.setLiftNo(null);//释放提升机
//                                if (liftProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放提升机令牌
//                                    liftProtocol.setToken(0);
//                                }
//                                break;
//                            case 24://24.提升机搬运中 ==> 25.提升机搬运完成
//                                wrkMast.setWrkSts(25L);
//                                if (wrkMast.getIoType() == 11) {//库位移转
//                                    wrkMast.setWrkSts(4L);//4.提升机搬运完成
//                                } else {
//                                    if (wrkMast.getMk() == null || !wrkMast.getMk().equals("Y")) {
//                                        //不需要用到机械臂，直接转29.出库完成
//                                        wrkMast.setWrkSts(29L);
//                                        wrkMast.setShuttleNo(null);//释放小车
//                                        wrkMast.setLiftNo(null);//释放提升机
//                                        wrkMast.setModiTime(new Date());
//                                    }
//                                }
//                                break;
                            case 306://306.提升机搬运中 ==> 307.提升机搬运完成
                                wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
                                forkLiftThread.setSyncTaskNo(0);
                                break;
                            default:
                        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN.sts) {
                            //3.提升机搬运中 ==> 4.提升机搬运完成
                            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts);
                            wrkMast.setLiftNo(null);//释放提升机
                            forkLiftThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_LIFT_RUN.sts) {
                            //104.提升机搬运中 ==> 109.出库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                            wrkMast.setLiftNo(null);//释放提升机
                            forkLiftThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_LIFT_RUN.sts) {
                            //306.提升机搬运中 ==> 307.提升机搬运完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
                            forkLiftThread.setSyncTaskNo(0);
                        }

                        wrkMast.setModiTime(new Date());
@@ -1565,107 +1082,6 @@
            }
        }
    }

    // -------------------------------------------------------------------------------

//    /**
//     * 空栈板初始化入库,叉车入库站放货
//     */
//    public void storeEmptyPlt(){
//        try {
//            for (DevpSlave devp : slaveProperties.getDevp()) {
//                // 遍历空板入库口
//                for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
//                    // 获取空板入库站信息
//                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
//                    StaProtocol staProtocol = devpThread.getStation().get(emptyInSta.getStaNo());
//                    if (staProtocol == null) {
//                        continue;
//                    } else {
//                        staProtocol = staProtocol.clone();
//                    }
//                    // 站点条件判断
//                    if (staProtocol.isAutoing()
//                            && staProtocol.isLoading()
//                            && staProtocol.isInEnable()
//                            && staProtocol.isEmptyMk()
//                            && (staProtocol.getWorkNo() == 0 || (staProtocol.getWorkNo() >= 9990 || staProtocol.getWorkNo() <= 9999))
//                            && staProtocol.isPakMk()) {
//
//                        // 获取条码扫描仪信息
//                        String barcode = null;
//                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, emptyInSta.getBarcode());
//                        if (barcodeThread != null) {
//                            String barcode0 = barcodeThread.getBarcode();
//                            if (!Cools.isEmpty(barcode0)) {
////                            News.info("{}号条码扫描器检测条码信息：{}", emptyInSta.getBarcode(), barcode0);
//                                if (!"NG".endsWith(barcode0) && !"NoRead".equals(barcode0) && !"empty".equals(barcode0)) {
//                                    barcode = barcode0;
//                                }
//                            }
//                        }
//
//                        if (!Cools.isEmpty(barcode)) {
//                            WrkMast wrkMast = wrkMastMapper.selectByBarcode(barcode);//条码存在工作档
//                            if (wrkMast != null) {
//                                continue;
//                            }
//                        }
//
//                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());
//
//                        try {
//                            LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//
//                            SearchLocParam param = new SearchLocParam();
//                            param.setIoType(10);
//                            if (!Cools.isEmpty(barcode)) {
//                                param.setBarcode(barcode);
//                            }
//                            param.setSourceStaNo(emptyInSta.getStaNo());
////                        param.setLocType1(locTypeDto.getLocType1());
//                            String response = new HttpHandler.Builder()
//                                    .setUri(wmsUrl)
//                                    .setPath("/rpc/pakin/loc/v2")
//                                    .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);
//                                barcodeThread.setBarcode("");
////                            // 更新站点信息 且 下发plc命令
////                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
////                            staProtocol.setStaNo(dto.getStaNo().shortValue());
////                            devpThread.setPakMk(staProtocol.getSiteId(), false);
////                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
////                            if (!result) {
////                                throw new CoolException("更新plc站点信息失败");
////                            }
//                            } else {
//                                if (ledThread != null) {
//                                    String errorMsg = jsonObject.getString("msg");
//                                    if (!Cools.isEmpty(errorMsg)) {
//                                        MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(3, errorMsg));
//                                    }
//                                }
//                                News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v2", JSON.toJSONString(param), response);
//                            }
//                        } catch (Exception e) {
//                            e.printStackTrace();
//                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        }
//
//                    }
//
//
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

    /**
     * 四向穿梭车电量检测 ===>> 发起充电
@@ -2314,4 +1730,63 @@
        return true;
    }

    //自动切换出入库模式
    public void autoSwitchForkLiftIOMode() {
        for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
            Integer liftNo = forkLiftSlave.getId();
            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
            if (forkLiftThread == null) {
                continue;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                continue;
            }

            //获取入库任务
            List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .eq("lift_no", liftNo)
                    .in("wrk_sts"
                            , WrkStsType.NEW_INBOUND.sts
                            , WrkStsType.INBOUND_DEVICE_RUN.sts
                            , WrkStsType.INBOUND_LIFT_RUN.sts
                            , WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts
                            , WrkStsType.INBOUND_SHUTTLE_RUN.sts
                            , WrkStsType.INBOUND_SHUTTLE_RUN_COMPLETE.sts
                    ));

            //获取出库任务
            List<WrkMast> outWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .eq("lift_no", liftNo)
                    .in("wrk_sts"
                            , WrkStsType.NEW_OUTBOUND.sts
                            , WrkStsType.OUTBOUND_SHUTTLE_RUN.sts
                            , WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts
                            , WrkStsType.OUTBOUND_LIFT_RUN.sts
                            , WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts
                    ));

            if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.NONE)) {
                //未知模式
                if (!inWrkMasts.isEmpty()) {
                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
                } else if (!outWrkMasts.isEmpty()) {
                    forkLiftThread.switchIOMode(ForkLiftIoModeType.OUT);
                }else {
                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
                }
            } else if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.IN)) {
                //入库模式
                if (inWrkMasts.isEmpty() && !outWrkMasts.isEmpty()) {
                    forkLiftThread.switchIOMode(ForkLiftIoModeType.OUT);
                }
            } else if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
                //出库模式
                if (outWrkMasts.isEmpty() && !inWrkMasts.isEmpty()) {
                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
                }
            }
        }
    }

}

 src/main/java/com/zy/asrs/task/WrkMastScheduler.java

@@ -11,7 +11,9 @@
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.core.enums.LocStsType;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkIoType;
import com.zy.core.enums.WrkStsType;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
@@ -248,6 +250,32 @@
                log.info("删除工作主档[workNo={}]失败", wrkMast.getWrkNo());
            }

            if (wrkMast.getIoType() == WrkIoType.IN.id) {
                LocMast locMast = locMastService.queryByLoc(wrkMast.getLocNo());
                locMast.setLocSts(String.valueOf(LocStsType.O));
                locMast.setModiTime(new Date());
                locMastService.updateById(locMast);
            } else if (wrkMast.getIoType() == WrkIoType.OUT.id) {
                LocMast locMast = locMastService.queryByLoc(wrkMast.getSourceLocNo());
                locMast.setLocSts(String.valueOf(LocStsType.O));
                locMast.setModiTime(new Date());
                locMastService.updateById(locMast);
            } else if (wrkMast.getIoType() == WrkIoType.LOC_MOVE.id) {
                LocMast sourceLocMast = locMastService.queryByLoc(wrkMast.getSourceLocNo());
                LocMast locMast = locMastService.queryByLoc(wrkMast.getLocNo());
                if (sourceLocMast.getLocSts().equals(String.valueOf(LocStsType.R))) {
                    sourceLocMast.setLocSts(String.valueOf(LocStsType.F));
                    sourceLocMast.setModiTime(new Date());
                    locMastService.updateById(sourceLocMast);
                }

                if (locMast.getLocSts().equals(String.valueOf(LocStsType.S))) {
                    locMast.setLocSts(String.valueOf(LocStsType.O));
                    locMast.setModiTime(new Date());
                    locMastService.updateById(locMast);
                }
            }

            //上报
            notifyUtils.notify("task", 1, String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.TASK_CANCEL, JSON.toJSONString(wrkMast));
        }

 src/main/java/com/zy/asrs/utils/Utils.java

@@ -1,9 +1,15 @@
package com.zy.asrs.utils;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Arith;
import com.core.common.Cools;
import com.core.common.SpringUtils;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.service.LocMastService;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.utils.NavigatePositionConvert;
import com.zy.common.utils.NavigateUtils;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.ShuttleSlave;
@@ -77,6 +83,29 @@

    public static List<String> getGroupLoc(String locNo) {
        return null;
    }

    //获取除白名单外的指定楼层全部穿梭车xy坐标点
    public static int[] getShuttlePoint(Integer shuttleNo) {
        //获取穿梭车所在节点位置
        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
        if (shuttleThread == null) {
            return null;
        }
        ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
        if (shuttleProtocol == null) {
            return null;
        }

        String currentLocNo = shuttleProtocol.getCurrentLocNo();
        if (currentLocNo == null) {
            return null;
        }

        if (shuttleProtocol.getCurrentLocNo() == null) {
            return null;
        }
        return NavigatePositionConvert.positionToXY(shuttleProtocol.getCurrentLocNo());
    }

    //获取除白名单外的指定楼层全部穿梭车xy坐标点
@@ -182,4 +211,33 @@

        return null;
    }

    //获取小车待机位
    public static String getShuttleStandbyLocNo(String locNo) {
        LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
                .eq("loc_type", "standby")
                .eq("lev1", Utils.getLev(locNo)));
        if (locMasts.isEmpty()) {
            return null;
        }

        Integer recentDistance = Integer.MAX_VALUE;
        String recentLocNo = null;
        for (LocMast locMast : locMasts) {
            //待机位到目标点距离
            List<NavigateNode> currentShuttlePath = navigateUtils.calc(locNo, locMast.getLocNo(), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(0, Utils.getLev(locNo)), null);//搜索空闲穿梭车，使用正常通道地图
            if (currentShuttlePath == null) {
                continue;
            }
            Integer currentAllDistance = navigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
            if (currentAllDistance < recentDistance) {
                recentDistance = currentAllDistance;
                recentLocNo = locMast.getLocNo();
            }
        }

        return recentLocNo;
    }
}

 src/main/java/com/zy/common/utils/ForkLiftUtils.java

@@ -1,5 +1,8 @@
package com.zy.common.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.SpringUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.NavigateNode;
@@ -9,8 +12,11 @@
import com.zy.core.model.protocol.ForkLiftStaProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.ForkLiftThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
@@ -36,7 +42,6 @@

        return null;
    }


    //获取提升机站点
    public static ForkLiftStaProtocol getLiftStaByLev(Integer liftNo, Integer lev) {
@@ -71,4 +76,77 @@
        return targetNodes;
    }

    //通过输送线站号获取对应提升机号
    public static Integer getConveyorBindLiftNo(Integer staNo) {
        ConfigService configService = SpringUtils.getBean(ConfigService.class);
        if (configService == null) {
            return null;
        }

        Config conveyorLiftBindConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "conveyorLiftBind"));
        if(conveyorLiftBindConfig == null) {
            return null;
        }

        List<JSONObject> list = JSON.parseArray(conveyorLiftBindConfig.getValue(), JSONObject.class);
        if (list.isEmpty()) {
            return null;
        }

        for (JSONObject data : list) {
            if(data.getInteger("staNo") == staNo) {
                return data.getInteger("liftNo");
            }
        }

        return null;
    }

    //请求上级系统，是否允许出库
    //查询是否有出库权限
    public static boolean queryOutMission(Integer staNo) {
        ConfigService configService = SpringUtils.getBean(ConfigService.class);
        if (configService == null) {
            return false;
        }

        Config queryOutMissionPathEnableConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "queryOutMissionPathEnable"));
        if (queryOutMissionPathEnableConfig != null) {
            String queryOutMissionPathEnable = queryOutMissionPathEnableConfig.getValue();
            if (!queryOutMissionPathEnable.equals("Y")) {
                return true;//关闭查询出库权限功能
            }
        }

        Config superSystemUriConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "superSystemUri"));
        if (superSystemUriConfig == null) {
            return false;
        }
        String superSystemUri = superSystemUriConfig.getValue();

        Config queryOutMissionPathConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "queryOutMissionPath"));
        if (queryOutMissionPathConfig == null) {
            return false;
        }
        String missionPath = queryOutMissionPathConfig.getValue();

        try {
            HashMap<String, Object> data = new HashMap<>();
            data.put("staNo", staNo);

            String response = new HttpHandler.Builder()
                    .setUri(superSystemUri)
                    .setPath(missionPath)
                    .setJson(JSON.toJSONString(data))
                    .build()
                    .doPost();
            if (response.equals("ok")) {
                return true;//有出库权限
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return false;
    }

}

 src/main/java/com/zy/common/utils/NavigateMapUtils.java

@@ -37,6 +37,12 @@
            }

            //获取小车节点
            int[] shuttlePoint = Utils.getShuttlePoint(shuttleNo);
            if (shuttlePoint == null) {
                return false;
            }

            //获取小车节点-获取除白名单外的指定楼层全部穿梭车xy坐标点
            List<int[]> shuttlePoints = Utils.getShuttlePoints(shuttleNo, lev);

            BasMap basMap = JSON.parseObject(o.toString(), BasMap.class);
@@ -52,6 +58,11 @@
            //检测路径是否被锁定
            if (lock) {
                for (NavigateNode node : nodes) {
                    //判断是否为当前小车
                    if(shuttlePoint[0] == node.getX() && shuttlePoint[1] == node.getY()) {
                        continue;
                    }

                    List<MapNode> listX = listsHasShuttle.get(node.getX());
                    MapNode mapNode = listX.get(node.getY());
                    if (mapNode.getValue() == MapNodeType.LOCK.id) {

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

@@ -41,37 +41,31 @@
                        continue;
                    }

//                    // 入库  ===>> 入库站到堆垛机站，根据条码扫描生成入库工作档
//                    mainService.generateStoreWrkFile(); // 组托

                    //初始化实时地图
                    mainService.initRealtimeBasMap();
//                    // 拣料、并板再入库
//                    mainService.stnToCrnStnPick();
//                    // 盘点再入库
//                    mainService.stnToCrnStnPlate();
//                    // 入库  ===>>  四向穿梭车入库作业下发
//                    mainService.shuttleInExecute();
//                    // 出库  ===>>  四向穿梭车出库作业下发
//                    mainService.shuttleOutExecute();
                    // 入库  ===>>  四向穿梭车入库作业下发
                    mainService.shuttleInExecute();
                    // 出库  ===>>  四向穿梭车出库作业下发
                    mainService.shuttleOutExecute();
                    //四向穿梭车任务完成
                    mainService.shuttleFinished();
                    //执行移库任务
                    mainService.shuttleLocMoveExecute();
//                    //提升机任务
//                    mainService.liftIoExecute();
                    //货叉提升机任务
                    mainService.forkLiftIoExecute();
                    //货叉提升机任务完成
                    mainService.forkLiftFinished();
                    //执行小车移库任务
                    //执行小车移动任务
                    mainService.shuttleMoveExecute();
                    // 异常信息记录
                    mainService.recErr();
//                    // 入库  ===>> 空栈板初始化入库,叉车入库站放货
//                    mainService.storeEmptyPlt();
                    // 穿梭车 ===>> 小车电量检测充电
                    mainService.loopShuttleCharge();
                    mainService.executeShuttleCharge();

                    //自动切换出入库模式
                    mainService.autoSwitchForkLiftIOMode();

                    // 间隔
                    Thread.sleep(200);
                } catch (Exception e) {

 src/main/java/com/zy/core/dispatcher/ShuttleDispatchUtils.java

@@ -226,11 +226,21 @@
            return false;
        }

        //获取主工作档信息
        WrkMast mainWrkMast = wrkMastService.selectByWorkNo(wrkNo);

        //判断是否有其他任务正在使用穿梭车
        WrkMast wrkMast2 = wrkMastService.selectShuttleWorking(shuttleNo);
        if (wrkMast2 != null) {//小车存在其他工作档任务，等待执行完成后再生成新的任务
            News.info("{}号小车，存在其他工作档任务，等待执行完成再生成新的任务", shuttleNo);
            return false;
            if (mainWrkMast == null) {
                News.info("{}号小车，存在其他工作档任务，等待执行完成再生成新的任务", shuttleNo);
                return false;
            }else {
                if (!mainWrkMast.getShuttleNo().equals(shuttleNo)) {
                    News.info("{}号小车，存在其他工作档任务，等待执行完成再生成新的任务", shuttleNo);
                    return false;
                }
            }
        }

        Integer sourceStaNo = null;//小车换层源站点
@@ -277,10 +287,9 @@
        }

        //给工作档绑定小车号
        WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkNo);
        if (wrkMast1 != null) {
            wrkMast1.setShuttleNo(shuttleNo);
            wrkMastService.updateById(wrkMast1);
        if (mainWrkMast != null) {
            mainWrkMast.setShuttleNo(shuttleNo);
            wrkMastService.updateById(mainWrkMast);
        }

        return true;

 src/main/java/com/zy/core/enums/LocStsType.java

@@ -5,6 +5,8 @@
    D,//空板
    F,//在库
    O,//空库
    R,//出库预约
    S,//入库预约
    X,//禁用
    E,//不可放货通道
    W,//母轨道

 src/main/java/com/zy/core/thread/ForkLiftThread.java

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

import com.zy.common.ExecuteSupport;
import com.zy.core.ThreadHandler;
import com.zy.core.enums.ForkLiftIoModeType;
import com.zy.core.enums.ForkLiftProtocolStatusType;
import com.zy.core.enums.ForkLiftTaskModeType;
import com.zy.core.model.CommandResponse;
@@ -35,6 +36,8 @@

    boolean setSyncTaskNo(Integer taskNo);//设置工作号

    boolean switchIOMode(ForkLiftIoModeType type);//切换出入库模式

    int generateDeviceTaskNo(int taskNo, ForkLiftTaskModeType type);//生成硬件设备工作号

    //***************获取命令*****************

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

@@ -19,6 +19,7 @@
import com.zy.core.action.ForkLiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.OutputQueue;
import com.zy.core.enums.ForkLiftIoModeType;
import com.zy.core.enums.ForkLiftProtocolStatusType;
import com.zy.core.enums.ForkLiftTaskModeType;
import com.zy.core.enums.RedisKeyType;
@@ -349,6 +350,15 @@
    }

    @Override
    public boolean switchIOMode(ForkLiftIoModeType type) {
        OperateResult result = siemensS7Net.Write("DB103.12", type.id.shortValue());
        if (result.IsSuccess) {
            return true;
        }
        return false;
    }

    @Override
    public int generateDeviceTaskNo(int taskNo, ForkLiftTaskModeType type) {
        return taskNo;
    }

 src/main/resources/application.yml

@@ -147,18 +147,18 @@
    staRow: 9
    staBay: 6
    sta[0]:
      staNo: 101
      staNo: 1
      lev: 1
      liftNo: ${wcs-slave.forkLift[0].id}
    sta[1]:
      staNo: 102
      staNo: 2
      lev: 2
      liftNo: ${wcs-slave.forkLift[0].id}
    sta[2]:
      staNo: 103
      staNo: 3
      lev: 3
      liftNo: ${wcs-slave.forkLift[0].id}
    sta[3]:
      staNo: 104
      staNo: 4
      lev: 4
      liftNo: ${wcs-slave.forkLift[0].id}

 src/main/resources/sql/20250213165543.nb3

Binary files differ

 src/main/webapp/static/js/locMast/locMast.js

@@ -25,6 +25,7 @@
            ,{field: 'row1', align: 'center',title: '排', sort:true}
            ,{field: 'bay1', align: 'center',title: '列', sort:true}
            ,{field: 'lev1', align: 'center',title: '层', sort:true}
            ,{field: 'locType', align: 'center',title: '库位类型'}
            ,{field: 'modiUser$', align: 'center',title: '修改人员', hide:true}
            ,{field: 'modiTime$', align: 'center',title: '修改时间', hide:true}

@@ -400,20 +401,12 @@
            shade: [0.5,'#000'] //0.1透明度的背景
        });
        var data = {
//            id: $('#id').val(),
            locNo: $('#locNo').val(),
            whsType: $('#whsType').val(),
            pltType: $('#pltType').val(),
            ctnType: $('#ctnType').val(),
            locSts: $('#locSts').val(),
            sheetNo: $('#sheetNo').val(),
            crnNo: $('#crnNo').val(),
            row1: $('#row1').val(),
            bay1: $('#bay1').val(),
            lev1: $('#lev1').val(),
            fullPlt: $('#fullPlt').val(),
            locType1: $('#locType1').val(),
            outEnable: $('#outEnable').val(),
            locType: $('#locType').val(),
            ioTime: top.strToDate($('#ioTime\\$').val()),
            firstTime: top.strToDate($('#firstTime\\$').val()),
            modiUser: $('#modiUser').val(),
@@ -421,15 +414,8 @@
            appeUser: $('#appeUser').val(),
            appeTime: top.strToDate($('#appeTime\\$').val()),
            errorTime: top.strToDate($('#errorTime\\$').val()),
            errorMemo: $('#errorMemo').val(),
            ctnKind: $('#ctnKind').val(),
            scWeight: $('#scWeight').val(),
            invWh: $('#invWh').val(),
            mk: $('#mk').val(),
            barcode: $('#barcode').val(),
            PdcType: $('#PdcType').val(),
            ctnNo: $('#ctnNo').val(),

        };
        $.ajax({
            url: baseUrl+"/locMast/"+name+"/auth",

 src/main/webapp/views/admin/locMast/locMast_detail.html

@@ -21,24 +21,6 @@
                <input id="locNo" class="layui-input" type="text" onkeyup="check(this.id, 'locMast')">
            </div>
        </div>
        <div class="layui-inline"  style="width:31%;display: none">
            <label class="layui-form-label"><span class="not-null">*</span>：</label>
            <div class="layui-input-inline">
                <input id="locType" class="layui-input" type="text" >
            </div>
        </div>
        <div class="layui-inline"  style="width:80%; display: none">
            <label class="layui-form-label">库位类型：</label>
            <div class="layui-input-inline cool-auto-complete">
                <input id="whsType" class="layui-input" type="text" style="display: none">
                <input id="whsType$" class="layui-input cool-auto-complete-div" onclick="autoShow(this.id)" type="text" onfocus=this.blur()>
                <div class="cool-auto-complete-window">
                    <input class="cool-auto-complete-window-input" data-key="basWhsQueryBywhsType" onkeyup="autoLoad(this.getAttribute('data-key'))">
                    <select class="cool-auto-complete-window-select" data-key="basWhsQueryBywhsTypeSelect" onchange="confirmed(this.getAttribute('data-key'))" multiple="multiple">
                    </select>
                </div>
            </div>
        </div>
        <div class="layui-inline"  style="width:80%;">
            <label class="layui-form-label"><span class="not-null">*</span>库位状态：</label>
            <div class="layui-input-inline cool-auto-complete">
@@ -69,7 +51,12 @@
                <input id="lev1" class="layui-input" type="text" autocomplete="off" disabled="disabled">
            </div>
        </div>

        <div class="layui-inline"  style="width:80%;">
            <label class="layui-form-label">库位类型：</label>
            <div class="layui-input-inline">
                <input id="locType" class="layui-input" type="text" autocomplete="off">
            </div>
        </div>

        <div id="data-detail-btn" class="layui-btn-container layui-form-item">
            <div id="data-detail-submit-save" type="button" class="layui-btn layui-btn-normal" lay-submit lay-filter="save">保存</div>