16-Bit Folge über LPT ausgeben

[BoondockDuckling]

sohooooo ....
das Problem wäre gefunden. Beim Übertragung der Bits muss ein Timing eingehalten werden.

Code:

/Load  -\__________________________________/-

Data   __/---\_________/---\_________/---\___

Clock  ___/-\____/-\____/-\____/-\____/-\____

Relativ stümperhaft habe ich das in meinem Code mal so eingebaut:

Delphi-Quellcode:

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

klappt sogar bis zu einem Delay von 5ms.


Wie könnte man das denn noch in deinen Code einbauen?

[Muetze1]

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;

  PortIO(APort, 0); // LOAD löschen

  for i := 0 to 15 do
  begin
      // Bit ermitteln
    lBit := ( lData and $8000 ) <> 0;
    lData := lData shl 1;
   
    if lBit then
      lPortData := DATA
    else
      lPortData := 0;
    PortIO(APort, lPortData);  // Data setzen
    delay(5);                  // kann vllt. weg
    PortIO(APort, lPortData or CLOCK);   // CLOCK zusätzlich setzen
    delay(5);
    PortIO(APort, lPortData);  // CLOCK wieder löschen

      // trotz des Timings können folgende beiden Zeile wahrscheinlich weg...
    delay(5);    
    PortIO(APort, 0);          // DATA löschen
  end;

  PortIO(APort, LOAD);
end;

Wieder nur aus dem Beitragseditor...

[BoondockDuckling]

danke
ich werds heute abend mal testen :)

[oldmax]

Hi
Ich habe dir bereits im DF geantwortet, aber hier mal zum Verständnis:
Bei SHR muß Bit 0 maskiert werden also And $0001
Dann mal zur beschaltung:

Zitat:

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)

Wenn Pin 3 der Data-Pin ist muß anschließend ein SHL 2, das heißt , das maskierte Bit 0 auf Bit 2 geschoben werden. Anschließend sind die Pins Clock mit Or $0001 und Or $0002 hinzuzufügen. Entsprechend dem Impulsdiagramm. Dabei ist zu beachten, das das Load Bit vor der Übertragung bereits einmal ausgegeben werden muß (Maskiert mit $0002) dann wird das Datenbit gesetzt und ! das Load Bit. Anschließend ein Clock- Bit und das Datenbit und das LoadBit. Danach wieder Datenbit und Loadbit und zum Schluß nur ein Loadbit, bzw. wieder von vorn mit dem einmal nach rechts geschobenen Originalwort.
Es ist halt wichtig, das man sich merkt, bei der Maskierung des Datenbits gehen die Load und Clockbits erst mal verloren und müssen entsprechend wieder hinzugefügt werden.
Gruß oldmax

@Muetze: Sorry, hab das grüne nicht gelesen und das Impulsdiagramm vom DF im Kkopf gehabt... daher bin ich etwas über die Signallage gestolpert. Dein Code dürfte ok sein.

[BoondockDuckling]

Und aus Abend wurde Morgen ...bzw. Mittag


Good News Everyone ... Es funktioniert :)


Ich unter einer Delayzeit von 8ms funktioniert es aber nicht mehr gescheit. Dann treten bei der Übertragung öfters Fehler auf. Das Problem habe ich mit der Software von Maxim aber auch. In deren Programm muss ich manchmal auch mehrfach Senden bis es richtig übertragen wird. Könnte an der Kabellänge liegen.

Etwas doof ist dass das Schreiben einer Matrix, also dem 5*7 Display, 2,5Sekunden dauert. (Kommt aber ja hin. Pro Schreibvorgang sind es knapp 400ms an Delayzeiten. Auf 5 Zeilen müsste es min. 2 Sekunden dauern.)



@oldmax
so ganz sicher bin ich mir jetzt nicht ob ich dir folgen kann. Im Prinzip wird das was du erklärst doch in dem Code von Muetze durchgeführt oder versteh ich jetzt etwas falsch?

[oldmax]

