Very High Speed Integrated Circuit Hardware Description Language/Embarquer un PIC 16F84

Nous allons mettre en œuvre dans ce chapitre un processeur softcore compatible avec le PIC® 16F84 de Microchip. Il s'agit d'un processeur RISC sur 8 bits. Après avoir exploré le processeur original, nous nous concentrerons sur le modèle VHDL du système mono-puce. Ce projet, bien que relativement simple, nécessitera une exploration avancée du cœur pour y réaliser certaines modifications : ajout d'un troisième PORT et ajout du signal "strobe" associé. Ce travail ne sera pas présenté dans ce chapitre.

**Embarquer un PIC 16F84**
Leçon : Very High Speed Integrated Circuit Hardware Description Language

Chapitre n^o 9
Chap. préc. :	Système monopuce compatible avec les PIC 16C57
Chap. suiv. :	Embarquer un Atmel ATMega8

En raison de limitations techniques, la typographie souhaitable du titre, « Very High Speed Integrated Circuit Hardware Description Language : Embarquer un PIC 16F84
Very High Speed Integrated Circuit Hardware Description Language/Embarquer un PIC 16F84 », n'a pu être restituée correctement ci-dessus.

Remarque

Le contenu de ce paragraphe peut sembler redondant avec les chapitres silicore1657 et ATMega8. Je rappelle que tous ces chapitres sont des projets qui font exactement la même chose, gérer un jeu de pong, d'où cette redondance. Il vous est demandé de choisir votre architecture et de lire le chapitre correspondant. Désolé, mais il en faut pour tous les goûts !

Choix du cœur

Il existe au moins trois versions de descriptions de cœur PIC® 16F84 sur Internet. La plus à jour me semble être un projet en Verilog, appelé risc16F84 dans la suite, et disponible sur le site d'opencores avec des mises à jour récentes (2006). Mais ayant des étudiants qui ne pratiquent que VHDL, nous avons décidé d’utiliser le projet CQPIC, plus ancien certes, mais à l'origine de ce cœur risc16F84.

Nous avons déjà eu l’occasion d’utiliser un cœur de processeur 16C57 dans un autre chapitre de ce cours. Cet ancien projet, dénommé silicore1657 dans la suite de ce document, nous a permis d'acquérir un peu d'expérience mise à profit pour le choix du cœur. Il existe en effet un autre cœur VHDL PIC16F84, appelé PPX par la suite, de Daniel Wallner qui a été utilisé et débogué par Patrice Nouel, Maître de Conférence à l’ENSEIRB (à la retraite maintenant). Mais mon choix s'est porté sur le CQPIC car il n'utilise pas de PORT bidirectionnel mais décompose les PORTS (comme expliqué plus loin dans ce document). La documentation du Silicore1657 nous a alerté à ce sujet : elle attire l'attention de l’utilisateur sur l’utilisation des PORTs dans un cœur. Un cœur bien réalisé doit proposer tout sauf la ROM la RAM et les PORTS parce que leur implémentation est trop dépendante du fabricant du FPGA ciblé. Il n'y a, en effet, aucune norme pour implanter ceux-ci.

Le CQPIC est un cœur de processeur (ou processeur softcore) compatible avec le PIC® 16F84 de microchip. On pouvait le trouver sur Internet sous la forme d'un fichier "cqpic100d.zip". Comme il devient difficile de le trouver nous avons mis une version (améliorée ?) sur Internet : CQPICStart.zip. Il a été développé par Sumio Morioka (Japon) et publié en décembre 1999 dans "Transistor Gijutsu Magazine" (sa dernière mise à jour datait de 2004 avant la notre en 2010)

L'hébergement de mon site perso se termine le 5 septembre 2023 ! À ce jour je n'ai pas encore décidé comment je vais gérer ce problème dont je ne suis pas à l'origine. Il en résulte que le lien CQPICStart et l'ensemble des corrections qui utilisent mon site perso seront indisponibles à partir de cette date. SergeMoutou (discuter)

Nous allons commencer par présenter la partie hardware du cœur en nous basant sur la documentation de Microchip. Vous pouvez lire aussi comment démarrer avec un PIC16F84 ainsi qu'un cours complet de la wikiversité dédié à la programmation des 16F et 18F avec un peu d'assembleur et beaucoup de C.

Architecture du PIC® 16F84

Il s'agit d'un processeur 8 bits avec des instructions codées avec un opcode sur 14 bits. La version originale de ce PIC avait peu de RAM (68 octets). Une autre de ses limitations est la taille de sa pile : avec une pile de huit niveaux seulement, il doit être difficile de réaliser un compilateur C.

Ce processeur gère un certain nombre d'interruptions.

Nous allons commencer par présenter le plus difficile, l'architecture des registres mémoire (Register File dans la terminologie anglo-saxonne que l’on pourrait traduire par dossier/classeur de registres (j'ai trouvé aussi fichier de registres), mais nous préférons registres mémoire ou mémoire de registres ou banc de registres). Nous parlons de difficultés parce qu’il y a plusieurs banques mémoires ce qui est une caractéristique des architectures 8 bits Microchip (jusqu'aux séries 18FXXX) qui disparaissent seulement avec les architectures 16/32 bits (24FXXX et autres)

Architecture des registres SFR et de la mémoire

Les registres SFR (Registres internes à Fonctions Spéciales) sont répartis en deux banques. Cette partie de mémoire est suivie par 68 registres d’usage général pouvant être utilisés comme mémoire simple qui sont identiques sur les deux banques. Ensuite vient une série de registres généraux qui eux dépendent de la banque mémoire choisie et qui ne sont pas implémenté dans le 16F84 original.

La mémoire du 16F84 est organisée en banques sélectionnées par le(s) bit(s) RP0 (et RP1) du registre STATUS. Seul RP0 est utilisé pour le 16F84, soit deux banques.

RAM et Registres du 16F84

Adr.	Banque0	Banque1	Adr.
00h	Indirect addr.	Indirect addr.	80h
01h	TMR0	OPTION_REG
02h	PCL	PCL	82h
03h	STATUS	STATUS
04h	FSR	FSR	84h
05h	PORTA	TRISA
06h	PORTB	TRISB	86h
07h	--	--
08h	EEDATA	EECON1	88h
09h	EEADR	EECON2
0Ah	PCLATH	PCLATH	8Ah
0Bh	INTCON	INTCON
0Ch – 4Fh	68 cases mémoires	idem banque 0	8Ch – CFH
50h – 7Fh	inutilisé	inutilisé	D0H – FFH

La première partie de cette mémoire (les registres) est parfois appelée banc de registres (ou fichier de registres). La partie marquée inutilisée est naturellement inutilisée dans le PIC16F84 original mais sera en fait utilisée par notre cœur CQPIC. Remarquez aussi l'adresse 07h et 87h inutilisée dans le PIC16F84 mais utilisée par notre cœur comme PORTC.

Vous pouvez lire aussi comment démarrer avec un PIC16F84 et/ou Utiliser les PIC 16F et 18F.

Les instructions

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.

Il est temps de présenter maintenant l’ensemble des 35 instructions du PIC® 16F84 codées sur 14 bits. 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 11 bits)
PC compteur programme

Jeu d'instructions 14-bit pour PIC 16F84
Opcode (binary)	Mnemonic	Description
`00 0000 0xx0 0000`	NOP	Pas d'opération
`00 0000 0110 0011`	SLEEP	arrête le processeur
`00 0000 0110 0100`	CLRWDT	Reset du timer watchdog

`00 1000 dfff ffff`	MOVF f,d	Recopie de W dans f (adressage direct)
`00 0000 1fff ffff`	MOVWF	déplacement de W vers f
`00 0001 0xxx xxxx`	CLRW	Positionne W à 0 (idem à CLR x, W)
`00 0001 1fff ffff`	CLRF f	Positionne f à 0 (idem à CLR f, F)
`00 0010 dfff ffff`	SUBWF f, d	Soustrait W de (d = f − W)
`00 0011 dfff ffff`	DECF f, d	Décrément f (d = f − 1)
`00 0100 dfff ffff`	IORWF f, d	OU Inclusif W avec F (d = f OR W)
`00 0101 dfff ffff`	ANDWF f, d	ET entre W et F (d = f AND W)
`00 0110 dfff ffff`	XORWF f, d	OU Exclusif W avec F (d = f XOR W)
`00 0111 dfff ffff`	ADDWF f, d	Additionne W avec F (d = f + W)
`00 1000 dfff ffff`	MOVF f, d	recopie F (d = f)
`00 1001 dfff ffff`	COMF f, d	Complement f (d = NOT f)
`00 1010 dfff ffff`	INCF f, d	Incrément f (d = f + 1)
`00 1011 dfff ffff`	DECFSZ f, d	Decrément f (d = f − 1) et saut si zero
`00 1100 dfff ffff`	RRF f, d	Rotation droite F (rotation droite avec la retenue)
`00 1101 dfff ffff`	RLF f, d	Rotation gauche F (rotation gauche avec la retenue)
`00 1110 dfff ffff`	SWAPF f, d	échange de groupes 4-bit de f (d = lsb:f msb:f)
`00 1111 dfff ffff`	INCFSZ f, d	Incrément f (d = f + 1) et saut si zero

`01 00bb bfff ffff`	BCF f, b	RaZ d'un bit de f (Clear bit b of f)
`01 01bb bfff ffff`	BSF f, b	Mise à 1 d'un bit de f (Set bit b of f)
`01 10bb bfff ffff`	BTFSC f, b	test de bit de f, saute si zéro (Test bit b of f)
`01 11bb bfff ffff`	BTFSS f, b	test de bit de f, saute si un (Test bit b of f)

