#

lsh

2024-01-26 3f81b75ec0922df70b8aee69bb6e84468453a1ff

 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;

/**
@@ -137,6 +138,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;
                }

                // 入出库模式判断
@@ -387,7 +429,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;
@@ -397,64 +439,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());
                    }

                }
@@ -489,19 +534,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()){
@@ -513,65 +545,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());
//                    }

                }

@@ -2200,7 +2304,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);
@@ -2913,10 +3018,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"));
@@ -2947,11 +3052,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) {
@@ -3178,8 +3283,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;
                }
                // 判断是否满足入库条件
@@ -3187,6 +3304,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);
@@ -3194,8 +3314,12 @@
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }

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

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

                }
            }
        }catch (Exception e){
@@ -3265,7 +3389,7 @@
                    }catch (Exception e){ }
                    basDevp135.setReportSign(2);
                    basDevpService.updateById(basDevp135);
                    int workNo = commonService.getWorkNo(7);
                    int workNo = commonService.getWorkNo(5);
                    staProtocol135.setWorkNo(workNo);
                    staProtocol135.setStaNo(144);
                    devpThread.setPakMk(staProtocol135.getSiteId(), false);
@@ -3325,7 +3449,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());
@@ -3383,7 +3507,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());
@@ -3485,40 +3609,40 @@
                        default:
                            break;
                    }
                }
                for (int signCount = 1;!signWork && signCount<7;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();
                                break;
                            case 2://放//拆盘
                                signWork = rgvRunWrkMastEmptyStaPut();
                                break;
                            case 3://满放
                                signWork = rgvRunWrkMastEmptyStaPutFull();
                                break;
                            case 4://取叠盘
                                signWork = rgvRunWrkMastEmptyStaTake();
                                break;
                            case 5:////满取
                                signWork = rgvRunWrkMastEmptyStaTakeFull();
                                break;
                            case 6:////提升
//                            signWork = rgvRunWrkMastEmptyStaPut();
                            break;
                        default:
                            break;
                                break;
                            default:
                                break;
                        }
                    }
                }
                if (!rgvIoExecuteSign){
                    rgvIoExecuteSign = signWork;
                }
            }
            if (!rgvIoExecuteSign){
                if (sign>6){
                    rgvRunWrkMastEmptyStaAvoidance();//避让
                }
            }
//            if (!rgvIoExecuteSign){
//                if (sign>6){
//
//                }
//            }
        }catch (Exception e){
            log.error("RGV小车任务下发报错"+e);
        }