MI PSPI API

int main(int argc, char *argv[])

{

    int fd = 0

    MI_PSPI_DEV   pspi_dev = 0;

    MI_PSPI_Param_t  pspi_para;

    MI_PSPI_OutputAttr_t stOutputAttr;

    MI_SYS_ChnPort_t stChnPort;

    MI_SYS_BufInfo_t stBufInfo;

    MI_SYS_BUF_HANDLE hSysBuf;

    memset(&stChnPort, 0x0, sizeof(MI_SYS_ChnPort_t));

    memset(&stBufInfo, 0x0, sizeof(MI_SYS_BufInfo_t));

    memset(&hSysBuf, 0x0, sizeof(MI_SYS_BUF_HANDLE));

    memset(&pspi_para, 0x0, sizeof(MI_PSPI_SpiParam_t));

    stChnPort.eModId    = E_MI_MODULE_ID_PSPI;

    stChnPort.u32DevId  = 0;

    stChnPort.u32ChnId  = 0;

    stChnPort.u32PortId = 0;

    stOutputAttr.u16Width   = 1920;

    stOutputAttr.u16Width   = 1080;

    stOutputAttr.ePixelFormat = E_MI_SYS_PIXEL_FRAME_YUV_SEMIPLANAR_420;

    pspi_para.u8BitsPerWord    = 8;

    pspi_para.u8DataLane        = DATA_DUAL;

    pspi_para.u16DelayCycle      = 0;

    pspi_para.u16WaitCycle       = 0;

    pspi_para.u8RgbSwap         = 0;

    pspi_para.u32MaxSpeedHz     = 1000000;

    pspi_para.u16PspiMode         = SPI_SLAVE;

    pspi_para.u8ChipSelect      = MI_PSPI_SELECT_0;

    /*** 通过I2C等手段向sensor发送命令 ***/


    MI_SYS_Init();

    MI_PSPI_CreateDevice(pspi_dev, &pspi_para);

    MI_PSPI_SetOutputAttr(&stOutputAttr);  //修改sensor输入图像的属性

    MI_PSPI_Enable(pspi_dev);//为了减小篇幅去掉了对函数调用的返回值进行判断

    MI_SYS_SetChnOutputPortDepth(&stChnPort,3,4);


    GET_OUT_BUF:

    if (MI_SUCCESS != MI_SYS_ChnOutputPortGetBuf(&stChnPort, &stBufInfo, &hSysBuf))

    {

        goto GET_OUT_BUF;

    }

    fd = open(“picture”, O_RDWR|O_CREAT|O_TRUNC, 0777);

    write(fd, tBufInfo.stFrameData.pVirAddr[0], stBufInfo.stFrameData.u32BufSize));

    sync();

    close(fd);

    PUT_OUT_BUF:

    if (MI_SUCCESS != MI_SYS_ChnOutputPortPutBuf(hSysBuf))

    {

        goto PUT_OUT_BUF;

    }

    MI_SYS_SetChnOutputPortDepth(&stChnPort,0,3);

    MI_PSPI_Disable(pspi_dev);

    MI_PSPI_DestroyDevice(pspi_dev);

    MI_SYS_Exit();

    Return 0;

}

int main（int argc, char *argv[]）

