*

lsh

2024-12-23 7ab864d4bd0c839c95101ce9c5c5157744810478

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

@@ -47,6 +47,7 @@
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
@@ -98,9 +99,14 @@
    private WrkMastStaMapper wrkMastStaMapper;
    @Autowired
    private BasRgvMapMapper basRgvMapMapper;
    @Autowired
    private RgvOneSignMapper rgvOneSignMapper;

    @Value("${wms.url}")
    private String wmsUrl;

    @Value("${wms.rgvOpen}")
    private boolean rgvOpen;

    /**
     * 组托
@@ -135,6 +141,47 @@
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 尺寸检测异常
                boolean back = false;
                String errMsg = "异常：";
                if (staProtocol.isFrontErr()) {
                    errMsg = errMsg+"前超限；";
                    back = true;
                }
                if (staProtocol.isBackErr()) {
                    errMsg = errMsg+"后超限";
                    back = true;
                }
                if (staProtocol.isHighErr()) {
                    errMsg = errMsg+"高超限";
                    back = true;
                }
                if (staProtocol.isLeftErr()) {
                    errMsg = errMsg+"左超限";
                    back = true;
                }
                if (staProtocol.isRightErr()) {
                    errMsg = errMsg+"右超限";
                    back = true;
                }
                if (staProtocol.isWeightErr()) {
                    errMsg = errMsg+"超重";
                    back = true;
                }
                if (staProtocol.isBarcodeErr()) {
                    errMsg = errMsg+"扫码失败";
                    back = true;
                }
                // 退回
                if (back) {
                    // led 异常显示
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    if (ledThread != null) {
                        MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errMsg));
                    }
                    continue;
                }

                // 入出库模式判断
@@ -383,8 +430,9 @@
//                // 入出库模式判断
//                if (devpThread.ioMode != IoModeType.PAKIN_MODE) { continue; }

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk() && staProtocol.getWorkNo()!=0) {
//                    WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
//                    WrkMast wrkMast = wrkMastMapper.selectPakInStep5(staProtocol.getSiteId(),"7");
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo());
                    if (wrkMast == null) {
                        // 无拣料数据
@@ -395,64 +443,67 @@
                        continue;
                    }

                    // 获取目标站
                    Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                            .eq("type_no", wrkMast.getIoType() - 50)
                            .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
                            .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
                    StaDesc staDesc = staDescService.selectOne(wrapper);
                    if (Cools.isEmpty(staDesc)) {
                        log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                        continue;
                    }

                    //   获取库位号
                    try {
                        // 保存工作明细档历史档
                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                            throw new CoolException("保存工作明细档历史档失败");
                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(wrkMast.getBarcode());
                        param.setIoType(wrkMast.getIoType());
                        param.setSourceStaNo(pickSta.getStaNo()); //作业站点
                        param.setLocType1((short)1);
                        String response = "";
                        log.info("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param);
                        try {
                            response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath("/rpc/pakin2/loc/v1")
                                    .setJson(JSON.toJSONString(param))
                                    .setTimeout(15, TimeUnit.SECONDS)
                                    .build()
                                    .doPost();
                        } catch(Exception e){
                            log.error("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param);
                            log.error("stnToCrnStnPick2===>>盘点查库位入库接口失败", e);
                            e.printStackTrace();
                            continue;
                        }
                        // 保存工作主档历史档
                        if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                            throw new CoolException("保存工作主档历史档失败");
                        log.info("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param);
                        log.info("入库作业站"+pickSta.getStaNo()+"下发盘点再入库任务请求WMS返回结果===>>" + response);
                        if(response.equals("")) {
                            continue;
                        }

                        Date now = new Date();
                        // 堆垛机站点(目标站)
                        Integer staNo = staDesc.getCrnStn();
                        // 更新工作档数据状态
                        wrkMast.setIoTime(now);
                        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                        wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
                        wrkMast.setStaNo(staNo); // 目标站
                        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
                        wrkMast.setSourceLocNo(""); // 源库位清空
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            throw new CoolException("更新工作档数据状态失败");
                        }
                        // 更新明细档io_time (历史档关联使用）
                        wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);
                        // 修改库位状态 Q.拣料/盘点/并板再入库
                        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                        locMast.setLocSts("Q");
                        locMast.setModiTime(new Date());
                        if (!locMastService.updateById(locMast)) {
                            throw new CoolException("修改库位状态失败");
                        JSONObject jsonObject = JSON.parseObject(response);
//                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
                        Integer code = jsonObject.getInteger("code");
                        if (code == 200) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            if (Cools.isEmpty(dto) || Cools.isEmpty(dto.getStaNo())) {
                                log.error("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位失败===>>" + jsonObject.toJSONString());
                            } else {
                                log.info("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位成功===>>" + jsonObject.toJSONString());
                                try {
                                    // 更新站点信息 且 下发plc命令
                                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                                    staProtocol.setStaNo(dto.getStaNo());
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);
//                                    ledThread.errorReset();
                                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(5, staProtocol));
                                    if (!result) {
                                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                                    }
                                    log.info("任务号"+wrkMast.getWrkNo()+"盘点/拣料再入库任务下发成功===>>" + staProtocol);
                                } catch (Exception e) {
                                    log.error("盘点再入库失败===>>" + e);
                                    e.printStackTrace();
                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                }
                            }
                        } else {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin2/loc/v1", JSON.toJSONString(param), response);
                        }
                    } catch (Exception e) {
                        log.error("stnToCrnStnPick2===>>fail", e);
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        continue;
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo(wrkMast.getStaNo());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

                }
@@ -487,19 +538,6 @@
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep4(staProtocol.getSiteId(),"3");

                    if (wrkMast == null) {
//                        WrkMast wrkMast1 = wrkMastMapper.selectPakInStep5(staProtocol.getSiteId(),"3");
//                        if (Cools.isEmpty(wrkMast1) && staProtocol.isEmptyMk()){
//                            WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(staProtocol.getSiteId() + 9999L);
//                            if (Cools.isEmpty(wrkMastSta)){
//                                WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),staProtocol.getSiteId());
//                                wrkMastSta1.setType(2);
//                                wrkMastSta1.setWrkType(1);
//                                wrkMastStaMapper.insert(wrkMastSta1);
//                            }
//                            continue;
//                        }
//                        log.error("站点号"+staProtocol.getSiteId()+"未查询到工作档案！");
                        // 无拣料数据
                        continue;
                    }
                    if (staProtocol.isEmptyMk()){
@@ -511,65 +549,137 @@
                        continue;
                    }

                    // 获取目标站
                    Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                            .eq("type_no", wrkMast.getIoType() - 50)
                            .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
                            .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
                    StaDesc staDesc = staDescService.selectOne(wrapper);
                    if (Cools.isEmpty(staDesc)) {
                        log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                    String barcode = wrkMast.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            continue;
                        }
                    } else {
                        continue;
                    }

                    //   获取库位号
                    try {
                        // 保存工作明细档历史档
                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                            throw new CoolException("保存工作明细档历史档失败");
                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(barcode);
                        param.setIoType(wrkMast.getIoType());
                        param.setSourceStaNo(pickSta.getStaNo()); //作业站点
                        param.setLocType1((short)1);
                        String response = "";
                        log.info("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param);
                        try {
                            response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath("/rpc/pakin2/loc/v1")
                                    .setJson(JSON.toJSONString(param))
                                    .setTimeout(15, TimeUnit.SECONDS)
                                    .build()
                                    .doPost();
                        } catch(Exception e){
                            log.error("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param);
                            log.error("stnToCrnStnPick2===>>盘点查库位入库接口失败", e);
                            e.printStackTrace();
                            continue;
                        }
                        // 保存工作主档历史档
                        if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                            throw new CoolException("保存工作主档历史档失败");
                        log.info("入库作业站"+pickSta.getStaNo()+"盘点再入库任务请求WMS===>>参数：" + param);
                        log.info("入库作业站"+pickSta.getStaNo()+"下发盘点再入库任务请求WMS返回结果===>>" + response);
                        if(response.equals("")) {
                            continue;
                        }

                        Date now = new Date();
                        // 堆垛机站点(目标站)
                        Integer staNo = staDesc.getCrnStn();
                        // 更新工作档数据状态
                        wrkMast.setIoTime(now);
                        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                        wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
                        wrkMast.setStaNo(staNo); // 目标站
                        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
                        wrkMast.setSourceLocNo(""); // 源库位清空
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            throw new CoolException("更新工作档数据状态失败");
                        }
                        // 更新明细档io_time (历史档关联使用）
                        wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);
                        // 修改库位状态 Q.拣料/盘点/并板再入库
                        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                        locMast.setLocSts("Q");
                        locMast.setModiTime(new Date());
                        if (!locMastService.updateById(locMast)) {
                            throw new CoolException("修改库位状态失败");
                        JSONObject jsonObject = JSON.parseObject(response);
//                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
                        Integer code = jsonObject.getInteger("code");
                        if (code == 200) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            if (Cools.isEmpty(dto) || Cools.isEmpty(dto.getStaNo())) {
                                log.error("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位失败===>>" + jsonObject.toJSONString());
                            } else {
                                log.info("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位成功===>>" + jsonObject.toJSONString());
                                try {
                                    // 更新站点信息 且 下发plc命令
                                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                                    staProtocol.setStaNo(dto.getStaNo());
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);
//                                    ledThread.errorReset();
                                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    if (!result) {
                                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                                    }
                                    log.info("任务号"+wrkMast.getWrkNo()+"盘点/拣料再入库任务下发成功===>>" + staProtocol);
                                } catch (Exception e) {
                                    log.error("盘点再入库失败===>>" + e);
                                    e.printStackTrace();
                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                }
                            }
                        } else {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin2/loc/v1", JSON.toJSONString(param), response);
                        }
                    } catch (Exception e) {
                        log.error("stnToCrnStnPick2===>>fail", e);
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        continue;
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo(wrkMast.getStaNo());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }
//                    // 获取目标站
//                    Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
//                            .eq("type_no", wrkMast.getIoType() - 50)
//                            .eq("stn_no", pickSta.getStaNo()) // 作业站点 = 拣料出库的目标站
//                            .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
//                    StaDesc staDesc = staDescService.selectOne(wrapper);
//                    if (Cools.isEmpty(staDesc)) {
//                        log.error("入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
//                        continue;
//                    }
//
//                    try {
//                        // 保存工作明细档历史档
//                        if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
//                            throw new CoolException("保存工作明细档历史档失败");
//                        }
//                        // 保存工作主档历史档
//                        if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
//                            throw new CoolException("保存工作主档历史档失败");
//                        }
//
//                        Date now = new Date();
//                        // 堆垛机站点(目标站)
//                        Integer staNo = staDesc.getCrnStn();
//                        // 更新工作档数据状态
//                        wrkMast.setIoTime(now);
//                        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
//                        wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
//                        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
//                        wrkMast.setStaNo(staNo); // 目标站
//                        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
//                        wrkMast.setSourceLocNo(""); // 源库位清空
//                        wrkMast.setModiTime(now);
//                        if (wrkMastMapper.updateById(wrkMast) == 0) {
//                            throw new CoolException("更新工作档数据状态失败");
//                        }
//                        // 更新明细档io_time (历史档关联使用）
//                        wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);
//                        // 修改库位状态 Q.拣料/盘点/并板再入库
//                        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
//                        locMast.setLocSts("Q");
//                        locMast.setModiTime(new Date());
//                        if (!locMastService.updateById(locMast)) {
//                            throw new CoolException("修改库位状态失败");
//                        }
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                        continue;
//                    }
//
//                    // 更新站点信息 且 下发plc命令
//                    staProtocol.setWorkNo(wrkMast.getWrkNo());
//                    staProtocol.setStaNo(wrkMast.getStaNo());
//                    devpThread.setPakMk(staProtocol.getSiteId(), false);
//                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                    if (!result) {
//                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
//                    }

                }

@@ -578,6 +688,164 @@
        }
    }

    /**
     * 2楼212呼叫空板
     */
    public synchronized void stnToCrnStnPick3Auto(Integer sign) {
        try{
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 2);
            StaProtocol staProtocol = devpThread.getStation().get(212);
            if (staProtocol == null) {
                return;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.getWorkNo()==0 ){
                switch (sign){
                    //执行小车货物搬运任务
                    case 1:
                    case 4:
                        stnToCrnStnPick3();
                        return;
                    //执行小车空板搬运任务
                    case 2://放//拆盘
                    case 5://放//拆盘
                        stnToCrnStnPick4();
                        return;
                    default:
                        return;
                }
            } else if (staProtocol.isAutoing() && staProtocol.isLoading()){
                switch (sign){
                    case 3://满放
                    case 6://满放
                        stnToCrnStnPick5();
                        return;
                    default:
                        return;
                }
            }
        }catch (Exception e){
            log.error("2楼212呼叫空板"+e);
        }
    }
    /**
     * 2楼212呼叫空板
     */
    public synchronized void stnToCrnStnPick3() {
        WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne212();
        if (Cools.isEmpty(wrkMast) || wrkMast.getWrkSts()!=61){//61、等待空板
            return;
        }
        for (DevpSlave devp : slaveProperties.getDevp()) {
            for (DevpSlave.Sta driveSta : devp.getDriveSta()) {
                if (driveSta.getStaNo()!=215){
                    continue;
                }
                // 获取拣料入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(driveSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo()==0
                        || (staProtocol.getWorkNo()>9899 && staProtocol.getWorkNo()<10000)) ){
                    boolean result1 = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));

                    staProtocol.setWorkNo(wrkMast.getWrkNo()-1);
                    staProtocol.setStaNo(driveSta.getStaNo()==215? 217:221);
                    boolean result2 = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result2) {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }
                    wrkMast.setWrkSts(62L);
                    wrkMastMapper.updateById(wrkMast);

                    boolean result3 = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
                    return;
                }
            }
        }
    }

    /**
     * 2楼212呼叫空板
     */
    public synchronized void stnToCrnStnPick4() {
        WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne212();
        if (Cools.isEmpty(wrkMast) || wrkMast.getWrkSts()!=62){//62、等待小车搬运
            return;
        }
        for (DevpSlave devp : slaveProperties.getDevp()) {
            for (DevpSlave.Sta driveSta : devp.getInSta()) {
                if (driveSta.getStaNo()!=217){
                    continue;
                }
                // 获取拣料入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(driveSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                StaProtocol staProtocol212 = devpThread.getStation().get(212);
                if (staProtocol212 == null) {
                    continue;
                } else {
                    staProtocol212 = staProtocol212.clone();
                }
                if (staProtocol212.isAutoing() && !staProtocol212.isLoading() && staProtocol212.getWorkNo()==0){
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo()==0
                            || (staProtocol.getWorkNo()>9899 && staProtocol.getWorkNo()<10000) || staProtocol.getWorkNo()==wrkMast.getWrkNo()-1) ){
//                        boolean result1 = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));

                        staProtocol.setWorkNo(wrkMast.getWrkNo());
                        staProtocol.setStaNo(212);
                        boolean result2 = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        if (!result2) {
                            log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        }
                        wrkMast.setWrkSts(63L);
                        wrkMastMapper.updateById(wrkMast);

//                        boolean result3 = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4, staProtocol));
                        return;
                    }
                }
            }
        }
    }

    /**
     * 2楼212呼叫空板
     */
    public synchronized void stnToCrnStnPick5() {
        WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne212();
        if (Cools.isEmpty(wrkMast) || wrkMast.getWrkSts()!=63){//63、等待完成
            return;
        }

        // 获取拣料入库站信息
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 2);
        StaProtocol staProtocol = devpThread.getStation().get(212);
        if (staProtocol == null) {
            return;
        } else {
            staProtocol = staProtocol.clone();
        }
        if (staProtocol.isAutoing() && staProtocol.isLoading()){
//            boolean result1 = MessageQueue.offer(SlaveType.Devp, 2, new Task(3, staProtocol));

            wrkMast.setWrkSts(64L);
            wrkMastMapper.updateById(wrkMast);

//            boolean result3 = MessageQueue.offer(SlaveType.Devp, 2, new Task(4, staProtocol));
            return;
        }
    }
    /**
     * 拣料、并板、盘点再入库  拆垛位置
     */
@@ -1027,7 +1295,7 @@
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y") && staDetl.getWrkNo().equals(wrkMast.getWrkNo())) {
                flag = true;
            }
            if (!flag) {
@@ -1285,6 +1553,13 @@
            if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null) {
                log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                continue;
            }
            //退库模式跳过118、119出库任务
            if (wrkMast.getStaNo()==118 || wrkMast.getStaNo()==119){
                RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign();
                if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()==1){
                    continue;
                }
            }
            // 获取源库位信息
            LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
@@ -2011,6 +2286,10 @@
     */
    public synchronized void storeEmptyPlt3() {
        try{
            RgvOneSign rgvOneSign = rgvOneSignMapper.selectOneSign();
            if (Cools.isEmpty(rgvOneSign) || rgvOneSign.getRgvOneSign()==1){
                return;
            }
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
@@ -2029,7 +2308,8 @@
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                        &&  (rgvProtocol.getLoaded2()==2  || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
//                        &&  (rgvProtocol.getLoaded2()==2  || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
                        &&  rgvProtocol.getLoaded2()==3 ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
                ) {
                    try {
                        WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep3(122);
@@ -2042,6 +2322,7 @@
                        param.setIoType(10);
                        param.setSourceStaNo(122);
                        param.setLocType1((short)1);
                        param.setRgvNo(rgvProtocol.getRgvNo());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/empty/loc/v1")
@@ -2087,7 +2368,8 @@
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
            // 命令集合
            List<LedCommand> commands = new ArrayList<>();
            // 工作档集合
            String orderNo = null;
                    // 工作档集合
            List<WrkMast> wrkMasts = new ArrayList<>();
            for (Integer staNo : led.getStaArr()) {
                // 获取叉车站点
@@ -2133,6 +2415,10 @@
                        ledCommand.setTitle("空板出库");
                        ledCommand.setEmptyMk(true);
                        break;
                    case 212:
                        ledCommand.setTitle("空板出库");
                        ledCommand.setEmptyMk(true);
                        break;
                    default:
                        log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        break;
@@ -2143,7 +2429,13 @@
//                ledCommand.setSourceStaNo(wrkMast.getSourceStaNo());
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl)));
                    if (Cools.isEmpty(wrkDetls)){
                        continue;
                    }
                    Integer count1 = wrkDetlService.count1();
                    Integer count2 = wrkDetlService.count2(wrkDetls.get(0).getOrderNo());
                    Integer count3 = wrkDetlService.count3();
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl,count1,count2,count3)));
                }
                commands.add(ledCommand);
            }
@@ -2738,10 +3030,10 @@
     */
    public synchronized void stackingCompletionDriveTray() {
        try {
            int[] staNos=new int[]{216,220,123};//(3个入库站点，1楼1个退货码垛站，2楼两个入库码垛站)
            int[] staNos=new int[]{215,219};//(2楼两个入库码垛站)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp.getWrkNo()!=9992 || Cools.isEmpty(basDevp.getBarcode())){
                if ((basDevp.getWrkNo()!=0 && (basDevp.getWrkNo()<9900 || basDevp.getWrkNo()>9999)) || Cools.isEmpty(basDevp.getBarcode())){
                    continue;
                }
                Integer zpallet = waitPakinMapper.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", basDevp.getBarcode()).eq("status","N"));
@@ -2772,11 +3064,11 @@
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk()
                        && staProtocol.getWorkNo() == 9992
                        && (basDevp.getWrkNo()==0 || (basDevp.getWrkNo()>=9900 && basDevp.getWrkNo()<=9999))
                ) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

                    staProtocol.setWorkNo(9999);
                    staProtocol.setStaNo(staNo + 1);
                    int workNo = commonService.getWorkNo(5);
                    staProtocol.setWorkNo(workNo);
                    staProtocol.setStaNo(staNo + 2);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                    if (!result) {
@@ -2887,7 +3179,7 @@
                        // 无拣料数据
                        continue;
                    }
                    if (!wrkMast.getSheetNo().equals("2") || wrkMast.getIoType()<100 || wrkMast.getWrkSts()!=14){
                    if (Cools.isEmpty(wrkMast.getSheetNo()) || !wrkMast.getSheetNo().equals("2") || wrkMast.getIoType()<100 || wrkMast.getWrkSts()!=14){
                        continue;
                    }
                    if (wrkMast.getIoType()==101){
@@ -3003,8 +3295,20 @@
                    staProtocol = staProtocol.clone();
                }

                StaProtocol staProtocol147 = devpThread.getStation().get(147);
                if (staProtocol147 == null) {
                    continue;
                } else {
                    staProtocol147 = staProtocol147.clone();
                }

                if (!staProtocol.isLoading()){
                    log.info("{}站点无物，异常！",staNo);
                    continue;
                }

                if (staProtocol147.isLoading()){
                    log.info("{}站点有物！",staProtocol147.getSiteId());
                    continue;
                }
                // 判断是否满足入库条件
@@ -3012,6 +3316,9 @@
                        && staProtocol.isLoading()
                        && !staProtocol.isEmptyMk()
                ) {

                    boolean result3 = MessageQueue.offer(SlaveType.Devp, 1, new Task(3, staProtocol147));

                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo(wrkMast.getStaNo());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
@@ -3019,8 +3326,12 @@
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }

                    wrkMast.setSheetNo("5");
                    wrkMastMapper.updateById(wrkMast);

                    boolean result4 = MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol147));

                }
            }
        }catch (Exception e){
@@ -3043,6 +3354,14 @@
                    continue;
                }
                if (basDevp135.getReportSign()!=0){
                    continue;
                }
                BasDevp basDevp121 = basDevpService.selectById(121);
                if (basDevp121.getReportSign()!=0){
                    continue;
                }
                BasDevp basDevp120 = basDevpService.selectById(120);
                if (basDevp120.getReportSign()!=0){
                    continue;
                }
                WrkMast wrkMast131 = wrkMastMapper.selectWrkMastUnstackingOne202Two(131);
