Servus DP,

ich habe eine Frage: Wie kann ich mit TComport ein Byte im Format &B11001100 senden? Es geht darum die Sendezeit eines Musters für meinen LED Cube zu verringern, denn wenn ich ein Byte als String sende, dann schickt Delphi ja 10 Bytes.

Ein Muster (liegt in einem array) sieht so aus:

markieren

Code:

&B01000000  &B00000000  &B00000000  &B00000000
&B00100000  &B00000000  &B00000000  &B00000000
&B00010000  &B00000000  &B00000000  &B00000000
&B00001000  &B00000000  &B00000000  &B00000000
&B00000100  &B00000000  &B00000000  &B00000000

Als links oben ist eins und dann nach rechts immer eins addieren und in der nächsten Zeile links weitermachen.

Das Protokoll sieht so aus:

markieren

Code:

Arrayfeld ; Muster
Bsp.:
02;&B11001100

Ich hoffe mir kann jmd. helfen, denn wenn ich ein String sende '02;&B11001100' dann dauert das natürlich viel zu lange und ich möchte ja gerne eine Musik Visualisierung drauf laufen lassen.

Wie viele LEDs hat der Cube pro Fläche und wie viele Flächen gibt es?

Der Cube ist 5³ also 125 LEDs. Davon sind 25 pro Ebene und eine Zeile in meinem Muster ist immer eine Ebene. Das Muster muss so sein, da es eigentlich nur die Ausgangszustände pro Port sagt und meine Bits für die Ebenen schon gesetzt sind.

Also am Protokoll könnte man was ändern am Muster jedoch nicht. Und der AtMega muss das ja auch noch verarbeiten.

Das heisst dann also mit 15 Bytes könnte man alle Leuchtdioden neu setzen.
Wobei bei jedem Byte von 8 möglichen Bits nur 5 benützt werden.

Wenn wir die Ebenen mit A,B,C benennen und die Zeilen mit 1 bis 5 dann ergäbe sich folgende Zuordnung

markieren

Code:

   EbeneA  EbeneB  EbeneC
================================
1  ByteA1  ByteB1  ByteC1
2  ByteA2  ByteB2  ByteC2 
3  ByteA3  ByteB3  ByteC3   
4  ByteA4  ByteB4  ByteC4   
5  ByteA5  ByteB5  ByteC5

In deinem Beispiel sind es 20 Bytes; was mich jetzt etwas verwirrt.
Je weniger Bytes übertragen werden, umso schneller die Reaktion.

