#

lsh

2024-01-21 0e32b14a61afca8f7dbbe9851f47b57158abfdc1

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

@@ -196,6 +196,9 @@
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());


                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo());

@@ -228,6 +231,62 @@
    }

    /**
     * 组托
     * 入库站，根据条码扫描通知桁架码垛
     */
    public synchronized void generateStoreWrkFileFull2LouM() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历码垛口
            for (DevpSlave.Sta driveSta : devp.getDriveSta()) {
                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, driveSta.getBarcode());
                if (barcodeThread == null) {
                    continue;
                }
                String barcode = barcodeThread.getBarcode();

                if (!Cools.isEmpty(barcode) && !barcode.equals("") && !barcode.equals("      ")) {
                    if ("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        continue;
                    }
                } else {
                    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.isInEnable()
                        && staProtocol.isEmptyMk()
                        && (staProtocol.getWorkNo() == 0 || (staProtocol.getWorkNo()>9899 && staProtocol.getWorkNo()<10000) )
                ) {
                    try {
                        BasDevp basDevp = basDevpService.selectById(driveSta.getStaNo());
                        if (basDevp.getReportSign()>0){
                            continue;
                        }
                        basDevp.setBarcode(barcode);
                        basDevp.setReportSign(1);
                        basDevpService.updateById(basDevp);
                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
                }
            }
        }
    }

    /**
     * wms入库
     * 入库站，根据条码扫描生成入库工作档，工作状态 1 ==>> 2
     */
@@ -235,7 +294,7 @@
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta inSta : devp.getInSta()) {
            for (DevpSlave.Sta inSta : devp.getInWmsSta()) {
                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
@@ -246,9 +305,9 @@
                }

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

                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
@@ -264,7 +323,11 @@

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo(wrkMast.getStaNo());
                    Integer staNo = wrkMast.getStaNo();
                    if (wrkMast.getSourceStaNo()==145){
                        staNo = 147;
                    }
                    staProtocol.setStaNo(staNo);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (result) {
@@ -433,17 +496,17 @@
                    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;
                        }
//                        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;
@@ -521,6 +584,46 @@

            }

        }
    }

    /**
     * 拣料、并板、盘点再入库  拆垛位置
     */
    public synchronized void storeEmptyPlt4() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历叠盘入库口
            for (DevpSlave.Sta pickSta : devp.getEmptyInSta2()) {

                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                BasDevp basDevp = basDevpService.selectById(staProtocol.getSiteId());
                if (Cools.isEmpty(basDevp) || basDevp.getReportSign()!=1){
                    continue;
                }

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isPakMk() && staProtocol.getWorkNo()==0 && !staProtocol.isOutEnable() && staProtocol.isInEnable()) {
                    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() + 19999L);
                            if (Cools.isEmpty(wrkMastSta)){
                                WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),staProtocol.getSiteId());
                                wrkMastSta1.setType(2);
                                wrkMastSta1.setWrkType(1);
                                wrkMastStaMapper.insert(wrkMastSta1);
                            }
                        }
                    }
                }
            }
        }
    }

