#

luxiaotao1123

2022-12-06 b3d960252636140962bf9bbdf053d3b1d3255020

 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.model.enums.WrkChargeType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
@@ -38,7 +39,6 @@
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
@@ -172,7 +172,7 @@
                        param.setBarcode(barcode);
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
//                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
@@ -536,7 +536,6 @@
    /**
     * 堆垛机站出库到出库站
     */
    @Async
    public void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
@@ -642,7 +641,7 @@
                    }
                }
                // 库位移转
                this.locToLoc(crn, crnProtocol);
//                this.locToLoc(crn, crnProtocol);
            }
        }
    }
@@ -719,42 +718,37 @@
                        String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo());
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                        switch (shallowLoc.getLocSts()) {
                            case "P":
                            case "R": {
                                WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
                                if (null == waitWrkMast) {
                                    log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                                } else {
                                    if (waitWrkMast.getWrkSts() < 17) {
                                        waitWrkMast.setIoPri(20D);
                                        waitWrkMast.setModiTime(new Date());
                                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                            log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                        }
                                        //20220719 Add，如果浅库位状态为P/R，工作状态为14/15,说明浅库位已经空了，可以执行入库任务
                                        continue;
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
                            if (null == waitWrkMast) {
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                if (waitWrkMast.getWrkSts() < 17) {
                                    waitWrkMast.setIoPri(30D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    //20220719 Add，如果浅库位状态为P/R，工作状态为14/15,说明浅库位已经空了，可以执行入库任务
                                }
                                break;
                            }
                            case "F":
                            case "D":
                                // 此标记避免多次执行移库任务
                                if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())) {
                                    wrkMast.setUpdMk("Y");
                                    wrkMast.setIoPri(20D);
                                    wrkMastMapper.updateById(wrkMast);
                                    // 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行)
                                    moveLocForDeepLoc(slave, shallowLoc);
                                }
                            continue;
                        }
                        if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            // 此标记避免多次执行移库任务
                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())) {
                                wrkMast.setUpdMk("Y");
                                wrkMast.setIoPri(20D);
                                wrkMastMapper.updateById(wrkMast);
                                // 生成工作档、改变浅库位的源库/目标库 库位状态、下发堆垛机命令（立马执行)
                                moveLocForDeepLoc(slave, shallowLoc);
                            }
                            continue;
                        }
                        if (shallowLoc.getLocSts().equals("Q")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
                            if (null != waitWrkMast && waitWrkMast.getWrkSts() == 9) {
                                continue;
                            case "Q": {
                                WrkMast waitWrkMast = wrkMastMapper.selectBySourceLocNo(shallowLocNo);
                                if (null != waitWrkMast && waitWrkMast.getWrkSts() == 9) {
                                    continue;
                                }
                                break;
                            }
                        }
                    }
@@ -781,8 +775,9 @@
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 {} => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
                        } else {
                            return true;
                        }
                        return true;
                    }
                }
            } else {
@@ -797,11 +792,13 @@
                            // 没有其他任务
                            if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
                                return true;
                            }
                        }
                        // 小车搬走
                        if (wrkMast.getWrkSts() == 3L) {
                            this.carMoveOut(wrkMast, steNo, crnProtocol);
                            return true;
                        }
                        // 没有小车
                    } else {
@@ -838,8 +835,9 @@
                                wrkMast.setModiTime(now);
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    log.error("修改工作档状态 {} => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
                                } else {
                                    return true;
                                }
                                return true;
                            }
                        }

@@ -851,11 +849,13 @@
                    Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                    // 有小车
                    if (steNo != null) {
                        // 小车行走到堆垛机待搬移点
                        // 小车行走到待机位
                        if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                            // 没有其他任务
                            if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                            } else {
                                return true;
                            }
                        }
                        // 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入  ===>> 7.吊车入库中
@@ -892,8 +892,9 @@
                                    wrkMast.setModiTime(now);
                                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                                        log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                                    } else {
                                        return true;
                                    }
                                    return true;
                                }
                            }
                        }
