HWIO.H

gehe zur Dokumentation dieser Datei

/*
File      : hwio.h
Project   : XCTL
Author    : Jan Picard <picard@informatik.hu-berlin.de> 2001-2002
   Institut fuer Informatik,
   Humboldt-Universitaet Berlin
Content   : another level of indirection:
         providing port I/O depending on Windows version
         - for win16 direct inp/outp calls are allowed
         - for win32 we use xport, a free generic kernel mode driver
           downloadable from www.simtel.net, search for "xport"
*/

#ifndef __HWIO_H
#define __HWIO_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define WIN32_LEAN_AND_MEAN // Do not include parts of windows headers that 
// that are used only rarely

#include <windows.h>
#include <setupapi.h>
#include <TCHAR.h>
#include <winioctl.h>

#if defined (Build_Hardware)
#define _HWIOCLASS __declspec(dllexport)
#elif defined(Use_Hardware)
#define _HWIOCLASS __declspec(dllimport)
#else
#define _HWIOCLASS
#endif

#ifdef __cplusplus
extern "C"
{
#endif
        LPCSTR _HWIOCLASS WINAPI hwGetVersion( void );
        HINSTANCE _HWIOCLASS WINAPI hwGetInstance( void );
#ifdef __cplusplus
}
#endif

// Treiber IOCTLs
#define XCTL_TYPE FILE_DEVICE_UNKNOWN
#define IOCTL_MC_REPORT_ID CTL_CODE(XCTL_TYPE,0x900,METHOD_BUFFERED,FILE_READ_ACCESS)

#define IOCTL_MC_READ_BYTE CTL_CODE(XCTL_TYPE,0x901,METHOD_BUFFERED,FILE_READ_ACCESS)
#define IOCTL_MC_READ_WORD CTL_CODE(XCTL_TYPE,0x902,METHOD_BUFFERED,FILE_READ_ACCESS)
#define IOCTL_MC_READ_DWORD CTL_CODE(XCTL_TYPE,0x903,METHOD_BUFFERED,FILE_READ_ACCESS)

#define IOCTL_MC_WRITE_BYTE CTL_CODE(XCTL_TYPE,0x904,METHOD_BUFFERED,FILE_WRITE_ACCESS)
#define IOCTL_MC_WRITE_WORD CTL_CODE(XCTL_TYPE,0x905,METHOD_BUFFERED,FILE_WRITE_ACCESS)
#define IOCTL_MC_WRITE_DWORD CTL_CODE(XCTL_TYPE,0x906,METHOD_BUFFERED,FILE_WRITE_ACCESS)

// zusätzliche IOCTLs für BraunPSD
#define IOCTL_DC_SET_WFR_CYCLES CTL_CODE( XCTL_TYPE,  0x907, METHOD_BUFFERED, FILE_WRITE_ACCESS) 
//      Set Wait For Ready Cycles --> ersetzt ASA.DLL SetTimeOut()
//      ein ULONG im Systembuffer übergeben mit Zyklenanzahl

#define IOCTL_DC_GET_DATA CTL_CODE( XCTL_TYPE,  0x908, METHOD_BUFFERED, FILE_WRITE_ACCESS) 
//      Get Data --> ersetzt ASA.DLL GetData()
//      Puffer gefüllt mit Struktur IrpParamsGetData übergeben

// Identifier der Detektoren und Motoren
enum EDeviceType {C812= 1, C832, RADICON, BRAUN, GENERIC, STOE};


// Datentypen
struct WriteBuffer
{
        DWORD Offset;
        union
        {
                BYTE bData;
                WORD wData;
                DWORD dwData;
        };
};

//Datenstrukturen für den BraunPSD
struct IrpParams
{
        ULONG Port;
        ULONG Value;
};

struct IrpParamsGetData
{
        PUCHAR pBuffer;                 //Zeiger auf Puffer in den die Daten eingelesen werden sollen
        ULONG MaxCount;                 //Anzahl der Einzulesenden Wörter -> größe von Buffer in WORD
        //WORD  ymax;
};

// allgemeine Hardwareverwaltungsfunktionen

//gibt Fehlermeldung aus
_HWIOCLASS void PrintError(DWORD dwError= 0);

//liefert die Anzahl der Devices zu einem DevivceInterface
_HWIOCLASS DWORD EnumDevices(const GUID& guid);

//liefert den DeviceName des Devices am angegebenen Index der DeviceListe des DeviceInterfaces
//dieser Name kann dann für CreateFile() genutzt werden
_HWIOCLASS bool GetDeviceDriver(const GUID& guid, DWORD devIndex, LPTSTR* pDriverName);

