Scriptable Generators

EASYHDL & SCRIPTS DE GENERATEURS

Introduction

PROSPICE supporte un langage de programmation qui peut être utilisé pour générer des signaux de tests complexes. Nous avons baptisé ce langage EasyHDL car il est plus simple à apprendre et à utiliser que les langages généraux de description tels que Verilog ou VHDL.EasyHDL peut être utilisé pour générer des formes d'ondes analogiques et numériques, ou créer des vecteurs de tests complexes dans un script qui spécifie le comportement de plusieurs objets générateurs du schéma.

EasyHDL est basé sur le langage de programmation BASIC tout en ajoutant des fonctionnalités supplémentaires afin de pouvoir spécifier des vecteurs de tests. La suite de ce chapitre montre comment créer des scripts EasyHDL et comment les lier à un ou plusieurs générateurs du schéma. Cependant, ce manuel ne fournit pas d'explications détaillées sur le langage BASIC, sauf pour les parties qui concernent les fonctionnalités addditionnelles EasyHDL. Les mots clés BASIC sont indiqués brièvement afin de présenter la syntaxe du langage.


Creating, Editing & Debugging EasyHDL Scripts

CREER, EDITER & DEBOGUER LES SCRIPTS EASYHDL

Les scripts EasyHDL peuvent être locaux à un générateur particulier, ou peuvent être placés sur le schéma puis associés à plusieurs générateurs afin de spécifier un jeu complexe de vecteurs de tests.

Pour créer un script EasyHDL local à un génératreur unique:

  1. Validez l'icône Générateur pour placer un générateur ou cliquez droite puis gauche pour éditer un générateur existant.
  2. Choisissez le type Easy HDL - celui-ci peut être analogique ou numérique en relation avec le type de générateur à créer.
  3. Entrez le script dans le champ d'édition prévu à cet effet. Vous pouvez également cliquer sur le bouton 'Editer' pour éditer le script dans votre éditeur de texte externe. Vous pouvez spécifier l'éditeur à utiliser en appelant la commande 'Définir editeur externe' dans le menu 'Source'.

La broche de sortie prend automatique le nom ‘OUT’. Si le générateur de l'étape 2 est analogique, alors OUT sera une variable NODE (noeud); dans le cas d'un générateur numérique, OUT sera une variable PIN (broche).

Pour créer un script EasyHDL sur le schéma:

  1. Validez l'icône 'Script' et cliquez gauche pour placer un objet script. La boite de dialogue d'édition du script apparaîtra.

    Voir SCRIPTS dans le manuel ISIS pour placer et éditer des scripts.
  2. La première ligne du script doit être:

    *SCRIPT GENERATOR script_name

     Le mot clé SCRIPT indique que le bloc de texte du script doit être inclus dans la netlist, tandis que le mot clé GENERATOR indique au simulateur PROSPICE le type de script. Le nom après le mot clé GENERATOR est celui qui vous indiquez pour identifier votre script. Toute suite de caractères alphanumériques ainsi que le caractère souligné ('_') peut être utilisé - un espace ou tout autre caractère sera vu comme la fin du nom du script.
  3. La dernière ligne du script doit être:

    *ENDSCRIPT

    Ceci indique la fin du script lors du chargement de la netlist dans PROSPICE; ISIS signalera un manque si le mot n'est pas trouvé pendant la compilation de la netlist. Tout ce qui est après ce mot sera ignoré et ne sera pas inclus dans le netlist.
  4. Entrez votre scipt EasyHDL entre les indicateurs d'ouverture *SCRIPT... et de fermeture *ENDSCRIPT. Vous devrez déclarer les générateurs avec les variables NODE et PIN.
  5. Fermez la boite de dialogue lorsque vous avez terminé.

Pour lier un générateur avec le script du schéma:

  1. Validez l'icône Générateur pour placer un générateur ou cliquez droite puis gauche pour éditer un générateur existant.
  2. Choisissez le type Easy HDL - celui-ci peut être analogique ou numérique en relation avec le type de générateur à créer.
  3. Utilisez le champ 'Affecter script' pour spécifier le script qui pilotera le générator. Le script doit utiliser la variable NODE or PIN en relation avec le type de générateur.

Pour déboguer le script du générateur pendant la simulation:

  1. Placez le générateur, validez lez type EasyHDL et écrivez le script.
  2. Cochez la case sous le script pour permettre le débogage.
  3. Mettez la simulation en pause pour voir la source et les variables du script.
  4. Placez un point d'arrêt (ou plusieurs) dans la fenêtre source (double clic sur la ligne en question) puis lancez la simulation.
  5. Lorsque le point d'arrêt est rencontré, la simulation est mise en pause. Vous pouvez avancer le script en pas à pas, contrôler l'évolution des variables, etc de façon habituelle.

Spécifier une forme d'onde triangulaire dans un script EasyHDL avec débogage

Pour un utilisateur, le débogage d'un script EasyHDL est comparable au débogage d'un firmware pour microcontrôleur dans Proteus VSM. Vous pouvez prendre connaissance du manuel VSM pour les opérations de base. Par contre, il existe certaines différences qu'il convient de noter:

  • Le temps d'exécution des instructions EASYHDL est de ZERO. Donc, lorsque vous avancez d'un pas dans le code EASYHDL, la simulation électrique n'avance pas d'un pas. Ceci est totalement différent de la simulation pour microcontrôleur pour laquelle chaque instruction s'exécute en un temps défini non nul.
  • Comme, das un script, le temps n'avance pas après chaque instruction, l'effet de chaque affectation sur la sortie ne sera perçu que lorsque la fin du script sera atteinte, ou, dans le cas d'un scirpt numérique, lorsqu'une instruction SLEEP ou WAIT est rencontrée.
  • Tous les scripts sont exécutés une fois au lancement de la simulation. Par conséquent, tout point d'arrêt atteint déclenchera avant que le point de fonctionnement du circuit soit calculé. Ceci peut générer des tensions ou des niveaux logigues inhabituels sur le schéma. Dans cette situation, le point de fonctionnement sera re-calculé après chaque pas jusqu'à ce que la fin du script soit atteinte.
  • Les points d'arrêts ou le pas à pas ne sont pas validés lors de l'appel d'un script analogique pour un point tempore ordinaire. Le débogage est uniquement actif lorsque le script est appelé par un timer ou un événement de type callback (fonction de rappel).

Plusieurs exemples de scripts EasyHDL se trouvent dans le sou-dossier 'Generator Scripts' du dossier 'Samples' lié à votre installation de Proteus. Leur complexité variable va de la simple forme d'onde sinusoidale au modulateur QPSK complet et méritent d'être regardés attentivement.


Program Structure

STRUCTURE DU PROGRAMME

EasyHDL est constitué de déclarations, affectations et commandes. Le déclarations sont utilisées pour définir des noms de variables, avec la possiblité de les initialiser. Les affectation permettent d'affecter les résultat d'une expression à une variable. Les commandes sont utilisées pour contrôler le flux des informations dans le script.

Chaque déclaration ou commande contient un ou plusieurs mots clés, bien que tous les mots clés ne soient pas indispensables; c'est à dire que certains éléments de la commande sont optionnels. Par exemple la commande FOR...TO...STEP...NEXT contient quatre mots clés, où seuls les mots clés FOR, TO et NEXT sont indispensables (le mot clé STEP et l'expression qui suit sont optionnels).

