【外部映像送受信(4)】Zynq上で外部映像を送受信するアプリケーション(受信系の作成②　ソースコードの解説)

#include "video_inout_receiveradd.h"

int main(void)
{
    int Status;
    int i;
    
    //-----------------------------------------------------
    /* S. 送信側*/
    //-----------------------------------------------------

    //-----------------------------------------------------
    /* S.1 dynclk の設定*/
    //-----------------------------------------------------
    Status = dynclk_setting(DYNCLK_BASEADDR, VMODE_640x480);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }

    //-----------------------------------------------------
    /* S.2 送信側VDMAの設定 */
    //-----------------------------------------------------
    // S.2.0 初期化
    XAxiVdma_Config *vdmaConfig;
    vdmaConfig = XAxiVdma_LookupConfig(DISP_VDMA_ID);
    Status = XAxiVdma_CfgInitialize(&vdma_inst, vdmaConfig, vdmaConfig->BaseAddress);

    // S.2 VDMAの読み出し設定
    // 画像を格納するフレームバッファのポインタを取得
    for (i = 0; i < DISPLAY_NUM_FRAMES; i++)
    {
        pFrames[i] = frameBuf[i];
    }
    
    //設定実行
    Status = VDMA_send_setting(&vdma_inst, pFrames, DEMO_STRIDE, VMODE_640x480);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }

    //-----------------------------------------------------
    /* S.3 送信側VTCの設定 */
    //-----------------------------------------------------
    // S.3.0 初期化
    XVtc_Config *vtcConfig;
    vtcConfig = XVtc_LookupConfig(DISP_VTC_ID);
    Status = XVtc_CfgInitialize(&vtc_disp, vtcConfig, vtcConfig->BaseAddress);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }
    
    // S.3 送信側VTCのタイミング生成の設定
    Status = VTC_send_setting(&vtc_disp, VMODE_640x480);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }

    //-----------------------------------------------------
    /* S.4 フレームバッファへの静止画の入力 */
    //-----------------------------------------------------
    u32 iPixelAddr;
    u32 xcoi, ycoi;
    for(xcoi = 0; xcoi < VMODE_640x480.width; xcoi++)
    {
    	iPixelAddr = xcoi *3;
        for(ycoi = 0; ycoi < VMODE_640x480.height; ycoi++)
        {
            //iPixelAddr = xcoi *3 + ycoi * DEMO_STRIDE;
            if(xcoi < X_BMP_SIZE && ycoi < Y_BMP_SIZE){
                frameBuf[0][iPixelAddr]       = bmp_file_array[Y_BMP_SIZE - 1- ycoi][xcoi][1];   //green
                frameBuf[0][iPixelAddr + 1]   = bmp_file_array[Y_BMP_SIZE - 1- ycoi][xcoi][2];   //blue
                frameBuf[0][iPixelAddr + 2]   = bmp_file_array[Y_BMP_SIZE - 1- ycoi][xcoi][0];   //red
            }
            iPixelAddr += DEMO_STRIDE;
        }
    }
    Xil_DCacheFlushRange((unsigned int) frameBuf, DEMO_MAX_FRAME);
    //-----------------------------------------------------
    
    //-----------------------------------------------------
    /* R. 受信側 */
    //-----------------------------------------------------
    /* R.1 GPIOの設定 */
    //-----------------------------------------------------
    // R.1.0 初期化
    Status = XGpio_Initialize(&gpio_inst, VID_GPIO_ID);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }

    // R.1 GPIOの設定
    Status = gpio_setting(&gpio_inst);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }

    //-----------------------------------------------------
    /* R.2 割り込みコントローラの設定 */
    //-----------------------------------------------------
    Status = interrput_controller();
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }
    

    while(1){
    };

    return 0;
}

//-----------------------------------------------------
/* S.1 dynclk の設定*/
//-----------------------------------------------------
int dynclk_setting(u32 dynClkAddr, VideoMode vMode)
{
    ClkConfig clkReg;
    ClkMode clkMode;

    ClkFindParams(vMode.freq, &clkMode);

    if (!ClkFindReg(&clkReg, &clkMode))
    {
        return XST_FAILURE;
    }
    
    ClkWriteReg(&clkReg, dynClkAddr);
    ClkStart(dynClkAddr);

    return XST_SUCCESS;
}