`11 01xx kkkk kkkk`	RETLW k	Positionne W à k et retour
`10 0kkk kkkk kkkk`	CALL k	Sauve l'adresse de retour, charge PC avec k
`00 0000 0000 1001`	RETFIE	retour d'interruption
`00 0000 0000 1000`	RETURN	retour de sous-programme
`10 1kkk kkkk kkkk`	GOTO k	saut à l'adresse k (9 bits!)
`11 111x kkkk kkkk`	ADDLW k	Addition de W et k
`11 110x kkkk kkkk`	SUBLW k	Soustraction de W et k
`11 00xx kkkk kkkk`	MOVLW k	Chargement littéral de W (W = k)
`11 1000 kkkk kkkk`	IORLW k	OU Inclusif littéral avec W (W = k OR W)
`11 1001 kkkk kkkk`	ANDLW k	ET littéral avec W (W = k AND W)
`11 1010 kkkk kkkk`	XORLW k	OU exclusif or littéral avec W (W = k XOR W)

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

Vous pouvez lire aussi comment démarrer avec un PIC16F84 et/ou Utiliser les PIC 16F et 18F.

Architecture matérielle du PIC 16F84

L'architecture matérielle du PIC 16F84 est relativement simple : elle peut être présentée sous forme de schéma.

Architecture matérielle du PIC 16F84

Évidemment, une description matérielle de cette architecture en VHDL laisse de côté un certain nombre de fonctions comme la réalisation d'une horloge, la gestion analogique des ports avec la possibilité de résistances de tirages par exemple …

Notre cœur ou processeur softcore

Le cœur original CQPIC a été réalisé de manière à être le plus proche du composant PIC® 16F84 original. Voici maintenant une description du cœur sous forme de programme VHDL.

component piccore
	generic (
		STACK_SIZE	: integer;
		WDT_SIZE	: integer
	);
	port (
		progdata	: in std_logic_vector(13 downto 0);
		progadr		: out std_logic_vector(12 downto 0);
		ramdtin		: in std_logic_vector(7 downto 0);
		ramdtout	: out std_logic_vector(7 downto 0);
		ramadr		: out std_logic_vector(8 downto 0);
		readram		: out std_logic;
		writeram	: out std_logic;
		existeeprom	: in std_logic;
		eepdtin		: in std_logic_vector(7 downto 0);
		eepdtout	: out std_logic_vector(7 downto 0);
		eepadr		: out std_logic_vector(7 downto 0);
		readeepreq	: out std_logic;
		readeepack	: in std_logic;
		writeeepreq	: out std_logic;
		writeeepack	: in std_logic;
--> changed ver1.10a, 2010/05/13 (Serge moutou)
--		porta_in	: in std_logic_vector(4 downto 0);
--		porta_out	: out std_logic_vector(4 downto 0);
--		porta_dir	: out std_logic_vector(4 downto 0);
		porta_in	: in std_logic_vector(7 downto 0);
		porta_out	: out std_logic_vector(7 downto 0);
		porta_dir	: out std_logic_vector(7 downto 0);
--<
		portb_in	: in std_logic_vector(7 downto 0);
		portb_out	: out std_logic_vector(7 downto 0);
		portb_dir	: out std_logic_vector(7 downto 0);
		rbpu		: out std_logic;
--> added ver1.10b May 22 2010 (Serge Moutou)
		portc_in	: in std_logic_vector(7 downto 0);	-- PORT-C input data
		portc_out	: out std_logic_vector(7 downto 0);	-- PORT-C output data
		portc_dir	: out std_logic_vector(7 downto 0);	-- TRISC: PORT-C signal direction (H:input, L:output)
		portc_strobe: out std_logic;				-- PORT_C strobe
--<
		int0		: in std_logic;
		int4		: in std_logic;
		int5		: in std_logic;
		int6		: in std_logic;
		int7		: in std_logic;
		t0cki		: in std_logic;
		wdtena		: in std_logic;
		wdtclk		: in std_logic;
		wdtfull		: out std_logic;
		powerdown	: out std_logic;
		startclkin	: out std_logic;
		ponrst_n	: in std_logic;
		mclr_n		: in std_logic;
		clkin		: in std_logic;
		clkout		: out std_logic
	);
end component;

À noter que contrairement au PIC® 16F84, le composant CQPIC utilise une entrée spécifique "t0cki" pour le timer0 (pour le PIC® c’est le bit b4 T0CKl du PORTA). Il y a encore bien d'autres différences : comparez au brochage original du PIC® 16F84 décrit dans un autre projet qui fait apparaître 18 broches seulement.

Conclusion

En général un processeur softcore comprend toujours beaucoup plus d'entrées sorties que le processeur original. Une des raisons est que le cœur donné ci-dessus ne comprend pas sa RAM et sa ROM contrairement au composant original.

Avant de passer aux périphériques nécessaires au bon fonctionnement, il nous faut aborder le problème très spécifique des ports.

Les deux ports du CQPIC

Nous avons fait des modifications sur la gestion des PORTS dans le cœur original qui seront présentées plus loin. Nous nous contenterons dans cette section de généralités.

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 (du FPGA) et donc de l'environnement d'utilisation. Ainsi, la description VHDL des ports est laissée à l'utilisateur du cœur CQPIC.

Un coup d'œil sur le cœur nous montre que chaque port est décomposé en trois ports distincts. Par exemple, pour le PORTA on trouve porta_dir, porta_in et porta_out. Cette façon de faire est assez courante dans les "soft core" et j’ai déjà eu l’occasion de la rencontrer lors d'un projet précédent, le silicore1657. La bidirectionnalité des PORTs 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 porta_dir et portb_dir. Ils sont tous les deux sur 8 bits contrairement au PIC® 16F84 pour lequel le PORTA ne possède que 5 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 porta_in et portb_in ainsi qu'en ports de sortie porta_out et portb_out.

Remarque

Pour des raisons de compatibilité le port porta_dir n’est pas accessible de manière normale. L'écriture dans porta_dir se fait par l'instruction :

// en langage C
TRISA=0xFF; // 1 ⟺ input

tandis qu'en assembleur on écrira :

; assembleur
bsf STATUS,5 ; select memory bank 1
movlw	255	  ;1:input
movwf TRISA ;

Remarque

Comme deuxième remarque, nous dirons qu’à l'origine le PORTA ne disposait que de 5 bits et que nous avons modifié le cœur et le fichier CQPIC.VHD pour que l’on puisse l’utiliser sur 8 bits. Tous les fichiers correspondants se trouvent dans le répertoire "\CQPICStart\PORTA8" du fichier CQPICStart.zip.

Remarque

Notre dernière remarque sera pour compléter notre description. Si l’on écrit dans un programme C :

// en langage C
  PORTA = PORTA; // recopie d'un PORT

ceci aura comme signification : porta_out <= porta_in. Physiquement, ce qui est à gauche du signe égal, n’est pas la même chose que ce qui est à droite.

La description des PORTs dans cette section n’est pas complète et sera reprise quand nous aurons besoin de les relier à une logique externe.

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

Il existe peu de modèles de mémoire standard dans le monde des FPGA et ASIC. En fait le type le plus commun de mémoire que l’on peut trouver est ce que la norme WISHBONE appelle 'FASM', ou FPGA and ASIC Subset Model. Pour la RAM, sa spécificité est qu’il s'agit d'une mémoire à écriture et lecture synchrone. 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 dataram is
   generic(
      ADDR_WIDTH: integer:=9;
      DATA_WIDTH: integer:=8
   );
   port(
      clk: in std_logic;
      write: in std_logic;
      read: in std_logic;
      addr: in std_logic_vector(ADDR_WIDTH-1 downto 0);
      datain: in std_logic_vector(DATA_WIDTH-1 downto 0);
      dataout: out std_logic_vector(DATA_WIDTH-1 downto 0)
    );
end dataram;

architecture RTL of dataram 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 (write='1') then
            ram(to_integer(unsigned(addr))) <= datain;
          end if;
          addr_reg <= addr;
      end if;
   end process;
	dataout <= ram(to_integer(unsigned(addr_reg)));
end RTL;

La gestion de la RAM dans un système mono-puce n’est pas un problème aussi simple qu’il n'y parait. Examinons de plus près ce problème et ce qui fait sa difficulté.

Un coup d'œil sur le programme ci-dessus nous indique immédiatement que les adresses mémoires sont sur 9 bits alors que la documentation du PIC16F84 donne des plages inutilisées à partir de FFh soit sur 8 bits. En VHDL, donner plus de mémoire à un cœur se fait très facilement s'il y a de la place dans le FPGA pour cela. Comme nous avons décidé d’utiliser un compilateur C, notre problème est de savoir comment faire comprendre au compilateur C que l’on dispose de plus de mémoire que prévu ?

Réponse spécifique à l'environnement MPLAB

Normalement les compilateurs ont une directive de compilation pour cela qu’il n’est pas difficile de trouver en page 60 de la documentation du compilateur HiTech C.

Aller dans :

Project → Build Options → project →onglet "global" et remplir "RAM Range".

Sans directive on obtient :

Data space used 7h ( 7) of 44h bytes ( 10.3%)

Avec "default,+50-7f" on obtient :

Data space used 7h ( 7) of 74h bytes ( 6.0%)

Avec "default,+50-7f,+d0-ff" on obtient :

Data space used 7h ( 7) of A4h bytes ( 4.3%)

