Processeur graphique FT800Q

Description

Principe : le processeur hôte communique avec le FT800Q via le bus SPI.

La première consiste à écrire directement les commandes de la liste d'affichage dans le RAM_DL (Display List RAM).

La deuxième consiste à écrire une série de commandes du coprocesseur ou de commandes de liste d'affichage dans le RAM_CMD (Command FIFO). Le coprocesseur crée ensuite la liste d'affichage dans le RAM_DL à partir des commandes qui lui sont transmises via le FIFO (RAM_CMD). Cette méthode facilite la combinaison d'objets graphiques (lignes, etc.) et de widgets (curseurs, etc.) sur un même écran.

Remarque: bien qu'il soit théoriquement 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 méthode pour un écran donné. En effet, le RAM_DL serait alors écrit à la fois par le MCU et par le coprocesseur au sein du FT800.

Commande de traitement 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 de type FIFO pour stocker sa liste de commandes. Lorsqu'une nouvelle liste doit être créée, le MCU écrit 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 aient été exécutées. La valeur de REG_CMD_WRITE est donc copiée dans une variable qui servira d'index de départ.

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

Étape 3

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

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

Cette opération a écrit quatre octets dans le FIFO. Une liste de commandes étant généralement composée de nombreuses commandes, le MCU doit maintenant mettre à jour sa propre valeur de décalage dans la variable cmdBufferWr afin de connaître la position à laquelle écrire 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. Elle gère également le cas où l'index atteint 4095 et doit revenir à 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
		}
		

Fonctionnement de la commande FIFO

La commande cmd(CMD_DLSTART) fait appel à la fonction cmd_execute. Celle-ci effectue jusqu'à 255 tentatives tant qu'elle ne retourne pas la valeur 1, indiquant que la commande a pu être exécutée.

La fonction cmd_execute retourne 0 tant que les deux registres ne permettent pas l'écriture d'une nouvelle commande. Dès que l'espace nécessaire est disponible, la commande est écrite dans la mémoire RAM_CMD.

Le registre REG_CMD_WRITE est ensuite incrémenté de 4 octets afin de pointer vers l'emplacement suivant du FIFO.

Chaque appel à la fonction cmd déclenche également la procédure HOST_MEM_WR32. Celle-ci permet d'écrire la commande dans le FIFO et de mettre à jour l'adresse utilisée pour l'écriture dans le registre REG_MEM_CMD.