{

    MI_S32 s32Ret = 0;

    MI_U16 * buff = NULL;

    MI_U32 size = 0;

    MI_PSPI_Msg_t  pspi_msg;

    MI_PSPI_Param_t  pspi_para;

    MI_PSPI_DEV   pspi_dev = 1;

    MI_SYS_ChnPort_t  stChnPort;

    MI_SYS_BUF_HANDLE  stHandle;

    MI_SYS_BufInfo_t   stBufInfo;

    MI_SYS_BufConf_t  stBufConf;

    pspi_para.u8BitsPerWord    = 9;

    pspi_para.u8DataLane       = DATA_SINGLE;

    pspi_para.u16DelayCycle    = 2;

    pspi_para.u16WaitCycle     = 2;

    pspi_para.u8RgbSwap        = 0;

    pspi_para.u32MaxSpeedHz    = 1000000;

    pspi_para.u16PspiMode      = 0;

    pspi_para.u8ChipSelect     = MI_PSPI_SELECT_0;

    pspi_para.u8TeMode         = 0;

    MI_PSPI_CreateDevice(pspi_dev, &pspi_para);//为了减小篇幅去掉了对函数调用的返回值进行判断

    memset(&pspi_msg, 0 ,sizeof(MI_PSPI_Msg_t));

    pspi_msg.u8TxBitCount = 9;//可根据panel的不同选择不同的数值

    pspi_msg.u8RxBitCount = 8;

    pspi_msg.u8TxSize = 1;

    //0xDA   //根据panel的型号发送对应的控制命令，视panel型号而定

    pspi_msg.au16TxBuf[0] = 0xDA;

    MI_PSPI_Transfer(pspi_dev,  & pspi_msg);

    /****    向panel发送命令   *****/

    memset(&stChnPort, 0, sizeof(MI_SYS_ChnPort_t));

    memset(&stBufConf, 0, sizeof(MI_SYS_BufConf_t));

    memset(&stBufInfo, 0, sizeof(MI_SYS_BufInfo_t));

    memset(&stHandle, 0, sizeof(MI_SYS_BUF_HANDLE));

    stChnPort.eModId = E_MI_MODULE_ID_PSPI;

    stChnPort.u32DevId = 1;

    stChnPort.u32ChnId = 0;

    stChnPort.u32PortId = 0;

    stBufConf.eBufType = E_MI_SYS_BUFDATA_FRAME;

    stBufConf.stFrameCfg.u16Height = 240;

    stBufConf.stFrameCfg.u16Width  = 320;//这些参数视情况而定

    stBufConf.stFrameCfg.eFrameScanMode = E_MI_SYS_FRAME_SCAN_MODE_PROGRESSIVE;

    stBufConf.stFrameCfg.eFormat    = E_MI_SYS_PIXEL_FRAME_RGB565;

    MI_PSPI_Enable(pspi_dev);

    while(1)

    {

    getBuff1:

    if(MI_SYS_ChnInputPortGetBuf(&stChnPort,&stBufConf,&stBufInfo,&stHandle,4000)!= MI_SUCCESS)
        {
            printf("get input port buf red failed\n");

                    goto getBuff1;
        }

        else
            {
                printf("MI_SYS_ChnInputPortGetBuf success 1\n");

                buff =  (MI_U16 *)stBufInfo.stFrameData.pVirAddr[0];

                size = stBufInfo.stFrameData.u32BufSize/2;

                for(i = 0; i < size ; i++)

                    {

                        buff[i] = 0xf800;

                    }

                putbuff1:

                    if(MI_SYS_ChnInputPortPutBuf(stHandle, &stBufInfo, FALSE) != MI_SUCCESS)

                    {   
    printf("writter frame err 1\n");

                        goto putbuff1;

                    }

                    else

                        printf("written a frame red to screen success\n");
        }

    }

#define           FRAME_RATE                 30

int main(int argc, char *argv[])

{

    MI_S32 s32Ret = 0;

    MI_SYS_ChnPort_t stSensorChnPort;

    MI_SYS_ChnPort_t stPanelChnPort;

    MI_SYS_ChnPort_t stDivpChnPort;

    MI_SYS_BindType_e eBindType;

    MI_U32 u32BindParam;

    MI_SYS_Init();

    /*sensor 初始化并使能，参考4.1例程*/

    /*panel 初始化并使能，参考4.2例程*/

    //vpe初始化

    MI_DIVP_ChnAttr_t stAttr;

    MI_DIVP_OutputPortAttr_t stOutputPortAttr;

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

    stAttr.bHorMirror = false;

    stAttr.bVerMirror = false;

    stAttr.eDiType = E_MI_DIVP_DI_TYPE_OFF;

    stAttr.eRotateType = E_MI_SYS_ROTATE_NONE;

    stAttr.eTnrLevel = E_MI_DIVP_TNR_LEVEL_OFF;

    stAttr.stCropRect.u16X = 0;

    stAttr.stCropRect.u16Y = 0;

    stAttr.stCropRect.u16Width = 640;

    stAttr.stCropRect.u16Height = 480;

    stAttr.u32MaxWidth = 640;

    stAttr.u32MaxHeight = 480;

    s32Ret = MI_DIVP_CreateChn(0, &stAttr);

    stOutputPortAttr.eCompMode = E_MI_SYS_COMPRESS_MODE_NONE;

    stOutputPortAttr.ePixelFormat = E_MI_SYS_PIXEL_FRAME_RGB565;

    stOutputPortAttr.u32Width = 240;

    stOutputPortAttr.u32Height = 320;

    s32Ret = MI_DIVP_SetOutputPortAttr(0, &stOutputPortAttr);

    s32Ret = MI_DIVP_StartChn(0);

    stSensorChnPort.eModId = E_MI_MODULE_ID_PSPI;

    stSensorChnPort.u32DevId = 0;

    stSensorChnPort.u32ChnId = 0;

    stSensorChnPort.u32PortId = 0;

    stDivpInputChnPort.eModId = E_MI_MODULE_ID_DIVP;

    stDivpInputChnPort.u32DevId = 0;

    stDivpInputChnPort.u32ChnId = 0;

    stDivpInputChnPort.u32PortId = 0;

    stPanelChnPort.eModId = E_MI_MODULE_ID_PSPI;

    stPanelChnPort.u32DevId = 1;

    stPanelChnPort.u32ChnId = 0;

    stPanelChnPort.u32PortId = 0;

    eBindType = E_MI_SYS_BIND_TYPE_FRAME_BASE;

    u32BindParam = 0;

    MI_SYS_SetChnOutputPortDepth(&stSensorChnPort,3,6);

    MI_SYS_BindChnPort2(&stSensorChnPort, &stDivpChnPort, FRAME_RATE, FRAME_RATE, eBindType, u32BindParam);

    MI_SYS_BindChnPort2(&stDivpChnPort, &stPanelChnPort, FRAME_RATE, FRAME_RATE, eBindType, u32BindParam);

    While(1)

    {

        sleep(10);

    }

    MI_PSPI_Disable(0);

    MI_PSPI_Disable(1);

    MI_PSPI_DestroyDevice(0);

    MI_PSPI_DestroyDevice(1);

    return 0;
}