TDA4VM EVM学习笔记（1）:屏幕上显示图形文件

已于 2023-04-18 17:45:28 修改
阅读量768 收藏 9
点赞数 3
分类专栏： TDA4VM 文章标签： 学习 笔记
于 2023-04-18 17:33:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/walker_bk/article/details/130211213
版权

本文介绍了基于TDA4VM EVM在屏幕上显示图形文件的实现步骤

1. 按照TI官方要求创建在Linux操作系统下的开发环境。目标可以在Vision_apps使用make生成目标文件。本文的环境是基于SDK8.0.5，Ubuntu 20.04 LTS + Docker

2. 在vision_apps/apps创建文件夹custom_usecase; 在custom_usecase下创建my_disp_img文件夹

3. 在my_disp_img文件夹下创建以下文件

a. concerto.mak

ifeq ($(TARGET_CPU),$(filter $(TARGET_CPU), x86_64 A72))

include $(PRELUDE)

TARGET      := my_disp_img

CSOURCES    := main.c

ifeq ($(TARGET_CPU),A72)
ifeq ($(TARGET_OS),$(filter $(TARGET_OS), LINUX QNX))

TARGETTYPE  := exe

CSOURCES    += main_linux_arm.c

include $(VISION_APPS_PATH)/apps/concerto_a72_inc.mak

endif
endif

ifeq ($(TARGET_OS),SYSBIOS)
ifeq ($(TARGET_CPU),$(filter $(TARGET_CPU), A72))
TARGETTYPE  := library
endif
endif

include $(FINALE)

endif

b. app_common.h

#ifndef _APP_COMMON
#define _APP_COMMON

#include <TI/tivx.h>
#include <TI/tivx_task.h>
#include <tivx_utils_file_rd_wr.h>

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/stat.h>
#include <float.h>
#include <math.h>

//#define APP_DEBUG

#define APP_MAX_FILE_PATH           (256u)
#define APP_ASSERT(x)               assert((x))
#define APP_ASSERT_VALID_REF(ref)   (APP_ASSERT(vxGetStatus((vx_reference)(ref))==VX_SUCCESS));

#define MAX_IMG_WIDTH  (2048)
#define MAX_IMG_HEIGHT (1024)
#define DISPLAY_WIDTH  (1280)
#define DISPLAY_HEIGHT (720)

#ifdef APP_DEBUG
#define APP_PRINTF(f_, ...) printf((f_), ##__VA_ARGS__)
#else
#define APP_PRINTF(f_, ...)
#endif

#endif

c. main.c

#include "app_common.h"

typedef struct {
    /* config options */
    char input_file_path[APP_MAX_FILE_PATH];
    char input_file_list[APP_MAX_FILE_PATH];

    /* Input image params */

    tivx_utils_bmp_image_params_t imgParams;
    vx_uint32 img_width;
    vx_uint32 img_height;
    vx_uint32 img_stride;

    /* OpenVX references */
    vx_context context;

    vx_graph   disp_graph;
    vx_node    disp_node;
    vx_image   disp_image;

    vx_user_data_object disp_params_obj;
    tivx_display_params_t disp_params;

    vx_uint32 display_option;
    vx_uint32 delay_in_msecs;

    tivx_task task;
    uint32_t stop_task;
    uint32_t stop_task_done;
} AppObj;

AppObj gAppObj;

static vx_status app_init(AppObj *obj);
static void app_deinit(AppObj *obj);
static vx_status app_create_graph(AppObj *obj);
static vx_status app_verify_graph(AppObj *obj);
static vx_status app_run_graph(AppObj *obj);
static vx_status app_run_graph_interactive(AppObj *obj);
static void app_delete_graph(AppObj *obj);

int app_disp_img_main()
{
    int status = 0;
    AppObj *obj = &gAppObj;
    status = app_init(obj);
    if(status == VX_SUCCESS)
    {
        status = app_create_graph(obj);
    }
    if(status == VX_SUCCESS)
    {
        status = app_verify_graph(obj);
    }
    if(status == VX_SUCCESS)
    {
        status = app_run_graph_interactive(obj);
        
    }
    app_delete_graph(obj);
    app_deinit(obj);
    return status;
}

