Advertisement
Guest User

TP1_ELN3

a guest
May 21st, 2019
163
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ;CHAURAY CHABOT
  2. ;-----------------------------------------------------------------------------
  3. ;  FILE NAME   :  EXO_SM1.asm
  4. ;  TARGET MCU  :  C8051F020
  5. ;  DESCRIPTION :  Cette suite d'exercices de base est destinée à faire
  6. ;                 découvrir le jeu d'instruction de la famille 8051.
  7. ;                 Insérez votre code sous chaque exercice.
  8. ;                 A la fin de la séance, vous rendrez ce fichier via E-campus
  9. ;                 ou par Email à l'adresse que l'on vous communiquera
  10. ;                
  11. ;******************************************************************************
  12. ;******************************************************************************
  13. ; NE PAS MODIFIER LES DIRECTIVES et INSTRUCTIONS SUIVANTES:
  14. ;******************************************************************************
  15. $include (c8051f020.inc)               ; Include register definition file.
  16. ;-----------------------------------------------------------------------------
  17. ; EQUATES
  18. ;-----------------------------------------------------------------------------
  19. GREEN_LED      equ   P1.6              ; Port I/O pin connected to Green LED.
  20. ;-----------------------------------------------------------------------------
  21. ; RESET and INTERRUPT VECTORS
  22. ;-----------------------------------------------------------------------------
  23.  
  24.                ; Reset Vector
  25.                cseg AT 0
  26.                ljmp Main               ; Locate a jump to the start of code at
  27.                                       ; the reset vector.
  28.  
  29. ;-----------------------------------------------------------------------------
  30. ; CODE SEGMENT
  31. ;-----------------------------------------------------------------------------
  32. Blink          segment  CODE
  33.  
  34.                rseg     Blink        ; Switch to this code segment.
  35.                using    0            ; Specify register bank for the following
  36.                                     ; program code.
  37.  
  38. Table_ex:          db  'VOILA UN EXEMPLE DE CHAINE A COPIER!!!'
  39.  
  40. ;Initialisations de périphériques - Fonctionnalités Microcontroleur
  41.  
  42. Main:          ; Disable the WDT. (IRQs not enabled at this point.)
  43.               ; If interrupts were enabled, we would need to explicitly disable
  44.               ; them so that the 2nd move to WDTCN occurs no more than four clock
  45.               ; cycles after the first move to WDTCN.
  46.                mov   WDTCN, #0DEh
  47.                mov   WDTCN, #0ADh
  48.               ; Enable the Port I/O Crossbar
  49.                mov   XBR2, #40h
  50.               ; Set P1.6 (LED) as digital output in push-pull mode.  
  51.                orl   P1MDIN, #40h    
  52.                orl   P1MDOUT,#40h
  53. ; Programme Principal
  54. ;******************************************************************************
  55. ;******************************************************************************
  56. ; VOUS POUVEZ FAIRE des MODIFICATIONS A PARTIR D'ICI
  57. ;******************************************************************************
  58.  
  59.  
  60. ;EXO 1 : INSTRUCTIONS DE TRANSFERT DE DONNEES
  61.  
  62.                 clr A;1.    Initialiser l'accumulateur à 0 (coder les 3 solutions possibles), le registre R0 à FFh et la case d'adresse mémoire 40h de la mémoire RAM interne à 55h.
  63.                 mov R0, #0FFh
  64.                 mov 40h, #55h
  65.                
  66.                 mov R1, A;2.    Copier le contenu de l'accumulateur dans le registre R1.
  67.  
  68.                 mov 42h, 40h;3. Copier le contenu de la mémoire 40h de la RAM interne dans la case 42h de la RAM Interne.
  69.  
  70.                 mov R1, #0D0h;4.    Copier le contenu de la mémoire 40h de la RAM interne dans la case D0h de la RAM Interne à accès indirect. Que se passe-t-il si on utilise par erreur l'adressage direct sur D0h?
  71.                 mov @R1, 40h
  72.  
  73.  
  74. ;EXO 2 : MANIPULATION DES ESPACES MEMOIRES
  75.  
  76.                 mov A, 20h;1.   Copier le contenu de 20h (DATA) dans la case mémoire 2FFh en mémoire RAM externe (XDATA).
  77.                 mov dptr, #2FFh
  78.                 movx @dptr, A
  79.  
  80.                 mov dptr, #0 ;2.    Copier le contenu de 0000h (CODE) dans la case mémoire 82h en mémoire RAM interne.
  81.                 clr A
  82.                 movc A, @A+dptr
  83.                 mov R0, #82h
  84.                 mov @R0, A
  85.  
  86.                 mov dptr, #0100h;3. Copier le contenu de la mémoire 0100h de la XDATA dans la case 43h de la RAM Interne.
  87.                 movx A,@dptr
  88.                 mov 43h, A
  89.  
  90.                 mov dptr, #1234h ;4.    Copier le contenu de la mémoire 1234h de la mémoire CODE dans la case 0102h de la mémoire XDATA.
  91.                 clr A
  92.                 movc A, @A+dptr
  93.                 mov dptr, #102h
  94.                 movx @dptr, A
  95.  
  96.  
  97. ;EXO 3 : INSTRUCTIONS ARITHMETIQUES - ARITHMETIQUE NON SIGNEE
  98.  
  99.                 inc A;1.    Incrémenter l'accumulateur de 1.
  100.  
  101.                 dec 33h;2.  Décrémenter de 1 l'octet d'adresse 33h de la RAM Interne.
  102.  
  103.                 mov dptr, #07FFh;3. Echanger le contenu de B avec le contenu de la mémoire 07FFh en mémoire externe (XDATA).
  104.                 movx A, @dptr
  105.                 xch A, B
  106.                 movx @dptr, A
  107.                
  108.                 xch A, 60h;4.   En une ligne de code, échanger le contenu de A avec le contenu de la mémoire 60h.
  109.  
  110.  
  111.  
  112. ;EXO 4 : INSTRUCTIONS LOGIQUES - MANIPULATION de BITS
  113.  
  114.                 cpl 10h ;1. Complémenter le bit d'adresse 10h. Ou se trouve-t-il ? (c'est le bit X de l'octet d'adresse YY dans la mémoire DATA).
  115.  
  116.                 orl 22h, #81h;2.    Mettre à 1, les bits 0 et 7  de l'octet d'adresse 22h de la RAM interne (sans changer les autres bits).
  117.  
  118.                 mov A, R0 ;3.   Mettre à 1, les bits 0 et 7 du registre R0 (sans changer les autres bits).
  119.                 orl A, #81h
  120.                 mov R0, A
  121.                
  122.  
  123.                 mov dptr, #07FFh ;4.    Mettre à 1, les bits 0 et 7 de l'octet d'adresse 07ffh de la XDATA (sans changer les autres bits)
  124.                 movx A, @dptr
  125.                 orl A, #81h
  126.                 movx @dptr, A
  127.  
  128.  
  129.  
  130. ;EXO 5 : INSTRUCTIONS DE SAUT CONDITIONNEL ET INCONDITIONNE
  131.  
  132.                 mov R3, #01h;1. Placez une valeur quelconque dans R3, incrémentez la jusqu'à ce qu'elle atteigne la valeur B6h (pensez à initialiser R3).
  133. INCR:           inc R3
  134.                 cjne R3, #0B6h, INCR
  135.                
  136.                 mov A, #'A';2.  Remplir la mémoire RAM interne de l'adresse 20h à 40h avec des codes ASCII égrainant l'alphabet.
  137.                 mov R0, #20h
  138. ALPHA:          mov @R0, A
  139.                 inc R0
  140.                 inc A
  141.                 cjne R0, #40h+1, ALPHA
  142.                
  143.  
  144.                 mov dptr, #0000h;3. Lire le contenu de l'adresse 0000h à 0002h dans l'espace code et le copier à l'adresse 0000h à 0002h de l'espace XDATA.
  145. BOUCLE:         clr A
  146.                 movc A, @A+dptr
  147.                 movx @dptr, A
  148.                 inc dptr
  149.                 mov A, dpl
  150.                 cjne A, #03h, BOUCLE
  151.  
  152.  
  153. ;EXO 6 : MANIPULATION DES BANCS de REGISTRES R0-R7
  154.  
  155.                 clr RS0
  156.                 setb RS1 ;1.    Commuter le banc de registres R0-R7 sur le banc 2 et copier le contenu de A dans le registre R4 sans utiliser "R4" dans l'instruction.
  157.                 mov 14h, A
  158.  
  159.                 setb RS0 ;2.    Mettre à zéro la case d'adresse 08h de la ram interne en utilisant un adressage par registre (utiliser un registre R0...R7).
  160.                 clr RS1
  161.                 mov R0, #00h
  162.  
  163.  
  164.  
  165. ;EXO 7 : INSTRUCTIONS LOGIQUES - MANIPULATION de BITS - 2
  166.                 mov A, B;1. Décaler le registre B d'une case vers la gauche, le bit6 devient bit7, le bit5 devient bit6, etc. le bit7 devient bit0.
  167.                 rl A
  168.                 mov B, A
  169.  
  170.                 mov dptr, #0F0Fh;2. Exécuter une rotation logique gauche sur le DPTR, le bit 15 devient le bit 0. (Initialiser auparavant le DPTR avec la valeur 0F0Fh).
  171.                 mov A, dph
  172.                 rlc A
  173.                 mov 24h, A
  174.                 mov 18h, C
  175.                 mov A, dpl
  176.                 rlc A
  177.                 mov 25h, A
  178.                 mov 28h, 18h
  179.                 mov 20h, C
  180.                
  181.                
  182.  
  183.  
  184. ;EXO 8 : INSTRUCTIONS ARITHMETIQUES - Arithmétique non signée - 2
  185.  
  186.                 mov dptr, #100h ;1. Incrémenter de 2 la case mémoire RAM externe d'adresse 100h.
  187.                 movx A, @dptr
  188.                 add A, #02h
  189.                 movx @dptr, A
  190.  
  191.                 mov A, 22h ;2.  Multiplier les données en RAM interne d'adresse 22h et 23h. Placer le résultat en 24h(LSB) et 25h(MSB).
  192.                 mov B, 23h
  193.                 mul AB
  194.                 mov 24h, A
  195.                 mov 25h, B
  196.  
  197.  
  198.  
  199. ;EXO 9 : INSTRUCTIONS DE SAUT CONDITIONNEL ET INCONDITIONNEL - 2
  200.  
  201.                 mov A, #'A' ;1. Remplir la mémoire RAM externe (XDATA) de l'adresse 120h à 140h avec des codes ASCII égrainant l'alphabet.
  202.                 mov dptr, #120h
  203. ALPAB:          movx @dptr, A
  204.                 inc dptr
  205.                 inc A
  206.                 mov R0, dpl
  207.                 cjne R0, #41h, ALPAB
  208.  
  209. ;2. Incrémentez le DPTR initialisé avec une valeur quelconque jusqu'à la valeur de ABCDh.
  210.                
  211.                 mov dptr, #42h
  212. TEST:           inc dptr
  213.                 mov A, dph
  214.                 cjne A, #0ABh, TEST
  215. TESTT:          inc dptr
  216.                 mov A, dpl
  217.                 cjne A, #0CDh, TESTT
  218.                
  219.  
  220.  
  221. ;EXO 10 : Exercices d'approfondissement - FACULTATIF
  222.  
  223.                 mov A, R6;1.    Additionner les registres R6 et R7, stocker le résultat dans R5. Quelles sont les limitations ? Pour s'affranchir des limitations précédentes, refaire la même opération mais stocker le résultat dans R4 (LSB) et R5(MSB).
  224.                 addc A, R7
  225.                 mov R4, A
  226.                 mov 38h, C
  227.                 mov R5, 27h
  228.  
  229.                 mov A, R0;2.    Faire l'opération R0 moins R1 et placer le résultat dans R7. Que se passe t'il si R1>R0 ?
  230.                 subb A, R1
  231.                 mov R7, A
  232.                
  233.                 cpl 50h;3.  Complémenter le demi-octet de pds faible de l'adresse 2Ah de la RAM interne.
  234.                 cpl 51h
  235.                 cpl 52h
  236.                 cpl 53h
  237.  
  238.                 mov R3, #77h;4. Placez une valeur quelconque dans R3, décrémentez la, jusqu'à ce qu'elle atteigne une valeur contenue dans R6 (pensez à initialiser R3 et R6).
  239.                 mov R6, #12h
  240. DECR:           dec R3
  241.                 mov A, R3
  242.                 mov 2Dh, R6
  243.                 cjne A, 2Dh, DECR              
  244.  
  245.                 mov R4, #0Fh;5. Initialiser les registres R4 et R5 respectivement avec les valeurs 0Fh et F5h. Faites un OU Exclusif entre ces deux registres et placez le résultat dans l'accumulateur.
  246.                 mov R5, #0F5h
  247.                 mov A, R5
  248.                 xrl A, R4
  249.  
  250.                 mov A, 44h ;6.  Stocker le demi-octet de poids faible de la case mémoire d'adresse 44h de la RAM interne dans les deux demi-octets du registre R4 (si la case 44h contient 17h, alors R4 devra contenir 77h).
  251.                 anl A, #0Fh
  252.                 mov R6, A
  253.                 rl A
  254.                 rl A
  255.                 rl A
  256.                 rl A
  257.                 add A, R6
  258.                 mov R4, A
  259.  
  260.                 mov A, R0 ;7.   Elever au carré le contenu de l'octet 12h, placer le résultat dans R0 (pds fort) et R1 (pds faible).
  261.                 mov B, R0
  262.                 mul AB
  263.                 mov R0, B
  264.                 mov R1, A
  265.  
  266.                 ;8. Soit 2 nombres BCD de 16 bits (valeur 0 à 9999) stockés respectivement dans R0(MSB)-R1(LSB) et R2(MSB)-R3(LSB). Faire l'addition BCD de ces deux nombres, et stocker le résultat dans R4(MSB)-R5(LSB). La retenue sera dans le bit Carry du registre PSW.
  267.  
  268. ;9. Compter le nombre de bits à 1 dans le registre B et stocker le résultat dans R5.
  269.  
  270. ;10. Diviser le contenu du registre R7 par le nombre 10, placer le quotient dans R5 et le reste dans R6.
  271.  
  272.  
  273.  
  274.  
  275. ;******************************************************************************
  276. ;******************************************************************************
  277. ; NE PAS MODIFIER LES DIRECTIVES et INSTRUCTIONS SUIVANTES:
  278. ;******************************************************************************
  279.  
  280. bcl:   jmp bcl
  281. ;-----------------------------------------------------------------------------
  282. ; End of file.
  283.  
  284. END
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement