Spaceuit Logo Spaceuit Plateforme Éducative

Informatique Appliquée

Fillière Intelligence Artificielle

Hiver 2025

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

Hiver 2025

Tronc Communs

Informatique Appliquée

Examen d'Architecture des ordinateurs SMI (S4) Juillet 2024

Questions de cours

  1. Comment calculer l'adresse physique d'un octet d'adresse xxxx:yyyy ?
    2. Correction
    • L'adresse physique/effective de l'adresse xxxx:yyyy octet est calculer par la formule suivante : 
      • Adresse physique = xxxx x 16 + yyyy
  2. Donner l'équivalent de l'adresse 0000:0042 dans le segment num 3 et dans le segment num 4 :
    3. Correction
    • On sait que : 
      •         Adresse physique = segment x 16 + offset
    • Donc le segment num 0 :
      •         Adresse physique = 0 x 16 + 42 = 42)16 = 66)10
    • Alors l'équivalent de ce adresse (octet numéro 66) pour le segment num 3 et 4 sont :
      •         66 = 3 x 16 + offset ⇒ offset = 18)10 = 12)16  
                                
              66 = 4 x 16 + offset ⇒ offset = 2)10 = 2)16
    • D'où l'équivalent de l'adresse 0000:0042 dans le segment num 3 est : 0003:0012 et dans le segment num 4 est : 0004:0002 .
  3. A quoi sert le registre IP?
    4. Correction
    • Le registre IP conserve l'adresse de l'instruction suivante à exécuter.

Exercice 1

  • Donner les commandes debug qui permettent de faire les taches suivantes :
    • Affichez le contenu de la mémoire à l'adresse par défaut en tant que :
      • Octets en hexa décimal
      • Octets en ASCII
      Correction
      • Pour afficher le contenu de la mémoire à l'adresse par défaut en hexa décimal et ASCII, il faut utiliser la commande :
        • d
    • Affichez le contenu de la mémoire à l'adresse par défaut en tant qu'instructions :
      • Correction
      • Pour afficher le contenu de la mémoire à l'adresse par défaut en tant qu'instructions, il faut utiliser la commande :
        • u
    • Remplissez de 00 le premier Ko du segment de travail. :
      • Correction
      • On a : 1Ko = 1024 octets, ce qui correspond à 400 en hexadécimal. Ainsi, pour remplir 1Ko, il faut remplir de l'offset de départ jusqu'à (départ + 400 - 1). Selon le professeur qui enseigne ce cours de 2022 à 2025, le segment commence à l'offset 0100. Par conséquent, pour remplir 1Ko, on remplit de 0100 à 400. Le segment de travail étant 073F, la commande pour remplir de 00 de 073F:0100 à 073F:0400 est : 
        •     f 073F:0100 0400 00
      • Remarque : Cette réponse dépend de l'enseignant. Certains documents indiqueraient que le segment débute à 0000 (donc de 0000 à 03FF pour 1Ko), mais selon le professeur en charge de ce cours (2022-2025), le segment commence à 0100, ce qui modifie la plage de remplissage.
    • Placez les caractères "SMIS4" au début du segment de travail :
      • Correction
      • Supposons que le segment de travail est 073F, donc le debut du segment est 073F:0100. Pour placez les caractères "SMIS4" il faut utiliser la commande : 
        • e 073F:0100 "SMIS4"
    • Vérifiez que ces caractères sont bien rangés en mémoire :
      • Correction
      • Pour vérifier si ces caractères sont bien rangés en mémoire, il faut utiliser la commande :
        • d 0100

Exercice 2

  • Écrire un programme assembleur qui permet de lire et d'afficher des caractères tant que le caractère lu est différent de '$'
    • Correction 
      data SEGMENT
    msg_entrer DB "Pour terminer, tapez dollar. Saisir un caractère : ",'$' ; Message d'invite pour entrer un caractère
    msg_lu DB "Caractere lu est : ",'$' ; 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

        ; Vérifier si le caractère est '$'
        CMP BL, '$'
        JE fin ; Quitter si c'est '$'

        ; 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

        JMP boucle ; Répéter

    fin:
        ; Fin du programme
        MOV AH, 4Ch
        INT 21h
