Discussion :

[foussa]

Voila, je doit réaliser un programme en assembleur qui lit les données qui se trouvent en DS=40 de l'offset 00 à 07 avec encuite, conversion de ces données en ASCII ...

Pour la conversion en ASCII, il n'y a pas de problèmes, mais pour la lecture des données, je ne vois pas du tout par ou commencer ... Si quelqu'un peut maiguiller...

Merci d'avance

[golem]

Salut,

tu veux simplement lire la zone données du BIOS je présume:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
   mov ax,40h
   mov ds,ax               ; segment ds=40h
   xor si,si                   ; registre index=0
   mov cx,8                 ; 8 octets à lire
boucle:
   mov bh,[si]              ; charge octet pointé par ds:si dans bh
   ...                ; tu fais ici le traitement que tu veux sur bh
   inc si
   loop boucle              ; continuer pour les octets restants tant cx n'est pas nul
 
   ...

golem
+++

[foussa]

Un grand merci à toi golem, je pense que ces explications vont m'occuper un bon bout de temps

Encore merci et a+

[foussa]

Voici ce que je suis parvenu a faire ... Si vous trouvez les erreurs qui ne doivent certainement pas manquer ...

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
;=====================================================================
;Convertion en ASCII de ce qui se trouve en ds=40 dans loffset 00 à 07
;=====================================================================
 
 
.MODEL SMALL
.STACK
.DATA
 
	abElem	DB  DUP  8 (' ')    ; tableau qui contiendra les valeurs convertie en ASCII
 
.CODE
 
main:
 
	mov bx, @data
	mov ds, bx
 
	mov ax,40h 
                mov ds,ax                   ; segment ds=40h 
                xor si,si                       ; registre index=0 
                mov cx,8                     ; 8 octets à lire 
 
	mov di,0
 
 
 
boucle:
 
                mov bh,[si]                  ; charge octet pointé par ds:si dans bh 
 
                                                  ; tu fais ici le traitement que tu veux    sur bh => je fais le traitement en dehors de la boucle
 
	mov dx:[di],bh             ; !!! certainement erreur de choix de  registre :s
			   ; memorise ce qui se trouve a l offeset si dans dx en vue d un traitement apres la boucle 	         
 
	inc si 
	dec cx
	inc di
 
	cmp cx,0
	jne boucle                     ; continuer pour les octets restants tant cx n'est pas nul
 
 
 
conv:
	                                   ; convertion en ASCII
 
 
	mov di,0                       ; initialise di a 0
	mov al,dx:[di]
 
	add al,30h		    ; convertir en ASCII le contenu de al 
 
	cmp al,39h
	jbe 39h next_conv
 
	add al,7h
 
nex_conv:
 
	mov abElem[di],al	     ; place la valeur convertie dans l emplacement di du tableau abElem		    
 
	inc di
 
	cmp di,9
	je end
 
affich:
 
	mov ax, 0900h              ;affichage de abElem 
                lea dx, abElem           
                int 21h 
 
end:
 
	mov ax,4c00h
	int 21h
 
 
END main

Merci d'avance

[golem]

Salut,

Bon voilà un truc qui marche. J'ai un peu torché ta fonction de conversion parce que j'ai pas tout compris à ton code.

Sur mon PC j'ai ça à l'adresse 40:00 (dumpé avec debug):

0040:0000 F8 03 F8 02 00 00 00 00 78 03 00 00 00 00 10 02
...

Cela correpond aux adresses des interfaces série (3F8h, 2F8h, 0h, 0h) selon le BIOS.

La sortie du programme c'est ça:

F803F80200000000

J'espère que c'est le fonctionnement que tu veux.

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
61
62
63
64
65
66
67
68
 
;===================================================================== 
;Conversion en ASCII de ce qui se trouve en ds=40 dans loffset 00 a 07 
;===================================================================== 
 
.MODEL SMALL 
.STACK 
.DATA 
        cr      EQU     13
        lf      EQU     10
 
        chextab DB      '0123456789ABCDEF'         ; pour conversion hexa => ASCII
        abElem  DB      16 DUP (' '), cr, lf, '$'  ; tableau contenant les valeurs hexa converties en ASCII
                                                   ; 1 octet => 2 caracteres ASCII en hexa
.CODE 
 
main:
        mov ax, @data 
        mov ds, ax         ; ds est le segment de donnees, ou on trouve abElem
        mov si,offset abElem    ; si pointe sur la chaine resultat
 
        mov ax,40h
        mov es,ax       ; es segment = 40h, zone data du BIOS
        xor di,di       ; di pointe sur le premier octet de la zone data du BIOS
 
        ; a tout moment, ds:[si] pointe sur le prochain emplacement de la chaine resultat (2 octets)
        ; es:[di] pointe sur le prochain octet a traiter de la zone data du BIOS
 
        mov cx,8        ; 8 octets a traiter dans la zone BIOS data
boucle:
        mov dl,es:[di]  ; charge octet de la zone BIOS
        call convert    ; charge DS:[SI] avec la valeur de DL convertie en ASCII (hexa)
        inc di          ; prochain octet de la zone data
        inc si          ; prochain emplacement de la chaine resultat
        inc si
        loop boucle     ; boucler jusqu'a cx nul
 
        mov ax, 0900h       ;affichage du resultat abElem 
        lea dx, abElem
        int 21h 
 
        mov ax,4c00h    ; retour au DOS
        int 21h 
 
;-- routine de conversion en ascii -----------
; entree:       DL octet a convertir en ASCII
;               DS:SI adresse sortie hexa ASCII (2 octets)
; sortie:       DS:[SI]
;
 
convert proc               ; conversion en ASCII
        xor ax,ax
        mov al,dl       ; on va traiter le poids faible
        and al,0Fh      ; garde le quartet inferieur de al
        lea bx,chextab  ; ds:bx pointe sur la table de conversion
        xlatb           ; AL <= DS:[BX+AL]
        mov [si+1],al   ; stocke code ASCII poids faible
        mov al,dl       ; on s'occupe maintenant du poids fort
        shr ax,1        ; garde quartet poids fort (decalage a droite de 4 bits)
        shr ax,1
        shr ax,1
        shr ax,1
        xlatb           ; charge le code ASCII pour le poids fort depuis chextab
        mov [si],al     ; stocke code ASCII poids fort dans la chaine resultat
        ret
convert endp
 
END main

Voilà. Remplace ma fonction de conversion par ta propre fonction si tu ne la comprends pas. Si t'as des questions, je suis sur MSN.

golem
+++

[foussa]

Merci à toi golem, ca fonctionne parfaitement désormais

Encore merci pour ton aide précieuse