Certaines commandes possèdent une syntaxe de bloc et une syntaxe en ligne. Un syntaxe de bloc regroupe plusieurs commandes placées entre un mot de début et un mot de fin. Une syntaxe en ligne regroupe plusieurs commandes sur un ligne; dans ce cas c'est la fin de la ligne qui signale la fin de la commande. L'exemple qui suit montre la commande IF...ELSE...ENDIF sous la forme d'une commande bloc et une commande en ligne:

IF i=0 THEN

j=1 // IF... BLOCK

k=2

ELSE

j=3 // ELSE... BLOCK

k=4

ENDIF

IF i=0 THEN j=1:k=2 ELSE j=3:k=4 // Pas besoin du ENDIF


Explanation of Syntax Layout

EXPLICATIONS SUR LA SYNTAXE

Nous donnons ici des explications sur la nomenclature et les symboles utilisés dans la section 'référence des commandes'. Il est indispensable de prendre connaissance de cette nomenclature en premier lieu.

Pour chaque commande de la section 'référence des commandes' ,la syntaxe est indquée dans un format BNF (Backus-Naur Form) simplifié expliqué ci-dessous:

  1. Dans les définitions de syntaxe et les exemples, toutes les commandes utilisent la police courier et tous les mots clés sont en gras. Par exemple:

    IF expression THEN ...
  2. Ellipses ('...') indicate one or more other commands, separated by colons.
  3. Les double crochets ouvrants et fermants ('[[' et ]]') indiquent que le texte entre crochets est optionnel. Lorsque des crochets sont imbriqués, alors le texte le plus interne n'est autorisé que si le texte du crochet le plus externe est présent; c'est à dire que, si vous omettez le texte des crochets externes, alors vous devez omettre tout le texte entre les double crochets. Par exemple:

    COMMAND [[A[[,B]] ]]

    signifie que 'A' peut éventuellement suivre COMMAND. Si c'est le cas, vous pouvez éventuellement ajouter une virgule après 'A' pour ajouter 'B'. Si 'A' ne suit pas la commande, alors vous ne pouvez pas ajouter autre chose.
  4. Le symbole de canalisation ('|') est utilisé pour indiquer une ou plusieurs options mutuellement exclusive. Par exemple:

    COMMAND A | B | C

    indique que le mot clé COMMAND peut être suvi par l'un quelconque des mots 'A', 'B', our 'C'.
  5. Les lettres etc sont utilisées pour signaler une répétition du paramètre(s) précédent(s). Les caractères avant etc indiquent à quel endroit du texte le(s) paramètre(s) se répète(nt). Dans l'exemple:

    INT variable=expression[[,variable=expression]][[,etc]]

    le ,etc indique que le paramètre précédent [[,variable=expression]] peut être répété indéfiniment.
  6. Les mots ou les phrases en minuscules et police italique Times Roman signalent une expresion ou variable arbitraire. Dans l'exemple:

    IF test_expression THEN ...

la suite test_expression indique un expression numérique arbitraire.


Using EasyHDL To Specify Analogue Signals

UTILISER EASYHDL POUR SPECIFIER DES SIGNAUX ANALOGIQUES

Déclarer les sorties

Les broches de sorties des scripts pour des générateurs de signaux analogiques doivent utiliser des variables NODE. Par exemple:

NODE V(OUT) // Single voltage output

NODE V(POS,NEG) // Differential voltage output

NODE I(OUT) // Single ended current output

NODE I(POS,NEG) // Current output

Un script de générateur local contient une déclaration implicite NODE V(OUT) pour un générateur de tension ou NODE I(OUT) pour un générateur de courant.

Flux du programme

Lorsqu'un script EasyHDL est utilisé pour spécifier des signaux analogiques, le script est exécuté en totalité du début jusqu'à la fin à chaque point temporel analogique et également lorsque survient une fonction de rappel (callback). Les commandes telle que SLEEP ne sont pas autorisées, et on suppose que le programme affectera toutes les variables NODE déclarées.

Les événements de rappel (callback) peuvent être planifiés via la commande CALLBACK ou TIMER. Ces commandes forcent un point temporel à intervenir au temps spécifié, ce qui appelera le script avec un ID d'événement.

Classiquement, vous pourrez utiliser une fonction mathématique pour spécifier la sortie en fonction du temps et utiliser l'événement de callback pour modifier la valeur de certains paramètres à des instants précis. Voici un exemple qui tente de clarifier ce qui vient d'être dit:

REM TRIANGLE WAVE GENERATOR

REM Define the Waveform Parameters

FLOAT FREQ=100, AMP=2, SLOPE=1

FLOAT PERIOD=1/FREQ,OFFSET=0

REM Repeating event for positive slope

ON TIMER AT PERIOD EVERY PERIOD

 OFFSET=EVTTIME

 SLOPE=1

ENDON

REM Repeating event for negative slope

ON TIMER AT PERIOD/2 EVERY PERIOD

 OFFSET=EVTTIME

 SLOPE=-1

ENDON

REM Set the output as a function of both time

REM and the current waveform slope.

OUT=AMP*SLOPE*(4*(REALTIME-OFFSET)/PERIOD-1)

Lorsque le script est appelé pour tout point temporel, seule la dernière ligne est exécutée. La sortie, en terme de tension, va croître ou décroître en fonction du temps en relation avec la valeur de SLOPE (pente). Cette valeur va être de 1 ou -1 en relation avec les deux blocs ON TIMER qui se déclenchent à chaque cycle ou demi-cycle afin de générer une forme d'onde triangulaire.

Il ressort de ceci qui les variables conservent leurs valeurs entre les différents appels. Par contre, ne faites aucune hypothèse sur le nombre de fois que votre code sera appelé pendant une période de temps de simulation. Par exemple:

REM !!!BAD CODE!!!

FLOAT VOUT=0

VOUT = VOUT + 1.0

OUT=VOUT

Ceci générera des résultats imprévisibles car la croissance de VOUT dépendra totalement du pas temporel choisi par le noyau SPICE.

Spécifier des transitions en sortie

Vous pouvez spécifier la sortie d'un générateur analogique de deux façons:

  • Comme une valeur instantanée.
    OUT=vout
  • Comme une transition temporelle.
    OUT=vout AFTER time_interval

Dans le cas d'une transtion dans le temps, la sortie va varier linéairement de sa valeur courant à la valeur désirée pendant l'intervalle de temps indiqué. Vous pouvez également spécifier une temps absolu avec la commande

OUT=vout AT time

L'exemple ci-dessous, montre comment planifier des transitions qui sont utilisées pour générer une forme d'onde linéaire par partie en relation avec des données mémorisées.

REM PIECEWISE LINEAR GENERATOR

REM Define time/value pairs for the output

DATA 2m,5

DATA 3m,5

DATA 5m,0

DATA 0,0  // End of data

FLOAT PERIOD=10m

FLOAT v,t,td

TIME OFFSET=0

REM Reset the data pointer to

REM start a new cycle

ON TIMER AT PERIOD EVERY PERIOD

   RESTORE

   OFFSET=EVTTIME

ENDON

ON EVENT

READ t,v

IF t > 0

t = t + OFFSET

OUT=v AT t // La sortie génère une tension v au temps t

CALLBACK AT t

ENDIF

ENDON


Using EasyHDL To Specify Digital Signals

UTILISER EASYHDL POUR SPECIFIER DES SIGNAUX NUMERIQUES

Déclarer les sorties

Les broches de sorties des scripts pour des générateurs de signaux analogiques doivent utiliser des variables PIN. Par exemple:

PIN Q // Single bit output

PIN D[0..7] // 8 bit data bus

Un script de générateur local contient une déclaration implicite PIN OUT.