ce qui montre que l’on peut effectivement augmenter l'espace géré par le compilateur. Nous avons réussi à gérer toutes les adresses sur 8 bits. Il nous reste un 9^e bit à gérer. Mais cela nécessite forcément d'aller regarder dans le cœur comment tout cela est géré, ce que nous n'avons pas fait pour le moment. Nous pensons de toute façon qu’il faut changer de PIC pour prendre un PIC16F87X dans notre projet C, mais ceci n’est pas sans risque puisqu’il y a alors quatre banques et que certain des registres ont été déplacés.

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.

-- This file was generated with hex2rom written by Daniel Wallner 
library IEEE; 
use IEEE.std_logic_1164.all; 
use IEEE.numeric_std.all; 

entity progrom is 
	port( 
		Clk	: in std_logic; 
		romaddr	: in std_logic_vector(12 downto 0); 
		romout	: out std_logic_vector(13 downto 0) 
	); 
end progrom; 

architecture rtl of progrom is 
	signal A_r : std_logic_vector(12 downto 0); 
begin 
	process (Clk) 
	begin 
		if Clk'event and Clk = '1' then 
			A_r <= romaddr; 
		end if; 
	end process; 
	process (A_r) 
	begin 
		case to_integer(unsigned(A_r)) is 
		when 000000 => romout <= "00000100101000";	-- 0x0000 
		when 000001 => romout <= "00001100010110";	-- 0x0002 
		when 000002 => romout <= "11111100110000";	-- 0x0004 
		when 000003 => romout <= "00010100000000";	-- 0x0006 
		when 000004 => romout <= "00001100010000";	-- 0x0008 
		when 000005 => romout <= "00000000110000";	-- 0x000A 
		when 000006 => romout <= "00001100011000";	-- 0x000C 
		when 000007 => romout <= "00000100110000";	-- 0x000E 
		when 000008 => romout <= "00011000000000";	-- 0x0010 
		when 000009 => romout <= "00001100010010";	-- 0x0012 
		when 000010 => romout <= "00010100001000";	-- 0x0014 
		when 000011 => romout <= "00011000000000";	-- 0x0016 
		when 000012 => romout <= "00100100101000";	-- 0x0018 
		when 000013 => romout <= "00000000101000";	-- 0x001A 
		when others => romout <= "--------------"; 
		end case; 
	end process; 
end;

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 se faire automatiquement. Nous utiliserons un programme en C++ que nous donnons en annexe 1 et qui se trouve dans le répertoire "\CQPICStart\ROM" du fichier CQPICStart.zip.

Nos premiers programmes en C

Nous n'allons pas présenter le langage C maintenant puisque d'autres projets le font :

Le langage C chez Wikipédia
La programmation C et ses exercices chez WikiBook
Introduction au langage C et les PIC 16F et 18F en assembleur et C chez Wikiversité

La programmation du cœur se fait à l'aide de l'environnement MPLAB. Ce n’est pas le seul environnement de développement pour les PICs, mais c’est probablement un des plus utilisés et pour ne rien gâcher, il est gratuit. Le téléchargement de MPLAB nous permet d’utiliser l'assembleur ainsi que le compilateur C HiTech. Puisque nous avons décidé pour ce projet de n'utiliser que des outils gratuits, le compilateur C n’est pas optimisé, pour cela il faut payer.

Remarque

MPLAB fonctionne sous wine donc sous Linux contrairement à winAVR.

MPLABX fonctionne directement sous Linux (sans wine) et naturellement sous Windows.

Notre premier programme en C a été réalisé pour tester le fonctionnement du cœur CQPIC sur notre carte d'application Digilent.

Notre architecture CQPIC étant une architecture 8 bits avec peu de mémoire RAM, il peut sembler intéressant de commencer par présenter un programme en C mais qui ne contient que de l'assembleur.

Le premier programme simple en C avec assembleur

Le programme présenté montre comment inclure de l'assembleur dans un programme C.

#include <pic1684.h> 
//#include <htc.h> serait-il mieux ?
main(void) 
{ 
#asm 
Start: bcf _STATUS,5 ; select memory bank 0 
movf _PORTA, W ;read PORTA 
bsf _STATUS,5 ; select memory bank 1 
movwf _TRISA ;Recopie de PORTA 
goto Start 
#endasm 
}

Ne prenez pas ce programme à la lettre. Il est donné pour exemple mais fonctionne de manière surprenante.

Pour avoir d'autres exemples en assembleur, consultez le WIKIBOOK Comment démarrer avec un PIC 16F84.

Le premier programme simple en C pur

Un programme tout simple de test est présenté maintenant : il s'agit tout simplement de recopier le PORTA sur le PORTB. Remarquons aussi que ce programme fonctionne complètement si l’on a pris soin de prendre la version que j’ai réalisée.

#include <pic1684.h> 
//#include <htc.h> serait-il mieux ?
main(void) 
{ // La gestion de TRISA et TRISB semble importante dans ce cœur
  TRISA = 0xFF; // 8 entrees pour A 
  TRISB = 0x00; // 8 sorties pour B 
  while(1) 
  PORTB = PORTA; // recopie du PORTA dans le PORTB qui allume les LEDs	 
}

