#堆垛机下发命令增加库位类型

zjj

2024-01-22 7a806791fba46b27f4a8af6809c270f92be5f11c

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

@@ -92,26 +92,27 @@
    private BasRgvService basRgvService;
    @Autowired
    private BasRgvMapMapper basRgvMapMapper;
    @Autowired
    private WrkMastService wrkMastService;

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

    public Integer wrkNo = 10000;

    /**
     * 组托
     * 入库站，根据条码扫描生成入库工作档，工作状态 2
     */
    public synchronized void generateStoreWrkFile(Integer mark) {
        String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                if (barcodeThread == null) {
                    continue;
                }

                // 获取入库站信息
                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                if (staProtocol == null) {
@@ -120,102 +121,87 @@
                    staProtocol = staProtocol.clone();
                }

                //LED
                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                // 入出库模式判断
//                if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) { continue; }
//                if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
//                    continue;
//                }

                // 判断是否满足入库条件
                if (!staProtocol.isLoading()){
                if (barcodeThread == null) {
                    continue;
                }
                String barcode11 = barcodeThread.getBarcode();
                if (Cools.isEmpty(barcode11)){
                    if (staProtocol.isAutoing()&& !staProtocol.isEmptyMk() && staProtocol.getWorkNo() == 9999 && staProtocol.isPakMk() && staProtocol.getStamp()==2){
                        staProtocol.setStamp(3);
                        News.info(""+mark+" - 7"+" - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode11, inSta.getStaNo());
                        staProtocol.setWorkNo(9989);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                        }
                        continue;
                    }
                String barcode = barcodeThread.getBarcode();
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "";
                if (staProtocol.isFrontErr()) {
                    errMsg = "前超限";
                    back = true;
                }
                if (staProtocol.isAutoing() && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() > 9990)
                        && staProtocol.isPakMk() && staProtocol.getStamp()>=2 && staProtocol.getStamp()!=3) {// && !Cools.isEmpty(barcode)) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行");
//                    try {
//                        Thread.sleep(300);
//                    }catch (Exception e){}
                if (!back && staProtocol.isBackErr()) {
                    errMsg = "后超限";
                    back = true;
                }
                if (!back && staProtocol.isHighErr()) {
                    errMsg = "高超限";
                    back = true;
                }
                if (!back && staProtocol.isLeftErr()) {
                    errMsg = "左超限";
                    back = true;
                }
                if (!back && staProtocol.isRightErr()) {
                    errMsg = "右超限";
                    back = true;
                }
                if (!back && staProtocol.isWeightErr()) {
                    errMsg = "超重";
                    back = true;
                }
                if (!back && staProtocol.isBarcodeErr()) {
                    errMsg = "扫码失败";
                    back = true;
                }
                // 退回
                if (back) {
//                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));

                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            staProtocol.setWorkNo( 9999);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                            News.info(""+mark+" - 2"+" - 扫码失败1 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode, inSta.getStaNo());
                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = "扫码失败，请重试";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                            }
                            continue;
                        }
                    } else {
                        staProtocol.setWorkNo( 9999);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        News.info(""+mark+" - 3"+" - 扫码失败2 ===>> {}号条码扫描器检测条码信息：{},站点:{}", inSta.getBarcode(), barcode, inSta.getStaNo());
                        // led 异常显示
                        if (ledThread != null) {
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                        }
                    if (!staProtocol.isLoading()){
                        continue;
                    }
                    if (!staProtocol.isPakMk()) {
                        continue;
                    }
                    staProtocol.setWorkNo(wrkNo);
                    News.info("{}入库回退：{}，任务号：{}", inSta.getStaNo(), errMsg,wrkNo);
                    wrkNo++;
                    staProtocol.setStaNo(inSta.getBackSta().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                }

                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk()
                        && staProtocol.isPakMk()) {
                    if(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                        News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);

                        continue;
                    }
                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    //过滤判断，防止拣料再入库货物，经过入库站再入库时，被退回到退库站
                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStepBarcode(barcode);
                    if (wrkMast1 !=null){
                        if (wrkMast1.getIoType()==103 || wrkMast1.getIoType()==107 || wrkMast1.getIoType()==104){
                            continue;
                        }
                    }
                    if (wrkMast != null) {
                        News.error(""+mark+" - 4"+" - 工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        staProtocol.setWorkNo(9999);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        if (!result) {
                            throw new CoolException("更新plc站点信息失败");
                        }

                        // led 异常显示
                        News.error(methodName + ":工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        if (ledThread != null) {
                            String errorMsg = "工作档已存在该条码号===>>" + barcode;
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                            News.error(methodName + ":扫码失败，请重试");
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, "工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={" + wrkMast.getWrkNo() + "}, 请手动取消已存在工作档"));
                        }
                        continue;
                    }

                    WrkMast checkPick = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                            .eq("barcode", barcode)
                            .in("io_type", 107,103));
                    if (!Cools.isEmpty(checkPick)) {
                        continue;
                    }
                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