Lorsque le générateur possède un nom qui n'est pas un nom de variable EasyHDL valide, vous pouvez utiliser la commande ALIAS:

ALIAS OUT=Test Signal

PIN OUT

Flux du programme

Lorsqu'un script EasyHDL est utilisé pour spécifier des signaux numériques, le script est exécuté en totalité depuis le début jusqu'à ce qu'une des conditions suivantes soit rencontrée:

· Une instruction END est exécutée.

· La dernière instruction du script est exécutée.

· Les commandes SLEEP ou WAIT mettent le script en pause.

Lorsque l'instrution END ou la fin du script est attteinte, le script n'est plus appelé sauf si un événement CALLBACK ou TIMER est planifié. Ces commandes forcent le script à reprendre son exécution (s'il est suspendu) ou à reprendre depuis le début avec l'identificateur d'événement correspondant. Notez qu'il ne peut y avoir qu'un seul thread d'exécution; si un événement survient lorsque le script est suspendu ou endormi, l'exécution reprend toujours à l'instruction suivante.

Typiquement, un script de générateur numérique est constitué d'affectations entrecoupées d'instructions SLEEP ou WAIT afin de créer le timing souhaité. Par exemple, le code suivant génère une suite de bits pour un flot série associé à une variable.

// Bit Bang a single character

// 1 Start bit, 1 Stop bit and no

// parity are assumed.

// Start bit

OUT = 0

SLEEP FOR BITTIME

// Data bits

FOR j=0 TO 7

OUT = d & (1 << j)

SLEEP FOR BITTIME

NEXT j

// Stop bit

OUT = 1

SLEEP FOR BITTIME

Spécifier des transitions en sortie

Vous pouvez spécifier la sortie d'un générateur numériques de plusieurs façons:

  • Comme une valeur instantanée (transition avec un retard nul)
    OUT=dout
  • Comme un valeur future
    OUT=vout AT time

L'affectation de plusieurs valeurs futures peut être planifié en une seule opération. Par exemple, une impulsion unique peut être décrite de la façon suivante

OUT=1 AT time

OUT=0 AT time+width

  • ou comme une transition temporelle.

    OUT=dout AFTER delay
    OUT=dout AFTER tdlh,tdhl

Dans le cas d'une transition temporelle avec deux paramètres, tdlh est utilisé lorsque la sortie est croissante (transition bas->haut) et tdlh lorsque la transition est décroissante (transition haut->bas).


VARIABLES

Déclaration des variables

Les varables peuvent être simple ou des tableaux. Les tableaux de variables sont une solution pour produire des tables de transcodage (look up tables) et, plus important, pour gérer des bus.

La déclaration des variables suit la forme:

TYPE nom[[[inférieur..supérieur]]] [[=expression]] [[,etc]]

TYPE nom[[[largeur]]] [[=expression]] [[,etc]]

Une déclaration contient le type de la variable à déclarer, suivi de la liste des noms de variables séparées par une virgule. Si la variable représente un tableau, alors le nom doit être doit être suivi des limites inférieure et supérieure séparées par deux points ou par la largeur, entre crochets. La largeur ou la limite inférieure et supérieure du tableau doivent être des constantes entières - les expressions ne sont pas autorisées. Si la largeur du tableau est indiquée, alors la limite basse est zéro et la limite haute est (largeur-1). L'initialisation de variable est obtenue en ajoutant le signe égal puis l'expression d'initialisation après la déclaration.

Par exemple,

PIN data[2..5]=13, output

INT i

INT j=0,k[2]

TIME t1,t2=10n

déclare deux variables de type PIN (data et output), trois variables de type INT (i, j, et k) et deux variables de type TIME (t1 et t2). Les variables data et k sont des tableaux ; data contient quatre éléments: data[2], data[3], data[4] and data[5], tandis que k contient deux éléments: k[0] et k[1]. Les variables data, j, et t2 ont été initialisées avec les valeurs 13, 0 and 1E-8 respectivement.

Les variables déclarées et initialisée avec une expression ne reçoivent la valeur résultante de l'expression d'une seule fois, lors de l'étape de lancement du simulateur numérique DSIM. Après le lancement, les variables conservent leurs valeurs liées aux appels successifs du script BASIC.

Voir les types BOOL et PIN pour plus d'information sur la déclaration de tableaux de variables PIN.

Voir 'Affectation des variables' pour une explication sur la façon d'affecter des expressions aux variables.

Types numériques

Il existe trois types numériques en EasyHDL:

Type | Description
INT | Entier signé ou non signé dans la gamme 0 à 2,147,483,648.
FLOAT | Valeur flottante signée ou non signée dans la gamme 2.225074 x 10-308 à 1.767693 x 10308.
TIME | Entier signé ou non signé capable de fixer un événement temporel avec une résolution de 1ps. Le temps courant d'une simulation analogique peut être obtenu via la variable système REALTIME which quit retourne une valeur flottante.

Types chaînes de caractères (string)

EasyHDL admet le type string (chaîne de caractères)

STRING Chaîne de caractères ASCII simple.

De nombreuse opérations peuvent être réalisées sur une variable string:

STRING S1 = "Hello", S2 = "World", S3

INT C

S3 = S1+" "+S2 // S3 <= "Hello World"

S3 = S1[1,4] // S3 <= "Hell"

C=ASC(S1) // C <= 48h ('H')

C=ASC(S1[2]) // C <= 65h ('e')

S3 = CHR(C+1) // S3 <= "f"

Types BOOL et PIN

Le type PIN de EasyHDL permet d'accéder aux broches du générateur(s) auxquelles le script est relié. Les variables de ce type sont "liées" au(x) générateur(s) de même nom auxquel(s) le script est affecté.

Voir 'Déclaration des sorties" pour plus d'information sur la déclaration des variables PIN.

L'ordre de déclaration des variables n'est pas important et l'initialisation des variables déclarées est permise.

Lorsqu'une variable PIN est lue ou testée, elle retourne à la fois sont activité courante et précédente - l'activité des la broche dépend de l'état du lien auquel la broche est connectée, du type électrique de la broche, de la table de translation de la famille logique, et des propriétés affectées à la broche par le composant ou le générateur. Les variables de type PIN ne devraient être testées qu'en relation avec une des constantes du tableau ci-dessous:

Type | Description
TRUE,ACTIVE | La broche est actuellement active; l'activité précédente est ignorée.
FALSE,INACTIVE | La broche est actuellement inactive; l'activité précédente est ignorée.
FF | La broche était inactive et reste inactive.
FT,POSEDGE | La broche était inactive et est devenue active.
TF,NEGEDGE | La broche était active et est devenue inactive.
TT | La broche était active et reste active.

Il est possible de driver directement le lien auquel la brocje de sortie est connectée, indépendamment du type électrique de la broche et des propriétés qui lui sont affectées, en affectant à la variable PIN une des constantes système suivantes:

Type | Description
FLT | Drive le lien avec un état the flottant.
SLO | Drive le lien avec un état bas fort.
SHI | Drive le lien avec un état haut fort.
WLO | Drive le lien avec un état bas faible.
WHI | Drive le lien avec un état haut faible.

Comme la mémorisation de l'état d'activité de la broche est complexe, le type spécial BOOL est fourni pour conserver l'état de la variable PIN. Le type BOOL est identique au type PIN sauf que les variables de type BOOL ne sont pas reliées à une broche externe.

Type NODE

Le type NODE de EasyHDL permet d'accéder aux broches du générateur(s) analogique auxquelles le script est relié. Les variables de ce type sont "liées" au(x) générateur(s) de même nom auxquel(s) le script est affecté.

Voir Déclaration des sortie pour plus d'information sur la façon de déclarer des variables NODE.

L'ordre de déclaration des variables n'est pas important et l'initialisation des variables déclarées est permise.

Lorsqu'une variable de type NODE est lue ou testée, elle retourne la tension ou le courant drivé. Dans le cas d'une transition à un temps précis, cette valeur sera interpolée au temps de simulation courant.

Affecter des variables

La syntaxe générale d'affectaion à des variables simples est:

[[LET]] variable = expr'n[[,variable=expr'n]][[,etc]]