@@ -1065,247 +1168,6 @@

            }
        }
    }

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

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

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

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

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

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

                //查找是否存在入出库工作中等待RGV搬运的任务
                List<WrkMast> wrkMasts = wrkMastMapper.selectIoRgvNo(rgv.getId());
                for (WrkMast wrkMast : wrkMasts) {
                    if (wrkMast.getWrkSts() == 2) {//2.设备上走1 => 3.RGV取货中
                        if (rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
                            continue;
                        }

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

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 2.设备上走1 => 3.RGV取货中
                            Date now = new Date();
                            wrkMast.setWrkSts(3L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 2.设备上走1 => 3.RGV取货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 14) {//4.RGV取货完成 => 5.RGV放货中   14出库完成
                        if (rgvProtocol.getTaskNo1() == 0 || !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
                            continue;
                        }
                        if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
                            continue;
                        }

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

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 4.RGV取货完成 => 5.RGV放货中
                            Date now = new Date();
                            wrkMast.setWrkSts(5L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 4.RGV取货完成 => 5.RGV放货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 23) {//23.设备上走1 => 24.RGV取货中
                        if (rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getLoaded1() != 0) {//RGV是否无任务、RGV是否无货
                            continue;
                        }

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

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 23.设备上走1 => 24.RGV取货中
                            Date now = new Date();
                            wrkMast.setWrkSts(24L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 23.设备上走1 => 24.RGV取货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 25) {//25.RGV取货完成 => 26.RGV放货中
                        if (rgvProtocol.getTaskNo1() == 0 || !rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())) {//RGV必须有任务且任务和当前工作档一致
                            continue;
                        }
                        if (rgvProtocol.getLoaded1() == 0) {//RGV必须有物
                            continue;
                        }

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

                        //  命令下发区 --------------------------------------------------------------------------
                        RgvCommand rgvCommand = new RgvCommand();
                        rgvCommand.setRgvNo(wrkMast.getRgvNo()); // RGV编号
                        rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                        rgvCommand.setTaskNo1(wrkMast.getWrkNo().shortValue()); // 工位1工作号
                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
                        rgvCommand.setDestinationStaNo1(wrkMast.getRgvDstaNo().shortValue());   //工位1目标站点
                        rgvCommand.setCommand((short) 1);   //工位1任务确认
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getRgvNo(), new Task(4, rgvCommand))) {
                            //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                            log.error("RGV命令下发失败，RGV号={}，任务数据={}", wrkMast.getRgvNo(), JSON.toJSON(rgvCommand));
                        } else {
                            // 修改工作档状态 25.RGV取货完成 => 26.RGV放货中
                            Date now = new Date();
                            wrkMast.setWrkSts(26L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 25.RGV取货完成 => 26.RGV放货中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    }
                }

            }
        }
    }

    private boolean rgvIoExecuteWrk2To3() {
        return false;
    }

    /**
@@ -3069,9 +2931,16 @@
                // 只有当RGV空闲、自动,工位二有物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        &&  (rgvProtocol.getLoaded2()==2  || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物
                        && 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：（）只允许拆盘
                ) {
                    try {
                        WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep3(122);
                        if (!Cools.isEmpty(wrkMast1)){
                            continue;
                        }
                        // 获取空板入库站信息

                        SearchLocParam param = new SearchLocParam();
@@ -3092,7 +2961,7 @@
                            if (!Cools.isEmpty(wrkMast) && wrkMast.getIoType()==10 && wrkMast.getWrkSts()==2){
                                WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(wrkMast.getWrkNo().longValue());
                                if (Cools.isEmpty(wrkMastSta)){
                                    WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),0);
                                    WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),wrkMast.getStaNo());
                                    wrkMastSta1.setWrkNo(wrkMast.getWrkNo().longValue());
                                    wrkMastSta1.setType(2);
                                    wrkMastSta1.setWrkType(6);//工作类型  1:取（叠盘）  2：拆盘  3：取放 5：满取  6：满放
@@ -3147,6 +3016,7 @@
                // 出库模式
                switch (wrkMast.getIoType()) {
                    case 1:
                    case 202:
                        ledCommand.setTitle("全板入库");
                        break;
                    case 10:
@@ -3178,7 +3048,7 @@
//                ledCommand.setSourceStaNo(wrkMast.getSourceStaNo());
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme())));
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl)));
                }
                commands.add(ledCommand);
            }
@@ -3191,21 +3061,22 @@
            }
            // 命令下发 -------------------------------------------------------------------------------
            if (!commands.isEmpty()) {
                if (led.getId() == 7) {
//                if (led.getId() == 7) {
                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(3, commands))) {
                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                        continue;
                    } else {
                        ledThread.setLedMk(false);
                    }
                } else {
                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                        continue;
                    } else {
                        ledThread.setLedMk(false);
                    }
                }
//                }
//                else {
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
//                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                        continue;
//                    } else {
//                        ledThread.setLedMk(false);
//                    }
//                }

            }

@@ -3924,7 +3795,10 @@
            int[] staNos=new int[]{131,135};//(2个入库站点，1楼2个出库码垛站,根据现场修改)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp.getWrkNo()!=0){
                if (Cools.isEmpty(basDevp) || basDevp.getReportSign()!=1){
                    continue;
                }
                if (basDevp.getWrkNo()!=0 && (basDevp.getWrkNo()<9900 || basDevp.getWrkNo()>9999)){
                    continue;
                }
                WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne202(staNo);
@@ -3954,7 +3828,7 @@
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && staProtocol.getWorkNo() == 0
                        && (staProtocol.getWorkNo() == 0 || (staProtocol.getWorkNo()>9899 && staProtocol.getWorkNo()<10000))
                ) {//&& staProtocol.isPakMk() && !Cools.isEmpty(barcode)) {

                    //任务完成
@@ -4048,7 +3922,7 @@
            int[] staNos=new int[]{144};//(1楼1个贴标位,根据现场修改)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if ((basDevp.getWrkNo()<9900 || basDevp.getWrkNo()>19999) && basDevp.getWrkNo()!=32222){
                if ((basDevp.getWrkNo()<9900 || basDevp.getWrkNo()>9999) && basDevp.getWrkNo()!=32222){
                    continue;
                }
                WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne202(staNo);
@@ -4091,6 +3965,135 @@
                    }
                    wrkMast.setWrkSts(55L);
                    wrkMastMapper.updateById(wrkMast);

                }
            }
        }catch (Exception e){
//            e.printStackTrace();
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            log.error("其他  ===>> 贴标完成驱动托盘进入下一步"+e);
        }
    }

    /**
     * 其他  ===>> 退货码垛完成托盘继续下一步
     */
    public synchronized void stackingCompletionDriveTrayOk3() {
        try {
            int[] staNos=new int[]{118};
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (Cools.isEmpty(basDevp) || basDevp.getWrkNo()!=0 || basDevp.getReportSign()!=3){
                    continue;
                }
                WrkMast wrkMast = wrkMastMapper.selectWrkMastUnstackingOne145(145);
                if (Cools.isEmpty(wrkMast)){
                    continue;
                }
                // 获取站点信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                if (!staProtocol.isLoading()){
                    log.info("{}站点无物，异常！",staNo);
                    continue;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && !staProtocol.isEmptyMk()
                ) {
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo(wrkMast.getStaNo());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }
                    wrkMast.setSheetNo("5");
                    wrkMastMapper.updateById(wrkMast);
                }
            }
        }catch (Exception e){
//            e.printStackTrace();
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            log.error("其他  ===>> 退货码垛完成托盘继续下一步"+e);
        }
    }

    /**
     * 其他  ===>> 拆垛完成继续下一步  运行途中自动避让空板
     */
    public synchronized void stackingCompletionDriveTray4() {
        try {
            int[] staNos=new int[]{134};//(134有任务，135空闲，则避让)
            for (int staNo : staNos){
                BasDevp basDevp = basDevpService.selectById(staNo);
                BasDevp basDevp135 = basDevpService.selectById(135);
                if (basDevp.getWrkNo()==0 || (basDevp.getWrkNo()<10000 && basDevp.getWrkNo()>9899) ){
                    continue;
                }
                if (basDevp135.getReportSign()!=0){
                    continue;
                }
                WrkMast wrkMast131 = wrkMastMapper.selectWrkMastUnstackingOne202Two(131);
                if (Cools.isEmpty(wrkMast131)){
                    continue;
                }
                // 获取站点信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol135 = devpThread.getStation().get(135);
                if (staProtocol135 == null) {
                    continue;
                } else {
                    staProtocol135 = staProtocol135.clone();
                }
                if (staProtocol135.getWorkNo()<9900 || staProtocol135.getWorkNo()>9999 || staProtocol135.getWorkNo()==0
                        || !staProtocol135.isLoading() || !staProtocol135.isAutoing()){
                    continue;
                }
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

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

                    //任务完成
                    boolean result1 = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(3, staProtocol135));
                    try{
                        Thread.sleep(100);
                    }catch (Exception e){ }
                    basDevp135.setReportSign(2);
                    basDevpService.updateById(basDevp135);
                    staProtocol135.setWorkNo(32222);
                    staProtocol135.setStaNo(144);
                    devpThread.setPakMk(staProtocol135.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol135));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>驱动码垛位托盘前进失败！");
                    }
                    boolean result2 = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(4, staProtocol135));

                }
            }