@@ -233,58 +219,40 @@
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                throw new CoolException("更新plc站点信息失败");
                            }
                                News.error(methodName + ":更新plc站点信息失败");

                            // led 入库信息显示
                            if (ledThread != null) {
                                // 命令集合
                                List<LedCommand> commands = new ArrayList<>();
                                // 组装命令
                                LedCommand ledCommand = new LedCommand();
                                ledCommand.setWorkNo(dto.getWorkNo());
                                ledCommand.setIoType(1);
                                ledCommand.setTitle("全板入库");
                                ledCommand.setLocNo(dto.getLocNo());
                                ledCommand.setStaNo(dto.getStaNo());
                                commands.add(ledCommand);
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, commands));
//                                ledThread.errorReset();
                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else {
                            News.error(""+mark+" - 5"+" - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            staProtocol.setWorkNo(9999);
                            staProtocol.setWorkNo(wrkNo);
                            wrkNo++;
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                throw new CoolException("更新plc站点信息失败");
                            }
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                            // led 异常显示
                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(5, errorMsg));
                                if (!Cools.isEmpty(errorMsg)) {
                                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                                }
                            }
                            News.error(methodName + ":请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }


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

                }else {
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isAutoing()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk()+"、入库印记：" + staProtocol.getStamp());
                }


            }
        }
@@ -372,7 +340,7 @@
                }
                String barcode = barcodeThread.getBarcode();
                if(!Cools.isEmpty(barcode)) {
                    News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
//                    News.info(""+mark+" - 1"+" - {}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
                    if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        continue;
                    }
@@ -539,7 +507,7 @@

                        // 下发站点信息
                        staProtocol.setWorkNo(wrkMast.getWrkNo());
                        staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                        staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo()));
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                            continue;
                        }