@@ -3071,6 +3390,26 @@
                if (!staProtocol.isLoading()){
                    continue;
                }
                StaProtocol staProtocol120 = devpThread.getStation().get(120);
                if (staProtocol120 == null) {
                    continue;
                } else {
                    staProtocol120 = staProtocol120.clone();
                }

                if (staProtocol120.isLoading()){
                    continue;
                }
                StaProtocol staProtocol121 = devpThread.getStation().get(121);
                if (staProtocol121 == null) {
                    continue;
                } else {
                    staProtocol121 = staProtocol121.clone();
                }

                if (staProtocol121.isLoading()){
                    continue;
                }
//                if (!staProtocol.getWorkNo().equals(wrkMast131.getWrkNo())){
//                    log.info("站点工作号={} 与贴标工作号={} 不一致，异常！",staProtocol.getWorkNo(),wrkMast131.getWrkNo().shortValue());
//                }
@@ -3079,9 +3418,9 @@
                        && staProtocol.isLoading()
                        && basDevp.getReportSign()==0
                ) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {
                    if (true){
                        return;
                    }
//                    if (true){
//                        return;
//                    }

                    //任务完成
                    boolean result1 = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(3, staProtocol135));
@@ -3090,7 +3429,8 @@
                    }catch (Exception e){ }
                    basDevp135.setReportSign(2);
                    basDevpService.updateById(basDevp135);
                    staProtocol135.setWorkNo(32222);
                    int workNo = commonService.getWorkNo(5);
                    staProtocol135.setWorkNo(workNo);
                    staProtocol135.setStaNo(144);
                    devpThread.setPakMk(staProtocol135.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol135));