Contrairement au Silicore1657 déjà évoqué (projet de l'année précédente), le cœur CQPIC dispose du mécanisme d'interruption que nous allons détailler maintenant avec un exemple simple.

Interruption

Pour tester plus en avant notre cœur CQPIC, je décide d’utiliser une interruption. La plus simple des interruptions à mettre en œuvre étant celle du timer0, nous allons examiner maintenant la documentation correspondante.

La documentation du timer0

Nous présentons maintenant le schéma complet correspondant à ce timer0.

Le timer 0 du 16F84

Comme on peut le voir dans la documentation schématique, la gestion du timer0 est essentiellement réalisée par le registre OPTION. Seuls les trois bits de poids faibles de ce registre sont à positionner à 1 pour avoir une division par 256. Comme on le verra dans le programme, cette division ne suffit pas il faudra encore lui ajouter une division par 16 dans l'interruption même, pour que notre chenillard soit visible.

Mettre en route le timer0 est une chose, mais déclencher une interruption en est une autre. Il nous faut maintenant documenter ce mécanisme.

L'interruption du timer 0 dans le 16F84

Pour réaliser l'interruption, il faut réaliser un front montant dans l'ellipse rouge : on en déduit immédiatement les bits à mettre à 1 dans INTCON, à savoir T0IE et GIE.

Remarque

Vous trouverez un peu plus de détails dans un autre projet sur le timer 0 et son interruption. Les schémas internes utilisés sont les mêmes, mais avec un peu plus de commentaires.

Le programme

Le programme correspondant est donné maintenant.

#include <pic1684.h> 
void interrupt decalage(void);

unsigned char nb; 
main(void) 
{ 
  TRISA = 0xF9; // 6 entrees, 2 sorties pour A 
  TRISB = 0x00; // 8 sorties pour B 
  OPTION = 0x07; // prescaler 256 , entree sur quartz 
  INTCON = 0xA0;  // autorise l'interruption timer 
  PORTB = 0x01; // une seule diode allumee		 
  TMR0 = 0x00 ; 
  nb=0; 
  while(1) 
    { 
   // on ne fait rien que recopier sur 2 segments la valeur de SW1 
      if ((PORTA & 0x01) == 1) PORTA = 0x06; 
    } 
} 

void interrupt decalage(void) 
{ 
  nb++; 
  //TMR0 = 0x00; //c'est fait car overflow
  if (!(nb % 16)) 
  PORTB = (PORTB << 1) ; 
  if (PORTB == 0x00)   PORTB = 0x01; 
  T0IF = 0;  // acquittement interruption 
}

Remarquez le "if (!(nb % 16))" qui réalise la division par 16 dans l'interruption. C'est absolument nécessaire pour notre cœur qui fonctionne à 50 Mhz pour voir les LEDs allumées se déplacer.

Remarque

Le lecteur, fin programmeur, nous fera remarquer, à juste titre, que la division est par 16. Il s'agit donc d'une division par une puissance de 2. Le calcul du reste peut alors se faire avec un masque. C'est certainement plus optimisé que l'opérateur modulo mais le projet de pong ne nécessite pas ce genre d'optimisation : notre programme passe son temps à attendre !

Il est maintenant grand temps de revenir sur notre problème original, à savoir interfacer un écran VGA.

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.

Le problème des PORTs

Nous avons besoin de deux fois 10 bits pour piloter nos coordonnées de balles. Une autre façon de dire les choses est qu’il nous faut 4 ports de 8 bits en sortie. Or, nous ne disposons que de deux PORTs de 8 bits en sortie (et encore parce que j’ai étendu le PORTA originel. C'est insuffisant. Il nous faut donc réfléchir sur la façon dont on va pouvoir connecter toutes ces données en sortie.

Pourquoi seulement deux PORTs en sortie ? L'entité du piccore présentée en section précédente ne montre-t-elle pas porta_dir et portb_dir en sortie ?

La modification du cœur CQPIC pour augmenter le nombre de bits du PORTA, m'a amené à lire son code VHDL et je suis tombé sur :

-- VHDL
for I in 0 to 7 loop 
  if (trisa_reg(I) = '1') then 
    ramin_node(I) := portain_sync_reg(I);-- PORT A (when input mode) 
  else 
    ramin_node(I) := portaout_reg(I);-- PORT A (when output mode) 
  end if; 
end loop;

Ce code montre que TRISA est pris en compte en interne dans le cœur CQPIC. Ceci peut sembler normal, mais n’est pas conforme à la seule expérience que nous avions avec le Silicore1657 : puisque TRISA était sorti à l'extérieur il pouvait servir de PORT supplémentaire. Si vous avez l’idée d’utiliser TRISA comme PORT supplémentaire ici, vous aurez un fonctionnement étrange d'un programme C :

//langage C 
TRISA = PORTA ;

Physiquement, on relie PORTA (ra_out) à des interrupteurs et TRISA (ra_dir) à des LEDs. Si PORTA est à OxFF (par les interrupteurs extérieurs), tout interrupteur mis à 0 éteindra correctement la LED correspondante (reliée à TRISA). Mais l'inverse ne marche plus : si ce même interrupteur est remis à 1 on n'allume plus la LED correspondante.

Conclusion

Les deux PORTs TRIS (physiquement porta_dir et portb_dir) du cœur CQPIC ne peuvent en aucun cas être utilisés comme PORTs supplémentaires de sortie. Ils sortent physiquement du cœur mais ne peuvent être utilisés sans précautions.

Après plusieurs années d'expérience avec les processeurs embarqués depuis que ce chapitre a été écrit, nous décidons de compléter cette conclusion. Nous ne comprenons absolument pas ce qui pousse les auteurs de cœurs récents à recopier la bidirectionnalité des PORTs (CQPIC n’est pas récent 1999-2002). Un FPGA comporte aujourd’hui bien plus de broches qu'un micro-contrôleur vendu dans le commerce. Ainsi tous les cœurs récents ne devraient pas utiliser la haute impédance en séparant les entrées et sorties. TRISA, TRISB et TRISC deviendraient alors tout naturellement des registres (ou des PORTs) !

Comment contourner cet obstacle ?

Ajouter un PORTC dans le CQPIC

(Le cœur correspondant se trouve dans le répertoire "\CQPICStart\PORTC" du fichier CQPICStart.zip).

Après avoir passé plusieurs heures à étendre à 8 bits le PORTA (au lieu des 5 initiaux), nous avons repéré à peu près tous les endroits à modifier pour ajouter un PORTC au CQPIC. Le jeu en vaut-il la chandelle ? Cela ne peut pas suffire à résoudre nos problèmes, puisqu'on aura alors en sortie que trois PORTs sur les huit qu’il nous faut. Nous avons finalement réalisé ce changement dans le cœur et en avons profité pour ajouter un signal "strobe" qui accompagne ce port supplémentaire (voir section suivante). C'est ce signal strobe qui va nous permettre de résoudre notre problème d'extension du nombre de PORTs assez facilement.

Notez que cette solution impose de déclarer PORTC et TRISC dans les programmes C. Je déconseille une modification du fichier pic1684.h Faites plutôt comme ceci :

#include <pic1684.h> // ou #include <hct.h>
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87;

C'est simple, mais cela ne permet pas un accès à des bits individuels (mais nous n'avons pas besoin de cela dans notre projet).

Approfondissons cette solution.

Ajouter un "strobe" au PORTC et augmenter le nombre de ports

Un signal "strobe" est une sortie qui indique une écriture dans le PORTC. Ajouter ce signal strobe a été en fait le plus délicat du travail. L'intérêt d'un tel signal est de permettre facilement la démultiplication des PORTs (jusqu'à 256). Nous présentons ci-dessous un exemple qui montre comment étendre à huit le nombre de PORTs. On met la valeur du port véritable de destination dans PORTA puis on met dans PORTC la valeur à écrire : le "strobe" lui sera alors envoyé et il recopiera ce qu’il y a dans PORTC.

Comment ajouter des PORTs avec le signal "strobe"

Il est peut être plus facile de raisonner à partir de ce schéma. Le PORTC (a gauche) est relié à tous les ports ajoutés (à droite) et la logique de décodage envoie le strobe dans le port qui doit recopier ce qu’il y a dans PORTC.

Conclusion

Le fait que le cœur original ne gère pas de signal "strobe" est un grand handicap si l’on veut ajouter de la logique externe. C'est une des raisons qui nous ont fait nous décider à ajouter un PORTC et son strobe associé. Nous ne pensons pas que ce travail puisse être réalisé par un étudiant du niveau 14.

Le programme VHDL correspondant au schéma de la page précédente est présenté maintenant. Il comporte deux entrées PORTA et PORTC pour réaliser quatre ports de sorties pA, pB, pC, pD.

-- increase the number of available ports with the new portC and its strobe 
-- ver1.10b, 2010/05/22 (Serge Moutou)	 
library ieee; 
use ieee.std_logic_1164.all; 
entity ports is 
	port( 
	 clk : in std_logic; 
	 strobeC_in : in std_logic; 
	 portA : in std_logic_vector(7 downto 0); 
	 portC : in std_logic_vector(7 downto 0); 
	 pA,pB,pC,pD : out std_logic_vector(7 downto 0) --new ports 
	); 
end ports; 
architecture BehPorts of ports is 
signal Internal_strobes : std_logic_vector(7 downto 0); 

begin	 
  dmux_Strobe:process(portA,strobeC_in) begin 
    case portA is 
	when "00000001" => Internal_strobes(0) <= strobeC_in; 
        when "00000010" => Internal_strobes(1) <= strobeC_in; 
        when "00000100" => Internal_strobes(2) <= strobeC_in; 
	when "00001000" => Internal_strobes(3) <= strobeC_in; 
	when others => internal_strobes <= (others =>'0'); 
	end case; 
  end process;		 
  
  port_A:process(clk)begin 
    if clk'event and clk='1' then 
	 if Internal_strobes="00000001" then 
		 pA<=portC; 
		end if; 
    end if; 
  end process;	 
  port_B:process(clk)begin 
    if clk'event and clk='1' then 
      if Internal_strobes="00000010" then 
		 pB<=portC; 
		end if; 
    end if; 
  end process; 
  port_C:process(clk)begin 
    if clk'event and clk='1' then 
      if Internal_strobes="00000100" then 
		 pC<=portC; 
		end if; 
    end if; 
  end process; 
  port_D:process(clk)begin 
    if clk'event and clk='1' then 
      if Internal_strobes="00001000" then 
		 pD<=portC; 
		end if; 
    end if; 
  end process;	  
end BehPorts;

Remarquez qu'on a utilisé des "process" au lieu de "components" pour simplifier le programme.

Exercice

Le programme VHDL ci-dessus permet de gérer 4 ports à partir de deux initiaux : le PORTA et le PORTC. Modifier ce programme VHDL pour qu’il gère les 6 ports en sortie conformément à la figure ci-dessus.

Solution

-- increase the number of available ports with the new portC and its strobe
-- ver1.10b, 2010/05/22 (Serge Moutou)	
library ieee;
use ieee.std_logic_1164.all;
entity ports is
	port(
	  clk : in std_logic;
	  strobeC_in : in std_logic;
	  portA : in std_logic_vector(7 downto 0);
	  portC : in std_logic_vector(7 downto 0);
	  pA,pB,pC,pD,pE,pF : out std_logic_vector(7 downto 0) --neww ports
	);
end ports;
architecture BehPorts of ports is
signal Internal_strobes : std_logic_vector(7 downto 0);

begin	
  dmux_Strobe:process(portA,strobeC_in) begin
    case portA is
	   when "00000001" => Internal_strobes(0) <= strobeC_in; 
           when "00000010" => Internal_strobes(1) <= strobeC_in; 
           when "00000100" => Internal_strobes(2) <= strobeC_in; 
	   when "00001000" => Internal_strobes(3) <= strobeC_in;

	   when "00010000" => Internal_strobes(4) <= strobeC_in;

	   when "00100000" => Internal_strobes(5) <= strobeC_in;
	   when others => internal_strobes <= (others =>'0');
	end case;
  end process;		
  
  port_A:process(clk)begin
    if clk'event and clk='1' then
	   if Internal_strobes="00000001" then
		  pA<=portC;
		end if;
    end if;
  end process;	
  port_B:process(clk)begin
    if clk'event and clk='1' then
      if Internal_strobes="00000010" then
		  pB<=portC;
		end if;
    end if;
  end process;
  port_C:process(clk)begin
    if clk'event and clk='1' then
      if Internal_strobes="00000100" then
		  pC<=portC;
		end if;
    end if;
  end process;
  port_D:process(clk)begin
    if clk'event and clk='1' then
      if Internal_strobes="00001000" then
		  pD<=portC;
		end if;
    end if;
  end process;

  port_E:process(clk)begin
    if clk'event and clk='1' then
      if Internal_strobes="00010000" then
		  pE<=portC;
		end if;
    end if;
  end process;

  port_F:process(clk)begin
    if clk'event and clk='1' then
      if Internal_strobes="00100000" then
		  pF<=portC;
		end if;
    end if;
  end process;
end BehPorts;

Arrivé à ce point, il nous faut certainement donner une image simple 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.

Nous allons traiter ce problème en commençant à gérer la balle seulement puis en ajoutant les raquettes.

Programmation du nouveau cœur avec écran VGA

(L'ensemble se trouve dans le répertoire "\CQPICStart\VGA_Pong" du fichier CQPICStart.zip). Nous avons déjà présenté quelques programmes en C, mais nous allons examiner ce qu’il faut changer dans ces programmes pour gérer les nouveaux PORTs.

Programmation en C

Nous commençons par présenter un sous-programme qui écrit une valeur 16 bits dans deux des nouveaux PORTs.

Le sous-programme "setX"

Une version en C pur est montrée ci-dessous :

void setX(unsigned int x){ 
  TRISA=0x00;TRISC=0x00; 
  PORTA=1; 
  PORTC=x; //poids faible 
  PORTA=2; 
  PORTC=x>>8;//poids fort 
}

Le contenu de ce programme est complètement déterminé par la partie matérielle.

Déplacement horizontal en continu de notre balle/rectangle

Nous allons présenter maintenant un programme fonctionnel qui déplace sans arrêt le rectangle sur une horizontale.

#include <pic1684.h>
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87; 
void setX(unsigned int x); 
void setY(unsigned int y); 
void wait(int tempo); 

void main(){ 
int i; 
	while(1){	 
		setY(321); 
		for(i=0;i<600;i++){ 
			setX(i); 
			wait(255); 
			wait(255); 
		} 
	} 
} 

void setX(unsigned int x){
  TRISA=0x00;TRISC=0x00;  
  PORTA=1; //poids faible
  PORTC=x;
  PORTA=2;//poids fort
  PORTC=x>>8;
} 

void setY(unsigned int y){ 
  TRISA=0x00;TRISC=0x00; 
  PORTA=4; //poids faible
  PORTC=x;
  PORTA=8;//poids fort
  PORTC=x>>8;
} 

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

Remarquez l’utilisation du timer0 sans interruption pour faire la temporisation.

Programme complet de gestion simple de la balle

Nous présentons maintenant un programme simple de gestion de la balle avec des rebonds :

#include <pic1684.h> 
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87; 
void setX(unsigned int x); 
void setY(unsigned int y); 
void wait(unsigned char tempo); 
void main(){ 
int posX=0,posY=0; 
signed char deltaX=1,deltaY=1;
	while(1){	 
		if ((posX>=620) && (deltaX>0)) deltaX= -deltaX; 
		if ((posX<=40) && (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); 
		wait(250); 
		wait(250);
	} 
} 

void setX(unsigned int x){ 
  TRISA=0x00;TRISC=0x00; 
  PORTA=1; //poids faible
  PORTC=x;
  PORTA=2;//poids fort
  PORTC=x>>8;
} 

void setY(unsigned int y){ 
  TRISA=0x00;TRISC=0x00; 
  PORTA=4; //poids faible
  PORTC=x;
  PORTA=8;//poids fort
  PORTC=x>>8;
} 

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

L'inconvénient de ce programme est le petit nombre des trajectoires gérées, ce qui peut devenir lassant pour un jeu.

Ajouter les bords, et les raquettes

Comme nous voulons deux raquettes, il nous faut deux coordonnées verticales sur 9 bits (soit 4 ports 8 bits). Nous voulons aussi deux coordonnées de balles soit encore 4 ports de 8 bits. Cela fait en tout 8 ports. Nous avons déjà eu l’occasion de montrer comment on pouvait augmenter le nombre de PORTs.

Solution simple sans bord

Nous avons l'intention dans cette section de mettre en œuvre le programme VHDL de la section Ajouter un "strobe" au PORTC et augmenter le nombre de ports. Puisque ce programme VHDL ne proposait que quatre PORTs de sortie nous allons présenter un ensemble fonctionnant mais avec des positions de raquette fixes. Si l’on numérote les quatre ports de sortie de 0 à 3 on choisit

choix technologiques

E/S module VGA	E/S CQPIC
x_rect<9:8>	PORT1<1:0>
x_rect<7:0>	PORT0<7:0>
y_rect<9:8>	PORT3<1:0>
y_rect<7:0>	PORT2<7:0>

Pour pouvoir gérer des rectangles de tailles différentes et de couleur différentes, on complique un peu la partie destinée à dessiner un rectangle en lui donnant une couleur de rectangle une largeur et une hauteur. Voici donc notre nouveau composant :

COMPONENT rect IS PORT( 
  row,col,x_rec,y_rec,delta_x,delta_y :in STD_LOGIC_VECTOR(9 DOWNTO 0); 
  colorRGB : in  STD_LOGIC_VECTOR(2 DOWNTO 0); 
  red1,green1,blue1 : out std_logic); 
END component;

L'intanciation des rectangles pour la balle et les raquettes se fera alors de la manière suivante :

balle:rect port map(row=>srow, col=>scol,r ed1=>sred, green1=>sgreen, blue1=>sblue, colorRGB=>"111", delta_x=>"0000001010", delta_y=>"0000001100", 				x_rec => x_rect, y_rec => y_rect); 
raquetteG:rect port map(row=>srow, col=>scol, red1=>sred1, green1=>sgreen1,
         blue1=>sblue1, colorRGB=>"100", delta_x=>"0000001010",
         delta_y=>"0000111010", 	x_rec => "0000010110", 
         y_rec(8 downto 1) => y_raquG, y_rec(9)=>'0',y_rec(0)=>'0');	 
raquetteD:rect port map(row=>srow, col=>scol, red1=>sred2, green1=>sgreen2,
          blue1=>sblue2,colorRGB=>"100", delta_x=>"0000001010",
          delta_y=>"0000111010", x_rec => "1001001000", 
          y_rec(8 downto 1) => y_raquD,y_rec(9)=>'0',y_rec(0)=>'0');							 
  red <= sred or sred1 or sred2; 
  green <= sgreen or sgreen1 or sgreen2; 
  blue <= sblue or sblue1 or sblue2;

Les déclarations des signaux dans ce morceau de programme sont omises. Voici maintenant le programme C permettant le rebond sur les raquettes. Vous pouvez remarquer que les coordonnées des raquettes sont calculées en fonction des interrupteurs sur le PORTB, mais ne sont pas mises à jour dans le matériel puisque le matériel ne peut pas le faire.

//#include <pic1684.h> // Programme pour Hitech C dans MPLAB
#include <htc.h> //***** Hitech C *******
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87; 
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(RB2==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}} PORTB/raquette 
		 if (RB6) if (raqG_y<215) raqG_y++; 
			if (RB7) if (raqG_y>0) raqG_y--; 
		//PORT4=raqG_y; 
			if (RB0) if (raqD_y<215) raqD_y++; 
			if (RB1) if (raqD_y>0) raqD_y--; 
		//PORT5=raqD_y; 
			wait(250); 
			wait(250); 
		} 
	} 
}