@@ -803,6 +771,7 @@
            crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 目标库位排
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            crnCommand.setTraySize(locMast.getLocType1() == 2);
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                News.error(""+mark+" - 1"+" - 16"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
@@ -964,6 +933,7 @@
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        News.error(""+mark+" - 2"+" - 13"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
@@ -1126,6 +1096,10 @@
            News.error(""+mark+" - 3"+" - 2"+" - 工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        if(sta.getLocType1() != sourceSta.getLocType1()){
            News.error("移库目标库位类型与源库位类型不符");
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
        BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
        if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
@@ -1158,6 +1132,7 @@
        crnCommand.setDestinationPosX(sta.getRow1().shortValue());     // 目标库位排
        crnCommand.setDestinationPosY(sta.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(sta.getLev1().shortValue());     // 目标库位层
        crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            News.error(""+mark+" - 3"+" - 4"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
        } else {
@@ -1374,10 +1349,11 @@

                // 站点条件判断
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk()
                        && (staProtocol.getWorkNo() > 9990 && staProtocol.getWorkNo() <= 9999)
                        && staProtocol.isPakMk()&& staProtocol.getStamp()>=2) {
                        && staProtocol.isPakMk()
                        ) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行：空栈板初始化入库,叉车入库站放货");

                    try {
@@ -1399,7 +1375,7 @@

                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(dto.getWorkNo());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            staProtocol.setStaNo(staProtocol.getSiteId().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
@@ -1422,22 +1398,22 @@
//                                ledThread.errorReset();
                            }
                        } else {
                            staProtocol.setWorkNo(9999);
                            staProtocol.setStaNo(emptyInSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.errorNoLog(""+mark+" - 2"+" - 更新plc站点信息失败");
                                throw new CoolException("更新plc站点信息失败");
                            }

                            if (ledThread != null) {
                                String errorMsg = jsonObject.getString("msg");
                                if (!Cools.isEmpty(errorMsg)) {
                                    MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
                                }
                            }
                            News.error(""+mark+" - 3"+" - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
//                            staProtocol.setWorkNo(wrkNo++);
//                            staProtocol.setStaNo(emptyInSta.getBackSta().shortValue());
//                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                            if (!result) {
//                                News.errorNoLog(""+mark+" - 2"+" - 更新plc站点信息失败");
//                                throw new CoolException("更新plc站点信息失败");
//                            }
//
//                            if (ledThread != null) {
//                                String errorMsg = jsonObject.getString("msg");
//                                if (!Cools.isEmpty(errorMsg)) {
//                                    MessageQueue.offer(SlaveType.Led, emptyInSta.getLed(), new Task(5, errorMsg));
//                                }
//                            }
//                            News.error(""+mark+" - 3"+" - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
@@ -2150,7 +2126,7 @@
            BasRgvMap basRgvMapOther = basRgvMapMapper.selectById(rgvNoOther);
            List<Integer> integers = RouteUtils.RouteMapCurrentFar(fallMerge, basRgvMapCurrent.getLockStartRoute());
            Integer lockEndRoute = RouteUtils.RouteMapOtherFarStnNo(integers, basRgvMapCurrent.getLockStartRoute());//另一台小车可活动最远位置
            basRgvMapOther.setStartRoute(lockEndRoute);
            basRgvMapOther.setEndRoute(lockEndRoute);
            basRgvMapMapper.updateById(basRgvMapOther);
            return true;
        }catch (Exception e){
@@ -2181,7 +2157,7 @@
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && (rgvProtocol.getTaskNo1()==0 || rgvProtocol.getTaskNo1()==9999)
                        && (rgvProtocol.getTaskNo2()==0 || rgvProtocol.getTaskNo2()==9999)

                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
@@ -2200,6 +2176,7 @@
     */
    public synchronized void rgvCompleteWrkMastSta() {
        try{
            for (DevpSlave devp : slaveProperties.getDevp()) {
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
@@ -2213,9 +2190,10 @@
                }

                // 只有当RGV等待WCS确认、自动
                if (rgvProtocol.getStatusType() == RgvStatusType.WAITING
                if ((rgvProtocol.getStatusType1() == RgvStatusType.WAITING || rgvProtocol.getStatusType1()==RgvStatusType.FETCHWAITING)
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                ) {
                        && (rgvProtocol.getStatusType() == RgvStatusType.WORKING1)
                ){
                    log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
                    if (rgvProtocol.getTaskNo1()!=0){
                        if (rgvProtocol.getTaskNo1()==9999){
@@ -2229,50 +2207,43 @@
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getType()!=1 || wrkMastSta.getWrkSts()!=1){
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getWrkSts()!=1){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
//                        boolean rgvComplete = true;
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                    }else if (rgvProtocol.getTaskNo2()!=0){
                        if (rgvProtocol.getTaskNo2()==9999){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                        StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                            if (!staProtocol.isPakMk()){
                                continue;
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo2().intValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getType()!=2){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            if (!MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol))) {
                                continue;
                            }
                        }
                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                    }else {
                    }

                    else {
                        log.error("小车复位失败，小车号{},等待wcs确认但是没有工作号！",rgvProtocol.getRgvNo());
                    }
                }
            }
            }
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
@@ -2309,10 +2280,10 @@
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                    for (WrkMastSta wrkMastSta : wrkMastStaList){
                        if (wrkMastSta.getType()!=1 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                        if (wrkMastSta.getType()!=0 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                            continue;
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta);
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
                        if (sign){
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd());
                            if (signMap){
@@ -2332,6 +2303,7 @@
                        break;
                    }
                }

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

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

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

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

    /*
     * 有任务但未执行  此时需要调整小车位置
@@ -2493,7 +2465,7 @@
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
//                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getTaskNo2()==0
//                        && rgvProtocol.getTaskNo2()==0
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
@@ -2513,24 +2485,52 @@
     * 小车XY移动  避让
     * */
    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1((short)9999); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.GO_ORIGIN); // 工位1任务模式:  回原点
            rgvCommand.setCommand((short) 1);   //工位1任务确认
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(9, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
        if (rgvId==1){
            try{
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvId);
                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1( (short)100);
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                }
            }catch (Exception e){
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;

            }
        }else {
            try{
                BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvId);
                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1( (short)161);
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                }
            }catch (Exception e){
                return false;

            }
        }
    }

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

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

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

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

    /*
     * 小车复位
@@ -2667,7 +2667,7 @@
    public synchronized boolean rgvComplete(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(3, new RgvCommand()))) {
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(3, new RgvCommand()))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}",rgvId);
                return false;