@@ -3149,10 +3489,15 @@
                            continue;
                        }
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                        if (!Cools.isEmpty(wrkMast) && wrkMastSta.getWrkType()!=5){
                            Thread.sleep(200);
                            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                            StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                            if (staProtocol == null) {
                                continue;
                            } else {
                                staProtocol = staProtocol.clone();
                            }
                            if (!staProtocol.isAutoing() || !staProtocol.isLoading()){
                                continue;
                            }
@@ -3207,7 +3552,7 @@
                            continue;
                        }
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                        if (!Cools.isEmpty(wrkMast)  && wrkMastSta.getWrkType()!=5){
                            Thread.sleep(200);
                            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                            StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
@@ -3260,7 +3605,8 @@
    /**
     * 入出库  ===>>  小车作业下发
     */
    public synchronized void rgvIoExecute(Integer sign) {
    public synchronized boolean rgvIoExecute(Integer sign) {
        boolean rgvIoExecuteSign = false;
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                // 获取小车信息
@@ -3287,20 +3633,20 @@
                    switch (sign){
                        //执行小车货物搬运任务
                        case 1:
                            signWork = rgvRunWrkMastFullSta();
                            signWork = rgvRunWrkMastFullSta(rgvSlave);
                            break;
                        //执行小车空板搬运任务
                        case 2://放//拆盘
                            signWork = rgvRunWrkMastEmptyStaPut();
                            signWork = rgvRunWrkMastEmptyStaPut(rgvSlave);
                            break;
                        case 3://满放
                            signWork = rgvRunWrkMastEmptyStaPutFull();
                            signWork = rgvRunWrkMastEmptyStaPutFull(rgvSlave);
                            break;
                        case 4://取叠盘
                            signWork = rgvRunWrkMastEmptyStaTake();
                            signWork = rgvRunWrkMastEmptyStaTake(rgvSlave);
                            break;
                        case 5:////满取
                            signWork = rgvRunWrkMastEmptyStaTakeFull();
                            signWork = rgvRunWrkMastEmptyStaTakeFull(rgvSlave);
                            break;
                        case 6:////提升
//                            signWork = qwe();
@@ -3308,56 +3654,62 @@
                        default:
                            break;
                    }
                }
                for (int signCount = 1;!signWork && signCount<8;signCount++){
                    switch (signCount){
                        case 1://执行小车货物搬运任务
                            signWork = rgvRunWrkMastFullSta();
                            break;
                        case 2://放//拆盘
                            signWork = rgvRunWrkMastEmptyStaPut();
                            break;
                        case 3://满放
                            signWork = rgvRunWrkMastEmptyStaPutFull();
                            break;
                        case 4://取叠盘
                            signWork = rgvRunWrkMastEmptyStaTake();
                            break;
                        case 5:////满取
                            signWork = rgvRunWrkMastEmptyStaTakeFull();
                            break;
                        case 6:////提升
                    for (int signCount = 1;!signWork && signCount<7;signCount++){
                        switch (signCount){
                            case 1://执行小车货物搬运任务
                                signWork = rgvRunWrkMastFullSta(rgvSlave);
                                break;
                            case 2://放//拆盘
                                signWork = rgvRunWrkMastEmptyStaPut(rgvSlave);
                                break;
                            case 3://满放
                                signWork = rgvRunWrkMastEmptyStaPutFull(rgvSlave);
                                break;
                            case 4://取叠盘
                                signWork = rgvRunWrkMastEmptyStaTake(rgvSlave);
                                break;
                            case 5:////满取
                                signWork = rgvRunWrkMastEmptyStaTakeFull(rgvSlave);
                                break;
                            case 6:////提升
//                            signWork = rgvRunWrkMastEmptyStaPut();
                            break;
                        default:
                            if (sign>6){
                                rgvRunWrkMastEmptyStaAvoidance();//避让
                                signWork = true;
                            }
                            break;
                                break;
                            default:
                                break;
                        }
                    }
                }else {
                    continue;
                }

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

                // 只有当RGV空闲、自动,工位一无物//rgv可用
@@ -3371,7 +3723,7 @@
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(basRgv.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                        return false;
                    }
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
@@ -3381,9 +3733,56 @@
                            continue;
                        }
                        BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                        if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y")){
                        if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y") || basDevp.getWrkNo()!=0){
                            continue;
                        }
                        if (basDevp.getDevNo()>117 && basDevp.getDevNo()<124){
                            if (basDevp.getLoadingSuper().equals("Y")){
                                continue;
                            }
                        }
                        if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                            if (!basDevp.getEmptyMk().equals("Y")){
                                continue;
                            }
                        }
                        Date date = new Date();

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


                        log.info(date+"取放任务下发：小车工作档："+wrkMastSta);
                        log.info(date+"取放任务下发：目标站状态："+basDevp);
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta);
                        if (sign){
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd());
@@ -3404,7 +3803,7 @@
                        break;
                    }
                }
            }
