*

lsh

6 天以前 f287ab5ee6b9938e0d48cdb62c05078bdec463d8

*

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

@@ -13,7 +13,6 @@
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.RouteUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
@@ -24,16 +23,12 @@
import com.zy.core.enums.*;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.RgvSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.command.RgvCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.RgvProtocol;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.RgvThread;
import com.zy.core.thread.SiemensDevpThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -74,31 +69,21 @@
    private TaskWrkService taskWrkService;
    @Autowired
    private StaDescMapper staDescMapper;

    @Autowired
    private StaDescService staDescService;

    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private BasRgvService basRgvService;
    @Autowired
    private WrkMastStaMapper wrkMastStaMapper;
    @Autowired
    private BasRgvMapMapper basRgvMapMapper;
    private CrnController crnController;

    @Value("${wms.url}")
    private String wmsUrl;
    @Value("${wms.inboundTaskApplyPath}")
    private String inboundTaskApplyPath;
    @Value("${wms.movePath}")
    private String movePath;
    @Value("${wms.taskStatusFeedbackPath}")
    private String taskStatusFeedbackPath;
    @Autowired
    private CrnController crnController;

    @Value("${wms.rgvOpen}")
    private boolean rgvOpen;
@@ -112,10 +97,8 @@
    @Value("${constant-parameters.trackProportion}")
    private Long trackProportion;

    public void generateStoreWrkFile() throws IOException, InterruptedException {
    public void generateStoreWrkFile() {
        try {


            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历入库口
@@ -387,7 +370,6 @@
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }


    /**
     * 堆垛机站出库到出库站
@@ -1117,1092 +1099,8 @@
            if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
                taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
            }

//        } else if (param.getIoType() == 2) {
//            taskWrk.setWrkSts(11);
//            if (!Cools.isEmpty(param.getStartPoint())) {
//                taskWrk.setStartPoint(Utils.getWcsLocNo(param.getStartPoint()));//起点
//                taskWrk.setOriginStartPoint(param.getStartPoint());
//            }
//            taskWrk.setTargetPoint(param.getTargetPoint());
//        }else if (param.getIoType() == 3){
//            taskWrk.setWrkSts(11);
//            if (!Cools.isEmpty(param.getStartPoint())) {
//                taskWrk.setStartPoint(param.getStartPoint());//起点
//                taskWrk.setOriginStartPoint(param.getStartPoint());
//            }
        }
        return taskWrk;
    }
    /**
     *  完成小车任务
     */
    public synchronized void rgvCompleteWrkMastSta() {
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV等待WCS确认、自动
                if (rgvProtocol.getStatusType() == RgvStatusType.WORKING
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && ((rgvProtocol.getStatusType1()==RgvStatusType.WAITING || rgvProtocol.getStatusType2()==RgvStatusType.WAITING ) ||
                        (rgvProtocol.getStatusType1()==RgvStatusType.FETCHWAITING || rgvProtocol.getStatusType2()==RgvStatusType.FETCHWAITING ))
                ) {
                    log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
                    if (rgvProtocol.getTaskNo1()!=0 && (rgvProtocol.getStatusType1()==RgvStatusType.WAITING || rgvProtocol.getStatusType1()==RgvStatusType.FETCHWAITING)){
                        if (rgvProtocol.getTaskNo1()==(short)32222){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().longValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getType()!=1 || wrkMastSta.getWrkSts()!=1){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }
                       /* WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast) && wrkMastSta.getWrkType()!=5){
                            Thread.sleep(200);
                            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                            StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                            if (staProtocol == null) {
                                continue;
                            } else {
                                staProtocol = staProtocol.clone();
                            }
                            if (!staProtocol.isAutoing() || !staProtocol.isLoading()){
                                continue;
                            }
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol))) {
                                continue;
                            }
                            log.error("小车任务完成下发输送线任务："+staProtocol);
//                            try{
//                                Thread.sleep(1000);
//                                DevpThread devpThreadEnd = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
//                                StaProtocol staProtocolEnd = devpThreadEnd.getStation().get(wrkMastSta.getStaEnd());
//                                log.error("小车任务完成读取输送线任务："+staProtocolEnd);
//                                if (staProtocolEnd.getWorkNo()==0 ){ //|| !staProtocolEnd.getWorkNo().equals(wrkMast.getWrkNo())
//                                    staProtocolEnd.setWorkNo(wrkMast.getWrkNo());
//                                    staProtocolEnd.setStaNo(wrkMast.getStaNo());
//                                    if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocolEnd))) {
//                                        continue;
//                                    }
//                                    log.error("小车任务完成下发输送线任务第二次："+staProtocolEnd);
//                                }
//                            }catch (Exception e){
//
//                            }
                        }*/
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                    }else if (rgvProtocol.getTaskNo2()!=0 && (rgvProtocol.getStatusType2()==RgvStatusType.WAITING || rgvProtocol.getStatusType2()==RgvStatusType.FETCHWAITING)){
                        if (rgvProtocol.getTaskNo2()==(short)32222){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo2().longValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getType()!=2){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }
                        /*WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)  && wrkMastSta.getWrkType()!=5){
                            Thread.sleep(200);
                            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                            StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                            if (!staProtocol.isAutoing() || !staProtocol.isLoading()){
                                continue;
                            }
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol))) {
                                continue;
                            }
                            log.error("小车任务完成下发输送线任务："+staProtocol);
//                            try{
//                                Thread.sleep(1000);
//                                DevpThread devpThreadEnd = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
//                                StaProtocol staProtocolEnd = devpThreadEnd.getStation().get(wrkMastSta.getStaEnd());
//                                log.error("小车任务完成读取输送线任务："+staProtocolEnd);
//                                if (staProtocolEnd.getWorkNo()==0 ){ //|| !staProtocolEnd.getWorkNo().equals(wrkMast.getWrkNo())
//                                    staProtocolEnd.setWorkNo(wrkMast.getWrkNo());
//                                    staProtocolEnd.setStaNo(wrkMast.getStaNo());
//                                    if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocolEnd))) {
//                                        continue;
//                                    }
//                                    log.error("小车任务完成下发输送线任务第二次："+staProtocolEnd);
//                                }
//                            }catch (Exception e){
//
//                            }
                        }*/
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                    }else {
                        log.error("小车复位失败，小车号{},等待wcs确认但是没有工作号！",rgvProtocol.getRgvNo());
                    }
                }
            }
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }
    /**
     * 入出库  ===>>  小车作业下发
     */
    public synchronized boolean rgvIoExecute(Integer sign) {
        boolean rgvIoExecuteSign = false;
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                // 获取小车信息
                boolean signWork = false;
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                ) {
                    switch (sign){
                        //执行小车货物搬运任务
                        case 1:
                            signWork = rgvRunWrkMastFullSta(rgvSlave);
                            break;
                        //执行小车空板搬运任务
                        case 2://放//拆盘
                            signWork = rgvRunWrkMastEmptyStaPut(rgvSlave);
                            break;
                        case 3://满放
                            signWork = rgvRunWrkMastEmptyStaPutFull(rgvSlave);
                            break;
                        case 4://取叠盘
                            signWork = rgvRunWrkMastEmptyStaTake(rgvSlave);
                            break;
                        case 6:////提升
//                            signWork = qwe();
                            break;
                        default:
                            break;
                    }
                    for (int signCount = 1;!signWork && signCount<7;signCount++){
                        switch (signCount){
                            case 1://执行小车货物搬运任务
                                signWork = rgvRunWrkMastFullSta(rgvSlave);
                                break;
                            case 2://放//拆盘
                                signWork = rgvRunWrkMastEmptyStaPut(rgvSlave);
                                break;
                            case 3://满放
                                signWork = rgvRunWrkMastEmptyStaPutFull(rgvSlave);
                                break;
                            case 4://取叠盘
                                signWork = rgvRunWrkMastEmptyStaTake(rgvSlave);
                                break;
                            case 6:////提升
//                            signWork = rgvRunWrkMastEmptyStaPut();
                                break;
                            default:
                                break;
                        }
                    }
                }else {
                    continue;
                }
                if (!rgvIoExecuteSign){
                    rgvIoExecuteSign = signWork;
                }
            }
