#

LSH

2023-11-21 6c265faa61e5cf0ea8a0c4fce81355a52e211de0

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

@@ -8,10 +8,9 @@
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.BasCrnErrorMapper;
import com.zy.asrs.mapper.BasRgvErrMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.RouteUtils;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.model.LocTypeDto;
@@ -70,6 +69,8 @@
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private WaitPakinMapper waitPakinMapper;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private StaDescService staDescService;
@@ -93,6 +94,10 @@
    private BasRgvPathService basRgvPathService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private WrkMastStaMapper wrkMastStaMapper;
    @Autowired
    private BasRgvMapMapper basRgvMapMapper;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -534,6 +539,7 @@
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {

                continue;
            }
            BasRgv basRgv = basRgvService.selectById(rgv.getId());
@@ -576,33 +582,157 @@
        return null;
    }

//    /**
//     * 绑定小车方法
//     */
//    public synchronized void rgvBindSte() {
//        //获取等待绑定RGV的任务
//        List<WrkMast> wrkMasts = wrkMastMapper.selectWaitBindRGV();
//        for (WrkMast wrkMast : wrkMasts) {
//            //目标站
//            Integer staNo = wrkMast.getStaNo();
//            //源站
//            Integer sourceStaNo = wrkMast.getSourceStaNo();
//            //通过目标站搜索rgv号
//            Integer rgvNo=0;
//            if (wrkMast.getCrnNo()==1){
//                rgvNo=1;
//            }else if (wrkMast.getCrnNo()==6){
//                rgvNo=2;
//            }else {
//                rgvNo = this.searchRgvNo(staNo);
//            }
//            if (rgvNo == null || rgvNo==0) {//未找到可用的rgv
//                continue;
//            }
//
//            wrkMast.setRgvNo(rgvNo);//绑定rgv号
//            wrkMast.setRgvDstaNo(wrkMast.getSourceStaNo());//设置RGV前往工作档源站取货
//            if (wrkMastMapper.updateById(wrkMast)==0){
//                log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
//            }
//        }
//    }

    /**
     * 绑定小车方法
     */
    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;
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                if (devp.getId()==2){
                    continue;
                }
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                //入库绑小车
                for (DevpSlave.Sta Sta : devp.getInRgvSta()) {
                    StaProtocol staProtocol = devpThread.getStation().get(Sta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() != 0 && staProtocol.getWorkNo() < 9990){
                        List<WrkMast> wrkMasts = wrkMastMapper.selectList(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getWorkNo()).eq("wrk_sts", 2L));
                        if (Cools.isEmpty(wrkMasts) || wrkMasts.size()!=1){
                            continue;
                        }
                        WrkMast wrkMast = wrkMasts.get(0);
                                    //目标站
                        Integer staNo = wrkMast.getStaNo();
                        //通过目标站搜索rgv号
                        Integer rgvNo=0;
                        if (wrkMast.getCrnNo()==1){
                            rgvNo=1;
                        }else if (wrkMast.getCrnNo()==6){
                            rgvNo=2;
                        }else {
                            rgvNo = this.searchRgvNo(staNo);
                        }
                        if (rgvNo == null || rgvNo==0) {//未找到可用的rgv
                            continue;
                        }
                        wrkMast.setRgvNo(rgvNo);//绑定rgv号
                        if (wrkMastMapper.updateById(wrkMast)==0){
                            log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                        }
                    }
                }
                //出库绑小车
                for (DevpSlave.Sta Sta : devp.getOutRgvSta()) {
                    StaProtocol staProtocol = devpThread.getStation().get(Sta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() != 0 && staProtocol.getWorkNo() < 9990){
                        List<WrkMast> wrkMasts = wrkMastMapper.selectList(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getWorkNo()).eq("wrk_sts", 14L));
                        if (Cools.isEmpty(wrkMasts) || wrkMasts.size()!=1){
                            continue;
                        }
                        WrkMast wrkMast = wrkMasts.get(0);
                        //目标站
                        Integer staNo = wrkMast.getStaNo();
                        //通过目标站搜索rgv号
                        Integer rgvNo=0;
                        if (wrkMast.getCrnNo()==1){
                            rgvNo=1;
                        }else if (wrkMast.getCrnNo()==6){
                            rgvNo=2;
                        }else {
                            rgvNo = this.searchRgvNo(staNo);
                        }
                        if (rgvNo == null || rgvNo==0) {//未找到可用的rgv
                            continue;
                        }
                        wrkMast.setRgvNo(rgvNo);//绑定rgv号
                        if (wrkMastMapper.updateById(wrkMast)==0){
                            log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("绑定小车异常：{}", e.getMessage());
        }
    }

            wrkMast.setRgvNo(rgvNo);//绑定rgv号
            wrkMast.setRgvDstaNo(wrkMast.getSourceStaNo());//设置RGV前往工作档源站取货
            if (wrkMastMapper.updateById(wrkMast)==0){
                log.error("绑定小车更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
    /**
     * 绑定小车方法
     */
    public synchronized void rgvBindSte2() {
        try{
            for (RgvSlave rgv : slaveProperties.getRgv()) {
                List<WrkMast> wrkMasts = wrkMastMapper.selectWaitBindRGVRgvNo(rgv.getId());
                if (!Cools.isEmpty(wrkMasts) && wrkMasts.size()!=0){
                    continue;
                }
                List<WrkMast> wrkMasts2 = wrkMastMapper.selectWaitBindRgvNo2(rgv.getId());
                for (WrkMast wrkMast : wrkMasts2) {
                    if (wrkMastMapper.selectWaitBindRgvNoOneWrkNo(wrkMast.getWrkNo())!=null){
                        continue;
                    }
                    //目标站
                    BasDevp basDevp = basDevpService.selectById(wrkMast.getRgvDstaNo());
                    if (Cools.isEmpty(basDevp) || !basDevp.getAutoing().equals("Y") || !basDevp.getLoading().equals("N") || basDevp.getWrkNo()!=0){
                        continue;
                    }
                    wrkMastMapper.insertRgvMast(wrkMast.getWrkNo());
                    wrkMastMapper.updateRgvMast(wrkMast.getWrkNo());
                    break;
                }
            }
        }catch (Exception e){
            log.error("小车搬运任务异常：{}", e.getMessage());
        }
    }

    /**
     * 入出库  ===>>  RGV入出库作业下发
     */
    public synchronized void rgvIoExecute() {
    public synchronized void rgvIoExecuteOld() {
        for (RgvSlave rgv : slaveProperties.getRgv()) {
            // 获取RGV信息
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
@@ -621,7 +751,7 @@
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
//                    && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
//                    && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
                    ) {
            ) {

                //查找是否存在入出库工作中等待RGV搬运的任务
                List<WrkMast> wrkMasts = wrkMastMapper.selectIoRgvNo(rgv.getId());
@@ -632,7 +762,7 @@
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getStaNo();
                        Integer staNo = wrkMast.getSourceStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
@@ -641,8 +771,14 @@
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);

//                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
@@ -664,13 +800,31 @@
                                log.error("修改工作档状态 2.设备上走1 => 3.RGV取货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 4) {//4.RGV取货完成 => 5.RGV放货中
                    } else if (wrkMast.getWrkSts() == 14) {//4.RGV取货完成 => 5.RGV放货中   14出库完成
                        if (rgvProtocol.getTaskNo1() == 0 || !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
                            continue;
                        }
                        if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
                            continue;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
@@ -696,6 +850,24 @@
                        if (rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
                            continue;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getSourceStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
@@ -725,6 +897,24 @@
                            continue;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
@@ -750,6 +940,247 @@

            }
        }
    }

    /**
     * 入出库  ===>>  RGV入出库作业下发
     */
    public synchronized void rgvIoExecute() {
        for (RgvSlave rgv : slaveProperties.getRgv()) {
            RgvSlave rgvSlave=null;
            if (rgv.getId()==1){
                rgvSlave = slaveProperties.getRgv().get(1);
            }else {
                rgvSlave = slaveProperties.getRgv().get(0);
            }

            // 获取RGV信息
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {
                continue;
            }

            RgvThread rgvThreadSlave = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            RgvProtocol rgvProtocolSlave = rgvThreadSlave.getRgvProtocol();
            BasRgv basRgvSlave = null;
            if (rgvProtocolSlave == null) {
                rgvSlave=null;
            }else {
                basRgvSlave = basRgvService.selectById(rgv.getId());
                if (basRgvSlave == null) {
                    rgvSlave=null;
                }
            }

            BasRgv basRgv = basRgvService.selectById(rgv.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！", rgv.getId());
                continue;
            }

            boolean signSlave=false;//此处判断RgvSlave是否已经规避
            boolean signSlaveState=false;//此处判断RgvSlave是否空闲
            Integer staSlave = 0;//此处记录RgvSlave当前位置

            // 只有当RGV空闲、自动,
            if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                    && rgvProtocol.getModeType() == RgvModeType.AUTO
//                    && rgvProtocol.getTaskNo1() == 0 && rgvProtocol.getTaskNo2() == 0
//                    && rgvProtocol.getLoaded1() == 0 && rgvProtocol.getLoaded2() == 0
                    ) {

                //查找是否存在入出库工作中等待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;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getSourceStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
//                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        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() == 14) {//4.RGV取货完成 => 5.RGV放货中   14出库完成
                        if (rgvProtocol.getTaskNo1() == 0 || !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
                            continue;
                        }
                        if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
                            continue;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        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;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getSourceStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        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;
                        }

                        //判断行走路径是否被占用
                        Integer staNo = wrkMast.getStaNo();
                        BasDevp basDevp = basDevpService.selectById(staNo);
                        if (basDevp == null) {
                            continue;//目标站不存在
                        }
                        //起始路径
                        int startPath = rgvProtocol.getRgvPos().intValue();
                        //目标路径值
                        int endPath = basDevp.getLocType3().intValue();
                        boolean pathUsed = RgvUtils.isPathUsed(startPath, endPath);//判断行走路径是否被占用
                        if (pathUsed) {
                            //行走路径被占用，禁止下发命令
                            continue;
                        }
                        //行走路径空闲，锁定路径
                        RgvUtils.lockPath(startPath, endPath, rgvProtocol.getRgvNo(), wrkMast.getWrkNo(), true);

                        //  命令下发区 --------------------------------------------------------------------------
                        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());
                            }
                        }
                    }
                }

            }
        }
    }

    private boolean rgvIoExecuteWrk2To3() {
        return false;
    }

    /**
@@ -1735,9 +2166,24 @@
                    wrkMast1.setWrkSts(27L);//27.RGV放货完成
                }

                //解锁路径
                RgvUtils.unLockPath(wrkMast1.getRgvNo());

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

                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                rgvCommand.setAckFinish1((short) 1);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.NONE); // 工位1任务模式:  无
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                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));
                }

//                //工位1取货完成后，工位2是无货空闲状态时，准备给工位2发任务，确认是否有待执行RGV任务
@@ -2439,64 +2885,7 @@
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }


//                    // 检索库位
//                    LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//                    StartupDto startupDto = commonService.getLocNo(1, 10, emptyInSta.getStaNo(), null, locTypeDto, 0);
//                    // 工作号
//                    int workNo = startupDto.getWorkNo();
//
//                    try {
//                        // 插入工作主档
//                        WrkMast wrkMast = new WrkMast();
//                        wrkMast.setWrkNo(workNo);
//                        wrkMast.setIoTime(new Date());
//                        wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
//                        wrkMast.setIoType(10); // 入出库状态：10.空板入库
//                        wrkMast.setIoPri(10D); // 优先级：10
//                        wrkMast.setCrnNo(startupDto.getCrnNo());
//                        wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
//                        wrkMast.setStaNo(startupDto.getStaNo());
//                        wrkMast.setLocNo(startupDto.getLocNo());
//                        wrkMast.setFullPlt("N"); // 满板
//                        wrkMast.setPicking("N"); // 拣料
//                        wrkMast.setExitMk("N"); // 退出
//                        wrkMast.setEmptyMk("Y"); // 空板
//                        wrkMast.setLinkMis("N");
////                    wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
//                        // 操作人员数据
//                        wrkMast.setAppeTime(new Date());
//                        wrkMast.setModiTime(new Date());
//                        Integer insert = wrkMastMapper.insert(wrkMast);
//                        if (insert == 0) {
//                            throw new CoolException("保存工作档失败");
//                        }
//                        // 更新目标库位状态
//                        LocMast locMast = locMastService.selectById(startupDto.getLocNo());
//                        locMast.setLocSts("S"); // S.入库预约
//                        locMast.setModiTime(new Date());
//                        if (!locMastService.updateById(locMast)){
//                            throw new CoolException("改变库位状态失败");
//                        }
//                        // 命令下发区 --------------------------------------------------------------------------
//
//                        // 更新站点信息 且 下发plc命令
//                        staProtocol.setWorkNo((short) workNo);
//                        staProtocol.setStaNo(startupDto.getStaNo().shortValue());
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                        if (!result) {
//                            throw new CoolException("更新plc站点信息失败");
//                        }
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                    }

                }


            }
        }
    }
@@ -3179,4 +3568,792 @@
            }
        }
    }

//    /**
//     * 其他  ===>> 码垛位自动补充空板：驱动拆盘机输出托盘
//     */
//    public synchronized void dischargingMachineOutputTray() {
//        try {
//            List<WrkMast> wrkMasts = wrkMastMapper.selectDischargingMachineOutputTray();
//            if (Cools.isEmpty(wrkMasts) || wrkMasts.size()>3){
//                return;
//            }
//
//            // 获取入库站信息
//            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
//            StaProtocol staProtocol = devpThread.getStation().get(213);
//            if (staProtocol == null) {
//                log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点查询失败");
//                return;
//            } else {
//                staProtocol = staProtocol.clone();
//            }
//
//            if (!staProtocol.isLoading()){
//                log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点无物，正在自动调出空板！");
//                int i = wrkMastMapper.selectConfigCount10468N();
//                if (i==1){
//                    wrkMastMapper.updateConfig10468Y();
//                }
//                return;
//            }else {
//                int i = wrkMastMapper.selectConfigCount10468N();
//                if (i==0){
//                    return;
//                }
//            }
//            StaProtocol staProtocol214 = devpThread.getStation().get(214);
//            // 判断是否满足入库条件
//            if (staProtocol.isAutoing() && staProtocol.getWorkNo() == 0 && staProtocol.isPakMk() && staProtocol214.getWorkNo()==0) {
//                staProtocol.setWorkNo((short)9999);
//                staProtocol.setStaNo((short)214);
//                devpThread.setPakMk(staProtocol.getSiteId(), false);
//                boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
//                if (!result) {
//                    throw new CoolException("更新plc站点信息失败==>码垛位自动补充空板：驱动拆盘机输出托盘！");
//                }
//                log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发成功：工作号9999、目标站214！");
//            }else {
//                log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点状态不符合！");
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//        }
//    }

