Mémoire RAM du 16C57

Nous allons commencer par présenter le plus difficile, l'architecture du banc de registres (Register File dans la terminologie anglo-saxonne que l’on pourrait traduire par dossier/classeur de registres, mais je préfère registres mémoire ou mémoire de registres ou banc de registres). Je parle de difficultés parce qu’il y a plusieurs banques mémoires ce qui est une caractéristique des architectures 8 bits Microchip.

Le banc de registres est divisée en quatre banques. Nous avons d’abord la série des (vrais) registres jusqu'au PORTC. Cette partie de mémoire est suivie par 8 registres d’usage général pouvant être utilisés comme mémoire simple. Cet ensemble est identique quelle que soit la banque choisie. Ensuite vient une série de registre généraux qui eux dépendent de la banque mémoire choisie. Voici le schéma simplifié de cette architecture.

RAM et Registres

Adr.	Banque0	Banque1	Banque2	Banque3	Adr.
00h	Indirect addr.	Indirect addr.	Indirect addr.	Indirect addr.	60h
01h	TMR0	TMR0	TMR0	TMR0
02h	PCL	PCL	PCL	PCL
03h	STATUS	STATUS	STATUS	STATUS
04h	FSR	FSR	FSR	FSR
05h	PORTA	PORTA	PORTA	PORTA
06h	PORTB	PORTB	PORTB	PORTB
07h	PORTC	PORTC	PORTC	PORTC
08h - 0Fh	8 registres généraux identiques sur les 4 banques	28h - 2FH	48h -4Fh	68h -6FH
10h - 1Fh	16 registres généraux	16 registres généraux	16 registres généraux	16 registres généraux	70H - 7FH

Calculons la taille de la mémoire de registres généraux :

4 x 16 + 1 x 8 = 72 octets.

C'est tout ce qu’il y a de disponible comme mémoire dans cette architecture.

Les registres oubliés

Dans la suite de ce cours, des registres TRISx et OPTION pourront apparaître. Ils ne sont pas présents dans la description que l’on vient de faire car ils ne sont accessibles que par des instructions spécialisées TRIS et OPTION présentées dans la section suivante.

Le jeu d'instructions du 16C57

Cette section est difficile à comprendre. Même si elle ne fait intervenir que des notions du niveau indiqué, il est conseillé d'avoir du recul sur les notions présentées pour bien assimiler ce qui suit. Cependant, ce contenu n'est pas fondamental et peut être sauté en première lecture.

Voici l’ensemble des instructions 12 bits du PIC 16C57. Vous trouverez en colonne de gauche le code binaire de l'instruction se trouvant au centre puis une courte explication de ce que fait l'instruction.

Les opérandes peuvent être de plusieurs types:

• f : adresse mémoire de registres (register file address) de 00 à 7F
• W : registre de travail
• d : sélection de destination : d=0 vers W, d=1 vers f
• pp : numéro de PORT entre 1 et 3 sur deux bits
• bbb : adresse de bit dans un registre 8 bits (sur 3 bits)
• k : champ littéral (8, ou 9 bits)
• PC compteur programme

Dans la terminologie Microchip, littéral signifie en adressage immédiat.

Accès à la mémoire de registres

Dans les instructions faisant intervenir la mémoire RAM (comme MOVWF f), f désigne une adresse mémoire qui semble être codée par fffff (5 bits) dans l'op-code. En fait il faut 7 bits pour coder l'adresse puisqu'elle peut aller jusqu'à 7Fh. Les deux bits manquants viennent d'ailleurs. D'où viennent-ils ? Les trois bits de poids fort du registre STATUS sont réservés à cet usage. Mais comme on l'a expliqué, la pagination est sur quatre pages différentes ce qui nécessite seulement deux bits (b6 et b5).

Mémoire ROM du 16C57

La taille de la ROM est de 2048 x 12 bits. C'est une mémoire très modeste qui limitera par la suite la taille des programmes que l’on fera tourner dans cette architecture, surtout si les programmes proviennent d'un compilateur.

Les trois ports du 16C57

Le PIC(R) 16C57 possède trois PORTs bidirectionnels appelés PORTA, PORTB et PORTC. La direction est choisie avec un registre TRIS dans lequel on écrit avec une instruction spéciale.

Avant de poursuivre, nous allons essayer de faire un parallèle avec le PIC 16C57 que l’on vient de décrire et le processeur softcore correspondant.

