Graphical processing unit

Il y a deux façons de créer un écran à afficher

La première façon est d'écrire des commandes de liste d'affichage directement dans le RAM_DL (Display List RAM).
La deuxième façon consiste à écrire une série de commandes de co-processeur ou des commandes de liste d'affichage dans le RAM_CMD (Commande FIFO). Le coprocesseur crée ensuite la liste d'affichage dans le RAM_DL sur la base des commandes qui lui sont données dans le FIFO RAM_CMD. Cette méthode facilite la combinaison du dessin d'objets graphiques (lignes, etc.) et de widgets (sliders, etc.) sur le même écran.
Remarque : Bien qu'il soit en théorie possible de mélanger les deux méthodes lors de la création d'une nouvelle liste d'affichage (écran), il est recommandé d'utiliser une seule des deux méthodes dans un écran donné. En effet, le RAM_DL serait écrit à la fois par le MCU et le coprocesseur au sein du FT800.

Commande de traitement FIFO

Lorsque REG_CMD_READ = REG_CMD_WRITE, le co-processeur a exécuté toutes les commandes de la commande FIFO.

 		
 	do {
	HAL_SPI_CSLow();
	HAL_SPI_SendAddressRD(REG_CMD_WRITE);   //
	cmdBufferWr = FT800_SPI_Read32();       //
	HAL_SPI_CSHigh();
	

	HAL_SPI_CSLow();
	HAL_SPI_SendAddressRD(REG_CMD_READ);    //
	cmdBufferRd = FT800_SPI_Read32();       //
	HAL_SPI_CSHigh();
	} while(cmdBufferWr != cmdBufferRd);

Étape 2

Le FT800 utilise un tampon circulaire/FIFO pour contenir sa liste de commandes. Lorsqu'une nouvelle liste doit être créée, le MCU écrira les commandes à partir du prochain emplacement disponible (c'est-à-dire la valeur actuelle de REG_CMD_WRITE). Le code ci-dessus attend que toutes les commandes soient exécutées, la valeur de REG_CMD_WRITE est donc copiée dans une variable en tant qu'index de départ.

CMD_Offset = cmdBufferWr; // Obtenir la valeur actuelle du pointeur CMD_WRITE

Étape 3

La première commande de la liste de commandes peut maintenant être écrite dans la pile FIFO (RAM_CMD), et la fonction SendAddressWR est utilisée pour envoyer la commande à l'adresse contenue dans cmdBufferWrite.

Dans ce cas, la commande est DL_START (CMD_DLSTART). Les commandes sont toujours des multiples de 4 octets pour le FT800. La ligne Chip_Select est ensuite désactivée, marquant la fin de cette commande.

Cette opération a écrit quatre octets dans le FIFO. Une liste de commandes sera généralement composée de nombreuses commandes et le MCU doit donc maintenant mettre à jour sa propre valeur de décalage dans la variable cmdBufferWr afin de connaître la position de la commande suivante.

La fonction FT800_IncCMDOffset

Dans la plupart des cas, cette fonction ajoute simplement la longueur de la dernière commande au décalage précédent, mais gère également le cas où l'index atteint 4095 et doit être remis à 0 en raison de la nature circulaire du FIFO.

 		
 	uint32_t ft800q::inc_cmd_Offset(uint32_t currentOffset, uint8_t commandSize)
	{
    	uint16_t newOffset;				// used to hold new offset
    	newOffset = currentOffset + commandSize;	// Calculate new offset
    	if(newOffset > 4095)				// If new offset past boundary...
    		{
        	newOffset = (newOffset - 4096);		// ... roll over pointer
    		}
    	return newOffset;				// Return new offset

La méthode ci-dessus est proposée par le document "Programmers guide FT800" de FTDI, mais personnellement je préfère une méthode différente:


 	/*** CMD Functions ***************************************/
	uint8_t ft800q::cmd_execute(uint32_t data)
	{
		uint32_t cmdBufferRd = 0;
		uint32_t cmdBufferWr = 0;
    	cmdBufferRd = HOST_MEM_RD32(REG_CMD_READ);
    	cmdBufferWr = HOST_MEM_RD32(REG_CMD_WRITE);

    	uint32_t cmdBufferDiff = cmdBufferWr - cmdBufferRd;

    	if( (4096 - cmdBufferDiff) > 4)
    	{
        	HOST_MEM_WR32(RAM_CMD + cmdBufferWr, data);
        	HOST_MEM_WR32(REG_CMD_WRITE, cmdBufferWr + 4);
        	return 1;
    	}
    	return 0;
	}

	uint8_t ft800q::cmd(uint32_t data)
	{
		uint8_t tryCount = 255;
		for(tryCount = 255; tryCount > 0; --tryCount)
		{
			if(cmd_execute(data)) { return 1; }
		}
	return 0;
	}

La commande cmd(CMD_DLSTART) : la fonction cmd va appeler la fonction cmd_execute. Tant que celle-ci ne retourne pas la valeur "1", elle essaiera jusqu'à 255 fois. La fonction cmd_execute va retourner la valeur "0" tant que les deux registres ne sont pas égaux. Lorsque c'est le cas, cela signifie que l'on peut écrire une nouvelle commande dans la RAM_CMD. Dès lors, le registre REG_CMD_WRITE sera augmenté de 4 afin de pointer sur la prochaine adresse de la FIFO.

Chaque appel à la fonction cmd déclenchera la procédure HOST_MEM_WR32 pour placer la commande dans la FIFO et adapter le décalage (l'adresse) du registre REG_MEM_CMD.

 	
 	/* ------------------------------------------------------------------------------------------ */
	/* Demo Screen */
	void ft800q::lcd_start_screen(uint8_t button)
	{
		cmd(CMD_DLSTART);
		cmd(CLEAR_COLOR_RGB(0,0,0));
		cmd(CLEAR(1,1,1));
		cmd_gradient(0,0,0xA1E1FF, 0,250,0x000080);
		cmd_text(10,220, 20,0, "Designed by: Herve Fankhauser");
		cmd_text(300,200, 20,OPT_RIGHTX, "zfphfr/myqnapcould.com/hfe");
		cmd(COLOR_RGB(0xDE,0x00,0x08));
		cmd_text(140,40, 31,OPT_CENTERX, "FT800 Demo");
		cmd(COLOR_RGB(255,255,255));
		cmd(TAG(1));

		if(!button)
		{
			cmd_fgcolor(0x228B22);
			cmd_button(50,150, 220,48, 28,0, "Tap to Continue");
		}
		else
		{
			cmd_fgcolor(0x0A520A);
			cmd_button(50,150, 220,48, 28,OPT_FLAT, "Tap to Continue");
		}
		
		cmd(DISPLAY());
		cmd(CMD_SWAP);
	}