code ENDS
END debut

Exercice 3

  • Ecrire un programme assembleur qui lit autant de caractères majuscule qu'on veut. Chaque caractère lu est converti en miniscule et affiché.
  • Utiliser deux procédures "lire_caractere" et "converti_caractere" qui permettent respectivement de lire un caractère et convertir un caractère majuscule en miniscule.
    • Correction 
      data SEGMENT
    msg_entrer DB "Veuillez vous entrer un caractere majuscule? 'O' si oui : ",'$' ; Message d'invite
    msg_maj DB "Caractere majuscule : ",'$' ; Message pour majuscule
    msg_min DB "Caractere miniscule : ",'$' ; Message pour minuscule
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 le caractère
        CALL lire_caractere

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02h
        INT 21h

        ; Vérifier si le caractère est 'O'
        AND BL, 11011111b
        CMP BL, 'O'
        JNE fin

        ; Afficher le message pour majuscule
        MOV DX, offset msg_maj
        MOV AH, 09h
        INT 21h

        ; Lire un autre caractère
        CALL lire_caractere

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02H
        INT 21H

        ; Convertir le caractère en minuscule
        CALL converti_caractere

        ; Afficher le message pour minuscule
        MOV DX, offset msg_min
        MOV AH, 09h
        INT 21h

        ; Afficher le caractère converti
        MOV DL, BL
        MOV AH, 02H
        INT 21H

        ; Ajouter un saut de ligne
        MOV DL, 0AH
        MOV AH, 02H
        INT 21H

    JMP boucle ; Répéter

    fin:
        ; Fin du programme
        MOV AH, 4Ch
        INT 21h

    lire_caractere PROC NEAR
        ; Lire un caractère et le sauvegarder dans BL
        MOV AH, 01H
        INT 21H
        MOV BL, AL
        RET
    lire_caractere ENDP

    converti_caractere PROC NEAR
        ; Convertir le caractère en minuscule
        OR BL, 00100000b
        RET
    converti_caractere ENDP
code ENDS
END debut

Exercice 4

  • Ecrire un programme assembleur qui permet de voir si un caractère miniscule figure dans une chaine de caractères miniscules ou non et si le caractère existe, il le convertit en majuscule dans la chaîne.
    La chaîne et le caractère doivent être initialement lus.
    • Correction 
      data SEGMENT
    msg_chaine DB "Entrer une chaine : ",'$' ; Message pour entrer une chaîne
    msg_caractere DB "Saisir un caractere miniscule : ",'$' ; Message pour entrer un caractère minuscule
    chaine DB 20 dup('?'),'$' ; Réservation pour la chaîne
data ENDS

code SEGMENT
    ASSUME DS:data, CS:code

    debut:
        ; Initialiser le segment de données
        MOV AX, data
        MOV DS, AX

        ; Afficher le message pour entrer une chaîne
        MOV DX, offset msg_chaine
        MOV AH, 09h
        INT 21h

        ; Lire la chaîne
        MOV DX, offset chaine
        MOV AH, 0Ah
        INT 21h

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02h
        INT 21H

        ; Afficher le message pour entrer un caractère
        MOV DX, offset msg_caractere
        MOV AH, 09H
        INT 21H

        ; Lire le caractère à rechercher
        MOV AH, 01H
        INT 21H
        MOV CL, AL

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02H
        INT 21H

        ; Parcourir la chaîne
        MOV BX, offset chaine
        boucle:
            ; Lire un caractère de la chaîne
            MOV AL, [BX]
            CMP AL, '$'
            JE fin

            ; Comparer avec le caractère entré
            CMP CL, AL
            JE convertit
            INC BX
            JMP boucle

        convertit:
            ; Convertir le caractère en majuscule
            AND CL, 11011111b
            MOV [BX], CL
            INC BX
            JMP boucle

    fin:
        ; Fin du programme
        MOV AH, 4Ch
        INT 21h
code ENDS
END debut