Was ist neu in der Version 5.0 ?
Top Next

Als erstes erlaubt TVicHW32 5.0 nun Code auf Benutzerebene auszuführen, der privilegierte CPU-Instruktionen enthält. Durch die neue RunRing0Function Routine ist es möglich eigene Prozeduren im Ring 0 Modus der CPU auszuführen.
In diesem Fall hat der Code maximalen privilegierten Status, der zuvor nur den Treibern vorbehalten war. Innerhalb solcher Prozeduren sind alle Ports direkt über Die IN/OUT Assemblerbefehle ansprechbar oder über die _inp() und _outp() „C" Funktionen. Desweiteren kann man die Hardware Interrupts aktivieren/deaktivieren, hat Zugriff auf Spezialregister der CPU und so weiter.
Schauen Sie unter „Ausführen von Benutzerebenen-Code als Ring 0 CPU" nach näheren Details.

Weiterhin erlaubt TVicHW32 5.0 das korrekte Behandlen von pegelsensitiven Interrupts die gewöhnlich von PCI-Geräten erzeugt werden. Schauen Sie unter
UnmaskIRQEx und Hardware Interrupts nach näheren Details.

Ausserdem kann TVicHW32 5.0 die IDE Festplatten-Seriennummer lesen sowie
deren Geometrie von 4 IDE-Kanälen anstelle von 2 Kanälen in der Vorgängerversion. Nähere Details unter „HDD hardware manufacturer info".

Zuletzt enthält TVicHW32 mehr Dokumentation und eine FAQ.
.


Kontaktinformationen
Previous Top Next

TVicHW32 ist erhältlich unter der folgenden Internetadresse:

http://www.entechtaiwan.com/tools.htm

auf der die neuesten Versionen, Support-Links und Online-Bestellmöglichkeiten zu finden sind.
Kommentare, Fragen und Vorschläge bezüglich TVicHW32 können an nachfolgende Emailadresse (auf Englisch) gerichtet werden:

tools@entechtaiwan.com.


Einleitung

TVicHW32 5.0
Hilfedatei

Copyright(c) Victor Ishikeev 1997-2003
http://www.entechtaiwan.com/tools.htm
tools@entechtaiwan.com


Was ist TVicHW32?

Sie haben eine Anwendung geschrieben, die eine übliche oder Systemhardware steuert unter DOS oder Win16. Nun kommt die Aufgabe diese auf Win32 zu portieren. Sie wissen, das ist eine masslose Untertreibung, denn keine Programmiersprache verfügt über Befehle und Funktionen für Win32 Hardwarezugriffe wie Port-E/A-Befehle, Zugriffe auf physikalischen Speicher, Hardwareinterruptbehandlung oder DMA-Funktionen. Bis jetzt bestand Ihre einzige Chance darin, einen eigenen Treiber zu schreiben. Das bedeutet für Sie:

· Das Microsoft Driver Development Kit (DDK ) muss auf Ihrem PC installiert sein
· Sie müssen die verschiedenen Treiberstrukturen verstehen, die sehr unterschiedlich für Windows 95/98/ME (VxD) und fürr Windows NT/2000/XP (kernel-mode driver) sind,
· Wenn Sie der Programmiersprache „C" nicht mächtig sind, müssen Sie diese erlernen und sich wahrscheinlich auch mit Assemblerbefehlen auseinandersetzen,
· Sie müssen lernen, mit Treiber-Debuggern zu arbeiten und wahrscheinlich teuere Debugger-Tools kaufen
· Bereiten Sie sich auf Datenverluste vor, weil schon minimale Treiberfehler zu Systemabstürzen führen

Glücklicherweise haben Sie eine einfachere Möglichkeit. TVicHW32 ist ein universeller Gerätetreiber, der praktisch von jeder Programmiersprache verwendet werden kann. Er lässt Sie direkt Hardware ansprechen und kontrollieren von beliebigen Win32-Anwendungen heraus unter Windows 95,98,ME,NT,2000 ohne das Windows DDk benutzen zu müssen.

Das „Herz" von TVicHW32 besteht aus 3 Dateien:

· TVicHW32.vxd - Treiber für Windows 95/98/ME im Ordner \windows\system.
· TVicHW32.sys - Treiber für Windows NT/2000 im Ordner winnt\system32\drivers
· TVicHW32.dll - DLL zum Aufrufen der Treiberfunktionen aus fast allen Programmiersprachen, im Ordner \windows\system oder im Ordner der jeweiligen Anwendung

Desweiteren bietet die Header-Datei TVicHW32.h ein C/C++ interface, die Datei tviclib.pas ein Delphi interface und tviclib.bas ein Visual Basic interface.


TVicHW32 Eigenschaften

TVicHW32 Eigenschaften:

· Direkte Portzugriffe
· Bietet Zeiger auf den physikalischen Speicher durch Kopieren auf den Benutzer-Adressraum
· Gleichzeitiges Behandeln von mehreren Hardwareinterrupts
· Fortschrittliche LPT Unterstützung eingeschlossen Zugriff auf jeden Pin jedes LPT-Ports
· Zugriff auf die Festplatten-Herstellerinformationen wie Seriennummer, Geometrie, etc. für IDE1-IDE4
· Tastaturabfragen und Scan-code Nachrichten abfangen
· Zugriff auf den PCI-Adressraum und Auflistung aller PCI-Geräte
· Speicherbereichreservierung für System und Busmaster Operationen
· Ausführen von Benutzerfunktionen auf hoch privilegierter CPU Ebene (Ring 0)


Unterstutzte Programmiersprachen

Unterstützte Programmiersprachen

TVicHW32 bietet eine Treiberschnittstelle für:

· Microsoft Visual C/C++
· Borland Delphi (Versionen 2-7)
· Borland C++ Builder (Versionen 1, 3-6)
· Microsoft Visual Basic 6.0
· Andere Programmiersprachen,die DLLs benutzen können


Lizensierung und Registrierung

TVicHW32 Version 5.0 Lizenzbestimmungen

Sie sollten sorgfältig die nachfolgenden Punkte und Bedingungen lesen, bevor Sie die Software benutzen. Die Benutzung dieser Software bedeutet die Akzeptanz dieser Lizenzbestimmungen und Gewährleistung.

TVicHW32 Shareware Lizenz (unregistriert)
TVicHW32 Einzellizenz
TVicHW32 Kommerzielle Lizenz
Juristische Hinweise


TVicHW32 Shareware Lizenz (unregistriert)

Sie dürfen eine Shareware-Kopie dieser Software zu Testzwecken für 30 Tage benutzen, um zu testen, ob sie Ihren Bedürfnissen entspricht, bevor Sie sie. Am Ende der Testperiode müssen Sie eine registrierte Kopie erwerben oder die Software wieder deinstallieren. Bis zum Eintreffen Ihrer registrierten Version dürfen Sie die Shareware-Version weiter benutzen.

Es ist nicht erlaubt:

· Hinweise in der Software zu entfernen, die den Benutzer auffordern, die Software zu registrieren
· Die Software zu verändern oderfür andere Zwecke zu modifizieren
· Zurückentwickeln, dekompilieren oder disassemblieren der Software ist untersagt.

Sie haben das Recht:

· Soviele Kopien der Software und der Dokumentation zu erstellen,wie Sie brauchen
· Exakter Kopien der Software (inklusive aller Dateien) der Originalversion weiterzugeben
· Dies schliesst auch elektronische Medien ein

Es gibt keine Gebühren für die oben genannten Punkte. Es ist speziell untersagt, mit diesen Kopien Gewinn zu erzielen. Eine kleine Aufwandsvergütung ist jedoch akzeptabel. Weiterhin ist es untersagt, die Software mit anderen Produkten ohne vorheriges schriftliches Einverständnis zu vertreiben.


TVicHW32 Einzellizenz

Nach der Regsitrierung haben Sie das nichtexklusive Recht, TVicHW32 auf einem Computer zur gleichen Zeit für jeden legalen Zweck einzusetzen. Die Lizenzgebühr hierfür beträgt $99 U.S. Registrieren Sie online mit Kreditkarte oder per Uberweisung uber sichere Server bei ShareIt.


TVicHW32 Kommerzielle Lizenz

Eine kostengünstige, kommerzielle Lizenz ist ebenfalls erhältlich. Diese umfasst optional neue Namen für die Treiber und das Einfügen zeitkritischen Codes direkt in den Treiber.

Für diese Lizenz ist der Vertrieb der TVicHW32.DLL und der Treiber als Teil Ihrer Software ohne Tantiemen oder weitere Gebühren enthalten.

Die Lizenzgebühr hierfür beträgt $297 U.S. Registrieren Sie online mit Kreditkarte oder per Uberweisung uber sichere Server bei ShareIt.


Juristische Hinweise

Diese Software wird angeboten "wie sie ist" ohne Gewährleistung jeglicher Art, weder ausdrücklich noch impliziert, eingeschlossen, jedoch nicht beschränkt auf die Gewährleistung des Handels oder Eignung für einen bestimmten Zweck. Das gesamte Risko für die Qualität und Ausführbarkeit der Software liegt beim Benutzer/Lizenznehmer. Sollte sich die Software als fehlerhaft erweisen, trägt der Benutzer/Lizenznehmer die Kosten für Service, Reparatur oder Behebung.
In keinem Fall wird der Autor oder Leute die diese Software vertreiben, wie oben erlaubt, haftbar sein für Schäden, eingeschlossen alle generellen, speziellen, gelegentlichen oder wiederholten Schäden, die durch den Gebrauch oder der Nichtbenutzbarkeit der Software (eingeschlossen, aber nicht beschränkt auf Datenverlust, Datenveränderung oder andauernde Verluste durch den Benutzer/Lizenznehmer oder Dritte oder einem Versagen der Software mit irgendwelchen anderen Programmen zu funktionieren) entstehen, auch wenn solche Besitzer oder Dritte über die Möglichkeit solcher Schäden unterrichtet wurden.


Hinweise zur Bestellung

TVicHW32 Einzellizenz: Einmal registriert, wird Ihnen eine nicht – exklusive Lizenz gewährt, TVicHW32 auf einem Computer zur gleichen Zeit für jeden legalen Zweck zu verwenden. Die Registrierungsgebühr beträgt $99 U.S. Registrieren Sie online mit Kreditkarte oder per Uberweisung uber sichere Server bei ShareIt.

TVicHW32 Kommerzielle Lizenz: Es wird Ihnen die Lizenz erteilt,die TVicHW32 Treiber und DLLs als Teil Ihrer Software ohne weitere Gebühren zu vertreiben. Optional beinhaltet dies Ihre eigenen Treiber/DLL – Namen. Zusätzlich können wir zeitkritischen Code in den Treiber implementieren (eine zusätzliche Funktion oder einen Interrupt-Handler). Die Registrierungsgebühr beträgt $297 U.S. Registrieren Sie online mit Kreditkarte oder per Uberweisung uber sichere Server bei ShareIt.

Site Lizenz: Für Entwicklerteams. Die Kosten dieser Lizenz hängen von der Benutzeranzahl ab. Bitte kontaktieren uns für einen genauen Preis.


Programmieranleitung

TVicHW32 5.0
Programmieranleitung

Copyright(c) Victor Ishikeev 1997-2001
http://www.entechtaiwan.com/tools.htm
tools@entechtaiwan.com


Ubersicht von TVicHW32

}bersicht von TVicHW32

Um die Treiberfunktionen benutzen zu können, muss dieser erst initialisiert werden mit der Funktion OpenTVicHW32 .
Dies muss einmalig nach dem Start Ihrer Anwendung getan werden. Ausserdem müssen auf diese Weise geöffnete Treiber vor Beenden der Anwendung wieder geschlossen werden.

Achtung ! – öffnen und schliessen Sie den Treiber nicht mehrfach in Ihrer Anwendung !

Funktionelles Beispiel:

  // Treiber Deskriptor -> 0 ( notwendige Bedingung! )

HANDLE HW32 = 0;

// Treiber öffnen
HW32 = OpenTVicHW32( HW32, "TVicHW32","TVicDevice0");

if ( GetActiveHW ( HW32 ) ) {

... Anwendung HW32 ...

// schließen Treiber

HW32 = CloseTVicHW32(HW32);
}
else // Fehler
MessageBox("Cannot open the driver","Attention!", MB_OK | MB_ICONWARNING);

Der Treiber kann gleichzeitig von 2 Anwendungen benutzt werden, aber nicht von weiteren. Die Ausdrücke "TVicDevice0" und "TVicDevice1" dienen zum Unterscheiden der Anwendungen.


Zugriff auf physikalische Speicheradressen

Memory Mapping
Weitere Funktionen


Memory Mapping

