En este momento estoy tratando de hacer ingeniería inversa de algo que hice hace mucho tiempo pero nunca entendí por qué está funcionando tan lentamente.
Tengo una placa Zybo, con un chip Zynq 7010s, que tiene un procesador dual AX-A9 y un FPGA muy compacto.
En el lado de la CPU, hice un juego, que para cada iteración genera una serie de valores que representan el valor en píxeles de la imagen del juego.
= > primera pregunta = > esta matriz es bastante grande, y no estoy seguro de dónde se almacenaría esta variable? ... Acabo de crear una variable que tenía este valor.
A continuación, la imagen del juego tenía que mostrarse en el puerto vga, para lo cual, i cómo transferir los datos del lado del PS al PL Utilicé el AXI DMA y lo transferí así:
void send_data(char c_map, u32 target){
//xil_printf("\r\nStarting sending data\r\n");
/* Initialize the XAxiDma device.
*/
CfgPtr = XAxiDma_LookupConfig(DMA_DEV_ID);
if (!CfgPtr) {
xil_printf("No config found for %d\r\n", DMA_DEV_ID);
//return XST_FAILURE;
}
Status = XAxiDma_CfgInitialize(&AxiDma, CfgPtr);
if (Status != XST_SUCCESS) {
xil_printf("Initialization failed %d\r\n", Status);
//return XST_FAILURE;
}
if(XAxiDma_HasSg(&AxiDma)){
xil_printf("Device configured as SG mode \r\n");
//return XST_FAILURE;
}
//Value = 0b11110000000000000000000101000000;
if(c_map == WALL){
//bbbbggggrrrr
Value = 0b11111111111100000000000000000000;
//Value = 0b00000100000000000000000000000000;
Value = Value + target;
}else if(c_map == BALL){
//Value = 0b10000000000000000000000000000000;
Value = 0b00000000111100000000000000000000;
Value = Value + target;
}else{
Value = 0b00000000000000000000000000000000;
Value = Value + target;
}
for(Index = 0; Index < MAX_PKT_LEN; Index ++) {
TxBufferPtr[Index] = Value;
}
Xil_DCacheFlushRange((UINTPTR)TxBufferPtr, MAX_PKT_LEN);
Status = XAxiDma_SimpleTransfer(&AxiDma,(UINTPTR) TxBufferPtr,
MAX_PKT_LEN, XAXIDMA_DMA_TO_DEVICE);
if (Status != XST_SUCCESS) {
xil_printf("No XST_SUCCESS \r\n");
//return XST_FAILURE;
}
while (XAxiDma_Busy(&AxiDma,XAXIDMA_DMA_TO_DEVICE)) {} //wait
}
En el PL creo un bloque ram como tal
type RAM is array (0 to ADDR_WIDTH+1) of std_logic_vector (DATA_WIDTH-1 downto 0);
signal mem : RAM := (others => (others => '1'));
Que supuestamente debería ser un bloque de memoria, y luego, dentro de mi controlador VGA, complete mi bloque de memoria con los datos recibidos como entrada del zynq como tal.
MEM_READ:
process(clk)
begin
if (rising_edge(clk)) then
if ((hSyncCounter > hBackPorch) and (hSyncCounter <= hBackPorch+hDataLen)) then
mem(conv_integer(data(19 downto 0))) <= data(31 downto 20);--"111100000000";
end if;
end if;
end process;
Los datos son una señal de entrada. 31 hasta 20 consisten en el valor RGB del píxel. y el 19 hasta el 0 es la dirección de la c.
19 downto 0 es solo la posición de la cuadrícula en la imagen y no una ubicación específica del ram o algo así, pero ¿dónde está el mem que creo en el PL almacenado, o está hecho de? ¿Es solo un gran mux gigante?