Discussion :

[HKati]

Bonjour

SVP,Je veux que vous m'aidez pour faire cette exercice:
Afficher 10 fois le message bonjour
Voici l'affichage pour une seule fois,mais je ne sais bien comment utiliser LOOP

ORG 100h
MOV AX, 0B800h
MOV DS, AX
MOV [02h], 'B'
MOV [04h], 'o'
MOV [06h], 'n'
MOV [08h], 'j'
MOV [0Ah], 'o'
MOV [0Ch], 'u'
MOV [0Eh], 'r'
MOV [10h], ','
RET

Et merci bcp

[Forthman]

Bonjour,

LOOP décrémente CX, contrôle si ce dernier =0, et si ce n'est pas le cas fais un jump à l'adresse indiquée.
Si le résultat =0, alors l'exécution se continue après la ligne loop.
il faut donc que CX contienne le compteur de boucles, et que ce dernier ne soit pas modifié pendant la boucle.
petit exemple pour la forme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
mov cx,4
debut_boucle:
nop
loop debut_boucle

Tout ce qui se trouve entre "debut_boucle:" et "loop debut_boucle" sera exécuté 4 fois, puis le programme
continuera après la ligne loop.

par contre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
debut_boucle:
mov cx,4
nop
loop debut_boucle

provoque une boucle sans fin car CX est initialisé à 4 pendant la boucle, donc arrivé sur le loop qui
fait CX=CX-1 le résultat sera toujours 3 et ne passera donc jamais à 0, bouclant pour toujours, et jusqu'à la fin des temps (oui, enfin presque )

[HKati]

bonjour!
merci pour votre reponse mais le probleme que le message s'affiche une seule fois par contre il boucle 10 fois. qu'est ce qu'on doit faire alors? et pour nop quel est son role?

[Invité]

Salut et bienvenue dans le monde de l'asm 16-bit ^^

nop ne fait rien du tout, c'est une instruction pour rien, si tu veut savoir ce que font les instructions, je te conseil de lire les volumes 2A 2B 2C de la doc intel: http://www.intel.com/content/www/us/...r-manuals.html où ça reference toutes les instruction du cpu intel.

(Merci bufferbob, j'ai corrigé mon code)
Et pour ton probème tu fait juste (balise code [ CODE ] [ /CODE ])

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
[BITS  16]
[ORG  0x100]
;======================================================================================================================================================================================
;CODE   CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE
;======================================================================================================================================================================================
source:
;{
    mov     ax, 0xB800
    mov     ds, ax
 
    xor     bx, bx
    mov     cx, 10
    loop_display:
   ;{
        mov     [ds:bx], byte 'B'
        add     bx, 2
 
        mov     [ds:bx], byte 'o'
        add     bx, 2
 
        mov     [ds:bx], byte 'n'
        add     bx, 2
 
        mov     [ds:bx], byte 'j'
        add     bx, 2
 
        mov     [ds:bx], byte 'o'
        add     bx, 2
 
        mov     [ds:bx], byte 'u'
        add     bx, 2
 
        mov     [ds:bx], byte 'r'
        add     bx, 2
 
        mov     [ds:bx], byte ','
        add     bx, 2
   ;}
    loop    loop_display
 
    ret
;}
;======================================================================================================================================================================================
;END_CODE   END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE
;======================================================================================================================================================================================

Comme tu l'a vu, je me suis permis d'ajouter quelques modification, car en mode 16 bit, on ne peut adresser la mémoire directement, obligée de passer par un selecteur de segment et un offset (segment(ds/es/ss)) * 16 + offset (bx, bp, si, di))

[BufferBob]

salut,

@glojii, ton programme ne fera qu'afficher 10x "bonjour," au même endroit

une solution pour afficher plusieurs fois le message à la suite il convient de faire intervenir un autre registre, par exemple SI, qu'on incrémentera tout le long de l'affichage, toujours avec des instructions simples et sans trop compliquer le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
org 100h
   mov ax, 0xB800
   mov ds, ax
 
   mov si, 0
   mov cx, 10
boucle:
   mov [si], byte 'B'
   add si, 2
   mov [si], byte 'o'
   add si, 2
   mov [si], byte 'n'
   add si, 2
   mov [si], byte 'j'
   add si, 2
   mov [si], byte 'o'
   add si, 2
   mov [si], byte 'u'
   add si, 2
   mov [si], byte 'r'
   add si, 2
   mov [si], byte ','
   add si, 2
   loop boucle
   ret

