Utilisation de Inpout32.dll

Bonjour à tous

Je dois développer une application qui déclanche un affichage lorsque l'on reçoit un front montant sur la broche D0 du port parallèle. Ce front montant étant envoyer par une autre application propriétaire sur un autre PC.

J'avais développer cela sous C++ Builder 6 avec le composant dlPortIo et cela fonctionnais bien.
Or, depuis que je suis passé sous Borland Developper Studio 2006, plus moyens;

Je me suis donc tourné vers d'autre méthodes et notamment la DLL inpout32.dll mais j'ai encore quelques soucis.

Je me suis créer une classe pour utiliser cette DLL

PortParallele.h

#include <vcl.h>
#include <conio.h>

/* prototype (function typedef) for DLL function Inp32 et out32: */
typedef short _stdcall (*PtrIn)(short portaddr);
typedef void _stdcall (*PtrOut)(short EndPorta, short valor);

// Union pour la récupération des broches de données
union TBrochesDonnees
{
    char chr;
    struct
    {
        unsigned char D0 : 1;
        unsigned char D1 : 1;
        unsigned char D2 : 1;
        unsigned char D3 : 1;
        unsigned char D4 : 1;
        unsigned char D5 : 1;
        unsigned char D6 : 1;
        unsigned char D7 : 1;
    };
};

// Classe pour le port parallèle
class TPortParallele
{
    private :

        // Adresse du port
        unsigned short AdressePort;

        // Instance de la librairie
        HINSTANCE hLib;

        // Fonction de lecture
        PtrIn Lecture;


        // Fonction d'écriture

        PtrOut Ecriture;

    public :

        // Constructeur
        __fastcall TPortParallele();

        // Destructeur
        __fastcall ~TPortParallele();

        // Méthode chargée de l'initialisation
        bool __fastcall Initialisation(unsigned short Adresse);

        // Méthode chargée de mettre le Port à 0
        void __fastcall MiseAZero(void);

        // Lecture des données
        TBrochesDonnees __fastcall LireDonnees(void);
};


PortParallele.cpp

#include "PortParallele.h"

//---------------------------------------------------------------------------

// Constructeur
__fastcall TPortParallele::TPortParallele()
{
}

//---------------------------------------------------------------------------

// Destructeur
__fastcall TPortParallele::~TPortParallele()
{
    // On libère la librairie
    FreeLibrary(hLib);
}

//---------------------------------------------------------------------------

// Méthode chargée de l'initialisation
bool __fastcall TPortParallele::Initialisation(unsigned short Adresse)
{
    // Booléen pour la valeur de retour
    bool Retour;

    // On affecte l'adresse du port
    AdressePort = Adresse;

    // On charge la librairie
    hLib = LoadLibrary("inpout32.dll");

    // Si le chargement s'est mal passé
    if(hLib == NULL)
    {
        ShowMessage("Erreur de chargement de la librairie !");

        return false;
    }

    // On récupère la fonction de lecture
    Lecture = (PtrIn) GetProcAddress(hLib, "Inp32");

    // Si le chargement s'est mal passé
    if(Lecture == NULL)
    {
        ShowMessage("Erreur de chargement de la fonction inp32 !");

        return false;
    }


    // On récupère la fonction d'écriture
    Ecriture = (PtrOut) GetProcAddress(hLib, "Out32");

    // Si le chargement s'est mal passé
    if(Ecriture == NULL)
    {
        ShowMessage("Erreur de chargement de la fonction out32 !");

        return false;
    }

    // SI l'on est ici, c'est que les chargements se sont bien passé
    // On met le port à 0
    MiseAZero();

    // On retourne true pour marquer que l'initialisation s'est bien passé
    return true;
}

//---------------------------------------------------------------------------

// Méthode chargée de mettre le Port à 0
void __fastcall TPortParallele::MiseAZero(void)
{
    // On met les broches de données à 0
    (Ecriture)(AdressePort, 0x0);
}

//---------------------------------------------------------------------------

// Lecture des données
TBrochesDonnees __fastcall TPortParallele::LireDonnees(void)
{
    // Union pour récupérer les données
    TBrochesDonnees Donnees;

    // On récupère les données
    Donnees.chr = (Lecture)(AdressePort);

    // On les retournes
    return Donnees;
}

//---------------------------------------------------------------------------

Et donc pour l'utilisation, je fais ceci
    #include "PortParallele.h"

    .....

    // Booléen pour la lecture
    bool Lecture;

    // On ouvre le port
    Port = new TPortParallele();

    // Si l'initialisation s'est bien passé
    if(Port->Initialisation(0x378))
    {
        // On marque que l'on est en lecture
        Lecture = true;

        // Tant que l'on est en lecture
        while(Lecture)
        {
            // On lit les données sur le port parallèle
            Donnees = Port->LireDonnees();
        }
    }

Quand j'utilise ceci avec le logiciel qui doit déclancher et le miens sur la même machine, il n'y a aucun problème, les changements d'état sont détecter.
Par contre dès que j'exécute mon soft sur un autre PC (Les 2 PC reliés par le port parallèle), rien ne se passe.

Est-ce que quelqu'un saurais d'où peu venir le problème

Merci d'avance pour votre aide

Personne ne peut m'aider ?

Bonjour,
je suis tombé sur votre problème en cherchant comment utiliser une DLL dans une application MFC en C++ 6.0. Je ne sais pas si depuis le temps vous avez trouver la solution. Mon problème est que je ne suis pas capable de compiler votre code. Si j'arrive à le compiler je vais probablement être capable de vous aider un peu... j'ai une petite idée de la source du problème.  Mais j'aimerais le vérifier avant de m'avancer.

Seriez-vous capable de me dire avec quoi vous compilez votre programme. Et peut-être de m'envoyer votre code souce.

Si vous travaillez sous MS c++ 6.0, je vais pouvoir tester ma DLL et tester votre problème.

Sylvain Poirier
sylvain.poirier@progcie.com