#RGV协议修改，rgv预调度，任务下发

lty

2025-08-14 fc86a263ca2ffdb0e701261ff3b1e730b2065542

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

@@ -46,7 +46,6 @@
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
@@ -2699,13 +2698,13 @@
                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE &&
                    rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                    && !rgvProtocol.isLoaded1ing()  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                    && (rgvProtocol.getTaskNo1()==0)
                        &&rgvThread.isPakMk()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());

                    Integer rgvNoOther = basRgvMap.getRgvNoOther(rgvProtocol.getRgvNo());
                    Integer rgvNoOther = basRgvMap.getRgvNoOther((int) rgvProtocol.getRgvNo());
                    RgvThread rgvThreadOther = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvNoOther);
                    RgvProtocol rgvProtocolOther = rgvThreadOther.getRgvProtocol();
                    if (rgvProtocolOther == null) {
@@ -2715,7 +2714,7 @@
                    }
                    if (rgvProtocolOther.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocolOther.getModeType() == RgvModeType.AUTO
                        && rgvProtocolOther.getLoaded1()==0
                        && !rgvProtocolOther.isLoaded1ing()
                        && (rgvProtocolOther.getTaskNo1()==0)
                        &&rgvThreadOther.isPakMk()
                    ){
@@ -2788,7 +2787,22 @@
                        && (rgvProtocol.getStatusType() == RgvStatusType.WORKING1)
                ){
                    log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
                    if (rgvProtocol.getTaskNo1()!=0){
                    if(rgvProtocol.getTaskNo1() == 9999){
                        List<Integer> staNos = Arrays.asList( 1043, 1104);
                        for (Integer staNo : staNos) {
                            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                            StaProtocol staProtocol = devpThread.getStation().get(staNo);
                            boolean rgvComplete = false;
                            if(!staProtocol.isLoading()){
                                rgvComplete = rgvComplete((int) rgvProtocol.getRgvNo(),3);//工位1复位
                            }
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！等待入库取货",rgvProtocol.getRgvNo());
                                break;
                            }
                        }
                    }
                    if (rgvProtocol.getTaskNo1()!=0 && rgvProtocol.getTaskNo1()!=9999){
//                        if (rgvProtocol.getTaskNo1()==32222){
//                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
//                            if (!rgvComplete){
@@ -2849,9 +2863,9 @@

                        //双工位出入库不同工位复位
                        if((sourceSta >= 1001 && sourceSta <= 1035) || (sourceSta >= 2001 && sourceSta <= 2030)){
                            rgvComplete = rgvComplete(rgvProtocol.getRgvNo(),6);
                            rgvComplete = rgvComplete((int) rgvProtocol.getRgvNo(),6);
                        }else{
                            rgvComplete = rgvComplete(rgvProtocol.getRgvNo(),3);
                            rgvComplete = rgvComplete((int) rgvProtocol.getRgvNo(),3);

                        }
                        if (!rgvComplete){
@@ -2883,6 +2897,8 @@
    }
    /**
     * 执行小车搬运任务
     *
     * @return
     */
    public synchronized boolean rgvRunWrkMastFullSta() {
        boolean wrkEnable = false;
@@ -2902,14 +2918,13 @@
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                // 只有当RGV空闲、自动,工位一无物//rgv可用  入库取货
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1() == 0
                        && !rgvProtocol.isLoaded1ing()
                        && rgvProtocol.getTaskNo1() == 0
                        && rgvProtocol.getTaskNo2() == 0
                        && rgvProtocol.getLoaded2() == 0
                        && rgvThread.isPakMk()
                        && rgvThread.isPakIn()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
@@ -2920,35 +2935,10 @@
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                    for (WrkMastSta wrkMastSta : wrkMastStaList){
//                        if (wrkMastSta.getType()!=0 || wrkMastSta.getWrkType()!=3 || wrkMastSta.getWrkSts()!=0){//1:满版   3：取放
//                            continue;
//                        }
                        //判断工作结束位置状态
//                        boolean signDev = false;
//                        BasDevp devNo = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", wrkMastSta.getStaEnd()));
//                        if (devNo.getDevNo()==113){
//                            BasDevp devNo114 = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", 114));
//                            if (!Cools.isEmpty(devNo114)){
//                                if (devNo114.getOutEnable().equals("Y")){
//                                    signDev = true;
//                                }
//                            }
//                        }
//                        if (!Cools.isEmpty(devNo)){
//                            if (devNo.getAutoing().equals("Y") && !devNo.getWrkNo().equals(0) && !devNo.getLoading().equals("N")){
//                                continue;
//                            }
//                            if (!signDev && devNo.getDevNo()==113){
//                                if (!devNo.getAutoing().equals("Y") || !devNo.getWrkNo().equals(0) || !devNo.getLoading().equals("N")){
//                                    wrkEnable = true;
//                                    continue;
//                                }
//                                if (!devNo.getOutEnable().equals("Y")){
//                                    wrkEnable = true;
//                                    continue;
//                                }
//                            }
//                        }
                        List<Integer> staNos = Arrays.asList(1042, 1105, 1038, 1036, 2037);//入库口
                        if (!staNos.contains(wrkMastSta.getStaStart())) {
                            continue;
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
                        wrkEnable = true;
                        if (sign){
@@ -2960,12 +2950,13 @@
                                log.error("更新小车任务失败");
                            }
                            rgvThread.setPakMk(false);
                            rgvThread.setPakOut(false);
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2526");
                            if (signMap){
                                return wrkEnable;
//                                break;
                            }else {
                                log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                                log.error("货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                                Thread.sleep(500);
                            }
                        } else {
@@ -2976,15 +2967,132 @@
                    }
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用  出库取货
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && !rgvProtocol.isLoaded2ing()
                        && rgvProtocol.getTaskNo2() == 0
                        && rgvThread.isPakMk()
                        && rgvThread.isPakOut()
                ){
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                    }
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                    for (WrkMastSta wrkMastSta : wrkMastStaList){
                        List<Integer> staNos = Arrays.asList(1042, 1105, 1038, 1036, 2037);//入库口
                        if (staNos.contains(wrkMastSta.getStaStart())) {
                            continue;
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
                        wrkEnable = true;
                        if (sign){
                            wrkMastSta.setWrkSts(1);
                            try{
                                wrkMastStaMapper.updateById(wrkMastSta);
                                log.error("更新小车任务成功");
                            }catch (Exception e){
                                log.error("更新小车任务失败");
                            }
                            rgvThread.setPakMk(false);
                            rgvThread.setPakOut(false);
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2526");
                            if (signMap){
                                return wrkEnable;
//                                break;
                            }else {
                                log.error("货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                                Thread.sleep(500);
                            }
                        } else {
                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                            Thread.sleep(500);
                        }
                        break;
                    }

                }

            }
//            if (!wrkEnable){
//                rgvRunWrkMastEmptyStaAvoidance();
//            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
            log.error("执行小车搬运任务下发失败");
        }
        return wrkEnable;
    }
    /**
     * 小车预调度
     */
    public synchronized  void rgvPreScheduling(){
        try{
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！4", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用  才进行预调度
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && !rgvProtocol.isLoaded1ing()
                        && rgvProtocol.getTaskNo1() == 0
                        && !rgvProtocol.isLoaded2ing()
                        && rgvProtocol.getTaskNo2() == 0
                        && rgvThread.isPakMk()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                    }
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    // 根据输送线plc遍历
                    for (DevpSlave devp : slaveProperties.getDevp()) {
                        // 遍历入库口  入库预调度
                        List<Integer> staNos = Arrays.asList(1042, 1043, 1105, 1104);
                        for (Integer staNo : staNos) {
                            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                            StaProtocol staProtocol = devpThread.getStation().get(staNo);
                            if(staProtocol.isLoading()){
                                RgvCommand rgvCommand = new RgvCommand();
                                rgvCommand.setRgvNo((int) rgvProtocol.getRgvNo()); // RGV编号
                                rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                                rgvCommand.setTaskNo1(9999); // 工位1工作号
                                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  取放货
                                rgvCommand.setEndStaNo1(0);   //工位1 放货后要去的位置
                                if(staNo == 1042 || staNo ==1043){
                                    rgvCommand.setTargetPosition1(1042);   //工位1目标站点
                                }else{
                                    rgvCommand.setTargetPosition1(1105);   //工位1目标站点
                                }
                                rgvCommand.setCommand(true);   //工位1任务确认
                                if (!MessageQueue.offer(SlaveType.Rgv, (int) rgvProtocol.getRgvNo(), new Task(4, rgvCommand))) {
                                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", (int) rgvProtocol.getRgvNo(), JSON.toJSON(rgvCommand));
                                }
                            }
                        }

                    }

                }
            }
        }catch (Exception e){
            log.error("执行小车移动下发失败");
        }
    }
    /**
     * 执行小车搬运任务
@@ -3118,107 +3226,107 @@
    /*
     * 有任务但未执行  此时需要调整小车位置
     * */
    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
        try{
            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
            if (integer==0){
                return;
            }
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！1", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvThread.isPakMk()
//                        && rgvProtocol.getTaskNo2()==0
                ){
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
                        continue;
                    }
