#

zjj

2025-03-14 54dd86cbf79e485cb0bbca3ad46032fb69306a13

#

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

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

    public Integer wrkNo = 10000;
    public Short wrkNo = 10000;

    /**
     * 组托
@@ -238,7 +238,7 @@
                            continue;
                        }
                        barcodeThread.setBarcode("");
                        staProtocol.setWorkNo(wrkMast.getWrkNo());
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                        staProtocol.setStaNo(RouteUtils.SouStaEnd(null,wrkMast.getSourceStaNo()));
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -280,7 +280,7 @@
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo());
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(RouteUtils.SouStaEnd(dto.getStaNo(),dto.getSourceStaNo()));
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -390,7 +390,7 @@
                    // 命令下发区 --------------------------------------------------------------------------

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -537,7 +537,7 @@
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo((short) 161);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -676,7 +676,7 @@
                                log.info("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位成功===>>" + jsonObject.toJSONString());
                                try {
                                    // 更新站点信息 且 下发plc命令
                                    staProtocol.setWorkNo(dto.getWorkNo());
                                    staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                                    staProtocol.setStaNo((short)161);
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);

@@ -763,7 +763,7 @@
                        // 命令下发区 --------------------------------------------------------------------------

                        // 下发站点信息
                        staProtocol.setWorkNo(wrkMast.getWrkNo());
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                        staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.getSourceStaNo()));
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                            log.info(staProtocol.getWorkNo()+","+staProtocol.getStaNo()+"输送线出库命令下发失败");
@@ -1642,7 +1642,7 @@
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(dto.getWorkNo());
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(staProtocol.getSiteId().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -2338,759 +2338,6 @@
            }
        }

    }

    public synchronized void autoEmptyIn() {
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        List<Integer> list = new ArrayList<>();
        list.add(153);list.add(157);
        for (Integer site:list){
            StaProtocol staProtocol = devpThread.getStation().get(site);
            if (staProtocol == null) {
                return;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (staProtocol.isAutoing()  //自动
                    && staProtocol.isLoading()  //有物
                    && staProtocol.isInEnable()  //可入信号
                    && staProtocol.isPakMk()
                    && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() > 9990) //工作号为0或者工作号是9991~9999（输送机留用）
            ) {

                try {
                    Short loctype1 = 1;
                    if (site == 153){
                        loctype1 = 2;
                    }
                    LocTypeDto locTypeDto = new LocTypeDto(loctype1, (short) 1, (short) 1);
                    locTypeDto.setSiteId(site);

                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/emptyIn/v1")
                            .setJson(JSON.toJSONString(locTypeDto))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        News.info((String) jsonObject.get("msg"));
                        staProtocol.setWorkNo(jsonObject.get("data").hashCode());
                        staProtocol.setStaNo(site.shortValue());
                        devpThread.setPakMk(site,false);
                        MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                    } else {
                        News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyIn/v1", JSON.toJSONString(locTypeDto), response);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            }

        }

    }

    /*
     * 小车地图更新  更新锁
     * */
    public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd,String sign){
//        log.info("小车地图更新！[标记：{}];[BasRgvMap：{}];[staStart：{}];[staEnd：{}];",sign,JSON.toJSONString(basRgvMapCurrent),staStart,staEnd);

//        List<Integer> integers = RouteUtils.RouteMapCurrentFar(basRgvMapCurrent.getNowRoute(),staStart,staEnd, basRgvMapCurrent.getLockStartRoute());
        //更新当前小车锁
        try{
            Integer farCurrentStaNo = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getNowRoute(), staStart, staEnd, basRgvMapCurrent.getLockStartRoute());//获取最远站点
//            log.info("小车地图更新！获取最远站点;[farCurrentStaNo：{}]",farCurrentStaNo);
            Integer fallMerge = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getRgvNo(), farCurrentStaNo); //获取合并干涉项
//            log.info("小车地图更新！获取合并干涉项;[fallMerge：{}]",fallMerge);
            basRgvMapCurrent.setLockEndRoute(fallMerge);
            Integer i = basRgvMapMapper.updateById(basRgvMapCurrent);
//            if (i>0){
//                log.error("{}:==>{}:{}号车更新结束锁,{}",sign,new Date(),basRgvMapCurrent.getRgvNo(),JSON.toJSONString(basRgvMapCurrent));
//            }

            //更新另一台小车地图
            Integer rgvNoOther = basRgvMapCurrent.getRgvNoOther(basRgvMapCurrent.getRgvNo());