Um auf ausgewählte physikalische Speicherbereiche zuzugreifen müssen diese physikalischen Adressen of einen linearen Speicherbereich des Adressraums der akuellen Anwendung kopiert werden. TVicHW32 enthält hierfür die Funktion MapPhysToLinear, die den Zeiger auf den linearen Speicher zurückgibt, definiert durch seine physikalische Adresse und Grösse. Wenn der Zeiger von der Anwendung nicht mehr benötigt wird, muss der physikalische Speicher wieder mit der Funktion UnmapMemory freigegeben werden.

Das nachfolgende Beispiel zeigt wie man einen Zeiger auf das BIOS erhält:

char *pBios;
HANDLE HW32 = NULL;

HW32 = OpenTVicHW32( HW32, "TVicHW32","TVicDevice0");

if (GetActiveHW(HW32)) {

     pBios = (char*)MapPhysToLinear(HW32,0xF8000,256); //256 bytes, starting from 0xF8000

     //...pBIOS session...

     UnmapMemory(HW32, 0xF8000,256); // undo mapping

     HW32 = CloseTVicHW32(HW32);     //  close the driver
  }
  else ... // failed


Weitere Funktionen

Wie bereits erwähnt gibt die Funktion MapPhysToLinear einen Zeiger auf den linearen Speicher definiert durch seine physikalische Adresse und Grösse zurück. Sie können mit dem zurückgegebenen Zeiger direkt oder mittels zusätzlicher Funktionen, die physikalischen Speicherzugriff mittels Bytes, Words oder Double Words bieten. Dies ist besonders für Visual Basic Programmier hilfreich, weil Visual Basic Beschränkungen im Umgang mit Zeigern aufweist.

Hier folgt eine Liste der erwähnten Funktionen:

UCHAR  GetMem  (HANDLE HW32, ULONG LinAddr, ULONG Offset);
USHORT GetMemW (HANDLE HW32, ULONG LinAddr, ULONG Offset);
ULONG  GetMemL (HANDLE HW32, ULONG LinAddr, ULONG Offset);
void   SetMem  (HANDLE HW32, ULONG LinAddr, ULONG Offset, UCHAR bValue);
void   SetMemW (HANDLE HW32, ULONG LinAddr, ULONG Offset, USHORT wValue);
void   SetMemL (HANDLE HW32, ULONG LinAddr, ULONG Offset, ULONG dValue);


E/A - Portzugriffe

Allgemeine Informationen
Einzelne Lese- und Schreiboperationen
Datenfeld lesen


Allgemeine Informationen

Ein- und Ausgabebefehle (E/A) auf Ports umfassen 2 Gruppen von Funktionen:

Einzelne E/A-Befehle mittels Bytes, Words und DoubleWords und Datenfeld-Funktionen

Direkte E/A-Befehle sind auch möglich durch die Verwendung von RunRing0Function mit Hilfe des eingebauten Assemblerbefehle wie inp()/outp().

Es gibt 2 Modi die E/A-Ports zu kontrollieren: "Soft Mode" und "Hard Mode". "Soft Mode" bietet grössere Geschwindigkeit, aber kann falsche Daten liefern, wenn der Port bereits durch einen anderen Treiber benutzt wird. "Hard Mode" ist langsamer, aber bietet sehr zuverlaessigen Portzugriff,auch wenn diese von anderen Treibern benutzt werden.

Bitte beachten Sie auch die FAQ in dieser Hinsicht.

Die Funktion SetHardAccess wird zum Umschalten zwischen diesen Modi benutzt. Um den aktuellen Modus zu ermitteln, dient die Funktion GetHardAccess.


Einzelne Lese- und Schreiboperationen

Die nachfolgenden Funktionen werden benutzt, um einzelne Werte an Ports zu senden bzw. zu empfangen:

GetPortByte - ein Byte von einem Port lesen
GetPortWord - ein Wort von einem Port lesen
GetPortLong - eine Doppelwort von einem Port lesen
SetPortByte - ein Byte zu einem Port senden
SetPortWord - ein Wort zu einem Port senden
SetPortLong - ein Doppelwort an einen Port senden


Datenfeld lesen

TVicHW32 bietet Funktionen um Datenfelder zu Ports zu senden bzw. zu lesen. Diese Funktionen basieren auf den Assembler INSB/INSW/INSD Lesebefehlen und den OUTSB/OUTSW/OUTSD Ausgabebefehlen. Man kann diese Funktionen z.B. benutzen, um LPT Operationen im EPP-Modus durchzuführen.

ReadPortFIFO - Byte-Datenfeld lesen
ReadPortWFIFO - Wort-Datenfeld lesen
ReadPortLFIFO - Doppelwort-Datenfeld lesen
WritePortFIFO - Byte-Datenfeld schreiben
WritePortWFIFO - Wort-Datenfeld schreiben
WritePortLFIFO - Doppelwort-Datenfeld schreiben

In der pPortRec Struktur müssen die Portadresse, die Menge der Datenelemente die gelesen/geschrieben werden sollen und ein Datenfeld mit Werten zum Senden zu dem Port angegeben werden.


Behandeln von Hardwareinterrupts

Normale Behandlung von Hardwareinterrupts
Erweiterte Optionen fur die Behandlung von Hardwareinterrupts
Aspekte der Leistungsfahigkeit


Normale Behandlung von Hardwareinterrupts

Achtung! – es werden nur Hardwareinterrupts behandelt. DOS/BIOS Funktionsaufrufe werden nicht unterstützt.

Es wird vorausgesetzt, dass der Anwender mit Hardwareinterrupts bereits vertraut ist und relevante Erfahrungen
mit DOS oer Win16 besitzt.

Die Funktion UnmaskIRQ installiert einen Hardwareinterrupthandler. Sie können die IRQ Nummer und diesen IRQ a
uf Hardwareebene de-maskieren.

  USHORT IrqNumber = 10;
  ULONG IrqCounter = 0;

  // The interrupt handler
  void __stdcall MyInterruptHandler( USHORT IrqNumber )
  {
      ++ IrqCounter;
  }

  ...

  // Main program
  HW32 = OpenTVicHW32( HW32, "TVicHW32","TVicDevice0" );
  if (GetActiveHW(HW32)) {
    UnmaskIRQ( HW32, IrqNumber, MyInterruptHandler );
  }
  else ... // failed

Der Aufruf der Funktion MaskIrq beendet die Behandlung des Hardwareinterrupts:

  MaskIrq( HW32, IrqNumber );

TVicHW32 hat die Fähigkeit verschiedene Interrupthandler zu installieren oder einen Interrupthandler für verschiedene
IRQs zu verwenden.

Wichtig !

· IRQ0 (Systemtimer) kann mit keiner Windowsversion benutzt werden;
· RTC (Real Time Clock) kann unter Windows NT/2000 nicht benutzt werden.

Die Funktion IsIrqMasked überprüft, ob der entsprechende Interrupt maskiert ist oder nicht. Der Zählerwert für die Anzahl der behandelten Interrupts wird von der GetIRQCounter zurückgegeben. Die Interrupts der Ack-Leitung (Pin 10) eines LPT-Ports sollte zusätzlich durch die Funktion ForceLPTIrq aktiviert werden.


Erweiterte Optionen fur die Behandlung von Hardwareinterrupts

Wie zuvor schon erwähnt, ist es sehr wichtig bei Pegel-getriggerten Interrupts nach seiner Aktivierung diesen Bus-Interrupt-Pegel wieder zu deaktivieren. Die neue Funktion UnmaskIRQEx ermöglicht es, ein Register zum Lesen/Schreiben des Interruptempfanges zu definieren:

  void UnmaskIRQEx  (
         HANDLE HW32,
         USHORT IRQNumber,
         ULONG IrqShared,
         TOnHWInterrupt HWHandler,
         pIrqClearRec IrqRec
  );

Nehmen wir an, wir müssen 0x0F0F in ein Register zum Interruptempfang schreiben. Das Register sei eine Wortverschiebung 0x320 im Speicherbereich mit der physikalischen Adresse 0x3C000:

   IrqClearRec IrqRec;               // control structure
   ULONG IrqShared = FALSE;          // interrupt is acquired
   memset(&IrqRec,0,sizeof(IrqRec)); // clean structure fields
   IrqRec.ClearIrq = 1;              // Interrupt acknowledge needed
   IrqRec.TypeOfRegister = 1;        // Register type - memory-mapped
   IrqRec.WideOfRegister =    2;     // Register size - 2 bytes (a word)
   IrqRec.ReadOrWrite = 1;           // acknowledge means write to a register
   IrqRec.RegBaseAddress = 0x3C000;  // base physical memory address
   IrqRec.RegOffset = 0x320;         // register first byte displacement in memory
   IrqRec.ValueToWrite = 0x0F0F;     // A value to write to a register for interrupt                                      // acknowledge

   UnmaskIRQEx(HwCtrl,IRQ,IrqShared, MyInterruptHandler,&IrqRec);

Der Interrupthandler ist der gleiche wie in der Grundfunktion.


Aspekte der Leistungsfahigkeit

TVicHW32 bewältigt ohne Probleme Interruptfolgen bis 10 kHz. Aber es können Verzögerungen bei der Übergabe zur Benutzerebenen auftreten, weil der Interrupthandler nicht direkt vom Treiber aufgerufen wird. Diese Verzögerungen können einige Millisekunden betragen und sind von der CPU-Belastung abhängig. Was ist zu tun, wenn diese Verzögerungen kritscih für die Anwendung sind?

Folgende Lösungen sind möglich:

· Nach Möglichkeit das Hardwaredesign ändern, um die Interruptbenutzung einzuschränken/zu vermeiden;
· Die TVicHW32 Kommerzielle Lizenz erwerben. In diesem Fall ist der Interrupthandler Teil des Treibers;
· Kundenspezifische Gerätetreiber bestellen.

Es ist wichtig zu bedenken, dass Windows kein Echtzeit-Betriebssystem ist !
Das ist der Grund, wenn die Antwortzeiten befriedigend und garantiert sein sollen, müssen Sie entweder einen kundenspezifischen Treiber bestellen oder ein Echtzeitbetriebssystem wie QNX verwenden.


Das Ansteuern der LPT ports

Einleitende Bemerkungen
Grundfunktionen fur die LPT-Ports
Benutzung verschieder Stecker-Pins der LPT-Ports
Arbeiten mit Centronix-Signalen


Einleitende Bemerkungen

Es wird vorausgesetzt, dass der Anwender mit der LPT-Port Architektur, Funktionalität und Pinbeschreibung bereits vertraut ist.

Diese Informationen sind in einer Reihe von Büchern und Handbüchern sowie im Internet erhältlich.

Folgendes exzellente Buch kann ich empfehlen:

Jan Axelson "Parallel Port Complete", erhältlich im Buchhandel und auf der Webseite des Autors:
www.lvr.com/parport.htm.

Die Webseite www.lvr.com/parport.htm ist eine exzellente Quelle für Informationen dieser Art.

TVicHW32 enthält ein Set von Funktionen um LPT-Ports auf Hardwareebene zu kontrollieren. jedoch ohne Protokolle für Datenaustausch zu bieten. Falls notwendig, können diese vom Benutzer mit Hilfe der Basisfunktionen von TVicHW32 realisiert werden.

Die neues Produkt TVicLPT - LPT-Ports bieten wird.


Grundfunktionen fur die LPT-Ports

Hier folgt eine kurze Befehlsübersicht:

GetLPTNumPorts - Gibt die Anzahl gefundener LPT-Ports zurück.
GetLPTNumber - Gibt die Nummer des aktuellen LPT-Ports zurück.
SetLPTNumber - Erlaubt die LPT-Port-Nummer zu ändern.
GetLPTBasePort - Gibt die Basisadresse der aktuellen LPT-Port-Nummer zurück.
AddNewLPT - Erlaubt eine Adresse eines benutzerdefinierten Ports anzugeben.
SetLPTReadMode - Schaltet den aktuellen LPT-Port als Eingang.
SetLPTWriteMode - Schaltet den aktuellen LPT-Port zurück auf Schreibmodus.
ForceIrqLPT - Die LPT-Schnittstelle verwendet ACK-Leitung als Interrupt (Pin 10).
AcquireLPT - Reserviert exklusiv den aktuellen LPT-Port.
ReleaseLPT - Gibt diesen wieder für andere Anwendungen frei.
IsLPTAcquired - Überprüft, ob der LPT port reserviert ist.


Benutzung verschieder Stecker-Pins der LPT-Ports

TVicHW32 ermöglicht Lese- und Schreibzugriffe auf unterschiedliche Pins der SubD25-Buchse. Um einen speziellen Pin zu setzen oder zu lesen werden die Funktionen SetPin und GetPin benutzt.