//-----------------------------------------------------
/* S.2 送信側VDMAの設定 */
//-----------------------------------------------------
int VDMA_send_setting(XAxiVdma *vdmaptr, u8 *framePtr[DISPLAY_NUM_FRAMES], u32 stride, VideoMode vMode)
{
    int i;
    int Status;
    XAxiVdma_DmaSetup   vdmasetup;

    // S.2.1 フレームを読み書きするのに必要な情報を設定
    vdmasetup.FrameDelay                = 0;
    vdmasetup.EnableCircularBuf         = 1;
    vdmasetup.EnableSync                = 0;
    vdmasetup.PointNum                  = 0;
    vdmasetup.EnableFrameCounter        = 0;
    vdmasetup.VertSizeInput             = vMode.height;
    vdmasetup.HoriSizeInput             = (vMode.width) * 3;
    vdmasetup.FixedFrameStoreAddr       = 0;
    vdmasetup.Stride                    = stride;
    for (i = 0; i < DISPLAY_NUM_FRAMES; i++)
    {
        vdmasetup.FrameStoreStartAddr[i]  = (u32)  framePtr[i];
    }

    // S.2.2 VideoDMA読み出し開始
    Status = XAxiVdma_StartReadFrame(vdmaptr, &vdmasetup);

    // S.2.3 送受信するフレームを特定のフレーム(0)に固定
    Status = XAxiVdma_StartParking(vdmaptr, 0, XAXIVDMA_READ);

    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }
    return  XST_SUCCESS;
}

//-----------------------------------------------------
/* S.3 送信側VTCの設定 */
//-----------------------------------------------------
int VTC_send_setting(XVtc *vtcptr, VideoMode vMode)
{
    XVtc_Timing vtcTiming;
    XVtc_SourceSelect SourceSelect;
    
    // S.3.1 タイミングを制御するのに必要な情報を設定
    vtcTiming.HActiveVideo  = vMode.width                     ;    /**< Horizontal Active Video Size */
    vtcTiming.HFrontPorch   = vMode.hps    - vMode.width      ;    /**< Horizontal Front Porch Size */
    vtcTiming.HSyncWidth    = vMode.hpe    - vMode.hps        ;    /**< Horizontal Sync Width */
    vtcTiming.HBackPorch    = vMode.hmax   - vMode.hpe + 1    ;    /**< Horizontal Back Porch Size */
    vtcTiming.HSyncPolarity = vMode.hpol                      ;    /**< Horizontal Sync Polarity */
    vtcTiming.VActiveVideo  = vMode.height                    ;    /**< Vertical Active Video Size */
    vtcTiming.V0FrontPorch  = vMode.vps    - vMode.height     ;    /**< Vertical Front Porch Size */
    vtcTiming.V0SyncWidth   = vMode.vpe    - vMode.vps        ;    /**< Vertical Sync Width */
    vtcTiming.V0BackPorch   = vMode.vmax   - vMode.vpe + 1    ;    /**< Horizontal Back Porch Size */
    vtcTiming.V1FrontPorch  = vMode.vps    - vMode.height     ;    /**< Vertical Front Porch Size */
    vtcTiming.V1SyncWidth   = vMode.vpe    - vMode.vps        ;    /**< Vertical Sync Width */
    vtcTiming.V1BackPorch   = vMode.vmax   - vMode.vpe + 1    ;    /**< Horizontal Back Porch Size */
    vtcTiming.VSyncPolarity = vMode.vpol                      ;    /**< Vertical Sync Polarity */
    vtcTiming.Interlaced    = 0                               ;    /**< Interlaced / Progressive video */

    memset((void *)&SourceSelect, 0, sizeof(SourceSelect));
    SourceSelect.VBlankPolSrc       = 1;
    SourceSelect.VSyncPolSrc        = 1;
    SourceSelect.HBlankPolSrc       = 1;
    SourceSelect.HSyncPolSrc        = 1;
    SourceSelect.ActiveVideoPolSrc  = 1;
    SourceSelect.ActiveChromaPolSrc = 1;
    SourceSelect.VChromaSrc         = 1;
    SourceSelect.VActiveSrc         = 1;
    SourceSelect.VBackPorchSrc      = 1;
    SourceSelect.VSyncSrc           = 1;
    SourceSelect.VFrontPorchSrc     = 1;
    SourceSelect.VTotalSrc          = 1;
    SourceSelect.HActiveSrc         = 1;
    SourceSelect.HBackPorchSrc      = 1;
    SourceSelect.HSyncSrc           = 1;
    SourceSelect.HFrontPorchSrc     = 1;
    SourceSelect.HTotalSrc          = 1;

    // S.3.2 VTCトランザクションの開始
    XVtc_SelfTest(vtcptr);
    XVtc_RegUpdateEnable(vtcptr);
    XVtc_SetGeneratorTiming(vtcptr, &vtcTiming);
    XVtc_SetSource(vtcptr, &SourceSelect);
    XVtc_EnableGenerator(vtcptr);

    return XST_SUCCESS;
}