static int app_init(AppObj *obj)
{
    APP_PRINTF("disp_img: Init ... \n");
    obj->context = vxCreateContext();
    APP_ASSERT_VALID_REF(obj->context);
    obj->disp_image = vxCreateImage(obj->context, DISPLAY_WIDTH, DISPLAY_HEIGHT, VX_DF_IMAGE_RGB);
    APP_ASSERT_VALID_REF(obj->disp_image)
 
    memset(&obj->disp_params, 0, sizeof(tivx_display_params_t));

    obj->disp_params.opMode = TIVX_KERNEL_DISPLAY_BUFFER_COPY_MODE;
    obj->disp_params.pipeId = 0;
    obj->disp_params.outWidth = DISPLAY_WIDTH;
    obj->disp_params.outHeight = DISPLAY_HEIGHT;
    obj->disp_params.posX = (1920-DISPLAY_WIDTH)/2;
    obj->disp_params.posY = (1080-DISPLAY_HEIGHT)/2;

    obj->disp_params_obj = vxCreateUserDataObject(obj->context, "tivx_display_params_t", sizeof(tivx_display_params_t), &obj->disp_params);
    APP_ASSERT_VALID_REF(obj->disp_params_obj)

    obj->delay_in_msecs = 1000; 

    tivxHwaLoadKernels(obj->context);
    snprintf(obj->input_file_path, APP_MAX_FILE_PATH-1, "%s",
        "/opt/vision_apps/test_data/psdkra/app_tidl");

    snprintf(obj->input_file_list, APP_MAX_FILE_PATH-1, "%s",
        "/opt/vision_apps/test_data/psdkra/app_tidl/names.txt");

    APP_PRINTF("disp_img: Init ... Done.\n");

    return 0;
}

static void app_deinit(AppObj *obj)
{
    tivxHwaUnLoadKernels(obj->context);
    vxReleaseContext(&obj->context);
    APP_PRINTF("disp_img: De-init ... Done.\n");
}

static void app_delete_graph(AppObj *obj)
{
    APP_PRINTF("disp_img: Delete ... \n");
    vxReleaseNode(&obj->disp_node);
    vxReleaseGraph(&obj->disp_graph);
    APP_PRINTF("disp_img: Delete ... Done.\n");
}

static vx_status app_create_graph(AppObj *obj)
{
    vx_status status = VX_SUCCESS;
    APP_PRINTF("disp_img: Creating graph ... \n");

    /* Create OpenVx Graph */
    obj->disp_graph = vxCreateGraph(obj->context);
    APP_ASSERT_VALID_REF(obj->disp_graph)
    vxSetReferenceName((vx_reference)obj->disp_graph, "Display");

    obj->disp_node = tivxDisplayNode(obj->disp_graph, obj->disp_params_obj, obj->disp_image);
    APP_ASSERT_VALID_REF(obj->disp_node)

    vxSetNodeTarget(obj->disp_node, VX_TARGET_STRING, TIVX_TARGET_DISPLAY1);

    /* Set names for diferent OpenVX objects */
    vxSetReferenceName((vx_reference)obj->disp_params_obj, "DisplayParams");
    vxSetReferenceName((vx_reference)obj->disp_node, "DisplayNode");

    APP_PRINTF("disp_img: Creating graph ... Done.\n");
    return status;
}

static void app_run_task(void *app_var)
{
    AppObj *obj = (AppObj *)app_var;
    vx_status status = VX_SUCCESS;

    while(!obj->stop_task)
    {
        status = app_run_graph(obj);
        if(status == VX_FAILURE)
        {
            printf("Error processing graph!\n");
            obj->stop_task = 1;
        }
    }
    obj->stop_task_done = 1;
}

static int32_t app_run_task_create(AppObj *obj)
{
    tivx_task_create_params_t params;
    int32_t status;

    tivxTaskSetDefaultCreateParams(&params);
    params.task_main = app_run_task;
    params.app_var = obj;

    obj->stop_task_done = 0;
    obj->stop_task = 0;

    status = tivxTaskCreate(&obj->task, &params);

    return status;
}

static void app_run_task_delete(AppObj *obj)
{
    while(obj->stop_task_done==0)
    {
         tivxTaskWaitMsecs(100);
    }

    tivxTaskDelete(&obj->task);
}

static char menu[] = {
    "\n"
    "\n ================================="
    "\n Display the images from file"
    "\n ================================="
    "\n"
    "\n x: Exit"
    "\n"
    "\n Enter Choice: "
};

static vx_status app_run_graph_interactive(AppObj *obj)
{
    vx_status status = VX_SUCCESS;
    uint32_t done = 0;
    char ch;
    
    status = app_run_task_create(obj);
    if(status != VX_SUCCESS)
    {
        printf("disp_img: ERROR: Unable to create task\n");
    }
    else
    {
        
        while((!done) && (status == VX_SUCCESS))
        {
            printf(menu);
            ch = getchar();
            printf("\n");

            if(ch == 'x')
            {
                obj->stop_task = 1;
                done = 1;
                break;
            }
        }
        app_run_task_delete(obj);
    }
    return status;
}

