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:

markieren

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.)

zusammenfalten · markieren

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;

zusammenfalten · markieren

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...

zusammenfalten · markieren

Delphi-Quellcode:

			procedure WriteWord(const APort: Word; const AData: Word);

const

  CLOCK = 1;

  LOAD = 2;

  DATA = 4;

var

  i: integer;

  lData: Word;

  lPortData: Byte;

  lBit: boolean;

begin

  lData := AData;

  // Wenn LOAD definitv auf high ist beim reinspringen in diese Proc, dann können die ersten beiden Zeilen weg...

  //PortIO(APort, LOAD);

  //Delay(20);

  PortIO(APort, 0);

  for i := 0 to 15 do

  begin

      // Bit ermitteln

    lBit := ( lData and $8000 ) <> 0;   // falls es dann gespiegelt ist, dann halt lBit := ( lData and 1 ) <> 0 und unten shr statt shl

    lData := lData shl 1;

    lPortData := CLOCK;

    if lBit then

      lPortData := lPortData or DATA;

    PortIO(APort, lPortData);

    Delay(20);

    PortIO(APort, lPortData and not CLOCK);

    Delay(20);

  end;

  PortIO(APort, LOAD);

end;

Ungetestet und hier im Beitragseditor getippelt...

**tr909**

probier doch mal (nur ne Vermutung) :

markieren

Delphi-Quellcode:

			 
procedure TForm1.Button8Click(Sender: TObject);

var

  output : word;

begin

  word := 2560; //0000 1010 0000 000 in dezimal

  PortOut($378,output); // oder PortOut ($378,$A00);

end;

Gruß
tr909

Das bringt doch nichts, da er seriell shiften muss.

**tr909**

hmm. stimmt. Muss ich überlesen haben.

Gruß
tr909

**Reinhard Kern**

Zitat von tr909:

probier doch mal (nur ne Vermutung) :

markieren

Delphi-Quellcode:

			 
procedure TForm1.Button8Click(Sender: TObject);

var

  output : word;

begin

  word := 2560; //0000 1010 0000 000 in dezimal

  PortOut($378,output); // oder PortOut ($378,$A00);

end;

Gruß
tr909

Hallo,

interessanter Versuch - aber LPT ist 8 bit breit und wird es immer bleiben.

Gruss Reinhard

**BoondockDuckling**

hey. danke soweit schon

@Muetze1
mit deinem Code passiert zwar etwas aber nicht das was passieren soll.
(kleine Erklärung: die Bitfolge 0000 1010 0000 0000 setzt die Leuchtintensität einer LED-Matrix, die am IC hängt, auf Minimal. Desshalb habe ich diese Bitfolge als Testfolge genommen. Stattdessen verschwindet aber einfach eine Zeile der Matrix. Das wird wohl eine Fehlinterpretation des ICs sein.)

Wenn ich, wie von dir angegeben, die Folge spiegel passiert garnichts mehr.

Ich habe nur ein relatives Delphi-Grundwissen und habe auch einige Minuten gebraucht deinen Code zu verstehen (und bin begeistern wie intelligent man sowas lösen kann

).

Was z.b. bedeutet das hier:
lBit := ( lData and $8000 ) <> 0;
bzw. was hat die and $8000 und das <> 0 für eine Funktion?

Achja aufgerufen habe ich die Prozedur so: WriteWord($378,2560); ... das sollte ja stimmen.

@reinhard
naja der lpt hat ja so viele pins... da kann man ja mal durcheinanderkommen

@tr909
ja wie schon gesagt tuts hier nix zur sache wieviel ausgänge der lpt hat denn die bitfolge wird an einem pin übergeben. die beiden anderen dienen nur zum schalten.