//-----------------------------------------------------
/* R.1 GPIOインスタンスの設定 */
//-----------------------------------------------------
int gpio_setting(XGpio *GpioPtr){
    int Status;

    XGpio_SelfTest(GpioPtr);

    // R.1.1 GPIOの入出力設定
    XGpio_DiscreteWrite(GpioPtr, 1, 0); //HPDチャネルからLow状態を出力
    XGpio_SetDataDirection(GpioPtr, 1, 0); //HPDチャネルを出力に設定
    XGpio_SetDataDirection(GpioPtr, 2, 1); //Lockedチャンネルを入力に設定

    // R.1.2 GPIOの割り込みをイネーブル
    XGpio_InterruptEnable(GpioPtr, XGPIO_IR_CH2_MASK);
    XGpio_InterruptGlobalEnable(GpioPtr);

    // R.1.3 HPDチャネルからHigh状態を出力
    XGpio_DiscreteWrite(GpioPtr, 1, 1);
    
    return XST_SUCCESS;
}

//-----------------------------------------------------
/* R.2 割り込みコントローラの設定 */
//-----------------------------------------------------
#define videoGpioIvt(x,y)\
    {x, (XInterruptHandler)GpioIsr, y, 0xA0, 0x3}
#define videoVtcIvt(x,y)\
    {x, (XInterruptHandler)XVtc_IntrHandler, y, 0xB0, 0x3}

typedef struct {
    u8 id;
    XInterruptHandler handler;
    void *pvCallbackRef;
    u8 priority; //not used for microblaze, set to 0
    u8 trigType; //not used for microblaze, set to 0
} ivt_t;

const ivt_t ivt[] = {
    videoGpioIvt(VID_GPIO_IRPT_ID, &gpio_inst),
    videoVtcIvt(VID_VTC_IRPT_ID, &vtc_video)
};

int interrput_controller(void){
    int Status;

    //-----------------------------------------------------
    // R.2.0. 例外処理
    //-----------------------------------------------------
    // R.2.0-1 ARMプロセッサの割り込み発生時に呼び出されるインスタンス(今回はGIC)の割り込みハンドラを登録
    Xil_ExceptionInit();
    Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, 
                (Xil_ExceptionHandler)XScuGic_InterruptHandler,
                &intc);
    Xil_ExceptionEnable();

    //-----------------------------------------------------
    // R.2.1. GIC(Generic Interrupt Controller)
    //-----------------------------------------------------
    // R.2.1-1 GICの初期化
    XScuGic_Config *IntcConfig;
    IntcConfig = XScuGic_LookupConfig(INTC_DEVICE_ID);
    Status = XScuGic_CfgInitialize(&intc, IntcConfig,
            IntcConfig->CpuBaseAddress);
    if (Status != XST_SUCCESS) {
        return XST_FAILURE;
    }

    // R.2.1-2 GIC割り込み発生時に呼び出されるインスタンスの割り込みハンドラを登録
    unsigned int isIVector;

    for (isIVector = 0; isIVector < sizeof(ivt)/sizeof(ivt[0]); isIVector++)
    {
        XScuGic_SetPriorityTriggerType(&intc, ivt[isIVector].id,
                ivt[isIVector].priority, ivt[isIVector].trigType);

        XScuGic_Connect(&intc, ivt[isIVector].id,
                     (Xil_ExceptionHandler)ivt[isIVector].handler, ivt[isIVector].pvCallbackRef);

        XScuGic_Enable(&intc, ivt[isIVector].id);
    }

    return XST_SUCCESS;
}

