Préparation du TP (homework : 3-4 heures)

• Lire l'intégralité du texte de TP en insistant sur les passages difficiles dans le but de
comprendre les informations fournies, les explications sur le fonctionnement des modules et les
demandes que l'on vous fait. Aidez-vous, si nécessaire, du contenu du cours de DSP, des autres
cours que vous avez eus (Traitement de Signal, Informatique Industrielle, GI, Traitement
d'Images etc.) et d'autres sources d'information sur internet (Wikipedia ...).
• Lire le code source compute.asm fourni avec le texte du TP et commenter d'une manière
exacte l'effet produit par chaque instruction sur les registres et les variables impliquées.
Identifiez clairement pour chaque instruction le type d'adressage (vous pouvez utiliser des
surligneurs de couleurs différentes). Remplir ensuite le tableau 1 (qui résume juste une partie
des instructions).
• Comprendre en détail le fonctionnement et la configuration du timer et du port série
synchrone de C50. Ensuite comprendre le fonctionnement, le rôle et la configuration du
convertisseur A/D et D/A TLC32040. Une fois compris, remplir les 9 cases blanches de la
figure 3 avec des expressions (soit des nombres constants soit des valeurs symboliques
représentant des registres ou des morceaux de registres) qui représentent le facteur de division
d'horloge entre l'entré et la sortie (une case remplie à 10 signifie qu'elle divise par 10 la
fréquence reçue en entrée).
• On souhaite faire fonctionner le convertisseur D/A à une fréquence de synthèse de 50 kHz.
Quels sont les registres concernés et quelle sera leur valeur ? Pourquoi a-t-on des degrés de
liberté ? Combien exactement ? Choisir la configuration qui aura l'ouverture de bande
maximale et déterminer la valeur des registres concernés.
• On souhaite faire fonctionner le convertisseur A/D à une fréquence d'échantillonnage de 40
kHz, avec le filtre passe-bande actif. Quels sont les registres concernés et quelle sera leur
valeur ? Pourquoi a-t-on des degrés de liberté ? Combien exactement ? Choisir la configuration
qui aura l'ouverture de bande maximale et déterminer la valeur des registres concernés.
• Programmation de l'AIC TLC32040 : qui le programme ? Quelle est la suite typique des mots
de 16 bits qu'il doit recevoir ? Quelle est la durée exacte de la transmission d'un mot vers le
TLC32040 ? Comparez cela par rapport au nombre de coups horloges dans le même intervalle.
• Ecrire dans le tableau suivant une suite possible pour les mots 16 bits à envoyer vers le
TLC32040 pour le configurer conformément aux points précédents (en plus on veut un gain de
2 et utiliser l'entrée auxiliaire).
Mots envoyés vers TLC 32040 (16 bits) Signification
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

• Lire le code source pass.asm et partagez-le en 5 sections (utilisez des surligneurs de diverses
couleurs) en pistant les modifications sur les 2 registres d'interruption :
code qui sert le service d'interruption de réception
code qui sert le service d'interruption d'émission
code qui risque d'être interrompu par le service d'interruption de réception
code qui risque d'être interrompu par le service d'interruption d'émission
code non-interruptible
préparation TP-1
• Réviser la synthèse et l'utilisation des filtres numériques. Quels sont les paramètres qui
caractérisent un système de filtrage numérique doté de convertisseurs en entrée et en sortie ?
Revoir les notions de délai de groupe, distorsion harmonique, plage d'entrée, gabarit de filtre ...
• Dessiner correctement le gabarit du filtre de l'exercice 3 sur une feuille A4. Bien délimiter les
zones permises et les zones interdites avec des valeurs correctes pour chaque segment et chaque
coordonnée (amplitude - fréquence).
• Pour l'exercice 5, calculer le rapport ηIO entre la puissance du signal de sortie et celui d'entrée
pour le filtre censé laisser passer que f3 et f7 (à 100%) et filtrer (atténuer) les autres
"mauvaises" fréquences par un facteur A ( >1 , à choisir plus tard ).
Touche appuyée ηIO (A) ηIO(1) ηIO(10) ηIO(100) ηIO(1000)
9
7, 8, 3, 6, C
1, 2, 5, D, B
• Réviser l'architecture DaVinci (cœur C64x+ et sous-système vidéo : front et back end).
• Réviser les normes PAL et NTSC (format, limitations, nombre de lignes, colonnes etc.) ainsi
que la transmission des signaux vidéo sous format Composite ou SVideo (différences,
avantages et inconvénients, connexions).
• Réviser le format vidéo YUV (ou YCbCr) : signification, formule, conversion etc. Réviser le
format YUYV (ou YUV422) : combiens de bits occupe un pixel ? Est-ce que chaque pixel peut
avoir une couleur indépendante (par rapport aux voisins) ? (en.wikipedia.org/wiki/YUV)
• Réviser la notion de pitch (ou widthstep) en traitement d'images (ne pas confondre avec la
finesse pixelique d'un écran !).
• Ecrire un bout de code C/C++ destiné à s'exécuter sur une architecture 32 bits, qui peut
transformer une image en couleur (format YUYV) dans une image en niveaux de gris sous le
même format, sur place (dans l'image d'entrée), en étant le plus rapide possible et en utilisant le
moins de mémoire.

Attention : L'ensemble du travail de préparation vous sera

demandé, vérifié et noté au début du TP de DSP.

préparation TP-2
 TP DSP
Cartes TMS 320 C50 & DM6437
1. Circuits d'interface du TMS320C50
Pour permettre le fonctionnement et la communication du convertisseur A/N et N/A le DSP utilise
son circuit timer et l'interface série (figure 1). Le timer génère l'horloge central du convertisseur
(MLCK) et l'interface série envoie et reçoit les valeurs numériques à convertir ou converties, sur 14
bits significatifs.

PC DSP TLC 32040

TMS320C50 (AIC)
~INT2 TOUT MCLK
Tx ~BIO CLKX SCLK
Interface Rx XF CLKR RCA
OUT+
RS 232 DTR ~RS FSX 1KΩ
OUT
~FSX
(COMx) FSR ~FSR RCA
GND GND DR DR IN+ IN
DX DX 1KΩ

CLKIN ~BR RESET

40Mhz Carte DSP KIT

Figure 1. Connexions entre PC, DSP et convertisseur A/N

1.1. Timer
Le timer divise la fréquence de l'horloge CLKIN pour générer deux signaux identiques, l'un envoyé
vers l'extérieur sur la broche TOUT et l'autre envoyé vers l'unité centrale pour générer l'interruption
TINT du timer. La division est déterminée par la valeur des deux registres PRD (16 bits) et TDDR
(4 bits) à l'aide de deux autres registres compteurs TIM (16 bits) et PSC (4 bits). Ces derniers sont
rechargés à partir de PRD et TDDR à chaque passage à zéro ou reset du timer.
fTOUT = fTINT = fCLKIN/(2*(TDDR+1)*(PRD+1))

d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0

Réservés, à zéro Soft Free PSC TRB TSS TDDR
Soft = mettre à 0 TRB = timer reset bit: écrit à 1 il remet à zéro le timer
Free = mettre à 0 TSS = timer stop status bit: à 1 il arrête le timer
Exemple de programmation du timer pour obtenir une interruption TINT et une fréquence du TOUT
égale à 50 kHz, si fCLKIN = 20 Mhz :
LPD #0 ; sélectionner la page 0
SPLK #199, PRD ; faire PRD = 199
OPL #8, IMR ; activer l'interruption
SPLK #20h, TCR ; faire TDDR = 0, reset du timer: TRB = 1 et son activation: TSS = 0
SPLK #1000b, IFR ; effacer une éventuelle demande d'interruption TINT dans IFR
; écrire un 1: efface la demande d'interruption; écrire un 0: pas d'effet
CLRC INTM ; activer globalement les interruptions

1.2. Port série

Le port série offre les services d'une liaison série synchrone capable de transmettre ou de recevoir
des mots de 16 bits. L'utilisateur ne voit que 3 registres DRR, DXR et SPC mappés en mémoire:

TP-1
 Adresse Registre Description
0020h DRR Registre de réception, reçoit le contenu de RSR. A lire par l'utilisateur.
0021h DXR Registre de transmission, écrit par l'utilisateur, il est chargé dans XSR.
0022h SPC Registre de contrôle du port série
- RSR Registre à décalage pour la réception
- XSR Registre à décalage pour l'émission
La structure du registre de contrôle SPC:
d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0
Free Soft RSRfull XSRempty XRDY RRDY IN1 IN0 ~RRST ~XRST TXM MCM FSM FO DLB X
R/W R/W R R R R R R R/W R/W R/W R/W R/W R/W R/W R
Free = mettre à 0 RSRfull = 1 : RSR est plein mais le dernier mot dans DRR n'a pas été lu
Soft = mettre à 0 XSRempty = 1 : XSR est vide et DXR ne contient pas de nouveau mot
In1 = copie de CLKX XRDY = 1 : DXR est vide, on peut écrire un mot
In0 = copie de CLKR RRDY = 1 : DRR contient un nouveau mot reçu, il faut le lire
~RRST = écrire un 0 pour remettre à zéro la partie de réception du port série
~XRST = écrire un 0 pour remettre à zéro la partie de transmission du port série
TXM = 0/1 : FSX sera une entrée/sortie, donc la synchronisation par trame sera externe/interne
MCM = 0/1 : CLKX sera une entrée/sortie, donc l'horloge de transmission sera externe/interne
FSM = 0/1 : synchronisation par trame utilisée pour le premier mot / tout les mots
FO = 0/1 : taille du mot égale à 16 / 8 bits
DLB = 1 : Digital Loopback Mode: DR et FSR connectés intérieurement aux DX et FSX. Si
MCM est à 1 alors CLKR est aussi connecté à CLKX.
Les signaux externes impliqués par le port série sont les suivants:
Broche (pin) Type Description
CLKR Entrée Horloge de réception
CLKX Entrée ou sortie Horloge d'émission
DR Entrée Données reçues
DX Sortie Données transmises
FSR Entrée Synchronisation par trame de la réception
FSX Entrée ou sortie Synchronisation par trame de l'émission
Reset: pour remettre à zéro et reconfigurer le port série il faut écrire 2 fois dans SPC.
écrire 0 dans ~XRST et ~RRST et écrire la configuration voulue dans le reste du SPC
écrire 1 dans ~XRST et ~RRST et réécrire la configuration voulue dans le reste du SPC
Transmission: L'écriture d'un mot dans DXR déclenchera, une fois XSR vidé, la copie du mot dans
XSR et le début de son transmission sur la broche DX. Cette copie génère une transition de 0 à 1 du
bit XRDY dans SPC et une demande d'interruption XINT indiquant que DXR peut être à nouveau
écrit avec un nouveau mot.
Réception: Les données qui arrivent sur DR sont mémorisées dans RSR, puis copiées dans DRR où
l'utilisateur peut les lire. Cette copie déclenche une transition de 0 à 1 du bit RRDY dans SPC et une
demande d'interruption RINT indiquant qu'il faut lire le mot reçu dans DRR.
2. Convertisseur numérique - analogique et analogique - numérique TLC 32040 (AIC)
Fonctionnement et timing des interfaces N/A et A/N :
L'horloge qui gouverne le fonctionnement du convertisseur MCLK (master clock) est générée par la
sortie TOUT du timer du DSP dont la fréquence est:
fTOUT = fMCLK = 10 MHz
fSCLK = fMCLK/4 = 2.5 MHz

TP-2
Les filtres analogiques sont réalisés avec des capacités commutées dont les fréquences de
fonctionnement fSCF_R (passe-bande 0.3-3.4kHz) et fSCF_T (passe-bas 3.45kHz) prévues sont de 288
kHz les deux. Mais leurs fréquences réelles, autant que les fréquences de la conversion N/A fDAC et
A/N fADC sont déterminées par le contenu des compteurs TXA, RXA, TXB et RXB:
En mode synchrone (d5=1 dans le registre de contrôle, c'est le mode utilisé par la carte DSP) :
fSCF_T = fSCF_R = fMCLK/(2*TXA)
fDAC = fADC = fMCLK/(2*TXA*TXB)
En mode asynchrone (d5=0 dans le registre de contrôle) :
fSCF_T = fMCLK/(2*TXA) fSCF_R = fMCLK/(2*RXA)
fDAC = fMCLK/(2*TXA*TXB) fADC = fMCLK/(2*RXA*RXB)
Les registres TXA, TXB, RXA, RXB sont chargés à chaque conversion à partir de registres TA,
TA', RA, TB, TB', RB en fonction des bits de commande envoyés par le DSP.

d6=1 Filtre passe-bande d2=1

d7=1 0.3 - 3.4 kHz
M
AUX IN+
AUX IN- ×1 M U A/D ~FSR
Port
U X série DR
IN+
×1 X ~EODR
IN-
d4=0 MCLK
Référence SCLK
de tension
interne DX
d3=0 ~FSX
~EODX
Filtre passe-bas VCC
OUT+ 3.45 kHz WORD/
OUT- D/A
~BYTE

Figure 2. Schéma bloc du convertisseur TLC 32040

3. Communication DSP - Convertisseur

3.1. Format du mot DR (émis par le convertisseur, vers le DSP)
La transmission commence par le bit de poids fort (d15). Les deux bits de poids faible ne sont pas
significatifs.
d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0
Tension d'entrée (signé sur 14 bits) X X

3.2. Format des mots DX (1 ou 2 mots émis par le DSP et reçus par le convertisseur)
La réception commence par le bit de poids fort (d15). Si CMD=11, un deuxième mot est attendu.
d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0
Tension de sortie (signé sur 14 bits) CMD
CMD=00 TXA TA ; RXA RA ; TXB TB ; RXB RB ;
CMD=01 TXA TA+TA' ; RXA RA+RA' ; TXB TB ; RXB RB ;
CMD=10 TXA TA-TA' ; RXA RA-RA' ; TXB TB ; RXB RB ;
CMD=11 TXA TA ; RXA RA ; TXB TB ; RXB RB ; et le mot suivant sera un mot de
configuration pour TA, RA ou TA', BA' ou TB, RB ou le registre de contrôle.

TP-3
Format du deuxième mot (quatre possibilités) :
d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0
X X registre TA (non-signé) X X registre RA (non-signé) 0 0

d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0

X registre TA' (signé) X registre RA' (signé) 0 1

d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0

X registre TB (non-signé) X registre RB (non-signé) 1 0

d15 d14 d13 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0

X X X X X X X X registre de contrôle 1 1
 d2 = 0/1 = désactive/active le filtre passe-bande
 d3 = 0/1 = ouvre/ferme la boucle entrées-sorties
Signification des bits du  d4 = 0/1 = entrée sur IN (0) ou AUX IN (1)
registre de contrôle  d5 = 0/1 = fonctionnement asynchrone/synchrone
 d7,d6 = 00/11 = gain d'entrée = 1
 = 01/10 = gain d'entrée = 2/4

3.3. Valeurs par défaut des registres (après la remise à zéro du convertisseur)
TA = 9 TA' = 1 TB = 24
RA = 9 RA' = 1 RB = 24
Registre de contrôle: d7,d6 = 11, d6 = 1, d5 = 1, d4 = 0, d3 = 0, d2 = 1
3.4. Restrictions de programmation des registres
TA ≥ 4 RA ≥ 4 TA ± TA' > 1 RA ± RA' > 1 TB > 1

4. Règles et restrictions de programmation sur le kit DSP

La table de vecteurs d'interruption est positionnée à l'adresse 0800h (IPTR=1). Il ne faut pas
essayer de modifier la valeur d'IPTR. Placez une instruction de saut à l'adresse du vecteur
d'interruption désiré. Par exemple, pour les vecteurs d'émission / réception:
.ps 080ah ;
rint: B receive ; 0A : Serial port receive interrupt RINT.
xint: B transmit ; 0C : Serial port transmit interrupt XINT.
Terminez le service d'interruption par l'instruction RETE, permettant ainsi l'activation des
interruptions à la sortie du service.
La valeur conseillée pour le début du code de programme est 0A00h. Elle est déclarée par
les directives:
.ps 0A00h ; commence l'assemblage à l'adresse 0A00h
.entry ; établi là le point d'entrée du programme (première instruction à exécuter)
Placez le segment de données à l'adresse 0F00h en utilisant la directive:
.ds 0F00h
Le DSP C50 doit rester en mode µC (µP/~µC=0) et le bloc de SARAM doit être vu comme
mémoire de programme (RAM=1) et mémoire de données (OVLY=1). Le bloc B2 de RAM et les
premiers 384 mots de la SARAM sont réservés pour le débogueur.
Les vecteurs d'interruption INT2, RESET et TRAP sont utilisés par le débogueur.
Restrictions de l'assembleur dsk5a : Toute ligne assembleur est limitée à maximum 80
caractères, le reste est pris comme une nouvelle ligne. Ne pas mettre d'étiquette sur la même ligne
qu'une instruction. Une étiquette non-définie placée sur un champ dma peut être évaluée à 0 sans
message d'erreur (il faut la vérifier à la fin du fichier listing). Les étiquettes sont sensibles aux
minuscules - majuscules.
TP-4
 Outils nécessaires pour le DSP Starter Kit C50

1. Environnement logiciel
L'ensemble des outils logiciels nécessaires pour l'utilisation de la carte C50 se trouvent dans le
répertoire c:\pfilesxx\dsp. Actions à effectuer pendant le TP :

Pour assembler un fichier appelé (par exemple) prog.asm

On ouvre un shell DOS, on se place dans le répertoire du ficher et on appelle dsk5a ainsi :
c:\pfilesxx\dsp\dsk5a prog -l
Suite à une compilation sans erreurs, il résulte une ficher prog.dsk (image exécutable) et
prog.lst (listing de la compilation).

Pour charger et exécuter sans interaction avec le PC un fichier prog.dsk

Appelez par un clic le programme RunDsk. A l'aide du bouton Browse choisir le ficher
prog1.dsk désiré puis choisir le port série sur lequel est connectée la carte DSK. Charger et
exécuter le programme en appuyant sur Run puis l'arrêter en appuyant sur le bouton Stop. A
n'importe quel moment vous pouvez modifier sur disque l'image prog.dsk car chaque nouvelle
exécution prendra en compte la nouvelle image.

Pour exécuter pas à pas à l'aide du debugger un fichier prog.dsk

Branchez une carte C50 sur un des ports série du PC. Appelez par un clic le programme
C50Debug. Chargez l'image exécutable désirée par le menu Fichiers/Ouvrir. Exécutez le
programme pas à pas et regardez la modification des registres et de la mémoire. Attention : Le
C50Debug ne permet pas le suivi des instructions pendant les interruptions, ni la modification des
registres ou des zones mémoire qu'il utilise pour son propre fonctionnement.

Pour exécuter le programme de synthèse de filtres FIR/IIR FilterExpress

Appelez par un clic le programme FilterExpress. Choisir la configuration désirée, marquer
la fréquence d'échantillonnage à laquelle fonctionnera la carte DSK puis générer le filtre. Essayez
de limiter au maximum le nombre de coefficients car le programme écrit actuellement sur DSP
supporte maximum 512 coefficients (limitation de la mémoire DARAM). En plus, le temps de
traitement dépend linéairement du nombre de coefficients et il est limité par la période
d'échantillonnage choisie (à une fréquence d'échantillonnage de 18kHz il peut traiter sans
problèmes 250-300 coefficients).

Pour exécuter le programme de filtrage ArmaDsk

Appelez par un clic le programme ArmaDsk.exe. Ce programme est prêt à charger une
image exécutable sur C50 qui fait un filtrage à réponse impulsionnelle finie. Par défaut, le
programme utilise un filtre FIR passe - tout symétrique de 85 coefficients. Pour changer de filtre, il
suffit de générer à l'aide de Systolix FilterExpress V5.0 ou écrire à la main un fichier à coefficients
*.txt, puis le charger en appuyant sur le bouton Load. Avant le chargement et l'exécution du
programme l'utilisateur pour choisir le facteur de pré-multiplication des coefficients du filtre ainsi
que le facteur de post-division du résultat. Le champ TLC montre les paramètres actuels de
programmation du convertisseur ADC/DAC et le bouton Change permet leur modification, ainsi
que le calcul direct des fréquences d'échantillonnage et de filtrage à capacités commutées.

2. Environnement matériel : Réglez le générateur pour avoir une sortie sinusoïdale d'amplitude
égale à 1V (2V crête à crête, sans composante continue). Vérifiez que vos sondes ou câbles et les
entrées de l'oscilloscope assurent une haute impédance d'entrée (1MΩ). Alimentez la carte DSK
C50, branchez le générateur de signal à l'entrée IN et l'oscilloscope à la sortie OUT de la carte
(Ch2) et à la sortie du générateur (Ch1). Synchronisez-vous sur l'entrée Ch1.

TP-5
5. Déroulement du TP
Exercice 1. Fonctionnement de l'unité arithmétique - Utiliser C50Debug
Compilez le programme compute.asm puis chargez dans le debugger l'image compute.dsk.
Analysez le programme, en expliquant l'action effectuée par chaque instruction.
A. Quels registres sont concernés par les instructions du programme ?
B. Où est la fin du programme ? Dans quel bloc mémoire se trouvent le programme et les données ?
C. Prévoir la modification successive des registres ACC, PREG et la case mémoire qui reçoit le
résultat (quelle est son adresse ?). Remplir le tableau suivant avec les valeurs successives prévues
en analysant le programme (certaines cases peuvent rester vides en fonction de la nature de
l'instruction).
Tableau 1.
Avant l'execution Après execution
Instruction @1er op. 1er op. @2ème op. 2ème op. PREG ACC result
lar
zap
sacl
mac
mac
mac
mac
mac
mac
mac
apac
sacl
D. Exécutez pas à pas le programme et vérifiez vos prévisions.
E. Ecrire une version optimisée du programme (le moins d'instructions possible).
F. Quelle liaison existe-t-il entre le programme compute.asm et le filtrage numérique ? De quel
type ?

Exercice 2. Filtre "pass-tout" - Utiliser RunDsk

Le but est d'acquérir un signal d'entrée et de le restituer ensuite en essayant de l'altérer le moins
possible. Regardez et compilez le programme pass.asm puis chargez à l'aide de Rundsk.exe
l'image exécutable pass.dsk sur la carte DSK.
A. Choisir une fréquence de 1 kHz puis regardez les signaux à l'entrée et la sortie de la carte. Est-ce
que la sortie est identique à l'entrée ? Mesurer les éventuelles différences (amplitude, phase).
Répétez les mesures pour 5 kHz et 200 Hz. Quelle conclusion tirez-vous ?
B. Editez le programme pass.asm et analysez rapidement l'architecture et la fonctionnalité du
programme. Accordez une attention particulière au système d'interruptions, et comment le
programme établit la fréquence d'échantillonnage. Remplir la figure suivante (chaque boite
représente un diviseur). Modifiez la configuration du convertisseur TLC 32040 pour avoir des
signaux de même amplitude et un déphasage minime. Si vous n'arrivez pas à avoir exactement la
même amplitude, essayez de corriger le signal numériquement, en effectuant une multiplication
avec une constante (en gardant le gain d'entrée à 1). Comment procède-t-on quand les opérations
arithmétiques se passent en virgule fixe ? Appelez votre nouveau programme pass0db.asm .
C. Une fois la correction réussie, modifiez la constante du programme pour amplifier le signal
d'entrée par 4. Appelez votre nouveau programme pass20db.asm . Regardez la sortie pour des
amplitudes d'entrée de 0.5V, 1V et 2V. A quel type de phénomène assiste-t-on ? Quelle est
l'amplitude maximale pour laquelle une amplification numérique par 4 marche encore ? Peut-on
corriger ce phénomène ?

TP-6
 TMS320C50 TLC32040
Timer fTOUT fMCLK
40MHz
Filtre
fCLK
CAN passe
fRINT fCLKR bande
RSR
fADC fSCF_R
DRR fFSR

Data Bus
fSCLK
DXR fFSX
fDAC fSCF_T
fXINT XSR fCLKX Filtre
CNA passe
bas
Figure 3. Propagation de l'horloge sur la carte C50

Exercice 3. Etude de cas - Utiliser FilterExpress

On veut réaliser un filtre passe bas avec les caractéristiques suivantes :
fréquence d'échantillonnage 16 kHz.
entre 0 et 5 kHz une atténuation de 0 dB, avec de variations de maximum 1 dB
à 5.5 kHz une atténuation de 80 dB.

A. Choisir les méthodes de synthèse qui répondent au cahier de charges, pour une précision infinie,
Q15, Q7 ou Q1 des coefficients. Remplir le tableau suivant en marquant chaque fois les
performances obtenues (réponse du filtre et nombre de coefficients générés). Quelle est la meilleure
précision à utiliser sur un C50 ? Quelle est la meilleure méthode de synthèse dans ces conditions ?
B. Quelles sont les modifications impliquées par le relâchement de la condition de variation dans la
bande passante de 1 dB à 10 dB ? Mais par le relâchement de l'atténuation de 80 dB à 60 dB.
Essayez l'ensemble des algorithmes proposés. Quel est le plus sensible ?
C. Passer à l'évaluation de la performance sur le DSP C50 qui travaille sur 16 bits en virgule fixe.
Choisir une position pour la virgule fixe et regardez comment les caractéristiques se détériorent.
Relancez la synthèse et notez combien des coefficients de plus sont nécessaires pour chaque
position possible de la virgule fixe. Quelle est sa meilleure position ?

Exercice 4. Suppression d'harmoniques

On règle le générateur de signal pour avoir un signal rectangulaire symétrique de 1 kHz et
d'amplitude crête à crête de 2V. Réalisez un filtre numérique à réponse impulsionnelle finie qui
laissera passer seulement la troisième harmonique du signal généré (celle à 3kHz). Choisir une
fréquence d'échantillonnage assez élevée (autour de 40 kHz) puis procéder à la synthèse du filtre
sous FilterExpress . L'atténuation de la fondamentale et des autres harmoniques sera d'au moins 60
dB.
A. Trouver un filtre de taille minimale pour chaque algorithme de synthèse proposé par
FilterExpress .
B. Parmi les filtres trouvées, choisir celui avec la taille minime et celui dont les caractéristiques
vous semblent les plus performantes et exécutez-le sur la carte DSK. Tracer quelques points de sa
caractéristique de transfert réelle (0, 0.1, 0.2 ... 0.9 et 1.0 de Fech/2). Quelle conclusion tirez-vous ?

Exercice 5. Détection DTMF

On veut implanter un filtre qui puisse faire la détection des signaux de type DTMF (touches
téléphoniques).
A. En sachant que le signal de chaque touche est obtenu par la superposition de 2 sinusoïdes de
fréquences différentes, parmi 8, réalisez l'implantation d'un filtre FIR pour la détection d'une seule
TP-7
touche 9 qui correspond aux fréquences f3 et f7. En simplifiant, la liste des fréquences DTMF est la
suivante :

f5 f6 f7 f8
1209 Hz 1336 Hz 1477 Hz 1633 Hz
f1 697 Hz 1 2 3 A
f2 770 Hz 4 5 6 B
f3 852 Hz 7 8 9 C
f4 941 Hz * 0 # D

On suppose donc qu'à l'entrée du filtre on a une superposition aléatoire de ces fréquences et du bruit
blanc. La décision de détection d'une touche se fait ensuite par l'intégration de l'énergie du signal à
la sortie du filtre demandé.
Conseils :
Choisir l'algorithme de synthèse le plus utile dans cette approche (la bande passante n'est pas
forcement plate !).
Utilisez la fonction Add du programme ArmaDsk pour superposer plusieurs filtres individuels.
Avant la synthèse, choisir convenablement la configuration du circuit convertisseur TLC 32040.
Pour tester, utilisez soit le générateur de signal BF soit une autre carte DSP en tant que
générateur en exécutant le programme DTMF (branché sur un autre PC ou juste sur un autre
port parallèle).
B. Peut-on utiliser le filtre passe bande du TLC 32040 dans cette application ?
C. Quelle serait la meilleure fréquence d'échantillonnage ?
D. Proposez quelques lignes de programme pour intégrer l'énergie du signal filtré et prendre la
décision de détection de la touche.

Exercice 6. Analyseur de spectre

Copiez l'ensemble du répertoire Analyser sur votre disque réseau. Compilez le projet contenu dans
la solution analyser.sln à l'aide du Visual 2008. Comprendre son fonctionnement: l'initialisation du
port série, le système d'interruption et la communication PC - DSP.
A. Quelle est la fréquence d'échantillonnage actuelle ?
B. Auxquelles fréquences correspondent-elles les amplitudes envoyées par la carte DSP ?
C. Regardez le spectre d'un signal sinusoïdal de 500 Hz et 1 volt d'amplitude. Est-ce que le résultat
correspond à la forme théorique du spectre ? Pourquoi ?
D. Modifiez de ±5% la fréquence pour obtenir les pics les plus étroits ou les plus larges possibles.
Quelles sont ces fréquences ? Pourquoi ?
E. Regardez un signal rectangulaire de fréquence comprise entre 500 Hz et 1 kHz. Variez lentement
sa fréquence et regardez le spectre affiché. Quelle est la différence de fonctionnement entre les
modes "FFT" et "Spectrogramme" ?
F. Diminuez à moitié la fréquence d'échantillonnage de la carte DSP (en modifiant le programme en
assembleur), assemblez et réexécutez le programme analyser.exe .
G. Faut-il modifier en même temps le programme en C++/MFC qui tourne sur PC ?

TP-8
Exercice 7. DM6437 : "Passe-tout" (loop-back) pour flux vidéo
Pour modifier, compiler et exécuter un projet DSP C6437 qui utilise l’approche registre (sans
DSP/BIOS) il faut suivre les étapes suivantes :
• Copier intégralement le répertoire du projet (par exemple
C:\CCStudio_v3.3\boards\evmdm6437_v2\tests\video_loopback) sur le disque z:, à
l’endroit de votre choix.
• Modifier le contenu du fichier linker.cmd en mettant le chemin complet pour les
bibliothèques concernées (par exemple pour rts64plus.lib mettre
C:\CCStudio_v3.3\C6000\cgtools\lib\rts64plus.lib ou pour evmdm6437bsl.lib mettre
C:\CCStudio_v3.3\boards\evmdm6437_v2\lib\evmdm6437bsl.lib).
• Dans le fichier – projet (*.pjt) remplacer tout chemin relatif d’inclusion avec un chemin
absolu. Garder en relatif les répertoires de sortie debug et release. Remplacer le chemin du
projet (ProjectDir) avec le chemin choisi sur z: .
• Connecter la carte DaVinci DM6437 au port USB du PC, connecter l'entrée et la sortie S-
Video puis alimenter la carte.
• Ouvrir Code Composer Studio, charger le projet (Project / Open …), recompiler entièrement
le projet (Rebuild All).
• Prendre le contrôle de la carte (Debug / Connect), charger le program compilé (*.out) en
(File / Load Program …) en version Debug ou Release, puis exécuter-le (Debug / Run).

A. Copier le projet video_loopback qui se trouve dans c:\CCStudio_v3.3\boards\tests chez vous.

Tester le passage du flux vidéo de la caméra vers l'écran. Analyser le code. Quelle est l'approche de
programmation ? Quand le programme se termine-t-il ? Quelle est la signification des switchs
utilisés par ce programme ? Choisir la configuration PAL et S-Video. Est-ce que la taille de l'image
est correcte ? Corriger la faute et tester à nouveau.

B. Copier le projet video_loopback dans un répertoire vloopback_opt et optimiser le code en

gardant que l'essentiel : l'initialisation, la lecture des switchs, l'initialisation du décodeur vidéo, du
front-end et du back-end vidéo. Faire en sorte que la position des switch ne modifie plus le mode
vidéo (il sera figé sur PAL et S-Video) mais qu'elle détermine la taille de l'image transférée entre
l'entrée et la sortie (100%, 50% vertical ou horizontal ou 25% de l'image d'entrée). Attention, le
changement de config ne doit pas se faire à chaque image, seulement s'il y a un changement d'état.

Exercice 8. Acquisition et traitement simple du flux vidéo à l'aide du noyau BIOS/DSP

Pour rajouter le support BIOS/DSP à un projet sans support il faut suivre les étapes suivantes :
• Aller dans File/New/DSP-BIOS Configuration/C6X et rajouter la configuration BIOS/DSP
"ti.platform.evmDM6437", activer seulement la RTDX (pour communiquer pendant
l'exécution du programme sur DSP), pas de Real-Time Analysis ni de TSK Manager.
Sauvegarder la sous le nom video.tcf puis rajoutez-le manuellement sous DSP/BIOS
Config.
• Rajouter la bibliothèque evmdm6437bsl.lib et remplacer l'ancien fichier de link
(linker.cmd) par celui généré automatiquement qui s'appelle videocfg.cmd . A ce point, un
Rebuild All doit marcher à nouveau.
• Rendre l'exécution de la fonction main() finie car le système DSP/BIOS s'initialise avant
mais s'exécute après elle ! Garder dans main() juste les initialisations nécessaires.
• Inclure tout au début de main() les fichiers d'entête de la couche DSP/BIOS : <std.h>,
<sys.h> <log.h> <c64.h> <clk.h> etc. ainsi que le fichier videocfg.h généré
automatiquement à partir de video.cfg .
• Créer un objet de LOG appelé LOG0, de 128 octets, dans le volet Instrumentation / LOG
puis utiliser la fonction LOG_printf(&LOG0,"format",variables) pour signaler le début
et la fin du main().
TP-9
 • Faire afficher le DSP-BIOS/MessageLog/LOG0 puis charger et exécuter votre programme.
L'affichage n'est visible qu'à l'arrêt (Halt) du programme.
• Pour rajouter un service d'interruption il faut choisir l'interruption matérielle, trouver son
numéro d'événement puis créer un objet sous Scheduling/HWI. Choisir une interruption
entre 4 et 15 (par ordre de priorité), éditer les propriétés, mettre le numéro d'événement dans
"interrupt selection number", le nom de la fonction - service, précédée de "_" dans
"function" et activer l'utilisation du dispatcher. Par exemple pour l'interruption du front-end
vidéo VENCINT : no. d'événement 32, fonction _VEncInt. Déclarer dans main() le
prototype de la fonction - service comme fonction C (extern "C") puis la définir.
• Activer les interruptions voulues dans main à l'aide de la fonction
C64_enableIER(C64_EINT#) ou # est le numéro de l'interruption (spécifier plusieurs par
OU bit à bit).
• Pour avoir des références temporelles on peut utiliser la fonction CLK_getltime qui
retourne le temps (par défaut en ms) depuis le début du programme.

Partir de la version simplifiée du projet précédent, activer l'utilisation du noyau BIOS/DSP et

rajouter les ressources nécessaires à l'activation des interruptions pour l'acquisition et la restitution
vidéo. Suivre les indications.

Utiliser les services d'interruption ainsi activés pour compter le nombre d'images et la fréquence du
flux vidéo. Modifier d'une manière synchrone (où ?) l'adresse mémoire de l'acquisition et de la
lecture vidéo pour réaliser un filtre "passe-tout" à retardement (par exemple 4 images).

Exercice 9. Acquisition et traitement du flux vidéo à l'aide des drivers DSP/TI

Utiliser le projet video_preview2 fourni. Analyser l'architecture du programme (threads,

interruptions etc.) et faire une liste des ressources utilisées.

• Quelles sont les marges de manœuvre pendant le traitement ?

• Quel est le format des images reçues ?
• Y a-t-il des erreurs dans l'exemple fourni ? Si oui, corrigez-les, sinon expliquez ...
• Procéder à un traitement simple sur les images acquises. Par exemple, inversez les couleurs
dans chaque image ou enlevez la composante chromatique. Comment traiter le plus
efficacement les pixels ?
• Peut-on apprécier la durée du traitement ?

TP-10
 compute.asm

********************************************************************************
* Program to stock take a fruit stall *
********************************************************************************
.mmregs
.ds 0f00h
result .word 0
blank .word 0,0,0,0,0,0 ; Leave reset of the row blank.
c_ap .word 5 ; Cost of the apples
c_pe .word 8 ; Cost of the pears
c_or .word 12 ; Cost of the Oranges
c_ba .word 10 ; Cost of the bananas
c_pi .word 21 ; Cost of the pineapples
c_le .word 15 ; Cost of the lemons
c_ki .word 40 ; Cost of the Kiwi fruit.

n_ap .word 12 ; Number of the apples

n_pe .word 6 ; Number of the pears
n_or .word 4 ; Number of the Oranges
n_ba .word 7 ; Number of the bananas
n_pi .word 2 ; Number of the pineapples
n_le .word 9 ; Number of the lemons
n_ki .word 3 ; Number of the Kiwi fruit.
.word 0,0,0,0,0,0,0 ; set to zero
.word 0,0,0,0,0,0,0

.ps 0a00h
again : ldp #result
lar ar0,#c_ap
zap
sacl result,0 ; Zero result
mac n_ap,*+ ; Multiply first 2 numbers
mac n_pe,*+ ; Multiply 2nd 2 numbers, add 1st product to total
sacl result,0 ; save result of 1st product
mac n_or,*+ ; Multiply 3rd numbers, add 2nd product to total
sacl result,0 ; save sum upto 2nd product
mac n_ba,*+ ; Multiply 4th numbers, add 3rd product to total
sacl result,0
mac n_pi,*+ ; Multiply 5th numbers
sacl result,0
mac n_le,*+ ; Multiply 6th numbers
sacl result,0
mac n_ki,*+ ; Multiply 7th numbers
sacl result,0
apac
sacl result,0
nop
nop
b again
nop
nop
nop
.end

pass.asm

.mmregs
.ds 0f00h
CMD_00 .word 0000h
CMD_11 .word 0003h
AIC_TARA .word 1224h; XX01 001X X010 0100b => TA=9, RA=9
AIC_TBRB .word 1E3Eh; X001 111X 0011 1110b => TB=15, RB=15
AIC_CTRL .word 0067h; XXXX XXXX 0010 0011b => Gain=*1,Syc,In,NoLoop,BPfilt

TP-11
 .ps 080Ah ; interrupt vectors :
rint: B RECEIVE ; 0A; Serial port receive interrupt RINT.
xint: B TRANSMIT ; 0C; Serial port transmit interrupt XINT.
.ps 0a00h ; main program
.entry ; entry point
SETC INTM ; Disable interrupts
LDP #0 ; Set data page pointer
OPL #0836h,PMST ; OR the status register
LACC #0
SAMM CWSR ; Set software wait state to 0
SAMM PDWSR ;
SETC SXM
SPLK #0022h,IMR ; Using XINT syn TX & RX
CALL AICINIT ; initialize AIC and enable interrupts
SPLK #0012h,IMR ; Select serial port receive interrupt
CLRC OVM
SPM 0
MAR *,ar0
LDP #0
CLRC INTM ; Enable interrupts
forever IDLE ; main loop
B forever
;************************** Receive ISR ***************************************
RECEIVE: LACC DRR,0
SACL DXR,0
RETE
;************************* Transmit ISR ***************************************
TRANSMIT: RETE
;********************* TLC32040 initialisation ********************************
AICINIT: SPLK #01h,PRD
SPLK #20h,TCR ; make a 10 mhz clock signal
MAR *,AR0
LACC #0008h ; Non continuous mode
SACL SPC ; FSX as input
LACC #00c8h ; 16 bit words
SACL SPC
LACC #080h ; Pulse AIC reset by setting it low
SACH DXR
SACL GREG
LAR AR0,#0FFFFh
RPT #10000 ; wait 10000 cycles
LACC *,0,AR0 ; (.5ms at 50ns)
SACH GREG
CLRC INTM
LMMR DXR,#CMD_00
IDLE
LMMR DXR,#CMD_11
IDLE
LMMR DXR,#AIC_TARA
IDLE
LMMR DXR,#CMD_11
IDLE
LMMR DXR,#AIC_TBRB
IDLE
LMMR DXR,#CMD_11
IDLE
LMMR DXR,#AIC_CTRL
IDLE
LMMR DXR,#CMD_00
IDLE
SETC INTM
RET

.end

TP-12
 Résumé des instructions TMS320C5x
(chaque instruction est détaillée par la séquence des micro-opérations associées)
Symbole Valeurs possibles Signification Symbole Valeurs possibles Signification
b =[0..1] =IREG(7) lkU =[0..65535] =IREG2(15:0)
i =[1..2] =IREG(12) lkS =[-32768..32767] =IREG2(15:0)
dma =[0..127] =IREG(6:0) pma =[0..65535] =IREG2(15:0)
n ou m =[0..7] =IREG(2:0) port =[0..65535] =IREG2(15:0)
k =[0..255] =IREG(7:0) bitpos =[0..15] =IREG(11:8)
kdp =[0..511] =IREG(8:0) intno =[0..31] =IREG(4:0)
shift =[0..15] =IREG(3:0)ou(11:8)
ind = * f(ind,INDX)=AR[ARP]
= *+ f(ind,INDX)=AR[ARP]+1
= *- f(ind,INDX)=AR[ARP]-1
= *0+ f(ind,INDX)=AR[ARP]+INDX
= *0- f(ind,INDX)=AR[ARP]-INDX
= *BR0+ f(ind,INDX)=AR[ARP] bit_reversed_+ INDX
= *BR0- f(ind,INDX)=AR[ARP] bit_reversed_- INDX
conds = une ou plusieurs conditions liées par ET logique
il est interdit de tester TC et BIO en même temps
il y a des combinaisons sans aucun sens (ex. GT,LT)
UNC, pas de condition NC, C = 0
EQ, ACC = 0 C, C = 1
NEQ, ACC ≠ 0 NOV, OV = 0
LT, ACC < 0 OV, OV = 1
LEQ, ACC ≤ 0 NTC, TC = 0
GT, ACC > 0 TC, TC = 1
GEQ, ACC ≥ 0 BIO ~BIO = niveau bas
ctrlbit = {C, CNF, HM, INTM, OVM, SXM, TC, XF}
oper = 00 ==
= 01 <
= 10 >
= 11 ≠
pmval = 00 shift(PREGS,PM)=PREGS
= 01 shift(PREGS,PM)=PREGS<<1
= 10 shift(PREGS,PM)=PREGS<<4
= 11 shift(PREGS,PM)=PREGS>>6
[] indique soit le contenu d’une adresse (si à l’intérieur il y a une adresse)
soit une partie optionnelle (comme l'opérande d’une instruction ou d'une micro-opération)
RPT il est interdit de repeter l’instruction en question
Signification des indices inférieurs:
S valeur signée
U valeur non-signée
SXM valeur déterminée par le bit SXM (==0/1 : non-signée/signée)
P adresse dans l'espace programme
D adresse dans l'espace données
D* adresse dans l'espace données sauf les MMR
Sigle Nom Signification Taille Dupliqué Adr.mem.
A Address Bus Bus d’adresses 16 bits
ACC Accumulator Accumulateur 32 bits OUI
ACCB Accumulator buffer Accumulateur-Buffer 32 bits OUI
AR0..7 Auxiliary reg. Banc de reg. auxiliaires 8x16 bits 16-27
ARB ST1(15:13) Garde l'ancienne valeur de ARP 3 bits
ARP ST0(15:13) Pointeur vers le banc AR 3 bits
ARCR AR compare Garde une valeur à comparer avec AR 16 bits OUI 25
BMAR Block move addr.reg. Adresse de mouvement de block 16 bits 31
BRCR Block rep. count reg. Compteur de boucle: block d'instr. 16 bits 9
CBSRx Circ.start buffer reg. Début du buffer circulaire x (1 ou 2) 16 bits 26,28
CBERx Circ.end buffer reg. Fin du buffer circulaire x (1 ou 2) 16 bits 27,29
D Data Bus Bus de données 16 bits
DBMR Dynamic bit manip.reg. Masque dynamique pour opér. logiques 16 bits 15
DP ST0(8:0) Page de l'espace données [0..511] 9 bits
INDX Index register Incrément pour le AR actuel 16 bits OUI 24
INTM ST0(9) Masque toutes les interruptions (à 1) 1 bit
IPTR PMST(15:11) *211=debut de la table des vect.d'int. 5 bits
IREG Instruction reg. Garde l'instruction à exécuter 16 bits
IREG2 Instruction reg. Garde le deuxième mot-instruction 16 bits
MCS Microcall stack Sauvegarde de PFC 16 bits
PAER Progr.addr. end reg. Fin du block d'instructions 16 bits 11
PASR Progr.addr.start reg. Début du block d'instructions 16 bits 10
PC Program counter Pointeur de programme 16 bits
PM ST1(1:0) Détermine le shift de PREG 2 bits
PMST Proc.mode status reg. Etat du processeur 16 bits OUI 7
PFC Prefetch counter Compteur de pré-extraction 16 bits
PREG Product register Résultat d'une multiplication 32 bits OUI
RPTC Repeat counter reg. Compteur de boucle: une instruction 16 bits 8
TP-13
ST0 Status register 0 Registre d'état 0 16 bits OUI\INTM
ST1 Status register 1 Registre d'état 1 16 bits OUI\XF
SXM ST1(10) Active l'extension de signe 1 bit
Stack Stack(1..8) Pile de 8 registres 8x16 bits
TOS Top of stack Sommet de la pile ou Stack(1) 16 bits
TC ST1(11) Bit de test ou contrôle 1 bit
TREG0 Temporary reg. 0 Garde le multiplicande 16 bits OUI 12
TREG1 Temporary reg. 1 Garde une amplitude de shift 5 bits OUI 13
TERG2 Temporary reg. 2 Garde une adresse d'un bit 4 bits OUI 14
XF ST1(4) Niveau logique de la sortie XF 1 bit
Nom Paramètres Signification
ABS PC PC+1; ACC |ACC|; C 0
ADCB PC PC+1; ACC ACC+ACCB+C
ADD dma[,shift] PC PC+1; ACCSXM ACCSXM+[DPdma]SXM*2shift
ADD ind[,shift][,ARn] PC PC+1; ACCSXM ACCSXM+[AR[ARP]]SXM*2shift; AR[ARP]=f(ind,INDX);
[ARB ARP; ARP n;]
ADD #k PC PC+1; ACCSXM ACCSXM+kU RPT
ADD #lk[,shift] PC PC+2; ACCSXM ACCSXM+lkS*2shift RPT
ADDB PC PC+1; ACC ACC+ACCB
ADDC dma PC PC+1; ACC ACCU+[DPdma]U+C
ADDC ind[,ARn] PC PC+1; ACC ACCU+[AR[ARP]]U+C; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n]
ADDS dma PC PC+1; ACC ACCU+[DPdma]U
ADDS ind[,ARn] PC PC+1; ACC ACCU+[AR[ARP]]U; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n]
ADDT dma PC PC+1; ACC ACCSXM+[DPdma]SXM*2TREG1(3:0)
ADDT ind[,ARn] PC PC+1; ACC ACCSXM+[AR[ARP]]SXM*2TREG1(3:0); AR[ARP]=f(ind,INDX);
[ARB ARP; ARP n;]
ADRK #k PC PC+1; AR[ARP]U AR[ARP]U+kU RPT
AND dma PC PC+1; ACC(15:0) ACC(15:0) AND [DPdma]; ACC(31:16) 0
AND ind[,ARn] PC PC+1; ACC(15:0) ACC(15:0) AND [AR[ARP]] ; ACC(31:16) 0;
AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
AND #lk[,shift] PC PC+2; ACC ACC AND lkU*2shift RPT
ANDB PC PC+1; ACC ACC AND ACCB
APAC PC PC+1; ACC ACC+shift(PREGS,PM);
APL dma PC PC+1; [DPdma] [DPdma] AND DBMR
APL #lk,dma PC PC+2; [DPdma] [DPdma] AND lk
APL ind[,ARn] PC PC+1; [AR[ARP]] [AR[ARP]] AND DBMR; AR[ARP]=f(ind,INDX);
[ARB ARP; ARP n;]
APL #lk,ind[,ARn] PC PC+2; [AR[ARP]] [AR[ARP]] AND lk; AR[ARP]=f(ind,INDX);
[ARB ARP; ARP n;]
B pma[,ind[,ARn]] PC pma; [AR[ARP]=f(ind,INDX); [ARB ARP; ARP n]] RPT
BACC PC ACC(15:0) RPT
BACCD exécute les 2 WORDs suivants (1 ou 2 instructions) puis BACC RPT
BANZ pma[,ind[,Arn]] si AR[ARP]≠0 alors PC pma sinon PC PC+2;
(par defaut ind=*-) [AR[ARP]=f(ind,INDX); [ARB ARP; ARP n]] RPT
BANZD pma[,ind[,Arn]] exécute les 2 WORDs suivants puis BANZ RPT
BCND pma,conds si conds alors PC pma sinon PC PC+2; RPT
BCNDD pma,conds exécute les 2 WORDs suivants (1 ou 2 instructions)puis BCND RPT
BD pma[,ind[,ARn]] exécute les 2 WORDs suivants (1 ou 2 instructions)puis B RPT
BIT dma,bitpos PC PC+1; TC [DPdma](15-bitpos)
BIT int,bitpos[,ARn] PC PC+1; TC [AR[ARP]](15-bitpos); [ARB ARP; ARP n]
BITT dma PC PC+1; TC [DPdma](15-TREG2(3:0))
BITT int[,ARn] PC PC+1; TC [AR[ARP]](15-TREG2(3:0)); [ARB ARP; ARP n]
BLDD BMAR,dma PC PC+1; MCS PFC; PFC BMAR; [DPdma]D [PFC]D; PFC MCS
BLDD dma,BMAR PC PC+1; MCS PFC; PFC Dpdma; [BMAR]D [PFC]D; PFC MCS
BLDD BMAR,ind[,ARn] PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
[AR[ARP]]D [PFC]D*; PFC PFC+1;
AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
fin RPTC 0; PFC MCS;
BLDD ind[,ARn],BMAR PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
[PFC]D* [AR[ARP]]D; PFC PFC+1;
AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
fin RPTC 0; PFC MCS;
BLDD #lk,dma PC PC+2; MCS PFC; PFC lk; [DPdma]D [PFC]D*; PFC MCS
BLDD dma,#lk PC PC+2; MCS PFC; PFC DPdma; [lk]D [PFC]D*; PFC MCS
BLDD #lk,ind[,ARn] PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire
[AR[ARP]]D [PFC]D*; PFC PFC+1;
AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
fin RPTC 0; PFC MCS;
BLDD ind[,ARn],#lk PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire
[PFC]D* [AR[ARP]]D; PFC PFC+1;
AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
fin RPTC 0; PFC MCS;
BLDP dma PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
[PFC]P [DPdma]D; PFC PFC+1;
TP-14
 fin RPTC 0; PFC MCS
