Atlas 200I A2 加速模块支持HDMI转CSI功能。此Demo只支持3840*2160 yuv422图片传输。

前提条件

Atlas 200I A2 加速模块环境已升级驱动和固件至最新版本，具体请参见驱动与固件升级。已升级CANN包至最新版本，具体请参见CANN软件安装。

操作步骤

下载Gitee上Ascend/samples开源代码仓中的camera_sample源码包。
登录Linux服务器。
执行如下命令，切换至root用户。
su - root
使用WinSCP工具或其他工具，将1下载的samples-master.zip源码包上传至Linux系统root用户属组目录下，如“/opt”，详细操作请参见使用WinSCP传输文件。
执行如下命令，进入“/opt”目录。
cd /opt
执行如下命令，解压zip包文件。
unzip samples-master.zip
执行如下命令，进入“samples-master”目录。
cd samples-master/cplusplus/level1_single_api/6_media/1_camera/camera_sample/sensor
执行如下命令，创建“sensor_isp”目录。
mkdir sensor_isp
执行如下命令，进入“sensor_isp”目录。
cd sensor_isp

执行如下命令，创建“isp_cmos.c”文件。

vim isp_cmos.c

添加如下代码，配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "hi_mpi_isp.h"
#include "hi_mpi_ae.h"
#include "hi_mpi_awb.h"
#include "hi_common_isp.h"
#include "hi_sns_ctrl.h"

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */
#define ISP_SENSOR_ID 0

static hi_s32 cmos_get_ae_default(hi_vi_pipe vi_pipe, hi_isp_ae_sensor_default *pstAeSnsDft)
{
    return HI_SUCCESS;
}

/* the function of sensor set fps */
static hi_void cmos_fps_set(hi_vi_pipe ViPipe, hi_float f32Fps, hi_isp_ae_sensor_default *pstAeSnsDft)
{
    return;
}

static hi_void cmos_slow_framerate_set(hi_vi_pipe vi_pipe, hi_u32 u32FullLines, hi_isp_ae_sensor_default *pstAeSnsDft)
{
    return;
}


/* while isp notify ae to update sensor regs, ae call these funcs. */
static hi_void cmos_inttime_update(hi_vi_pipe vi_pipe, hi_u32 u32IntTime)
{
    return;
}

static hi_void cmos_again_calc_table(hi_vi_pipe ViPipe, hi_u32 *pu32AgainLin, hi_u32 *pu32AgainDb)
{
    return;
}

static hi_void cmos_dgain_calc_table(hi_vi_pipe vi_pipe, hi_u32 *pu32DgainLin, hi_u32 *pu32DgainDb)
{
    return;
}

static hi_void cmos_gains_update(hi_vi_pipe vi_pipe, hi_u32 u32Again, hi_u32 u32Dgain)
{
    return;
}

static hi_void cmos_get_inttime_max(hi_vi_pipe vi_pipe, hi_u16 u16ManRatioEnable,
    hi_u32 *au32Ratio, hi_u32 *au32IntTimeMax,
    hi_u32 *au32IntTimeMin, hi_u32 *pu32LFMaxIntTime)
{
    return;
}

/* Only used in LINE_WDR mode */
static hi_void cmos_ae_fswdr_attr_set(hi_vi_pipe vi_pipe, hi_isp_ae_fswdr_attr *pstAeFSWDRAttr)
{
    return;
}
static hi_s32 cmos_init_ae_exp_function(hi_isp_ae_sensor_exp_func *pstExpFuncs)
{
    int ret;

    CMOS_CHECK_POINTER(pstExpFuncs);

    ret = memset(pstExpFuncs, 0, sizeof(hi_isp_ae_sensor_exp_func));

    pstExpFuncs->pfn_cmos_get_ae_default    = cmos_get_ae_default;
    pstExpFuncs->pfn_cmos_fps_set           = cmos_fps_set;
    pstExpFuncs->pfn_cmos_slow_framerate_set = cmos_slow_framerate_set;
    pstExpFuncs->pfn_cmos_inttime_update    = cmos_inttime_update;
    pstExpFuncs->pfn_cmos_gains_update      = cmos_gains_update;
    pstExpFuncs->pfn_cmos_again_calc_table  = cmos_again_calc_table;
    pstExpFuncs->pfn_cmos_dgain_calc_table  = cmos_dgain_calc_table;
    pstExpFuncs->pfn_cmos_get_inttime_max   = cmos_get_inttime_max;
    pstExpFuncs->pfn_cmos_ae_fswdr_attr_set = cmos_ae_fswdr_attr_set;

    return HI_SUCCESS;
}

static hi_s32 cmos_get_awb_default(hi_vi_pipe vi_pipe, hi_isp_awb_sensor_default *pstAwbSnsDft)
{
    return HI_SUCCESS;
}

static hi_s32 cmos_init_awb_exp_function(hi_isp_awb_sensor_exp_func *pstExpFuncs)
{
    int ret;
    CMOS_CHECK_POINTER(pstExpFuncs);

    ret = memset(pstExpFuncs, 0, sizeof(hi_isp_awb_sensor_exp_func));

    pstExpFuncs->pfn_cmos_get_awb_default = cmos_get_awb_default;

    return HI_SUCCESS;
}

static hi_s32 cmos_get_isp_default(hi_vi_pipe ViPipe, hi_isp_cmos_default *pstDef)
{
    return HI_SUCCESS;
}


static hi_s32 cmos_get_isp_black_level(hi_vi_pipe ViPipe, hi_isp_cmos_black_level *pstBlackLevel)
{
    return HI_SUCCESS;
}

static hi_void cmos_set_pixel_detect(hi_vi_pipe vi_pipe, hi_bool bEnable)
{
    return;
}


static hi_s32 cmos_set_wdr_mode(hi_vi_pipe ViPipe, hi_u8 u8Mode)
{
    return HI_SUCCESS;
}

