#

lsh

2024-01-25 6efee0aeb0bada6e10af55e13d469ff52572fdfb

 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,6 +99,8 @@
    private WrkMastStaMapper wrkMastStaMapper;
    @Autowired
    private BasRgvMapMapper basRgvMapMapper;
    @Autowired
    private RgvOneSignMapper rgvOneSignMapper;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -385,7 +388,7 @@

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {
//                    WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo());
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep5(staProtocol.getSiteId(),"7");
                    if (wrkMast == null) {
                        // 无拣料数据
                        continue;
@@ -395,64 +398,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(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());
                    }

                }
@@ -487,19 +493,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 +504,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 +643,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;
        }
    }
    /**
     * 拣料、并板、盘点再入库  拆垛位置
     */
@@ -1285,6 +1508,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 +2241,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();
@@ -2130,6 +2364,10 @@
                        ledCommand.setTitle("盘点出库");
                        break;
                    case 110:
                        ledCommand.setTitle("空板出库");
                        ledCommand.setEmptyMk(true);
                        break;
                    case 212:
                        ledCommand.setTitle("空板出库");
                        ledCommand.setEmptyMk(true);
                        break;
@@ -2738,10 +2976,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 +3010,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 +3125,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){
@@ -3079,9 +3317,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 +3328,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));
@@ -3260,7 +3499,8 @@
    /**
     * 入出库  ===>>  小车作业下发
     */
    public synchronized void rgvIoExecute(Integer sign) {
    public synchronized boolean rgvIoExecute(Integer sign) {
        boolean rgvIoExecuteSign = false;
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                // 获取小车信息
@@ -3309,7 +3549,7 @@
                            break;
                    }
                }
                for (int signCount = 1;!signWork && signCount<8;signCount++){
                for (int signCount = 1;!signWork && signCount<7;signCount++){
                    switch (signCount){
                        case 1://执行小车货物搬运任务
                            signWork = rgvRunWrkMastFullSta();
@@ -3330,18 +3570,22 @@
//                            signWork = rgvRunWrkMastEmptyStaPut();
                            break;
                        default:
                            if (sign>6){
                                rgvRunWrkMastEmptyStaAvoidance();//避让
                                signWork = true;
                            }
                            break;
                    }
                }

                if (!rgvIoExecuteSign){
                    rgvIoExecuteSign = signWork;
                }
            }
            if (!rgvIoExecuteSign){
                if (sign>6){
                    rgvRunWrkMastEmptyStaAvoidance();//避让
                }
            }
        }catch (Exception e){
            log.error("RGV小车任务下发报错"+e);
        }
        return rgvIoExecuteSign;
    }
    /**
     * 执行小车搬运任务