class _HWIOCLASS DeviceListEntry
{
private:
        EDeviceType DeviceID;           //GUID des Treibers
        char HardwareID[9];             //IO-Adresse der Hardware (hex ohne führendes '0x')
        char FileName[257];             //friendly name des Treibers

        DeviceListEntry* prev;
        DeviceListEntry* next;

public:
        DeviceListEntry(EDeviceType DeviceID, LPTSTR HardwareID, LPTSTR FileName);
        void SetPrevEntry(DeviceListEntry* pEntry);
        void SetNextEntry(DeviceListEntry* pEntry);
        DeviceListEntry* GetPrevEntry();
        DeviceListEntry* GetNextEntry();
        int GetDeviceID();
        LPTSTR GetHardwareID();
        LPTSTR GetFileName();
};

class _HWIOCLASS DeviceList
{
private:
        DeviceListEntry* first;
        DeviceListEntry* last;

public:
        DeviceList();
        virtual  ~DeviceList();

        void Add(EDeviceType DeviceID, LPTSTR HardwareID, LPTSTR FileName);
        void Add(DeviceListEntry* pEntry);
        void Clear();
        LPTSTR GetFileName(int DeviceID, LPTSTR HardwareID);
};

//Erstellt eine Tabelle aus DeviceID und zugehörigem Treibernamen
_HWIOCLASS bool RegisterDrivers(DeviceList* Drivers, const GUID& guid, EDeviceType DeviceID);

//kapselt den Zugriff auf die Hardware (über Treiber)
class _HWIOCLASS HardwareIo
{
protected:
        char szDeviceName[257];
        HANDLE hDevice;

public:
        HardwareIo();
        HardwareIo(char* szDeviceName);
        virtual ~HardwareIo();

        virtual BOOL Read(DWORD Offset, BYTE* Data);
        virtual BOOL Read(DWORD Offset, WORD* Data);
        virtual BOOL Read(DWORD Offset, DWORD* Data);

        virtual BOOL Write(DWORD Offset, BYTE Data);
        virtual BOOL Write(DWORD Offset, WORD Data);
        virtual BOOL Write(DWORD Offset, DWORD Data);
};

//fängt den Zugriff auf die Hardware ab (wenn kein Treiber vorhanden)
class _HWIOCLASS DummyIo : public HardwareIo
{

public:
        //DummyIo();
        DummyIo(int DeviceID, LPTSTR HardwareID, bool DoMessage= true);
        //virtual ~DummyIo(){}

        virtual BOOL Read(DWORD Offset, BYTE* Data)
        {
                *Data= 0xFF;
                return (TRUE);
        }
        virtual BOOL Read(DWORD Offset, WORD* Data)
        {
                *Data= 0xFFFF;
                return (TRUE);
        }
        virtual BOOL Read(DWORD Offset, DWORD* Data)
        {
                *Data= 0xFFFFFFFF;
                return (TRUE);
        }

        virtual BOOL Write(DWORD Offset, BYTE Data)
        {
                return (TRUE);
        }
        virtual BOOL Write(DWORD Offset, WORD Data)
        {
                return (TRUE);
        }
        virtual BOOL Write(DWORD Offset, DWORD Data)
        {
                return (TRUE);
        }

};

//spezielle Treiberzugriffe für BraunPSD
class _HWIOCLASS BraunPsdIo : public HardwareIo
{

public:
        BraunPsdIo();
        BraunPsdIo(char* id);
        virtual ~BraunPsdIo();

        virtual BOOL Read(DWORD Offset, BYTE* Data);
        virtual BOOL Read(DWORD Offset, WORD* Data)
        {
                return (FALSE);
        }       //von BraunPSD nicht unterstützt
        virtual BOOL Read(DWORD Offset, DWORD* Data)
        {
                return (FALSE);
        } //von BraunPSD nicht unterstützt

        virtual BOOL Write(DWORD Offset, BYTE Data);
        virtual BOOL Write(DWORD Offset, WORD Data)
        {
                return (FALSE);
        }       //von BraunPSD nicht unterstützt
        virtual BOOL Write(DWORD Offset, DWORD Data)
        {
                return (FALSE);
        } //von BraunPSD nicht unterstützt

        virtual BOOL SetTimeout(unsigned long Cycles);
        virtual BOOL GetData(IrpParamsGetData *Params); // 31.06.2004 MEMCORRECT (IrpParamsGetData *Params)
};