//            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
@@ -3414,18 +3813,18 @@
    /**
     * 执行小车搬运任务//拆盘
     */
    public synchronized boolean rgvRunWrkMastEmptyStaPut() {//拆盘
    public synchronized boolean rgvRunWrkMastEmptyStaPut(RgvSlave rgvSlave) {//拆盘
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                    return false;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                    return false;
                }

                // 只有当RGV空闲、自动,工位二有物//rgv可用//拆盘
@@ -3439,7 +3838,7 @@
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                        return false;
                    }
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
@@ -3451,9 +3850,43 @@
                        boolean sign = false;
                        if ( wrkMastSta.getStaEnd()!=0){//放
                            BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                            if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y")){
                            if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y") || basDevp.getWrkNo()!=0){
                                continue;
                            }
                            if (basDevp.getDevNo()>117 && basDevp.getDevNo()<124){
                                if (basDevp.getLoadingSuper().equals("Y")){
                                    continue;
                                }
                            }
                            if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                                if (!basDevp.getEmptyMk().equals("Y")){
                                    continue;
                                }
                            }
                            Date date = new Date();

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

                            log.info(date+"拆盘任务下发：小车工作档："+wrkMastSta);
                            log.info(date+"拆盘任务下发：目标站状态："+basDevp);
                            sign = rgvPutEmpty(rgvProtocol.getRgvNo(),wrkMastSta);//拆盘
                        }else {
                            continue;
@@ -3477,7 +3910,7 @@
                        break;
                    }
                }
            }