static vx_status app_verify_graph(AppObj *obj)
{
    vx_status status = VX_SUCCESS;

    APP_PRINTF("disp_img: Verifying graph ... \n");

    /* Verify the TIDL Graph */
    status = vxVerifyGraph(obj->disp_graph);
    if(status != VX_SUCCESS)
    {
        printf("disp_img: ERROR: Verifying display graph ... Failed !!!\n");
        return status;
    }

    APP_PRINTF("disp_img: Verifying display graph ... Done.\n");

    /* wait a while for prints to flush */
    tivxTaskWaitMsecs(100);

    return status;
}

static vx_status app_run_graph_for_one_frame(AppObj *obj, char *curFileName, vx_uint32 counter)
{
    vx_status status = VX_SUCCESS;
    vx_char input_file_name[APP_MAX_FILE_PATH];

    //Clear the full image to black
    void *base_ptr = NULL;
    vx_uint32 plane = 0;
    vx_rectangle_t rect;
    vx_imagepatch_addressing_t addr;
    vx_map_id map_id;
    rect.start_x = rect.start_y = 0;
    rect.end_x = DISPLAY_WIDTH;
    rect.end_y = DISPLAY_HEIGHT;
    status = vxMapImagePatch(obj->disp_image, &rect, plane, &map_id, 
                            &addr, &base_ptr,
                            VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0);
    if (status == VX_SUCCESS)
    {
        APP_PRINTF("Mapping successful!\n");
        vx_uint32 x,y;
        vx_uint8 pixel = 0;
        /* 2d addressing access */        
        for (y = 0; y < addr.dim_y; y+=addr.step_y) 
        {
            for (x = 0; x < addr.dim_x; x+=addr.step_x) 
            {
                vx_uint8 *ptr2 = vxFormatImagePatchAddress2d(base_ptr,
                    x, y, &addr);
                *ptr2 = pixel; 
                *(ptr2+1) = pixel;
                *(ptr2+2) = pixel;
            }
        } 
        status = vxUnmapImagePatch(obj->disp_image, map_id);
    }
    else
    {
        APP_PRINTF("Mapping failed!\n");
    }
    snprintf(input_file_name, APP_MAX_FILE_PATH-1, "%s/%s",
          obj->input_file_path,
          curFileName
          );
    APP_PRINTF("disp_img: Reading input file %s ... \n", curFileName); 
    /* Read input from file */
    status = tivx_utils_load_vximage_from_bmpfile ( obj->disp_image, input_file_name, (vx_bool)vx_false_e);
    APP_PRINTF("disp_image: Reading input file Done!\n");
    /* Execute the display graph */
    if(status == VX_SUCCESS)
    {
        status = vxProcessGraph(obj->disp_graph);
    }
    APP_PRINTF("disp_img: Running display graph ... Done.\n");
    return status;
}

static vx_status app_run_graph(AppObj *obj)
{
    vx_status status = VX_SUCCESS;
    vx_char curFileName[APP_MAX_FILE_PATH];
    uint64_t cur_time;
    uint64_t max_frames = INT64_MAX;
    vx_uint32 counter = 0;
    FILE* test_case_file;

    test_case_file =  fopen(obj->input_file_list,"r");
    if(test_case_file==NULL)
    {
        printf("Open file Error");
        status = VX_FAILURE;
    }
    if(status == VX_SUCCESS)
    {
        while (fgets(curFileName, sizeof(curFileName), test_case_file) && (counter < max_frames))
        {
            curFileName[strlen(curFileName) - 1] = 0;

            cur_time = tivxPlatformGetTimeInUsecs();

            APP_PRINTF("Input file: %s ...\n", curFileName);
            if(status == VX_SUCCESS)
            {
                status = app_run_graph_for_one_frame(obj, curFileName, counter++);
            }
            APP_PRINTF("Display input file %s ...Done!\n", curFileName);

            cur_time = tivxPlatformGetTimeInUsecs() - cur_time;
            /* convert to msecs */
            cur_time = cur_time/1000;

            if(cur_time < obj->delay_in_msecs)
            {
                tivxTaskWaitMsecs(obj->delay_in_msecs - cur_time);
            }

            /* user asked to stop processing */
            if(obj->stop_task || (status != VX_SUCCESS))
            {
                break;
            }
       }
       fclose(test_case_file);
    }
    return status;
}

备注：记得将图像文件的路径和文件列表替换为自己。本文中使用的test_data集中的文件。