static hi_s32 cmos_get_sns_regs_info(hi_vi_pipe ViPipe, hi_isp_sns_regs_info *pstSnsRegsInfo)
{
    return HI_SUCCESS;
}

static hi_s32 cmos_set_image_mode(hi_vi_pipe ViPipe, hi_isp_cmos_sensor_image_mode *pstSensorImageMode)
{
    return HI_SUCCESS;
}

static hi_void sensor_global_init(hi_vi_pipe ViPipe)
{
    return;
}


void sensor_init(hi_vi_pipe vi_pipe)
{
    return;
}

void sensor_exit(hi_vi_pipe vi_pipe)
{
    return;
}
static hi_s32 cmos_init_sensor_exp_function(hi_isp_sensor_exp_func *pstSensorExpFunc)
{
    int ret;

    CMOS_CHECK_POINTER(pstSensorExpFunc);

    ret = memset(pstSensorExpFunc, 0, sizeof(hi_isp_sensor_exp_func));

    pstSensorExpFunc->pfn_cmos_sensor_init                  = sensor_init;
    pstSensorExpFunc->pfn_cmos_sensor_exit                  = sensor_exit;
    pstSensorExpFunc->pfn_cmos_sensor_global_init           = sensor_global_init;
    pstSensorExpFunc->pfn_cmos_set_image_mode               = cmos_set_image_mode;
    pstSensorExpFunc->pfn_cmos_set_wdr_mode                 = cmos_set_wdr_mode;
    pstSensorExpFunc->pfn_cmos_get_isp_default              = cmos_get_isp_default;
    pstSensorExpFunc->pfn_cmos_get_isp_black_level          = cmos_get_isp_black_level;
    pstSensorExpFunc->pfn_cmos_set_pixel_detect             = cmos_set_pixel_detect;
    pstSensorExpFunc->pfn_cmos_get_sns_reg_info             = cmos_get_sns_regs_info;

    return HI_SUCCESS;
}
static hi_s32 sensor_set_bus_info(hi_vi_pipe vi_pipe, hi_isp_sns_commbus sns_bus_info)
{
    return HI_SUCCESS;
}

static hi_s32 sensor_ctx_init(hi_vi_pipe ViPipe)
{

    return HI_SUCCESS;
}

static hi_void sensor_ctx_exit(hi_vi_pipe ViPipe)
{
    return;
}

static hi_s32 sensor_register_callback(hi_vi_pipe ViPipe, hi_isp_3a_alg_lib *pstAeLib, hi_isp_3a_alg_lib *pstAwbLib, hi_isp_3a_alg_lib *pstAfLib)
{
    hi_s32 s32Ret;
    hi_isp_sensor_register stIspRegister;
    hi_isp_ae_sensor_register  stAeRegister;
    hi_isp_awb_sensor_register stAwbRegister;
    hi_isp_sns_attr_info   stSnsAttrInfo;

    if (((ViPipe) < 0) || ((ViPipe) >= HI_ISP_MAX_PIPE_NUM)) {    \
        printf("Err viPipe %d!\n", ViPipe); \
        return HI_ERR_ISP_ILLEGAL_PARAM; 
    }

    CMOS_CHECK_POINTER(pstAeLib);
    CMOS_CHECK_POINTER(pstAwbLib);
    CMOS_CHECK_POINTER(pstAfLib);

    s32Ret = sensor_ctx_init(ViPipe);

    if (HI_SUCCESS != s32Ret)
    {
        return HI_FAILURE;
    }

    stSnsAttrInfo.sensor_id = ISP_SENSOR_ID;

    s32Ret  = cmos_init_sensor_exp_function(&stIspRegister.sns_exp);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor none cmos_init_sensor_exp_function err\n");
        return s32Ret;
    }
    s32Ret = hi_mpi_isp_sensor_reg_callback(ViPipe, &stSnsAttrInfo, &stIspRegister);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor none register callback function failed!\n");
        return s32Ret;
    }

    s32Ret  = cmos_init_ae_exp_function(&stAeRegister.sns_exp);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor none cmos_init_ae_exp_function err\n");
        return s32Ret;
    }
    s32Ret = hi_mpi_ae_sensor_reg_callback(ViPipe, pstAeLib, &stSnsAttrInfo, &stAeRegister);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor none sensor register callback function to ae lib failed!\n");
        return s32Ret;
    }

    s32Ret  = cmos_init_awb_exp_function(&stAwbRegister.sns_exp);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor none cmos_init_awb_exp_function err\n");
        return s32Ret;
    }
    s32Ret = hi_mpi_awb_sensor_reg_callback(ViPipe, pstAwbLib, &stSnsAttrInfo, &stAwbRegister);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor none sensor register callback function to awb lib failed!\n");
        return s32Ret;
    }

    return HI_SUCCESS;
}


static hi_s32 sensor_unregister_callback(hi_vi_pipe ViPipe, hi_isp_3a_alg_lib *pstAeLib, hi_isp_3a_alg_lib *pstAwbLib, hi_isp_3a_alg_lib *pstAfLib)
{
    hi_s32 s32Ret;

    CMOS_CHECK_POINTER(pstAeLib);
    CMOS_CHECK_POINTER(pstAwbLib);
    CMOS_CHECK_POINTER(pstAfLib);

    s32Ret = hi_mpi_isp_sensor_unreg_callback(ViPipe, ISP_SENSOR_ID);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor unregister callback function failed!\n");
        return s32Ret;
    }

    s32Ret = hi_mpi_ae_sensor_unreg_callback(ViPipe, pstAeLib, ISP_SENSOR_ID);
    if (HI_SUCCESS != s32Ret)
    {
        printf("sensor unregister callback function to ae lib failed!\n");
        return s32Ret;
    }

    s32Ret = hi_mpi_awb_sensor_unreg_callback(ViPipe, pstAwbLib, ISP_SENSOR_ID);
    if (HI_SUCCESS != s32Ret)
    {
        printf("isp sensor unregister callback function to awb lib failed!\n");
        return s32Ret;
    }

    sensor_ctx_exit(ViPipe);

    return HI_SUCCESS;
}

