Spaceuit


Informatique Appliquée

Fillière Intelligence Artificielle

Automne 2024

Ali El Hourch
[email protected]


Guide
Nouveau
Assistant AI
Visual Studio Code Google Classroom Whatsapp Whatsapp Discord Discord
Module 1: Probabilités Et Statistiques Module 2: Architecture Des Ordinateurs Module 3: Structure De Données En C Module 4: Système d'exploitation 1 Module 5: Programmation Web 1 Module 6: Langues Etrangéres Module 7: Compétences Culturelles & Artistiques

Semestres

Automne 2024

Tronc Communs

Informatique Appliquée

Assembleur


Série


Comment créer et modifier un fichier d'assembleur sous TASM


  • Pour créer ou modifier un fichier d'assembleur tapez sous DOS:
  • edit NomFichier.asm
  • Vous pouvez ensuite saisir votre code d'assembleur et enregistrer votre fichier comme le montre la vidéo :
  • Pour enregistrer le fichier, appuyez sur ctrl + f, puis faites descendre la barre de contrôle jusqu'à l'option « Save ».

Comment compiler et exécuter les fichiers OBJ


  • Pour compiler un fichier assembly exécuter la commande TASM NomFichier.asm sous DOS.
  • S'il n'y a pas d'erreurs et que le fichier se compile normalement, exécutez la commande TLINK NomFichier.obj pour créer un fichier .exe .
  • Pour exécuter le fichier, il suffit de saisir le nom du fichier avec ou sans l'extension .exe, par exemple :
  • NomFichier
  • Ou
  • NomFichier.exe

Exercice 1


  • Ecrire un programme assembleur qui permet d’afficher le message suivant : « mon premier programme en assembleur ».
  • Indication
    • La fonction 09h de l’interruption 21h permet d’afficher une chaîne de caractères dont l’offset est placé dans le registre DX.
    Correction
      data SEGMENT
          msg DB "mon premier programme en assembleur",'$'
      data ENDS
      
      code SEGMENT
          ASSUME DS: data, CS: code
      
          debut:
              MOV AX, data
              MOV DS, AX
      
              MOV DX, offset msg
              MOV AH, 09h
              INT 21h
      
              MOV AH, 4Ch
              INT 21h
      code ENDS
      END debut
      

Exercice 2


  • Ecrire un programme assembleur qui permet d’afficher le deuxième élément d’un tableau de caractères.
  • Indication
    • La fonction 02h de l’interruption 21h permet d’afficher le caractère dont le code ASCII est placé dans le registre DL.
    Correction
      data SEGMENT
          tableau DB 'a','b','c','d','e'
      data ENDS
      
      code SEGMENT
          ASSUME DS: data, CS: code
      
          debut:
              MOV AX, data
              MOV DS, AX
      
              MOV DL, tableau + 1
              MOV AH, 02h
              INT 21h
      
              MOV AH, 4Ch
              INT 21h
      code ENDS
      END debut
      

Exercice 3


  • Ecrire le programme assembleur correspondant à l’algorithme suivant :
  •             Si al == bl
                Alors écrire « registres égaux »
                Sinon écrire « registres différents » Fsi
    
  • On suppose initialement que chaque registre contient initialement un caractère (Demander au l'utilisateur d'entrer les caractères).
  • Indication
    • La fonction 01h de l’interruption 21h permet de lire et d’afficher la touche tapée au clavier, le code ASCII du caractère lu est dans le registre AL.
    Correction
      data SEGMENT
          msg_entrer DB "Entrer un caractere : ",'$'
          msg_egaux DB "Registres egaux",'$'
          msg_differents DB "Registres differents",'$'
      data ENDS
      
      code SEGMENT
          ASSUME DS: data, CS: code
      
          debut:
              ; Initialiser le segment de données
              MOV AX, data
              MOV DS, AX
      
              ; Lire le premier caractère
              MOV DX, offset msg_entrer
              MOV AH, 09h
              INT 21h
      
              ; Lire le caractère saisi par l'utilisateur
              MOV AH, 01h
              INT 21h
              MOV CL, AL ; Conserver le caractère dans CL
      
              ; Ajouter un retour à la ligne
              MOV DL, 0Ah ; 0Ah est le code ASCII pour retour à la ligne
              MOV AH, 02h ; Fonction pour afficher un caractère
              INT 21h
      
              ; Lire le deuxième caractère
              MOV DX, offset msg_entrer
              MOV AH, 09h
              INT 21h
      
              ; Lire le caractère saisi par l'utilisateur
              MOV AH, 01h
              INT 21h
              MOV BL, AL ; Conserver le caractère dans BL
      
              ; Ajouter un retour à la ligne
              MOV DL, 0Ah
              MOV AH, 02h
              INT 21h
      
              ; Comparer les deux caractères
              MOV AL, CL ; Charger le premier caractère
              CMP AL, BL
              JE egaux ; Sauter à "egaux" si AL == BL
              JNE differents ; Sauter à "differents" si AL != BL
      
              egaux:
                  ; Afficher le message "Registres égaux"
                  MOV DX, offset msg_egaux
                  MOV AH, 09h
                  INT 21h
      
                  ; Fin du programme
                  MOV AH, 4Ch
                  INT 21h
      
              differents:
                  ; Afficher le message "Registres différents"
                  MOV DX, offset msg_differents
                  MOV AH, 09h
                  INT 21H
      
                  ; Fin du programme
                  MOV AH, 4Ch
                  INT 21h
      code ENDS
      END debut
      

Exercice 4


  • Ecrire un programme assembleur qui demande d'entrer 2 caractères, permet d’échanger et d’afficher le contenu des registres AL et BL.
  • Correction
      data SEGMENT
              msg_entrer DB "Entrer un caractere: ",'$'
              msg_apres DB "Apres permutation: ",'$'
              msg_al DB "AL = ",'$'
              msg_BL DB "BL = ",'$'
      data ENDS 
      
      code SEGMENT
              ASSUME DS: data, CS: code
      
              debut:
                      ; Initialiser le segment de données
                      MOV AX, data
                      MOV DS, AX
      
                      ; Demander à l'utilisateur d'entrer le premier caractère
                      MOV AH, 09h
                      MOV DX, offset msg_entrer
                      INT 21H
      
                      ; Lire le premier caractère saisi par l'utilisateur
                      MOV AH, 01h
                      INT 21h
                      MOV CL, AL ; Sauvegarder le caractère dans CL
      
                      ; Ajouter un saut de ligne
                      MOV AH, 02h
                      MOV DL, 0Ah
                      INT 21H
      
                      ; Demander à l'utilisateur d'entrer le deuxième caractère
                      MOV AH, 09h
                      MOV DX, offset msg_entrer
                      INT 21h
      
                      ; Lire le deuxième caractère saisi par l'utilisateur
                      MOV AH, 01h
                      INT 21h
                      MOV BL, AL ; Sauvegarder le caractère dans BL
      
                      ; Ajouter un saut de ligne
                      MOV AH, 02h
                      MOV DL, 0Ah
                      INT 21h
      
                      ; Afficher le message "Après permutation"
                      MOV AH, 09h
                      MOV DX, offset msg_apres
                      INT 21h
      
                      ; Ajouter un saut de ligne
                      MOV AH, 02h
                      MOV DL, 0Ah
                      INT 21h
      
                      ; Échanger les deux caractères
                      MOV AL, CL
                      XCHG AL, BL
      
                      ; Afficher le message "AL = "
                      MOV AH, 09h
                      MOV DX, offset msg_al
                      INT 21h
      
                      ; Afficher la valeur de AL
                      MOV AH, 02h
                      MOV DL, AL
                      INT 21h
      
                      ; Ajouter un saut de ligne
                      MOV AH, 02h
                      MOV DL, 0Ah
                      INT 21H
      
                      ; Afficher le message "BL = "
                      MOV AH, 09h
                      MOV DX, offset msg_BL
                      INT 21h
      
                      ; Afficher la valeur de BL
                      MOV AH, 02h
                      MOV DL, BL
                      INT 21h
      
                      ; Fin du programme
                      MOV AH, 4Ch
                      INT 21h
      code ENDS
      END debut
      

