#

luxiaotao1123

2022-09-21 fdc2e5aea439d1cccbe60d6cecbe19d5382574a0

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

@@ -15,6 +15,7 @@
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.core.CrnThread;
@@ -32,6 +33,7 @@
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.LedThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.core.thread.SteThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -78,6 +80,10 @@
    private BasCrnErrorMapper basCrnErrorMapper;
    @Autowired
    private BasSteService basSteService;
    @Autowired
    private WrkChargeService wrkChargeService;
    @Autowired
    private CommonService commonService;

    /**
     * 组托
@@ -427,6 +433,8 @@
                        crnProtocol.setLastIo("O");
                    }
                }
                // 库位移转
                this.locToLoc(crn, crnProtocol);
            }
        }
    }
@@ -454,7 +462,7 @@
            // 获取工作状态为 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());
//                log.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
                continue;
            }
            if (wrkMast.getWrkSts() < 3) {
@@ -477,6 +485,10 @@
                continue;
            }

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

            // 目标库位 ===>> 最外层库位
            if (locMastService.isOutMost(wrkMast.getLocNo())) {
                // 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
@@ -497,7 +509,7 @@
                    // 当前入库库位组没有小车 堆垛机则去站点取货入库
                    // case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
                    // case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
                    if (wrkMast.getWrkSts() == 2L || wrkMast.getWrkSts() == 6L) {
                    if ((wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) || wrkMast.getWrkSts() == 6L) {

                        // 已经存在吊车执行任务时，则过滤
                        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
@@ -609,7 +621,7 @@
    public boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo());
            WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
            if (wrkMast == null) {
                continue;
            }
@@ -647,6 +659,10 @@
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

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

                // 最外层库位，直接堆垛机出库
                if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
@@ -700,6 +716,10 @@
                                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 {
@@ -727,7 +747,7 @@
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(sourceSta.getRow1().shortValue());     // 源库位排
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceSta.getRow1()).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
@@ -768,6 +788,291 @@
            }
        }
        return false;
    }

    /**
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
            return;
        }
        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
        if (!sourceLoc.getLocSts().equals("R") && !sourceLoc.getLocSts().equals("S")) {
            return;
        }
        // 获取目标库位信息
        LocMast loc = locMastService.selectById(wrkMast.getLocNo());
        if (null == loc) {
            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.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 => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                }
            } else {
                Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                        this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                    }
                    // 堆垛机将货放至小车上 6.小车待入  ===>> 7.吊车入库中
                    if (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.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getGroupRow(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 {
                                // 修改工作档状态  6.小车待入 ===>> 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());
                                }
                            }
                        }
                    }
                } else {
                    if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
                            // 标记移库当前流程
                            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);
                    }
                }
            }

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

                        // 命令下发区 --------------------------------------------------------------------------
                        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;
                    }

                    // 目标库位 ===>> 最外层库位
                    if (locMastService.isOutMost(wrkMast.getLocNo())) {
                        // 堆垛机出库 命令下发区 --------------------------------------------------------------------------
                        CrnCommand crnCommand = new CrnCommand();
                        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((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(Utils.getGroupRow(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());
                            }
                            wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
                        }
                    } else {

                        // 把货搬到临时存放货位 todo:luxiaotao


                        // 小车行走到堆垛机待搬移点
                        if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                        }
                        // 堆垛机将货放至小车上 6.小车待入  ===>> 7.吊车入库中
                        if (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.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                                crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
                                crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                                crnCommand.setDestinationPosX(Utils.getGroupRow(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 {
                                    // 修改工作档状态  6.小车待入 ===>> 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());
                                    }
                                }
                            }
                        }

                    }

                }
            } else {
                if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                    // 寻找最近的小车
                    SteThread steThread = queryIdleCar(wrkMast);
                    if (steThread != null) {
                        // 标记移库当前流程
                        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);
                }
            }
        }
    }

    /**
@@ -819,7 +1124,7 @@
            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
            steCommand.setSteNo(steNo); // 穿梭车编号
            steCommand.setTaskNo(9999); // 工作号
            steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
            steCommand.setTaskMode(SteTaskModeType.findWaiting(steProtocol.getRow().intValue())); // 任务模式:  去近点 等待堆垛机叉取

            steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
@@ -834,6 +1139,36 @@
                wrkMast.setModiTime(new Date());
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkMast.getWrkNo());
                }
            }
        }
    }

    public void letCarBeWaiting(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

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

            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 {
                // 修改工作档状态 绑定穿梭车
                wrkCharge.setSteNo(steNo);
                wrkCharge.setModiTime(new Date());
                if (!wrkChargeService.updateById(wrkCharge)) {
                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkCharge.getWrkNo());
                }
            }
        }
@@ -894,7 +1229,7 @@
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(steProtocol.getRow());     // 源库位排
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue());     // 目标库位排
@@ -923,7 +1258,7 @@
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(steProtocol.getRow());     // 源库位排
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue());     // 目标库位排
@@ -974,8 +1309,8 @@
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(steProtocol.getRow());     // 源库位排
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                crnCommand.setDestinationPosX(Utils.getGroupRow(idleLocNo).shortValue());     // 目标库位排
@@ -1016,15 +1351,83 @@
                // 获取入库待确认工作档
                WrkMast wrkMast = wrkMastMapper.selectCrnWaiting(crnProtocol.getTaskNo().intValue());
                if (wrkMast == null) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    continue;

                    // 充电任务
                    WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
                    if (wrkCharge == null) {
                        log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    } else {
                        // 小车搬至指定库位完成
                        if (wrkCharge.getWrkSts() == 4) {
                            // 4.迁入小车 ===>> 6.小车待入
                            wrkCharge.setWrkSts(6L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改充电任务状态 4.迁入小车 ===>> 6.小车待入 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        }
                    }

                }
                // 入库 ==>> 货物搬入库
                if (wrkMast.getWrkSts() == 7){
                    // 判断是否需要小车入库
                    if (locMastService.isOutMost(wrkMast.getLocNo())) {
                        // ==> 9.入库完成
                        wrkMast.setWrkSts(9L);
                if (wrkMast == null) { continue; }
                if (wrkMast.getIoType() != 11) {
                    // 入库 ==>> 货物搬入库
                    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);
@@ -1032,108 +1435,161 @@
                        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("修改工作档状态 7.吊车入库中 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                            log.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    } else {
                        // 入库 ===>> 迁出小车 完成
                    } else if (wrkMast.getWrkSts() == 5) {
                        // 5.迁出小车 ==> 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("修改工作档状态 5.迁出小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 出库 ===>> 迁入小车 完成
                    } else if (wrkMast.getWrkSts() == 13) {
                        // 给穿梭车下发命令
                        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));
                        // 穿梭车重新定位排列层
                        if (!steThread.confirmPos()) {
                            log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                        }
                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(steNo); // 穿梭车编号
                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  搬出库
                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                        } else {
                            // 13.迁入小车 ==> 14.小车搬出库
                            wrkMast.setWrkSts(14L);
                            Date now = new Date();
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                            } else {
                                // 修改工作档状态 7.吊车入库中 => 8.小车搬入库
                                wrkMast.setWrkSts(8L);
                                Date now = new Date();
                                wrkMast.setCrnEndTime(now);
                                wrkMast.setModiTime(now);
                                if (wrkMastMapper.updateById(wrkMast) > 0) {
                                    // 堆垛机复位
                                    crnThread.setResetFlag(true);
                                log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                        // 移库 ===>> 堆垛机搬至目标库位组 完成
                    }
                // 库位移转
                } else {
                    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);
                        }
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                        } else {
                            log.error("修改工作档状态 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    } 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 {
                                    log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库 失败！！，工作号={}", wrkMast.getWrkNo());
                                    // 修改工作档状态 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());
                    }
                // 入库 ===>> 迁出小车 完成
                } else if (wrkMast.getWrkSts() == 5) {
                    // 5.迁出小车 ==> 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("修改工作档状态 5.迁出小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                // 出库 ===>> 迁入小车 完成
                } else if (wrkMast.getWrkSts() == 13) {
                    // 给穿梭车下发命令
                    Integer steNo = wrkMast.getSteNo();
                    SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                    SteProtocol steProtocol = steThread.getSteProtocol();
                    if (steProtocol == null) { continue; }
                    if (steProtocol.isIdle()) {
                    } else if (wrkMast.getWrkSts() == 13) {
                        // 给穿梭车下发命令
                        Integer steNo = wrkMast.getSteNo();
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
                        // 穿梭车重新定位排列层
                        if (!steThread.confirmPos()) {
                            log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
@@ -1181,8 +1637,33 @@
                } else {
                    // 查询是否有待入库的任务
                    WrkMast wrkMast = wrkMastMapper.selectCarWaiting(steProtocol.getTaskNo().intValue());
                    if (wrkMast == null) { continue; }
                    if (wrkMast == null) {
                        // 充电任务
                        WrkCharge wrkCharge = wrkChargeService.selectById(steProtocol.getTaskNo());
                        if (wrkCharge == null) {
                            continue;
                        } else {
                            if (wrkCharge.getWrkSts() == 11) {
                                // 11.生成出库ID ===>> 12.小车待搬
                                wrkCharge.setWrkSts(12L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 11.生成出库ID ===>> 12.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 8) {
                                // 8.小车搬入库 ===>> 9.入库完成
                                wrkCharge.setWrkSts(9L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 8.小车搬入库 ===>> 9.入库完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
                        }
                    }

                    if (wrkMast == null) { continue; }
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 2:
                            // 修改工作档状态 2.设备上走 => 3.小车待搬
@@ -1205,8 +1686,28 @@
                            }
                            break;
                        case 11:
                            // 修改工作档状态 11.生成出库ID => 12.小车待搬
                            wrkMast.setWrkSts(12L);
                            if (wrkMast.getIoType() != 11) {
                                // 修改工作档状态 11.生成出库ID => 12.小车待搬
                                wrkMast.setWrkSts(12L);
                            } else {
                                if (Cools.isEmpty(wrkMast.getMk())) {
                                    log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
                                } else {
                                    if (wrkMast.getMk().equals("I")) {
                                        String locNo = wrkMast.getLocNo();
                                        if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
                                            // 修改工作档状态 11.生成出库ID => 6.小车待入
                                            wrkMast.setWrkSts(6L);
                                        } else {
                                            // 修改工作档状态 11.生成出库ID => 3.小车待搬
                                            wrkMast.setWrkSts(3L);
                                        }
                                    } else if (wrkMast.getMk().equals("O")) {
                                        // 修改工作档状态 11.生成出库ID => 12.小车待搬
                                        wrkMast.setWrkSts(12L);
                                    }
                                }
                            }
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 11.生成出库ID => 12.小车待搬 失败！！，工作号={}", wrkMast.getWrkNo());
@@ -1439,6 +1940,7 @@
                // 组装命令
                LedCommand ledCommand = new LedCommand();
                ledCommand.setWorkNo(wrkMast.getWrkNo());
                ledCommand.setIoType(wrkMast.getIoType());
                // 出库模式
                switch (wrkMast.getIoType()) {
                    case 101:
@@ -1465,7 +1967,14 @@
                ledCommand.setStaNo(wrkMast.getStaNo());
                if (wrkMast.getIoType() != 110) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme())));
                    wrkDetls.forEach(wrkDetl -> {
                        if (wrkMast.getIoType() == 101) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), 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()));
                        }
                    });
                }
                commands.add(ledCommand);
            }
@@ -1481,8 +1990,6 @@
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
                    log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    continue;
                } else {
                    ledThread.setLedMk(false);
                }
            }

@@ -1520,9 +2027,7 @@
            for (Integer staNo : led.getStaArr()) {
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                }
                if (staProtocol == null) { continue; }
                if (staProtocol.getWorkNo() != 0) {
                    reset = false;
                    break;
@@ -1531,19 +2036,131 @@
            // 获取led线程
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getDevpPlcId());
            // led显示默认内容
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
            if (reset) {
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
                    log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                } else {

                }
            }
        }
    }

    /**
     * 小车电量检测 ===>> 发起充电
     */
    public void loopSteCharge() {
        for (SteSlave ste : slaveProperties.getSte()) {
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            BasSte basSte = basSteService.selectById(ste.getId());
            if (Cools.isEmpty(steProtocol, basSte)) { continue; }
            try {
                if (!steProtocol.statusType.equals(SteStatusType.IDLE)) {
                    continue;
                }
                if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                WrkCharge wrkCharge = wrkChargeService.selectById(steProtocol.getTaskNo());

                if (wrkCharge == null) {
                    String idleLoc = basSte.getIdleLoc();
                    wrkCharge = new WrkCharge();
                    wrkCharge.setSteNo(ste.getId());
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
                    wrkCharge.setWrkSts(11L);
                    wrkCharge.setCrnNo(basSte.getCrnNo());
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setLocNo(idleLoc);
                    if (wrkChargeService.insert(wrkCharge)) {
                        log.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
                    }

                    if (Utils.getGroupRow(idleLoc).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(idleLoc) && steProtocol.getLev() == Utils.getLev(idleLoc)) {
                        // 修改工作档状态 11.生成出库ID => 6.小车待入
                        wrkCharge.setWrkSts(6L);
                        wrkCharge.setModiTime(new Date());
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            log.error("修改工作档状态 11.生成出库ID => 6.小车待入 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    } else {
                        this.letCarBeWaiting(wrkCharge, ste.getId());
                    }

                } else {
                    // 12.小车待搬
                    if (wrkCharge.getWrkSts() == 12) {
                        // 搬小车至充电库位
                        LocMast locMast = locMastService.selectById(basSte.getIdleLoc());

                        // 堆垛机命令下发区 --------------------------------------------------------------------------
                        CrnCommand crnCommand = new CrnCommand();
                        crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                        crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                        crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                        crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo()).shortValue());     // 目标库位排
                        crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                        crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                        if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 修改穿梭车运行中排列层
                            steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo()), locMast.getBay1(), locMast.getLev1());
                            // 修改工作档状态 12.小车待搬 => 4.迁入小车
                            Date now = new Date();
                            wrkCharge.setWrkSts(4L);
                            wrkCharge.setCrnStrTime(now);
                            wrkCharge.setModiTime(now);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改工作档状态 12.小车待搬 => 4.迁入小车 失败！！，工作号={}", wrkCharge.getWrkNo());
                            }
                        }

                    } else if (wrkCharge.getWrkSts() == 6L) {
                        // 小车行驶至充电位
                        if (steProtocol.isIdle()) {
                            // 命令下发区 --------------------------------------------------------------------------
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findChargeByLoc(steProtocol.getRow().intValue()));
                            if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                            } else {
                                // 修改工作档状态 6.小车待入 ===> 8.小车搬入库
                                wrkCharge.setWrkSts(8L);
                                Date now = new Date();
                                wrkCharge.setCrnEndTime(now);
                                wrkCharge.setModiTime(now);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改工作档状态 6.小车待入 ===> 8.小车搬入库 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                        }
                    } else if (wrkCharge.getWrkSts() == 9L) {
                        // 给输送线下发充电任务
                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                        SteChargeType steChargeType = SteChargeType.get(wrkCharge.getLocNo());
                        if (null != steChargeType) {
                            if (devpThread.charge(steChargeType.ssbm - 1, true)) {
                                // 修改工作档状态 9.入库完成 ===> 10.库存更新完成
                                wrkCharge.setWrkSts(10L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 9.入库完成 ===> 10.库存更新完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                        } else {
                            log.error("获取充电桩号失败，解析库位：{}", wrkCharge.getLocNo());
                        }
                    }
                }
            } catch (Exception e) {
                log.error("fail", e);
            }
        }
    }

}