static void sensor_standby(hi_vi_pipe vi_pipe)
{
    return;
}
static void sensor_restart(hi_vi_pipe vi_pipe)
{
    return;
}

static hi_s32 sensor_write_register(hi_vi_pipe vi_pipe, hi_u32 addr, hi_u32 data)
{
    return HI_SUCCESS;
}
static hi_s32 sensor_read_register(hi_vi_pipe vi_pipe, hi_u32 addr)
{
    return HI_SUCCESS;
}

static hi_s32 sensor_set_init(hi_vi_pipe ViPipe, hi_isp_init_attr *pstInitAttr)
{
    return HI_SUCCESS;
}
hi_isp_sns_obj g_sns_isp_obj =
{
    .pfn_register_callback    = sensor_register_callback,
    .pfn_un_register_callback  = sensor_unregister_callback,
    .pfn_standby             = sensor_standby,
    .pfn_restart             = sensor_restart,
    .pfn_write_reg            = sensor_write_register,
    .pfn_read_reg             = sensor_read_register,
    .pfn_set_bus_info          = sensor_set_bus_info,
    .pfn_set_init             = sensor_set_init
};

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */

执行如下命令，创建“CMakeLists.txt”文件。

vim CMakeLists.txt

添加如下代码，配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

# Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.

# CMake lowest version requirement
cmake_minimum_required(VERSION 3.5.1)

### Sensor SONY IMX219 ###
# project information
project(sns_isp)

set(LIB_PATH $ENV{NPU_HOST_LIB})
# Dynamic libraries in the stub directory can only be used for compilation
if (NOT DEFINED ENV{NPU_HOST_LIB})
    set(LIB_PATH "/usr/local/Ascend/ascend-toolkit/latest/CANN-6.4/runtime/lib64/stub/aarch64")
    message(STATUS "set default LIB_PATH: ${LIB_PATH}")
else ()
    message(STATUS "env LIB_PATH: ${LIB_PATH}")
endif()
set(INC_PATH $ENV{NPU_HOST_INC})
# Dynamic libraries in the stub directory can only be used for compilation
if (NOT DEFINED ENV{NPU_HOST_INC})
    set(INC_PATH "/usr/local/Ascend/ascend-toolkit/latest/CANN-6.4/runtime/include")
    message(STATUS "set default INC_PATH: ${INC_PATH}")
else ()
    message(STATUS "env INC_PATH: ${INC_PATH}")
endif()

set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIB_PATH})

link_directories(
    ${LIB_PATH}
    ${LIB_PATH}/stub
)

add_library(sns_isp SHARED
        isp_cmos.c
)

include_directories(sns_isp
        ${INC_PATH}/acl/media
        ../include
)

target_link_libraries(sns_isp
        acl_isp_mpi
)

其中“/usr/local/Ascend/ascend-toolkit/latest/CANN-6.4/runtime/lib64/stub/aarch64”和“/usr/local/Ascend/ascend-toolkit/latest/CANN-6.4/runtime/include”为CANN包安装路径，请根据实际情况替换。

新增“isp_sensor_config.h”文件。

执行如下命令，进入“sensor_sample”目录。
cd /opt/samples-master/cplusplus/level1_single_api/6_media/1_camera/camera_sample/sensor_sample

执行如下命令，新增“isp_sensor_config.h”文件。

vim isp_sensor_config.h

添加如下代码。

#include "hi_mipi_rx.h"
#include "hi_mpi_isp.h"
#include "hi_mpi_vi.h"

#include "sensor_management.h"

combo_dev_attr_t MIPI_4lane_SENSOR_NONE_12BIT_1920x1080_ATTR =
{
    .devno = 2,
    .input_mode = INPUT_MODE_MIPI,
    .data_rate = MIPI_DATA_RATE_X1,
    .img_rect = {0, 0, 3840, 2160},
    {
        .mipi_attr =
        {
            DATA_TYPE_YUV422_8BIT,
            HI_MIPI_WDR_MODE_NONE,
            {4, 5, 6, 7, -1, -1, -1, -1}
        }
    }
};

hi_isp_pub_attr ISP_PUB_ATTR_SENSOR_NONE_1080P_30FPS =
{
    {0, 0, 3840, 2160},
    {3840, 2160},
    30,
    HI_ISP_BAYER_RGGB,
    HI_WDR_MODE_NONE,
    1,
};

// hi_vi_dev_attr 1920X1080
hi_vi_dev_attr DEV_ATTR_SENSOR_NONE_1080P_BASE =
{
    HI_VI_MODE_MIPI_YUV422,
    HI_VI_SCAN_PROGRESSIVE,
    HI_VI_DATA_SEQ_VUVU,
    HI_VI_DATA_TYPE_YUV,
    {3840, 2160},
    {
        HI_WDR_MODE_NONE,
        2160
    },
    HI_DATA_RATE_X1
};

// hi_vi_pipe_attr 1920x1080 RAW8
hi_vi_pipe_attr PIPE_ATTR_SENSOR_NONE_1920x1080_RAW8_420_3DNR_RFR =
{
    HI_VI_PIPE_BYPASS_NONE,
    HI_TRUE,
    {3840, 2160},
    HI_PIXEL_FORMAT_YVU_SEMIPLANAR_422,
    HI_COMPRESS_MODE_NONE,
    HI_DATA_BIT_WIDTH_8,
    { -1, -1}
};


hi_vi_chn_attr CHN_ATTR_SENSOR_NONE_1920x1080_420_SDR8_LINEAR =
{
    {3840, 2160},
    HI_PIXEL_FORMAT_YVU_SEMIPLANAR_422,
    HI_DYNAMIC_RANGE_SDR8,
    HI_VIDEO_FORMAT_LINEAR,
    HI_COMPRESS_MODE_NONE,
    0,
    { -1, -1}
};

配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

修改“vi_with_sensor.c”文件。

