Adresse mémoire video

[gheaeckkseqrz]

Bonjour tout le monde, comme la plupart des gens qui poste sur ce forum je suis en train de programmer un OS.

Pour l'instant je suis ce tuto.

Actuellement je voudrais afficher un message en couleur, le tuto indique de modifier directement les octets en mémoire vidéo.

Le problème c'est que le tuto me dit

La mémoire vidéo est mappée en mémoire à l'adresse physique 0xB8000.

Je modifie donc les octets comme indiqué mais il ne se passe rien.

Je pense que le problème viens du fait que je suis encore en mode reel et que l'adresse mémoire n'est pas la même.

Je voudrait donc connaitre l'adresse physique de la mémoire vidéo en mode reel.

[dapounet]

Ça fait longtemps que je n'ai plus fait d'ASM 16 bits mais à mon avis il faut initialiser un segment à 0xB800 puis adresser la mémoire de la carte graphique en passant par ce segment-là.

[Edit]

Si ça peut t'aider j'avais adapté une petite demo : http://pastie.org/131935
C'est dans le même style mais ça n'utilise pas la même adresse et c'est pour FASM.

[gheaeckkseqrz]

Merci de ta réponse, le problème c'est que je débute en ASM, si t'as le temps est ce que tu peux m'expliquer comment faire STP.

Si t'as pas le temps laisse tomber, je me débrouillerai.

[dapounet]

Lis ça : http://benoit-m.developpez.com/assem.../Partie1-2.php
Et n'oublie pas que ça sert seulement pour l'assembleur 16 bits.

[gheaeckkseqrz]

Merci je vais voir ca .

[milouz123]

Bonsoir,

c'est vrai que je n'ai pas précisé les différences entre adressage en mode réel et adressage en mode protégé ... Le tuto proposé par Dapounet est complet et clair : je te le recommande moi aussi vivement

Essaye de le lire et revient vers nous si ça n'est toujours pas clair après ça.
Bon courage,

[gheaeckkseqrz]

Je comprend pas ce qui faut faire , vous pourriez m'expliquer comment on initialise un segment en mode réel SVP.

[Forthman]

Hello,

En mode reel, quand tu veux acceder a une donnee en memoire (1Mo maxi)
tu as besoin de 2 registre

1 registre de segment : CS, SS, DS, ES, FS ou GS
CS = Code Segment = segment utilise par le proc pour trouver le code a executer (ne pas y toucher)
SS = Stack Segment = segment de pile (ne pas toucher non plus)
DS = Data Segment = segment general de donnees
ES = Extra Segment = 2eme segment utilise par les donnees
FS et GS = comme ES mais uniquement sur les 386 et superieurs

Ensuite il te faut un registre d'offset : BX, BP, SI, DI

Toi, tu veux acceder a la RAM video en mode texte, son segment est B800h
Un registre de segment ne peut recevoir une valeur immediate

Code :

1
2
 
mov ES,B800h

ne fonctionnera pas et il faut faire :

Code :

1
2
3
 
mov ax,B800h
mov es,ax

Maintenant que ton registre de segment est bien positionne, tu peux
t'occuper du registre d'offset

par exemple DI (Destination Index)

Code :

1
2
 
mov di,0000h

Voila, tout est pret pour envoyer une valeur en B800:0000h
soit le premier octets de la RAM video qui se trouve etre le premier caractere
en haut a gauche.

exemple:

Code :

1
2
3
4
5
6
 
mov ax,B800h
mov es,ax
mov di,0000h
mov al,65 ; code ASCII de "A"
mov es:[di],al

Et la, tu vas me dire : "Ca marche pas !!!"
En fait, ca a bien marche, mais la RAM video du mode texte comporte 2 octets
par caractere. 1 pour le code ASCII et 1 pour la couleur !
Par defaut, la couleur du caractere ET du fond = 0 donc noir sur noir... il n'y a plus d'espoir

Pour voir ton caractere, tu peux remplacer l'utilisation de AL par
AX en placant dans AH la valeur de l'attribut video.

le programme devriendra donc :

Code :

1
2
3
4
5
6
7
 
mov ax,B800h
mov es,ax
mov di,0000h
mov al,65 ; code ASCII de "A"
mov ah,07 ; 7 = couleur blanc pas tres lumineux
mov es:[di],ax

Et voila ! le miracle de l'informatique moderne !!

a+ Francois

[milouz123]

Envoyé par gheaeckkseqrz

Je comprend pas ce qui faut faire , vous pourriez m'expliquer comment on initialise un segment en mode réel SVP.

As-tu lu le tutoriel cité par Dapounet ?

[gheaeckkseqrz]

Oui j'ai lu le tuto, mais c'est bon, j'ai compris avec les explication de forthman

Mais j'ai des erreur a la compilation

mov ax, B800 ==> error: symbol 'B800' undefined
mov es: [di], al ==> error: invalid combination of opcode and operandes
msg00: db'Vous venez de demarer AKruX v 0.0.0.3!',1,0 ==>error: phase error detected at the end of assembly.

[dapounet]

Envoyé par gheaeckkseqrz

mov ax, B800 ==> error: symbol 'B800' undefined

Essaie d'ajouter un zéro devant le B800 (sinon l'assembleur croit que c'est un identifiant).

Envoyé par gheaeckkseqrz

mov es: [di], al ==> error: invalid combination of opcode and operandes

Il faut voir comment NASM veut le prendre, essaie "mov [es:di], al".

Envoyé par gheaeckkseqrz