@@ -907,12 +908,14 @@
                                if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                    // 让小车等待搬运待续
                                    this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
                                    return true;
                                }
                            }
                        }
                        // 堆垛机搬运小车
                        if (wrkMast.getWrkSts() == 3L) {
                            this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                            return true;
                        }
                    }
                }
@@ -925,7 +928,7 @@
    /**
     * 出库  ===>>  库位到堆垛机站
     */
    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());
@@ -943,6 +946,16 @@
                log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                continue;
            }

            // 判断是否有同库位组的出库任务，如果有，则暂停
            List<String> outsideLoc = Utils.getGroupOutsideLoc(wrkMast.getSourceLocNo());
            if (!Cools.isEmpty(outsideLoc)) {
                if (!Cools.isEmpty(wrkMastMapper.selectWorkingOfPakOutBySource(outsideLoc))) {
//                    log.warn("{}工作档出库失败，原因：外层库位{}正在执行出库任务！", wrkMast.getWrkNo(), JSON.toJSONString(outsideLoc));
                    continue;
                }
            }

            // 获取堆垛机出库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
@@ -974,11 +987,11 @@
                }

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

                // 判断是否为穿梭库
                if (!locMastService.isShuttle(wrkMast.getLocNo())) {
                if (!locMastService.isShuttle(wrkMast.getSourceLocNo())) {

                    // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                    if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
@@ -991,7 +1004,7 @@
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                if(waitWrkMast.getWrkSts() == 11) {
                                    waitWrkMast.setIoPri(20D);
                                    waitWrkMast.setIoPri(wrkMast.getIoPri() + 1);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
@@ -1039,8 +1052,9 @@
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 11.生成出库ID => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        } else {
                            return true;
                        }
                        break;
                    }

                } else {
@@ -1074,8 +1088,9 @@
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 11.生成出库ID => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                return true;
                            }
                            return true;
                        }
                    // 不是最外层库位，需要使用穿梭车搬运后，再堆垛机出库
                    } else {
@@ -1110,8 +1125,13 @@
                                        wrkMast.setSteNo(steNo);
                                        wrkMast.setCrnStrTime(now);
                                        wrkMast.setModiTime(now);
                                        LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                                        Integer outCrnNo = locMastService.getOutCrnNo(locMast);
                                        wrkMast.setCrnNo(outCrnNo);
                                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                                            log.error("修改工作档状态 11.生成出库ID => 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
                                        } else {
                                            return true;
                                        }
                                    }
                                }
@@ -1144,8 +1164,9 @@
                                    wrkMast.setModiTime(now);
                                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                                        log.error("修改工作档状态 15.等待吊车 => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                                    } else {
                                        return true;
                                    }
                                    return true;
                                }
                            }

@@ -1159,12 +1180,14 @@
                                    if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
                                        // 让小车等待搬运待续
                                        this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
                                        return true;
                                    }
                                }
                            }
                            // 堆垛机搬运小车
                            if (wrkMast.getWrkSts() == 12L) {
                                this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                                return true;
                            }
                        }
                    }
@@ -1178,6 +1201,7 @@
    /**
     * 库位移转
     */
    @Deprecated
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
@@ -1255,11 +1279,12 @@
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), true))
                    && steProtocol.getBay() == Utils.getBay(locNo)
                    && steProtocol.getLev() == Utils.getLev(locNo)) {
                return steProtocol.getSteNo().intValue();
            BasSte basSte = basSteService.selectById(ste.getId());
            if (Cools.isEmpty(steProtocol, basSte)) { continue; }
            if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(basSte.getRow(), true))
                    && basSte.getBay() == Utils.getBay(locNo)
                    && basSte.getLev() == Utils.getLev(locNo)) {
                return ste.getId();
            }
        }
        return null;
@@ -1329,7 +1354,14 @@
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (!steProtocol.isIdle()) { continue; }
            if (steProtocol.getRow() == 1) { continue; }
            String locNo = wrkMast.getWrkSts() < 10 ? wrkMast.getLocNo() : wrkMast.getSourceLocNo();
            // 如果在同一个库位组
            if (Utils.getGroupRow(locNo, true).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), true))
                    && steProtocol.getBay().intValue() == Utils.getBay(locNo)
                    && steProtocol.getLev().intValue() == Utils.getLev(locNo)) {
                return steThread;
            }
            LocMast locMast = locMastService.selectById(locNo);
            int lev = locMast.getLev1();
            int bay = locMast.getBay1();