执行如下命令，进入“vi_with_sensor.c”所在目录。
cd /opt/samples-master/cplusplus/level1_single_api/6_media/1_camera/camera_sample
执行如下命令，进入“vi_with_sensor.c”文件编译模式。
vim vi_with_sensor.c

将代码中的“sony_imx477”修改为“sensor_isp”信息，同时修改sampleViInfo的值，此样例mipi dev2是4条lane。具体如下代码加粗字体内容。

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <errno.h>
#include "vi_with_sensor.h"
#include "sample_comm.h"
#include "sample_comm_vi.h"
#include "sample_comm_isp.h"
#include "image_dump_util.h"
#include "acl/acl_rt.h"
#include "acl/acl.h"

#define HI_MAX_PIPE_NUM  4
#define HI_MAX_NAME_SIZE 128
SAMPLE_VI_CONFIG_S g_stViConfig;
hi_s32 pipe_mult_sensor[HI_MAX_PIPE_NUM] = {0};

static hi_s32 yuv_cnt = 0;     //新增支持CSI接收YUV422图片

hi_u32 hi_pixel_format_bit_width(hi_pixel_format enPixelFormat)
{
    switch (enPixelFormat) {
        case HI_PIXEL_FORMAT_RGB_BAYER_8BPP:
            return 8;
        case HI_PIXEL_FORMAT_RGB_BAYER_10BPP:
            return 10;
        case HI_PIXEL_FORMAT_RGB_BAYER_12BPP:
            return 12;
        case HI_PIXEL_FORMAT_RGB_BAYER_14BPP:
            return 14;
        case HI_PIXEL_FORMAT_RGB_BAYER_16BPP:
            return 16;
        default:
            return 0;
    }
}

static hi_s32 sample_sys_init()
{
    hi_s32 ret = HI_FAILURE;
    hi_mpi_sys_exit();

    SAMPLE_PRT("begin hi_mpi_sys_init !\n");
    ret = hi_mpi_sys_init();
    if (HI_SUCCESS != ret) {
        SAMPLE_PRT("hi_mpi_sys_init failed!\n");
        return HI_FAILURE;
    }
    SAMPLE_PRT("begin aclInit !\n");
    ret = aclInit(NULL);
    if (ret != HI_SUCCESS) {
        SAMPLE_PRT("aclInit failed!\n");
        return HI_FAILURE;
    }
    return HI_SUCCESS;
}

hi_void close_camera(void)
{
    hi_s32 s32Ret;
    (void)Sample_Comm_Vi_StopVi(&g_stViConfig);
    s32Ret = hi_mpi_sys_exit();
    if (s32Ret != HI_SUCCESS) {
        SAMPLE_PRT("hi_mpi_sys_exit failed!\n");
    } else {
        SAMPLE_PRT("hi_mpi_sys_exit succ \n");
    }
    s32Ret = aclFinalize();
    if (s32Ret != ACL_SUCCESS) {
        SAMPLE_PRT("aclFinalize failed!\n");
    } else {
        SAMPLE_PRT("aclFinalize succ \n");
    }
    return;
}

hi_s32 dump_raw(hi_vi_pipe ViPipe)
{
    hi_s32 s32Ret       = 0;
    hi_u32 u32Nbit      = 12;
    hi_u32 u32FrmCnt    = 1;
    hi_u32 u32RawDepth  = 2;
    hi_u32 u32ByteAlign = 1;
    hi_u32 u32RatioShow = 0;
    hi_compress_mode enCompressMode = HI_COMPRESS_MODE_NONE;
    hi_vi_frame_dump_attr astBackUpDumpAttr;
    hi_vi_frame_dump_attr stDumpAttr;
    hi_vi_pipe_attr stPipeAttr;

    if (1 > u32FrmCnt || MAX_FRM_CNT < u32FrmCnt) {
        printf("invalid FrmCnt %d, FrmCnt range from 1 to %d\n", u32FrmCnt, MAX_FRM_CNT);
        exit(HI_FAILURE);
    }

    s32Ret = hi_mpi_vi_get_pipe_attr(ViPipe, &stPipeAttr);
    if (HI_SUCCESS != s32Ret) {
        printf("Get Pipe %d attr failed!\n", ViPipe);
        return s32Ret;
    }
    u32Nbit = hi_pixel_format_bit_width(stPipeAttr.pixel_format);
    if (u32Nbit == 0) {
        printf("the enPixFmt is %d, cannot dump raw!\n", stPipeAttr.pixel_format);
        return -1;
    }  
    s32Ret = hi_mpi_vi_get_pipe_frame_dump_attr(ViPipe, &astBackUpDumpAttr);
    if (HI_SUCCESS != s32Ret) {
        printf("Get Pipe %d dump attr failed!\n", ViPipe);
        return s32Ret;
    }
    memcpy(&stDumpAttr, &astBackUpDumpAttr, sizeof(hi_vi_frame_dump_attr));
    stDumpAttr.enable = HI_TRUE;
    stDumpAttr.depth = u32RawDepth;
    s32Ret = hi_mpi_vi_set_pipe_frame_dump_attr(ViPipe, &stDumpAttr);
    if (HI_SUCCESS != s32Ret) {
        printf("Set Pipe %d dump attr failed!\n", ViPipe);
        return s32Ret;
    }
    // dump raw
    DumpLinearBayer(ViPipe, u32Nbit, enCompressMode, u32FrmCnt, u32ByteAlign, u32RatioShow);
    stDumpAttr.enable = HI_FALSE;
    s32Ret = hi_mpi_vi_set_pipe_frame_dump_attr(ViPipe, &stDumpAttr);
    if (HI_SUCCESS != s32Ret) {
        printf("Set Pipe %d dump attr failed!\n", ViPipe);
        return s32Ret;
    }
    return s32Ret;
}