//            }
        }catch (Exception e){
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
@@ -3488,18 +3921,18 @@
    /**
     * 执行小车搬运任务
     */
    public synchronized boolean rgvRunWrkMastEmptyStaPutFull() {//满放
    public synchronized boolean rgvRunWrkMastEmptyStaPutFull(RgvSlave rgvSlave) {//满放
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                    return false;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                    return false;
                }

                // 只有当RGV空闲、自动,工位二有物//rgv可用
@@ -3513,7 +3946,7 @@
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                        return false;
                    }
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
@@ -3525,9 +3958,43 @@
                        boolean sign = false;
                        if ( wrkMastSta.getStaEnd()!=0){//满放
                            BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                            if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y")){
                            if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y") || basDevp.getWrkNo()!=0){
                                continue;
                            }
                            if (basDevp.getDevNo()>117 && basDevp.getDevNo()<124){
                                if (basDevp.getLoadingSuper().equals("Y")){
                                    continue;
                                }
                            }
                            if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                                if (!basDevp.getEmptyMk().equals("Y")){
                                    continue;
                                }
                            }
                            Date date = new Date();

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

                            log.info(date+"满放任务下发：小车工作档："+wrkMastSta);
                            log.info(date+"满放任务下发：目标站状态："+basDevp);
                            sign = rgvPutEmptyFull(rgvProtocol.getRgvNo(),wrkMastSta);
                        }else {
                            continue;
@@ -3551,7 +4018,7 @@
                        break;
                    }
                }
            }
//            }
        }catch (Exception e){
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
@@ -3559,18 +4026,18 @@
        return false;
    }

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

                // 只有当RGV空闲、自动,工位二无物//rgv可用
@@ -3584,7 +4051,7 @@
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                        return false;
                    }
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
@@ -3599,6 +4066,30 @@
                            if (!basDevp.getAutoing().equals("Y") || !basDevp.getLoading().equals("Y")){
                                continue;
                            }
                            if (basDevp.getDevNo()>=118 && basDevp.getDevNo()<=123){
                                if (!basDevp.getEmptyMk().equals("Y")){
                                    continue;
                                }
                            }
                            Date date = new Date();

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

                            log.info(date+"叠盘任务下发：小车工作档："+wrkMastSta);
                            log.info(date+"叠盘任务下发：目标站状态："+basDevp);
                            sign = rgvTakeEmpty(rgvProtocol.getRgvNo(),wrkMastSta);//叠盘
                        }else {
                            continue;
@@ -3622,7 +4113,7 @@
                        break;
                    }
                }
            }
//            }
        }catch (Exception e){
            log.error("3989行执行小车取空板任务下发失败");
            log.error("3989行"+e);
@@ -3630,18 +4121,18 @@
        return false;
    }

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

                // 只有当RGV空闲、自动,工位二无物//rgv可用
