Este artículo es una continuación del experimento de visualización HDMI de zynq 7000. El contenido que se muestra arriba está incluido en el código, y este artículo muestra directamente el archivo de imagen BMP en la tarjeta SD.
Debe haber completado el experimento de pantalla HDMI de zynq 7000 antes de poder realizar este experimento.
Descarga de código:
Enlace: https://pan.baidu.com/s/11-RLOYtl1AyxcQ_XGbw2YQ
código de extracción: zvnc
hdmiSDsrc.zip es el código de este artículo 17k, satan.zip es la compresión de imágenes de muestra, los demás son el contenido anterior
diseño de hardware
El diseño de hardware de este experimento es básicamente el mismo que el experimento de pantalla HDMI de zynq 7000 , por lo que no es necesario volver a crear un nuevo proyecto, abrir su proyecto Vivado, guardarlo como un nuevo proyecto y nombrarlo "sd_hdmi_out". como se muestra en la figura a continuación, ábralo después de completar la carpeta del proyecto, elimine la carpeta .sdk, este es el programa del experimento anterior, este experimento no es necesario.
Luego, el software abrirá automáticamente este proyecto, haga clic en "Abrir diseño de bloque" para abrir el archivo de diseño. Debido a que este experimento quiere leer los datos de la tarjeta SD, SD0 debe estar habilitado. Haga doble clic en el sistema de procesamiento ZYNQ7 para abrir la página de configuración y habilitar SD0, como se muestra en la figura a continuación (esto debe configurarse de acuerdo con el hardware de su tarjeta SD):
Luego haga clic en "Aceptar" y guarde la configuración. Luego, regenere el HDL de nivel superior. Haga clic en Generar flujo de bits para generar un nuevo archivo de flujo de bits.
Una vez completada la generación, exporte el hardware (Archivo-> Exportar-> Exportar hardware) y marque Incluir bitstream al exportar.
La parte de hardware está completa. Archivo -> Iniciar SDK Ingresemos a la parte de diseño del software.
diseño de software
Cree un nuevo proyecto de aplicación en el software SDK abierto y asígnele el nombre "hdmi_sd". Seleccione la plantilla del proyecto en blanco. En este experimento, necesitamos leer archivos en la tarjeta SD, así que agregue un sistema de archivos para admitir operaciones con archivos, haga clic en Modificar la configuración de este BSP para ingresar a la página de configuración, como se muestra en la siguiente figura:
Generalmente, esta interfaz se mostrará después de crear un nuevo proyecto. Si no aparece, recuerde hacer clic en system.mss en el directorio bsp.
Verifique los xilffs a continuación, el software agregará automáticamente archivos relacionados al proyecto, como se muestra en la siguiente figura:
Después de eso, puede ver que los archivos relevantes se han agregado al proyecto.
Luego abra el archivo descargado y cópielo, o el directorio de rutina de datos de microfase SDK_Demo \ 18_sd_hdmi_out \ sd_hdmi_out \ sd_hdmi_out.sdk, copie la carpeta src en ella y guárdelo en la misma ubicación del proyecto recién creado, solicitando el mismo archivo para omita y no lo reemplace. Luego, haga clic con el botón derecho en el proyecto en el software SDK y haga clic en Actualizar para volver a compilar.
Abra el archivo de programa principal display_demo.c, podemos ver que este experimento agrega la función bmp_read para leer el archivo de imagen sobre la base del experimento anterior. Utilice la función de operación de archivo f_open en la función para abrir el archivo de imagen, luego lea los primeros 54 bytes del archivo de encabezado de imagen para obtener el píxel de la imagen y otra información de atributos, y luego lea los datos de píxel en el orden de abajo hacia arriba, de izquierda a derecha. De esta forma, hemos obtenido todos los datos de píxeles de la imagen, lo que equivale a los archivos de encabezado de varios datos de imagen utilizados en el experimento anterior. Después de obtener con éxito los datos de la imagen, podemos seguir los pasos del experimento anterior para escribir los datos en el búfer VDMA y luego mostrarlos en la pantalla a través de la interfaz HDMI.
En comparación con el código del experimento anterior, bmp_read reemplaza a DemoPrintTest. Ahora lea los datos de visualización del archivo de imagen, y este último es una variable preasignada del archivo de encabezado, el punto común es que se envía al área de visualización DDR.
#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include <stdlib.h>
#include "xil_types.h"
#include "xil_cache.h"
#include "xparameters.h"
#include "display_demo.h"
#include "display_ctrl/display_ctrl.h"
#include "display_ctrl/vga_modes.h"
#include "ff.h"
/*
* XPAR redefines
*/
#define DYNCLK_BASEADDR XPAR_AXI_DYNCLK_0_BASEADDR
#define VGA_VDMA_ID XPAR_AXIVDMA_0_DEVICE_ID
#define DISP_VTC_ID XPAR_VTC_0_DEVICE_ID
/* ------------------------------------------------------------ */
/* Global Variables */
/* ------------------------------------------------------------ */
/*
* Display Driver struct
*/
DisplayCtrl dispCtrl;
XAxiVdma vdma;
static FIL fil; /* File object */
static FATFS fatfs;
/*
* Frame buffers for video data
*/
u8 frameBuf[DISPLAY_NUM_FRAMES][DEMO_MAX_FRAME];
u8 *pFrames[DISPLAY_NUM_FRAMES]; // array of pointers to the frame buffers
/* ------------------------------------------------------------ */
/* Procedure Definitions */
/* ------------------------------------------------------------ */
unsigned char read_line_buf[1920 * 4];
void bmp_read(char * bmp,u8 *frame,u32 stride)
{
short y,x;
short Ximage;
short Yimage;
u32 iPixelAddr = 0;
FRESULT res;
unsigned char TMPBUF[64];
unsigned int br; // File R/W count
res = f_open(&fil, bmp, FA_OPEN_EXISTING | FA_READ);
if(res != FR_OK)
{
return ;
}
res = f_read(&fil, TMPBUF, 54, &br);
if(res != FR_OK)
{
return ;
}
Ximage=(unsigned short int)TMPBUF[19]*256+TMPBUF[18];
Yimage=(unsigned short int)TMPBUF[23]*256+TMPBUF[22];
iPixelAddr = (Yimage-1)*stride ;
for(y = 0; y < Yimage ; y++)
{
f_read(&fil, read_line_buf, Ximage * 3, &br);
for(x = 0; x < Ximage; x++)
{
frame[x * BYTES_PIXEL + iPixelAddr + 0] = read_line_buf[x * 3 + 0];
frame[x * BYTES_PIXEL + iPixelAddr + 1] = read_line_buf[x * 3 + 1];
frame[x * BYTES_PIXEL + iPixelAddr + 2] = read_line_buf[x * 3 + 2];
}
iPixelAddr -= stride;
}
f_close(&fil);
}
int main(void)
{
int i;
int Status;
XAxiVdma_Config *vdmaConfig;
FRESULT rc;
/*
* Initialize an array of pointers to the 3 frame buffers
*/
for (i = 0; i < DISPLAY_NUM_FRAMES; i++)
{
pFrames[i] = frameBuf[i];
}
/*
* Initialize VDMA driver, get the hardware VDMA configurations
*/
vdmaConfig = XAxiVdma_LookupConfig(VGA_VDMA_ID);
if (vdmaConfig == NULL)
{
xil_printf("No video DMA found for ID %d\r\n", VGA_VDMA_ID);
}
/*
* Use hardware VDMA configurations to initialize the driver
*/
Status = XAxiVdma_CfgInitialize(&vdma, vdmaConfig, vdmaConfig->BaseAddress);
if (Status != XST_SUCCESS)
{
xil_printf("VDMA Configuration Initialization failed %d\r\n", Status);
}
/*
* Initialize the Display controller and start it
*/
VideoMode VMODE = VMODE_1920x1080;
Status = DisplayInitialize(&dispCtrl, &vdma, DISP_VTC_ID, DYNCLK_BASEADDR, pFrames, DEMO_STRIDE, VMODE);
if (Status != XST_SUCCESS)
{
xil_printf("Display Ctrl initialization failed during demo initialization%d\r\n", Status);
}
Status = DisplayStart(&dispCtrl);
if (Status != XST_SUCCESS)
{
xil_printf("Couldn't start display during demo initialization%d\r\n", Status);
}
rc = f_mount(&fatfs, "0:/", 0);
if (rc != FR_OK)
{
return 0 ;
}
bmp_read("shatan.bmp",dispCtrl.framePtr[dispCtrl.curFrame], DEMO_STRIDE);
Xil_DCacheFlushRange((unsigned int) dispCtrl.framePtr[dispCtrl.curFrame], DEMO_MAX_FRAME);
return 0;
}
función principal:
Primero inicialice pFrames (puntero a búferes de marco)
obtener las configuraciones de hardware VDMA: vdmaConfig
Inicializar el controlador
Se inicia la pantalla.
Instale y abra el archivo "shatan.bmp"
Finalmente, los datos de la pantalla se copian en el búfer de pantalla a través de la función bmp_read, y se muestra la imagen.
Fin del programa
Una vez compilado el programa, copie las imágenes de muestra en la carpeta de rutina a la tarjeta SD, y podrá descargarlas y verificarlas en la placa de desarrollo.
Descarga de verificación
Conecte el cable serial y el cable de descarga de la placa de desarrollo, y use el cable HDMI para conectar la interfaz HDMI y la pantalla. Inserte la tarjeta SD con las imágenes de muestra copiadas en la ranura para tarjetas. Haga clic en Ejecutar-> Ejecutar configuración en la barra de menú para ingresar a la página de configuración de programación y establezca las configuraciones relevantes como se muestra en la siguiente figura.
Una vez completada la configuración, haga clic en "Ejecutar" para grabar el programa, puede ver la imagen de muestra que se muestra en la pantalla como se muestra en la figura siguiente.
Estos son los requisitos para los archivos gráficos. El nombre del archivo es: shatan.bmp, que es el nombre del archivo abierto en el programa. Si cambia el nombre, debe modificar el nombre del archivo en el software y colocarlo en la raíz directorio. El archivo es un archivo gráfico 1900x1600 de 24 bits.
Si desea abrir archivos con otras resoluciones, VideoMode VMODE = VMODE_1920x1080; esto debe cambiarse. No lo intenté.
Si desea abrir una imagen bmp que no sea de 24 bits, debe comprender la estructura del archivo y luego modificar el código del software bmp_read. Esto es un poco difícil. Se recomienda no hacerlo. Puede cambiar la imagen a 24 bits.
Eso es todo para la introducción.