RGV control

Junjie

2023-07-05 986cf93c869bf8d5181f96a4a8b1a6092fc34247

RGV control

 src/main/java/com/zy/asrs/entity/BasRgvPath.java

New file
@@ -0,0 +1,154 @@
package com.zy.asrs.entity;

import com.core.common.Cools;import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.enums.IdType;
import com.baomidou.mybatisplus.annotations.TableField;
import com.core.common.SpringUtils;
import com.zy.system.service.UserService;
import com.zy.system.entity.User;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.core.common.SpringUtils;
import com.zy.system.service.UserService;
import com.zy.system.entity.User;
import java.text.SimpleDateFormat;
import java.util.Date;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import com.baomidou.mybatisplus.annotations.TableName;
import java.io.Serializable;

@Data
@TableName("asr_bas_rgv_path")
public class BasRgvPath implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * RGV编号
     */
    @ApiModelProperty(value= "RGV编号")
    @TableId(value = "rgv_no", type = IdType.INPUT)
    @TableField("rgv_no")
    private Integer rgvNo;

    /**
     * RGV运行路径
     */
    @ApiModelProperty(value= "RGV运行路径")
    private String path;

    /**
     * 状态 1: 正常  0: 禁用  
     */
    @ApiModelProperty(value= "状态 1: 正常  0: 禁用  ")
    private Integer status;

    /**
     * 添加人员
     */
    @ApiModelProperty(value= "添加人员")
    @TableField("create_by")
    private Long createBy;

    /**
     * 添加时间
     */
    @ApiModelProperty(value= "添加时间")
    @TableField("create_time")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    /**
     * 修改人员
     */
    @ApiModelProperty(value= "修改人员")
    @TableField("update_by")
    private Long updateBy;

    /**
     * 修改时间
     */
    @ApiModelProperty(value= "修改时间")
    @TableField("update_time")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date updateTime;

    /**
     * 备注
     */
    @ApiModelProperty(value= "备注")
    private String memo;

    public BasRgvPath() {}

    public BasRgvPath(Integer rgvNo,String path,Integer status,Long createBy,Date createTime,Long updateBy,Date updateTime,String memo) {
        this.rgvNo = rgvNo;
        this.path = path;
        this.status = status;
        this.createBy = createBy;
        this.createTime = createTime;
        this.updateBy = updateBy;
        this.updateTime = updateTime;
        this.memo = memo;
    }

//    BasRgvPath basRgvPath = new BasRgvPath(
//            null,    // RGV编号[非空]
//            null,    // RGV运行路径
//            null,    // 状态
//            null,    // 添加人员
//            null,    // 添加时间
//            null,    // 修改人员
//            null,    // 修改时间
//            null    // 备注
//    );

    public String getStatus$(){
        if (null == this.status){ return null; }
        switch (this.status){
            case 1:
                return "正常";
            case 0:
                return "禁用";
            default:
                return String.valueOf(this.status);
        }
    }

    public String getCreateBy$(){
        UserService service = SpringUtils.getBean(UserService.class);
        User user = service.selectById(this.createBy);
        if (!Cools.isEmpty(user)){
            return String.valueOf(user.getUsername());
        }
        return null;
    }

    public String getCreateTime$(){
        if (Cools.isEmpty(this.createTime)){
            return "";
        }
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.createTime);
    }

    public String getUpdateBy$(){
        UserService service = SpringUtils.getBean(UserService.class);
        User user = service.selectById(this.updateBy);
        if (!Cools.isEmpty(user)){
            return String.valueOf(user.getUsername());
        }
        return null;
    }

    public String getUpdateTime$(){
        if (Cools.isEmpty(this.updateTime)){
            return "";
        }
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.updateTime);
    }


}

 src/main/java/com/zy/asrs/mapper/BasRgvPathMapper.java

New file
@@ -0,0 +1,14 @@
package com.zy.asrs.mapper;