@@ -4151,11 +4154,29 @@
                        StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                            Thread.sleep(200);
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol))) {
                                continue;
                            }
                            log.error("小车任务完成下发输送线任务："+staProtocol);
                            try{
                                Thread.sleep(1000);
                                DevpThread devpThreadEnd = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                                StaProtocol staProtocolEnd = devpThreadEnd.getStation().get(wrkMastSta.getStaEnd());
                                log.error("小车任务完成读取输送线任务："+staProtocolEnd);
                                if (staProtocolEnd.getWorkNo()==0 ){ //|| !staProtocolEnd.getWorkNo().equals(wrkMast.getWrkNo())
                                    staProtocolEnd.setWorkNo(wrkMast.getWrkNo());
                                    staProtocolEnd.setStaNo(wrkMast.getStaNo());
                                    if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocolEnd))) {
                                        continue;
                                    }
                                    log.error("小车任务完成下发输送线任务第二次："+staProtocolEnd);
                                }
                            }catch (Exception e){

                            }
                        }
                        wrkMastSta.setWrkSts(3);
@@ -4188,11 +4209,29 @@
                        StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                            Thread.sleep(200);
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol))) {
                                continue;
                            }
                            log.error("小车任务完成下发输送线任务："+staProtocol);
                            try{
                                Thread.sleep(1000);
                                DevpThread devpThreadEnd = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                                StaProtocol staProtocolEnd = devpThreadEnd.getStation().get(wrkMastSta.getStaEnd());
                                log.error("小车任务完成读取输送线任务："+staProtocolEnd);
                                if (staProtocolEnd.getWorkNo()==0 ){ //|| !staProtocolEnd.getWorkNo().equals(wrkMast.getWrkNo())
                                    staProtocolEnd.setWorkNo(wrkMast.getWrkNo());
                                    staProtocolEnd.setStaNo(wrkMast.getStaNo());
                                    if (!MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocolEnd))) {
                                        continue;
                                    }
                                    log.error("小车任务完成下发输送线任务第二次："+staProtocolEnd);
                                }
                            }catch (Exception e){

                            }
                        }
                        wrkMastSta.setWrkSts(3);
