system on chip (soc)...créer un sous programme « delai » qui génère un délai de 1 msec sachant...

ELT3

2014-2015

Vahid MEGHDADI

System on Chip (SoC)

Vahid MEGHDADI ENSIL Limoges

Introduction

Schéma global d’un circuit numérique composé d’un circuit programmable de type

µP et des circuits logiques tout au tours.


Le tout sur un FPGA (SoC)

FPGA

Un microprocesseur est un circuit logique comme les autres, donc tout à fait

intégrable sur le FPGA.


Evolution de FPGA FPGA uniquement contenant des logiques programmables, tout se

construit avec des logiques disponibles

Ajout de la mémoire embarquée (block RAM)

Ajout de multiplieurs (hard)

Ajout de microprocesseur (hard)

« Power PC » pour série Virtex, « Dual-core ARM Cortex »

pour les plus récents (série 7)

Ajout des CAN et CNA


Microprocesseur embarqué

Deux types de microprocesseur

Hard, le µP est gravé dans le FPGA

Soft, le µP n’est qu’un programme VHDL

Pour les FPGA de Xilinx, MicroBlaze est un µp 32 bits soft

Pour les FPGA de Xilinx, PowerPC est un µp 32 bits hard

Il y a aussi un petit µp 8 bits open source (PicoBlaze) que nous

allons utiliser dans ce cours


Comment utiliser PicoBlaze ?

1. Apprendre son architecture

2. Apprendre son jeu d’instructions

3. L’instancier dans un programme VHDL

4. Lui connecter une mémoire contenant les codes opératoires

5. Ajouter en VHDL toute la logique autour

6. Synthèse, placement et routage de l’ensemble,


Architecture de PicoBlaze

sortie

Interface avec

la mémoire

externe

sortie Entrée

Entrée


Instanciation

Deux components dans le

programme principal.


Déclaration de PicoBlaze dans le

programme principal


Instanciation

Max 105 MHz

pour spartan 6 Les ports du

PicoBlaze Les signaux à

déclarer dans

le P.P.

Des paramètres

de configuration


Déclaration et instanciation de la

mémoire

Les signaux à

déclarer dans

le P.P.

Les ports de

la mémoire

Des paramètres de

configuration


Création de la mémoire de programme

Comment peut-on remplir la mémoire avec les codes opératoires en

même temps que l’on crée tout le circuit ?

Ecrire le programme en langage assembleur dans un fichier

texte

Compiler pour générer les codes opératoires

Ecrire un programme VHDL pour créer une mémoire ROM

contenant les codes opératoires

Instancier la mémoire en même temps que le reste du circuit


Démonstration

Créer une application simple, un chenillard.

Le circuit est le suivant


Entité

entity test_pico6 is

Port ( CLK : in STD_LOGIC;

LED : out STD_LOGIC_VECTOR(7 downto 0));

end test_pico6;

CLK LED 8


Déclaration Component PicoBlaze component kcpsm6

generic( hwbuild : std_logic_vector(7 downto 0) := X"00";

interrupt_vector : std_logic_vector(11 downto 0) := X"3FF";

scratch_pad_memory_size : integer := 64);

port ( address : out std_logic_vector(11 downto 0);

instruction : in std_logic_vector(17 downto 0);

bram_enable : out std_logic;

in_port : in std_logic_vector(7 downto 0);

out_port : out std_logic_vector(7 downto 0);

port_id : out std_logic_vector(7 downto 0);

write_strobe : out std_logic;

k_write_strobe : out std_logic;

read_strobe : out std_logic;

interrupt : in std_logic;

interrupt_ack : out std_logic;

sleep : in std_logic;

reset : in std_logic;

clk : in std_logic);

end component;


Déclaration Component Mémoire

component prog_memo

generic ( C_FAMILY : string := "S6";

C_RAM_SIZE_KWORDS : integer := 1;

C_JTAG_LOADER_ENABLE : integer := 0);

Port ( address : in std_logic_vector(11 downto 0);

instruction : out std_logic_vector(17 downto 0);

enable : in std_logic;

rdl : out std_logic;

clk : in std_logic);

end component;


Architecture (µp) Architecture ...

...

Begin

processor: kcpsm6

generic map ( hwbuild => X"00",

interrupt_vector => X"3FF",

scratch_pad_memory_size => 64)

port map( address => adr,

instruction => instr,

bram_enable => bram_enable,

port_id => open,

write_strobe => we,

k_write_strobe => open,

out_port => data,

read_strobe => open,

in_port => "00000000",

interrupt => '0',

interrupt_ack => open,

sleep => '0',

reset => kcpsm6_reset,

clk => clk);


Architecture (mémoire)

program_rom: prog_memo

generic map( C_FAMILY => "S6",

C_RAM_SIZE_KWORDS => 1,

C_JTAG_LOADER_ENABLE => 1)

port map( address => adr,

instruction => instr,

enable => bram_enable,

rdl => kcpsm6_reset,

clk => clk);

process(clk)

begin

if clk'event and clk = '1' then

if we= '1' then

LED <= data;

end if;

end if;

end process;


Environnement ISE


Elaborer la partie logicielle

Etudier l’architecture (les registres, les connexions, les drapeaux, les opération, les ports d’entrée/sorties, les interruptions, etc)

Ecrire le programme utilisant le jeu d’instructions de PicoBlaze

Assembler pour générer les codes opératoires

Un programme (kcpsm6.exe) est fourni par Xilinx

Créer une mémoire ROM contenant ces codes

Un utilitaire est fourni par Xilinx


Registres internes

Deux banques de registre A et B dans chacun 16 registres sur

8 bits : S0, S1, …, SF.

REGBANK A

REGBANK B

STAR Sx,Sy


ALU et drapeaux

Deux drapeaux liés à l’ALU : carry et zero


Syntaxe d’instruction

optionnel

Chargement (load)

Logique (and, or, etc)

Arithmétique (+, -)

Décalage/rotation

etc

Toutes instructions sauf

« return » possède au

moins un opérande.

C’est aussi la

destination.

Si dans

l’instruction il y a

aussi un deuxième

opérande

Commentaire

optionnel

Remarque: toutes les instructions

sont exécutées exactement en 2

cycles d’horloge.


Jeu d’instructions


Programme chenillard LOAD S4,01

debut: LOAD S2,00

loop3: LOAD S1,00

loop2: LOAD S0,00

loop1: SUB S0,01

JUMP NZ,loop1

SUB S1,01

JUMP NZ,loop2

SUB S2,01

JUMP NZ,loop3

OUTPUT S4,00

RL S4

JUMP debut

rslt=0

?

Decrmt cmp

Init cmp

non

oui

Réalisation d’un délai

Loop3 tourne 256 fois, loop2 tourne 256², et loop1 tourne 2563=16 777 216 fois

On peut aussi écrire un sous programme pour obtenir le retard nécessaire.


Exercice: sous programme délai Créer un sous programme « delai » qui génère un délai de 1 msec sachant que

l’horloge de PicoBlaze est de 100 MHz.

Sachant que chaque instruction dure deux cycles d ’horloge, il faut exécuter

50.000 instructions pour arriver à un délai de 1 msec.

DELAI: REGBANK B (1)

LOAD s0,n1 (1)

LOOP1: LOAD s1,n2 (n1)

LOOP2: SUB s1,01 (n1.n2)

JUMP NZ,LOOP2 (n1.n2)

SUB s0,01 (n1)

JUMP NZ,LOOP1 (n1)

REGBANK A (1)

RETURN (1)

Temps d’exécution:

1+1+n1.(1+2.n2+2)+1+1=50000

n1(3+2.n2)=49996

Avec n1=244, n2=101

=> Nombre d’instructions: 50020

Pour obtenir approximativement 1 msec :

CALL DELAI


Assembler Enregistrer le fichier du programme avec extension psm :

