#码垛位自动补充空板：码垛完成下一步执行实装

LSH

2023-07-25 136717ef591afb69723440be32b99cbdc6a48407

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

@@ -21,6 +21,8 @@
import com.zy.common.service.CommonService;
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.RedisUtil;
import com.zy.common.utils.RgvUtils;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.cache.MessageQueue;
@@ -89,6 +91,8 @@
    private BasRgvErrLogService basRgvErrLogService;
    @Autowired
    private BasRgvPathService basRgvPathService;
    @Autowired
    private RedisUtil redisUtil;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -530,6 +534,7 @@
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol == null) {

                continue;
            }
            BasRgv basRgv = basRgvService.selectById(rgv.getId());
@@ -581,6 +586,8 @@
        for (WrkMast wrkMast : wrkMasts) {
            //目标站
            Integer staNo = wrkMast.getStaNo();
            //源站
            Integer sourceStaNo = wrkMast.getSourceStaNo();
            //通过目标站搜索rgv号
            Integer rgvNo = this.searchRgvNo(staNo);
            if (rgvNo == null) {//未找到可用的rgv
@@ -627,6 +634,24 @@
                            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编号
@@ -655,6 +680,24 @@
                            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编号
@@ -679,6 +722,24 @@
                        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();
@@ -708,6 +769,24 @@
                            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编号
@@ -733,6 +812,10 @@

            }
        }
    }

    private boolean rgvIoExecuteWrk2To3() {
        return false;
    }

    /**
@@ -1718,9 +1801,24 @@
                    wrkMast1.setWrkSts(27L);//27.RGV放货完成
                }

                //解锁路径
                RgvUtils.unLockPath(wrkMast1.getRgvNo());

                wrkMast1.setModiTime(now);
                if (wrkMastMapper.updateById(wrkMast1) == 0) {
                    log.error("工位1修改工作档状态失败！！，工作号={}", wrkMast1.getWrkNo());
                }

                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgv.getId()); // RGV编号
                rgvCommand.setAckFinish1((short) 1);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.NONE); // 工位1任务模式:  无
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
                    //step=2,工位1、2任务确认；   step=4，工位1确认；     step=5，工位2任务确认
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgv.getId(), JSON.toJSON(rgvCommand));
                }

//                //工位1取货完成后，工位2是无货空闲状态时，准备给工位2发任务，确认是否有待执行RGV任务
@@ -2394,7 +2492,12 @@
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

                        SearchLocParam param = new SearchLocParam();
                        param.setIoType(10);
                        if (emptyInSta.getStaNo().equals(214)){
                            //拆盘机处空板扫码，驱动托盘向码垛位，不入库
                            param.setIoType(201);
                        }else {
                            param.setIoType(10);
                        }
                        param.setSourceStaNo(emptyInSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
@@ -2422,64 +2525,7 @@
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }


//                    // 检索库位
//                    LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//                    StartupDto startupDto = commonService.getLocNo(1, 10, emptyInSta.getStaNo(), null, locTypeDto, 0);
//                    // 工作号
//                    int workNo = startupDto.getWorkNo();
//
//                    try {
//                        // 插入工作主档
//                        WrkMast wrkMast = new WrkMast();
//                        wrkMast.setWrkNo(workNo);
//                        wrkMast.setIoTime(new Date());
//                        wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
//                        wrkMast.setIoType(10); // 入出库状态：10.空板入库
//                        wrkMast.setIoPri(10D); // 优先级：10
//                        wrkMast.setCrnNo(startupDto.getCrnNo());
//                        wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
//                        wrkMast.setStaNo(startupDto.getStaNo());
//                        wrkMast.setLocNo(startupDto.getLocNo());
//                        wrkMast.setFullPlt("N"); // 满板
//                        wrkMast.setPicking("N"); // 拣料
//                        wrkMast.setExitMk("N"); // 退出
//                        wrkMast.setEmptyMk("Y"); // 空板
//                        wrkMast.setLinkMis("N");
////                    wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
//                        // 操作人员数据
//                        wrkMast.setAppeTime(new Date());
//                        wrkMast.setModiTime(new Date());
//                        Integer insert = wrkMastMapper.insert(wrkMast);
//                        if (insert == 0) {
//                            throw new CoolException("保存工作档失败");
//                        }
//                        // 更新目标库位状态
//                        LocMast locMast = locMastService.selectById(startupDto.getLocNo());
//                        locMast.setLocSts("S"); // S.入库预约
//                        locMast.setModiTime(new Date());
//                        if (!locMastService.updateById(locMast)){
//                            throw new CoolException("改变库位状态失败");
//                        }
//                        // 命令下发区 --------------------------------------------------------------------------
//
//                        // 更新站点信息 且 下发plc命令
//                        staProtocol.setWorkNo((short) workNo);
//                        staProtocol.setStaNo(startupDto.getStaNo().shortValue());
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                        if (!result) {
//                            throw new CoolException("更新plc站点信息失败");
//                        }
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                    }

                }


            }
        }
    }
@@ -2841,7 +2887,21 @@
     * 初始化RGV地图
     */
    public synchronized void initRgvMap() {

        Object data = redisUtil.get("rgv_map");
        if (data == null) {
            //重新获取全路径地图
            BasRgvPath basRgvPath = basRgvPathService.selectByRgvNo(0);//获取默认路径
            if (basRgvPath != null) {
                ArrayList<RgvNode> rgvNodes = new ArrayList<>();
                List<Integer> rgvPath = JSON.parseArray(basRgvPath.getPath(), Integer.class);
                for (Integer integer : rgvPath) {
                    RgvNode rgvNode = new RgvNode(integer);
                    rgvNodes.add(rgvNode);
                }
                //将数据库地图数据存入redis
                redisUtil.set("rgv_map", JSON.toJSONString(rgvNodes));
            }
        }
    }

    /**
@@ -3148,4 +3208,117 @@
            }
        }
    }

    /**
     * 其他  ===>> 码垛位自动补充空板：驱动拆盘机输出托盘
     */
    public synchronized void dischargingMachineOutputTray() {
        try {
            List<WrkMast> wrkMasts = wrkMastMapper.selectDischargingMachineOutputTray();
            if (Cools.isEmpty(wrkMasts) || wrkMasts.size()>3){
                return;
            }

            // 获取入库站信息
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocol = devpThread.getStation().get(213);
            if (staProtocol == null) {
                log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点查询失败");
                return;
            } else {
                staProtocol = staProtocol.clone();
            }

            if (!staProtocol.isLoading()){
                log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点无物，正在自动调出空板！");
                int i = wrkMastMapper.selectConfigCount10468N();
                if (i==1){
                    wrkMastMapper.updateConfig10468Y();
                }
                return;
            }else {
                int i = wrkMastMapper.selectConfigCount10468N();
                if (i==0){
                    return;
                }
            }
            StaProtocol staProtocol214 = devpThread.getStation().get(214);
            // 判断是否满足入库条件
            if (staProtocol.isAutoing() && staProtocol.getWorkNo() == 0 && staProtocol.isPakMk() && staProtocol214.getWorkNo()==0) {
                staProtocol.setWorkNo((short)9999);
                staProtocol.setStaNo((short)214);
                devpThread.setPakMk(staProtocol.getSiteId(), false);
                boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                if (!result) {
                    throw new CoolException("更新plc站点信息失败==>码垛位自动补充空板：驱动拆盘机输出托盘！");
                }
                log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发成功：工作号9999、目标站214！");
            }else {
                log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点状态不符合！");
            }
        }catch (Exception e){
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    /**
     * 其他  ===>> 拆盘机处空板扫码，驱动托盘向码垛位，不入库
     */
    public synchronized void scanBarcodeEmptyBoard() {
        try {

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

    /**
     * 其他  ===>> 码垛完成驱动托盘下一步扫码入库
     */
    public synchronized void stackingCompletionDriveTray() {
        try {
            List<WrkMast> wrkMasts = wrkMastMapper.selectStackingCompletionDriveTray();
            if (Cools.isEmpty(wrkMasts) || wrkMasts.size()==0){
                return;
            }

            for (WrkMast wrkMast : wrkMasts){
                wrkMast.setWrkSts(44L);
                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getStaNo());
                if (staProtocol == null) {
                    log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点查询失败");
                    return;
                } else {
                    staProtocol = staProtocol.clone();
                }

                if (!staProtocol.isLoading()){
                    log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点无物，正在自动调出空板！");
                    return;
                }
                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.getWorkNo().equals(wrkMast.getWrkNo().shortValue()) && staProtocol.isPakMk()) {
                    staProtocol.setWorkNo((short)9999);
                    int staNo = wrkMast.getStaNo() + 1;
                    staProtocol.setStaNo((short)staNo);
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                    if (!result) {
                        throw new CoolException("更新plc站点信息失败==>码垛位自动补充空板：驱动拆盘机输出托盘！");
                    }
                    log.info("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发成功：工作号9999、目标站214！");
                    wrkMastMapper.updateStackingCompletionDriveTray(wrkMast.getWrkNo());
                }else {
                    log.error("码垛位自动补充空板：驱动拆盘机输出托盘，任务下发失败，站点状态不符合！");
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
}