Discussion :

[Invité]

Salut,
j'ai un code en assembleur qui lit les interruptions et qui et les convertit au caractère ASCII correspondant :

Code cpp :

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
 
/*
 *	keyboard.s
 */
 
.text
.globl _keyboard_interrupt
 
/*
 * these are for the keyboard read functions
 */
size	= 1024		/* must be a power of two ! And MUST be the same
			   as in tty_io.c !!!! */
head = 4
tail = 8
proc_list = 12
buf = 16
 
mode:	.byte 0		/* caps, alt, ctrl and shift mode */
leds:	.byte 2		/* num-lock, caps, scroll-lock mode (nom-lock on) */
e0:	.byte 0
 
/*
 *  con_int is the real interrupt routine that reads the
 *  keyboard scan-code and converts it into the appropriate
 *  ascii character(s).
 */
_keyboard_interrupt:
	pushl %eax
	pushl %ebx
	pushl %ecx
	pushl %edx
	push %ds
	push %es
	movl $0x10,%eax
	mov %ax,%ds
	mov %ax,%es
	xorl %al,%al		/* %eax is scan code */
	inb $0x60,%al
	cmpb $0xe0,%al
	je set_e0
	cmpb $0xe1,%al
	je set_e1
	call key_table(,%eax,4)
	movb $0,e0
e0_e1:	inb $0x61,%al
	jmp 1f
1:	jmp 1f
1:	orb $0x80,%al
	jmp 1f
1:	jmp 1f
1:	outb %al,$0x61
	jmp 1f
1:	jmp 1f
1:	andb $0x7F,%al
	outb %al,$0x61
	movb $0x20,%al
	outb %al,$0x20
	pushl $0
	call _do_tty_interrupt
	addl $4,%esp
	pop %es
	pop %ds
	popl %edx
	popl %ecx
	popl %ebx
	popl %eax
	iret
set_e0:	movb $1,e0
	jmp e0_e1
set_e1:	movb $2,e0
	jmp e0_e1

Ce que je voudrais faire c'est récupérer cette touche dans cette fonction (en insérant le code assembleur dans le code c++.)

Code cpp :

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

1
2
3
4
 
void FenClient::readKey() {
 
}

Quelqu'un sait t'il comment faire ?

Merci d'avance.

[Invité]

Bon j'ai essayé cela (pour récupérer l'interruption clavier) :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
 
void FenClient::readKey() {
    while(true){
        char kin;
        asm(
            "mov al, 16h;"
            "movb %%al, %0;"
            :"=r"(kin));
        printf("key : %c\n", kin);
    }
}

Mais il me dit Error : too many references for mov.

[kolodz]

Potentiellement le manque de \n
Sachant que le ; en assembleur n'indique pas la fin de ligne, mais le début d'un commentaire. Enfin de mémoire...

[Invité]

Ok j'ai essayé cela :

Code :

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

1
2
3
4
5
6
 
asm(
       "mov al, 16h \n"
       "movb %%al, %0"
        :"=r"(kin));
       printf("key : %c\n", kin);

Mais, même message d'erreur. :/

Je ne m'y connais pas beaucoup en assembleur alors je cherche des tutoriels par ci par là mais pour l'instant je n'ai rien trouvé qui fonctionne sur ma machine pour ce que je souhaite faire. :/

J'ai un processeur intel core i5.

[stendhal666]

http://en.cppreference.com/w/cpp/language/asm

tu as consulté ça? Il semble que la syntaxe varie en fonction des compilateurs. Cependant la syntaxe gcc a l'air supportée par d'autres compilateurs et le lien donne deux exemples. Le séparateur de ligne semble être \n\t

[ternel]

Au passage, l'assembleur n'est pas portable d'un processeur à l'autre. Comme on a déjà du mal à mettre d'accord les compilateurs entre eux sur la norme...

[Invité]

Oui, je ne parviens pas à trouver un code assembleur compatible avec ma machine, tellement il y en a des différents.

Je n'ai bien sûr pas non plus le manuel de mon processeur pour la syntaxe du langage. (Et comme ça varie fort d'un processeur à l'autre et que on a du mal à ce mettre d'accord sur les normes hé bien...)

[ternel]

Et si ca venait de ce que ce n'est pas la bonne façon d'obtenir l'information?

[bacelar]

Heu, les gars, vous en connaissez encore beaucoup des de OS qui laissent les programmes utilisateurs faire des bidouilles avec les vecteurs interruptions ???
Moi pas, depuis le bon vieux DOS tout pourri.
Il sort de quel musée ce bout de code ???

[Invité]

Non ça n'existe plus ce genre d'OS en effet, on est toujours obligé de passer par la console du programme pour gérer les interruptions.

A moins de créer son propre OS ?

Mais c'est beaucoup plus de boulot.

Si je ne me trompe pas je devrais le faire en assembleur x86.

[bacelar]

par la console du programme pour gérer les interruptions.

C'est quoi votre question, au bout du compte ???

[Christophe]

D'après le code asm, je pense que c'est pour appeler l'interruption BIOS int 0x16 en mode réel et je ne vois pas l'appel à l'int 0x16.

Par ailleurs:

Code :

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

mov al, 16h

ça c'est de la syntaxe Intel, en assembleur inline il faut utiliser la syntaxe at&t (même pour de l'assembleur x86) ce qui devrait donner quelque chose comme :

Code :

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

movb $16,%al

Je ne suis pas sûr à 100% de la syntaxe.

De plus stendhal666 a raison, il faut mettre des \n en fin de lignes, et il y a une codification pour le passage de paramètre entre la partie asm et C :
http://asm.developpez.com/cours/asminline/

Tu ne peux pas copier-coller du code assembleur sans le comprendre.

Tu pourras utiliser l'int 0x16 sous MS-DOS, mais sous Windows ou Linux c'est hors de question (comme l'a indiqué bacelar). Le processeur en mode protégé, la fonction BIOS int 0x16 sera inaccessible à moins de repasser temporairement en mode réel, ce qui est ni fait ni à faire et que l'OS t'interdira, on utilisera plutôt la fonction équivalente de l'OS.

Pourquoi ne pas utiliser getchar() ou un équivalent ?