//            if (!rgvIoExecuteSign){
//                if (sign>6){
//
//                }
//            }
        }catch (Exception e){
            log.error("RGV小车任务下发报错"+e);
        }
        return rgvIoExecuteSign;
    }

    /**
     * 执行小车搬运任务
     */
    public synchronized boolean rgvRunWrkMastFullSta(RgvSlave rgvSlave) {
        try{
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                return false;
            }
            BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                return false;
            }

            // 只有当RGV空闲、自动,工位一无物//rgv可用
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getLoaded1()==0
                    && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
            ) {
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(basRgv.getRgvNo());
                if (basRgvMap == null) {
                    log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                    return false;
                }
                List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                for (WrkMastSta wrkMastSta : wrkMastStaList){
                    if (wrkMastSta.getType()!=1 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                        continue;
                    }
                    BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                    if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y") || basDevp.getWrkNo()!=0){
                        continue;
                    }
                    Date date = new Date();

                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, rgvSlave.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
                    if (staProtocol == null) {
                        log.info(date+"取放任务下发：未查询到站点信息："+wrkMastSta);
                        continue;
                    }
                    if (!staProtocol.isAutoing() || staProtocol.isLoading() || staProtocol.getWorkNo() != 0){
                        continue;
                    }
                    if (basDevp.getDevNo()>117 && basDevp.getDevNo()<124){
                        if (staProtocol.isLoadingSuper()){
                            continue;
                        }
                    }
                    if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                        if (!staProtocol.isEmptyMk()){
                            continue;
                        }
                    }
                    BasDevp basDevpS = basDevpService.selectById(wrkMastSta.getStaStart());
                    if (!basDevpS.getAutoing().equals("Y") || !basDevpS.getLoading().equals("Y") || basDevpS.getWrkNo()!=wrkMastSta.getWrkNo().intValue()){
                        continue;
                    }
                    StaProtocol staProtocols = devpThread.getStation().get(basDevpS.getDevNo());
                    if (staProtocols == null) {
                        log.info(date+"取放任务下发：未查询到站点信息："+wrkMastSta);
                        continue;
                    }
                    if (!staProtocols.isAutoing() || !staProtocols.isLoading() || staProtocols.getWorkNo() != wrkMastSta.getWrkNo().intValue()){
                        continue;
                    }


                    log.info(date+"取放任务下发：小车工作档："+wrkMastSta);
                    log.info(date+"取放任务下发：目标站状态："+basDevp);
                    boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta);
                    if (sign){
                        boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd());
                        if (signMap){
                            wrkMastSta.setWrkSts(1);
                            try{
                                wrkMastStaMapper.updateById(wrkMastSta);
                            }catch (Exception e){
                                log.error("更新小车任务失败");
                            }
                            return true;
                        }else {
                            log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                        }
                    }else {
                        log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                    }
                    break;
                }
            }
//            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
        }
        return false;
    }
    /**
     * 执行小车搬运任务//拆盘
     */
    public synchronized boolean rgvRunWrkMastEmptyStaPut(RgvSlave rgvSlave) {//拆盘
        try{
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                return false;
            }
            BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                return false;
            }

            // 只有当RGV空闲、自动,工位二有物//rgv可用//拆盘
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                    && (rgvProtocol.getLoaded2()==3  || rgvProtocol.getLoaded2()==1 || rgvProtocol.getLoaded2()==4)////0 无物；1 一层无物二层有物 （只能拆叠） ；2一层有物二层无物() ；3  1、2层都有物  4：（）只允许拆盘
            ) {
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                if (basRgvMap == null) {
                    log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                    return false;
                }
                basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
                List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);//查询可执行任务
                for (WrkMastSta wrkMastSta : wrkMastStaList){
                    if (wrkMastSta.getType()!=2 || wrkMastSta.getWrkType()!=2){// 2:空板  || 工作类型  1:取（叠盘）  2：拆盘  5：满取  6：满放
                        continue;
                    }
                    boolean sign = false;
                    if ( wrkMastSta.getStaEnd()!=0){//放
                        BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                        if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y") || basDevp.getWrkNo()!=0){
                            continue;
                        }
                        Date date = new Date();

                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, rgvSlave.getDevpPlcId());
                        StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
                        if (staProtocol == null) {
                            log.info(date+"拆盘任务下发：未查询到站点信息："+wrkMastSta);
                            continue;
                        }
                        if (!staProtocol.isAutoing() || staProtocol.isLoading() || staProtocol.getWorkNo() != 0){
                            continue;
                        }
                        if (basDevp.getDevNo()>117 && basDevp.getDevNo()<124){
                            if (staProtocol.isLoadingSuper()){
                                continue;
                            }
                        }
                        if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                            if (!staProtocol.isEmptyMk()){
                                continue;
                            }
                        }

                        log.info(date+"拆盘任务下发：小车工作档："+wrkMastSta);
                        log.info(date+"拆盘任务下发：目标站状态："+basDevp);
                        sign = rgvPutEmpty(rgvProtocol.getRgvNo(),wrkMastSta);//拆盘
                    }else {
                        continue;
                    }
                    if (sign){
                        boolean signMap = rgvMapUpdate(basRgvMap, basRgvMap.getStartRoute(), wrkMastSta.getStaEnd());
                        if (signMap){
                            wrkMastSta.setWrkSts(2);
                            try{
                                wrkMastStaMapper.updateById(wrkMastSta);
                            }catch (Exception e){
                                log.error("更新小车任务失败");
                            }
                            return true;
                        }else {
                            log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                        }
                    }else {
                        log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                    }
                    break;
                }
            }