Par exemple:

INT VAR1, VAR2, VAR2

...

VAR1=10, VAR2=20, VAR3=30

En générale, le résultat de toute expression s'adapte au type de la variable qui reçoit le résultat de l'affectation. L'exception à cette règle intervient lors de l'affectation de l'état d'un lien à une variable de type PIN qui est reliée à un générateur externe ou une broche de sortie d'un composant, lorsque l'état est directement appliqué au lien auquel la broche ou le générateur est connecté.

Les tableaux peuvent également être afffectés. Lorsque l'expression d'affectation contient au moins le même nombre de valeurs que le tableau, l'affectation se fait à partir de l'élément d'indice le plus bas du tableau. Une erreur survient si le nombre d'éléments est insuffisant.

Par exemple:

INT A[10..19]

A[10..12]=A[15..19] // A[10]=A[11], A[11]=A[16], A[12]=A[17]

A[10..15]=A[16..17] // Error, insufficient elements in // A[16..17].

Si l'expression contient une valeur unique, et que la variable tableau n'est pas de type PIN, alors la valeur est affectée à tous les éléments du tableau. Pour les variables tableau de type PIN, la valeur est, en premier, transformée en INT (entier) puis chaque élément du tableau PIN est mis en actif ou inactif en relation avec chaque bit (0 ou 1) du mot INT. Le premier élément du tableau reçoit l'état du bit zéro, l'élément suivant celui du bit un, et ainsi de suite. Par exemple:

INT A[3]

PIN D[2..3]

A=4 // A[0]=4, A[1]=4, A[2]=4

D=10 // D[2]=Bit 0 of 10, D[3]=Bit 1 of 10.

Une affectation à une variable de type PIN (soit une variable simple, soit un tableau) peut utiliser une information de timing, tel que:

pin_var = expression AFTER time_expression

pin_var = expression AFTER tlh_expression,thl_expression

pin_var = expression AT|@ time_expression

La première syntaxe utilise le mot AFTER et une expression de temps qui force la sortie à changer après un temps spécifié.

La deuxième syntaxe utilise le mot AFTER . La sortie change soit après tlh_expression, dans ce cas le changement est une transition bas-haut ou après thl_expression, dans ce cas le changement est une transition haut-bas. Notez que les termes bas-haut et haut-bas sont généraux - par exemple une transition de l'état flottant à faible-bas représente une transition haut-bas.

La dernière syntaxe utilise AT ou le symbole @ pour indiquer un changement de la broche de sortie au temps absolu spécifié..

Il faut noter que l'affectation d'une broche n'intervient qu'au temps spécifié, et pas après la fin du script ou lorsque le script est suspendu, même lorsque le temps d'affectation est identique au temps indiqué dans le script.

Par exemple:

PIN p

p=TRUE // Assume pin was inactive, we assign it active.

IF p=TRUE THEN // Pin is still inactive, therefore test fails.

...

Vour les 'Types BOOL et PIN' pour obtenir plus d'information sur l'affectation des variables PIN.


EXPRESSIONS

Les expressions dans EasyHDL sont constituées de termes séparés par des opérateurs. Un terme est un opérateur unaire optionnel séparé soit par une valeur litérale, une variable ou une constante, une fonction, ou le résultat d'une expression entre parenthèses.

Opérateurs

Les oérateurs suivants sont autorisés dans EasyHDL:

Opérateur | Description
() | Parenthèses
- | Moins
NOT or ! | NON logique
NOT~ | Opération sur bit
AND or && | ET logique
OR or || | OU logique
& | ET sur bit
| | OU sur bit
^ | OU exclusif sur bit
<= | Inférieur ou égal
< | Inférieur à
= or == | Egal
<> or != | Différent de
> | Supérieur à
>= | Supérieur ou égal
>> | Décalage à gauche
<< | Décalage à droite
+ | Addition
- | Soustraction
* | Multiplication
 | Division
% | Modulo

La précédence des opérateurs, par priorité décroissante, est

Opérateurs unaires (!, NOT, -).

Parenthèeses.

Modulo, Division, Multiplication.

Addition, Soustraction.

Décalage gauche et droite.

AND, OR et XOR sur bits.

Inférieur à, inférieur ou égal, supérieur à, supérieur ou égal.

Egal, différent de

ET ou OU logiques.

Valeurs

Les valeurs peuvent être soit des variables, des variables système, le résultat de fonctions, le résultat d'expression ou des nombres. Les nombres s'expriment en numération décimale, hexadécimale (faire précéder le nombre avec le caractère dollar) ou binaire (faire précéder le nombre avec le caractère pourcent). Toutes les valeurs peuvent être modifiées en les faisant précéder d'un opérateur unaire.

Values | Description
23 | Valeur décimale, 23 décimal
%1010 | Valeur binaire, 1010 (10 décimal)
$010A | Valeur hexadécimale, 010A (266 décimal)
(10*5) | Sous-expression, 10*5 (50 décimal)
TRUE | Constante système, TRUE
!TRUE | Opérateur unaire et constante, NOT TRUE
max_count | Variable, max_count
EVTTIME | Variable système, EVTTIME
~%1010 | NOT logique sur bits (5 décimal)
!$A | NOT unaire logique (0 décimal)
"Hello" | Chaîne constante

Exemple de précédence lors de l'évaluation

Voici quelques exemples d'expressions:

Expression | Solution de l'évaluation
2 * -3 + 4 | Résultat : -2
2 * -(3 + 4) | Résultat : -14
5 << 3 | Résultat : 40
10 >> 2 | Résultat : 2
3 << 3+4 | Résultat : 28
20-3*4 | Résultat : 8
2<1+3 | Résultat : 1 (c.a.d. TRUE, 2<4)
1+2>=8 | Résultat : 0 (c.a.d. FALSE, 3>=8)
40%16 | Résultat : 8
!(1<3) | Résultat : 0 (c.a.d. FALSE, !TRUE)
!5<2 | Résultat : 1 (c.a.d. TRUE, 0<2)

Fonctions

EasyHDL supporte plusieurs fonctions mathématiques très utiles. Tous les noms de fonctions sont suivis d'un argument (qui peut être une expression) entre parenthèses. Le résultat d'une fonction est renvoyé en tant que valeur. Par exemple, l'expressions suivante affecte la racine carré de l'expression a*b*c à la variable z:

z = sqrt (a*b*c)

EasyHDL admet les fonctions suivantes:

Fonction | Description
DEG | Retourne la valeur en degrés de l'argument en radians.
RAD | Retourne la valeur en radians de l'argument en degrés.
SIN | Retourne le sinus de l'argument en radians.
COS | Retourne le cosinus de l'argument en radians.
TAN | Retourne la tangente de l'argument en radians.
ASIN | Retourne l'arc-sinus de l'argument en radians.
ACOS | Retourne l'arc-cosinus de l'argument en radians.
ATAN | Retourne l'arc-tangente de l'argument en radians.
SQRT | Retourne la racine carré de l'argument.
ROUND | Retourne la valeur entière la plus proche de l'argument.
FRAC | Retourne la valeurs décimale de l'argument en nombre flottant.
ASC | Retourne le code ASCII du premier caractère de la chaîne de caractères.
CHR | Retourne le caractère qui correspond au code ASCII de l'argument.
LEN | Retourne la longueur de la chaîne de caractères.
SUBSTR | Rettourne la sous-chaîne contenu dans une chaîne, à partir du second argument, et d'une longueur indiquée dans le troisième argument optionnel.


