Accès au ports

**YéTeeh** · 26/07/2002, 14h27

Builder me dit que les fonctions outp, inp et autres permettants l'écriture et la lecture directe sur les ports ne sont plus valables et qu'il faut utiliser la fonction CreateFile de l'API windows pour y accéder ou de passer par l'assembleur, bien que NT ne l'accèptera pas.

Bon, pourquoi pas, me dis-je. Un petite recherche pour en apprendre plus sur cette fonction, et là : rien.

Tout ce que je trouve me permet juste de communiquer avec les ports COM, LPT et autres ports nommés. Pas moyen de spécifier une adresse, genre écrire au port 0x226.

Ce que je voudrais donc savoir, c'est :

- Comment faire avec la fonction CreateFile

ou bien / et

- Comment passer un registre à une variable en assembleur, car lorsque j'écris (par exemple) :

int ret;
asm mov ret, eax;

j'ai le droit à une erreur comme quoi on ne sait pas ce que c'est que "ret".

Ou alors n'importe quelle autre solution qui résoudra mon problème.

Merci bien.

**drobert** · 26/07/2002, 15h07

Windows est un système protégé. Ce qui veut dire qu'il est impossible à une application d'accéder directement au hard, c'est à dire ni aux interruptions, ni aux ports, ni directement au disque dur. Et le fait d'écrire en assembleur n'y changera rien. Pour ouvrir un port série, il faut effectivement utiliser CreateFile, par exemple, en C:

Code :

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

1
2
3
4
 
  hPort = CreateFile("COM1:", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  ReadFile(hPort, szBuf, nbOctets, &nbOctetsLus, NULL);
  CloseHandle(hPort);

**ChMerlier** · 26/07/2002, 18h49

Bonjour,

Le CreateFile permet d'acceder un driver non à un port (en conjonction avec les ReadFile, WriteFile et DeviceIoControl).

Pour passer outre ça, sous Windows 95 (9X, Me, etc...) tu n'auras pas de probleme en ré-ecrivant les fonction Outp (que j'ai si tu veux) en assembleur.
Sur une base Nt (2000, Xp ou Nt4), l'accées au Ring0 n'est autorisé qu'au drivers. Donc soit tu developpes un driver pour faire plaisir à Big brother, soit tu utilises un driver générique (GiveIo.sys par exemple) te permettant de percer la couche Ring0 (ton appli tourne au Ring3).
L'inconvénient réside dans le fait que c'est l&pplicatif qui fait tout le boulot au lieu du Driver. Si tu n'as que quelques valeurs à écrire pas de probleme en revanche pour piloter une carte.

**YéTeeh** · 26/07/2002, 23h58

OK, donc c'est plutot chiant. Je veux bien les fonctions outp et inp en assembleur. Je crois déjà avoir fait outp, je ne l'ai pas testée :

Code :

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

1
2
3
4
5
6
7
8
9
void OutPort(int address, int value)
{
	asm
    {
    	MOV edx, address
        MOV eax, value
        OUT dx, ax
    }
}

mais j'ai des soucis avec inp.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int InPort(int address)
{
	int ret;
	/*__asm
    {
    	MOV edx, address
        XOR eax, eax
        IN  ax, dx
        MOV ret, ax
    }   */
 
    return ret;
}

Cela dit j'ai des soucis avec l'assembleur en fait....

Merci de m'aider.

**ChMerlier** · 29/07/2002, 11h11

Bonjour,

Voila ...

Ports.c

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
 
#include "ports.h"
 
//-----------------------------------------------------------------------
//  functions
//      inport  - inputs a word from a hardware port
//      inportb - inputs a byte from a hardware port
//      inp     - inputs a byte from a hardware port
//      inpw    - inputs a word from a hardware port
//
//      outport  - outputs a word to a hardware port
//      outportb - outputs a byte to a hardware port
//      outp     - outputs a byte to a hardware port
//      outpw    - outputs a word to a hardware port
//-----------------------------------------------------------------------
 
