Manipulationen in einem Bildspeicher

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • Manipulationen in einem Bildspeicher

      Hi Bastler und Denker, gegeben ist ein Leddisplay mit 20 (h) x 40 (b) Bildpunkten. Die pixel sind zu 5x 8bytes in der Breite, das ganze 20x übereinander, ansprechbar. Es gibt somit einen Bildspeicher mit 100 bytes. Ein Zeichen eines 12x16 fonts belegt in der Breite ein ganzes byte und die restlichen 4 bit werden auf den bytes links und rechts verteilt. Das ganze in der Höhe 16x. Ein waagrechtes scrollen ist durch shiften der bits relativ einfach zu machen, man muss halt die aus dem byte geshifteten bits in die Nachbarbytes hinein kopieren. So, jetzt die eigentliche Frage, wie scrollt man am geschicktesten einzelne (!) Zeichen in der Vertikalen? Die komplett belegten bytes werden einfach nach oben/unten im Speicher rum kopiert. Bleiben jetzt die 'angebrochenen' byte(s). Gibt's da einen Trick, das elegant und schnell zu machen? Der Bildspeicher wird natürlich ständig angezeigt, wenn das Manipulieren langsam geht, dann verwischt es ja die Anzeige. Wenn man die Manipulation außerhalb der Bildspeichers vornimmt und das Ergebnis dann nur in den Bildspeicher kopiert, wird das besser aussehen. Bleibt aber immernoch, wie macht man das am schönsten=schnellsten. Es muss ein 12x16 Zeichen zeilenweise nach oben/unten aus dem Bildspeicher geschoben werden und der freie Platz wird durch ein anderes Zeichen belegt, halt wie bei einem Walzenzählwerk.
      Der Bildspeicher ist ein eindimensionales array.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Der Index für ein Zeichen startet bei welcher Position? Bei 12 Bit (=3 Nibbles) finde ich es unpraktisch, wenn mit 2 Bit links und rechts der Bytegrenze gearbeitet wird - was nicht heißt das es nicht geht. Das die 4 übrigen Bits (40 Pixel / 12 = 3 Rest 4) gleichmäßig verteilt werden sollen ist mir optisch klar...
      Das vertikale Rausrollen würde ich in einer Schleife realisieren, dazu die betreffenden 3 Bytes maskieren (damit die benachbarten Zeichen stehen bzw. unberücksichtigt bleiben) und dann mit Index+/-5 kopieren.
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • Im Prinzip kann der Text, bzw Zeichen beliebig auf dem display angeordnet werden. Wenn jetzt so ein Zählwerk angezeigt werden soll, werden die Zeichen mittig in der Höhe platziert werden, Bei 16pixel Zeichenhöhe und 20 pixel displayhöhe, dann halt in der 3. Reihe von unten beginnend, unten 2 pixel Abstand zum Rand, oben auch 2 pixel. Wird das Zeichen nach unten geschoben, dann passiert erst dann was in der oberen Pixelreihe, wenn das Zeichen unten schon aus dem display verschwindet, dann sieht man oben schon die untere Kante des neuen Zeichens.
      Der font ist so organisiert, dass 2 bytes eine Spalte des Zeichens entsprechen. Also ein 12x16 font benötigt 12x2bytes pro Zeichen. Die bytes vom font muss man stehend betrachten, die bytes im Bildspeicher liegen.
      Ein Programm für einen statischen Text schaut zB. so aus. Es ist eine 20x40 rgb-matrix.
      Files
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Das horizontale schieben der Bits bewirkt eine seitliche Bewegung.
      Das Vertikale schiebe funtioniert genauso. Nur eben nicht um 1 Bit schieben, sondern um die Anzahl Bits der Zeichenhöhe. Da du 2 Byte für 1 Zeichen in der Breite hast, müsstest du vermutlich 2x Zeichenhöhe schieben.

      Schieben bedeutet hier Bytes im Array umkopieren.
      Kaum macht man es richtig - und schon geht's!
    • Guenther wrote:

      Bytes im Array umkopieren ist doch meistens überflüssig. Da kann man doch einfach einen Zeiger auf den Anfang setzen und diesen zum Shiften vergrößern bzw. verkleinern.
      Da stellt sich mir die Frage, ob die Verwaltung von Zeigern bei derart kleinen Speicherbereichen wirklich spart. Aber vielleicht habe ich den Lösungsansatz noch nicht verstanden.
      Die Anforderung, dass die folgende/vorherige Ziffer quasi auch teilweise zu sehen sein soll hat mich dazu erwogen, die Pixel zu kopieren/überschreiben.
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • Mitch64 wrote:

      Schieben bedeutet hier Bytes im Array umkopieren.
      das ist mir schon klar. Mir geht es ja um die angefangenen bytes. Da muss ich ja 1 bis 4 bits davon auch rumkopieren. Entweder einzeln oder mit Maskierungen. Das sind halt dann in der Summe ein ganzer Haufen an Befehlen.

      Guenther wrote:

      Da kann man doch einfach einen Zeiger auf den Anfang setzen und diesen zum Shiften vergrößern bzw. verkleinern.
      Das geht hier nicht, weil das array Bildspeicher ja direkt an das display ausgegeben wird. Zeiger nützen da nix.

      Vielleicht wäre ein anpassen meiner Zeichen-zu-Bildspeicher Prozedur das einfachste. Es wird dann der Bereich des Bildspeichers eben mit Teilen der 2 Zeichen beschrieben. Dabei wird dann nix im Bildspeicher umkopiert.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Das dauert ja dann 'ewig' und es würde die komplette Anzeige vertikal versetzen. Es ändert sich ja nur im Bereich der scrollenden Zeichen der Bildspeicher etwas.

      Oder winnst du nur eine Ziffer (Zeichen) shieb a_27_b277ca12 klingonisch?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hi @tschoeatsch
      Ich glaube nicht, dass das ewig dauern würde, wenn man das ganze Display vertical (bzw. des Array) scrollt.

      Aber davon abgesehen.
      Da du nur 1 Zeichen verschieben willst, wirst du Wordweise (16-Bit) vorgehen müssen.
      Also Quell-Word laden und ZielWord laden.
      Dann an Quellword mit 0 schreiben und an Zielword den neu berechneten Wert speichern.

      Ob du nun das 1. Nibble (links) oder der letzte Nibble (rechts) maskieren musst, hängt dabon ab, ob die Zeichenposition an einer geraden oder ungeraden Position sitzt.

      (ich muss ständig über erweiterte Antwort senden! Problem noch nicht behoben?)
      Kaum macht man es richtig - und schon geht's!
    • Ich mach mal hier weiter, es handelt sich aber um eine 32x64 RGB-Matrix.
      Für dieses Zählwerk verwende ich jetzt 2 Zwischenspeicher, mem_start(60) as word und mem_ziel(60) as word. Der Startspeicher wird mit dem Text der Zahl geladen, der Zielspeicher wird an der gewünschten Stelle in den Bildspeicher kopiert. Vor jedem kopieren wird aus dem Startspeicher in den Zielspeicher geshiftet, wo die Ziffern sich ändern sollen. Was besseres ist mir jetzt nicht eingefallen. Das schaut jetzt so aus, erst wird rauf und runter gezählt, dann verschiedene Zufallszahlen angezeigt. Das demonstriert, dass sich nur die veränderten Stellen drehen.
      Files
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------