@@ -1349,8 +1381,7 @@
    }

    /**
     * 让小车从 远点 ====>> 待机
     *  等待堆垛机搬运
     * 让小车行走至待机位
     */
    public void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
        // 获取穿梭车信息
@@ -1359,24 +1390,35 @@
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

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

            steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).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 {
            // 如果处于待机位
            if (steProtocol.locaType.equals(SteLocaType.A_WAITING) || steProtocol.locaType.equals(SteLocaType.B_WAITING)) {
                // 修改工作档状态 绑定穿梭车
                wrkMast.setWrkSts(3L);
                wrkMast.setSteNo(steNo);
                wrkMast.setModiTime(new Date());
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkMast.getWrkNo());
                }
            } else {
                // 命令下发区 --------------------------------------------------------------------------
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(steNo); // 穿梭车编号
                steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.findWaiting(steProtocol.getRow().intValue())); // 任务模式:  行走至待机位

                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).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 {
                    // 修改工作档状态 绑定穿梭车
                    wrkMast.setSteNo(steNo);
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                }
            }
        }
@@ -1459,7 +1501,7 @@
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() == 0) {
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) && crnProtocol.getTaskNo() == 0) {
                LocMast locMast;
                // 入库搬
                if (wrkMast.getWrkSts() <= 10) {
@@ -1551,7 +1593,7 @@
        // 穿梭车空闲
        if (steProtocol.isIdle()) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() == 0) {
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) && crnProtocol.getTaskNo() == 0) {

                BasSte basSte = basSteService.selectById(steNo);
                if (basSte == null) {
@@ -1602,7 +1644,6 @@
    /**
     * 执行对工作档的完成操作
     */
    @Async
    @Transactional
    public void storeFinished() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
@@ -1663,6 +1704,34 @@
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 42) {
                            // 42.吊车搬运 ===>> 43.小车到达
                            wrkCharge.setWrkSts(43L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改复位任务状态 42.吊车搬运 ===>> 43.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 46) {
                            // 46.放至待机位 ===>> 47.复位成功
                            wrkCharge.setWrkSts(47L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改复位任务状态 46.放至待机位 ===>> 47.复位成功 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    log.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        }
@@ -1817,6 +1886,9 @@
                            Date now = new Date();
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                            Integer outCrnNo = locMastService.getOutCrnNo(locMast);
                            wrkMast.setCrnNo(outCrnNo);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
@@ -1906,6 +1978,14 @@
                                wrkCharge.setWrkSts(37L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }  else if (wrkCharge.getWrkSts() == 44) {
                                // 44.小车走行 ===>> 45.小车待搬
                                wrkCharge.setWrkSts(45L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改演示任务状态 44.小车走行 ===>> 45.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
@@ -2229,7 +2309,6 @@
    /**
     * 空栈板初始化入库,叉车入库站放货
     */
    @Async
    public void storeEmptyPlt(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历空板入库口
@@ -2318,7 +2397,6 @@
    /**
     * 出库  ===>> 工作档信息写入led显示器
     */
    @Async
    public void ledExecute() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
@@ -2419,7 +2497,6 @@
    /**
     * 其他  ===>> LED显示器复位，显示默认信息
     */
    @Async
    public void ledReset() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
@@ -2451,6 +2528,12 @@
     */
    @SuppressWarnings("serial")
    public synchronized void loopSteCharge() {
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) {
            return;
        }
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.charge)) {
            return;
        }
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        for (SteSlave ste : slaveProperties.getSte()) {
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
@@ -2473,7 +2556,7 @@
                if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                WrkCharge wrkCharge = wrkChargeService.selectWorking(null);
                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);

                if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
                    // 寻找空闲充电桩
@@ -2481,23 +2564,29 @@
                    do {
                        String locNo;
                        if (!devpThread.charge0) {
                            locNo = SteChargeType.FIRST.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null) {
                                steCharge = SteChargeType.FIRST;
                            SteChargeType first = SteChargeType.FIRST;
                            locNo = first.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null
                                && wrkChargeService.selectWorkingOfCharge(first.ssbm) == null) {
                                steCharge = first;
                                break;
                            }
                        }
                        if (!devpThread.charge1) {
                            locNo = SteChargeType.SECOND.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null) {
                                steCharge = SteChargeType.SECOND;
                            SteChargeType second = SteChargeType.SECOND;
                            locNo = second.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null
                                && wrkChargeService.selectWorkingOfCharge(second.ssbm) == null) {
                                steCharge = second;
                                break;
                            }
                        }
                        if (!devpThread.charge2) {
                            locNo = SteChargeType.THIRD.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null) {
                                steCharge = SteChargeType.THIRD;
                            SteChargeType third = SteChargeType.THIRD;
                            locNo = third.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null
                                && wrkChargeService.selectWorkingOfCharge(third.ssbm) == null) {
                                steCharge = third;
                                break;
                            }
                        }
@@ -2511,15 +2600,51 @@
                    String chargeLocNo = steCharge.locNo;
                    wrkCharge = new WrkCharge();
                    wrkCharge.setSteNo(ste.getId());
                    wrkCharge.setCharge(steCharge.ssbm);
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
                    wrkCharge.setWrkSts(21L);   // 21.准备充电
                    wrkCharge.setCrnNo(2);  // 固定2号堆垛机
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setLocNo(chargeLocNo);
                    wrkCharge.setMemo("charge");
                    wrkCharge.setAppeTime(new Date());
                    if (!wrkChargeService.insert(wrkCharge)) {
                        log.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
                        continue;
                    }

                    // 小车处于通道
                    List<String> channel = slaveProperties.getChannel();
                    for (String channelLocNo : channel) {
                        if (steProtocol.getRow().intValue() == Utils.getRow(channelLocNo)
                                && steProtocol.getBay().intValue() == Utils.getBay(channelLocNo)
                                && steProtocol.getLev().intValue() == Utils.getLev(channelLocNo)) {
                            Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
                            if (null != otherSte) {
                                log.warn("{}号小车充电阻断，原因：通道存在{}号穿梭车！", wrkCharge.getSteNo(), otherSte);
                            } else {
                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                                steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN);  // 去右端

                                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
                                steCommand.setBay(steProtocol.getBay());
                                steCommand.setLev(steProtocol.getLev());
                                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                                } else {
                                    // 修改工作档状态 21.准备充电 ===> 25.小车走行
                                    wrkCharge.setWrkSts(25L);
                                    Date now = new Date();
                                    wrkCharge.setModiTime(now);
                                    if (!wrkChargeService.updateById(wrkCharge)) {
                                        log.error("修改充电任务状态 21.准备充电 ===> 25.小车走行 失败！！，工作号={}", wrkCharge.getWrkNo());
                                    }
                                }
                            }
                        }
                    }

                    // 处于充电库位组
