#

luxiaotao1123

2022-09-22 29e8cbccfba7cd77026c724d093d6a82da99e5af

 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;

    /**
     * 组托
@@ -479,6 +485,10 @@
                continue;
            }

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

            // 目标库位 ===>> 最外层库位
            if (locMastService.isOutMost(wrkMast.getLocNo())) {
                // 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
@@ -650,6 +660,10 @@
                    continue;
                }

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

                // 最外层库位，直接堆垛机出库
                if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
                    // 已经存在吊车执行任务时，则过滤
@@ -817,6 +831,10 @@
            return;
        }

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

        // 源库位 ===>> 最外层库位
        if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
            // 目标库位 ===>> 最外层库位
@@ -913,6 +931,7 @@
            }

        } else {

            // 当前组库位是否有穿梭车
            Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
            // 有小车
@@ -984,6 +1003,10 @@
                            wrkMastMapper.setSteEmpty(wrkMast.getWrkNo());
                        }
                    } else {

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


                        // 小车行走到堆垛机待搬移点
                        if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
@@ -1117,6 +1140,39 @@
                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 (!basSteService.updatePakMk(steNo, "Y")) {
            log.error("修改穿梭车作业状态 失败！！，穿梭车={}", steNo);
            return;
        }

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

        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());
            }
        }
    }
@@ -1298,9 +1354,33 @@
                // 获取入库待确认工作档
                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() == 23) {
                            // 23.吊车搬运 ===>> 24.小车到达
                            wrkCharge.setWrkSts(24L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                log.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达 失败！！，工作号={}", 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 == null) { continue; }
                if (wrkMast.getIoType() != 11) {
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
@@ -1547,7 +1627,7 @@
    /**
     * 执行对工作档的完成操作
     */
    public void carGenerateStore() {
    public synchronized void carGenerateStore() {
        Date now = new Date();
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取穿梭车信息
@@ -1560,8 +1640,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() == 21) {
                                // 21.准备充电 ===>> 22.小车待搬
                                wrkCharge.setWrkSts(22L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 25) {
                                // 25.小车去充电 ===>> 26.等待充电
                                wrkCharge.setWrkSts(26L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
                        }
                    }

                    if (wrkMast == null) { continue; }
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 2:
                            // 修改工作档状态 2.设备上走 => 3.小车待搬
@@ -1942,4 +2047,142 @@
        }
    }

    /**
     * 小车电量检测 ===>> 发起充电
     */
    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.getMode() == 0
                        || !steProtocol.statusType.equals(SteStatusType.IDLE)
                        || basSte.getPakMk().equals("Y")
//                        || steProtocol.getChargeStatus() == 1
                ) {
                    continue;
                }
                if (!steProtocol.isEnable()) {
                    continue;
                }
                if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                WrkCharge wrkCharge = wrkChargeService.selectWorking(steProtocol.getSteNo().intValue());

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

                    // 处于充电库位组
                    if (Utils.getGroupRow(idleLoc).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(idleLoc) && steProtocol.getLev() == Utils.getLev(idleLoc)) {
                        // 修改工作档状态 21.准备充电 => 24.小车到达
                        wrkCharge.setWrkSts(24L);
                        wrkCharge.setModiTime(new Date());
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            log.error("修改充电任务状态 21.准备充电 => 24.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    } else {
                        this.letCarBeWaiting(wrkCharge, ste.getId());
                    }

                } else {
                    // filter
                    if (wrkCharge.getWrkSts() < 26 && steProtocol.getChargeStatus() == 1) {
                        continue;
                    }

                    // 22.小车待搬
                    if (wrkCharge.getWrkSts() == 22) {
                        // 搬小车至充电库位
                        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());
                            // 修改工作档状态 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());
                            }
                        }

                    } 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.findChargeByLoc(steProtocol.getRow().intValue()));
                            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) {
                        if (steProtocol.getChargeStatus() == 0) { continue; }
                        // 给输送线下发充电任务
                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                        SteChargeType steChargeType = SteChargeType.get(wrkCharge.getLocNo());
                        if (null != steChargeType) {
                            if (devpThread.charge(steChargeType.ssbm - 1, true)) {
                                // 修改工作档状态 26.等待充电 ===> 28.完成充电
                                wrkCharge.setWrkSts(28L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    log.error("修改充电任务状态 26.等待充电 ===> 28.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
                        } else {
                            log.error("获取充电桩号失败，解析库位：{}", wrkCharge.getLocNo());
                        }
                    }
                }
            } catch (Exception e) {
                log.error("fail", e);
            }
        }
    }

}