16-Bit Folge über LPT ausgeben

[BoondockDuckling]

morgen

ich bin irgendwie zu doof eine 16-Bit folge über 3 Pins des LPTs an einen Schieberegister zu übergeben.

Seltsamerweise bin ich nur zu doof das in eine Prozeudur zu packen denn durch "manuellelles schalten" der LPT-Pins bekomme ich es hin.

Folgendes: Der MAX7221 wird wie ein Schieberegister angesteuert. Er besitzt einen Data, einen Load und einen Clock Eingang.
Um die internen Register zu beschreiben wird eine 16-Bit-Folge geschrieben. Dazu setzt man Load auf low und übergibt zu jeweiligen zustände (logische 0 und 1) an Data und schreibt diese per Clock in den Register. Z.b. um eine 1 zu übergeben wird Data und Clock gleichzeitig High gesetzt, um eine 0 zu schreiben wird nur Clock auf high gesetzt. Nach ende der 16 Bit wird Load wieder high gesetzt.

Bei mir ist
LPT-Pin1: Clock
LPT-Pin2: Load
LPT-Pin3: Data

nachtrag: p.s. pin1 ist datenpin0(wert 1), pin2 datenpin1(wert 2) und pin3 datenpin2(wert 4)

Ich habe mir drei Checkboxen erstellt mit denen ich die Pins1-3 beliebig in allen Kombinationen schalten kann. Das funktioniert auch, so kann ich die 16 Bit manuell in den Schieberegister schreiben.
Ich bin schlichtweg zu doof das in eine Prozedur zu packen die das automatisch macht.

Beispielsweise soll folgende Bitfolge übergeben werden: 0000 1010 0000 0000

Manuell sieht das so aus:

Code:

Pin2 auf Low 
-> Pin1 auf High -> Pin1 auf Low        //1 (log. 0)
-> Pin1 auf High -> Pin1 auf Low        //2 (log. 0)
-> Pin1 auf High -> Pin1 auf Low        //3 (log. 0)
-> Pin1 auf High -> Pin1 auf Low        //4 (log. 0)

-> Pin1+Pin3 auf High -> Pin1+3 auf Low //5 (log. 1)
-> Pin1 auf High -> Pin1 auf Low        //6 (log. 0)
-> Pin1+Pin3 auf High -> Pin1+3 auf Low //7 (log. 1)
-> Pin1 auf High -> Pin1 auf Low        //8 (log. 0)

-> Pin1 auf High -> Pin1 auf Low        //9 (log. 0)
-> Pin1 auf High -> Pin1 auf Low        //10(log. 0)
-> Pin1 auf High -> Pin1 auf Low        //11(log. 0)
-> Pin1 auf High -> Pin1 auf Low        //12(log. 0)

-> Pin1 auf High -> Pin1 auf Low        //13(log. 0)
-> Pin1 auf High -> Pin1 auf Low        //14(log. 0)
-> Pin1 auf High -> Pin1 auf Low        //15(log. 0)
-> Pin1 auf High -> Pin1 auf Low        //16(log. 0)

-> Pin2 auf High

Da dachte ich mir: Kein problem, schreibe ich das einfach mal eins zu eins in eine Prozedur:
(Die port-kontrolle funlktionier über "io.dll" -> google!! Die Prozedur delay ist eine, wie zu erwarten, delay-Prozedur. Die tut jetzt zwar nichts zur sache, habe sie unten aber mal mit eingefügt.)

Delphi-Quellcode:

procedure TForm1.Button8Click(Sender: TObject);
var d:integer;
begin
 d:=100; //millisekunden
 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 //
 PortOut($378,0);  delay(d);
 PortOut($378,5);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,5);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 //
 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 //
 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 PortOut($378,0);  delay(d);
 PortOut($378,1);  delay(d);

 //
 PortOut($378,0); delay(d);
 PortOut($378,2); delay(d);

end;

Delphi-Quellcode:

procedure Delay(Milliseconds: Integer);
var
Tick: DWord;
Event: THandle;
begin
Event := CreateEvent(nil, False, False, nil);
try
  Tick := GetTickCount + DWord(Milliseconds);
  while (Milliseconds > 0) and
   (MsgWaitForMultipleObjects(1, Event, False, Milliseconds, QS_ALLINPUT) <> WAIT_TIMEOUT) do
    begin
      Application.ProcessMessages;
      if Application.Terminated then Exit;
      Milliseconds := Tick - GetTickcount;
    end;
finally
  CloseHandle(Event);
end;
end;

Leute, schlagt mich. Was zur ...... mache ich denn falsch??? Das ist doch nicht das erste mal dass ich einen Schieberegister beschreibe...