//                    if (rgvProtocol.getRgvNo()==1 && rgvProtocol.getRgvPosI().equals(100)){
//                        continue;
//                    } else if (rgvProtocol.getRgvNo()==2 && rgvProtocol.getRgvPosI().equals(157)  ){
//    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
//        try{
//            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
//            if (integer==0){
//                return;
//            }
//            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
//            for (BasRgvMap rgvSlave:basRgvMaps) {
//                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
//                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
//                if (rgvProtocol == null) {
//                    continue;
//                }else {
//                    rgvProtocol = rgvProtocol.clone();
//                }
//                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
//                if (basRgv == null) {
//                    log.error("{}号RGV尚未在数据库进行维护！1", rgvSlave.getRgvNo());
//                    continue;
//                }
//
//                // 只有当RGV空闲、自动,工位一无物//rgv可用
//                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
//                        && rgvProtocol.getModeType() == RgvModeType.AUTO
//                        && !rgvProtocol.isLoaded1ing()  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
//                        && rgvProtocol.getTaskNo1()==0
//                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
//                        && rgvThread.isPakMk()
////                        && rgvProtocol.getTaskNo2()==0
//                ){
//                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
//                        continue;
//                    }
                    rgvAvoidanceXY(rgvProtocol.getRgvNo());
                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2727");
                }
            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }
////                    if (rgvProtocol.getRgvNo()==1 && rgvProtocol.getRgvPosI().equals(100)){
////                        continue;
////                    } else if (rgvProtocol.getRgvNo()==2 && rgvProtocol.getRgvPosI().equals(157)  ){
////                        continue;
////                    }
//                    rgvAvoidanceXY((int) rgvProtocol.getRgvNo());
//                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2727");
//                }
//            }
//        }catch (Exception e){
//            log.error("4109行执行小车初始化任务下发失败");
//            log.error("4109行"+e);
//        }
//    }

    /*
     * 小车XY移动  避让
     * */
    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
        BasRgvMap basRgvMap = basRgvMapService.selectByRgvNo(rgvId);
        if (basRgvMap.getStartRoute() == 100 || basRgvMap.getStartRoute() == 101){
            try{

                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1(basRgvMap.getStartRoute().shortValue());
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                }
            }catch (Exception e){
                return false;

            }
        }else {
            try{
                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1(basRgvMap.getStartRoute().shortValue());
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                }
            }catch (Exception e){
                return false;

            }
        }
    }
//    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
//        BasRgvMap basRgvMap = basRgvMapService.selectByRgvNo(rgvId);
//        if (basRgvMap.getStartRoute() == 100 || basRgvMap.getStartRoute() == 101){
//            try{
//
//                //  命令下发区 --------------------------------------------------------------------------
//                RgvCommand rgvCommand = new RgvCommand();
//                rgvCommand.setRgvNo(rgvId); // RGV编号
//                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
//                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
//                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
//                //basRgvMap.getLockStartRoute().shortValue()
//                rgvCommand.setSourceStaNo1(basRgvMap.getStartRoute().shortValue());
//                rgvCommand.setCommand((short) 1);   //工位1任务确认
//                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
//                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
//                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
//                    return false;
//                } else {
//                    return true;
//                }
//            }catch (Exception e){
//                return false;
//
//            }
//        }else {
//            try{
//                //  命令下发区 --------------------------------------------------------------------------
//                RgvCommand rgvCommand = new RgvCommand();
//                rgvCommand.setRgvNo(rgvId); // RGV编号
//                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
//                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
//                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
//                //basRgvMap.getLockStartRoute().shortValue()
//                rgvCommand.setSourceStaNo1(basRgvMap.getStartRoute().shortValue());
//                rgvCommand.setCommand((short) 1);   //工位1任务确认
//                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
//                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
//                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
//                    return false;
//                } else {
//                    return true;
//                }
//            }catch (Exception e){
//                return false;
//
//            }
//        }
//    }


    /*
@@ -3229,39 +3337,80 @@
            int startSta = wrkMastSta.getStaStart();
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            boolean pakIn1 = true;
            boolean pakIn2 = true;
            rgvCommand.setRgvNo(rgvId); // RGV编号
            if((startSta >= 1001 && startSta <= 1035) || (startSta >= 2001 && startSta <= 2030)){//出库RGV取货
                rgvCommand.setAckFinish2((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
                rgvCommand.setTaskMode2(RgvTaskModeType.FETCH_PUT); // 工位2任务模式:  取放货
                rgvCommand.setSourceStaNo2(wrkMastSta.getStaStart().shortValue());   //工位2起点
                rgvCommand.setDestinationStaNo2(wrkMastSta.getStaEnd().shortValue());   //工位2目标站点
                rgvCommand.setCommand((short) 2);   //工位1任务确认
            }else{  //入库RGV取货
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
                rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
                rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
                rgvCommand.setCommand((short) 1);   //工位1任务确认
            }
            if(rgvCommand.getCommand() == 1){
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
            if(wrkMastSta.getWrkSts() == 1){//取货
                if((startSta >= 1001 && startSta <= 1035) || (startSta >= 2001 && startSta <= 2030)){//出库RGV取货
                    rgvCommand.setAckFinish2(false);  // 工位2任务完成确认位
                    rgvCommand.setTaskNo2(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位2工作号
                    rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式:  取放货
                    rgvCommand.setEndStaNo2(wrkMastSta.getWrkEnd());   //工位2 放货后要去的位置
                    rgvCommand.setTargetPosition2(wrkMastSta.getStaStart());   //工位2目标站点
                    rgvCommand.setCommand(true);   //工位1任务确认
                    pakIn1 = false;
                }else{  //入库RGV取货
                    rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                    rgvCommand.setTaskNo1(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位1工作号
                    rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取放货
                    rgvCommand.setEndStaNo1(wrkMastSta.getWrkEnd());   //工位1 放货后要去的位置
                    rgvCommand.setTargetPosition1(wrkMastSta.getStaStart());   //工位1目标站点
                    rgvCommand.setCommand(true);   //工位1任务确认
                }
            }else{
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(5, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                if(!pakIn1){
                    if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                        //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                        return false;
                    } else {
                        return true;
                    }
                }else{
                    if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(5, rgvCommand))) {
                        //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                        return false;
                    } else {
                        return true;
                    }
                }
            }
            if(wrkMastSta.getWrkSts() == 2) {//放货
                if((startSta >= 1001 && startSta <= 1035) || (startSta >= 2001 && startSta <= 2030)){//出库RGV取货
                    rgvCommand.setAckFinish2(false);  // 工位2任务完成确认位
                    rgvCommand.setTaskNo2(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位2工作号
                    rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式:  取放货
                    rgvCommand.setEndStaNo2(wrkMastSta.getWrkEnd());   //工位2 放货后要去的位置
                    rgvCommand.setTargetPosition2(wrkMastSta.getStaEnd());   //工位2目标站点
                    rgvCommand.setCommand(true);   //工位1任务确认
                    pakIn2 = false;
                }else{  //入库RGV取货
                    rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                    rgvCommand.setTaskNo1(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位1工作号
                    rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  取放货
                    rgvCommand.setEndStaNo1(wrkMastSta.getWrkEnd());   //工位1 放货后要去的位置
                    rgvCommand.setTargetPosition1(wrkMastSta.getStaEnd());   //工位1目标站点
                    rgvCommand.setCommand(true);   //工位1任务确认
                }
                if(!pakIn2){
                    if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                        //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                        return false;
                    } else {
                        return true;
                    }
                }else{
                    if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(5, rgvCommand))) {
                        //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                        return false;
                    } else {
                        return true;
                    }
                }
            }
            return true;
        }catch (Exception e){
            return false;
        }