华为昇腾310嵌入式开发重力小球迷宫的部分源码

已于 2024-02-14 22:00:45 修改
阅读量629 收藏 14
点赞数 18
分类专栏： FPGA 文章标签： 华为 java 算法
于 2024-01-14 21:39:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74215144/article/details/135589208
版权
这篇文章详细展示了在华为昇腾310平台上进行的嵌入式实验中，涉及的重力小迷宫游戏的部分源码，包括球体移动、清除点以及地图绘制等函数。代码揭示了如何利用硬件加速器处理传感器数据并更新游戏逻辑。
摘要由CSDN通过智能技术生成

华为昇腾310开发板重力小球迷宫的部分源码

作者：爱写代码的刚子

时间：2024.1.11

前言：本篇博客是对学校嵌入式大实验的记录

void Ball_Point(int x,int y)
{
    DrawPoint(x-1,y-2);
    DrawPoint(x,y-2);
    DrawPoint(x+1,y-2);
    
    DrawPoint(x-2,y-1);
    DrawPoint(x-1,y-1);
    DrawPoint(x,y-1);
    DrawPoint(x+1,y-1);
    DrawPoint(x+2,y-1);
    
    DrawPoint(x-2,y);
    DrawPoint(x-1,y);
    DrawPoint(x,y);
    DrawPoint(x+1,y);
    DrawPoint(x+2,y);
    
    DrawPoint(x-2,y+1);
    DrawPoint(x-1,y+1);
    DrawPoint(x,y);
    DrawPoint(x+1,y+1);
    DrawPoint(x+2,y+1);
    
    DrawPoint(x-1,y+2);
    DrawPoint(x,y+2);
    DrawPoint(x+1,y+2);
}


void Ball_Clear(int x,int y)
{
    ClearPoint(x-1,y-2);
    ClearPoint(x,y-2);
    ClearPoint(x+1,y-2);
    
    ClearPoint(x-2,y-1);
    ClearPoint(x-1,y-1);
    ClearPoint(x,y-1);
    ClearPoint(x+1,y-1);
    ClearPoint(x+2,y-1);
    
    ClearPoint(x-2,y);
    ClearPoint(x-1,y);
    ClearPoint(x,y);
    ClearPoint(x+1,y);
    ClearPoint(x+2,y);
    
    ClearPoint(x-2,y+1);
    ClearPoint(x-1,y+1);
    ClearPoint(x,y);
    ClearPoint(x+1,y+1);
    ClearPoint(x+2,y+1);
    
    ClearPoint(x-1,y+2);
    ClearPoint(x,y+2);
    ClearPoint(x+1,y+2);
}


void DrawBlock(int x,int y)
{
    for(int i=x;i<x+8;i++)
    {
        for(int j=y;j<y+8;j++)
        {
            DrawPoint(i,j);
        }
    }
}

void DrawMap()
{
    DrawBlock(24,0);    
    DrawBlock(32,0);
    DrawBlock(40,0);
    DrawBlock(56,0);
        
    DrawBlock(0,8);
    DrawBlock(8,8);
    DrawBlock(56,8);

    DrawBlock(24,16);
    DrawBlock(32,16);
    DrawBlock(40,16);
    DrawBlock(56,16);

    DrawBlock(0,24);
    DrawBlock(16,24);
    DrawBlock(24,24);
    DrawBlock(56,24);

    DrawBlock(16,32);
    DrawBlock(40,32);

    DrawBlock(0,40);
    DrawBlock(16,40);
    DrawBlock(32,40);
    DrawBlock(40,40);
    DrawBlock(56,40);
    
    DrawBlock(40,48);
    DrawBlock(56,48);
    
    DrawBlock(0,56);
    DrawBlock(8,56);
    DrawBlock(16,56);
    DrawBlock(32,56);
    DrawBlock(40,56);
    DrawBlock(56,56);


}
void set_arr(int arr[][64])
{
        
    set_arr_block(arr,24,0);    
    set_arr_block(arr,32,0);
    set_arr_block(arr,40,0);
    set_arr_block(arr,56,0);


        
    set_arr_block(arr,0,8);
    set_arr_block(arr,8,8);
    set_arr_block(arr,56,8);


    set_arr_block(arr,24,16);
    set_arr_block(arr,32,16);
    set_arr_block(arr,40,16);
    set_arr_block(arr,56,16);


    set_arr_block(arr,0,24);
    set_arr_block(arr,16,24);
    set_arr_block(arr,24,24);
    set_arr_block(arr,56,24);

    set_arr_block(arr,16,32);
    set_arr_block(arr,40,32);
    
    set_arr_block(arr,0,40);
    set_arr_block(arr,16,40);
    set_arr_block(arr,32,40);
    set_arr_block(arr,40,40);
    set_arr_block(arr,56,40);
    
    set_arr_block(arr,40,48);
    set_arr_block(arr,56,48);
    
    set_arr_block(arr,0,56);
    set_arr_block(arr,8,56);
    set_arr_block(arr,16,56);
    set_arr_block(arr,32,56);
    set_arr_block(arr,40,56);
    set_arr_block(arr,56,56);
}