Comme on peut le voir nous avons choisi le PORTB connecté aux interrupteurs sw0,sw1,sw6 et sw7 de la carte, pour faire descendre et monter les raquettes et sw2 (RB2) pour le départ.

Travail à réaliser

Analyse

Comprendre la partie matérielle. Vous devez être capable de dessiner les composants et leurs liaisons à partir des fichiers VHDL donnés dans le répertoire "\CQPICStart\VGA_Pong" du fichier CQPICStart.zip.

Synthèse

Étendre la partie matérielle pour gérer le déplacement des deux raquettes. On choisira une coordonnée Y de chacune des raquettes, au choix, sur 8 bits (comme dans le projet silicore1657 de l'année dernière) ou sur 9/10 bits. Pour un choix sur 8 bits on pourra prendre :

choix technologiques

E/S module VGA	E/S CQPIC
x_rect<9:8>	PORT1<1:0>
x_rect<7:0>	PORT0<7:0>
y_rect<9:8>	PORT3<1:0>
y_rect<7:0>	PORT2<7:0>
y_raqG<7:0>	PORT4<7:0>
y_raqD<7:0>	PORT5<7:0>

Solution

Le contenu de la gestion des ports est donné dans l'exercice plus haut. Voici le complément :

-- CQPIC.vhd
-- CQPIC top (PIC16F8 with CPU-core, program ROM and data RAM)
-- (1) Version 1.00a		Nov 1 1999
--
-- Copyright(c)1999-2002 Sumio Morioka
-- e-mail:morioka@fb3.so-net.ne.jp, URL:http://www02.so-net.ne.jp/~morioka

-- (5) version 1.10a	May 13 2010 (Serge Moutou)
-- remove the single bit Input/Outout and replace them with vectors
-- (6) version 1.10b	May 15 2010 (Serge Moutou)
-- increase the number of ports using strobe signal
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;

entity cqpic is
	port (
--> changed ver1.10a, 2010/05/13 (Serge Moutou)
--		ra4_in		: in  std_logic;
--		ra3_in		: in  std_logic;
--		ra2_in		: in  std_logic;
--		ra1_in		: in  std_logic;
--		ra0_in		: in  std_logic;	
		ra_in		: in  std_logic_vector(7 downto 0);
--		rb7_in		: in  std_logic;
--		rb6_in		: in  std_logic;
--		rb5_in		: in  std_logic;
--		rb4_in		: in  std_logic;
--		rb3_in		: in  std_logic;
--		rb2_in		: in  std_logic;
--		rb1_in		: in  std_logic;
--		rb0_in		: in  std_logic;
		rb_in		: in  std_logic_vector(7 downto 0);
--<		
		ponrst_n	: in  std_logic;
		mclr_n		: in  std_logic;
		clkin		: in  std_logic;
		wdtena		: in  std_logic;
		wdtclk		: in  std_logic;
--> changed ver1.10a, 2010/05/13 (Serge Moutou)
--		ra4_out		: out std_logic;
--		ra3_out		: out std_logic;
--		ra2_out		: out std_logic;
--		ra1_out		: out std_logic;
--		ra0_out		: out std_logic;
		ra_out		: out  std_logic_vector(7 downto 0);
--		rb7_out		: out std_logic;
--		rb6_out		: out std_logic;
--		rb5_out		: out std_logic;
--		rb4_out		: out std_logic;
--		rb3_out		: out std_logic;
--		rb2_out		: out std_logic;
--		rb1_out		: out std_logic;
--		rb0_out		: out std_logic;
		rb_out		: out  std_logic_vector(7 downto 0);
--		ra4_dir		: out std_logic;
--		ra3_dir		: out std_logic;
--		ra2_dir		: out std_logic;
--		ra1_dir		: out std_logic;
--		ra0_dir		: out std_logic;
		ra_dir		: out  std_logic_vector(7 downto 0);
--		rb7_dir		: out std_logic;
--		rb6_dir		: out std_logic;
--		rb5_dir		: out std_logic;
--		rb4_dir		: out std_logic;
--		rb3_dir		: out std_logic;
--		rb2_dir		: out std_logic;
--		rb1_dir		: out std_logic;
--		rb0_dir		: out std_logic;
		rb_dir		: out  std_logic_vector(7 downto 0);
--<
--> added ver1.10b May 22 2010 (Serge Moutou)		
		rc_out, rc_dir	: out  std_logic_vector(7 downto 0);	-- PORT-C  data
		rc_in : in std_logic_vector(7 downto 0);
		rd_out : out  std_logic_vector(7 downto 0);	-- PORT-D  data
		re_out : out  std_logic_vector(7 downto 0);	-- PORT-E  data

		rf_out : out  std_logic_vector(7 downto 0);	-- PORT-F  data
--<		
		clkout		: out std_logic;
		wdtfull		: out std_logic;
		powerdown	: out std_logic;
		startclkin	: out std_logic
	);
end cqpic;

architecture RTL of cqpic is
	-- CPU core
	component piccore
		generic (
			STACK_SIZE	: integer;
			WDT_SIZE	: integer
		);
		port (
			progdata	: in  std_logic_vector(13 downto 0);
			progadr		: out std_logic_vector(12 downto 0);
			ramdtin		: in  std_logic_vector(7 downto 0);
			ramdtout	: out std_logic_vector(7 downto 0);
			ramadr		: out std_logic_vector(8 downto 0);
			readram		: out std_logic;
			writeram	: out std_logic;
			existeeprom	: in  std_logic;
			eepdtin		: in  std_logic_vector(7 downto 0);
			eepdtout	: out std_logic_vector(7 downto 0);
			eepadr		: out std_logic_vector(7 downto 0);
			readeepreq	: out std_logic;
			readeepack	: in  std_logic;
			writeeepreq	: out std_logic;
			writeeepack	: in  std_logic;
--> changed ver1.10a, 2010/05/13 (Serge moutou)	
--		porta_in	: in  std_logic_vector(4 downto 0);				
--		porta_out	: out std_logic_vector(4 downto 0);				
--		porta_dir	: out std_logic_vector(4 downto 0);				
		porta_in	: in  std_logic_vector(7 downto 0);				
		porta_out	: out std_logic_vector(7 downto 0);				
		porta_dir	: out std_logic_vector(7 downto 0);
--<
		portb_in	: in  std_logic_vector(7 downto 0);
		portb_out	: out std_logic_vector(7 downto 0);
		portb_dir	: out std_logic_vector(7 downto 0);
		rbpu		: out std_logic;
--> added ver1.10b May 22 2010 (Serge Moutou)		
		portc_in	: in  std_logic_vector(7 downto 0);	-- PORT-C input data
		portc_out	: out std_logic_vector(7 downto 0);	-- PORT-C output data
		portc_dir	: out std_logic_vector(7 downto 0);	-- TRISC: PORT-C signal direction (H:input, L:output)
		portc_strobe: out std_logic;				-- PORT_C strobe
--<				
		int0		: in  std_logic;
		int4		: in  std_logic;
		int5		: in  std_logic;
		int6		: in  std_logic;
		int7		: in  std_logic;
		t0cki		: in  std_logic;
		wdtena		: in  std_logic;
		wdtclk		: in  std_logic;
		wdtfull		: out std_logic;
		powerdown	: out std_logic;
		startclkin	: out std_logic;
		ponrst_n	: in  std_logic;
		mclr_n		: in  std_logic;
		clkin		: in  std_logic;
		clkout		: out std_logic
	);
	end component;

	-- program ROM
	component progrom
		port (
			romaddr		: in  std_logic_vector(12 downto 0);
			clk			: in  std_logic;
			romout		: out std_logic_vector(13 downto 0)
		);
	end component;

	-- data RAM (SRAM)
	component dataram
		port (
			addr	: in  std_logic_vector(8 downto 0);
			read	: in  std_logic;
			write	: in  std_logic;
			clk		: in  std_logic;
			datain	: in  std_logic_vector(7 downto 0);
			dataout	: out std_logic_vector(7 downto 0)
		);
	end component;
--> added ver1.10b May 22 2010 (Serge Moutou)	
	component ports 
	port(
	  clk : in std_logic;
	  strobeC_in : in std_logic;
	  portA : in std_logic_vector(7 downto 0);
	  portC : in std_logic_vector(7 downto 0);
	  pA,pB,pC,pD,pE,pF : out std_logic_vector(7 downto 0) --neww ports
	);
	end component;
--<		
	signal romaddr		: std_logic_vector(12 downto 0);
	signal romdata		: std_logic_vector(13 downto 0);

	signal ramaddr		: std_logic_vector(8 downto 0);
	signal ramindata	: std_logic_vector(7 downto 0);
	signal ramoutdata	: std_logic_vector(7 downto 0);
	signal readram		: std_logic;
	signal writeram		: std_logic;
--> changed ver1.10a, 2010/05/13 (Serge Moutou)
--	signal rain_node	: std_logic_vector(4 downto 0);
--	signal raout_node	: std_logic_vector(4 downto 0);
--	signal radir_node	: std_logic_vector(4 downto 0);
	signal rain_node	: std_logic_vector(7 downto 0);
	signal raout_node	: std_logic_vector(7 downto 0);
	signal radir_node	: std_logic_vector(7 downto 0);
--<	
	signal rbin_node	: std_logic_vector(7 downto 0);
	signal rbout_node	: std_logic_vector(7 downto 0);
	signal rbdir_node	: std_logic_vector(7 downto 0);
--> added ver1.10b May 22 2010 (Serge Moutou)
	signal rcin_node	: std_logic_vector(7 downto 0);
	signal rcout_node	: std_logic_vector(7 downto 0);
	signal rcdir_node	: std_logic_vector(7 downto 0);
	signal s_strobe 		: std_logic;
--<	
	signal VCC_node		: std_logic;
	signal GND_node		: std_logic;
	signal GND_vec_node	: std_logic_vector(7 downto 0);	

begin
	VCC_node		<= '1';
	GND_node		<= '0';
	GND_vec_node	<= "00000000";

	U1: piccore
		generic map (
			STACK_SIZE	=> 8,
			WDT_SIZE	=> 255		
		)
		port map (
			progdata	=>	romdata,		--  in
			progadr		=>	romaddr,		--  out
			ramdtin		=>	ramoutdata,		--  in
			ramdtout	=>	ramindata,		--  out
			ramadr		=>	ramaddr,		--  out
			readram		=>	readram,		--  out
			writeram	=>	writeram,		--  out
			existeeprom	=>	GND_node,		--  in
			eepdtin		=>	GND_vec_node,	--  in
--	NC		eepdtout	=>	,				--  out
--	NC		eepadr		=>	,				--  out
--	NC		readeepreq	=>	,				--  out
			readeepack	=>	VCC_node,		--  in
--	NC		writeeepreq	=>	,				--  out
			writeeepack	=>	VCC_node,		--  in
			porta_in	=>	rain_node,		--  in
			porta_out	=>	raout_node,		--  out
			porta_dir	=>	radir_node,		--  out
			portb_in	=>	rbin_node,		--  in
			portb_out	=>	rbout_node,		--  out
			portb_dir	=>	rbdir_node,		--  out
--> added ver1.10b May 22 2010 (Serge Moutou)		
			portc_in	=>	rcin_node,		--  in
			portc_out	=>	rcout_node,		--  out
			portc_dir	=>	rcdir_node,		--  out
			portc_strobe => s_strobe, 
--<			
-- NC		rbpu		=>					--  out
			int0		=>	rbin_node(0),	--  in
			int4		=>	rbin_node(4),	--  in
			int5		=>	rbin_node(5),	--  in
			int6		=>	rbin_node(6),	--  in
			int7		=>	rbin_node(7),	--  in
			t0cki		=>	rain_node(4),	--  in
			wdtena		=>	wdtena,			--  in
			wdtclk		=>	wdtclk,			--  in
			wdtfull		=>	wdtfull,		--  out
			powerdown	=>	powerdown,		--  out
			startclkin	=>	startclkin,		--  out
			-- added "not" (Serge Moutou 2010/05) for Digilent board
			ponrst_n	=>	not ponrst_n,		--  in
			mclr_n		=>	not mclr_n,			--  in
			clkin		=>	clkin,			--  in
			clkout		=>	clkout			--  out
		);

	U2: progrom
		port map (
			romaddr		=> romaddr,
			clk			=> clkin,
			romout		=> romdata
		);

	U3: dataram
		port map (
			addr		=> ramaddr,
			read		=> readram,
			write		=> writeram,
			clk			=> clkin,
			datain		=> ramindata,
			dataout		=> ramoutdata
		);
--> added ver1.10b May 22 2010 (Serge Moutou)
	U4: ports
			port map (
				clk => clkin,--rbout_node(0),
				strobeC_in => s_strobe,--rbout_node(1),
				portA => raout_node,
				portC => rcout_node,
				pA => ra_out, --neww ports
				pB => rb_out,
				pC => rc_out,--pC => rd_out,
				pD => rd_out,--pD => re_out,

				pE => re_out,

				pF => rf_out
			);
--<
--> changed ver1.10a, 2010/05/13 (Serge Moutou)
--	rain_node(4) <= ra4_in;
--	rain_node(3) <= ra3_in;
--	rain_node(2) <= ra2_in;
--	rain_node(1) <= ra1_in;
--	rain_node(0) <= ra0_in;
	rain_node <= ra_in;
--	ra4_out	<= raout_node(4);
--	ra3_out	<= raout_node(3);
--	ra2_out	<= raout_node(2);
--	ra1_out	<= raout_node(1);
--	ra0_out	<= raout_node(0);
--removed ver1.10b, 2010/05/15	ra_out <= raout_node;
--	ra4_dir	<= radir_node(4);
--	ra3_dir	<= radir_node(3);
--	ra2_dir	<= radir_node(2);
--	ra1_dir	<= radir_node(1);
--	ra0_dir	<= radir_node(0);
	ra_dir <= radir_node;
--	rbin_node(7) <= rb7_in;
--	rbin_node(6) <= rb6_in;
--	rbin_node(5) <= rb5_in;
--	rbin_node(4) <= rb4_in;
--	rbin_node(3) <= rb3_in;
--	rbin_node(2) <= rb2_in;
--	rbin_node(1) <= rb1_in;
--	rbin_node(0) <= rb0_in;
	rbin_node <= rb_in;
--	rb7_out	<= rbout_node(7);
--	rb6_out	<= rbout_node(6);
--	rb5_out	<= rbout_node(5);
--	rb4_out	<= rbout_node(4);
--	rb3_out	<= rbout_node(3);
--	rb2_out	<= rbout_node(2);
--	rb1_out	<= rbout_node(1);
--	rb0_out	<= rbout_node(0);
-- removed	ver1.10b, 2010/05/15 rb_out <= rbout_node;
--	rb7_dir	<= rbdir_node(7);
--	rb6_dir	<= rbdir_node(6);
--	rb5_dir	<= rbdir_node(5);
--	rb4_dir	<= rbdir_node(4);
--	rb3_dir	<= rbdir_node(3);
--	rb2_dir	<= rbdir_node(2);
--	rb1_dir	<= rbdir_node(1);
--	rb0_dir	<= rbdir_node(0);
	rb_dir <= rbdir_node;
--<
--> added ver1.10b May 22 2010 (Serge Moutou)
	rcin_node <= rc_in;
	rc_dir <= rcdir_node;
	--rc_out <= rcout_node; -- c<=b:normal 
--	rb_out <= rbout_node;
--	ra_out <= raout_node;
--<	
end RTL;

Programmation

Explorer s'il n’est pas possible d’utiliser l'algorithme de tracé de segment de droite Bresenham pour les trajectoires de balles. Cet algorithme est expliqué dans le WIKI : Algorithme de tracé de segment de Bresenham. Il est possible de trouver directement une version en C : tapez Bresenham en C dans google.

Solution

Premièrement : modifier le programme pour utiliser setXY au lieu et place de setX et setY :

//#include <pic1684.h> // Programme pour Hitech C dans MPLAB
#include <htc.h>
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87; 
void setXY(unsigned int x,unsigned int y); 
void wait(unsigned char tempo); 
unsigned int posRaqu_16; 
void main(){ 
unsigned int posX,posY;
unsigned char raqD_y=0,raqG_y=0; 
signed char deltaX=1,deltaY=1; 
	TRISB=0xFF;// entree
	while(1){	 
		posX=113;		 
		posY=101; 
		setXY(posX,posY); 
		while(RB2==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; 
			if ((posY>=460) && (deltaY>0)) deltaY= -deltaY; 
			if ((posY<=10) && (deltaY<0)) deltaY= -deltaY; 
			posY=posY+deltaY; 
			setXY(posX,posY); 
// gestion des raquettes {{Unité|2|bits}} PORTB/raquette 
		 if (RB6) if (raqG_y<215) raqG_y++; 
			if (RB7) if (raqG_y>0) raqG_y--; 
		//PORTE=raqG_y;
 			PORTA=16;
			PORTC=raqG_y;
			if (RB0) if (raqD_y<215) raqD_y++; 
			if (RB1) if (raqD_y>0) raqD_y--; 
		//PORTF=raqD_y;
			PORTA=32;
			PORTC=raqD_y; 
			wait(250); 
			wait(250); 
		} 
	} 
} 

void setXY(unsigned int x,unsigned int y){ 
  TRISA=0x00;TRISC=0x00;
  PORTA=1; //poids faible
  PORTC=x;
  PORTA=2;//poids fort
  PORTC=x>>8;
  PORTA=4; //poids faible
  PORTC=y;
  PORTA=8;//poids fort
  PORTC=y>>8;
} 

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

Pour l’algorithme de tracé de segment de Bresenham, le programme le plus compact trouvé sur internet est :

//********* http://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm
void line(int x0, int y0, int x1, int y1) {
 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1; 
 int err = (dx>dy ? dx : -dy)/2, e2;
  for(;;){
    setPixel(x0,y0);
    if (x0==x1 && y0==y1) break;
    e2 = err;
    if (e2 >-dx) { err -= dy; x0 += sx; }
    if (e2 < dy) { err += dx; y0 += sy; }
  }
}

La première chose que fait l'algorithme est de calculer dx et dy. En ce qui nous concerne, nous ne ferons pas ce calcul puisque nous gérerons directement ce dx et ce dy. Entre parenthèse, cela nous évite de calculer des points d'intersections de notre trajectoire avec les bords de l'écran.

En remarquant que x0 est notre posX, y0 est notre posY, sx est notre deltaX et donc sy notre delatY, il vient :

#include <pic1684.h> // Programme pour Hitech C dans MPLAB
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87; 
void setXY(unsigned int x,unsigned int y); 
void wait(unsigned char tempo); 
unsigned int posRaqu_16; 
void main(){ 
unsigned int posX,posY;
int dx=10,dy=10,err=-5,e2; //Pour Bresenham
unsigned char raqD_y=0,raqG_y=0; 
signed char deltaX=1,deltaY=1; 
	TRISB=0xFF;// entree
	while(1){	 
		posX=113;		 
		posY=101; 
		setXY(posX,posY); 
		while(RB2==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; Retiré pour Bresenham
			if ((posY>=460) && (deltaY>0)) deltaY= -deltaY; 
			if ((posY<=10) && (deltaY<0)) deltaY= -deltaY;
//*********** Début de Brensenham
			e2 = err; 
			if (e2 >-dx) { err -= dy; posX += deltaX; }
			if (e2 < dy) { err += dx; posY += deltaY; } 
//			posY=posY+deltaY; 
			setXY(posX,posY); 
//*********** fin de Bresenham
// gestion des raquettes {{Unité|2|bits}} PORTB/raquette 
		 if (RB6) if (raqG_y<215) raqG_y++; 
			if (RB7) if (raqG_y>0) raqG_y--; 
		//PORTE=raqG_y;
 			PORTA=16;
			PORTC=raqG_y;
			if (RB0) if (raqD_y<215) raqD_y++; 
			if (RB1) if (raqD_y>0) raqD_y--; 
		//PORTF=raqD_y;
			PORTA=32;
			PORTC=raqD_y; 
			wait(250); 
			wait(250); 
		} 
	} 
} 

//************* voir ci-dessus pour setXY et wait

Il ne reste plus qu’à faire varier deltaY entre 15 et 5 par exemple à l'aide des rebonds sur les raquettes.

Certains se demandent peut-être ce qu’il y a de Bresenham là-dedans. Je vous rappelle que l'algorithme original permet de calculer les points d'une droite sans multiplication et sans division, c’est ce que l’on fait ici. Ce qui caractérise cet algorithme c’est que la pente de la droite tracée est dy/dx, c'est-à-dire un nombre rationnel, c’est ce que l’on a encore une fois. Changez la ligne

// int err = (dx>dy ? dx : -dy)/2, e2; montre comment calculer err
int dx=10,dy=10,err=-5,e2; //Pour Bresenham

en

// int err = (dx>dy ? dx : -dy)/2, e2; montre comment calculer err
int dx=10,dy=5,err=+5,e2; //Pour Bresenham

ou encore en

// int err = (dx>dy ? dx : -dy)/2, e2; montre comment calculer err
int dx=10,dy=15,err=-7,e2; //Pour Bresenham

pour voir les différentes pentes du déplacement de la balle.

Ne pas oublier que dès que dy ou dx varie il faut mettre à jour la variable err pour bien faire ! Seule cette opération nécessite une division par 2.

Voici un exemple qui change la pente de la balle en fonction du mouvement de la raquette au moment du rebond. Pour bien faire, il faudrait que si le déplacement de la raquette et de la balle sont dans le même sens la pente augmente, s'ils sont dans la direction opposée la pente diminue et si les raquettes sont immobiles la pente reste constante. Cela revient à gérer les rebonds sur les raquettes, par exemple, de la manière suivante :

dx est fixé à 10 et ne change jamais
si les raquettes sont immobiles au moment du rebond dy ne change pas
si le déplacement de la balle (suivant y) et de la raquette ont même signe on augmente dy en ne dépassant jamais 15
si le déplacement de la raquette et de la balle (suivant y) sont en sens contraires on diminue dy en ne dépassant jamais 5

#include <pic1684.h> // Programme pour Hitech C dans MPLAB
volatile unsigned char	PORTC	@ 0x07; 
volatile unsigned char TRISC	@ 0x87; 
void setXY(unsigned int x,unsigned int y); 
void wait(unsigned char tempo); 
unsigned int posRaqu_16; 
void main(){ 
unsigned int posX,posY;
// int err = (dx>dy ? dx : -dy)/2, e2;
int dx=10,dy=10,err=-5,e2; //Brensenham
unsigned char raqD_y=0,raqG_y=0; 
signed char deltaX=1,deltaY=1,delta_raqG_y,delta_raqD_y; 
	TRISB=0xFF;// entree
	while(1){	 
		posX=113;		 
		posY=101; 
		setXY(posX,posY); 
		while(RB2==0); // attente départ
		dx=10;dy=10;err=-5; //reinitialisation Bresenham
		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;
				if (delta_raqD_y) { // delta_raqG_y!=0 on change la pente
					 if ((delta_raqD_y >0 && deltaY >0) ||(delta_raqD_y <0 && deltaY <0)) {
					 	dy+=1; if (dy > 15) dy=15; // ne peut dépasser 15
				// int err = (dx>dy ? dx : -dy)/2, e2;
						if (dx>dy) err = dx/2; else err = -dy/2;
					 } else {
					 	dy-=1; if (dy < 5) dy=5; // ne peut dépasser 5
				// int err = (dx>dy ? dx : -dy)/2, e2;
						if (dx>dy) err = dx/2; else err = -dy/2;
					 }
				}	
 			}	
			posRaqu_16=raqG_y<<1; 
			if ((posX<=32) && (posY<posRaqu_16+58) && (posY+10>posRaqu_16) && (deltaX<0)) {
				deltaX= -deltaX;
				if (delta_raqG_y) { // delta_raqG_y!=0 on change la pente
					 if ((delta_raqG_y >0 && deltaY >0) ||(delta_raqG_y <0 && deltaY <0)) {
					 	dy+=1; if (dy > 15) dy=15; // ne peut dépasser 15
				// int err = (dx>dy ? dx : -dy)/2, e2;
						if (dx>dy) err = dx/2; else err = -dy/2;
					 } else {
					 	dy-=1; if (dy < 5) dy=5; // ne peut dépasser 5
				// int err = (dx>dy ? dx : -dy)/2, e2;
						if (dx>dy) err = dx/2; else err = -dy/2;
					 }
				}			
			}
//			posX=posX+deltaX; Removed 
			if ((posY>=460) && (deltaY>0)) deltaY= -deltaY; 
			if ((posY<=10) && (deltaY<0)) deltaY= -deltaY;
// gestion des raquettes {{Unité|2|bits}} PORTB/raquette
			delta_raqG_y=0; 
		 if (RB6) if (raqG_y<215) delta_raqG_y=1; 
			if (RB7) if (raqG_y>0) delta_raqG_y=-1;
            raqG_y+=delta_raqG_y; 
		//PORTE=raqG_y;
 			PORTA=16;
			PORTC=raqG_y;
			delta_raqD_y=0; 
			if (RB0) if (raqD_y<215) delta_raqD_y=1; 
			if (RB1) if (raqD_y>0) delta_raqD_y=-1;
			raqD_y+=delta_raqD_y;; 
		//PORTF=raqD_y;
			PORTA=32;
			PORTC=raqD_y; 
// Brensenham
			e2 = err; 
			if (e2 >-dx) { err -= dy; posX += deltaX; }
			if (e2 < dy) { err += dx; posY += deltaY; } 
//			posY=posY+deltaY; 
			setXY(posX,posY); 
			wait(250); 
			wait(250); 
		} 
	} 
}

Pour information l’ensemble des resources mémoire de ce programme est donné maintenant :

Memory Summary:  
Program space        used   396h (   918) of   400h words   ( 89.6%)
Data space           used    21h (    33) of    A4h bytes   ( 20.1%)
EEPROM space         used     0h (     0) of    40h bytes   (  0.0%)
Configuration bits   used     0h (     0) of     1h word    (  0.0%)
ID Location space    used     0h (     0) of     4h bytes   (  0.0%)

Ce qui montre qu’il ne nous reste plus grand chose au niveau de la mémoire de code !!! Bon une bonne nouvelle quand même :

Dans l'environnement MPLAB, aller dans : Project → Build Options → project →onglet "global" et remplir "ROM" avec : default,+400-7FF.

Ceci double la ROM disponible dans notre cœur... et toute cette mémoire est disponible sans problème dans notre FPGA.

Synthèse matérielle et programmation

Gérer un affichage des scores dans la partie basse de l'écran, soit avec une mémoire de caractères, soit avec des afficheurs sept segments à construire.

Gestion du jeu de Pong sur un écran VGA

Voila ce que cela donne avec un affichage sept segments simulé.

Annexe 1

Le programme C++ pour transformer le fichier HEX en fichier VHDL n’est pas donné car un petit peu trop long. Il se trouve dans le répertoire "\CQPICStart\ROM" du fichier CQPICStart.zip