//-----------------------------------------------------
/* R.3 GPIOの割り込みハンドラ */
//-----------------------------------------------------
void GpioIsr(XGpio *GpioPtr)
{
    u32 locked;
    int Status;

    // R.3.1 割り込みのペンディングをクリア
    XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH2_MASK);

    // R.3.2 Lockedチャンネルを読み出し
    locked = XGpio_DiscreteRead(GpioPtr, 2);

    if (locked)
    {
        XVtc_Config *vtcConfig;

        // R.3.3 受信側VTCの初期化
        vtcConfig = XVtc_LookupConfig(VID_VTC_ID);
        Status = XVtc_CfgInitialize(&vtc_video, vtcConfig, vtcConfig->BaseAddress);
        if (Status != XST_SUCCESS)
        {
            return XST_FAILURE;
        }

        // R.3.4 受信側VTCのタイミング検出の設定
        Status = VTC_receive_setting(&vtc_video);
        if (Status != XST_SUCCESS)
        {
            return XST_FAILURE;
        }

        // R.3.5 GICをイネーブル
        XScuGic_Enable(&intc, VID_VTC_IRPT_ID);
    }
}

// R.3.4 受信側VTCのタイミング検出の設定
int VTC_receive_setting(XVtc *vtcptr)
{
    XVtc_SelfTest(vtcptr);

    XVtc_RegUpdateEnable(vtcptr);
    XVtc_SetCallBack(vtcptr, XVTC_HANDLER_LOCK, VtcIsr, vtcptr); //VTCのLock信号受信時の割り込みハンドラを設定
    XVtc_IntrEnable(vtcptr, XVTC_IXR_LO_MASK); //VTCのLock信号受信時の割り込みをイネーブル
    XVtc_EnableDetector(vtcptr); //VTCの検出をイネーブル

    return XST_SUCCESS;
}

//-----------------------------------------------------
/* R.4 ビデオ側VTCの割り込みハンドラ */
//-----------------------------------------------------
void VtcIsr(XVtc *vtcvideoPtr, u32 pendingIrpt)
{
    int Status;
    XVtc_Timing vtc_video_timing;

    if ((XVtc_GetDetectionStatus(vtcvideoPtr) & XVTC_STAT_LOCKED_MASK))
    {
        // R.4.1 VTCでHDMI信号のタイミングを検出
        XVtc_GetDetectorTiming(vtcvideoPtr, &vtc_video_timing);

        // R.4.2 受信側VDMAの設定
        Status = VDMA_receive_setting(&vdma_inst, pFrames, DEMO_STRIDE,  &vtc_video_timing);
        if (Status != XST_SUCCESS)
        {
            return XST_FAILURE;
        }


        XVtc_IntrDisable(vtcvideoPtr, XVTC_IXR_LO_MASK);
        XVtc_IntrClear(vtcvideoPtr, XVTC_IXR_LO_MASK);
    }
}

// R.4.2 受信側VDMAの設定
int VDMA_receive_setting(XAxiVdma *vdmaptr, u8 *framePtr[DISPLAY_NUM_FRAMES], u32 stride, XVtc_Timing *timing)
{
    int Status;
    int i;
    XAxiVdma_DmaSetup vdmasetup;
    
    /*---------------------------------------------------------------*/
    /* フレームを読み書きするのに必要な情報を設定 */
    vdmasetup.FrameDelay                = 0;
    vdmasetup.EnableCircularBuf         = 1;
    vdmasetup.EnableSync                = 0;
    vdmasetup.PointNum                  = 0;
    vdmasetup.EnableFrameCounter        = 0;
    vdmasetup.VertSizeInput             = timing->VActiveVideo;
    vdmasetup.HoriSizeInput             = timing->HActiveVideo * 3;
    vdmasetup.FixedFrameStoreAddr       = 0;
    vdmasetup.Stride                    = stride;
    
    for (i = 0; i < DISPLAY_NUM_FRAMES; i++)
    {
        vdmasetup.FrameStoreStartAddr[i] = (u32)  framePtr[i];
    }

    Status = XAxiVdma_StartWriteFrame(vdmaptr, &vdmasetup);
    Status = XAxiVdma_StartParking(vdmaptr, 0, XAXIVDMA_WRITE);
    if (Status != XST_SUCCESS)
    {
        return XST_FAILURE;
    }

    return XST_SUCCESS;
}