Es ist auch möglich, die Pins durch direkte Portzugriffe zu setzen, deswegen sind diese Funktionen dem Komfort zu zu rechnen.

Beachten Sie bitte, dass nicht alle Pins für Lese-/ und Schreibzugriffe zugänglich sind. Das LPTTest-Beispiel gibt hierüber weitere Auskunft.

Die Pins 2-8 vom Datenregister sind nur lesbar, wenn der Port zuvor mit SetLPTReadMode in Lesemodus versetzt wurde.


Arbeiten mit Centronix-Signalen

Hier wurden eine Reihe von Befehlen geschaffen, die sich an den Namenskonventionen der Centronix-Schnittstelle orientieren. Zu beachten ist, dass viele dieser Signale invertiert sind.

Ganauere Informationen entnehmen Sie bitte der jeweiligen Beschreibung.

GetLPTAckwl
GetLPTBusy
GetLPTPaperEnd
GetLPTSlct
GetLPTError
LPTInit
LPTSlctIn
LPTAutofd
LPTStrobe


Festplatteninformationen der Hersteller ermitteln

TVicHW32 erlaubt Herstellerinformationen von Festplatten auszulesen, einschliesslich Modell, Seriennummer,
Geometrie und andere. Bitte beachten Sie den Unterschied zwischen der Hersteller-Seriennummer und der
Seriennummer einer Partition, die beim Formatieren vergeben wird und mittels GetVolumeInformation gelesen
werden kann ! Die Hersteller-Seriennummer ist permanent und wird beim Formatieren nicht geändert.

Die folgende Funktion ermittelt die Herstellerinformationen:

void GetHDDInfo( HANDLE HW32, USHORT IdeNumber, USHORT Master, pHDDInfo Info);

Eingabeparameter für diese Funktion sind der IDE(1-4)-Kanal und "Master" oder "Slave", abhängig Das Ergebnis
erscheint in der Struktur HDDInfo.

Diese Informationen können beispielsweise für Softwareschutz verwendet werden, s. auch FAQ.


Ermitteln von PCI-Geratedaten

Ermitteln von PCI-Gerätedaten

PCI Grundfunktionen
Das Auflisten aller PCI-Gerate


PCI Grundfunktionen

GetLasPciBus - Gibt die Nummer des letzten PCI-Busses, beginnend bei 0, zurück.
GetHardwareMechanism - Gibt den PCI-Hardwaremechanismus zurück.
GetPciHeader - Liest die Daten des Headers des Configurationspace eines PCI-Gerätes anhand einer vorhandenen VendorID und DeviceID.
SetPciHeader - Schreibt Daten in den Configuration-space eines PCI-Gerätes.
GetPciDeviceInfo - Gibt eine PCI-Geräteinfo zurück anhand einer gegebenen Busnummer, Gerätenummer und Funktionsnummer.


Das Auflisten aller PCI-Gerate

Die Funktion GetPciDeviceInfo Kann benutzt werden um Informationen über alle PCI-Geräte, die installiert sind, einschliesslich AGP und PCMCIA. Das folgende Beispiel zeigt, wie es funktioniert:

int buses;
WORD n,bus,dev,func;
PCI_COMMON_CONFIG Info;

buses = GetLastPciBus(HW32); // Letzte PCI-Bus-Nummer (Erste - 0)

n = 0; // 0 Geräte wurden erkannt

for (bus = 0; bus<=buses; bus++) { //  Für alle Busse
  for (dev = 0; dev<32; dev++)   { // Für alle Geräte
    for (func= 0; func<8; func++) { // Für alle Funktionen

      if ( GetPciDeviceInfo(HwCtrl,bus,dev,func,&Info) &&
           (Info.VendorID != 0xFFFF) &&
           (Info.DeviceID != 0xFFFF ) ) {

               n++; // Gerät gefunden!
              ..    Geräteinfos aus der Info-Struktur auslesen   ..
      }
    }
  }
}


Die Tastatur kontrollieren

Einen Scan-code an den Keyboardcontroller senden
Tastatureingaben abfangen


Einen Scan-code an den Keyboardcontroller senden

TVicHW32 kann Scan-codes direkt an den Keyboadcontroller schicken und somit eine Tastatureingabe simulieren. Da dieses Senden auf Hardwareebene geschieht,sind diese Eingaben systemweit gültig.

Der Zusammenhang zwischen Scan-codes and tatsächlichen Tasten ist aus fast jedem PC-Handbuch oder dem Handbuch Ihrer Programmiersprache ersichtlich.

Es ist wichtig, daran zu denken, nach einem simulierten Tastaturanschlag auch einen „Loslass"-Code (key release code) zu senden. Dies ist der gleiche Code wie für eine Taste nur mit einer „1" als MSB.

BYTE KeyDownCode = 31; // Tastaturanschlag "s"
PutScanCode( HW32, KeyDownCode); // Tastaturanschlag senden
 PutScanCode( HW32, KeyDownCode | 0x80); // Taste wieder freigeben (release)


Tastatureingaben abfangen

void HookKeyboard( HANDLE HW32, TKbHookHandler HWHandler);

Diese Funktion installiert eine Tastaturabfrage, um Eingaben abzufangen. Wieder enfernt wird diese
durch die folgende Funktion:

The following procedure will remove this feature:

void UnhookKeyboard( HANDLE HW32).

Beispiel:

ULONG HookCounter = 0;

// Einfaches Abfangen

void __stdcall KeyboardHookHandler(BYTE scan_code)
{
   HookCounter++; // "Abfangzähler"
}

// Tastaturabfangen installieren

HookKeyboard ( HW32, KeyboardHookHandler);

..... ....

// Deaktivieren

UnhookKeyboard ( HW32 );


DMA-Puffer-Reservierung

Ubersicht DMA Puffer
Wie reserviere ich DMA-Puffer


Ubersicht DMA Puffer

Wichtig!

TVicHW32 ersetzt keine DMA Funktionen, weil der Benutzer diese unabhängig mittels anderer Funktionen tun kann. Aber TVicHW32 erlaubt es Ihnen, ein grösseres Problem bei der Reservierung von DMA-Puffer zu lösen.

Wie Sie wahrscheinlich wissen, sollte dieser Speicher den folgenden Erfordernissen genügen:

· Der physikalische Speicherbereich sollte linear sein
· Die physikalische Anfangsadresse sollte einem spezifizierten Endpunkt zugeordnet sein
· Der Speicherbereich sollte fixiert werden
· Der Speicher muss "page-locked" sein
· Für System-DMA-Operationen (über den DMA-Controller) dürfen die physikalischen Adressen nur kleiner als 16 MB sein.
· Dies gilt nicht für Bus-Master-DMA die PCI-spezifisch sind, wenn DMA-Operationen von Adaptern durchgeführt werden und nicht vom DMA-Controller. Bei System-DMA ist die Beschränkung auf 16 MB essentiell, aber leider nicht immer machbar, wenn der Speicher bereits vom System benutzt wird und keine Möglichkeit besteht, Speicher im benötigten Mass zu reservieren. In diesem Fall ist zu empfehlen, die Option "Memory Hole: 15-16 Mb" im BIOS Setup-Programm zu verwenden, die in manchen BIOS-Versionen verfügbar ist in Hinblick auf DMA-Operationen.


Wie reserviere ich DMA-Puffer

Nachfolgend ein Beispiel für die Funktion GetSysDmaBuffer :

DMA_BUFFER_REQUEST DmaBuffer;

DmaBuffer.LengthOfBuffer = 16*1024; // 16 K in our case
DmaBuffer.AlignMask = 0x00;         // aligning to 4K
if (GetSysDmaBuffer(HwCtrl,&DmaBuffer)){ // memory distribution System (Slave) DMA
     ... buffer is distributed successfully...
     ... process ...
     FreeDmaBuffer(HwCtrl,&DmaBuffer);   // freeing the buffer
}

Speicherbereiche für Bus Master DMA kann benutzt werden mit der Hilfe folgender Funktion:

GetBusmasterDmaBuffer(HwCtrl,&DmaBuffer); // Busmaster DMA Puffer reservieren.


Ausfuhren einer Benutzerfunktion auf hochprivilegierter CPU-Ebene (Ring 0)

Allgemein
RunRing0Function benutzen


Allgemein

Es ist möglich, dass Ihnen der Funktionsumfang von TVicHW32 nicht ausreicht und Sie diesen erweitern möchten. Natürlich können Sie 1-2 zusätzliche Funktionen bestellen ( order ) aber das ist nicht immer praktisch und nicht kostenlos.
Ab der Version 5 können Sie fast alles zu den Treibern hinzufügen, ohne diese zu verändern.

Die neue Funktion RunRing0Function erlaubt Ihnen, Ihre Prozeduren auf Ring0-Ebene auszuführen.
Das bedeutet, dass Sie diese Funktion nutzen können, um beliebige, privilegierte CPU-Befehle auszuführen, die zuvor nur den Treibern vorbehalten waren.


RunRing0Function benutzen

Als Beispiel direkte Portzugriffe unter Windows2000/NT:

//=================================================================
  // Diese Funktion beeinhaltet direkten Portzugriff auf Ring0-Ebene
// Sie liefert die Speichergrösse anhand der CMOS Einträge
//=================================================================

ULONG __stdcall Ring0Proc(PULONG pBaseMem)
{
   USHORT BaseMem;
   __asm {

          cli        // deaktiviert Interrupts während der Interaktion mit dem CMOS
        mov dx,70h // Liest das untere Byte
        mov al,15h
        out dx,al
        mov dx,71h
        in  al,dx
        mov byte ptr BaseMem,al

        mov dx,70h // liest das obere Byte
        mov al,16h
        out dx,al
        mov dx,71h
        in  al,dx
        mov byte ptr BaseMem+1,al
        sti   // aktiviert Interrupts
   }

  *pBaseMem = BaseMem;
  return 1; // Erfolg
}

Beim Versuch, diese Funktion direkt unter Windows NT/2000 aufzurufen, erscheint die Meldung "Privileged instruction", aber mit RunRing0Function erhalten Sie das richtige Ergebnis:

ULONG BaseMemorySize;
RunRing0Function ( HW32, Ring0Proc, &BaseMemorySize);

Hier wurden Assemblerbefehle verwendet, um zu demonstrieren, dass man jeden CPU-Befehl verwenden kann. Natürlich hätte man auch _inp() und outp() für die Portzugriffe verwenden können.


Alle TVicHW32 – Befehle und Strukturen im Uberblick

TVicHW32 5.0

Alle TVicHW32 – Befehle
und Strukturen im Uberblick

Copyright(c) Victor Ishikeev 1997-2001
http://www.entechtaiwan.com/tools.htm
tools@entechtaiwan.com


OpenTVicHW32

Lädt den TVicHW32.vxd virtuellen Gerätetreiber unter 95/98 or den TVicHW32.sys Kernelmodetreiber unter Windows NT/2000, um Direktzugriff auf die Hardware zu ermöglichen.

HANDLE OpenTVicHW32(
         HANDLE  HW32,
         char *  DriverName,
         char *  EntryPoint
       );

Parameter:

HW32 - das Handle für TVicHW32, dies muss NULL vor dem ersten Aufruf sein.
DriverName - Treibername, dieser muss "TVicHW32" lauten.
EntryPoint - Einstiegspunkt des Treibers, "TVicDevice0" oder "TVicDevice1".

Rückgabewert:

Ein neues Handle oder NULL bei einem Fehler. Dieses Handle muss beibehalten werden, um auf die Funktionen von TVicHW32 zugreifen zu können und auf CloseTVicHW32() am Ende der Anwendung.

Bemerkungen:

Wenn der Treiber erfolgreich geöffnet (gestartet) wurde, gibt die Funktion GetActiveHW() TRUE zurück, ansonsten FALSE. TVicHW32 kann von 2 Anwendungen gleichzeitig benutzt werden. Die erste Anwendung benutzt:

HW32 = OpenTVicHW32(HW32, "TVicHW32","TVicDevice0");

Die 2. Anwendung:

HW32 = OpenTVicHW32(HW32, "TVicHW32","TVicDevice1");

Siehe auch:

CloseTVicHW32 GetActiveHW


GetActiveHW

Diese Funktion überprüft, ob der Treiber aktiv ist.

  BOOL GetActiveHW ( HANDLE HW32 );

Parameter:
HW32 - Das Handle bei einem erfolgreichen Start mittels OpenTVicHW32

Rückgabewert:

TRUE falls der Treiber bereits aktiv ist, ansonsten FALSE.

Bemerkungen:

Sofort anzuwenden nach OpenTVicHW32() call.

Siehe auch:

OpenTVicHW32 CloseTVicHW32


CloseTVicHW32