une stratégie plus intéressante consistera néanmoins à afficher la chaine en une seule fois plutôt que caractère par caractère

[Invité]

BufferBob > Sauf que l'ont peut pas afficher en une seul fois, car dans l'exemple, on est limité dans des déplacement 16 bit (2 octets).

Il faudrait passer par une function qui prend juste le pointeur du début d'une chaine de caractère et faire un mov de chaque caracteres de cette chaine à partir de [0xB8000] avec un incrémentation de 2.

[Forthman]

@ glogii : le segment pris par défaut pour l'adressage est DS, donc pas besoin de le spécifier si c'est celui-ci

Le message s'affiche bien 10 fois, au même endroit, certe, mais il s'affiche bien 10 fois
c'est un exo, alors il est hors de question que je le fasse pour toi par contre, aucun problème pour t'amener à "une" solution
(oui, car en asm des solutions, il y en a souvent des tas)

Puisque l'adresse vidéo est B800h, j'en déduis que tu es en mode texte 80x25 (le plus standard des modes texte)
chaque caractère occupe 2 octets, 1 pour le code ASCII et 1 pour son code couleur
D'ailleurs il se pourrait que ton code n'affiche rien du tout car le code couleur n'est pas indiqué, et du coup s'il est = à 0 c'est du noir sur noir

donc... 80 colonne de 2 octets = 160 octets tu peux donc (ce que je ferais) incrémenter de 10 le segment après chaque affichage, ce qui aura pour conséquence
de passer à la ligne suivante (il faut savoir comment fonctionne un segment:offset)
l'opérande ADD ne fonctionne pas avec un registre segment comme DS, par contre, il fonctionnera avec AX qui contient la valeur initiale de ce segment, et qui n'est
pas modifié dans le reste du code.
donc un :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
add ax,10
mov ds,ax

est à placer quelque part... je te laisse chercher

[Invité]

Re, merci forthman j'avais quelques doute ^^

Sinon pour pour renseigner l'offset, on ne peut y mettre ds, on ne peut que entrer bx/bp/si/di comme offset et ds/es/ss en selecteur de segment.

[Forthman]

mais l'adressage direct fonctionne aussi, par contre suivant l'assembleur, il faut préciser le type de donnée (byte,word...etc...)
avec Fasm : mov [00h],"A" ne fonctionne pas mais mov byte [00h],"A" oui

[Invité]

En effet

Je suis plus spécialiser dans la prog x64, donc j'ai quelque fois oublier le 16-bit ^^

[HKati]

Voici ce que j'ai fait mais encore reste le meme probleme!!!


Autre chose chose,j'ai pas compris l'intéret de la ligne xor
Excusez moi, je suis encore débutante

[Invité]

Pas de problème ^^

la ligne xor permet d'inialisé a zero l'indice qui va servir a parcourir l'ecran, et c'est plus rapide d'utiliser un xor plutot qu'un mov reg., 0

Pour ton programme, tu as oublier l'incrémentation de l'indice du screen, enfin pas pour le premier bonjour, mais pour les autres, je vais te faire un remix du code que j'ai fait avec commentaire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
 
[BITS  16]
[ORG  0x100]
;======================================================================================================================================================================================
;CODE   CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE    CODE
;======================================================================================================================================================================================
source:
;{
    ; Initialisation du selecteur de segment, pour pouvoir ecrire dedans, note que l'on peut faire directement mov     ds, [TRAM], pour etre plus rapide ^^
    ; Et note qu'on établie un systeme segment:offset, car en mode 16 bit, on ne peut dépasser la zone mémoire 0xFF_FF (1 octet/byte = 2 chifre hexadécimal = ex. 0xFF)
        mov     ax, 0xB800
        mov     ds, ax
       ; mov     ds, [TRAM]
 
    xor     bx, bx      ; Initialisation de l'indice servant a parcourir l'ecran
    mov     cx, 10      ; Initialisation de la boucle loop qui va boucler tant que cx est différent de 0
    loop_display:
   ;{
        mov     [ds:bx], byte 'B'
        add     bx, 2
 
        mov     [ds:bx], byte 'o'
        add     bx, 2
 
        mov     [ds:bx], byte 'n'
        add     bx, 2
 
        mov     [ds:bx], byte 'j'
        add     bx, 2
 
        mov     [ds:bx], byte 'o'
        add     bx, 2
 
        mov     [ds:bx], byte 'u'
        add     bx, 2
 
        mov     [ds:bx], byte 'r'
        add     bx, 2
 
        mov     [ds:bx], byte ','
        add     bx, 2
   ;}
    loop    loop_display
 
    ret
;}
;======================================================================================================================================================================================
;END_CODE   END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE    END_CODE
;======================================================================================================================================================================================
 
;======================================================================================================================================================================================
;DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA	DATA
;======================================================================================================================================================================================
 
	TRAM		dw	0xB800		; [T]ext[RAM] adresse du début de la zone mappée qui est la mémoire vidéo, mais en mode texte et non graphique (pixel) .
 
;======================================================================================================================================================================================
;END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA	END_DATA
;======================================================================================================================================================================================

Voilà, si ta d'autres questions n'hésite, et ne t'en fait, on est tous passer par ces moments difficile nous les programmeurs en assembleur (plus que les autres langages ? )

l'art ascii ( ;===; ) que tu voit dans mon code n'est là que pour une meilleur lecteur/lisibilité, car personnelement désolé par avance, mais je trouve ça un peu exaspérant de voir encore des personnes ne faisant aucun effort d'ecrire leur code asm sous aucune forme agréable à lire, car c'est un fait, l'assembleur est plus difficile que les autres langages, autant niveaux lecture que comprehension.

Voilà pour le petit topo, et si tu veut une façon de faire tes fonctions asm, voice là mienne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
        func:
       ;{
            ;===============================================================================================================.
            ; void     func(...)                                                                                            |
            ; Purpose : None                                                                                                |
            ; Input   : None                                                                                                |
            ; Output  : None                                                                                                |
            ; Destoy  : None                                                                                                |
            ; Data    :                                                                                                     |
                        [section .data use16]                                                                              ;|
                       ;{                                                                                                  ;|
                                ; None                                                                                     ;|
                       ;}                                                                                                  ;|
                        [section .code use16]                                                                              ;|
            ;===============================================================================================================.
           ;{                                                                                                              ;|
                ; Code                                                                                                     ;|
                                                                                                                           ;|
                ret                                                                                                        ;|
           ;}                                                                                                              ;|
            ;===============================================================================================================.
            ; /func                                                                                                         |
            ;===============================================================================================================.
       ;}

Bon étant donné que tu fait du *.com 16 bit, tu n'a pas besoin de préciser ces deux lignes ([section .data use16] et [section .code use16]) par contre, dés que tu feras de la programmation pour exe, il faudra les préciser. C'est en syntaxe nasm par contre.

Enjoy ^^

Et pour les futurs troll à propos de mon message, je vous envoie une jolie (maintenant j'anticipe )

[BufferBob]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
add ax,10
mov ds,ax

effectivement c'est encore la solution la moins intrusive et la plus simple ici

[Forthman]

@HKati : dans ton prog xor bx,bx ne sert à rien puisque tu n'utilises pas le registre bx par la suite...

Avec toutes les explications données, tu as 2 possibilités.
- Utiliser un registre d'offset comme le propose Glojii, pour ça tu vas devoir transformer un "mov [00h],'B'" par un "mov [Bx+00h],'B'" (et pareil pour le reste) et incrémenter BX pour pointer la ligne suivante
- Modifier le segment comme je te l'ai proposé

Les deux méthodes auront le même résultat, mais l'approche est différente.

J'ai longtemps programmé dans ma jeunesse sur des machines ou il fallait gratter le moindre octet, le résultat était
un programme performant mais rigide, et la moindre modification imposait souvent de réécrire une grosse partie du code.
donc avec mon choix, tu obtiens ce que tu recherches avec seulement 2 lignes à ajouter à ton code

Glojii propose une solution un peu plus longue à mettre en place, avec plus de modification du programme d'origine
(on ne le reconnaît presque plus), et un programme plus volumineux (ok, de quelques octets juste )
Mais elle a l’avantage d'être beaucoup plus souple, et si demain, tu as besoin d'utiliser une fonction pratiquement identique,
les modifications seront moins importantes pour réutiliser le code.

edit : @Glojii si tu faisait allusion à mes réponse quand tu parles de troll, désolé, ce n'était pas mon intention

[Invité]

Salut Forthman, non ce n'est pas destiner à toi ^^

Sinon j'ai un doute pour l'addition de 10 du sélecteur de segment, car bon ok il est à 0xB800, mais sachant que le calcule est de (0xB800 * 16 + 0 = 0xB8000), alors si tu additionne 0xB800 de 0xA, ça donnera (0xB80A * 16 + 0 = 0xB80A0).

Hmm ah oui je vois où tu veux en venir, mais bon c'est une autre façon de parcourir la ram, personnellement je préfère rester sur le fonctionnement de segment:offset ^^, même si l'équation d'en bas est exacte, bon tu fait des saut de 16 (0x10), mais il faut bien calculer son coup ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
C = ((A + B) * 16) +  0
C =  (A      * 16) + (B * 16) :aie:

Et merci pour l'avis sur ma façon de coder ^^ (première fois que j'en ai une )
Après tout je me demande si il n'est pas temps de crée une norme pour ce langage vieux comme le monde (bon ok j'exagère ) , sachant que les autres langages en ont et pas lui

