RGV control

Junjie

2023-07-06 83eb556b86fac1aae7f9d4ea3ea343e8ea9f8b0b

 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;
@@ -188,7 +189,13 @@

                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());

                            if(Cools.isEmpty(dto.getRgvNo()) || dto.getRgvNo() <= 0) {
                                staProtocol.setStaNo(dto.getStaNo().shortValue());
                            } else {//如果存在RGV编号，说明需要RGV接驳，先下发任务到RGV源站
                                staProtocol.setStaNo(dto.getRgvSstaNo().shortValue());
                            }

                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
@@ -507,6 +514,88 @@
    }

    /**
     * 搜索RGV车。通过目标站搜索哪台车可用
     */
    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());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                continue;
            }
            BasRgv basRgv = basRgvService.selectById(rgv.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！", rgv.getId());
                continue;
            }

            list.add(rgvThread);
        }

        if (list.size() > 1) {
            //超过两台车，按照配置的规则进行分配
            for (RgvThread rgvThread : list) {
                //获取车辆配置的路径规则
                BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(rgvThread.getSlave().getId());
                if (basRgvPath == null) {
                    continue;
                }
                //目标站是否包含当前路径中
                List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
                if (rgvPath.contains(path)) {
                    //当前路径中包含目标站，则选定这台车
                    return rgvThread.getSlave().getId();
                }
            }
        }else {
            //小于或等于1台车，分配全路径
            BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(0);//获取默认路径
            if (basRgvPath == null) {
                return null;
            }
            List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
            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());
            }
        }
    }

    /**
     * 入出库  ===>>  RGV入出库作业下发
     */
    public synchronized void rgvIoExecute() {
@@ -523,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");
                    }
                }

            }
        }
    }
@@ -1237,6 +1419,9 @@
     * 入库  ===>>  RGV入库站到站
     */
    public synchronized void rgvInStn(RgvSlave slave, RgvProtocol rgvProtocol) {
        WrkMast wrkMast = wrkMastMapper.selectRgvInSteNo(slave.getId());


        //查找工作状态为2（设备上走）,且RGV入库接驳站符合的的入库工作档，提取出最多2笔
        List<WrkMast> wrkMastTask = getRgvInTask(slave);
        if(wrkMastTask.size() <= 0){
@@ -1500,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());
@@ -1507,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());
//                        }
//                    }
//                }
            }

        }
@@ -2624,6 +2838,13 @@
    }

    /**
     * 初始化RGV地图
     */
    public synchronized void initRgvMap() {

    }

    /**
     * 堆垛机演示  ===>> 库位移转
     */
    public synchronized void crnDemoOfLocMove1() {