//            log.info("小车地图更新！另一台小车号;[rgvNoOther：{}]",rgvNoOther);

            BasRgvMap basRgvMapOther = basRgvMapMapper.selectById(rgvNoOther);
//            log.info("小车地图更新！另一台小车;[basRgvMapOther：{}]",JSON.toJSONString(basRgvMapOther));

            List<Integer> integers = RouteUtils.RouteMapCurrentFar(fallMerge, basRgvMapCurrent.getLockStartRoute());
            Integer lockEndRoute = RouteUtils.RouteMapOtherFarStnNo(integers, basRgvMapCurrent.getLockStartRoute());//另一台小车可活动最远位置
//            log.info("小车地图更新！另一台小车可活动最远位置;[lockEndRoute：{}]",lockEndRoute);
            basRgvMapOther.setEndRoute(lockEndRoute);
            Integer i1 = basRgvMapMapper.updateById(basRgvMapOther);
//            if (i1>0){
//                log.error("{}:==>{}:{}号车更新结束位置,{}",sign,new Date(),basRgvMapOther.getRgvNo(),JSON.toJSONString(basRgvMapOther));
//            }
            return true;
        }catch (Exception e){
            log.error("小车地图更新出错！异常原因："+e);
            return false;
        }
    }

    /*
     * 刷新地图数据
     * */
    public synchronized void refreshRgvMap() {
        try{
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！2", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE &&
                    rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                    && (rgvProtocol.getTaskNo1()==0)
                        &&rgvThread.isPakMk()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());

                    Integer rgvNoOther = basRgvMap.getRgvNoOther(rgvProtocol.getRgvNo());
                    RgvThread rgvThreadOther = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvNoOther);
                    RgvProtocol rgvProtocolOther = rgvThreadOther.getRgvProtocol();
                    if (rgvProtocolOther == null) {
                        continue;
                    }else {
                        rgvProtocolOther = rgvProtocolOther.clone();
                    }
                    if (rgvProtocolOther.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocolOther.getModeType() == RgvModeType.AUTO
                        && rgvProtocolOther.getLoaded1()==0
                        && (rgvProtocolOther.getTaskNo1()==0)
                        &&rgvThreadOther.isPakMk()
                    ){
                        //对工作档进行判断
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        if (rgvProtocol.getTaskNo1() >0 && rgvProtocol.getTaskNo1()<=9000){
                            WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                            rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2366");
                        }else if (rgvProtocol.getTaskNo1() == 0){
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2366");
                        }

                    }



                }
            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }


    /**
     *  完成小车任务
     */
    public synchronized void rgvCompleteWrkMastSta() {
        try{
            for (DevpSlave devp : slaveProperties.getDevp()) {
                List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！3", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV等待WCS确认、自动
                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()==32222){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2415");
                            rgvThread.setPakMk(true);
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getWrkSts()!=1){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }

                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                        StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                        if (staProtocol == null) {
                            continue;
                        } else {
                            staProtocol = staProtocol.clone();
                        }
                        if (!staProtocol.isAutoing() || !staProtocol.isLoading()){
                            continue;
                        }
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                            if (!staProtocol.isPakMk()){
                                continue;
                            }
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            log.error("rgv任务完成给输送线下发命令："+wrkMast.getWrkNo()+","+wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol))) {
                                continue;
                            }
                        }else {
                            log.error("rgv任务完成给输送线下发命令,但未查询到工作档");
                            // 下发站点信息
                            Map<Integer,Integer> map = new HashMap<>();
                            map.put(101,102);map.put(112,111);
                            map.put(100,100);
                            staProtocol.setWorkNo(rgvProtocol.getTaskNo1().intValue());
                            staProtocol.setStaNo(map.get(rgvProtocol.getRgvPosI()).shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            log.error("rgv任务完成给输送线下发命令："+wrkMast.getWrkNo()+","+wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol))) {
                                continue;
                            }
                        }
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
//                        boolean rgvComplete = true;
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        WrkMast wrkMast1 = wrkMastService.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                        wrkMast1.setPdcType("Y");

                        wrkMastService.updateById(wrkMast1);

                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2471");
                        rgvThread.setPakMk(true);
                    }

                    else {
                        log.error("小车复位失败，小车号{},等待wcs确认但是没有工作号！",rgvProtocol.getRgvNo());
                    }
                }
            }
            }
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }
    /**
     * 执行小车搬运任务
     */
    public synchronized boolean rgvRunWrkMastFullSta() {
        boolean wrkEnable = false;
        try{
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！4", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0
                        && rgvProtocol.getTaskNo1() == 0
                        && rgvThread.isPakMk()
                ) {
                    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()!=0 || wrkMastSta.getWrkType()!=3 || wrkMastSta.getWrkSts()!=0){//1:满版   3：取放
                            continue;
                        }
                        //判断工作结束位置状态
                        boolean signDev = false;
                        BasDevp devNo = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", wrkMastSta.getStaEnd()));
                        if (devNo.getDevNo()==113){
                            BasDevp devNo114 = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", 114));
                            if (!Cools.isEmpty(devNo114)){
                                if (devNo114.getOutEnable().equals("Y")){
                                    signDev = true;
                                }
                            }
                        }
                        if (!Cools.isEmpty(devNo)){
                            if (devNo.getAutoing().equals("Y") && !devNo.getWrkNo().equals(0) && !devNo.getLoading().equals("N")){
                                continue;
                            }
                            if (!signDev && devNo.getDevNo()==113){
                                if (!devNo.getAutoing().equals("Y") || !devNo.getWrkNo().equals(0) || !devNo.getLoading().equals("N")){
                                    wrkEnable = true;
                                    continue;
                                }
                                if (!devNo.getOutEnable().equals("Y")){
                                    wrkEnable = true;
                                    continue;
                                }
                            }
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
                        wrkEnable = true;
                        if (sign){
                            wrkMastSta.setWrkSts(1);
                            try{
                                wrkMastStaMapper.updateById(wrkMastSta);
                                log.error("更新小车任务成功");
                            }catch (Exception e){
                                log.error("更新小车任务失败");
                            }
                            rgvThread.setPakMk(false);
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2526");
                            if (signMap){
                                return wrkEnable;
//                                break;
                            }else {
                                log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                                Thread.sleep(500);
                            }
                        } else {
                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                            Thread.sleep(500);
                        }
                        break;
                    }
                }

            }