import com.zy.asrs.entity.BasRgvPath;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface BasRgvPathMapper extends BaseMapper<BasRgvPath> {

    BasRgvPath selectByRgvNo(Integer rgvNo);

}

 src/main/java/com/zy/asrs/mapper/WrkMastMapper.java

@@ -177,6 +177,20 @@
    /*================================================RGV任务绑定相关 ==================================================*/

    /**
     * 获取等待绑定RGV的任务
     * @return
     */
    List<WrkMast> selectWaitBindRGV();

    /**
     * 查找是否存在入出库工作中等待RGV搬运的任务
     *
     * @param rgvNo
     * @return
     */
    List<WrkMast> selectIoRgvNo(@Param("rgvNo") Integer rgvNo);

    /**
     * 查找是否存在入库工作中正在走向RGV的任务
     * @param wrkNo
     * @return

 src/main/java/com/zy/asrs/service/BasRgvPathService.java

New file
@@ -0,0 +1,10 @@
package com.zy.asrs.service;

import com.zy.asrs.entity.BasRgvPath;
import com.baomidou.mybatisplus.service.IService;

public interface BasRgvPathService extends IService<BasRgvPath> {

    BasRgvPath selectByRgvNo(Integer rgvNo);

}

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

New file
@@ -0,0 +1,16 @@
package com.zy.asrs.service.impl;

import com.zy.asrs.mapper.BasRgvPathMapper;
import com.zy.asrs.entity.BasRgvPath;
import com.zy.asrs.service.BasRgvPathService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service("basRgvPathService")
public class BasRgvPathServiceImpl extends ServiceImpl<BasRgvPathMapper, BasRgvPath> implements BasRgvPathService {

    @Override
    public BasRgvPath selectByRgvNo(Integer rgvNo) {
        return this.baseMapper.selectByRgvNo(rgvNo);
    }
}

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

@@ -10,7 +10,6 @@
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.BasCrnErrorMapper;
import com.zy.asrs.mapper.BasRgvErrMapper;
import com.zy.asrs.mapper.WaitPakinMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
@@ -88,6 +87,8 @@
    private BasRgvErrMapper basRgvErrMapper;
    @Autowired
    private BasRgvErrLogService basRgvErrLogService;
    @Autowired
    private BasRgvPathService basRgvPathService;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -513,9 +514,17 @@
    }

    /**
     * 绑定小车方法
     * 搜索RGV车。通过目标站搜索哪台车可用
     */
    public synchronized void rgvBindSte() {
    public synchronized Integer searchRgvNo(Integer staNo) {
        BasDevp basDevp = basDevpService.selectById(staNo);
        if (basDevp == null) {
            return null;//目标站不存在
        }
        //路径值
        int path = basDevp.getLocType3().intValue();

        ArrayList<RgvThread> list = new ArrayList<>();
        for (RgvSlave rgv : slaveProperties.getRgv()) {
            // 获取RGV信息
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
@@ -529,78 +538,63 @@
                continue;
            }

            // 只有当RGV空闲、自动, 并且无任务、无物时才继续执行
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
                    && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
            ) {
                // 如果最近一次是入库模式
                if (rgvProtocol.getLastIo().equals("I")) {
                    if (basRgv.getInEnable().equals("Y")) {
                        this.rgvBindSteIn(rgv, rgvProtocol); //  入库
                        rgvProtocol.setLastIo("O");
                    } else if (basRgv.getOutEnable().equals("Y")) {
                        this.rgvBindSteOut(rgv, rgvProtocol); //  出库
                        rgvProtocol.setLastIo("I");
                    }
            list.add(rgvThread);
        }

        if (list.size() > 1) {
            //超过两台车，按照配置的规则进行分配
            for (RgvThread rgvThread : list) {
                //获取车辆配置的路径规则
                BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(rgvThread.getSlave().getId());
                if (basRgvPath == null) {
                    continue;
                }
                // 如果最近一次是出库模式
                else if (rgvProtocol.getLastIo().equals("O")) {
                    if (basRgv.getOutEnable().equals("Y")) {
                        this.rgvBindSteOut(rgv, rgvProtocol); //  出库
                        rgvProtocol.setLastIo("I");
                    } else if (basRgv.getInEnable().equals("Y")) {
                        this.rgvBindSteIn(rgv, rgvProtocol); //  入库
                        rgvProtocol.setLastIo("O");
                    }
                //目标站是否包含当前路径中
                List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
                if (rgvPath.contains(path)) {
                    //当前路径中包含目标站，则选定这台车
                    return rgvThread.getSlave().getId();
                }
            }
        }else {
            //小于或等于1台车，分配全路径
            List<Integer> rgvPath = new ArrayList<Integer>(){{
                add(1);add(2);add(3);add(4);add(5);add(6);
                add(7);add(8);add(9);add(10);add(11);add(12);
                add(13);add(14);add(15);add(16);add(17);add(18);
            }};
            if (rgvPath.contains(path)) {
                //当前路径中包含目标站，则选定这台车
                return list.get(0).getSlave().getId();
            }
        }

        return null;
    }

    /**
     * 绑定小车方法
     */
    public synchronized void rgvBindSte() {
        //获取等待绑定RGV的任务
        List<WrkMast> wrkMasts = wrkMastMapper.selectWaitBindRGV();
        for (WrkMast wrkMast : wrkMasts) {
            //目标站
            Integer staNo = wrkMast.getStaNo();
            //通过目标站搜索rgv号
            Integer rgvNo = this.searchRgvNo(staNo);
            if (rgvNo == null) {//未找到可用的rgv
                continue;
            }

            wrkMast.setRgvNo(rgvNo);//绑定rgv号
            wrkMast.setRgvDstaNo(wrkMast.getSourceStaNo());//设置RGV前往工作档源站取货
            if (wrkMastMapper.updateById(wrkMast)==0){
                log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
            }
        }
    }

    /**
     * 绑定小车入库方法
     */
    public synchronized void rgvBindSteIn(RgvSlave slave, RgvProtocol rgvProtocol) {
        for (RgvSlave.RgvStn rgvStn: slave.getRgvInSStn()){
            Integer staNo = rgvStn.getStaNo();
            BasDevp basDevp = basDevpService.selectById(rgvStn.getDevpPlcId());
            if (Cools.isEmpty(basDevp) || basDevp.getWrkNo()==0){
                continue;
            }else {
                WrkMast wrkMast = wrkMastMapper.selectRgvInSteWrkNo(basDevp.getWrkNo());
                if (!Cools.isEmpty(wrkMast)){
                    wrkMast.setRgvNo(wrkMast.getCrnNo()>3 ? 2 : 1);
                    wrkMast.setAppeTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast)==0){
                        log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                    }
                }
            }
        }
    }

    /**
     * 绑定小车出库方法
     */
    public synchronized void rgvBindSteOut(RgvSlave slave, RgvProtocol rgvProtocol) {
        for (RgvSlave.RgvStn rgvStn: slave.getRgvOutSStn()){
            BasDevp basDevp = basDevpService.selectById(rgvStn.getDevpPlcId());
            if (Cools.isEmpty(basDevp) || basDevp.getWrkNo()==0){
                continue;
            }else {
                WrkMast wrkMast = wrkMastMapper.selectRgvOutSteWrkNo(basDevp.getWrkNo());
                if (!Cools.isEmpty(wrkMast)){
                    wrkMast.setRgvNo(rgvStn.getStaNo());
                    wrkMast.setAppeTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast)==0){
                        log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                    }
                }
            }
        }
    }
    /**
     * 入出库  ===>>  RGV入出库作业下发
     */