Les trois ports du SLC1657

Les ports sont des entités très spécifiques dans un micro contrôleur car ils sont bidirectionnels. Ce côté bidirectionnel est difficile à implanter de manière générale dans un FPGA puisqu’il dépend du fabricant et donc de l'environnement d’utilisation. Alors, puisqu'elle dépend de l'environnement de programmation, cette description VHDL est laissée à l'utilisateur du cœur SLC1657.

En principe, cette bidirectionnalité est gérée par un registre spécial TRIS associé à chacun des ports. Ces registres spécifiques existent dans le cœur, ils s'appellent PCOUT0, PCOUT1 et PCOUT2. Ils sont tous sur 8 bits, contrairement au PIC® 16F57 pour lequel le PORTA ne possède que 4 bits et peuvent être utilisés soit comme ports généraux en sortie, soit pour la gestion bidirectionnelle. Les ports proprement dit se décomposent alors en port d'entrée PTIN0, PTIN1 et PTIN2 et en ports de sortie PTOUT0, PTOUT1 et PTOUT2.

Remarque : pour des raisons de compatibilité le port PCOUTi n’est pas accessible de manière normale. Si i=0 l'écriture dans PCOUT0 se fait par l'instruction :

              // en langage C
              TRISA=0xFF;

tandis qu'en assembleur on écrira :

             ; assembleur
             movlw 255        ;1:input
             TRIS      PORTA ;PORTA en entree

même si les commentaires de ce programme ne sont pas appropriés dans le cas où l’on n'a pas un port bidirectionnel (ce qui, je le rappelle, est notre cas).

Abordons maintenant les deux autres périphériques nécessaires, la RAM et la ROM. Ces deux composants ne font pas partie du cœur tout simplement parce que les implantations de ceux-ci sont spécifiques aux FPGA cibles.

La RAM