//            if (!wrkEnable){
//                rgvRunWrkMastEmptyStaAvoidance();
//            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
        }
        return wrkEnable;
    }
    /**
     * 执行小车搬运任务
     */
//    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);
//        }
//    }

//    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);
//        }
//    }

    /*
     * 有任务但未执行  此时需要调整小车位置
     * */
    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
        try{
            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
            if (integer==0){
                return;
            }
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！1", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvThread.isPakMk()
//                        && rgvProtocol.getTaskNo2()==0
                ){
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
                        continue;
                    }
//                    if (rgvProtocol.getRgvNo()==1 && rgvProtocol.getRgvPosI().equals(100)){
//                        continue;
//                    } else if (rgvProtocol.getRgvNo()==2 && rgvProtocol.getRgvPosI().equals(157)  ){
//                        continue;
//                    }
                    rgvAvoidanceXY(rgvProtocol.getRgvNo());
                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2727");
                }
            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }

    /*
     * 小车XY移动  避让
     * */
    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
        BasRgvMap basRgvMap = basRgvMapService.selectByRgvNo(rgvId);
        if (basRgvMap.getStartRoute() == 100 || basRgvMap.getStartRoute() == 101){
            try{

                //  命令下发区 --------------------------------------------------------------------------
                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(basRgvMap.getStartRoute().shortValue());
                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 {
            try{
                //  命令下发区 --------------------------------------------------------------------------
                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(basRgvMap.getStartRoute().shortValue());
                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;

            }
        }
    }


    /*
     * 小车取货至工位任务
     * */
    public synchronized boolean rgvTakeFullAll(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_PUT); // 工位1任务模式:  取放货
            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位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 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.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 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 rgvComplete(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            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;
            } else {
                log.info("RGV命令下发成功，RGV号={}",rgvId);
                return true;
            }
        }catch (Exception e){
            log.error("RGV命令下发失败，RGV号={}。异常："+e,rgvId);
            return false;
        }
    }

}

 src/main/java/com/zy/core/MainProcess.java

@@ -47,9 +47,6 @@

                    // 演示
