LPT-Port ansteuern [NT!]. Infos und/oder Tester gesucht.

[engine]

Zitat:

Aufruf an alle Leser

Bitte laßt mir in diesem Thread oder per PM ein paar Codeschnipsel zukommen, die per IN/OUT den LPT ansteuern - aus DOS-Zeiten oder eben Windows 9x. Am interessantesten wäre Code, mit dem man einen DOS-fähigen (also Nicht-GDI) Drucker ansprechen kann - bei denen ist nämlich das Fabrikat egal.

Danke.

Hallo Mephistopheles,

vor längerer Zeit habe ich mal ein kleines Programm zum Ansteuern des LPT-Port in TP oder BP geschrieben. Bevor sich jetzt Alle über die schlechte Programmierung auslassen; ich würde das heute auch anders machen!
Ich bin mir nicht ganz sicher, ob Du so etwas gesucht hast. Dann habe ich noch ein Programm zum Auslesen eines D/A-Wandlers über den Com-Port. Für dieses Programm benötigt man definitiv einen Porttreiber.

Delphi-Quellcode:

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{ *                                                                         * }
{ *  Programm     :  TestLPT                              Stand : 22.07.95  * }
{ *  Datei        :  TestLPT.pas                                            * }
{ *                                                                         * }
{ *  Beschreibung :  Testprogramm zum Ansteuern der Datenleitungen          * }
{ *                  am LPT-Port                                            * }
{ *                                                                         * }
{ *  Autor        :  Ralf Appel                                             * }
{ *                                                                         * }
{ *                                                                         * }
{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }



program TestLPT;

uses crt, dos, gra_tool, graph, Maus;

const
  KreisX : array[1..25] of integer = (400, 380, 360, 340, 320, 300, 280, 260,
                                      240, 220, 200, 180, 160, 390, 370, 350,
                                      330, 310, 290, 270, 250, 230, 210, 190,
                                      170);

  KreisY : array[1..25] of integer = (170, 170, 170, 170, 170, 170, 170, 170,
                                      170, 170, 170, 170, 170, 200, 200, 200,
                                      200, 200, 200, 200, 200, 200, 200, 200,
                                      200);

  Bit : array[1..8] of byte = (0, 0, 0, 0, 0, 0, 0, 0);
  SetBit : integer = 0;

  SchnittStelle : integer = 0;         { Als Schnittstelle wird LPT1 gesetzt }

var
  BitFeld, testBit, zaehler, code : integer;
  taste : char;

function ParalelReadReg(SchnittStelle : Integer) : integer;
var reg:Registers;

begin
  reg.ah:= 2;    { Status der Paralelen Schnittstelle abfragen - Funktion 02 }
  reg.dx:= SchnittStelle;              { Nummer der Schnittstelle - 0 = LPT1 }
  Intr($17,reg);                                  { Aufruf des Interrupt 17h }
  ParalelReadReg := reg.ah;                   { Rückgabe des Status als Byte }
end;

function ParalelWriteReg(SchnittStelle, SetBit : Integer) : integer;
var reg:Registers;

begin
  reg.ah:= 0;       { Daten zur Paralelen Schnittstelle Senden - Funktion 00 }
  reg.ah:= SetBit;           { Bit 0-7 an der Paralelen Schnittstelle setzen }
  reg.dx:= SchnittStelle;              { Nummer der Schnittstelle - 0 = LPT1 }
  Intr($17,reg);                                  { Aufruf des Interrupt 17h }
end;

procedure Zustand(Nummer, Farbe : integer);
begin
  if Farbe = blue then SetFillStyle(SolidFill, Blue)
                  else SetFillStyle(SolidFill, Green);
  FloodFill(KreisX[Nummer], KreisY[Nummer], black);
end;

procedure ZustandAusgang(Nummer, Farbe : integer);
begin
  if Farbe = magenta then SetFillStyle(SolidFill, magenta)
                     else SetFillStyle(SolidFill, yellow);
  FloodFill(KreisX[Nummer], KreisY[Nummer], black);
end;