hi_s32 dump(hi_s32 Pipe)
{
    hi_char szYuvName[HI_MAX_NAME_SIZE];
    hi_u32 depth = 3;
    hi_s32 s32MilliSec = 120000;
    hi_video_frame_info stFrame;
    hi_s32 s32Ret;
    hi_vi_chn_attr stChnAttr;
    hi_s32 Chn = 0;
    FILE* pfd = HI_NULL;

    s32Ret = hi_mpi_vi_get_chn_attr(Pipe, Chn, &stChnAttr);
    if (s32Ret != HI_SUCCESS)  {
        SAMPLE_PRT("get chn attr error!!!\n");
        return HI_FAILURE;
    }

    stChnAttr.depth = depth;
    s32Ret = hi_mpi_vi_set_chn_attr(Pipe, Chn, &stChnAttr);
    if (s32Ret != HI_SUCCESS) {
        SAMPLE_PRT("set chn attr error!!!\n");
        return HI_FAILURE;
    }

    memset(&stFrame, 0, sizeof(stFrame));

    for (int i = 0; i < HI_MAX_PIPE_NUM; i++) {
        s32Ret = hi_mpi_vi_get_chn_frame(Pipe, Chn, &stFrame, s32MilliSec);
        if (s32Ret != HI_SUCCESS) {
            SAMPLE_PRT("Get frame fails s32Ret = 0x%x!!\n", s32Ret);
            continue;
        }
        SAMPLE_PRT("hi_mpi_vi_get_chn_frame success\n!");
        break;
    }
    if (s32Ret != HI_SUCCESS) {
        SAMPLE_PRT("get frame error for 4 times, now exit !!!\n");
        return HI_FAILURE;
    }
    /* get frame */
    snprintf(szYuvName, HI_MAX_NAME_SIZE, "./vi_pipe%d_chn%d_w%d_h%d.yuv",
        Pipe, Chn, stFrame.v_frame.width, stFrame.v_frame.height);
    /* open file */
    pfd = fopen(szYuvName, "wb");
    if (HI_NULL == pfd) {
        SAMPLE_PRT("open file failed:%s!\n", strerror(errno));
    }
    hi_u32 u32Size = (stFrame.v_frame.width) * (stFrame.v_frame.height) * 3 / 2;
    fwrite(stFrame.v_frame.phys_addr[0], u32Size, 1, pfd);
    fflush(pfd);
    fclose(pfd);
    s32Ret = hi_mpi_vi_release_chn_frame(Pipe, Chn, &stFrame);
    if (HI_SUCCESS != s32Ret) {
        SAMPLE_PRT("Release frame error ,now exit s32Ret is %#x!!!\n", s32Ret);
    }
    return s32Ret;
}

hi_s32 start_camera(hi_u32 index, case_info sensor_info)
{
    hi_s32 ret;
    hi_size stSize;
    hi_s32 sensorId;
    hi_s32 num;
    lane_divide_mode_t divide_mode;
    SAMPLE_SNS_TYPE_E sensor_type;
    SAMPLE_VI_INFO_S sampleViInfo[HI_MAX_PIPE_NUM];

    ret = sample_sys_init();
    if (ret != HI_SUCCESS) {
        goto sys_init_failed;
    }
    // Obtaining Sensor and MIPI Information
    if (sensor_info.sensor_num == 1) {
        divide_mode = 1;
        g_stViConfig.s32WorkingViNum = 1; // simple pipe
    } else {
        divide_mode = 3;
        g_stViConfig.s32WorkingViNum = HI_MAX_PIPE_NUM;
    }
    // 1: imx219
    if (sensor_info.sensor_type == 1) {
        sensor_type = SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL;
    } else if (sensor_info.sensor_type == 2){
        sensor_type = SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL;   //修改支持CSI接收YUV422图片
    } else {
        goto sys_init_failed;
    }
    SAMPLE_PRT("The input sensor type is %#x\n", sensor_type);

    g_stViConfig.mipi_lane_divide_mode = divide_mode;
    for (num = 0; num < g_stViConfig.s32WorkingViNum; num++) {
        ret = get_sample_vi_info_by_sensorType(sensor_type, &sampleViInfo[num + 2], num + 2);//根据环境修改sampleViInfo的值，此样例mipi dev2是4条lane
        if (ret != HI_SUCCESS) {
            return -1;
        }
        hi_vi_dev_attr stViDevAttr;
        Sample_Comm_Vi_GetDevAttrBySns(sensor_type, &stViDevAttr);
        g_stViConfig.as32WorkingViId[num] = num + 2;//根据环境修改sampleViInfo的值，此样例mipi dev2是4条lane
        memcpy(&(g_stViConfig.astViInfo[num + 2]), &sampleViInfo[num + 2], sizeof(SAMPLE_VI_INFO_S));//根据环境修改sampleViInfo的值，此样例mipi dev2是4条lane
    }

    ret = Sample_Comm_Vi_StartVi(&g_stViConfig);
    if (ret != HI_SUCCESS) {
        goto start_vi_failed;
    }

    return 0;
start_vi_failed:
    Sample_Comm_Vi_StopVi(&g_stViConfig);
sys_init_failed:
    return -1;
}