d. main_linux_arm.c

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>
#include <TI/tivx.h>
#include <utils/app_init/include/app_init.h>

int main()
{
    int status = 0;
    
    status = appInit();
    
    if(status==0)
    {
        int app_disp_img_main();
        
        status = app_disp_img_main();
        appDeInit();
    }
    
    return status;
}

4. 在vision_apps下使用make生成可执行文件my_disp_img.out

5. 将文件my_disp_img.out拷贝至开发板/opt/vision_apps下

6. 运行my_disp_img.out将可以看到存储在EVM上的文件可以依次显示在屏幕上，时间间隔为1秒。

【函数说明】

1. tivx_utils_load_vximage_from_bmpfile()

函数定义：

vx_status tivx_utils_load_vximage_from_bmpfile(vx_imageimage,
char * filename,
vx_boolconvert_to_gray_scale 
)

函数功能：

将BMP文件的图像加载到已经创建的vx_image对象中。

参数

image[in] 已经创建的图像对象
filename[in] 扩展名为bmp的图像文件的文件名
convert_to_gray_scale[in] vx_true_e: 将图像文件中RGB转化为8b灰度值
vx_false_e: 保留原始RGB值
备注：目前不能转化

返回值：

VX_SUCCESS：如果BMP文件可以成功加载到image的对象中

【参考信息】

  1. Ti SDK version 8.0.5： Processor SDK Linux Software Developer’s Guide — Processor SDK Linux for J721e Documentation
     
