STC89C51RC ETCvf

Machine Translated by Google
MCU série STC89Cxx

MCU série STC89LExx
Fiche de données
1
CONTENU
Chapitre 1 Introduction............................................... .......................4 1.1
Caractéristiques.......................... .................................................................. .......................
4 1.2 Schéma fonctionnel ....................... .................................................................. .......
5 1.3 Configurations des broches .................................. ...................................... 6 1.4
Descriptions des broches . .................................................................. ........................
7 1.5 Dessins du paquet de broches............. .................................................................. ..........
8 Chapitre 2 GESTION DE L'ÉNERGIE, RÉINITIALISATION ............ 11 2.1 Gestion
de l'alimentation ..... .................................................................. ................... 11
2.1.1 Mode veille.................................................. .................................................................. ......11
2.1.2 Mode mise hors tension (PD) ............................................ ...................................12
2.2 Commande RESET ........ .................................................................. ...................... 16
2.2.1 Réinitialiser la broche ....................................... .................................................................. .......16
2.2.2 Réinitialisation à la mise sous tension (POR) ............................... ......................................................17
2.2.3 Chronomètre de surveillance.................................................. ........................................17
2.2.4 RÉINITIALISATION DU Logiciel.. .................................................................. .....................................20
2.2.5 Délai de réinitialisation à la mise sous tension du
STC MCU Limitée

MAX810.. .................................................................. ............20 Chapitre 3 Organisation de la
mémoire.................................. .....................21 3.1 Mémoire du
programme .......................... .................................................................. ... 21 3.2 Mémoire de
données.................................. ...................................... 22 3.2.1 Sur puce RAM du bloc
notes ............................................ ........................22 3.2.2 RAM
auxiliaire ..................... .................................................................. ......................22 3.2.3 RAM externe.................................. ...................
3.2.4 Registre de fonctions spéciales pour la RAM.................................................. ............23
Chapitre 4 Configurations des ports d'E/S configurables .................. ... 29 4.1 E/S
quasibidirectionnelles............................................... .................................. 29 4.2
Sortie pushpull.............. .................................................................. ................... 30
4.3 Mode d'entrée uniquement .......................... .................................................................. ......
30 4.4 Sortie à drain ouvert.................................................. ......................................
30 Chapitre 5 Système d'instructions....... ..................................................................
.31 5.1 Registres de fonctions spéciales............................................ ..................... 31
5.2 Modes d'adressage.......................... .................................................................. ..
36 5.3 Résumé du jeu d'instructions .............................................. ....................... 37
5.4 Définitions des instructions.......................... ...................................................... 41
2
Chapitre 6 Interruption............................................................ ........................78

6.1 Structure des interruptions........ .................................................................. ......
79 6.2 Registre d'interruption ....................................... ......................................
80 6.3 Priorités d'interruption....... .................................................................. ..................
84 6.4 Comment les interruptions sont gérées.......................... ..................................
84 6.5 Interruptions externes.............. .................................................................. ............
85 6.6 Temps de réponse.................................. ..................................................................
88 Chapitre 7 Minuterie/Compteur............................................ ........89 7.1 Mode
de fonctionnement du minuteur/compteur 0............................... ...................... 92
7.2 Mode de fonctionnement du minuteur/compteur 1............... ...................... 95
7.3 Mode de fonctionnement du minuteur/compteur 2.......... ...................................
100 Chapitre 8 UART avec fonction améliorée ....... ......................109 8.1 Mode
STC MCU Limitée

de fonctionnement UART.............. .................................................. 112 8.2 Cadre
Détection d'erreur................................................ .................... 118 8.3
Communications multiprocesseurs .......................... ........................ 118 8.4
Reconnaissance automatique d'adresses........ ...................................... 120 8.5
Tarifs Buad........ .................................................................. ...................... 122
Chapitre 9 IAP / EEPROM................. ......................................123 9.1 Registre de
contrôle IAP/ISP .................................................................. ............ 123 9.2
Tableau de sélection EEPROM interne de la série STC89xx ............... 125
9.3 Introduction au programme en langage assembleur IAP/EEPROM....... 126
9.4 Fonctionnement de la démonstration EEPROM interne par langage
assembleur..... 128 Annexe A : Programmation en langage
assembleur............. ........132 Annexe B : Programmation du 8051
C ............................... ............154 Annexe C : Tableau de sélection de la série STC89xx............................ ..164
3
Chapitre 1 Introduction
La série STC89xx, produite par STC MCU Limited, est un microcontrôleur monopuce 8 bits avec un jeu d'instructions entièrement compatible
avec le microcontrôleur de la série 80C51 de norme industrielle. Il y a une mémoire flash de 64 Ko intégrée pour le programme d'application, qui
est partagée avec le code de programmation dans le système. La programmation dans le système (ISP) et la programmation dans l'application
(IAP) aident les utilisateurs à mettre à niveau le programme et les données du système. . ISP permet à l'utilisateur de télécharger un nouveau
code sans retirer le microcontrôleur du produit final réel ; IAP signifie que l'appareil peut écrire des données non valides dans la mémoire Flash
pendant l'exécution du programme d'application. Il y a 1280 octets ou 512 octets de RAM intégrée sur la puce qui répondent aux exigences d'une
application sur un large champ. L'utilisateur peut configurer l'appareil pour qu'il fonctionne avec 12 horloges par cycle machine et pour obtenir les
mêmes performances, tout comme s'il utilise un autre appareil 80C51 standard fourni par un autre fournisseur, ou 6 horloges par cycle machine
pour obtenir des performances deux fois supérieures. La série STC89xx conserve toutes les fonctionnalités de la norme 80C51. De plus, la série
STC89xx dispose d'un port d'E/S supplémentaire (P4), d'un minuteur 2, d'une structure d'interruption à 8 sources et 4 niveaux de priorité, d'un
oscillateur à cristal sur puce et d'un minuteur de surveillance activé une seule fois.
1.1 Caractéristiques
•
Unité centrale de traitement 80C51 améliorée, 6T ou 12T par cycle machine
•
Plage de tension de fonctionnement : 5,5 V ~ 3,3 V (série STC89C) ou 2,0 V ~ 3,6 V (série STC89LE)
•
Plage de fréquences de fonctionnement : 048 MHz à 12 T ou 0 à 24 MHz à 6 T
•
Mémoire de programme FLASH 4/8/13/16/20/32/64K sur puce avec capacité ISP/IAP flexible
•
Sur puce 1280 octets / 512 octets de RAM
•
Être capable d'adresser jusqu'à 64 Ko de RAM externe
•
Être capable d'adresser jusqu'à 64 Ko de mémoire externe
•
Dual Data Pointer (DPTR) pour accélérer le mouvement des données
•
Trois minuterie/compteur 16 bits, la minuterie 2 est un compteur/décompteur avec sortie d'horloge programmable sur P1.0
•
8 adresses vectorielles, capacité d'interruption à 4 niveaux de priorité
•
Un UART amélioré avec reconnaissance d'adresse matérielle, fonction de détection d'erreur de trame et avec autobaud
générateur de taux.
•
Un WatchDogTimer 15 bits avec préscaler 8 bits (activé une seule fois)
•
intégrer MAX810 circuit de réinitialisation spécialisé
•
Trois modes de gestion de l'énergie : mode veille et mode mise hors tension
• Faible EMI : inhibe l'émission ALE
•
Le mode de mise hors tension peut être réveillé par la broche INT0/P3.2, la broche INT1/P3.3, T0/P3.4, T1/P3.5, la broche RXD/P3.0,
INT2/P4.3, INT3/P4.2
•
Un maximum de 39 ports d'E/S programmables sont disponibles
•
Quatre ports bidirectionnels 8 bits ; Des P4 supplémentaires de quatre bits supplémentaires sont disponibles pour PLCC44 et LQFP44
•
Température de fonctionnement : 40 ~ +85 ° C (industriel) / 0 ~ 75 ° C (commercial)
•
Type de paquet : LQFP44, PDIP40, PLCC44
4
1.2 Schéma fonctionnel

Le noyau CPU de la série STC89xx est entièrement compatible avec le microcontrôleur standard 8051, conserve tous les
mnémoniques d'instructions et la compatibilité binaire. La série STC89xx peut exécuter les instructions les plus rapides par 6 cycles
d'horloge ou 12 cycles d'horloge (identiques au standard 80C51). L'amélioration des programmes individuels dépend des instructions
réellement utilisées.
AUXRAM ADRESSE RAM 256 octets

1024 octets Registre RAM
Empiler ÉCLAIR
B S'inscrire ACC
Poniter 64 Ko
TMP2 TMP1 Minuterie 0/1 FAI/FAI
Minuterie 2
Adresse
UART Générateur
ALU
WDT Programme
PSSP
Comptoir
PSEN
Contrôle Ports 0,1,2,3,4
ALE Loquet
EA Unité
RÉINITIALISER
XTAL1 XTAL2 Ports 0,1,2,3,4

Conducteur
P0, P1, P2, P3, P4
Schéma fonctionnel STC89xx
5
PD
po
35
d'
S
1.3 Configurations des broches
4E
N5
1
7
6 0P
E.S
A
4
L
2 E
A
T2/P1.0 40 Vcc
T2EX/P1.1 39 P0.0
223
P0.3 P2.4
1
0
9
8
7
6
5
4
3
34 22 P1.2 38 P0.1
P0.2 P2.3
35 21 P1.3 37 P0.2
P0.1 P2.2
36 20 P1.4 36 P0.3
P0.0 P2.1
37 19 P1.5 35 P0.4
Vcc P2.0
38 LQFP44 18 P1.6 34 P0.5
INT3/P4.2 P4.0
39 39 ports d'E/S 17 P0.6
T2/P1.0 Terre P1.7 33
40 16
T2EX/P1.1 XTAL1 RST 123456789 32 P0.7
41 15
P1.2 XTAL2 RxD/P3.0 10 31 EA
42 14
P1.3 RD/P3.7 TxD/P3.1 11 30 ALE
43 13
P1.4 INT0/P3.2 12 29 PSEN
44 12 WR/P3.6
INT1/P3.3 13 28 P2.7
019
8
7
6
5
4
3
2
T0 /P3.4 14 27 P2.6
1
T1/P3.5 15 26 P2.5
WR/P3.6 16 25 P2.4
RD/P3.7 17 24 P2.3
//1
0 7
4
5
0
1
2D
6T
2/3 x10xNR
DT./S34 P
TI
XTAL2 18 23 P2.2
XTAL1 19 22 P2.1
Terre 20 21 P2 .0
44
3
2
1
0 1
2
3
5
6 X/33
0
1
2 1c2NP
4EcT.0
4 V
TI
P1.5 39 P0.4
P1.6 38 P0.5
P1.7 789 37 P0.6
RST 10 36 P0.7
RxD/P3.0 11 PLCC44 35 EA
INT2/P4.3 12 34 P4.1
TxD/P3.1 36 ports d'E/S
13 33 ALE
INT0/P3.2 14 32 PSEN
INT1/P3.3 15 31 P2.7
T0/P3.4 16 30 P2.6
29 P2.5
T1/P3.5 17
92
0
1
2
3
4
5
6
7
8 1
3W
aT
.D
s/R M
RX
P
4P
7/A
2eLs6
0.2
1
2
3
4
1
6
1.4 Description des broches
MNÉMONIQUE LQFP44 PDIP40 PLCC44 P0.0 ~ P0.7 DESCRIPTION
37~30 39~32 43~36 Port0 :Port0 est un port d'E/S bidirectionnel 8 bits avec résistance de rappel.
En plus d'être GPIO, le port 0 est également l'adresse d'ordre inférieur et le bus de données
multiplexés lors des accès à la mémoire externe des programmes et des données.
P1.0 ~ P1.7 40~44 18 2~9 Port1 : E/S à usage général avec une faible résistance de traction à l'intérieur. Lorsque des 1 sont écrits
1~3 dans le port 1, la forte sortie pilotant le CMOS n'active que deux périodes, puis la faible résistance
de rappel maintient le port élevé.
P1.0/T2 40 2
P1.1/T2EX 41 12 3 P1.0 est également utilisé comme l'une des sources d'événements pour le temporisateur 2, ou porteuse de sortie
du temporisateur 2, alias T2.
P1.1 est également utilisé comme l'une des sources de contrôle d'interruption pour le temps 2,
alias T2EX.
P2.0 ~ P2.7 1825 2128 24~31 Port2 : Le port2 est un port d'E/S bidirectionnel 8 bits avec résistance de pullup.
En plus d'être GPIO, le Port2 émet l'octet d'adresse de poids fort lors de l'accès au programme
externe et à la mémoire de données.
P3.0/RxD 5 10 11 Port3 : E/S à usage général avec une faible résistance de traction à l'intérieur. Lorsque des 1 sont
P3.1/TxD 7 11 13 écrits dans le port 1, la forte sortie pilotant le CMOS n'active que deux périodes, puis la faible
P3.2/INT0 8 12 14
résistance de rappel maintient le port élevé. Port3 remplit également les fonctions de diverses
P3.3/INT1 9 13 15
fonctionnalités spéciales.
P3.4/T0 10 14 16
P3.5/T1 11 15 17 P3.0 et P3.1 agissent comme récepteur et émetteurrécepteur des données pour le bloc
P3.6/WR 12 16 18
fonctionnel UART, Alias RxD et TxD.
P3.7/RD 13 17 19
P3.2 et P3.3 agissent également comme sources d'interruption externes, alias /INT0 et /INT1.
P3.4 et P3.5 agissent également comme sources d'événements pour timer0 et timer1
individuellement, alias T0 et T1.

P3.6 agit également comme signal d'écriture lors de l'accès à la mémoire externe, alias /WR.
P3.7 agit également comme signal de lecture lors de l'accès à la mémoire externe, alias /RD.
P4.0 17 23 Port4 : Port4 sont des ports d'E/S étendus tels que Port1. Il ne peut être disponible que sur
P4.1 28 34 LQFP44, PLCC44.
P4.2/INT3 39 1
P4.3/INT2 6 12
P4.2 et P4.3 agissent également comme sources d'interruption externes, alias /INT3 et /INT2.
TVD 4 9 10 RESET : Un niveau haut sur cette broche pendant au moins deux cycles machine réinitialisera le
appareil.
/EA 29 31 35 EA doit être maintenu au niveau bas pour permettre à l'appareil de récupérer le code de programme de
la mémoire flash externe.
Une résistance interne de traction a été intégrée dans cette broche.
/ALE 27 30 33 Impulsion de sortie pour verrouiller l'octet de poids faible de l'adresse lors des accès à la
mémoire externe.
/PSEN 26 29 32 Le stroboscope de lecture vers la mémoire de programme externe, faiblement actif.
XTAL1 15 19 21 Cristal 1 : entrée vers l'amplificateur d'oscillateur inverseur. Reçoit le signal de l'oscillateur
externe lorsqu'un oscillateur externe est utilisé.
XTAL2 14 18 20 Crystal 2 : Sortie de l'amplificateur inverseur. Cette épingle devrait flotter
lorsqu'un oscillateur externe est utilisé.
VCC 38 40 44 Puissance
Terre 16 20 22 Terrain
7
Dessins du paquet à 1,5 broches
FORFAIT LQFP44
D1
44 34
33
1
VARIATIONS (TOUTES LES DIMENSIONS INDIQUÉES EN MM
SYMBOLES MIN. NOM MAX.
UN 1,60
A1 0,05 0,15
E
A2 1,35 1,40 1,45
c1 0,09 0,16
23 D 12h00
11
D1 10h00
E 12h00
12 22
b E1 10h00
e e 0,80
1 b (sans placage) 0,25 0,30 0,35

NU
2A
L 0,45 0,60 0,75
L1 1.00REF
θ0 00 3,50 70
0,05MAX
REMARQUES:
1. APERÇU JEDEC : MS026 BSB

2.DIMENSIONS D1 ET E1 D0 NON
INCLURE LA SAILLIE DU MOULE.
52,0
LA SAILLIE AUTORISÉE EST

PLAN DE PORTE
0,25 mm PAR CÔTÉ. D1 ET E1 SONT DES
PLAN DE SIÈGE
DIMENSIONS MAXIMALES DE LA TAILLE DU
θ0
CORPS EN PLASTIQUE, Y COMPRIS LES
L
DÉSADAPTATIONS AU MOULE.
L1 3.LA DIMENSION b NE COMPREND PAS
LA SAILLIE DU DAMBAR. AUTORISER LA
SAILLIE DU DAMBAR NE DOIT PAS FAIRE
DÉPASSER LA LARGEUR DU PLOMB LA DIMNSION
MAXIMALE b DE PLUS
QUE 0,08 mm.
8
FORFAIT PDIP40
D θ0
40 21
E
1 20
H
SIÈGES
2A
AVION
L
0,050tyb.
0,001tyb.
SYMBOLES MIN NI MAX
0,050tyb.
UN 0,190
A1 0,015
A2 0,015 0,155 0,160

C 0,008 0,015
D 2,025 2,060 2,070
E 0,600
E1 0,540 0,545 0,550
L 0,120 0,130 0,140
eθ 0,630 0,650 0,670
0 0 7 15
NOTE:
1. APERÇU JEDEC : MS011 AC
9
PAQUET D'ENSEMBLE PLCC44

UN
Il
E A2
A1
17 7
b
18 6
DH
uei.D
e
28 40
29 39
L
H
c
Ge
Oui
Avion de sièges DIMENSIONS EN

DIMENSIONS EN POUCES
SYMBOLES MILMÈTRES
MIN NOM MAX MIN NOM MAX
UN 0,165 0,180 4.191 4.572
A1 0,020 0,508
A2 0,147 0,158 3.734 4.013

b1 0,026 0,028 0,032 0,660 0,711 0,813
b 0,013 0,017 0,021 0,330 0,432 0,533
c 0,007 0,010 0,0013 0,178 0,254 0,330
D 0,650 0,653 0,656 16,510 16,586 16,662
E 0,650 0,653 0,656 16,510 16,586 16,662
NOTE: e 0,050BSC 1.270BSC
D.ieu 0,590 0,610 0,630 14.986 15.494 16.002
1. APERÇU JEDEC : M0047 AC Ge 0,590 0,610 0,630 14.986 15.494 16.002
HD 0,685 0,690 0,695 17,399 17,526 17,653
2. LE PLAN DE RÉFÉRENCE H EST LAQUÉ AU
Il 0,685 0,690 0,695 17,399 17,526 17,653
LE FOND DE LA LIGNE DE SÉPARATION DU MOULE
L 0,100 0,112 2.540 2,845
Coïncident avec l'endroit où se trouve le fil
Oui 0,004 0,102
SORTIE DU CORPS.
3. LES DIMENSIONS E ET D D0 N'INCLUENT PAS LE MODE

SAILLIE. LA SAILLIE AUTORISÉE EST DE 10
MIL PRE CÔTÉ.DIMENSIONS E ET D D0 INCLUENT
LES INADAPTATIONS DE MOISISSURE ET SONT DÉTERMINÉES
AU PLAN DE RÉFÉRENCE H .
4. LA DIMENSION b1 NE COMPREND PAS LE DAMBAR

SAILLIE.
dix
Chapitre 2 GESTION DE L'ÉNERGIE, RÉINITIALISATION
2.1 Gestion de l'alimentation
Il existe deux modes d'économie d'énergie, qui peuvent être sélectionnés pour faire passer le STC89xx en mode d'économie
d'énergie en réglant le SFR PCON suivant.
Registre PCON (registre de contrôle de puissance)

LSB
peu B7 B6 B5 B4B3 B2 B1 B0
nom SMOD SMOD0 POF GF1 GF0 PD IDL
SMOD : Double débit en bauds de l'interface UART

0 Conservez un débit en bauds normal lorsque l'UART est utilisé en mode 1,2 ou 3. (par défaut)
1 Bit de débit en bauds double lorsque l'UART est utilisé en mode 1,2 ou 3.
SMOD0 : sélection de bit SM0/FE pour SCON.7 ; le réglage de ce bit définira SCON.7 comme fonction d'erreur de trame. L'effacer pour
définissez SCON.7 comme un bit de bits de sélection de mode UART.
B5 : Réservé
POF : Indicateur de mise sous tension. Il est défini par une action de mise hors tension et ne peut être effacé que par un logiciel.
GF1 : Pavillon généraliste 1
GF0 : drapeau généraliste 0
PD : Bit de mise hors tension.
IDL : Bit de mode veille.
2.1.1 Mode veille
Une instruction qui définit IDL/PCON.0 fait que c'est la dernière instruction exécutée avant de passer en mode veille, l'horloge interne
est connectée au CPU mais pas aux fonctions d'interruption, de minuterie, de WDT et de port série. L'état du processeur est conservé
dans son intégralité : le pointeur de pile, le compteur de programme, le mot d'état du programme, l'accumulateur et tous les autres
registres conservent leurs données pendant l'inactivité. Les broches du port conservent les états logiques qu'elles avaient au moment
de l'activation de l'inactivité. ALE et PSEN se maintiennent à des niveaux logiques élevés. Le mode inactif laisse les périphériques
fonctionner afin de leur permettre de réveiller le CPU lorsqu'une interruption est générée. Timer 0, Timer 1, Timer 2 et UART
continueront de fonctionner en mode veille.
Il existe deux manières de mettre fin au ralenti. L'activation de toute interruption activée entraînera l'effacement matériel d'IDL/
PCON.0, mettant ainsi fin au mode veille. L'interruption sera traitée et après RETI, la prochaine instruction à exécuter sera celle qui
suivra l'instruction qui a mis l'appareil en veille.
Les bits d'indicateur (GFO et GF1) peuvent être utilisés pour donner une indication artistique si une interruption s'est produite pendant le fonctionnement normal.
ou pendant le ralenti. Par exemple, une instruction qui active Idle peut également définir un ou les deux bits d'indicateur. Lorsque l'inactivité
se termine par une interruption, la routine de service d'interruption peut examiner les bits d'indicateur.
L'autre façon de sortir du mode veille consiste à tirer RESET au niveau haut pour générer une réinitialisation matérielle interne. Puisque l'oscillateur d'horloge
est toujours en cours d'exécution, la réinitialisation matérielle doit être maintenue active pendant seulement deux cycles d'horloge système (24 horloges
système) pour terminer l'opération. réinitialiser.
11
2.1.2 Mode mise hors tension (PD)

Une instruction qui définit PD/PCON.1 fait qu'il s'agit de la dernière instruction exécutée avant de passer en mode mise hors tension. En mode
PowerDown, l'oscillateur intégré et la mémoire Flash sont arrêtés afin de minimiser la consommation d'énergie. Seuls les circuits de mise sous
tension continueront à consommer de l'énergie pendant la mise hors tension.
Le contenu de la RAM et des SFR sur puce est conservé. La seule façon de sortir du mode hors tension est la réinitialisation du matériel. Le
mode de mise hors tension peut être réveillé par la broche RESET, l'interruption externe /INT0~/INT3, la broche RXD, la broche T0, la broche
T1. Lorsqu'il sera réveillé par RESET, le programme s'exécutera à partir de l'adresse 0x0000.
Veillez à garder la broche RESET active pendant au moins 10 ms afin d'obtenir une horloge stable. S'il est réveillé des E/S, le CPU
refonctionnera en passant à la routine de service d'interruption associée. Avant la refonte du CPU, l'horloge est bloquée et comptée jusqu'à
32768 afin de dénoncer l'horloge instable. Pour utiliser le réveil des E/S, les registres liés aux interruptions doivent être activés et programmés
avec précision avant d'entrer dans la mise hors tension. Faites attention à ce qu'il y ait au moins une instruction « NOP » après l'instruction de
mise hors tension si le réveil des E/S est utilisé. Lors de la fin de la mise hors tension par une interruption, la période de réveil est chronométrée
en interne. Au bord négatif de la broche d'interruption, la mise hors tension est quittée, l'oscillateur est redémarré et une minuterie interne
commence à compter. L'horloge interne sera autorisée à se propager et le processeur ne reprendra son exécution qu'après que la minuterie
aura atteint le compteur interne plein.
Après le délai d'attente, la routine de service d'interruption commencera. Pour empêcher l'interruption de se déclencher à nouveau, la routine
de service d'interruption doit désactiver l'interruption avant de revenir. La broche d'interruption doit être maintenue basse jusqu'à ce que le
périphérique ait expiré et commencé à s'exécuter. L'utilisateur ne doit pas tenter d'entrer (ou de rentrer) dans le mode de mise hors tension
pendant au moins 4 us avant que l'une des conditions suivantes ne se soit produite : Début de l'exécution du code (après tout type de
réinitialisation) ou Sortie de l'alimentation. mode bas.
L'exemple de programme C suivant montre que le mode de mise hors tension doit être réveillé par une interruption externe.
/* */
/* STC MCU International Limitée */
/* Démo du mode de réveil du MCU de la série STC89xx */
/* Portable : (86) 13922805190 */
/* Télécopieur : 8675582944243 */
/* Tél : 8675582948412 */
/* Web : www.STCMCU.com */
/* Si vous souhaitez utiliser le programme ou le programme référencé dans le */
/* article, veuillez préciser dans quelles données et procédures de STC */
/* */
#include <reg51.h>
#include <intrins.h>
sbit Début_LED = P1^2 ; // L'indicateur BeginLED indique le démarrage du système

caractère non signé Is_Power_Down = 0 ; sbit //Définissez ce bit avant de passer en mode mise hors tension
Is_Power_Down_LED_INT0 = P1^7 ; //Indicateur LED de réveil hors tension sur INT0
sbit Not_Power_Down_LED_INT0 = P1^6 ; // Pas d'indicateur LED de réveil hors tension sur INT0
sbit Is_Power_Down_LED_INT1 = P1^5 ; //Indicateur LED de réveil hors tension sur INT1
sbit Not_Power_Down_LED_INT1 = P1^4 ; // Pas d'indicateur LED de réveil en cas de mise hors tension sur INT1
sbit Power_Down_Wakeup_Pin_INT0 = P3^2 ; // Broche de réveil hors tension sur INT0
sbit Power_Down_Wakeup_Pin_INT1 = P3^3 ; // Broche de réveil hors tension sur INT1
sbit Normal_Work_Flashing_LED = P1^3 ; //Indicateur LED de travail normal
void Normal_Work_Flashing (void);

void INT_System_init (void);
void INT0_Routine (vide);
void INT1_Routine (vide);
12
vide principal (vide)

{
caractère non signé j=0;
caractère non signé compteur_réveil = 0 ;
//efface la variable du compteur de réveil d'interruption wakeup_counter
Début_LED = 0 ; //LED de démarrage du système
INT_System_init ( ); //Interruption de l'initialisation du système
pendant que(1)
{
P2 = compteur_réveil ;
wakeup_counter++;
pour(j=0; j<2; j++)
{
Normal_Work_Flashing( ); // Travail normal du système
}
Is_Power_Down = 1 ; //Définissez ce bit avant de passer en mode mise hors tension
PCON = 0x02 ; //après cette instruction, le MCU sera en mode mise hors tension
//arrêt de l'horloge externe
_nop_( );
_nop_( );
_nop_( );
_nop_( );
}
}
vide INT_System_init (vide)
{
IT0 = 0 ; /* Interruption externe 0, niveau électrique bas déclenché */
// IT0 = 1 ; /* Interruption externe 0, front négatif déclenché */
EX0 = 1 ; /* Activer l'interruption externe 0
IT1 = 0 ; = 1 ; /* Interruption externe 1, niveau électrique bas déclenché */
// IT1 /* Interruption externe 1, front négatif déclenché */
EX1 = 1 ; /* Activer l'interruption externe 1
EA = 1 ; /* Définir le bit d'activation globale
}
void INT0_Routine (void) interruption 0
{
si (Is_Power_Down)
{
//Is_Power_Down ==1; /* Réveil après mise hors tension sur INT0 */
Is_Power_Down = 0 ;
Is_Power_Down_LED_INT0 = 0 ;
/*interruption externe ouverte 0 Indicateur LED de réveil en cas de mise hors tension */
tandis que (Power_Down_Wakeup_Pin_INT0 == 0)
{
/* attends plus haut */
}
/* fermer l'interruption externe 0 Indicateur LED de réveil en cas de mise hors tension */
}
13
autre
{
Not_Power_Down_LED_INT0 = 0 ; /* ouverture d'une interruption externe 0 LED de travail normal */ while
(Power_Down_Wakeup_Pin_INT0 ==0) {

}
Not_Power_Down_LED_INT0 = 1 ; /* ferme l'interruption externe 0 LED de travail normal */
}
}
void INT1_Routine (void) interruption 2 {
si (Is_Power_Down) {
//Is_Power_Down ==1; /* Réveil après mise hors tension sur INT1 */

Is_Power_Down = 0 ;
Is_Power_Down_LED_INT1= 0 ;
/*ouverture d'une interruption externe 1 Indicateur LED de réveil à la mise hors tension
*/ while (Power_Down_Wakeup_Pin_INT1 == 0) {

}
/* fermer l'interruption externe 1 Indicateur LED de réveil en cas de mise hors tension */
} autre
{
Not_Power_Down_LED_INT1 = 0 ; /* ouvre une interruption externe 1 LED de travail normal */ while
(Power_Down_Wakeup_Pin_INT1 ==0) {

}
Not_Power_Down_LED_INT1 = 1 ; /* ferme l'interruption externe 1 LED de travail normal */
}
}
délai nul (vide) {
entier non signé j = 0x00 ; entier non

signé k = 0x00 ; pour (k=0; k<2; ++k) {
pour (j=0; j<=30000; ++j) {
_nop_( );
_nop_( );
_nop_( );
_nop_( );
14
_nop_( );
_nop_( );
_nop_( );
_nop_( );
}
}
}
vide Normal_Work_Flashing (vide)

{
Normal_Work_Flashing_LED = 0 ;
retard ( );
Normal_Work_Flashing_LED = 1 ;
retard ( );
}
Le programme suivant montre également que le mode hors tension ou le mode inactif peut être réveillé par une interruption
externe, mais il est écrit en langage assembleur plutôt qu'en langage C.
;*************************************************** *************
;Réveil au ralenti et réveil hors tension
;*************************************************** *************
ORG 0000H
PRINCIPAL AJMP
ORG 0003H
int0_interruption :
CLR P1.7 ;ouvrir l'indicateur LED P1.7
Retard ACALL ;délai afin d'observer
CLR EA ;effacer le bit d'activation global, arrêter toutes les interruptions
RÉTI
ORG 0013H
int1_interruption :
CLR P1.6 Délai ;ouvrir l'indicateur LED P1.6
ACALL CLR EA ;;retard afin d'observer
;effacer le bit d'activation global, arrêter toutes les interruptions
RÉTI
ORG 0100H
retard:
CLRA
MOUVEMENT R0, A
MOUVEMENT R1, A
MOV R2, #02
delay_loop :
DJNZ R0, delay_loop
DJNZ R1, delay_loop
DJNZ R2, delay_loop
RETRAIT
15
principal:
MOUVEMENT R3, #0 ;Le mode d'incrémentation de la LED P1 a été modifié
;commence à exécuter le programme
boucle principale:
MOUVEMENT A, R3
CPLA
MOV P1, A
Retard ACALL
INC. R3
MOUVEMENT A, R3
SUBB A, #18H
Boucle_main JC
MOV P1, #0FFH ; fermez toutes les LED, le MCU passe en mode mise hors tension
CLR IT0 ; un niveau électrique faible déclenche une interruption externe 0
; SETB IT0 ;le front négatif déclenche une interruption externe 0
SETB EX0 ;activer l'interruption externe 0
CLR IT1 ; un niveau électrique faible déclenche une interruption externe 1
; SETB IT1 ;le front négatif déclenche l'interruption externe 1
SETB EX1 ;activer l'interruption externe 1
ENSEMBLE EA ;définir l'activation globale
; si ce n'est pas le cas, le mode hors tension ne peut pas être réveillé
;MCU passera en mode veille ou en mode mise hors tension après les instructions suivantes
MOV PCON, #00000010B ; Définir le bit PD, mode mise hors tension (PD = PCON.1)
; NON
; NON
; NON
; MOV PCON, #00000001B ;Définir le bit IDL, mode veille (IDL = PCON.0)
MOV P1, #0DFH ;1101,1111
NON
NON
NON
ATTENDRE1 :
SJMP ATTENDRE1 ;arrêter dynamiquement

FIN
2.2 Commande de RÉINITIALISATION
Dans la série STC89xx, il existe 5 sources pour générer une réinitialisation interne. Il s'agit de la broche RESET, de la réinitialisation à la mise sous tension sur puce,
du minuteur WatchDog, de la réinitialisation du logiciel et du délai de synchronisation POR MAX810 sur puce.
2.2.1 Réinitialiser la broche
La broche RST, qui est l'entrée du Schmitt Trigger, est la broche d'entrée pour la réinitialisation de la puce. Un changement de
niveau de la broche RESET doit conserver au moins 24 cycles plus 10us pour pouvoir utiliser l'échantillonnage interne du CPU.
Lorsque ce signal est porté au niveau haut pendant au moins deux cycles machine plus 10 us, les registres internes sont chargés
avec les valeurs appropriées pour un démarrage ordonné du système. Pour un fonctionnement normal, le RST est faible.
16
2.2.2 Réinitialisation à la mise sous tension (POR)
Lorsque VCC descend en dessous du seuil de détection du circuit POR, tous les circuits logiques sont réinitialisés.
Lorsque VCC remonte, une réinitialisation interne est automatiquement déclenchée après un délai de 32 768 horloges. Le seuil
nominal de détection du POR est d'environ 2,0 V pour un appareil 3 V et 3,3 V pour un appareil 5 V.
L'indicateur de mise sous tension, POF/PCON.4, est défini par le matériel pour indiquer que la puissance VCC a déjà été inférieure à la tension POR. Et
cela aide les utilisateurs à vérifier si le démarrage du processeur provient de la mise sous tension ou d'une réinitialisation matérielle (réinitialisation de la
broche RST), d'une réinitialisation logicielle ou d'une réinitialisation de la minuterie de surveillance. Le bit POF doit être effacé par logiciel.
Registre PCON (registre de contrôle de puissance)

LSB
peu B7 B6 B5 B4 B3 B2 B1 B0
nom SMOD SMOD0 POF GF1 GF0 PD IDL
POF : Indicateur de mise sous tension. Il est défini par une action de mise hors tension et ne peut être effacé que par un logiciel.
2.2.3 Chronomètre de surveillance
Le minuteur de surveillance du MCU de la série STC89xx se compose d'un minuteur de préscaler de 8 bits et d'un minuteur de 15 bits.
La minuterie est activée une seule fois en définissant EN_WDT(WDT_CONTR.5). Effacer EN_WDT peut arrêter le comptage WDT.
Lorsque le WDT est activé, le logiciel doit toujours réinitialiser le temporisateur en écrivant 1 dans le bit CLR_WDT avant que le WDT
ne déborde. Si le MCU de la série STC89xx est hors de contrôle en raison d'une perturbation, cela signifie que le CPU ne peut pas
exécuter le logiciel normalement, alors WDT peut manquer « l'écriture 1 sur CLR_WDT » et un débordement se produira. Un
débordement de WatchDogTimer engendrera une réinitialisation interne.
1/256
1/128
1/64
1/32
minuterie 15 bits
1/16
1/8
1/4
1/2
Préscalaire 8 bits
SYSclk/12
IDL/PCON.0

EN_WDT CLR_WDT IDLE_WDT PS2 PS1 PS0
WDT_CONTR
Structure WDT
WDT_CONTR : registre de contrôle WatchDogTimer

LSB
peu B7B6 B5 B4 B3 B2B1B0

nom
EN_WDT CLR_WDT IDLE_WDT PS2 PS1 PS0
17
EN_WDT : Active le bit WDT. Une fois défini, WDT est démarré.
CLR_WDT : bit d'effacement WDT. Une fois défini, WDT recomptera. Le matériel effacera automatiquement ce bit.
IDLE_WDT : Bit de mode IDLE WDT. Lorsqu'il est défini, WDT est activé en mode IDLE. Lorsqu'il est clair, WDT est désactivé dans
INACTIF.
PS2, PS1, PS0 : Bit de réglage de la valeur de prééchelle WDT.

La valeur de prééchelle de la minuterie Watchdog est affichée dans le tableau cidessous :
Temps de débordement WDT à 20 MHz

PS2 PS1 PS0 Prééchelle
et mode 12T
0 0 0 2 39,3 mS
0 0 1 4 78,6 ms
0 1 0 8 157,3 mS
0 1 1 16 314,6 mS
1 0 0 32 629,1 mS
1 0 1 64 1,25 S
1 1 0 128 2,5S
1 1 1 256 5S
Le temps de débordement WDT est déterminé par l'équation suivante :

Temps de débordement WDT = (N × Prééchelle × 32768) / SYSclk
Lorsque le MCU est en mode 12T, N=12 ; Lorsque MCU en mode 6T, N=6
Le SYSclk = 20 MHz et MCU en mode 12T dans le tableau cidessus.
Si SYSclk=12MHz et MCU en mode 12T, le temps de débordement WDT est :
Temps de débordement WDT = (12 × Prééchelle × 32768) / 12000000 = Prééchelle × 393216 / 12000000
Le temps de dépassement WDT est indiqué dans le tableau cidessous lorsque SYSclk = 12 MHz et MCU en mode 12T :
Temps de débordement WDT à 12 MHz

PS2 PS1 PS0 Prééchelle
et mode 12T
0 0 0 2 65,5 ms
0 0 1 4 131,0 mS
0 1 0 8 262,1 mS
0 1 1 16 524,2 mS
1 0 0 32 1,0485S
1 0 1 64 2.0971S
1 1 0 128 4.1943S
1 1 1 256 8.3886S
Le temps de dépassement WDT est indiqué dans le tableau cidessous lorsque SYSclk = 11,0592 MHz et MCU en mode 12T :
PS2 PS1 PS0 Temps de débordement WDT prééchelle à 11,0592 MHz

et mode 12T
0 0 0 2 71,1 mS
0 0 1 4 142,2 mS
0 1 0 8 284,4 mS
0 1 1 16 568,8 mS
1 0 0 32 1,1377S
1 0 1 64 2,2755S
1 1 0 128 4.5511S
1 1 1 256 9.1022S
18
L'exemple suivant est un programme en langage assembleur qui illustre le MCU WDT de la série STC89xx.
;/* */
;/* STC MCU International Limitée */
;/* Démo WDT du MCU série STC89xx */
;/* Si vous souhaitez utiliser le programme ou le programme référencé dans le */
;/* article, merci de préciser dans quelles données et procédures de STC */
;/* */
; Temps de débordement WDT = (N × Prééchelle × 32768) / SYSclk

;Lorsque MCU est en mode 12T, N=12. Lorsque MCU en mode 6T, N=6
WDT_CONTR EQU 0E1H EQU ;Adresse WDT

DIRIGÉ P1.5 ; Le temps ;DEL temps de débordement WDT sur P1.5
de débordement WDT peut être mesuré par le temps d'éclairage des LED
ÉQU 0x35 ;Démarrez WDT, la valeur de prééchelle est 64
Pre_scale_Word ;SYSclk=18,432, MCU en mode 12T, temps de débordement WDT=(12 x 64 x 32768)/18432000 = 1,36 S
ORG 0000H
PRINCIPAL AJMP
ORG 0100H
PRINCIPAL:
LED CLR ;allumer le voyant LED

Délai ACALL ; délai d'environ 1 s
MOV WDT_CONTR, #Pre_scale_Word ; Démarrer WDT
LED SETB ; éteindre la LED
ATTENDEZ:
ATTENDRE SJMP ;attendez la réinitialisation du débordement WDT
;La LED s'allumera à nouveau après la réinitialisation
Retard:
MOUVEMENT R0, #0
MOV R1, #0
MOUVEMENT R2, #15
Delay_Loop :
DJNZ R0, Retard_Boucle
RETRAIT
FIN
19
2.2.4 RÉINITIALISATION DU logiciel
L'écriture d'un « 1 » sur le bit SWRST dans le registre ISP_CONTR générera une réinitialisation interne.
ISP_CONTR : registre de contrôle ISP/IAP

LSB
nom ISPEN SWBS SWRST WT2,WT1,WT0
ISPEN : activation du fonctionnement ISP/IAP.

0 : Désactivation globale de tous les programmes/fonctions d'effacement/lecture FAI/IAP.
1 : Activer le programme ISP/IAP/fonction d'effacement/lecture.
SWBS : contrôle de sélection de démarrage logiciel.
0 : Démarrez à partir de la mémoire principale après la réinitialisation.
1 : Démarrez à partir de la mémoire du FAI après la réinitialisation.
SWRST : commande de déclenchement de réinitialisation logicielle.
0 : Aucune opération
1 : Générer une réinitialisation du système logiciel. Il sera automatiquement effacé par le matériel.
B4 ~ B3 : réservé.
WT2 ~ WT0 : sélection du temps d'attente ISP/IAP lorsque le flash est occupé.
2.2.5 Délai de réinitialisation à la mise sous tension du MAX810
Il existe un autre circuit de retard POR sur puce intégré sur le STC89xx. Ce circuit est un circuit de réinitialisation spécial MAX810 et est
contrôlé en configurant le registre d'options flash. Temps de retard POR très long – environ 400 ms seront générés par ce circuit une fois
activé.
20
Chapitre 3 Organisation de la mémoire
3.1 Mémoire du programme
Le MCU de la série STC89xx dispose d'un espace d'adressage séparé pour la mémoire programme et la mémoire de données. La mémoire
de programme est la mémoire qui stocke les codes de programme que le processeur doit exécuter. Il y a jusqu'à 64 Ko de mémoire flash
pour le stockage des programmes et des données dans le MCU de la série STC89xx. Le 4K inférieur pour le STC89C51RC (8K pour le
STC89C52RC, 16K pour le STC89C54RC, etc.) peut résider sur la puce. La conception permet aux utilisateurs de le configurer comme s'il
y avait trois banques de partitions individuelles à l'intérieur. Elles sont appelées région AP (programme d'application), région IAP (In
ApplicationProgram) et région de démarrage ISP (InSystemProgram). La région AP est l'espace dans lequel réside le programme
utilisateur. La région IAP (InApplicationProgram) est l'espace de stockage de données non volatile qui peut être utilisé pour enregistrer
des paramètres importants par le programme AP. En d'autres termes, la capacité IAP de la série STC89xx permet à l'utilisateur de lire/
écrire la région flash de données sur puce définie par l'utilisateur pour éviter d'avoir besoin d'utiliser un périphérique EEPROM externe. La
région de démarrage du FAI est l'espace qui permet à un programme spécifique que nous appelons « programme FAI » de résider. Dans
la région FAI, l'utilisateur peut également activer l'accès en lecture/écriture à un petit espace mémoire pour stocker des paramètres à des fins spécifiques.
Généralement, le but du programme FAI est d'effectuer la mise à niveau du programme AP sans qu'il soit nécessaire de retirer l'appareil
du système. Le matériel de la série STC89xx récupère les informations de configuration depuis la durée de mise sous tension et effectue
une protection matérielle hors espace en fonction de critères prédéterminés. Les critères sont les suivants : la région AP est accessible
uniquement par le programme FAI, la région IAP est accessible par le programme FAI et le programme AP, et l'accès à la région FAI est
interdit à partir du programme AP et du programme FAI luimême. Mais si le « Flash de données FAI est activé », le programme FAI peut
lire/écrire cet espace. Lorsque de mauvais réglages sur les SFR ISPIAP sont effectués, le « manque d'espace » se produit et la série
STC89xx suit les critères cidessus, ignorez la commande de déclenchement.
Après la réinitialisation, le processeur commence l'exécution à partir de l'emplacement 0000H de la mémoire programme, où devrait se
trouver le début du code d'application de l'utilisateur. Pour traiter les interruptions, les emplacements de service d'interruption (appelés
vecteurs d'interruption) doivent être situés dans la mémoire du programme. Chaque interruption se voit attribuer un emplacement fixe dans
la mémoire du programme. L'interruption fait sauter le processeur vers cet emplacement, où il commence l'exécution de la routine de
service. L'interruption externe 0, par exemple, est affectée à l'emplacement 0003H. Si l'interruption externe 0 doit être utilisée, sa routine
de service doit commencer à l'emplacement 0003H. Si l'interruption ne doit pas être utilisée, son emplacement de service est disponible en
tant que mémoire de programme à usage général.
Les emplacements de service d'interruption sont espacés d'un intervalle de 8 octets : 0003H pour une interruption externe 0, 000BH pour une minuterie
0, 0013H pour une interruption externe 1, 001BH pour une minuterie 1, etc. Si une routine de service d'interruption est suffisamment courte (comme
c'est souvent le cas cas dans les applications de contrôle), il peut résider entièrement dans cet intervalle de 8 octets. Les routines de service plus
longues peuvent utiliser une instruction de saut pour sauter les emplacements d'interruption suivants, si d'autres interruptions sont utilisées.
FFFFH FFFFH FFFFH FFFFH

60K 56K
Octets Octets
Externe 64 Ko 64 Ko
Externe
1000H Octets 2000H Octets
ou ou
Externe Externe
0FFFF 1FFFH
4 Ko octets 8 Ko octets
Interne Interne
0000H 0000H 0000H 0000H
Mémoire de programme STC89C51RC Mémoire de programme STC89C52RC
21
3.2 Mémoire de données
3.2.1 RAM ScratchPad sur puce

Tout comme le microcontrôleur 8051 conventionnel, la série STC89xx dispose de 256 octets de mémoire de données SRAM, dont 128
octets d'espace SFR. Les 128 octets inférieurs de la mémoire de données sont accessibles via un adressage direct et indirect. Les
128 octets supérieurs de la mémoire de données et les 128 octets de l'espace SFR partagent le même espace d'adressage. Les 128
octets supérieurs de la mémoire de données ne sont accessibles que par adressage indirect. Les 128 octets de SFR ne sont
accessibles qu'en adressage direct. Les 32 octets les plus bas (00H~1FH) de la mémoire de données sont regroupés en 4 banques
de 8 registres chacune. Les instructions du programme appellent ces registres de R0 à R7. Les bits RS0 et RS1 du registre PSW (voir
la section 3.2.4) sélectionnent la banque de registres utilisée.
Les instructions utilisant l'adressage de registre n'accéderont qu'à la banque actuellement spécifiée. Cela permet une utilisation plus
efficace de l'espace de code, car les instructions de registre sont plus courtes que les instructions qui utilisent l'adressage direct. Les
16 octets suivants (20H ~ 2FH) audessus des banques de registres forment un bloc d'espace mémoire adressable par bits. Le jeu
d'instructions 80C51 comprend une large sélection d'instructions monobit, et les 128 bits de cette zone peuvent être directement
adressés par ces instructions. Les adresses de bits dans cette zone vont de 00H à 7FH.
Tous les octets du Lower 128 sont accessibles par adressage direct ou indirect, tandis que le Upper 128 n'est accessible que par
adressage indirect. Les SFR incluent les verrous de port, les minuteries, les commandes de périphériques, etc.
Ces registres ne sont accessibles que par adressage direct. Seize adresses dans l'espace SFR sont adressables en octets et en bits.
Les SFR adressables par bits sont ceux dont l'adresse se termine par 0H ou 8H.
3.2.2 RAM auxiliaire

Il y a 1 024 octets de RAM de données supplémentaires disponibles sur la série STC89C54RD+ (tandis que 256 octets de RAM de
données supplémentaires sont disponibles sur le STC89C51RC). Ils sont accessibles par les instructions MOVX @Ri ou MOVX
@DPTR. Un bit de contrôle – EXTRAM situé dans le registre AUXR.1 (voir section 3.2.4) sert à contrôler l'accès à la RAM auxiliaire.
Une fois défini, désactivez l’accès à la RAM auxiliaire. Lorsqu'elle est effacée (EXTRAM=0), cette RAM auxiliaire est la cible par défaut
pour la plage d'adresses de 0x0000 à 0x03FF et est accessible indirectement par l'instruction externe de déplacement, « MOVX @Ri
» et « MOVX @DPTR ». Si EXTRAM=0 et que l'adresse cible est supérieure à 0x03FF, bascule automatiquement pour accéder à la
RAM externe. Lorsque EXTRAM=0, le contenu de DPH est ignoré lors de l'exécution de l'instruction MOVX @Ri.
Pour le compilateur KEILC51, pour attribuer les variables à localiser dans la RAM auxiliaire, la définition « pdata » ou « xdata » doit
être utilisée. Après avoir été compilées, les variables déclarées par « pdata » et « xdata » deviendront respectivement les mémoires
accédées par « MOVX @Ri » et « MOVX @DPTR ». Ainsi, le matériel MCU de la série STC89xx peut y accéder correctement.
3.2.3 RAM externe
Un espace d'adressage de 64 Ko est disponible pour la série STC89xx afin d'accéder à la RAM de données externe. Tout comme la
conception du 8051 conventionnel, les ports P2, P0, ALE, P3.6 et P3.7 ont une fonction alternative pour l'accès à la RAM de données
externes. Pour accéder à la mémoire de données externe, le bit EXTRAM doit être mis à 1. Les accès à la mémoire de données
externe peuvent utiliser soit une adresse de 16 bits (en utilisant 'MOVX @DPTR'), soit une adresse de 8 bits (en utilisant 'MOVX
@Ri' ). Les adresses 8 bits sont souvent utilisées conjointement avec une ou plusieurs autres lignes d'E/S pour paginer la RAM. Si
une adresse 8 bits est utilisée, le contenu du SFR du port 2 reste sur les broches du port 2 tout au long du cycle de mémoire externe.
Cela facilitera l’accès à la radiomessagerie. Les adresses 16 bits sont souvent utilisées pour accéder jusqu'à 64 Ko de données externes
mémoire.
22
7FH
FR
Fonction spéciale
Haut 128 octets
Registres (SFR) 30H
RAM interne
2FH
80 bit adressable
7F 20H
1FH
Faible 128 octets Banque 0
RAM interne 18H
17H
Banque 0
10H
00 0FH
Banque 0
RAM sur puce ScratchPad 08H
07H
Banque 0
FFFF 00H
Moins de 128 octets de SRAM interne
03FF
64 Ko octets
RAM externe
1024 octets
de RAM étendue
0000
RAM auxiliaire 0000
RAM externe
3.2.4 Registre de fonctions spéciales pour la RAM
Certains SFR liés à la RAM sont présentés comme suit.
Pour un déplacement rapide des données, la série STC89xx prend en charge deux pointeurs de données. Ils partagent la même adresse SFR
et sont commutés par le bit de registre – DPS/AUXR1.0.
Registre des PSSP
nom CY AC F0 RS1 RS0 VO F1 P.
CY : Portez le drapeau.
AC : Drapeau de transport auxiliaire. (Pour les opérations BCD)
F0 : Flag 0. (Disponible à l'utilisateur à des fins générales)
RS1 : bit de contrôle de sélection de banque d'enregistrement 1.
OV : Drapeau de débordement.
F1 : Flag 1. Flag défini par l'utilisateur.

P : Drapeau de parité.
23
Registre AUXR
nom EXTRA ALEOFF
EXTRAM : Accès RAM interne/externe
0 : Pour la série RD+, la RAM auxiliaire sur puce est activée et située à l'adresse 0x0000 à 0x03FF. Et si
adresse supérieure à 0x03FF, la RAM externe hors puce devient automatiquement la cible.
Pour les séries RC, la RAM auxiliaire sur puce est activée et située à l'adresse 00H à FFH. Et si l'adresse est via FFH,
la RAM externe hors puce devient automatiquement la cible.
1 : La RAM auxiliaire sur puce est toujours désactivée.
ALEOFF : Désactiver/Activer ALE
0 : ALE est émis à un taux constant de 1/3 de l'horloge système en mode 6T, 1/6 SYSclk en mode 12T. 1 : ALE est
actif uniquement lors d'une instruction MOVX ou MOVC.
FFFFH
0xFFFF
Externe
RAM 63 Ko
Externe
RAM 64 Ko
0x0400
0x03FF
RAM auxiliaire 1 Ko
0x0000
0000H
EXTRAME=0 EXTRAME=1
Registre AUXR1
nom CF2 DPS
GF2 : Flag défini par l'utilisateur à usage général. Il peut être utilisé par logiciel.
DPS : DPTR enregistre le bit de sélection.
0 : DPTR0 est sélectionné (par défaut).
1 : Le DPTR secondaire (DPTR 1) est mis en service.
24
Un exemple de programme pour une démonstration de RAM étendue interne du STC89C58RD+ :
;/* */
;/* Démo de RAM interne étendue du MCU série STC89xx */
;/* */
#include<reg52.h>
#include<intrins.h> /* utilise la fonction _nop_( ) */
sfr AUXR = 0x8e ;

sfr AUXR1 = 0xa2 ;
sfr P4 = 0xe8 ;
sfr XICON = 0xc0 ;
sfr IPH = 0xb7;
sfr WDT_CONTR = 0xe1 ;

sfr FAI_DATA = 0xe2 ;
sfr FAI_ADDRH = 0xe3 ;
sfr FAI_ADDRL = 0xe4 ;
sfr FAI_CMD = 0xe5 ;
sfr FAI_TRIG = 0xe6 ;
sfr ISP_CONTR = 0xe7 ;
sbit ERROM_LED = P1^5 ;

sbit OK_LED = P1^7 ;
vide principal ( )
{
unsigned int array_point = 0 ;
/*Testarray : Test_array_one[512], Test_array_two[512] */

char non signé xdata Test_array_one[512] =
{
0x00, 0x01 0x02, 0x03, 0x04 0x0b, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0c, 0x13, 0x14, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x1b, 0x1c, 0x23, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x24, 0x2b, 0x2c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x33, 0x34, 0x3b, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x3c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3d, 0x3e, 0x3f
25
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,

0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb ,0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0 xe0, 0 xe1, 0xe2 , 0xe3, 0xe 0xe5 , 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 4, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xec, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xf4, 0xfd, 0xfe, 0xff,
0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfa, 0xf9, 0xf8,
0xf7, 0xf6, 0xf5, 0xf4, 0xfb , 0xf2, 0xf1, 0xf0,
0xef, 0xee, 0xed, 0xec, 0xf3, 0xea, 0xe9, 0xe8,
0xe7, 0xe6, 0xe5, 0xe4, 0xeb, 0xe2, 0xe1, 0xe0,
0xdf, 0xde, 0xdd, 0xdc, 0xe3, 0xda, 0xd9, 0xd8,
0xd7, 0xd6, 0xd5, 0xd4, 0xdb, 0xd2, 0xd1, 0xd0,
0xcf, 0xce, 0xcd, 0xcc, 0xd3, 0xca, 0xc9, 0xc8,
0xc7, 0xc6, 0xc5, 0xc4, 0xcb, 0xc2, 0xc1, 0xc0,
0xbf, 0xbe, 0xbd, 0xbc, 0xc3, 0xba, 0xb9, 0xb8,
0xb7, 0xb6, 0xb5, 0xb4, 0xbb, 0xb2, 0xb1, 0xb0,
0xaf, 0xae, 0xad, 0xac, 0xb3, 0xaa, 0xa9, 0xa8,
0xa7, 0xa6, 0xa5, 0xa4, 0xab, 0xa2, 0xa1, 0xa0,
0x9f, 0x9e, 0x9d, 0x9c, 0xa3, 0x9a, 0x99, 0x98,
0x97, 0x96, 0x95, 0x94, 0x9b, 0x92, 0x91, 0x90,
0x8f, 0x8e, 0x8d, 0x8c, 0x93, 0x8a, 0x89, 0x88,
0x87, 0x86, 0x85, 0x84, 0x8b, 0x82, 0x81, 0x80,
0x7f, 0x7e, 0x7d, 0x7c, 0x83, 0x7a, 0x79, 0x78,
0x77, 0x76, 0x75, 0x74, 0x7b, 0x72, 0x71, 0x70,
0x6f, 0x6e, 0x6d, 0x6c, 0x73, 0x6a, 0x69, 0x68,
0x67, 0x66, 0x65, 0x64, 0x6b, 0x62, 0x61, 0x60,
0x5f, 0x5e, 0x5d, 0x5c, 0x63, 0x5a, 0x59, 0x58,
0x57, 0x56, 0x55, 0x54, 0x5b, 0x52, 0x51, 0x50,
0x4f, 0x4e, 0x4d, 0x4c, 0x5 3, 0x4a, 0x49, 0x48,
0x47, 0x46, 0x45, 0x44, 0x4b, 0x43,0x42, 0x41, 0x40,
26
0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38,

0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00
};
char non signé xdata Test_array_two[512] =

{
0x00, 0x01 0x02, 0x03, 0x04 0x0b, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0c, 0x13, 0x14, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x1b, 0x1c, 0x23, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x24, 0x2b, 0x2c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x33, 0x34, 0x3b, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x3c, 0x43, 0x44, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x4b, 0x4c, 0x 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 53, 0x54, 0x5b, 0x3d, 0x3e, 0x3f
0x40, 0x41, 0x42, 0x5c, 0x63, 0x64 , 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x6b, 0x6c, 0x73, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x74, 0x7b, 0x7c, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x83, 0x84, 0x8b, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x8c, 0x93, 0x94, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x9b, 0x9c, 0xa3, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0xa4, 0xab, 0xac, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0xb3, 0xb4, 0 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, xbb, 0xbc, 0xc3, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0xc4, 0xcb , 0xcc, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0xd3, 0xd4, 0xdb, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0xdc, 0xe3, 0xe4, 0x9d, 0x9e, 0x9f,
0 xa0, 0x a1, 0 xa2, 0xeb, 0xec, 0xf3, 0 xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xf4, 0xfb, 0xfc, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xfc, 0xfb, 0xf4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xf3, 0xec, 0xEB, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xE4, 0xe3, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9 , 0xca, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd5, 0xd6, 0xd7
0xd8, 0xd9, 0xda, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfd, 0xfe, 0xff,
0xff, 0xfe, 0xfd, 0xfa, 0xf9, 0xf8,
0xf7, 0xf6, 0xf5, 0xf2, 0xf1, 0xf0,
0xef, 0xee, 0xed, 0xea, 0xe9, 0xe8,
0xe7, 0xe6, 0xe5, 0xe2, 0xe1, 0xe0,
27
0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8,

0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0,
0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc8,
0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0,
0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0,
0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
0x9f, 0x9e, 0x9d, 0x9c, 0x9b, 0x9a, 0x99, 0x98,
0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88,
0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68,
0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58,
0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48,
0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
0x3f , 0x3e , 0x3d , 0x3c , 0x3b , 0x3a , 0x39, 0x38,
0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00
};
ERREUR_LED = 1 ;
OK_LED = 1 ;
pour (array_point = 0 ; array_point<512 ; array_point++)
{
si (Test_array_one[array_point] != Test_array_two [array_point])
{
ERREUR_LED = 0 ;
OK_LED = 1 ;
casser;
}
autre{
OK_LED = 0 ;
ERREUR_LED = 1 ;
}
}
tandis que (1);
}
28
Chapitre 4 Configurations des ports d'E/S configurables
Le MCU de la série STC89xx possède les ports d'E/S suivants : P0.0~P0.7, P1.0~P1.7, P2.0~P2.7, P3.0~P3.7, P4.0~P4.3 (uniquement disponible
pour LQFP44 et PLCC44). Toutes les broches de port de la série STC89xx peuvent être configurées indépendamment sur l'un des quatre modes
suivants : quasibidirectionnel (sortie de port standard 8051), sortie pushpull, entrée uniquement ou sortie à drain ouvert. Toutes les broches de
port sont par défaut quasibidirectionnelles après la réinitialisation. . Chacun dispose d'une entrée déclenchée par Schmitt pour une meilleure
réjection du bruit d'entrée.
4.1 E/S quasibidirectionnelles
Les broches de port en mode de sortie quasibidirectionnel fonctionnent de manière similaire aux broches de port standard 8051. Un port quasi
bidirectionnel peut être utilisé comme entrée et sortie sans qu'il soit nécessaire de reconfigurer le port. Ceci est possible car lorsque le port émet
une valeur logique haute, il est faiblement piloté, ce qui permet à un périphérique externe de tirer la broche vers le bas. Lorsque la sortie de la
broche est faible, elle est fortement entraînée et capable d'absorber un courant important. Il y a trois transistors pullup dans la sortie quasi
bidirectionnelle qui servent à des fins différentes.
L'un de ces pullups, appelé pullup « très faible », est activé chaque fois que le registre de port de la broche contient un « 1 » logique. Ce pullup
très faible génère un très petit courant qui tirera la broche vers le haut si elle reste flottante.
Un deuxième pullup, appelé pullup « faible », est activé lorsque le registre de port de la broche contient un « 1 » logique et que la broche elle
même est également à un niveau logique « 1 ». Ce pullup fournit la source de courant primaire pour une broche quasibidirectionnelle qui produit
un 1. Si cette broche est tirée vers le bas par le périphérique externe, ce pullup faible s'éteint et seul le pullup très faible reste activé. . Afin de
tirer la broche vers le bas dans ces conditions, le périphérique externe doit absorber suffisamment de courant pour maîtriser le faible pullup et
tirer la broche du port en dessous de sa tension de seuil d'entrée.
Le troisième pullup est appelé le pullup « fort ». Ce pullup est utilisé pour accélérer les transitions bashaut sur une broche de port quasi
bidirectionnelle lorsque le registre du port passe d'un « 0 » logique à un « 1 » logique. Lorsque cela se produit, le pullup puissant s'active pour
deux horloges du processeur, tirant rapidement la broche du port vers le haut.
VCC VCC VCC

2 heures
Faible
retard
Fort Très faible
PORT
ÉPINGLE
PORT
DONNÉES DE VERROU
SAISIR
DONNÉES
Sortie quasibidirectionnelle
29
4.2 Sortie pushpull
La configuration de sortie pushpull a la même structure pulldown que les modes de sortie à drain ouvert et quasibidirectionnel, mais fournit un pull
up fort et continu lorsque le registre du port contient un « 1 » logique.
Le mode pushpull peut être utilisé lorsqu'un courant source plus important est nécessaire à partir d'une sortie de port. De plus, le chemin d'entrée de
la broche du port dans cette configuration est également le même que celui du mode quasibidirectionnel.
VCC
PORT
PORT
DONNÉES DE VERROU
ÉPINGLE
SAISIR
DONNÉES
Sortie pushpull
4.3 Mode d'entrée uniquement
La configuration d'entrée uniquement est une entrée déclenchée par Schmitt sans aucune résistance de rappel sur la broche.
SAISIR PORT
DONNÉES ÉPINGLE
Mode d'entrée uniquement
4.4 Sortie à drain ouvert
La configuration de sortie à drain ouvert désactive tous les pullups et pilote uniquement le transistor pulldown de la
broche du port lorsque le registre du port contient un « 0 » logique. Pour utiliser cette configuration dans une application,
une broche de port doit avoir un pullup externe, généralement lié à VCC. Le pulldown pour ce mode est le même que
pour le mode quasibidirectionnel. Le chemin d'entrée de la broche du port dans cette configuration est le même que
celui du mode quasibidirection.
PORT
ÉPINGLE
PORT
DONNÉES DE VERROU
SAISIR
DONNÉES
Sortie à drain ouvert
30
Chapitre 5 Système d'instructions
5.1 Registres de fonctions spéciales
0/8 1/9 2/A 3/B 4/C 5/J 6/E 7/F

0F8H 0FFH
0F0HB 0F7H
0000,0000
0E8H P4 0EFH
xxxx,1111
0E0H ACC WDT_CONR ISP_DATA ISP_ADDRH ISP_ADDRL ISP_CMD ISP_TRIG ISP_CONTR 0E7H
0000,0000 xx00,0000 1111,1111 0000,0000 0000,0000 xxxx,x000 xxxx,xxxx 000x,x000
0D8H 0DFH
0D0H PSW 0D7H
0000,0000
0C8H T2CON T2MOD RCAP2L RCAP2H TL2 TH2 0CFH
0000,0000 xxxx,xx00 0000,0000 0000,0000 0000,0000 0000,0000
0C0H XICON 0C7H
0000,0000
0B8HIP SADEN 0BFH
x0x0,0000 0000,0000
0B0H P3 IPH 0B7H
1111,1111 0000,0000
0A8H IE SADDR 0AFH
0000,0000 0000,0000
0A0HP2 AUXR1 N'utilisez pas 0A7H
1111,1111 xxxx,0xx0
098H SCON SBUF 09FH
0000 0000 xxxx, xxxx
090H P1 097H
1111,1111
088H TCON TMOD TL0 TL1 TH0 TH1 AUXR 08FH
0000,0000 0000,0000 0000,0000 0000,0000 0000,0000 0000,0000 xxxx,xx00
080H P0 PS chef du projet Debian DPH PCON 087H
1111,1111 0000,0111 0000,0000 0000,0000 00x1 0000
0/8 1/9 2/A 3/B 4/C 5/J 6/E 7/F
31
Valeur après
Symbole Description Adresse Adresse de bit et symbole Allumer ou
MSB LSB Réinitialiser
P0 Port 0 80H P0,7 P0,6 P0,5 P0,4 P0,3 P0,2 P0,1 P0.0 1111 1111B
PS Pointeur de pile 81H 0000 0111B
chef du projet Debian Pointeur de données bas 82H 0000 0000B
DPTR
DPH Pointeur de données élevé 83H 0000 0000B
PCON Contrôle de puissance 87H SMOD SMOD0 POF GF1 GF0 PD IDL 00x1 0000B
Minuterie/Compteur
TCON 88H TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0 0000 0000B
0 et 1 Contrôle
Minuterie/Compteur 0
TMOD 89H PORTE C/T M1 M0 PORTE C/T M1 M0 0000 0000B
et 1 mode
TL0 8AH 0000 0000B
Octet faible
TL1 8BH 0000 0000B
Octet faible
TH0 8CH 0000 0000B
Octet de poids fort
TH1 8DH 0000 0000B
Octet de poids fort
AUXR Registre auxiliaire 0 8EH EXTRA ALEOFF xxxx xx00B
P1 Port 1 90H P1.7 P1.6 P1.5 P1.4 P1.3 P1.2 P1.1 P1.0 1111 1111B
SCON Contrôle série 98H SM0/FE SM1 SM2 REN TB8 RB8 TI RI 0000 0000B
SBUF Tampon série 99H xxxx xxxxB
P2 Port 2 A0H P2.7 P2.6 P2.5 P2.4 P2.3 P2.2 P2.1 P2.0 1111 1111B
AUXR1 Registre auxiliaire1 A2H CF2 DPS 0xxx 0xx0B
C'EST À DIRE
Activation interruption A8H EA ET2 ES ET1 EX1 ET0 EX0 0000 0000B
Adresse de l'esclave SADDR A9H 0000 0000B
P3 Port 3 B0H P3.7 P3.6 P3.5 P3.4 P3.3 P3.2 P3.1 P3.0 1111 1111B
Priorité d'interruption PX3H PX2H PT2H PSH PT1H PX1H PT0H PX0H
IPH B7H 0000 0000B
Haut
Priorité d'interruption PT2 PS PT1 PX1 PT0 PX0
PI B8H xx00 0000B
Faible
Adresse de l'esclave
SADEN B9H 0000 0000B
Masque
Interruption auxiliaire PX3 EX3 IE3 IT3 PX2 EX2 IE2 IT2
XICON C0H 0000 0000B
Contrôle
Minuterie/Compteur 2 TF2 EXF2 RCLK TCLK EXEN2 TR2 C/T2 CP/RL2
T2CON C8H 0000 0000B
Contrôle
Minuterie/Compteur 2 T2OE DCEN
T2MOD C9H xxxx xx00B
Mode
RCAP2L Recharger/Capturer CAH 0000 0000B
Octet faible
32
Valeur après
RCAP2H Recharger/Capturer CBH 0000 0000B
Octet de poids fort
Minuterie/compteur bas
TL2 CCH 0000 0000B
Octet
Minuterie/Compteur élevé
TH2 CDH 0000 0000B
Octet
Statut du programme CY AC F0 RS1 RS0 OV F1 P
PSSP D0H 0000 0000B
Mot
ACC Accumulateur E0H 0000 0000B

Minuteur de chien de garde EN_WDT CLR_WDT IDLE_WDT PS2 PS1 PS0
WDT_CONTR E1H xx00 0000B
Registre de contrôle
Données Flash FAI/IAP
FAI_DATA E2H 1111 1111B
Registre
Flash FAI/IAP
ISP_ADDRH E3H 0000 0000B
Adresse élevée
Flash FAI/IAP
FAI_ADDRL E4H 0000 0000B
Adresse basse
Flash FAI/IAP MS2 MS1 MS0
FAI_CMD E5H xxxx x000B
Registre de commandes
Flash FAI/IAP
FAI_TRIG E6H xxxx xxxxB
Déclencheur de commande
Contrôle FAI/IAP ISPEN SWBS SWRST WT2,WT1,WT0
ISP_CONTR E7H 000x x000B
Registre
P4 Port 4 E8H P4.7 P4.6 P4.5 P4.4 P4.3 P4.2 P4.1 P4.0 1111 1111B
B B S'inscrire F0H 0000 0000B
Accumulateur
ACC est le registre accumulateur. Cependant, les mnémoniques des instructions spécifiques à l'accumulateur font simplement référence
à l'accumulateur par A.
Registre B
Le registre B est utilisé lors des opérations de multiplication et de division. Pour d'autres instructions, il peut être traité comme un autre
registre de blocnotes.
Pointeur de pile
Le registre Stack Pointer a une largeur de 8 bits. Il est incrémenté avant que les données ne soient stockées lors des exécutions PUSH
et CALL. Bien que la pile puisse résider n'importe où dans la RAM sur puce, le pointeur de pile est initialisé à 07H après une réinitialisation.
Cela fait que la pile commence à l’emplacement 08H.
33
Mot d'état du programme (PSW)
Le mot d'état du programme (PSW) contient plusieurs bits d'état qui reflètent l'état actuel de la CPU. Le PSW, illustré cidessous, réside dans
l’espace SFR. Il contient le bit de report, le report auxiliaire (pour le fonctionnement BCD), les deux bits de sélection de banque de registres,
l'indicateur de débordement, un bit de parité et deux indicateurs d'état définissables par l'utilisateur.
Le bit Carry, en plus de remplir la fonction de bit Carry dans les opérations arithmétiques, sert également d'« accumulateur » pour un certain
nombre d'opérations booléennes.
Les bits RS0 et RS1 sont utilisés pour sélectionner l'une des quatre banques de registres présentées dans la page précédente. Un certain
nombre d'instructions font référence à ces emplacements de RAM de R0 à R7.
Le bit de parité reflète le nombre de 1 dans l'accumulateur. P=1 si l'Accumulateur contient un nombre impair de 1 et sinon P=0.
Registre des PSSP
peu 7 6 5 4 3 2 1 0
nom CY AC F0 RS1 RS0 VO F1 P.
CY : Portez le drapeau.
AC : Drapeau de transport auxiliaire. (Pour les opérations BCD)
F0 : Flag 0. (Disponible à l'utilisateur à des fins générales)
OV : Drapeau de débordement.
F1 : Flag 1. Flag défini par l'utilisateur.

P : Drapeau de parité.
Pointeur de données
Le pointeur de données (DPTR) se compose d'un octet de poids fort (DPH) et d'un octet de poids faible (DPL). Sa fonction prévue est de contenir
une adresse de 16 bits. Il peut être manipulé comme un registre de 16 bits ou comme deux registres indépendants de 8 bits.
Pour un déplacement rapide des données, la série STC89xx prend en charge deux pointeurs de données. Ils partagent la même adresse SFR
et sont commutés par le bit de registre – DPS/AUXR1.0.
Registre AUXR1
LSB
nom CF2 DPS
GF2 : Indicateur défini par l'utilisateur à usage général. Il peut être utilisé par logiciel.
DPS : DPTR enregistre le bit de sélection.

0 : DPTR0 est sélectionné (par défaut).
1 : Le DPTR secondaire (DPTR 1) est mis en service.
34
Le programme suivant est un programme assembleur qui montre comment utiliser le double pointeur de données.
AUXR1 DONNÉES 0A2H ;Définir le registre de fonctions spéciales AUXR1

MOV AUXR1, #0 ;DPS=0, sélectionnez DPTR0
MOV DPTR, #1FFH ;Définissez DPTR0 pour 1FFH

MOV UN, #55H
MOVX @DPTR, A ;charger la valeur 55H dans l'unité 1FFH
MOV DPTR, #2FFH ;Définissez DPTR0 pour 2FFH

MOV UN, #0AAH
MOVX @DPTR, A ;charger la valeur 0AAH dans l'unité 2FFH
INC. AUXR1 ;DPS=1, DPTR1 est sélectionné

MOV DPTR, #1FFH ;Réglez DPTR1 sur 1FFH
MOVX UN, @DPTR ;Obtenir le contenu de l'unité
1FFH ;qui est pointée par DPTR1,
;le contenu de l'Accumulateur a changé pendant 55H
;le contenu de l'accumulateur a changé pour 0AAH
;le contenu de l'Accumulateur a changé pendant 55H
;le contenu de l'accumulateur a changé pour 0AAH
35
5.2 Modes d'adressage
Les modes d'adressage font partie intégrante du jeu d'instructions de chaque ordinateur. Ils permettent de spécifier la source ou la
destination des données de différentes manières, selon la situation de programmation. Il y a huit modes disponibles :
•
Registre
• Direct
• Indirect
• Immédiat
• Relatif
• Absolu
•
Long
• Indexé
Adressage direct (DIR)

En adressage direct, l'opérande est spécifié par un champ d'adresse de 8 bits dans l'instruction. Seules les données internes RAM et
SFR peuvent être adressées directement.
Adressage indirect (IND)

En adressage indirect, l'instruction spécifie un registre qui contient l'adresse de l'opérande. La RAM interne et externe peut être
indirectement adressée.
Le registre d'adresses pour les adresses 8 bits peut être R0 ou R1 de la banque sélectionnée, ou le Stack Pointer.
Le registre d'adresses pour les adresses 16 bits ne peut être que le registre de pointeur de données 16 bits – DPTR.
Instruction d'enregistrement (REG)

Les banques de registres, contenant les registres R0 à R7, sont accessibles par certaines instructions qui portent une spécification de
registre de 3 bits dans le code opérationnel de l'instruction. Les instructions qui accèdent aux registres de cette manière sont efficaces
en termes de code car ce mode élimine le besoin d'un octet d'adresse supplémentaire. Lorsqu'une telle instruction est exécutée, l'un
des huit registres de la banque sélectionnée est accédé.
Instruction spécifique au registre

Certaines instructions sont spécifiques à un certain registre. Par exemple, certaines instructions opèrent toujours sur l'accumulateur ou
le pointeur de données, etc. Aucun octet d'adresse n'est nécessaire pour de telles instructions. L'opcode luimême le fait.
Constante immédiate (IMM)

La valeur d'une constante peut suivre l'opcode dans la mémoire du programme.
Adressage d'index
Seule la mémoire programme est accessible avec un adressage indexé et elle ne peut être que lue. Ce mode d'adressage est destiné
à la lecture de tables de correspondance dans la mémoire programme. Un registre de base de 16 bits (DPTR ou PC) pointe vers la
base de la table et l'accumulateur est configuré avec le numéro d'entrée de la table. Un autre type d'adressage indexé est utilisé dans
l'instruction de saut conditionnel.
En saut conditionnel, l'adresse de destination est calculée comme la somme du pointeur de base et de l'accumulateur.
36
5.3 Résumé du jeu d'instructions
Les instructions STC MCU sont entièrement compatibles avec la norme 8051, qui sont réparties en cinq groupes fonctionnels :
• Arithmétique
•
Logique
• Transfert de données
• Variable booléenne
•
Branchement du programme
Les tableaux suivants fournissent un tableau de référence rapide montrant toutes les instructions 8051. Une fois que vous êtes
familiarisé avec le jeu d’instructions, ce tableau devrait s’avérer une source de référence pratique et rapide.
Horloges d'exécution de Horloges d'exécution de

Mnémonique Description Octet Microcontrôleur STC 12T Microcontrôleur STC6T
OPÉRATIONS ARITHMÉTIQUES
AJOUTER A, Rn Ajouter un registre à l'accumulateur 1 12 6
AJOUTER A, ajouter directement un octet ditect à l'accumulateur 2 12 6
AJOUTER UN, @Ri Ajouter de la RAM indirecte à l'accumulateur 1 12 6
ADD A, #data Ajouter des données immédiates à l'accumulateur 2 12 6
ADDC A, Rn Ajouter un registre à l'accumulateur avec Carry 1 12 6
ADDC A, direct Ajout d'un octet direct à l'accumulateur avec Carry 2 12 6
ADDC A, @Ri Ajoutez de la RAM indirecte à l'accumulateur avec Carry 1 12 6
ADDC A, #data Ajouter des données immédiates à Acc avec Carry 2 12 6
SUBB A, Rn Soustraire le registre du compte avec emprunt 1 12 6
SUBB A, direct Soustraire l'octet direct de Acc avec emprunt 2 12 6
SUBB A, @Ri Soustraire la RAM indirecte de l'ACC avec emprunt 1 12 6
SUBB A, #données Soustraire les données immédiates de l'ACC avec l'emprunt 2 12 6
INC A Accumulateur d'incrément 1 12 6
INC Rn Registre d'incrémentation 1 12 6
INC. direct Incrémenter l'octet direct 2 12 6
INC @Ri Incrémenter la RAM directe 1 12 6
DÉC A Accumulateur de décrémentation 1 12 6
DÉC Rn Registre de décrémentation 1 12 6
DÉC direct Décrémenter l'octet direct 2 12 6
DEC @Ri Décrémenter la RAM indirecte 1 12 6
INC DPTR Incrémenter le pointeur de données 1 24 12
MUL AB Multiplier A et B 1 48 24
DIVAB Diviser A par B 1 48 24
DA A Accumulateur de réglage décimal 1 12 6
Toutes les instructions arithmétiques exécutent un cycle machine à l'exception de l'instruction INC DPTR (deux cycles machine) et des
instructions MUL AB et DIV AB (quatre cycles machine). Notez qu'un cycle machine contient 12 horloges et prend 1us si le MCU
fonctionne en mode 12T et à partir d'une horloge de 12 MHz. Alors que le MCU fonctionne en mode 6T, un cycle machine contient 6
horloges.
37
Horloges d'exécution Horloges d'exécution de

Mnémonique Description Octet STC du MCU 12T Microcontrôleur STC6T
OPÉRATIONS LOGIQUES
ANL A, Rn ET S'inscrire sur l'accumulateur 1 12 6

ANL A, direct ET accès direct à l'accumulateur 2 12 6
ANL A, @Ri ET RAM indirecte vers l'accumulateur 1 12 6
ANL A, #données ET données immédiates vers l'accumulateur 2 12 6
ANL direct, A ET Accumulateur vers octet direct 2 12 6
ANL direct,#data ET données immédiates vers l'octet direct 3 24 12
ORL A, Rn. OU inscrivezvous sur Accumulator 1 12 6
ORL A,direct OU octet direct vers l'accumulateur 2 12 6
ORL A,@Ri OU RAM indirecte vers l'accumulateur 1 12 6
ORL A, #données OU données immédiates vers l'accumulateur 2 12 6
ORL direct, A OU Accumulateur vers octet direct 2 12 6
ORL direct,#data OU données immédiates vers octet direct 3 24 12
XRL A, Rn Registre OU exclusif sur l'accumulateur 1 12 6
XRL A, direct Octet direct OU exclusif vers l'accumulateur 2 12 6
XRL A, @Ri RAM indirecte OU exclusive à 1 12 6

Accumulateur
XRL A, #données Données immédiates OU exclusif à 2 12 6
Accumulateur
XRL direct, A Accumulateur OU exclusif pour diriger l'octet 2 12 6
XRL direct,#données Données immédiates OU exclusif vers l'octet 3 24 12

direct
CLRA Effacer l'accumulateur 1 12 6
CPLA Accumulateur de complément 1 12 6
RL A Faire pivoter l'accumulateur vers la gauche 1 12 6

RLC A Faites pivoter l'accumulateur vers la gauche à travers le 1 12 6
Porter
RR A Faire pivoter l’accumulateur vers la droite 1 12 6
CRR A Faites pivoter l’accumulateur à travers le 1 12 6
Porter
ÉCHANGER UN Échangez des amusegueules dans l'accumulateur 1 12 6
38

Mnémonique Description Octet Microcontrôleur STC6T
Microcontrôleur STC 12T
TRANSFERT DE DONNÉES
MOV A, Rn Déplacer le registre vers l'accumulateur 1 12 6
MOV A, direct Déplacer l'octet direct vers l'accumulateur 2 12 6
MOV A,@Ri Déplacez la RAM indirecte vers 1 12 6
MOV A, #données Déplacer les données immédiates vers l'accumulateur 2 12 6
MOV Rn, A Déplacez l’accumulateur pour vous inscrire 1 12 6
MOV Rn, direct Déplacer l'octet direct pour s'inscrire 2 24 12
MOV Rn, #données Déplacer les données immédiates pour vous inscrire 2 12 6
MOV direct, A Déplacer l'accumulateur vers l'octet direct 2 12 6
MOV direct, Rn Déplacer le registre vers l'octet direct 2 24 12
MOV direct,direct Déplacer l'octet direct vers direct 3 24 12
MOV direct, @Ri Déplacer la RAM indirecte vers l'octet direct 2 24 12
MOV direct,#données Déplacer les données immédiates vers l'octet direct 3 24 12
MOV @Ri, A Déplacer l'accumulateur vers la RAM indirecte 1 12 6
MOV @Ri, direct Déplacer l'octet direct vers la RAM indirecte 2 24 12
MOV @Ri, #données Déplacer les données immédiates vers la RAM indirecte 2 12 6
MOV DPTR,#data16 Déplacer les données immédiates vers la RAM indirecte 2 12 6
MOVC A,@A+DPTR Déplacer l'octet de code par rapport à DPTR vers Acc 1 24 12
MOVC A, @A+PC Déplacer l'octet de code par rapport au PC vers Acc 1 24 12
MOVX A,@Ri Déplacer la RAM externe (adresse 16 bits) vers Acc 1 24 12
MOVX A,@DPTR Déplacer la RAM externe (adresse 16 bits) vers Acc 1 24 12
MOVX @Ri, A Déplacer Acc vers la RAM externe (adresse 8 bits) 1 24 12
MOVX @DPTR,A Déplacer Acc vers la RAM externe (adresse 16 bits) 1 24 12

POUSSER directement Pousser l'octet direct sur la pile 2 24 12
POPULAIRE direct POP octet direct de la pile 2 24 12
XCHA,Rn Registre d'échange avec Accumulateur 1 12 6
XCH A, direct Échanger un octet direct avec l'accumulateur 2 12 6
XCH A, @Ri Échangez de la RAM indirecte avec l'accumulateur 1 12 6
XCHD A, @Ri Échangez la RAM indirecte 1 à chiffres d'ordre inférieur 12 6

avec Acc
39

Mnémonique Description Octet Microcontrôleur STC 12T Microcontrôleur STC6T
MANIPULATION DES VARIABLES BOOLÉENNES

CLR C Effacer le transport 1 12 6
Bit CLR Effacer le bit direct 2 12 6
SETB C Ensemble de transport
1 12 6
Bit SETB Définir le bit direct 2 12 6
CPLC Complément de transport 1 12 6
CPL peu Complément bit direct 2 12 6
ANL C, bit ET peu direct à transporter 2 24 12
ANL C, /bit ET complément de bit direct au Carry 2 24 12
ORL C, bit OU bit direct vers Carry 2 24 12
ORL C, /bit OU complément de bit direct à Carry 2 24 12
MOV C, bit Déplacer le bit direct vers Carry 2 12 6
Bit MOV, C Déplacer Carry vers le bit direct 2 24 12

JC rel Sauter si Carry est activé 2 24 12
JNC rapport
Sauter si Carry n'est pas réglé 2 24 12
JB peu, rel Sauter si le bit direct est activé 3 24 12
JNB peu,rel Sauter si le bit direct n'est pas défini 3 24 12
JBC peu, rel Sauter si le bit direct est activé et effacer le bit 3 24 12
BRANCHEMENT DE PROGRAMME
Adresse d'appel AC11 Appel de sousprogramme absolu 2 24 12
Adresse LCALL16 Appel de sousprogramme long 3 24 12
RETRAIT Retour du sousprogramme 1 24 12
RÉTI Retour d'interruption 1 24 12
Adresse AJMP11 Saut absolu 2 24 12
Adresse LJMP16 Long saut 3 24 12
SJMP rel. Saut court (adresse relative) 2 24 12
JMP @A+DPTR Saut indirect par rapport au DPTR 1 24 12

JZ rapport
Sauter si l'accumulateur est nul 2 24 12
JNZ rapport
Sauter si l'accumulateur n'est pas zéro 2 24 12
CJNE A,direct,rel Comparez l'octet direct à Acc et sautez s'il n'est pas 3 24 12
égal
CJNE A,#données,rel Comparez immédiat à Acc et Jump s'il n'est pas 3 24 12
égal
CJNE Rn,#données,rel Comparez immédiatement pour vous inscrire et Jump 3 24 12
s'il n'est pas égal
CJNE @Ri,#data,rel Comparez l'immédiat à l'indirect et sautez s'il n'est pas égal 3 24 12
DJNZ Rn, rel. Décrémenter le registre et sauter sinon Zéro 2 24 12
DJNZ direct, rel. Décrémenter l'octet direct et sauter sinon 3 24 12

Zéro
NON Pas d'opération 1 12 6
40
5.4 Définitions des instructions

Adresse ACALL 11
Fonction : Appel Absolu
Description : ACALL appelle sans condition un sousprogramme situé à l'adresse indiquée. L'instruction incrémente le PC deux fois pour
obtenir l'adresse de l'instruction suivante, puis pousse le résultat 16 bits sur la pile (octet de poids faible en premier)
et incrémente le pointeur de pile. deux fois.
L'adresse de destination est obtenue en concaténant successivement les cinq bits de poids fort des bits 7 à 5 du code
d'opération PC incrémenté et le deuxième octet de l'instruction. Le sousprogramme appelé doit donc démarrer
dans le même bloc de 2 Ko de la mémoire programme que le premier octet de l'instruction suivant ACALL. Aucun
drapeau n'est affecté.
Exemple : Initialement SP est égal à 07H. L'étiquette « SUBRTN » se trouve à l'emplacement de mémoire de programme 0345H.
Après avoir exécuté l'instruction,
APPEL SUBRTN
à l'emplacement 0123H, SP contiendra 09H, les emplacements RAM internes 08H et 09H contiendront respectivement
25H et 01H, et le PC contiendra 0345H.
Octets : 2
Cycles : 2
Encodage : a10 a9 a8 1 0010 a7 a6 a5 a4 a3 a2 a1 a0
Opération : APPEL
(PC) ← (PC)+ 2
(SP) (SP) + 1
((sP)) ← (PC70)
(SP) (SP) + 1
((SP)) (PC158)
(PC100) ← adresse de la page
AJOUTER A,<srcbyte>
Fonction : Ajouter
Description : ADD ajoute la variable d'octet indiquée à l'accumulateur, laissant le résultat dans le
Accumulateur. Les indicateurs de report et de report auxiliaire sont activés, respectivement, s'il y a un report à
partir du bit 7 ou du bit 3, et effacés dans le cas contraire. Lors de l'ajout d'entiers non signés, l'indicateur de retenue
indique qu'un débordement s'est produit.
OV est activé s'il y a un report du bit 6 mais pas du bit 7, ou un report du bit 7 mais pas du bit 6 ; sinon, OV est effacé.
Lors de l'ajout d'entiers signés, OV indique un nombre négatif produit comme la somme de deux opérandes positifs,
ou une somme positive de deux opérandes négatifs.
Quatre modes d'adressage des opérandes sources sont autorisés : registre, registre directindirect ou immédiat.
Exemple : l'accumulateur contient 0C3H (11000011B) et le registre 0 contient 0AAH (10101010B). L'instruction,
AJOUTER A,R0
laissera 6DH (01101101B) dans l'accumulateur avec le drapeau AC effacé et les deux
drapeau et OV mis à 1.
41
AJOUTER A,Rn
Octets : 1
Cycles : 1
Codage: 0010 1 rrr
Opération : AJOUTER
(A) (A) + (Rn)
AJOUTER A, direct
Octets : 2
Cycles : 1
Codage: 0010 0101 adresse directe
(A)← (A) + (direct)
AJOUTER UN,@Ri
Octets : 1
Cycles : 1
Codage: 0010 0 1 1 je
(A) (A) + ((Ri))
AJOUTER A,#données
Octets : 2
Cycles : 1
Codage: 0010 0100 données immédiates
(A) (A) + #données
ADDC A,<octetsrc>
Fonction : Ajouter avec Carry
Description : ADDC ajoute simultanément la variable d'octet indiquée, le drapeau Carry et l'Accumulateur, laissant le résultat dans
l'Accumulateur. Les indicateurs de report et de report auxiliaire sont activés, respectivement, s'il y a un report à partir
du bit 7 ou du bit 3, et effacés dans le cas contraire. Lors de l'ajout d'entiers non signés, l'indicateur de retenue
indique qu'un débordement s'est produit.
OV est activé s'il y a un report du bit 6 mais pas du bit 7, ou un report du bit 7 mais pas du bit 6 ; sinon, OV est
effacé. Lors de l'ajout d'entiers signés, OV indique un nombre négatif produit comme la somme de deux opérandes
positifs ou une somme positive de deux opérandes négatifs.
Quatre modes d'adressage des opérandes sources sont autorisés : registre, direct, registreindirect ou immédiat.
42
ADDC A,Rn
Octets : 1
Cycles : 1
Codage: 001 1 1 rrr
Opération : ADDC
(UNE)← (UNE) + (C) + (Rn)
ADDC A, direct
Octets : 2
Cycles : 1
Opération : ADDC
(A)← (A) + (C) + (direct)
ADDC A,@Ri
Octets : 1
Cycles : 1
Codage: 001 1 0 1 1 je
Opération : ADDC
(UNE)← (UNE) + (C) + ((Ri))
ADDC A,#données
Octets : 2
Cycles : 1
Opération : ADDC
(A) (A) + (C) + #données
Adresse AJMP 11
Fonction : saut absolu
Description : AJMP transfère l'exécution du programme à l'adresse indiquée, qui est formée au moment de l'exécution par
concaténer les cinq bits de poids fort du PC (après avoir incrémenté le PC deux fois), les bits d'opcode 7 à 5
et le deuxième octet de l'instruction. La destination doit donc se trouver dans le même bloc de 2 Ko de mémoire
programme que le premier octet de l'instruction suivant AJMP.
Exemple : L'étiquette « JMPADR » se trouve à l'emplacement de mémoire programme 0123H. L'instruction,
AJMP JMPADR
est à l'emplacement 0345H et chargera le PC avec 0123H.
Octets : 2
Cycles : 2
Encodage : a10 a9 a8 0 0 0 0 1 a7 a6 a5 a4 a3 a2 a1 a0
Opération : AJMP
(PC) ← (PC)+ 2
(PC100) ← adresse de la page
43
ANL <destbyte> , <srcbyte>

Fonction : ET logique pour les variables d'octet
Description : ANL effectue l'opération ET logique au niveau du bit entre les variables indiquées et stocke
les résultats dans la variable de destination. Aucun drapeau n'est affecté.
Les deux opérandes permettent six combinaisons de modes d'adressage. Lorsque la destination est
l'accumulateur, la source peut utiliser un adressage par registre, direct, par registre indirect ou immédiat ;
lorsque la destination est une adresse directe, la source peut être l'accumulateur ou des données
immédiates.
Remarque : Lorsque cette instruction est utilisée pour modifier un port de sortie, la valeur utilisée comme valeur d'origine
les données du port seront lues à partir du verrou de données de sortie et non à partir des broches d'entrée.
Exemple : Si l'accumulateur contient 0C3H (11000011B) et que le registre 0 contient 55H (01010101B), alors le
instruction,
ANL A,R0
laissera 41H (01000001B) dans l'accumulateur.
Lorsque la destination est un octet directement adressé, cette instruction effacera les combinaisons de bits
dans n'importe quel emplacement RAM ou registre matériel. L'octet de masque déterminant le modèle de bits
à effacer serait soit une constante contenue dans l'instruction, soit une valeur calculée dans l'accumulateur
au moment de l'exécution. L'instruction,
Place ANL, #01110011B
effacera les bits 7, 3 et 2 du port de sortie 1.
ANL A,Rn
Octets : 1
Cycles : 1
Codage: 0101 1 rrr
Opération : ANL
(UNE) (UNE) (Rn)
ANL A, direct
Octets : 2
Cycles : 1
Opération : ANL
(A) (A) (direct)
ANL A,@Ri
Octets : 1
Cycles : 1
Codage: 0101 0 1 1 je
Opération : ANL
(UNE) (UNE) ((Ri))
44
ANL A,#données
Octets : 2
Cycles : 1
Opération : ANL
(A) (A) #données
ANL direct,A
Octets : 2
Cycles : 1
Opération : ANL
(direct) (direct) (A)
ANL direct,#données
Octets : 3
Cycles : 2
Codage: 0101 0011 adresse directe données immédiates
Opération : ANL
(direct) (direct) #données
ANL C , <bitsrc>
Fonction : ET logique pour les variables binaires
Description : Si la valeur booléenne du bit source est un 0 logique, effacez l'indicateur de retenue ; sinon
laissez le drapeau de transport dans son état actuel. Une barre oblique (« / ») précédant l'opérande dans
le langage assembleur indique que le complément logique du bit adressé est utilisé comme valeur
source, mais que le bit source luimême n'est pas affecté. Aucun autre fichier n'est affecté.
Seul l'adressage direct est autorisé pour l'opérande source.
Exemple : définissez l'indicateur de report si, et seulement si, P1.0 = 1, ACC. 7 = 1, et VO = 0 :
MOUVEMENT C, P1.0 ;CHARGEMENT TRANSPORT AVEC ÉTAT DE BROCHE D'ENTRÉE
ANL C, ACC.7 ;ET À PORTER AVEC ACCUM. BIT.7
ANL C, /OV ;ET AVEC DRAPEAU INVERSE DE DEBORDEMENT
ANL C,bit
Octets : 2
Cycles : 2
Codage: 1000 0010 adresse de bit
Opération : ANL
(C) ← (C) (bit)
45
ANL C, /bit
Octets : 2
Cycles : 2
(C) (C) (bit)
CJNE <destbyte>, <srcbyte>, rel

Fonction : comparer et sauter si ce n'est pas égal
Description : CJNE compare les grandeurs des deux premiers opérandes et effectue des branchements si leurs valeurs ne sont pas
égal. La destination de la branche est calculée en ajoutant le déplacement relatif signé dans le
dernier octet d'instruction au PC, après avoir incrémenté le PC jusqu'au début de l'instruction suivante.
L'indicateur de retenue est défini si la valeur entière non signée de <destbyte> est inférieure à la valeur entière non signée de <destbyte>.
valeur entière de <srcbyte> ; sinon, le report est autorisé. Aucun des deux opérandes n’est affecté.
Les deux premiers opérandes permettent quatre combinaisons de modes d'adressage : l'accumulateur peut
être comparé à n'importe quel octet directement adressé ou donnée immédiate, et tout emplacement RAM
indirect ou registre de travail peut être comparé à une constante immédiate.
Exemple : L'Accumulateur contient 34H. Le registre 7 contient 56H. La première instruction de la séquence
CJNE R7,#60H, NONEQ

; ... ...... ; R7 = 60H.
NOT_EQ : JC REQ_LOW ; SI R7 < 60H.
; ... ..... ; R7 > 60H.
définit l'indicateur de report et passe à l'instruction sur l'étiquette NOTEQ. En testant l'indicateur de report, cette
instruction détermine si R7 est supérieur ou inférieur à 60H.
Si les données présentées au port 1 sont également de 34H, alors l'instruction,
ATTENDRE : CJNE A, P1, ATTENDRE

efface l'indicateur de retenue et continue avec l'instruction suivante dans la séquence, puisque
l'accumulateur est égal aux données lues sur P1. (Si une autre valeur était entrée sur Pl, le programme bouclera
à ce stade jusqu'à ce que les données P1 passent à 34H.)
CJNE A,direct,rel
Octets : 3
Cycles : 2
Codage: 1011 0101 adresse directe rel. adresse
Fonctionnement : (PC) ← (PC) + 3

SI (A) < > (direct)
ALORS
(PC) ← (PC) + décalage relatif
SI (A) < (direct)
ALORS
(C) ←1
AUTRE
(C) ←0
46
CJNE A,#données,rel
Octets : 3
Cycles : 2
Codage: 1011 0101 données immédiates rel. adresse

SI (A) < > (données)
ALORS

SI (A) < (données)
ALORS
(C) ←1
AUTRE
(C) ←0
CJNE Rn,#données,rel
Octets : 3
Cycles : 2
Codage: 1011 1 rrr données immédiates rel. adresse

SI (Rn) < > (données)
ALORS

SI (Rn) < (données)
ALORS
(C) ←1
AUTRE
(C) ←0
CJNE @Ri,#data,rel
Octets : 3
Cycles : 2
Codage: 1011 0 1 1 je données immédiates rel. adresse

SI ((Ri)) < > (données)
ALORS

SI ((Ri)) < (données)
ALORS
(C) ←1
AUTRE
(C) ←0
47
CLRA
Fonction : Effacer l'accumulateur
Description : L'Aecunmlator est effacé (tous les bits mis à zéro). Aucun drapeau n'est affecté.
Exemple : L'accumulateur contient 5CH (01011100B). L'instruction,

CLRA
laissera l’accumulateur réglé sur 00H (00000000B).
Octets : 1
Cycles : 1
Codage: 1110 0100
Fonctionnement : CLR
(A) ←0
Bit CLR
Fonction : Effacer le bit
Description : Le bit indiqué est effacé (remis à zéro). Aucun autre drapeau n'est affecté. CLR peut fonctionner sur l'indicateur
de retenue ou sur tout bit directement adressable.
Exemple : Le port 1 a déjà été écrit avec 5DH (01011101B). L'instruction,

CLR P1.2
laissera le port réglé sur 59H (01011001B).

CLR C
Octets : 1
Cycles : 1
Codage: 11000011
Fonctionnement : CLR
(C) ←0
Bit CLR
Octets : 2
Cycles : 1
Opération : CLR (bit)

←0
48
CPLA
Fonction : accumulateur de complément
Description : Chaque bit de l'Accumulateur est logiquement complété (son complément). Les bits qui
contenaient auparavant un un sont remplacés par un zéro et vice versa. Aucun drapeau n'est affecté.
Exemple : L'accumulateur contient 5CH(01011100B). L'instruction,
CPLA
laissera l’accumulateur réglé sur 0A3H (101000011B).
Octets : 1
Cycles : 1
Codage: 1111 0100
Opération : CPL
(A) ← (A)
Bit CPL
Fonction : bit complémentaire
Description : La variable bit spécifiée est complétée. Un bit qui était un un est mis à zéro
et vice versa. Aucun autre drapeau n'est affecté. CLR peut fonctionner sur le report ou sur tout bit
directement adressable.
Remarque : lorsque cette instruction est utilisée pour modifier une broche de sortie, la valeur utilisée comme données
d'origine sera lue à partir du verrou de données de sortie, et non de la broche d'entrée.
Exemple : Le port 1 a déjà été écrit avec 5DH (01011101B). L'instruction,
CLR P1.1
CLR P1.2
laissera le port réglé sur 59H (01011001B).

CPLC
Octets : 1
Cycles : 1
Codage: 101 1 0011
Opération : CPL
(C) ← (C)
Bit CPL
Octets : 2
Cycles : 1
Opération : CPL
(bits) ← (bits)
49
DA A
Fonction : accumulateur à réglage décimal pour l'addition
Description : DA A ajuste la valeur de huit bits dans l'accumulateur résultant de l'ajout antérieur de
deux variables (chacune au format BCD compressé), produisant deux chiffres de quatre bits. Toute
instruction ADD ou ADDC peut avoir été utilisée pour effectuer l'addition.
Si les bits de l'accumulateur 3 à 0 sont supérieurs à neuf (xxxx1010xxxx1111), ou si l'indicateur AC est un,
six sont ajoutés à l'accumulateur, produisant le chiffre BCD approprié dans le quartet de poids faible.
Cet ajout interne définirait l'indicateur de report si un report du champ de quatre bits de poids faible se
propageait à travers tous les bits de poids fort, mais il n'effacerait pas l'indicateur de report dans le cas contraire.
Si l'indicateur de report est maintenant activé ou si les quatre bits de poids fort dépassent maintenant
neuf (1010xxxx111xxxx), ces bits de poids fort sont incrémentés de six, produisant le chiffre BCD
approprié dans le quartet de poids fort. Encore une fois, cela activerait l'indicateur de report s'il y avait un
report des bits de poids fort, mais n'effacerait pas le report. L'indicateur de retenue indique ainsi si la
somme des deux variables BCD d'origine est supérieure à 100, permettant une addition décimale à
précision multiple. OV n'est pas affecté.
Tout cela se produit au cours d’un seul cycle d’instruction. Essentiellement, cette instruction effectue le
conversion décimale en ajoutant 00H, 06H, 60H ou 66H à l'accumulateur, selon
conditions initiales de l’accumulateur et du PSW.
Remarque : DA A ne peut pas simplement convertir un nombre hexadécimal de l'accumulateur en notation

BCD, et DA A ne s'applique pas non plus à la soustraction décimale.
Exemple : L'accumulateur contient la valeur 56H (01010110B) représentant les chiffres BCD compressés du nombre décimal
56. Le registre 3 contient la valeur 67H (01100111B) représentant les chiffres BCD compressés du
nombre décimal 67. L'indicateur de retenue est activé. La séquence d'instructions.
ADDC A, R3
DA A
effectuera d'abord une addition binaire standard à complément à deux, ce qui donnera la valeur 0BEH
(10111110) dans l’accumulateur. Les drapeaux de transport et de transport auxiliaire seront effacés.
L'instruction Decimal Adjust modifiera alors l'accumulateur à la valeur 24H (00100100B),

indiquant les chiffres BCD compressés du nombre décimal 24, les deux chiffres de poids faible de la
somme décimale de 56,67 et le report. L'indicateur de report sera activé par l'instruction Decimal Adjust,
indiquant qu'un dépassement décimal s'est produit. La vraie somme 56, 67 et 1 est 124.
Les variables BCD peuvent être incrémentées ou décrémentées en ajoutant 01H ou 99H. Si l'accumulateur
contient initialement 30H (représentant les chiffres de 30 décimales), alors la séquence d'instructions,
AJOUTER UN,#99H
DA A
laissera le carry set et 29H dans l'Accumulateur, puisque 30+99=129. L'octet de poids faible de la somme
peut être interprété comme signifiant 30 – 1 = 29.
50
Octets : 1
Cycles : 1
Codage: 11010100
Fonctionnement : DA
le contenu de l'accumulateur est en BCD
SI [[(A30) > 9] V [(AC) = 1]]
ALORS(A30) ← (A30) + 6
ET
SI [[(A74) > 9] V [(C) = 1]]
ALORS (A74) ← (A74) + 6
Octet DEC
Fonction : Décrémenter
Description : La variable indiquée est décrémentée de 1. Une valeur originale de 00H passera en dessous de
0FFH.
Aucun drapeau n'est affecté. Quatre modes d'adressage d'opérandes sont autorisés : accumulateur,
registre, direct ou registreindirect.
Remarque : Lorsque cette instruction est utilisée pour modifier un port de sortie, la valeur utilisée comme données de
port d'origine sera lue à partir du verrou de données de sortie, et non des broches d'entrée.
Exemple : le registre 0 contient 7FH (01111111B). Les emplacements de RAM interne 7EH et 7FH contiennent
respectivement 00H et 40H. La séquence d'instructions,
DÉC @R0
DÉC R0
DÉC @R0
laissera le registre 0 défini sur 7EH et les emplacements RAM internes 7EH et 7FH définis sur 0FFH
et 3FH.
DÉC A
Octets : 1
Cycles : 1
Codage: 0001 0100
Opération : DÉC.
(UNE) (UNE) 1
DÉC Rn
Octets : 1
Cycles : 1
Codage: 0001 1 rrr
Opération : DÉC.
(Rn) (Rn) 1
51
DÉC direct
Octets : 2
Cycles : 1
Opération : DÉC.
(direct) (direct) 1
DEC @Ri
Octets : 1
Cycles : 1
Codage: 0001 0 1 1 je
Opération : DÉC.
((Ri)) ((Ri)) 1
DIVAB
Fonction : Diviser
Description : DIV AB divise l'entier de huit bits non signé dans l'accumulateur par l'entier de huit bits non signé.
entier dans le registre B. L'Accumulateur reçoit la partie entière du quotient ; registre B
reçoit le reste entier. Les drapeaux carry et OV seront effacés.
Exception : si B contenait à l'origine 00H, les valeurs renvoyées dans l'accumulateur et le registre B ne
seront pas définies et l'indicateur de débordement sera activé. Le drapeau de report est effacé dans n'importe quel
cas.
Exemple : L'accumulateur contient 251 (OFBH ou 11111011B) et B contient 18 (12H ou 00010010B).

L'instruction,
DIVAB
laissera 13 dans l'Accumulateur (0DH ou 00001101B) et la valeur 17 (11H ou 00010010B)

en B, puisque 251 = (13×18) + 17. Carry et OV seront tous deux effacés.
Octets : 1
Cycles : 4
Codage: 10000100
Opération : DIV
(A)158
(B)70 ← (A)/(B)
52
DJNZ <octet>, <adresserel>

Fonction : Décrémenter et sauter si ce n'est pas zéro
Description : DJNZ décrémente l'emplacement indiqué de 1, et bifurque vers l'adresse indiquée par le
deuxième opérande si la valeur résultante n’est pas nulle. Une valeur originale de 00H sera inférieure à
0FFH. Aucun drapeau n'est affecté. La destination de la branche serait calculée en ajoutant le signé
valeur de déplacement relatif dans le dernier octet d'instruction vers le PC, après avoir incrémenté le PC
jusqu'au premier octet de l'instruction suivante.
L'emplacement décrémenté peut être un registre ou un octet directement adressé.
Exemple : les emplacements RAM internes 40H, 50H et 60H contiennent les valeurs 01H, 70H et 15H,
respectivement. La séquence d'instructions,
DJNZ 40H, LABEL_1

DJNZ 50H, LABEL_2
DJNZ 60H, LABEL_3
provoquera un saut vers l'instruction à l'étiquette LABEL_2 avec les valeurs 00H, 6FH et 15H dans
les trois emplacements RAM. Le premier saut n’a pas été réalisé car le résultat était nul.
Cette instruction permet d'exécuter simplement une boucle de programme un nombre de fois donné,
soit pour ajouter une temporisation modérée (de 2 à 512 cycles machine) avec une seule instruction La
séquence d'instructions,
MOUVEMENT R2, #8
OUTIL : CPL P1.7
DJNZ R2, TOOGLE
basculera P1.7 huit fois, provoquant l'apparition de quatre impulsions de sortie au bit 7 du port de sortie 1.
Chaque impulsion durera trois cycles machine ; deux pour DJNZ et un pour modifier la broche.
DJNZ Rn,rel
Octets : 2
Cycles : 2
Codage: 1101 1 rrr rel. adresse
Opération : DJNZ
(PC) ← (PC) + 2
(Rn) ← (Rn) – 1
SI (Rn) > 0 ou (Rn) < 0

ALORS
(PC) ← (PC)+ rel
DJNZ direct, rel.
Octets : 3
Cycles : 2
Codage: 1101 0101 adresse directe rel. adresse
53
Opération : DJNZ
(PC) ← (PC) + 2
(direct) ← (direct) – 1
SI (direct) > 0 ou (direct) < 0
ALORS
(PC) ← (PC) + rel
INC <octet>
Fonction : Incrément
Description : INC incrémente la variable indiquée de 1. Une valeur originale de 0FFH débordera vers
00H.Aucun drapeau n’est affecté. Trois modes d'adressage sont autorisés : registre, direct ou registre
indirect.
Remarque : Lorsque cette instruction est utilisée pour modifier un port de sortie, la valeur utilisée comme valeur d'origine
les données du port seront lues à partir du verrou de données de sortie, et non des broches d'entrée.
Exemple : le registre 0 contient 7EH (011111110B). Les emplacements RAM internes 7EH et 7FH contiennent 0FFH
et 40H, respectivement. La séquence d'instructions,
INC @R0
INC R0
INC @R0
laissera le registre 0 réglé sur 7FH et les emplacements RAM internes 7EH et 7FH contenant
(respectivement) 00H et 41H.
INC A
Octets : 1
Cycles : 1
Codage: 00000100
Opération : INC
(A) ← (A)+1
INC Rn
Octets : 1
Cycles : 1
Codage: 0000 1 rrr
Opération : INC
(Rn) ←( )+1
INC direct
Octets : 2
Cycles : 1
Opération : INC
(direct) (direct) +1
54
INC @Ri
Octets : 1
Cycles : 1
Codage: 0000 0 1 1 je
Opération : INC
((Ri)) ((Ri)) + 1
INC DPTR
Fonction : incrémenter le pointeur de données
Description : Incrémentez le pointeur de données 16 bits de 1. Un incrément de 16 bits (modulo 216) est effectué ; un
le dépassement de l'octet de poids faible du pointeur de données (DPL) de 0FFH à 00H incrémentera
l'octet de poids fort (DPH). Aucun drapeau n'est affecté.
C'est le seul registre de 16 bits pouvant être incrémenté.
Exemple : les registres DPH et DPL contiennent respectivement 12H et 0FEH. La séquence d'instructions,
INC DPTR
INC DPTR
INC DPTR
changera DPH et DPL à 13H et 01H.
Octets : 1
Cycles : 2
Codage: 10100011
Opération : INC
(DPTR) ← (DPT )+1
JB peu, rel
Fonction : Sauter si le bit est défini
Description : Si le bit indiqué est un, passez à l'adresse indiquée ; sinon, passez à l'instruction suivante. La destination du
branchement est calculée en ajoutant le déplacement relatif signé dans le troisième octet d'instruction au
PC, après avoir incrémenté le PC jusqu'au premier octet de l'instruction suivante. Le bit testé n'est pas
modifié. Aucun drapeau n'est affecté.
Exemple : Les données présentes sur le port d'entrée 1 sont 11001010B. L'accumulateur en contient 56 (01010110B). Le
la séquence
d'instructions, JB P1.2,
LABEL1 JB ACC.2, LABEL2
entraînera le branchement de l'exécution du programme à l'instruction portant l'étiquette LABEL2.
Octets : 3
Cycles : 2
Codage: 0010 0000 adresse de bit rel. adresse
Opération : JB
(PC) ← (PC)+ 3
SI (bit) = 1
ALORS
(PC) ← (PC) + rel
55
Bit JBC, rel

Fonction : Sauter si le bit est défini et effacer le bit
Description : Si le bit indiqué est un, branchez à l'adresse indiquée ; sinon passez à l'instruction suivante. Le bit ne sera
pas effacé s'il est déjà à zéro. La destination du branchement est calculée en ajoutant le
déplacement relatif signé dans le troisième octet d'instruction au PC, après avoir incrémenté le PC
jusqu'au premier octet de l'instruction suivante. Aucun drapeau n'est affecté.
Remarque : lorsque cette instruction est utilisée pour tester une broche de sortie, la valeur utilisée comme données d'origine
sera lu à partir du verrou de données de sortie, pas de la broche d'entrée.
Exemple : L'accumulateur contient 56H (01010110B). La séquence d'instructions,

JBC ACC.3, ÉTIQUETTE1
JBC ACC.2, ÉTIQUETTE2
entraînera la poursuite de l'exécution du programme à l'instruction identifiée par l'étiquette LABEL2, avec
l'accumulateur modifié à 52H (01010010B).
Octets : 3
Cycles : 2
Opération : JBC
(PC) ← (PC)+ 3
SI (bit) = 1
ALORS
(bits) ←0
(PC) ← (PC) + rel
JC rel
Fonction : Sauter si Carry est activé
Description : Si l'indicateur de report est activé, branchezvous à l'adresse indiquée ; sinon, passez au suivant
instruction. La destination de branchement est calculée en ajoutant le déplacement relatif signé dans le
deuxième octet d'instruction au PC, après avoir incrémenté le PC deux fois. Aucun indicateur n'est affecté.
Exemple : l'indicateur de report est effacé. La séquence d'instructions,

ÉTIQUETTE JC1
CPLC
JC LABEL2s
définira le report et provoquera la poursuite de l'exécution du programme à l'instruction identifiée par le

étiquette ÉTIQUETTE2.
Octets : 2
Cycles : 2
Codage: 0100 0000 rel. adresse
Opération : JC
(PC) ← (PC)+ 2
SI (C) = 1
ALORS
(PC) ← (PC) + rel
56
JMP @A+DPTR
Fonction : Saut indirect
Description : ajoutez le contenu non signé de huit bits de l'accumulateur avec le pointeur de données de seize bits et
chargez la somme résultante dans le compteur du programme. Ce sera l’adresse pour les récupérations
d’instructions ultérieures. Une addition de seize bits est effectuée (modulo 216) : un report à partir des huit
bits de poids faible se propage à travers les bits de poids fort. Ni l'accumulateur ni le pointeur de données
ne sont modifiés. Aucun drapeau n'est affecté.
Exemple : Un nombre pair de 0 à 6 se trouve dans l'accumulateur. La séquence d'instructions suivante
se branchera sur l'une des quatre instructions AJMP dans une table de sauts commençant à JMP_TBL :
MOUVEMENT DPTR, #JMP_TBL

JMP @A+DPTR
JMPTBL : AJMP LABEL0
ÉTIQUETTE AJMP1
ÉTIQUETTE AJMP2
ÉTIQUETTE AJMP3
Si l'accumulateur est égal à 04H au démarrage de cette séquence, l'exécution passera à l'étiquette
ÉTIQUETTE2. N'oubliez pas qu'AJMP est une instruction sur deux octets, donc les instructions de saut commencent
à une adresse sur deux.
Octets : 1
Cycles : 2
Codage: 0111 0011
Opération : JMP
(PC) ← (A) + (DPTR)
Bit JNB, rel

Fonction : Sauter si le bit n'est pas défini
Description : Si le bit indiqué est un zéro, branchezvous à l'adresse indiquée ; sinon, passez au suivant
instruction. La destination du branchement est calculée en ajoutant le déplacement relatif signé dans le
troisième octet d'instruction au PC, après avoir incrémenté le PC au premier octet du prochain octet.
instruction. Le bit testé n'est pas modifié. Aucun drapeau n'est affecté.
Exemple : Les données présentes sur le port d'entrée 1 sont 11001010B. L'accumulateur contient 56H (01010110B).
La séquence d'instructions,
JNB P1.3, ÉTIQUETTE1
JNB ACC.3, ÉTIQUETTE2
entraînera la poursuite de l'exécution du programme à l'instruction sur l'étiquette LABEL2

Octets : 3
Cycles : 2
Opération : JNB
(PC) ← (PC)+ 3
SI (bit) = 0
ALORS (PC) ← (PC) + rel
57
JNC rel
Fonction : Sauter si le transport n'est pas défini
Description : Si l'indicateur de report est à zéro, branchezvous à l'adresse indiquée ; sinon, passez au suivant
instruction. La destination de branchement est calculée en ajoutant le déplacement relatif signé dans le
deuxième octet d'instruction au PC, après avoir incrémenté le PC deux fois pour pointer vers le prochain.
instruction. Le drapeau de report n'est pas modifié
Exemple : l'indicateur de report est activé. La séquence d'instructions,
ÉTIQUETTE JNC1
CPLC
ÉTIQUETTE JNC2
effacera le report et provoquera la poursuite de l'exécution du programme à l'instruction identifiée par

l'étiquette LABEL2.
Octets : 2
Cycles : 2
Opération : JNC
(PC) ← (PC)+ 2
SI (C) = 0
JNZrel
Fonction : Sauter si l'accumulateur n'est pas nul
Description : Si un bit de l'accumulateur est à un, branchezvous à l'adresse indiquée ; sinon continuez
avec l'instruction suivante. La destination du branchement est calculée en ajoutant le déplacement relatif signé
dans le deuxième octet d'instruction au PC, après avoir incrémenté le PC deux fois. Le
L'accumulateur n'est pas modifié. Aucun drapeau n'est affecté.
Exemple : l'accumulateur contient à l'origine 00H. La séquence d'instructions,
ÉTIQUETTE JNZ1
INC A
JNZ LAEEL2
définira l'accumulateur sur 01H et continuera à l'étiquette LABEL2.
Octets : 2
Cycles : 2
Opération : JNZ
(PC) ← (PC)+ 2
SI (A) ≠ 0
58
JZ rel
Fonction : Sauter si l'accumulateur est nul
Description : Si tous les bits de l'Accumulateur sont à zéro, branchezvous à l'adresse indiquée ; sinon, passez à l'instruction
suivante. La destination du branchement est calculée en ajoutant le déplacement relatif signé dans le deuxième
octet d'instruction au PC, après avoir incrémenté le PC deux fois. Le
L'accumulateur n'est pas modifié. Aucun drapeau n'est affecté.
Exemple : L'accumulateur contient à l'origine 01H. La séquence d'instructions,
ÉTIQUETTE JZ1
DÉC A
JZ LAEEL2
changera l'accumulateur à 00H et entraînera la poursuite de l'exécution du programme selon
l'instruction identifiée par l'étiquette LABEL2.
Octets : 2
Cycles : 2
Opération : JZ
(PC) ← (PC)+ 2
SI (A) = 0
Adresse LCALL16
Fonction : Appel long
Description : LCALL appelle un sousprogramme situé à l'adresse indiquée. L'instruction en ajoute trois au compteur du
programme pour générer l'adresse de l'instruction suivante, puis pousse le 16 bits
résultat sur la pile (l'octet faible en premier), en incrémentant le pointeur de pile de deux. Les octets de poids
fort et de poids faible du PC sont ensuite chargés respectivement avec les deuxième et troisième octets de
l'instruction LCALL. L'exécution du programme continue avec l'instruction à cette adresse.
Le sousprogramme peut donc commencer n'importe où dans l'espace d'adressage complet de la mémoire programme
de 64 Ko. Aucun drapeau n'est affecté.
Exemple : initialement, le pointeur de pile est égal à 07H. Le label « SUBRTN » est attribué à la mémoire programme
lieu 1234H. Après avoir exécuté l'instruction,
LCALL SUBRTN
à l'emplacement 0123H, le pointeur de pile contiendra 09H, les emplacements RAM internes 08H et 09H
contiendra 26H et 01H, et le PC contiendra 1234H.
Octets : 3
Cycles : 2
Codage: 0001 0010 adresse15adresse8 adresse7adresse0
Opération : LCALL
(PC) ← (PC) + 3
(SP) ← (SP) + 1
((SP)) ← (PC70)
(SP) ← (SP) + 1
((SP)) ← (PC158)
(PC) ← adresse 150
59
Adresse LJMP16
Fonction : Saut en longueur
Description : LJMP provoque un branchement inconditionnel vers l'adresse indiquée, en chargeant le code d'ordre supérieur
et les octets de poids faible du PC (respectivement) avec les deuxième et troisième octets d'instruction. La destination
peut donc se trouver n'importe où dans l'espace d'adressage complet de la mémoire programme de 64 Ko. Aucun
drapeau n'est affecté.
Exemple : L'étiquette « JMPADR » est attribuée à l'instruction à l'emplacement mémoire programme 1234H. Le
instruction,
LJMP JMPADR
à l'emplacement 0123H chargera le compteur de programme avec 1234H.
Octets : 3
Cycles : 2
Codage: 0000 0010 adresse15adresse8 adresse7adresse0
Opération : LJMP
(PC) ← adresse 150
MOV <destbyte> , <srcbyte>

Fonction : Déplacer la variable d'octet
Description : La variable d'octet indiquée par le deuxième opérande est copiée à l'emplacement spécifié par le
premier opérande. L'octet source n'est pas affecté. Aucun autre registre ou drapeau n’est concerné.
C'est de loin l'opération la plus flexible. Quinze combinaisons de modes d'adressage source et destination sont
autorisées.
Exemple : l'emplacement RAM interne 30 H contient 40 H. La valeur de l'emplacement RAM 40H est 10H. Les données présentes
sur le port d'entrée 1 sont 11001010B (0CAH).
MOUVEMENT R0, #30H ;R0< = 30H

MOUVEMENT A, @R0 ;A < = 40H
MOUVEMENT R1, A ;R1 < = 40H
MOUVEMENT B, @Rl ;B < = 10H
MOV @Rl, Pl ;RAM (40H) < = 0CAH
MOUVEMENT P2, P1 ;P2 #0CAH
laisse la valeur 30H dans le registre 0,40H à la fois dans l'accumulateur et dans le registre 1,10H dans le registre B,
et 0CAH(11001010B) à la fois dans l'emplacement RAM 40H et en sortie sur le port 2.
MOUVEMENT A,Rn
Octets : 1
Cycles : 1
Codage: 11 dix 1 rrr
Opération : MOV
(A) ← (Rn)
60
*MOV A, direct
Octets : 2
Cycles : 1
Opération : MOV
(A) ← (direct)
*MOV A, ACC n'est pas une instruction valide

MOV A,@Ri
Octets : 1
Cycles : 1
Codage: 11 dix 0 1 1 je
Opération : MOV
(A) ← ((Ri))
MOV A,#données
Octets : 2
Cycles : 1
Opération : MOV
(A) ← #données
MOV Rn, A
Octets : 1
Cycles : 1
Codage: 1111 1 rrr
Opération : MOV
(Rn) (A)
MOV Rn,direct
Octets : 2
Cycles : 2
Codage: 1010 1 rrr adresse directe.
Opération : MOV
(Rn) (direct)
MOV Rn,#données
Octets : 2
Cycles : 1
Codage: 0111 1 rrr données immédiates
Opération : MOV
(Rn) ← #données
61
MOV direct, A
Octets : 2
Cycles : 1
Opération : MOV
(direct) ← (A)
MOV direct, Rn
Octets : 2
Cycles : 2
Codage: 1000 1 rrr adresse directe
Opération : MOV
(direct) ← (Rn)
MOV direct, direct

Octets : 3
Cycles : 2
Codage: 1000 0101 dir.addr. (src)
Opération : MOV
(direct) ← (direct)
MOV direct, @Ri

Octets : 2
Cycles : 2
Codage: 1000 0 1 1 je adresse directe.
Opération : MOV
(direct) ((Ri))
MOV direct,#données
Octets : 3
Cycles : 2
Opération : MOV
(direct) ← #données
MOV @Ri, A
Octets : 1
Cycles : 1
Codage: 1111 0 1 1 je
Opération : MOV
((Ri)) ← (UNE)
62
MOV @Ri, direct
Octets : 2
Cycles : 2
Codage: 1010 0 1 1 je adresse directe.
Opération : MOV
((Ri)) ← (direct)
MOV @Ri, #données
Octets : 2
Cycles : 1
Codage: 0111 0 1 1 je données immédiates
Opération : MOV
((Ri)) ← #données
MOV <bit de destination> , <bitsrc>

Fonction : déplacer les données binaires
Description : La variable booléenne indiquée par le deuxième opérande est copiée à l'emplacement spécifié par
le premier opérande. L'un des opérandes doit être le drapeau de report ; l'autre peut être n'importe quel bit
directement adressable. Aucun autre registre ou drapeau n’est concerné.
Exemple : l'indicateur de report est défini à l'origine. Les données présentes sur le port d'entrée 3 sont 11000101B. Les données
précédemment écrit sur le port de sortie 1 est 35H (00110101B).
MOV P1.3, C
MOV C, P3.3
MOV P1.2, C
laissera le report effacé et changera le port 1 en 39H (00111001B).
MOV C,bit
Octets : 2
Cycles : 1
Opération : MOV
(C) ← (bit)
Bit MOV,C
Octets : 2
Cycles : 2
Codage: 10010010 adresse de bit
Opération : MOV
(bits) ← (C)
63
MOUVEMENT DPTR , #données 16

Fonction : Charger un pointeur de données avec une constante de 16 bits
Description : Le pointeur de données est chargé avec la constante de 16 bits indiquée. La constante de 16 bits est chargée dans les
deuxième et troisième octets de l'instruction. Le deuxième octet (DPH) est le poids fort
octet, tandis que le troisième octet (DPL) contient l'octet de poids faible. Aucun drapeau n'est affecté.
C'est la seule instruction qui déplace 16 bits de données à la fois.
Exemple : l'instruction,
MOUVEMENT DPTR, #1234H
chargera la valeur 1234H dans le pointeur de données : DPH contiendra 12H et DPL tiendra 34H.
Octets : 3
Cycles : 2
Codage: 10010000 données immédiates 158
Opération : MOV
(DPTR) ← #données 150
DPH DPL ← #données158 #données70
MOVC A , @A+ <basereg>

Fonction : déplacer l'octet de code
Description : Les instructions MOVC chargent l'accumulateur avec un octet de code ou une constante du programme.
mémoire. L'adresse de l'octet récupéré est la somme des huit bits non signés d'origine.
Contenu de l'accumulateur et contenu d'un registre de base de seize bits, qui peut être soit le pointeur de
données, soit le PC. Dans ce dernier cas, le PC est incrémenté à l'adresse de l'instruction suivante avant d'être
ajouté à l'Accumulateur ; sinon le registre de base n'est pas modifié. Une addition de seize bits est effectuée afin
qu'un report à partir des huit bits de poids faible puisse se propager à travers les bits de poids fort. Aucun drapeau
n'est affecté.
Exemple : Une valeur comprise entre 0 et 3 se trouve dans l'accumulateur. Les instructions suivantes traduiront le
valeur dans l'accumulateur à l'une des quatre valeurs définies par la directive DB (define byte).
RELPC : INC A
MOVCA, @A+PC
RETRAIT
Base de données 66H

Si le sousprogramme est appelé avec l'Accumulateur égal à 01H, il reviendra avec 77H dans le
Accumulateur. L'INC A avant l'instruction MOVC est nécessaire pour « contourner » le RET
instructions audessus de la table. Si plusieurs octets de code séparaient le MOVC de la table, le
le numéro correspondant serait ajouté à l’accumulateur à la place.
MOVCA,@A+DPTR
Octets : 1
Cycles : 2
Codage: 1001 0011
Opération : MOVC
(A) ← ((A)+(DPTR))
64
MOVCA,@A+PC
Octets : 1
Cycles : 2
Codage: 1000 0011
Opération : MOVC
(PC) ← (PC)+1
(A) ← ((A)+(PC))
MOVX <octetdest> , <octetsrc>

Fonction : Déplacer externe
Description : Les instructions MOVX transfèrent des données entre l'accumulateur et un octet de mémoire de données externe,
d'où le « X » ajouté à MOV. Il existe deux types d'instructions, qui diffèrent par
s'ils fournissent une adresse indirecte de huit ou seize bits à la RAM de données externe.
Dans le premier type, le contenu de R0 ou R1 dans la banque de registres actuelle fournit un code de huit bits.
adresse multiplexée avec les données sur P0. Huit bits suffisent pour le décodage d’extension d’E/S externe ou
pour une matrice RAM relativement petite. Pour les tableaux un peu plus grands, toutes les broches du port de
sortie peuvent être utilisées pour générer des bits d'adresse d'ordre supérieur. Ces broches seraient contrôlées par un
instruction de sortie précédant le MOVX.
Dans le deuxième type d'instruction MOVX, le pointeur de données génère une adresse de seize bits.
P2 génère les huit bits d'adresse de poids fort (le contenu de DPH) tandis que P0 multiplexe les huit bits de
poids faible (DPL) avec des données. Le registre de fonctions spéciales P2 conserve son contenu précédent
tandis que les tampons de sortie P2 émettent le contenu de DPH. Ce formulaire est plus rapide et
plus efficace lors de l'accès à de très grands tableaux de données (jusqu'à 64 Ko), car aucune instruction
supplémentaire n'est nécessaire pour configurer les ports de sortie.
Il est possible dans certaines situations de mélanger les deux types MOVX. Un grand réseau de RAM avec
ses lignes d'adresse d'ordre élevé pilotées par P2 peut être adressé via le pointeur de données, ou avec un
code pour sortir des bits d'adresse d'ordre élevé vers P2 suivis d'une instruction MOVX utilisant R0 ou R1.
Exemple : Une RAM externe de 256 octets utilisant des lignes d'adresses/données multiplexées (par exemple, une RAM/Intel 8155
I/O/Timer) est connecté au port 0 du 8051. Le port 3 fournit des lignes de contrôle pour la RAM externe.
Les ports 1 et 2 sont utilisés pour les E/S normales. Les registres 0 et 1 contiennent 12H et 34H.
L'emplacement 34H de la RAM externe contient la valeur 56H. La séquence d'instructions,
MOVXA, @R1
MOVX @R0, A
copie la valeur 56H dans l'accumulateur et dans l'emplacement 12H de la RAM externe.
MOVX A,@Ri
Octets : 1
Cycles : 2
Fonctionnement : MOVX
(A) ← ((Ri))
65
MOVX A,@DPTR
Octets : 1
Cycles : 2
Codage: 1110 0000
(A) ← ((DPTR))
MOVX @Ri, A
Octets : 1
Cycles : 2
Codage: 1111 0 0 1 je
((Ri)) ← (A)
MOVX @DPTR, A
Octets : 1
Cycles : 2
Codage: 1111 0000
(DPTR) (A)
MUL AB
Fonction : Multiplier
Description : MUL AB multiplie les entiers non signés de huit bits dans l'accumulateur et le registre B. L'octet de poids
faible du produit de seize bits est laissé dans l'accumulateur et l'octet de poids fort dans B. Si le produit
est supérieur à 255 (0FFH) le drapeau de débordement est activé ; sinon, il est effacé.
Le drapeau de portage est toujours effacé
Exemple : À l'origine, l'accumulateur contient la valeur 80 (50H). Le registre B contient la valeur 160 (0A0H).
L'instruction,
MUL AB
donnera au produit 12 800 (3200H), donc B est remplacé par 32H (00110010B) et
l'accumulateur est effacé. L'indicateur de débordement est activé, le report est effacé.
Octets : 1
Cycles : 4
Codage: 10100100
Fonctionnement : MUL
(A)70 ← (A)×(B)
(B)158
66
NON
Fonction : Aucune opération
Description : L'exécution se poursuit à l'instruction suivante. Hormis le PC, aucun registre ou indicateur n'est
affecté.
Exemple : il est souhaité de produire une impulsion de sortie faible sur le bit 7 du port 2 durant exactement 5 cycles. Une
simple séquence SETB/CLR générerait une impulsion d’un cycle, donc quatre cycles supplémentaires
doivent être insérés. Cela peut être fait (en supposant qu'aucune interruption n'est activée) avec l'instruction
séquence.
CLR P2.7
NON
NON
NON
NON
SETB P2.7
Octets : 1
Cycles : 1
Codage: 00000000
Opération : NOP
(PC) ← (PC)+1
ORL <destbyte> , <srcbyte>

Fonction : OU logique pour les variables d'octet
Description : ORL effectue l'opération OU logique au niveau du bit entre les variables indiquées, en stockant les résultats
dans l'octet de destination. Aucun drapeau n'est affecté.
l'accumulateur, la source peut utiliser un adressage par registre, direct, par registre indirect ou immédiat ;
lorsque la destination est une adresse directe, la source peut être l'accumulateur ou des données
immédiates.
Exemple : Si l'accumulateur contient 0C3H (11000011B) et que R0 contient 55H (01010101B), alors l'instruction,
ORL A, R0
laissera l'accumulateur contenant la valeur 0D7H (11010111B).

Lorsque la destination est un octet directement adressé, l'instruction peut définir des combinaisons de bits dans
n'importe quel emplacement RAM ou registre matériel. Le modèle de bits à définir est déterminé par un
octet de masque, qui peut être soit une valeur de données constante dans l'instruction, soit une
variable calculée dans l'accumulateur au moment de l'exécution. L'instruction,
ORL P1, #00110010B
définira les bits 5, 4 et 1 du port de sortie 1.
67
ORL A,Rn
Octets : 1
Cycles : 1
Codage: 01001 rrr
Opération : ORL
(A) ← (A) (Rn)
ORL A,direct
Octets : 2
Cycles : 1
Codage: 01000101 adresse directe
Opération : ORL
(A) ← (A) (direct)
ORL A,@Ri
Octets : 1
Cycles : 1
Codage: 010001 1 je
Opération : ORL
(A) ← (A) ((Ri))
ORL A,#données
Octets : 2
Cycles : 1
Codage: 01000100 données immédiates
Opération : ORL
(A) ← (A) #données
ORL direct, A
Octets : 2
Cycles : 1
Opération : ORL
(direct) ← (direct) (A)
ORL direct, #données

Octets : 3
Cycles : 2
Codage: 0100001 1 adresse directe données immédiates
Opération : ORL
(direct) ← (direct) #données
68
ORL C, <bitsrc>
Fonction : OU logique pour les variables binaires
Description : définit l'indicateur de retenue si la valeur booléenne est un 1 logique ; laisser le carry dans son état actuel
sinon. Une barre oblique (« / ») précédant l'opérande dans le langage assembleur indique que le
Le complément logique du bit adressé est utilisé comme valeur source, mais le bit source luimême est
pas affecté. Aucun autre drapeau n'est affecté.
Exemple : définissez l'indicateur de report si et seulement si P1.0 = 1, ACC. 7 = 1, ou VO = 0 :

MOV C, P1.0 ORL ; TRANSPORT DE CHARGE AVEC BROCHE D'ENTRÉE P10
C, ACC.7 ORL C, /OV ;OU EMPORTER AVEC L'ACC.BIT 7
;OU PORTER AVEC L'INVERSE DE OV
ORL C, bit
Octets : 2
Cycles : 2
Codage: 01 1 1 0010 adresse de bit
Opération : ORL
(C) ← (C) (bit)
ORL C, /bit
Octets : 2
Cycles : 2
Codage: 10100000 adresse de bit
Opération : ORL
(C) ← (C) (bit)
PLV directe
Fonction : pop de la pile
Description : le contenu de l'emplacement RAM interne adressé par le pointeur de pile est lu et le
Le pointeur de pile est décrémenté de un. La valeur lue est ensuite transférée vers l'octet directement
adressé indiqué. Aucun drapeau n'est affecté.
Exemple : le pointeur de pile contient à l'origine la valeur 32H et les emplacements RAM internes 30H.
à 32H contiennent respectivement les valeurs 20H, 23H et 01H. La séquence d'instructions,
POP DPH
Responsable du projet POP
laissera le pointeur de pile égal à la valeur 30H et le pointeur de données défini sur 0123H. À ceci
pointez l'instruction,
POP SP
laissera le pointeur de pile réglé sur 20H. Notez que dans ce cas particulier, le Stack Pointer était
décrémenté à 2FH avant d'être chargé avec la valeur sautée (20H).
Octets : 2
Cycles : 2
Codage: 1 101 0000 adresse directe
Opération : POP
(diect) ← ((SP))
(SP) ← (SP) 1
69
POUSSER directement
Fonction : Passer sur la pile
Description : le pointeur de pile est incrémenté de un. Le contenu de la variable indiquée est ensuite copié
dans l’emplacement RAM interne adressé par le pointeur de pile. Sinon, aucun drapeau n'est affecté.
Exemple : lors de l'entrée dans la routine d'interruption, le pointeur de pile contient 09H. Le pointeur de données contient le
valeur 0123H. La séquence d'instructions,
POUSSER LE DPL
POUSSER DPH
laissera le pointeur de pile réglé sur 0BH et stockera 23H et 01H dans les emplacements RAM internes
0AH et 0BH, respectivement.
Octets : 2
Cycles : 2
Fonctionnement : POUSSER
(SP) ← (SP) + 1
((SP)) ← (direct)
RETRAIT
Fonction : Retour du sousprogramme
Description : RET extrait successivement les octets de poids fort et faible du PC de la pile, décrémentant le pointeur de pile de deux. L'exécution
du programme se poursuit à l'adresse résultante, généralement l'instruction qui suit immédiatement un ACALL ou un LCALL.
Aucun drapeau n'est affecté.
Exemple : le pointeur de pile contient à l'origine la valeur 0BH. Emplacements RAM internes 0AH et 0BH
contiennent respectivement les valeurs 23H et 01H. L'instruction,
RETRAIT
laissera le pointeur de pile égal à la valeur 09H. L'exécution du programme se poursuivra à l'emplacement 0123H.
Octets : 1
Cycles : 2
Codage: 00100010
Opération : RET
(PC158) ← ((SP))
(SP) ← (SP) 1
(PC70) ← ((SP))
(SP) ← (SP) 1
70
RÉTI
Fonction : Retour d'une interruption
Description : RETI extrait successivement les octets de poids fort et faible du PC de la pile et restaure la logique
d'interruption pour accepter des interruptions supplémentaires au même niveau de priorité que celle
qui vient d'être traitée. Le pointeur de pile est décrémenté de deux. Aucun autre registre n'est concerné ;
le PSW n'est pas automatiquement restauré à son état d'avant l'interruption. L'exécution du programme
se poursuit à l'adresse résultante, qui est généralement l'instruction immédiatement après le point
auquel la demande d'interruption a été détectée. Si une interruption de niveau inférieur ou de même
niveau était en attente lorsque l'instruction RETI est exécutée, cette instruction sera exécutée avant
le traitement de l'interruption en attente.
Exemple : le pointeur de pile contient à l'origine la valeur 0BH. Une interruption a été détectée pendant l'instruction
se terminant à l'emplacement 0122H. Les emplacements RAM internes 0AH et 0BH contiennent
respectivement les valeurs 23H et 01H. L'instruction,
RÉTI
laissera le pointeur de pile égal à 09H et renverra l'exécution du programme à l'emplacement 0123H.
Octets : 1
Cycles : 2
Codage: 0011 0010
Opération : RETI
(PC158) ← ((SP))
(SP) ← (SP) 1
(PC70) ← ((SP))
(SP) ← (SP) 1
RL A
Fonction : faire pivoter l'accumulateur vers la gauche
Description : Les huit bits de l'accumulateur pivotent d'un bit vers la gauche. Le bit 7 est transformé en bit 0
position. Aucun drapeau n'est affecté.
Exemple : L'accumulateur contient la valeur 0C5H (11000101B). L'instruction,
RL A
laisse l'accumulateur détenant la valeur 8BH (10001011B) avec le report inchangé.
Octets : 1
Cycles : 1
Codage: 0010001 1
Opération : RL
(An+1) ← (An) n = 06
(A0) ← (A7)
71
RLC A
Fonction : faire pivoter l'accumulateur vers la gauche via le drapeau de transport
Description : Les huit bits de l'accumulateur et l'indicateur de retenue sont pivotés ensemble d'un bit vers la gauche. Peu
7 se déplace vers le drapeau de portage ; l'état d'origine du drapeau de retenue passe à la position bit 0.
Aucun autre drapeau n'est affecté.
Exemple : l'accumulateur contient la valeur 0C5H (11000101B) et le report est nul. L'instruction,
RLC A
laisse l'accumulateur contenant la valeur 8BH (10001011B) avec l'ensemble de transport.
Octets : 1
Cycles : 1
Codage: 0011 001 1
Opération : RLC
(An+1) ← (An) n = 06
(A0) ← (C)
(C) ← (A7)
RR A
Fonction : faire pivoter l'accumulateur vers la droite
Description : Les huit bits de l'accumulateur pivotent d'un bit vers la droite. Le bit 0 est transformé en bit 7
position. Aucun drapeau n'est affecté.
RR A
laisse l'accumulateur contenant la valeur 0E2H (11100010B) avec le report inchangé.
Octets : 1
Cycles : 1
Codage : 0000001 1
Opération : RR
(An) ← (An+1) n = 0 6
(A7) ← (A0)
CRR A
Fonction : faire pivoter l'accumulateur à travers le drapeau de transport
Description : Les huit bits de l'accumulateur et l'indicateur de report sont pivotés ensemble d'un bit vers la droite.
Le bit 0 passe dans l'indicateur de retenue ; la valeur originale de l'indicateur de report se déplace vers la
position du bit 7. Aucun autre indicateur n'est affecté.
Exemple : l'accumulateur contient la valeur 0C5H (11000101B) et le report est nul. L'instruction,
CRR A
laisse l'accumulateur contenant la valeur 62H (01100010B) avec le set de transport.
Octets : 1
Cycles : 1
Codage: 0001 001 1
Fonctionnement : RRC
(An+1) ← (An) n = 06
(A7) ← (C)
(C) ← (A0)
72
SETB <bit>
Fonction : définir le bit
Description : SETB définit le bit indiqué sur un. SETB peut fonctionner sur l'indicateur de retenue ou sur tout bit
directement adressable. Aucun autre drapeau n'est affecté
Exemple : l'indicateur de report est effacé. Le port de sortie 1 a été écrit avec la valeur 34H (00110100B).
Les instructions,
SETB C
SETB P1.0
laissera l'indicateur de report défini sur 1 et modifiera la sortie de données sur le port 1 en 35H (00110101B).
SETB C
Octets : 1
Cycles : 1
Codage: 1 101 001 1
Opération : SETB
(C) ←1
Bit SETB
Octets : 2
Cycles : 1
Opération : SETB
(bits) ←1
SJMP rel.
Fonction : saut court
Description : Le contrôle du programme se branche sans condition à l'adresse indiquée. La destination de la branche est
calculé en ajoutant le déplacement signé dans le deuxième octet d'instruction au PC, après
incrémenter le PC deux fois. Par conséquent, la plage de destinations autorisées va de 128 octets
précédant cette instruction à 127 octets la suivant.
Exemple : L'étiquette « RELADR » est attribuée à une instruction à l'emplacement mémoire programme 0123H.
L'instruction,
SJMP RELADR
se rassembleront à l'emplacement 0100H. Une fois l'instruction exécutée, le PC contiendra le
valeur 0123H.
(Remarque : dans les conditions cidessus, l'instruction suivant SJMP sera à 102H. Par conséquent,
l'octet de déplacement de l'instruction sera le décalage relatif (0123H 0102H) = 21H.
En d’autres termes, un SJMP avec un déplacement de 0FEH serait une boucle infinie à une instruction).
Octets : 2
Cycles : 2
Codage: 10000000 rel. adresse
Opération : SJMP
(PC) ← (PC)+2
(PC) ← (PC)+rel
73
SUBB A, <octetsrc>
Fonction : Soustraire avec emprunt
Description : SUBB soustrait ensemble la variable indiquée et l'indicateur de retenue de l'accumulateur,

laissant le résultat dans l’accumulateur. SUBB définit l'indicateur de report (emprunt) si un emprunt est nécessaire
pour le bit 7, et efface C dans le cas contraire. (Si C a été défini avant d'exécuter une instruction SUBB,
cela indique qu'un emprunt était nécessaire pour l'étape précédente dans une soustraction à précision multiple,
la retenue est donc soustraite de l'accumulateur avec l'opérande source). AC est défini si un emprunt est
nécessaire pour le bit 3, et effacé dans le cas contraire. OV est défini si un emprunt est nécessaire dans le bit
6, mais pas dans le bit 7, ou dans le bit 7, mais pas dans le bit 6.
Lors de la soustraction d'entiers signés, OV indique un nombre négatif produit lorsqu'un nombre négatif
la valeur est soustraite d’une valeur positive, ou un résultat positif lorsqu’un nombre positif est soustrait
d’un nombre négatif.
L'opérande source autorise quatre modes d'adressage : registre, direct, registreindirect ou immédiat.
Exemple : l'accumulateur contient 0C9H (11001001B), le registre 2 contient 54H (01010100B) et le

Le drapeau de report est défini. L'instruction,
SUBB A, R2
laissera la valeur 74H (01110100B) dans l'accumulateur, avec le drapeau de report et AC effacés
mais OV réglé.
Notez que 0C9H moins 54H équivaut à 75H. La différence entre ce résultat et le résultat cidessus est due
au drapeau de report (emprunt) étant défini avant l'opération. Si l'état du transport n'est pas connu
avant de commencer une soustraction en simple ou en précision multiple, elle doit être explicitement effacée par
une instruction CLR C.
SUBB A, Rn
Octets : 1
Cycles : 1
Codage: 1001 1 rrr
Opération : SUBB
(A) ← (A) (C) (Rn)
SUBB A, direct
Octets : 2
Cycles : 1
Opération : SUBB
(A) ← (A) (C) (direct)
SUBB A, @Ri
Octets : 1
Cycles : 1
Codage: 1001 01 1 je
Opération : SUBB
(A) ← (A) (C) ((Ri))
74
SUBB A, #données
Octets : 2
Cycles : 1
Codage: 10010100 données immédiates
Opération : SUBB
(A) ← (A) (C) #données
ÉCHANGER UN
Fonction : échanger des grignotines dans l'accumulateur
Description : SWAP A échange les quartets d'ordre faible et élevé (champs de quatre bits) de l'accumulateur.
(bits 30 et bits 74). L'opération peut également être considérée comme une instruction de rotation sur quatre bits.
Aucun drapeau n'est affecté.

ÉCHANGER UN
laisse l'accumulateur contenant la valeur 5CH (01011100B).

Octets : 1
Cycles : 1
Codage: 1 1000100
Opération : ÉCHANGE
(A30) (A74)
XCH A, <octet>
Fonction : accumulateur d'échange avec variable d'octet
Description : XCH charge l'accumulateur avec le contenu de la variable indiquée, en même temps
écrire le contenu original de l'accumulateur dans la variable indiquée. L'opérande source/destination
peut utiliser un adressage de registre, direct ou indirect.
Exemple : R0 contient l'adresse 20H. L'accumulateur contient la valeur 3FH (00111111B). Interne
L'emplacement RAM 20H contient la valeur 75H (01110101B). L'instruction,
XCHA, @R0
quittera l'emplacement RAM 20H contenant les valeurs 3FH (00111111B) et 75H (01110101B) dans
l'accumulateur.
XCH A, Rn
Octets : 1
Cycles : 1
Codage: 1100 1 rrr
Opération : XCH
(UN) (Rn)
XCH A, direct
Octets : 2
Cycles : 1
Opération : XCH
(UN) (direct)
75
XCH A, @Ri
Octets : 1
Cycles : 1
Codage: 1100011 je
Opération : XCH
(UN) ((Ri))
XCHD A, @Ri
Fonction : Chiffre d'échange
Description : XCHD échange le quartet de poids faible de l'accumulateur (bits 3 à 0), représentant généralement un chiffre
hexadécimal ou BCD, avec celui de l'emplacement RAM interne indirectement adressé par le registre
spécifié. Les quartets de poids fort (bits 7 à 4) de chaque registre ne sont pas affectés. Aucun drapeau
n'est affecté.
Exemple : R0 contient l'adresse 20H. L'accumulateur contient la valeur 36H (00110110B). Interne
L'emplacement RAM 20H contient la valeur 75H (01110101B). L'instruction,
XCHDA, @R0
quittera l'emplacement RAM 20H contenant les valeurs 76H (01110110B) et 35H (00110101B) dans
l'accumulateur.
Octets : 1
Cycles : 1
Codage: 1101 0 1 1 je
Opération : XCHD
(A30) (Ri30)
XRL <octetdest>, <octetsrc>

Fonction : OU exclusif logique pour les variables d'octet
Description : XRL effectue l'opération logique OU exclusif au niveau du bit entre les variables indiquées,
stocker les résultats dans la destination. Aucun drapeau n'est affecté.
l'accumulateur, la source peut utiliser l'adressage par registre, direct, par registreindirect ou immédiat ;
lorsque la destination est une adresse directe, la source peut être l'accumulateur ou des données immédiates.
(Remarque : lorsque cette instruction est utilisée pour modifier un port de sortie, la valeur utilisée comme données de port
d'origine sera lue à partir du verrou de données de sortie, et non des broches d'entrée.)
Exemple : Si l'accumulateur contient 0C3H (11000011B) et que le registre 0 contient 0AAH (10101010B), alors
l'instruction,
XRLA, R0
quittera l'accumulateur contenant la valeur 69H (01101001B).

Lorsque la destination est un octet directement adressé, cette instruction peut compléter la combinaison
de bits dans n'importe quel emplacement RAM ou registre matériel. Le modèle de bits à compléter est
ensuite déterminé par un octet de masque, soit une constante contenue dans l'instruction, soit une
variable calculée dans l'accumulateur au moment de l'exécution. L'instruction,
XRL P1, #00110001B
complétera les bits 5,4 et 0 du port de sortie 1.
76
XRL A, Rn
Octets : 1
Cycles : 1
Codage: 01 dix 1 rrr
Fonctionnement : XRL
(A) ← (A) (Rn)
XRL A, direct
Octets : 2
Cycles : 1
(A) ← (A) (direct)
XRL A, @Ri
Octets : 1
Cycles : 1
(A) ← (A) ((Ri))
XRL A, #données
Octets : 2
Cycles : 1
Codage: 01 dix 0100 données immédiates
(A) ← (A) #données
XRL direct, A
Octets : 2
Cycles : 1
Codage: 01 dix 0010 adresse directe
(direct) ←( direct) (UN)
XRL direct, #dataw
Octets : 3
Cycles : 2
Codage: 01 dix 0011 adresse directe données immédiates
(direct) ←( direct) # données
77
Chapitre 6 Interruption
Il existe 8 adresses de vecteur d'interruption disponibles dans la série STC89xx. En association avec chaque vecteur d'interruption,
chaque source d'interruption peut être activée ou désactivée individuellement en réglant ou en effaçant un bit dans les registres IE et XICON.
Le registre contient également un bit de désactivation global (EA), qui peut être effacé pour désactiver toutes les interruptions à la fois.
Chaque source d'interruption a deux bits correspondants pour représenter sa priorité. L'un est situé chez SFR nommé IPH et l'autre dans
le registre IP ou XICON. L'interruption de priorité supérieure ne sera pas interrompue par une demande d'interruption de priorité inférieure.
Si deux demandes d'interruption de niveaux de priorité différents sont reçues simultanément, la demande de priorité la plus élevée est
traitée. Si des demandes d'interruption du même niveau de priorité sont reçues simultanément, une séquence d'interrogation interne
détermine quelle demande est traitée. Le tableau suivant montre la séquence d'interrogation interne dans le même niveau de priorité et
l'adresse du vecteur d'interruption.
Interrompre Interrompre
Vecteur Vote Priorité 0 Priorité Priorité Priorité 3 Interrompre
Source d'interruption Adresse de réglage Activer
des priorités Séquence (le plus bas) 1 2 (le plus élevé) Demande
(IP/XICON,IPH) Bit de contrôle
/INT0 IE0 EX0/EA
0003H 0 (le plus élevé) PX0H, PX0 0,0 0,1 1,0 1,1
(Interruption externe 0)
Minuterie 0 000BH 1 PT0H,PT0 0,0 0,1 1,0 1,1 TF0 ET0/EA
/INT1 0013H 2 IE1 EX1/EA
PX1H,PX1 0,0 0,1 1,0 1,1
(Interruption externe 1)
Minuterie1 001BH 3 PT1H, PT1 0,0 0,1 1,0 1,1 TF1 ET1/EA
UART
0023H 4 PSH,PS 0,0 0,1 1,0 1,1 RI+TI ES/EA
(Interface série)
Minuterie 2 002BH5 PT2H, PT2 0,0 0,1 1,0 1,1 TF2+EXF2 ET2/EA
/INT2 0033H 6 PX2H,PX2 0,0 0,1 1,0 1,1 IE2 EX2/EA
/INT3 003BH 7 (le plus bas) PX3H, PX3 0,0 0,1 1,0 1,1 IE3 EX3/EA
78
6.1 Structure des interruptions
Priorité la plus élevée

Interruption de niveau
IP, XICON,IPH
Registres
Registres IE, XICON
TCON.0/IT0=0
EX0
/INT0 IE0
TCON.0/IT0=1
haut
ET0
TF0
TCON.2/IT1=0
EX1
/INT1 IE1
TCON.2/IT1=1
ET1
TF1
ES
RI
TI Interrompre
ET2
Vote
TF2+EXF2 Séquence
XICON.0/IT2=0
EX2
/INT2 IE2
XICON.0/IT2=1
XICON.4/IT3=0
EX3
/INT3 IE2
XICON.4/IT3=1
faible
EA
Activation globale
Priorité la plus basse
EA
Interruption de niveau
Schéma du système d'interruption de la série STC89xx
79
, INT3 peuvent chacune être activées par niveau ou par transition, en fonction des bits IT0
Les interruptions externes INT0, INT1, INT2 et
et IT1 du registre TCON, IT2 et IT3 de SFR XICON. Les indicateurs qui génèrent réellement ces interruptions sont les bits IE0 et IE1
dans TCON, IE2 et IE3 dans XICON. Lorsqu'une interruption externe est générée, l'indicateur qui l'a générée est effacé par le matériel
lorsque la routine de service est dirigée vers si et seulement si l'interruption a été activée par transition, sinon la source de requête
externe est ce qui contrôle l'indicateur de demande, plutôt que l'indicateur de demande. matériel sur puce.
Les interruptions Timer 0 et Timer1 sont générées par TF0 et TF1, qui sont définies par un roulement dans leurs registres Timer/Counter
respectifs dans la plupart des cas. Lorsqu'une interruption de minuterie est générée, l'indicateur qui l'a générée est effacé par le matériel
sur puce lorsque la routine de service est dirigée vers.
L'interruption du port série est générée par le OU logique de RI et TI. Aucun de ces indicateurs n'est effacé par le matériel lorsque la
routine de service est orientée vers. En fait, la routine de service devra normalement déterminer si ce sont RI et TI qui ont généré
l'interruption, et le bit devra être effacé par logiciel.
L'interruption du Timer 2 est générée par le OU logique de TF2 et EXF2. Tout comme le port série, aucun de ces indicateurs n'est effacé
par le matériel lorsque la routine de service est orientée vers.
Tous les bits qui génèrent des interruptions peuvent être activés ou effacés par logiciel, avec le même résultat que s'ils avaient été activés
ou effacés par le matériel. En d’autres termes, des interruptions peuvent être générées ou des interruptions en attente peuvent être annulées
dans le logiciel.
6.2 Registre des interruptions
Valeur après
C'EST À DIRE
Activation d'interruption A8H EA ET2 ES ET1 EX1 ET0 EX0 0000 0000B
PI Priorité d'interruption basse B8H PT2 PS PT1 PX1 PT0 PX0 xx00 0000B
IPH Priorité d'interruption B7H PX3H PX2H PT2H PSH PT1H PX1H PT0H PX0H
0000,0000B
Haut
Minuterie/Compteur 0 et
TCON 88H TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0 0000 0000B
1 Contrôle
T2CON C8H TF2 EXF2 RCLK TCLK EXEN2 TR2 C/T2 CP/RL2 0000 0000B
Contrôle
Interruption auxiliaire
XICON C0H PX3 EX3 IE3 IT3 PX2 EX2 IE2 IT1 0000 0000B
Contrôle
80
IE : Interruption Activer Rsgister

(MSB) (LSB)
EA ET2 ES ET1 EX1 ET0 EX0
Enable Bit = 1 active l'interruption.

Activer Bit = 0 le désactive .
Fonction de position du symbole

désactive toutes les interruptions. si EA = 0, aucune interruption ne sera acquittée. si
EA IE.7 EA = 1, chaque source d'interruption est activée ou désactivée individuellement en
réglant ou en effaçant son bit d'activation.
ET2 Bit d'activation d'interruption du temporisateur IE.5 2
ES IE.4 Bit d'activation d'interruption du port série
ET1 IE.3 Bit d'activation d'interruption du temporisateur 1
EX1 IE.2 Bit d'activation de l'interruption externe 1
ET0 Bit d'activation d'interruption du temporisateur IE.1 0
EX0 IE.0 Bit d'activation d'interruption externe 0
IP : Registre bas à priorité d'interruption

(MSB) (LSB)
PT2 PS PT1 PX1 PT0 PX0
Le bit de priorité = 1 attribue une priorité élevée.

Bit de priorité = 0 attribue une faible priorité.
Position du symbole Fonction
PT2 IP.5 Bit de priorité d'interruption du minuteur 2

PS Bit de priorité d'interruption du port série IP.4.
PT1 IP.3 Bit de priorité d'interruption du temporisateur 1
PX1 IP.2 Interruption externe 1 bit de priorité
TP0 IP.1 Temporisation 0 bit de priorité d'interruption
PX0 IP.0 Interruption externe 0 bit de priorité
IPH : registre élevé à priorité d'interruption

LSB
nom PX3H PX2H PT2H PSH PT1H PX1H PT0H PX0H
PX3H : Si défini, définit la priorité pour l'interruption externe 3 la plus élevée
PT2H : si défini, défini pour l'interruption de la minuterie 2 la plus élevée
PSH : si défini, définissez la priorité la plus élevée pour le port série.

PT1H : si défini, définissez la priorité la plus élevée pour l'interruption de la minuterie 1.

PT0H : si défini, définissez la priorité la plus élevée pour l'interruption de la minuterie 0.
81
Registre TCON : registre de contrôle de minuterie/compteur

(MSB) (LSB)
TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0
Position du symbole Nom et signification Nom de la position du symbole et signification

TF1 TCON.7 Drapeau de débordement du temporisateur 1. Défini par IE1 TCON.3 Indicateur d’interruption 1 Edge. Défini par le
matériel en cas de dépassement de minuterie/compteur.
matériel lorsqu'un front d'interruption
effacé par le matériel lorsque les vecteurs du externe est détecté. Effacé lors du
processeur interrompent la routine. traitement de l'interruption.
TR1 TCON.6 Minuterie 1 Exécuter le bit de contrôle. Réglé/effacé IT1 TCON.2 Intenupt 1 Type de bit de contrôle. Ensemble/
effacé par le logiciel pour spécifier les
par le logiciel pour activer/désactiver la minuterie/
interruptions externes déclenchées par front
compteur.
descendant/niveau bas.
TF0 TCON.5 Débordement du temporisateur 0 Flag. Défini par IE0 TCON.1 Indicateur de front d'interruption 0. Défini par
matériel en cas de dépassement de minuterie/compteur.
le matériel lorsqu'un front d'interruption
TR0 TCON.4 Minuterie 0 Exécuter le bit de contrôle. Réglé/effacé IT0 TCON.0 Intenupt 0 Type de bit de contrôle. Ensemble/
interruptions externes déclenchées par front
compteur.
descendant/niveau bas.
Registre SCON
LSB
peu 6 5 4 3 2 1 0
7 nom SM0/FE SM1 SM2 REN TB8 RB8 TI RI
FE : bit d'erreur de trame. Le bit SMOD0 doit être défini pour permettre l'accès au bit FE
0 : le bit FE n'est pas effacé par les trames valides mais doit être effacé par le logiciel.
1 : ce bit est défini par le récepteur lorsqu'un identifiant de bit d'arrêt invalide est détecté.
SM0,SM1 : Mode port série Bit 0/1.
SM0 SM1 Description Registre à décalage 8 bits Débit en bauds
0 0 UART 8 bits UART 9 SYSclk/12

0 bits UART 9 variable
1 1 bits SYSclk/64 ou SYSclk/32(SMOD=1)
1 01 variable
SM2 : Activez la fonction de reconnaissance automatique d'adresse en modes 2 et 3. Si SM2=1, RI ne sera pas défini à
moins que le 9ème bit de données reçu soit 1, indiquant une adresse, et que l'octet reçu soit une adresse
donnée ou de diffusion. En mode 1, si SM2=1 alors RI ne sera pas défini sauf si un arrêt valide
Le bit a été reçu et l'octet reçu est une adresse donnée ou de diffusion. En mode 0, SM2 doit être 0.
REN : Lorsqu'il est défini, il active la réception série.
TB8 : Le 9ème bit de données qui sera transmis en mode 2 et 3.
RB8 : En mode 2 et 3, le 9ème bit de données reçu ira dans ce bit.
TI : indicateur d'interruption de transmission.
RI : réception d'un indicateur d'interruption.
82
T2CON : Minuterie/Compteur 2 Registre de contrôle

LSB
nom TF2 EXF2 RCLK TCLK EXEN2 TR2 C/T2 CP/RL2
TF2 : Flag de débordement du Timer 2. TF2 est réglé par un débordement du Timer 2 et doit être effacé par le logiciel. TF2
ne sera pas défini lorsque RCLK=1 ou TCLK=1.
EXF2 : Flag externe Timer 2. Indicateur externe du minuteur 2 activé lorsqu'une capture ou un rechargement est provoqué par un élément négatif.
transition sur la broche T2EX(P1.1) et EXEN2=1. Lorsque l'interruption du Timer 2 est activée, EXF2=1 amènera le CPU à vecteurr la
routine d'interruption du Timer 2. EXF2 doit être effacé par logiciel. EXF2 ne provoque pas d'interruption en mode haut/bas (DCEN=1).
RCLK : Réception du drapeau d'horloge. Lorsqu'il est défini, le port série utilise les impulsions de débordement de la minuterie 2 pour son horloge de réception.
modes 1 et 3. Une fois effacé, le dépassement de la minuterie 1 est utilisé pour l'horloge de réception.
TCLK : indicateur d'horloge de transmission. Lorsqu'il est défini, le port série utilise les impulsions de débordement de la minuterie 2 pour son horloge de transmission.
dans les modes 1 et 3. Une fois effacé, les dépassements du temporisateur 1 seront utilisés pour l'horloge de transmission.
EXEN2 : Flag d'activation externe du Timer 2. Lorsqu'il est défini, permet une capture ou un rechargement à la suite d'un résultat négatif.
transition sur la broche T2EX (P1.1) si la minuterie 2 n'est pas utilisée pour synchroniser le port série. Une fois désactivé, le minuteur
2 ignore les événements sur la broche T2EX (P1.1).
TR2 : Bit de contrôle d'exécution de la minuterie 2. Une fois défini, démarrez la minuterie 2. Une fois effacé, arrêtez la minuterie 2.
C/T2 : Sélecteur de minuterie ou de compteur.
0 : Sélectionnez Minuterie 2 comme fonction de minuterie interne.
1 : Sélectionnez le minuteur 2 comme compteur d'événements externe (déclenchement par front descendant).
CP/RL2 : Drapeau Capture/Rechargement.
0 : Les rechargements automatiques se produiront soit avec des débordements du Timer 2, soit avec des transitions négatives sur la broche T2EX lorsque EXEN2=1.
1 : Les captures se produiront sur les transitions négatives sur la broche T2EX si EXEN2=1.
XICON : Registre de contrôle d'interruption auxiliaire

LSB
nom PX3 EX3 IE3 IT3 PX2 EX2 IE2 IT2
PX3 : si défini, définissez la priorité pour l'interruption externe 3 plus haut

EX3 : Si défini, active l'interruption externe 3.
IE3 : indicateur d'interruption externe 3 Edge. Définit par le matériel lorsqu'un front d'interruption externe est détecté. Effacé par le matériel
lorsque l'interruption commence à être traitée.
IT3 : Bit de contrôle de type Interruption Externe 3. Régler/effacer par le logiciel sur le front descendant spécifié/niveau bas déclenché
interrompre.
PX2 : si défini, définissez la priorité pour l'interruption externe 3 plus haut
EX2 : Si défini, active l'interruption externe 2.
IE2 : indicateur Edge d’interruption externe 2. Définit par le matériel lorsqu'un front d'interruption externe est détecté. Effacé quand
l'interruption commence à être traitée.
IT2 : Interruption 2 types de bit de contrôle. Réglé/effacé par le logiciel pour spécifier une interruption déclenchée par front descendant/niveau bas.
IP (ou XICON) et IPH sont combinés pour former une interruption prioritaire à 4 niveaux comme dans le tableau suivant.
{IPH.x, IP.x/XICON.x} Niveau de priorité

1,1 0 (le plus élevé)
1,0 1
0,1 2
0,0 3
83
6.3 Priorités d'interruption
Chaque source d'interruption peut également être programmée individuellement sur l'un des quatre niveaux de priorité en définissant ou en effaçant un bit
dans les registres de fonctions spéciales IP ou XICON et IPH. Une interruption. de faible priorité peut ellemême être interrompue par une interruption de
haute porité, mais pas par une autre interruption de faible priorité. interruption prioritaire. Une interruption de haute priorité ne peut être interrompue par
aucune autre source d'interruption.
Si deux demandes de niveaux de priorité différents sont reçues simultanément, la demande de niveau de priorité plus élevé est traitée.
Si des demandes du même niveau de priorité sont reçues simultanément, une séquence d'interrogation interne détermine quelle
demande est traitée. Ainsi, au sein de chaque niveau de priorité, il existe une deuxième structure de priorité déterminée par la
séquence d'interrogation, comme suit :
Priorité de la source dans le niveau
0. IE0 0 (le plus élevé)
1. TF0 1
2. IE1 2
3. TF1
4. RI +Tl 34
5. TF2+EXF2 5
6. IE2 6
7. IE3 7
Notez que la structure « priorité au sein du niveau » n'est utilisée que pour résoudre des demandes simultanées du même niveau de
priorité.
6.4 Comment les interruptions sont gérées
Chaque indicateur d'interruption est échantillonné à chaque cycle d'horloge système. Les échantillons sont interrogés lors de la prochaine horloge système.
Si l'un des indicateurs était dans un état défini au premier cycle, le deuxième cycle (cycle d'interrogation) le trouvera et le système
d'interruption générera un LCALL matériel à la routine de service appropriée tant qu'il n'est pas bloqué par l'un des éléments suivants.
conditions.
Conditions de blocage :
•
Une interruption de niveau de priorité égal ou supérieur est déjà en cours.
•
Le cycle en cours (polling cycle) n'est pas le cycle final dans l'exécution de l'instruction en cours.
•
L'instruction en cours est RETI ou toute écriture dans les registres IE ou IP.
•
L'activité FAI/IAP est en cours.
Chacune de ces quatre conditions bloquera la génération du matériel LCALL vers la routine de service d'interruption.
La condition 2 garantit que l'instruction en cours sera terminée avant de passer à une routine de service.
La condition 3 garantit que si l'instruction en cours est RETI ou tout accès à IE ou IP, alors au moins une ou plusieurs instructions
seront exécutées avant qu'une interruption ne soit vectorisée.
Le cycle d'interrogation est répété avec le dernier cycle d'horloge de chaque cycle d'instruction. Notez que si un indicateur d'interruption
est actif mais ne reçoit pas de réponse pour l'une des conditions cidessus, si l'indicateur n'est pas toujours actif lorsque la condition
de blocage est supprimée, l'interruption refusée ne sera pas traitée. En d'autres termes, le fait que l'indicateur d'interruption était
autrefois actif mais n'a pas reçu de réponse pour l'une des conditions cidessus, si l'indicateur n'est pas toujours actif lorsque la
condition de blocage est supprimée, l'interruption refusée ne sera pas traitée. L'indicateur d'interruption était autrefois actif mais non
réparé n'est pas conservé en mémoire. Chaque cycle de scrutin est nouveau.
84
Notez que si une interruption de niveau de priorité plus élevé devient active avant le front montant du troisième cycle machine,
alors, conformément aux règles cidessus, elle sera guidée pendant les cinquième et sixième cycles machine, sans qu'aucune
instruction de la routine de priorité inférieure n'ait été exécuté.
Ainsi, le processeur accuse réception d'une demande d'interruption en exécutant un LCALL généré par le matériel vers la
routine de maintenance appropriée. Dans certains cas, il efface également l'indicateur qui a généré l'interruption, et dans
d'autres cas, ce n'est pas le cas. Il n'efface jamais les indicateurs du port série. Cela doit être fait dans le logiciel de l'utilisateur.
Il efface un indicateur d'interruption externe (IE0 ou IE1) uniquement s'il a été activé par transition. Le LCALL généré par le
matériel pousse le contenu du compteur de programme sur la pile (mais il ne sauvegarde pas le PSW) et recharge le PC avec
une adresse qui dépend de la source de l'interruption dirigée vers, comme indiqué en bas.
Adresse du vecteur source
IE0 0003H
TF0 000BH
IE1 0013H
TF1 001BH
RI+TI 0023H
TF2+EXF2 002BH
IE2 0033H
IE3 003BH
L'exécution se poursuit à partir de cet emplacement jusqu'à ce que l'instruction RETI soit rencontrée. L'instruction RETI
informe le processeur que cette routine d'interruption n'est plus en cours, puis extrait les deux premiers octets de la pile et
recharge le compteur de programme. L'exécution du programme interrompu continue là où elle s'était arrêtée.
Notez qu'une simple instruction RET aurait également renvoyé l'exécution au programme interrompu, mais elle aurait laissé
le système de contrôle d'interruption penser qu'une interruption était toujours en cours.
6.5 Interruptions externes
Il existe quatre sources d'interruption externes dans le MCU STC89xx. Les sources externes peuvent être programmées pour être activées par
niveau ou par transition en effaçant ou en définissant les bits IT0, IT1, IT2 ou IT3 dans les registres TCON ou XICON. Si ITx = 0, l'interruption
externe x est déclenchée par un niveau bas détecté au niveau de la broche INTx . Si ITx=1, l'interruption externe x est déclenchée par front.
Dans ce mode, si des échantillons successifs de la broche INTx montrent un niveau haut dans un cycle et un niveau bas dans le cycle suivant,
l'indicateur de demande d'interruption IEx dans TCON est défini. Le bit indicateur IEx demande alors l'interruption.
Étant donné que les broches d'interruption externes sont échantillonnées une fois à chaque cycle machine, une entrée haute ou basse doit
être maintenue pendant au moins 12 horloges système pour garantir l'échantillonnage. Si l'interruption externe est activée par transition, la
source externe doit maintenir la broche de requête haute pendant au moins un cycle machine, puis la maintenir basse pendant au moins un
cycle machine pour garantir que la transition est vue afin que l'indicateur de demande d'interruption IEx sera réglé. IEx sera automatiquement
effacé par la CPU lorsque la routine de service est appelée.
Si l'interruption externe est activée par niveau, la source externe doit maintenir la demande active jusqu'à ce que l'interruption
demandée soit réellement générée. Ensuite, il doit désactiver la demande avant que la routine de service d'interruption ne soit
terminée, sinon une autre interruption sera générée.
85
Exemple : Concevez un système d'avertissement d'intrusion utilisant des interruptions qui émettent une tonalité de 400 Hz pendant 1 seconde
(à l'aide d'un hautparleur connecté à P1.7) chaque fois qu'un capteur de porte connecté à INT0 effectue une transition de haut en bas.
Solution de langage d'assemblage
ORG 0
PRINCIPAL LJMP ;Instruction sur 3 octets
LJMP INT0INT ;EXT 0 adresse vectorielle
ORG 000BH ;Temporisateur 0 vecteur
LJMP T0INT
ORG 001BH ;Vecteur Minuterie 1
LJMP T1INT
ORG 0030H
PRINCIPAL:
SETB IT0 ;front négatif activé

MOV TMOD, #11H ;Mode minuterie 16 bits
FILM, #81H ;activer EXT 0 uniquement
SJMP $ ; maintenant, détendstoi
;
INT0INT :
#20 ' 5000 us = 1 seconde
MOV R7,
SETB TF0 ;20 ;forcer l'interruption du minuteur 0
SETB TF1 ;forcer l'interruption du minuteur 1
SETB ET0 ;commencer le ton pendant 1 seconde
SETB ET1 ;activer les interruptions de minuterie
RÉTI
;
T0INT :
CLR TR0 ;arrêter le chronomètre
DJNZ R7, SAUTER ;si ce n'est pas la 20ème fois, quittez
CLR ET0 ;si le 20, désactiver la tonalité

CLR ET1 ; se désactiver
SORTIE LJMP
SAUTER:
MOV TH0, #ÉLEVÉ (50000) ;0,05 s. retard

MOV TL0, #FAIBLE (5000)
SETB TR0
SORTIE:
RÉTI
;
T1INT :
CLR TR1
MOV TH1, #HAUT (1250) ;comptez pour 400 Hz
MOUVEMENT TL1, #BAS (1250)
CPL P1.7 ;maestro de la musique !
SETB TR1
RÉTI
FIN
86
Solution en langage C
#inclure <REG51.H> /* Déclarations SFR */

sbit sortie = P1 ^ 7 ; /* utilise la variable outbit pour faire référence à P1.7 */
caractère non signé R7 ; /* utilise une variable 8 bits pour représenter R7 */

principal( )
{
IT0 = 1 ; /* front négatif activé */
TMOD = 0x11 ; /* Mode minuterie 16 bits */
IE = 0x81 ; /* activer EXT 0 uniquement */
tandis que(1);
}
vide INT0INT (vide) { interrompre 0
R7 = 20 ; /* 20 x 5000us = 1 seconde */
TF0 = 1 ; /* force l'interruption du timer 0 */
TF1 = 1 ; /* force l'interruption du timer 1 */
ET0 = 1 ; /* commence la tonalité pendant 1 seconde */
ET1 = 1 ; /* active les interruptions du timer 1 */

/* les interruptions du timer feront le travail */
}
void T0INT(void) interruption 1
{
TR0 = 0 ; /* arrêter le chronomètre */
R7 = R71 ; si /* décrémenter R7 */
(R7 == 0) { /* si c'est la 20ème fois, */
ET0 = 0 ; /* se désactive */
ET1 = 0 ;
}
autre
{
TH0 = 0x3C ; /* 0,05 s. retard */
TL0 = 0xB0 ;
}
}
void T1INT (vide) interruption 3
{
TR0 = 0 ;
TH1 = 0xFB ; /* compte pour 400 Hz */
TL1 = 0x1E ;
sortie = !sortie; TR1 /* maestro de la musique ! */
=1;
}
87
Dans la solution en langage assembleur cidessus, cinq sections distinctes sont les emplacements du vecteur d'interruption, le programme principal
et les trois routines de service d'interruption. Tous les emplacements de vecteurs contiennent des instructions LJMP pour les routines respectives.
Le programme principal, commençant à l'adresse de code 0030H, ne contient que quatre instructions. SETB IT0 configure l'entrée d'interruption
de détection de porte comme déclenchée par front négatif. MOV TMOD, #11H configure les deux minuteries pour le mode 1, mode minuterie 16
bits. Seule l'interruption externe 0 est activée initialement (MOV IE, #81H), donc une condition « porte ouverte » est nécessaire avant qu'une
interruption ne soit acceptée. Enfin, SJMP $ met le programme principal dans une boucle sans rien faire.
Lorsqu'une condition d'ouverture de porte est détectée (par une transition hautbas de INT0), une interruption externe 0 est générée,
INT0INT commence par mettre la constante 20 dans R7, puis définit les indicateurs de débordement pour les deux minuteries pour forcer les
interruptions de la minuterie. arriver.
Toutefois, une interruption de minuterie ne se produit que si les bits correspondants sont activés dans le registre IE. Les deux instructions
suivantes (SETB ET0 et SETB ET1) activent les interruptions de temporisation. Enfin, INT0INT se termine par un RETI au programme principal.
La minuterie 0 crée le délai d'attente d'une seconde et la minuterie 1 crée la tonalité de 400 Hz. Après le retour de INT0INT au programme
principal, les interruptions de minuterie sont immédiatement générées (et acceptées après une exécution de SJMP $). En raison de la séquence
d'interrogation fixe, l'interruption du minuteur 0 est traitée en premier. Un délai d'attente d'une seconde est créé en programmant 20 répétitions
d'un délai d'attente de 50 000 us. R7 sert de compteur. Dixneuf fois sur 20, T0INT fonctionne de la manière suivante.
Tout d'abord, la minuterie 0 est désactivée et R7 est décrémentée. Ensuite, TH0/TL est rechargé avec 50 000, la minuterie est réactivée et
l'interruption est terminée. À la 20ème interruption du Timer 0, R7 est décrémenté à 0 (1 seconde s'est écoulée).
Les deux interruptions de minuterie sont désactivées (CLR ET0, CLR ET1) et l'interruption est terminée. Aucune autre interruption de minuterie ne
sera générée jusqu'à ce que la prochaine condition « porte ouverte » soit détectée.
La tonalité de 400 Hz est programmée à l'aide des interruptions du Timer 1, 400 Hz nécessite une période de 1/400 = 2 500 us ou 1 250
us en temps haut et 1 250 us en temps bas. Chaque minuterie 1 ISR met simplement 1250 dans TH1/TL1, complète le bit de port pilotant le haut
parleur, puis se termine.
6.6 Temps de réponse
Les niveaux INT0, INT1, INT2 et INT3 sont inversés et verrouillés dans les indicateurs d'interruption IE0, IE1, IE2 et IE3 lors du front
montant de chaque cycle d'horloge du système.
Les indicateurs Timer 0 et Timer 1, TF0 et TF1, sont définis, après quoi les timers débordent. Les valeurs sont ensuite interrogées par les circuits
lors du front montant du cycle d'horloge système suivant.
Si une requête est active et que les conditions sont réunies pour qu'elle soit accusée de réception, un appel de sousprogramme
matériel à la routine de service demandée sera la prochaine instruction à exécuter. L'appel luimême prend six cycles d'horloge système.
Ainsi, un minimum de sept cycles complets d'horloge système s'écoulent entre l'activation d'une demande d'interruption externe et le
début de l'exécution de la première instruction de la routine de service.
Un temps de réponse plus long résulterait si la demande était bloquée par l'une des quatre conditions énumérées précédemment. Si une
interruption de niveau de priorité égal ou supérieur est déjà en cours, le temps d'attente supplémentaire dépend évidemment de la nature de la
routine de service de l'autre interruption. Si l'instruction en cours n'est pas dans son cycle final, le temps d'attente supplémentaire ne peut être
supérieur à 3 cycles, puisque les instructions les plus longues (LCALL) ne font que 6 cycles, et si l'instruction en cours est RETI ou un accès à IE
ou IP, le temps d'attente supplémentaire ne peut pas être supérieur à 5 cycles (au maximum un cycle supplémentaire pour terminer l'instruction
en cours, plus 6 cycles pour terminer l'instruction suivante si l'instruction est LCALL).
Ainsi, dans un système à interruption unique, le temps de réponse est toujours supérieur à 7 cycles et inférieur à 12 cycles.
88
Chapitre 7 Minuterie/Compteur
STC89xx dispose de trois temporisateurs 16 bits, nommés T0, T1 et T2. Chacun d'eux peut également être configuré individuellement comme
minuteries ou compteurs d'événements.
Dans la fonction « Timer », le registre est incrémenté toutes les 12 horloges système ou 6 horloges système selon le mode 12T ou le mode
6T que l'utilisateur a configuré cet appareil.
Dans la fonction « Compteur », le registre est incrémenté en réponse à une transition de 1 à 0 sur sa broche d'entrée externe correspondante,
T0, T1 ou T2. Dans cette fonction, l'entrée externe est échantillonnée une fois sur le front positif de chaque cycle d'horloge. Lorsque les
échantillons affichent un niveau élevé au cours d'un cycle et un niveau bas au cycle suivant, le décompte est incrémenté.
La nouvelle valeur de comptage apparaît dans le registre à la fin du cycle suivant celui dans lequel la transition a été détectée. Puisqu'il faut
2 cycles machine (24 horloges système) pour reconnaître une transition de l à 0, le taux de comptage maximum est de 1/24 de l'horloge
système. Il n'y a aucune restriction sur le cycle de service du signal d'entrée externe, mais pour garantir qu'un niveau donné est échantillonné
au moins une fois avant de changer, il doit être maintenu pendant au moins un cycle machine complet.
La fonction « Timer » ou « Counter » du Timer 0 et du Timer 1 est sélectionnée par les bits de commande C/T dans le registre de fonctions
spécifiques TMOD. Et la fonction « Timer » ou « Counter » du Timer 2 est sélectionnée par le bit de commande C/T2 dans le registre de
fonctions spécifiques T2CON.
Il existe deux SFR conçus pour configurer les timers T0 et T1. Ce sont TMOD, TCON.
Il existe deux SFR supplémentaires conçus pour configurer la minuterie T2. Ce sont T2MOD, T2CON.
Valeur après
TCON Contrôle de la minuterie 88H TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0 0000 0000B
TMOD Mode minuterie 89H PORTE C/T M1 M0 PORTE C/T M1 M0 0000 0000B
TL0 Minuterie basse 0 8AH 0000 0000B

TL1 Minuterie basse 1 8BH 0000 0000B
TH0 Minuterie élevée 0 8CH 0000 0000B
TH1 Minuterie haute 1 8DH 0000 0000B
T2CON Minuterie/Compteur 2 contrôle C8H TF2 EXF2 RCLK TCLK EXEN2 TR2 C/T2 CP/RL2 0000 0000B
T2MOD Minuterie/Compteur 2 mode C9H T2OE DCEN xxxx xx00B

Minuterie/Compteur 2 Rechargement/
RCAP2L CAH 0000 0000B
Capturer les octets élevés
Minuterie/Compteur 2 Rechargement/
RCAP2H CBH 0000 0000B
Capturer les octets élevés
Minuterie/Compteur 2 bas
TL2 CCH 0000 0000B
Octet
Minuterie/Compteur 2 haut
TH2 CDH 0000 0000B
Octet
89
Registre TCON : registre de contrôle de minuterie/compteur

(MSB) (LSB)
TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0
Position du symbole Nom et signification Nom de la position du symbole et signification

TF1 TCON.7 Drapeau de débordement du temporisateur 1. Défini par IE1 TCON.3 Indicateur d’interruption 1 Edge. Défini par le
matériel en cas de dépassement de minuterie/ matériel lorsqu'un front d'interruption
compteur. effacé par le matériel lorsque les externe est détecté. Effacé lors du
vecteurs du processeur interrompent la routine. traitement de l'interruption.
TR1 TCON.6 IT1 TCON.2 Intenupt 1 Type de bit de contrôle. Ensemble/
Minuterie 1 Exécuter le bit de contrôle. Réglé/effacé
interruptions externes déclenchées par
compteur.
front descendant/niveau bas.
TF0 TCON.5 Débordement du temporisateur 0 Flag. Défini par IE0 TCON.1 Indicateur de front d'interruption 0. Défini par
matériel en cas de dépassement de minuterie/compteur. le matériel lorsqu'un front d'interruption
TR0 TCON.4 IT0 TCON.0 Intenupt 0 Type de bit de contrôle. Ensemble/
Minuterie 0 Exécuter le bit de contrôle. Réglé/effacé
interruptions externes déclenchées par
compteur.
front descendant/niveau bas.
Registre TMOD : registre de contrôle du mode minuterie/compteur
(MSB) (LSB)
PORTAIL C/T M1 M0 PORTAIL C/T M1 M0
}}
Minuterie 1 Minuterie 0
Contrôle de déclenchement lorsqu'il est défini. La minuterie/compteur "x" est activée uniquement lorsque la broche "INTx" est haute et
GRILLE
que la broche de contrôle "TRx" est définie. Lorsqu'elle est effacée, la minuterie "x" est activée chaque fois que le bit de contrôle "TRx" est défini.
Minuterie ou sélecteur de compteur effacé pour le fonctionnement de la minuterie (entrée de l'horloge système interne). Réglé pour le
C/T
fonctionnement du compteur (entrée depuis la broche d'entrée "Tx").
M0 M1 Mode de fonctionnement
0 0 Minuterie/compteur Bbit « THx » avec « TLx » comme prééchelonneur 5 bits.
0 1 Le minuteur/compteur 16 bits "THx" et "TLx" sont en cascade ; il n'y a pas de prééchelle
Le minuteur/compteur de rechargement automatique 8 bits « THx » contient une valeur qui doit être rechargée dans « TLx »
1 0
à chaque fois ça déborde.
(Timer 0) TL0 est un temporisateur/compteur 8 bits contrôlé par les bits de contrôle standard du Timer 0. TH0
1 1
est un timer 8 bits contrôlé uniquement par les bits de contrôle du Timer 1.
1 1 (Minuterie 1) Minuterie/Compteur 1 arrêté
90
T2CON : Minuterie/Compteur 2 Registre de contrôle

LSB
nom TF2 EXF2 RCLK TCLK EXEN2 TR2 C/T2 CP/RL2
TF2 : Flag de débordement du Timer 2. TF2 est réglé par un débordement du Timer 2 et doit être effacé par le logiciel. TF2 ne sera pas
défini lorsque RCLK=1 ou TCLK=1.
EXF2 : Flag externe Timer 2. Indicateur externe du minuteur 2 activé lorsqu'une capture ou un rechargement est provoqué par un élément négatif.
transition sur la broche T2EX(P1.1) et EXEN2=1. Lorsque l'interruption du Timer 2 est activée, EXF2=1 amènera le CPU à vecteurr
la routine d'interruption du Timer 2. EXF2 doit être effacé par logiciel. EXF2 ne provoque pas d'interruption en mode haut/bas
(DCEN=1).
RCLK : Réception du drapeau d'horloge. Une fois défini, faites en sorte que le port série utilise les impulsions de dépassement de la minuterie 2 pour son horloge de réception
dans les modes 1 et 3. Une fois désactivé, faites en sorte que le dépassement de la minuterie 1 soit utilisé pour l'horloge de réception.
TCLK : indicateur d'horloge de transmission. Lorsqu'il est défini, le port série utilise les impulsions de débordement de la minuterie 2 pour son horloge de transmission.
dans les modes 1 et 3. Une fois effacé, les dépassements du temporisateur 1 seront utilisés pour l'horloge de transmission.
EXEN2 : Flag d'activation externe du Timer 2. Lorsqu'il est défini, permet une capture ou un rechargement à la suite d'un résultat négatif.
transition sur la broche T2EX (P1.1) si la minuterie 2 n'est pas utilisée pour synchroniser le port série. Une fois désactivé, le
minuteur 2 ignore les événements sur la broche T2EX (P1.1).
TR2 : Bit de contrôle d'exécution de la minuterie 2. Une fois défini, démarrez la minuterie 2. Une fois effacé, arrêtez la minuterie 2.
C/T2 : Sélecteur de minuterie ou de compteur.
0 : Sélectionnez Minuterie 2 comme fonction de minuterie interne.
1 : Sélectionnez le minuteur 2 comme compteur d'événements externe (déclenchement par front descendant).
CP/RL2 : Drapeau Capture/Rechargement.
0 : Les rechargements automatiques se produiront soit avec des débordements du Timer 2, soit avec des transitions négatives sur la broche T2EX lorsque EXEN2=1.
1 : Les captures se produiront sur les transitions négatives sur la broche T2EX si EXEN2=1.
T2MOD : registre de mode minuterie/compteur 2

LSB
nom T20E DCEN
T2OE : Bit d'activation de la sortie du temporisateur 2. Il permet au taux de débordement de la minuterie 2 de basculer sur P1.0.
DCEN : bit d'activation du décompte. Lorsqu'il est défini, cela permet à la minuterie 2 d'être configurée comme compteur décroissant.
91
7.1 Mode de fonctionnement du minuteur/compteur 0
Mode 0
Dans ce mode, le registre temporisateur est configuré comme un registre 13 bits. Lorsque le décompte passe de tous les 1 à tous les
0, il définit l'indicateur d'interruption du temporisateur TF0. L'entrée comptée est activée pour le temporisateur lorsque TR0 = 1 et GATE
= 0 ou INT0 = 1. (Le réglage de GATE = 1 permet au temporisateur d'être contrôlé par des mesures , pour faciliter la largeur d'impulsion
INT0 d'entrée externe.) TR0 est un bit de contrôle dans le registre des fonctions spéciales. TCON. GATE est en TMOD.
Le registre de 13 bits comprend les 8 bits de TH0 et les 5 bits inférieurs de TL0. Les 3 bits supérieurs de TL0 sont indéterminés et
doivent être ignorés. La définition de l'indicateur d'exécution (TR0) n'efface pas les registres.
Il existe deux bits GATE différents. un pour le minuteur 1 (TMOD.7) et un pour le minuteur 0 (TMOD.3).
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T
C/T=0 TL0 TH0
TF0 Interrompre
Broche T0 C/T=1 (5 bits) (8 bits)
contrôle
TR0
GRILLE
INT0
Minuterie/Compteur 0 Mode 0 : Compteur 13 bits
Mode 1
Dans ce mode, le registre temporisateur est configuré comme un registre 16 bits. Lorsque le décompte passe de tous les 1 à tous les
0, il définit l'indicateur d'interruption du temporisateur TF0. L'entrée comptée est activée pour le temporisateur lorsque TR0 = 1 et GATE
= 0 ou INT0 = 1. (Le réglage de GATE = 1 permet au temporisateur d'être contrôlé par des mesures , pour faciliter la largeur d'impulsion
INT0 d'entrée externe.) TR0 est un bit de contrôle dans le registre des fonctions spéciales. TCON. GATE est en TMOD.
Le registre 16 bits comprend les 8 bits de TH0 et les 8 bits inférieurs de TL0. La définition de l'indicateur d'exécution (TR0) n'efface pas
les registres.
Le mode 1 est identique au mode 0, sauf que le registre de minuterie est exécuté avec les 16 bits.
÷12 MCU en mode 12T
SYSclk
÷6
MCU en mode 12T
C/T=0 TL0 TH0
TF0 Interrompre
C/T=1 (8 bits) (8 bits)
Broche T0
contrôle
TR0
GRILLE
INT0
92
Mode 2
Le mode 2 configure le registre temporisé comme un compteur 8 bits (TL0) avec rechargement automatique. Le débordement de TL0 règle non seulement
TF0, mais recharge également TL0 avec le contenu de TH0, qui est prédéfini par le logiciel. Le rechargement laisse TH0 inchangé. Le fonctionnement du
mode 2 est le même pour la minuterie 0 et la minuterie 1.
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T
C/T=0
TL0
TF0 Interrompre
C/T=1 (8 bits)
Broche T0
contrôle
TR0
GRILLE
TH0
INT0 (8 bits)
Minuterie/Compteur 0 Mode 2 : Rechargement automatique 8 bits
Mode 3
La minuterie 1 du mode 3 maintient simplement son décompte, l'effet est le même que si l'on réglait TR1 = 0. La minuterie 0 du mode 3 a établi TL0 et TH0
comme deux compteurs distincts de 8 bits. TL0 utilise les bits de contrôle du Timer 0 : C/T, GATE, TR0, INT0 et TF0.
TH0 est verrouillé sur une fonction de minuterie (compte des cycles machine) et reprend l'utilisation de TR1 de Tmer 1. Ainsi, TH0 contrôle désormais
l'interruption « Timer 1 ».
Le mode 3 est fourni pour les applications nécessitant un temporisateur ou un compteur supplémentaire de 8 bits. Lorsque la minuterie 0 est en mode 3, la
minuterie 1 peut être activée et désactivée en la sortant et en entrant dans son propre mode 3, ou peut toujours être utilisée par le port série comme
générateur de débit en bauds, ou en fait, dans n'importe quelle application. ne nécessitant pas d'interruption.
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T TL0
C/T=0
TF0 Interrompre
C/T=1 (8 bits)
Broche T0
contrôle
TR0
GRILLE
INT0
MCU en mode 12T

÷12
SYSclk TH0 TF1

(8 bits) Interrompre
÷6
MCU en mode 6T
contrôle
TR1
Minuterie/Compteur 0 Mode 3 : Deux compteurs 8 bits
93
Exemple : écrivez un programme en utilisant Timer 0 pour créer une onde carrée de 5 KHz sur P1.0.
Solution en langage d'assemblage :
ORG 0030H
MOV TMOD, #20H MOV TL0, ;Mode de rechargement automatique 8 bits
#9CH MOV TH0, #9CH SETB TR0 ;initialiser TL0

;100 valeur de rechargement en TH0
;Démarrer Tmier 0
BOUCLE : JNB TF0, BOUCLE CLR TF0 CPL ;Attendez le débordement
P1.0 ;Effacer l'indicateur de dépassement de minuterie
;Basculer le bit de port

BOUCLE SJMP ;Répéter
FIN
Solution en langage C utilisant l'interruption de minuterie :

#include <REG51.H> port /* Déclarations SFR */
sbit = P1^0 ; /* Utiliser un portbit variable pour faire référence à P1.0 */
principal( )
{
TMOD = 0x02 ; /* minuterie 0, mode 2 */
TH0 = 9CH ; /* Délai de 100us */
TR0 = 1 ; /* Démarrer le minuteur */
IE = 0x82 /* Activer l'interruption du timer 0 */

tandis que(1); /* répéter indéfiniment */
}
void T0INT(void) interruption 1

{
portbit = !portbit; /*basculer le bit de port P1.0 */
}
94
Mode 0
Dans ce mode, le registre temporisateur est configuré comme un registre 13 bits. Lorsque le décompte passe de tous les 1 à tous les 0,
il active l'indicateur d'interruption de minuterie TF1. L'entrée comptée est activée pour le temporisateur lorsque TR1 = 1 et GATE = 0 ou
INT1 = 1. (Le réglage de GATE = 1 permet au temporisateur d'être contrôlé par l'entrée externe INT1, pour faciliter les mesures de
largeur d'impulsion.) TR0 est un bit de contrôle. dans le registre des fonctions spéciales TCON. GATE est en TMOD.
Le registre de 13 bits comprend les 8 bits de TH1 et les 5 bits inférieurs de TL1. Les 3 bits supérieurs de TL1 sont indéterminés et
doivent être ignorés. La définition de l'indicateur d'exécution (TR1) n'efface pas les registres.
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T C/T=0 TL1 TH1
TF1 Interrompre
Broche T1
contrôle
TR1
GRILLE
INT1
Mode 1
Dans ce mode, le registre temporisateur est configuré comme un registre 16 bits. Lorsque le décompte passe de tous les 1 à tous les 0,
il active l'indicateur d'interruption de minuterie TF1. L'entrée comptée est activée pour le temporisateur lorsque TR1 = 1 et GATE = 0 ou
INT1 = 1. (Le réglage de GATE = 1 permet au temporisateur d'être contrôlé par l'entrée externe INT1 pour ,faciliter les mesures de largeur
d'impulsion.) TRl est un bit de contrôle dans le registre de fonctions spéciales TCON. GATE est en TMOD.
Le registre 16 bits comprend les 8 bits de THl et les 8 bits inférieurs de TL1. La définition de l'indicateur d'exécution (TR1) n'efface pas
les registres.
Le mode 1 est identique au mode 0, sauf que le registre de minuterie est exécuté avec les 16 bits.
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T C/T=0 TL1 TH1
TF1 Interrompre
Broche T1
contrôle
TR1
GRILLE
INT1
95
Exemple : écrivez un programme en utilisant Timer 1 pour créer une onde carrée de 500 Hz sur P1.0.
Solution en langage d'assemblage :
ORG 0030H
MOUVEMENT TMOD, #10H ;Mode minuterie 16 bits

MOUVEMENT TH1, #0F8H ;1000 (octet de poids fort)
MOUVEMENT TH1, #30H ;1000 (octet de poids faible)
SETB TR1 ;Démarrer Tmier 1
BOUCLE : JNB TF1, BOUCLE CLR TF1 CPL P1.0 ;Attendez le débordement
;Effacer l'indicateur de dépassement de minuterie
;Basculer le bit de port

BOUCLE SJMP ;Répéter
FIN
Solution en langage C :
#inclure <REG51.H> /* Déclarations SFR */

sbit portbit = P1^0 ; /* Utiliser un portbit variable pour faire référence à P1.0 */
principal( )
{
TMOD = 0x10 ; tandis /* minuterie 1, mode 1, mode minuterie 16 bits */
que (1) { /* répéter indéfiniment */
TH1 = 0xF8 ; TL1 /* 1000 (octet de poids fort) */

= 0x30 ; TR1 = /* 1000 (octet de poids faible) */
1 ; tandis /* Démarrer le minuteur 1 */
que (TF0 !=1); TR1 = /* attendre le débordement */
0 ; TF0 = 0 ; /* arrêter le chronomètre 1 */
portbit = ! /* efface l'indicateur de débordement du minuteur */
(portbit); /* basculer P1.0 */

}
}
Mode 2
Le mode 2 configure le registre temporisé comme un compteur 8 bits (TL1) avec rechargement automatique. Le débordement de TL1 règle non seulement TFx,
mais recharge également TL1 avec le contenu de TH1, qui est prédéfini par le logiciel. Le rechargement laisse TH1 inchangé.
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T C/T=0 TL1
TF1 Interrompre
C/T=1 (8 bits)
Broche T1
contrôle
TR1
GRILLE TH1
(8 bits)
INT1
Minuterie/Compteur 1 Mode 2 : Rechargement automatique 8 bits
96
Le programme suivant est un code en langage assembleur qui domestère le minuteur 1 du MCU de la série STC89xx qui fait office de
générateur de débit en bauds.
;/* */

;/* La minuterie 1 du MCU série STC 89xx a fait office de démonstration du générateur de débit en bauds */
;/* */
;Déclarer le MCU SFR série STC89xx
AUXR ÉQU 8EH
;*/ */
;Définir le compteur de rechargement automatique du débit en bauds
;*************************************************** **************************
;Le nombre de rechargements et les Bauds suivants sont basés sur SYSclk = 22,1184 MHz, mode 1T, SMOD = 1
;RELOAD_COUNT ;Baud=1 382ÉQU 400 0FFH
bps
;RELOAD_COUNT ;Baud=691 200 ÉQUbps0FEH
ÉQU 0FDH ;Baud=460 800 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 0FCH;Baud=345 600 bps
;RELOAD_COUNT ;Baud=276 480 ÉQUbps0FBH
;RELOAD_COUNT ;Baud=230 400 ÉQUbps0FAH
;RELOAD_COUNT ;Baud=115 200 ÉQUbps0F4H
ÉQU 0E8H ;Baud=57 600 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 0DCH;Baud=38 400 bps
;RELOAD_COUNT ;Baud=19 200 ÉQUbps0B8H
;RELOAD_COUNT ;Baud=9 600ÉQU bps 70H
;*************************************************** *****************************
;Le nombre de rechargements et les Bauds suivants sont basés sur SYSclk = 1,8432 MHz, mode 1T, SMOD = 1.
;RELOAD_COUNT EQU 0FFH ;Baud=115 200 bps
;RELOAD_COUNT EQU 0FEH ;Baud=57 600 bps
;RELOAD_COUNT EQU 0FDH ;Baud=38 400 bps
;RELOAD_COUNT EQU 0FCH ;Baud=28 800 bps
;RELOAD_COUNT EQU 0FAH ;RELOAD_COUNT ;Baud=19 200 bps
EQU 0F4H ;Baud=9 600 bps
;RELOAD_COUNT EQU 0E8H ;Baud=4 800 bps
;RELOAD_COUNT EQU 0D0H ;Baud=2 400 bps
;RELOAD_COUNT EQU 0A0H ;Baud=1 200 bps
;*************************************************** *******************************
;RELOAD_COUNT ;Baud=1 152ÉQU
000 0FFH
bps
ÉQUbps
;RELOAD_COUNT ;Baud=576 000 0FEH
ÉQUbps
;RELOAD_COUNT ;Baud=288 000 0FDH
ÉQU 0FCH ;Baud=144 000 bps
ÉQU 0F6H
;RELOAD_COUNT ;RELOAD_COUNT ;Baud=115 200 bps
ÉQU
;RELOAD_COUNT ;Baud=57 600 bps0ECH
97
;RELOAD_COUNT ;Baud=38 ÉQU 0E2H

400 bps
;RELOAD_COUNT ;Baud=28 ÉQU 0D8H
800 bps
;RELOAD_COUNT ;Baud=19 ÉQU 0C4H
200 bps
;RELOAD_COUNT ;Baud=9 600 ÉQUbps088H
;*************************************************** *******************************
;RELOAD_COUNT ;Baud=576ÉQU 000 0FFH
bps
;RELOAD_COUNT ;Baud=288ÉQU 000 0FEH
bps
;RELOAD_COUNT ;Baud=144ÉQU 000 0FDH
bps
ÉQU 0FCH ;Baud=115 200 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 0F6H ;Baud=57 600 bps
;RELOAD_COUNT ;Baud=38 ÉQU 0ECH
400 bps
;RELOAD_COUNT ;Baud=28 ÉQU 0E2H
800 bps
;RELOAD_COUNT ;Baud=19 ÉQU 0D8H
200 bps
ÉQU 0C4H ;Baud=96 000 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 088H ;Baud=4 800 bps
;*************************************************** ********************************
ÉQU
RELOAD_COUNT ; Bauds = 9 600 0FBH
bps
ÉQU 0F6H ;Baud=4 800 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 0ECH ;Baud=2 400 bps
;RELOAD_COUNT ;Baud=1 200 ÉQUbps0D8H
;*************************************************** ********************************
ÉQU 0FBH ;Baud=19 200 bps
RELOAD_COUNT ;RELOAD_COUNT ÉQU 0F6H ;Baud=9 600 bps
;RELOAD_COUNT ;Baud=4 800 ÉQUbps0ECH
;RELOAD_COUNT ;Baud=1 200 ÉQUbps0B0H
;*************************************************** *******************************
;RELOAD_COUNT ;Baud=28 ÉQU 0FFH
800 bps
;RELOAD_COUNT ;Baud=14 ÉQU 0FEH
400 bps
;RELOAD_COUNT ;Baud=9 600 ÉQUbps0FDH
ÉQU 0FAH ;Baud=4 800 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 0F4H ;Baud=2 400 bpsS
;RELOAD_COUNT ;Baud=1 200 ÉQUbps0E8H
;*************************************************** *******************************
;*************************************************** *******************************
;RELOAD_COUNT ;Baud=57 ÉQU 0FFH
600 bps
;RELOAD_COUNT ;Baud=28 ÉQU 0FEH
800 bps
;RELOAD_COUNT ;Baud=14 ÉQU 0FDH
400 bps
;RELOAD_COUNT ;Baud=9 600 ÉQUbps0FAH
ÉQU 0F4H ;Baud=4 800 bps
;RELOAD_COUNT ;RELOAD_COUNT ÉQU 0E8H ;Baud=2 400 bps
;*************************************************** *******************************
98
;Définir l'indicateur LED

LED_MCU_START EQU P1.7 ; Indicateur LED de fonctionnement du MCU
;
ORG 0000H
AJMP PRINCIPAL
;

ORG 0023H
AJMP UART_Interrupt ; Passer au sousprogramme de service RS232 UARTInterrupt
NON
NON
;
PRINCIPAL:
MOUVEMENT SP, #7FH ;Définir le pointeur de pile

CLR LED_MCU_START ; Allumer l'indicateur LED de fonctionnement du MCU
ACALL Initial_UART ;Initialiser l'UART
MOUVEMENT R0, #30H ;30H = le code ASCII du caractère imprimable '0'
MOV R2, #10 ;Envoyez dix caractères '0123456789'
BOUCLE:
MOUVEMENT A, R0
ACALL Send_One_Byte ;Envoyer un octet
; si CharacterDisplay, afficher '0123456789'
;si affichage hexadécimal, afficher '30 31 32 33 34 35 36 37 38 39'
INC. R0
DJNZ R2, BOUCLE
MAIN_WAIT :
SJMP MAIN_WAIT ;cercle infini
;
UART_Interruption : ;Sousprogramme de service d'interruption UART
JB RI, Is_UART_Receive
CLR TI ;Effacer l'indicateur d'interruption de transmission du port série
RÉTI
Is_UART_Receive :
CLR IR
POUSSER ACC
MOUVEMENT A, SBUF ;acquérir l'octet reçu
ACALL Send_One_Byte ;renvoie l'octet reçu
ACC POP
RÉTI
;
Initial_UART : ;Initialiser l'UART
;Bits SCON : 7 6 5 4 3 2 dix
; SM0/FE SM1 SM2 REN TB8 RB8 TI RI

MOV SCON, #50H ; 0101,0000 Débit en bauds variable de 8 bits, pas de bit de parité impair
MOV TMOD, #21H ;Utiliser la minuterie 1 comme compteur de rechargement automatique 8 bits
MOV TH1, #RELOAD_COUNT ;Définir le nombre de rechargement automatique de la minuterie 1
MOV TL1, #RELOAD_COUNT

;
; ORL PCON, #80H ;débit en bauds doublé
99
;

; ORL AUXR, #01000000B ;Utiliser la minuterie 1 en mode 1T
ANL AUXR, #10111111B ;Utiliser la minuterie 1 en mode 12T
;
SETB R1 ; Minuterie de démarrage 1
SETB FR
ENSEMBLE EA
RETRAIT
;

;Paramètre du portail : A= l'octet à envoyer
Envoyer_One_Byte : ;Envoyer un octet
CLR FR
CLR TI ;Effacer l'indicateur d'interruption de transmission du port série
MOV SBUF, A
Wait_Send_Finish :
JNBTI, Attendre_Envoyer_Finir ;Attendez la fin de l'envoi
CLR TI
SETB FR
RETRAIT
;

FIN
Le temporisateur 2 est un temporisateur/compteur 16 bits qui peut fonctionner soit comme un temporisateur d'événements, soit comme un compteur d'événements, selon la sélection de
C/T2 dans le registre de fonctions spéciales T2CON. La minuterie 2 dispose de quatre modes de fonctionnement : le mode de capture, le mode de
rechargement automatique (comptage ou décomptage), le mode générateur de débit en bauds et le mode de sortie d'horloge programmable, qui sont
sélectionnés par les bits T2CON et T2MOD comme indiqué dans le tableau suivant.
Tableau des modes de fonctionnement de la minuterie 2
RCLK+TCLK CP/RL2 TR2 Mode

0 0 1 Rechargement automatique 16 bits
0 1 1 capture 16 bits
1 X 1 générateur de débit
X X 0 (éteint)
Mode de capture
En mode capture, il existe deux options sélectionnées par le bit EXEN2 dans T2CON. Si EXEN2=0, le temporisateur 2 est un temporisateur
ou un compteur de 16 bits qui, en cas de débordement, active le bit TF2 (indicateur de dépassement du temporisateur 2). Ce bit peut
ensuite être utilisé pour générer une interruption (en activant le bit d'interruption Timer 2 dans le registre IE). Si EXEN2 = 1, le temporisateur
2 fait toujours ce qui précède, mais avec la fonctionnalité supplémentaire qu'une transition de 1 à 0 sur l'entrée externe T2EX provoque la
capture de la valeur actuelle dans les registres du temporisateur 2, TH2 et TL2, dans les registres RCAP2H et RCAP2L, respectivement.
De plus, la transition à T2EX provoque la définition du bit EXF2 dans T2CON, et le bit EXF2, comme TF2, peut générer une interruption qui
se dirige vers le même emplacement que l'interruption de débordement du temporisateur 2. TF2 et EXF2 sont soumis à un OU pour
demander le service d'interruption. Le mode de capture est illustré dans la figure suivante.
100
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T C/T2=0 TL2 TH2
TF2
C/T2=1 (8 bits) (8 bits)
Broche T2 contrôle
Transition
capturer Minuterie 2
Détecteur TR2
Interrompre
RCAP2L RCAP2H
Broche T2EX EXF2
contrôle
EXEN2
Minuterie 2 en mode capture
Mode de rechargement automatique
En mode de rechargement automatique 16 bits, la minuterie 2 peut être configurée pour compter vers le haut ou vers le bas. Le sens de comptage est déterminé par
DCEN dans le registre de fonctions spéciales T2MOD et la broche T2EX. Si DCEN=0, comptage croissant. Si DCEN=1, le sens de comptage est déterminé par la broche
T2EX. Si T2EX=1, décompte croissant, sinon décompte.
La figure suivante montre DCEN=0, ce qui permet au Timer 2 de compter automatiquement. Dans ce mode, il existe deux options sélectionnées par le bit EXEN2 dans le
registre T2CON. Si EXEN2=0, alors le temporisateur 2 compte jusqu'à 0FFFFH et active le bit TF2 (Overflow Flag) en cas de débordement. Cela provoque le rechargement
des registres Timer 2 avec la valeur 16 bits dans RCAP2L et RCAP2H. Les valeurs dans RCAP2L et RCAP2H sont prédéfinies par le firmware. Si EXEN2=1, alors un
rechargement 16 bits peut être déclenché soit par un débordement, soit par une transition 1 vers 0 à l'entrée T2EX. Cette transition définit également le bit EXF2.
L'interruption Timer 2, si elle est activée, peut être générée lorsque TF2 ou EXF2 sont 1.
MCU en mode 12T

÷12
SYSclk
÷6
MCU en mode 6T C/T2=0 TL2 TH2
C/T2=1 (8 bits) (8 bits)
Broche T2 contrôle
recharger
Transition TR2
Détecteur TF2 Minuterie 2
RCAP2L RCAP2H
Interrompre
Broche T2EX EXF2
contrôle
EXEN2
Minuterie 2 en mode de rechargement automatique (DCEN=0)
101
La figure suivante montre DCEN=1, ce qui permet au minuteur 2 de compter vers le haut ou vers le bas. Ce mode permet à la broche T2EX de contrôler le sens de
comptage. Lorsqu'un 1 logique est appliqué à la broche T2EX, la minuterie 2 comptera. La minuterie 2 débordera à 0FFFFH et définira l'indicateur TF2, qui pourra alors
générer une interruption si l'interruption est activée. Ce débordement provoque également le rechargement de la valeur 16 bits dans RCAP2L et RCAP2H dans les
registres temporisateurs TL2 et TH2. Un 0 logique appliqué à la broche T2EX entraîne le compte à rebours du minuteur 2. La minuterie débordera lorsque TL2 et TH2
deviendront égales à la valeur stockée dans RCAP2L et RCAP2H. Ce dépassement bas active le drapeau TF2 et provoque le rechargement de 0FFFFH dans les
registres temporisateurs TL2 et TH2.
L'indicateur externe EXF2 bascule lorsque le Timer 2 dépasse ou dépasse. Ce bit EXF2 peut être utilisé comme 17ème bit de résolution si nécessaire. L'indicateur EXF2
ne génère pas d'interruption dans ce mode.
Décompte de la valeur de rechargement

MCU en mode 12T Basculer
÷12
FFF FFF
EXF2
SYSclk
÷6
MCU en mode 6T C/T2=0 TL2 TH2 Débordement Minuterie 2
TF2
C/T2=1 (8 bits) (8 bits) Interrompre
Broche T2 contrôle
Direction de comptage
1=HAUT
TR2 0=BAS
RCAP2L RCAP2H
Broche T2EX
Comptage de la valeur de rechargement
Minuterie 2 en mode de rechargement automatique (DCEN=1)
Mode générateur de débit Buad
Timer2 peut être configuré pour générer différents débits en bauds. Les bits TCLK et/ou RCLK dans T2CON permettent aux débits en bauds de transmission et de
réception du port série d'être dérivés de Timer1 ou Timer2. Lorsque TCLK = 0, Timer1 est utilisé comme générateur de débit en bauds de transmission du port série.
Lorsque TCLK = 1, Timer2 est utilisé comme générateur de débit en bauds de transmission du port série. RCLK a le même effet pour le débit en bauds du port série.
Avec ces deux bits, le port série peut avoir différents débits en bauds de réception et de transmission – l'un généré par le minuteur 1 et l'autre par le minuteur 2.
En mode BRG, les minuteries fonctionnent de manière très similaire au mode de rechargement automatique uniquement, sauf que la broche T2EX ne peut pas contrôler
le rechargement. Un débordement sur Timer 2 chargera le contenu RCAP2H, RCAP2L sur Timer2, mais TF2 ne sera pas défini. Une transition 1 vers 0 sur la broche
P2EX peut configurer EXF2 pour demander un service d'interruption si EXEN2 = 1.
La figure suivante montre le Timer 2 en mode de génération de débit en bauds pour générer l'horloge RX et l'horloge TX dans le moteur UART. Le mode de génération
de débit en bauds est similaire au mode de rechargement automatique, dans la mesure où un basculement dans TH2 provoque le rechargement des registres Timer 2
avec la valeur 16 bits dans les registres RCAP2H et RCAP2L, qui sont prédéfinis par logiciel.
Le débit en bauds dans les modes UART 1 et 3 est déterminé par le débit de débordement de Timer2 indiqué cidessous :
Débit de débordement de la minuterie 2
Débit en bauds = (en comptant T2EX)
16
La minuterie peut être configurée pour un fonctionnement « minuterie » ou « compteur ». Dans les applications les plus typiques, il est configuré pour le fonctionnement
« timer » (C/T2=0). Le fonctionnement « Timer » est un peu différent pour le Timer 2 lorsqu'il est utilisé comme générateur de débit en bauds. Normalement, en tant que
minuterie, elle incrémente chaque cycle de machine (donc à 1/6 ou 1/12 de l'horloge système). Dans ce cas, le débit en bauds est donné par le formulaire : SYSclk
(comme minuterie)
Débit en bauds =
n×[65536 (RCAP2H, RCAP2L)]
lorsque le MCU est en mode 12T, n=32 ; Lorsque le MCU est en mode 6T, n = 16.
102
Minuterie 1
Débordement
MCU en mode 12T

÷12
÷2
SYSclk '0' '1'
÷6 SMOD
MCU en mode 6T C/T2=0 TL2 TH2 '1' '0'
C/T2=1 (8 bits) (8 bits) RCLK
Broche T2 contrôle
÷16 Horloge RX
Recharger '1'
Transition '0'
TR2
Détecteur TCLK
RCAP2L RCAP2H
÷16 Horloge d'émission
Broche T2EX Minuterie 2

EXF2
Interrompre
contrôle
EXEN2
Minuterie 2 en mode générateur de débit en bauds
Le Timer 2 en tant que mode générateur de débit en bauds n'est valide que si RCLK et/ou TCLK=1 dans le registre T2CON. Notez qu'un
rollover dans TH2 ne définit pas TF2 et ne générera pas d'interruption. Ainsi, l'interruption du Timer 2 n'a pas besoin d'être désactivée lorsque
le Timer 2 est en mode générateur de débit en bauds. De plus, si EXEN2 (bit d'activation externe T2) est activé, une transition 1 vers 0 dans
T2EX (entrée de déclenchement minuterie/compteur 2) activera EXF2 (drapeau externe T2) mais ne provoquera pas de rechargement depuis
(RCAP2H, RCAP2L). à (TH2,TL2). Par conséquent, lorsque le Timer 2 est utilisé comme générateur de débit en bauds, T2EX peut être
utilisé comme interruption externe supplémentaire, si nécessaire.
Il convient de noter que lorsque le Timer 2 fonctionne (TR2=1) en fonction "timer" en mode générateur de débit en bauds, il ne faut pas
essayer de lire ou d'écrire TH2 et TL2. En tant que générateur de débit en bauds, le minuteur 2 est incrémenté à la moitié de l'horloge
système ou de manière asynchrone à partir de la broche T2 ; dans ces conditions, une lecture ou une écriture de TH2 ou TL2 peut ne pas être précise.
Les registres RCAP2 peuvent être lus, mais ne doivent pas être écrits, car une écriture pourrait chevaucher un rechargement et provoquer
des erreurs d'écriture et/ou de rechargement. La minuterie doit être éteinte (effacer TR2) avant d'accéder aux registres Timer 2 ou RCAP2.
Le programme suivant est un code en langage assembleur qui domestère le Timer 2 du MCU de la série STC89xx qui fait office de générateur
de débit en bauds.
;/* */

;/* Minuterie 2 du MCU série STC 89xx en tant que démo du générateur de débit en bauds */
;/* */
;Déclarer les MCU SFR de la série STC89xx
;SFR associés au Timer 2 et au port RS232
T2CON ÉQU 0C8H
TR2 ÉQU. T2CON.2 ;TR2 est le deuxième bit de SFR—T2CON
103
RCAP2L ÉQU 0CAH

RCAP2H ÉQU 0CBH
TH2 ÉQU 0CDH
TL2 ÉQU 0CCH
;
;Définir la valeur de rechargement automatique du débit en bauds
RELOAD_COUNT_HIGH ÉQU 0FFH
;RELOAD_COUNT_HIGH doit être défini sur 0FFH lorsque les paramètres suivants sont
utilisés ;RELOAD_COUNT_LOW EQU 0FAH ;SYSclk=22,1184 MHz, Baud=115200
;RELOAD_COUNT_LOW EQU 0EEH ;SYSclk=22,1184MHz, Baud=38400
;RELOAD_COUNT_LOW EQU 0F0H ;SYSclk=20.000MHz, Baud=38400
;RELOAD_COUNT_LOW EQU 0F6H ;RELOAD_COUNT_LOW ;SYSclk=12 000 MHz, Bauds=38 400
EQU 0FDH ;SYSclk=11,059MHz, Baud=115200
;RELOAD_COUNT_LOW EQU 0F7H ;SYSclk=11,059 MHz, Baud=38 400
;RELOAD_COUNT_LOW EQU 0F8H ;SYSclk=10.000MHz, Baud=38400
;RELOAD_COUNT_LOW EQU 0FBH ;SYSclk=6.000MHz, Baud=38400
;RELOAD_COUNT_LOW EQU 0FCH ;RELOAD_COUNT_LOW ;SYSclk=5 000 MHz, Bauds=38 400
EQU 070H ;SYSclk=11,059 MHz, Baud=2400
;
;calculer la valeur de rechargement automatique
;

;RELOAD=INT(SYSclk/Baud/32+0.5), INT signifie obtenir une partie entière et abandonner la partie fractionnaire
; changez le RELOAD décimal en hexadécimal et enregistrez la valeur de 1000H en soustrayant RELOAD dans RCAP2H, RCAP2L
;

ORG 0000H
PRINCIPAL AJMP
;
ORG 0023H ;Interruption du port série RS232
AJMPUART
NON
NON
;
PRINCIPAL:
MOUVEMENT SP, #0E0H

ACALL Initial_UART ;Initialiser le port série
MOUVEMENT R0, #30H ;Envoyez dix caractères "0123456789"
MOV R2, #10
BOUCLE:
MOUVEMENT A, R0
ACALL Send_One_Byte ;Envoyer un octet
INC. R0
DJNZ R2, BOUCLE
ATTENDRE1 :
SJMP ATTENDRE1 ;arrêt dynamique
104
;
UART : ;Routine de service d'interruption du port série
JBC RI, UART_1
RÉTI ;Demande lors de la transmission
UART_1 : ;Recevoir un octet
POUSSER ACC
MOUVEMENT A, SBUF ;Récupère l'octet reçu
ACALL Send_One_Byte ;Renvoyer l'octet reçu
ACC POP
RÉTI
;
Initial_UART : ;Initialiser le port série
;BIT 7 6 5 4 321 0
;SCON SM0/FE SM1 SM2 REN TB8 RB8 TI ;0101,0000 Débit en bauds variable 8 bits, RI
MOUVEMENT SCON, #50H pas de parité
Init_RS232 :
MOUVEMENT A #RELOAD_COUNT_HIGH ;Valeur de rechargement automatique en Bauds
MOV RCAP2H,A
MOUVEMENT TH2, A
MOUVEMENT A, #RELOAD_COUNT_LOW
MOUVEMENT RCAP2L,A
MOV TL2, A
MOUVEMENT T2CON, #0x34 ;Timer 2 comme générateur de débit en bauds
SETB FR ;Activer l'interruption du port série
ENSEMBLE EA
RETRAIT
;
;Envoyer_One_Byte : ;Envoyer un octet
CLR FR
CLR TI ;effacer l'indicateur d'interruption de transmission UART
MOV SBUF, A
ATTENDRE2 :
JNBTI, ATTENDRE2 ;Attendez la fin de la transmission

CLR TI
SETB FR
RETRAIT
;
FIN
;
105
Mode de sortie d'horloge programmable
La série STC89xx est capable de générer une sortie d'horloge programmable sur P1.0. Lorsque le bit T2OE est activé et que le bit C//T2 est effacé,
l'impulsion de débordement de la minuterie 2 génère une horloge de service de 50 % et la transmet à P1.0. La fréquence de pointage est calculée selon
la formule suivante.
SYSclk
Débit en bauds =
n×[65536 (RCAP2H, RCAP2L)
lorsque le MCU est en mode 12T, n=4 ; lorsque le MCU est en mode 6T, n = 2.
Remarque Timer 2 overflag, TF2 ne sera toujours pas réglé dans ce mode.
L'horloge d'entrée, SYSclk/2, incrémente le temporisateur de 16 bits (TH2, TL2). La minuterie compte à plusieurs reprises pour dépasser une valeur
chargée. Une fois les débordements produits, le contenu de (RCAP2H, RCAP2L) est chargé dans (TH2, TL2) pour le comptage consécutif. En mode
d'horloge de sortie, les basculements du Timer2 ne généreront pas d'interruption. Ceci est similaire à lorsque Timer 2 est utilisé comme générateur de
débit en bauds. Il est possible d'utiliser Timer 2 simultanément comme générateur de débit en bauds et comme générateur d'horloge. Notez cependant
que le débit en bauds et la fréquence d'horloge de sortie dépendent du même taux de débordement du Timer 2. La figure suivante montre le Timer 2 en
mode de sortie d'horloge programmable.
MCU en mode 12T

÷12
SYSclk TL2 TH2

(8 bits) (8 bits)
÷6 contrôle
MCU en mode 6T
TR2
RCAP2L RCAP2H
C/T2
Broche T2 (P1.0) ÷2
T2OE
Transition
Détecteur
Broche T2EX (P1.1) EXF2 Interruption de la minuterie 2
contrôle
EXEN2
Minuterie 2 en mode de sortie d'horloge programmable
Si la minuterie 2 est en mode Programmabel Clock Out, certaines opérations comme indiqué cidessous doivent être effectuées :
•
Définissez le bit T2OE dans le registre T2MOD.
•
Effacer le bit C/T2 dans le registre T2CON.
•
Déterminez la valeur de rechargement 16 bits à partir de la formule et saisissezla dans les registres RCAP2H et RCAP2L.
•
Entrez la même valeur de rechargement que la valeur initiale dans les registres TH2 et TL2.
•
Réglez le bit TR2 dans le registre T2CON pour démarrer le Timer 2.
106
Le programme suivant est un code en langage assembleur qui domestère la fonction d'horloge/sortie d'impulsion programmable du
Timer 2 sur P1.0.
;/* */

;/* Minuterie MCU 2 série STC 89xx en mode horloge/sortie d'impulsion programmable, sur P1.0*/
;/* */
;Déclarer les MCU SFR de la série STC89xx
;SFR associés au Timer 2 et au port RS232
T2CON ÉQU 0C8H
T2MOD ÉQU 0C9H
TR2 ÉQU T2CON.2 ÉQU ;TR2 est le deuxième bit de SFR—T2CON
RCAP2L 0CAH
RCAP2H ÉQU 0CBH
TH2 ÉQU 0CDH
TL2 ÉQU 0CCH
; Registre de contrôle minuterie/compteur 2 T2CON
; B7 B6 B5 CF CE CD B4 B3 B2 B0 Réinitialiser la valeur
B1 ; adresse de bit CC CB CA C9 C8
;T2CON(C8H) TF2 EXF2 RCLK TCLK EXEN2 TR2 C//T2 CP//RL2 00
;T2MOD Registre
; B7 B6 B5 B4 B3 B2 B1 B0 Réinitialiser la valeur
T2OE DCEN xxxxxx00B
;T2CON(C9H) ;
ORG 0000H
PRINCIPAL AJMP
;
ORG 0100H
PRINCIPAL:
MOUVEMENT SP, #0E0H

MOV P1, #0FFH ;éteindre le voyant du port P1
ACALL SET_T2_OUT_MODE ;Réglez la minuterie 2 comme mode de sortie d'impulsions à grande vitesse
MOUVEMENT DPTR, #0FFF0H ;Régler la vitesse de sortie d'impulsion de la minuterie
ACALL SET_T2_OUT_SPEED
ATTENDRE1 :
SJMP ATTENDRE1
DÉLAI D'APPEL
PAUSE D'APPEL ;Pause pour observation
MOUVEMENT DPTR, #0FFE0H ; Régler la vitesse de sortie d'impulsion de la minuterie, inférieure de 1/2 à la dernière
DÉLAI D'APPEL
MOUVEMENT DPTR #0FFD0H Régler la vitesse de sortie d'impulsion de la minuterie, inférieure de 1/3 à la dernière fois
107
DÉLAI D'APPEL
ATTENDRE2 :
SJMP ATTENDRE2 ;arrêt dynamique

;
RETARD:
MOV R1, #0
MOUVEMENT R2, #0
MOUVEMENT R3, #30
DELAY_LOOP :
DJNZ R1, DELAY_LOOP
DJNZ R2, DELAY_LOOP
DJNZ R3, DELALY_LOOP
RETRAIT
;
SET_T2_OUT_MODE : ;Définir Timer2 comme mode de sortie d'impulsion
MOUVEMENT T2CON, #0 ;Définir la minuterie 2 comme mode "minuterie"
MOV T2MOD, #02 ;0000,0010, activer

;Impulsion de débordement du temporisateur 2 émise sur P1.0
;
SET_T2_OUT_SPEED : ;Régler la vitesse de sortie d'impulsion de la minuterie 2
CLR TR2 ;Désactiver la minuterie 2
MOV RCAP2H, DPH

MOV RCAP2L, chef du projet Debian
SETB TR2 ;Déclenchement du minuteur 2
RETRAIT
;
PAUSE: ;Fermer la fonction Minuterie 2
CLR TR2
MOV P1, #0FFH ;éteindre le voyant du port P1
DÉLAI D'APPEL
RETRAIT
;
FIN
;
108
Chapitre 8 UART avec fonction améliorée
Le port série de la série STC89xx est en duplex intégral, ce qui signifie qu'il peut transmettre et recevoir simultanément. Il est
également tamponné en réception, ce qui signifie qu'il peut commencer la réception d'un deuxième octet avant qu'un octet
précédemment reçu n'ait été lu dans le registre de réception. (Cependant, si le premier octet n'a toujours pas été lu au moment
où la réception du deuxième octet est terminée, l'un des octets sera perdu). Le port série de réception et de transmission
partage le même SFR – SBUF, mais en réalité il y a deux registres SBUF dans la puce, l'un pour la transmission et l'autre pour la réception.
Le port série peut fonctionner selon 4 modes différents : le mode 0 fournit une communication synchrone tandis que les modes 1, 2 et 3
fournissent une communication asynchrone. La communication asynchrone fonctionne comme un récepteur et émetteur asynchrone
universel (UART) fullduplex, qui peut transmettre et recevoir simultanément et à différents débits en bauds.
La communication série implique la transmission de bits de données via une seule ligne de communication. Les données sont transmises
bit par bit au format synchrone ou asynchrone. La communication série synchrone transmet un bloc entier de caractères en synchronisation
avec une horloge de référence tandis que la communication série asynchrone transmet de manière aléatoire un caractère à tout moment,
indépendamment de toute horloge.
Valeur après
SBUF Tampon série 99H xxxx xxxxB
C'EST À DIRE
Activation d'interruption A8H EA ET2 ES ET1 EX1 ET0 EX0 0000 0000B
Priorité d'interruption PT2 PS PT1 PX1 PT0 PX0

PI B8H xx00 0000B
Faible
Priorité d'interruption PX3H PX2H PT2H PSH PT1H PX1H PT0H PX0H
IPH B7H 0000 0000B
Haut
Adresse de l'esclave
SADEN B9H 0000 0000B
Masque
Adresse de l'esclave SADDR A9H 0000 0000B
109
Registre SCON
LSB
peu B7 B5 B4 B3 B2 B1 B0
Nom B6 SM0/FE SM1 SM2 REN TB8 RB8 TI RI
FE : bit d'erreur de trame. Le bit SMOD0 doit être défini pour permettre l'accès au bit FE
0 : le bit FE n'est pas effacé par les trames valides mais doit être effacé par le logiciel.
1 : ce bit est défini par le récepteur lorsqu'un identifiant de bit d'arrêt invalide est détecté.
SM0,SM1 : Mode port série Bit 0/1.
SM0 SM1 Description 0 Registre à décalage 8 bits Débit en bauds
0 UART 8 bits SYSclk/12

0 1 variable
1 0 UART 9 bits SYSclk/64 ou SYSclk/32(SMOD=1)
1 1 UART 9 bits variable
SM2 : Activez la fonction de reconnaissance automatique d'adresse en modes 2 et 3. Si SM2=1, RI ne sera pas défini
à moins que le 9ème bit de données reçu soit 1, indiquant une adresse, et que l'octet reçu soit une
adresse donnée ou de diffusion. En mode 1, si SM2=1 alors RI ne sera pas défini sauf si un arrêt valide
Le bit a été reçu et l'octet reçu est une adresse donnée ou de diffusion. En mode 0, SM2 doit être 0.
REN : Lorsqu'il est défini, il active la réception série.
TB8 : Le 9ème bit de données qui sera transmis en mode 2 et 3.
RB8 : En mode 2 et 3, le 9ème bit de données reçu ira dans ce bit.
TI : indicateur d'interruption de transmission.
RI : réception d'un indicateur d'interruption.
Registre SBUF
LSB
peu 7 6 5 4 3 2 1 0
nom
Il est utilisé comme registre tampon en émission et en réception. Le registre tampon du port série (SBUF) est en réalité constitué de
deux tampons. L'écriture sur SBUF charge les données à transmettre et la lecture sur SBUF accède aux données reçues. Il s'agit de
deux registres séparés et distincts, le registre de transmission en écriture seule et le registre de réception en lecture seule.
PCON : registre de contrôle de puissance

LSB
Nom B7 SMOD SMOD0 FOP CA1 GF0 PD IDL
SMOD : bit de contrôle du débit double.
0 : Désactive le double débit en bauds de l'UART.
1 : Activer le double débit en bauds de l'UART en mode 1,2 ou 3.
SMOD0 : sélection d'erreur de trame.
0 : SCON.7 est la fonction SM0.
1 : SCON.7 est la fonction FE. Notez que FE sera défini après une erreur de trame quel que soit l'état de SMOD0.
110
IE : Interruption Activer Rsgister
(MSB) (LSB)
EA ET2 ES ET1 EX1 ET0 EX0
Enable Bit = 1 active l'interruption.

Activer Bit = 0 le désactive .
Fonction de position du symbole

désactive toutes les interruptions. si EA = 0, aucune interruption ne sera acquittée. si EA = 1, chaque
EA IE.7
source d'interruption est activée ou désactivée individuellement en réglant ou en effaçant son bit d'activation.
ES Bit d'activation d'interruption du port série IE.4
IP : Registre bas à priorité d'interruption
(MSB) (LSB)
PT2 PS PT1 PX1 PT0 PX0
Le bit de priorité = 1 attribue une priorité élevée.

Bit de priorité = 0 attribue une faible priorité.
Symbole Position PS Fonction
IP.4 Bit de priorité d’interruption du port série.
IPH : registre élevé à priorité d'interruption

LSB
Nom B2 PX3H PX2H PT2H PSH PT1H PX1H PT0H PX0H
PSH : si défini, définissez la priorité la plus élevée pour le port série.
SADEN : registre de masque d'adresse d'esclave

LSB
nom
SADDR : registre d'adresses d'esclave

LSB
nom
Le registre SADDR est combiné avec le registre SADEN pour former une adresse donnée/diffusée pour la reconnaissance
automatique de l'adresse. En fait, SADEN fonctionne comme un registre « masque » pour le registre SADDR. Ce qui suit en est
un exemple.
SADDR = 1100 0000
SADEN = 1111 1101
Donné = 1100 00x0 L'adresse de l'esclave donnée sera vérifiée sauf que le bit 1 est traité
comme "ne s'en soucie pas".
L'adresse de diffusion pour chaque esclave est créée en prenant le OU logique de SADDR et SADEN. Zéro dans ce résultat est
considéré comme « je m'en fiche » et une adresse diffusée de tous « je m'en fiche ». Cela désactive la fonction de détection
automatique d'adresse.
111
8.1 Mode de fonctionnement UART
Registre à décalage 8 bits (mode 0)
Le mode 0, sélectionné en écrivant des 0 dans les bits SM1 et SM0 de SCON, met le port série en mode registre à décalage 8 bits.
Les données série entrent et sortent via RXD, et TXD génère l'horloge de décalage. Huit bits de données sont transmis/
reçu avec le moins significatif (LSB) en premier. Le débit en bauds est fixé à 1/12 du cycle d'horloge du système. Les termes « RxD » et «
TxD » sont trompeurs dans ce mode. La ligne RxD est utilisée à la fois pour l'entrée et la sortie des données, et la ligne TxD sert d'horloge.
La transmission est initiée par toute instruction qui utilise SBUF comme registre de destination. Le signal « écrire sur SBUF » charge
également un « 1 » dans la 9ème position du registre à décalage de transmission et indique au bloc de contrôle TX de commencer une
transmission. Le timing interne est tel qu'un cycle d'horloge système complet s'écoulera entre « l'écriture sur SBUF » et l'activation de SEND.
SEND transfère la sortie du registre à décalage vers la ligne de fonction de sortie alternative de P3.0, et transfère également Shift Clock vers
la ligne de fonction de sortie alternative de P3.1. Au front descendant de l'horloge à décalage, le contenu du registre à décalage est décalé
d'une position vers la droite.
À mesure que les bits de données se déplacent vers la droite, « 0 » arrive par la gauche. Lorsque le MSB de l'octet de données est à la
position de sortie du registre à décalage, alors le « 1 » qui a été initialement chargé dans la 9ème position se trouve juste à gauche du MSB,
et toutes les positions à gauche de celuici contiennent des zéros. Cette condition signale au bloc de contrôle TX d'effectuer un dernier
décalage, puis de désactiver SEND et de définir TI. Ces deux actions se produisent après « écrire dans SBUF ».
La réception est initiée par la condition REN=1 et RI=0. Après cela, l'unité de contrôle RX écrit les bits 11111110 dans le registre à décalage
de réception et, dans la phase d'horloge suivante, active RECEIVE. RECEIVE active SHIFT CLOCK sur la ligne de fonction de sortie
alternative de P3.1. Lorsque RECEIVE est actif, le contenu du registre à décalage de réception est décalé vers la gauche d'une position. La
valeur qui vient de droite est la valeur qui a été échantillonnée au niveau de la broche P3.0, sur le front montant de l'horloge Shift.
Lorsque les bits de données arrivent par la droite, les « 1 » se déplacent vers la gauche. Lorsque le «0» initialement chargé dans la position
la plus à droite arrive à la position la plus à gauche dans le registre à décalage, il signale au bloc de contrôle RX d'effectuer un dernier
décalage et de charger SBUF. Ensuite, RECEIVE est effacé et RI est défini.
112
BUS INTERNE DU MCU STC
ÉCRIRE
À
DS FONCTION
SBUF Q SBUF DE SORTIE RXD/P3.0
CL
CHANGEMENT
DÉTECTEUR DE ZÉRO
COMMENCER CHANGEMENT
CONTRÔLE D'ÉMISSION
SYSclk/12 HORLOGE TX TI ENVOYER
EN SÉRIE
PORT
INTERROMPRE CHANGEMENT FONCTION
RX HORLOGE RI HORLOGE DE SORTIE TXD/P3.1
RECEVOIR
CONTRÔLE RÉCEPTION
REN CHANGEMENT
COMMENCER
11111110
RI
DÉCALAGE D'ENTRÉE REG. FONCTION

D'ENTRÉE RXD/P3.0
CHARGER
CHANGEMENT
SBUF
SBUF
LIRE
SBUF
ÉCRIRE À SBUF
ENVOYER
CHANGEMENT
TRANSMETTRE
D1 D2 D3 D4 J5 D6 J7
RXD (SORTIE DE DONNÉES) D0
TXD (HORLOGE DE DÉCALAGE)
TI
ÉCRIRE À SCON (EFFACER RI)
RI
RECEVOIR
RECEVOIR
CHANGEMENT
D0 D1 D2 D3 D4 J5 D6 J7
RXD (ENTRÉE DE DONNÉES)
TXD (HORLOGE DE DÉCALAGE)
Mode port série 0
113
UART 8 bits avec débit en bauds variable (mode 1)
En mode 1, le port série STC89xx fonctionne comme un UART 8 bits avec un débit en bauds variable. Un UART, ou « récepteur/émetteur
asynchrone universel », est un appareil qui reçoit et transmet des données série avec chaque caractère de données précédé d'un bit de démarrage
(bas) et suivi d'un bit d'arrêt (haut). Un bit de parité est parfois inséré entre le dernier bit de données et le bit d'arrêt. Le fonctionnement essentiel
d'un UART est la conversion parallèlesérie des données de sortie et la conversion sérieparallèle des données d'entrée.
En mode 1, 10 bits sont transmis via TXD ou reçus via RXD. Les données de trame comprennent un bit de départ (toujours 0), 8 bits de données
(LSB en premier) et un bit d'arrêt (toujours 1). Pour une opération de réception, le bit d'arrêt va dans RB8 dans SFR – SCON. Le débit en bauds est
déterminé par le taux de débordement du Timer 1 ou du Timer 2. .
Débit en bauds en mode 1 = (2SMOD /32 ) x débit de débordement du timer

1 ou = (2SMOD /16 ) x débit de débordement du timer 2
La transmission est initiée par toute instruction qui utilise SBUF comme registre de destination. Le signal « écriture sur SBUF » charge également
un « 1 » dans la position 9e bit du registre à décalage de transmission et signale à l'unité de contrôle TX qu'une transmission est demandée. La
transmission se produit en fait au prochain retournement du compteur divisé par 16. Ainsi, les temps binaires sont synchronisés sur le compteur
divisé par 16, et non sur le signal « écriture dans SBUF ».
La transmission commence par l'activation de SEND qui met le bit,de départ à TXD. Un peu plus tard, DATA est activé, ce qui active le bit de sortie
du registre à décalage de transmission vers TXD. La première impulsion de décalage se produit un peu plus tard.
À mesure que les bits de données se déplacent vers la droite, les zéros sont cadencés à partir de la gauche. Lorsque le MSB de l'octet de données
est à la position de sortie du registre à décalage, alors le 1 qui a été initialement chargé dans la 9ème position se trouve juste à gauche du MSB, et
toutes les positions à gauche de celuici contiennent des zéros. Cette condition signale à l'unité de contrôle TX d'effectuer un dernier changement,
puis de désactiver SEND et de régler TI. Cela se produit lors du 10e roulement de division par 16 après « écriture dans SBUF ».
La réception est initiée par une transition 1 vers 0 détectée au RXD. À cette fin, RXD est échantillonné à une vitesse de 16 fois la vitesse de
transmission établie. Lorsqu'une transition est détectée, le compteur divisé par 16 est immédiatement réinitialisé et 1FFH est écrit dans le registre
à décalage d'entrée. La réinitialisation du compteur divisé par 16 aligne ses rollovers sur les limites des temps de bits entrants.
Les 16 états du compteur divisent chaque temps bit en seizièmes. Aux 7ème, 8ème et 9ème états du compteur de chaque temps bit, le détecteur
de bits échantillonne la valeur de RXD. La valeur acceptée est la valeur observée dans au moins 2 des 3 échantillons. Ceci est fait pour rejeter le
bruit. Afin de rejeter les faux bits, si la valeur acceptée pendant le premier temps bit n'est pas un 0, les circuits de réception sont réinitialisés et
l'unité continue à chercher une autre transition 1 vers 0. Ceci permet de rejeter les bits de faux départ. Si le bit de départ est valide, il est décalé
dans le registre à décalage d'entrée et la réception du reste de la trame se poursuit.
Lorsque les bits de données arrivent par la droite, les « 1 » se déplacent vers la gauche. Lorsque le bit de départ arrive à la position la plus à
gauche dans le registre à décalage (qui est un registre de 9 bits en mode 1), il signale au bloc de contrôle RX d'effectuer un dernier décalage, de
charger SBUF et RB8 et de définir RI. Le signal pour charger SBUF et RB8 et pour définir RI est généré si, et seulement si, les conditions suivantes
sont remplies au moment où l'impulsion de décalage finale est générée.
1) RI=0 et 2)
Soit SM2=0, soit SM2=0 et le bit d'arrêt reçu = 1
Si l’une ou l’autre de ces deux conditions n’est pas remplie, la trame reçue est irrémédiablement perdue. Si les deux conditions sont remplies, le bit
d'arrêt passe dans RB8, les 8 bits de données vont dans SBUF et RI est activé. A ce moment, que les conditions cidessus soient remplies ou non,
l'unité continue de rechercher une transition 1 vers 0 dans RXD.
114

MINUTERIE 2
DÉBORDEMENT TB8
MINUTERIE 1
DÉBORDEMENT ÉCRIRE
À
DS Q
SBUF SBUF TXD
CL
÷2
SMOD SMOD DÉTECTEUR DE ZÉRO
=0 =1
DONNÉES
"0" "1"
TCLK
÷16 HORLOGE TX TI ENVOYER
EN SÉRIE
"0" "1" PORT
INTERROMPRE
RCLK
÷16
ÉCHANTILLON
1À0 RX HORLOGE RI CHARGER
TRANSITION COMMENCER
SBUF
DÉTECTEUR CHANGEMENT
1FFH
PEU
DÉTECTEUR
DÉCALAGE D'ENTRÉE REG.

RXD (9 BITS)
CHANGEMENT
CHARGER
SBUF
SBUF
LIRE
SBUF
Émission
HORLOGE
ÉCRIRE À SBUF
ENVOYER
TRANSMETTRE
DONNÉES
CHANGEMENT
TXD D0 D1 D2 D3 D4 D5 D6 D7 ARRÊTER LE PEU
TI DÉMARRAGE
HORLOGE RÉCEPTION ÷16 RÉINITIALISATION
RXD DÉMARRAGE J0 J1 D2 D3 D4 D5 D6 D7 ARRÊTER LE PEU

RECEVOIR TEMPS D’ÉCHANTILLON DU DÉTECTEUR DE BITS
CHANGEMENT
RI
Mode port série 1
115
UART 9 bits avec débit en bauds fixe (mode 2)
Lorsque SM1=1 et SM0=0, le port série fonctionne en mode 2 comme un UART 9 bits avec un débit en bauds fixe. 11 bits sont transmis via
TXD ou reçus via RXD. Les données de trame comprennent un bit de départ (0), 8 bits de données, un 9ème bit de données programmable
et un bit d'arrêt (1). Lors de la transmission, le 9ème bit de données provient de TB8 dans SCON. A la réception, le 9ème bit de données va
dans RB8 dans SCON. Le débit en bauds est programmable à 1/32 ou 1/64 du cycle d'horloge du système.
Débit en bauds en mode 2 = (2SMOD/64) x SYSclk
La transmission est initiée par toute instruction qui utilise SBUF comme registre de destination. Le signal « écriture sur SBUF » charge
également TB8 dans la position 9ème bit du registre à décalage de transmission et signale à l'unité de contrôle TX qu'une transmission est
demandée. La transmission se produit en fait au prochain retournement du compteur divisé par 16. Ainsi, les temps binaires sont synchronisés
sur le compteur divisé par 16, et non sur le signal « écriture dans SBUF ».
La transmission commence lorsque /SEND est activé, ce qui place le bit de départ à TXD. Un peu plus tard, DATA est activé, ce qui active le
bit de sortie du registre à décalage de transmission vers TXD. La première impulsion de décalage se produit un peu plus tard. Le premier
décalage synchronise un « 1 » (le bit d'arrêt) à la 9ème position du bit sur le registre à décalage. Par la suite, seuls les « 0 » sont cadencés.
À mesure que les bits de données se déplacent vers la droite, les « 0 » sont cadencés à partir de la gauche. Lorsque TB8 de l'octet de
données est à la position de sortie du registre à décalage, alors le bit d'arrêt est juste à gauche de TB8, et toutes les positions à gauche de
celuici contiennent des « 0 ». Cette condition signale à l'unité de contrôle TX d'effectuer un dernier changement, puis de désactiver /SEND
et de régler TI. Cela se produit au 11e roulement divisé par 16 après « écriture dans SBUF ».
La réception est initiée par une transition 1 vers 0 détectée au RXD. À cette fin, RXD est échantillonné à une vitesse de 16 fois, quelle que
soit la vitesse de transmission établie. Lorsqu'une transition est détectée, le compteur divisé par 16 est immédiatement réinitialisé et 1FFH
est écrit dans le registre à décalage d'entrée.
Aux 7ème, 8ème et 9ème états du compteur de chaque temps bit, le détecteur de bits échantillonne la valeur de RXD. La valeur acceptée
est la valeur observée dans au moins 2 des 3 échantillons. Ceci est fait pour rejeter le bruit. Afin de rejeter les faux bits, si la valeur acceptée
pendant le premier temps bit n'est pas un 0, les circuits de réception sont réinitialisés et l'unité continue à chercher une autre transition 1 vers
0. Si le bit de départ est valide, il est décalé dans le registre à décalage d'entrée et la réception du reste de la trame se poursuit.
Lorsque les bits de données arrivent par la droite, les « 1 » se déplacent vers la gauche. Lorsque le bit de départ arrive à la position la plus à
gauche dans le registre à décalage (qui est un registre de 9 bits en modes 2 et 3), il signale au bloc de contrôle RX d'effectuer un dernier
décalage, de charger SBUF et RB8 et de définir RI. . Le signal pour charger SBUF et RB8 et pour définir RI est généré si, et seulement si,
les conditions suivantes sont remplies au moment où l'impulsion de décalage finale est générée. :
1) RI=0 et
2) Soit SM2=0, soit le 9ème bit de données reçu = 1
Si l’une ou l’autre de ces deux conditions n’est pas remplie, la trame reçue est irrémédiablement perdue. Si les deux conditions sont remplies,
le bit d'arrêt passe dans RB8, les 8 premiers bits de données vont dans SBUF et RI est activé. A ce moment, que les conditions cidessus
soient remplies ou non, l'unité continue de rechercher une transition 1 vers 0 à l'entrée RXD.
Notez que la valeur du bit d'arrêt reçu n'a aucune importance pour SBUF, RB8 ou RI.
116
TB8
ÉCRIRE
À
SBUF DS Q SBUF TXD
CL
DÉTECTEUR DE ZÉRO
SYSclk/2
STOP BIT CHANGEMENT
DONNÉES
DÉMARRAGE GEN.
MODE 2 CONTRÔLE D'ÉMISSION

SMOD=1 EN SÉRIE
PORT
÷2 INTERROMPRE
SMOD=0
÷16
(SMOD EST PCON.7) ÉCHANTILLON
RX RI CHARGER
1À0 HORLOGE
SBUF
DÉTECTEUR Changement de commande RX
1FFH
PEU
DÉTECTEUR

RXD (9 BITS)
CHANGEMENT
CHARGER
SBUF
SBUF
LIRE
SBUF
Émission
HORLOGE
ÉCRIRE À SBUF
ENVOYER
TRANSMETTRE
DONNÉES
CHANGEMENT
TXD D0 D1 D2 D3 D4 D5 D6 D7 TB8 ARRÊTER LE PEU
TI DÉMARRAGE
ARRÊTER LA GÉNÉRATION DE BIT
HORLOGE RÉCEPTION
RXD DÉMARRAGE J0 J1 D2 D3 D4 D5 D6 D7 RB8 ARRÊTER LE PEU

RECEVOIR
TEMPS D’ÉCHANTILLON DU DÉTECTEUR DE BITS
CHANGEMENT
RI
Mode port série 2
117
UART 9 bits avec débit en bauds variable (mode 3)
Le mode 3, UART 9 bits avec débit en bauds variable, est identique au mode 2 sauf que le débit en bauds est variable.
Débit en bauds en mode 3 = (2SMOD /32 ) x Débit de débordement du Timer

1 ou = (2SMOD /16 ) x Débit de débordement du Timer 2
Dans les quatre modes, la transmission est initiée par toute instruction qui utilise SBUF comme registre de destination. La réception est initiée en
mode 0 par la condition RI = 0 et REN = 1. La réception est initiée dans les autres modes par le bit de start entrant avec transition 1 vers 0 si REN=1.
8.2 Détection d'erreur de trame
Lorsqu'il est utilisé pour la détection d'erreurs de trame, l'UART recherche les bits d'arrêt manquants dans la communication. Un bit manquant dans
le bit d'arrêt définira le bit FE dans le registre SCON. Le bit FE partage le bit SCON.7 avec SM0 et la fonction de SCON.7 est déterminée par
PCON.6(SMOD0). Si SMOD0 est défini, alors SCON.7 fonctionne comme FE. SCON.7 fonctionne comme SM0 lorsque SMOD0 est effacé. Lorsqu'il
est utilisé comme FE, SCON.7 ne peut être effacé que par logiciel. Reportezvous à la figure suivante.
données 9 bits
D0 D1 D2 D3 D4 D5 D6 D7 D8 BIT D'ARRÊT
DÉMARRAGE
1 SET bit FE si STOP=0
0 Contrôle du mode SM0 vers UART
PCON.6/SMOD0
SCON SM0/FE SM1 SM2 REN TB8 RB8 TI RI
Détection d'erreur de trame UART
8.3 Communications multiprocesseurs
Les modes 2 et 3 comportent une disposition spéciale pour les communications multiprocesseurs. Dans ces modes, 9 bits de données sont reçus.
Le 9ème va dans RB8. Vient ensuite un petit arrêt. Le port peut être programmé de telle sorte que lorsque le bit d'arrêt est reçu, l'interruption du port
série ne sera activée que si RB8 = 1. Cette fonctionnalité est activée en réglant le bit SM2 dans SCON. Une façon d’utiliser cette fonctionnalité dans
les systèmes multiprocesseurs est la suivante.
Lorsque le processeur maître souhaite transmettre un bloc de données à l'un des nombreux esclaves, il envoie d'abord un octet d'adresse qui identifie
l'esclave cible. Un octet d'adresse diffère d'un octet de données dans le sens où le 9ème bit est 1 dans un octet d'adresse et 0 dans un octet de
données. Avec SM2 = 1, aucun esclave n'est interrompu par un octet de données. Cependant, un octet d'adresse interrompra tous les esclaves, afin
que chaque esclave puisse examiner l'octet reçu et voir s'il est adressé. L'esclave adressé effacera son bit SM2 et se préparera à recevoir les octets
de données à venir. Les esclaves qui n'ont pas été adressés laissent leurs SM2 activés et vaquent à leurs occupations, ignorant les octets de
données à venir.
SM2 n'a aucun effet en mode 0 et en mode 1 peut être utilisé pour vérifier la validité du bit d'arrêt. Dans une réception en mode 1, si SM2 = 1,
l'interruption de réception ne sera activée que si un bit d'arrêt vapid est reçu.
118

MINUTERIE 2
DÉBORDEMENT TB8
MINUTERIE 1
DÉBORDEMENT ÉCRIRE
À
DS Q
SBUF SBUF TXD
CL
÷2
SMOD SMOD DÉTECTEUR DE ZÉRO
=0 =1
DONNÉES
"0" "1"
TCLK
EN SÉRIE
"0" "1" PORT
INTERROMPRE
RCLK
÷16
ÉCHANTILLON
1À0 RX HORLOGE RI CHARGER
SBUF
DÉTECTEUR CHANGEMENT
1FFH
PEU
DÉTECTEUR

RXD (9 BITS)
CHANGEMENT
CHARGER
SBUF
SBUF
LIRE
SBUF
Émission
HORLOGE
ÉCRIRE À SBUF
ENVOYER
TRANSMETTRE
DONNÉES
CHANGEMENT
TXD D0 D1 D2 D3 D4 D5 D6 D7 TB8 ARRÊTER LE PEU
TI DÉMARRAGE
ARRÊTER LA GÉNÉRATION DE BIT
HORLOGE RÉCEPTION ÷16 RÉINITIALISATION
RXD DÉMARRAGE J0 J1 D2 D3 D4 D5 D6 D7 RB8 ARRÊTER LE PEU

RECEVOIR
TEMPS D’ÉCHANTILLON DU DÉTECTEUR DE BITS
CHANGEMENT
RI
Mode port série 3
119
8.4 Reconnaissance automatique d'adresse

La reconnaissance automatique d'adresses est un avenir qui permettra à l'UART de reconnaître certaines adresses dans le flux binaire série en utilisant
du matériel pour effectuer les comparaisons. Cette fonctionnalité permet d'économiser une grande partie de la charge logicielle en éliminant la nécessité
pour le logiciel d'examiner chaque adresse série qui passe par le port série. Cette fonctionnalité est activée en définissant le bit SM2 dans SCON. Dans
les modes UART 9 bits, Mode 2 et Mode 3, l'indicateur d'interruption de réception (RI) sera automatiquement défini lorsque l'octet reçu contient soit
l'adresse « Donnée » soit l'adresse « Diffusion ». Le mode 9 bits nécessite que le 9ème bit d'information soit un « 1 » pour indiquer que les informations
reçues sont une adresse et non des données.
Le mode 8 bits est appelé Mode 1. Dans ce mode, l'indicateur RI sera activé si SM2 est activé et que les informations reçues ont un bit d'arrêt valide
après les 8 bits d'adresse et que les informations sont soit une adresse donnée, soit une adresse de diffusion.
Le mode 0 est le mode Registre à décalage et SM2 est ignoré.
L'utilisation de la fonction de reconnaissance automatique d'adresse permet à un maître de communiquer de manière sélective avec un ou plusieurs
esclaves en appelant la ou les adresses d'esclave données. Tous les esclaves peuvent être contactés en utilisant l'adresse de diffusion. Deux registres
de fonctions spéciales sont utilisés pour définir l'adresse de l'esclave, SADDR, et le masque d'adresse, SADEN. SADEN est utilisé pour définir quels
bits du SADDR doivent être utilisés et quels bits sont « indifférents ». Le masque SADEN peut être logiquement AND avec le SADDR pour créer
l'adresse « donnée » que le maître utilisera pour s'adresser à chacun des esclaves. L'utilisation de l'adresse donnée permet de reconnaître plusieurs
esclaves, ce qui en exclut les autres. Les exemples suivants permettront de montrer la polyvalence de ce schéma :
Esclave 0 SADDR = 1100 0000
SADEN = 1111 1101

DONNÉ = 1100 00x0

SADEN = 1111 1110
DONNÉ = 1100 000x
Dans l'exemple précédent, SADDR est le même et les données SADEN sont utilisées pour différencier les deux esclaves.
L'esclave 0 nécessite un « 0 » dans le bit 0 et ignore le bit 1. L'esclave 1 nécessite un « 0 » dans le bit 1 et le bit 0 est ignoré. Une adresse unique pour
l'esclave 0 serait 11000010 puisque l'esclave 1 nécessite un « 0 » dans le bit 1. Une adresse unique pour l'esclave 1 serait 11000001 puisqu'un « 1 »
dans le bit 0 exclura l'esclave 0. Les deux esclaves peuvent être sélectionnés à la fois. en même temps par une adresse qui a le bit 0=0 (pour l'esclave
0) et le bit 1 =0 (pour le salve 1). Ainsi, les deux pourraient être résolus avec 1 100 000.
Dans un système plus complexe, les éléments suivants pourraient être utilisés pour sélectionner les esclaves 1 et 2 tout en excluant l'esclave 0 :

SADEN = 1111 1001
DONNÉ = 1100 0xx0

SADEN = 1111 1010
DONNÉ = 1110 0x0x

SADEN = 1111 1100
DONNÉ = 1110 00xx
120
Dans l'exemple cidessus, la différenciation entre les 3 esclaves se fait dans les 3 bits d'adresse inférieurs. L'esclave 0 nécessite que le bit0 = 0 et il
peut être adressé de manière unique par 11100110. L'esclave 1 nécessite que le bit 1 = 0 et il peut être adressé de manière unique par 11100101.
L'esclave 2 nécessite que le bit 2=0 et son adresse unique est 11100011. Pour sélectionner les Salve 0 et 1 et exclure l'esclave 2, utilisez l'adresse
11100100, car il est nécessaire de faire bit2=1 pour exclure l'esclave 2.
L'adresse de diffusion pour chaque esclave est créée en prenant le OU logique de SADDR et SADEN. Les zéros dans ce résultat ont tendance à ne
pas s'en soucier. Dans la plupart des cas, en interprétant les indifférents comme tels, l'adresse de diffusion sera FF hexadécimale.
Lors de la réinitialisation, SADDR et SADEN sont chargés avec des « 0 ». Cela produit une adresse donnée de tous les « ne s'en soucie pas » ainsi
qu'une adresse de diffusion de tous les « ne s'en soucie pas ». Cela désactive efficacement le mode d'adressage automatique et permet au
microcontrôleur d'utiliser des pilotes UART standard de type 80C51 qui n'utilisent pas cette fonctionnalité.
Exemple : écrire un programme qui transmet en permanence des caractères à partir d'un tampon de transmission. Si des caractères entrants sont
détectés sur le port série, stockezles dans le tampon de réception en commençant à l'emplacement RAM interne 50H. Supposons que le port série
du MCU STC89xx ait déjà été initialisé en mode 1.
Solution:
ORG 0030H
MOUVEMENT R0, #30H ;pointeur pour le tampon tx
MOV R1, #50H ;pointeur pour le tampon rx
BOUCLE : JB RI, RECEVOIR ;caractère reçu ?
;oui : traitezle
JB TI, Émission
;caractère précédent transmis ? ;oui :
traitezle
BOUCLE SJMP ;non : continuez à vérifier
TX : MOV A, MOV C, CLR C @R0 ;obtenir le caractère du tampon tx
MOV ACC.7, C P. ;mettre le bit de parité en C
CLR TI ;changer en parité impaire
;ajouter au code de caractère
;effacer le drapeau de transmission
MOV SBUF, A CLR ACC.7 ;envoyer un caractère

;supprimer le bit de parité
INC. R0 ;pointe vers le caractère suivant dans le tampon
CJNE R0, #50H, BOUCLE ;fin du tampon ?
;non : continuer
MOUVEMENT R0, #30H ;oui : recycler
BOUCLE SJMP ;continuer la vérification
Réception : CLR IR ;effacer l'indicateur de réception
MOUVEMENT A, SBUF ;lire le caractère dans A

MOUVEMENT C, P. ;pour une parité impaire dans A, P doit être défini
CPLC ; compléter correctement indique "erreur"
CLR ACC.7 ;supprimer la parité
MOUVEMENT @R1, A ;stocker le caractère reçu dans le tampon
INC. R1 ;pointer vers l'emplacement suivant dans le tampon
BOUCLE SJMP ;continuer la vérification
FIN
121
8.5 Débits en bauds

Le débit en bauds en mode 0 est fixe :
SYSclk
Mode 0 Débit en bauds =
12
Le débit en bauds en mode 2 dépend de la valeur du bit SMOD dans le registre de fonctions spéciales PCON. Si SMOD = 0 (qui est la valeur
1
lors de la réinitialisation), le débit en bauds du cycle /64 le cycle d'horloge du système. Si SMOD = 1, le débit en bauds est de 1/32 le
d'horloge du système.
Débit en bauds mode 2 = 2SMOD ×(SYClk)

64
Dans la série STC89xx, les débits en bauds dans les modes 1 et 3 sont déterminés par le débit de débordement de la minuterie 1 ou de la minuterie 2.
Le débit en bauds dans les modes 1 et 3 est fixe : Mode
1,3 Débit en bauds = (2SMOD /32 ) x débit de débordement de la minuterie 1 =

(2SMOD /32 ) x débit de débordement de la minuterie 2
Taux de débordement du minuteur 1 = (SYSclk/12)/(256 TH1) ;

Taux de débordement du minuteur 2 = SYSclk/(65536(RCAP2H,RCAP2L))
Lorsque la minuterie 1 est utilisée comme générateur de débit en bauds, l'interruption de la minuterie 1 doit être désactivée dans cette application.
La minuterie ellemême peut être configurée pour un fonctionnement « minuterie » ou « cormter », et dans l'un de ses 3 modes de fonctionnement.
Dans la plupart des applications typiques, il est configuré pour un fonctionnement « timer », en mode autoreload (quartet élevé de TMOD =
0010B).
On peut atteindre un débit en bauds très faible avec le Timer 1 en laissant l'interruption du Timer 1 activée, en configurant le Timer pour qu'il
fonctionne comme un timer de 16 bits (un quartet élevé de TMOD = 0001B) et en utilisant l'interruption du Timer 1 pour effectuer un l6
rechargement du logiciel bit.
Le tableau suivant répertorie les différents débits en bauds couramment utilisés et comment ils peuvent être obtenus à partir du minuteur 1.
Minuterie 1
Débit en bauds FOSC SMOD Recharger
Mode C/T
Valeur
Mode 0 MAX : 1 MHZ 12 MHz X X X X
Mode 2 MAX : 375K 12 MHz 1 X X X
Modes 1,3 : 62,5K 12 MHz 1 0 2 FFF
19,2K 11,059 MHz 1 0 2 FDH
9,6K 11,059 MHz 0 0 2 FDH
4,8K 11,059 MHz 0 0 2 FAH
2,4K 11,059 MHz 0 0 2 F4H
1,2K 11,059 MHz 0 0 2 E8H
137,5 11,986 MHz 0 0 2 1DH
110 6 MHz 0 0 2 72H
110 12 MHz 0 0 1 FEEBH
Minuterie 1 générée Débits en bauds couramment utilisés
Lorsque la minuterie 2 est utilisée comme générateur de débit en bauds (TCLK ou RCLK dans T2CON est « 1 »), le débit en bauds est le suivant :
2SMOD ×SYClk
Mode 1,3 Débit en bauds =
32×(65536(RCAP2H,RCAP2L))
122
Le tableau suivant répertorie les différents débits en bauds couramment utilisés générés par Timer 2.
Débit en bauds Horloges système Minuterie 2
Mode 12T Mode 6T /MHz RCAP2H RCAP2L

375 000 750 000 12 FR FR
9 600 19 200 12 FR D9
2 800 9 600 12 FR B2
2 400 4 800 12 FR 64
1 200 2 400 12 FE C8
300 600 12 Facebook 1E
110 220 12 F2 UN F
300 600 6 FD 8F
110 220 6 F9 57
123
Chapitre 9 IAP/EEPROM
Le FAI de la série STC89xx permet de mettre à jour le programme d'application de l'utilisateur et les données d'application non volatiles (dans
la mémoire IAP) sans retirer la puce MCU du produit final réel. Cette capacité utile rend possible une large gamme d’applications de mise à
jour sur le terrain. (Remarque : ISP a besoin du programme de chargement préprogrammé dans la mémoire ISP.) En général, l'utilisateur n'a
pas besoin de savoir comment fonctionne ISP car STC a fourni l'outil ISP standard et le code ISP intégré dans les échantillons expédiés par
STC. Mais, pour développer un bon programme pour la fonction ISP, l'utilisateur doit comprendre l'architecture du flash intégré.
Le flash intégré se compose de 90 (max) pages. Chaque page contient 512 octets. S'agissant du flash, l'utilisateur doit l'effacer par unité
de page avant d'y écrire des données (de programmation).
Effacer le flash signifie définir le contenu de ce flash sur FFH. Deux modes d'effacement sont disponibles dans cette puce. L’un est le
mode masse et l’autre le mode page. Le mode masse obtient plus de performances, mais il efface tout le flash.
Le mode page est un peu moins performant, mais il est flexible puisqu'il efface le flash par unité de page. Contrairement au fonctionnement en
temps réel de la RAM, effacer le flash ou écrire (programmer) le flash prend souvent beaucoup de temps, il faut donc attendre la fin.
De plus, il s’agit d’une procédure de synchronisation assez complexe pour effacer/programmer le flash. Heureusement, le STC89xx est
doté d'un mécanisme pratique pour aider l'utilisateur à lire/modifier le contenu flash. En remplissant simplement l'adresse cible et les données
dans plusieurs SFR et en déclenchant l'automatisation ISP intégrée, l'utilisateur peut facilement effacer, lire et programmer les registres
flash et d'options intégrés.
La fonctionnalité du programme intégré à l'application est conçue pour permettre à l'utilisateur de lire/écrire des données flash non
volatiles. Il peut s'avérer très utile de stocker des paramètres qui devraient être indépendants de la mise sous tension et de l'action effectuée.
En d'autres termes, l'utilisateur peut stocker des données dans la mémoire flash de données, et après avoir arrêté le MCU et redémarré le
MCU, il peut obtenir la valeur d'origine dans laquelle il avait stocké.
L'utilisateur peut programmer le flash de données de la même manière que le programme du FAI, il doit donc approfondir ses connaissances.
compréhension liée à SFR ISP_DATA, ISP_ADDRL, ISP_ADDRH, ISP_CMD, ISP_TRIG et ISP_CONTR.
9.1 Registre de contrôle IAP/ISP
Les registres de fonctions spéciales suivants sont liés au fonctionnement IAP/ISP. Tous ces registres sont
accessibles par logiciel dans le programme d'application de l'utilisateur.
Valeur après
Données Flash FAI/IAP

FAI_DATA E2H 1111 1111B
Registre
Flash FAI/IAP
ISP_ADDRH E3H 0000 0000B
Adresse élevée
Flash FAI/IAP
FAI_ADDRL E4H 0000 0000B
Adresse basse
Flash FAI/IAP MS2 MS1 MS0
FAI_CMD E5H xxxx x000B
Registre de commandes
Flash FAI/IAP
FAI_TRIG E6H xxxx xxxxB
Déclencheur de commande
Contrôle FAI/IAP ISPEN SWBS SWRST WT2 ,WT1,WT0
ISP_CONTR E7H 000x x000B
Registre
124
ISP_DATA : registre de données Flash ISP/IAP

LSB
nom
ISP_DATA est le registre du port de données pour le fonctionnement ISP/IAP. Les données dans ISP_DATA seront écrites à l'adresse
souhaitée lors de l'écriture ISP/IAP en cours d'exécution et constituent la fenêtre de lecture des données lors de l'écriture ISP/IAP en cours d'exécution.
Lecture IAP.
ISP_ADDRH : adresse Flash FAI/IAP élevée

LSB
nom
ISP_ADDRH est le port d'adresse à octets élevés pour tous les modes ISP/IAP.
ISP_ADDRH[7:5] doit être remis à 000, si un bit de ISP_ADDRH[7:5] est défini, la fonction d'écriture IAP/ISP doit échouer.
ISP_ADDRL : adresse Flash FAI/IAP faible

LSB
nom
ISP_ADDRL est le port bas pour tous les modes ISP/IAP. Lors de l’opération d’effacement de page, il est ignoré.
ISP_CMD : registre de commandes Flash ISP/IAP

LSB
nom MS2 MS1 MS0
MS2, MS1, MS0 : Sélection du mode de fonctionnement ISP/IAP. IAP_CMD est utilisé pour sélectionner le mode flash pour exécuter de
nombreuses fonctions FAI/IAP ou utilisé pour accéder aux SFR protégés.
0, 0, 0 : Veille
0, 0, 1 : Lecture de données Flash/EEPROM.
0, 1, 0 : Programme Data Flash/EEPROM.
0, 1, 1 : Effacement de la page Data Flash/EEPROM.
ISP_TRIG : Déclencheur de commande Flash ISP/IAP.

LSB
nom
ISP_TRIG est le port de commande permettant de déclencher l'activité FAI/IAP et l'accès protégé aux SFR. Si ISP_TRIG est
rempli de 0x46h séquentiels, 0xB9h et si ISPEN(ISP_CONTR.7) = 1, l'activité ISP/IAP ou l'accès SFR protégé sera déclenché.
125
ISP_CONTR : registre de contrôle ISP/IAP

LSB
nom ISPEN SWBS SWRST WT2 WT1 WT0
ISPEN : activation du fonctionnement ISP/IAP.

0 : Désactivation globale de tous les programmes/fonctions d'effacement/lecture FAI/IAP.
1 : Activer le programme ISP/IAP/fonction d'effacement/lecture.
SWBS : contrôle de sélection de démarrage logiciel.
0 : Démarrez à partir de la mémoire principale après la réinitialisation.
1 : Démarrez à partir de la mémoire du FAI après la réinitialisation.
SWRST : commande de déclenchement de réinitialisation logicielle.
0 : Aucune opération
1 : Générer une réinitialisation du système logiciel. Il sera automatiquement effacé par le matériel.
Remarque : les actions de réinitialisation logicielle pourraient réinitialiser d'autres SFR, mais cela n'influencera jamais les bits ISPEN et SWBS. L'ISPEN et le SWBS seront
réinitialisés uniquement par une action de mise sous tension, mais pas par une réinitialisation logicielle.
B3 : Réservé. Le logiciel doit écrire « 0 » sur ce bit lors de l'écriture de ISP_CONTR.
WT2~WT0 : Sélection du temps d'attente lorsque le flash est occupé.
Fixer les temps d'attente Temps d'attente du processeur
Programme Effacement du secteur Système recommandé

WT2 WT1 WT0 Lecture
<=55uS <=21mS Fréquence d'horloge (MHz)
0 1 1 6 Clés SYS 30 Clés SYS 5471 Clés système 5 MHz
0 1 0 11 Clés SYS 60 Clés SYS 10942 Clés système 10 MHz
0 0 1 22 SYSclks 120SYSclks 21885SYSclks 20MHz
0 0 0 43 Clés SYS 240 Clés SYS 43769 Clés SYS 40MHz
9.2 Tableau de sélection EEPROM interne de la série STC89xx
Tableau de sélection EEPROM interne du MCU série STC89xx

EEPROM Secteur Début_Secteur Fin_Secteur
Taper
(Octet) Nombres Adresse_début Adresse_de fin
STC89C/LE51RC 4K 8 0000H 0FFFF
STC89C/LE52RC 4K 8 0000H 0FFFF
STC89C/LE54RD+ 45K 90 0000H 0B3FFH
STC89C/LE58RD+ 29K 58 0000H 73FFH
126
9.3 Introduction au programme de langage d'assemblage IAP/EEPROM
; /*Il est décidé par l'assembleur/compilateur utilisé par les utilisateurs que les adresses SFR soient déclarées par le
DATA ou la directive EQU*/
FAI_DATA DONNÉES 0E2H ou FAI_DATA ÉQU 0E2H
ISP_ADDRH DONNÉES 0E3H ou ISP_ADDRH ÉQU 0E3H
FAI_ADDRL DONNÉES 0E4H ou ISP_ADDRL ÉQU 0E4H
FAI_CMD DONNÉES 0E5H ou FAI_CMD ÉQU 0E5H
FAI_TRIG DONNÉES 0E6H ou FAI_TRIG ÉQU 0E6H
ISP_CONTR DONNÉES 0E7H ou ISP_CONTR ÉQU 0E7H
;/*Définir la commande ISP/IAP/EEPROM et le temps d'attente*/

ISP_IAP_BYTE_READ ÉQUIPEMENT 1 ;Lecture d'octets
ISP_IAP_BYTE_PROGRAM ÉQUIPEMENT 2 ;Programme d'octets
ISP_IAP_SECTOR_ERASE ÉQU 3 ;Effacement de secteur
TEMPS D'ATTENTE ÉQU 0 ;Définir le temps d'attente
;/*Lecture d'octets*/
MOUVEMENT ISP_ADDRH, #BYTE_ADDR_HIGH ;Définir l'adresse ISP/IAP/EEPROM à un niveau élevé
MOV ISP_ADDRL, #BYTE_ADDR_LOW ;Définir l'adresse ISP/IAP/EEPROM à un niveau bas
MOUVEMENT ISP_CONTR, #TEMPS D'ATTENTE ;Définir le temps d'attente
ORLISP_CONTR, #10000000B ;Ouvrir la fonction FAI/IAP

MOV ISP_CMD, #ISP_IAP_BYTE_READ ;Définir la commande ISP/IAP ByteRead
MOUVEMENT ISP_TRIG, #46H ;Envoyer la commande de déclenchement1 (0x46)
MOV IsP_TRIG, #0B9H ;Envoyer la commande de déclenchement2 (0xb9)

NON ;Le CPU restera ici jusqu'à ce que l'opération ISP/IAP/EEPROM soit terminée
MOUVEMENT A, FAI_DATA ;Lire les données ISP/IAP/EEPROM
;/*Désactiver la fonction ISP/IAP/EEPROM, mettre le MCU dans un état sûr*/

MOUVEMENT ISP_CONTR, #00000000B ;Fermer la fonction ISP/IAP/EEPROM
MOV ISP_CMD, #00000000B ;Effacer la commande ISP/IAP/EEPROM
;MOV ISP_TRIG, #00000000B ;Effacer le registre de déclenchement pour éviter les erreurs de déclenchement
;MOV ISP_ADDRH, #0 ;Définir l'adresse haute (00h), les données pointent vers une zone nonEEPROM
;MOV FAI_ADDRL, #0 ;Effacer l'adresse IAP pour éviter toute utilisation abusive
ENSEMBLE EA ;Définir le bit d'activation global
;/*ByteProgram, si l'octet est nul (0FFH), il peut être programmé ; sinon, le MCU doit d'abord utiliser SectorErase, puis peut utiliser Byte
Program.*/
MOV ISP_DATA, #ONE_DATA ; Écrire les données ISP/IAP/EEPROM
MOV ISP_ADDRH, #BYTE_ADDR_HIGH ; Définir l'adresse ISP/IAP/EEPROM à un niveau élevé
MOV ISP_ADDRL, #BYTE_ADDR_LOW ; Définir l'adresse ISP/IAP/EEPROM à un niveau bas
MOV ISP_CONTR, #WAIT_TIME ; Définir le temps d'attente
ORL ISP_CONTR, #10000000B ; Ouvrir la fonction ISP/IAP
MOV ISP_CMD, #ISP_IAP_BYTE_READ ; commande Set ISP/IAP ByteRead
MOV ISP_TRIG, #46H MOV ISP_TRIG, ;Envoyer la commande de déclenchement1 (0x46)
NOP #0B9H ;Envoyer la commande de déclenchement2 (0xb9)
;Le CPU restera ici jusqu'à ce que l'opération ISP/IAP/EEPROM soit terminée
127

ENSEMBLE EA ;Définir le bit d'activation global
;/*Effacer une zone de secteur, il n'y a qu'un effacement de secteur au lieu de l'effacement d'octets, chaque zone de secteur représente 512 octets*/
MOV ISP_ADDRH, #SECTOT_FIRST_BYTE_ADDR_HIGH

;Définissez l'adresse de départ de la zone de secteur à un niveau élevé
MOV ISP_ADDRL, #SECTOT_FIRST_BYTE_ADDR_LOW

;Définir l'adresse de départ de la zone de secteur à un niveau bas
MOUVEMENT ISP_CONTR, #TEMPS D'ATTENTE ;Définir le temps d'attente
ORLISP_CONTR, #10000000B ;Ouvrir la fonction FAI/IAP

MOV ISP_CMD, #ISP_IAP_SECTOR_ERASE ;Définir la commande SectotEffacer
MOUVEMENT ISP_TRIG, #46H ;Envoyer la commande de déclenchement1 (0x46)
MOUVEMENT ISP_TRIG, #0B9H ;Envoyer la commande de déclenchement2 (0xb9)

NON ;Le CPU restera ici jusqu'à ce que l'opération ISP/IAP/EEPROM soit terminée

128
9.4 Fonctionnement de la démonstration EEPROM interne par langage d'assemblage
;/* */
;/* Démo MCU ISP/IAP/EEPROM série STC89xx */
;/* */
;/*Déclarer les SFR associés à l'IAP */

FAI_DATA ÉQU 0E2H ;Enregistrement des données Flash
ISP_ADDRH ÉQU 0E3H ;Adresse Flash ÉLEVÉE

ISP_ADDRL ÉQU 0E4H ;Adresse Flash FAIBLE
FAI_CMD ÉQU 0E5H ; Registre des commandes Flash
FAI_TRIG ÉQU 0E6H ;Déclencheur de commande Flash
ISP_CONTR ÉQU 0E7H ;Registre de contrôle du flash
;/*Définir la const de l'opération ISP/IAP/EEPROM pour IAP_CONTR*/

ENABLE_ISP EQU 80H ;si SYSCLK>20MHz
;ENABLE_ISP EQU 81H ;si SYSCLK<20MHz
ENABLE_ISP EQU 82H ;si SYSCLK<10MHz
;ENABLE_ISP EQU 83H ;si SYSCLK<5MHz
DEBUG_DATA ÉQU 5AH
;Sélectionnez le type de microcontrôleur
DATA_FLASH_START_ADDRESS ÉQU 2000H ;STC89C/LE52RC

;
ORG 0000H
PRINCIPAL LJMP
;
ORG 0100H
PRINCIPAL:
MOV P1, #0F0H ;1111,0000 Réinitialisation du système OK

DÉLAI D'APPEL ;Retard
MOV P1, #0F0H ;1111,0000 Réinitialisation du système OK
DÉLAI D'APPEL ;Retard
MOUVEMENT SP, ;Initialiser le pointeur de pile
#0E0H ;************************************
;Lire le premier octet écrit dans Flash
PRINCIPAL1 :
MOV DPTR, #DATA_FLASH_START_ADDRESS

LCALL Octet_Lecture
MOUVEMENT 40H, A
CJNE A, #DEBUG_DATA, DATA_NOT_EQU_DEBUG_DATA
129
DATA_IS_DEBUG_DATA :
MOV P1, #0111111B ;(DATA_FLASH_START_ADDRESS) = #5A, ;allumer la
LED P1.7
Délai LCALL ;retard
MOUVEMENT A, 40H
CPLA
MOV P1, A ;Les données sont correctes et affichées dans le port 1
ATTENDRE1 :
ATTENDRE SJMP ;Arrêt

DATA_NOT_EQU_DEBUG_DATA :
MOV P1, #11110111B ;(DATA_FLASH_START_ADDRESS) != #5A, ;allumer la
LED P1.3
Délai LCALL ;retard
MOUVEMENT A, 40H
CPLA
MOV P1, A ;Les données sont erronées et affichées sur le
Délai LCALL port 1 ;délai
MOV DPTR, #DATA_FLASH_START_ADDRESS ACALL

Sector_Erase ;Effacement du secteur, ;
(DATA_FLASH_START_ADDRESS) != #DEBUG_DATA
MOV DPTR, #DATA_FLASH_START_ADDRESS

MOUVEMENT A, #DEBUG_DATA ;Écrire DEBUG_DATA dans Falsh
ACALL Octet_Programme ;Programme d'octets
MOV P1, #11011111B ; allumez d'abord la LED P1.3, puis allumez la LED P1.5
ATTENDRE2 :
SJMP ;Arrêtez ici après le programme d'octets

ATTENDRE2 ;************************************************ *****
;
;Lire un octet
Octet_Lecture :
MOUVEMENT ISP_CONTR, #ENABLE_ISP ;Activer la fonction IAP/ISP ;déterminer
le temps d'attente du Flash
MOV ISP_CMD, #01 ;Sélectionnez le mode Lecture AP
MOV ISP_ADDRH, DPH ;Remplir l'adresse de la page dans ISP_ADDRH&ISP_ADDRL

MOV ISP_ADDRL, DPL
CLR EA
MOUVEMENT ISP_TRIG, #46H ;Déclencher le traitement du FAI
MOUVEMENT ISP_TRIG, #0B9H ;Déclencher le traitement du FAI
NON
MOUVEMENT A, FAI_DATA ;Récupérer les données dans ISP_DATA
ENSEMBLE EA
;Maintenant en cours de traitement. (Le processeur s'arrêtera ici avant de terminer)
ACALL IAP_Désactiver ;Désactiver la fonction IAP,
;effacer certains registres associés au FAI
RETRAIT
130
;
;Programme d'octets
Octet_Programme :
MOUVEMENT ISP_CONTR, #ENABLE_ISP ;Activer la fonction IAP, ;déterminer le
temps d'attente du Flash
MOV ISP_CMD, #02H ;Sélectionner le mode Programme d'octets
MOV ISP_ADDRH, DPH ;Remplir l'adresse de la page dans ISP_ADDRH&ISP_ADDRL

MOV ISP_ADDRL, DPL
MOV ISP_DATA, UN ;Enregistrez la valeur dans ISP_DATA
CLR EA
NON
ENSEMBLE EA
RETRAIT
;
;Effacement de secteur
Secteur_Effacer :
MOUVEMENT ISP_CONTR, #ENABLE_ISP ;Activer la fonction IAP, ;déterminer le
temps d'attente du Flash
MOV ISP_CMD, #03H ;Sélectionner le mode d'effacement de page
MOV ISP_ADDRH, DPH ; Remplir l'adresse de la page dans ISP_ADDRH&ISP_ADDRL

MOV ISP_ADDRL, DPL
CLR EA
NON
ENSEMBLE EA
RETRAIT
;
Déclencheur_ISP :
CLR EA
NON
ENSEMBLE EA
RETRAIT
;
IAP_Désactiver : ; Désactiver la fonction IAP, effacer certains registres associés au FAI
MOUVEMENT ISP_CONTR, #0
MOV ISP_CMD, #0
MOUVEMENT ISP_TRIG #0
RETRAIT
131
;
Retard:
CLRA
MOUVEMENT R0, A
MOUVEMENT R1, A
MOV R2, #20
Delay_loop :
MOUVEMENT R0, Delay_loop
MOV R1, Delay_loop
MOUVEMENT R2, Delay_loop
RETRAIT
;
FIN
;*********************************************
132
Annexe A : Programmation en langage assembleur
INTRODUCTION
Le langage assembleur est un langage informatique situé entre les extrêmes du langage machine et les langages de haut niveau comme Pascal ou C
utilisent des mots et des instructions facilement compréhensibles par les humains, bien qu'encore loin du langage « naturel ». Le langage machine est
le langage binaire. d’ordinateurs. Un programme en langage machine est une série d’octets binaires représentant les instructions que l’ordinateur peut
exécuter.
Le langage assembleur remplace les codes binaires du langage machine par des « mnémoniques » faciles à retenir qui facilitent la programmation.
Par exemple, une instruction supplémentaire en langage machine peut être représentée par le code « 10110011 ». Elle peut être représentée en
langage assembleur par le mnémonique « 10110011 ». ADD".La programmation avec des mnémoniques est évidemment préférable à la programmation
avec des codes binaires.
Bien entendu, cela ne représente pas toute l’histoire. Les instructions fonctionnent sur des données et l'emplacement des données est spécifié
par divers « modes d'adressage » intégrés dans le code binaire de l'instruction en langage machine. Ainsi, il peut y avoir plusieurs variantes de
l’instruction ADD, en fonction de ce qui est ajouté. Les règles de spécification de ces variations sont au cœur du thème de la programmation en langage
assembleur.
Un programme en langage assembleur n’est pas exécutable par un ordinateur. Une fois écrit, le programme doit être traduit en langage machine.
Dans l'exemple cidessus, le mnémonique « ADD » doit être traduit en code binaire « 10110011 ». En fonction de la complexité de l'environnement de
programmation, cette traduction peut impliquer une ou plusieurs étapes avant qu'un programme exécutable en langage machine n'aboutisse. Au
minimum, un programme appelé « assembleur » est requis pour traduire les mnémoniques d’instructions en codes binaires en langage machine. Une
étape supplémentaire peut nécessiter un "éditeur de liens" pour combiner des parties du programme provenant de fichiers séparés et pour définir
l'adresse en mémoire à laquelle le programme peut s'exécuter. Commençons par quelques définitions.
Un programme en langage assembleur est un programme écrit à l'aide d'étiquettes, de mnémoniques, etc., dans lequel chaque instruction
correspond à une instruction machine. Les programmes en langage assembleur, souvent appelés code source ou code symbolique, ne peuvent pas
être exécutés par un ordinateur.
Un programme en langage machine est un programme contenant des codes binaires qui représentent des instructions destinées à un ordinateur.
Les programmes en langage machine, souvent appelés code objet, sont exécutables par un ordinateur.
Un assembleur est un programme qui traduit un programme en langage assembleur en un programme en langage machine.
Le programme en langage machine (code objet) peut être sous forme « absolue » ou sous forme « délocalisable ». Dans ce dernier cas, une « liaison »
est nécessaire pour définir l'adresse absolue d'exécution.
Un éditeur de liens est un programme qui combine des programmes objets déplaçables (modules) et produit un programme objet absolu
exécutable par un ordinateur. Un éditeur de liens est parfois appelé « éditeur de liens/localisateur » pour refléter ses fonctions distinctes de combinaison
de modules relocalisables (liaison) et de définition de l'adresse d'exécution (localisation).
Un segment est une unité de code ou de mémoire de données. Un segment peut être relocalisable ou absolu. Un segment relocalisable
possède un nom, un type et d'autres attributs qui permettent à l'éditeur de liens de le combiner avec d'autres segments paritiaux, si nécessaire, et de
localiser correctement le segment. Un segment absolu n'a pas de nom et ne peut pas être combiné avec d'autres segments.
Un module contient un ou plusieurs segments ou segments partiels. Un module a un nom attribué par l'utilisateur. Les définitions de module
déterminent la portée des symboles locaux. Un fichier objet contient un ou plusieurs modules. Un module peut être considéré comme un « fichier » dans
de nombreux cas.
Un programme se compose d'un seul module absolu, fusionnant tous les segments absolus et déplaçables de tous les modules d'entrée. Un
programme contient uniquement les codes binaires des instructions (avec constantes d'adresse et de données) qui sont comprises par un ordinateur.
133
FONCTIONNEMENT DE L'ASSEMBLEUR
Il existe de nombreux programmes assembleurs et autres programmes de support disponibles pour faciliter le développement d'applications
pour le microcontrôleur 8051. L'assembleur original de la famille MCS51 d'Intel, ASM51, n'est plus disponible dans le commerce. Cependant,
il établit la norme à laquelle les autres sont comparés.
ASM51 est un assembleur puissant doté de toutes les fonctionnalités. Il est disponible sur les systèmes de développement Intel et
sur la famille de microordinateurs IBM PC. Étant donné que ces ordinateurs « hôtes » contiennent une puce CPU autre que le 8051,
l'ASM51 est appelé un assembleur croisé. Un programme source 8051 peut être écrit sur l'ordinateur hôte (à l'aide de n'importe quel éditeur
de texte) et peut être assemblé en un fichier objet et un fichier de liste (à l'aide d'ASM51), mais le programme ne peut pas être exécuté.
Étant donné que la puce CPU du système hôte n'est pas un 8051, elle ne comprend pas l'instruction binaire dans le fichier objet. L'exécution
sur l'ordinateur hôte nécessite soit une émulation matérielle, soit une simulation logicielle du processeur cible. Une troisième possibilité
consiste à télécharger le programme objet sur un système cible basé sur 8051 pour exécution.
ASM51 est invoqué à partir de l'invite système par
ASM51 source_file [assembler_controls]
Le fichier source est assemblé et tous les contrôles assembleur spécifiés prennent effet. L'assembleur reçoit un fichier source en entrée
(par exemple, PROGRAM.SRC) et génère un fichier objet (PROGRAM.OBJ) et un fichier de liste (PROGRAM.
LST) en sortie. Ceci est illustré dans la figure 1.
Étant donné que la plupart des assembleurs analysent le programme source deux fois lors de la traduction en langage machine, ils
sont décrits comme des assembleurs à deux passes. L'assembleur utilise un compteur d'emplacement comme adresse des instructions et
valeurs des étiquettes. L'action de chaque passe est décrite cidessous.
PROGRAMME.OBJ
PROGRAMME.SRC ASM51
Légende PROGRAMME.LST
Programme utilitaire
Fichier utilisateur
Figure 1 Assemblage d'un programme source
Passer un
Lors du premier passage, le fichier source est analysé ligne par ligne et une table de symboles est construite. Le compteur d'emplacement
est par défaut à 0 ou est défini par la directive ORG (set origin). Au fur et à mesure que le fichier est analysé, le compteur d'emplacement
est incrémenté de la longueur de chaque instruction. Définir des directives de données (DB ou DW) incrémente le compteur d'emplacement
du nombre d'octets défini. Les directives de réserve de mémoire (DS) incrémentent le compteur d'emplacement du nombre d'octets réservés.
Chaque fois qu'une étiquette est trouvée en début de ligne, elle est placée dans la table des symboles avec la valeur actuelle du
compteur de localisation. Les symboles définis à l'aide de directives d'équation (EQU) sont placés dans la table des symboles avec la valeur
« assimilée ». La table des symboles est enregistrée puis utilisée lors de la deuxième passe.
Passez deux
Au cours de la deuxième passe, les fichiers d'objet et de liste sont créés. Les mnémoniques sont convertis en opcodes et placés dans les
fichiers de sortie. Les opérandes sont évalués et placés après les opcodes d'instruction. Lorsque des symboles apparaissent dans le champ
d'opérande, leurs valeurs sont extraites de la table des symboles (créée lors de la première passe) et utilisées pour calculer les données ou
adresses correctes pour les instructions.
Puisque deux passes sont effectuées, le programme source peut utiliser des « références directes », c'estàdire utiliser un symbole
avant qu'il ne soit défini. Cela se produirait, par exemple, lors de la progression d'un programme.
134
Le fichier objet, s'il est absolu, contient uniquement les octets binaires (00H0FH) du programme en langage machine.
Un fichier objet déplaçable contiendra également une table de symboles et d'autres informations requises pour la liaison et la localisation.
Le fichier de liste contient des codes de texte ASCII (02H7EH) pour le programme source et les octets hexadécimaux du programme en langage machine.
Une bonne démonstration de la distinction entre un fichier objet et un fichier de liste consiste à afficher chacun d'eux sur l'écran CRT de
l'ordinateur hôte (en utilisant, par exemple, la commande TYPE sur les systèmes MSDOS). Le fichier de liste s'affiche clairement, chaque ligne de sortie
contenant une adresse, un opcode et peutêtre des données, suivis de l'instruction de programme du fichier source. Le fichier de liste s'affiche correctement
car il contient uniquement des codes de texte ASCII. L'affichage du fichier objet pose cependant un problème. La sortie apparaîtra comme "poubelle",
puisque le fichier objet contient les codes binaires d'un programme en langage machine 8051, plutôt que les codes texte ASCII.
FORMAT DU PROGRAMME DE LANGUE ASSEMBLÉE

Les programmes en langage assembleur contiennent les éléments suivants :
• Instructions pour les machines
• Directives de l'assembleur
• Contrôles de l'assembleur
• commentaires
Les instructions machine sont les mnémoniques familiers des instructions exécutables (par exemple, ANL). Les directives assembleur sont des
instructions destinées au programme assembleur qui définissent la structure du programme, les symboles, les données, les constantes, etc. (par exemple,
ORG). Les contrôles de l'assembleur définissent les modes de l'assembleur et le flux d'assemblage direct (par exemple, $TITLE). Les commentaires
améliorent la lisibilité des programmes en expliquant le but et le fonctionnement des séquences d'instructions.
Les lignes contenant des instructions machine ou des directives assembleur doivent être écrites selon des règles spécifiques comprises par
l'assembleur. Chaque ligne est divisée en « champs » séparés par des espaces ou des tabulations. Le format général de chaque ligne est le suivant :
[étiquette :] mnémonique [opérande] [, opérande] […] [;commentaire]
Seul le champ mnémonique est obligatoire. De nombreux assembleurs exigent que le champ d'étiquette, s'il est présent, commence à gauche dans la
colonne 1, et que les champs suivants soient séparés par des caractères d'espace ou de tabulation. Avec ASM51, le champ d'étiquette n'a pas besoin de
commencer dans la colonne 1 et le champ mnémonique n'a pas besoin d'être sur la même ligne que le champ d'étiquette. Le champ opérande doit
cependant commencer sur la même ligne que le champ mnémonique. Les champs sont décrits cidessous.
Champ d'étiquette
Une étiquette représente l'adresse de l'instruction (ou de la donnée) qui suit. Lors d'un branchement vers cette instruction, cette étiquette est utilisée dans
le champ d'opérande de l'instruction de branchement ou de saut (par exemple, SJMP SKIP).
Alors que le terme « étiquette » représente toujours une adresse, le terme « symbole » est plus général. Les étiquettes sont un type de symbole
et sont identifiées par l'exigence selon laquelle elles doivent se terminer par deux points (:). Les symboles se voient attribuer des valeurs ou des attributs,
à l'aide de directives telles que EQU, SEGMENT, BIT, DATA, etc. Les symboles peuvent être des adresses, des constantes de données, des noms de
segments ou d'autres constructions conçues par le programmeur. Les symboles ne se terminent pas par deux points. Dans l'exemple cidessous, PAR
est un symbole et START est une étiquette (qui est un type de symbole).
PAR EQU 500 ;"PAR" EST UN SYMBOLE QUI
;REPRÈSENTE LA VALEUR 500
DÉBUT : MOV A,#0FFH ;"START" EST UNE ÉTIQUETTE QUI
;REPRÈSENTE L'ADRESSE DE
;L'INSTRUCTION DE MOUVEMENT
Un symbole (ou une étiquette) doit commencer par une lettre, un point d'interrogation ou un trait de soulignement (_) ; doit être suivi de lettres, de
chiffres, de "?" ou de "_" ; et peut contenir jusqu'à 31 caractères. Les symboles peuvent utiliser des caractères majuscules ou minuscules, mais ils sont
traités de la même manière. Les mots réservés (mnémoniques, opérateurs, symboles prédéfinis et directives) ne peuvent pas être utilisés.
135
Champ mnémonique
Les mnémoniques d'instruction ou les directives assembleur vont dans le champ mnémonique, qui suit le champ d'étiquette. Des
exemples de mnémoniques d'instruction sont ADD, MOV, DIV ou INC. Des exemples de directives assembleur sont ORG, EQU ou DB.
Champ d'opérande
Le champ opérande suit le champ mnémonique. Ce champ contient l'adresse ou les données utilisées par l'instruction. Une étiquette
peut être utilisée pour représenter l'adresse des données, ou un symbole peut être utilisé pour représenter une constante de
données. Les possibilités du champ d'opérande dépendent largement de l'opération. Certaines opérations n'ont pas d'opérande (par
exemple l'instruction RET), tandis que d'autres autorisent plusieurs opérandes séparés par des virgules. En effet, les possibilités
pour le champ d’opérandes sont nombreuses, et nous les développerons longuement. Mais d’abord, le champ de commentaire.
Champ de commentaire
Les remarques visant à clarifier le programme sont placées dans le champ de commentaires à la fin de chaque ligne. Les commentaires doivent
commencer par un pointvirgule (;). Chaque ligne peut être une ligne de commentaire en la commençant par un pointvirgule. Les sous
programmes et les grandes sections d'un programme commencent généralement par un bloc de commentaires : plusieurs lignes de
commentaires expliquant les propriétés générales de la section du logiciel qui suit.
Symboles d'assembleur spéciaux

Des symboles assembleur spéciaux sont utilisés pour les modes d'adressage spécifiques aux registres. Ceuxci incluent A,
R0 à R7, DPTR, PC, C et AB. De plus, un signe dollar ($) peut être utilisé pour désigner la valeur actuelle du compteur de
localisation. Quelques exemples suivent.
SETB C
INC DPTR
JNB TI ,$
La dernière instruction cidessus utilise efficacement le compteur de localisation de l'ASM51 pour éviter d'utiliser une étiquette. On pourrait aussi
l'écrire comme
ICI : JNB TI , ICI
Adresse indirecte
Pour certaines instructions, le champ opérande peut spécifier un registre contenant l'adresse des données. Le signe
commercial "arobase" (@) indique une indirection d'adresse et ne peut être utilisé qu'avec R0, R1, le DPTR ou le
PC, selon l'instruction. Par exemple,
AJOUTER UN , @R0
MOVC A , @A+PC
La première instruction cidessus récupère un octet de données de la RAM interne à l'adresse spécifiée dans R0. La
deuxième instruction récupère un octet de données de la mémoire de code externe à l'adresse formée en ajoutant le
contenu de l'accumulateur au compteur de programme. Notez que la valeur du compteur de programme, lorsque l'ajout
a lieu, est l'adresse de l'instruction qui suit MOVC. Pour les deux instructions cidessus, la valeur récupérée est placée
dans l'accumulateur.
Données immédiates
Les instructions utilisant l'adressage immédiat fournissent des données dans le champ d'opérande qui font partie de l'instruction.
Les données immédiates sont précédées du signe dièse (#). Par exemple,
136
ÉQUATION CONSTANTE 100

MOUVEMENT A , #0FEH
ORL 40H , #CONSTANTE
Toutes les opérations de données immédiates (sauf MOV DPTR,#data) nécessitent huit bits de données. Les données immédiates sont
évaluées comme une constante de 16 bits, puis l'octet de poids faible est utilisé. Tous les bits de l'octet de poids fort doivent être identiques
(00H ou FFH), sinon le message d'erreur « la valeur ne rentre pas dans un octet » est généré. Par exemple, les instructions suivantes sont
syntaxiquement correctes :
MOUVEMENT A , #0FF00H
MOUVEMENT A , #00FFH
Mais les deux instructions suivantes génèrent des messages d'erreur :

MOUVEMENT A , #0FE00H
MOUVEMENT A , #01FFH
Si la notation décimale signée est utilisée, des constantes de 256 à +255 peuvent également être utilisées. Par exemple, les deux
instructions suivantes sont équivalentes (et syntaxiquement correctes) :
MOUVEMENT A , #256
MOUVEMENT A , #0FF00H
Les deux instructions cidessus mettent 00H dans l’accumulateur A.
Adresse des données
De nombreuses instructions accèdent aux emplacements mémoire en utilisant l'adressage direct et nécessitent une adresse mémoire de
données sur puce (00H à 7FH) ou une adresse SFR (80H à 0FFH) dans le champ d'opérande. Des symboles prédéfinis peuvent être utilisés
pour les adresses SFR. Par exemple,
MOUVEMENT A , 45H
MOUVEMENT A , SBUF ;IDENTIQUE AU MOUVEMENT A, 99H
Adresse de bit
L'une des fonctionnalités les plus puissantes du 8051 est la possibilité d'accéder à des bits individuels sans avoir besoin d'opérations de
masquage sur les octets. Les instructions accédant à des emplacements adressables par bits doivent fournir une adresse de bit dans la
mémoire de données interne (00h à 7FH) ou une adresse de bit dans les SFR (80H à 0FFH).
Il existe trois manières de spécifier une adresse de bit dans une instruction : (a) explicitement en donnant l'adresse, (b) en
utilisant l'opérateur point entre l'adresse d'octet et la position du bit, et (c) en utilisant un symbole assembleur prédéfini. Quelques
exemples suivent.
SETB 0E7H ;ADRESSE DE BITS EXPLICITE
SETB ACC.7 ;OPÉRATEUR DOT (MÊME QUE CIDESSUS)
JNB TI ,$ ;"TI" EST UN SYMBOLE PRÉDÉFINI
JNB 99H ,$ ;(COMME CIDESSUS)
Code Adresse
Une adresse de code est utilisée dans le champ d'opérande pour les instructions de saut, y compris les sauts relatifs (SJMP et
sauts conditionnels), les sauts et appels absolus (ACALL, AJMP) et les sauts et appels longs (LJMP, LCALL).
L'adresse du code est généralement indiquée sous la forme d'une étiquette.
ASM51 déterminera l'adresse de code correcte et insérera dans l'instruction le décalage signé de 8 bits correct, l'adresse de page
de 11 bits ou l'adresse longue de 16 bits, selon le cas.
137
Sauts et appels génériques

ASM51 permet aux programmeurs d'utiliser un mnémonique générique JMP ou CALL. « JMP » peut être utilisé à la place de SJMP,
AJMP ou LJMP ; et "CALL" peut être utilisé à la place de ACALL ou LCALL. L'assembleur convertit le mnémonique générique en une «
vraie » instruction en suivant quelques règles simples. Le mnémonique générique est converti en forme courte (pour JMP uniquement) si
aucune référence directe n'est utilisée et que la destination du saut se trouve dans 128 emplacements, ou en forme absolue si aucune
référence directe n'est utilisée et que l'instruction qui suit l'instruction JMP ou CALL est dans le même bloc 2K que l’instruction de
destination. Si les formes courtes ou absolues ne peuvent pas être utilisées, la conversion s'effectue vers la forme longue.
La conversion n'est pas nécessairement le meilleur choix de programmation. Par exemple, si vous avancez quelques instructions,
le JMP générique sera toujours converti en LJMP même si un SJMP est probablement meilleur. Considérez la séquence d'instructions
assemblées suivante utilisant trois sauts génériques.
SOURCE DE LIGNE OBJ LOC

1234 1 ORG 1234H
1234 04 2 COMMENCER: INC A
1235 80FD 3 DÉMARRER JMP ;ASSEMBLE COMME SJMP
12FC 4 DÉBUT DE L'ORG + 200
12FC4134 5 DÉMARRER JMP ;ASSEMBLE COMME AJMP
12FE 021301 6 FINITION JMP ;ASSEMBLE COMME LJMP
1301 04 7 FINITION: INC A
8 FIN
Le premier saut (ligne 3) s'assemble en SJMP car la destination est avant le saut (c'estàdire pas de référence avant) et le décalage est
inférieur à 128. La directive ORG de la ligne 4 crée un écart de 200 emplacements entre l'étiquette START et le deuxième saut, donc la
conversion à la ligne 5 se fait en AJMP car le décalage est trop important pour SJMP.
Notez également que l'adresse suivant le deuxième saut (12FEH) et l'adresse de START (1234H) se trouvent dans la même page de 2K,
qui, pour cette séquence d'instructions, est délimitée par 1000H et 17FFH. Ce critère doit être rempli pour un adressage absolu. Le
troisième saut s'assemble en tant que LJMP car la destination (FINISH) n'est pas encore définie lorsque le saut est assemblé (c'estàdire
qu'une référence vers l'avant est utilisée). Le lecteur peut vérifier que la conversion est telle qu'indiquée en examinant le champ objet de
chaque instruction de saut.
ÉVALUATION DE L'EXPRESSION DU TEMPS D'ASSEMBLAGE

Les valeurs et les constantes dans le champ d'opérande peuvent être exprimées de trois manières : (a) explicitement (par exemple,
0EFH), (b) avec un symbole prédéfini (par exemple, ACC), ou (c) avec une expression (par exemple, 2 + 3). . L'utilisation d'expressions
constitue une technique puissante pour rendre les programmes en langage assembleur plus lisibles et plus flexibles. Lorsqu'une
expression est utilisée, l'assembleur calcule une valeur et l'insère dans l'instruction.
Tous les calculs d'expression sont effectués à l'aide de l'arithmétique 16 bits ; cependant, 8 ou 16 bits sont insérés dans l'instruction
selon les besoins. Par exemple, les deux instructions suivantes sont identiques :
MOUVEMENT DPTR, #04FFH + 3
MOUVEMENT DPTR, #0502H ;RESULTAT ENTIER 16 BITS UTILISÉ
Cependant, si la même expression est utilisée dans une instruction "MOV A,#data", le message d'erreur "la valeur ne tiendra pas dans un
octet" est généré par ASM51. Un aperçu des règles d’évaluation des expressions suit.
138
Bases numériques
La base des constantes numériques est indiquée de la manière habituelle pour les microprocesseurs Intel. Les constantes doivent
être suivies de « B » pour binaire, « O » ou « Q » pour octal, « D » ou rien pour décimal, ou « H » pour hexadécimal. Par exemple,
les instructions suivantes sont les mêmes :
MOUVEMENT A , #15H
MOUVEMENT A , #1111B
MOUVEMENT A , #0FH
MOUVEMENT A , #17Q
MOUVEMENT A , #15D
Notez qu'un chiffre doit être le premier caractère des constantes hexadécimales afin de les différencier des étiquettes (c'estàdire «
0A5H » et non « A5H »).
Cordes de caractère
Les chaînes utilisant un ou deux caractères peuvent être utilisées comme opérandes dans les expressions. Les codes ASCII sont convertis
en équivalent binaire par l'assembleur. Les constantes de caractères sont placées entre guillemets simples ('). Quelques exemples suivent.
CJNE A , # 'Q', ENCORE
SUBB A , # '0' ;CONVERTIR UN CHIFFRE ASCII EN CHIFFRE BINAIRE
MOUVEMENT DPTR, # 'AB'
MOV DPTR, #4142H ;COMME CIDESSUS
Opérateurs arithmétiques
Les opérateurs arithmétiques sont
+ ajout
soustraction
*
multiplication
/ division
MOD modulo (reste après division)
Par exemple, les deux instructions suivantes sont identiques :

MOUVEMENT A, 10 +10H
MOUVEMENT A, #1AH
Les deux instructions suivantes sont également les mêmes :

MOUVEMENT A, #25 MOD 7
MOV A, #4
L'opérateur MOD pouvant être confondu avec un symbole, il doit être séparé de ses opérandes par au moins un espace ou un
caractère de tabulation, ou les opérandes doivent être mis entre parenthèses. Il en va de même pour les autres opérateurs
composés de lettres.
Opérateurs logiques
Les opérateurs logiques sont
OU logique OU
ET logique ET
XOR logique OU exclusif
PAS NON logique (complément)
139
L'opération est appliquée sur les bits correspondants dans chaque opérande. L'opérateur doit être séparé des opérandes par des espaces
ou des tabulations. Par exemple, les deux instructions suivantes sont identiques :
MOV A, # '9' ET 0FH
MOV A, #9
L'opérateur NOT ne prend qu'un seul opérande. Les trois instructions MOV suivantes sont identiques :
TROIS ÉQU 3
MINUS_THREE ÉQU 3
MOV A, # (PAS TROIS) + 1
MOUVEMENT A, #MINUS_THREE
MOUVEMENT A, #11111101B
Opérateurs spéciaux
Les opérateurs spéciaux sont
SHR décale à droite
SHL décale à gauche
HIGH octet de poids fort
LOW octet de poids faible
() évaluer d'abord
Par exemple, les deux instructions suivantes sont identiques :

MOV A, #8 SHL1
MOUVEMENT A, #10H
Les deux instructions suivantes sont également les mêmes :

MOUVEMENT A, #HAUT 1234H
MOUVEMENT A, #12H
Opérateurs relationnels
Lorsqu'un opérateur relationnel est utilisé entre deux opérandes, le résultat est toujours faux (0000H) ou vrai (FFFFH).
Les opérateurs sont
=
ÉQ équivaut à
NE <> pas égal
LT < moins que
LE <= inférieur ou égal à
GT > supérieur à
GE >= Plus grand ou égal à
Notez que pour chaque opérateur, deux formes sont acceptables (par exemple, "EQ" ou "="). Dans les exemples suivants, tous les tests
relationnels sont « vrais » :
MOUVEMENT A, #5 = 5
MOUVEMENT A,#5 NE 4
MOUVEMENT A,# 'X' LT 'Z'
MOUVEMENT A,# 'X' >= 'X'
MOUVEMENT A,#$ > 0
MOUVEMENT A,#100 GE 50
140
Ainsi, les instructions assemblées sont égales à
MOUVEMENT A, #0FFH
Même si les expressions donnent des résultats sur 16 bits (c'estàdire 0FFFFH), dans les exemples cidessus, seuls les huit bits de poids
faible sont utilisés, puisque l'instruction est une opération de déplacement d'octet. Le résultat n'est pas considéré comme trop important
dans ce cas, car en tant que nombres signés, la valeur FFFFH sur 16 bits et la valeur FFH sur 8 bits sont identiques (1).
Exemples d'expressions
Voici des exemples d'expressions et des valeurs qui en résultent :
Expression Résultat
'B' 'A' 0001H
8/3 0002H
155 MOD 2 0001H
4*4 0010H
8 ET 7 0000H
PAS 1 FFFEH
'A' SHL8 4100H
BAS 65535 00FFH
(8 + 1) * 2 0012H
5 égaliseur 4 0000H
'A' LT 'B' FFFFH
3 <= 3 FFFFHss
Voici un exemple pratique qui illustre une opération courante pour l'initialisation du temporisateur : Mettez 500 dans les registres du
temporisateur 1 TH1 et TL1. En utilisant les opérateurs HIGH et LOW, une bonne approche est EQU
VALEUR 500
MOV TH1, #HAUTE VALEUR
MOV TL1, #VALEUR FAIBLE
L'assembleur convertit 500 en la valeur 16 bits correspondante (FE0CH) ; puis les opérateurs HIGH et LOW extraient les octets haut
(FEH) et bas (0CH). selon le cas pour chaque instruction MOV.
Priorité des opérateurs

La priorité des opérateurs d'expression du plus élevé au plus bas est
()
HAUT BAS
*/MOD SHL SHR
+
EQ NE LT LE GT GE = < > < <= > >=
PAS
ET
OU XOR
Lorsque des opérateurs de même priorité sont utilisés, ils sont évalués de gauche à droite.
Exemples:
Expression Valeur
ÉLEVÉE ( 'A' SHL 8) 0041H
ÉLEVÉ 'A' SHL 8 0000H
PAS 'A' 1 FFBFH
'A' OU 'A' SHL 8 4141H
141
DIRECTIVES ASSEMBLEUR
Les directives assembleur sont des instructions destinées au programme assembleur. Ce ne sont pas des instructions en langage assembleur
exécutables par le microprocesseur cible. Ils sont cependant placés dans le champ mnémonique du programme. A l'exception de DB et DW, ils
n'ont aucun effet direct sur le contenu de la mémoire.
ASM51 propose plusieurs catégories de directives :
•
Contrôle de l'état de l'assembleur (ORG, END, USING)
•
Définition des symboles (SEGMENT, EQU, SET, DATA, IDATA, XDATA, BIT, CODE)
•
Initialisation/réservation du stockage (DS, DBIT, DB, DW)
•
Lien avec le programme (PUBLIC, EXTRN,NAME)
•
Sélection de segments (RSEG, CSEG, DSEG, ISEG, ESEG, XSEG)
Chaque directive assembleur est présentée cidessous, classée par catégorie.
Contrôle de l'état de l'assembleur
ORG (Définir l'origine) Le format de la directive ORG (set origin) est
Expression ORG
La directive ORG modifie le compteur d'emplacement pour définir une nouvelle origine de programme pour les instructions qui suivent. Une
étiquette n’est pas autorisée. Deux exemples suivent.
ORG 100H ORG ;CONFIGURER LE COMPTEUR DE LOCALISATION À 100H
($ + 1000H) ET 0F00H ; DÉFINI SUR LA PROCHAINE LIMITE 4K
La directive ORG peut être utilisée dans n'importe quel type de segment. Si le segment actuel est absolu, la valeur sera une adresse absolue
dans le segment actuel. Si un segment relocalisable est actif, la valeur de l'expression ORG est traitée comme un décalage par rapport à
l'adresse de base de l'instance actuelle du segment.
Fin Le format de la directive END est
FIN
END doit être la dernière instruction du fichier source. Aucune étiquette n'est autorisée et rien audelà de l'instruction END n'est traité par
l'assembleur.
En utilisant Le format de la directive END est
UTILISER l'expression
Cette directive informe l'ASM51 de la banque de registres actuellement active. Les utilisations ultérieures des adresses de registre symboliques
prédéfinies AR0 à AR7 seront converties en adresse directe appropriée pour la banque de registres active. Considérons la séquence suivante :
UTILISER 3
POUSSEZ AR7
UTILISER 1
POUSSEZ AR7
La première poussée cidessus s'assemble à PUSH 1FH (R7 dans la banque 3), tandis que la deuxième poussée s'assemble à PUSH 0FH (R7
dans la banque 1).
Notez que USING ne change pas réellement de banque de registres ; il informe uniquement l'ASM51 de la banque active.
L'exécution des instructions 8051 est le seul moyen de changer de banque de registres. Ceci est illustré en modifiant l'exemple cidessus
comme suit :
142
MOV PSW, #00011000B ;SÉLECTIONNER LA BANQUE DE REGISTRE 3

UTILISER 3
POUSSEZ AR7 ;ASSEMBLEZ POUR POUSSER 1FH
MOV PSW, #00001000B ;SÉLECTIONNER LA BANQUE D'ENREGISTREMENT 1
UTILISER 1
POUSSEZ AR7 ;ASSEMBLEZ POUR POUSSER 0FH
Définition du symbole
Les directives de définition de symboles créent des symboles qui représentent des segments, des registres, des nombres et des adresses.
Aucune de ces directives ne peut être précédée d'un label. Les symboles définis par ces directives peuvent ne pas avoir été définis
précédemment et ne peuvent en aucun cas être redéfinis. La directive SET est la seule exception. Les directives de définition des
symboles sont décrites cidessous.
Symbole Le format de la directive SEGMENT est indiqué cidessous.
de segment SEGMENT type_segment
Le symbole est le nom d'un segment déplaçable. Dans l'utilisation des segments, ASM51 est plus complexe que les assembleurs
conventionnels, qui ne prennent généralement en charge que les types de segments « code » et « données ». Cependant, ASM51 définit
des types de segments supplémentaires pour s'adapter aux divers espaces mémoire du 8051. Voici les types de segments 8051 définis
(espaces mémoire) :
•
CODE (le segment de code)
•
XDATA (l'espace de données externe)
•
DATA (l'espace de données interne accessible par adressage direct, 00H–07H)
•
IDATA (tout l'espace de données interne accessible par adressage indirect, 00H–07H)
•
BIT (l'espace binaire ; emplacements d'octets superposés 20H à 2FH de l'espace de données interne)
Par exemple, la déclaration

EPROM SEGMENT CODE
déclare le symbole EPROM comme étant un SEGMENT de type CODE. Notez que cette instruction déclare simplement ce qu'est
l'EPROM. Pour réellement commencer à utiliser ce segment, la directive RSEG est utilisée (voir cidessous).
EQU (Équivalent) Le format de la directive EQU est
Symbole Expression EQU
La directive EQU attribue une valeur numérique à un nom de symbole spécifié. Le symbole doit être un nom de symbole valide et
l'expression doit être conforme aux règles décrites précédemment.
Voici des exemples de la directive EQU :
N27 ÉQU 27 ;METTRE N27 À LA VALEUR 27
ICI ÉQU $ ;METTRE "ICI" SUR LA VALEUR DE
;LE COMPTEUR DE LOCALISATION
CR ÉQU 0DH ;METTRE CR (RETOUR CHARIOT) À 0DH
MESSAGE: DB 'Ceci est un message'
LONGUEUR EQU $ MESSAGE ;"LONGUEUR" EST ÉGAL À LA LONGUEUR DU "MESSAGE"
D'autres directives de définition de symboles La directive SET est similaire à la directive EQU sauf le
peuvent être redéfinies ultérieurement, à l'aide d'une autre directive SET.
143
Les directives DATA, IDATA, XDATA, BIT et CODE attribuent des adresses du type de segment correspondant à un symbole. Ces
directives ne sont pas essentielles. Un effet similaire peut être obtenu en utilisant la directive EQU ; Cependant, s'ils sont utilisés, ils évoquent
une puissante vérification de type par ASM51. Considérez les deux directives et quatre instructions suivantes :
DRAPEAU1 ÉQU 05H

DRAPEAU2 PEU 05H
SETB DRAPEAU1
DRAPEAU SETB2
MOUVEMENT DRAPEAU1, #0
MOUVEMENT DRAPEAU2, #0
L'utilisation de FLAG2 dans la dernière instruction de cette séquence générera un message d'erreur « adresse de segment de données attendue
» de l'ASM51. Puisque FLAG2 est défini comme une adresse de bit (à l'aide de la directive BIT), il peut être utilisé dans une instruction de bit
défini, mais il ne peut pas être utilisé dans une instruction de déplacement d'octets. D'où l'erreur. Même si FLAG1 représente la même valeur
(05H), il a été défini à l'aide d'EQU et n'a pas d'espace d'adressage associé. Ce n’est pas un avantage d’EQU, mais plutôt un inconvénient. En
définissant correctement les symboles d'adresse à utiliser dans un espace mémoire spécifique (en utilisant les directives BIT, DATA, XDATA,
etc.), le programmeur profite de la puissante vérification de type de l'ASM51 et évite les bogues dus à une mauvaise utilisation des symboles.
Initialisation/réservation du stockage
Les directives d'initialisation et de réservation du stockage initialisent et réservent de l'espace en unités de mots, d'octets ou de bits.
L'espace réservé commence à l'emplacement indiqué par la valeur actuelle du compteur d'emplacement dans le segment actuellement actif.
Ces directives peuvent être précédées d'une étiquette. Les directives d'initialisation/réservation du stockage sont décrites cidessous.
DS (Define Storage) Le format de la directive DS (define storage) est
[étiquette:] DS expression
La directive DS réserve de l'espace en unités d'octets. Il peut être utilisé dans n'importe quel type de segment sauf BIT. L’expression doit
être une expression valide au moment de l’assemblage, sans références directes ni références transférables ou externes.
Lorsqu'une instruction DS est rencontrée dans un programme, le compteur d'emplacement du segment actuel est incrémenté de la valeur de
l'expression. La somme du compteur d'emplacement et de l'expression spécifiée ne doit pas dépasser les limites de l'espace d'adressage actuel.
L'instruction suivante crée un tampon de 40 octets dans le segment de données interne :
DSEG À 30H ;MISE DANS LE SEGMENT DE DONNÉES (ABSOLU, INTERNE)

LONGUEUR ÉQU 40
TAMPON : DS LONGUEUR ;40 OCTETS RÉSERVÉS
Le label BUFFER représente l'adresse du premier emplacement de mémoire réservé. Pour cet exemple, le tampon commence à l'adresse 30H
car « AT 30H » est spécifié avec DSEG. Le tampon peut être vidé à l'aide de la séquence d'instructions suivante :
MOV R7, #LONGUEUR

MOUVEMENT R0, #TAMPON
BOUCLE : MOV @R0, #0
DJNZ R7, BOUCLE
(continuer)
144
Pour créer un tampon de 1 000 octets dans la RAM externe à partir de 4 000 H, les directives suivantes peuvent être utilisées :
XSTART ÉQU 4000H
LONGUEUR XL ÉQU 1000
XSEG CHEZ XSTART
XTAMPON : DS XLLONGUEUR
Ce tampon peut être vidé avec la séquence d'instructions suivante :
MOUVEMENT DPTR, #XBUFFER

BOUCLE : CLR A
MOVX @DPTR, A
INC DPTR
MOV A, DPL
CJNE A, #LOW (XBUFFER + XLENGTH + 1), BOUCLE
MOUVEMENT A, DPH
CJNE A, #HIGH (XBUFFER + XLENGTH + 1), BOUCLE
(continuer)
Il s'agit d'un excellent exemple d'une utilisation puissante des opérateurs et des expressions de temps d'assemblage d'ASM51. Puisqu’il
n’existe pas d’instruction pour comparer le pointeur de données avec une valeur immédiate, l’opération doit être fabriquée à partir des
instructions disponibles. Deux comparaisons sont nécessaires, une pour les octets de poids fort et de poids faible du DPTR.
De plus, l'instruction comparer et sauter si différent ne fonctionne qu'avec l'accumulateur ou un registre, de sorte que les octets du pointeur
de données doivent être déplacés dans l'accumulateur avant l'instruction CJNE. La boucle se termine uniquement lorsque le pointeur de
données a atteint XBUFFER + LENGTH + 1. (Le "+1" est nécessaire car le pointeur de données est incrémenté après la dernière instruction
MOVX.)
DÉBIT Le format de la directive DBIT (define bit) est :
[étiquette:] Expression du débit
La directive DBIT réserve de l'espace en unités de bits. Il ne peut être utilisé que dans un segment BIT. L'expression doit être une
expression valide au moment de l'assemblage, sans références directes. Lorsque l'instruction DBIT est rencontrée dans un programme, le
compteur d'emplacement du segment (BIT) actuel est incrémenté de la valeur de l'expression. Notez que dans un segment BIT, l'unité de
base du compteur d'emplacement est constituée de bits plutôt que d'octets. Les directives suivantes créent trois indicateurs dans un
segment de bits absolu :
BSEG ;SEGMENT DE BITS (ABSOLU)
KÉFLAG : DÉBIT 1 ;ÉTAT DU CLAVIER
PRFLAG : DÉBIT 1 ;ÉTAT DE L'IMPRIMANTE
DKFLAG : DÉBIT 1 ;ÉTAT DU DISQUE
Comme aucune adresse n'est spécifiée avec BSEG dans l'exemple cidessus, l'adresse des drapeaux définis par DBIT pourrait être
déterminée (si on le souhaite) en examinant la table des symboles dans les fichiers .LST ou .M51. Si les définitions cidessus constituaient
la première utilisation de BSEG, alors KBFLAG serait à l'adresse de bit 00H (bit 0 de l'adresse d'octet 20H). Si d'autres bits avaient été
définis précédemment à l'aide de BSEG, alors les définitions cidessus suivraient le dernier bit défini.
DB (Définir l'octet) Le format de la directive DB (define byte) est :
[étiquette:] Base de données

expression [, expression] […]
La directive DB initialise la mémoire de code avec des valeurs d'octets. Puisqu'il est utilisé pour placer des constantes de données dans la
mémoire de code, un segment CODE doit être actif. La liste d'expressions est une série d'un ou plusieurs octets de valeurs (chacun pouvant
être une expression) séparés par des virgules.
145
La directive DB autorise les chaînes de caractères (entre guillemets simples) de plus de deux caractères tant qu'elles ne font pas partie
d'une expression. Chaque caractère de la chaîne est converti en code ASCII correspondant. Si une étiquette est utilisée, l'adresse du
premier octet lui est attribuée. Par exemple, les déclarations suivantes
CSEG À 0100H
CARRÉS : DB 0, 1, 4, 9, 16, 25 ;CARRÉS DE CHIFFRES 05
MESSAGE : BD 'Connexion :', 0 ;CHAÎNE DE CARACTÈRES TERMINÉE PAR NULL
Une fois assemblé, cela donne les affectations de mémoire hexadécimales suivantes pour la mémoire de code externe :
Adresse Contenu
0100 00
0101 01
0102 04
0103 09
0104 dix
0105 19
0106 4C
0107 6F
0108 67
0109 69
010A 6E
010B 3A
010C 00
DW (Define Word) Le format de la directive DW (define word) est
[étiquette:] Expression DW [, expression] […]
La directive DW est la même que la directive DB sauf que deux emplacements mémoire (16 bits) sont attribués à chaque élément de
données. Par exemple, les déclarations
CSEG À 200H
DW $, 'A', 1234H, 2, 'BC'
entraînent les affectations de mémoire hexadécimales suivantes :

Adresse Contenu
0200 02
0201 00
0202 00
0203 41
0204 12
0205 34
0206 00
0207 02
0208 42
0209 43
Lien avec le programme
Les directives de liaison de programme permettent aux modules (fichiers) assemblés séparément de communiquer en autorisant les
références intermodules et la dénomination des modules. Dans la discussion suivante, un « module » peut être considéré comme un «
fichier ». (En fait, un module peut englober plusieurs fichiers.)
146
Publique Le format de la directive PUBLIC (symbole public) est

PUBLIQUE symbole [, symbole] […]
La directive PUBLIC permet de connaître et d'utiliser la liste des symboles spécifiés en dehors du module actuellement assemblé. Un symbole
déclaré PUBLIC doit être défini dans le module courant. Le déclarer PUBLIC permet de le référencer dans un autre module. Par exemple,
INCHAR PUBLIC, OUTCHR, INLINE, OUTSTR
Externe Le format de la directive EXTRN (symbole externe) est

EXTRN segment_type (symbole [, symbole] […], …)
La directive EXTRN répertorie les symboles à référencer dans le module actuel qui sont définis dans d'autres modules. La liste des symboles
externes doit avoir un type de segment associé à chaque symbole de la liste. (Les types de segments sont CODE, XDATA, DATA, IDATA, BIT
et NUMBER. NUMBER est un symbole sans type défini par EQU.)
Le type de segment indique la manière dont un symbole peut être utilisé. Les informations sont importantes au moment de la liaison pour garantir que les
symboles sont utilisés correctement dans les différents modules.
Les directives PUBLIC et EXTRN fonctionnent ensemble. Considérez les deux fichiers, MAIN.SRC et MESSAGES.
SRC. Les sousprogrammes HELLO et GOOD_BYE sont définis dans le module MESSAGES mais sont mis à disposition des autres modules
grâce à la directive PUBLIC. Les sousprogrammes sont appelés dans le module MAIN même s'ils n'y sont pas définis. La directive EXTRN
déclare que ces symboles sont définis dans un autre module.
PRINCIPAL.SRC :
EXTRN CODE (BONJOUR, GOOD_BYE)

…
APPEL BONJOUR
…
APPEL AU REVOIR
…
FIN
MESSAGES.SRC :
PUBLIQUE BONJOUR AU REVOIR

…
BONJOUR: (commencer le sousprogramme)
…
RETRAIT
AU REVOIR: (commencer le sousprogramme)
…
RETRAIT
…
FIN
Ni MAIN.SRC ni MESSAGES.SRC ne sont un programme complet ; ils doivent être assemblés séparément et liés entre eux pour former
un programme exécutable. Lors de la liaison, les références externes sont résolues avec des adresses correctes insérées comme destination
des instructions CALL.
Nom Le format de la directive NAME est
NOM nom_module
147
Toutes les règles habituelles pour les noms de symboles s'appliquent aux noms de modules. Si aucun nom n'est fourni, le module prend le nom
du fichier (sans spécificateur de lecteur ou de sousrépertoire et sans extension). En l'absence de toute utilisation de la directive NAME, un
programme contiendra un module pour chaque fichier. Le concept de « modules » est donc quelque peu fastidieux, du moins pour des
problèmes de programmation relativement mineurs. Même les programmes de taille modérée (comprenant, par exemple, plusieurs fichiers
complets avec des segments déplaçables) n'ont pas besoin d'utiliser la directive NAME et n'ont pas besoin d'accorder une attention particulière
au concept de « modules ». Pour cette raison, il a été mentionné dans la définition qu'un module peut être considéré comme un « fichier », afin
de simplifier l'apprentissage de l'ASM51. Cependant, pour les programmes très volumineux (plusieurs milliers de lignes de code ou plus), il est
judicieux de partitionner le problème en modules, où, par exemple, chaque module peut englober plusieurs fichiers contenant des routines
ayant un objectif commun.
Directives de sélection des segments

Lorsque l'assembleur rencontre une directive de sélection de segment, il détourne le code ou les données suivants vers le segment sélectionné
jusqu'à ce qu'un autre segment soit sélectionné par une directive de sélection de segment. La directive peut sélectionner un segment
relocalisable préalablement défini ou éventuellement créer et sélectionner des segments absolus.
RSEG (segment relocalisable) Le format de la directive RSEG (segment relocalisable) est

RSEG nom_segment
Où "nom_segment" est le nom d'un segment relocalisable préalablement défini avec la directive SEGMENT.
RSEG est une directive de « sélection de segment » qui détourne le code ou les données suivants vers le segment nommé jusqu'à ce qu'une
autre directive de sélection de segment soit rencontrée.
Sélection de segments absolus RSEG sélectionne un segment déplaçable. Un segment « absolu », en revanche, est sélectionné à l'aide
de l'une des directives :
CSEG (adresse AT)

DSEG (adresse AT)
ISEG (adresse AT)
BSEG (adresse AT)
XSEG (adresse AT)
Ces directives sélectionnent respectivement un segment absolu dans les espaces d'adressage de code, de données internes, de données
internes indirectes, de bits ou de données externes. Si une adresse absolue est fournie (en indiquant « adresse AT »), l'assembleur termine le
dernier segment d'adresse absolue, le cas échéant, du type de segment spécifié et crée un nouveau segment absolu commençant à cette
adresse. Si aucune adresse absolue n'est spécifiée, le dernier segment absolu du type spécifié est continué. Si aucun segment absolu de ce
type n'a été sélectionné auparavant et que l'adresse absolue est omise, un nouveau segment est créé à partir de l'emplacement 0. Les
références directes ne sont pas autorisées et les adresses de début doivent être absolues.
Chaque segment possède son propre compteur de localisation, qui est toujours initialement mis à 0. Le segment par défaut est un
segment de code absolu ; par conséquent, l'état initial de l'assembleur est l'emplacement 0000H dans le segment de code absolu.
Lorsqu'un autre segment est choisi pour la première fois, le compteur de localisation de l'ancien segment conserve la dernière valeur active.
Lorsque cet ancien segment est resélectionné, le compteur d'emplacement reprend à la dernière valeur active. La directive ORG peut être
utilisée pour modifier le compteur d'emplacement dans le segment actuellement sélectionné.
COMMANDES DE L'ASSEMBLEUR
Les contrôles de l'assembleur établissent le format des fichiers de liste et d'objet en régulant les actions de l'ASM51. Pour la plupart, les
contrôles assembleur affectent l'apparence du fichier de liste, sans avoir d'effet sur le programme luimême.
Ils peuvent être saisis sur la ligne d'invocation lorsqu'un programme est assemblé, ou ils peuvent être placés dans le fichier source.
Les champs Assembleur apparaissant dans le fichier source doivent être précédés du signe Dollor et doivent commencer dans la colonne 1.
148
Il existe deux catégories de contrôles assembleur : primaires et généraux. Les contrôles primaires peuvent être placés dans la ligne d'invocation
ou au début du programme source. Seuls d’autres contrôles primaires peuvent précéder un contrôle primaire. Les contrôles généraux peuvent être
placés n'importe où dans le programme source.
FONCTIONNEMENT DU LIEUR
Lors du développement de grands programmes d'application, il est courant de diviser les tâches en sousprogrammes ou modules contenant des
sections de code (généralement des sousprogrammes) qui peuvent être écrites séparément du programme global. Le terme « programmation modulaire
» fait référence à cette stratégie de programmation. Généralement, les modules sont déplaçables, ce qui signifie qu'ils ne sont pas destinés à une
adresse spécifique dans le code ou l'espace de données. Un programme de liaison et de localisation est nécessaire pour combiner les modules en un
seul module objet absolu pouvant être exécuté.
Le RL51 d'Intel est un éditeur de liens/localisateur typique. Il traite une série de modules objets déplaçables en entrée et crée un programme en
langage machine exécutable (PROGRAM, peutêtre) et un fichier de liste contenant une carte mémoire et une table de symboles (PROGRAM.M51).
Ceci est illustré dans la figure suivante.
FICHIER3.OBJ PROGRAMME.ABS
FICHIER2.OBJ
FICHIER1.OBJ RL51
PROGRAMME.MAP
Légende
Programme utilitaire
Fichier utilisateur
Fonctionnement de l'éditeur de liens
Au fur et à mesure que les modules déplaçables sont combinés, toutes les valeurs des symboles externes sont résolues avec les valeurs insérées
dans le fichier de sortie. L'éditeur de liens est invoqué à partir de l'invite système par
Liste_entrée RL51 [Fichier_sortie T0] [location_controls]
La input_list est une liste de modules objets (fichiers) déplaçables séparés par des virgules. La liste_sortie est le nom du module objet absolu de
sortie. Si aucun n'est fourni, la valeur par défaut est le nom du premier fichier d'entrée sans aucun suffixe. Les location_controls définissent les adresses
de début pour les segments nommés.
Par exemple, supposons que trois modules ou fichiers (MAIN.OBJ, MESSAGES.OBJ et SUBROUTINES.OBJ) doivent être combinés en un
programme exécutable (EXEMPLE), et que ces modules contiennent chacun deux segments déplaçables, un appelé EPROM de type CODE , et l'autre
appelé ONCHIP de type DATA. Supposons en outre que le segment de code doit être exécutable à l'adresse 4000H et que le segment de données doit
résider à partir de l'adresse 30H (dans la RAM interne). L'invocation de l'éditeur de liens suivante pourrait être utilisée :
RS51 MAIN.OBJ, MESSAGES.OBJ, SUBROUTINES.OBJ VERS EXEMPLE ET CODE (EPROM (4000H) DONNEES (SUR
PUCE (30H))
Notez que le caractère esperluette "&" est utilisé comme caractère de continuation de ligne.
Si le programme commence à l'étiquette START et qu'il s'agit de la première instruction du module MAIN, alors l'exécution commence à
l'adresse 4000H. Si le module MAIN n'a pas été lié en premier, ou si l'étiquette START n'est pas au début de MAIN, alors le point d'entrée du programme
peut être déterminé en examinant la table des symboles dans le fichier de liste EXAMPLE.M51 créé par RL51. Par défaut, EXAMPLE.M51 contiendra
uniquement la mappe de liens. Si une table de symboles est souhaitée, chaque programme source doit avoir utilisé le contrôle SDEBUG. Le tableau
suivant présente les contrôles assembleur pris en charge par ASM51.
149
Contrôles assembleur pris en charge par ASM51

PRIMAIRE/
NOM GÉNÉRAL DÉFAUT ABRÉV. SIGNIFICATION
DATE (date) P. DATE( ) DA Placer la chaîne dans l'entête (9 caractères max.)

DÉBOGUER P. BUG DE NŒUD DB génère des informations sur les symboles de débogage dans un fichier objet
ÉJECTER g n'est pas applicable EJ Continuer l'inscription sur la page suivante
IMPRIME D'ERREUR P. PAS D'IMPRESSION D'ERREUR EP Désigne un fichier pour recevoir les messages d'erreur en plus du fichier de listing (par
(fichier) défaut en console)
NOERREURPRINT P NOERRORPRINT NOEP Désigne que les messages d'erreur seront imprimés dans le fichier de liste
seulement
GÉNÉRATION g GÉNIQUEMENT GO Lister uniquement la source entièrement développée comme si toutes les lignes étaient générées
par un appel de macro étaient déjà dans le fichier source
GÉNIQUEMENT g GÉNIQUEMENT NOGE Répertorie uniquement le texte source original dans le fichier de listing
INCLUS(fichier) g n'est pas applicable CI Désigne un fichier à inclure dans le cadre du programme
LISTE g LISTE LI Imprimer les lignes suivantes du code source dans le fichier de liste
NOLISTE g LISTE NOLI Ne pas imprimer les lignes suivantes du code source dans le fichier de liste
MACRO P. MACRO(50) MR Évaluez et développez tous les appels de macro. Allouer un pourcentage de mémoire
(men_precent) libre pour le traitement des macros
NOMACRO P. MACRO(50) NOMR Ne pas évaluer les appels de macro
MOD51 P. MOD51 MO Reconnaître les registres de fonctions spéciales prédéfinis spécifiques au 8051
NOMOD51 P. MOD51 NOMO Ne reconnaît pas les registres de fonctions spéciales prédéfinis spécifiques au 8051
OBJET(fichier) P. OBJECT(source.OBJ) OJ Désigne le fichier devant recevoir le code objet

AUCUN OBJET P. OBJECT(source.OBJ) NOOJ Indique qu'aucun fichier objet ne sera créé
PAGINATION P. PAGINATION PI Désigne que le fichier de liste soit divisé en pages et chacune aura un entête
NOPAGAGE P. PAGINATION NOPI Désigne que le fichier de liste ne contiendra aucun saut de page
LONGUEUR DE LA PAGE P. LONGUEUR DE PAGE(60) PL Définit le nombre maximum de lignes dans chaque page du fichier de liste (plage = 10
(N) à 65 536)
LARGEUR DE LA PAGE (N) P. PAGEWIDTH(120) PW Définir le nombre maximum de caractères dans chaque ligne de liste
fichier (plage = 72 à 132)
Imprimer le fichier) P. PRINT(source.LST) PR Désigne le fichier pour recevoir la liste des sources
NOPRINT P. PRINT(source.LST) NOPR Indique qu'aucun fichier de liste ne sera créé
SAUVEGARDER g sans objet sans SA stocke les paramètres de contrôle actuels de la pile SAVE
RESTAURER g objet RS restaure les paramètres de contrôle de la pile SAVE
BANQUE D'ENREGISTREMENT P. REGISTERBANK(0) RB Indique une ou plusieurs banques utilisées dans le module de programme
(rb,...)
NOREINSCRIPTION P. REGISTERBANK(0) NORB Indique qu'aucune banque de registre n'est utilisée

BANQUE
SYMBOLES P. SYMBOLES SB Crée un tableau formaté de tous les symboles utilisés dans le programme
NOSYMBOLES P. SYMBOLES NOSB Indique qu'aucune table de symboles n'est créée
TITRE (chaîne) g TITRE( ) TT Place une chaîne dans tous les entêtes de page suivants (max. 60 caractères)
FICHIERS DE TRAVAIL P. identique à la source WF désigne un chemin alternatif pour les fichiers de travail temporaires
(chemin)
XREF P. NOXREF XR Crée une liste de références croisées de tous les symboles utilisés dans
programme
NOXREF P. NOXREF NOXR Indique qu'aucune liste de références croisées n'est créée
150
MACROS
La fonction de traitement de macros (MPL) de l'ASM51 est une fonction de « remplacement de chaîne ». Les macros permettent de définir une seule fois
les sections de code fréquemment utilisées à l'aide d'un simple mnémonique et de les utiliser n'importe où dans le programme en insérant le mnémonique.
La programmation à l'aide de macros est une extension puissante des techniques décrites jusqu'à présent. Les macros peuvent être définies n'importe
où dans un programme source et ensuite utilisées comme n'importe quelle autre instruction. La syntaxe de définition des macros est
%*DÉFINIR (modèle_d'appel) (macro_body)
Une fois défini, le modèle d’appel est comme un mnémonique ; elle peut être utilisée comme n'importe quelle instruction en langage assembleur
en la plaçant dans le champ mnémonique d'un programme. Les macros se distinguent des instructions « réelles » en les faisant précéder du signe de
pourcentage, « % ». Lorsque le programme source est assemblé, tout ce qui se trouve dans le corps de la macro, caractère par caractère, est remplacé
par le modèle d'appel. La mystique des macros est largement infondée.
Ils fournissent un moyen simple de remplacer des modèles d'instructions encombrants par des mnémoniques primitifs et faciles à retenir. La substitution,
nous le répétons, se fait personnage par personnage – ni plus, ni moins.
Par exemple, si la définition de macro suivante apparaît au début d'un fichier source,
%*DÉFINIR (PUSH_DPTR)
(APPOUSSER DPH
POUSSER LE DPL
puis la déclaration
%PUSH_DPTR
apparaîtra dans le fichier .LST comme
POUSSER DPH
POUSSER LE DPL
L'exemple cidessus est une macro typique. Étant donné que les instructions de la pile 8051 fonctionnent uniquement sur des adresses directes,
pousser le pointeur de données nécessite deux instructions PUSH. Une macro similaire peut être créée pour POP le pointeur de données.
L’utilisation de macros présente plusieurs avantages distincts :
•
Un programme source utilisant des macros est plus lisible, car le mnémonique de la macro est généralement plus indicatif de l'opération
prévue que les instructions assembleur équivalentes.
•
Le programme source est plus court et nécessite moins de saisie.
•
L'utilisation de macros réduit les bugs
•
L'utilisation de macros libère le programmeur du traitement des détails de bas niveau.
Les deux derniers points cidessus sont liés. Une fois qu'une macro est écrite et déboguée, elle est utilisée librement sans souci de bugs. Dans l'exemple
PUSH_DPTR cidessus, si les instructions PUSH et POP sont utilisées plutôt que les macros push et pop, le programmeur peut par inadvertance inverser
l'ordre des push ou pop. (Estce que c'est l'octet haut ou l'octet bas qui a été poussé en premier ?) Cela créerait un bug. Cependant, à l'aide de macros,
les détails sont réglés une fois...
lorsque la macro est écrite et que la macro est utilisée librement par la suite, sans souci de bugs.
Étant donné que le remplacement se fait caractère par caractère, la définition de la macro doit être soigneusement construite avec des retours
chariot, des tabulations, etc., pour garantir un alignement correct des instructions de macro avec le reste du programme en langage assembleur.
Quelques essais et erreurs sont nécessaires.
Il existe des fonctionnalités avancées de la fonction de macrotraitement de l'ASM51 qui permettent le passage de paramètres, les étiquettes
locales, les opérations répétées, le contrôle du flux d'assemblage, etc. Ceuxci sont discutés cidessous.
151
Passage de paramètres
Une macro avec des paramètres transmis depuis le programme principal a le format modifié suivant :
%*DÉFINIR (macro_name (parameter_list)) (macro_body)
Par exemple, si la macro suivante est définie,

%*DÉFINIR (#CMPA (VALEUR))
(CJNE A, #%VALEUR, $ + 3
)
puis l'appel de macro
%ACPM# (20H)
se développera en l'instruction suivante dans le fichier .LST :
CJNE A, #20H, $ + 3
Bien que le 8051 ne dispose pas d'instruction « comparer l'accumulateur », une instruction est facilement créée à l'aide de l'instruction
CJNE avec « $+3 » (l'instruction suivante) comme destination du saut conditionnel. Le mnémonique CMPA# peut être plus facile à retenir
pour de nombreux programmeurs. En outre, l'utilisation de la macro évite au programmeur de se souvenir des détails de notation, tels
que "$+3".
Développons un autre exemple. Ce serait bien si le 8051 avait des instructions telles que
SAUTER SI ACCUMULATEUR SUPÉRIEUR À X
SAUTER SI ACCUMULATEUR SUPÉRIEUR OU ÉGAL À X
SAUTER SI ACCUMULATEUR INFÉRIEUR À X
SAUTER SI ACCUMULATEUR INFÉRIEUR OU ÉGAL À X
mais ce n'est pas le cas. Ces opérations peuvent être créées en utilisant CJNE suivi de JC ou JNC, mais les détails sont délicats.
Supposons, par exemple, que l'on souhaite accéder à l'étiquette GREATER_THAN si l'accumulateur contient un code ASCII supérieur à
"Z" (5AH). La séquence d'instructions suivante fonctionnerait :
CJNE A, #5BH, ÷3$

JNC PLUS GRAND_THAN
L'instruction CJNE soustrait 5BH (c'estàdire "Z" + 1) du contenu de A et active ou efface l'indicateur de report en conséquence. CJNE
laisse C=1 pour les valeurs d’accumulateur 00H jusqu’à 5AH inclus. (Remarque : 5AH5BH<0, donc C=1 ; mais 5BH5BH=0, donc C=0.)
Sauter à GREATER_THAN à la condition « pas de transport » saute correctement pour les valeurs d'accumulateur 5BH, 5CH, 5DH, et
ainsi allumé, jusqu'à FFH. Une fois que de tels détails sont réglés, ils peuvent être simplifiés en inventant un mnémonique approprié, en
définissant une macro et en utilisant la macro au lieu de la séquence d'instructions correspondante. Voici la définition d'une macro "sauter
si supérieur à" :
%*DÉFINIR (JGT (VALEUR, ÉTIQUETTE))
(CJNE A, #%VALEUR+1, $+3 ;JGT
JNC %ÉTIQUETTE
)
Pour tester si l'accumulateur contient un code ASCII supérieur à "Z", comme nous venons de le voir, la macro serait appelée comme
%JGT ('Z', GREATER_THAN)
ASM51 étendrait cela à
CJNE A, #5BH, +3$ ;JGT

JNC PLUS GRAND_THAN
La macro JGT est un excellent exemple d’utilisation pertinente et puissante des macros. En utilisant des macros, le programmeur
bénéficie de l'utilisation d'un mnémonique significatif et évite les détails désordonnés et potentiellement porteurs de bogues.
152
Étiquettes locales
Les étiquettes locales peuvent être utilisées dans une macro en utilisant le format suivant :
%*DÉFINIR (nom_macro [(liste_paramètres)])
[LOCAL list_of_local_labels] (macro_body)
Par exemple, la définition de macro suivante
%*DEFINE (DEC_DPTR) SAUTER LOCAL

(DEC DPL ;DIMINUER LE POINTEUR DE DONNÉES
MOV A, DPL
CJNE A, #0FFH, %SKIP
DEC DPL
%SAUTER: )
serait appelé comme
%DEC_DPTR
et serait étendu par l'ASM51 à

DEC DPL ;DIMINUER LE POINTEUR DE DONNÉES
MOV A, DPL
CJNE A, #0FFH, SKIP00
DÉC DPH
SAUTER00 :
Notez qu'une étiquette locale n'entrera généralement pas en conflit avec la même étiquette utilisée ailleurs dans le programme source,
puisque ASM51 ajoute un code numérique à l'étiquette locale lorsque la macro est développée. De plus, la prochaine utilisation de la
même étiquette locale reçoit le code numérique suivant, et ainsi de suite.
La macro cidessus a un « effet secondaire » potentiel. L'accumulateur est utilisé comme lieu de stockage temporaire pour le
DPL. Si la macro est utilisée dans une section de code qui utilise A à d’autres fins, la valeur de A serait perdue.
Cet effet secondaire représente probablement un bug dans le programme. La définition de la macro pourrait se prémunir contre cela
en enregistrant A sur la pile. Voici une définition alternative pour la macro DEC_DPTR :
%*DÉFINIR (DEC_DPTR) SAUTER LOCAL
(PUSHACC
DEC DPL ;DIMINUER LE POINTEUR DE DONNÉES
MOV A, DPL
CJNE A, #0FFH, %SKIP
DÉC DPH
%SAUTER: ACC POP
)
Répéter les opérations

Il s'agit de l'une des nombreuses macros intégrées (prédéfinies). Le format est
%RÉPÉTER (expression) (texte)
Par exemple, pour remplir un bloc de mémoire avec 100 instructions NOP,
%RÉPÉTITION (100)
(NOP
)
153
Opérations de flux de contrôle

L'assemblage conditionnel d'une section de code est fourni par la définition de macro de flux de contrôle d'ASM51. Le format est
%IF (expression) ALORS (texte_équilibré)
[ELSE (balanced_text)] FI
Par exemple,
INTRÉNALE ÉQUIPEMENT 1 ;1 = 8051 PILOTES D'E/S SÉRIE
;0 = 8251 PILOTES D'E/S SÉRIE
.
.
%IF (INTERNE) ALORS
(INCHAR : . ;8051 PILOTES
.
OUTCHR : .
.
) AUTRE
(INCHAR : . ;8251 PILOTES
.
OUTCHR : .
.
)
Dans cet exemple, le symbole INTERNE reçoit la valeur 1 pour sélectionner les sousprogrammes d'E/S pour le port série du
8051, ou la valeur 0 pour sélectionner les sousprogrammes d'E/S pour un UART externe, dans ce cas le 8251. La macro IF
provoque l'ASM51. pour assembler un ensemble de pilotes et sauter l'autre. Ailleurs dans le programme, les sousprogrammes
INCHAR et OUTCHR sont utilisés sans tenir compte de la configuration matérielle particulière. Tant que le programme est
assemblé avec la valeur correcte pour INTERNE, le sousprogramme correct est exécuté.
154
Annexe B : Programmation 8051 C
AVANTAGES ET INCONVÉNIENTS DU 8051 C

Les avantages de la programmation du 8051 en C par rapport à l'assemblage sont :
•
Offre tous les avantages des langages de programmation structurés de haut niveau tels que C, y compris la facilité d'écriture de
sousprogrammes
•
Cela décharge souvent le programmeur des détails matériels que le compilateur gère au nom du
programmeur
•
Plus facile à écrire, en particulier pour les programmes volumineux et complexes
•
Produit des codes sources de programme plus lisibles
Néanmoins, le 8051 C, étant très similaire au langage C conventionnel, souffre également des inconvénients suivants :
•
Traite les inconvénients des langages de programmation structurés de haut niveau.
•
Génère généralement des codes machine plus volumineux
•
Le programmeur a moins de contrôle et moins de capacité à interagir directement avec le matériel
Pour comparer entre 8051 C et le langage assembleur, considérez les solutions de l'exemple : écrivez un programme en utilisant la minuterie
0 pour créer une onde carrée de 1 KHz sur P1.0.
Une solution écrite cidessous en langage 8051 C :
portbit sbit = P1^0 ; /*Utiliser un portbit variable pour faire référence à P1.0*/
principal ( )
{
TMOD = 1 ;
tandis que (1)
{
TH0 = 0xFE ;
TL0 = 0xC ;
TR0 = 1 ;
tandis que (TF0 !=1);
TR0 = 0 ;
TF0 = 0 ;
portbit = !(P1.^0);
}
}
Une solution écrite cidessous en langage assembleur :

ORG 8100H
MOV TMOD, #01H ;Mode minuterie 16 bits
BOUCLE : MOV TH0, #0FEH ;500 (octet de poids fort)
MOUVEMENT TL0, #0CH ;500 (octet de poids faible)
SETB TR0 ;démarrer le minuteur
ATTENDRE : JNB TF0, ATTENDRE ;attendre le débordement

CLR TR0 ;arrêter le chronomètre
CLRTF0 ;effacer l'indicateur de dépassement de minuterie
CPL P1.0 ;basculer le bit de port

BOUCLE SJMP ;répéter
FIN
155
Notez que les solutions en assembleur et en langage C pour l'exemple cidessus nécessitent presque le même nombre de lignes. Cependant, la différence réside
dans la lisibilité de ces programmes. La version C semble plus humaine que l'assemblage, et est donc plus lisible. Cela facilite souvent les efforts du programmeur
humain pour écrire des programmes même très complexes. La version en langage assembleur est plus étroitement liée au code machine et, bien que moins
lisible, elle donne souvent lieu à un code machine plus compact. Comme pour cet exemple, le code machine résultant de la version assembleur prend 83 octets
tandis que celui de la version C nécessite 149 octets, soit une augmentation de 79,5 % !
Le choix du programmeur humain entre un langage C de haut niveau ou un langage assembleur pour communiquer avec le
8051, dont le langage est le langage machine, présente une image intéressante, comme le montre la figure suivante.
Langage humain Langage C (haut niveau)
Par exemple. Anglais, Malais, Chinois Par exemple. pour (x=0; x<9; x++)...
Compilateur
Langage d'assemblage
Par exemple. MOV, AJOUTER, SOUS
Language de machine
Par exemple. 10011101 0101010101 Assembleur
Conversion entre le langage humain, de haut niveau, d'assemblage et machine
8051 COMPILATEURS C
Nous avons vu dans la figure cidessus qu'un compilateur est nécessaire pour convertir les programmes écrits en langage C 8051 en langage machine, tout
comme un assembleur est nécessaire dans le cas de programmes écrits en langage assembleur. Un compilateur agit essentiellement comme un assembleur,
sauf qu'il est plus complexe puisque la différence entre C et le langage machine est bien plus grande que celle entre l'assembleur et le langage machine. Le
preneur d’ordre est donc confronté à une tâche plus lourde pour combler cette différence.
Il existe actuellement différents compilateurs 8051 C, qui offrent des fonctions presque similaires. Tous nos exemples et programmes ont été compilés
et testés avec l'IDE μ Vision 2 de Keil par Keil Software, un 8051 intégré
environnement de développement de programmes qui inclut son compilateur croisé C51 pour C. Un compilateur croisé est un compilateur qui s'exécute
normalement sur une plateforme telle que les PC compatibles IBM, mais est destiné à compiler des programmes en codes à exécuter sur d'autres platesformes
telles que le 8051.
TYPES DE DONNÉES
Le 8051 C ressemble beaucoup au langage C conventionnel, sauf que plusieurs extensions et adaptations ont été apportées pour le rendre adapté à
l'environnement de programmation 8051. La première préoccupation du programmeur 8051 C concerne les types de données. Rappelezvous qu'un type de
données est quelque chose que nous utilisons pour stocker des données. Les lecteurs seront familiers avec les types de données de base du C tels que int, char
et float, qui sont utilisés pour créer des variables pour stocker des entiers, des caractères ou des virgules flottantes. Dans le 8051 C, tous les types de données
C de base sont pris en charge, ainsi que quelques types de données supplémentaires destinés à être utilisés spécifiquement avec le 8051.
Le tableau suivant donne une liste des types de données courants utilisés dans le 8051 C. Ceux en gras sont les extensions spécifiques au 8051. Le
type de données bit peut être utilisé pour déclarer des variables qui résident dans les emplacements adressables par bits du 8051 (à savoir les emplacements
d'octets 20H à 2FH ou les emplacements de bits 00H à 7FH). Évidemment, ces variables binaires ne peuvent stocker que des valeurs binaires de 0 ou 1. À titre
d'exemple, l'instruction C suivante :
indicateur de bits = 0 ;
déclare une variable binaire appelée flag et l'initialise à 0.

156
Types de données utilisés en langage 8051 C
Bit de type de Plage de valeurs Bits Octets

données 1 0à1
caractère signé 8 1 128 à +127
caractère non signé 8 1 0 à 255

énumération 16 2 32768 à +32767
signé court 16 2 32768 à +32767
non signé court 16 2 0 à 65535
signé int 16 2 32768 à +32767
non signé int 16 2 0 à 65535
signé long 32 4 2 147 483 648 à +2 147 483 647

non signé long 32 4 0 à 4 294 967 295
flottant 32 4 ±1,175494E38 à ±3,402823E+38
sbit 1 0à1
sfr 8 1 0 à 255
16 francs suisses 16 2 0 à 65535
Le type de données sbit est quelque peu similaire au type de données bit, sauf qu'il est normalement utilisé pour déclarer des
variables de 1 bit qui résident dans des registres de fonctions spéciales (SFR). Par exemple:
sbit P = 0xD0 ;
déclare la variable sbit P et précise qu'elle fait référence à l'adresse de bit D0H, qui est en réalité le LSB du PSW SFR. Notez la différence
ici dans l'utilisation de l'opérateur d'affectation ("="). Dans le contexte des déclarations sbit , il indique à quelle adresse réside la variable
sbit , tandis que dans les déclarations bit , il est utilisé pour spécifier la valeur initiale de la variable bit .
En plus d'attribuer directement une adresse de bit à une variable sbit , nous pourrions également utiliser un sfr préalablement défini.
variable comme adresse de base et assignez notre variable sbit pour faire référence à un certain bit dans ce sfr. Par exemple:
sfr PSW = 0xD0 ;
sbit P = PSW^0 ;
Celuici déclare une variable sfr appelée PSW qui fait référence à l'adresse d'octet D0H puis l'utilise comme adresse de base pour faire
référence à son LSB (bit 0). Celuici est ensuite attribué à une variable sbit , P. À cette fin, le symbole carat (^) est utilisé pour spécifier la
position binaire 0 du PSW.
Une troisième alternative utilise une adresse d'octet constante comme adresse de base à l'intérieur de laquelle un certain bit est
référencé. À titre d'illustration, les deux déclarations précédentes peuvent être remplacées par ce qui suit :
sbit P = 0xD0 ^ 0 ;
Pendant ce temps, le type de données sfr est utilisé pour déclarer les variables d’octets (8 bits) associées aux SFR. La déclaration:
sfr IE = 0xA8 ;
déclare une variable sfr IE qui réside à l'adresse d'octet A8H. Rappelons que cette adresse est l'endroit où se trouve le SFR Interrupt Enable
(IE) ; par conséquent, le type de données sfr n'est qu'un moyen pour nous permettre d'attribuer des noms aux SFR afin qu'ils soient plus
faciles à mémoriser.
Le type de données sfr16 est très similaire à sfr mais, alors que le type de données sfr est utilisé pour les SFR 8 bits, sfr16 est utilisé pour
SFR 16 bits. Par exemple, la déclaration suivante :
sfr16 DPTR = 0x82 ;
157
déclare une variable DPTR de 16 bits dont l'adresse de l'octet inférieur est à 82H. En vérifiant l'architecture 8051, nous constatons
qu'il s'agit de l'adresse du DPL SFR, donc encore une fois, le type de données sfr16 nous permet de faire plus facilement référence
aux SFR par leur nom plutôt que par leur adresse. Il ne reste plus qu'une chose à mentionner. Lors de la déclaration de sbit, sfr ou sfr16
variables, n'oubliez pas de le faire en dehors de main, sinon vous obtiendrez une erreur.
En réalité, tous les SFR du 8051, y compris les bits d'indicateur, d'état et de contrôle individuels des SFR adressables
par bits, ont déjà été déclarés dans un fichier d'inclusion, appelé reg51.h, fourni avec la plupart des compilateurs C 8051. . En
utilisant reg51.h, nous pouvons par exemple faire référence au registre d'activation d'interruption comme simplement IE plutôt
que d'avoir à spécifier l'adresse A8H, et au pointeur de données comme DPTR plutôt que 82H. Tout cela rend les programmes
8051 C plus lisibles et gérables par l'homme. Le contenu de reg51.h est répertorié cidessous.
/*
REG51.H
Fichier d'entête pour le microcontrôleur générique 8051.
*/
/* Registre BYTE */ sbit IE1 = 0x8B ;
franc P0 = 0x80 ; sbit IT1 = 0x8A ;
sfr P1 = 0x90 ; sbit IE0 = 0x89 ;
fr = 0xA0 ; P2 sbit IT0 = 0x88 ;
sfr P3 = 0xB0 ; /* C'EST À DIRE */
sfr PSW = 0xD0 ; sbit EA sbit = 0xAF ;

sfr ACC = 0xE0 ; sbit ES = 0xAC;
sfr B = 0xF0 ; sbit ET1 = 0xAB ;
sfr PS = 0x81 ; EX1 = 0xAA;
sfr DPL = 0x82 ; sbit ET0 = 0xA9 ;
sfr DPH = 0x83 ; sbit EX0 = 0xA8 ;
sfr PCON = 0x87 ; /* IP */
sfr TCON = 0x88 ; sbit PS = 0xBC ;
sfr TMOD = 0x89 ; sbit PT1 = 0xBB;
sfr TL0 = 0x8A ; sbit PX1 = 0xBA ;
sfr TL1 = 0x8B ; sbit TP0 = 0xB9 ;
sfr TH0 = 0x8C ; sbit PX0 = 0xB8 ;
sfr TH1 = 0x8D ; /* P3 */
sfr IE = 0xA8 ; sbit RD = 0xB7 ;
sfr PI = 0xB8 ; sbit WR = 0xB6 ;
sfr SCON = 0x98 ; sbit = 0xB5T1
;
sfr SBUF = 0x99 ; sbit T0 = 0xB4 ;
/* Registre BIT */ sbit INT1 = 0xB3 ;
/* PSW */ sbit INT0 = 0xB2 ;
sbit CY = 0xD7 ; sbit TXD = 0xB1 ;
sbit AC = 0xD6 ; sbit RXD = 0xB0 ;
sbit = 0xD5F0; /* SCON */
bit = 0xD4 ;RS1 sbit SM0 = 0x9F ;
sbit = 0xD3RS0
; sbit SM1 = 0x9E ;
sbit OV = 0xD2 ; sbit SM2 = 0x9D ;
sbit P = 0xD0 ; sbit REN = 0x9C ;
/* TCON */ sbit TB8 = 0x9B ;
sbit TF1 = 0x8F ; sbit RB8 = 0x9A ;
TR1 = 0x8E ; sbit TI = 0x99 ;
sbit TF0 = 0x8D ; sbit RI = 0x98 ;
sbit TR0 = 0x8C ;
158
TYPES ET MODÈLES DE MÉMOIRE
Le 8051 dispose de différents types d’espace mémoire, notamment une mémoire de code et de données interne et externe. Lors de la déclaration de variables,
il est donc raisonnable de se demander dans quel type de mémoire ces variables résideraient. À cette fin, plusieurs spécificateurs de type de mémoire sont
disponibles, comme indiqué dans le tableau suivant.
Types de mémoire utilisés en langage 8051 C
Code du type de Description (Taille)

mémoire Mémoire de code (64 Ko)
données Mémoire de données interne directement adressable (128 octets)
idata Mémoire de données interne indirectement adressable (256 octets)
bdata Mémoire de données interne adressable par bits (16 octets)
xdata Mémoire de données externe (64 Ko)
pdata Mémoire de données externe paginée (256 octets)
Le premier spécificateur de type de mémoire donné dans le tableau cidessus est le code. Ceci est utilisé pour spécifier qu'une variable doit résider dans la
mémoire de code, qui a une plage allant jusqu'à 64 Ko. Par exemple:
carboniser code errormsg[ ] = "Une erreur s'est produite" ;
déclare un tableau de caractères appelé errormsg qui réside dans la mémoire de code.
Si vous souhaitez placer une variable dans la mémoire de données, utilisez l'un des cinq spécificateurs de mémoire de données restants dans le
tableau cidessus. Même si le choix vous appartient, gardez à l'esprit que chaque type de mémoire de données affecte la vitesse d'accès et la taille de la
mémoire de données disponible. Par exemple, considérons les déclarations suivantes :
signé int data num1 ;

bit bdata numbit ;
int non signé xdata num2 ;
La première instruction crée une variable int signée num1 qui réside dans la mémoire de données interne (00H à 7FH). La ligne suivante déclare un bit numbit
variable qui doit résider dans les emplacements mémoire adressables par bits (adresses d'octets 20H à 2FH), également appelés bdata. Enfin, la dernière
ligne déclare une variable int non signée appelée num2 qui réside dans la mémoire de données externe, xdata. Avoir une variable située dans la mémoire de
données interne directement adressable accélère considérablement l'accès ; par conséquent, pour les programmes dont le temps est critique, les variables
doivent être de type data. Pour d'autres variantes telles que le 8052 avec une mémoire de données interne jusqu'à 256 octets, le spécificateur idata peut être
utilisé. Notez cependant que cela est plus lent que les données puisqu'il doit utiliser un adressage indirect. En attendant, si vous préférez que vos variables
résident dans une mémoire externe, vous avez le choix de les déclarer comme pdata ou xdata. Une variable déclarée dans pdata réside dans les 256 premiers
octets (une page) de la mémoire externe, tandis que si plus de stockage est requis, xdata doit être utilisé, ce qui permet d'accéder jusqu'à 64 Ko de mémoire
de données externe.
Que se passetil si, lors de la déclaration d'une variable, vous oubliez de spécifier explicitement dans quel type de mémoire elle doit résider, ou si vous
souhaitez que toutes les variables se voient attribuer un type de mémoire par défaut sans avoir à les spécifier une par une ? Dans ce cas, nous utilisons des
modèles de mémoire. Le tableau suivant répertorie les différents modèles de mémoire que vous pouvez utiliser.
Modèles de mémoire utilisés en langage 8051 C
Modèle de mémoire Description

Petit Les variables sont par défaut dans la mémoire de données interne (données)
Compact Les variables sont par défaut les 256 premiers octets de la mémoire de données externe (pdata)
Grand Les variables sont par défaut dans la mémoire de données externe (xdata)
159
Un programme est explicitement sélectionné pour être dans un certain modèle de mémoire à l'aide de la directive C, #pragma. Sinon, le modèle de mémoire
par défaut est petit. Il est recommandé aux programmes d'utiliser le modèle à petite mémoire, car il permet un accès le plus rapide possible en définissant
par défaut que toutes les variables résident dans la mémoire de données interne.
Le modèle de mémoire compact fait en sorte que toutes les variables soient par défaut sur la première page de la mémoire de données externe, tandis
que le modèle de mémoire grande fait en sorte que toutes les variables soient par défaut sur la plage complète de mémoire de données externe allant jusqu'à 64 Ko.
TABLEAUX
Souvent, un groupe de variables utilisé pour stocker des données du même type doit être regroupé pour une meilleure lisibilité.
Par exemple, le tableau ASCII pour les chiffres décimaux serait celui indiqué cidessous.
Tableau ASCII pour les chiffres décimaux

Chiffre décimal Code ASCII en hexadécimal
0 30H
1 31H
2 32H
3 33H
4 34H
5 35H
6 36H
7 37H
8 38H
9 39H
Pour stocker une telle table dans un programme 8051 C, un tableau pourrait être utilisé. Un tableau est un groupe de variables du même type de données,
toutes accessibles en utilisant le nom du tableau ainsi qu'un index approprié.
Le tableau pour stocker la table décimale ASCII est :
int tableau [10] =

{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39} ;
Notez que tous les éléments d'un tableau sont séparés par des virgules. Pour accéder à un élément individuel, un index commençant à 0 est utilisé. Par
exemple, table[0] fait référence au premier élément tandis que table[9] fait référence au dernier élément de ce tableau ASCII.
STRUCTURE
Parfois, il est également souhaité que des variables de types de données différents mais qui sont liées les unes aux autres d'une manière ou d'une autre
soient regroupées. Par exemple, le nom, l'âge et la date de naissance d'une personne seraient stockés dans différents types de variables, mais toutes font
référence aux données personnelles de la personne. Dans un tel cas, une structure peut être déclarée. Une structure est un groupe de variables liées qui
peuvent être de différents types de données. Une telle structure est déclarée par :
structurer personne {
nom du personnage ;
âge entier ;
date de naissance longue ;
};
Une fois qu'une telle structure a été déclarée, elle peut être utilisée comme spécificateur de type de données pour créer des variables de structure comportant
le nom, l'âge et la date de naissance du membre. Par exemple:
structurer personne grâce = {"Grâce", 22, 01311980};
160
créerait une structure variable grace pour stocker le nom, l'âge et les données de naissance d'une personne appelée Grace. Ensuite, afin
d'accéder aux membres spécifiques au sein de la variable de structure de personne, utilisez le nom de la variable suivi de l'opérateur point
(.) et du nom du membre. Par conséquent, grace.name, grace.age, grace.DOB feraient respectivement référence au nom, à l'âge et aux
données de naissance de Grace.
POINTEURS
Lors de la programmation du 8051 en assemblage, des registres tels que R0, R1 et DPTR sont parfois utilisés pour stocker les adresses
de certaines données dans un certain emplacement mémoire. Lorsque les données sont accessibles via ces registres, un adressage
indirect est utilisé. Dans ce cas, nous disons que R0, R1 ou DPTR sont utilisés pour pointer vers les données, ce sont donc essentiellement
des pointeurs.
De manière correspondante, en C, l'accès indirect aux données peut être effectué via des variables de pointeur spécialement définies. Les
pointeurs ne sont simplement que des types spéciaux de variables, mais alors que les variables normales sont utilisées pour stocker directement des
données, les variables de pointeur sont utilisées pour stocker les adresses des données. Gardez simplement à l’esprit que, que vous utilisiez des variables
normales ou des variables de pointeur, vous aurez toujours accès aux données à la fin. Il s'agit simplement de savoir si vous allez directement là où elles
sont stockées et récupérez les données, comme dans le cas des variables normales, ou si vous consultez d'abord un répertoire pour vérifier l'emplacement
de ces données avant d'y aller pour les obtenir, comme dans le cas d'un pointeur. variables.
La déclaration d'un pointeur suit le format :
type_données *nom_pointeur ;
où
Type de données fait référence au type de données vers lequel le pointeur pointe
*
indique qu'il s'agit d'une variable de pointeur
nom_pointeur est le nom du pointeur
A titre d'exemple, les déclarations suivantes :

int * numPtr
numéro int ;
numPtr = &num;
déclare d'abord une variable pointeur appelée numPtr qui sera utilisée pour pointer vers des données de type int. La deuxième déclaration
déclare une variable normale et y est placée à des fins de comparaison. La troisième ligne attribue l'adresse de la variable num au pointeur
numPtr. L'adresse de n'importe quelle variable peut être obtenue en utilisant l'opérateur d'adresse &, comme utilisé dans cet exemple.
Gardez à l'esprit qu'une fois attribué, le pointeur numPtr contient l'adresse de la variable num, pas la valeur de ses données.
L'exemple cidessus pourrait également être réécrit de telle sorte que le pointeur soit immédiatement initialisé avec une adresse
lors de sa première déclaration :
numéro int ;
int * numPtr = &num;
Afin d'illustrer davantage la différence entre les variables normales et les variables pointeurs, considérons le
suivant, qui n'est pas un programme C complet mais simplement un fragment pour illustrer notre propos :
numéro int = 7 ;
int * numPtr = &num;
printf ("%d\n", num);
printf ("%d\n", numPtr);
printf ("%d\n", &num);
printf ("%d\n", *numPtr);
161
La première ligne déclare une variable normale, num, qui est initialisée pour contenir les données 7. Ensuite, une variable pointeur, numPtr,
est déclarée, qui est initialisée pour pointer vers l'adresse de num. Les quatre lignes suivantes utilisent la fonction printf(), qui provoque
l'impression de certaines données sur un terminal d'affichage connecté au port série. La première ligne affiche le contenu de la variable
num, qui est dans ce cas la valeur 7. La suivante affiche le contenu du pointeur numPtr, qui est en réalité un nombre étrange qui est
l'adresse de la variable num.
La troisième ligne de ce type affiche également les adresses de la variable num car l'opérateur d'adresse est utilisé pour obtenir l'adresse
de num. La dernière ligne affiche les données réelles vers lesquelles pointe le pointeur numPtr, qui est 7. Le symbole * est appelé opérateur
d'indirection et, lorsqu'il est utilisé avec un pointeur, obtient indirectement les données dont l'adresse est pointée par le pointeur. Par
conséquent, l’affichage de sortie sur le terminal afficherait :
7
13452 (ou un autre numéro bizarre)
13452 (ou un autre numéro bizarre)
7
Type de mémoire d'un pointeur
Rappelezvous que les pointeurs sont également des variables, la question se pose donc de savoir où ils doivent être stockés. Lors de la déclaration
des pointeurs, nous pouvons spécifier différents types de zones mémoire dans lesquelles ces pointeurs doivent se trouver, par exemple :
int * xdata numPtr = & num;
C’est la même chose que nos exemples de pointeurs précédents. Nous déclarons un pointeur numPtr, qui pointe vers des données de type
int stockées dans la variable num. La différence ici réside dans l’utilisation du spécificateur de type de mémoire xdata après le *. Ceci
spécifie que le pointeur numPtr doit résider dans la mémoire de données externe (xdata), et nous disons que le type de mémoire du pointeur
est xdata.
Pointeurs typés
On peut aller encore plus loin en déclarant des pointeurs. Prenons l'exemple :
int données * xdata numPtr = &num;
L'instruction cidessus déclare que le même pointeur numPtr réside dans la mémoire de données externe (xdata), et ce pointeur pointe vers
des données de type int qui sont ellesmêmes stockées dans la variable num dans la mémoire de données interne (data). Le spécificateur
de type de mémoire, data, avant le * spécifie le type de mémoire de données tandis que le spécificateur de type de mémoire, xdata, après
le * spécifie le type de mémoire du pointeur.
Les déclarations de pointeurs dans lesquelles les types de mémoire de données sont explicitement spécifiés sont appelées pointeurs
typés. Les pointeurs typés ont la propriété que vous spécifiez dans votre code où doivent résider les données pointées par les pointeurs. La
taille des pointeurs saisis dépend du type de mémoire de données et peut être d'un ou deux octets.
Pointeurs non typés
Lorsque nous n'indiquons pas explicitement le type de mémoire de données lors de la déclaration des pointeurs, nous obtenons des pointeurs non
typés, qui sont des pointeurs génériques pouvant pointer vers des données résidant dans n'importe quel type de mémoire. Les pointeurs non typés ont
l'avantage de pouvoir être utilisés pour pointer vers n'importe quelle donnée, quel que soit le type de mémoire dans laquelle les données sont stockées.
Tous les pointeurs non typés comportent 3 octets et sont donc plus grands que les pointeurs typés. Les pointeurs non typés sont également généralement
plus lents car le type de mémoire de données n'est pas déterminé ou connu tant que le programme conforme n'est pas exécuté au moment de l'exécution.
Le premier octet des pointeurs non typés fait référence au type de mémoire de données, qui est simplement un nombre selon le tableau
suivant. Les deuxième et troisième octets sont respectivement les octets de poids fort et de poids faible de l'adresse pointée.
Un pointeur non typé est déclaré comme le C normal, où :

int * xdata numPtr = &num;
ne spécifie pas explicitement le type de mémoire des données pointées par le pointeur. Dans ce cas, nous utilisons des pointeurs non typés.
162
Valeurs de type de mémoire de données stockées dans le premier octet de pointeurs non typés
Valeur Type de mémoire de données
1 idata
2 données x
3 pdonnées
4 données/bdonnées
5 code
LES FONCTIONS
En programmant le 8051 en assembleur, nous avons appris les avantages d'utiliser des sousprogrammes pour regrouper des instructions communes
et fréquemment utilisées. Le même concept apparaît dans 8051 C, mais au lieu de les appeler sousprogrammes, nous les appelons fonctions.
Comme en C conventionnel, une fonction doit être déclarée et définie. Une définition de fonction comprend une liste du nombre et des types d'entrées,
ainsi que le type de sortie (type de retour), ainsi qu'une description du contenu interne ou de ce qui doit être fait dans cette fonction.
Le format d'une définition de fonction typique est le suivant :
return_type nom_fonction (arguments) [mémoire] [réentrant] [interruption] [utilisation]

{
…
}
où
return_type fait référence au type de données de la valeur de retour (sortie)

nom_fonction est n'importe quel nom que vous souhaitez appeler la fonction comme
arguments est la liste du type et du nombre de valeurs d'entrée (argument)
mémoire fait référence à un modèle de mémoire explicite (petit, compact ou grand)
réentrante fait référence à si la fonction est réentrante (récursive)
interrompre indique que la fonction est en fait un ISR
en utilisant spécifie explicitement quelle banque de registre utiliser
Prenons un exemple typique, une fonction pour calculer la somme de deux nombres :
somme entière (int a, int b)

{
renvoyer a + b ;
}
Cette fonction est appelée sum et prend deux arguments, tous deux de type int. Le type de retour est également un int, ce qui signifie que la sortie
(valeur de retour) serait un int. Dans le corps de la fonction, délimité par des accolades, nous voyons que la valeur de retour est essentiellement la
somme des deux arguments. Dans notre exemple cidessus, nous avons omis de spécifier explicitement les options : mémoire, réentrant, interruption
et utilisation. Cela signifie que les arguments transmis à la fonction utiliseraient le modèle de petite mémoire par défaut, ce qui signifie qu'ils seraient
stockés dans la mémoire de données interne. Cette fonction est également par défaut non récursive et une fonction normale, pas un ISR. Pendant ce
temps, la banque de registre par défaut est la banque 0.
Passage de paramètres
En 8051 C, les paramètres sont transmis vers et depuis les fonctions et utilisés comme arguments de fonction (entrées). Néanmoins, les détails
techniques sur l'endroit et la manière dont ces paramètres sont stockés sont transparents pour le programmeur, qui n'a pas à se soucier de ces détails
techniques. Dans le 8051 C, les paramètres sont transmis via le registre ou via la mémoire.
Le passage des paramètres via les registres est plus rapide et constitue la manière par défaut de procéder. Les registres utilisés et leur objectif sont
décrits plus en détail cidessous.
163
Registres utilisés dans le passage des paramètres
Nombre d'arguments Char / Pointeur 1 octet INT / Pointeur 2 octets Long/Float Pointeur générique
1 R7 R6 et R7 R4 à R7 R1 à R3
2 R5 R4 et R5 R4 à R7
3 R3 R2 et R3
Comme il n'y a que huit registres dans le 8051, il peut y avoir des situations où nous n'avons pas assez de registres pour passer les
paramètres. Lorsque cela se produit, les paramètres restants peuvent être transmis via des emplacements mémoire fixes. Pour spécifier que
tous les paramètres seront transmis via la mémoire, la directive de contrôle NOREGPARMs est utilisée. Pour spécifier l'inverse, utilisez la
directive de contrôle REGPARMs.
Valeurs de retour
Contrairement aux paramètres, qui peuvent être transmis à l'aide de registres ou d'emplacements mémoire, les valeurs de sortie doivent être
renvoyées par les fonctions via des registres. Le tableau suivant montre les registres utilisés pour renvoyer différents types de valeurs à partir des
fonctions.
Registres utilisés pour renvoyer les valeurs des fonctions

Bit de type de Registre Description
retour Porter le drapeau (C)
char/caractère non signé/pointeur de 1 octet R7

int/non signé int/pointeur 2 octets R6 et R7 long/non MSB en R6, LSB en R7
signé long float R4 à R7 MSB en R4, LSB en R7
R4 à R7 Format IEEE 32 bits
pointeur générique R1 à R3 Type de mémoire en R3, MSB en R2, LSB en R1
164
Annexe C : Tableau de sélection de la série STC89xx

E Interruptions Minuterie
Interne
F S T E externes spéciale Emballer Paquet de
Taper U D Interne La
Tension de
je UN je APC/ W P. pouvant pour 40 broches 44
12T/6T 8051 un UN P. UN/ réinitialisation de la
fonctionnement R. M MLI D R. réveiller le mode broches
MCU s R. T D tension de seuil basse
(V) h M E D/A T Ô mode mise veille et (35 E/S (39 ports
T R. interrompue
peut être
(B) R. M hors mise d'E/S) ports)
(B) configuré tension hors tension
(B)
LQFP/
STC89C51RC 5,5~3,3 4K 512 3 1 2 NNY 4K O N 4 NPDIP
PLCC
LQFP/
STC89C52RC 5,5~3,3 8K 512 3 1 2 NNY 4K O N 4 NPDIP
PLCC
LQFP/
STC89C53RC 5,5~3,3 13K 512 3 1 2 NNY / Oui N 4 NPDIP
PLCC
LQFP/
STC89LE51RC 3,6 ~ 2,0 4K 512 3 1 2 NNY 4K O N 4 NPDIP
PLCC
LQFP/
STC89LE52RC 3,6 ~ 2,0 8K 512 3 1 2 NNY 4K O N 4 NPDIP
PLCC
LQFP/
STC89LE53RC 3,6 ~ 2,0 13K 512 3 1 2 NNY / Oui N 4 NPDIP
PLCC
LQFP/
STC89C54RD+ 5,5~3,3 16K 1280 3 1 2 NNY 45K O N 4 NPDIP
PLCC
LQFP/
STC89C58RD+ 5,5~3,3 32K 1280 3 1 2 NNY 29K O N 4 NPDIP
PLCC
LQFP/
STC89C516RD+ 5,5~3,3 61K 1280 3 1 2 NNY / Oui N 4 NPDIP
PLCC
LQFP/
STC89LE54RD+ 3,6~2,0 16K 1280 3 1 2 NNY 45K O N 4 NPDIP
PLCC
LQFP/
STC89LE58RD+ 3,6~2,0 32K 1280 3 1 2 NNY 29K O N 4 NPDIP
PLCC
LQFP/
STC89LE516RD+ 3,6~2,0 61K 1280 3 1 2 NNY / Oui N 4 NPDIP
PLCC
165

STC89C51RC ETCvf

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

STC89C51RC ETCvf

Transféré par

Droits d'auteur :

Formats disponibles

Machine Translated by Google

MCU série STC89Cxx

STC MCU Limitée

Chapitre 6 Interruption............................................................ ........................78

STC MCU Limitée

1.2 Schéma fonctionnel

AUX­RAM ADRESSE RAM 256 octets

TMP2 TMP1 Minuterie 0/1 FAI/FAI

XTAL1 XTAL2 Ports 0,1,2,3,4

P0, P1, P2, P3, P4

Schéma fonctionnel STC89xx

1.4 Description des broches

MNÉMONIQUE LQFP44 PDIP40 PLCC44 P0.0 ~ P0.7 DESCRIPTION

individuellement, alias T0 et T1.

Dessins du paquet à 1,5 broches

SYMBOLES MIN. NOM MAX.

1 b (sans placage) 0,25 0,30 0,35

L 0,45 0,60 0,75

1. APERÇU JEDEC : MS­026 BSB

LA SAILLIE AUTORISÉE EST

A2 0,015 0,155 0,160

PAQUET D'ENSEMBLE PLCC­44

Avion de sièges DIMENSIONS EN

A2 0,147 ­ 0,158 3.734 ­ 4.013

3. LES DIMENSIONS E ET D D0 N'INCLUENT PAS LE MODE

4. LA DIMENSION b1 NE COMPREND PAS LE DAMBAR

Chapitre 2 GESTION DE L'ÉNERGIE, RÉINITIALISATION

2.1 Gestion de l'alimentation

Registre PCON (registre de contrôle de puissance)

nom SMOD SMOD0 ­ POF GF1 GF0 PD IDL

SMOD : Double débit en bauds de l'interface UART

2.1.1 Mode veille

2.1.2 Mode mise hors tension (PD)

sbit Début_LED = P1^2 ; // L'indicateur Begin­LED indique le démarrage du système

void Normal_Work_Flashing (void);

vide principal (vide)

/* attends plus haut */

void INT1_Routine (void) interruption 2 {

//Is_Power_Down ==1; /* Réveil après mise hors tension sur INT1 */

/* attends plus haut */

/* attends plus haut */

délai nul (vide) {

entier non signé j = 0x00 ; entier non

pour (j=0; j<=30000; ++j) {

vide Normal_Work_Flashing (vide)

MOUVEMENT R3, #0 ;Le mode d'incrémentation de la LED P1 a été modifié

;commence à exécuter le programme

SJMP ATTENDRE1 ;arrêter dynamiquement

2.2 Commande de RÉINITIALISATION

2.2.1 Réinitialiser la broche

2.2.2 Réinitialisation à la mise sous tension (POR)

Registre PCON (registre de contrôle de puissance)

nom SMOD SMOD0 ­ POF GF1 GF0 PD IDL

2.2.3 Chronomètre de surveillance

WDT_CONTR : registre de contrôle Watch­Dog­Timer

peu B7B6 B5 B4 B3 B2B1B0

PS2, PS1, PS0 : Bit de réglage de la valeur de pré­échelle WDT.

Temps de débordement WDT à 20 MHz

Le temps de débordement WDT est déterminé par l'équation suivante :

Si SYSclk=12MHz et MCU en mode 12T, le temps de débordement WDT est :

Temps de débordement WDT à 12 MHz

PS2 PS1 PS0 Temps de débordement WDT pré­échelle à 11,0592 MHz

; Temps de débordement WDT = (N × Pré­échelle × 32768) / SYSclk

AUXRAM ADRESSE RAM 256 octets

1. APERÇU JEDEC : MS026 BSB

PAQUET D'ENSEMBLE PLCC44

A2 0,147 0,158 3.734 4.013

nom SMOD SMOD0 POF GF1 GF0 PD IDL

sbit Début_LED = P1^2 ; // L'indicateur BeginLED indique le démarrage du système

nom SMOD SMOD0 POF GF1 GF0 PD IDL

WDT_CONTR : registre de contrôle WatchDogTimer

PS2, PS1, PS0 : Bit de réglage de la valeur de prééchelle WDT.

PS2 PS1 PS0 Temps de débordement WDT prééchelle à 11,0592 MHz

; Temps de débordement WDT = (N × Prééchelle × 32768) / SYSclk

nom ISPEN SWBS SWRST WT2,WT1,WT0

3.2.1 RAM ScratchPad sur puce

/Testarray : Test_array_one[512], Test_array_two[512] /

4.1 E/S quasibidirectionnelles

4.2 Sortie pushpull

AUXR Registre auxiliaire 0 8EH EXTRA ALEOFF xxxx xx00B

AUXR1 Registre auxiliaire1 A2H CF2 DPS 0xxx 0xx0B