void check_change(int*buff,float*buff_cur,int arr[128][64])
{
    if(abs((int)buff_cur[1]-(int)buff[1])>3||abs((int)buff_cur[0]-(int)buff[0])>3)
    {
        if(buff_cur[0]>buff[0])
        {
            buff_cur[0]=buff[0]+2;
        }
        else
        {
            buff_cur[0]=buff[0]-2;
        }
        if(buff_cur[1]>buff[1])
        {
            buff_cur[1]=buff[1]+2;
        }
        else
        {
            buff_cur[1]=buff[1]-2;
        }
    }
    int flag=0;
    int flag2=0;
    
    if((int)buff_cur[1]-3<0)//x
    {
        int a=(int)buff_cur[1]-3;
        buff[1]=(int)buff_cur[1]-a;
        buff[0]=(int)buff_cur[0];
        flag=1;
    }
    if((int)buff_cur[0]-3<0)//y
    {
        int a=(int)buff_cur[0]-3;
        buff[0]=(int)buff_cur[0]-a;
        buff[1]=(int)buff_cur[1];
        flag=1;
    }
    if((int)buff_cur[1]+3>=128)
    {
        int a=(int)buff_cur[1]-127;
        buff[1]=(int)buff_cur[1]-a;
        buff[0]=(int)buff_cur[0];
        flag=1;
    }   
    if((int)buff_cur[0]+3>=64)
    {
        int a=(int)buff_cur[0]-63
                  buff[0]=(int)buff_cur[0]-a;
        buff[1]=(int)buff_cur[1];
        flag=1;
    }


    if(flag)return;

    if(arr[(int)buff_cur[1]][(int)buff_cur[0]-3]==1)
    {
        while(1)
        {
            (int)buff_cur[0]++;
            if(arr[(int)buff_cur[1]][(int)buff_cur[0]-3]==0)break;  

        }
        buff[0]=(int)buff_cur[0];
        buff[1]=(int)buff_cur[1];
        flag2=1;
    }

    if(arr[(int)buff_cur[1]][(int)buff_cur[0]+3]==1)
    {
        while(1)
        {
            (int)buff_cur[0]--;
            if(arr[(int)buff_cur[1]][(int)buff_cur[0]+3]==0)break;  

        }
        buff[0]=(int)buff_cur[0];
        buff[1]=(int)buff_cur[1];
        flag2=1;
    }

    if(arr[(int)buff_cur[1]-3][(int)buff_cur[0]]==1)
    {
        while(1)
        {
            (int)buff_cur[1]++;
            if(arr[(int)buff_cur[1]-3][(int)buff_cur[0]]==0)break;  

        }
        buff[1]=(int)buff_cur[1];
        buff[0]=(int)buff_cur[0];
        flag2=1;
    }

    if(arr[(int)buff_cur[1]+3][(int)buff_cur[0]]==1)
    {
        while(1)
        {
            (int)buff_cur[1]--;
            if(arr[(int)buff_cur[1]+3][(int)buff_cur[0]]==0)break;  

        }
        buff[1]=(int)buff_cur[1];
        buff[0]=(int)buff_cur[0];
        flag2=1;
    }

    if(flag2)return;        
    
    buff[0]=buff_cur[0];
    buff[1]=buff_cur[1];
}
void Labyrinth()
{
    oled_init();
    adxl345_Init();
    int arr[128][64];
    set_arr(arr);
    int buff[3]={5,3,0};
    float buff_cur[3];
    while(1)
    {
        ColorTurn(TURNOVER_COLOR);
        DisplayTurn(NORMAL_DISPLAY);
        DrawMap();
        Ball_Point((int)buff[1],(int)buff[0]);
        Refresh();
        Ball_Clear((int)buff[1],(int)buff[0]);
        adxl345_GetData(buff_cur);
        //修正
        check_change(buff,buff_cur,arr);
    }
}