@@ -618,32 +612,125 @@
                continue;
            }

            // 只有当RGV空闲、自动, 并且无任务、无物时才继续执行
            // 只有当RGV空闲、自动,
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
                    && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
//                    && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
//                    && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
                    ) {
                // 如果最近一次是入库模式
                if (rgvProtocol.getLastIo().equals("I")) {
                    if (basRgv.getInEnable().equals("Y")) {
                        this.rgvInStn(rgv, rgvProtocol); //  入库
                        rgvProtocol.setLastIo("O");
                    } else if (basRgv.getOutEnable().equals("Y")) {
                        this.rgvOutStn(rgv, rgvProtocol); //  出库
                        rgvProtocol.setLastIo("I");

                //查找是否存在入出库工作中等待RGV搬运的任务
                List<WrkMast> wrkMasts = wrkMastMapper.selectIoRgvNo(rgv.getId());
                for (WrkMast wrkMast : wrkMasts) {
                    if (wrkMast.getWrkSts() == 2) {//2.设备上走1 => 3.RGV取货中
                        if (rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
                            continue;
                        }

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 2.设备上走1 => 3.RGV取货中
                            Date now = new Date();
                            wrkMast.setWrkSts(3L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 2.设备上走1 => 3.RGV取货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 4) {//4.RGV取货完成 => 5.RGV放货中
                        if (rgvProtocol.getTaskNo1() == 0 || !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
                            continue;
                        }
                        if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
                            continue;
                        }

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 4.RGV取货完成 => 5.RGV放货中
                            Date now = new Date();
                            wrkMast.setWrkSts(5L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 4.RGV取货完成 => 5.RGV放货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 23) {//23.设备上走1 => 24.RGV取货中
                        if (rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
                            continue;
                        }

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 23.设备上走1 => 24.RGV取货中
                            Date now = new Date();
                            wrkMast.setWrkSts(24L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 23.设备上走1 => 24.RGV取货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 25) {//25.RGV取货完成 => 26.RGV放货中
                        if (rgvProtocol.getTaskNo1() == 0 || !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
                            continue;
                        }
                        if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
                            continue;
                        }

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 25.RGV取货完成 => 26.RGV放货中
                            Date now = new Date();
                            wrkMast.setWrkSts(26L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 25.RGV取货完成 => 26.RGV放货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    }
                }
                // 如果最近一次是出库模式
                else if (rgvProtocol.getLastIo().equals("O")) {
                    if (basRgv.getOutEnable().equals("Y")) {
                        this.rgvOutStn(rgv, rgvProtocol); //  出库
                        rgvProtocol.setLastIo("I");
                    } else if (basRgv.getInEnable().equals("Y")) {
                        this.rgvInStn(rgv, rgvProtocol); //  入库
                        rgvProtocol.setLastIo("O");
                    }
                }

            }
        }
    }
@@ -1598,6 +1685,7 @@
     * 根据RGV完成信号，执行对工作档的完成操作，和RGV的任务下发
     */
    public synchronized void rgvFinished() {
        Date now = new Date();
        for (RgvSlave rgv : slaveProperties.getRgv()) {
            // 获取RGV信息
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
@@ -1605,133 +1693,161 @@
            if (rgvProtocol == null) {
                continue;
            }
            //  工位1状态：取货完成等待确认91 并且  任务完成位 = 1
            if (rgvProtocol.statusType1 == RgvStatusType.FETCHWAITING && rgvProtocol.getTaskNo1() != 0) {
                //工位1取货完成后，工位2是无货空闲状态时，准备给工位2发任务，确认是否有待执行RGV任务
                if (rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() == 0
                        && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() == 0
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                ) {
                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
                    if (wrkMast1 == null) {
                        log.error("RGV工位1处于等待确认且取货任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgv.getId(), rgvProtocol.getTaskNo1());
                        continue;
                    }
                    List<WrkMast> wrkMastTask = new ArrayList<>();
                    List<WrkMast> list = new ArrayList<>();
                    Integer type = 0;//1入库，2出库
                    if(wrkMast1.getWrkSts()==6L){
                        wrkMastTask = getRgvInTask(rgv);
                        list = wrkMastMapper.selectRgvInWorking(rgv.getId());
                        type = 1;
                    } else if(wrkMast1.getWrkSts()==16L){
                        wrkMastTask = getRgvOutTask(rgv);
                        list = wrkMastMapper.selectRgvOutWorking(rgv.getId());
                        type = 2;
                    }
                    if(wrkMastTask.size() > 0){//有继续执行任务，下发取货任务给工位2
                        // 已经存在RGV执行任务时，则过滤
                        if (list.size() > 1) {
                            continue;
                        }
                        WrkMast wrkMast2 = wrkMastTask.get(0);
                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                        rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
                        rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
                        rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式:  取货
                        rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //工位2源站点
                        rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //工位2目标站点
                        rgvCommand.setCommand((short) 0);   //工位1、2任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast2.getRgvNo(), new Task(5, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 2.设备上走 => 6.RGV入库取货中
                            Date now = new Date();
                            wrkMast2.setWrkSts(type==1 ? 6L : 16L);
                            wrkMast2.setCrnStrTime(now);
                            wrkMast2.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast2) == 0) {
                                log.error("工位2修改工作档状态 2/14.设备上走 => 6/16.RGV入库取货中 失败！！，工作号={}", wrkMast2.getWrkNo());
                            }
                        }
                    } else {//没有继续执行任务，下发放货任务给工位1
                        if(type == 1 && wrkMast1.getWrkSts() != 6L){//RGV入库取货中
                            continue;
                        }
                        if(type == 2 && wrkMast1.getWrkSts() != 16L){//RGV出库取货中
                            continue;
                        }

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
                        rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //工位1源站点
                        rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 0);   //工位1、2任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2任务确认；   step=4，工位1确认；     step=5，工位2任务确认
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 6.RGV入库取货中 => 7.RGV入库放货中
                            Date now = new Date();
                            wrkMast1.setWrkSts(type==1 ? 7L : 17L);
                            wrkMast1.setCrnEndTime(now);
                            wrkMast1.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast1) == 0) {
                                log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中 失败！！，工作号={}", wrkMast1.getWrkNo());
                            }
                            log.error("RGV命令下发成功，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
                        }
                    }
                } else if (rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() > 0
                        && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() > 0
                        && rgvProtocol.statusType2 == RgvStatusType.FETCHWAITING){
                    //  工位2状态：也是取货完成等待确认91 并且  任务完成位 = 1,  工位1、2同时下发放货任务
                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
                    WrkMast wrkMast2 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo2().intValue());
                    //  命令下发区 --------------------------------------------------------------------------
                    RgvCommand rgvCommand = new RgvCommand();
                    rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                    rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                    rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
                    rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
                    rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //工位1源站点
                    rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //工位1目标站点
                    rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
                    rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
                    rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式:  放货
                    rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //工位2源站点
                    rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //工位2目标站点
                    rgvCommand.setCommand((short) 0);   //工位1、2任务确认
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
                        //step=2,工位1、2任务确认；   step=4，工位1确认；     step=5，工位2任务确认
                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
                    } else {
                        // 修改工作档状态 2.设备上走 => 6.RGV入库取货中
                        Date now = new Date();
                        wrkMast1.setWrkSts(wrkMast1.getWrkSts()==6L ? 7L : 17L);
                        wrkMast1.setCrnStrTime(now);
                        wrkMast1.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast1) == 0) {
                            log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中 失败！！，工作号={}", wrkMast1.getWrkNo());
                        }

                        wrkMast2.setWrkSts(wrkMast2.getWrkSts()==6L ? 7L : 17L);
                        wrkMast2.setCrnStrTime(now);
                        wrkMast2.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast2) == 0) {
                            log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中 失败！！，工作号={}", wrkMast2.getWrkNo());
                        }
                    }
            //判断RGV是否空闲，工位1是否空闲，工位1是否有物，是否为电脑模式，工位1是否有工作号
            if (rgvProtocol.statusType1 == RgvStatusType.FETCHWAITING
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getTaskNo1() != 0
                    && rgvProtocol.getStatus() != 0
                    && rgvProtocol.getStatus1() != 0
            ) {
                WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
                if (wrkMast1 == null) {
                    log.error("RGV工位1处于等待确认且取货任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgv.getId(), rgvProtocol.getTaskNo1());
                    continue;
                }

                if (wrkMast1.getWrkSts() == 3) {//3.RGV取货中 => 4.RGV取货完成
                    wrkMast1.setWrkSts(4L);
                }else if(wrkMast1.getWrkSts() == 5){//5.RGV放货中 => 6.RGV放货完成
                    rgvProtocol.setTaskNo1((short) 0);//入库任务完成，清空任务号
                    wrkMast1.setWrkSts(6L);
                } else if (wrkMast1.getWrkSts() == 24) {//24.RGV取货中 => 25.RGV取货完成
                    wrkMast1.setWrkSts(25L);//
                } else if (wrkMast1.getWrkSts() == 26) {//26.RGV放货中 => 27.RGV放货完成
                    rgvProtocol.setTaskNo1((short) 0);//出库任务完成，清空任务号
                    wrkMast1.setWrkSts(27L);//27.RGV放货完成
                }

                wrkMast1.setModiTime(now);
                if (wrkMastMapper.updateById(wrkMast1) == 0) {
                    log.error("工位1修改工作档状态失败！！，工作号={}", wrkMast1.getWrkNo());
                }

//                //工位1取货完成后，工位2是无货空闲状态时，准备给工位2发任务，确认是否有待执行RGV任务
//                if (rgvProtocol.getModeType() == RgvModeType.AUTO
//                        && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() == 0
//                        && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() == 0
//                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
//                ) {
//                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
//                    if (wrkMast1 == null) {
//                        log.error("RGV工位1处于等待确认且取货任务完成状态，但未找到工作档。RGV号={}，工作号={}", rgv.getId(), rgvProtocol.getTaskNo1());
//                        continue;
//                    }
//                    List<WrkMast> wrkMastTask = new ArrayList<>();
//                    List<WrkMast> list = new ArrayList<>();
//                    Integer type = 0;//1入库，2出库
//                    if(wrkMast1.getWrkSts()==6L){
//                        wrkMastTask = getRgvInTask(rgv);
//                        list = wrkMastMapper.selectRgvInWorking(rgv.getId());
//                        type = 1;
//                    } else if(wrkMast1.getWrkSts()==16L){
//                        wrkMastTask = getRgvOutTask(rgv);
//                        list = wrkMastMapper.selectRgvOutWorking(rgv.getId());
//                        type = 2;
//                    }
//                    if(wrkMastTask.size() > 0){//有继续执行任务，下发取货任务给工位2
//                        // 已经存在RGV执行任务时，则过滤
//                        if (list.size() > 1) {
//                            continue;
//                        }
//                        WrkMast wrkMast2 = wrkMastTask.get(0);
//                        //  命令下发区 --------------------------------------------------------------------------
//                        RgvCommand rgvCommand = new RgvCommand();
//                        rgvCommand.setRgvNo(rgv.getId()); // RGV编号
//                        rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
//                        rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
//                        rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式:  取货
//                        rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //工位2源站点
//                        rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //工位2目标站点
//                        rgvCommand.setCommand((short) 0);   //工位1、2任务确认
//                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast2.getRgvNo(), new Task(5, rgvCommand))) {
//                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
//                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
//                        } else {
//                            // 修改工作档状态 2.设备上走 => 6.RGV入库取货中
//                            Date now = new Date();
//                            wrkMast2.setWrkSts(type==1 ? 6L : 16L);
//                            wrkMast2.setCrnStrTime(now);
//                            wrkMast2.setModiTime(now);
//                            if (wrkMastMapper.updateById(wrkMast2) == 0) {
//                                log.error("工位2修改工作档状态 2/14.设备上走 => 6/16.RGV入库取货中 失败！！，工作号={}", wrkMast2.getWrkNo());
//                            }
//                        }
//                    } else {//没有继续执行任务，下发放货任务给工位1
//                        if(type == 1 && wrkMast1.getWrkSts() != 6L){//RGV入库取货中
//                            continue;
//                        }
//                        if(type == 2 && wrkMast1.getWrkSts() != 16L){//RGV出库取货中
//                            continue;
//                        }
//
//                        //  命令下发区 --------------------------------------------------------------------------
//                        RgvCommand rgvCommand = new RgvCommand();
//                        rgvCommand.setRgvNo(rgv.getId()); // RGV编号
//                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
//                        rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
//                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
//                        rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //工位1源站点
//                        rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //工位1目标站点
//                        rgvCommand.setCommand((short) 0);   //工位1、2任务确认
//                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
//                            //step=2,工位1、2任务确认；   step=4，工位1确认；     step=5，工位2任务确认
//                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
//                        } else {
//                            // 修改工作档状态 6.RGV入库取货中 => 7.RGV入库放货中
//                            Date now = new Date();
//                            wrkMast1.setWrkSts(type==1 ? 7L : 17L);
//                            wrkMast1.setCrnEndTime(now);
//                            wrkMast1.setModiTime(now);
//                            if (wrkMastMapper.updateById(wrkMast1) == 0) {
//                                log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中 失败！！，工作号={}", wrkMast1.getWrkNo());
//                            }
//                            log.error("RGV命令下发成功，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
//                        }
//                    }
//                } else if (rgvProtocol.getModeType() == RgvModeType.AUTO
//                        && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() > 0
//                        && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() > 0
//                        && rgvProtocol.statusType2 == RgvStatusType.FETCHWAITING){
//                    //  工位2状态：也是取货完成等待确认91 并且  任务完成位 = 1,  工位1、2同时下发放货任务
//                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
//                    WrkMast wrkMast2 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo2().intValue());
//                    //  命令下发区 --------------------------------------------------------------------------
//                    RgvCommand rgvCommand = new RgvCommand();
//                    rgvCommand.setRgvNo(rgv.getId()); // RGV编号
//                    rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
//                    rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
//                    rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
//                    rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //工位1源站点
//                    rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //工位1目标站点
//                    rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
//                    rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 工位2工作号
//                    rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式:  放货
//                    rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //工位2源站点
//                    rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //工位2目标站点
//                    rgvCommand.setCommand((short) 0);   //工位1、2任务确认
//                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
//                        //step=2,工位1、2任务确认；   step=4，工位1确认；     step=5，工位2任务确认
//                        log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
//                    } else {
//                        // 修改工作档状态 2.设备上走 => 6.RGV入库取货中
//                        Date now = new Date();
//                        wrkMast1.setWrkSts(wrkMast1.getWrkSts()==6L ? 7L : 17L);
//                        wrkMast1.setCrnStrTime(now);
//                        wrkMast1.setModiTime(now);
//                        if (wrkMastMapper.updateById(wrkMast1) == 0) {
//                            log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中 失败！！，工作号={}", wrkMast1.getWrkNo());
//                        }
//
//                        wrkMast2.setWrkSts(wrkMast2.getWrkSts()==6L ? 7L : 17L);
//                        wrkMast2.setCrnStrTime(now);
//                        wrkMast2.setModiTime(now);
//                        if (wrkMastMapper.updateById(wrkMast2) == 0) {
//                            log.error("修改工作档状态 6/16.RGV入库取货中 => 7/17.RGV入库放货中 失败！！，工作号={}", wrkMast2.getWrkNo());
//                        }
//                    }
//                }
            }

        }

 src/main/java/com/zy/common/config/RedisConfig.java