Nagut nun zum Protokoll
Du sendest eine Anfangskennung (in deinem Bsp war das 02 gefolgt von den 15 Bytes in einem Block.
Das wären dann 18 Bytes insgesamt und du kannst mit Baudrate die Reaktionszeit ausrechnen:
9600 Baud / 11 / 18 = 48,5 Änderungen pro Sekunde (im Optimalfall)

Ich denke du hast da etwas falsch verstanden.

Meine 20 Bytes sind fest. Da sind noch die 5 Transistoren um die Ebenen zu schalten. Das sind die 1 in meinem Muster.
Und pro Zeile sind das dann die Ausgangszustände meines AtMegas.

Meine Frage ist also wie kann ich ein Byte einzeln senden, denn wenn ich das als String sende, dann schick er ja 10 Bytes statt einem.

Zitat von Muellermilchtrinker:

Meine Frage ist also wie kann ich ein Byte einzeln senden, denn wenn ich das als String sende, dann schick er ja 10 Bytes statt einem.

Write(@ZuSendendesByte,1)

Zitat von Muellermilchtrinker:

Meine 20 Bytes sind fest. Da sind noch die 5 Transistoren um die Ebenen zu schalten. Das sind die 1 in meinem Muster.
Und pro Zeile sind das dann die Ausgangszustände meines AtMegas.

Das heisst also der kleinstmögliche Befehl schaltet eine Zeile auf allen drei Ebenen
und benötigt dazu 4 Bytes:

markieren

Code:

&B00010000  &B00000000  &B00000000  &B00000000

Zitat von Muellermilchtrinker:

Meine Frage ist also wie kann ich ein Byte einzeln senden,

Das ist eine ganze schlechte Idee, weil durch den FIFO in der seriellen Schnittstelle kannst du sowieso das Timing wie die Byte rausgehen nicht kontrollieren.

Ich würde es so machen, dass immer ein Befehlbyte gefolgt von den 4 Datenbytes gesendet wird.

markieren

Code:

Befehl     Row-Select  EbeneA     EbeneB      EbeneC
&B00000001 &B00010000  &B00000000  &B00000000  &B00000000

Wenn der AT-Mega den Befehl &B00000001 bekommt, dann weiss er, dass noch 4 weitere Byte folgen müssen.
Er empfängt die 4 Bytes schickt diese auf seine Ports und wartet auf den nächsten Befehl.
Im Delphiprogramm wird der Befehl inklusive der Daten auf einen Rutsch gesendet; nur so macht das Sinn.

Ich mal folgende Befehle vorsehen:
&B00000001 - Beschreibung oben
&B00000011 - Alle LEDs an
&B00000101 - Alle LEDs aus
&B00000111 - Alle LEDs invertieren

Leute ich bekomm das einfach nicht gebacken die Anzahl der Bytes die er sendet zu minimieren.

Mein jetziger Code:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.ButtonPicSendClick(Sender: TObject);
  var i:integer; s:String;
begin
  fcMakeCodeforRS232;
  for I := 1 to 20 do
  begin
    s := format('%.2d',[i])+';'+marray[i];
    comport1.WriteStr(s+#13);
    sleep(1);
  end;
end;

In marray steht mein Muster drin. Format siehe oben.
Ich weiß, dass ich es am besten mit Comport1.Write() machen soll, aber jeder Versuch wollte bei mir nicht. Es als String zu senden dauert einfach viel zu lange, da dort ja mehr als ein Byte gesendet werden, wenn ich nur ein Byte senden möchte.
Laut Serial Port Monitor werden 280 Bytes gesendet. Das sind viel zu viele um ein schnelle Übertragung zum Beispiel für Musikvisualisierung bei einer niedrigen Baudrate zu bekommen.
Momentan arbeite ich mit einem USB-Seriell-Adapter bei einer Baudrate von 250.000 um eine halbwegs schnelle Übertragung zu bekommen.

Vielleicht gibts ja hier ein Comportexpert und kann mir helfen. Danke.

1. Du zeigst immer nur Bruchstücke von Deinem Kode, da kann man Dir schlecht helfen.
Die Deklaration vom marray und der Kode von fcMakeCode... wäre nicht schlecht.

2. Du hast kein Problem mit dem Comport, sondern mit dem Verständnis, was ASCII-Strings und was Binärdaten sind.

Sorge einfach dafür, dass Dein zu sendendes Bitmuster binär in einem Array of Byte liegt. Dann kannst Du dieses Array problemlos mit der Write-Methode senden.

Write(DasZuSendendeArray,LaengeDesArray)

Gruß
Erich

Also in marray (String) steht:

markieren

Code:

marray[1] := &B01000000
marray[2] := &B00000000
marray[3] := &B00000000
marray[4] := &B00000000
marray[5] := &B00100000
marray[6] := &B00000000
marray[7] := &B00000000
marray[8] := &B00000000
marray[9] := &B00010000
marray[10] := &B00000000
marray[11] := &B00000000
marray[12] := &B00000000
marray[13] := &B00001000
marray[14] := &B00000000
marray[15] := &B00000000
marray[16] := &B00000000
marray[17] := &B00000100
marray[18] := &B00000000
marray[19] := &B00000000
marray[20] := &B00000000

Da Programm intern meine Zustände in einem 3D-Array liegt, konvertiert die Funktion fcMakeCodeforRS232 einfach die richtigen LEDs zu meinem Musterformat oben und legt diese dann in marray.