//            }
        }catch (Exception e){
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
        }
        return false;
    }

    /**
     * 执行小车搬运任务
     */
    public synchronized boolean rgvRunWrkMastEmptyStaPutFull(RgvSlave rgvSlave) {//满放
        try{
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                return false;
            }
            BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                return false;
            }

            // 只有当RGV空闲、自动,工位二有物//rgv可用
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                    &&  (rgvProtocol.getLoaded2()==2  || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
            ) {
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                if (basRgvMap == null) {
                    log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                    return false;
                }
                basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
                List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);//查询可执行任务
                for (WrkMastSta wrkMastSta : wrkMastStaList){
                    if (wrkMastSta.getType()!=2 || wrkMastSta.getWrkType()!=6){// 2:空板  || 工作类型  1:取（叠盘）  2：拆盘  5：满取  6：满放  7:提升
                        continue;
                    }
                    boolean sign = false;
                    if ( wrkMastSta.getStaEnd()!=0){//满放
                        BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                        if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y") || basDevp.getWrkNo()!=0){
                            continue;
                        }
                        Date date = new Date();

                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, rgvSlave.getDevpPlcId());
                        StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
                        if (staProtocol == null) {
                            log.info(date+"满放任务下发：未查询到站点信息："+wrkMastSta);
                            continue;
                        }
                        if (!staProtocol.isAutoing() || staProtocol.isLoading() || staProtocol.getWorkNo() != 0){
                            continue;
                        }
                        if (basDevp.getDevNo()>117 && basDevp.getDevNo()<124){
                            if (staProtocol.isLoadingSuper()){
                                continue;
                            }
                        }
                        if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                            if (!staProtocol.isEmptyMk()){
                                continue;
                            }
                        }

                        log.info(date+"满放任务下发：小车工作档："+wrkMastSta);
                        log.info(date+"满放任务下发：目标站状态："+basDevp);
                        sign = rgvPutEmptyFull(rgvProtocol.getRgvNo(),wrkMastSta);
                    }else {
                        continue;
                    }
                    if (sign){
                        boolean signMap = rgvMapUpdate(basRgvMap, basRgvMap.getStartRoute(), wrkMastSta.getStaEnd());
                        if (signMap){
                            wrkMastSta.setWrkSts(2);
                            try{
                                wrkMastStaMapper.updateById(wrkMastSta);
                            }catch (Exception e){
                                log.error("更新小车任务失败");
                            }
                            return true;
                        }else {
                            log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                        }
                    }else {
                        log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                    }
                    break;
                }
            }
//            }
        }catch (Exception e){
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
        }
        return false;
    }

    public synchronized boolean rgvRunWrkMastEmptyStaTake(RgvSlave rgvSlave) {//叠盘
        try{
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                return false;
            }
            BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                return false;
            }

            // 只有当RGV空闲、自动,工位二无物//rgv可用
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                    && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                    &&  (rgvProtocol.getLoaded2()==0  || rgvProtocol.getLoaded2()==1 ) //现场修改：叠盘机，////0 无物；1 一层无物二层有物（只能拆叠）   ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
            ) {
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                if (basRgvMap == null) {
                    log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                    return false;
                }
                List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                for (WrkMastSta wrkMastSta : wrkMastStaList){
                    if (wrkMastSta.getType()!=2 || wrkMastSta.getWrkType()!=1){// 2:空板  || 工作类型  1:取（叠盘）  2：拆盘  5：满取  6：满放
                        continue;
                    }
                    boolean sign = false;
                    if ( wrkMastSta.getStaStart()!=0){//取
                        BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaStart());
                        if (!basDevp.getAutoing().equals("Y") || !basDevp.getLoading().equals("Y")){
                            continue;
                        }
                        Date date = new Date();

                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, rgvSlave.getDevpPlcId());
                        StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
                        if (staProtocol == null) {
                            log.info(date+"叠盘任务下发：未查询到站点信息："+wrkMastSta);
                            continue;
                        }
                        if (!staProtocol.isAutoing() || !staProtocol.isLoading()){
                            continue;
                        }
                        if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                            if (!staProtocol.isEmptyMk()){
                                continue;
                            }
                        }

                        log.info(date+"叠盘任务下发：小车工作档："+wrkMastSta);
                        log.info(date+"叠盘任务下发：目标站状态："+basDevp);
                        sign = rgvTakeEmpty(rgvProtocol.getRgvNo(),wrkMastSta);//叠盘
                    }else {
                        continue;
                    }
                    if (sign){
                        boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), basRgvMap.getStartRoute());
                        if (signMap){
                            wrkMastSta.setWrkSts(1);
                            try{
                                wrkMastStaMapper.updateById(wrkMastSta);
                            }catch (Exception e){
                                log.error("更新小车任务失败");
                            }
                            return true;
                        }else {
                            log.error("3879行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                        }
                    }else {
                        log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                    }
                    break;
                }
            }
