#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;

/**
@@ -748,7 +747,7 @@
                        continue;
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                    if ((wrkMast.getIoType() != 12 && wrkMast.getIoType() < 100) || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
@@ -802,8 +801,100 @@
    }

    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     * 堆垛机任务衔接任务生成
     */
    public synchronized void connectWrk(Integer mark) {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            StaProtocol staProtocolIn = devpThread.getStation().get(4001);
            if (staProtocolIn == null) {
                continue;
            } else {
                staProtocolIn = staProtocolIn.clone();
            }
            StaProtocol staProtocolOut = devpThread.getStation().get(1015);
            if (staProtocolOut == null) {
                continue;
            } else {
                staProtocolOut = staProtocolOut.clone();
            }
            if(staProtocolOut.getWorkNo() != null &&staProtocolOut.getStaNo() == 4006){
                WrkMast wrkMastOut = wrkMastMapper.selectByWrkNo(staProtocolOut.getWorkNo());
                WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9997);
                if(wrkMast == null){
                    continue;
                }
                try {
                    TransplantWork param = new TransplantWork();
                    param.setWorkNo(wrkMastOut.getWrkNo());
                    param.setBarcode(wrkMastOut.getBarcode());
                    param.setSourceStaNo(1015);
                    param.setStaNo(wrkMastOut.getStaNo());
                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/TransplantingIn/v1")
                            .setJson(JSON.toJSONString(param))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        staProtocolOut.setWorkNo(9997);
                        devpThread.setPakMk(staProtocolOut.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocolOut));

                        if (!result) {
                            throw new CoolException("更新plc站点信息失败");
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            }

            if(staProtocolIn.getWorkNo() != null &&staProtocolIn.getStaNo() != 4001){
                WrkMast wrkMastIn = wrkMastMapper.selectByWrkNo(staProtocolIn.getWorkNo());
                WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9996);
                if(wrkMast == null){
                    continue;
                }
                try {
                    TransplantWork param = new TransplantWork();
                    param.setWorkNo(wrkMastIn.getWrkNo());
                    param.setBarcode(wrkMastIn.getBarcode());
                    param.setSourceStaNo(4001);
                    param.setStaNo(wrkMastIn.getStaNo());
                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/TransplantingOut/v1")
                            .setJson(JSON.toJSONString(param))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        staProtocolIn.setWorkNo(9996);
                        devpThread.setPakMk(staProtocolIn.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocolIn));

                        if (!result) {
                            throw new CoolException("更新plc站点信息失败");
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            }
        }

    }


        /**
         * 入出库  ===>>  堆垛机入出库作业下发
         */
    public synchronized void crnIoExecute(Integer mark) {

        for (CrnSlave crn : slaveProperties.getCrn()) {
@@ -929,6 +1020,61 @@
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (slave.getId() == 3) {
                SiemensDevpThread devpThread1 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol2 = devpThread1.getStation().get(4001);
                if (staProtocol2 == null) {
                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol2);
                    break;
                } else {
                    staProtocol2 = staProtocol2.clone();
                }
                WrkMast wrkMast9999 = wrkMastMapper.selectByWrkNo(9996);
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
                if(wrkMast9999 != null && staProtocol2.isAutoing() && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        break;
//                        return;
                    }
                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo((short) 9996); // 工作号
//                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX((short) 5);     // 源库位排
                    crnCommand.setSourcePosY((short) 1);     // 源库位列
                    crnCommand.setSourcePosZ((short) 4);     // 源库位层
                    crnCommand.setDestinationPosX((short) 6);     // 目标库位排
                    crnCommand.setDestinationPosY((short) 1);     // 目标库位列
                    crnCommand.setDestinationPosZ((short) 1);     // 目标库位层
//                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9999.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9999.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        wrkMast9999.setWrkSts(3L);
                        wrkMast9999.setCrnStrTime(now);
                        wrkMast9999.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast9999) == 0) {
                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9999.getWrkNo());
                        }
                        break;
                    }
                }
            }
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
@@ -1074,6 +1220,61 @@
            // 获取工作状态为11（生成出库ID）的出库工作档
//            WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
            List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo());
            if (slave.getId() == 3) {
                SiemensDevpThread devpThread1 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol2 = devpThread1.getStation().get(1015);
                if (staProtocol2 == null) {
                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol2);
                    break;
                } else {
                    staProtocol2 = staProtocol2.clone();
                }
                WrkMast wrkMast9999 = wrkMastMapper.selectByWrkNo(9997);
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
                if(wrkMast9999 != null && staProtocol2.isAutoing() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        break;
//                        return;
                    }
                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo((short) 9997); // 工作号
//                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX((short) 5);     // 源库位排
                    crnCommand.setSourcePosY((short) 1);     // 源库位列
                    crnCommand.setSourcePosZ((short) 1);     // 源库位层
                    crnCommand.setDestinationPosX((short) 6);     // 目标库位排
                    crnCommand.setDestinationPosY((short) 1);     // 目标库位列
                    crnCommand.setDestinationPosZ((short) 4);     // 目标库位层