[HKati]

Merciii infiniment enfin il est marché

Je vous demande si vous avez un PDF où je peux trouver le cours de ce langage en details, je cherche maintenant sur comment rendre ceci coloré :/ si vous avez des idées aidez moi svp

[Invité]

Salut, et pas de quoi ^^

Personellement j'ai une propre syntaxe sous notepad++ après si tu veux des conseil.

* Prend les sept volumes sur
http://www.intel.com/content/www/us/...r-manuals.html
(Prend les volume séparément - Seven-Volume Set of Intel® 64 and IA-32 Architectures Software Developer’s Manuals)

2A-2B-2C = info sur toutes les instructions du cpu intel.

* Ensuite je te conseil nasm comme syntaxe:
http://www.nasm.us/doc/nasmdoc1.html
http://www.nasm.us/
http://forum.nasm.us/

Voici notepad: http://notepad-plus-plus.org/


Voilà à quoi la syntaxe ressemble:

[Forthman]

Pour ajouter de la couleur, il faut que ton émulateur le supporte. (pour le coup je n'en sais rien, il faut essayer)
la couleur des lettres en mode texte est distincte pour chaque lettre.
La couleur est codée sur l'octet suivant l'octet du code ASCII
Dans ton exemple, tu as:
MOV [02h],"B" pour afficher la lettre B en colonne 1 ligne 0
puis MOV [04h],"o" pour afficher la lettre o en colonne 2 ligne 0

de 02h à 04h tu as 2 octets, pourtant les deux lettres sont l'une à coté de l'autre
et un code ASCII n'occupe qu'un seul octet.
en fait, en 03h est stockée la couleur de "B" et en 05h celle du "o"

En mode texte tu as à disposition... 8 couleurs (pas 8 million hein, juste 8 )
chaque caractère peut être affiché avec une couleur de caractère, et une couleur de fond spécifique
un bit permet d'augmenter l'intensité lumineuse du caractère, l'autre provoque un clignotement

voici comment se code l'octet d'attributs d'un caractère :
bit 7 = clignotement (0=normal 1=clignote)
bit 6 = composante ROUGE du fond
bit 5 = composante VERTE du fond
bit 4 = composante BLEUE du fond
bit 3 = intensité caractère (0=normal 1=intensité max)
bit 2 = composante ROUGE du caractère
bit 1 = composante VERTE du caractère
bit 0 = composante BLEUE du caractère

Donc si je veux afficher un caractère jaune vif sur un fond bleu, sans clignotement,
le code binaire est : 00011110b soit 30 en décimal
simple non ?

Pour que ta première lettre "B" soit affichée avec cette couleur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
mov [03h],30

(et si ça ne fonctionne pas, c'est que l'émulateur ne prend pas en compte le mode texte couleur)

[HKati]

Mercii bcp @Forthman il marche très bien et voici


une petite chose si je veux les lignes, par exemple je mets un registre BX qui va faire l'affichage des lignes
comment je vais les colorer?

[Forthman]

Mon pseudo codé "en dur" dans un programme c'est la classe !

Je ne comprends pas bien ta question, pour les lignes, tu veux afficher les numéros de lignes ?
Et je vois qu'il y a un "mov cx,10" mais que la ligne ne s'affiche qu'une seule fois,
c'est volontaire ? ou tu n'as pas su où mettre les deux lignes de codes que j'avais indiqué plus haut ?