Hardware Access/de

From Lazarus wiki
Jump to navigationJump to search

Deutsch (de) English (en) español (es) français (fr) magyar (hu) 日本語 (ja) 한국어 (ko) polski (pl) português (pt) русский (ru) slovenčina (sk) 中文(中国大陆)‎ (zh_CN)

Überblick

Diese Seite ist der Beginn eines Tutorials über den Zugriff auf Hardware Geräte mit Lazarus. Diese Geräte enthalten, ohne darauf beschränkt zu sein: ISA, PCI, USB, paralleler und serieller Anschluß.

Der Zugriff auf Hardware Geräte auf einer komplett plattformunabhängigen Weise ist nicht implementiert durch die Free Pascal Runtime Library oder durch die LCL, daher umfasst dieses Tutorial grundsätzlich Hardware Zugriffsmethoden auf verschiedenen Plattformen. Der Code kann unter verschiedenen Umgebungen kompiliert werden unter Verwendung bedingter Kompilierung, etwa so:

uses
 Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, ExtCtrls,
{$IFDEF WIN32}
  Windows;
{$ENDIF}
{$IFDEF Linux}
  ports;
{$ENDIF}

Hilfe ist willkommen, speziell zu MacOS.

Parallel und Seriell Vergleich

ISA Karten, PCI Karten und der Parallele Anschluß kommunizieren mit dem Computer unter Verwendung eines parallelen Protokolls. Der Serielle Anschluß und USB Geräte arbeiten mit einem seriellen Protokoll. Da der Prozessor und damit auch alle Programmiersprachen auf Daten parallel zugreifen, ist es wesentlich einfacher solche Protokolle softwareseitig zu programmieren. Beispielsweise erfolgt der Zugriff auf eine Ganzzahl-Variable (INTEGER) nur durch einen einzelnen Befehl. Mit einem seriellen Protokoll kann jedoch nur jeweils auf ein Bit zugegriffen werden. Im Nachhinein ist es notwendig, die Teildaten zusammen zu fügen um sie zu verwenden.

Serielle Kommunikation ist schwierig direkt zu programmieren. Wenn allerdings eine fertige Komponente zur Verfügung steht wird es deutlich einfacher. Auch hardwareseitig sind serielle Schnittstellen deutlich umständlicher, daher benötigen die meisten seriellen Schnittstellen spezielle IC-Bausteine oder Microcontroller für die Kommunikation.

Hier eine kurze Gegenüberstellung der Hardware-Zugriffsprotokolle:

Geschwindigkeit Hardwareimplementierungsschwierigkeit
Serieller Anschluß sehr langsam (< 100 kBit/s) mittel
Paralleler Anschluß langsam (~ 1 MBit/s) einfach
ISA Karte mittel (~ 10 MBit/s) mittel
USB 1.x mittel (~ 1.6 MBit/s) schwierig
USB 2.0 schnell (~ 480 MBit/s) sehr schwierig
PCI Karte sehr schnell (> 1 GBit/s) sehr schwierig

Parallele Kommunikation

Verwendung von inpout32.dll für Windows

Windows hat verschiedene Wege für die Ansteuerung von Hardware Geräten bei der 9x Serie und bei der NT Serie, und dies kann wirklich problematisch sein. Die 9x Serie (95, 98, Me) erlaubt den Prgrammen direkten Zugriff auf die Ports, genau wie unter DOS. Windows NT, jedoch, verhindert dies komplett, und erlaubt nur den Zugriff durch die Gerätetreiber auf die Ports. Dies ist ein Sicherheitsmechanismus, der aber nervig sein kann, wenn ein Gerätetreiber zu komplex für ein kleines Projekt ist, das Zugriff auf den parallelen Port benötigt.

Glücklicherweise gibt es eine Bibliothek, die einen Gerätetreiber enthält. Wenn Windows NT erkannt wird, dann dekomprimiert sie das Gerät und installiert den Hwinterface.sys Kernel Gerätetreiber. Wenn Windows 9x erkannt wird, dann benutzt sie einfach Assembler Opcodes für den Zugriff auf die Hardware.

Aber wie benutzt man die Bibliothek? Einfach! Sie hat nur zwei Funktionen, Inp32 und Out32, und deren Benutzung ist ganz intuitiv.

Wir werden die Bibliothek dynamisch laden, so lassen sie uns zuerst beide Funktionen definieren:

type
  TInp32 = function(Address: ShortInt): ShortInt; stdcall;
  TOut32 = procedure(Address: ShortInt; Data: ShortInt); stdcall;

  • Address representiert die Adresse des Ports, auf den sie zugreifen wollen. Out32 sendet Daten zu dem Port, den sie mit Adress spezifiziert haben. Inp32 gibt ein Byte zurück vom Port, den sie mit Address spezifiziert haben.

Nun können wir die Bibliothek laden. Dies kann implementiert werden an einer Stelle wie der OnCreate Methode des Haupformulars ihres Programms:

 type
  TMyForm = class(TForm)
  .........
  private
    { private declarations }
    Inpout32: THandle;
    Inp32: TInp32;
    Out32: TOut32;
  .........
implementation
  .........
procedure TMyForm.FormCreate(Sender: TObject);
begin
{$IFDEF WIN32}
  Inpout32 := LoadLibrary('inpout32.dll');
  if (Inpout32 <> 0) then
  begin
    // needs overtyping, plain Delphi's @Inp32 = GetProc... leads to compile errors
    Inp32 := TInp32(GetProcAddress(Inpout32, 'Inp32'));
    if (@Inp32 = nil) then Caption := 'Error';
    Out32 := TOut32(GetProcAddress(Inpout32, 'Out32'));
    if (@Out32 = nil) then Caption := 'Error';
  end
  else Caption := 'Error';
{$ENDIF}
end;

Wenn sie die Bibliothek bei OnCreate laden, vergessen sie nicht, sie bei OnDestroy zu entladen:

procedure TMyForm.FormDestroy(Sender: TObject);
begin
{$IFDEF WIN32}
  FreeLibrary(Inpout32);
{$ENDIF}
end;

Hier ist ein einfaches Beispiel, wie man die Inp32 Funktion benutzt:

{$IFDEF WIN32}
  myLabel.Caption := IntToStr(Inp32($0220));
{$ENDIF}

Dieser Code wurde getestet mit einer maßgeschneiderten ISA Karte auf Port $0220, unter Verwendung von Lazarus 0.9.10 mit Windows XP. Natürlich müssen sie Windows in ihrem uses Abschnitt haben damit dieser Code läuft. Für den Einsatz müssen sie nur "inpout32.dll" in das selbe Verzeichnis wie ihre Anwendung einfügen.

Dies ist die Homepage für die Bibliothek: www.logix4u.net/inpout32.htm

Verwendung von Assembler unter Windows 9x

Unter Windows 9x können sie auch Assembler Code verwenden. Suppose you with to write $CC to the $320 port. Der folgende Code erledigt das:

{$ASMMODE ATT}
...
   asm
       movl $0x320, %edx
       movb $0xCC, %al
       outb %al, %dx
   end ['EAX','EDX'];

Mögliche Fehlerquellen in Windows

Eine mögliche Fehlerquelle in Windows bezüglich parallel verwendeter Hardware, welche kein "Plug and Play" unterstützt kann darin liegen, dass Windows den von der Hardware benötigten Port einem anderen Gerät zugewiesen hat. Unter der folgenden Adresse können Sie Informationen darüber finden, wie man Windows daran hintern kann, den benötigten Port zu vergeben:

http://support.microsoft.com/kb/135168

Verwendung von ioperm zum Zugriff auf Ports unter Linux

Der beste Weg um auf Hardware unter Linux zuzugreifen, ist durch Gerätetreiber, aber, wegen der Komplexität der Aufgabe, einen Treiber zu erstellen, ist manchmal eine schnelle Methode sehr nützlich.

Damit sie die "ports" Unit unter Linux benutzen können, muß ihr Programm als root laufen, und IOPerm muß aufgerufen werden um eine angemessene Erlaubnis für den Portzugriff zu setzen. Sie können die Dokumentation über die "ports" Unit hier finden.

Zunächst müssen sie auf glibc verlinken und IOPerm aufrufen. Eine Unit, die auf das ganze glibc verlinkt, existiert in Free Pascal, aber diese Unit macht Probleme, wenn sie direkt von der Anwendung benutzt wird und das statische Verlinken auf die gesamte glibc Bibliothek ist keine sehr gute Idee für eine Multiplattform Anwendung. Die Verwendung plattformspezifischer Funktionen sollte auf ein Minimum reduziert werden.

{$IFDEF Linux}
function ioperm(from: Cardinal; num: Cardinal; turn_on: Integer): Integer; cdecl; external 'libc';
{$ENDIF}

  • "from" representiert den ersten Port auf den zugegriffen wird.
  • "num" ist die Anzahl (number) der Ports nach dem ersten Port, auf den zugegriffen wird, daher wird ioperm($220, 8, 1) Zugriff ermöglichen für das Programm auf alle Ports zwischen $220 and $227 (einschließlich).

Nach dem Verlinken auf OIPerm können sie port[<Address>] eingeben für den Zugriff auf die Ports.

{$IFDEF Linux}
  i := ioperm($220, 8, 1);
  port[$220] := $00;
  myLabel.Caption := 'ioperm: ' + IntToStr(i);
  i := Integer(port[$220]);
  myOtherLabel.Caption := 'response: ' + IntToStr(i);
{$ENDIF}

Dieser Code wurde mit einer maßgeschneiderten ISA Karte auf Port $0220 getested, unter Verwendung von Lazarus 0.9.10 unter Mandriva Linux 2005 und Damn Small Linux 1.5

Der übliche UNIX Hardwarezugriff

{$IFDEF Unix}
Uses Clib;   // retrieve libc library name.
{$ENDIF}

{$IFDEF Unix}
function ioperm(from: Cardinal; num: Cardinal; turn_on: Integer): Integer; cdecl; external clib;
{$ENDIF}


Beachten sie, daß FPC eine Abstraktion für ioperm genannt "fpioperm" bietet in der Unit x86, und auch out und import Funktionen. Diese Funktionen sind gegenwärtig für Linux/x86 und FreeBSD/x86 implementiert.

Es wird nicht empfohlen to link to libc unless absolutely necessary due to possible deployment and portability functions. Also manual linking to libc (by declaring ad hoc libc imports for functions that are available elsewhere) like done above is not recommended (e.g. the above libc import line will unnecessarily fail if the standard C lib is not called libc, wie z.B. libroot unter BeOS (Zeta), oder auf Plattformen mit a non standard C symbol mangling).

Anmerkung 2 Die Verwendung von unit_ libc wird nicht empfohlen unter anderen Umständen als der Kylix Kompatibilität. Dies ist so, weil die Unit relativ unportierbar ist (wegen der übermäßigen Beanspruchung von Strukturen und anderen privaten Symbolen) und must only be modified as little as possible out of Kylix compability issues.

Serielle Kommunikation

Der Externe Links Abschnitt enthält UNIX und Windows Tutorials über den seriellen Anschluß.

Externe Links

Kommunikationsprotokolle Geschwindigkeitsvergleich:

  1. http://en.wikipedia.org/wiki/Serial_port#Speed
  2. http://www.lvr.com/jansfaq.htm - Jan Axelson's Parallel Port FAQ
  3. http://en.wikipedia.org/wiki/USB#Transfer_Speed
  4. http://en.wikipedia.org/wiki/PCI#Conventional_PCI_bus_specifications

Serielle Kommunikation Links:

  1. Unter UNIX: [1]
  2. Unter Windows: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnfiles/html/msdn_serial.asp
  3. Synaser Komponente: http://synapse.ararat.cz/
  4. Comport Delphi package: http://sourceforge.net/projects/comport/

ISA Digital Oscilloscope - Ein Beispiel für Hardwarezugriff mit dem vollständigen Source-Code:

[2]