BLDP ind[,ARn] PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
[PFC]P [AR[ARP]]D; AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
PFC PFC+1;
fin RPTC 0; PFC MCS;
BLPD BMAR,dma PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
[DPdma]D [PFC]P; PFC PFC+1;
fin RPTC 0; PFC MCS;
BLPD BMAR,ind[,ARn] PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
[AR[ARP]]D [PFC]P; AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
PFC PFC+1;
fin RPTC 0; PFC MCS;
BLPD #lk,dma PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire
[DPdma]D [PFC]P; PFC PFC+1;
fin RPTC 0; PFC MCS;
BLPD #lk,ind[,ARn] PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire
[AR[ARP]]D [PFC]P; AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
PFC PFC+1;
fin RPTC 0; PFC MCS;
BSAR shift PC PC+1; ACC ACCSXM>>shift
CALA TOS PC+1; PC ACC(15:0) RPT
CALAD exécute les 2 WORDs suivants puis CALA avec TOS PC+3 RPT
CALL pma[,ind[,Arn]] TOS PC+2; PC pma; AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;] RPT
CALLD pma[,ind[,Arn]] exécute les 2 WORDs suivants puis CALL avec TOS PC+4 RPT
CC pma conds si conds alors TOS PC+2; PC pma sinon PC PC+2 RPT
CCD pma conds exécute les 2 WORDs suivants puis CC avec TOS PC+4 RPT
CLRC ctrlbit PC PC+1; ctrlbit 0
CMPL PC PC+1; ACC ACC
CMPR oper PC PC+1; TC AR[ARP]U oper ARCRU
CPL dma PC PC+1; TC [DPdma]==DBMR
CPL #lk,dma PC PC+2; TC [DPdma]==lk
CPL ind[,ARn] PC PC+1; TC [AR[ARP]]==DBMR; AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
CPL #lk,ind[,ARn] PC PC+2; TC [AR[ARP]]==lk; AR[ARP]=f(ind,INDX); [ARB ARP; ARP n;]
CRGT PC PC+1; C ACCS≥ACCBS; ACC ACCB max(ACCS,ACCBS)
CRLT PC PC+1; C ACCS<ACCBS; ACC ACCB min(ACCS,ACCBS)
DMOV dma PC PC+1; [DPdma+1] [DPdma]
DMOV ind[,ARn] PC PC+1; [AR[ARP]+1] [AR[ARP]];AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
EXAR PC PC+1; ACCB ↔ ACC
IDLE PC PC+1; attend une interruption
IDLE2 PC PC+1; power-down et attend une interruption
IN dma,port PC PC+2;
pour RPTC+1 fois faire
A(15:0) port; [DPdma] D(15:0); port port+1;
fin RPTC 0
IN ind,port[,ARn] PC PC+2;
pour RPTC+1 fois faire
A(15:0) port; [AR[ARP]] D(15:0); port port+1;
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
fin RPTC 0
INTR intno TOS PC+1; Stack(1..7) Stack(2..8); PC [IPTR*211+intno*2] RPT
LACB PC PC+1; ACC ACCB
LACC dma[,shift] PC PC+1; ACC [DPdma]SXM*2shift
LACC ind[,shift[,ARn]] PC PC+1; ACC [AR[ARP]]SXM*2shift; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LACC #lk[,shift] PC PC+2; ACC lkSXM*2shift
LACL dma PC PC+1; ACC(15:0) [DPdma]U; ACC(31:16) 0
LACL ind[,ARn] PC PC+1; ACC(15:0) [AR[ARP]]U; ACC(31:16) 0;
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
LACL #k PC PC+1; ACC(7:0) kU; ACC(31:8) 0 RPT
LACT dma PC PC+1; ACC [DPdma]SXM*2TREG1(3:0)
LACT ind[,ARn] PC PC+1;ACC [AR[ARP]]SXM*2TREG1(3:0);AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LAMM dma PC PC+1; ACC(15:0) [dma]; ACC(31:16) 0
LAMM ind[,ARn] PC PC+1; ACC(15:0) [AR[ARP](6:0)]; ACC(31:16) 0;
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
LAR ARm,dma PC PC+1; ARm [DPdma]
LAR ARm,ind[,ARn] PC PC+1; ARm [AR[ARP]]; si ARP≠m alors AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
LAR ARm,#k PC PC+1; ARm k RPT
LAR ARm,#lk PC PC+2; ARm lkU RPT
LDP dma PC PC+1; DP [DPdma](8:0)
LDP ind[,ARn] PC PC+1; DP [AR[ARP]](8:0); AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LDP #kdp PC PC+1; DP kdp RPT
LMMR dma,#lk PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire
[dma] [PFC]; PFC PFC+1;
TP-15
 fin RPTC 0; PFC MCS
