#

tqs

2022-12-23 eb96c650d25d9d17ea3c582cd091dbeff9909bf1

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

@@ -3,7 +3,6 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
@@ -12,6 +11,7 @@
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
@@ -63,6 +63,8 @@
    @Autowired
    private WrkMastMapper wrkMastMapper;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;
@@ -95,8 +97,7 @@
     * 组托
     * 入库站，根据条码扫描生成入库工作档，工作状态 2
     */
    @Async
    public void generateStoreWrkFile() {
    public synchronized void generateStoreWrkFile() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
@@ -153,6 +154,11 @@
                        continue;
                    }

                    // 过滤盘点/拣料/并板任务
                    if (null != wrkMastMapper.selectPickStepByBarcode(barcode)) {
                        continue;
                    }

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    if (wrkMast != null) {
@@ -183,6 +189,8 @@
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);

                            ledThread.errorReset();

                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
@@ -221,8 +229,7 @@
     * wms入库
     * 入库站，根据条码扫描生成入库工作档，工作状态 1 ==>> 2
     */
    @Async
    public void generateStoreWrkFile0() {
    public synchronized void generateStoreWrkFile0() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
@@ -324,6 +331,7 @@
    /**
     * 拣料、并板、盘点再入库【第2阶段】
     */
    @Transactional
    public synchronized void stnToCrnStnPick1(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
@@ -342,7 +350,7 @@
                        && staProtocol.isInEnable()
                        // 0 - 9990 或者 9996
                        && ((staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() < 9990) || staProtocol.getWorkNo() == 9996)
                        && staProtocol.getStaNo().equals(staProtocol.getWorkNo())
                        && staProtocol.getStaNo().equals(staProtocol.getSiteId().shortValue())
                        && staProtocol.isPakMk()){

                    // 获取条码扫描仪信息
@@ -425,16 +433,18 @@
                        if (code.equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            // 获取目标站
                            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                                    .eq("type_no", wrkMast.getIoType() - 50)
                                    .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
                                    .eq("crn_no", dto.getCrnNo()); // 堆垛机号
                            StaDesc staDesc = staDescService.selectOne(wrapper);
                            if (Cools.isEmpty(staDesc)) {
                                log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                                continue;
                            }
//                            // 获取目标站
//                            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
//                                    .eq("type_no", wrkMast.getIoType() - 50)
//                                    .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
//                                    .eq("crn_no", dto.getCrnNo()); // 堆垛机号
//                            StaDesc staDesc = staDescService.selectOne(wrapper);
//                            if (Cools.isEmpty(staDesc)) {
//                                log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
//                                continue;
//                            }
//                            // 堆垛机站点(目标站)
//                            Integer staNo = staDesc.getCrnStn();

                            // 保存工作明细档历史档
//                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
@@ -445,13 +455,13 @@
                                throw new CoolException(wrkMast.getWrkNo() + "保存工作主档历史档失败");
                            }

                            // 堆垛机站点(目标站)
                            Integer staNo = staDesc.getCrnStn();
                            String sourceLocNo = wrkMast.getSourceLocNo().trim();

                            // 更新工作档数据状态
                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                            wrkMast.setSourceStaNo(pickSta.getStaNo()); // 源站
                            wrkMast.setStaNo(staNo); // 目标站
                            wrkMast.setStaNo(dto.getStaNo()); // 目标站
                            wrkMast.setCrnNo(dto.getCrnNo());
                            wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
                            wrkMast.setSourceLocNo(""); // 源库位清空
@@ -462,13 +472,8 @@
                            if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                            }
                            // 修改源库位状态 O.空库位
                            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                            locMast.setLocSts("O");
                            locMast.setModiTime(new Date());
                            if (!locMastService.updateById(locMast)) {
                                throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
                            }

                            LocMast locMast = null;
                            // 修改目标库位状态 Q.拣料/盘点/并板再入库
                            locMast = locMastService.selectById(wrkMast.getLocNo());
                            locMast.setLocSts("Q");
@@ -476,13 +481,26 @@
                            if (!locMastService.updateById(locMast)) {
                                throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
                            }
                            // 库存明细转移
                            if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
                                throw new CoolException(wrkMast.getWrkNo() + "任务库存明细转移失败！！！");
                            // 源库位库存明细转移到目标库位
                            if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
                                throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
                            }

                            // 修改源库位状态 O.空库位
                            LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
                            if (sourceLocMast.getLocSts().equals("P")) {
                                sourceLocMast.setLocSts("O");
                                sourceLocMast.setModiTime(new Date());
                                if (!locMastService.updateById(sourceLocMast)) {
                                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
                                }
                                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
                            }

                            // 条码设备处理
                            barcodeThread.setBarcode("");

                            ledThread.errorReset();

                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
@@ -528,10 +546,97 @@
    }

    /**
     * 盘点货物抵达盘点目标站 wrkMast.sourceLoc P ===>> O
     */
    public synchronized void pickWrkCompleteStaNo() {
        List<WrkMast> wrkMasts = wrkMastMapper.selectPick17(null, null);
        for (WrkMast wrkMast : wrkMasts) {
//            // 修改源库位状态 O.空库位
//            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
//            if (locMast.getLocSts().equals("P")) {
//                locMast.setLocSts("O");
//                locMast.setModiTime(new Date());
//                if (!locMastService.updateById(locMast)) {
//                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
//                }
//                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
//            }
            // 修改工作档
            wrkMast.setIoPri(13D);
            wrkMast.setModiTime(new Date());
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                log.error("更新工作档的优先级失败！！！ [工作号:{}]", wrkMast.getWrkNo());
            }
        }
    }

    /**
     * 拣料/盘点转全板后，300站任务转100/200站去
     */
    public synchronized void transPickToFullChangeStn() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料出库口
            for (DevpSlave.Sta pickSta : devp.getPickOutSta()) {
                // 获取拣料出库站信息
                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.getStaNo().equals(staProtocol.getSiteId().shortValue())
                        && staProtocol.isPakMk()){
                    WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
                    if(Cools.isEmpty(wrkMast)){
                        log.error("拣料/盘点转全板,任务号工作档不存在===>>[任务号:{}]", staProtocol.getWorkNo());
                        continue;
                    }
                    if (wrkMast.getIoType() != 101) { continue; }

                    //拣料转全板默认出库站100站，当100站有物时，目标改200站
                    Integer staNo = 100;
                    StaProtocol staProtocol100 = devpThread.getStation().get(staNo);
                    if (staProtocol100 == null) {
                        continue;
                    } else {
                        staProtocol100 = staProtocol100.clone();
                    }
                    if (staProtocol100.isLoading()) {
                        staNo = 200;
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(staNo.shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    } else {
                        wrkMast.setStaNo(staNo);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("更新工作档的目标站失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }
                    }

                }
            }


        }
    }

    /**
     * 堆垛机站出库到出库站
     */
    @Async
    public void crnStnToOutStn() {
    public synchronized void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
@@ -576,6 +681,7 @@

                        // 更新工作档状态为 17.出库完成
                        wrkMast.setWrkSts(17L);
                        wrkMast.setSteNo(0);
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
@@ -636,7 +742,9 @@
                    }
                }
                // 库位移转
                this.locToLoc(crn, crnProtocol);
                this.locToLoc1(crn, crnProtocol);
                // 库位移转，回原库位
                this.locToLoc17(crn, crnProtocol);
                // 演示任务
                this.steMoveDemo(crn, crnProtocol);
            }
@@ -646,7 +754,7 @@
    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public boolean crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized boolean crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            boolean flag = false;
            // 获取堆垛机入库站信息
@@ -663,12 +771,32 @@
                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }

            //加强判断，只要存在移库任务，说明出库任务未完全结束，不执行入库任务
            WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
            if(!Cools.isEmpty(one)){
                log.error("入库 ===>> 存在移库未完成任务，不能入库。移库任务号={},堆垛机号={}", one.getWrkNo(), slave.getId());
                continue;
            }

            // 获取工作状态为 2,3,4,5,6 的入库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakInStep23456(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
            if(null == wrkMast) {
//                log.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
                continue;
            }

            // 判断是否已存在小车绑定任务
            BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
            if(basSte == null) continue;
            WrkMast one1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                    .eq("ste_no",basSte.getSteNo())
                    .last(" and wrk_sts > 10"));
            if(one1 != null){
                log.error("{}入库任务无法作业，因出库任务已绑定小车!", wrkMast.getWrkNo());
                continue;
            }

            if (wrkMast.getWrkSts() < 3) {
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                        && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
@@ -689,7 +817,19 @@
                continue;
            }

            // 过滤
            // 检测是否存在出库任务