hi_s32 get_sample_vi_info_by_sensorType(const SAMPLE_SNS_TYPE_E sensor_type,
    SAMPLE_VI_INFO_S *sample_vi_info, hi_s32 dev_id)
{
    static SAMPLE_VI_INFO_S sample_vi_info_linear = {
        .stSnsInfo = {
            .s32SnsId = 4,
            .s32BusId = 2,
            .MipiDev = 0,
        },
        .stDevInfo = {
            .enWDRMode = HI_WDR_MODE_NONE,
        },
        .stPipeInfo = {
            .aPipe = {2, -1, -1, -1},//根据环境修改sampleViInfo的值，此样例mipi dev2是4条lane
        },
        .stChnInfo = {
            .ViChn = 0,
            .enPixFormat = HI_PIXEL_FORMAT_YVU_SEMIPLANAR_420,
            .enDynamicRange = HI_DYNAMIC_RANGE_SDR8,
            .enVideoFormat = HI_VIDEO_FORMAT_LINEAR,
            .enCompressMode = HI_COMPRESS_MODE_NONE
        }
    };
    switch (sensor_type) {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
            memcpy(sample_vi_info, &sample_vi_info_linear, sizeof(SAMPLE_VI_INFO_S));
            sample_vi_info->stSnsInfo.enSnsType = sensor_type;
            sample_vi_info->stSnsInfo.s32BusId = dev_id;
            sample_vi_info->stSnsInfo.s32SnsId = 0;
            sample_vi_info->stSnsInfo.MipiDev = dev_id;
            sample_vi_info->stPipeInfo.aPipe[0] = dev_id;
            sample_vi_info->stDevInfo.ViDev = dev_id;
            pipe_mult_sensor[dev_id] = dev_id;
            break;
	   case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(sample_vi_info, &sample_vi_info_linear, sizeof(SAMPLE_VI_INFO_S));
            sample_vi_info->stSnsInfo.enSnsType = sensor_type;
            sample_vi_info->stSnsInfo.s32BusId = 0 + yuv_cnt*2;
            sample_vi_info->stSnsInfo.s32SnsId = 1;
            sample_vi_info->stSnsInfo.MipiDev = 2 + yuv_cnt*2;
            sample_vi_info->stPipeInfo.aPipe[0] = 2 + yuv_cnt;
            sample_vi_info->stDevInfo.ViDev = 2 + yuv_cnt*2;
            pipe_mult_sensor[dev_id] = 2 + yuv_cnt;
            yuv_cnt++;                //修改支持CSI接收YUV422图片
	       break;
        default:
            SAMPLE_PRT("Function %s() Error. Undefined sensor type: %#x\n", __FUNCTION__, sensor_type);
            return HI_FAILURE;
    }

    return HI_SUCCESS;
}

hi_s32 vi_with_sensor(hi_u32 index, case_info info) {  //修改支持CSI接收YUV422图片
    hi_s32 ret;
    ret = start_camera(index, info);
    if (ret == 0) {
        sleep(1);
        // ?camera ?Pipe0, ?camera ?Pipe0,2
        dump(2);
        dump(3);
    }
    close_camera();
    return 0;
}

配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

修改“sensor_management.c”文件。

执行如下命令，进入“sensor_management.c”文件目录。
cd /opt/samples-master/cplusplus/level1_single_api/6_media/1_camera/camera_sample/sensor_sample
执行如下命令，进入“sensor_management.c”文件编译模式。
vim sensor_management.c

修改代码。

将“hi_s32 Sample_Set_Mipi_2lane”和“hi_s32 Sample_Comm_Vi_GetComboAttrBySns”函数修改为如下代码的“hi_s32 Sample_Comm_Vi_GetComboAttrBySns”函数。
将“sony_imx477”修改为“sensor_isp”信息，具体如下代码中加粗字体内容。

#include "sensor_management.h"
#include "sony_imx219_config.h"
#include "isp_sensor_config.h" 

hi_s32 Sample_Comm_Vi_GetComboAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev, combo_dev_attr_t* pstComboAttr)
{
    switch (enSnsType) { 
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
            memcpy(pstComboAttr, &MIPI_2lane_CHN0_SENSOR_IMX219_10BIT_24M_NOWDR_ATTR, sizeof(combo_dev_attr_t));
            pstComboAttr->devno = MipiDev;
            switch(MipiDev){
                case 0:
                    pstComboAttr->mipi_attr.lane_id[0]= 0;
                    pstComboAttr->mipi_attr.lane_id[1]= 2;
                    break;
                case 1:
                    pstComboAttr->mipi_attr.lane_id[0]= 1;
                    pstComboAttr->mipi_attr.lane_id[1]= 3;
                    break;
                case 2:
                    pstComboAttr->mipi_attr.lane_id[0]= 4;
                    pstComboAttr->mipi_attr.lane_id[1]= 6;
                    break;
                case 3:
                    pstComboAttr->mipi_attr.lane_id[0]= 5;
                    pstComboAttr->mipi_attr.lane_id[1]= 7;
                    break;
                default:
                    printf("Function %s() Error. MipiDev: %d\n", __FUNCTION__, MipiDev);
                    return HI_FAILURE;
            }
            break;
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
            memcpy(pstComboAttr, &MIPI_2lane_CHN0_SENSOR_IMX219_10BIT_1920x1080_NOWDR_ATTR, sizeof(combo_dev_attr_t));
            pstComboAttr->devno = MipiDev;
            switch(MipiDev){
                case 0:
                    pstComboAttr->mipi_attr.lane_id[0]= 0;
                    pstComboAttr->mipi_attr.lane_id[1]= 2;
                    break;
                case 1:
                    pstComboAttr->mipi_attr.lane_id[0]= 1;
                    pstComboAttr->mipi_attr.lane_id[1]= 3;
                    break;
                case 2:
                    pstComboAttr->mipi_attr.lane_id[0]= 4;
                    pstComboAttr->mipi_attr.lane_id[1]= 6;
                    break;
                case 3:
                    pstComboAttr->mipi_attr.lane_id[0]= 5;
                    pstComboAttr->mipi_attr.lane_id[1]= 7;
                    break;
                default:
                    printf("Function %s() Error. MipiDev: %d\n", __FUNCTION__, MipiDev);
                    return HI_FAILURE;
            }
            break;
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(pstComboAttr, &MIPI_4lane_SENSOR_NONE_12BIT_1920x1080_ATTR, sizeof(combo_dev_attr_t));
	    break;
        default:
            return HI_FAILURE;
    }
    return HI_SUCCESS;
}

hi_s32 Sample_Comm_Vi_GetSnsRstSourceBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev, sns_rst_source_t* sns_reset_port)
{
    switch (enSnsType) {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            *sns_reset_port = 0;
            break;
        default:
            printf("Function %s() Error. Undefined sensor type: %#x\n", __FUNCTION__, enSnsType);
            return HI_FAILURE;
    }
    return HI_SUCCESS;
}