LMMR ind,#lk[,ARn] PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire
[AR[ARP](6:0)] [PFC]; PFC PFC+1;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
fin RPTC 0; PFC MCS
LPH dma PC PC+1; PREG(31:16) [DPdma];
LPH ind[,ARn] PC PC+1; PREG(31:16) [AR[ARP]]; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LST #b,dma PC PC+1; STb [DPdma]; ARP [DPdma](13:15); INTM inchangé
LST #b,ind[,ARn] PC PC+1; STb [AR[ARP]]; ARP [AR[ARP]](13:15); INTM inchangé;
AR[ARP]=f(ind,INDX);
LT dma PC PC+1; TREG0 [DPdma]; si TRM==0 alors TREG2 TREG1 TREG0;
LT ind[,ARn] PC PC+1; TREG0 [AR[ARP]]; si TRM==0 alors TREG2 TREG1 TREG0;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LTA dma PC PC+1; TREG0 [DPdma]; ACC ACC+shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
LTA ind[,ARn] PC PC+1; TREG0 [AR[ARP]]; ACC ACC+shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LTD dma PC PC+1; TREG0 [DPdma+1] [DPdma]; ACC ACC+shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
LTD ind[,ARn] PC PC+1; TREG0 [AR[ARP]+1] [AR[ARP]]; ACC ACC+shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LTP dma PC PC+1; TREG0 [DPdma]; ACC shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
LTP ind[,ARn] PC PC+1; TREG0 [AR[ARP]]; ACC shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
LTS dma PC PC+1; TREG0 [DPdma]; ACC ACC-shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
LTS ind[,ARn] PC PC+1; TREG0 [AR[ARP]]; ACC ACC-shift(PREGS,PM);
si TRM==0 alors TREG2 TREG1 TREG0;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
MAC pma,dma PC PC+2; MCS PFC; PFC pma;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [DPdma]D;
PREG TREG0*[PFC]P; PFC PFC+1;
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MAC pma, ind[,ARn] PC PC+2; MCS PFC; PFC pma;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [AR[ARP]]D; PREG TREG0*[PFC]P;
PFC PFC+1; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MACD pma,dma PC PC+2; MCS PFC; PFC pma;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [DPdma+1]D [DPdma]D;
PREG TREG0*[PFC]P; PFC PFC+1;
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MACD pma, ind[,ARn] PC PC+2; MCS PFC; PFC pma;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [AR[ARP]+1]D [AR[ARP]]D;
PREG TREG0*[PFC]P; PFC PFC+1; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MADD dma PC PC+2; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [DPdma+1]D [DPdma]D;
PREG TREG0*[PFC]P; PFC PFC+1;
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MADD ind[,ARn] PC PC+2; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [AR[ARP]+1]D [AR[ARP]]D;
PREG TREG0*[PFC]P; PFC PFC+1; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MADS dma PC PC+1; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [DPdma]D;
PREG TREG0*[PFC]P; PFC PFC+1;
fin
RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MADS ind[,ARn] PC PC+2; MCS PFC; PFC BMAR;
pour RPTC+1 fois faire
ACC ACC+shift(PREGS,PM); TREG0 [AR[ARP]]D;
PREG TREG0*[PFC]P; PFC PFC+1; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
fin RPTC 0; PFC MCS; si TRM==0 alors TREG2 TREG1 TREG0;
MAR dma PC PC+1;
MAR ind[,ARn] PC PC+1; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
MPY dma PC PC+1; PREG TREG0*[DPdma]
MPY ind,[,ARn] PC PC+1; PREG TREG0*[AR[ARP]]; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]