//                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9999.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9999.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        wrkMast9999.setWrkSts(12L);
                        wrkMast9999.setCrnStrTime(now);
                        wrkMast9999.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast9999) == 0) {
                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9999.getWrkNo());
                        }
                        break;
                    }
                }
            }
            for (WrkMast wrkMast : wrkMasts) {
                if (wrkMast == null) {
                    continue;
@@ -1126,11 +1327,11 @@

                if (staProtocol.isAutoing() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                        ) {
                    if (slave.getId() == 1 || slave.getId() == 2){
                        if (staProtocol.isLoading() || staProtocol.getWorkNo() != 0 || !staProtocol.isOutEnable()){
                            continue;
                        }
                    }
//                    if (slave.getId() == 1 || slave.getId() == 2){
//                        if (staProtocol.isLoading() || staProtocol.getWorkNo() != 0 || !staProtocol.isOutEnable()){
//                            continue;
//                        }
//                    }
                    // 命令下发区 --------------------------------------------------------------------------

                    // 堆垛机控制过滤
@@ -1438,14 +1639,50 @@
            if (crnProtocol == null) {
                continue;
            }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行对工作档的完成操作，任务号:"+crnProtocol.getTaskNo());
            if(crnProtocol.getTaskNo() == 9999){
                //  状态：等待确认 并且  任务完成位 = 1
                if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行对工作档的完成操作，任务号:" + crnProtocol.getTaskNo());



                    // 堆垛机复位
                    News.warnNoLog("" + mark + " - 2" + " - 修改成功后复位堆垛机 : 堆垛机号={}", crnThread.getCrnProtocol().getCrnNo());
                    crnThread.setResetFlag(true);
                }
            } else if (crnProtocol.getTaskNo() == 9996) {//盘点入库衔接
                //  状态：等待确认 并且  任务完成位 = 1
                if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行对工作档的完成操作，任务号:" + crnProtocol.getTaskNo());

                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
                    if (wrkMast == null) {
                        News.error(""+mark+" - 1"+" - 堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    // 入库 + 库位转移  ==> 4.入库完成
                    if (wrkMast.getWrkSts() == 3 || (wrkMast.getWrkSts() == 12 && wrkMast.getIoType() == 11)) {
                        wrkMast.setWrkSts(4L);
                    } else {
                        continue;
                    }
                    Date now = new Date();
                    wrkMast.setCrnEndTime(now);
                    wrkMast.setModiTime(now);
                    // 修改成功后复位堆垛机
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        // 堆垛机复位
                        log.error(wrkMast.getWrkNo() + "任务修改状态4成功，复位堆垛机={}", crnThread.getCrnProtocol().getCrnNo());
                        News.warnNoLog("" + mark + " - 2" + " - 修改成功后复位堆垛机 : 堆垛机号={}", crnThread.getCrnProtocol().getCrnNo());
                        crnThread.setResetFlag(true);
                    }
                }
            }else{
                //  状态：等待确认 并且  任务完成位 = 1
                if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行对工作档的完成操作，任务号:" + crnProtocol.getTaskNo());

                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
                    if (wrkMast == null ) {
                        News.error("" + mark + " - 1" + " - 堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    }
                    // 入库 + 库位转移  ==> 4.入库完成
@@ -1460,16 +1697,19 @@
                    // 修改成功后复位堆垛机
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        // 堆垛机复位
                        log.error(wrkMast.getWrkNo()+"任务修改状态4成功，复位堆垛机={}",crnThread.getCrnProtocol().getCrnNo());
                        News.warnNoLog(""+mark+" - 2"+" - 修改成功后复位堆垛机 : 堆垛机号={}",crnThread.getCrnProtocol().getCrnNo());
                        log.error(wrkMast.getWrkNo() + "任务修改状态4成功，复位堆垛机={}", crnThread.getCrnProtocol().getCrnNo());
                        News.warnNoLog("" + mark + " - 2" + " - 修改成功后复位堆垛机 : 堆垛机号={}", crnThread.getCrnProtocol().getCrnNo());
                        crnThread.setResetFlag(true);
                    }
                }
            }



        }
//        News.infoNoLog(""+mark+" - 0"+" - 对工作档的完成操作执行完成");
    }


    /**
     * 堆垛机异常信息记录
@@ -2458,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) {
@@ -2474,7 +2714,7 @@
                    }
                    if (rgvProtocolOther.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocolOther.getModeType() == RgvModeType.AUTO
                        && rgvProtocolOther.getLoaded1()==0
                        && !rgvProtocolOther.isLoaded1ing()
                        && (rgvProtocolOther.getTaskNo1()==0)
                        &&rgvThreadOther.isPakMk()
                    ){
@@ -2547,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){
@@ -2608,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){
@@ -2642,6 +2897,8 @@
    }
    /**
     * 执行小车搬运任务
     *
     * @return
     */
    public synchronized boolean rgvRunWrkMastFullSta() {
        boolean wrkEnable = false;
@@ -2661,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) {
@@ -2679,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){
@@ -2719,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 {
@@ -2735,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("执行小车移动下发失败");
        }
    }
    /**
     * 执行小车搬运任务
@@ -2877,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;
//
//            }
//        }
//    }


    /*
@@ -2988,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;
        }