@@ -3655,11 +4146,18 @@
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                        return false;
                    }
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                    WrkMast wrkMast = wrkMastMapper.selectBy122ManQu(122,110,15L);
                    if (!Cools.isEmpty(wrkMast)){
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(wrkMast.getWrkNo().longValue());
                        if (!Cools.isEmpty(wrkMastSta) && wrkMastSta.getType()==2 && wrkMastSta.getWrkType()==5 ){
                            wrkMastStaList.add(wrkMastSta);
                        }
                    }
                    for (WrkMastSta wrkMastSta : wrkMastStaList){
                        if (wrkMastSta.getType()!=2 || wrkMastSta.getWrkType()!=5){// 2:空板  || 工作类型  1:取（叠盘）  2：拆盘  5：满取  6：满放
                            continue;
@@ -3670,6 +4168,20 @@
                            if (!basDevp.getAutoing().equals("Y") || !basDevp.getLoading().equals("Y")){
                                continue;
                            }
                            Date date = new Date();

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

                            log.info(date+"满取任务下发：小车工作档："+wrkMastSta);
                            log.info(date+"满取任务下发：目标站状态："+basDevp);
                            sign = rgvTakeEmptyFull(rgvProtocol.getRgvNo(),wrkMastSta);
                        }else {
                            continue;
@@ -3693,7 +4205,7 @@
                        break;
                    }
                }
            }
//            }
        }catch (Exception e){
            log.error("3989行执行小车取空板任务下发失败");
            log.error("3989行"+e);
@@ -3706,10 +4218,17 @@
    * */
    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
        try{
            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
            if (integer==0){
//            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
//            if (integer==0){
//                return;
//            }
            WrkMastSta wrkMastSta = wrkMastStaMapper.selectAllWrkStsCountWrkMastSta(null, 0);
            if (Cools.isEmpty(wrkMastSta)){
                return;
            }
            boolean signRgv = true;
            boolean signRgv1 = true;
            boolean signRgv2 = true;
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
@@ -3731,17 +4250,63 @@
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                ) {

                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//                    Integer fallMerge = RouteUtils.RouteIndexFarMas(basRgvMap.getRgvNo(), basRgvMap.getEndRoute()); //获取合并干涉项
//                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(),fallMerge);
//                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route ,route);
//                    if (!wrkMastStaList.isEmpty()){
//                        log.info("小车存在可执行任务，跳过避让！！4214");
//                        return;
//                    }
                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
                        continue;
//                    if (!RouteUtils.RgvRunStaSign(rgvProtocol.getRgvPosI(),RouteUtils.RouteIndexFarMas(rgvProtocol.getRgvNo(),rgvRunSta[rgvProtocol.getRgvNo()-1]),rgvProtocol.getRgvNo())){
//                    if (!RouteUtils.RgvRunStaSign(rgvProtocol.getRgvPosI(),rgvRunSta[rgvProtocol.getRgvNo()-1],rgvProtocol.getRgvNo())){
                        if (rgvProtocol.getRgvNo()==1){
                            signRgv1 = false;
                        }else {
                            signRgv2 = false;
                        }
                    }
                    if (rgvProtocol.getRgvNo()==1 && (rgvProtocol.getRgvPosI().equals(101) || rgvProtocol.getRgvPosI().equals(102) )){
                        signRgv1 = false;
                        continue;
                    } else if (rgvProtocol.getRgvNo()==2 && (rgvProtocol.getRgvPosI().equals(116) || rgvProtocol.getRgvPosI().equals(117) ) ){
                        signRgv2 = false;
                        continue;
                    }
                    rgvAvoidanceXY(rgvProtocol.getRgvNo());
                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                }else {
                    signRgv = false;
                    break;
                }
            }
            if (signRgv &&  (signRgv1 || signRgv2)){
                for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                    RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                    RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                    if (rgvProtocol == null) {
                        continue;
                    }

                    // 只有当RGV空闲、自动,工位一无物//rgv可用
                    if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                            && rgvProtocol.getModeType() == RgvModeType.AUTO
                            && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                            && rgvProtocol.getTaskNo1()==0
                            && rgvProtocol.getTaskNo2()==0
                            && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                            && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                    ) {
                        if (rgvProtocol.getRgvNo()==1 && (rgvProtocol.getRgvPosI().equals(101) || rgvProtocol.getRgvPosI().equals(102) )){
                            continue;
                        } else if (rgvProtocol.getRgvNo()==2 && (rgvProtocol.getRgvPosI().equals(116) || rgvProtocol.getRgvPosI().equals(117) ) ){
                            continue;
                        }
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        rgvAvoidanceXY(rgvProtocol.getRgvNo());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());

                    }
                }
            }
        }catch (Exception e){
@@ -4038,11 +4603,15 @@
     * 小车地图更新  更新锁
     * */
    public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd){
        if (rgvOpen){
            return true;
        }

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