//            WrkMast pakoutWrkMast = wrkMastMapper.selectPakout(slave.getId(), null);
//            if (null != pakoutWrkMast) {
//                if ((pakoutWrkMast.getIoType() == 103 || pakoutWrkMast.getIoType() == 104 || pakoutWrkMast.getIoType() == 107)
//                        && pakoutWrkMast.getWrkSts() == 17
//                        && basDevpService.selectByWrkNo(pakoutWrkMast.getWrkNo()) != null
//                ) {
//
//                } else {
//                    log.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
//                    continue;
//                }
//            }
            if (null != wrkMastMapper.selectPakout(slave.getId(), null)) {
                log.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
                continue;
@@ -734,6 +874,7 @@
                        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setCommand((short) 0);
                        crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                        crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
@@ -788,6 +929,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
@@ -812,7 +954,7 @@
                    }
                // 没有小车
                } else {
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                    if (wrkMast.getWrkSts() == 2L && (wrkMast.getSteNo() == null || wrkMast.getSteNo() == 0)) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
@@ -837,13 +979,97 @@
    /**
     * 出库  ===>>  库位到堆垛机站
     */
    public boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
            if (wrkMast == null) {
                continue;
            }

            // 判断是否已存在小车绑定任务
            BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
            if(basSte == null) continue;
            WrkMast one1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                    .eq("ste_no",basSte.getSteNo())
                    .last(" and wrk_sts < 10"));
            if(one1 != null){
                log.error("{}出库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
                continue;
            }

            //加强判断，确保因出库导致的移库整套任务全部结束后，才能执行下一笔出库任务。只有库位完成移库回去全部任务后，才认为当组出库任务完成
            WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
            if(!Cools.isEmpty(one)){
                //存在移库任务，且在移出中，且移库源库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
                if(wrkMast.getWrkNo() == 11  && one.getWrkSts() > 10 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getSourceLocNo())
                        || Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getSourceLocNo())
                        || Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getSourceLocNo()))){
                    continue;
                }
                //存在移库任务，且在移回中，且移库目标库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
                if(wrkMast.getWrkNo() == 11  && one.getWrkSts() < 11  && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getLocNo())
                        || Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getLocNo())
                        || Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getLocNo()))){
                    continue;
                }
            }

            //出库库位不是最外层库位，判断浅库位组是否都为空，或存在库位移转任务
            boolean flag = false;
            if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
                WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
                if(wrkMastMove != null && wrkMast.getWrkNo() == 11){
                    continue;
                }

                String[] shallowlocs  = Utils.getShallowLocs(wrkMast.getSourceLocNo());
                if(!Cools.isEmpty(shallowlocs)){
                    for(String shallowLocNo : shallowlocs){
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            if (null == waitWrkMast) {
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                //iotype=11，wrksts=17，说明货物已经移库到暂存库位，等待回原库位,此时允许继续出库
                                if (waitWrkMast.getIoType()!=11 || waitWrkMast.getWrkSts()!=17) {
                                    waitWrkMast.setIoPri((double) 9999);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    flag = true;
                                    break;
                                }
                            }
                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            if (null == waitWrkMast) {
                                // 生成一笔移库任务工作档、改变浅库位的源库/目标库 库位状态
                                moveLocForDeepLoc(slave, shallowLoc);
                                flag = true;
                                break;
                            } else {
                                if (waitWrkMast.getWrkSts()!=18) {
                                    log.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                                    flag = true;
                                    break;
                                }

                            }
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")){
                            log.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                            flag = true;
                            break;
                        }

                    }
                }
            }
            if(flag){
                continue;
            }

            // 工作档状态判断
            if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null){
                log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
@@ -901,6 +1127,7 @@
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(sourceSta.getRow1().shortValue());     // 源库位排
                    crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
@@ -935,6 +1162,12 @@
                            if (steProtocol == null) { continue; }
                            if (steProtocol.isIdle()) {

                                //小车只能绑定一笔作业中任务
                                WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
                                if(wrkMast1 != null){
                                    continue;
                                }

                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(steNo); // 穿梭车编号
@@ -944,10 +1177,12 @@
                                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
                                steCommand.setBay(steProtocol.getBay());
                                steCommand.setLev(steProtocol.getLev());
                                steCommand.setMemo("11==>14小车搬出库任务，任务号"+wrkMast.getWrkNo()+"");

                                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                } else {
                                    log.info("穿梭车命令下发成功(11==>14小车搬出库任务)，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                    // 修改工作档状态 11.生成出库ID => 14.小车搬出库
                                    Date now = new Date();
                                    wrkMast.setWrkSts(14L);
@@ -971,6 +1206,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceSta.getRow1()).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
@@ -1000,6 +1236,22 @@
                            SteThread steThread = queryIdleCar(wrkMast);
                            if (steThread != null) {
                                // 没有其他任务
//                                boolean hasPakout = true;
//                                WrkMast pakoutWrkMast = wrkMastMapper.selectPakout(slave.getId(), steNo);
//                                if (null != pakoutWrkMast) {
//                                    if ((pakoutWrkMast.getIoType() == 103 || pakoutWrkMast.getIoType() == 104 || pakoutWrkMast.getIoType() == 107)
//                                            && pakoutWrkMast.getWrkSts() == 17
//                                            && basDevpService.selectByWrkNo(pakoutWrkMast.getWrkNo()) != null
//                                    ) {
//                                        hasPakout = false;
//                                    }
//                                } else {
//                                    hasPakout = false;
//                                }
//                                if (!hasPakout) {
//                                    // 让小车等待搬运待续
//                                    this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
//                                }
                                if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
                                    // 让小车等待搬运待续
                                    this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
@@ -1019,9 +1271,404 @@
    }

    /**
     * 库位移转 NEW
     */
    public synchronized void locToLoc1(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
            return;
        }
        // 过滤
        if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
            log.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
            return;
        }

        // 判断是否已存在小车绑定任务
        BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
        if(basSte == null) return;
        WrkMast one = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                .eq("ste_no",basSte.getSteNo())
                .last(" and io_type != 11 and wrk_sts < 10"));
        if(one != null){
            log.error("{}移库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
            return;
        }

        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
        if (!sourceLoc.getLocSts().equals("R")) {
            return;
        }
        // 获取目标库位信息
        LocMast loc = locMastService.selectById(wrkMast.getLocNo());
        if (null == loc || !loc.getLocSts().equals("S")) {
            log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
        BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
        if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
            return;
        }

        // 堆垛机控制过滤
        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
            return;
        }

        // 已经存在吊车执行任务时，则过滤
        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
            return;
        }

        // 置顶任务
        wrkMast.setIoPri((double) 9999);
        wrkMastMapper.updateById(wrkMast);

        // 源库位 ===>> 最外层库位
        if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
            // 目标库位 ===>> 最外层库位
            if (locMastService.isOutMost(wrkMast.getLocNo())) {
                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
                crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                crnCommand.setDestinationPosX(loc.getRow1().shortValue());     // 目标库位排
                crnCommand.setDestinationPosY(loc.getBay1().shortValue());     // 目标库位列
                crnCommand.setDestinationPosZ(loc.getLev1().shortValue());     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 16.吊车出库中
                    Date now = new Date();
                    wrkMast.setWrkSts(16L);
                    wrkMast.setCrnStrTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("【库位移转】 修改工作档状态 11.生成出库ID => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                }

            }
            // 不是最外层库位，需要使用穿梭车搬运后，再堆垛机移库
        } else {
            // 当前组库位是否有穿梭车
            Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
            // 有小车
            if (steNo != null) {
                if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {

                    // 给穿梭车下发命令 让其将货物挪至堆垛机搬运点
                    SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                    SteProtocol steProtocol = steThread.getSteProtocol();
                    if (steProtocol == null) { return; }
                    if (steProtocol.isIdle()) {

                        //小车只能绑定一笔作业中任务
                        WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
                        if(wrkMast1 != null){
                            return;
                        }

                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(steNo); // 穿梭车编号
                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  去近点 等待堆垛机叉取

                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
                        steCommand.setBay(steProtocol.getBay());
                        steCommand.setLev(steProtocol.getLev());

                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                        } else {
                            // 修改工作档状态 11.生成出库ID => 14.小车搬出库
                            Date now = new Date();
                            wrkMast.setWrkSts(14L);
                            wrkMast.setSteNo(steNo);
                            wrkMast.setCrnStrTime(now);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    }
                }
                if (wrkMast.getWrkSts() == 15L) {
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        return;
                    }

                    // 堆垛机出库 命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
                    crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                    crnCommand.setDestinationPosX(loc.getRow1().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(loc.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(loc.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 15.等待吊车 => 16.吊车出库中
                        Date now = new Date();
                        wrkMast.setWrkSts(16L);
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        return;
                    }
                }
                // 没有小车
            } else {
                if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                    // 寻找最近的小车
                    SteThread steThread = queryIdleCar(wrkMast);
                    if (steThread != null) {
                        if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
                            // 标记移库当前流程
                            wrkMast.setMk("O");
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                            // 让小车等待搬运待续
                            this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
                        }
                    }
                }
                // 堆垛机搬运小车
                if (wrkMast.getWrkSts() == 12L) {
                    this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                }
            }
        }
    }

    /**
     * 库位移转，回原库位
     */
    public synchronized void locToLoc17(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove17(slave.getId());
        if (null == wrkMast) {
            return;
        }

        if (wrkMast.getWrkSts() == 17) {
            //查找库位
            boolean flag = false;
//            append
            Integer row = Utils.getGroupRow(wrkMast.getSourceLocNo());
            Integer bay = Utils.getBay(wrkMast.getSourceLocNo());
            Integer lev = Utils.getLev(wrkMast.getSourceLocNo());

            String locNo = Utils.append(row, bay, lev);
            String[] deeplocs  = Utils.getDeepLocs(locNo);
            if(!Cools.isEmpty(deeplocs)){
                for(String deepLocNo : deeplocs) {
                    LocMast deepLoc = locMastService.selectById(deepLocNo);
//                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(deepLocNo);
                    if(deepLoc != null && !deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("O")){
                        log.error("移库再回库时，深库位组深库位状态为作业中 ===>> deepLoc={},loc_sts={}", deepLoc.getLocNo(), deepLoc.getLocSts());
                        flag = true;
                        break;
                    }
                    if(deepLoc != null && deepLoc.getLocSts().equals("O")){
                        //修改移库工作档
                        wrkMast.setSourceLocNo(wrkMast.getLocNo());
                        wrkMast.setIoPri((double)9999);
                        wrkMast.setWrkSts(2L);
                        wrkMast.setLocNo(deepLocNo);
                        wrkMast.setSteNo(0);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 17.移库完成 => 2.移库再入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }

                        if(deepLoc.getLocSts().equals("O")){
                            deepLoc.setLocSts("S"); // S.入库预约
                            deepLoc.setModiTime(new Date());
                            if (!locMastService.updateById(deepLoc)) {
                                log.error("双深库位 --- 更新目标库位状态失败！ 待移转浅库位：" + deepLoc.getLocNo());
                                throw new CoolException("更新移库回库目标库位状态失败");
                            }
                        }
                        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                        if(sourceLoc.getLocSts().equals("F") || sourceLoc.getLocSts().equals("D")){
                            sourceLoc.setLocSts("R"); // R.出库预约
                            sourceLoc.setModiTime(new Date());
                            if (!locMastService.updateById(sourceLoc)) {
                                throw new CoolException("更新移库回库目标库位状态失败");
                            }
                        }
                        break;
                    }
                }
            }
            if(flag){
                return;
            }
        }

        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
        if (!sourceLoc.getLocSts().equals("R")) {
            return;
        }

        // 获取目标库位信息
        LocMast loc = locMastService.selectById(wrkMast.getLocNo());
        if (null == loc || !loc.getLocSts().equals("S")) {
            log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }

        // 获取堆垛机信息 并 判断是否可入出
        BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
        if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
            return;
        }

        // 堆垛机控制过滤
        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
            return;
        }

        // 已经存在吊车执行任务时，则过滤
        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
            return;
        }

        // 置顶任务
        wrkMast.setIoPri((double) 9999);
        wrkMastMapper.updateById(wrkMast);

        // 源库位 ===>> 最外层库位
        if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
            // 目标库位 ===>> 最外层库位
            if (!locMastService.isOutMost(wrkMast.getLocNo())) {
                // 判断小车是否在当前组库位，如果是则将穿梭车移至最外层，等待堆垛机放货；如果不是，则堆垛机寻找穿梭车，并放置当前组最外层
                Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && (wrkMast.getSteNo() == null || wrkMast.getSteNo() == 0)) {
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { return; }
                            if(steProtocol.getLoca()==3 || steProtocol.getLoca()==4){
                                //小车已经在待机位时，无需下发到待机位任务，直接更新状态微3，同时绑定小车
                                wrkMast.setWrkSts(3L);
                                wrkMast.setSteNo(steNo);
                                wrkMast.setModiTime(new Date());
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkMast.getWrkNo());
                                }
                            } else {
                                this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                            }
                        }
                    }
                    // 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入  ===>> 7.吊车入库中
                    if (wrkMast.getWrkSts() == 3L || wrkMast.getWrkSts() == 6L) {
                        // 小车处于空闲
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { return; }
                        if (steProtocol.isIdle()) {

                            // 已经存在吊车执行任务时，则过滤
                            if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                                return;
                            }
                            // 堆垛机入库 命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getGroupRow(loc.getLocNo()).shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(loc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(loc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改工作档状态  3.小车待搬 ===>> 7.吊车入库中
                                Date now = new Date();
                                wrkMast.setWrkSts(7L);
                                wrkMast.setCrnStrTime(now);
                                wrkMast.setModiTime(now);
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                                }
                                return;
                            }
                        }
                    }
                    // 没有小车
                } else {
                    if (wrkMast.getWrkSts() == 2L && (wrkMast.getSteNo() == null || wrkMast.getSteNo() == 0)) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
                            // 没有其他任务
                            if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                // 标记移库当前流程
                                wrkMast.setMk("I");
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    log.error("标记移库当前流程 I 失败！！，工作号={}", wrkMast.getWrkNo());
                                }
                                // 让小车等待搬运待续
                                this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
                            }
                        }
                    }
                    // 堆垛机搬运小车
                    if (wrkMast.getWrkSts() == 3L) {
                        this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                    }
                }
            }
        }
    }

    /**
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
@@ -1074,6 +1721,7 @@
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1090,9 +1738,10 @@
                    wrkMast.setCrnStrTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        log.error("【库位移转】 修改工作档状态 11.生成出库ID => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                }

            } else {
                Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                // 有小车
@@ -1123,6 +1772,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1179,6 +1829,12 @@
                    if (steProtocol == null) { return; }
                    if (steProtocol.isIdle()) {

                        //小车只能绑定一笔作业中任务
                        WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
                        if(wrkMast1 != null){
                            return;
                        }

                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(steNo); // 穿梭车编号
@@ -1217,6 +1873,7 @@
                        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setCommand((short) 0);
                        crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                        crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1263,6 +1920,7 @@
                                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                                crnCommand.setCommand((short) 0);
                                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                                crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1313,7 +1971,7 @@
    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCar(String locNo) {
    public synchronized Integer hasCar(String locNo) {
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
@@ -1329,7 +1987,7 @@
    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCarOfIdle(String locNo) {
    public synchronized Integer hasCarOfIdle(String locNo) {
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
@@ -1347,7 +2005,7 @@
    /**
     * 查找当前库位最适合的穿梭车来作业
     */
    public SteThread queryIdleCar(WrkMast wrkMast) {
    public synchronized SteThread queryIdleCar(WrkMast wrkMast) {
        Integer crnNo = wrkMast.getCrnNo();
        BasSte basSte = basSteService.findByCrnNo(crnNo);
        // 获取穿梭车信息
@@ -1365,12 +2023,18 @@
     * 让小车从 远点 ====>> 待机
     *  等待堆垛机搬运
     */
    public void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
    public synchronized void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            //小车只能绑定一笔作业中任务
            WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
            if(wrkMast1 != null){
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
@@ -1385,6 +2049,7 @@
            if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
            } else {
                log.error("穿梭车命令下发成功让小车从 远点 ====>> 待机位,绑定穿梭车,IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
                // 修改工作档状态 绑定穿梭车
                wrkMast.setSteNo(steNo);
                wrkMast.setModiTime(new Date());
@@ -1395,7 +2060,7 @@
        }
    }

    public void letCarBeWaiting(WrkCharge wrkCharge, Integer steNo) {
    public synchronized void letCarBeWaiting(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
@@ -1403,6 +2068,12 @@

        if (!basSteService.updatePakMk(steNo, "Y")) {
            log.error("修改穿梭车作业状态 失败！！，穿梭车={}", steNo);
            return;
        }

        //小车只能绑定一笔作业中任务
        WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
        if(wrkMast1 != null){
            return;
        }

@@ -1432,12 +2103,18 @@
     * 让小车从 远点 ====>> 移动到近点
     *  等待堆垛机搬运
     */
    public void letCarBeReady(WrkMast wrkMast, Integer steNo, String locNo) {
    public synchronized void letCarBeReady(WrkMast wrkMast, Integer steNo, String locNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            //小车只能绑定一笔作业中任务
            WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
            if(wrkMast1 != null){
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
@@ -1448,10 +2125,12 @@
            steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
            steCommand.setBay(steProtocol.getBay());
            steCommand.setLev(steProtocol.getLev());
            steCommand.setMemo("绑定小车号，让小车从 远点 ====>> 移动到近点");

            if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
            } else {
                log.info("穿梭车命令下发成功(让小车从远点==>>移动到近点)，IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
                // 修改工作档状态 绑定穿梭车
                wrkMast.setSteNo(steNo);
                wrkMast.setModiTime(new Date());
@@ -1466,12 +2145,18 @@
     * 让小车从 远点 ====>> 移动到近点
     *  等待堆垛机搬运
     */
    public void letCarBeReady(WrkCharge wrkCharge, Integer steNo) {
    public synchronized void letCarBeReady(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            //小车只能绑定一笔作业中任务
            WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
            if(wrkMast1 != null){
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
@@ -1499,12 +2184,12 @@
    /**
     * 入出库  ===>>  堆垛机搬入小车
     */
    public void carMoveIn(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
    public synchronized void carMoveIn(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
        // 获取堆垛机信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {
        if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() == 0) {
                LocMast locMast;
@@ -1516,6 +2201,7 @@
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -1545,6 +2231,7 @@
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -1575,13 +2262,13 @@
    /**
     * 入库  ===>>  堆垛机搬出小车
     */
    public void carMoveOut(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
    public synchronized void carMoveOut(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        // 穿梭车空闲
        if (steProtocol.isIdle()) {
        if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() == 0) {

@@ -1597,6 +2284,7 @@
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -1626,9 +2314,8 @@
    /**
     * 执行对工作档的完成操作
     */
    @Async
    @Transactional
    public void storeFinished() {
    public synchronized void storeFinished() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
@@ -1804,9 +2491,11 @@
                        steCommand.setSteNo(steNo); // 穿梭车编号
                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  搬出库
                        steCommand.setMemo("出库 ===>> 迁入小车 完成");
                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                        } else {
                            log.info("穿梭车命令下发成功，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                            // 13.迁入小车 ==> 14.小车搬出库
                            wrkMast.setWrkSts(14L);
                            Date now = new Date();
@@ -1824,15 +2513,133 @@
                    }
                // 库位移转
                } else {
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
                        // 判断是否需要小车入库
                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
                            // ==> 9.入库完成
                            wrkMast.setWrkSts(9L);
                            Date now = new Date();
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                            } else {
                                log.error("修改工作档状态 7.吊车入库中 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        } else {
                            // 给穿梭车下发命令
                            Integer steNo = wrkMast.getSteNo();
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
                            if (steProtocol.isIdle()) {
                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(steNo); // 穿梭车编号
                                steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                                steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
                                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                } else {
                                    // 修改工作档状态 7.吊车入库中 => 8.小车搬入库
                                    wrkMast.setWrkSts(8L);
                                    Date now = new Date();
                                    wrkMast.setCrnEndTime(now);
                                    wrkMast.setModiTime(now);
                                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                                        // 堆垛机复位
                                        crnThread.setResetFlag(true);
                                    } else {
                                        log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库 失败！！，工作号={}", wrkMast.getWrkNo());
                                    }
                                }
                            }
                        }
                        // 入库 ===>> 迁入小车 完成
                    } else if (wrkMast.getWrkSts() == 4) {
                        // 4.迁入小车 ==> 6.小车待入
                        wrkMast.setWrkSts(6L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
                            if (!steThread.confirmPos()) {
                                log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                            }
                            // 穿梭车去待机位
                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(9999); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
//                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
//                        steCommand.setBay(steProtocol.getBay());
//                        steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            log.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 入库 ===>> 迁出小车 完成
                    }
                    if (wrkMast.getWrkSts() == 16) {
                        Date now = new Date();
//                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
//                            // 16.吊车出库中 ==> 9.入库完成
//                            wrkMast.setWrkSts(9L);
//                            wrkMast.setCrnEndTime(now);
//                        } else {
//                            // 16.吊车出库中 ==> 9.入库完成
//                            wrkMast.setWrkSts(9L);
//                        }
                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
                            // 16.吊车出库中 ==> 9.入库完成
                            wrkMast.setWrkSts(9L);
                            wrkMast.setCrnEndTime(now);
                        } else {
                            // 16.吊车出库中 ==> 9.入库完成
                            wrkMast.setWrkSts(9L);
                            wrkMast.setWrkSts(17L);
                            wrkMast.setSteNo(0);
                            // 默认目标库位是空板
                            String locSts = "";
                            // 库位移转判断是否为空板移转
                            if (wrkMast.getEmptyMk().equals("N")) {
                                locSts = "F";
                                // 转移库存明细数据: 库存号 由工作档源库位变为目标库位
                                if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
                                    log.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
                                    continue;
                                }
                            } else {
                                locSts = "D";
                            }
                            if(Cools.isEmpty(locSts)){
                                log.error("库位移转 ===>> 库存状态为空；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
                                continue;
                            }

                            // 修改源库位状态 ==> O
                            LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                            if (null != sourceLoc) {
                                sourceLoc.setBarcode("");
                                sourceLoc.setLocSts("O");
                                sourceLoc.setModiTime(now);
                                sourceLoc.setIoTime(now);
                                if (!locMastService.updateById(sourceLoc)) {
                                    log.error("库位移转 ===>> 修改源库位状态失败；[workNo={}],[sourceLoc={}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                                }
                            }
                            // 修改目标库位状态 ==> .locSts
                            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                            locMast.setLocSts(locSts);
                            locMast.setModiTime(new Date());
                            if (!locMastService.updateById(locMast)) {
                                log.error("");
                            }
                        }
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
@@ -1964,7 +2771,12 @@
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0) {
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() == 0){
                log.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
            }

            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0 && steProtocol.getStatus() == 10) {
                log.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}", steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus());
                if (steProtocol.getTaskNo() == 9999) {
                    steThread.setResetFlag(true);
                } else {
@@ -2083,7 +2895,7 @@
    /**
     * 异常信息记录
     */
    public void recErr() {
    public synchronized void recErr() {
        try {
            this.recCrnErr();
            this.recSteErr();
@@ -2095,7 +2907,7 @@
    /**
     * 堆垛机异常信息记录
     */
    private void recCrnErr(){
    private synchronized void recCrnErr(){
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -2326,8 +3138,7 @@
    /**
     * 空栈板初始化入库,叉车入库站放货
     */
    @Async
    public void storeEmptyPlt(){
    public synchronized void storeEmptyPlt(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历空板入库口
            for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
@@ -2383,6 +3194,8 @@
                        if (code.equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            ledThread.errorReset();

                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
@@ -2415,8 +3228,7 @@
    /**
     * 出库  ===>> 工作档信息写入led显示器
     */
    @Async
    public void ledExecute() {
    public synchronized void ledExecute() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -2468,10 +3280,13 @@
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> {
                        if (wrkMast.getIoType() == 101) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                        }
                        if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() || 0 == wrkDetl.getInspect())) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                        }
                        if (wrkMast.getIoType() == 107) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                        }
                    });
                }
@@ -2516,8 +3331,7 @@
    /**
     * 其他  ===>> LED显示器复位，显示默认信息
     */
    @Async
    public void ledReset() {
    public synchronized void ledReset() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -2612,6 +3426,7 @@
                        crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setCommand((short) 0);
                        crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                        crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -2820,6 +3635,7 @@
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -2883,5 +3699,108 @@

    }

    /**
     * 因深库位阻塞，对浅库位进行移转
     */
    private synchronized void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
        try {
            String rows = "";
            switch (crn.getId()){
                case 1:
                    rows = "3,4";
                    break;
                case 2:
                    rows = "11,12";
                    break;
                case 3:
                    rows = "18,19";
                    break;
            }
            LocMast loc = null;
            List<LocMast> locs = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no",crn.getId())
                                                .eq("loc_type1",shallowLoc.getLocType1())
                                                .eq("loc_sts","O")
                                                .last(" and row1 in (" + rows + ") order by bay1,lev1"));
            for (LocMast one : locs){
                if(Utils.getGroupRow(one.getLocNo()) != Utils.getGroupRow(shallowLoc.getLocNo())
                    || Utils.getBay(one.getLocNo()) != Utils.getBay(shallowLoc.getLocNo())
                    || Utils.getLev(one.getLocNo()) != Utils.getLev(shallowLoc.getLocNo())){
                    loc = one;
                    break;
                }
            }

            if (null == loc) {
                log.error("深库位出库 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("深库位出库 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
            }

            // 获取工作号
            int workNo = commonService.getWorkNo(0);
            Date now = new Date();
            // 保存工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(11); // 入出库状态： 11.库格移载
            wrkMast.setIoPri((double) 9999);
            wrkMast.setCrnNo(crn.getId());
            wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
            wrkMast.setLocNo(loc.getLocNo()); // 目标库位
            wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
            wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
            wrkMast.setLinkMis("N");
            wrkMast.setAppeTime(now);
            wrkMast.setModiTime(now);
            int res = wrkMastMapper.insert(wrkMast);
            if (res == 0) {
                throw new CoolException("保存工作档失败");
            }
            // 工作档明细保存
            if (shallowLoc.getLocSts().equals("F")) {
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
                for (LocDetl locDetl : locDetls) {
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.sync(locDetl);
                    wrkDetl.setWrkNo(workNo);
                    wrkDetl.setIoTime(new Date());
                    wrkDetl.setAnfme(locDetl.getAnfme());
                    wrkDetl.setAppeTime(new Date());
                    wrkDetl.setModiTime(new Date());
                    if (!wrkDetlService.insert(wrkDetl)) {
                        throw new CoolException("保存工作档明细失败");
                    }
                }
            }
            // 修改源库位状态
            if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
                shallowLoc.setLocSts("R"); // R.出库预约
                shallowLoc.setModiTime(now);
                if (!locMastService.updateById(shallowLoc)) {
                    throw new CoolException("更新源库位状态失败");
                }
            } else {
                throw new CoolException("源库位出库失败");
            }
            // 修改目标库位状态
            if (loc.getLocSts().equals("O")) {
                loc.setLocSts("S"); // S.入库预约
                loc.setModiTime(now);
                if (!locMastService.updateById(loc)) {
                    throw new CoolException("更新目标库位状态失败");
                }
            } else {
                throw new CoolException("移转失败");
            }
        } catch (Exception e) {
            log.error("深库位阻塞，对浅库位进行移转失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

}