Ce n’est pas le fichier original hex2vhd.c proposé avec le cœur CQPIC qui est utilisé. C'est le fichier hex2rom.cpp présent dans un cœur concurrent, à savoir le cœur PPX. Ce fichier a été légèrement modifié pour que le programme généré puisse aller directement dans notre projet VHDL.

Un fois compilé mon utilitaire s’appelle hex2rom.exe (sous windows) ou hex2rom sous Linux. L'utilisation est faite par la ligne de commande :

	hex2rom demo16F84.hex progrom 13l14s >progrom.vhd

si le fichier à convertir s’appelle demo16F84.hex.

Le fichier généré s’appelle progrom.vhd et a "progrom" comme nom d'entité. 13 est le nombre de bit d'adresses, l désigne le fait que l’on utilise la convention little indian (b désignerait big indian) et 14 est le nombre de bits de données dans la ROM.

Si l’on utilise le fichier VHDL directement sans modifier les options de synthèse, nous nous trouvons avec de la ROM distribuée. C'est à vous de décider si c’est grave ou pas.

Les blocs mémoires distribués utilisés dans le FPGA

L'ensemble des blocs utilisés se trouve en blanc et cet exemple montre bien pourquoi on appelle cela de la RAM distribuée (points blancs répartis dans le FPGA). Les blocs RAM (rectangles rouges) sont donc inutilisés (en fait ils sont partiellement utilisés par la RAM du 16F84). Vous pourrez noter que cette façon de faire est très consommatrice de ressources.