System Constants and Variables

CONSTANTES ET VARIABLES SYSTEME

A system constant is a constant value defined with DSIM for the purpose of providing portability of scripts; system constants are fixed for a particular release of the simulator engine and never change value from one invocation of the script to another. A system variable is a read-only variable that returns some value particular to the current simulation run and the current invocation of the script; system variables may thus change from one invocation to another. The DSIM system constants defined as follows:

Constantes numériques

La constante numérique suivante est disponible:

PI (p) - 3.141582654…

Constantes d'identification d'événement

Les constantes EI_ANY, EI_BOOT, EI_SETTLE, EI_INPUT et EI_CALLBACK sont fournies pour tester la variable système EVTID afin de déterminer si l'appel du script est le résultat d'un événement système (ou utilisateur indéfini), et à utiliser dans les commandes SLEEP et WAIT.

Lorsqu'un script est invoqué, l'identification de l'événement qui a provoqué l'appel est placé dans la constante système EVTID. La valeur EI_INPUT indique que l'invocation est le résultat d'un changement d'état d'un lien à une des broches du composant auquel le script est connecté. La valeur EI_CALLBACK indique que l'invocation est le résultat d'un événément de rappel (callaback) utilisateur qui a été initialisé sans un code ID d'événement utilisateur.

Voir également la commande SLEEP .

Voir également la commande WAIT.

Constantes d'état de lien

Les constantes SHI, SLO, FLT, WLO, WHI sont fournies pour affecter des variables de type PIN, afin de driver directement le lien auquel la broche du composant ou le générateur est connecté.

Voir les types BOOL et PIN pour plus d'information sur ces constantes.

Constantes activité de broche PIN et BOOL

Les états d'activité de broche FALSE, INACTIVE, FF, FT,TRUE, ACTIVE, TF, FT, POSEDGE, et NEGEDGE sont disponibles en relation avec les variables de type PIN afin d'obtenir de l'information sur l'activité courante et précédente de la broche.

Voir les types BOOL et PIN pour plus d'information sur ces constantes.

Variable système TDSCALE

La variable TDSCALE retourne la valeur courante de la propriété de contrôle du simulateur TDSCALE qui fournit l'échelle des propriétés de timing. Si la propriété TDSCALE a été initialisée pour produire des valeurs aléatoires d'échelle de temps, alors la variable TDSCALE retourne la nouvelle valeur aléatoire d'échelle de temps à chaque fois que le temps est lu.

Variable système RANDOM

La variable RANDOM retourne le prochain nombre aléatoire obtenu par le script du générateur de nombre aléatoire de DSIM. Le nombre aléatoire retourné est compris entre 1 et 32767 (215-1).

Vous pouvez initialiser le générateur via la commande SEED.

Voir également la commande SEED.

Variables système REALTIME et EVTTIME

La variable REALTIME retourne la valeur courante du temps dans la simulation analogique, en tant que valeur de type FLOAT. La variable EVTTIME retourne la valeur courante de l'événement temporel de la simulation numérique, en tant que valeur de type TIME. Les événements temporels sont quantifiés avec une résolution de 1ps.


Command Reference

REFERENCE DES COMMANDES

Cette section liste toutes les commandes supportées par EasyHDL. La syntaxe de chaque commande est décrite, son objet et un ou plusieurs exemples.

Commande ABORT

Syntaxe

ABORT idcode_expr

Objet

La commande ABORT fournit un moyen d'arrêter la simulation courante. L'exécution de cette commande force le noyau de simulation EasyHDL à générer une erreur de run-time. Le message d'erreur inséré dans le journal de simulation inclut un code d'identification donné dans idcode_expr qui suit le mot clé ABORT.

Il faut noter que la commande ABORT ne se contente pas de stopper l'invocation actuelle de EasyHDL, mais stoppe également la simulation.

Exemple:

IF input=TRUE THEN PRINT "Input Is TRUE!" : ABORT 0

Commande ALIAS

Syntaxe

ALIAS new_name=existing_name [[,new_name=existing_name]] [[,etc]]

Objet

La commande ALIAS permet de fournir un alias (nom équivalent) d'une variable. Les alias sont très utiles lorsque le nom de la broche d'un composant utilise des caractères non autorisés dans les noms des variables EasyHDL; par conséquent lorsqu'il n'est pas possible de déclarer directement une variable de PIN ou NODE pour la broche du générateur. Le nouveau_nom est le nom auquel vous souhaitez associer la variable ou la broche externe ou la propriété, et doit respecter les règles des noms des variables EasyHDL. Le nom_existant est le nom d'une variable existante, d'une propriété ou d'un nom de broche - tous les caractères ainsi qu'un espace ou une virgule sont valides - si votre alias doit contenir des espaces ou des virgules dans son nom, alors vous devrez inclure le nom_existant entre guillemets. Suite à la déclaration de l'alias, nouveau_nom est vu comme un synonyme du nom_existant et peut être utilisé en lieu et place du nom_existant.

Par exemple le compteur TTL 7493 possède des broches de reset qui contiennent des parenthèses - R0(1) and R0(2). Comme les parenthèses ne sont pas autorisées dans les noms de variablesEasyHDL, vous devrez utiliser un alias - t.q. RS0 et RS1, puis déclarer les variables de type PIN avec ces noms - voir l'exemple suivant.

Voir les types BOO L et PIN pour plus d'information sur l'utilisation de la commande ALIAS pour déclarer des variables de type PIN.

Exemple:

ALIAS RS1=R0(1),RS2=R0(2)

...

PIN RS1,RS2 // RS1 est synonyme de R0(1), etc.

...

IF RS1 AND RS2 THEN ...

Commande BREAK

Syntaxe

BREAK

Objet

La commande BREAK met fin aux boucles FOR...TO...NEXT, WHILE...WEND, REPEAT...UNTIL ou termine les commande MAP ON ou SWITCH , comme suit:

· L'exécution de la commande interne à la boucle WHILE...WEND force l'exécution à se poursuivre à la première instruction qui suit le mot clé WEND.

· L'exécution de la commande interne à la boucle REPEAT...UNTIL force l'exécution à se poursuivre à la première instruction qui suit le mot clé UNTIL.

· L'exécution de la commande interne à la boucle FOR...TO...NEXT force l'exécution à se poursuivre à la première instruction qui suit le mot clé NEXT.

· L'exécution de la commande interne à la boucle AP ON...ENDMAP force l'exécution à se poursuivre à la première instruction qui suit le mot clé ENDMAP.

· L'exécution de la commande interne à la boucle SWITCH...ENDSW force l'exécution à se poursuivre à la première instruction qui suit le mot clé ENDSW.

Exemple:

WHILE pin_enable=TRUE

...

IF EVTTIME > 1 THEN BREAK

...

WEND

Commande CALLBACK

Syntaxe

CALLBACK [[eventid]] AFTER time_expression

CALLBACK [[eventid]] AT time_expression [[EVERY repeat_expression]]

Objet

La commande CALLBACK poste un événement de rappel; Le script EasyHDL est appelé lors de temps de l'événement est atteint.