msg00: db'Vous venez de demarer AKruX v 0.0.0.3!',1,0 ==>error: phase error detected at the end of assembly.

Enlève les deux points et ajoute un espace après le db. L'avant-dernier byte doit sûrement être 10 au lieu d'1.

[gheaeckkseqrz]

J'aireussi a compiler

Mais maintenant j'ai rajouté tous les mov byte [0xB800]

J'ai

warning: byte value exceeds bounds. pour toute le lignes d'atribut...

Sinon estce qui a un site qui reference toute les erreurs que renvois nasm ?

[dapounet]

Envoyé par gheaeckkseqrz

Mais maintenant j'ai rajouté tous les mov byte [0xB800]

J'ai

warning: byte value exceeds bounds. pour toute le lignes d'atribut...

Tu essayes d'envoyer les deux octets de chaque caractère d'un coup ? Utilise word (16 bits) ou bien envoie chaque octet un par un. Poste ton code si tu veux qu'on t'aide plus.

Envoyé par gheaeckkseqrz

Sinon estce qui a un site qui reference toute les erreurs que renvois nasm ?

Il y a ça : http://nasm.sourceforge.net/doc/nasm...l#section-11.1

[gheaeckkseqrz]

Code :

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
[BITS 16]
[ORG 0x0]
 
jmp start
 
%include "UTIL.INC"
 
start:
; initialisation des segments en 0x100
    mov ax, 0x100
    mov ds, ax
    mov es, ax
    mov ax, 0x8000  ; stack en 0xFFFF
    mov ss, ax
    mov sp, 0xf000
 
; affiche un msg
    mov si, msg00
    call afficher
 
 
mov ax, 0xB800
mov es, ax 
mov di, 0000
mov al, 65
mov ah,  07
mov [es:di], al
 
 
mov byte [0xB800], 'K'
mov byte [0xB801], '0x0A'
mov byte [0xB802], 'R'
mov byte [0xB803], '0x0A'
mov byte [0xB804], 'U'
mov byte [0xB805], '0x0A'
mov byte [0xB806], 'X'
mov byte [0xB807], '0x0A'
 
 
 
end:
    jmp end
 
 
msg00 db  'Vous venez de demarer AKruX     v0.0.0.3 !', 10, 0

[dapounet]

Quand NASM voit les guillemets il essaie de remplacer les caractères qui apparaissent par leur code ASCII. Donc avec '0x0A', il essaie de mettre le code du 0, celui du x, celui du 0 puis celui du A. C'est trop grand pour un octet, donc il t'avertit. Si tu mets 0x0A à la place ça donnera sûrement ce que tu veux.

[gheaeckkseqrz]

J'arrive a compiler mais quand je "boot" avec qemu, pas de caracteres en couleur...

juste le message du debut. "Vous venez de demarer AKruX 0.0.0.3!"

Qu'est ce que je fais pas bien ?

[milouz123]

C'est possible de voir le code source ?

[gheaeckkseqrz]

Code :

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
[BITS 16]
[ORG 0x0]
 
jmp start
 
%include "UTIL.INC"
 
start:
; initialisation des segments en 0x100
    mov ax, 0x100
    mov ds, ax
    mov es, ax
    mov ax, 0x8000  ; stack en 0xFFFF
    mov ss, ax
    mov sp, 0xf000
 
; affiche un msg
    mov si, msg00
    call afficher
 
 
mov ax, 0xB800
mov es, ax 
mov di, 0000
mov al, 65
mov ah,  07
mov [es:di], al
 
 
mov byte [0xB800], 'K'
mov byte [0xB801], 0x0A
mov byte [0xB802], 'R'
mov byte [0xB803], 0x0A
mov byte [0xB804], 'U'
mov byte [0xB805], 0x0A
mov byte [0xB806], 'X'
mov byte [0xB807], 0x0A
 
 
 
end:
    jmp end
 
 
msg00 db  'Vous venez de demarer AKruX     v0.0.0.3 !', 10, 0

[Forthman]

euhhh... je crois que tu utilise une routine presente dans UTIL.INC

c'est donc normal que tu ne puisse pas "gerer" la couleur

Et ce bout de code :

Code :

1
2
3
4
5
6
7
8
9
 
mov byte [0xB800], 'K'
mov byte [0xB801], 0x0A
mov byte [0xB802], 'R'
mov byte [0xB803], 0x0A
mov byte [0xB804], 'U'
mov byte [0xB805], 0x0A
mov byte [0xB806], 'X'
mov byte [0xB807], 0x0A

ne fonctionnera pas, car l'adresse du segment video est bien B800
mais tu melange le segment et l'offset
Il faudrait que ca ressemble plus a du :

Code :

1
2
3
4
 
mov byte ES:[0x0000], 'K'
mov byte ES:[0x0001], 0x0A
...etc...

a+ Francois

[PyNub]

Le code du tuto de http://a.michelizza.free.fr/pmwiki.php fonctionne très bien sauf que l'exemple présenté par gheaeckkseqrz ne montre pas tout...

En fait ce sont deux extraits de deux codes différents : le secteur de boot qui est en mode réel et le kernel en mode protégé. Le secteur de boot initialise les segments de données et de code avant de passer la main à kernel qui lui est en mode protégé et peut accéder à la ram vidéo.

Je cherche une doc exhaustive sur le mappage de la vidéo (en mode texte, mais s'il existe un autre mode cela m'intéresse...) sur un PC, surtout comment manipuler les octets d'attribut. Si quelqu'un sait où je peux trouver ça...

Salut à tous...