//            }
        }catch (Exception e){
            log.error("3989行执行小车取空板任务下发失败");
            log.error("3989行"+e);
        }
        return false;
    }

    /*
     * 有任务但未执行  此时需要调整小车位置
     * */
    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
        try{
//            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
//            if (integer==0){
//                return;
//            }
            WrkMastSta wrkMastSta = wrkMastStaMapper.selectAllWrkStsCountWrkMastSta(null, 0);
            if (Cools.isEmpty(wrkMastSta)){
                return;
            }
            boolean signRgv = true;
            boolean signRgv1 = true;
            boolean signRgv2 = true;
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getTaskNo2()==0
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                ) {
                    if (rgvProtocol.getRgvNo()!=1){
                        if (!rgvProtocol.getRgvPosI().equals(120) && !rgvProtocol.getRgvPosI().equals(110)){
                            continue;
                        }
                        rgvAvoidanceXY(rgvProtocol.getRgvNo());
//                        return;
                        continue;
                    }
                    if (!rgvProtocol.getRgvPosI().equals(110) && !rgvProtocol.getRgvPosI().equals(108) &&  !rgvProtocol.getRgvPosI().equals(119)){
                        continue;
                    }
                    Integer count108Y = wrkMastStaMapper.selectAllWrkCount108Y();
                    if (count108Y!=0){
                        continue;
                    }
//                    Integer count108 = wrkMastStaMapper.selectAllWrkCount108();
//                    if (count108!=0){
//                        continue;
//                    }
                    rgvAvoidanceXY(rgvProtocol.getRgvNo());
                    continue;
//                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//                    Integer fallMerge = RouteUtils.RouteIndexFarMas(basRgvMap.getRgvNo(), basRgvMap.getEndRoute()); //获取合并干涉项
//                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(),fallMerge);
//                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route ,route);
//                    if (!wrkMastStaList.isEmpty()){
//                        log.info("小车存在可执行任务，跳过避让！！4214");
//                        return;
//                    }
//                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
////                    if (!RouteUtils.RgvRunStaSign(rgvProtocol.getRgvPosI(),RouteUtils.RouteIndexFarMas(rgvProtocol.getRgvNo(),rgvRunSta[rgvProtocol.getRgvNo()-1]),rgvProtocol.getRgvNo())){
////                    if (!RouteUtils.RgvRunStaSign(rgvProtocol.getRgvPosI(),rgvRunSta[rgvProtocol.getRgvNo()-1],rgvProtocol.getRgvNo())){
//                        if (rgvProtocol.getRgvNo()==1){
//                            signRgv1 = false;
//                        }else {
//                            signRgv2 = false;
//                        }
//                    }
//                    if (rgvProtocol.getRgvNo()==1 && (rgvProtocol.getRgvPosI().equals(101) || rgvProtocol.getRgvPosI().equals(102) )){
//                        signRgv1 = false;
//                        continue;
//                    } else if (rgvProtocol.getRgvNo()==2 && (rgvProtocol.getRgvPosI().equals(116) || rgvProtocol.getRgvPosI().equals(117) ) ){
//                        signRgv2 = false;
//                        continue;
//                    }
                }else {
                    signRgv = false;
                    break;
                }
            }
//            if (signRgv &&  (signRgv1 || signRgv2)){
//                for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
//                    RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
//                    RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
//                    if (rgvProtocol == null) {
//                        continue;
//                    }
//
//                    // 只有当RGV空闲、自动,工位一无物//rgv可用
//                    if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
//                            && rgvProtocol.getModeType() == RgvModeType.AUTO
//                            && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
//                            && rgvProtocol.getTaskNo1()==0
//                            && rgvProtocol.getTaskNo2()==0
//                            && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
//                            && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
//                    ) {
//                        if (rgvProtocol.getRgvNo()==1 && (rgvProtocol.getRgvPosI().equals(101) || rgvProtocol.getRgvPosI().equals(102) )){
//                            continue;
//                        } else if (rgvProtocol.getRgvNo()==2 && (rgvProtocol.getRgvPosI().equals(116) || rgvProtocol.getRgvPosI().equals(117) ) ){
//                            continue;
//                        }
//                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//                        rgvAvoidanceXY(rgvProtocol.getRgvNo());
//                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
//
//                    }
//                }
//            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }

    /*
     * 刷新地图数据
     * */
    public synchronized void refreshRgvMap() {
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getTaskNo2()==0
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvSlave.getId());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                }
            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }

    /*
     * 小车XY移动  避让
     * */
    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
        if (rgvId==1){
            try{
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvId);
                //  命令下发区 --------------------------------------------------------------------------
                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( (short)104);
                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{
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvId);
                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
                rgvCommand.setTaskNo2((short)32222); // 工位2工作号
                rgvCommand.setTaskMode2(RgvTaskModeType.X_MOVE); // 工位2任务模式:  回原点
                rgvCommand.setSourceStaNo2((short)114);
                rgvCommand.setCommand((short) 2);   //工位2任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(5, 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 rgvTakeFullAll(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // 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 (!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;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车取货至工位任务
     * */
    public synchronized boolean rgvTakeFull(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
            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写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车放货至输送线任务
     * */
    public synchronized boolean rgvPutFull(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
            rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
            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写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车取空板至工位任务  叠盘
     * */
    public synchronized boolean rgvTakeEmpty(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
            rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式:  取货
            rgvCommand.setSourceStaNo2(wrkMastSta.getStaStart().shortValue());   //工位2起点
            rgvCommand.setCommand((short) 2);   //工位2任务确认
            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;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车放空板至输送线任务   //拆盘
     * */
    public synchronized boolean rgvPutEmpty(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
            rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式:  放货
            rgvCommand.setDestinationStaNo2(wrkMastSta.getStaEnd().shortValue());   //工位2目标站点
            rgvCommand.setCommand((short) 2);   //工位2任务确认
            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;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车取空板至工位任务  满取
     * */
    public synchronized boolean rgvTakeEmptyFull(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
            rgvCommand.setTaskMode2(RgvTaskModeType.FETCH_5); // 工位2任务模式:  满取
            rgvCommand.setSourceStaNo2(wrkMastSta.getStaStart().shortValue());   //工位2起点
            rgvCommand.setCommand((short) 2);   //工位2任务确认
            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;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车放空板至输送线任务   //满放
     * */
    public synchronized boolean rgvPutEmptyFull(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
            rgvCommand.setTaskMode2(RgvTaskModeType.PUT_6); // 工位2任务模式:  满放
            rgvCommand.setDestinationStaNo2(wrkMastSta.getStaEnd().shortValue());   //工位2目标站点
            rgvCommand.setCommand((short) 2);   //工位2任务确认
            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;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车复位
     * */
    public synchronized boolean rgvComplete(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(3, new RgvCommand()))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}",rgvId);
                return false;
            } else {
                log.info("RGV命令下发成功，RGV号={}",rgvId);
                return true;
            }
        }catch (Exception e){
            log.error("RGV命令下发失败，RGV号={}。异常："+e,rgvId);
            return false;
        }
    }

    /*
     * 小车地图更新  更新锁
     * */
    public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd){
        if (rgvOpen){
            return true;
        }

//        List<Integer> integers = RouteUtils.RouteMapCurrentFar(basRgvMapCurrent.getNowRoute(),staStart,staEnd, basRgvMapCurrent.getLockStartRoute());
        //更新当前小车锁
        try{
            Integer farCurrentStaNo = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getNowRoute(), staStart, staEnd, basRgvMapCurrent.getLockStartRoute());//获取最远站点
//            Integer farCurrentStaNo = RouteUtils.RouteIndexFarMas(staEnd, staStart, staEnd, basRgvMapCurrent.getLockStartRoute());//获取最远站点
            Integer fallMerge = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getRgvNo(), farCurrentStaNo); //获取合并干涉项
            basRgvMapCurrent.setLockEndRoute(fallMerge);
            basRgvMapMapper.updateById(basRgvMapCurrent);

            //更新另一台小车地图
            Integer rgvNoOther = basRgvMapCurrent.getRgvNoOther();
            BasRgvMap basRgvMapOther = basRgvMapMapper.selectById(rgvNoOther);
            List<Integer> integers = RouteUtils.RouteMapCurrentFar(fallMerge, basRgvMapCurrent.getLockStartRoute());
            Integer lockEndRoute = RouteUtils.RouteMapOtherFarStnNo(integers, basRgvMapCurrent.getLockStartRoute());//另一台小车可活动最远位置
            Integer lockEndRouteL = RouteUtils.RouteIndexFarMasL(rgvNoOther, lockEndRoute);//另一台小车可活动最远位置
            basRgvMapOther.setEndRoute(lockEndRouteL);
            basRgvMapMapper.updateById(basRgvMapOther);
            return true;
        }catch (Exception e){
            log.error("小车地图更新出错！");
            return false;
        }
    }

}

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