@@ -2536,154 +2661,199 @@
                        this.letCarBeWaiting(wrkCharge, ste.getId());
                    }

                } else {
                    // filter
                    if (wrkCharge == null || (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1)) {
                        continue;
                    }
                    break;
                }
            } catch (Exception e) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                log.error("loopSteCharge fail", e);
            }
        }
    }

                    // 22.小车待搬
                    if (wrkCharge.getWrkSts() == 22) {
    /**
     * 执行小车充电任务
     */
    public synchronized void executeSteCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        if (null == wrkCharge) { return; }
        Integer steNo = wrkCharge.getSteNo();
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        BasSte basSte = basSteService.selectById(steNo);
        if (Cools.isEmpty(steProtocol, basSte)) { return; }
        if (steProtocol.getMode() == 0
                || !steProtocol.statusType.equals(SteStatusType.IDLE)
                || basSte.getPakMk().equals("Y")
                || basSte.getAutoCharge().equals("N")
//                || steProtocol.getChargeStatus() == 1
        ) {
            return;
        }
        if (!steProtocol.isEnable()) {
            return;
        }
        if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
            wrkCharge.setWrkSts(30L);
            wrkChargeMapper.updateById(wrkCharge);
            return;
        }
        try {
            // filter
            if (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1) {
                return;
            }

                        // 搬小车至小车走向通道
                        List<String> channel = slaveProperties.getChannel();
                        for (String channelLocNo : channel) {
                            Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
                            if (null != otherSte) {
                                log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
                            } else {
                                LocMast channelLoc = locMastService.selectById(channelLocNo);
            // 22.小车待搬
            if (wrkCharge.getWrkSts() == 22) {

                                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                                if (crnProtocol == null) { continue; }
                                // 只有当堆垛机空闲 并且 无任务时才继续执行
                                if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                                    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(), true).shortValue());     // 源库位排
                                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                                    crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), true).shortValue());     // 目标库位排
                                    crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue());     // 目标库位列
                                    crnCommand.setDestinationPosZ(channelLoc.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(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
                                        // 修改工作档状态 22.小车待搬 => 23.吊车搬运
                                        Date now = new Date();
                                        wrkCharge.setWrkSts(23L);
                                        wrkCharge.setCrnStrTime(now);
                                        wrkCharge.setModiTime(now);
                                        if (!wrkChargeService.updateById(wrkCharge)) {
                                            log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                                        }
                                    }
                                    break;
                                }
                // 入出库任务优先
                if (null != wrkMastMapper.selectWorkingByCrn(wrkCharge.getCrnNo())) {
                    return;
                }

                            }
                        }
                // 搬小车至小车走向通道
                List<String> channel = slaveProperties.getChannel();
                for (String channelLocNo : channel) {
                    Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
                    if (null != otherSte) {
                        log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
                    } else {
                        LocMast channelLoc = locMastService.selectById(channelLocNo);

                    } else if (wrkCharge.getWrkSts() == 24L) {
                        // 小车行驶通道
                        if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
                            if (steProtocol.getChargeStatus() == 1) { continue; }
                            // 命令下发区 --------------------------------------------------------------------------
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN);  // 去右端

                            steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
                            steCommand.setBay(steProtocol.getBay());
                            steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                            } else {
                                // 修改工作档状态 24.小车到达 ===> 25.小车走行
                                wrkCharge.setWrkSts(25L);
                                Date now = new Date();
                                wrkCharge.setCrnEndTime(now);
                                wrkCharge.setModiTime(now);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 24.小车到达 ===> 25.小车走行 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                        }
                    } else if (wrkCharge.getWrkSts() == 26) {
                        // 固定堆垛机
                        int crnNo = 1;
                        // 充电位
                        LocMast chargeLoc = locMastService.selectById(wrkCharge.getLocNo());

                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                        CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                        if (crnProtocol == null) { continue; }
                        // 只有当堆垛机空闲 并且 无任务时才继续执行
                        if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                            // 堆垛机命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(crnNo); // 堆垛机编号
                            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(), false).shortValue());     // 源库位排
                            crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                            crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                            crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(2, crnCommand))) {
                                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
                            crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), true).shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改穿梭车运行中排列层
                                steThread.modifyPos(chargeLoc.getRow1(), chargeLoc.getBay1(), chargeLoc.getLev1());
                                // 修改工作档状态 26.等待充电 => 27.放至充电位
                                steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
                                // 修改工作档状态 22.小车待搬 => 23.吊车搬运
                                Date now = new Date();
                                wrkCharge.setWrkSts(27L);
                                wrkCharge.setWrkSts(23L);
                                wrkCharge.setCrnStrTime(now);
                                wrkCharge.setModiTime(now);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改工作档状态 26.等待充电 => 27.放至充电位 失败！！，工作号={}", wrkCharge.getWrkNo());
                                    log.error("修改工作档状态 22.小车待搬 => 23.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                            break;
                        }
                    } else if (wrkCharge.getWrkSts() == 28L) {
                        // 穿梭车下发充电任务
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                        steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
                        if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                        } else {
                            // 28.充电就绪 ===>> 29.开始充电
                            wrkCharge.setWrkSts(29L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                            }

                    }
                }

            } else if (wrkCharge.getWrkSts() == 24L) {
                // 小车行驶通道
                if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
                    if (steProtocol.getChargeStatus() == 1) { return; }
                    // 命令下发区 --------------------------------------------------------------------------
                    SteCommand steCommand = new SteCommand();
                    steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                    steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                    steCommand.setTaskMode(SteTaskModeType.GO_ORIGIN);  // 去右端

                    steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
                    steCommand.setBay(steProtocol.getBay());
                    steCommand.setLev(steProtocol.getLev());
                    if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                        log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                    } else {
                        // 修改工作档状态 24.小车到达 ===> 25.小车走行
                        wrkCharge.setWrkSts(25L);
                        Date now = new Date();
                        wrkCharge.setCrnEndTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            log.error("修改充电任务状态 24.小车到达 ===> 25.小车走行 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    }
                }
            } catch (Exception e) {
                log.error("fail", e);
            } else if (wrkCharge.getWrkSts() == 26) {
                // 固定堆垛机
                int crnNo = 1;
                // 入出库任务优先
                if (null != wrkMastMapper.selectWorkingByCrn(crnNo)) {
                    return;
                }

                // 充电位
                LocMast chargeLoc = locMastService.selectById(wrkCharge.getLocNo());

                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) { return; }
                // 只有当堆垛机空闲 并且 无任务时才继续执行
                if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(crnNo); // 堆垛机编号
                    crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(chargeLoc.getRow1().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(chargeLoc.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(chargeLoc.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
                        log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(crnCommand));
                    } else {
                        // 修改穿梭车运行中排列层
                        steThread.modifyPos(chargeLoc.getRow1(), chargeLoc.getBay1(), chargeLoc.getLev1());
                        // 修改工作档状态 26.等待充电 => 27.放至充电位
                        Date now = new Date();
                        wrkCharge.setWrkSts(27L);
                        wrkCharge.setCrnStrTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            log.error("修改工作档状态 26.等待充电 => 27.放至充电位 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    }
                }
            } else if (wrkCharge.getWrkSts() == 28L) {
                // 穿梭车下发充电任务
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                } else {
                    // 28.充电就绪 ===>> 29.开始充电
                    wrkCharge.setWrkSts(29L);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        log.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }
                }
            }
        } catch (Exception e) {
            log.error("executeSteCharge fail", e);
        }
    }

    /**
     * 小车从充电桩 至 待机库位
     * 轮询充电桩是否有空闲小车
     */
    public synchronized void steFromChargeToIdleLoc() {
    public synchronized void queryChargeLocOfComplete() {
        // 与充电任务不同步进行
        if (null != wrkChargeService.selectWorking(null)) { return; }
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.charge)) { return; }
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) { return; }
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        // 检索充电桩
        for (SteChargeType value : SteChargeType.values()) {
@@ -2695,96 +2865,198 @@
                if (Cools.isEmpty(steProtocol, basSte)) {
                    continue;
                }
                // 1号充电桩
                if (value.equals(SteChargeType.FIRST) && devpThread.charge0) {
                if (steProtocol.getCharge() < 99) {
                    continue;
                }
                // 2号充电桩
                if (value.equals(SteChargeType.SECOND) && devpThread.charge1) {
                if (steProtocol.getMode() == 0) {
                    continue;
                }
                // 3号充电桩
                if (value.equals(SteChargeType.THIRD) && devpThread.charge2) {
                if (!steProtocol.getStatusType().equals(SteStatusType.IDLE)) {
                    continue;
                }
                // 小车是否处于充电状态
                if (steProtocol.getChargeStatus() == 1) {
                    continue;
                }
//                // 1号充电桩
//                if (value.equals(SteChargeType.FIRST) && devpThread.charge0) {
//                    continue;
//                }
//                // 2号充电桩
//                if (value.equals(SteChargeType.SECOND) && devpThread.charge1) {
//                    continue;
//                }
//                // 3号充电桩
//                if (value.equals(SteChargeType.THIRD) && devpThread.charge2) {
//                    continue;
//                }
//                // 小车是否处于充电状态
//                if (steProtocol.getChargeStatus() == 1) {
//                    continue;
//                }
                // case 1 : 自动充电开   馈电      ×
                // case 2 : 自动充电开   满电      ✔
                // case 3 : 自动充电关   馈电      ✔
                // case 4 : 自动充电关   满电      ✔
                if (basSte.getAutoCharge().equals("Y")
                    && steProtocol.getCharge() < Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                // 开始穿梭车复位任务
                WrkCharge wrkCharge = new WrkCharge();
                wrkCharge.setSteNo(steNo);
                wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
                wrkCharge.setWrkSts(41L);   // 41.小车准备复位
                wrkCharge.setCrnNo(2);  // 固定2号堆垛机
                wrkCharge.setIoPri((double) 10);
                wrkCharge.setSourceLocNo(value.locNo);
                wrkCharge.setLocNo(basSte.getIdleLoc());
                wrkCharge.setMemo("reset");
                if (!wrkChargeService.insert(wrkCharge)) {
                    log.error("保存{}号穿梭车复位任务失败!!!", steNo);
                        && steProtocol.getCharge() < Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }

                // 1.搬运至固定通道
                if (wrkCharge.getWrkSts() == 41L) {
                    // 搬小车至小车走向通道
                    List<String> channel = slaveProperties.getChannel();
                    for (String channelLocNo : channel) {
                        Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
                        if (null != otherSte) {
                            log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
                WrkCharge wrkCharge = wrkChargeService.selectWorking(steNo, WrkChargeType.reset);

                if (wrkCharge == null) {
                    // 开始穿梭车复位任务
                    wrkCharge = new WrkCharge();
                    wrkCharge.setSteNo(steNo);
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(6));
                    wrkCharge.setWrkSts(41L);   // 41.小车准备复位
                    wrkCharge.setCrnNo(2);  // 固定2号堆垛机
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setSourceLocNo(value.locNo);
                    wrkCharge.setLocNo(basSte.getIdleLoc());
                    wrkCharge.setMemo("reset");
                    wrkCharge.setAppeTime(new Date());
                    if (!wrkChargeService.insert(wrkCharge)) {
                        log.error("保存{}号穿梭车复位任务失败!!!", steNo);
                    } else {
                        break;
                    }
                }
            }
        }
    }

    /**
     * 小车从充电桩 至 待机库位
     */
    public synchronized void steFromChargeToIdleLoc() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.reset);
        if (wrkCharge == null) { return; }
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
        SteProtocol steProtocol = steThread.getSteProtocol();
        BasSte basSte = basSteService.selectById(wrkCharge.getSteNo());
        if (Cools.isEmpty(steProtocol, basSte)) {
            return;
        }
        // 搬运至固定通道
        if (wrkCharge.getWrkSts() == 41L) {
            // 搬小车至小车走向通道
            List<String> channel = slaveProperties.getChannel();
            for (String channelLocNo : channel) {
                Integer otherSte = existOtherSte(channelLocNo, wrkCharge.getSteNo());
                if (null != otherSte) {
                    log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), channelLocNo, otherSte);
                } else {
                    // 固定堆垛机
                    int crnNo = 1;
                    if (null != wrkMastMapper.selectWorkingByCrn(crnNo)) {
                        return;
                    }

                    LocMast channelLoc = locMastService.selectById(channelLocNo);

                    CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
                    CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                    if (crnProtocol == null) { continue; }
                    // 只有当堆垛机空闲 并且 无任务时才继续执行
                    if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                        // 堆垛机命令下发区 --------------------------------------------------------------------------
                        CrnCommand crnCommand = new CrnCommand();
                        crnCommand.setCrnNo(crnNo); // 堆垛机编号
                        crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(steProtocol.getRow());     // 源库位排
                        crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                        crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                        crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), false).shortValue());     // 目标库位排
                        crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue());     // 目标库位列
                        crnCommand.setDestinationPosZ(channelLoc.getLev1().shortValue());     // 目标库位层
                        if (!MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, crnCommand))) {
                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 固定堆垛机
                            int crnNo = 1;
                            LocMast channelLoc = locMastService.selectById(channelLocNo);

                            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
                            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                            if (crnProtocol == null) { continue; }
                            // 只有当堆垛机空闲 并且 无任务时才继续执行
                            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                                // 堆垛机命令下发区 --------------------------------------------------------------------------
                                CrnCommand crnCommand = new CrnCommand();
                                crnCommand.setCrnNo(crnNo); // 堆垛机编号
                                crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                                crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                                crnCommand.setDestinationPosX(Utils.getGroupRow(channelLoc.getLocNo(), false).shortValue());     // 目标库位排
                                crnCommand.setDestinationPosY(channelLoc.getBay1().shortValue());     // 目标库位列
                                crnCommand.setDestinationPosZ(channelLoc.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(channelLoc.getLocNo(), true), channelLoc.getBay1(), channelLoc.getLev1());
                                    // 修改工作档状态 41.小车准备复位 => 42.吊车搬运
                                    Date now = new Date();
                                    wrkCharge.setWrkSts(42L);
                                    wrkCharge.setCrnStrTime(now);
                                    wrkCharge.setModiTime(now);
                                    if (!wrkChargeService.updateById(wrkCharge)) {
                                        log.error("修改工作档状态 41.小车准备复位 => 42.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                                    }
                                }
                                break;
                            // 修改穿梭车运行中排列层
                            steThread.modifyPos(Utils.getGroupRow(channelLoc.getLocNo(), false), channelLoc.getBay1(), channelLoc.getLev1());
                            // 修改工作档状态 41.小车准备复位 => 42.吊车搬运
                            Date now = new Date();
                            wrkCharge.setWrkSts(42L);
                            wrkCharge.setCrnStrTime(now);
                            wrkCharge.setModiTime(now);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改复位任务状态 41.小车准备复位 => 42.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                            }

                        }
                        break;
                    }

                }
            }
        } else if (wrkCharge.getWrkSts() == 43L) {
            // 小车行驶通道
            if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
                // 命令下发区 --------------------------------------------------------------------------
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.BACK_ORIGIN);  // 去左端

                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());
                steCommand.setBay(steProtocol.getBay());
                steCommand.setLev(steProtocol.getLev());
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                } else {
                    // 修改工作档状态 43.小车到达 ===> 44.小车走行
                    wrkCharge.setWrkSts(44L);
                    Date now = new Date();
                    wrkCharge.setCrnEndTime(now);
                    wrkCharge.setModiTime(now);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        log.error("修改复位任务状态 43.小车到达 ===> 44.小车走行 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }
                }
            }
        } else if (wrkCharge.getWrkSts() == 45L) {
            if (null != wrkMastMapper.selectWorkingByCrn(wrkCharge.getCrnNo())) {
                return;
            }

            LocMast idleLoc = locMastService.selectById(basSte.getIdleLoc());

            Integer otherSte = existOtherSte(idleLoc.getLocNo(), wrkCharge.getSteNo());
            if (null != otherSte) {
                log.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", wrkCharge.getSteNo(), idleLoc.getLocNo(), otherSte);
            } else {
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) { return; }
                // 只有当堆垛机空闲 并且 无任务时才继续执行
                if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    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(), true).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(idleLoc.getLocNo(), true).shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(idleLoc.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(idleLoc.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(idleLoc.getLocNo(), true), idleLoc.getBay1(), idleLoc.getLev1());
                        // 修改工作档状态 45.小车待搬 => 46.放至待机位
                        Date now = new Date();
                        wrkCharge.setWrkSts(46L);
                        wrkCharge.setCrnStrTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            log.error("修改工作档状态 45.小车待搬 => 46.放至待机位 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    }
                }

            }
        }
    }
@@ -2811,7 +3083,6 @@
                            }
                        }
                    }


                    if (null != loc) {
                        break;