//fängt den Zugriff auf die BraunPsd-Hardware ab (wenn kein Treiber vorhanden)
class _HWIOCLASS BraunPsdDummyIo : public BraunPsdIo
{

public:
        BraunPsdDummyIo();
        BraunPsdDummyIo(char* id);
        virtual ~BraunPsdDummyIo()
        {}

        virtual BOOL Read(DWORD Offset, BYTE* Data)
        {
                return (FALSE);
        }
        virtual BOOL Read(DWORD Offset, WORD* Data)
        {
                return (FALSE);
        }
        virtual BOOL Read(DWORD Offset, DWORD* Data)
        {
                return (FALSE);
        }

        virtual BOOL Write(DWORD Offset, BYTE Data)
        {
                return (FALSE);
        }
        virtual BOOL Write(DWORD Offset, WORD Data)
        {
                return (FALSE);
        }
        virtual BOOL Write(DWORD Offset, DWORD Data)
        {
                return (FALSE);
        }

        virtual BOOL SetTimeout(unsigned long Cycles)
        {
                return (FALSE);
        }

        virtual BOOL GetData(IrpParamsGetData *Params) // 31.06.2004 MEMCORRECT (IrpParamsGetData *Params)
        {
                return (FALSE);
        }
};

//Controller-Interface
class _HWIOCLASS Controller
{
protected:
        HardwareIo* Hardware;                   //Hardwarezugriffe
        const EDeviceType DeviceID;             //GUID des zugehörigen Treibers
        char HardwareID[9];                             //IO-Adresse des Controllers
        unsigned Clients;                               //Anzahl der durch den Controller verwalteten Geräte
        const unsigned MaxClients;              //Anzahl der max. zu verwaltenden Geräte

public:
        Controller(EDeviceType DeviceID, LPTSTR HardwareID, unsigned MaxClients);
        virtual ~Controller(){};

        int GetDeviceID();
        LPTSTR GetHardwareID();
        BOOL AddClient();

        virtual BOOL Read(DWORD Offset, BYTE* Data);
        virtual BOOL Read(DWORD Offset, WORD* Data);
        virtual BOOL Read(DWORD Offset, DWORD* Data);

        virtual BOOL Write(DWORD Offset, BYTE Data);
        virtual BOOL Write(DWORD Offset, WORD Data);
        virtual BOOL Write(DWORD Offset, DWORD Data);

        //-> Controller ist abstract
        virtual BOOL Check()= 0;                //Test, ob Hardware angeschlossen
};

//kapselt das HardwareIo-Objekt für Geräte, die an einen Controller angeschlossen sind
//dies ist lediglich ein Basiscontroller
//- speziellere Controller (z.B. für TC_832) können von diesem ageleitet werden
class _HWIOCLASS StandardController : public Controller
{
public:
        StandardController(EDeviceType DeviceID, LPTSTR HardwareID, LPTSTR szDeviceName);
        StandardController(EDeviceType DeviceID, LPTSTR HardwareID, DeviceList* Devices);
        virtual ~StandardController();

        virtual BOOL Check();
};

class _HWIOCLASS ControllerListEntry
{
private:
        Controller* asController;               //assigned Controller

        ControllerListEntry* prev;
        ControllerListEntry* next;

public:
        ControllerListEntry(Controller* asController);
        virtual  ~ControllerListEntry();

        void SetPrevEntry(ControllerListEntry* pEntry);
        void SetNextEntry(ControllerListEntry* pEntry);
        ControllerListEntry* GetPrevEntry();
        ControllerListEntry* GetNextEntry();
        int GetDeviceID();
        LPTSTR GetHardwareID();
        Controller* GetController();
};

class _HWIOCLASS ControllerList
{
private:
        ControllerListEntry* first;
        ControllerListEntry* last;

public:
        ControllerList();
        virtual  ~ControllerList();

        void Add(Controller* asController);
        void Add(ControllerListEntry* pEntry);
        void Clear();
        Controller* GetController(int DeviceID, LPTSTR HardwareID);
        Controller* GetController(unsigned index);
        DWORD GetControllerIndex(int DeviceID, LPTSTR HardwareID);
};

//legt eine Liste aller in der Hardware.ini eingetragenen Controller an
//(ControllerClass= {Motor, Device})
_HWIOCLASS bool RegisterControllers(ControllerList* Controllers, LPTSTR pControllerClass);


#endif // #ifndef __HWIO_H

---