Nous avons déjà eu l’occasion de présenter celle-ci, en tout cas du point de vue de sa capacité. Sa spécificité est qu’il s'agit d'une mémoire à écriture synchrone mais à lecture asynchrone. Il est facile de trouver des exemples d'une telle mémoire en VHDL. Nous avons choisi :

             library ieee;
             use ieee.std_logic_1164.all;
             use ieee.numeric_std.all;
             entity xilinx_one_port_ram_sync is
               generic(
                  ADDR_WIDTH: integer:=7;
                  DATA_WIDTH: integer:=8
               );
               port(
                  clk: in std_logic;
                  we: in std_logic;
                  addr: in std_logic_vector(ADDR_WIDTH-1 downto 0);
                  din: in std_logic_vector(DATA_WIDTH-1 downto 0);
                  dout: out std_logic_vector(DATA_WIDTH-1 downto 0)
                );
             end xilinx_one_port_ram_sync;
             architecture beh_arch of xilinx_one_port_ram_sync is
               type ram_type is array (2**ADDR_WIDTH-1 downto 0)
                    of std_logic_vector (DATA_WIDTH-1 downto 0);
               signal ram: ram_type;
             begin
               process (clk)
               begin
                  if (clk'event and clk = '1') then
                     if (we='1') then
                        ram(to_integer(unsigned(addr))) <= din;
                        end if;
                  end if;
               end process;
                         dout <= ram(to_integer(unsigned(addr)));
             end beh_arch;

Remarque

Une mauvaise implémentation de cette mémoire est fatale au bon fonctionnement du processeur, surtout s'il est utilisé avec un compilateur C qui utilise des variables locales.

La ROM

C'est là que se situe le programme à exécuter. Puisque tout compilateur ou assembleur génère un fichier hex, il nous est nécessaire de transformer ce fichier hex en fichier VHDL. Ceci est laissé à un programme C décrit un peu plus loin. Commençons à présenter un exemple de ROM.

             library IEEE;
             use IEEE.std_logic_1164.all;
             use IEEE.numeric_std.all;
             entity PIC_ROM is
               port (
                          Addr : in std_logic_vector(10 downto 0);
                          Data : out std_logic_vector(11 downto 0));
               end PIC_ROM;
               architecture first of PIC_ROM is
               begin
                Data <=
                    "000000000000" When to_integer(unsigned(Addr)) = 0000 Else
                    "110011111111" When to_integer(unsigned(Addr)) = 0000 Else
                    "000000000101" When to_integer(unsigned(Addr)) = 0001 Else
                    "110000000000" When to_integer(unsigned(Addr)) = 0002 Else
                    "000000000110" When to_integer(unsigned(Addr)) = 0003 Else
                    "001000000101" When to_integer(unsigned(Addr)) = 0004 Else
                    "000000100110" When to_integer(unsigned(Addr)) = 0005 Else
                    "101000000100" When to_integer(unsigned(Addr)) = 0006 Else
                    "101000000000" When to_integer(unsigned(Addr)) = 2047 Else
                    "000000000000";
               end first;

Cet exemple montre un contenu mais chaque programme donnera une ROM différente. Il est à noter que ce que l’on présente est du VHDL alors que chaque compilateur ou assembleur ne délivre qu'un fichier au format HEX. Il faudra donc un utilitaire pour transformer le fichier HEX en fichier VHDL car il s'agit d'une opération qui peut se faire automatiquement. Nous utiliserons un programme en C que nous donnons en annexe 1.

Assemblage du cœur, des mémoires et du module VGA

Avant d'aller plus loin, relisez Interfaces VGA et PS2.

À la fin de ce précédent chapitre Interfaces VGA, nous avons présenté un module capable de dessiner une balle et deux raquettes, ces trois objets étant mobiles.

Utile aussi de lire ou de relire l'article sur le VGA.

Donnons une image simplifiée de ce que l’on cherche à faire.

Interface VGA et processeur

La gestion de l'écran VGA peut se présenter comme une boite, certes complexe, mais qui sait dessiner :

• une balle
• deux raquettes

La seule chose qui sera demandé au processeur sera de gérer toutes les coordonnées de ces éléments.

Toute interface entre un processeur et de la logique externe passe par un ou plusieurs ports. Nous donnons maintenant l'assemblage complet de notre projets sous la forme de choix technologiques avec d'un côté les entrées sorties (E/S) du module VGA et de l'autre les entrées sorties du processeur softcore.

choix technologiques

E/S module VGA	E/S SLC1657
x_rect<9:8>	TRISA<1:0>
x_rect<7:0>	PORTA<7:0>
y_rect<9:8>	TRISB<1:0>
y_rect<7:0>	PORTB<7:0>
y_raqG<7:0>	PORTC<7:0>
y_raqD<7:0>	TRISC<7:0>

Ces choix montrent qu'on utilise 4 PORTs 8 bits pour faire les deux signaux 10 bits nécessaires aux deux coordonnées du rectangle (qui sera une balle) et deux ports 8 bits pour faire les deux entrées des positions des raquettes droites et gauches.

library ieee; 
use ieee.std_logic_1164.all; 

ENTITY TopTopLogic IS 
port (                     
            MCLK:       in  std_logic; 
            PCOUT0:     out std_logic_vector(  7 downto 0 ); 
            PCOUT1:     out std_logic_vector(  7 downto 0 );
            PTIN0:      in  std_logic_vector(  7 downto 0 ); 
            PTIN1:      in  std_logic_vector(  7 downto 0 ); 
            PTIN2:      in  std_logic_vector(  7 downto 0 ); 
            PTOUT0:     out std_logic_vector(  7 downto 0 ); 
            PTOUT1:     out std_logic_vector(  7 downto 0 ); 
            PTSTB0:     out std_logic; 
            PTSTB1:     out std_logic; 
            PTSTB2:     out std_logic; 
            RESET:      in  std_logic;           
            SLEEP:      out std_logic;
            TMRCLK:     in  std_logic; 
	    affpdsfaible,affpdsfort : out std_logic; 
	    sorties : out std_logic_vector(6 downto 0); 
	    hsynch,vsynch,red,green,blue : out STD_LOGIC 
        ); 
END TopTopLogic; 

ARCHITECTURE aTopTopLogic OF TopTopLogic IS 
signal EADR: std_logic_vector(6 downto 0 ); 
signal EALU: std_logic_vector(7 downto 0 ); 
signal EMCLK_16:  std_logic; 
signal EPRC: std_logic_vector(10 downto 0 ); 
signal EWERAM: std_logic; 
signal GP: std_logic_vector(7 downto 0 ); 
signal PRESET: std_logic; 
signal MCLK_16 : std_logic; 
signal ROM: std_logic_vector(11 downto 0 ); 

COMPONENT VGAtop IS 
  PORT (clk_50 : in STD_LOGIC; 
	x_rect, y_rect: IN std_logic_vector(9 DOWNTO 0); 
        y_raquG, y_raquD: IN std_logic_vector(7 DOWNTO 0); 
        hsynch,vsynch,red,green,blue : out std_logic); 
END COMPONENT VGAtop; 

component xilinx_one_port_ram_sync 
   generic( 
      ADDR_WIDTH: integer:=7; 
      DATA_WIDTH: integer:=8 
   ); 
   port( 
      clk: in std_logic; 
      we: in std_logic; 
      addr: in std_logic_vector(ADDR_WIDTH-1 downto 0); 
      din: in std_logic_vector(DATA_WIDTH-1 downto 0); 
      dout: out std_logic_vector(DATA_WIDTH-1 downto 0) 
    ); 
end component xilinx_one_port_ram_sync; 

COMPONENT PIC_ROM 
   port( 
      addr: in std_logic_vector(10 downto 0); 
      data: out std_logic_vector(11 downto 0) 
   ); 
end COMPONENT PIC_ROM; 

component TOPLOGIC 
    port ( 
            EADR:       out std_logic_vector( 6 downto 0 ); 
            EALU:       out std_logic_vector( 7 downto 0 ); 
            EMCLK_16:   out std_logic; 
            EPRC:       out std_logic_vector( 10 downto 0 ); 
            EWERAM:     out std_logic; 
            GP:         in  std_logic_vector( 7 downto 0 ); 
            MCLK:       in  std_logic; 
            PCOUT0:     out std_logic_vector( 7 downto 0 ); 
            PCOUT1:     out std_logic_vector( 7 downto 0 ); 
            PCOUT2:     out std_logic_vector( 7 downto 0 ); 
            PTIN0:      in  std_logic_vector( 7 downto 0 ); 
            PTIN1:      in  std_logic_vector( 7 downto 0 ); 
            PTIN2:      in  std_logic_vector( 7 downto 0 ); 
            PTOUT0:     out std_logic_vector( 7 downto 0 ); 
            PTOUT1:     out std_logic_vector( 7 downto 0 ); 
            PTOUT2:     out std_logic_vector( 7 downto 0 ); 
            PTSTB0:     out std_logic; 
            PTSTB1:     out std_logic; 
            PTSTB2:     out std_logic; 
            PRESET:     in  std_logic; 
            RESET:      in  std_logic; 
            ROM:        in  std_logic_vector( 11 downto 0 ); 
            SLEEP:      out std_logic; 
            TESTIN:     in  std_logic; 
            TMRCLK:     in  std_logic 
        ); 
end component; 

signal s_x, s_y : std_logic_vector(9 downto 0); 
signal s_PORTB, s_PTOUT2,s_PCOUT2 : std_logic_vector(7 downto 0); 
BEGIN 
  i0b: VGAtop PORT MAP (clk_50 => MCLK,
		hsynch=>hsynch,vsynch=>vsynch, red=>red,green=>green,blue=>blue, y_raquG =>s_PTOUT2, 
                y_raquD=>s_PCOUT2, x_rect=>s_x, y_rect=>s_y); 
  i1: PIC_ROM PORT MAP (addr =>EPRC, data => ROM); 
  
  i2:xilinx_one_port_ram_sync PORT MAP( 
      clk=>MCLK, 
      we=>EWERAM, 
      addr=>EADR, 
      din=>EALU , 
      dout=>GP   ); 
		 
  i3: TOPLOGIC PORT MAP (			 
	TESTIN=>'0',	 
	EADR=>EADR, 
	EALU=>EALU, 
        EMCLK_16=>EMCLK_16, 
        EPRC=>EPRC, 
        EWERAM=>EWERAM, 
        GP=>GP, 
        MCLK=>MCLK, 
        PCOUT0(7 downto 2)=>PCOUT0(7 downto 2), 
        PCOUT0(1 downto 0)=>s_x(9 downto 8), 
	PCOUT1(7 downto 2)=>PCOUT1(7 downto 2), 
        PCOUT1(1 downto 0)=>s_y(9 downto 8), 
        PCOUT2=>s_PCOUT2, 
        PTIN0=>PTIN0, 
        PTIN1=>PTIN1, 
        PTIN2=>PTIN2, 
        PTOUT0=>s_x(7 downto 0), 
        PTOUT1=>s_y(7 downto 0), 
        PTOUT2=>s_PTOUT2, 
        PTSTB0=>PTSTB0, 
        PTSTB1=>PTSTB1, 
        PTSTB2=>PTSTB2, 
        PRESET=>'0',--PRESET, 
        RESET=>RESET, 
        ROM=>ROM, 
        SLEEP=>SLEEP, 
        TMRCLK => TMRCLK 
        ); 
-- sorties 
   PTOUT1 <= s_y(7 downto 0); 
   PTOUT0 <= s_x(7 downto 0); 
END aTopTopLogic ;

void setX(unsigned int x){
  PORTA=x;
  TRISA=x>>8;
}

Utiliser le Timer0 avec le langage C

Nous aimerions bien explorer maintenant la possibilité de faire une attente (malheureusement active) en utilisant le seul et unique timer de notre architecture, à savoir le timer0. Commençons par présenter la documentation du Timer0 sous la forme d'un schéma :

Le timer 0 dans le SLC1657

La figure ci-dessus montre clairement la gestion du timer0 du SLC1657. Elle est légèrement différente de ce qui est matériellement réalisé par Microchip dans son PIC 16C57. Le registre général de gestion du timer 0 s’appelle OPTION dans le PIC et TCO dans le SLC1657. Dans le programme en C on utilisera naturellement "OPTION" pour désigner ce registre.

Début de l'exemple

Exemple

On désire réaliser une attente la plus longue possible avec le timer 0. Une division par 256 sur le quartz interne est donc nécessaire. La figure vous permet de trouver les valeurs à mettre dans le registre OPTION.

Voici donc un exemple de code :

void wait(unsigned char tempo){ // temporisation avec timer0
  OPTION=0x07; // div par 256 et source=quartz
  TMR0 =0;
  while(TMR0<tempo);
}

La boucle d'attente est réalisée par un "while".

Fin de l'exemple

Le sous-programme "wait" de l'exemple ci-dessus appelé avec une valeur de 250 est un peu plus rapide qu'un appel de

void wait(int tempo){ // temporisation classique
  int i; 
  for(i=tempo;i>0;i--); 
}

avec une valeur de 30000.

Remarque

Le PIC 16C57 ne possède pas d'interruptions. Il est donc impossible de gérer la temporisation avec des interruptions. Les attentes seront donc actives, c'est-à-dire gérées par des boucles d'attentes : impossible de faire une autre tâche pendant l'attente.

#include <pic16F5x.h> // Programme pour Hitech C dans MPLAB
void setX(unsigned int x); 
void setY(unsigned int y); 
void wait(unsigned char tempo); 
unsigned int posRaqu_16; 
void main(){ 
int posX,posY; 
unsigned char raqD_y=0,raqG_y=0; 
signed char deltaX=1,deltaY=1; 
	while(1){	 
		posX=113;		 
		posY=101; 
		setX(posX); 
		setY(posY); 
		while(RC2==0); // attente départ 
		while( (posX>30) && (posX<580)){ 
			posRaqu_16=raqD_y<<1; 
			if ((posX>=574) && (posY<posRaqu_16+58) &&
                                                 (posY+10>posRaqu_16) && (deltaX>0)) deltaX= -deltaX; 
			posRaqu_16=raqG_y<<1; 
			if ((posX<=32) && (posY<posRaqu_16+58) &&
                                                (posY+10>posRaqu_16) && (deltaX<0)) deltaX= -deltaX; 
			posX=posX+deltaX; 
			setX(posX); 
			if ((posY>=460) && (deltaY>0)) deltaY= -deltaY; 
			if ((posY<=10) && (deltaY<0)) deltaY= -deltaY; 
			posY=posY+deltaY; 
			setY(posY); 
// gestion des raquettes {{Unité|2|bits}} PORTC/raquette 
	 	if (RC0) if (raqG_y<215) raqG_y++; 
			if (RC1) if (raqG_y>0) raqG_y--; 
// positionnement raquette gauche
	 	PORTC=raqG_y; 
			if (RC6) if (raqD_y<215) raqD_y++; 
			if (RC7) if (raqD_y>0) raqD_y--; 
// positionnement raquette droite
			TRISC=raqD_y; 
// atttente
			wait(250); 
			wait(250); 
		} 
	} 
} 


void setX(unsigned int x){ 
  PORTA=x; 
  TRISA=x>>8; 
} 

void setY(unsigned int y){ 
  PORTB=y; 
  TRISB=y>>8; 
} 

void wait(unsigned char tempo){ 
OPTION=0x07; // div 256 et source=quartz 
TMR0 =0; 
while(TMR0<tempo); 
}