introCOA6-Intro_VHDL_AMS.ppt

29/11/2022 15:14 Yannick Herve, Wilfried Uhring 1
Outils de CAO
Chapitre 4
Introduction au VHDL AMS
Définitions, besoins , Structure, Objets, sémantique de connexion,
instructions concurrentes, instructions simultanées, exemples
Cours d’électronique numérique dispensé à l’ENSPS.
Auteurs :
Yannick Hervé - MCF HDR Université Louis Pasteur
Wilfried Uhring - MCF Université Louis Pasteur
SIMPLIFIER ENCORE

Définitions
•VHDL est l’abréviation de VHSIC (Very High Speed
Integrated Circuit) HDL
•Un HDL est un langage de description
matériel (Hardware Description Language)
•C’est un standard (concurrents Verilog, System C, …)
•On distingue :
–une partie numérique pure (VHDL’93)
–Une extension analogique (VHDL-AMS : IEEE
1076.1-1999) (compatible VHDL’93)

Besoins et buts
•Description en générale (dialogue entre fournisseur,
outils, …)
•Spécifications, CdC, pré-étude (modèles simulables)
•Documentation
•Extraction LVS
•Plusieurs niveau d’abstraction (fonctionnel, structurel)
•Bibliothèques de modèles de composants
•Synthèse logique (uniquement numérique)
•Intellectual Property

Besoins et buts
•Modélisation environnementale
–Tenir compte du « monde » autour du système
•Plusieurs disciplines (thermique, électrique, logique, …)
•Conception mixte (analogique, numérique)
•Co-Design (Matériel/Logociel)
•Représentation hiérarchique
•Preuve formelle
•Approche TOP – DOWN
•Concurrent ingineering (travail grande équipe,
optimisation Time-to-Market)

Exemples d’applications
•Intervient dans la conception de
•Avion, voiture
•ABS, airbag, climatisation
•Microprocesseur, microcontrôleur, DSP,
•Systèmes numériques, montre, radio réveil, autoradio
•Chipset, ordinateur
•Asservissement, servomoteur
•Imprimante, MOEMS (voir plus loin)
•Prototypage virtuel (application sur des SLM au labo)

Image LEPSI
EXEMPLE :
mise en situation du CI
Exemples d’applications

Application MOEMS
(micro-opto-electronical-mechanical systems)
•Mécanique, Optique, Electronique dans le silicium
(compatible process Si)
•Nouvelles techniques de conception et modélisation
•Collaboration techniques
de simulation

Application MOEMS
(micro-opto-electronical-mechanical systems)