hi_s32 Sample_Comm_Vi_GetSnsClkCfgBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev, sns_clk_cfg_t* sns_clk_cfg)
{
    switch (enSnsType) {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(sns_clk_cfg, &g_mipi_sns_clk_cfg_attr, sizeof(sns_clk_cfg_t));
            break;
        default:
            printf("Function %s() Error. Undefined sensor type: %#x\n", __FUNCTION__, enSnsType);
            return HI_FAILURE;
    }
    return HI_SUCCESS;
}

hi_s32 Sample_Comm_Isp_GetIspAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_isp_pub_attr* pstPubAttr)
{
    switch (enSnsType)
    {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
            memcpy(pstPubAttr, &ISP_PUB_ATTR_IMX219_24M_20FPS_raw10, sizeof(hi_isp_pub_attr));
            break;
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
            memcpy(pstPubAttr, &ISP_PUB_ATTR_IMX219_1920x1080_20FPS_raw10, sizeof(hi_isp_pub_attr));
            break;
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
            memcpy(pstPubAttr, &ISP_PUB_ATTR_IMX219_1920x1080_30FPS_raw10, sizeof(hi_isp_pub_attr));
            break;
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(pstPubAttr, &ISP_PUB_ATTR_SENSOR_NONE_1080P_30FPS, sizeof(hi_isp_pub_attr));
            break;
        default:
            return HI_FAILURE;
    }

    return HI_SUCCESS;
}

hi_s32 Sample_Comm_Vi_GetDevAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_vi_dev_attr* pstViDevAttr)
{
    switch (enSnsType)
    {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
            memcpy(pstViDevAttr, &DEV_ATTR_IMX219_24M, sizeof(hi_vi_dev_attr));
            break;
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
            memcpy(pstViDevAttr, &DEV_ATTR_IMX219_1920x1080, sizeof(hi_vi_dev_attr));
            break;
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(pstViDevAttr, &DEV_ATTR_SENSOR_NONE_1080P_BASE, sizeof(hi_vi_dev_attr));
            break;
        default:
            return HI_FAILURE;
    }

    return HI_SUCCESS;
}

hi_s32 Sample_Comm_Vi_GetPipeAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_vi_pipe_attr* pstPipeAttr)
{
    switch (enSnsType)
    {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
            memcpy(pstPipeAttr, &IMX219_PIPE_ATTR_3264x2448_RAW10_420_3DNR_RFR, sizeof(hi_vi_pipe_attr));
            break;
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
            memcpy(pstPipeAttr, &IMX219_PIPE_ATTR_1920x1080_RAW10_420_3DNR_RFR, sizeof(hi_vi_pipe_attr));
            break;
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(pstPipeAttr, &PIPE_ATTR_SENSOR_NONE_1920x1080_RAW8_420_3DNR_RFR, sizeof(hi_vi_pipe_attr));
            break;            
        default:
	    return HI_FAILURE;
    }

    return HI_SUCCESS;
}

hi_s32 Sample_Comm_Vi_GetChnAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_vi_chn_attr* pstChnAttr)
{
    switch (enSnsType)
    {
        case SONY_IMX219_MIPI_3K_10BIT_NORMAL:
            memcpy(pstChnAttr, &IMX219_CHN_ATTR_3264x2448_420_SDR8_LINEAR, sizeof(hi_vi_chn_attr));
            break;
        case SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL:
        case SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL:
            memcpy(pstChnAttr, &IMX219_CHN_ATTR_1920x1080_420_SDR8_LINEAR, sizeof(hi_vi_chn_attr));
            break;
        case SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL:
            memcpy(pstChnAttr, &CHN_ATTR_SENSOR_NONE_1920x1080_420_SDR8_LINEAR, sizeof(hi_vi_chn_attr));
            break;            
        default:
            return HI_FAILURE;
    }
    return HI_SUCCESS;
}

const hi_isp_sns_obj* g_enSnsObj[MAX_SENSOR_NUM] = {
    &g_sns_imx219_obj,
    &g_sns_isp_obj,
};

const hi_isp_sns_obj* Sample_Comm_Isp_GetSnsObj(hi_u32 u32SnsId)
{
    return g_enSnsObj[u32SnsId];
}

配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

修改“sensor_management.h”文件。

执行如下命令，进入“sensor_management.h”文件编译模式。
vim sensor_management.h

将代码中的“sony_imx477”修改为“sensor_isp”信息，具体如下加粗字体内容。

#include "hi_mipi_rx.h"
#include "hi_mpi_isp.h"
#include "hi_common_sns.h"
#include "hi_common_3a.h"
#include "hi_mpi_vi.h"
#include "hi_sns_ctrl.h"
#define MAX_SENSOR_NUM 20

#ifndef SENSOR_MANAGEMENT_H
#define SENSOR_MANAGEMENT_H

typedef unsigned int combo_dev_t;
typedef unsigned int sns_rst_source_t;

typedef enum HISAMPLE_SNS_TYPE_E
{
    SONY_IMX219_MIPI_3K_10BIT_NORMAL = 0x60,
    SONY_IMX219_MIPI_1920x1080_10BIT_NORMAL = 0x62,
    SONY_IMX219_MIPI_1920x1080_10BIT_30FPS_NORMAL = 0x64,
    SENSOR_NONE_MIPI_1920x1080_8BIT_YUV_30FPS_NORMAL = 0x71,

    SAMPLE_SNS_TYPE_BUTT,
} SAMPLE_SNS_TYPE_E;