Exercice 5


  • Écrire un programme assembleur qui permet de lire une chaîne de caractères en minuscule, la convertir en une chaîne de caractère en majuscule et de l’afficher.
  • Indication
    • La fonction 0Ah de l’interruption 21h permet de lire une chaîne de caractères, l’offset de la chaîne lue est placé dans le registre DX.
    Correction
      data SEGMENT
          msg db 20 dup('?'), '$' ; Zone mémoire pour la chaîne saisie, terminée par '$'
          msg_entrer db "Veuillez entrer une chaine de caracteres : ",'$' ; Message d'invite
      data ENDS
      
      code SEGMENT
          ASSUME DS: data, CS: code
      
          debut:
              ; Initialisation du segment de données
              MOV AX, data
              MOV DS, AX
      
              ; Affichage du message d'invite
              MOV DX, offset msg_entrer
              MOV AH, 09H
              INT 21H
      
              ; Ajouter un saut de ligne
              MOV DL, 0AH
              MOV AH, 02H
              INT 21H
      
              ; Lecture de la chaîne saisie par l'utilisateur
              MOV DX, offset msg
              MOV AH, 0AH
              INT 21H
      
              ; Conversion des caractères en majuscules
              MOV BX, offset msg
          boucle:
              MOV CL, [BX] ; Charger le caractère actuel
              CMP CL, '$' ; Vérifier le terminateur
              JE affiche ; Sauter à l'affichage si fin de chaîne
              AND CL, 11011111b ; Convertir en majuscule
              MOV [BX], CL ; Sauvegarder le caractère converti
              INC BX ; Passer au caractère suivant
              JMP boucle ; Répéter
      
          affiche:
              ; Ajouter un saut de ligne
              MOV DL, 0AH
              MOV AH, 02H
              INT 21H
      
              ; Afficher la chaîne convertie
              MOV AH, 09H
              MOV DX, offset msg
              INT 21H
      
              ; Fin du programme
              MOV AH, 4CH
              INT 21H
      code ENDS
      END debut
      

Exercice 6


  • Écrire un programme assembleur qui permet de lire et d’afficher des caractères tant que le caractère lu est différent de ‘$’.
    Indication
    • La fonction 01h de l’interruption 21h permet de lire et d’afficher la touche tapée au clavier, le code ASCII du caractère lu est dans le registre AL.
    Correction
      data SEGMENT
          msg_entrer DB "Entrer un caractère : ",'$' ; Message d'invite pour entrer un caractère
          msg_lu DB "Caractère lu : ",'$' ; Message affiché après lecture
      data ENDS
      
      code SEGMENT
          ASSUME DS: data, CS: code
      
          debut:
              ; Initialiser le segment de données
              MOV AX, data
              MOV DS, AX
      
          boucle:
              ; Afficher le message d'invite
              MOV DX, offset msg_entrer
              MOV AH, 09H
              INT 21H
              
              ; Lire un caractère de l'utilisateur
              MOV AH, 01H
              INT 21H
              MOV BL, AL ; Sauvegarder le caractère lu dans BL
      
              ; Ajouter un saut de ligne
              MOV DL, 0AH
              MOV AH, 02H
              INT 21H
      
              ; Afficher le message "Caractère lu"
              MOV DX, offset msg_lu
              MOV AH, 09H
              INT 21H
          
              ; Afficher le caractère lu
              MOV DL, BL
              MOV AH, 02H
              INT 21H
      
              ; Ajouter un saut de ligne
              MOV DL, 0AH
              MOV AH, 02H
              INT 21H
      
              ; Vérifier si le caractère est '$'
              CMP BL, '$'
              JNE boucle ; Répéter si ce n'est pas '$'
              
              ; Fin du programme
              MOV AH, 4CH
              INT 21H
      code ENDS
      END debut