Différences Langage / HDL
Langage HDL
Sous-programme (dyn) Composant (stat)
appel, calcul, oubli existe en soi
Variables (dynamique) Signaux(statiques+historique (future)
a := b a <= b
a := c (b oublié) a <= c (équipotentielle.)
Simulation du temps Gestion du temps
VHDL : composants et sous-programmes
signaux et variables
COMPLET / POLYVALENT
(inévitable / incontournable)

Besoin d ’un standard :
Ce que peut faire VHDL-AMS
•Modèles multi-disciplines hiérarchiques continus et à
événements discrets en bibliothèques « UTILISATEUR »
•Abstraction comportementale, structurelle, signal-flow
•Equations différentielles ordinaires (par rapport au temps)
Modélisation en Laplace, en Z, spectrale, bruit
Sémantique de connexion : Kirchoff généralisé
Egalité des efforts / Somme des flux = 0
v-i, °C-W, m-N, rad/s-1-N.m, n.A-Wb, Pa-l/s ...
Facilités d ’analyse de type SPICE (dépend de l ’outil)
(DC, transient, AC, noise, Monte-Carlo,…)

Ce qu’il ne peut pas faire
•Equations différentielles d./dx avec x différent de t
Modèles « géométriques » et mailleur associé.
Définition de sémantique de connexion
Ces limitations font l’objet de travaux au sein des
groupes de normalisation et seront examinés à la
prochaine re-normalisation en 2004.

Inconvénients
Inconvénients :
Puissant, général = complexe
(mais pas compliqué)
Limitations intrinsèques
(un peu bâclé sur certains points)
Simulation pas efficace en temps pour l’instant
Pas de simulateur natif (et outils existants coûteux)

Structure d’un simulateur
numérique
Basé sur l’exécution conditionnelle et itérative d ’équations
logiques dépendantes dans un temps discrétisé
Modèle : Equations de composants logiques
Netlist
Procédure : (emploi d’une liste d ’événement (EL) et de signaux datés)
Mise à jour de l ’EL classée par date
Extraction des signaux avec t mini
Avancée de l’horloge de simulation
Réveil et simulation des process dépendants
Production de nouveaux événements
Production d ’un LSP

Structure d’un simulateur
analogique
Basé sur la résolution des équations de kirchoff à chaque t
Modèle : Equations de branches (loi des composants)
(éventuellement non-linéaires, non stationnaires, …)
Equations de structure (loi de Kirchoff)
Procédure : (calcul matriciel d ’ordre élevé !!)
Mise en équation (jeu d’équations Diff NL)
Discrétisation (jeu d’équations aux différences NL)
x(t+d) = fNL(x(t),x ’(t),p(t)) [méth. d ’intégration]
Linéarisation (jeu d’équations aux différences L)
Résolution [gauss seidel]
Vérification de la convergence
Convergence : Production d ’un ASP
À chaque t

•Structure générale d'un modèle
•Structuration en bibliothèques
•Identificateurs, Objets et typage. Opérateurs
•Instructions séquentielles, concurrentes
•Notion d ’attributs
•Exemples
Introduction à VHDL AMS

Structure générale d ’un modèle
Entity
Déf. connexions
Architecture
Déclaration
Body
Inst.concurrentes
Inst.simultanées
Instanciations
Vue interne du modèle
discret-event
continuous time
structurel/hiérarchie
Entity
Architecture
Vue extérieure
Interfaçage/netlist (port)
signal : numérique
terminal : analogique, kirchoff
quantity : analogique, signal flow

ENTITY exemple IS
port (signal sig_ext:in real; terminal vp,vm : electrical);
END exemple;
LIBRARY ressource_lib;
USE ressources_lib.ressources_package.ALL;
ARCHITECTURE archi1 OF exemple IS
TYPE list_ex IS (el1,el2,el2);
CONSTANT cst1 : list_ex, k:REAL;
SIGNAL sig1 : BIT, sig2 :INTEGER, sig3 : REAL;
QUANTITY vbias ACROSS ibias THROUGH vp TO vm;
QUANTITY free_quant : REAL;
BEGIN
u1:ENTITY model_externe(archi_du_modele)
GENERIC MAP(100.0e3,5.0) PORT MAP(vp,vm,sig1);
free_quant == 3.0*sinus( k * now );
ibias == free_quant’dot;
p1:PROCESS
variable x : real := 5.5;
BEGIN
wait on sig3 until sig2 > 3 for 25 ms;
x := 2*x ;
sig_ext <= sig3 after 1 ms;
END PROCESS;
END archi1;
Exemple
illustratif
non
compilable
Structure générale d ’un modèle : Exemple

Structure générale d ’un modèle :
Prise en charge par le simulateur
Entity
Architecture
E+A E+A
E+A E+A
CS1
CS2
CS3
...
CS1
CS2
SS1
SS2
SS3
...
SS1
SS2
SS3
...
CS1
CS2
SS1
Sim anal. Sim num.
{}Equa.Diff
NL (SS)
{}Equa.Log
(CS)
Tsim
Produit des ASP
{valeurs i(t),v(t)}
Produit des
événements
CS : concurrent statement
SS : simultaneous statement
E+A : Entity + Architecture
2 simulateurs cohabitent, un simulateur analogique, un numérique
ASP: Analogique Signal Point

Structuration en bibliothèques
• Pas de longue description
• Unités petites et hiérarchisées
• Partie compilable = Unité de conception (UC)
• Système complexe = développé par une équipe
Besoin de méthodologie rigoureuse
• Une compilation qui aboutit
Mise à jour d ’une bibliothèque de travail (WORK)
• Bibliothèque de ressources (de projet, d ’un
fournisseur, de test, …)
LIBRARY ressource_lib;
USE ressource_lib.pack_lib.ALL;

Structuration en bibliothèque :
Les unités de conception
• Modèle : ENTITY (UC) + ARCHITECTURE (UC)
plusieurs ARCHITECTURE possibles par ENTITY
• Code souvent utilisé et partagé : paquetage
PACKAGE (UC) + PACKAGE BODY (UC)
vue ext. : exportation vue interne : privé
• Association effective d ’une instance et un modèle
compilé : CONFIGURATION (UC)
• Les bibliothèques contiennent des UC
• Méthode : Un fichier = Une Unité de Conception

Identificateurs
• Noms des objets : identificateurs
• Suite de lettres et de chiffres
• Commence par une lettre, no case sensitive
• Possible de poser des traits bas : Rdf_232
• Traits bas doubles, au début, à la fin : interdit
• Commentaire : -- (jusqu’à la fin de la ligne)

Littéraux (1)
(Valeurs « dures » du langage)
• Caractères : 95 des 128 ASCII (imprimables)
‘ a ’, ‘ b ’, ’Q ’, …
• Chaînes de caractères
«C ’est »& --(« » = guillemets)
«possible sur deux lignes»
• Notations décimales
1345, 1_345, 1e6, 1E6
1345.3, 1_345.1, 1.0e2 (attention x.0)

Littéraux (2)
• Notations basées (entiers et réels exprimables)
2#01101# est un entier qui vaut 13
7#03630#, 16#FF3A#
2#01101.0# est un réel qui vaut 13.0
16#FF.4A#e12
• Notation par chaînes
B«000110» = (‘0’, ‘0’, ‘0’, ‘1’, ‘1’, ‘0’)
0«06» = (‘0’, ‘0’, ‘0’, ‘1’, ‘1’, ‘0’)
X«255» = (‘1’, ‘1’, ‘1’, ‘1’, ‘1’, ‘1’, ‘1’, ‘1’)

• Tous les objets sont typés (strong typing)
• Permet l’initialisation fiable et augmente le pouvoir de
vérification du compilateur
• Familles (définit les valeurs et opérations possibles):
– scalaires (un seul élément porté à la fois, ordonnés)
• integer, real, physical
• énumérés
– composites (plusieurs éléments portés à la fois)
• array, record
– access
– fichiers
• Types et sous-types utilisateurs possibles
Typage

type_declaration ::= TYPE type_name IS type_definition;
Enuméré : TYPE enum_type IS (bleu, blanc, rouge) ; -- relation d ’ordre
Entiers : TYPE index IS RANGE -3 TO 27 ;
TYPE rev_index IS RANGE 27 DOWNTO -3 ;
Flottants : TYPE ex_real IS RANGE -3.0 TO 27.0 ;
Physique : TYPE distance IS RANGE 0 TO 1e16 ;
UNITS A ;
nm = 10 A ; -- espace obligatoire
mil = 254_000 A ;
inch = 1_000 mil ;
ft = 12 inch ;
yd = 3 ft ,
cm = 10e7 nm ;
END UNITS ; -- facteurs conversion = integer !!!
35 yd + 547 cm + 17 inch calculée en Angströms
(35 yd + 547 cm)/mil sera calculé en mils.
(103 nm) / nm est un entier
A * nm transforme un entier en nm
Typage :
Déclaration scalaires

Vecteur : rassembler plusieurs valeurs de même type
index entier ou énuméré, ne peut contenir des fichiers
TYPE int_vec IS ARRAY(3 to 45) of integer ; Tableau d’entier contraint
TYPE real_vec IS ARRAY(natural range <>) of real ; Tableau non contraint
TYPE enum_vec IS ARRAY(enum_type) of integer ;
si A est de type enum_vec on a A(bleu),A(blanc) et A(rouge)
Record : rassembler plusieurs valeurs de type différent (champs)
accès par notation pointée, ne peut contenir des fichiers
TYPE record_ex IS RECORD -- Record d’array ou de record possible
champ_1 : bit ;
champ_2 : real ;
autre_champ : enum_type ;
END RECORD;
Si A est de type record_ex : A.champ_1,A.champ_2 et A.autre_champ existent
Typage :
Déclaration composites

• Types prédéfinis
– integer TYPE integer IS RANGE integer’low to integer’high;
– real TYPE real IS RANGE real’low to real’high ;
– bit TYPE bit IS (‘0’, ’1’) ;
– std_logic TYPE std_logic IS (‘U’,’0 ’,’1’,’Z’,’X’,’H’,’L’,’W’,’-’) ; (IEEE 1164)
– bit_vector TYPE bit_vector IS ARRAY (natural RANGE<>) of bit ;
– boolean TYPE boolean IS (false, true)
– severity_level TYPE severity_level IS (NOTE,WARNING,ERROR,FAILURE) ;
– character TYPE character IS (NUL, SOH,…, ’a’, ’b’, …, ‘~’,DEL) ;
– string TYPE string IS ARRAY (positive range <>) of character ;
– time TYPE time IS RANGE integer’low TO integer’high UNITS fs;
ps = 1000 fs ; ns = 1000 ps ; us = 1000 ns ;
ms = 1000 us ; sec = 1000 ms ; mn = 60 sec ; hr = 60 mn;
END UNITS ;
Typage :
Types prédéfinis (notes)

• En VHDL-AMS tous les objets sont initialisés
implicitement ou explicitement
• Un objet prend la valeur la plus à gauche de son type
signal A : bit ; -- A vaut ‘0’
signal A : bit := ‘1’; -- A vaut ‘1’
variable B : boolean ; -- B vaut false
quantity Q : real ; -- Q vaut0.0
Typage :
Initialisation des objets

• Les classes d ’objets (transport de l ’information)
CONSTANT (valeur fixe connue à l ’élaboration)
VARIABLE (séquentiel / dynamique)
modifiée par affectation ( := )
SIGNAL (concurrent / statique)
modifié par affectation ( <= )
TERMINAL
permet les connexions analogiques
branch/free QUANTITY
participe aux simult.stat. ( == )
est toujours d ’un type issu des real
FILE
Les 6 classes d’objets

Classes d ’objets :
Constantes
Permet de stocker des valeurs constantes
CONSTANT pi : real := 3.141592 ;
CONSTANT clock_period : time := 20 ns ;
CONSTANT BV0 : bit_vector(15 DOWNTO 0) := (‘1’, ’0 ’,others=> ’0 ’) ;
CONSTANT tt : truth_table := (others => (others => ‘ 0 ’)) ;
CONSTANT mem_bus : memory_bus := (adrr =>X «00AA»,data=>X«FF»,
read => ‘0’, write => ’1 ’, enable => ’1 ’ ) ;
Peut être initialisée au moment de l ’utilisation
CONSTANT cst_val : integer := 40 * N ;
N ne peut être connu qu ’à l ’élaboration (paramètre générique)
Si la déclaration de constante est dans une fonction N peut être un paramètre de celle-ci

Variables
• Stockage et manipulation de valeurs
VARIABLE phase : real := 124.0 ;
VARIABLE clock_period : time := 20 ns ;
VARIABLE var1: integer := function_d_init(…) ;
Affectation et modification : A := B *C + 3.0;
N ’est utilisable que dans un contexte séquentiel
PROCESS uniquement
• Il existe des variables partagées (shared)
!!! Programmes non déterministes !!!
A manipuler avec circonspection

Signal
• Transporte les valeurs du simulateur event-driven
S <= 3 after 15 ns;
• Modélise les fils entre les portes (symbolique)
Inport <= Outport ;
• Nom de fonction dans la déclaration: signal résolu
plusieurs sources possible / résolution du conflit (voir cours suivant)
• REGISTER ou BUS : signal gardé (guarded)
ne pourra être affecté que si le signal GUARD est TRUE (vu plus loin)
• Possède un passé, une valeur, un futur proposé
le driver du signal
signal_declaration ::=
SIGNAL signal_name : [fonc_resolution] type [contraintes]
[REGISTER|BUS] [:= init_value];

Terminal
Permet de nommer des nœuds (ne porte pas de valeur !!!)
Une nature est définie par deux types réels
NATURE name IS acr ACROSS thr THROUGH ref REFERENCE ;
Across = effort / through = flux
v-i, °C-W, m-N, rad.s-1-N.m, n.A-Wb, Pa-l/s, ...
SUBTYPE v IS real ; SUBTYPE i IS real ;
NATURE electrical IS v ACROSS i THROUGH gnd REFERENCE ;
TERMINAL vp,vm : electrical ;
Vecteur de nature
NATURE elec_vec IS ARRAY(natural RANGE <>) of electrical ;
Record de nature
terminal_declaration ::= terminal identifier_list :
subnature_indication ;

Quantity
« Signaux continus » du simulateur analogique
Free Quantity (n ’est pas attachée à un TERMINAL)
QUANTITY Q : real := expression;
Valeur initiale implicite 0.0 (dépend de l’outil)
Branch Quantity
QUANTITY [across_aspect] [through_aspect] terminal_aspect ;
QUANTITY V12 across I1 through t1 to t2 ;
QUANTITY V1,V2 across t1; -- alias
QUANTITY I1,I2 through t1; -- branches parallèles
Implicit Quantity
QUANTITY Q : real := expression;
Q’dot, Q’integ existent toujours et sont créées si besoin
QUANTITY QV : real_vector (3 downto 0) ;
QV’dot, QV’integ sont valides

Terminal/Quantity : exemples
terminal t1,t2 : electrical ;
terminal t3, t4 : electrical_vector (1 to 5);
quantity v12 across i1, i2 through t1 to t2 ;
définit une tension et deux courants
quantity v31 across i3 through t3 to t2 ;
Définir un système étoile,un système triangle
(terminaux scalaires)
Définir un système N-phases étoile, N-triangle
(N inconnu)

Sémantique de connexion
ENTITY exemple IS
port (signal sig :{in|out|inout|linkage|buffer} real);
END exemple;
• Un port de classe signal ne peut être branché que sur un signal
ou sur un port de même type, les modes doivent être
compatibles
• Un port de mode OUT n ’est pas lisible dans l ’architecture
• LINKAGE, BUFFER : modes inutilisés en pratique
• Un port de mode INOUT est forcément résolu
• Le mot clef OPEN permet de laisser ouvert

Sémantique de connexion :
Event driven : formal/actual port
Avec :
ENTITY source IS
PORT (SIGNAL a : in real; b : out real);
END; -- a et b sont les ports formels
On a:
ENTITY testdetector IS
PORT (SIGNAL extin : IN real; extout : OUT real);
END;
LIBRARY disciplines;
USE disciplines.Electromagnetic_system.ALL;
ARCHITECTURE test OF testdetector IS
SIGNAL pin,pout:real;
BEGIN
u1:ENTITY source(pulse_proba) PORT MAP (extin,extout);
u2:ENTITY source(pulse_proba) PORT MAP (pin,pout);
END; -- extin,extout,pin,pout sont des ports réels (actual)

Signal Flow
ENTITY exemple IS
port (QUANTITY Q1 : in real,
Q2 : out real);
END exemple;
• Support de l ’interconnexion à temps continu
• Permet de modéliser sous forme de schéma-blocs
Une entrée n ’influence pas une sortie
(impédance d ’entrée infinie, impédance de sortie nulle)
• Les quantités connectées doivent être de même type
• Les ports de classe Quantity connectés doivent être
compatibles
Pas encore supporté par les outils

Signal Flow : exemple
Avec :
ENTITY block1 IS
PORT (QUANTITY a : in real; b : out real);
END;
On a:
ENTITY black_boxes IS
PORT (QUANTITY extin : IN real;QUANTITY extout : OUT real);
END;
LIBRARY disciplines;
USE disciplines.Electromagnetic_system.ALL;
ARCHITECTURE test OF black_boxes IS
QUANTITY ploc:real; -- Free Quantity
BEGIN
u1:ENTITY block1(beh) PORT MAP (extin,ploc);
u2:ENTITY block1(beh) PORT MAP (ploc,extout);
END;

Conservatif : Kirchoff généralisé
ENTITY exemple IS
port (TERMINAL T1,T2 : electrical); --PAS DE MODE/VALEUR
END exemple;
Interconnexions à temps continu conservatif
Permet de tenir compte influences Entrées/Sorties
TERMINAL connectés doivent être de même nature
KIRCHOFF LAW : Si T1 est branché sur T2 et si les aspects
ACROSS et THROUGH sont définis alors
ACROSS( T1 ) = ACROSS( T2 )
et THROUGH( T1 ) + THROUGH( T2 ) = 0
Quelle que soit la nature : multi-discipline

Conservatif : Netlist analogique
ENTITY R IS
port (TERMINAL T1,T2 : electrical);
END R;
ENTITY C IS
END C;
ENTITY RC IS
END RC;
ARCHITECTURE ONE OF RC IS
TERMINAL LocalT:electrical
BEGIN
R:ENTITY R(beh) PORT MAP (T1 => T1,T2 => LocalT);
C:ENTITY C(beh) PORT MAP (T1 => LocalT,T2 => T2);
END ;
Association par nommage : Formal => Actual

Opérateurs
• 6 classes d ’opérateurs et niveaux de priorité
(l ’évaluation d ’une expression commence par la priorité la plus haute)
– logic : and, or, nand, nor, xor, xnor, sll, sla, sra, srl, rol, ror
(s ’appliquent à boolean et bit, surcharge sur IEEE_1164-MVL9)
– relationnels : =, /=, <, <=, >, >=
(s ’appliquent à tout sauf fichiers, résultat de type BOOLEAN)
– addition : +, -, & (& : concaténation sur type STRING)
– signe : +, -
– multiplication : *, /, mod, rem
– divers :: **, abs, not
Opérateurs surchargeables, pas de changement de
priorités
Priority

Instructions du langage
(les plus importantes)
• Une architecture contient
simultaneous statements (doivent être évalués à chaque ASP)
f == g / procedural / if use / case use / null
concurrent statements (évalués si besoin à chaque LSP)
process / affectation de signal
instanciation
affectations, break, assertion
• Un process contient
séquential statements (évalués en séquence dans le process)
affectation signal, affectation variable
wait
if, case, loop ...

Instructions séquentielles, concurrentes, simultanées :
Instructions séquentielles
• Permet de fabriquer des PROCESS
– (instruction concurrente utilisateur)
Flow control : test et boucles
Gestion du temps : Wait
Affectation variables
Affectation signal et mécanismes temporels associés
Auto test : Assert / report

• Affectation variables
V := f (V|S|Q) (la valeur de l ’objet)
tab1 := tab2; tableaux tab(3 to 5) := (1,2,4);
• Affectation signal : proposition de transaction
[label :] target <= [transport | [reject time ] inertial]
waveform ; avec target ::= name | aggregate
et waveform ::= wf_element {,wf_element} | unaffected
lab1: S <= ’0’; -- affectation à délai delta
S <= ’0’ after 3 ns; -- inertial par défaut
lab:(S1,S2)<= (’0’,’1’) after 3 ns, (’1’, ’0’) after 10 ns;
S1 <= inertial s2 after 4 ns; -- anti-physique
S1 <= reject 10 ns inertial S2 after 4 ns; -- mieux
• Transport : pas d’inertie, le signal est propagé quelque soit la durée des signaux
affectant
affectations (1)

affectations (2)
• Notion de forme d ’onde (waveform)
s <= a after ta, b after tb, …, x after tx ;
la liste (ta, tb, tc, …, tx) doit être ordonnée
• Mécanisme temporel : transport, inertiel, réjection
• Sources possibles : constantes, variables, signaux, quantités
S <= objet
• Notion de transaction et d’événement
si S vaut x et y /= x : S <= y after 3 ns; événement
S <= x after 3 ns; transaction sans event
• Notion de pilote (driver)
S <= x after 5 ns; ne modifie pas la valeur de S
S sera éventuellement modifiée quand l ’horloge avancera à to+ 5 ns
• Notion de source unique
Un signal ne peut être affecté que par une seule source
(sauf résolution : voir cours suivant)

WAIT
• Instruction la plus importante de la partie numérique
wait [on signal_list] [until bool_cond] [for time] ;
Pour au plus time
si un événement survient sur un signal de la liste signal_list
la condition booléenne bool_cond est évaluée :
si elle est fausse on se remet en attente
si elle est vraie on passe à la ligne suivante.
Tous les PROCESS sont sur un WAIT : blocage
On recherche le prochain event dans la liste d ’événement
On avance l ’horloge de simulation, nouveau LSP
Formes simplifiées : wait; wait on a; wait on a,b;
wait for 10 ns; -- time out
wait until a=‘1’; -- front;

flow control - test / sélection
• Test
[label:]if cond_bool then
{séquence instructions séquentielles}
elsif cond2 then
else
end if ;
• Sélection
[label:]case expression is
when value_1 => {séq. Inst. Séqu. 1}
when value_2 => {séq. Inst. Séqu. 2}
when others => {séq. Inst. Séqu.}
end case ;

flow control - boucles
[label:][schéma d ’itération] loop
end loop [label] ;
Infinie : loop
N :=N+1;
end loop;
Conditionnelle : Itérative :
while conditions loop for i in 1 to 100 loop
{séqu. Instr. Séqu.} {séqu. Instr. Séqu.}
[exit;] [exit;][next[label]]
end loop ; end loop ;
Boucle : i déclaré de facto / «i in A’range» possible
next [label] when cond_bool / exit [label] when cond_bool

auto-test
• Envoi d ’un message à la console
[lab:]report expr [severity note|warning|error|failure] ;
• Surveillance d ’une condition
[lab:] assert cond_bool
[report expression]
[severity note|warning|error|failure] ;
Si cond_bool est fausse alors expression est envoyée à la
console associé à un niveau d ’erreur.
assert teff<tsetup report «Set up violé» severity error ;

Instructions concurrentes
• Support de la modélisation/simulation à temps discret
Ces instructions sont évaluées, si besoin, à chaque LSP
Process
Affectation concurrente de signal
Instanciation de composant
Assertion concurrente
Break (voir synchronisation des noyaux)

Process
• Instruction concurrente « Utilisateur »
[label :][postponed]process -- postponed: vu plus tard
{zone de déclaration / pas de signaux}
begin
{sequ. Instr. Sequ.}
end[postponed]process [label] ;
• Un PROCESS vit toujours (il est global)
éventuellement suspendu sur un wait
• Un PROCESS est itératif (boucle sans arrêt)
sauf si wait
• Variante : méthode synthétisable (issue de VHDL 7.2)
[label :] Process(signal_liste) -- liste de sensisbilité
{zone de déclaration}
begin
{sequ. Instr. Sequ. sans wait}
end process [label] ;

Process (exemple)
process
variable sp_res : integer_vector(0 to c_nb-1) := (others=>0);
variable index_tab : integer;
begin
wait on vtest,watchdog;
if watchdog'event then
for i in sp_res’range loop
spectre <= real(sp_res(i));
wait for 1 us;
end loop;
spectre <= 0.0;
end if;
end process;
process
begin
wait for analysis_time;
watchdog <= not watchdog;
end process;

Affectation
• Raccourci d’ écriture
toujours remplaçable par : process + affectation séquentielle + tests
• Forme simple :
[label:]nom_ou_aggregat <= [options] waveform ;
options ::= [guarded] [transport | [reject time ] inertial]
• Forme conditionnelle :
[label:]nom_ou_aggregat<=[options]waveform1 when cond1 else
waveform2 when cond2 else
. . .
waveformN when condN ;
• Forme sélective :
[label:] With expression select
nom_ou_aggregat <= [options] waveform1 when list1,
. . .
waveformN when listN ;

Instanciation
Prendre une copie (une instance) d ’un modèle
la personnaliser, la configurer, la brancher
label : entity nom_du_compo(archi_compo)
[generic map (formal => actual)]
[port map(formal => actual)];
Recherche de l ’entité dans les « library » référencées
si archi_compo n ’apparaît pas : la dernière analysée
(!!??outil)
Attention : label obligatoire (plusieurs instances d’un modèle)
Configuration : association composant / modèle de la base
vue au cours suivant

Instanciation (exemple)
entity RS is
port (S,R : bit ; Q,Qb : out bit);
end entity;
architecture structural of RS is
signal n1_out, n2_out : bit ;
begin
nand1: entity nandg port map(in1=>S,
in2=>n2_out,
outp=>n1_out);
nand2: entity nandg generic map (5 ns)
port map(R,n1_out, n2_out);
Q <= n1_out;
Qb <= n2_out;
end structural;

Assertion
• Permet de surveiller en permanence une condition
[lab:] [postponed]assert cond_bool
[report expression]
• Process équivalent :
[lab:] [postponed] Process (signaux_de la conditions)
begin
assert cond_bool
[report expression]
end process [lab] ;

Instructions simultanées :
Instructions simultanées
Support de la modélisation/simulation à temps continu
Ces instructions sont évaluées à chaque ASP
Simple simultaneous statement : ==
Forme conditionnelle : if cond use
Forme sélective : case cond when
Forme procédurale : Procedural

Forme simple
Simple simultaneous statements (doivent être évalués à chaque ASP)
f == g f et g deux fonctions NL contenant des quantités
le simulateur s ’assure qu ’à chaque ASP f-g=0.0
aux tolérances prêt (équation caractéristique)
Ces équations sont explicites ou implicites
Exemple : Q**2 + Y ’dot == sqr(Y) - Q ’integ ;
C*U == Q ;
Q == I’integ;
ENTITY R IS
generic (R_value : real := 1_000.0)
port (TERMINAL vp,vm:electrical);
END;
ARCHITECTURE equ OF R IS
QUANTITY V ACROSS I THROUGH vp TO vm;
BEGIN
V == R_value * I;
END;

Instruction, simultanées
Choix
Choix du jeu d ’équations en fonction de conditions
La forme conditionelle :
label :IF cond_1 USE -- ASP = evaluation condx
{equations analogiques} -- !! BREAK
ELSIF cond_2 USE
{equations analogiques}
…
ELSE
{equations analogiques}
END USE label;
La forme sélective :
label : CASE expr USE
WHEN value1 => {equations analogiques}
WHEN value2 => {equations analogiques}
END CASE label

Procedural
Fabriquer un « Simultaneous Statement » à partir de séquentiel
[label :] PROCEDURAL [IS]
{declaration_part} -- NORME : réévalués /exécution
BEGIN -- (pas de mémoire ?)
{sequential_statement} -- sauf wait, break, and <=
END PROCEDURAL [label]
Sommateur analogique pondéré
Avec beta:real_vector et vp(i) ACROSS T(i) to GND (taille identique inconnue)
ARCHITECTURE
…
BEGIN
PROCEDURAL IS
variable bvs : real := 0.0;
BEGIN
bvs := 0.0; -- si memorisation
FOR i IN beta’range loop -- Quantités externes
bvs := bvs + beta(i) * vp(i); -- sont vues comme des
END LOOP; -- variables
Qout := bvs;
END PROCEDURAL;
END;

Notion d’attribut
Fonctions à syntaxe spécifique
(AB : attribut appliqué à A rend un objet B)
Array  range : A’range
Array  value : A’length
Signal  signal : S’delayed(T), S’stable, S’quiet
Signal  fonction : S’event, S’last_event, S’last_value
Quantité  quantité : Q’dot, Q’integ,
Quantité  signal : Q’above(E)
Nature  terminal : N’reference
Nature  type : N’across, N’through
Terminal  quantité : T’contribution, T’reference

Exemples simples
• Exemple purement numériques
– Porte NAND
– Bascule D
• Exemple VHDL ’AMS
– Résistance, Condensateur, Inductance
– RLC parallèle, RLC série
– Source sinus parfaite
– Diode avec comportement thermique

64
ENTITY nandg IS
GENERIC (tplh,tphl : time := 10 ns);
PORT (SIGNAL inp1,inp2 : IN std_ulogic, outp : OUT std_ulogic);
END;
LIBRARY IEEE; use ieee.math_real.all;
ARCHITECTURE beh1 OF nandg IS
BEGIN
outp <= inp1 nand inp2 after (tplh + tphl)/2;
END;
ARCHITECTURE beh2 OF nandg IS
BEGIN
process
variable loc : std_ulogic;
begin
loc := inp1 nand inp2;
if loc = ‘1’ then
outp <= loc after tplh;
else
outp <= loc after tphl;
end if;
wait on inp1,inp2;
end process;
END;
Porte NAND

ENTITY bascd IS
GENERIC (tpd: time := 10 ns);
PORT (SIGNAL D,CLK : IN std_ulogic; SIGNAL Q : OUT std_ulogic);
END;
LIBRARY IEEE;
use ieee.math_real.all;
ARCHITECTURE beh1 OF bascd IS
BEGIN
Q <= D after tpd when (CLK’event and CLK=‘1’) else
unaffected;
END;
ARCHITECTURE beh2 OF bascd IS
BEGIN
process
begin
wait until CLK=‘1’;
Q <= D after tpd;
end process ;
END;
Bascule D

ENTITY R IS
generic (R_value : real := 1_000.0)
END;
ARCHITECTURE equ OF R IS
BEGIN
V == R_value * I;
END;
Résistance

ENTITY C IS
generic (C_value : real := 1.0e-6)
END;
ARCHITECTURE equ OF C IS
BEGIN
I == C_value * V ’dot;
END;
Condensateur

ENTITY L IS
generic (L_value : real := 1.0e-3)
END;
ARCHITECTURE equ OF L IS
BEGIN
V == L_value * I ’dot;
END;
Inductance

ENTITY RLCp IS
generic (R,L,C : real)
END;
ARCHITECTURE struct OF RLCp IS
BEGIN
lab_R: entity R generic map (R) port map (b => vm, a => vp);
lab_C: entity C generic map (C) port map (vp, vm);
lab_L: entity L generic map (L) port map (vp, vm);
END;
ARCHITECTURE equ OF RLCp IS
quantity V across I1,I2,I3 through vp to vm;
BEGIN
V == R*I1 ;
V == L*I2’dot
V == I3’integ/C ;
END;
RLC parallèle

ENTITY RLCs IS
generic (R,L,C : real)
END;
ARCHITECTURE struct OF RLCs IS
Terminal RC,CL : electrical;
BEGIN
lab_R: entity R generic map (R) port map (vp,RC);
lab_C: entity C generic map (C) port map (RC, CL);
lab_L: entity L generic map (L) port map (CL, vm);
END;
ARCHITECTURE equ OF RLCp IS
quantity V across I through vp to vm;
BEGIN
V == R*I + L*I’dot + I’integ/C ;
END;
RLC série

ENTITY gene_sinus IS
generic (Ampl,freq,phase : real)
END;
library ieee;
use ieee.math_real.all;
ARCHITECTURE beh OF gene_sinus IS
quantity V across I through vp to vm;
BEGIN
V == Ampl * sin( 2.0 * math_pi * freq * now ) ;
END;
Source sinus idéale

ENTITY diode IS
generic(Iss:real:=1.0e-14;n,af:real:=1.0;
tt,cjo,vj,rs,kf:real:=0.0);
port (TERMINAL anode,cathode:electrical);
END;
ARCHITECTURE level0 OF diode IS
quantity Vd across id,ic through anode to cathode;
quantity qc : charge;
constant vt : real := 0.0258;
BEGIN
ic == qc ’dot;
qc == tt * id - 2.0 * cjo * sqrt( vj**2 - vj * vd );
id == iss * exp(( vd - rs*id )/( n * vt )) - 1.0);
END ARCHITECTURE level0;
1)
.(e
I
I )/(n.vt)
rs.I
(v
s
d
d
d

 
)
.v
v
-
²
v
.
2.C
-
(tt.I
dt
d
I d
j
j
jo
d
c 
Diode paramétrée

ENTITY diodth IS
generic(Iss:real:=1.0e-14;n,af:real:=1.0;
tt,cjo,vj,rs,kf:real:=0.0);
port (TERMINAL anode,cathode:electrical;
TERMINAL junction:thermal);
END;
ARCHITECTURE level0 OF diodth IS
quantity Vd across id,ic through anode to cathode;
quantity temp across power through thermal_ref to junction;
quantity qc : charge;
quantity vt : voltage;
BEGIN
ic == qc ’dot;
qc == tt * id - 2.0 * cjo * sqrt( vj**2 - vj * vd );
id == iss * exp(( vd - rs*id )/( n * vt )) - 1.0);
vt == temp * boltzmann / elec_charge ;
power == vd * id;
END ARCHITECTURE level0;
Diode : modèle électro-thermique

library Disciplines;
use Disciplines. electrical_ system. all;
use Disciplines. thermal_ system. all;
entity TestBench is end entity TestBench;
architecture DiodeWithHeatSink of TestBench is
terminal a, b: electrical; terminal j, h: thermal;
begin
v0: entity Vdc generic map (dc => 1.0)
port map (p => a, m => ground);
r1: entity Resistor generic map (r => 1.0e3)
port map (p => a, m => b);
d1: entity DiodeTh port map (anode => b,
cathode => ground, junction => j);
heatres: entity ResistorTh generic map (r => 0.1)
port map (p => j, m => h);
heatsink: entity CapacitorTh generic map (c => 0.008)
port map (p => h, m => thermal_ ref);
rad: entity ResistorTh generic map (r => 10.0)
port map (p => h, m => thermal_ ref);
end architecture DiodeWithHeatSink;
Diode : modèle électro-thermique - Testbench

introCOA6-Intro_VHDL_AMS.ppt

Recommandé

Recommandé

Contenu connexe

Similaire à introCOA6-Intro_VHDL_AMS.ppt

Similaire à introCOA6-Intro_VHDL_AMS.ppt (20)

introCOA6-Intro_VHDL_AMS.ppt

Notes de l'éditeur