#

Junjie

2025-01-07 c41aa8ce031c6c549a75ab8f0f08ae7f998d3965

#

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

@@ -43,9 +43,9 @@
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private LocMastService locMastService;
    private WrkMastLogMapper wrkMastLogMapper;
    @Autowired
    private StaDescService staDescService;
    private LocMastService locMastService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
@@ -64,8 +64,6 @@
    private ShuttleDispatchUtils shuttleDispatchUtils;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private WrkMastLogMapper wrkMastLogMapper;
    @Autowired
    private BasLiftOptService basLiftOptService;
    @Autowired
@@ -819,28 +817,27 @@
//        return true;
//    }

//    /**
//     * 四向穿梭车任务完成
//     */
//    public synchronized void shuttleFinished() {
//        try {
//            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
//                //获取四向穿梭车信息
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                //四向穿梭车状态为等待确认、小车处于空闲状态
//                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
//                        && shuttleProtocol.getTaskNo() != 0
//                        && shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
//                ) {
//                    //将任务档标记为完成
//                    WrkMast wrkMast = wrkMastMapper.selectByWorkNo(shuttleProtocol.getTaskNo());
//                    if (wrkMast != null) {
//                        switch (wrkMast.getWrkSts().intValue()) {
    /**
     * 四向穿梭车任务完成
     */
    public synchronized void shuttleFinished() {
        try {
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                //获取四向穿梭车信息
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                if (shuttleProtocol == null) {
                    continue;
                }

                //四向穿梭车状态为等待确认、小车处于空闲状态
                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
                        && shuttleProtocol.getTaskNo() != 0
                ) {
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
                    if (wrkMast != null) {
                        switch (wrkMast.getWrkSts().intValue()) {
//                            case 5://5.小车搬运中 ==> 9.入库完成
//                                wrkMast.setWrkSts(9L);
//                                shuttleProtocol.setTaskNo(0);
@@ -857,78 +854,55 @@
//                                    shuttleProtocol.setToken(0);
//                                }
//                                break;
//                            case 102://102.小车移动至站点 ==> 103.小车移动至站点完成
//                                wrkMast.setWrkSts(103L);
//                                break;
//                            case 104://104.小车迁入提升机中 ==> 105.小车迁入提升机完成
//                                wrkMast.setWrkSts(105L);
//                                shuttleProtocol.setTaskNo(0);//清理工作号
//                                break;
//                            case 108://108.小车迁出提升机中 ==> 109.小车迁出提升机完成
//                                wrkMast.setWrkSts(109L);
//                                break;
//                            case 110://110.小车移动中 ==> 111.小车移动完成
//                                wrkMast.setWrkSts(111L);
//                                shuttleProtocol.setTaskNo(0);
//                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放小车令牌
//                                    shuttleProtocol.setToken(0);
//                                }
//                                break;
//                            default:
//                        }
//
//                        if (wrkMastMapper.updateById(wrkMast) > 0) {
//                            if (wrkMast.getWrkSts() == 111) {
//                                // 保存工作主档历史档
//                                if (wrkMastLogMapper.save(wrkMast.getWrkNo()) <= 0) {
//                                    log.info("保存工作历史档[workNo={0}]失败", wrkMast.getWrkNo());
//                                }
//                                // 删除工作主档
//                                if (!wrkMastService.deleteById(wrkMast)) {
//                                    log.info("删除工作主档[workNo={0}]失败", wrkMast.getWrkNo());
//                                }
//                            }
//
//                            //设置四向穿梭车为空闲状态
//                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
//                            //源库位清零
//                            shuttleProtocol.setSourceLocNo(null);
//                            //目标库位清零
//                            shuttleProtocol.setLocNo(null);
//                            //任务指令清零
//                            shuttleProtocol.setAssignCommand(null);
//                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
//                        } else {
//                            News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
//                        }
//                    } else {
//                        ShuttleAssignCommand assignCommand = shuttleProtocol.getAssignCommand();
//                        if (!assignCommand.getAuto()) {
//                            //手动模式
//                            //工作号清零
//                            shuttleProtocol.setTaskNo(0);
//                            //设置四向穿梭车为空闲状态
//                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
//                            //源库位清零
//                            shuttleProtocol.setSourceLocNo(null);
//                            //目标库位清零
//                            shuttleProtocol.setLocNo(null);
//                            //任务指令清零
//                            shuttleProtocol.setAssignCommand(null);
//                            //清零令牌
//                            shuttleProtocol.setToken(0);
//                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
//                        }
//                    }
//
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
                            case 302://302.小车移动至站点 ==> 303.小车移动至站点完成
                                wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
                                break;
                            case 110://310.小车移动中 ==> 311.小车移动完成
                                wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
                                shuttleThread.setTaskNo(0);
                                break;
                            default:
                        }

                        if (wrkMastService.updateById(wrkMast)) {
                            if (wrkMast.getWrkSts() == 111) {
                                // 保存工作主档历史档
                                if (wrkMastLogMapper.save(wrkMast.getWrkNo()) <= 0) {
                                    log.info("保存工作历史档[workNo={0}]失败", wrkMast.getWrkNo());
                                }
                                // 删除工作主档
                                if (!wrkMastService.deleteById(wrkMast)) {
                                    log.info("删除工作主档[workNo={0}]失败", wrkMast.getWrkNo());
                                }
                            }

                            //设置四向穿梭车为空闲状态
                            shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                        } else {
                            News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                        }
                    } else {
                        Object object = redisUtil.get(RedisKeyType.SHUTTLE_WORK_FLAG.key + shuttleProtocol.getTaskNo());
                        if(object != null){
                            ShuttleAssignCommand assignCommand = JSON.parseObject(object.toString(), ShuttleAssignCommand.class);
                            if (!assignCommand.getAuto()) {
                                //手动模式
                                //工作号清零
                                shuttleThread.setTaskNo(0);
                                //设置四向穿梭车为空闲状态
                                shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                                News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                            }
                        }
                    }
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 提升机任务
@@ -1253,37 +1227,27 @@
//        return true;
//    }
//
//    /**
//     * 提升机任务完成
//     */
//    public synchronized void liftFinished() {
//        try {
//            for (LiftSlave liftSlave : slaveProperties.getLift()) {
//                //获取提升机信息
//                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
//                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//                if (liftProtocol == null) {
//                    continue;
//                }
//
//                //提升机为等待确认且空闲
//                if (liftProtocol.getProtocolStatus() == LiftProtocolStatusType.WAITING.id
//                        && liftProtocol.getTaskNo() != 0
//                        && !liftProtocol.getBusy()
//                ) {
//                    int taskNo = liftProtocol.getTaskNo().intValue();
//                    if (taskNo >= 20000 && taskNo <= 30000) {
//                        //提升机设备工作号，需要查询对应任务号
//                        BasLiftOpt basLiftOpt = basLiftOptService.selectByDeviceWrk(liftProtocol.getTaskNo().toString(), liftSlave.getId());
//                        if (basLiftOpt != null) {
//                            taskNo = basLiftOpt.getWrkNo();
//                        }
//                    }
//
//                    //将任务档标记为完成
//                    WrkMast wrkMast = wrkMastMapper.selectByWorkNo324104(taskNo);
//                    if (wrkMast != null) {
//                        switch (wrkMast.getWrkSts().intValue()) {
    /**
     * 货叉提升机任务完成
     */
    public synchronized void forkLiftFinished() {
        try {
            for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
                //获取提升机信息
                ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
                ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
                if (forkLiftProtocol == null) {
                    continue;
                }

                //提升机为等待确认且空闲
                if (forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.WAITING.id
                        && forkLiftProtocol.getWrkNo() != 0
                ) {
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
                    if (wrkMast != null) {
                        switch (wrkMast.getWrkSts().intValue()) {
//                            case 3://3.提升机搬运中 ==> 4.提升机搬运完成
//                                wrkMast.setWrkSts(4L);
//                                wrkMast.setLiftNo(null);//释放提升机
@@ -1305,47 +1269,29 @@
//                                        wrkMast.setModiTime(new Date());
//                                    }
//                                }
//
//                                if (liftProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放提升机令牌
//                                    liftProtocol.setToken(0);
//                                }
//
//                                break;
//                            case 106://106.提升机搬运中 ==> 107.提升机搬运完成
//                                wrkMast.setWrkSts(107L);
//                                break;
//                            default:
//                        }
//
//                        if (wrkMastMapper.updateById(wrkMast) > 0) {
//                            //设置提升机为空闲状态
//                            liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
//                            //任务指令清零
//                            liftProtocol.setAssignCommand(null);
//                            News.info("提升机已确认且任务完成状态。提升机号={}", liftProtocol.getLiftNo());
//                        } else {
//                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
//                        }
//                    } else {
//                        LiftAssignCommand assignCommand = liftProtocol.getAssignCommand();
//                        if (assignCommand != null) {
//                            if (!assignCommand.getAuto()) {
//                                //手动操作
//                                //设置提升机为空闲状态
//                                liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
//                                //任务指令清零
//                                liftProtocol.setAssignCommand(null);
//                                News.info("提升机已确认手动操作。提升机号={}", liftProtocol.getLiftNo());
//                            }
//                        }
//                    }
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
                            case 306://306.提升机搬运中 ==> 307.提升机搬运完成
                                wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
                                //货叉提升机需要跳过迁出提升机流程
                                wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
                                break;
                            default:
                        }

                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            forkLiftThread.reset();
                            News.info("提升机已确认且任务完成状态。提升机号={}", forkLiftProtocol.getLiftNo());
                        } else {
                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", forkLiftProtocol.getLiftNo(), forkLiftProtocol.getWrkNo());
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 异常信息记录

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

@@ -54,12 +54,12 @@
//                    mainService.shuttleInExecute();
//                    // 出库  ===>>  四向穿梭车出库作业下发
//                    mainService.shuttleOutExecute();
//                    //四向穿梭车任务完成
//                    mainService.shuttleFinished();
                    //四向穿梭车任务完成
                    mainService.shuttleFinished();
//                    //提升机任务
//                    mainService.liftIoExecute();
//                    //提升机任务完成
//                    mainService.liftFinished();
                    //货叉提升机任务完成
                    mainService.forkLiftFinished();
                    //执行小车移库任务
                    mainService.shuttleMoveExecute();
//                    // 异常信息记录

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

@@ -23,7 +23,7 @@

    CommandResponse shuttleSwitch(ForkLiftCommand command);//小车换层

    CommandResponse reset(ForkLiftCommand command);//复位
    CommandResponse reset();//复位

    boolean isIdle();//是否空闲


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

@@ -269,8 +269,12 @@
    }

    @Override
    public CommandResponse reset(ForkLiftCommand command) {
    public CommandResponse reset() {
        CommandResponse response = new CommandResponse(false);
        OperateResult result = siemensS7Net.Write("DB103.20", (short) 1);
        if (result.IsSuccess) {
            response.setResult(true);
        }
        return response;
    }