const hi_isp_sns_obj* Sample_Comm_Isp_GetSnsObj(hi_u32 u32SnsId);
hi_s32 Sample_Comm_Vi_GetComboAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev, combo_dev_attr_t* pstComboAttr);
hi_s32 Sample_Comm_Isp_GetIspAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_isp_pub_attr* pstPubAttr);
hi_s32 Sample_Comm_Vi_GetDevAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_vi_dev_attr* pstViDevAttr);
hi_s32 Sample_Comm_Vi_GetChnAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_vi_chn_attr* pstChnAttr);
hi_s32 Sample_Comm_Vi_GetPipeAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, hi_vi_pipe_attr* pstPipeAttr);
hi_s32 Sample_Comm_Vi_GetSnsRstSourceBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev, sns_rst_source_t* sns_reset_port);
hi_s32 Sample_Comm_Vi_GetSnsClkCfgBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev, sns_clk_cfg_t* sns_clk_cfg);
extern const hi_isp_sns_obj* g_enSnsObj[];

// Sensor Object
extern hi_isp_sns_obj g_sns_imx219_obj;
extern hi_isp_sns_obj g_sns_isp_obj;
#endif

配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

修改“camera_sample”目录下的“CMakeLists.txt”文件。

执行如下命令，进入“camera_sample”文件目录。
cd /opt/samples-master/cplusplus/level1_single_api/6_media/1_camera/camera_sample
执行如下命令，进入“CMakeLists.txt”文件编译模式。
vim CMakeLists.txt

将代码中的“sony_imx477”修改为“sensor_isp”信息，具体如下加粗字体内容。

# Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.

# CMake lowest version requirement
cmake_minimum_required(VERSION 3.5.1)

# project information
project(vi_l1_sample)

set(LIB_PATH $ENV{NPU_HOST_LIB})
# Dynamic libraries in the stub directory can only be used for compilation
if (NOT DEFINED ENV{NPU_HOST_LIB})
    set(LIB_PATH "/usr/local/Ascend/ascend-toolkit/latest/CANN-6.4/runtime/lib64/stub/aarch64")
    message(STATUS "set default LIB_PATH: ${LIB_PATH}")
else ()
    message(STATUS "env LIB_PATH: ${LIB_PATH}")
endif()

set(INC_PATH $ENV{NPU_HOST_INC})
# Dynamic libraries in the stub directory can only be used for compilation
if (NOT DEFINED ENV{NPU_HOST_INC})
    set(INC_PATH "/usr/local/Ascend/ascend-toolkit/latest/CANN-6.4/runtime/include")
    message(STATUS "set default INC_PATH: ${INC_PATH}")
else ()
    message(STATUS "env INC_PATH: ${INC_PATH}")
endif()

link_directories(
    ${LIB_PATH}
    ${LIB_PATH}/stub
)

add_executable(vi_l1_sample
  main.c
  vi_with_sensor.c
  ./common/sample_comm_isp.c
  ./common/sample_comm_vi.c
  ./sensor_sample/sensor_management.c
  ./common/image_dump_util.c
)

include_directories(vi_l1_sample
    ${INC_PATH}
    ${INC_PATH}/acl/media
    ./sensor_sample
    ./common
    ./sensor/include
    ./sensor/sony_imx219
    ./sensor/sensor_isp
)

add_compile_options(vi_l1_sample
    -O2
    -Wall
    -fpic
)

target_link_libraries(vi_l1_sample
    acl_dvpp_mpi
    acl_isp_mpi
    sns_imx219
    sns_isp
    acl_vi_mpi
    acl_vpss_mpi
    acl_isp_ae_mpi
    acl_isp_awb_mpi
    ascendcl
    pthread
)

配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。

修改“sensor”目录下的“CMakeLists.txt”文件。
1. 执行如下命令，进入“sensor”文件目录。
  cd /opt/samples-master/cplusplus/level1_single_api/6_media/1_camera/camera_sample/sensor
2. 执行如下命令，进入“CMakeLists.txt”文件编译模式。
  vim CMakeLists.txt
3. 将代码中的“sony_imx477”修改为“sensor_isp”信息，具体修改如下加粗字体内容。
```
add_subdirectory(sony_imx219)
add_subdirectory(sensor_isp)
```
4. 配置完成后，按“Esc”键，再执行:wq!保存修改，并按“Enter”键退出。
参考camera_sample编译生成“libsns_imx219.so”、“libsns_isp.so”文件和CSI工具。
登录Atlas 200I A2 加速模块整机，具体请参见使用PuTTY登录设备（网口方式）。
使用WinSCP工具或其他工具，将18编译成的“libsns_isp.so”和“vi_l1_sample”上传至Atlas 200I A2 加速模块整机目录，例如“/mnt”。
“libsns_isp.so”还需要放到CANN包安装路径下，例如：“/usr/local/Ascend/nnrt/7.0.0/runtime/lib64/”路径下。
执行如下命令，进入“/mnt”目录。
cd /mnt
执行如下命令，配置环境变量。
export LD_LIBRARY_PATH=/lib64/:$LD_LIBRARY_PATH
执行如下命令，运行CSI工具。
./vi_l1_sample 1 1 2
- 参数1：测试程序模式，1为sensor出yuv图，2为出raw图。Atlas 200I A2 加速模块暂不支持raw图。
- 参数2：camera num，可选1或2。
- 参数3：sensor_type，1为“imx219”，2为“isp”。
CSI工具若存在有变化（例如：升级驱动、系统重启、退出CSI工具等），则需要hdmi信号输入退出后，再重启CSI工具。
用户自行配置HDMI信号输入。

执行如下命令，查看是否收到数据。

cat /proc/umap/mipi_rx

如出现以下类似回显信息，则表示收到数据。

----mipi phy data info------------------------------------------------------
  phy_id        lane_id           phy_data               mipi_data             lvds_data            freq
       0       0, 1, 2, 3    0x00,0x00,0x00,0x00    0x00,0x00,0x00,0x00    0x00,0x00,0x00,0x00       n/a
       1       4, 5, 6, 7    0xc4,0x48,0xbf,0x22    0x1e,0x00,0x1e,0x3a    0x00,0x00,0x00,0x00    156MHZ

执行如下命令，在“vi_l1_sample”工具目录下查看生成的图片。
cd /mnt

ls

生成图片为“vi_pipe2_chn0_w3840_h2160.yuv”。

Demo参考2

前提条件

操作步骤