//    /**
//     * 其他  ===>> 拆盘机处空板扫码，驱动托盘向码垛位，不入库
//     */
//    public synchronized void scanBarcodeEmptyBoard() {
//        try {
//
//        }catch (Exception e){
//            e.printStackTrace();
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//        }
//    }

    /**
     * 其他  ===>> 码垛完成驱动托盘进入下一步（入库前扫码）
     */
    public synchronized void stackingCompletionDriveTray() {
        try {
            int[] staNos=new int[]{216,220,123};//(3个入库站点，1楼1个退货码垛站，2楼两个入库码垛站)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp.getWrkNo()!=9992 || Cools.isEmpty(basDevp.getBarcode())){
                    continue;
                }
                Integer zpallet = waitPakinMapper.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", basDevp.getBarcode()).eq("status","N"));
                if (zpallet<=0){
                    continue;
                }
                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 入出库模式判断
//                if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
//                if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
//                    continue;
//                }

                if (!staProtocol.isLoading()){
                    log.info("{}站点无物，正在自动调出空板！",staNo);
                    continue;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk()
                        && staProtocol.getWorkNo() == 9992
                ) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

                    staProtocol.setWorkNo((short)9999);
                    staNo = staNo + 1;
                    staProtocol.setStaNo((short)staNo);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }

                }
            }
        }catch (Exception e){
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
    /**
     * 其他  ===>> 码垛完成驱动托盘进入下一步
     */
    public synchronized void stackingCompletionDriveTray2() {
        try {
            int[] staNos=new int[]{133,135};//(2个入库站点，1楼2个出库码垛站,根据现场修改)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp.getWrkNo()<9990){
                    continue;
                }
                WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne202(staNo);
                if (Cools.isEmpty(wrkMast)){
                    continue;
                }
                // 获取站点信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 入出库模式判断
//                if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
//                if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
//                    continue;
//                }

                if (!staProtocol.isLoading()){
                    log.info("{}站点无物，异常！",staNo);
                    continue;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.getWorkNo() >= 9990
                ) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }
                    wrkMast.setWrkSts(52L);
                    wrkMastMapper.updateById(wrkMast);

                }
            }
        }catch (Exception e){
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
    /**
     * 其他  ===>> 贴标完成驱动托盘进入下一步
     */
    public synchronized void stackingCompletionDriveTray3() {
        try {
            int[] staNos=new int[]{144};//(1楼1个贴标位,根据现场修改)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp.getWrkNo()<9990){
                    continue;
                }
                WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne202(staNo);
                if (Cools.isEmpty(wrkMast)){
                    continue;
                }
                // 获取站点信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 入出库模式判断
//                if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
//                if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
//                    continue;
//                }

                if (!staProtocol.isLoading()){
                    log.info("{}站点无物，异常！",staNo);
                    continue;
                }
                if (!staProtocol.getWorkNo().equals(wrkMast.getWrkNo().shortValue())){
                    log.info("站点工作号={} 与贴标工作号={} 不一致，异常！",staProtocol.getWorkNo(),wrkMast.getWrkNo().shortValue());
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                ) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }
                    wrkMast.setWrkSts(55L);
                    wrkMastMapper.updateById(wrkMast);

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

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

                // 只有当RGV等待WCS确认、自动
                if (rgvProtocol.getStatusType() == RgvStatusType.WAITING
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                ) {
                    log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
                    if (rgvProtocol.getTaskNo1()!=0){
                        if (rgvProtocol.getTaskNo1()==9999){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getType()!=1 || wrkMastSta.getWrkSts()!=1){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                    }else if (rgvProtocol.getTaskNo2()!=0){
                        if (rgvProtocol.getTaskNo2()==9999){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo2().intValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getType()!=2){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                    }else {
                        log.error("小车复位失败，小车号{},等待wcs确认但是没有工作号！",rgvProtocol.getRgvNo());
                    }
                }
            }
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }
    /**
     * 执行小车搬运任务
     */
    public synchronized void rgvRunWrkMastFullSta() {
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0
                ) {
                    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){
                        if (wrkMastSta.getType()!=1 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                            continue;
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta);
                        if (sign){
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd());
                            if (signMap){
                                wrkMastSta.setWrkSts(1);
                                try{
                                    wrkMastStaMapper.updateById(wrkMastSta);
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                            }else {
                                log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
                        }else {
                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                        }
                        break;
                    }
                }
            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
        }
    }
    /**
     * 执行小车搬运任务
     */
    public synchronized void rgvRunWrkMastEmptyStaPut() {//放
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV空闲、自动,工位二有物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded2()==1  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                    }
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);//查询可执行任务
                    for (WrkMastSta wrkMastSta : wrkMastStaList){
                        if (wrkMastSta.getType()!=2 || (wrkMastSta.getWrkType()!=2 && wrkMastSta.getWrkType()!=4)){// 2:空板  2:放 4：拆盘
                            continue;
                        }
                        boolean sign = false;
                        if (wrkMastSta.getStaStart()==0 && wrkMastSta.getStaEnd()!=0){//放
                            sign = rgvPutEmpty(rgvProtocol.getRgvNo(),wrkMastSta);
                        }else {
                            continue;
                        }
                        if (sign){
                            boolean signMap = rgvMapUpdate(basRgvMap, basRgvMap.getStartRoute(), wrkMastSta.getStaEnd());
                            if (signMap){
                                wrkMastSta.setWrkSts(2);
                                try{
                                    wrkMastStaMapper.updateById(wrkMastSta);
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                            }else {
                                log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
                        }else {
                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                        }
                        break;
                    }
                }
            }
        }catch (Exception e){
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
        }
    }

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

                // 只有当RGV空闲、自动,工位二无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded2()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                ) {
                    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){
                        if (wrkMastSta.getType()!=2 || wrkMastSta.getWrkType()!=1){// 2:空板  1:取
                            continue;
                        }
                        boolean sign = false;
                        if (wrkMastSta.getStaEnd()==0 && wrkMastSta.getStaStart()!=0){//取
                            sign = rgvTakeEmpty(rgvProtocol.getRgvNo(),wrkMastSta);
                        }else {
                            continue;
                        }
                        if (sign){
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), basRgvMap.getStartRoute());
                            if (signMap){
                                wrkMastSta.setWrkSts(1);
                                try{
                                    wrkMastStaMapper.updateById(wrkMastSta);
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                            }else {
                                log.error("3879行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
                        }else {
                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                        }
                        break;
                    }
                }
            }
        }catch (Exception e){
            log.error("3989行执行小车取空板任务下发失败");
            log.error("3989行"+e);
        }
    }

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

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

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

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

    /*
     * 小车XY移动  避让
     * */
    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1((short)9999); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.GO_ORIGIN); // 工位1任务模式:  回原点
            rgvCommand.setCommand((short) 1);   //工位1任务确认
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(9, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;

        }
    }


    /*
    * 小车取货至工位任务
    * */
    public synchronized boolean rgvTakeFullAll(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
            rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
            rgvCommand.setCommand((short) 1);   //工位1任务确认
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(4, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车取货至工位任务
     * */
    public synchronized boolean rgvTakeFull(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
            rgvCommand.setCommand((short) 1);   //工位1任务确认
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(4, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

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

    /*
     * 小车取空板至工位任务
     * */
    public synchronized boolean rgvTakeEmpty(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
            rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式:  取货
            rgvCommand.setSourceStaNo2(wrkMastSta.getStaStart().shortValue());   //工位2起点
            rgvCommand.setCommand((short) 2);   //工位2任务确认
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(5, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车放空板至输送线任务
     * */
    public synchronized boolean rgvPutEmpty(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
            rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式:  放货
            rgvCommand.setDestinationStaNo2(wrkMastSta.getStaEnd().shortValue());   //工位2目标站点
            rgvCommand.setCommand((short) 2);   //工位2任务确认
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(5, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

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

    /*
     * 小车地图更新  更新锁
     * */
    public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd){

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

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

}