@@ -5,6 +5,7 @@
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
@@ -14,7 +15,7 @@
 * Redis配置类
 * Created by vincent on 2019-12-23
 */
//@Configuration
@Configuration
//@EnableCaching // 开启数据缓存机制
public class RedisConfig extends CachingConfigurerSupport {


 src/main/java/com/zy/common/utils/RedisUtil.java

@@ -2,8 +2,11 @@

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -13,13 +16,16 @@
 * redisTemplate封装
 *
 */
//@Component
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
//    @Autowired
//    private RedisTemplate<String, Object> redisTemplate;

    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
    @Autowired
    private RedisTemplate redisTemplate;

    public RedisUtil(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

@@ -96,6 +102,21 @@
    }

    /**
     * 获取全部数据
     * @return
     */
    public HashMap<Object, Object> getRedis() {
        Set<String> keys = redisTemplate.keys("*");
        HashMap<Object, Object> map = new HashMap<>();
        for (String key : keys) {
            Object value = redisTemplate.opsForValue().get(key);
            map.put(key, value);
        }

        return map;//返回全部数据集合
    }

    /**
     * 普通缓存放入
     *
     * @param key   键

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

@@ -68,8 +68,8 @@
                    mainService.rgvIoExecute();
                    // RGV入库  ===>> 根据RGV完成信号,执行对工作档的完成操作
                    mainService.rgvFinished();
                    // 入出库  ===>>  RGV出库站到系统入出库站
                    mainService.rgvDestStnToCrnStn();
//                    // 入出库  ===>>  RGV出库站到系统入出库站
//                    mainService.rgvDestStnToCrnStn();
//                    // 出库  ===>>  RGV出库站到系统出库站
//                    mainService.rgvOutDStnToOutStn();
                    //////////////////////////////////////////////////////////////////

 src/main/resources/mapper/BasRgvPathMapper.xml

New file
@@ -0,0 +1,24 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zy.asrs.mapper.BasRgvPathMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.zy.asrs.entity.BasRgvPath">
        <result column="rgv_no" property="rgvNo" />
        <result column="path" property="path" />
        <result column="status" property="status" />
        <result column="create_by" property="createBy" />
        <result column="create_time" property="createTime" />
        <result column="update_by" property="updateBy" />
        <result column="update_time" property="updateTime" />
        <result column="memo" property="memo" />

    </resultMap>

    <select id="selectByRgvNo" resultMap="BaseResultMap">
        select * from asr_bas_rgv_path
        where 1=1
        and rgv_no = #{rgvNo}
    </select>

</mapper>

 src/main/resources/mapper/WrkMastMapper.xml

@@ -240,6 +240,13 @@
    <!--                                       RGV调度入出库相关                                      -->
    <!-- ==============================================RGV任务绑定相关 ============================================== -->

    <select id="selectWaitBindRGV" resultMap="BaseResultMap">
        select * from dbo.asr_wrk_mast
        where 1=1
        and wrk_sts in (2,22)
        and rgv_no is null
    </select>

    <select id="selectRgvInSteWrkNo" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast where 1=1 and wrk_sts =12 and wrk_no=#{wrkNo} and rgv_no is null
    </select>
@@ -248,6 +255,14 @@
        select top 1 * from dbo.asr_wrk_mast where 1=1 and wrk_sts =24 and wrk_no=#{wrkNo} and rgv_no is null
    </select>

    <select id="selectIoRgvNo" resultMap="BaseResultMap">
        select * from dbo.asr_wrk_mast
        where 1=1
        and wrk_sts in (2,4,23,25)
        and rgv_no = #{rgvNo}
        order by io_pri desc,io_time desc,wrk_no ASC
    </select>

    <select id="selectRgvInSteNo" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast where 1=1 and wrk_sts =12 and rgv_no=#{rgvNo}
        <if test="rgvNo == 1">