//                    mainService.crnDemoOfLocMove1();
                    //刷新RGV地图
                    mainService.refreshRgvMap();

                    // 入出库模式切换函数
//                    mainService.ioConvert();


 src/main/java/com/zy/core/ServerBootstrap.java

@@ -58,30 +58,30 @@
        for (Slave crn : slaveProperties.getCrn()) {
            MessageQueue.init(SlaveType.Crn, crn);
        }
        // 初始化Rgv小车mq
        for (Slave rgv : slaveProperties.getRgv()) {
            MessageQueue.init(SlaveType.Rgv, rgv);
        }
//        // 初始化Rgv小车mq
//        for (Slave rgv : slaveProperties.getRgv()) {
//            MessageQueue.init(SlaveType.Rgv, rgv);
//        }
        // 初始化输送线mq
        for (Slave devp : slaveProperties.getDevp()) {
            MessageQueue.init(SlaveType.Devp, devp);
        }
        // 初始化条码扫描仪mq
        for (Slave barcode : slaveProperties.getBarcode()) {
            MessageQueue.init(SlaveType.Barcode, barcode);
        }
//        // 初始化条码扫描仪mq
//        for (Slave barcode : slaveProperties.getBarcode()) {
//            MessageQueue.init(SlaveType.Barcode, barcode);
//        }
        // 初始化Led灯mq
        for (Slave led : slaveProperties.getLed()) {
            MessageQueue.init(SlaveType.Led, led);
        }
        // 初始化磅称mq
        for (Slave scale : slaveProperties.getScale()) {
            MessageQueue.init(SlaveType.Scale, scale);
        }
        // 初始化台车mq
        for (Slave car : slaveProperties.getCar()) {
            MessageQueue.init(SlaveType.Car, car);
        }