Schliesst den Kernelmodetreiber und gibt seinen Speicher frei. Wenn Hardwareinterrupts unmaskiert waren, werden die Masken wieder restauriert.

HANDLE CloseTVicHW32 ( HANDLE HW32 );

Parameters:
HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32.

Return Value :
NULL.

Siehe auch:
OpenTVicHW32 GetActiveHW


MapPhysToLinear

Legt eine bestimmte physikalische Adresse auf einen Zeiger im linearen Speicher für den Adressraum des aktuellen Prozesses. Diese Funktion ist dafür gedacht auf gerätespezifischen physikalischen Speicher zuzugreifen, für die „memory-mapped" – Geräte, d.h. für die Geräte, die über Speicherzugriffe angesprochen werden.

ULONG MapPhysToLinear (
         HANDLE HW32,
         ULONG  PhysAddr,
         ULONG  MappedSize
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PhysAddr - 32-bit physikalische Adresse des Anfangs des zu prüfenden Bereichs.
MappedSize - Länge in Bytes des physikalischen Bereichs. Die Funktion benutzt diesen Parameter um zu überprüfen, ob der gesamte Bereich adressierbar ist.

Rückgabewert:

Die lineare Adresse des ersten Bytes im gewählten Bereich der physikalischen Adresse.

Bemerkungen:

1. Gibt den Datentyp ULONG zurück. Dieser sollte vor Benutzung in einen Zeiger konvertiert werden
2. Der belegte physikalische Speicher muss mit UnmapMemory wieder freigegeben werden,w enn die Anwendung beendet wird.
3. Es werden keine Informationen zurückgegeben, falls wenn die Adressen ausserhalb des angeforderten Bereichs liegen.

Siehe auch:

UnmapMemory


UnmapMemory

Gibt eine definierte physikalische Adresse wieder frei, die MapPhysToLinear belegt wurde.

void UnmapMemory (
          HANDLE HW32,
          ULONG  PhysAddr,
          ULONG  MappedSize
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PhysAddr - 32-bit physikalische Adresse des Beginns des Bereichs der zuvor belegt wurde.
MappedSize - Länge in Bytes des belegten Bereichs.

Rückgabewert:

Kein.

Siehe auch:

MapPhysToLinear


GetMem

Liest EIN Byte aus dem Speicherbereich. Dies ist hauptsächlich für Visual Basic Anwender gedacht, die nur begrenzte Möglichkeiten der Zeiger-Manipulationen haben.

BYTE GetMem(
        HANDLE HW32,
        ULONG  MappedAddress,
        ULONG  MemOffset
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
MappedAddress - die lineare Adresse die von MapPhysToLinear zurückgegeben wird.
MemOffset - der Offsetwert, der bei "0" beginnen sollte.

Rückgabewert:

1 Byte aus dem Bereich.

Bemerkungen:

Normalerweise kann "MappedAddress" irgendein gültiger linearer Zeiger auf den Speicher sein, aber wenn der Zeiger von der MapPhysToLinear Funktion empfangen wurde, kann man auch auf den physikalischen Speicher zugreifen.

Siehe auch:

MapPhysToLinear UnmapMemory GetMemW GetMemL SetMem SetMemW SetMemL


GetMemW

Liest ZWEI Bytes (16-Bit) aus dem Speicherbereich, ansonsten wie GetMem .

BYTE GetMemW(
        HANDLE HW32,
        ULONG  MappedAddress,
        ULONG  MemOffset
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
MappedAddress - die lineare Adresse die von MapPhysToLinear zurückgegeben wird.
MemOffset - Offsetwert, der bei "0" beginnen sollte.

Rückgabewert:

2 Bytes (word) aus dem Speicherbereich.

Siehe auch:

MapPhysToLinear UnmapMemory GetMem GetMemL SetMem SetMemW SetMemL


GetMemL

Liest VIER Bytes (double word) aus dem Speicherbereich, ansonsten wie GetMem.

BYTE GetMemL(
        HANDLE HW32,
        ULONG  MappedAddress,
        ULONG  MemOffset
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf OpenTVicHW32 ;
MappedAddress - die lineare Adresse die von MapPhysToLinear zurückgegeben wird.
MemOffset - der Offsetwert, der bei "0" beginnen sollte.

Rückgabewert:

4 Bytes (double word) aus dem Speicherbereich.

Siehe auch:

MapPhysToLinear UnmapMemory GetMem GetMemW SetMem SetMemW SetMemL


SetMem

Schreibt EIN Byte in den Speicherbereich. Dies ist hauptsächlich für Visual Basic Anwender gedacht, die nur begrenzte Möglichkeiten der Zeiger-Manipulationen haben.

void SetMem(
        HANDLE HW32,
        ULONG  MappedAddress,
        ULONG  MemOffset,
        BYTE   bValue
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
MappedAddress - die lineare Adresse die von MapPhysToLinear zurückgegeben wird.
MemOffset - der Offsetwert, der bei "0" beginnen sollte.
bValue - der Wert zum Schreiben.

Rückgabewerte:

Kein.

Bemerkungen:

Normalerweise kann "MappedAddress" irgendein gültiger linearer Zeiger auf den Speicher sein, aber wenn der Zeiger von der MapPhysToLinear Funktion empfangen wurde, kann man auch auf den physikalischen Speicher zugreifen.

Siehe auch:


SetMemW

Schreibt ZWEI Bytes in den Speicherbereich, ansonsten wie SetMem.

void SetMemW(
        HANDLE HW32,
        ULONG  MappedAddress,
        ULONG  MemOffset,
        USHORT wValue
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
MappedAddress - die lineare Adresse die von MapPhysToLinear zurückgegeben wird.
MemOffset - der Offsetwert, der bei "0" beginnen sollte.
wValue - zu schreibender Wert.

Rückgabewerte:

Kein.

Siehe auch:

MapPhysToLinear UnmapMemory GetMem GetMemW GetMemL SetMem SetMemL


SetMemL

Schreibt VIER Bytes (double word) in den Speicherbereich, ansonsten wie SetMem.

void SetMemL(
        HANDLE HW32,
        ULONG  MappedAddress,
        ULONG  MemOffset,
        ULONG  dwValue
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
MappedAddress - die lineare Adresse die von MapPhysToLinear zurückgegeben wird.
MemOffset - der Offsetwert, der bei "0" beginnen sollte.
dwValue - zu schreibender Wert.

Rückgabewert:

Kein.

Siehe auch:

MapPhysToLinear UnmapMemory GetMem GetMemW GetMemL SetMem SetMemW


SetHardAccess

Bestimmt, ob der Treiber "hard" oder "soft" Zugriffe auf die Ports ausführt.

void SetHardAccess(
        HANDLE  HW32,
        BOOL    AccessMode
     );

Parameter:
HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
AcessMode - TRUE => "hard" Zugriffe, FALSE =>"soft" - Zugriffe.

Rückgabewerte:

Keine.

Bemerkungen:

"Soft" Zugriffe bieten schnellere Portzugriffe, aber können scheitern, wenn bereits ein anderer Kernelmodetreiber auf die gleichen Ports zugreift "Hard" Zugriffe sind langsamer, dafür sicherer, falls ein Port auch durch einen anderen Treiber bereits benutzt wird.

Siehe auch:

GetHardAccess


GetHardAccess

Gibt den aktuellen Zugriffsmodus auf die Ports zurück.

BOOL GetHardAccess(
          HANDLE  HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewerte:

TRUE   für "hard".
FALSE für "soft".

Bemerkungen:

"Soft" Zugriffe bieten schnellere Portzugriffe, aber können scheitern, wenn bereits ein anderer Kernelmodetreiber auf die gleichen Ports zugreift "Hard" Zugriffe sind langsamer, dafür sicherer, falls ein Port auch durch einen anderen Treiber bereits benutzt wird.

Siehe auch:
SetHardAccess


GetPortByte

Liest ein Byte von der angegebenen Portadresse.

BYTE GetPortByte(
        HANDLE HW32,
        ULONG  PortAddress
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PortAddress - Die Portadresse des E/A-Bereichs.

Rückgabewert:

Das gelesene Byte der angegebenen Portadresse.

Siehe auch:

GetPortWord GetPortLong SetPortByte SetPortWord SetPortLong


GetPortWord

Liest 2 Bytes (Wort) von der angegebenen Portadresse.

USHORT GetPortWord(
        HANDLE HW32,
        ULONG  PortAddress
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
PortAddress - Die Portadresse des E/A-Bereichs

Rückgabewert:

Das gelesene Wort der angegebenen Portadresse.

Siehe auch:

GetPortByte GetPortLong SetPortByte SetPortWord SetPortLong


GetPortLong

Liest 4 Bytes (DoppelWort) von der angegebenen Portadresse.

ULONG GetPortLong(
         HANDLE HW32,
         ULONG  PortAddress
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PortAddress - Die Portadresse des E/A-Bereichs.

Rückgabewert:

Das gelesene DoppelWort der angegebenen Portadresse.

Siehe auch:

GetPortByte GetPortWord SetPortByte SetPortWord SetPortLong


SetPortByte

Schreibt ein Byte an die angegebene Portadresse.

void SetPortByte(
        HANDLE  HW32,
        ULONG   PortAddress,
        UCHAR   bValue
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PortAddress - Die Portadresse des E/A-Bereichs.
bValue - das zu schreibende Byte.

Rückgabewert:

Keine.

Siehe auch:

GetPortByte GetPortWord GetPortLong SetPortWord SetPortLong


SetPortWord

Schreibt 2 Bytes an die angegebene Portadresse.

void SetPortWord(
        HANDLE  HW32,
        ULONG   PortAddress,
        USHORT  wValue
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PortAddress - Die Portadresse des E/A-Bereichs.
wValue - das zu schreibende Wort.

Rückgabewert:

Keiner.

Siehe auch:

GetPortByte GetPortWord GetPortLong SetPortByte SetPortLong


SetPortLong

Schreibt 4 Bytes an die angegebene Portadresse.

void SetPortLong(
        HANDLE  HW32,
        ULONG   PortAddress,
        ULONG   dwValue
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PortAddress - Die Portadresse des E/A-Bereichs.
dwValue - das zu schreibende Doppelwort.

Rückgabewert:

Keiner.

Siehe auch:


ReadPortFIFO

Liest eine Anzahl von Bytes von einer gegebenen Portadresse in einen Puffer.

void ReadPortFIFO(
         HANDLE       HW32,
         PFIFO_RECORD pPortRec
);

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
pPortRec - Zeigt auf die Struktur FIFO_RECORD , die die Portadresse, einen Puffer in den ein Datenfeld von Bytes gelesen wird und die Anzahl der Bytes die in diesen Puffer gelesen werden, beinhaltet.

Rückgabewert:

Keiner.

Siehe auch:


ReadPortWFIFO

Liest eine Anzahl von Worten von einer gegebenen Portadresse in einen Puffer.

void ReadPortWFIFO(
         HANDLE        HW32,
         PFIFO_RECORDW pPortRec
);

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
pPortRec - Zeigt auf die Struktur FIFO_RECORDW , die die Portadresse, einen Puffer in den ein Datenfeld von Worten gelesen wird und die Anzahl der Worte, die in diesen Puffer gelesen werden, beinhaltet.

Rückgabewert:

Keiner.

Siehe auch:

ReadPortFIFO ReadPortLFIFO WritePortFIFO WritePortWFIFO WritePortLFIFO


ReadPortLFIFO

Liest eine Anzahl von DoppelWorten von einer gegebenen Portadresse in einen Puffer.

void ReadPortLFIFO(
         HANDLE        HW32,
         PFIFO_RECORDL pPortRec
);

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
pPortRec - Zeigt auf die Struktur FIFO_RECORDL , die die Portadresse, einen Puffer in den ein Datenfeld von DoppelWorten gelesen wird und die Anzahl der DoppelWorte, die in diesen Puffer gelesen werden, beinhaltet.

Rückgabewert:

Keiner.

Siehe auch:


WritePortFIFO

Schreibt eine Anzahl von Bytes zu einer gegebenen Portadresse in einen Puffer.

void WritePortFIFO(
          HANDLE       HW32,
          PFIFO_RECORD pPortRec
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
pPortRec - Zeigt auf die Struktur FIFO_RECORD, die die Portadresse, einen Puffer in den ein Datenfeld von Bytes geschrieben wird und die Anzahl der Bytes die in diesen Puffer geschrieben werden, beinhaltet.

Rückgabewert:

Keiner.

Siehe auch:


WritePortWFIFO

Schreibt eine Anzahl von Worten zu einer gegebenen Portadresse in einen Puffer.

void WritePortWFIFO(
          HANDLE        HW32,
          PFIFO_RECORDW pPortRec
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
pPortRec - Zeigt auf die Struktur FIFO_RECORDW, die die Portadresse, einen Puffer in den ein Datenfeld von Worten geschrieben wird und die Anzahl der Worte die in diesen Puffer geschrieben werden, beinhaltet.

Rückgabewert:

Keiner.

Siehe auch:

ReadPortFIFO ReadPortWFIFO ReadPortLFIFO WritePortFIFO WritePortLFIFO


WritePortLFIFO

Schreibt eine Anzahl von Doppelworten zu einer gegebenen Portadresse in einen Puffer.

void WritePortLFIFO(
          HANDLE        HW32,
          PFIFO_RECORDL pPortRec
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
pPortRec - Zeigt auf die Struktur FIFO_RECORDL, die die Portadresse, einen Puffer in den ein Datenfeld von Doppelworten geschieben wird und die Anzahl der Doppelworte die in diesen Puffer geschrieben werden, beinhaltet.

Rückgabewert:

Keiner.

Siehe auch:


UnmaskIRQ

Installiert einen Hardwareinterrupt-Handler für dwn ausgewählten IRQ und demaskiert diesen IRQ auf Hardwareebene.

void UnmaskIRQ(
       HANDLE         HW32,
       USHORT         IrqNumber,
       TOnHWInterrupt InterruptHandler
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IrqNumber - Nummer des Interrupts (1-15).
InterruptHandler - Adresse der Callback-Prozedur die die Hardwareinterrupts für diesen IRQ bearbeitet.

Rückgabewert:

Keiner.

Bemerkung:

1. Die Interrupthandler-Funktion muss folgendermassen deklariert werden:

typedef void (__stdcall * TOnHWInterrupt)(USHORT IRQNumber);

2. Diese Funktion ist ein spezieller Fall der gebräuchlicheren Funktion UnmaskIRQEx.

Siehe auch:


UnmaskIRQEx

Installiert einen Hardwareinterrupt-Handler für dwn ausgewählten IRQ und demaskiert diesen IRQ auf Hardwareebene. UnmaskIRQEx erlaubt die Behandlung von "shared", "level sensitive" und "edge triggered" Interrupts.

void UnmaskIRQ(
       HANDLE         HW32,
       USHORT         IrqNumber,
       ULONG          IsIrqShared,
       TOnHWInterrupt InterruptHandler,
       pIrqClearRec   IrqRec
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IrqNumber - Nummer des Interrupts (1-15).
IsIrqShared - legt fest, ob dieser Interrupt shared(1) oder nicht (0) ist.
InterruptHandler - Adresse der Callback-Prozedur die die Hardwareinterrupts für diesen IRQ bearbeitet.
IrqRec - zeigt auf die Struktur IrqClearRec, die beschreibt, wie ein Interrupt im Treiber durchzuführen ist.

Rückgabewert:

Keiner.

Bemerkungen:

1. Die Interrupthandler-Funktion muss folgendermassen deklariert werden:

typedef void (__stdcall * TOnHWInterrupt)(USHORT IRQNumber);

2. Diese Funktion hilft die "level sensitive" Interrupts besser als die "edge triggered" zu behandeln. Wenn der Interrupt-Pegel auf dem Bus nicht am Ende der Interruptbehandlung fällt, ruft das System den Interrupthandler immer wieder auf und hängt Mittels der UnmaskIRQEx() Funktion kann man dem Treiber mitteilen, wie dieser einen Interrupt in einem primären Interrupthandler löscht.

Es ist nicht notwendig, den Interrupt-Pegel in Ihrer Benutzer-Interrupt-Behandlungsroutine zu löschen, weil dies der Treiber für Sie erledigt.

Siehe auch:
MaskIRQ UnmaskIRQ IsIRQMasked GetIRQCounter


MaskIRQ

Stoppt die Interruptprozesse die mit UnmaskIRQ oder UnmaskIRQEx gestartet wurden durch Maskieren des gewählten Interrupts auf Hardwareebene.

void MaskIRQ(
       HANDLE HW32,
       USHORT IrqNumber
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IrqNumber - Nummer des Interrupts (1-15).

Rückgabewert:

Keiner.

Siehe auch:


IsIRQMasked

Überprüft, ob der benannte Interrupt maskiert ist oder nicht.

BOOL IsIRQMasked(
       HANDLE HW32,
       USHORT IrqNumber
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IrqNumber - Nummer des Interrupts (1-15).

Rückgabewert:

TRUE wenn maskiert, ansonsten FALSE

Siehe auch:


GetIRQCounter

Gibt die Anzahl der behandelten Interrupts durch den Treiber zurück.

ULONG GetIRQCounter(
         HANDLE HW32,
         USHORT IrqNumber
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IrqNumber - Nummer des Interrupts (1-15).

Rückgabewert:

Anzahl der behandelten Interrupts durch den Treiber

Siehe auch:


GetLPTNumPorts

Gibt die Anzahl der installierten LPT-Ports auf dem PC zurück.

UCHAR GetLPTNumPorts(
         HANDLE  HW32
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Anzahl der installierten LPT-Ports.

Siehe auch:

GetLPTBasePort GetLPTNumber SetLPTNumber


GetLPTNumber

Gibt die aktuelle LPT-Port-Nummer zurück.

UCHAR GetLPTNumber(
         HANDLE HW32
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32.

Rückgabewert:

Aktuelle LPT-Port-Nummer (1 - LPT1, 2 - LPT2  etc.).

Bemerkung:

Es ist notwendig einen aktuellen LPT-Port festzulegen, um andere LPT-Funktionen benutzen zu können.

Siehe auch:


SetLPTNumber

Setzt den gewählten LPT-Port als aktuell (current).

void SetLPTNumber(
        HANDLE  HW32,
        UCHAR   LptNumber
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
LptNumber - LPT-Port-Nummer (1 - LPT1, 2 - LPT2 etc.).

Bemerkungen:

Es ist notwendig einen aktuellen LPT-Port festzulegen, um andere LPT-Funktionen benutzen zu können.

Siehe auch:


GetLPTBasePort

Gibt die Basisadresse des aktuellen LPT-Ports zurück.

ULONG GetLPTBasePort(
         HANDLE HW32
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32

Rückgabewert:

Basisadresse des aktuellen LPT-Ports (=DataPort).

Siehe auch:


Add New LPT

Erlaubt eine Adresse für einen benutzerdefinierten Port zu vergeben, der nicht standard ist.

UCHAR AddNewLPT(
         HANDLE HW32,
         USHORT PortBaseAddress
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PortBaseAddress - Wort das die Basisadresse des eigenen LPT-Ports angibt.

Rückgabewert:

Nummer des hinzugefügten LPT-Ports.

Siehe auch:


AcquireLPT

Erlaubt anderen Anwendungen, einschliesslich dem Drucksystem, von der Benutzung des gewählten
LPT-Ports abzuhalten.

USHORT AcquireLPT(
              HANDLE  HW32,
              USHORT  LPTNumber
       );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
LPTNumber - LPT Port (1,2,...).

Rückgabewerte:

LPT_ACQUIRE_SUCCESS – Der Port ist erfolgreich gesperrt.

LPT_ACQUIRE_NOT_OPENED - TVicHW32 wurde nicht geöffnet.

LPT_ACQUIRE_BAD_PORT - ungültige LPT number.

LPT_ACQUIRE_REFUSED – Der Port wurde bereits von einem anderen Prozess gesperrt.

Bemerkungen:

Werk unter 95/98/ME.

Siehe auch:


ReleaseLPT

Gibt den durch AcquireLPT function gesperrten LPT-Port wieder frei.

void ReleaseLPT(
            HANDLE HW32,
            USHORT LPTNumber
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
LPTNumber - LPT-Port-Nummer (1,2,...).

Rückgabewert:

Keiner.

Bemerkungen:

Werk unter 95/98/ME.

Siehe auch:


IsLPTAcquired

Überprüft, ob der angegebene Port gesperrt ist.

USHORT IsLPTAcquired(
         HANDLE HW32,
         USHORT LPTNumber
       );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
LPTNumber - LPT-Port-Nummer (1,2,...).

Rückgabewerte:

LPT_ACQUIRE_SUCCESS – das Sperren war erfolgreich
LPT_ACQUIRE_NOT_OPENED - TVicHW32 driver ist nicht geöffnet
LPT_ACQUIRE_BAD_PORT – ungültige LPT-Nummer
LPT_NOT_ACQUIRED – der Port ist nicht gesperrt

Siehe auch:

AcquireLPT ReleaseLPT


GetPin

Erlaubt, den elektrischen Pegel des gewählten Pins des aktuellen LPT-Ports zu lesen.

BOOL GetPin(
        HANDLE HW32,
        UCHAR  PinNumber
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PinNumber - die gewählte Pin-Nummer (1-25).

Rückgabewerte:

TRUE => High, ansonsten Low

Bemerkung:

Nicht alle Pins sind durch diese Funktion abfragbar. Lesen Sie die LPT-Dokumentation oder probieren Sie das LPT Testbeispiel aus.

Siehe auch:
SetPin


SetPin

Ermöglicht die einzelnen Pins des aktuellen LPT-Ports zu setzen.

void SetPin(
        HANDLE HW32,
        UCHAR  PinNumber,
BOOL PinLevel
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
PinNumber - die gewählte Pin-Nummer (1-25).
PinLevel - der zu setzende Pegel (TRUE => HIGH , FALSE => LOW).

Rückgabewerte:

Keiner.

Bemerkung:

Nicht alle Pins sind durch diese Funktion abfragbar. Lesen Sie die LPT-Dokumentation oder probieren
Sie das LPT Testbeispiel aus.

Siehe auch:
GetPin


GetLPTAckwl

Gibt den Status der Acknowledge-Leitung des aktuellen LPT-Ports zurück.

BOOL GetLPTAckwl(
        HANDLE   HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

TRUE => Aktive, ansonsten Inaktiv.


GetLPTBusy

Gibt den Status der BUSY - Leitung des aktuellen LPT-Ports zurück.

BOOL GetLPTBusy(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

TRUE => Aktive, ansonsten Inaktiv.


GetLPTPaperEnd

Gibt den Status der Paper End - Leitung des current LPT-Ports zurück.

BOOL GetLPTPaperEnd(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

TRUE => Aktive, ansonsten Inaktiv.


GetLPTSlct

Gibt den Status der Select –Leitung des aktuellen LPT-Ports zurück.

BOOL GetLPTSlct(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

TRUE => Aktive, ansonsten Inaktiv.


GetLPTError

Gibt den Status der Error – Leitung des aktuellen Ports zurück

BOOL GetLPTError(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

TRUE => Aktive, ansonsten Inaktiv.


LPTStrobe

Erzeugt einen kurzen Impuls (Strobe) an Pin 1 des aktuellen LPT-Ports.

void LPTStrobe(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Keiner.


LPTAutofd

Setzt den aktuellen Staus der Autofeed – Leitung des aktuellen LPT-Ports.

void LPTAutofd(
        HANDLE HW32,
        BOOL   Flag
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
Flag - RUE => Aktive, ansonsten Inaktiv.

Rückgabewert:

Keiner.


LPTInit

Erzeugt kurze Impulse auf der INIT – Leitung des aktuellen Druckerports.

void LPTInit(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Keiner.


LPTSlctIn

Setzt das SELECTIN – Signal auf den aktuellen LPT-Port.

void LPTSlctIn(
        HANDLE HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Keiner.


LPTPrintChar

Sendet ein Zeichen zum Drucker im Kompatibilitätsmodus (LPT "Compatible Mode").

BOOL LPTPrintChar(
        HANDLE HW32,
        UCHAR  ch
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
ch - Zeichen zum drucken.

Rückgabewert:

TRUE wenn erfolgreich, ansonsten FALSE.


ForceLPTIrq

Zwingt ein LPT Gerät Interrupts zu erzeugen, wenn die Ack-Leitung (Pin 10) durch ein externes Gerät getriggert wurde. Die Anwendung muss diese Funktion vor UnmaskIRQ oder UnmaskIRQEx benutzen.

void ForceLPTIrq(
          HANDLE HW32,
          BOOL   IrqEnable
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IrqEnable - TRUE => LPT IRQ aktiv, ansonsten inaktiv

Rückgabewert:

None.

Siehe auch:


SetLPTReadMode

Schaltet den aktuellen LPT-Port auf lesen über das Datenregister (Pins 2-9).

void SetLPTReadMode(
        HANDLE HW32
       );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Keiner.

Bemerkungen:
1. Der aktuelle LPT-Port sollte "bidirektional" sein und als PS/2 oder ECP konfiguriert sein
2. Der Port muss wieder auf schreiben geschaltet werden, bevor Daten geschrieben werden können.

Siehe auch:

SetLPTWriteMode


SetLPTWriteMode

Schaltet den aktuellen LPT-Port zurück auf schreiben, um Daten über das Datenregister auf die Pins 2-9 senden zu.

void SetLPTWriteMode(
        HANDLE  HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Keiner.

Bemerkungen:

Der Port muss auf lesen geschaltet werden, um Daten lesen zu können.

Siehe auch:

SetLPTReadMode


GetHDDInfo

Erlaubt Zugriffe auf die Herstellerinformationen der Festplatten wie Seriennummer, Geometrie, etc.

void GetHDDInfo(
        HANDLE    HW32,
        USHORT    IdeNumber,
        USHORT    Master,
        HDDInfo * Info
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
IdeNumber - Der gewählte IDE-Controller (1-4).
Master - "Master disk" =1 oder "0" für "Slave disk".
Info - verweist auf die Struktur HDDInfo, die die angeforderten Informationen enthält.

Rückgabewert:

Keiner.


GetLastPciBus

Gibt die letzte PCI-Bus-Nummer Ihres PC zurück.

USHORT GetLastPciBus(
          HANDLE HW32
       );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewert:

Die letzte PCI-Bus-Nummer, beginnend mit 0

Siehe auch:

GetHardwareMechanism GetPciDeviceInfo


GetHardwareMechanism

Gibt den Hardware PCI-Mechanismus Ihres PC zurück.

USHORT GetHardwareMechanism(
          HANDLE HW32
       );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Rückgabewerte:

Der Hardware-PCI-Mechanismus 1 oder 2.

Siehe auch:

GetPciDeviceInfo GetLastPciBus


GetPciDeviceInfo

Gibt eine PCI Geräteinfo zurück anhand einer gegebenen Bus-Nummer, Geräte-Nummer und Funktions-Nummer.

BOOL GetPciDeviceInfo(
        HANDLE HW32,
        USHORT BusNum,
        USHORT DeviceNum,
        USHORT FuncNum,
        PCI_COMMON_CONFIG * PciConfig
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
BusNum - PCI-Bus-Nummer (0..bis GetLastPciBus)
Device - PCI Gerät auf dem Bus (0..31);
FuncNum - Funktions-Nummer des Gerätes (0..7);
PciConfig - enthält die gesuchten Informationen, dokumentiert in der Datei TVicHW32.h als auch in den Dateien TVicHW32.pas/TVicHW32.bas.

Rückgabewert:

TRUE => Gerät existiert, ansonsten FALSE.

Siehe auch:


GetPciHeader

Liest den Header des Configuration space eines Gerätes aus in die Struktur PciConfig.

BOOL GetPciHeader(
        HANDLE      HW32,
        USHORT      VendorId,
        USHORT      DeviceId,
        USHORT      StartOffset,
        USHORT      Count,
        PCI_COMMON_CONFIG * PciConfig
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
DeviceId - PCI Geräte Identifikation (DID) des Gerätes.
StartOffset - Null-basierter Offset in Bytes vom Anfang des Configurationspace an dem die Leseoperation beginnen soll, anwendbar für den Geräte-Configurationspace und für die Struktur PciConfig.

Count - Anzahl der zu übertragenden Bytes.
PciConfig - enthält die gesuchten Informationen, dokumentiert in der Datei TVicHW32.h als auch in den Dateien TVicHW32.pas/TVicHW32.bas.

Rückgabewert:

TRUE => Gerät existiert, ansonsten FALSE.

Siehe auch:

SetPciHeader, GetPciDeviceInfo


SetPciHeader

GetPciHeader

Schreibt Daten in den Header des PCI-Configurationspace des Gerätes aus dem unterstützen Puffer.

BOOL GetPciHeader(
        HANDLE   HW32,
        USHORT   VendorId,
        USHORT   DeviceId,
        USHORT   StartOffset,
        USHORT   Count,
        PCI_COMMON_CONFIG * PciConfig
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
DeviceId       -  PCI Geräte Identifikation (DID) des Gerätes.
VendorId      -  PCI – Geräte-Hersteller-Identifikation (VID) des Gerätes.
StartOffset    -  Null-basierter Offset in Bytes vom Anfang des Configurationspace an dem die Leseoperation beginnen soll, anwendbar für den Geräte-Configurationspace und für die Struktur PciConfig.

PciConfig  - enthält die gesuchten Informationen, dokumentiert in der Datei TVicHW32.h als auch in den Dateien. TVicHW32.pas/TVicHW32.bas.

Count              -   Anzahl der zu übertragenden Bytes.

Rückgabewert:

TRUE => Gerät existiert, ansonsten FALSE.

Siehe auch:

GetPciHeader, GetPciDeviceInfo


PutScanCode

Sendet einen Tastatur-Scancode direkt zum Keyboardcontroller.

void PutScanCode(
        HANDLE HW32,
        UCHAR  scode
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
scode - Scancode zum Senden.

Bemerkung:

Es darf nicht vergessen werden einen "Key Up code" nach dem "Key Down code" zu senden !
KeyUpCode = KeyDownCode | 0x80.


HookKeyboard

Diese Funktion installiert eine systemweite Tastaturabfrage und fängt alle Tastatureingaben ab. Beachten Sie das
keyboard test Beispiel für weitere Informationen.

void HookKeyboard(
         HANDLE HW32,
         TKbHookHandler KbdHandler
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
KbdHandler - Tastaturabfrageprozedur.

Bemerkung:

1. Die Tastaturabfrage muss folgendermassen deklariert werden:

typedef void (__stdcall * TKbHookHandler)(UCHAR ScanCode);

2. Es kann nur eine Abfrage mit TVicHW32 installiert werden

Siehe auch:

UnhookKeyboard


UnhookKeyboard

Deinstalliert eine mit HookKeyboard() installierte Tastaturabfrage.

void UnhookKeyboard(
           HANDLE  HW32
     );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .

Siehe auch:

HookKeyboard


RunRing0Function

Erlaubt die Ausführung von Benutzerebenen-Funktionen auf hochprivilegierter CPU-Ebene (Ring0). Die Benutzerebenen-Funktion kann direkte E/A-Operationen durchführen, die Inhalte der CPU-Kontrollregister lesen,wie CR0, CR2 und mehr.

ULONG RunRing0Function(
         HANDLE         HW32,
         TRing0Function R0Func,
         PVOID          pParm
      );

Parameter:

HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 .
R0Func - zeigt auf die Benutzerebene-Funktion die als Ring0 Operation von der CPU ausgeführt werden soll.
pParm - Zeiger der zu R0Func als Parameter übergeben wird.

Rückgabewert:

Der ULONG – Wert, zurückgegeben von der R0Func.

Bemerkung:

Die R0Func muss folgendermassen deklariert werden:

typedef ULONG (__stdcall * TKbHookHandler)(PVOID pParm);

Siehe R0Test Beispiel für weitere Details.


GetSysDmaBuffer

Erlaubt einen Puffer für System-(Slave)-DMA Zugriffe zu reservieren innerhalb des Bereiches der ersten 16 MB.

BOOL GetSysDmaBuffer(
        HANDLE HW32,
        DMA_BUFFER_REQUEST * DmaRec
     );

Parameter:
HW32 - das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
DmaRec - die Struktur vom Typ DMA_BUFFER_REQUEST.

Rückgabewert:
TRUE, wenn erfolgreich.

Bemerkung:
"15-16 MB Memory Hole" im BIOS-Setup aktivieren. Nicht vergessen den DMA-Speicher wieder freizugeben ! Behalten und ändern Sie nicht die DmaReq – Struktur für die Funktion FreeDmaBuffer!

Siehe auch:


GetBusmasterDmaBuffer

Erlaubt einen Puffer für Busmaster- DMA – Zugriffe zu reservieren, normalerweise für PCI – Geräte.

BOOL GetBusmasterDmaBuffer (
        HANDLE HW32,
        DMA_BUFFER_REQUEST * DmaRec
     );

Parameter:
HW32 - das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32 ;
DmaRec - die Struktur vom Typ DMA_BUFFER_REQUEST.

Rückgabewert:
TRUE, wenn erfolgreich.

Bemerkung:
Nicht vergessen den DMA-Speicher wieder freizugeben ! Behalten und ändern Sie nicht die DmaReq – Struktur für die Funktion FreeDmaBuffer!

Siehe auch:


FreeDmaBuffer

Gibt den zuvor mittels GetSysDmaBuffer oder GetBusmasterDmaBuffer belegten Speicher wieder frei.

void GetBusmasterDmaBuffer (
        HANDLE HW32,
        DMA_BUFFER_REQUEST * DmaRec
);

Parameter:
HW32 - Das Handle nach einem erfolgreichen Aufruf von OpenTVicHW32
DmaRec - die Struktur vom Typ DMA_BUFFER_REQUEST.

Siehe auch:


FIFO_RECORD

typedef struct _FIFO_RECORD {

        ULONG PortAddr; // die gewählte Portadresse
        ULONG NumPorts; // Anzahl der Bytes zum Einlesen oder Schreiben in
// den Puffer von/zu der gewählten Portadresse
        UCHAR Buf[1];     // der Pufferspeicher

} FIFO_RECORD, *PFIFO_RECORD;


FIFO_RECORDW

typedef struct _FIFO_RECORDW {

        ULONG PortAddr;  // die gewählte Portadresse
        ULONG NumPorts;  // Anzahl der Worte zum Einlesen oder Schreiben in
// den Puffer von/zu der gewählten Portadresse
        USHORT Buf[1];     // der Pufferspeicher

} FIFO_RECORDW, *PFIFO_RECORDW;


FIFO_RECORDL

typedef struct _FIFO_RECORL {

        ULONG PortAddr; // die gewählte Portadresse
        ULONG NumPorts; // Anzahl der Doppelworte zum Einlesen oder Schreiben in
// den Puffer von/zu der gewählten Portadresse
        ULONG Buf[1];     // der Pufferspeicher

} FIFO_RECORL, *PFIFO_RECORL;


IrqClearRec

typedef struct _IrqClearRec {

        UCHAR ClearIrq;                  // 1 => IRQ muss gelöscht werden, 1 => nicht
        UCHAR TypeOfRegister;    // 0 => Memory-mapped register, 1 => Port
        UCHAR WideOfRegister;     // Registerbreite: 1 => Byte,2 => Wort, 4 => Doppelwort
        UCHAR ReadOrWrite;          // 0 => Lese Register um IRQ zu löschen, 1 => schreiben
        ULONG RegBaseAddress; // Register Basisadresse
        ULONG RegOffset;               // Register Offset
        ULONG ValueToWrite;         // zu schreibender Wert (if Read Or Write=1)

} IrqClearRec, *pIrqClearRec;


PCI_COMMON_CONFIG

This structure describes the PCI configuration space for PCI devices. All PCI devices have a common set of registers that include VendorID, DeviceID, and so on. This structure differs for PCI devices of header type 0 for devices, of header type 1 for PCI-PCI bridges, and of header type 2 for PCI-CardBus bridges. For more information, see the PCI Local Bus Specification, revision 2.1 or 2.2.

typedef struct _PCI_COMMON_CONFIG {
    USHORT  VendorID;
    USHORT  DeviceID;
    USHORT  Command;
    USHORT  Status;
    UCHAR   RevisionID;
    UCHAR   ProgIf;
    UCHAR   SubClass;
    UCHAR   BaseClass;
    UCHAR   CacheLineSize;
    UCHAR   LatencyTimer;
    UCHAR   HeaderType;
    UCHAR   BIST;

    union {
        struct _PCI_HEADER_TYPE_0 {
            ULONG   BaseAddresses[PCI_TYPE0_ADDRESSES];
            ULONG   CIS;
            USHORT  SubVendorID;
            USHORT  SubSystemID;
            ULONG   ROMBaseAddress;
            ULONG   Reserved2[2];

            UCHAR   InterruptLine;
            UCHAR   InterruptPin;
            UCHAR   MinimumGrant;
            UCHAR   MaximumLatency;
        } type0;

        struct _PCI_HEADER_TYPE_1 {
            ULONG   BaseAddresses[PCI_TYPE1_ADDRESSES];
            UCHAR   PrimaryBusNumber;
            UCHAR   SecondaryBusNumber;
            UCHAR   SubordinateBusNumber;
            UCHAR   SecondaryLatencyTimer;
            UCHAR   IOBase;
            UCHAR   IOLimit;
            USHORT  SecondaryStatus;
            USHORT  MemoryBase;
            USHORT  MemoryLimit;
            USHORT  PrefetchableMemoryBase;
            USHORT  PrefetchableMemoryLimit;
            ULONG   PrefetchableMemoryBaseUpper32;
            ULONG   PrefetchableMemoryLimitUpper32;
            USHORT  IOBaseUpper;
            USHORT  IOLimitUpper;
            ULONG   Reserved2;
            ULONG   ExpansionROMBase;
            UCHAR   InterruptLine;
            UCHAR   InterruptPin;
            USHORT  BridgeControl;
        } type1;

        struct _PCI_HEADER_TYPE_2 {
            ULONG   BaseAddress;
            UCHAR   CapabilitiesPtr;
            UCHAR   Reserved2;
            USHORT  SecondaryStatus;
            UCHAR   PrimaryBusNumber;
            UCHAR   CardbusBusNumber;
            UCHAR   SubordinateBusNumber;
            UCHAR   CardbusLatencyTimer;
            ULONG   MemoryBase0;
            ULONG   MemoryLimit0;
            ULONG   MemoryBase1;
            ULONG   MemoryLimit1;
            USHORT  IOBase0_LO;
            USHORT  IOBase0_HI;
            USHORT  IOLimit0_LO;
            USHORT  IOLimit0_HI;
            USHORT  IOBase1_LO;
            USHORT  IOBase1_HI;
            USHORT  IOLimit1_LO;
            USHORT  IOLimit1_HI;
            UCHAR   InterruptLine;
            UCHAR   InterruptPin;
            USHORT  BridgeControl;
            USHORT  SubVendorID;
            USHORT  SubSystemID;
            ULONG   LegacyBaseAddress;
            UCHAR   Reserved3[56];
            ULONG   SystemControl;
            UCHAR   MultiMediaControl;
            UCHAR   GeneralStatus;
            UCHAR   Reserved4[2];
            UCHAR   GPIO0Control;
            UCHAR   GPIO1Control;
            UCHAR   GPIO2Control;
            UCHAR   GPIO3Control;
            ULONG   IRQMuxRouting;
            UCHAR   RetryStatus;
            UCHAR   CardControl;
            UCHAR   DeviceControl;
            UCHAR   Diagnostic;
        } type2;

    } u;

    UCHAR   DeviceSpecific[108];

} PCI_COMMON_CONFIG , *PPCI_COMMON_CONFIG;

Members

VendorID
PCI vendor identifier register.
DeviceID
PCI device identifier register.
Command
PCI command register.
Status
PCI status register.
RevisionID
PCI revision identifier register.
ProgIf
PCI programming interface register.
SubClass
PCI device sub-class register.
BaseClass
PCI device base-class register.
CacheLineSize
PCI cache line size register.
LatencyTimer
PCI latency timer register.
HeaderType
PCI header type register. 0 indicates a normal PCI device, 1 indicates a PCI-PCI bridge, and 2 indicates a PCI-CardBus bridge.
BIST
PCI built-in self test register.
BaseAddresses
Array of PCI base address registers. Normal PCI devices have 6 base address registers, while PCI-PCI bridges have 2 and PCI-CardBus bridges have 1.
CIS
CardBus CIS pointer register.
SubVendorID
PCI subsystem vendor identifier register.
SubSystemID
PCI subsystem identifier register.
ROMBaseAddress
PCI ROM base address register.
Reserved2, Reserved3, Reserved4
Reserved.
InterruptLine
PCI interrupt line register.
InterruptPin
PCI interrupt pin register.
MinimumGrant
PCI minimum grant register.
MaximumLatency
PCI maximum latency register.
BaseAddress
PCI base address register.
PrimaryBusNumber
PCI primary bus number register.
SecondaryBusNumber
PCI secondary bus number register.
SubordinateBusNumber
PCI subordinate bus number.
SecondaryLatencyTimer
PCI secondary latency timer.
IOBase
Lower 8 bits of PCI I/O base address register.
IOLimit
Lower 8 bits of PCI I/O limit address register.
SecondaryStatus
PCI secondary status register.
MemoryBase
PCI memory base address register.
MemoryLimit
PCI memory limit address register
PrefetchableMemoryBase
Lower 16 bits of PCI prefetchable memory base address register.
PrefetchableMemoryLimit
Lower 16 bits of PCI prefetchable memory limit address register.
PrefetchableMemoryBaseUpper32
Upper 32 bits of PCI prefetchable memory base address register.
PrefetchableMemoryLimitUpper32
Upper 32 bits of PCI prefetchable memory limit address register.
IOBaseUpper
Upper 16 bits of PCI I/O base address register.
IOLimitUpper
Upper 16 bits of PCI I/O limit address register.
ExpansionROMBase
PCI expansion ROM base address register.
BridgeControl
PCI bridge control register.
CapabilitiesPtr
PCI capabilities pointer register.
SecondaryStatus
PCI secondary status register.
CardbusBusNumber
CardBus bus number register.
CardbusLatencyTimer
CardBus latency timer register.
MemoryBase0
CardBus memory base address register 0.
MemoryLimit0
CardBus memory limit address register 0.
MemoryBase1
CardBus memory base address register 1.
MemoryLimit1
CardBus memory limit address register 1.
IOBase0_LO
Lower 16 bits of CardBus I/O base address register 0.
IOBase0_HI
Upper 16 bits of CardBus I/O base address register 0.
IOLimit0_LO
Lower 16 bits of CardBus I/O limit address register 0.
IOLimit0_HI
Upper 16 bits of CardBus I/O limit address register 0.
IOBase1_LO
Lower 16 bits of CardBus I/O base address register 1.
IOBase1_HI
Upper 16 bits of CardBus I/O base address register 1.
IOLimit1_LO
Lower 16 bits of CardBus I/O limit address register 1.
IOLimit1_HI
Upper 16 bits of CardBus I/O limit address register 1.
LegacyBaseAddress
CardBus legacy base address register.
SystemControl
CardBus system control register.
MultiMediaControl
CardBus multimedia control register.
GeneralStatus
CardBus general status register.
GPIO0Control, GPIO1Control, GPIO2Control, GPIO3Control
CardBus GPIO control registers
IRQMuxRouting
CardBus IRQ multiplexer routing register.
RetryStatus
CardBus retry status register.
CardControl
CardBus card control register.
DeviceControl
CardBus device control register.
Diagnostic
CardBus diagnostic register.
DeviceSpecific
Device specific registers in the PCI configuration space, varies by device.


HDDInfo

typedef struct _HDDInfo {

  DWORD BufferSize;
  DWORD DoubleTransfer;
  DWORD ControllerType;
  DWORD ECCMode;
  DWORD SectorsPerInterrupt;
  DWORD Cylinders;
  DWORD Heads;
  DWORD SectorsPerTrack;
  char  Model[41];
  char  SerialNumber[21];
  char  Revision[9];

} HDDInfo, * pHDDInfo;


DMA_BUFFER_REQUEST

typedef struct _DMA_BUFFER_REQUEST {

  ULONG LengthOfBuffer;         // Länge des Puffers in Bytes
  ULONG AlignMask;               // Gesetzte Grenzen:
                                             // 0x00 -   4K
                                             // 0x01 -   8K
                                             // 0x03 -  16K
                                             // 0x07 -  32K
                                            // 0x0F -  64K
                                          // 0x1F - 128K
  ULONG PhysDmaAddress;    // zurückgegebene physikalische Adresse des DMA-Puffers
  PVOID LinDmaAddress;         // zurückgegebene lineare Adresse des Puffers
  ULONG PMemHandle;            // Internes Handle des Treibers – merken !
  ULONG KernelDmaAddress;  s// Interne Variable des Treibers – merken !

} DMA_BUFFER_REQUEST, * PDMA_BUFFER_REQUEST;


TVicHW32 Fragen & Antworten (F.A.Q)

Was ist der Umfang des TVicHW32 – Pakets ?

Worin bestehen die Unterschiede zwischen den verschiedenen Lizenzen ?

Ist meine Anwendung, die auf TVicHW32 basiert, auf mein momentanes Betriebssystem beschränkt ?

Meine Anwendung kann TVicHW32 unter Windows NT/2000 nicht öffnen, wenn der Benutzer keine Administratorrechte besitzt.

Welche Programmiersprachen unterstützt TVicHW32 ?

Ich bin Delphi – Programmierer. Was soll ich bevorzugt in meiner Anwendung verwenden, TVicHW32.DLL oder TVicHW32.VCL ?

Ich brauche TVicHW32 oder einen ähnlichen Gerätetreiber um mit I/O-Ports unter WindowsNT zu arbeiten. Welche Vorteile bietet eigentlich TVicHW32 unter Windows 95/98/ME, wo ich alle Ports direkt aus meiner Anwendung ansprechen kann ?

Was ist der Unterschied zwischen "hard" und "soft" Port I/O- Zugriffen ?

Wie schnell ist der Zugriff auf Hardwareregister mit TVicHW32 ?

Was ist die höchste Interrupt-Folge-Frequenz, die mit TVicHW32 noch behandelt werden kann ?

Wie kann ich die Interrupt-Folge-Frequenz erhöhen ?

Ist es möglich, Interrupts des Systems oder des RTC Timers zu behandlen ?

Wann muss ich einen normalen Gerätetreiber schreiben, anstatt TVicHW32 zu benutzen ?

Wie benutze ich TVicHW32 für die serielle Kommunikation über den COM-Port ?

Warum hängt mein PC, wenn ich versuche, Interrupts meiner PCI-Karte zu demaskieren ?

Wie schütze ich meine Software gegen illegales Kopieren mit der GetHDDInfo-Funktion ?

Wie kann ich DOS/BIOS – Funktionen aufrufen ?

Wie kontrolliere ich Hardware, die am LPT-Port angeschlossen ist ?

Ich habe TVicHW32 erworben, aber meine Anwendung und/oder mein Gerät funktioniert immer noch nicht. Was soll ich tun ?

Meine Anwendung funktioniert nicht mit TVicHW32. Kann ich Ihnen mein Projekt schicken, um herauszufinden, worin mein Fehler leigt ?


Was ist der Umfang des TVicHW32 – Pakets?

Die Demoversion von TVicHW32 ist voll funktionsfähig, so dass Sie Ihre Anwendung schreiben und testen lönnen, bevor Sie eine Lizenz erwerben, den Treiber zu benutzen oder zu vertreiben.
Die lizensierte Version hat nur einen Unterschied zur Sharewareversion. Sie beeinhaltet die Treiber TVicHW32.vxd für Windows 95/98/ME und TVicHW32.sys für Windows NT/2000/XP ohne störende Hinweisboxen.

Benutzer, die die TVicHW32 Kommerzielle Lizenz erwerben, bekommen zusätzlich den Quellcode der DLL TVicHW32.DLL geschrieben in MSVC++ 6.0.

Der Quellcode der Treibers ist natürlich durch keine Lizenz zu erwerben !


Worin bestehen die Unterschiede zwischen den verschiedenen Lizenzen?

TVicHW32 Einzellizenz: Einmal registriert, wird Ihnen eine nicht – exklusive Lizenz gewährt, TVicHW32 auf einem Computer zur gleichen Zeit für jeden legalen Zweck zu verwenden. Die Registrierungsgebühr beträgt $99 U.S. Registrieren Sie online mit Kreditkarte oder per Uberweisung uber sichere Server bei ShareIt.

TVicHW32 Kommerzielle Lizenz: Es wird Ihnen die Lizenz erteilt,die TVicHW32 Treiber und DLLs als Teil Ihrer Software ohne weitere Gebühren zu vertreiben. Optional beinhaltet dies Ihre eigenen Treiber/DLL – Namen. Zusätzlich können wir zeitkritischen Code in den Treiber implementieren (eine zusätzliche Funktion oder einen Interrupt-Handler). Die Registrierungsgebühr beträgt $297 U.S. Registrieren Sie online mit Kreditkarte oder per Uberweisung uber sichere Server bei ShareIt.

Site Lizenz: Für Entwicklerteams. Die Kosten dieser Lizenz hängen von der Benutzeranzahl ab. Bitte kontaktieren uns für einen genauen Preis..


Ist meine Anwendung, die auf TVicHW32 basiert, auf mein momentanes Betriebssystem beschrankt ?

Nein, mit TVicHW32 funktioniert Ihre Anwendung von Windows (95/98/ME/NT/2000/XP) ohne Modifikation.


Meine Anwendung kann TVicHW32 unter Windows NT/2000 nicht offnen, wenn der Benutzer keine Administratorrechte besitzt.

Meine Anwendung kann TVicHW32 unter Windows NT/2000 nicht öffnen, wenn der Benutzer keine Administratorrechte besitzt.
Previous Top Next

Nach der Registrierung ist eine spezielle *.inf Datei erhältlich, um TVicHW32 neu zu installieren. Nach dem Booten können Sie sich als normaler Benutzer anmelden.


Welche Programmiersprachen unterstutzt TVicHW32?

Wir haben TVicHW32 mit den folgenden Programmiersystemen getestet:

· Microsoft Visual C++ 6.0
· Microsoft Visual Basic 6.0
· Inprise (Borland) Delphi Versionen 2 - 6
· Inprise (Borland) C++ Builder Versionen 1.0, 3.0, 4.0, 5.0
· Borland C++ 5.0

Normalerweise können Sie TVicHW32 mit jeder Programmiersprache benutzen, die DLL-Aufrufe unterstützt. Ich weiss, dass TVicHW32 auch mit Borland Power Builder und Forth funktioniert, aber fragen Sie mich bitte nicht wie ! J


Ich bin Delphi – Programmierer. Was soll ich bevorzugt in meiner Anwendung verwenden, TVicHW32.DLL oder TVicHW32.VCL ?

Die VCL Komponente ist nur ein praktischer Wrapper um die DLL, deshalb ist das direkte Benutzen der DLL mit einer etwas besseren Performance verbunden. Es ist hauptsächlich von Ihrern Vorlieben als Programmierer abhängig, was sie verwenden.


Ich brauche TVicHW32 oder einen ahnlichen Geratetreiber um mit I/O-Ports unter WindowsNT zu arbeiten. Welche Vorteile bietet eigentlich TVicHW32 unter Windows 95/98/ME, wo ich alle Ports direkt aus meiner Anwendung ansprechen kann ?

Ich brauche TVicHW32 oder einen ähnlichen Gerätetreiber um mit I/O-Ports unter WindowsNT zu arbeiten. Welche Vorteile bietet eigentlich TVicHW32 unter Windows 95/98/ME, wo ich alle Ports direkt aus meiner Anwendung ansprechen kann ?
Previous Top Next

Es ist fast richtig, dass man alle Ports unter Windows 95/98/ME ansprechen kann. Windows ist ein
Multitasking – Betriebssystem unter dem jedes Gerät durch mehrere Geräte gleichzeitig angesprochen werden kann, deswegen bietet Windows keinen Weg um Geräte vor mehr als einer Instruktion auf einmal zu schützen. Um den Zugriff auf I/O-Adressen zu kontrollieren benutzt Windows 9X eine Bit-orientierte Liste aller Ports, genannt I/O-Permission Map (IOPM). Ein gesetztes Bit in dieser Liste bedeutet, dass der Zugriff verboten ist, eine nicht gesetztes Bit bedeutet, dass der Zugriff gewährt wird. Es ist kein Problem, auf einen im IOPM freigegebenen Port zuzugreifen, anderenfalls ist es schwierig.

Die Treiber (VxD's) rufen einen Systemservice auf, um einen bestimmten Port zu belegen und eine Callback-Funktion zu registrieren, „port trap handler" genannt. Das System reagiert mit dem Setzen des zugehörigen Bytes des Ports in der IOPM. Wenn eine Win32 Anwendung auf diesen Port zugreift und einen Fehler verursacht, ruft der systemeigene Fehlerbehandlung den port trap handler der VxD
auf.

Diese port trap handler kann alles als Antwort auf diesen I/O-Zugriff einer Win32 Anwendung tun:
Die VxD kann die Anweisung ignorieren, kann sie ausführen oder einen Wert ersetzen anstelle denjenigen zu senden, der geschickt wurde !

Windows 9x und seine VxDs belegen fast alle Standard-PC-I/O-Adressen, aber niemals welche, die nicht standardisiert sind. Deswegen ist es notwendig, vorsichtig zu sein, wenn man mit den Standard-System-Geräten arbeitet. Auf der anderen Seite kann das System nicht die I/O-Zugriffe belegen, die von einer anderen VxD kommen und das ist der Grund, warum Sie einen zuverlässigen Gerätetreiber
Für Portzugriffe unter Windows 95/98/ME benötigen.


Was ist der Unterschied zwischen “hard” und “soft” Port I/O- Zugriffen?

Was ist der Unterschied zwischen "hard" und "soft" Port I/O- Zugriffen?
Previous Top Next

Der „soft" – Modus bietet eine bessere Performance, kann aber versagen, wenn ein anderer Treiber die gleichen Ports bereits benutzt (siehe vorherige Erläuterung) (Siehe der vorige). "Hard" – Zugriffe bieten einen sichereren Portzugriff, aber ist langsamer wegen des grösseren Verwaltungsaufwandes der DeviceIOContol() API calls.


Wie schnell ist der Zugriff auf Hardwareregister mit TVicHW32?

Zugriff auf die speicherbezogenen Zugriff sind schnellstmöglich, da diese direkt über Windows-eigene Zeiger auf den Speicher erfolgen

Bei Port I/O – Zugriffen konnte ich die folgenden Ergebnisse auf einem P II 450MHz system messen:

· Einzelner Lesezugriff, hard mode - 5.85 µsec
· Einzelner Lesezugriff, soft mode - 2.04 µsec
· Direkter Portzugriff aufgerufen durch RunRing0Function - 1.51 µsec
· Ein Array von Werten lesen mit ReadPortFIFO - 1.22 µsec


Was ist die hochste Interrupt-Folge-Frequenz, die mit TVicHW32 noch behandelt werden kann?

TVicHW32 funktioniert perfekt bis zu 10 kHz auf einem 450 MHz Pentium II.
Für sehr stabile Ergebnisse empfehlen wir, TVicHW32 nicht für Interrupt-Perioden unter 10 ms zu verwenden.
TVicHW32 behandelt alle Interrupts bei höheren Frequenzen, aber es beginnt die Verzögerungen zu beeinflussen,
wenn diese Interrupts zur Benutzerebene geliefert werden.

Dies ist nur möglich, wenn Windows TVicHW32´s Thread aktiviert. Um diesen indirekten Verzögerungseffekt zu
bekommen, muss TVicHW32 die Klasse REALTIME_PRIORITY_CLASS besitzen und seine Thread-Priorität auf THREAD_PRIORITY_TIME_CRITICAL gesetzt sein. In diesem Extremfall bekommen wir mit Probleme mit der Tastatur
und der Maus, die ebenfalls blockiert werden können.


Wie kann ich die Interrupt-Folge-Frequenz erhohen ?

Der einzig zuverlässige Weg ist Ihren Interrupt-Handler in den Treiber zu verlagern. Wenn Sie die TVicHW32 Kommerzielle Lizenz erworben haben, kann ich dies für Sie tun. Diese Lizenz ermöglicht auch einen einen kundenspezifischen Treiber


Ist es moglich, Interrupts des Systems oder des RTC Timers zu behandlen?

Nein, dies ist nicht möglich. Der System-Timer (IRQ10) wird vom System zur Systemsteuerung benutzt und kann für keine anderen Zwecke verwendet werden. Auch unter Windows NT/2000 können wir den RTC-Timer nicht benutzen (IRQ9).

Allgemein ist präzises Timing unter Windows ein unlösbares Problem, weil Windows nicht als Echtzeitbetriebssystem entwickelt wurde. Entwickler, die hochpräzise Timer benötigen, können die Win32 API Funktion timeSetEvent() benutzen, die eine Genauigkeit von 1 Millisekunde (ms) aufweist.

Wie auch immer, unter Windows Multi-Thread-Umgebung ist diese Genauigkeit nicht zuverlässig, wenn andere hochprivilegierte Thread Prozessorzeit beanspruchen.

Bei zeitkritischen Algorithmen ist auch die GetTickCount() Funktion nicht zu empfehlen. Stattdessen wird empfohlen, die Win32 API Funktionen QueryPerformanceCounter() und QueryPerformanceFrequency() zu verwenden.


Wann muss ich einen normalen Geratetreiber schreiben, anstatt TVicHW32 zu benutzen?

Wenn TVicHW32 Ihr Problem nicht lösen kann, kann ich Ihnen einen Treiber schreiben und seine Quellcode senden. Schicken Sie mir eine E-mail damit ich Ihnen den Preis nennen kann, der von Ihren speziellen Wünschen und der Lieferzeit abhängt.


Wie benutze ich TVicHW32 fur die serielle Kommunikation uber den COM-Port?

TVicHW32 wird nicht für serielle Kommuniation empfohlen. Es gibt viel leichtere und billigere Wege,diese Aufgabe mit normalen API-Aufrufen zu erledigen. Öffnen Sie einfach das Win32 help file und suchen nach "communications". Sie können auch MSCOMM32 OCX benutzen oder Shareware und sogar Freeware Bibliotheken im Internet finden.

Achtung! : TVicHW32 kann keine seriellen Interrupts unter Windows NT/2000/XP behandeln !


Warum hangt mein PC, wenn ich versuche, Interrupts meiner PCI-Karte zu demaskieren?

Warum hängt mein PC, wenn ich versuche, Interrupts meiner PCI-Karte zu demaskieren ?
Hierfür gibt es zwei mögliche Gründe:

- Die Interrupt-Folge-Frequenz ist zu hoch. Sie können diese herabsetzen oder Ihren Interrupthandler überreden, schneller zu arbeiten.
Oder Ihr Gerät erzeugt wahrscheinlich pegelgetriggerte Interrupts statt flankengetriggerte. Wenn der Interruptpegel auf dem

- Bus nicht weggenommen wird am Ende der Interruptbehandlung, ruft das System den Interrupt-Handler immer wieder auf und das System hängt. Um dies zu vermeiden, benutzen Sie die UnmaskIRQEx() Funktion um einen Interrupthandler zu installieren anstatt UnmaskIrq() .

Beim Aufruf dieser neuen Funktion können Sie die Information übermitteln wie der TVicHW32-Treiber einen Interrupt innerhalb des primären Interrupt-Handlers löschen soll.
Es ist nicht notwendig, den Interrupt-Pegel in Ihrem Interrupt-Handler zu löschen,weil dies bereits durch den TVicHW32-Treber geschieht !


Wie schutze ich meine Software gegen illegales Kopieren mit der GetHDDInfo()-Funktion ?

Wie schütze ich meine Software gegen illegales Kopieren mit der GetHDDInfo()-Funktion?
Previous Top Next

Wir können dies nicht empfehlen, weil es Probleme für den Endbenutzer bedeutet. Diese können ihren PC nicht aufrüsten, Ihr Programm nicht auf einen anderen PC ausführen, der dem gleichen Benutzer gehört (Zuhause/Arbeit/Notebook). Diese Methoden funktionieren nur bei IDE-Festplatten und nicht bei SCSI-Festplatten. Solche Schutzfunktionen sind auch sehr leicht knackbar.


Wie kann ich DOS/BIOS – Funktionen aufrufen?

Unglücklicherweise kann Ihnen TVicHW32 hierbei nicht helfen. Das Problem liegt darin, das Windows NT/2000/XP keine Kernel- oder Benutzerebenen-Funktionen besitzt, die zu tun auf dokumentiertem Weg. Windows NT wurde ursprünglich für viele CPUs entwickelt, icht nur für Intel, deswegen können wir keine Empfehlungen für BIOS oder DOS geben.


Wie kontrolliere ich Hardware, die am LPT-Port angeschlossen ist ?

TVicHW32 beinhaltet eine Menge von Standardfunktionen für diese Aufgabe.
Besuchen Sie www.lvr.com/parport.htm um sehr nützliche Tipps,Informationen, Bücher, FAQs, Links,
Softwaretools, etc. zu bekommen.
Schauen Sie sich auch unser neues Tool TVicLPT auf unserer Webseite.


Ich habe TVicHW32 erworben, aber meine Anwendung und/oder mein Gerat funktioniert immer noch nicht. Was soll ich tun ?

Ich habe TVicHW32 erworben, aber meine Anwendung und/oder mein Gerät funktioniert immer noch nicht. Was soll ich tun ?
Previous Top Next

TVicHW32 ist ein Werkzeug für Hardwarezugriffe und, wie jedes Werkzeug, erledigt es nicht die Aufgabe alleine. In anderen Worten ausgedrückt, um ein Werkzeug wie ein Experte zu benutzen, muss man wissen, was damit zu tun ist. Es ist möglich, dass wir Ihnen Vorschläge machen können, Ihnen zu helfen, aber in den meisten Fällen liegt die Lösung wirklich darin, dass Sie mehr über die Hardware lernen, auf die Sie zugreifen wollen, besonders, wenn Sie mit keinen Standard-Geräten arbeiten.


Meine Anwendung funktioniert nicht mit TVicHW32. Kann ich Ihnen mein Projekt schicken, um herauszufinden, worin mein Fehler leigt?
Previous Top

Nein ! Bitte tun Sie das nicht !

Wir haben nicht genügend freie Zeit, auch nur mit Ihrem Projekt vertraut zu werden, bevor wir Fehler finden könnten. Probieren Sie, den Bereich des Fehlers auf einige Zeilen Code einzuengen, schicken uns diesen per Email und wir werden versuchen zu helfen, wenn möglich.