*

lsh

2025-09-09 bf8895d798f6308717f83b2bdb413ff5f304b3e4

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

@@ -8,11 +8,16 @@
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.ArmTaskAssignmentParam;
import com.zy.asrs.entity.param.CombParam;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.PostMesDataUtils;
import com.zy.asrs.utils.RouteUtils;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.asrs.utils.core.ReturnT;
import com.zy.common.constant.ArmConstant;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
@@ -93,9 +98,16 @@
    private WrkMastService wrkMastService;
    @Autowired
    private BasRgvMapService basRgvMapService;
    @Autowired
    private BasArmService basArmService;
    @Autowired
    private BasArmMastService basArmMastService;

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

    @Value("${wms.comb}")
    private String wmsComb;
    @Value("${inventory.number}")
    private Integer inventoryNumber;

@@ -750,6 +762,7 @@
                    if ((wrkMast.getIoType() != 12 && wrkMast.getIoType() < 100) || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        continue;
                    }

                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                    CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
                    CrnProtocol crnProtocol = crnThread.getCrnProtocol();
@@ -812,51 +825,63 @@
            } else {
                staProtocolIn = staProtocolIn.clone();
            }
            StaProtocol staProtocolOut = devpThread.getStation().get(1015);
            if (staProtocolOut == null) {
                continue;
            } else {
                staProtocolOut = staProtocolOut.clone();
            }
            if(staProtocolOut.getWorkNo() != null &&staProtocolOut.getStaNo() == 4006){
                WrkMast wrkMastOut = wrkMastMapper.selectByWrkNo(staProtocolOut.getWorkNo());
                WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9997);
                if(wrkMast == null){
            int[] outStaNos = {1015, 2016};
            for (int outStaNo : outStaNos) {
                StaProtocol staProtocolOut = devpThread.getStation().get(outStaNo);// 盘点出库衔接站点（可能是 1015，也可能是 2016）
                if (staProtocolOut == null) {
                    continue;
                } else {
                    staProtocolOut = staProtocolOut.clone();
                }
                try {
                    TransplantWork param = new TransplantWork();
                    param.setWorkNo(wrkMastOut.getWrkNo());
                    param.setBarcode(wrkMastOut.getBarcode());
                    param.setSourceStaNo(1015);
                    param.setStaNo(wrkMastOut.getStaNo());
                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/TransplantingIn/v1")
                            .setJson(JSON.toJSONString(param))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        staProtocolOut.setWorkNo(9997);
                        devpThread.setPakMk(staProtocolOut.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocolOut));

                        if (!result) {
                            throw new CoolException("更新plc站点信息失败");
                        }
                if (staProtocolOut.getWorkNo() != null && staProtocolOut.getStaNo() == 4006) {
                    WrkMast wrkMastOut = wrkMastMapper.selectByWrkNo(staProtocolOut.getWorkNo());
                    WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9997);
                    if (wrkMastOut == null) {
                        continue;
                    }
                    if (wrkMast != null) {
                        News.info("已存在斜街任务，等待任务完成");
                        continue;
                    }
                    try {
                        TransplantWork param = new TransplantWork();
                        param.setWorkNo(wrkMastOut.getWrkNo());
                        param.setBarcode(wrkMastOut.getBarcode());
                        param.setSourceStaNo(outStaNo);
                        param.setStaNo(wrkMastOut.getStaNo());

                } catch (Exception e) {
                    e.printStackTrace();
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/auto/TransplantingOut/v1")
                                .setJson(JSON.toJSONString(param))
                                .build()
                                .doPost();

                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            staProtocolOut.setWorkNo(9997);
                            devpThread.setPakMk(staProtocolOut.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocolOut));

                            if (!result) {
                                throw new CoolException("更新plc站点信息失败");
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
                }
            }

            if(staProtocolIn.getWorkNo() != null &&staProtocolIn.getStaNo() != 4001){
                WrkMast wrkMastIn = wrkMastMapper.selectByWrkNo(staProtocolIn.getWorkNo());
                WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9996);
                if(wrkMast == null){
                if(wrkMastIn == null){
                    continue;
                }
                if(wrkMast != null){
                    News.info("已存在斜街任务，等待任务完成");
                    continue;
                }
                try {
@@ -867,7 +892,7 @@
                    param.setStaNo(wrkMastIn.getStaNo());
                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/TransplantingOut/v1")
                            .setPath("/rpc/auto/TransplantingIn/v1")
                            .setJson(JSON.toJSONString(param))
                            .build()
                            .doPost();
@@ -2535,16 +2560,20 @@
    public synchronized void autoEmptyOut() {
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        List<Integer> list = new ArrayList<>();
        list.add(1108);list.add(112);
        Map<Integer,Integer> map = new HashMap<>();
        map.put(101,102);map.put(112,111);
        list.add(1108);list.add(2031);
        for (Integer site:list){
            WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("sta_no", map.get(site)));
            if (!Cools.isEmpty(wrkMast)){
            Integer emptyCount = wrkMastMapper.countPakOutEmpty(site);
            StaProtocol staProtocol = null;
            if(emptyCount >= 2 && site == 1108){
                continue;
            }else if(emptyCount == 1 && site == 2031){
                continue;
            }
            //如果站点可出禁用，则不生成空盘出库任务
            StaProtocol staProtocol = devpThread.getStation().get(site);
            switch (site){
                case 1108:staProtocol = devpThread.getStation().get(site - 2);break;
                case 2031:staProtocol = devpThread.getStation().get(site);break;
            }
            if (staProtocol == null) {
                return;
            } else {
@@ -2555,10 +2584,6 @@
                    && staProtocol.isOutEnable()  //可出信号
                    && staProtocol.getWorkNo() == 0
            ) {
                WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(site);
                if (null != pakoutEmpty) {
                    return;
                }
                Short loctype1 = 1;
                LocTypeDto locTypeDto = new LocTypeDto(loctype1, (short) 1, (short) 1);
                locTypeDto.setSiteId(site);
@@ -2699,7 +2724,9 @@
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE &&
                    rgvProtocol.getModeType() == RgvModeType.AUTO
                    && !rgvProtocol.isLoaded1ing()  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                    && (rgvProtocol.getTaskNo1()==0)
                    && rgvProtocol.getTaskNo1()==0
                        && !rgvProtocol.isLoaded2ing()
                        && rgvProtocol.getTaskNo2()==0
                        &&rgvThread.isPakMk()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
@@ -2715,7 +2742,9 @@
                    if (rgvProtocolOther.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocolOther.getModeType() == RgvModeType.AUTO
                        && !rgvProtocolOther.isLoaded1ing()
                        && (rgvProtocolOther.getTaskNo1()==0)
                        && rgvProtocolOther.getTaskNo1()==0
                        && !rgvProtocolOther.isLoaded2ing()
                        && rgvProtocolOther.getTaskNo2()==0
                        &&rgvThreadOther.isPakMk()
                    ){
                        //对工作档进行判断
@@ -2799,17 +2828,16 @@
                        StaProtocol staProtocol = devpThread.getStation().get(staNo);
                        boolean rgvComplete = false;

                        long now = System.currentTimeMillis();
                        if (staProtocol.isLoading()) {
                            rgvProtocol.setLoadingStartTime(null); // 已到位，清空时间戳
                        } else {
                            if (rgvProtocol.getLoadingStartTime() == null) {
                                rgvProtocol.setLoadingStartTime(now);
                            }
                        }
//                        long now = System.currentTimeMillis();
//                        if (staProtocol.isLoading()) {
//                            rgvProtocol.setLoadingStartTime(null); // 已到位，清空时间戳
//                        } else {
//                            if (rgvProtocol.getLoadingStartTime() == null) {
//                                rgvProtocol.setLoadingStartTime(now);
//                            }
//                        }

                        if (staProtocol.isLoading() ||
                                (rgvProtocol.getLoadingStartTime() != null && now - rgvProtocol.getLoadingStartTime() > 10000)) {
                        if (staProtocol.isLoading()) {
                            rgvComplete = rgvComplete((int) rgvProtocol.getRgvNo(), 3);
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！等待入库取货", rgvProtocol.getRgvNo());
@@ -3062,7 +3090,7 @@

                }
            }
            //入库放货
            //出库放货
            if(  rgvThread.isPakOut()){
                for(RgvSlave.RgvStn rgvStn : rgv.getRgvOutPStn()){//入库放货站点
                    boolean flag = false;
@@ -3070,7 +3098,7 @@
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
                    if (staProtocol == null) {
                        News.infoNoLog( " - 1" + " - 1" + " - Rgv入库放货站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                        News.infoNoLog( " - 1" + " - 1" + " - Rgv出库放货站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
@@ -3078,7 +3106,7 @@
                    // 查询站点详细信息
                    BasDevp staDetl = basDevpService.selectById(rgvStn.getStaNo());
                    if (staDetl == null) {
                        News.error( " - 1" + " - 2" + " - 入库 ===>>Rgv放货站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
                        News.error( " - 1" + " - 2" + " - 出库 ===>>Rgv放货站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
                        continue;
                    }

@@ -3087,7 +3115,7 @@
                        flag = true;
                    }
                    if (!flag) {
                        News.errorNoLog( " - 1" + " - 3" + " - Rgv入库放货站信息(以下需要全true):"
                        News.errorNoLog( " - 1" + " - 3" + " - Rgv出库放货站信息(以下需要全true):"
                                + "自动信号" + staProtocol.isAutoing() + "有物信号" + staProtocol.isLoading()
                                + "工作号>0" + staProtocol.getWorkNo() + "可入信号" + staProtocol.isOutEnable()
                                + "能入信号（wms设置）.equals(\"Y\")" + staDetl.getCanouting());
@@ -3104,7 +3132,7 @@
                    }
                    WrkMastSta wrkMastSta = wrkMastStaMapper.selectNoInterfere(route, route, Long.valueOf(wrkNo));//根据站点工作号和小车工作范围检索任务档
                    if( null == wrkMastSta ) {
                        News.infoNoLog( " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts0, 工作号={}", staProtocol.getWorkNo());
                        News.infoNoLog( " - 1" + " - 4" + " - 查询无待出库数据--wrk_sts0, 工作号={}", staProtocol.getWorkNo());
                        continue;
                    }
                    wrkMastSta.setWrkSts(2);
@@ -3202,17 +3230,34 @@
    public synchronized void rgvRunWrkMastIn(RgvSlave slave, RgvProtocol rgvProtocol,Integer mark) {
        for (RgvSlave.RgvStn rgvStn : slave.getRgvInTStn()) {//rgv入库取货站点
            boolean flag = false;
            boolean ds = false;
            //遍历rgv入库取货站点
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, (int) rgvProtocol.getRgvNo());
            StaProtocol staProtocol2 = null;

            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, (int) rgvProtocol.getRgvNo());
            if(rgvStn.getStaNo2()!= null ){
                staProtocol2 = devpThread.getStation().get(rgvStn.getStaNo2());
                if (staProtocol2 == null) {
                    News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv入库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                    continue;
                } else {
                    staProtocol2 = staProtocol2.clone();
                }
                BasDevp staDetl2 = basDevpService.selectById(rgvStn.getStaNo2());
                if (staDetl2 == null) {
                    News.error("" + mark + " - 1" + " - 2" + " - 入库 ===>>Rgv站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
                    continue;
                }
            }
            if (staProtocol == null) {
                News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv入库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }

            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(rgvStn.getStaNo());
            if (staDetl == null) {
@@ -3236,12 +3281,13 @@
            List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
            WrkMastSta wrkMastSta = wrkMastStaMapper.selectNoInterfere(route, route, Long.valueOf(staProtocol.getWorkNo()));//根据站点工作号和小车工作范围检索任务档

            if( null == wrkMastSta ) {
                News.infoNoLog("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts0, 工作号={}", staProtocol.getWorkNo());
                continue;
            }
            WrkMastSta wrkMastSta2 = wrkMastStaMapper.selectByWorkSta(2, (int) rgvProtocol.getRgvNo());
            boolean result = true;
            boolean result = false;
            if(wrkMastSta2 != null && rgvProtocol.getRgvNo() == 1){ //距离计算   2楼单入库口不需要计算
                 result = rgvCalcDistance((int) rgvProtocol.getRgvNo(),wrkMastSta2.getStaEnd(),wrkMastSta.getStaStart());//工位2放货站点，工位1取货站点
            }
@@ -3252,7 +3298,16 @@
            wrkMastSta.setWorkSta(wrkMastSta2 != null ? 1 : 2);
            wrkMastSta.setRgvNo((int) rgvProtocol.getRgvNo());
            Short direction = 2;//双工位最终抵达位置
            boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta,direction); //命令下发
            boolean sign = false;
            //若取货为工位2且取货口前一站点有物，给双工位同时下发指令
            if(wrkMastSta.getWorkSta() == 2 && staProtocol2 != null && staProtocol2.isLoading() && staProtocol2.getWorkNo() > 0){
                WrkMastSta wrkMastSta3 = wrkMastStaMapper.selectNoInterfere(route, route, Long.valueOf(staProtocol2.getWorkNo()));//根据站点工作号和小车工作范围检索任务档
                wrkMastSta3.setWorkSta(1);
                wrkMastSta3.setRgvNo((int) rgvProtocol.getRgvNo());
                sign =  rgvTakeFullAll2(basRgvMap.getRgvNo(), wrkMastSta, wrkMastSta3);
            }else{
                sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta,direction); //命令下发
            }
            if (sign){
                wrkMastSta.setWrkSts(1);
                try{
@@ -3283,7 +3338,21 @@
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, (int) rgvProtocol.getRgvNo());

            StaProtocol staProtocol2 = null;
            if(rgvStn.getStaNo2()!= null ){
                staProtocol2 = devpThread.getStation().get(rgvStn.getStaNo2());
                if (staProtocol2 == null) {
                    News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv入库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                    continue;
                } else {
                    staProtocol2 = staProtocol2.clone();
                }
                BasDevp staDetl2 = basDevpService.selectById(rgvStn.getStaNo2());
                if (staDetl2 == null) {
                    News.error("" + mark + " - 1" + " - 2" + " - 入库 ===>>Rgv站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
                    continue;
                }
            }
            if (staProtocol == null) {
                News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv出库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                continue;
@@ -3316,12 +3385,29 @@
                News.infoNoLog("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts0, 工作号={}", staProtocol.getWorkNo());
                continue;
            }
            WrkMastSta wrkMastSta2 = wrkMastStaMapper.selectByWorkSta(2, (int) rgvProtocol.getRgvNo());
            boolean result = false;
            if(wrkMastSta2 != null && rgvProtocol.getRgvNo() == 1){ //距离计算   2楼单入库口不需要计算
                result = rgvCalcDistance((int) rgvProtocol.getRgvNo(),wrkMastSta2.getStaEnd(),wrkMastSta.getStaStart());//工位2放货站点，工位1取货站点
            }
            if(result){//若小车距离放货点距离近于取货点则跳过取货 true跳过取货/false优先取货
                rgvThread.setPakRgv(false);
                continue;
            }
            WrkMastSta wrkMastSta1 = wrkMastStaMapper.selectByWorkSta(1, (int) rgvProtocol.getRgvNo());
            wrkMastSta.setWorkSta(wrkMastSta1 != null ? 2 : 1);//若1号工位有任务给2号工位
            wrkMastSta.setRgvNo((int) rgvProtocol.getRgvNo());

            boolean sign = false;
            Short direction = 1;//工位1方向
            boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta, direction); //命令下发
            //若取货为工位2且取货口前一站点有物，给双工位同时下发指令
            if(wrkMastSta.getWorkSta() == 1 && staProtocol2 != null && staProtocol2.isLoading() && staProtocol2.getWorkNo() > 0){
                WrkMastSta wrkMastSta3 = wrkMastStaMapper.selectNoInterfere(route, route, Long.valueOf(staProtocol2.getWorkNo()));//根据站点工作号和小车工作范围检索任务档
                wrkMastSta3.setWorkSta(2);
                wrkMastSta3.setRgvNo((int) rgvProtocol.getRgvNo());
                sign =  rgvTakeFullAll2(basRgvMap.getRgvNo(), wrkMastSta, wrkMastSta3);
            }else{
                sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta,direction); //命令下发
            }
            if (sign){
                wrkMastSta.setWrkSts(1);
                try{
@@ -3435,7 +3521,7 @@
//                        if (staNos.contains(wrkMastSta.getStaStart())) {//非入库口（出库口）限制
//                            continue;
//                        }
//                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
//                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta,null); //命令下发
//                        wrkEnable = true;
//                        if (sign){
//                            wrkMastSta.setWrkSts(1);
@@ -3509,7 +3595,7 @@
                    // 根据输送线plc遍历
                    for (DevpSlave devp : slaveProperties.getDevp()) {
                        // 遍历入库口  入库预调度
                        List<Integer> staNos = Arrays.asList(1042, 1043, 1105, 1104);
                        List<Integer> staNos = Arrays.asList( 1043, 1104,1037);
                        for (Integer staNo : staNos) {
                            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                            StaProtocol staProtocol = devpThread.getStation().get(staNo);
@@ -3520,10 +3606,14 @@
                                rgvCommand.setTaskNo1(9999); // 工位1工作号
                                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  移动
                                rgvCommand.setEndStaNo1(0);   //工位1 放货后要去的位置
                                if(staNo == 1042 || staNo ==1043){
                                    rgvCommand.setTargetPosition1(1042);   //工位1目标站点
                                }else{
                                    rgvCommand.setTargetPosition1(1105);   //工位1目标站点
                                switch (staNo){
                                    case 1043: rgvCommand.setTargetPosition1(1042);break;  //工位1目标站点
                                    case 1104: rgvCommand.setTargetPosition1(1105);break;
                                    case 1037: rgvCommand.setTargetPosition1(1036);break;

                                }
                                if(Objects.equals(basRgvMap.getNowRoute(), staNo)){
                                    continue;
                                }
                                rgvCommand.setCommand(true);   //工位1任务确认
                                if (!MessageQueue.offer(SlaveType.Rgv, (int) rgvProtocol.getRgvNo(), new Task(4, rgvCommand))) {
@@ -3864,6 +3954,96 @@
        }
    }


    /*
     * 小车取货至双工位任务
     * */
    public synchronized boolean rgvTakeFullAll2(Integer rgvId,WrkMastSta wrkMastSta,WrkMastSta wrkMastSta2){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            boolean pakIn1 = true;
            boolean pakIn2 = true;
            rgvCommand.setRgvNo(rgvId); // RGV编号
            if(wrkMastSta.getWrkSts() == 0) {//取货
                if (wrkMastSta.getWorkSta() == 2) {//入库RGV取货
                    rgvCommand.setAckFinish2(false);  // 工位2任务完成确认位
                    rgvCommand.setTaskNo2(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位2工作号
                    rgvCommand.setTaskStatus2(RgvTaskStatusType.FETCH); // 工位2任务模式:  取放货
                    rgvCommand.setEndStaNo2(wrkMastSta.getWrkEnd());   //工位2 放货后要去的位置
                    rgvCommand.setTargetPosition2(wrkMastSta.getStaStart());   //工位2目标站点
                    rgvCommand.setCommand(true);   //工位1任务确认
                    rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                    rgvCommand.setTaskNo1(Math.toIntExact(wrkMastSta2.getWrkNo())); // 工位1工作号
                    rgvCommand.setTaskStatus1(RgvTaskStatusType.FETCH); // 工位1任务模式:  取放货
                    rgvCommand.setEndStaNo1(wrkMastSta2.getWrkEnd());   //工位1 放货后要去的位置
                    rgvCommand.setTargetPosition1(wrkMastSta2.getStaStart());   //工位1目标站点
                    rgvCommand.setCommand(true);   //工位1任务确认
                    rgvCommand.setWrkTaskPri((short) 2); //优先执行工位2任务
                } else {  //出库RGV取货
                    rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
                    rgvCommand.setTaskNo1(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位1工作号
                    rgvCommand.setTaskStatus1(RgvTaskStatusType.FETCH); // 工位1任务模式:  取放货
                    rgvCommand.setEndStaNo1(wrkMastSta.getWrkEnd());   //工位1 放货后要去的位置
                    rgvCommand.setTargetPosition1(wrkMastSta.getStaStart());   //工位1目标站点
                    rgvCommand.setAckFinish2(false);  // 工位2任务完成确认位
                    rgvCommand.setTaskNo2(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位2工作号
                    rgvCommand.setTaskStatus2(RgvTaskStatusType.FETCH); // 工位2任务模式:  取放货
                    rgvCommand.setEndStaNo2(wrkMastSta.getWrkEnd());   //工位2 放货后要去的位置
                    rgvCommand.setTargetPosition2(wrkMastSta.getStaStart());   //工位2目标站点
                    rgvCommand.setWrkTaskPri((short) 1); //出库取货优先执行工位1任务
                    rgvCommand.setCommand(true);   //工位1任务确认
                }
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(2, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                }
            }

//            if(wrkMastSta.getWrkSts() == 2) {//放货
//                if((wrkMastSta.getWorkSta() == 2)){ //工位2任务放货
//                    rgvCommand.setAckFinish2(false);  // 工位2任务完成确认位
//                    rgvCommand.setTaskNo2(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位2工作号
//                    rgvCommand.setTaskStatus2(RgvTaskStatusType.PUT); // 工位2任务模式:  放货
//                    rgvCommand.setEndStaNo2(wrkMastSta.getWrkEnd());   //工位2 放货后要去的位置
//                    rgvCommand.setTargetPosition2(wrkMastSta.getStaEnd());   //工位2目标站点
//                    rgvCommand.setCommand(true);   //工位1任务确认
//                    pakIn2 = false;
//                }else{  //工位1任务放货
//                    rgvCommand.setAckFinish1(false);  // 工位1任务完成确认位
//                    rgvCommand.setTaskNo1(Math.toIntExact(wrkMastSta.getWrkNo())); // 工位1工作号
//                    rgvCommand.setTaskStatus1(RgvTaskStatusType.PUT); // 工位1任务模式:  放货
//                    rgvCommand.setEndStaNo1(wrkMastSta.getWrkEnd());   //工位1 放货后要去的位置
//                    rgvCommand.setTargetPosition1(wrkMastSta.getStaEnd());   //工位1目标站点
//                    rgvCommand.setCommand(true);   //工位1任务确认
//                }
//                if(!pakIn2){
//                    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;
//                    }
//                }else{
//                    if (!MessageQueue.offer(SlaveType.Rgv, 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;
//                    }
//                }
//            }
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 小车取货至工位任务
     * */
@@ -4015,4 +4195,170 @@
        }
    }




    /*
     * arm任务完成自动组托
     * */
    public synchronized void armMissionAccomplished() {
        try{
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历拣料入库口
                for (DevpSlave.Sta armSta : devp.getArmSta()) {
                    // 获取条码扫描仪信息
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, armSta.getBarcode());
                    if (barcodeThread == null) {
                        continue;
                    }
                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                            continue;
                        }
                    } else {
                        continue;
                    }

                    List<BasArm> basArmList = basArmService.selectList(new EntityWrapper<BasArm>()
                            .eq("arm_no", armSta.getArmNo())
                            .eq("sta_no", armSta.getStaNo())
                            .eq("status", 1));
                    for (BasArm basArm : basArmList) {
                        if (basArm.getStatus()!=1){
                            continue;
                        }
                        try{
                            List<BasArmMast> basArmMastList = basArmMastService.selectList(
                                    new EntityWrapper<BasArmMast>()
                                            .eq("arm_no", basArm.getArmNo())
                                            .eq("sorting_line", basArm.getSortingLine())
                                            .eq("status", 3)
                            );
                            if (basArmMastList.isEmpty()){
                                continue;
                            }
                            CombParam combParam = new CombParam(basArmMastList);
                            combParam.setBarcode(barcode);
                            //设置工作空间就绪
                            ReturnT<String> result = new PostMesDataUtils().postMesData("arm任务完成自动组托",wmsUrl, wmsComb, combParam);
                            if (result.getCode()==200){
                                basArmMastService.updateArmMastStatus(basArm.getArmNo(),basArm.getSortingLine(),3,4);
                            } else {
                                log.error("机械臂抓取任务完成："+JSON.toJSON(basArmMastList)+"===》自动组托失败，等待重试");
                            }
                        }  catch (Exception e){
                            log.error("arm编号："+basArm.getArmNo()+"====》机械臂抓取任务完成"+e.getMessage());
                        }
                        break;
                    }
                }
            }
        } catch (Exception e){
            log.error("机械臂抓取任务完成组托失败"+e.getMessage());
        }
    }
    public synchronized void armMissionAccomplishedScanToCheckIn() {
        try{
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历拣料入库口
                for (DevpSlave.Sta armSta : devp.getArmSta()) {

                    List<BasArmMast> basArmMastList = basArmMastService.selectList(
                            new EntityWrapper<BasArmMast>()
                                    .eq("arm_no", armSta.getArmNo())
                                    .eq("sta_no", armSta.getStaNo())
                                    .eq("status", 4)
                    );

                    if (basArmMastList.isEmpty()){
                        continue;
                    }
                    // 获取站点信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(armSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }

                    if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {
                        int workNo = commonService.getWorkNo(6);//待完善
                        // 更新站点信息 且 下发plc命令
                        staProtocol.setWorkNo(workNo);
                        staProtocol.setStaNo(armSta.getStaNoEnd().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        log.error("输送线下发5："+workNo+","+armSta.getStaNoEnd());
                        if (!result) {
                            News.error(""+" - 3"+" - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        }
                        basArmMastService.updateArmMastStatus(basArmMastList.get(0).getArmNo(),basArmMastList.get(0).getSortingLine(),4,5);
                    }
                }
            }
        } catch (Exception e){
            log.error("组托完成驱动托盘扫码入库失败"+e.getMessage());
        }
    }

    /*
     * arm任务下发
     * */
    public synchronized void armTaskAssignment() {
        try{
            List<BasArm> basArmList = basArmService.selectList(new EntityWrapper<>());
            for (BasArm basArm : basArmList) {
                if (basArm.getStatus()!=1){
                    continue;
                }
                try{
                    List<BasArmMast> basArmMastListRuning = basArmMastService.selectList(
                            new EntityWrapper<BasArmMast>()
                                    .eq("arm_no", basArm.getArmNo())
                                    .eq("sorting_line", basArm.getSortingLine())
                                    .eq("status", 1)
                    );
                    List<BasArmMast> basArmMastListRuning3 = basArmMastService.selectList(
                            new EntityWrapper<BasArmMast>()
                                    .eq("arm_no", basArm.getArmNo())
                                    .eq("sorting_line", basArm.getSortingLine())
                                    .eq("status", 3)
                    );
                    if (basArmMastListRuning.isEmpty() && basArmMastListRuning3.isEmpty()){
                        List<BasArmMast> basArmMastList = basArmMastService.selectList(
                                new EntityWrapper<BasArmMast>()
                                        .eq("arm_no", basArm.getArmNo())
                                        .eq("sorting_line", basArm.getSortingLine())
                                        .eq("status", 0)
                        );
                        if (basArmMastList.isEmpty()){
                            continue;
                        }
                        if (basArmMastList.size()>1){
                            log.error("arm编号："+basArm.getArmNo()+"====》拆码垛任务异常禁止下发！！！任务待执行数量大于1！！！");
                            continue;
                        }
                        for (BasArmMast basArmMast:basArmMastList) {
                            ArmTaskAssignmentParam armTaskAssignmentParam = new ArmTaskAssignmentParam(basArmMast.getSortingLine());
                            //设置工作空间就绪
                            ReturnT<String> result = new PostMesDataUtils().postMesData("机械臂抓取任务下发：通知工作空间已就绪",ArmConstant.ARM_URL, ArmConstant.ARM_WORKSPACE, armTaskAssignmentParam);
                            if (result.getCode()==200){
                                basArmMast.setStatus(1);
                                basArmMastService.updateById(basArmMast);
                            } else {
                                log.error("机械臂抓取任务："+JSON.toJSON(basArmMast)+"===》任务信息下发失败");
                            }
                        }
                    }
                }  catch (Exception e){
                    log.error("arm编号："+basArm.getArmNo()+"====》拆码垛任务下发失败"+e.getMessage());
                }
            }
        }catch (Exception e){
            log.error("arm任务下发失败"+e.getMessage());
        }
    }

}