La différence entre RAM distribuée et bloc RAM (BRAM) est expliquée dans un autre projet.

Remarque

Un essai avec une ROM minimale me montre une synthèse qui prend seulement 5% du Spartan3 200 contre 80% avec un programme conséquent. Ces chiffres nous ont conduit à considérer sérieusement la possibilité d’utiliser des BRAM dans ce projet. Ce travail bien fait pourrait nous autoriser à utiliser data2mem comme expliqué dans un autre chapitre donc gagner énormément en taille et en souplesse. Consulter la section Utiliser data2mem avec CQPIC pour voir l'état d'avancement de ce futur travail.

Annexe II : le fichier ucf

Le fichier ucf dépend à la fois du FPGA utilisé et de la carte de développement.

#PORTB sur leds
net "rb0_out" loc="K12";
net "rb1_out" loc="P14";
net "rb2_out" loc="L12";
net "rb3_out" loc="N14";
net "rb4_out" loc="P13";
net "rb5_out" loc="N12";
net "rb6_out" loc="P12";
net "rb7_out" loc="P11";
#PORTB sur interrupteurs
net "rb_in<7>" loc="k13"; 
net "rb_in<6>" loc="k14"; 
net "rb_in<5>" loc="j13"; 
net "rb_in<4>" loc="j14"; 
net "rb_in<3>" loc="h13"; 
net "rb_in<2>" loc="h14";  
net "rb_in<1>" loc="g12"; 
net "rb_in<0>" loc="f12";
# clock
net "clkin" loc="T9";
net "clkin" TNM_NET = "clkin";
TIMESPEC "TS_mclk" = PERIOD "clkin" 20 ns HIGH 50 %;
# reset
net "mclr_n" loc="M13"; 
net "ponrst_n" loc="M14";
#VGA
net "hsynch" loc="R9";
net "vsynch" loc="T10";
net "red" loc="R12";
net "blue" loc="R11";
net "green" loc="T12";

Ce fichier ucf fonctionne correctement avec la version 9.2 de l'IDE mais la version 11.1 nécessite le rajout de :

NET "rb_in<0>" CLOCK_DEDICATED_ROUTE = FALSE;
NET "rb_in<4>" CLOCK_DEDICATED_ROUTE = FALSE;
NET "rb_in<5>" CLOCK_DEDICATED_ROUTE = FALSE;
NET "rb_in<6>" CLOCK_DEDICATED_ROUTE = FALSE;
NET "rb_in<7>" CLOCK_DEDICATED_ROUTE = FALSE;

en tout début de fichier.

Voir aussi

System on Chip
Processeur softcore
La version pdf, une version parfois plus complète de ce document.
PIC 16F84 de Microchip
Conception et VHDL
Comment démarrer avec un PIC 16F84
Utiliser les PIC 16F et 18F
Le langage C chez Wikipédia
La programmation C et ses exercices chez WikiBook
Introduction au langage C chez Wikiversité
la carte Spartan-3 Starter Board
ISE Xilinx pour développer en VHDL ou plus exactement le WebPack gratuit. Attention choisir une version qui propose le webPack (12.3 ou 12.2 mais pas 12.1 ou une plus ancienne avec laquelle je travaille 11.1).
RAM et FPGA dans un FPGA.
le site du CQPIC

Very High Speed Integrated Circuit Hardware Description Language

Système monopuce compatible avec les PIC 16C57

Embarquer un Atmel ATMega8