Hi
Ja, ich hab mal wieder nicht vollständig gelesen und nachvollzogen...irgendwie hatte ich auch die Signallage anders im Kopf, daher das Chaos... :oops:
Ich lös halt solche Bitbearbeitung gern über ASM...
Gruß oldmax

[BoondockDuckling]

soweit so schön

jetzt hätte ich noch zwei Fragen:

1. Gibt es eine einfach Möglichkeit mehrere Word-Variabeln in eine Zusammenzufassen. Nicht addieren sondern so als ob man die Binärzahlen hintereinander schreibt. Hierbei kommt es auf die Reihenfolge an und es müssen 16Bit sein, also die Nullen vor einer Folge müssen auch beachtet werden.

Beispiel: Das + hier bedeutet "hintereinander"

Code:

  
-    | Hexadezimal | Integer      | Binär
1:   |      A01    |      2561    |                     0000 1010 0000 0001 
2:   |      37F    |       895    |                     0000 0011 0111 1111 
1+2: | 1400837F    | 335577983    | 0000 1010 0000 0001 0000 0011 0111 1111 
2+1: |  37F0A01    |  58657281    | 0000 0011 0111 1111 0000 1010 0000 0001

2. Wie kann ich herausfinden wie viele 16-Bit Folgen vorhanden sind?
Theoretisch können zwei Folgen ja so aussehen: 10000000000000001 und wäre Hexadezimal eine 1001 bzw. als Integer eine 4097. Wäre ja was ganz anderes als Hexadezimal FFFFFFFF, also von der binären Länge der Folge.


Ich könnte mir da jetzt irgendwas zusammenbasteln das zwar funktioniert, aber es gibt ja sicherlich intelligentere Wege als mit irgendwelchen Schleifen etc zu hantieren. (wäre jetzt meine Überlegung)



Nachtrag: ach ich sehe gerade der variablentyp word geht ja nur bis 16Bit... also kann man ja keine zwei word variabeln zusammenfassen.

Um das vielleicht nochmals genauer zu erklären. Man kann mehrer der MAX-ICs kaskadieren, muss dann aber entsprechend viele 16-Bit Folgen schreiben um eine Aktion durchzuführen.

[Muetze1]

Zitat:

Zitat von BoondockDuckling

1. Gibt es eine einfach Möglichkeit mehrere Word-Variabeln in eine Zusammenzufassen. Nicht addieren sondern so als ob man die Binärzahlen hintereinander schreibt. Hierbei kommt es auf die Reihenfolge an und es müssen 16Bit sein, also die Nullen vor einer Folge müssen auch beachtet werden.

Beispiel: Das + hier bedeutet "hintereinander"

Code:

  
-    | Hexadezimal | Integer      | Binär
1:   |      A01    |      2561    |                     0000 1010 0000 0001 
2:   |      37F    |       895    |                     0000 0011 0111 1111 
1+2: | 1400837F    | 335577983    | 0000 1010 0000 0001 0000 0011 0111 1111 
2+1: |  37F0A01    |  58657281    | 0000 0011 0111 1111 0000 1010 0000 0001

1. Deine Hexadezimalzahl von dem Beispiel mit 1+2 ist mehr als falsch. Es müsste 0A01037F sein.
2. Ein LongWord ist 32 Bit gross, somit 2x 16 Bit
3. Aber wozu? Rufe meine Funktion nacheinander mit den 16 Bit Werten auf, bis du alle 16 Bit Werte ausgegeben hast.

Zitat:

Zitat von BoondockDuckling

2. Wie kann ich herausfinden wie viele 16-Bit Folgen vorhanden sind?
Theoretisch können zwei Folgen ja so aussehen: 10000000000000001 und wäre Hexadezimal eine 1001 bzw. als Integer eine 4097. Wäre ja was ganz anderes als Hexadezimal FFFFFFFF, also von der binären Länge der Folge.

Gar nicht. Der Speicher ist voller Bits und Bytes. Wer nicht weiß was wie zu interpretieren ist und was bedeutet, könntest du nicht ohne weiteres grundlegend Code und Daten unterscheiden. Es gibt keine Möglichkeit dies zu ermitteln.