begin
  clrscr;
  write('Wählen Sie 1 für LPT1 oder 2 für LPT2 : ');
  readln(taste);
  if taste = '1' then SchnittStelle := 0;
  if taste = '2' then SchnittStelle := 1;
  Grafik_ein(1);


  MausReg(1,2);
  SetColor(black);
  SetFillStyle(SolidFill, LightGray);
  bar(0, 0, GetMaxX, GetMaxY);
  for zaehler := 13 downto 1 do
  Circle(KreisX[zaehler], KreisY[1], 5);
  for zaehler := 25 downto 14 do
  Circle(KreisX[zaehler], KreisY[14], 5);
  Circle(150, 20, 5);
  OutTextXY(160,17,' = Masse');
  Circle(150, 40, 5);
  OutTextXY(160,37,' = Ausgang');
  Circle(150, 60, 5);
  OutTextXY(160,57,' = Eingang, nicht geschaltet');
  Circle(150, 80, 5);
  OutTextXY(160,77,' = Eingang, durch geschaltet');
  Circle(150, 100, 5);
  OutTextXY(160,97,' = Ausgang, nicht geschaltet');
  Circle(150, 120, 5);
  OutTextXY(160,117,' = Ausgang, durch geschaltet');

  if SchnittStelle = 0 then OutTextXY(210,182,'-Status von LPT1-')
                       else OutTextXY(210,182,'-Status von LPT2-');
  OutTextXY(397,150,'1');
  OutTextXY(377,150,'2');
  OutTextXY(357,150,'3');
  OutTextXY(337,150,'4');
  OutTextXY(317,150,'5');
  OutTextXY(297,150,'6');
  OutTextXY(277,150,'7');
  OutTextXY(257,150,'8');
  OutTextXY(237,150,'9');
  OutTextXY(212,150,'10');
  OutTextXY(192,150,'11');
  OutTextXY(172,150,'12');
  OutTextXY(152,150,'13');

  OutTextXY(385,220,'14');
  OutTextXY(365,220,'15');
  OutTextXY(345,220,'16');
  OutTextXY(325,220,'17');
  OutTextXY(305,220,'18');
  OutTextXY(285,220,'19');
  OutTextXY(265,220,'20');
  OutTextXY(245,220,'21');
  OutTextXY(225,220,'22');
  OutTextXY(205,220,'23');
  OutTextXY(185,220,'24');
  OutTextXY(165,220,'25');

  OutTextXY(20,GetMaxY - 100,'Tasten 2-9 schalten den Ausgang Ein/Aus.');
  OutTextXY(20,GetMaxY - 80,'Schalten Sie den Drucker ein.');
  OutTextXY(20,GetMaxY - 60,'Probieren Sie ON - OFF Line aus.');
  OutTextXY(20,GetMaxY - 40,'Entfernen Sie einmal das Papier aus dem Drucker.');
  OutTextXY(20,GetMaxY - 20,'ESC = Programm beenden...');
  MoveTo(140,160);
  LineRel(280,0);
  LineRel(-20,50);
  LineRel(-240,0);
  LineTo(140,160);
  SetFillStyle(SolidFill, brown);
  for zaehler := 25 downto 18 do
  FloodFill(KreisX[zaehler], KreisY[14], black);
  FloodFill(150, 20, black);
  SetFillStyle(SolidFill, yellow);
  FloodFill(150, 100, black);
  for zaehler := 9 downto 2 do
  FloodFill(KreisX[zaehler], KreisY[1], black);
  SetFillStyle(SolidFill, DarkGray);
  FloodFill(KreisX[14], KreisY[14], black);
  FloodFill(KreisX[16], KreisY[17], black);
  FloodFill(KreisX[17], KreisY[17], black);
  FloodFill(150, 40, black);
  SetFillStyle(SolidFill, Green);
  for zaehler := 13 downto 10 do
  FloodFill(KreisX[zaehler], KreisY[1], black);
  FloodFill(KreisX[15], KreisY[15], black);
  FloodFill(150, 60, black);
  SetFillStyle(SolidFill, blue);
  FloodFill(150, 80, black);
  SetFillStyle(SolidFill, magenta);
  FloodFill(150, 120, black);

  repeat
    if keypressed then
    begin
      taste := readkey;
      case taste of
        #50 : if Bit[1] = 0 then Bit[1] := 1
                            else Bit[1] := 0;
        #51 : if Bit[2] = 0 then Bit[2] := 1
                            else Bit[2] := 0;
        #52 : if Bit[3] = 0 then Bit[3] := 1
                            else Bit[3] := 0;
        #53 : if Bit[4] = 0 then Bit[4] := 1
                            else Bit[4] := 0;
        #54 : if Bit[5] = 0 then Bit[5] := 1
                            else Bit[5] := 0;
        #55 : if Bit[6] = 0 then Bit[6] := 1
                            else Bit[6] := 0;
        #56 : if Bit[7] = 0 then Bit[7] := 1
                            else Bit[7] := 0;
        #57 : if Bit[8] = 0 then Bit[8] := 1
                            else Bit[8] := 0;
      end;
      SetBit := (Bit[1] *1 + Bit[2] *2 + Bit[3] *4 + Bit[4] *8 + Bit[5] *16 +
                 Bit[6] *32 + Bit[7] *64 + Bit[8] *128);
      ParalelWriteReg(SchnittStelle, SetBit);
      for zaehler := 1 to 8 do
      begin
        if Bit[zaehler] = 1 then ZustandAusgang(zaehler+1, magenta)
                            else ZustandAusgang(zaehler+1, yellow);
      end;
    end;

    testBit := ParalelReadReg(SchnittStelle);
    BitFeld := testBit;
    if BitFeld and 8 <> 0 then Zustand(15, blue)
                           else Zustand(15, green);
    BitFeld := testBit;
    if BitFeld and 16 <> 0 then Zustand(13, blue)
                            else Zustand(13, green);
    BitFeld := testBit;
    if BitFeld and 32 <> 0 then Zustand(12, blue)
                            else Zustand(12, green);
    BitFeld := testBit;
    if BitFeld and 64 <> 0 then Zustand(10, blue)
                            else Zustand(10, green);
    BitFeld := testBit;
    if BitFeld and 128 <> 0 then Zustand(11, blue)
                             else Zustand(11, green);
  until taste in [#27,#13];
  Grafik_aus;
end.