//        // 初始化磅称mq
//        for (Slave scale : slaveProperties.getScale()) {
//            MessageQueue.init(SlaveType.Scale, scale);
//        }
//        // 初始化台车mq
//        for (Slave car : slaveProperties.getCar()) {
//            MessageQueue.init(SlaveType.Car, car);
//        }
    }

    private void initThread(){

 src/main/resources/application.yml

@@ -41,7 +41,7 @@
  # 双深
  doubleDeep: true
  # 双深库位排号
  doubleLocs: 1,4,5,8,9,12,13,16
  doubleLocs: 1,4
  # 一个堆垛机负责的货架排数
  groupCount: 4
  # 堆垛机1
@@ -57,174 +57,56 @@
    # 堆垛机入库站点
    crnInStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 123
      row: 3
      bay: 1
      lev: 1
    # 堆垛机出库站点
    crnOutStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 118
      staNo: 1112
      row: 2
      bay: 1
      bay: 2
      lev: 1
  # 堆垛机2
  crn[1]:
    id: 2
    ip: 10.10.10.20
    port: 102
    rack: 0
    slot: 0
    # 偏移量，当堆垛机站点列号=1时，偏移量=2
    offset: 2
    demo: false
    # 堆垛机入库站点
    crnInStn[0]:
    crnInStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 131
      row: 7
      bay: 1
      staNo: 1114
      row: 2
      bay: 2
      lev: 1
    # 堆垛机入库站点
    crnInStn[2]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 1122
      row: 2
      bay: 2
      lev: 1
    # 堆垛机入库站点
    crnInStn[3]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 1124
      row: 2
      bay: 2
      lev: 1
    # 堆垛机出库站点
    crnOutStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 127
      row: 6
      bay: 1
      staNo: 1112
      row: 2
      bay: 2
      lev: 1
  # 堆垛机3
  crn[2]:
    id: 3
    ip: 10.10.10.30
    port: 102
    rack: 0
    slot: 0
    # 偏移量，当堆垛机站点列号=1时，偏移量=2
    offset: 2
    demo: false
    # 堆垛机入库站点
    crnInStn[0]:
    crnOutStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 135
      row: 10
      bay: 1
      staNo: 1114
      row: 2
      bay: 2
      lev: 1
    # 堆垛机出库站点
    crnOutStn[0]:
    crnOutStn[2]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 139
      row: 11
      bay: 1
      staNo: 1122
      row: 2
      bay: 2
      lev: 1
  # 堆垛机4
  crn[3]:
    id: 4
    ip: 10.10.10.40
    port: 102
    rack: 0
    slot: 0
    # 偏移量，当堆垛机站点列号=1时，偏移量=2
    offset: 2
    demo: false
    # 堆垛机入库站点
    crnInStn[0]:
    crnOutStn[3]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 144
      row: 14
      bay: 1
      staNo: 1124
      row: 2
      bay: 2
      lev: 1
    # 堆垛机出库站点
    crnOutStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 148
      row: 15
      bay: 1
      lev: 1

  # RGV穿梭车1
  rgv[0]:
    id: 1
    ip: 10.10.10.60
    port: 502
    rack: 0
    slot: 0
    #RGV入库源站点
    rgvInSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 100
    rgvInSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 101
    #RGV出库源站点
    rgvOutSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 110
    rgvOutSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 112
    #RGV目标站点
    rgvDestStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
    rgvDestStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 103
  # RGV穿梭车2
  rgv[1]:
    id: 2
    ip: 10.10.10.63
    port: 502
    rack: 0
    slot: 0
    #RGV入库源站点
    rgvInSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 100
    rgvInSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 101
    #RGV出库源站点
    rgvOutSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 110
    rgvOutSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 112
    #RGV目标站点
    rgvDestStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
    rgvDestStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 103
  # RGV穿梭车2
  rgv[2]:
    id: 3
    ip: 10.10.10.66
    port: 502
    rack: 0
    slot: 0
    #RGV入库源站点
    rgvInSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 100
    rgvInSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 101
    #RGV出库源站点
    rgvOutSStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 110
    rgvOutSStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 112
    #RGV目标站点
    rgvDestStn[0]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 102
    rgvDestStn[1]:
      devpPlcId: ${wcs-slave.devp[0].id}
      staNo: 103
  # 输送线1
  devp[0]:
    id: 1
@@ -239,83 +121,12 @@
      barcodeMat: ${wcs-slave.barcode[3].id}
      backSta: 105
      led: ${wcs-slave.led[1].id}
    # 空板入库口1
    emptyInSta[0]:
      staNo: 106
      barcode: ${wcs-slave.barcode[0].id}
      backSta: 105
      led: ${wcs-slave.led[1].id}
    # 拣料入库口1
    pickSta[0]:
      staNo: 159
      barcode: ${wcs-slave.barcode[2].id}
      led: ${wcs-slave.led[5].id}
      backSta: 160
    # 入库口1
    inSta[1]:
      staNo: 107
      barcode: ${wcs-slave.barcode[1].id}
      barcodeMat: ${wcs-slave.barcode[4].id}
      backSta: 108
      led: ${wcs-slave.led[2].id}
    # 空板入库口1
    emptyInSta[1]:
      staNo: 107
      barcode: ${wcs-slave.barcode[1].id}
      backSta: 108
      led: ${wcs-slave.led[2].id}
    inSta[2]:
      staNo: 159
      barcode: ${wcs-slave.barcode[2].id}
      barcodeMat: ${wcs-slave.barcode[5].id}
      backSta: 160
      led: ${wcs-slave.led[5].id}
#    # 拣料入库口1
#    pickSta[1]:
#      staNo: 107
#      barcode: ${wcs-slave.barcode[1].id}
#      led: ${wcs-slave.led[1].id}
#      backSta: 108
    # 出库口1
    outSta[0]:
      staNo: 100
      led: ${wcs-slave.led[0].id}
    outSta[1]:
      staNo: 152
      led: ${wcs-slave.led[3].id}
    outSta[2]:
      staNo: 156
      led: ${wcs-slave.led[4].id}


  # 条码扫描仪1
  barcode[0]:
    id: 1
    ip: 10.10.10.121
    port: 51236
  # 条码扫描仪2
  barcode[1]:
    id: 2
    ip: 10.10.10.122
    port: 51236
  # 条码扫描仪3
  barcode[2]:
    id: 3
    ip: 10.10.10.123
    port: 51236
  # 条码扫描仪1mat
  barcode[3]:
    id: 4
    ip: 10.10.10.121
    port: 51236
  # 条码扫描仪2mat
  barcode[4]:
    id: 5
    ip: 10.10.10.122
    port: 51236
  # 条码扫描仪3mat
  barcode[5]:
    id: 6
    ip: 10.10.10.123
    port: 51236
   # LED1
  led[0]: