Discussion :

[Mero_]

Bonjour,

Je me demandais si c'était possible d'écrire un programme assembleur avec l'heure qui s'actualise. J'en ai déjà écrit un mais qui affiche uniquement l'heure (non actualisée).

Si quelqu'un a un code source je suis prenant pour l'analyser.

J'aurais aussi aimé savoir comment identifier quel assembleur est utilisé dans un code. Il y a certains codes sources sur internet que j'aimerais faire fonctionner mais je ne sais que compiler en TASM et les autres sont dénués d'identificateur pour savoir à quel assembleur ils appartiennent et pouvoir utiliser l'assembleur adéquat.

Également, existe-t-il une interruption qui attend une touche clavier pour interrompre le programme ? Par exemple j'affiche l'heure (en théorie, actualisée) et puis lorsque j'appuie sur une touche, ça s'arrête ou disparaît.

[Invité]

Salut,

Alors, pour les sources, il est dans le zip à https://sourceforge.net/projects/shaynoxhackos/, pour le clavier, il faut ouvrir le fichier "HackOS-3.0_(64bits).zip\nasm\1.ASM\HackOS\kernel.asm" et va à la fonction keywait(), pour l'heure "HackOS-3.0_(64bits).zip\nasm\1.ASM\HackOS\programme\void_Date().asm"

Ces sources sont documentées.

Ensuite, pour savoir comment identifier le type de syntaxe d'un assembleur, normalement comme tout code-source qui se respecte, il est suivi d'un build file, mais si tu n'en as pas il te faudra donc télécharger plusieurs compilateurs et le tester avec.

De mémoire il y à fasm/masm/nasm/tasm/yasm/sasm/emu8086/... .

[Forthman]

Bonjour,

Effectivement, des questions de débutant (ok, on a tous commencé comme ça)
Déjà, tu devrais nous dire sous quel environnement tu programmes, car les réponses peuvent varier d'un système à l'autre.

Par exemple, pour afficher l'heure "actualisée" avec sur un système monotache comme DOS, tu as deux options :
1 - c'est le programme principal, tu utilises ton écran comme une grosse pendule
2 - c'est un programme résident, et tu affiches l'heure dans un coin pendant que le système continue de fonctionner comme si de rien n'était

Dans le premier cas c'est un programme classique avec boucle interrompue par une touche
Dans le deuxième cas, c'est un programme résident (d'un niveau bien supérieur)

Pour savoir quel assembleur utiliser avec un code source... et bien tu vas devoir apprendre à le reconnaître tout seul
En gros, il te faut apprendre les principales syntaxes des assembleurs (NASM, TASM, MASM, FASM...etc...)
Ou du moins, quand tu auras trouvé "ton" assembleur, du premier coup d'oeil, tu sauras si c'est celui utilisé, et si ce n'est pas
le cas, tu sauras faire les modifications

[Invité]

Sinon oui, la question de l'environnement est importante, alors je dirais sois-tu travaille en x86 ou x64 mode.

En mode 32, tu peux faire appel aux interruptions 16 bit du BIOS et des ports du CPU, en mode x64 des OS comme windows/Linux, tu ne peux pas faire appel aux int et in/out, sinon ça crash car environnement x64 protégé par l'OS.
Et dans ce cas, tu dois faire appel aux fonctions de l'OS fourni pas des bibliothèques déjà installer comme la Windows API: https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx

Mais cela ne veut pas dire qu'en mode x64, tu ne peux pas faire appel aux in/out, cela ne concerne que windows et peut-être Linux.

[Mero_]

Je vous remercie pour vos réponses.

Shaynox tes fichiers sont très intéressants malheureusement je ne code pas en 64 bits et j'ai très difficile à les exploiter.

ça seras le programme principal, Il affichera genre l'heure qui tourne, puis à l'appui d'une touche ça s'arrêtera.

je code sur tasm sur du 32 bits, j'ai vu qu'il y avait l'interruption 16h pour la touche en mémoire mais je n'arrive pas à l'exploiter, de toute manière je n'arrive pas à rafraichir l'horloge

[Forthman]

Dans la même ligne tu écris "32 bits" et "int 16h"
Et là déjà ça sent pas bon

C'est du 32 bits pour win$ ? je ne suis pas sûr que TASM soit très indiqué pour faire
des programmes win$ (je ne suis pas sûr de ce que j'avance)

Pourrais-tu copier/coller ton programme ici qu'on puisse voir plus clair ?

[Invité]

@Mero_, bah passe en 64 bit x)

Sinon pour quelle raison tu codes en x86:
- Contrainte technique (windows 32 bit) ?
- Tu veux savoir coder en x86 avant d'attaquer le x64 ?
- Ou c'est juste parceque tu trouve le x86 plus complet et plus facile avec les fonctions du BIOS disponible ?

Et oui cela serait une bonne idée de poster le code ici.

[Mero_]

Voici le code en question, c'est avec ce code que j'obtiens l'heure mais non actualisée

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
include libshow.inc
.386
 
data segment use16
msg1 db 'lecture heure',10,13,'$'
msg2 db 'erreur de lecture !',10,13,'$'
barre db ':','$'
heu db 0
min db 0
sec db 0
data ends
 
pile segment stack
db 256 dup(?)
pile ends
 
code segment use16
assume cs:code,ds:data,ss:pile
MainProc:
 
;initialise segment
mov ax,data
mov ds,ax
mov es,ax
 
push cx dx
 
mov ah,02h
int 1Ah
jc erreur
 
fonctionne:
;enregistrement des resustats
mov sec,dh
mov min,cl
mov heu,ch
 
lea dx,msg1
mov ah,09h
int 21h
 
;affiche l'heure
xor ax,ax
mov al,heu
mov cl,4
shr al,cl
ecrit_ent
mov al,heu
and al,00001111b
ecrit_ent
 
lea dx,barre
call affiche_string
 
;affiche la minute
xor ax,ax
mov al,min
mov cl,4
shr al,cl
ecrit_ent
mov al,min
and al,00001111b
ecrit_ent
 
lea dx,barre
call affiche_string
 
;affiche la seconde
xor ax,ax
mov al,sec
mov cl,4
shr al,cl
ecrit_ent
mov al,sec
and al,00001111b
ecrit_ent
 
pop dx cx
 
jmp quitter
 
affiche_string proc near
mov ah,09h
int 21h
ret
affiche_string endp
 
erreur:
lea dx,msg2
mov ah,09h
int 21h
 
quitter:
mov ah,4ch
int 21h
 
code ends
 
end MainProc

La bibliothèque :

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
 
;Macro qui écrit un entier à l'écra
;Paramètres : AX = nombre à écrire
;Résultat : écran...
 
ecrit_ent	macro
		local	boucle1, boucle2, termine	;doit être la première ligne !
		.386
		pushf						;sauvegarde des flags
		pusha						;sauvegarde des reg. généraux
 
		mov	dx, 0BEBEh				;empiler le mot BEBEh
		push	dx					; (comme repère)
		mov	bx, 10				;on va diviser par 10
 
boucle1:							;pour trouver les chiffres
		xor	dx, dx				;mettre DX à 0 pour la division
		div	bx					;diviser !
		push	dx					;empiler un chiffre
		or	ax, ax				;a-t-on fini ?
		jnz	boucle1				;boucler sinon !
 
boucle2:							;boucle pour l'affichage
		pop	ax					;obtenir un chiffre
		cmp	ax, 0BEBEh				;est-ce la fin ?
		je	termine				;oui ? alors quitter !
		add	al, '0'				;ajouter le code ASCII '0'
		xchg	al, dl				;mettre dans DL
		mov	ah, 02h				;écrire un caractère
		int	21h					; à l'écran !
		xchg	dl, al				;restaurer DL
		jmp	boucle2				;prochain chiffre
termine:
 
		popa						;restauration des reg. généraux
		popf						;restauration des flags
endm

[Invité]

Et ça donne quoi avec une boucle ?

Une boucle avec un call keywait à l'intérieur, en somme si tu veux tourner plusieurs fonctions qui nécessitent une boucle infinie, tu peux faire des branchements en spaghetti pour faire du multi thread (bon le temps d'exécution des tâches n'est pas super répartie par contre, mais plus facile de mettre en place ce système que celui du CPU ).

[Forthman]

Pareil que Shaynox, ton programme fait un "jmp quitter" si tu le remplace par un "jmp MainProc" déjà tu auras l'heure actualisée (mais dans une boucle infinie )
Et pour info, ton code c'est du 16 bits pas du 32