TP-16
MPY #k PC PC+1; PREG TREG0*kS RPT
MPY #lk PC PC+2; PREG TREG0*lkS RPT
MPYA dma PC PC+1; ACC ACC+shift(PREGS,PM); PREG TREG0*[DPdma]
MPYA ind,[,ARn] PC PC+1; ACC ACC+shift(PREGS,PM); PREG TREG0*[AR[ARP]];
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
MPYS dma PC PC+1; ACC ACC-shift(PREGS,PM); PREG TREG0*[DPdma]
MPYS ind,[,ARn] PC PC+1; ACC ACC-shift(PREGS,PM); PREG TREG0*[AR[ARP]];
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
MPYU dma PC PC+1; PREG TREG0U*[DPdma]U
MPYU ind,[,ARn] PC PC+1; PREG TREG0U*[AR[ARP]]U;AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
NEG PC PC+1; ACC -ACCS; C ACC==0;
NMI PC PC+1; Stack(1..7) Stack(2..8); PC 24h; INTM 1;
NOP PC PC+1;
NORM ind PC PC+1; si ACC(31)==ACC(30) AND ACC≠0
alors TC 0; ACC 2*ACCS; AR[ARP]=f(ind,INDX); sinon TC 1
OPL dma PC PC+1; [DPdma] [DPdma] OR DBMR
OPL #lk,dma PC PC+2; [DPdma] [DPdma] OR lk
OPL ind[,ARn] PC PC+1; [AR[ARP]] [AR[ARP]] OR DBMR; AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
OPL #lk,ind[,ARn] PC PC+2; [AR[ARP]] [AR[ARP]] OR lk; AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
OR dma PC PC+1; ACC(15:0) [DPdma] OR ACC(15:0);
OR ind[,ARn] PC PC+1; ACC(15:0) [AR[ARP]] OR ACC(15:0); AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
OR #lk[,shift] PC PC+2; ACC lkU*2shift OR ACC; RPT
ORB PC PC+1; ACC ACC OR ACCB
OUT dma,port PC PC+2;
pour RPTC+1 fois faire
port A(15:0); D(15:0) [DPdma]; port port+1;
fin RPTC 0;
OUT ind,port[,ARn] PC PC+2;
pour RPTC+1 fois faire
port A(15:0); D(15:0) [AR[ARP]]; port port+1;
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
fin RPTC 0;
PAC PC PC+1; ACC shift(PREGS,PM);
POP PC PC+1; ACC(15:0) TOS; ACC(31:16) 0; Stack(1..7) Stack(2..8);
POPD dma PC PC+1; [DPdma] TOS; Stack(1..7) Stack(2..8);
POPD ind[,ARn] PC PC+1; [AR[ARP]] TOS; Stack(1..7) Stack(2..8);
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
PSHD dma PC PC+1; Stack(2..8) Stack(1..7); TOS [DPdma];
PSHD ind[,ARn] PC PC+1; Stack(2..8) Stack(1..7); TOS [AR[ARP]];
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
PUSH PC PC+1; Stack(2..8) Stack(1..7); TOS ACC(15:0); RPT
RET PC TOS; Stack(1..7) Stack(2..8); RPT
RETC conds si conds alors PC TOS;Stack(1..7) Stack(2..8); sinon PC PC+1; RPT
RETCD conds exécute les 2 WORDs suivants puis RETC RPT
RETD exécute les 2 WORDs suivants puis RET RPT
RETE INTM 0; puis RETI RPT
RETI PC TOS; Stack(1..7) Stack(2..8); restaure les regs. dupliqués RPT
ROL PC PC+1; rotation_à_gauche(C,ACC);
ROLB PC PC+1; rotation_à_gauche(C,ACC,ACCB);
ROR PC PC+1; rotation_à_droite(C,ACC);
RORB PC PC+1; rotation_à_droite(C,ACC,ACCB);
RPT dma PC PC+1; RPTC [DPdma]; réitérer RPTC fois la prochaine instruction
RPT ind[,ARn] PC PC+1; RPTC [AR[ARP]]; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
réitérer RPTC fois la prochaine instruction RPT
RPT #k PC PC+1; RPTC k; réitérer RPTC fois la prochaine instruction RPT
RPT #lk PC PC+2; RPTC lkU; réitérer RPTC fois la prochaine instruction RPT
RPTB pma BRAF 1; PASR PC+2; PAER pma RPT
RPTZ #lk ACC 0; PREG 0; puis exécute RTP RPT
SACB PC PC+1; ACCB ACC;
SACH dma[,shift] PC PC+1; [DPdma] ACC*2shift(31:16);
SACH ind[,shift[,ARn]] PC PC+1; [AR[ARP]] ACC*2shift(31:16);
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SACL dma[,shift] PC PC+1; [DPdma] ACC(15:0)*2shift;
SACL ind[,shift[,ARn]] PC PC+1; [AR[ARP]] ACC(15:0)*2shift;
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SAMM dma PC PC+1; [dma] ACC(15:0)
SAMM ind[,ARn] PC PC+1; [AR[ARP](6:0)] ACC(15:0);
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SAR ARm,dma PC PC+1; [DPdma] ARm
SAR ARm,ind[,ARn] PC PC+1; [AR[ARP]] ARm; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SATH PC PC+1; ACC ACCSXM>>(TREG1(4)*16);
SATL PC PC+1; ACC ACCSXM>>TREG1(3:0);
SBBB PC PC+1; ACC ACC-ACCB-NOT(C)
SBRK #k PC PC+1; AR[ARP] AR[ARP]-k; RPT
SETC ctrlbit PC PC+1; ctrlbit 1
SFL PC PC+1; (C,ACC) (C,ACC)<<1;
TP-17
SFLB PC PC+1; (C,ACC,ACCB) (C,ACC,ACCB)<<1;
SFR PC PC+1; (ACC,C) (ACC,C)SXM>>1;
SFRB PC PC+1; (ACC,ACCB,C) (ACC,ACCB,C)SXM>>1;
SMMR dma,#lk PC PC+2; MCS PFC; PFC lk;
pour RPTC+1 fois faire [PFC] [dma]; PFC PFC+1; dma dma+1; fin
RPTC 0; PFC MCS
SMMR ind,#lk[,ARn] PC PC+2; MCS PFC; PFC lk; dma=AR[ARP](6:0);
pour RPTC+1 fois faire [PFC] [dma]; PFC PFC+1; dma dma+1;
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;] fin
RPTC 0; PFC MCS
SPAC PC PC+1; ACC ACC-shift(PREGS,PM);
SPH dma PC PC+1; [DPdma] shift(PREGS,PM)(31:16);
SPH ind[,ARn] PC PC+1; [AR[ARP]] shift(PREGS,PM)(31:16);
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SPL dma PC PC+1; [DPdma] shift(PREGS,PM)(15:0);
SPL ind[,ARn] PC PC+1; [AR[ARP]] shift(PREGS,PM)(15:0);
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SPLK #lk,dma PC PC+2; [DPdma] lk; RPT
SPLK #lk,ind[,ARn] PC PC+2; [AR[ARP]] lk; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;] RPT
SPM pmval PC PC+1; PM pmval; RPT
SQRA dma PC PC+1; ACC ACC+shift(PREGS,PM); TREG0 [DPdma];PREG [DPdma]*[DPdma]
si TRM==0 alors TREG2 TREG1 TREG0;
SQRA ind[,ARn] PC PC+1; ACC ACC+shift(PREGS,PM); TREG0 [AR[ARP]];
PREG [AR[ARP]]*[AR[ARP]]; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
si TRM==0 alors TREG2 TREG1 TREG0;
SQRS dma PC PC+1; ACC ACC-shift(PREGS,PM); TREG0 [DPdma];PREG [DPdma]*[DPdma]
si TRM==0 alors TREG2 TREG1 TREG0;
SQRS ind[,ARn] PC PC+1; ACC ACC-shift(PREGS,PM); TREG0 [AR[ARP]];
PREG [AR[ARP]]*[AR[ARP]]; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
si TRM==0 alors TREG2 TREG1 TREG0;
SST #b,dma PC PC+1; [dma] STb;
SST #b,ind[,ARn] PC PC+1; [AR[ARP]] STb; AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
SUB dma[,shift] PC PC+1; ACCSXM ACCSXM-[DPdma]SXM*2shift
SUB ind[,shift][,ARn] PC PC+1; ACCSXM ACCSXM-[AR[ARP]]SXM*2shift; AR[ARP]=f(ind,INDX);
[ARB ARP; ARP n;]
SUB #k PC PC+1; ACCSXM ACCSXM-kU RPT
SUB #lk[,shift] PC PC+2; ACCSXM ACCSXM-lkS*2shift RPT
SUBB dma PC PC+1; ACC ACCU-[DPdma]U-NOT(C)
SUBB ind[,ARn] PC PC+1; ACC ACCU-[AR[ARP]]U-NOT(C);
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
SUBC dma PC PC+1; si ACCU≥[DPdma]<<15 alors ACC ACC*2-([DPdma]<<16)+1
sinon ACC ACC*2;
SUBC ind[,ARn] PC PC+1; si ACCU≥[AR[ARP]]<<15 alors ACC ACC*2-([AR[ARP]]<<16)+1
sinon ACC ACC*2; fin AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
SUBS dma PC PC+1; ACC ACCU-[DPdma]U
SUBS ind[,ARn] PC PC+1; ACC ACCU-[AR[ARP]]U; AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
SUBT dma PC PC+1; ACC ACCSXM-[DPdma]SXM*2TREG1(3:0)
SUBT ind[,ARn] PC PC+1; ACC ACCSXM-[AR[ARP]]SXM*2TREG1(3:0); AR[ARP]=f(ind,INDX);
[ARB ARP; ARP n;]
TBLR dma PC PC+1; MCS PFC; PFC ACC(15:0); [DPdma]D [PFC]P;
si RPTC≠0 alors PFC PFC+1; RPTC RPTC-1; fin PFC MCS;
TBLR ind[,ARn] PC PC+1; MCS PFC; PFC ACC(15:0); [AR[ARP]]D [PFC]P;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
si RPTC≠0 alors PFC PFC+1; RPTC RPTC-1; fin PFC MCS;
TBLW dma PC PC+1; MCS PFC; PFC ACC(15:0); [PFC]P [DPdma]D;
si RPTC≠0 alors PFC PFC+1; RPTC RPTC-1; fin PFC MCS;
TBLW ind[,ARn] PC PC+1; MCS PFC; PFC ACC(15:0); [PFC]P [AR[ARP]]D;
AR[ARP]=f(ind,INDX);[ARB ARP;ARP n;]
si RPTC≠0 alors PFC PFC+1; RPTC RPTC-1; fin PFC MCS;
TRAP TOS PC+1; Stack(1..7) Stack(2..8); PC 22h RPT
XC i,conds si conds alors exécuter i WORDs suivants sinon exécuter i NOP RPT
XOR dma PC PC+1; ACC(15:0) [DPdma] XOR ACC(15:0);
XOR ind[,ARn] PC PC+1; ACC(15:0) [AR[ARP]] XOR ACC(15:0); AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
XOR #lk[,shift] PC PC+2; ACC lkU*2shift XOR ACC; RPT
XORB PC PC+1; ACC ACC XOR ACCB
XPL dma PC PC+1; [DPdma] [DPdma] XOR DBMR
XPL #lk,dma PC PC+2; [DPdma] [DPdma] XOR lk
XPL ind[,ARn] PC PC+1; [AR[ARP]] [AR[ARP]] XOR DBMR; AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
XPL #lk,ind[,ARn] PC PC+2; [AR[ARP]] [AR[ARP]] XOR lk; AR[ARP]=f(ind,INDX);
[ARB ARP;ARP n;]
ZALR dma PC PC+1; ACC(15:0) 8000h; ACC(31:16) [DPdma]
ZALR ind[,ARn] PC PC+1; ACC(15:0) 8000h; ACC(31:16) [AR[ARP]];
AR[ARP]=f(ind,INDX); [ARB ARP;ARP n;]
ZAP PC PC+1; ACC 0; PREG 0;
ZPR PC PC+1; PREG 0;

TP-18