耀眼宝玉
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
[TI TDA4 J721E]TIOVX OpenVX Graph Pipelining理解和移植使用（更新版）
AIRKernel的博客
02-18 5358
关于Piplining的一些总结和使用 Enqueue 和Dequeue一些使用方法等
tda4vm.pdf
03-15
TI TDA4VM 芯片datsheet 包含芯片的简介，特点介绍，芯片架构和芯片提供的功能,以及芯片各种详细参数
TDA4 J721 EVM开发板开发学习
weixin_47995004的博客
04-12 3070
TDA4
[TI TDA4 J721E](升级版)单屏显示多路摄像头数据(img_mosaic_module节点使用)
AIRKernel的博客
11-08 2239
前几天写了一个关于单屏多显示的帖子： [TI TDA4]TIOVX 单屏显示多路摄像头数据(Mosaic节点使用)_AIRKernel的博客-CSDN博客 当时只是研究了其中的一个Demo，这个Demo里面的图像显示还是有点问题，应该是当时作者算法的问题，我也没有详细研究。 这两天重新梳理了以下，发现有一个Node是专门做这个图像镶嵌的工作的，img_mosaic节点。 这篇博客就写一下这个节点的移植和实际应用。 首先看一下效果图： 这里可以......
TDA4 IPC基本介绍
libuping2023的博客
08-11 516
TI J7 DRA8xx/TDA4xx、AM65xx、J6家族的处理器，基于异构、可扩展的架构开发，拿TDA4VM的处理器来说，该处理器包含了TI DSP处理器（C66/C7x）、Cortex A72、Main域Cortex R5F、MCU域Cortex R5F、深度学习加速器MMA、图形处理器GPU等核，属于多核异构的架构。
TDA4VM板卡启动分析
YGZ_hao的博客
04-12 1397
本篇文章主要分析TDA4VM板卡的启动过程，对于TDA4VM板卡加深了解。TDA4VM板卡通过u-boot启动，引导内核后进入TI的edgeAI界面，在下文对此进行详细分析。
在tda4vm evm上基于v4l2实现使用usb摄像头采集数据并显示
05-02
本文将详细介绍如何在TDA4VM EVM（Evaluation Module）上利用V4L2库来实现USB摄像头的数据采集，并将YUV4:2:2格式的图像转换为RGB格式以便在显示器上显示。 首先，TDA4VM EVM是一款由Texas Instruments推出的开发...
DRA829/TDA4VM Safety Manual
06-02
"DRA829/TDA4VM Safety Manual" DRA829/TDA4VM Safety Manual是Texas Instruments（TI）发布的一份关于Jacinto 7处理器家族的安全手册。该手册旨在指导开发者正确使用DRA829/TDA4VM处理器，确保系统的安全性和可靠...
TI的TDA4VM dataBook
02-22
7. **PDF文件内容**: 各个PDF文件分别涵盖不同的主题，如“tda4vm-1-160”和“tda4vm-161-323”可能详细讲解了处理器的特定部分，而“Jacinto7 J721E_DRA829_TDA4VM 评估模块 (EVM)”则专注于EVM的使用和调试。...
tda4vm中文版-适用于 ADAS 和自动驾驶汽车的
03-25
**TDA4VM Jacinto处理器器件**是针对高级驾驶辅助系统(ADAS)和自动驾驶汽车设计的一款高性能处理器。它在1.0和1.1版本中提供了强大的计算能力和丰富的功能，以满足现代智能车辆对实时数据处理和安全性的严格要求。 ...
[TI TDA4] USB摄像头显示YUYV图像模板工程 可显示BMP NV12
11-01
请配合此博客一起查看。 https://blog.csdn.net/AIRKernel/article/details/121038301?spm=1001.2014.3001.5502 此工程是在TI SDK 0800版本基础上修改的一个版本，比较干净。 删除了多余的内容，保留了最基础的显示功能，可以显示两种图片，一种是BMP，另一种是NV12（从摄像头获取的YUYV转换成NV12数据）
tirtos_task:创建TIRTOS任务的非常基础的类
03-27
Tirtos_Task 实例化TIRTOS任务的非常基础的类。 如何使用 添加TI Tirtos构建（即tirtos_builds_CC1352R1_LAUNCHXL_release_ccs）作为构建依赖项 创建一个扩展基类并实现“ run”方法的任务类： class MyTask : public Task { MyTask (); // ... void run (UArg arg); } void MyTask::run (UArg arg) { // do some TIRTOS stuff } 实例化并创建任务 # define TASK_PRIORITY 1 # define TASK_STACK_SIZE 512 int main () { MyTask *tirtosTask = new MyTask (); tirtosTask-> create (T
DRA829/TDA4VM Technical Reference Manual (Rev. C)
04-13
1. **处理器体系结构**：手册中会详细介绍DRA829/TDA4VM的多核处理器架构，可能包括Cortex-A72应用处理器、Cortex-R5F实时处理器以及C66x DSP核心，这些处理器协同工作，处理复杂的计算任务和实时响应。 2. **...
TDA4VM_vision_apps Demo调试过程简述
最新发布
weixin_43722921的博客
11-17 433
介绍了TDA4VM开发板调试摄像头的过程
[TI TDA4 J721E]Encode节点编码YUV NV12图像视频生成H.264视频流 使用和移植
AIRKernel的博客
12-09 4981
YUV encode H.264
[TI TDA4 J721E]TIOVX OpenVX 框架下Kernel注册/Node使用
AIRKernel的博客
09-14 4199
使用Python脚本生成步骤参照上一篇内容。[TI TDA4] TIOVX OpenVX框架下的Python脚本使用 此处以TI 官方提供的Demo为例。~/vision_apps/apps/dl_demos/app_tidl_od 一、host端注册 调用链如下：main->app_tidl_od_main->app_init->tivxMytiovxLoadKernels tivxMytiovxLoadKernels函数位于~/vision_apps/k.....
优雅的玩转TDA4VM
yiyu20180729的博客
04-23 2315
Linux TDA4VM 安装、使用、编译、启动
[TI TDA4 J721E]PROCESSOR-SDK-J721E Demo开发板运行与测试 基于 ubuntu 18.04
AIRKernel的博客
11-09 5582
https://blog.csdn.net/AIRKernel/article/details/121135143?spm=1001.2014.3001.5501
tda4vm使用教程
10-10
tda4vm是一个基于TensorFlow的深度学习框架，用于进行时序数据分析和预测。下面是一个简单的tda4vm的使用教程： 1. 安装tda4vm：通过pip安装tda4vm库，可以使用以下命令进行安装： ``` pip install tda4vm ``` 2. 导入tda4vm库：在Python脚本中导入tda4vm库，可以使用以下代码： ```python import tda4vm ``` 3. 加载数据：准备好你的时序数据，并将其加载到tda4vm中，可以使用以下代码： ```python data = tda4vm.load_data("path/to/your/data.csv") ``` 4. 数据预处理：根据你的需求对数据进行预处理，比如进行标准化、滤波、降采样等操作。 5. 构建模型：使用tda4vm中提供的类和方法构建你的时序数据分析和预测模型。tda4vm支持多种模型，比如RNN、LSTM等。 6. 训练模型：使用加载的数据对模型进行训练，可以使用以下代码： ```python model = tda4vm.build_model() model.fit(data) ``` 7. 模型评估和预测：使用训练好的模型对新数据进行预测，并评估模型的性能。可以使用以下代码进行预测： ```python predictions = model.predict(new_data) ``` 以上是一个简单的tda4vm的使用教程。你可以根据自己的需求和数据进行进一步的调整和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

耀眼宝玉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值