@@ -5,11 +5,9 @@
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;
import java.util.ArrayList;

/**
 * WCS主流程
@@ -24,9 +22,6 @@
    private MainServiceImpl mainService;
    // 所属线程
    private Thread thread;
    // 频率
    private int i = 0;
    private int k = 0;

    /**
     * =====>>  开始工作
@@ -44,8 +39,6 @@
                        continue;
                    }

                    // 演示
//                    mainService.crnDemoOfLocMove1();
                    // 入库  ===>> 入库站到堆垛机站，根据条码扫描生成入库工作档
                    mainService.generateStoreWrkFile(); // 组托
                    // 出库  ===>>  堆垛机出库站到出库站
@@ -57,28 +50,6 @@

                    // 堆垛机异常信息记录
                    mainService.recCrnErr();


                    i++;
                    k++;
                    if (i<7) {
                        // RGV  ===>>  小车任务作业下发
                        try{
                            boolean rgvIoExecuteSign = mainService.rgvIoExecute(i);
                            if (rgvIoExecuteSign){
                                k = 0;
                            } else if (k>7){
                                k = 0;
                                mainService.rgvRunWrkMastEmptyStaAvoidance();//避让
                            }
                        }catch (Exception e){
                            log.error("RGV  ===>>  小车任务作业下发异常"+e);
                        }
                    }else {
                        i = 0;
                    }
                    //完成小车任务
                    mainService.rgvCompleteWrkMastSta();

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

 src/main/java/com/zy/core/cache/RgvStatusCache.java

New file
@@ -0,0 +1,44 @@
package com.zy.core.cache;

import com.zy.core.model.protocol.RgvProtocol;

import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by IX on 2025/02/21
 */
public class RgvStatusCache {
    // 本地缓存，键为 currentPosition，值为 DeviceStatus
    private static final ConcurrentHashMap<Integer, RgvProtocol> cache = new ConcurrentHashMap<>();

    /**
     * 更新设备状态
     */
    public static void updateRgvStatus(RgvProtocol status) {
        try {
            cache.put(status.getRgvNo(), status);
        } finally {
        }
    }

    /**
     * 获取设备状态
     */
    public static RgvProtocol getRgvStatus(Integer RgvNo) {
        try {
            return cache.get(RgvNo);
        } finally {
        }
    }

    /**
     * 获取所有设备状态
     */
    public static ConcurrentHashMap<Integer, RgvProtocol> getAllRgvStatus() {
        try {
            return new ConcurrentHashMap<>(cache); // 返回副本
        } finally {
        }
    }

}

 src/main/java/com/zy/core/cache/TaskProtocolCache.java

New file
@@ -0,0 +1,120 @@
package com.zy.core.cache;

import com.zy.core.model.protocol.TaskProtocol;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by IX on 2025/02/21
 */
@Slf4j
public class TaskProtocolCache {
    // 本地缓存，键为 taskNo，值为 TaskProtocol
    private final ConcurrentHashMap<Long, TaskProtocol> cache = new ConcurrentHashMap<>();

    // 读写锁，确保线程安全
//    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    /**
     * 更新设备状态
     */
    public void updateTaskProtocol(TaskProtocol status) {
        cache.put(status.getTaskNo(), status);
    }

    /**
     * 删除任务缓存
     */
    public TaskProtocol removeTaskProtocol(String taskNo) {
//        lock.readLock().lock(); // 加读锁
        try {
            return cache.remove(taskNo);
        } finally {
//            lock.readLock().unlock(); // 释放读锁
        }
    }

    /**
     * 获取任务缓存
     */
    public TaskProtocol getTaskProtocol(String taskNo) {
//        lock.readLock().lock(); // 加读锁
        try {
            return cache.get(taskNo);
        } finally {
//            lock.readLock().unlock(); // 释放读锁
        }
    }

    /**
     * 获取所有任务
     */
    public ConcurrentHashMap<Long, TaskProtocol> getAllTaskProtocol() {
//        lock.readLock().lock(); // 加读锁
        try {
            return new ConcurrentHashMap<>(cache); // 返回副本
        } finally {
//            lock.readLock().unlock(); // 释放读锁
        }
    }

    /**
     * 获取所有取任务
     */
    public List<TaskProtocol> getAllTakeTaskProtocol() {
//        lock.readLock().lock(); // 加读锁
        try {
            List<TaskProtocol> allTakeTaskProtocol = new ArrayList<>();
            for (TaskProtocol task : cache.values()) {
                if (task.getTaskStatus()==1) {
                    allTakeTaskProtocol.add(task);
                }
            }
            return allTakeTaskProtocol; // 返回副本
        } finally {
//            lock.readLock().unlock(); // 释放读锁
        }
    }

    /**
     * 获取所有取任务
     */
    public List<TaskProtocol> getAllPutTaskProtocol() {
//        lock.readLock().lock(); // 加读锁
        try {
            List<TaskProtocol> allPutTaskProtocol = new ArrayList<>();
            for (TaskProtocol task : cache.values()) {
                if (task.getTaskStatus()==2) {
                    allPutTaskProtocol.add(task);
                }
            }
            return allPutTaskProtocol; // 返回副本
        } finally {
//            lock.readLock().unlock(); // 释放读锁
        }
    }