Cette commande permet également qu'une valeur d'identification de l'événement soit spécifiée; cette valeur sera placée dans la variable système EVTID lorsque l'événement est traité et le script appelé. Comme toutes les valeurs utilisées par le système pour identifier un événement système sont négatives ou nulles, seules les valeurs positives non-nulles idoivent être utilisées dans les commandes CALLBACK. Si aucune valeur d'identification n'est spécifiée, alors la variable EVTID variable contiendra la constante système EI_CALLBACK lorsque le script est appelé.

L'expression d'identification d'événement, si elle existe, est suivie du mot AFTER ou du mot AT puis d'une expression qui indique le temps auquel le rappel intervient. Le mot clé AFTER indique que l'expression de temps est un retard qui s'ajoute au temps courant; la commande AFTER indique un temps absolu auquel intervient le rappel .

Un rappel répétitif peut être prévu par l'utilisation de la construction AT... EVERY.

Voir les constantes d'identification d'événements pour une explication de la variable système EVTID et des des codes d'identification d'événements.

Exemple:

IF EVTID = EI_BOOT THEN

REM BOOT Sequence; post call back for 1u.

CALLBACK 2 AT 1u

ELIF EVTID = 2 THEN

REM Process out call-back.

...

ENDIF

Commande CONTINUE

Syntaxe

CONTINUE

Objet

La commande CONTINUE force l'expression de boucle WHILE...WEND, REPEAT...UNTIL a être ré-évaluée ou la variable de boucle de la boucle courante FOR...TO...NEXT à être incrémentée et testée par rapport à sa condition limite, comme suit:

  • L'exécution de la commande interne à la boucle WHILE...WEND force l'exécution à se poursuivre à la commande WHILE.
  • L'exécution de la commande interne à la boucle REPEAT...UNTIL force l'exécution à se poursuivre à la commande UNTIL.
  • L'exécution de la commande interne à la boucle FOR...TO...NEXT force l'exécution à se poursuivre comme si le mot clé NEXT avait été atteint.

Exemple:

REPEAT

...

IF EVTTIME <= 100n THEN CONTINUE

...

UNTIL pin_enable=F

Commande DATA

Syntaxe

DATA constant [[,constant]] [[,etc]]

DATA REPEAT

Objet

La commande DATA spécifie une ou plusieurs valeurs constantes qui peuvent être lues en séquence par la commande READ. Typiquement, les données mémorisées déterminent l'évolution temporelle du signal de test contrôlé par le script. Par exemple, vous pourriez définir des couples temps/tensions afin de spécifier une forme d'onde linéaire par morceaux, ou mémoriser des données et des adresses à sortir sur un bus.

Le type des valeurs constantes peut être un des types EASYHDL valide y compris les chaînes de caractères.

Le mot clé REPEAT force la table des données à être circulaire, c'est à dire que lorsque la dernière valeur est rencontrée, la prochaine commande READ recommencera au début de la table.

Exemple:

DATA "Hello World ", 250m

DATA "- EASYHDL Test Program\r", 500m

DATA REPEAT

Commande END

Syntaxe

END

Objet

La commande END force le script BASIC courant à se terminer puis le contrôle est rendu au noyau de simulation. Il n'est pas nécessaire de terminer le script BASIC avec une commande END; ceci est implicite.

Exemple:

IF EVTTIME < 100n THEN END

Commande FOR...TO...STEP...NEXT

Syntaxe