nom_du_fichier.psm

Exécuter le fichier kcpsm6

Saisissez le nom du fichier à assembler


La mémoire est générée,

on n’a qu’à l’utiliser

comme un component.


implantation

Synthèse

Assignation des broches

Placement routage

téléchargement


Démonstration Circuit

LOAD S4,01 (0)

debut: LOAD S3,01 (1)

loop3: LOAD S0,01 (2)

loop2: LOAD S1,01 (3)

loop1: SUB S1,01 (4)

JUMP NZ,loop1 (5)

SUB S0,01 (6)

JUMP NZ,loop2 (7)

SUB S3,01 (8)

JUMP NZ,loop3 (9)

OUTPUT S4,00 (10)

RL S4 (11)

JUMP debut (12)


Port de sortie

L’instruction à utiliser est:

output Sx,pp

output Sx,(Sy)


Port de sortie

Décodage complet de l’adresse, possibilité d’avoir 256 ports de sortie


Décodage partiel


Implantation décodage partiel process(clk)

begin


if write_strobe = '1' then

if port_id(0) = '1' then

LED <= out_port;

end if;


UART <= out_port;

end if;


output_port_x <= out_port;

end if;


output_port_y <= out_port;

end if;

end if;

end if;

end process;


Port d’entrée

L’instruction à utiliser :

input Sx,pp

input Sx,(Sy)


Port d’entrée complet


Port d’entrée partiel

in_port

port_id

Process synchrone kcpsm6


Implantation partiel port d’entrée

process(clk)

begin


case port_id(1 downto 0) is

when "00" => in_port <= A;

when "01" => in_port <= B;

when "10" => in_port <= C;

when others => in_port <= D;

end case;

end if;

end process;

Adresse du port= B"- - - -_- - 00"=X"00"




in_port

port_id

Process synchrone kcpsm6

Lire l’état des switch et les afficher sur les LED:

input S0,00 ; ou input S0,F0; ou …

output S0,08

On a supposé que les switches sont connectés au port

00 et que les LED sont connectées au port 8.


Interruption


Routine d’interruption

Quand l’interruption arrive (un niveau 1 sur l’entrée

« interrupt »)

PicoBlaze termine l’instruction en cours, puis saute à une

adresse prédéfinie (celle que nous avions indiquée au moment

de l’instanciation du KCPSM6).

C’est à la charge de programmeur de mettre sa routine à cette

adresse.

processor: kcpsm6