    /**
     * 获取所有取任务
     */
    public List<TaskProtocol> getAllWalkTaskProtocol() {
//        lock.readLock().lock(); // 加读锁
        try {
            List<TaskProtocol> allWalkTaskProtocol = new ArrayList<>();
            for (TaskProtocol task : cache.values()) {
                if (task.getTaskStatus()==0) {
                    allWalkTaskProtocol.add(task);
                }
            }
            return allWalkTaskProtocol; // 返回副本
        } finally {
//            lock.readLock().unlock(); // 释放读锁
        }
    }

}

 src/main/java/com/zy/core/enums/RgvModeType.java

@@ -7,7 +7,7 @@
    HAND(1, "手动"),
    HALF_AUTO(2, "半自动"),
    AUTO(3, "自动"),
    AUTO2(100, "其它"),
    OTHER(100, "其它"),
    ;

    public Integer id;
@@ -19,25 +19,25 @@

    public static RgvModeType get(Short id) {
        if (null == id) {
            return null;
            return OTHER;
        }
        for (RgvModeType type : RgvModeType.values()) {
            if (type.id.equals(id.intValue())) {
                return type;
            }
        }
        return null;
        return OTHER;
    }

    public static RgvModeType get(RgvModeType type) {
        if (null == type) {
            return null;
            return OTHER;
        }
        for (RgvModeType rgvModeType : RgvModeType.values()) {
            if (rgvModeType == type) {
                return rgvModeType;
            }
        }
        return null;
        return OTHER;
    }
}

 src/main/java/com/zy/core/enums/RgvStatusType.java

@@ -11,7 +11,7 @@
    WAITING(90, "任务完成等待WCS确认"),
    FETCHWAITING(91, "取货任务完成等待WCS确认"),
    SOS99(99, "报警99"),
    SOS100(100, "其它100")
    OTHER(100, "其它100")
    ;

    public Integer id;
@@ -23,25 +23,25 @@

    public static RgvStatusType get(Short id) {
        if (null == id) {
            return null;
            return OTHER;
        }
        for (RgvStatusType type : RgvStatusType.values()) {
            if (type.id.equals(id.intValue())) {
                return type;
            }
        }
        return NONE;
        return OTHER;
    }

    public static RgvStatusType get(RgvStatusType type) {
        if (null == type) {
            return null;
            return OTHER;
        }
        for (RgvStatusType rgvStatusType : RgvStatusType.values()) {
            if (rgvStatusType == type) {
                return rgvStatusType;
            }
        }
        return null;
        return OTHER;
    }
}

 src/main/java/com/zy/core/model/RgvSlave.java

@@ -22,22 +22,10 @@

    private Boolean demo;

    private Integer devpPlcId;
    private Integer otherId;

    // RGV入库源站点
    private List<RgvStn> rgvInSStn = new ArrayList<>();

    // RGV出库源站点
    private List<RgvStn> rgvOutSStn = new ArrayList<>();

    // RGV叠盘
    private List<RgvStn> rgvEmptyInSStn = new ArrayList<>();

    // RGV空板入库
    private List<RgvStn> rgvEmptyOutSStn = new ArrayList<>();

    // RGV出库目标站点
    private List<RgvStn> rgvDestStn = new ArrayList<>();

    @Data
    public static class RgvStn {

 src/main/java/com/zy/core/model/protocol/RgvProtocol.java

@@ -18,9 +18,9 @@
     * 2 = 自动模式
     * 3 = 电脑模式
     */
    public Short mode;
    public Short mode = -1;

    public RgvModeType modeType;
    public RgvModeType modeType = RgvModeType.NONE;

    /**
     * RGV当前状态
@@ -28,12 +28,12 @@
     * 1：作业中
     * 2：报警
     */
    public Short status;
    public Short status = -1;

    /**
     * 状态枚举
     */
    public RgvStatusType statusType;
    public RgvStatusType statusType = RgvStatusType.NONE;

    /**
     * 任务号
@@ -41,14 +41,14 @@
    public Short taskNo = 0;

    /**
     * 工位1有物
     * 有物
     */
    public Short loaded;//0 无物；1 有物

    /**
     * RGV当前位置
     */
    public Long RgvPos;
    public Long RgvPos = 0L;

    /**
     * 走行在定位
@@ -76,6 +76,21 @@
     * 累计走行时长h
     */
    public Float xDuration;

    /**
     * 是否避让
     */
    public Short Avoid;//0\1\2

    /**
     * 避让目的地
     */
    public Short AvoidingTheDestination;

    /**
     * 是否启用
     */
    public boolean statusEnable;//0\1\2

    public void setMode(Short mode) {
        this.mode = mode;
@@ -115,12 +130,6 @@

    public void setxDuration(Short xDuration) {
        this.xDuration = Float.valueOf(xDuration);
    }

    public Integer getRgvPosI(){
        //需要根据现场改造  根据读到的值获取对应站点位置
        if (RgvPos==null) return 0;
        return RgvPos.intValue();
    }

}

 src/main/java/com/zy/core/model/protocol/TaskProtocol.java

New file
@@ -0,0 +1,33 @@
package com.zy.core.model.protocol;

import lombok.Data;

/**
 * Created by IX on 2025/02/21
 */
@Data
public class TaskProtocol {
    private volatile Long taskNo; // 任务号（主属性）
    private volatile Long targetPosition = 0L; // 目标位置
    private volatile Long currentPosition = 0L; // 当前位置

    private volatile int isRunning = 0; // 运行状态  0：初始  1：等待执行  2：执行中 3：执行中断 4：完结

    private volatile int taskStatus = 0; //作业模式  0：行走  1：取  2：放

    public TaskProtocol(){}

    public TaskProtocol(Long taskNo, Long targetPosition, Long currentPosition, int isRunning, int taskStatus) {
        this.taskNo = taskNo;
        this.targetPosition = targetPosition;
        this.currentPosition = currentPosition;
        this.isRunning = isRunning;
        this.taskStatus = taskStatus;
    }

    public TaskProtocol(TaskProtocol taskProtocol) {
        this.taskNo = taskProtocol.getTaskNo();
        this.targetPosition = taskProtocol.getTargetPosition();
        this.taskStatus = taskProtocol.getTaskStatus();
    }
}

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

@@ -5,6 +5,7 @@
import HslCommunication.Profinet.Siemens.SiemensPLCS;
import HslCommunication.Profinet.Siemens.SiemensS7Net;
import com.alibaba.fastjson.JSON;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.SpringUtils;
import com.zy.asrs.entity.BasRgv;
@@ -15,6 +16,9 @@
import com.zy.core.ThreadHandler;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.cache.RgvStatusCache;
import com.zy.core.cache.TaskProtocolCache;
import com.zy.core.enums.RgvModeType;
import com.zy.core.enums.RgvStatusType;
import com.zy.core.enums.RgvTaskModeType;
import com.zy.core.enums.SlaveType;
@@ -22,11 +26,14 @@
import com.zy.core.model.Task;
import com.zy.core.model.command.RgvCommand;
import com.zy.core.model.protocol.RgvProtocol;
import com.zy.core.model.protocol.TaskProtocol;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * RGV线程
@@ -38,7 +45,9 @@

    private SiemensS7Net siemensNet;
    private RgvSlave slave;
    private RgvProtocol rgvProtocol;
//    private RgvProtocol rgvProtocol;
    private TaskProtocolCache taskProtocolCache = new TaskProtocolCache();

    /**
     * 工位1复位信号
     */
@@ -55,46 +64,135 @@
    @Override
    @SuppressWarnings("InfiniteLoopStatement")
    public void run() {
        this.connect();
        boolean connect = this.connect();
        if (connect){

            // 启动读数据线程
            new Thread(this::readStatusRgv).start();

            // 启动任务下发线程
            new Thread(this::taskTakeIssued).start();

            new Thread(this::taskPutIssued).start();

            new Thread(this::taskWalkIssued).start();
        }
    }

    private void readStatusRgv(){
        while (true) {
            try {
                int step = 1;
                Task task = MessageQueue.poll(SlaveType.Rgv, slave.getId());
                if (task != null) {
                    step = task.getStep();
                }
                switch (step) {
                    // 读数据
                    case 1:
                        readStatus();
                        break;
                    // 工位1、2写入数据
                    case 2:
                        write((RgvCommand) task.getData());
                        break;
                    // 复位
                    case 3:
                        RgvCommand command = (RgvCommand) task.getData();
                        if (null == command) {
                            command = new RgvCommand();
                        }
                        command.setRgvNo(slave.getId()); // RGV编号
                        command.setTaskNo((short) 0); // 工作号
                        command.setAckFinish((short) 1);  // 任务完成确认位
                        command.setTaskMode(RgvTaskModeType.NONE); // 任务模式
                        command.setDestinationStaNo(0L);     // 目标站
                        command.setCommand((short)0);
                        write(command);
                        break;
                    default:
                        break;
                }
                Thread.sleep(500);
                Thread.sleep(100);

                readStatus();

            } catch (Exception e) {
                log.error("RGV线程异常！！！"+e.getMessage());
                log.error("RGV数据读取线程异常！！！"+e.getMessage());
                initRgv();
//                e.printStackTrace();
            }

        }

    }

    /**
     * 任务下发
     */
    private void taskTakeIssued() {
        while (true) {
            try {
                // 休眠 1 秒
                Thread.sleep(100);
                if (!deviceDetection()){
                    continue;
                }
                RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
                if (rgvProtocol == null) {
                    initRgv();
                    rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
                }
                if (rgvProtocol.getAvoid() == 0 || !rgvProtocol.getLoaded().equals((short) 0)) {
                    continue;
                }
                List<TaskProtocol> allTakeTaskProtocol = taskProtocolCache.getAllTakeTaskProtocol();
                for(TaskProtocol taskProtocol: allTakeTaskProtocol){
                    if (taskProtocol.getTaskStatus() == 1){//准备下发








                        TaskProtocol issued = new TaskProtocol(taskProtocol);
                        write(issued);
                        taskProtocol.setIsRunning(taskProtocol.getIsRunning() +1);
                        taskProtocolCache.updateTaskProtocol(taskProtocol);
                        break;
                    }
                }


            } catch (Exception e) {
                log.error("RGV取货任务下发线程异常！！！"+e.getMessage());
//                e.printStackTrace();
            }
        }
    }

    public boolean deviceDetection(){
        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
        if (rgvProtocol == null) {
            return false;
        }
        if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L)
                || !rgvProtocol.getStatusType().equals(RgvStatusType.IDLE)) {
            return false;
        }
        RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId());
        if (rgvProtocolOther == null) {
            return false;
        }
        if (rgvProtocolOther.statusEnable){
            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 任务下发
     */
    private void taskPutIssued() {
        while (true) {
            try {
                // 休眠 1 秒
                Thread.sleep(100);

            } catch (Exception e) {
                log.error("RGV放货任务下发线程异常！！！"+e.getMessage());
//                e.printStackTrace();
            }
        }
    }

    /**
     * 任务下发
     */
    private void taskWalkIssued() {
        while (true) {
            try {
                // 休眠 1 秒
                Thread.sleep(100);


            } catch (Exception e) {
                log.error("RGV行走任务下发线程异常！！！"+e.getMessage());
//                e.printStackTrace();
            }
        }
    }

@@ -102,8 +200,10 @@
     * 初始化RGV状态
     */
    private void initRgv() {
        if (null == rgvProtocol) {
        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
        if (rgvProtocol == null) {
            rgvProtocol = new RgvProtocol();
            rgvProtocol.setRgvNo(slave.getId());
        }
        rgvProtocol.setMode((short) -1);
        rgvProtocol.setStatus((short)-1);
@@ -113,6 +213,15 @@
        rgvProtocol.setxSpeed((short) 0);
        rgvProtocol.setxDistance((short) 0);
        rgvProtocol.setxDuration((short) 0);
        BasRgvService basRgvService = SpringUtils.getBean(BasRgvService.class);
        BasRgv rgv = basRgvService.selectById(slave.getId());
        if (!Cools.isEmpty(rgv)){
            rgvProtocol.setStatusEnable(rgv.getStatus() == 1);
        } else {
            rgvProtocol.setStatusEnable(false);
        }
        RgvStatusCache.updateRgvStatus(rgvProtocol);

    }

    @Override
@@ -142,7 +251,9 @@
        try {
            OperateResultExOne<byte[]> result = siemensNet.Read("DB101.0", (short) 34);
            if (result.IsSuccess) {
                if (null == rgvProtocol) {
                // 构建设备状态对象
                RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
                if (rgvProtocol == null) {
                    rgvProtocol = new RgvProtocol();
                    rgvProtocol.setRgvNo(slave.getId());
                }
@@ -155,37 +266,49 @@
//                rgvProtocol.setxDuration(siemensNet.getByteTransform().TransInt16(result.Content, 48));

                OutputQueue.RGV.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
                // 工位1复位信号
                if (rgvProtocol.getStatusType().equals(RgvStatusType.WAITING)
                        || rgvProtocol.getStatusType().equals(RgvStatusType.FETCHWAITING)) {
                    if (resetFlag1) {
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setAckFinish1((short)1);
                        if (write(rgvCommand)) {
                            resetFlag1 = false;
                        }
                    }
                }
//                // 工位1复位信号
//                if (rgvProtocol.getStatusType().equals(RgvStatusType.WAITING)
//                        || rgvProtocol.getStatusType().equals(RgvStatusType.FETCHWAITING)) {
//                    if (resetFlag1) {
//                        RgvCommand rgvCommand = new RgvCommand();
//                        rgvCommand.setAckFinish1((short)1);
//                        if (write(rgvCommand)) {
//                            resetFlag1 = false;
//                        }
//                    }
//                }

                try {
                    // 根据实时信息更新数据库
                    BasRgvService basRgvService = SpringUtils.getBean(BasRgvService.class);
                    BasRgv basRgv = new BasRgv();
                    BasRgv basRgv = basRgvService.selectById(slave.getId());
                    if (!Cools.isEmpty(basRgv)){
                        rgvProtocol.setStatusEnable(basRgv.getStatus() == 1);
                    } else {
                        rgvProtocol.setStatusEnable(false);
                    }
//                    BasRgv basRgv = new BasRgv();
                    basRgv.setRgvNo(slave.getId());
                    basRgv.setRgvSts((int)rgvProtocol.getMode());
                    if (!basRgvService.updateById(rgvProtocol.toSqlModel(basRgv))){
                        log.error("RGV plc数据库更新失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
                    }
                } catch (Exception ignore){}
                } catch (Exception ignore){

                }


                // 更新缓存
                RgvStatusCache.updateRgvStatus(rgvProtocol);

            } else {
                initRgv();
                OutputQueue.RGV.offer(MessageFormat.format("【{0}】读取RGV plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
//                OutputQueue.RGV.offer(MessageFormat.format("【{0}】读取RGV plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
                log.error("读取RGV plc状态信息失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
            }
        } catch (Exception e) {
            e.printStackTrace();
            OutputQueue.RGV.offer(MessageFormat.format("【{0}】读取RGV plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
//            e.printStackTrace();
//            OutputQueue.RGV.offer(MessageFormat.format("【{0}】读取RGV plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            log.error("读取RGV plc状态信息失败 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
            initRgv();
        }
@@ -194,40 +317,40 @@
    /**
     * 写入数据
     */
    private boolean write(RgvCommand command) throws InterruptedException {
        if (null == command) {
    private boolean write(TaskProtocol taskProtocol) throws InterruptedException {
        if (null == taskProtocol) {
            log.error("RGV写入命令为空");
            return false;
        }
//        convertRow(command);
        command.setRgvNo(slave.getId());
        short[] array = new short[11];
        array[0] = command.getAckFinish1();
        array[1] = command.getTaskNo();
        array[2] = command.getTaskMode();
//        taskProtocol.setRgvNo(slave.getId());
        Long[] array = new Long[11];
//        array[0] = taskProtocol.getAckFinish1();
        array[1] = taskProtocol.getTaskNo();
//        array[2] = taskProtocol.getTaskMode();
//        array[4] = command.getDestinationStaNo();
        array[10] = command.getCommand();
        OperateResult result = siemensNet.Write("DB100.0", array);
//        array[10] = taskProtocol.getCommand();
        OperateResult result = siemensNet.Write("DB100.0", taskProtocol.getTaskNo());

        if (command.getAckFinish1() == 0) {
            short commandFinish = 3;  //工位1、2任务同时写入
            Thread.sleep(100L);
            result = siemensNet.Write("DB100.20", commandFinish);
        }
//        if (taskProtocol.getAckFinish1() == 0) {
//            short commandFinish = 3;  //工位1、2任务同时写入
//            Thread.sleep(100L);
//            result = siemensNet.Write("DB100.20", commandFinish);
//        }

        try {
            // 日志记录
            BasRgvOptService bean = SpringUtils.getBean(BasRgvOptService.class);
            BasRgvOpt basRgvOpt = new BasRgvOpt(
                    command.getTaskNo().intValue(),
                    command.getTaskNo().intValue(),
                    command.getRgvNo(),
                    taskProtocol.getTaskNo().intValue(),
                    taskProtocol.getTaskNo().intValue(),
                    slave.getId(),
                    new Date(),
                    command.getTaskModeType().toString(),
                    String.valueOf(taskProtocol.getTaskStatus()),
                    null,
                    null,
                    null,
                    command.getDestinationStaNo().intValue(),
                    result.IsSuccess? 1 : 0,
                    null,
                    new Date(),
                    null
@@ -238,8 +361,8 @@
        if (result != null && result.IsSuccess) {
            Thread.sleep(200);
            this.readStatus();
            log.info("RGV 命令下发[id:{}] >>>>> {}", slave.getId(), JSON.toJSON(command));
            OutputQueue.RGV.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(command)));
            log.info("RGV 命令下发[id:{}] >>>>> {}", slave.getId(), JSON.toJSON(taskProtocol));
            OutputQueue.RGV.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(taskProtocol)));
            return true;
        } else {
            OutputQueue.RGV.offer(MessageFormat.format("【{0}】写入RGV plc数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));

 src/main/resources/application-prod.yml

@@ -39,28 +39,14 @@
    port: 502
    rack: 0
    slot: 0
    devpPlcId: ${wcs-slave.devp[0].id}
    #RGV入库源站点
    otherId: 2
    #RGV源站点
    rgvInSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 100
    rgvInSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 101
    #RGV出库源站点
    rgvOutSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 110
    rgvOutSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 112
    #RGV目标站点
    rgvDestStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
    rgvDestStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 103
  # RGV穿梭车2
  rgv[1]:
    id: 2
@@ -68,25 +54,11 @@
    port: 502
    rack: 0
    slot: 0
    devpPlcId: ${wcs-slave.devp[0].id}
    #RGV入库源站点
    otherId: 1
    #RGV源站点
    rgvInSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 100
    rgvInSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 101
    #RGV出库源站点
    rgvOutSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 110
    rgvOutSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 112
    #RGV目标站点
    rgvDestStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
    rgvDestStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 103
      staNo: 101