FOR variable=init_expr'n TO limit_expr'n [[STEP step_expr'n]]

...

NEXT variable

Objet

La commande FOR...TO...STEP...NEXT permet d'exécuter plusieurs fois les commandes situées entre les mots clés FOR et NEXT. La variable après les mot clé FOR est appelée variable de boucle et son type doit être INT ou FLOAT qui doit également être indiqué après le mot clé NEXT.

La variable boucle est initialisée dans init_expression, puis les commandes dans le bloc FOR...NEXT sont exécutées. Lorsque le mot clé NEXT est rencontré, la valeur de la variable boucle est incrémentée soit par la valeur de step_expression si elle est indiquée, ou par un. Si la nouvelle valeur de la variable boucle est inférieure ou égale à la valeur de limit_expression, alors l'exécution se poursuit avec la première commande qui suit le mot clé FOR, sinon elle se poursuit au niveau de la première commande qui suit le mot clé NEXT.

Les commandes à l'intérieur du bloc FOR...NEXT sont toujours exécutées au minimum une fois, indépendamment des valeurs init_expression et limit_expression. La variable de boucle est toujours disponible dans le bloc FOR...NEXT et peut être manipulée comme tout autre variable. Notez cependant qu'il est possible de manipuler la variable de boucle de telle façon que la boucle FOR...NEXT ne se termine jamais. Par exemple:

FOR i=0 TO 10 STEP 2

i=0

NEXT i

la variable de boucle (i) est mise systématiquement à zéro; même si elle est incrémentée de 2 lorsque le mot clé NEXT est rencontré, elle n'atteindra jamais la valeur 10.

Exemple:

INT v

FOR v=0 TO 10 STEP 2

PRINT v;"*";v;"=";v*v

NEXT v

Commande GOTO

Syntaxe

GOTO label_name

Objet

La commande GOTO permet au programme de se dérouter directement vers un label label_name. Le label doit être déclaré quelque part dans le script BASIC; les sauts avant ou arrière sont permis.

Le label doit être déclaré au début d'une ligne et doit contenir moins de 30 caractères alphanumériques et soulignés ('_'). Le label est suivi de deux points et, pour éviter toute ambiguité, il ne peut pas être identique à un mot clé EasyHDL. Plusieurs commandes peuvent suivre le label, si nécessaire.

Exemple:

LBL_START: // Declare the label.

PRINT "START OF SCRIPT"

...

IF !done THEN GOTO LBL_START // Jump to PRINT... command.

Commande IF...ELIF...ELSE...ENDIF

Syntaxe

IF expression [[THEN]]

...

...

[[ELIF expression [[THEN]]

...

...]]

[[ELIF expression [[THEN]]

...

...]]

etc

[[ELSE

...

...]]

ENDIF

IF expression [[THEN]] ... [[ELIF expression [[THEN]] ... ]][[ELSE ... ]][[ENDIF]]

Objet

La commande IF...ELIF...ELSE...ENDIF autorise une exécution conditionnelle des commandes contenues dans les blocs. Il ne peut y avoir qu'un seul mot clé IF et, optionnellement, un mot clé ELSE. Il peut y avoir un nombre quelconque de mots clés ELIF entre le mot clé IF et les mots clés ELSE ou ENDIF.

Les expression qui suivent IF et ELIF sont évaluées en séquence; La première de ces expressions qui est non nulle provoque l'exécution du bloc de commandes qui suit le IF ou ELIF et qui précède le le prochain ELIF, ELSE or ENDIF sont exécutés. Si aucune expression IF ou ELIF est évaluée à non nulle, alors les instructions qui suivent le mot clé ELSE (si elles existent) sont exécutées. L'exécution se poursuit par la commande qui est placée après le mot clé ENDIF.

Exemple:

IF i=0 THEN

PRINT "Value is zero"

zero = TRUE

ELSE

PRINT "Value is non-zero"

zero = FALSE

ENDIF

IF i THEN j=0 : WHILE (i>0) j=j*2:i=i-1 : WEND : i=0 ELSE j=-1

Commande MAP ON...ENDMAP

Syntaxe

MAP ON property_name

CASE string1 : ...

...

[[BREAK]]

[[CASE string2 : ...

...

[[BREAK]] ]]

[[DEFAULT : ...

...

[[BREAK]] ]]

ENDMAP

Objet

La commande MAP ON...ENDMAP permet d'exécuter un bloc de comandes incluses dans un ou plusieurs cas. Le cas sélectionné est obtenu par comparaison de la valeur d'une propriété indiquée après le mot clé MAP ON et de plusieurs labels de cas.

Un ou plusieurs cas sont référencés à l'intérieur du bloc MAP ON...ENDMAP. Chaque cas comment soit par le mot DEFAULT suivi de deux-points, soit du mot CASE suivi du label et de deux-points. Les quinze premiers caractères après le mot clé CASE jusqu'au caractère espace ou tabulation ou le deux-points font partie du label. Les commandes qui suivent le deux-points sont associées au cas.

La valeur textuelle de la propriété qui suit le mot clé MAP ON est comparée avec chaque cas, dans l'ordre de déclaration. La comparaison n'est pas sensitive. Si une correspondance est trouvée, alors l'exécution se poursuit avec la première commande qui suit le label; si aucune correspondance n'est trouvée, et qu'un cas DEFAULT existe, alors l'exécution se poursuit avec la première commande qui suit le mot clé DEFAULT. L'exécution continue avec toutes les commandes jusqu'au mot clé ENDMAP; l'exécution des commandes d'un cas se termine lorsque le mot clé BREAK est rencontré.

La structure MAP ON...ENDMAP s'utilise pour initialiser un script en relation avec l'état d'une propriété composant, habituellement sa valeur. Les commandes internes au bloc MAP ON...ENDMAP sont exécutées lors du premier appel au script - les commandes sont automatiquement ignorées lors des appels suivants au script et il n'est pas nécessaire de les inclure dans un test IF...ENDIF block.

Exemple:

// Assign timing properties depending on what family

// of device we are modelling.

MAP ON VALUE

CASE 74259 : TDRQ=16n : TDLHDQ=14n

TDHLDQ=11n : TDLHAQ=15n

BREAK

CASE 74LS259 : TDRQ=12n : TDLHDQ=19n

TDHLDQ=13n : TDLHAQ=17n

BREAK

ENDMAP

Commande ON BOOT … ENDON

Syntaxe

ON BOOT

...

...

ENDON

Objet

La commande ON BOOT permet de n'exécuter qu'une fois une suite de commandes, au lancement de la simulation. C'est totalement équivalent à:

IF EVTID = EI_BOOT THEN

...

...

ENDIF

Exemple:

ON BOOT

REM BOOT Sequence; post call back for 1u.

CALLBACK AT 1u

ENDON

Commande ON EVENT … ENDON

Syntaxe

ON EVENT [[event_id]]

...

...

ENDON

Objet

La commande ON EVENT permet d'exécuter une suite de commandes lorsqu'un événement particulier survient. C'est totalement équivalent à:

IF EVTID = event_id THEN

...

...

ENDIF

Si event_id n'est pas spécifié, on suppose que la valeur est EI_ANY.

Tout le code du bloc ON EVENT block ne sera pas exécuté lors d'un événement analogique ordinaire.

Exemple:

ON TIMER AT PERIOD EVERY PERIOD

RESTORE

OFFSET=EVTTIME

ENDON

ON EVENT

READ t,v

IF t > 0

t = t + OFFSET

OUT=v AT t

CALLBACK AT t

ENDIF

ENDON

Le bloc ON EVENT sera exécuté au lancement (EI_BOOT), à chaque période TIMER, et lors de chaque rappel (EI_CALLBACK).

Commande ON TIMER… ENDON

Syntaxe

ON TIMER event_id AFTER delay_expr

...

...

ENDON

ON TIMER event_id AT time_expr [[EVERY period_expr]]

...

...

ENDON

Objet

La commande ON TIMER valide un timer et permet d'exécuter une suite de commande lorsqu'il se déclenche. Ceci est équivalent à:

TIMER event_id AT time_expr EVERY period_expr

IF EVTID = event_id

...

...

ENDIF

Si event_id n'est pas spécifié, un identifiant unique est automatiquement alloué.

Comme pour la commande TIMER, la commande ON TIMER ne peut pas être redéclenchée lorsqu'un événement a été planifié.

Exemple:

ON TIMER AT PERIOD EVERY PERIOD

OFFSET=EVTTIME

SLOPE=1

ENDON

Commande PRINT

Syntaxe

PRINT expression | "text" [[,|; expression | "text"]][[etc]][[,|;]]

Objet

La commande PRINT fournit un moyen d'insérer du texte et des expressions/variables dans le journal de simulation.

Le mot clé PRINT est suivi d'une liste d'arguments séparés par une virgule ou un point-virgule; chaque argument peut être une expression ou un texte littéral entre guillements. Chaque argument est inséré dans le journal de simulation de la gauche vers la droite; les arguments séparés par une virgule seront ajoutés dans le journal avec un espace comme séparateur; les arguments séparés par un point-virgule seront insérés dans le journal immédiatement après l'argument précédent. Si la commande PRINT se termine par un argument, un retour à la ligne (carriage-return et linefeed) est inséré dans le journal après le dernier argument; si la liste se termine par une virgule ou un point-virgule, aucun retour à la ligne ne sera inséré et la prochaine sortie d'une commande PRINT se poursuivra sur la même ligne à partir du point courant.

Exemple:

PRINT var1;"+";var2;"=";var1+var2;".";

Commande READ

Syntaxe

READ var1 [[,var2]] [[,etc]]

Objet

La commande READ trouve le(s) prochain(s) item(s) déclaré(s) dans une instruction DATA du programme et les range dans la ou les variables spécifiées.

Exemple

REM Define data to be output

DATA "Hello World", 250m

REM Read the data

READ s,td

Commande REM

Syntaxe

REM text

Objet

La commande REM (remarque) permet d'ajouter des commentaires ou de l'information dans le script EasyHDL. La totalité du texte qui suit le mot clé REM est ignorée par le compilateur EasyHDL.

Notez que vous pouvez également ajouter un commentaire sur une ligne grâce au doublebarre oblique ('//').

Exemple:

REM This is a comment, and will be ignored.

REM So is this.

PRINT "A=",a // Display the value of A

Commande REPEAT...UNTIL

Syntaxe

REPEAT

...

...

UNTIL expression

Objet

La commande REPEAT...UNTIL permet d'exécuter plusieurs fois les commandes situées entre les mots clés REPEAT et UNTIL, jusqu'à ce que la condition qui suit le mot clé UNTIL soit évaluée à non-nulle.

Si le résultat de la condition est non-nul, l'exécution se poursuit avec la première commande placée après le mot clé UNTIL, sinon l'exécution continue avec la première commande qui suit le mot clé REPEAT.

Notez que l'expression de boucle est testée à la fin de la boucle, donc les commandes situées entre les mots clés REPEAT et UNTIL sont toujours exécutées au moins une fois.

Exemple:

REPEAT

WAIT

count=count+1

UNTIL enable_pin=TRUE

Commande RESTORE

Syntaxe

RESTORE

Objet

La commande RESTORE réinitialise le pointeur de données utilisé par la commande READ afin de se référer à nouveau à la première valeur de l'instruction DATA du programme. Ceci permet de lire à nouveau les données.

Exemple:

// Define data to be output

DATA "Hello World", 250m

// Read the data

READ s,td

// Read the data again

RESTORE

READ s,td

Commande SEED

Syntaxe

SEED (value)

Objet

The SEED command is used to seed the script's random number generator. For a given seed value, DSIM guarantees that, whilst the sequence of values returned by subsequent reads of the RANDOM system variable appear random, the sequence itself is finite and determinate.

For example, given a seed value of 1, the first ten random values produced by the RANDOM system variable will always be: 909, 3365, 5030, 24170, 3305, 10539, 20191, 14244, 15844, 21839, 9277. Similarly, for a seed value for 500, the first ten values would always be: 14616, 21006, 7672, 12031, 9888, 2966, 3985, 24555, 30757, 30317, 27030.

See RANDOM System Variable for an explanation of the RANDOM System Variable.

Exemple

SEED (500)

FOR i=1 TO 10

PRINT "Random Value",i,"=",RANDOM

NEXT I

Commande SLEEP

Syntaxe

SLEEP [[eventid]] FOR time_expression

SLEEP [[eventid]] UNTIL time_expression

Objet

La commande SLEEP permet de suspendre l'invocation actuelle du script numérique soit pendant un temps fixe, soit jusqu'à un temps défini. Lorsque le temps de fin est atteint, l'exécution se poursuit avec la première commande qui suit le mot clé SLEEP.

La commande SLEEP permet de spécifier un identificateur d'événement. La valeur de cette expression indique si la suspension du script peut être interrompue par d'autres événements, tel qu'un événement de rappel (call-back) devenu actif, ou un changement dans un ou plusieurs liens auxquels les broches d'entrée sont connectées. L'expression d'identification d'événement , si spécifiée, devrait être soit un entier unique positif non nul ou un des constantes système: EI_ANY, EI_INPUT, ou EI_CALLBACK. Utiliser un entier unique ou la constante EI_CALLBACK garantit que la suspension ne sera pas interrompue; EI_ANY ou EI_INPUT autorise la suspension a être interrompue par tout événement ou modification sur les broches d'entrée. Lorsque la suspension se termine, la variable EVTID contiendra la valeur d'identification de l'événement. La valeur d'identification par défaut, si aucune expression n'est donnée, est EI_CALLBACK.

L'expression d'identification d'événement, si elle existe, est suivie du mot clé FOR ou UNTIL puis de l'expression avec le temps de fin de la suspension. Le mot clé FOR indique que l'expression temporelle est un retard à ajouter au temps courant de l'événement; le mot clé UNTIL indique que l'expression temporelle est un temps absolu auquel la suspension prend fin.

La commande SLEEP ne peut pas être utilisée avec un script de générateur analogique.

Voir les constantes d'identification d'événement pour une explication sur la variable système EVTID et les codes d'identification d'événement.

Exemple:

PIN output

...

// Generate 100 periods of mark=20n, space=10n clock

FOR i=0 TO 100

output = TRUE // Output active

SLEEP 1 FOR 20n // Wait 20ns (mark time)

output = FALSE // Output inactive

SLEEP 1 FOR 10n // Wait 10ns (space time)

NEXT i

...

Commande SWITCH...ENDSW

Syntaxe

SWITCH switch_expression

CASE value1 : ...

...

[[BREAK]]

[[CASE value2 : ...

...

[[BREAK]] ]]

[[DEFAULT : ...

...

[[BREAK]] ]]

ENDSW

Objet

La commande SWITCH...ENDSW permet d'exécuter des commandes placées dans un ou plusieurs cas. Le cas sélectionné correspond au résultat de l'évaluation d'une expression placée au niveau de SWITCH.

Chaque cas inclut dans le bloc SWITCH...ENDSW commence par le mot clé CASE suivi d''une valeur fixe FLOAT et de deux-points ou du mot clé DEFAULT suivi de deux-points. Les commandes sont placées à la suite du deux-points.

L'expression qui suit le mot clé SWITCH est évaluée comme une valeur flottante (FLOAT) et comparée avec chaque valeur de cas dans l'ordre de déclaration. Si une correspondance est trouvée, l'exécution se poursuit à la première commande qui suit la valeur du CASE; si aucune correspondance n'est trouvée, et qu'un cas DEFAULT est spécifié, l'exécution continue à la première commande qui suit le mot clé DEFAULT. L'exécution se poursuit avec toutes les commandes jusqu'à rencontrer le mot clé ENDSW; Si l'exécution doit s'arrêter avant le cas suivant, alors la dernière commande du cas doit être une commande BREAK. Si aucune correspondance n'est trouvée dans tous les cas et ou si un BREAK est rencontré, l'exécution se poursuit à la première commande qui suit le mot clé ENDSW.

Exemple:

SWITCH bus[0..2]

CASE 0 : REM Fall through to next case...

CASE 1 : REM Fall through to next case...

CASE 2 : PRINT "Bus is 0,1,or 2" : BREAK

DEFAULT : PRINT "Unknown bus value!" : BREAK

ENDSW

Commande TIMER

Syntaxe

TIMER [[event_id]] AFTER delay_expr

TIMER [[event_id]] AT time_expr [[EVERY period_expr]]

Objet

La commande TIMER permet de planifier des événements de façon identique à la commande CALLBACK. Cependant, la différence est que le timer peut uniquement être redéclenché lorsqu'un événement prévu intervient. En d'autres mots, lorsque l'instruction TIMER a été exécutée et a posté un événement, les exécutions suivantes ne feront rien jusqu'au temps où l'événement a été atteint.

Exemple:

PIN OUT = 0

TIMER 1 AT PERIOD EVERY PERIOD

OUT = !OUT

Commande WAIT

Syntaxe

WAIT [[eventid]]

Objet

La commande WAIT suspend l'invocation courante du script dans l'attente d'un nouvel événement. Lorsque et si l'événement intervient, l'exécution se poursuit à la première commande qui suit le mot clé WAIT.

La commande peut optionnellement être suivie d'une expresion qui indique la valeur d'identification de l'événement à attendre; si une telle valeur est spécifiée, alors le script ne reprendra que lorsqu'un événement de cette valeur d'expression devient actif. Si aucune valeur d'identification d'événement n'est spécifiée, alors la valeur par défaut égale à la constante système EI_ANY est utilisée, et le script reprendra sur tout événement qui répond.

Voir les constantes d'identification d'événement pour une explication sur les codes d'identification.

Exemple:

REM Post call-back, and then wait for it and only it - input

REM pin transitions are ignored.

CALLBACK 2 AFTER 100n

WAIT 2

...

REM Post call-back; wait for it or an input pin transition

CALLBACK 3 AFTER 200n

WHILE EVTID != 3 AND EVTID != EI_INPUT WAIT

Commande WHILE...WEND

Syntaxe

WHILE expression

...

...

WEND

WHILE expression ... [[WEND]]

Objet

La commande WHILE...WEND permet de répéter les commandes entre les mots clés WHILE et WEND dès lors que l'expression qui suit le mot clé WHILE est non nulle.

L'expression de boucle qui suit le mot clé WHILE est évaluée et, si le résultat est zéro, l'exécution continue à la première commande qui suit le mot clé WEND. Dans le cas contraire, les commandes entre les mots clés WHILE et WEND sont exécutées; lorsque le mot clé WEND est rencontré, l'exécution retourne à la commande WHILE et l'expression de boucle est ré-évaluée.

Noter que, comme l'expression de boucle est évaluée au début de la boucle, les commandes entre les mots clés WHILE et WEND peuvent ne jamais être exécutées si l'expression est évaluée à zéro lors du premier test.

Exemple:

WHILE i<j

PRINT "i is less than j"

i=i+2:j=j+1

WEND

WHILE enable_pin=F WAIT