port map( address => address,


Exemple d’interruption A chaque interruption, incrémenter le registre SF.

processor: kcpsm6


interrupt_vector => X"3FE",


port map( address => address,…

Instanciation

enable interrupt

...

address 3FE

ISR : add SF,01

returni enable

Option 1

enable interrupt

...

ISR : add SF,01

returni enable

address 3FE ; on ne connaît pas la

JUMP ISR ; taille de la routine,

Option 2


Mise en place du circuit

« Open loop », il est nécessaire de

faire durer la demande de

l’interruption au moins pour deux

cycles d’horloge => pas de circuit

supplémentaire.

« Closed-loop », l’interruption est maintenue à ‘1’ jusqu’à ce que le processeur la serve.

process


Exercice Créer un timer qui donne une interruption toutes les

secondes à PicoBlaze. La routine d’interruption se charge de faire clignoter les 8 LED de la carte.


Instanciation KCPSM6

processor: kcpsm6




port map( address => address,

instruction => instruction,

bram_enable => bram_enable,

port_id => open,

write_strobe => we,

k_write_strobe => open,

out_port => out_port,

read_strobe => open,

in_port => SW,

interrupt => interrupt,

interrupt_ack => int_ack,

sleep => '0',

reset => kcpsm6_reset,

clk => clk);


Instanciation Timer et outport

TIMER: process(clk) begin


cmp <= cmp + 1;

timer_trig <= '0';

if cmp = 99999999 then

cmp <= 0;

timer_trig <= '1';

end if;

end if;

end process;

output_ports: process(clk)

begin


if we = '1' then

LED <= out_port;

end if;

end if;

end process output_ports;


Interruption software

interrupt_control: process(clk)

begin

if clk'event and clk='1' then

if int_ack = '1' then

interrupt <= '0';

else

if timer_trig = '1' then

interrupt <= '1';

else

interrupt <= interrupt;

end if;

end if;

end if;

end process interrupt_control;


Software

ENABLE INTERRUPT

LOAD S1,00

LOOP: JUMP LOOP

ISR: INPUT S0,00

COMPARE S1,00

JUMP Z,INVERS

LOAD S1,00

JUMP AFFICH

INVERS:

LOAD S1,FF

XOR S0,FF

AFFICH:

OUTPUT S0,00

RETURNI ENABLE

ADDRESS 3FF

JUMP ISR


Exercice On va créer le circuit nécessaire pour simplifier l’ffichage d’une valeur

hexadécimale 4 digits sur les sept-segments de la carte Nexy3. Ainsi le

programme pour afficher la valeur « 1234 » sur les 7-segment serait :

LOAD s0,12

OUTPUT s0,01 ; l’adresse du port pour les 2 MSD

LOAD s0,34

OUTPUT s0,02 ; l’adresse du port pour les 2 LSD


Conception circuit (hardware)

Dans un premier temps l’interface 7-seg : Commande

with-select

process(CLK)

begin

if CLK’event and CLK=‘1’ then

if trig=‘1’ then segment <= segment + 1; end if;

end if;

end process;


Interface avec PicoBlaze


Ajout d’un port UART

En programmation, on vérifie si UART n’est pas "busy" on

lui envoie un octet:

; sous programme UART

UART: INPUT SF,01 ; Busy est à lire sur le port 1

AND SF,01 ; Busy est le LSB

JUMP NZ,UART ; attend tant que Busy = ‘1’

OUTPUT S0,04 ; envoyer à l’interface le carac

RETURN ; ASCII

Pour appeler:

LOAD S0,"A"

CALL UART


Ajout de l’UART

Ici, puisqu’il n’y a qu’une seule entrée sur le port « in_port »:

in_port <= "0000000" & busy;


Ajout d’un timer On va maintenant mettre en place un timer qui donne une interruption toutes

les secondes. La routine d’interruption va incrémenter un registre 16-bits puis

envoie le contenu à l’interface qui l’affiche sur les 7-segments.

Le hardware a été expliqué plus haut. Le programme sera:

ISR: ADD SA,01

ADDC SB,00

OUTPUT SA,01

OUTPUT SB,02

RETURNI ENABLE


Affichage du timer sur PC

ISR: ADD SA,01

ADDCY SB,00

OUTPUT SA,01

OUTPUT SB,02

LOAD S0,SB

CALL HEX2ASCII

LOAD S0,SE

CALL UART

LOAD S0,SF

CALL UART

LOAD S0,SA

CALL HEX2ASCII

LOAD S0,SE

CALL UART

LOAD S0,SF

CALL UART

; sous-programme qui transforme une

; donnée numérique 8 bits en deux codes

; ascii pour les deux digits

; "4F" 52 et 65

; on suppose la donnée 8 bits dans S0

; la routine retourne deux codes ascii

; dans SE et SF

HEX2ASCII:

LOAD SF,S0

LOAD SE,S0

AND SF,0F

ADD SF,30

COMPARE SF,3A

JUMP C,DONE1

ADD SF,07

DONE1: SR0 SE

SR0 SE

SR0 SE

SR0 SE

ADD SE,30

COMPARE SE,3A

JUMP C,DONE2

ADD SE,07

DONE2: RETURN


Travaux Pratiques

La mise en place de l’architecture abordée en cours

Transporter la partie logicielle HEX2ASCII en hardware

system on chip (soc)...créer un sous programme « delai » qui génère un délai de 1 msec sachant...

Documents