@@ -4210,9 +4249,91 @@
        }
    }
    /**
     * 入出库  ===>>  小车作业下发
     */
    public synchronized void rgvIoExecute(Integer sign) {
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                // 获取小车信息
                boolean signWork = false;
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！", rgvSlave.getId());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                ) {
                    switch (sign){
                        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 = qwe();
                            break;
                        default:
//                            signWork = rgvRunWrkMastEmptyStaAvoidance();//避让
                            break;
                    }
                }
                for (int signCount = 1;!signWork && signCount<8;signCount++){
                    switch (signCount){
                        case 1://执行小车货物搬运任务
                            signWork = rgvRunWrkMastFullSta();
                            break;
                        case 2://放//拆盘
                            signWork = rgvRunWrkMastEmptyStaPut();
                            break;
                        case 3://满放
                            signWork = rgvRunWrkMastEmptyStaPutFull();
                            break;
                        case 4://取叠盘
                            signWork = rgvRunWrkMastEmptyStaTake();
                            break;
                        case 5:////满取
                            signWork = rgvRunWrkMastEmptyStaTakeFull();
                            break;
                        case 6:////提升
//                            signWork = rgvRunWrkMastEmptyStaPut();
                            break;
                        default:
//                            signWork = rgvRunWrkMastEmptyStaAvoidance();//避让
                            break;
                    }
                }

            }
        }catch (Exception e){
            log.error("RGV小车任务下发报错"+e);
        }
    }
    /**
     * 执行小车搬运任务
     */
    public synchronized void rgvRunWrkMastFullSta() {
    public synchronized boolean rgvRunWrkMastFullSta() {
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
@@ -4228,6 +4349,8 @@

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
@@ -4244,6 +4367,10 @@
                        if (wrkMastSta.getType()!=1 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                            continue;
                        }
                        BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                        if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y")){
                            continue;
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta);
                        if (sign){
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd());
@@ -4254,7 +4381,7 @@
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                                return true;
                            }else {
                                log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
@@ -4269,11 +4396,12 @@
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
        }
        return false;
    }
    /**
     * 执行小车搬运任务//拆盘
     */
    public synchronized void rgvRunWrkMastEmptyStaPut() {//拆盘
    public synchronized boolean rgvRunWrkMastEmptyStaPut() {//拆盘
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
@@ -4289,9 +4417,11 @@

                // 只有当RGV空闲、自动,工位二有物//rgv可用//拆盘
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                        && (rgvProtocol.getLoaded2()==3  || rgvProtocol.getLoaded2()==1 )////0 无物；1 一层无物二层有物 （只能拆叠） ；2一层有物二层无物 ；3  1、2层都有物
                        && (rgvProtocol.getLoaded2()==3  || rgvProtocol.getLoaded2()==1 || rgvProtocol.getLoaded2()==4)////0 无物；1 一层无物二层有物 （只能拆叠） ；2一层有物二层无物() ；3  1、2层都有物  4：（）只允许拆盘
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
@@ -4307,6 +4437,10 @@
                        }
                        boolean sign = false;
                        if ( wrkMastSta.getStaEnd()!=0){//放
                            BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                            if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y")){
                                continue;
                            }
                            sign = rgvPutEmpty(rgvProtocol.getRgvNo(),wrkMastSta);//拆盘
                        }else {
                            continue;
@@ -4320,7 +4454,7 @@
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                                return true;
                            }else {
                                log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
@@ -4335,12 +4469,13 @@
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
        }
        return false;
    }

    /**
     * 执行小车搬运任务
     */
    public synchronized void rgvRunWrkMastEmptyStaPutFull() {//满放
    public synchronized boolean rgvRunWrkMastEmptyStaPutFull() {//满放
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
@@ -4356,8 +4491,11 @@

                // 只有当RGV空闲、自动,工位二有物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        &&  (rgvProtocol.getLoaded2()==2  || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                        &&  (rgvProtocol.getLoaded2()==2  || rgvProtocol.getLoaded2()==3 ) ////0 无物；1 一层无物二层有物  ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
@@ -4372,7 +4510,11 @@
                            continue;
                        }
                        boolean sign = false;
                        if (wrkMastSta.getStaStart()==0 && wrkMastSta.getStaEnd()!=0){//满放
                        if ( wrkMastSta.getStaEnd()!=0){//满放
                            BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaEnd());
                            if (!basDevp.getAutoing().equals("Y") || basDevp.getLoading().equals("Y")){
                                continue;
                            }
                            sign = rgvPutEmptyFull(rgvProtocol.getRgvNo(),wrkMastSta);
                        }else {
                            continue;
@@ -4386,7 +4528,7 @@
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                                return true;
                            }else {
                                log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
@@ -4401,9 +4543,10 @@
            log.error("3933行执行小车放空板任务下发失败");
            log.error("3933行"+e);
        }
        return false;
    }

    public synchronized void rgvRunWrkMastEmptyStaTake() {//叠盘
    public synchronized boolean rgvRunWrkMastEmptyStaTake() {//叠盘
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
@@ -4419,9 +4562,11 @@

                // 只有当RGV空闲、自动,工位二无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                        &&  (rgvProtocol.getLoaded2()==0  || rgvProtocol.getLoaded2()==1 ) //现场修改：叠盘机，////0 无物；1 一层无物二层有物（只能拆叠）   ；2一层有物二层无物 （只能满放）；3  1、2层都有物
                        &&  (rgvProtocol.getLoaded2()==0  || rgvProtocol.getLoaded2()==1 ) //现场修改：叠盘机，////0 无物；1 一层无物二层有物（只能拆叠）   ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
@@ -4437,6 +4582,10 @@
                        }
                        boolean sign = false;
                        if ( wrkMastSta.getStaStart()!=0){//取
                            BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaStart());
                            if (!basDevp.getAutoing().equals("Y") || !basDevp.getLoading().equals("Y")){
                                continue;
                            }
                            sign = rgvTakeEmpty(rgvProtocol.getRgvNo(),wrkMastSta);//叠盘
                        }else {
                            continue;
@@ -4450,7 +4599,7 @@
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                                return true;
                            }else {
                                log.error("3879行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
@@ -4465,9 +4614,10 @@
            log.error("3989行执行小车取空板任务下发失败");
            log.error("3989行"+e);
        }
        return false;
    }

    public synchronized void rgvRunWrkMastEmptyStaTakeFull() {//满取
    public synchronized boolean rgvRunWrkMastEmptyStaTakeFull() {//满取
        try{
            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
@@ -4483,8 +4633,11 @@

                // 只有当RGV空闲、自动,工位二无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        &&  rgvProtocol.getLoaded2()==0  //现场修改：叠盘机，////0 无物；1 一层无物二层有物（只能拆叠）   ；2一层有物二层无物 （只能满放）；3  1、2层都有物
                        && rgvProtocol.getTaskNo1()==0 && rgvProtocol.getTaskNo2()==0
                        &&  rgvProtocol.getLoaded2()==0  //现场修改：叠盘机，////0 无物；1 一层无物二层有物（只能拆叠）   ；2一层有物二层无物 （只能满放）；3  1、2层都有物  4：（）只允许拆盘
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
@@ -4499,7 +4652,11 @@
                            continue;
                        }
                        boolean sign = false;
                        if (wrkMastSta.getStaEnd()==0 && wrkMastSta.getStaStart()!=0){//满取
                        if (wrkMastSta.getStaStart()!=0){//满取
                            BasDevp basDevp = basDevpService.selectById(wrkMastSta.getStaStart());
                            if (!basDevp.getAutoing().equals("Y") || !basDevp.getLoading().equals("Y")){
                                continue;
                            }
                            sign = rgvTakeEmptyFull(rgvProtocol.getRgvNo(),wrkMastSta);
                        }else {
                            continue;
@@ -4513,7 +4670,7 @@
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                return;
                                return true;
                            }else {
                                log.error("3879行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
@@ -4528,6 +4685,7 @@
            log.error("3989行执行小车取空板任务下发失败");
            log.error("3989行"+e);
        }
        return false;
    }

    /*
@@ -4536,6 +4694,13 @@
    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
        try{
            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
            if (integer==0){
                return;
            }
            //查询是否需要避让
            //未完成
            Thread.sleep(1000);
            integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
            if (integer==0){
                return;
            }
@@ -4557,6 +4722,8 @@
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getTaskNo2()==0
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
@@ -4601,7 +4768,7 @@
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getTaskNo2()==0
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvSlave.getId());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute());
                }