5x7-Anzeige umrechnen

[H.Joachim S. (crazyhorse)]

Ich brauche mal nen Schubser :-)
Zeilen (7) werden gemultiplext, Spalten (5) parallel ausgegeben.
Die Daten kommen aber in 5Byte (also spaltenweise) rein. Kann man 
natürlich Bit für Bit abklappern, aber das müsste doch eleganter gehen?

[Sebastian R. (sebastian_r569)]

Maskieren und das Byte auf das Ausgangsregister schreiben?

Wenn die Schaltung entsprechend intelligent gestaltet und die 
Spalten-Bits sortiert sind.

[Harry L. (mysth)]

Look-Up-Table

[MaWin (Gast)]

H.Joachim S. schrieb:
> Kann man natürlich Bit für Bit abklappern, aber das müsste doch
> eleganter gehen?

Einfach Spalten multiplexen und Zeile als Byte ausgeben, das steigert 
die Helligkeit auch um 40% bzw. reduziert den nötigen Spitzenstrom, man 
brauchg halt 7 statt 5 Vorwiderstände.

Ansonsten gibt es Bitmatrix-Rotationsalgorithmen die erst 4x4, dann 2x2 
Blöcke drehen, aber die sind nicht 'einfacher' zu formulieren.

[Thomas E. (thomase)]

H.Joachim S. schrieb:
> aber das müsste doch eleganter gehen?

Du mußt das spaltenweise Array in ein zeilenweises umsortieren. Das sind 
ein paar Zeilen Code in einer Schleife und dem Controller ist die 
Eleganz dabei vollkommen egal.

Harry L. schrieb:
> Look-Up-Table

Da gibt es nicht viel zu gucken.

[Peter D. (peda)]

Beim Schreiben vom Zeichensatz-Flash in den Bild-RAM drehen.
Oder gleich richtig rum im Flash ablegen, wenn der Platz reicht.

[Egon D. (Gast)]

H.Joachim S. schrieb:

> Zeilen (7) werden gemultiplext, Spalten (5) parallel
> ausgegeben. Die Daten kommen aber in 5Byte (also
> spaltenweise) rein. Kann man natürlich Bit für Bit
> abklappern, aber das müsste doch eleganter gehen?

Schuss aus der Hüfte:
Je nach Wortbreite und Maschine mit 100010000100001b
multiplizieren, maskieren, ggf. Schieben und verodern.

[Marc V. (Firma: Vescomp) (logarithmus)]

H.Joachim S. schrieb:
> Ich brauche mal nen Schubser :-)
> Zeilen (7) werden gemultiplext, Spalten (5) parallel ausgegeben.
> Die Daten kommen aber in 5Byte (also spaltenweise) rein. Kann man
> natürlich Bit für Bit abklappern, aber das müsste doch eleganter gehen?

 Wenn die Spalten alle auf einem Port sind, musst du die 5 Bytes in 5
 Register laden und diese Register dann 7 Mal (beim Multiplexen) in den
 für Ausgabe vorgesehenen Register schieben.
 Sollte aber in Assembler weniger als 20 Takte dauern, etwa 1 us.

Peter D. schrieb:
> Beim Schreiben vom Zeichensatz-Flash in den Bild-RAM drehen.
> Oder gleich richtig rum im Flash ablegen, wenn der Platz reicht.

 Dazu bedarf es dann aber 7 Bytes, nicht 5.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Harry L. schrieb:
> Look-Up-Table
Eine LUT bringt hier leider nichts, weil die Bits keinerlei Korrelation 
zueinander haben. Sie sind lediglich an der falschen Stelle.

MaWin schrieb:
> Einfach Spalten multiplexen und Zeile als Byte ausgeben
Schlimmstenfalls hängt da sogar ein Binärdecoder an den Zeilen, sodass 
man nur 1 Zeile aktivieren kann.
Ich hätte aber auch prinzipiell eher 1:5 als 1:7 gemultiplext...

H.Joachim S. schrieb:
> das müsste doch eleganter gehen?
Weil/wenn der µC keine "Matritzendrehfunktion" hat, bleibt nichts 
anderes, als die Bits einzeln herauszuklauben. Ob man das effizient oder 
umständlich löst, steht auf dem nächsten Blatt.

[H.Joachim S. (crazyhorse)]

Ok, gut, dann bin ich beruhigt, ich dachte ich übersehe was ganz 
einfaches.
Hardware umbauen geht nicht (wieder mal die gute alte alte VQC10 :-) ).

Am Zeichensatz rumbasteln hilft auch nicht, da es bei der gewünschten 
Betriebsart jede LED einzeln  ansteuerbar sein soll.

mask=0x10;
i=0;
for (loop=0;loop<20;loop++)
             {temp=pixel_direct_buffer[loop];  //4x5Byte
              if (temp & 0x01)
                 pixel[i][0]|= mask;
              if (temp & 0x02)
                 pixel[i][1]|= mask;
              if (temp & 0x04)
                 pixel[i][2]|= mask;
              if (temp & 0x08)
                 pixel[i][3]|= mask;
              if (temp & 0x10)
                 pixel[i][4]|= mask;
              if (temp & 0x20)
                 pixel[i][5]|= mask;
              if (temp & 0x40)
                 pixel[i][6]|= mask;
              mask=mask>>1;
              if (!mask)
                 {mask=0x10;
                 i++;
                 }
             }

[Eric B. (beric)]

Marc V. schrieb:
> Peter D. schrieb:
>> Oder gleich richtig rum im Flash ablegen, wenn der Platz reicht.
>
>  Dazu bedarf es dann aber 7 Bytes, nicht 5.

Deswegen schreibt er ja "wenn der Platz reicht".
Es ist aber die eleganteste und schlussendlich einfachste Lösung.

[Georg (Gast)]

H.Joachim S. schrieb:
> Kann man
> natürlich Bit für Bit abklappern, aber das müsste doch eleganter gehen?

Muss man denn das auf der Ebene Segmente bearbeiten? Ich gebe da in der 
Gegel Strings aus und erstelle die notwendige Tabelle Zeichen -> 
Segmente gleich in der passenden Anordnung.

Das ist wohl auch mit Lookup gemeint - irgendwo muss ja eine Zahl in die 
Segmentdarstellung umgesetzt werden. Und für 7 Segmente + DP ist der 
Arbeitsaufwand für die Tabelle ja wohl noch zumutbar.

Georg

[Egon D. (Gast)]

Lothar M. schrieb:

> Harry L. schrieb:
>> Look-Up-Table
> Eine LUT bringt hier leider nichts, weil die Bits
> keinerlei Korrelation zueinander haben. Sie sind
> lediglich an der falschen Stelle.

Tatsächlich?

Man kann also Permutationen NICHT per Tabelle berechnen,
weil die Bits ja nur an der falschen Stelle sind und
keine Korrelationen zueinander haben?