unsigned short inport(unsigned short port)
{
    asm     mov     dx,port
    asm     in      ax,dx
        return _AX;
}
 
unsigned char inportb(unsigned short port)
{
    asm     mov     dx,port
    asm     in      al,dx
    asm     xor     ah,ah
        return _AX;
}
 
unsigned short inpw(unsigned short port)
{
    asm     mov     dx,port
    asm     in      ax,dx
        return _AX;
}
 
short int inp(unsigned short port)
{
    asm     mov     dx,port
    asm     in      al,dx
    asm     xor     ah,ah
        return _AX;
}
 
void outport(unsigned short port, unsigned short val)
{
    asm     mov     dx, port
    asm     mov     ax, val
    asm     out     dx, ax
}
 
void outportb(unsigned short port, unsigned char val)
{
    asm     mov     dx, port
    asm     mov     al, val
    asm     out     dx, al
}
 
unsigned short outpw(unsigned short port, unsigned short val)
{
    asm     mov     dx, port
    asm     mov     ax, val
    asm     out     dx, ax
        return (_AX);
}
 
short int outp(unsigned short port, unsigned char val)
{
    asm     mov     dx, port
    asm     mov     al, val
    asm     out     dx, al
    asm     xor     ah, ah
        return (_AX);
}

Ports.h

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
 
#ifndef _PORTS_
#define _PORTS_
 
#pragma message Warning: port I/O not allowed in Windows NT
#pragma link "ports.obj"
//#pragma link "outport.obj"
 
#ifdef __cplusplus
extern "C" {
#endif
 
unsigned char  inportb( unsigned short __portid );
unsigned short inport ( unsigned short __portid );
short int      inp( unsigned short __portid );
unsigned short inpw( unsigned short __portid );
void           outportb( unsigned short __portid, unsigned char __value );
void           outport ( unsigned short __portid, unsigned short __value );
short int      outp( unsigned short __portid, unsigned char __value );
unsigned short outpw( unsigned short __portid, unsigned short __value );
 
#ifdef __cplusplus
}
#endif
 
#endif

N'oubliez pas que ce code ne fonctionne pas seul sous Windows à base d'Nt (il faut le GiveIO.sys)

**HRS** · 29/07/2002, 15h46

Depuis Win9X et +, l'accès aux ports COM soulève de nombreuses questions

drobert dit

qu'il faut passer par des API Windows pour y accéder (CreateFile,
ReadFile, WriteFile, CloseHandle de Winbase.h)

ChMerlier dit

que ces API ne sont pas adaptés et qu'on peut directement accéder aux ports par des routines assembleur
-------------------
Réponses contradictoires. Qu'en est-il ? idem pour USB (Universal Serial
BUS) ?
------------
D'autres parlent de librairies dédiées : TComPort, CPortLib, Port95nt.
Qu'en dire ? Sont elles des composants libres ?

**ChMerlier** · 29/07/2002, 15h54

Bonjour,

Pour HRS : Je n'ai jamais dit que les CreateFile etc n'étaient pas adaptées aux ports COM mais aux ports tout court (Inp(port adresse)). Ce qui est radicalement différent.
Si tu lis correctement le debut du post tu vois la nuance.

Pour utiliser un Port Com, j'utilise moi même TCommPort pour des applications simples et les APIs Win pour des applications plus compléxes.

Faut pas me faire dire ce que je n'ai pas dit ... non mais

Pour ma part et pour répondre à ta question, je conseille le TCommPort (ou autre composant). C'est simple et facile à utiliser. J'utilise les Api quand je dois faire des choses un peu plus poussées. A vous de voir pour la suite à l'utilisation.

PS : ça macherais aussi en assembleur le sujet du Post n'etait pas la ...

Accès au ports

C++Builder

Discussions similaires

Partager

Partager