给出部分源码是因为这个实验是在Ascend310项目之上的，调用了一些外设的接口，给出来是在是太麻烦，主要是提供思路。

爱写代码的刚子
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
极智开发 | 谈谈昇腾 Ascend310 AI Core 资源利用率
极智视界
02-01 2660
大家好，我是极智视界，本文主要谈谈昇腾 Ascend310 AI Core 资源利用率。
基于Atlas200 DK开发板，Ascend310芯片的嵌入式系统：模拟温度检测系统
weixin_51894564的博客
03-04 1760
嵌入式系统；Atlas200;Ascend310
华为昇腾310B初体验，OrangePi AIpro开发板使用测评
刘墨苏的技术博客
05-27 3008
在这几天的体验OrangePi AiPro开发板的过程中，上手体验非常好，优点如下：官方提供的系统镜像已经做了很多预先的配置工作，可以更快上手。如默认开启的ssh、vnc服务等，内置的docker、conda、torch_npu、MindSpore等等，这对新手来说就少了很多配环境的折磨，可以更快的进入到AI应用的学习和实践。对于发布半年左右的开发板，提供的开发资料非常详细。用户手册写的非常详细了，对 Linux 内核源码包和Linux 镜像编译脚本都做了详细的说明。支持昇腾技术路线。
华为昇腾嵌入式实验一
weixin_50039698的博客
11-17 569
华为昇腾嵌入式实验
青云1000------华为昇腾310
Johnor的博客
10-09 1344
可以关注我的博客查找相关资料。： 如果你想在新的虚拟环境中使用与旧环境相同的包，可以将已安装的包列表导出并在新环境中导入。现在，你已经成功将虚拟环境中的Python版本更改为Python 3.6，并且可以在新环境中使用该版本的Python。不同环境下的python版本和包是独立的，好处是可以在系统中安装多个版本的python和多个版本的包。： 首先，创建一个新的虚拟环境，使用你希望的Python版本（这里是Python 3.6）。的虚拟环境，并将你的终端环境切换到使用Python 3.6。
PC访问华为昇腾开发板的摸索过程
clever101的专栏
11-22 1068
PC访问华为昇腾开发板的摸索过程。
重磅推荐-嵌入式开发常用算法工具类源码&规范合集（100+份）.zip
03-22
重磅推荐，嵌入式开发常用算法工具类源码&规范合集，共100+份。 1、常用算法源码 左倾堆.zip 最小生成树.zip 最短路径算法.zip 最大子段和问题的简单算法.zip 最大访客数.zip 最大m子段问题.zip 最长公共子序列问题...
5gwp华为源码 最新二开网站华为5G源码完整运营版
06-08
这种源码可能是由华为公司开发，或者是基于华为提供的5G开发平台进行二次开发的成果。"最新二开网站华为5G源码完整运营版"则说明这是一个已经过二次开发并且适配了运营需求的版本，意味着它不仅包含基础的源代码，还...
HUAWEI-EMBEDED.rar_华为嵌入式_嵌入式笔试_笔试题 嵌入式
09-20
理解微控制器(MCU)和系统级芯片(SoC)的区别，以及如何选择合适的处理器来满足项目需求是嵌入式开发的基础。 2. **嵌入式编程语言**：嵌入式开发中，C语言是最常用的语言，因为它高效、接近硬件，便于底层操作。理解...
华为b310刷机
06-05
华为b310刷机
android迷宫小球
11-27
android小游戏 游戏开发 适合初学者研究
Android游戏 迷宫小球 源代码
04-23
Android 游戏代码 迷宫小球 源代码详解 适合初学者参考学习
华为EM310 GPRS模块完整开发资料
06-05
10. **嵌入式系统集成**：将EM310模块集成到嵌入式系统中，需要编写驱动程序和应用程序，这部分涉及嵌入式系统编程和硬件接口设计，开发者应具备相应的编程技能和硬件知识。 以上就是华为EM310 GPRS模块开发过程中...
搭载昇腾310NPU的Orange Pi AIpro开箱体验以及深度学习样例测试
Johnor的博客
05-27 1344
话不多说先放两张Orange Pi AIpro的全身照，可以看到板子还是很漂亮的。Atlas 200计算模块作为开发板的CPU与NPU。模块集成了Ascend 310处理器，可以高效地高效能低功耗： 昇腾310采用7nm工艺制造，拥有高效的能耗比，能够在提供强大计算能力的同时保持较低的功耗，非常适合嵌入式和边缘计算应用。强大计算能力。
香橙派OriengePi AiPro 华为昇腾芯片开发板开箱测评
最新发布
机器人梦想家 Bing
05-30 1618
博主有幸受邀CSDN测评香橙派与华为昇腾共同研发的OriengePi AiPro的开箱测评，本文会对正常使用的一些情况做记录，包括常用配置，docker配置使用，以及可能包含机器人相关的一些配置等，同时也会对产品的性能及使用的感受做分享。2023.12月初，香橙派联合华为发布了基于昇腾的Orange Pi AIpro开发板，提供8/20TOPS澎湃算力，能覆盖生态开发板者的主流应用场景，让用户实践各种创新场景，并为其提供配套的软硬件。而价格更是极为亲民。
arm 升腾310_华为Atlas智能计算平台，基于华为自主研发的“昇腾310AI芯片”
weixin_31585653的博客
12-31 3241
在面对恶劣和复杂的自然环境时，同时，改变每个行业，为客户提供高性能、覆盖全场景的行业解决方案，“AI作为一种新的通用目的技术，并在此基础上构建华为全栈全场景AI解决方案，迈向智能化时代提供智能计算的底座，单台可提供16 TOPS INT8的处理惩罚能力，将成为一种基础能力，加速各行各业的智能化再造，可广泛的应用于聪明都会、运营商、金融、互联网、电力等领域，每个组织，同时，Atlas 200 DK ...
AI芯片：华为昇腾（ASCEND）310结构分析
热门推荐
evolone的专栏
05-18 1万+
华为的麒麟SOC中使用的是寒武纪的AI芯片模块。 但是，华为自己也推出了自有的AI芯片架构。 本文根据华为公布的信息，简单分析下其结构。 所有信息都来自互联网，来自华为的官方信息。 感谢华为的分享！！ 首先看看，华为发布的一张海报，如下图所示。 整体采用华为自研的达芬奇架构，采用高性能的3D Cube计算引擎。 因为兴趣及工作领域的因素，我更关注其芯片内部的AI 卷积核的设计。 从海报中能够看出...
深度：华为芯片的自研之旅
weixin_45727359的博客
10-15 2619
本文将对华为公司的芯片产业布局进行全面梳理。文章将围绕以下内容依序展开：1、华为公司三十年芯片自研之旅回溯2、快速崛起的计算芯片双底座：鲲鹏、昇腾3、从追赶到领跑的手机SoC芯片：麒麟4...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱写代码的刚子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值