EA DOGM128 128x64 Grafik Display

Hallo,

daran wäre ich auch brennend interessiert !

Thomas

Gibt jetzt auch die 132x32 bei Reichelt für 13,70€!!

Weiss jemand, ob die 132x32 in die Sockel der alphanumerischen Versionen 
passen, also identische Abmessungen und Pinbelegungen haben?

@Diego
Wenn Du das DIP122x-5 Modul meinst, dann passt dieses auch auf den 
Sockel der Text-Module mit 2x 9poligen Steckverbinder, z.B. DIP-204x-4. 
Auch die Anschlüsse sind kompatibel, DIP-122x-5 Modul hat jedoch noch 
einen 2. Enable-Anschluß, welcher bei den Text-Module frei bleibt.

Matthias

@Matthias
Nein, ich meine selbstverständlich die Module der DOG-Reihe z.B. 
eDOG162, siehe Link des Posters.

Hab's aber bereits befunden, die Teile haben dieselben Abmessungen, aber 
sind leider NICHT pinkompatibel. Also leider nicht variabel einsetzbar, 
ein Kombi-Layout für beide Versionen macht wenig Sinn.

Hatte ich auch schon nachgeschaut. Wäre schön gewesen :)

Hi

Reichelt hat die mittlerweile auch im Programm.

MfG Spess

Hallo,

gibts was neues ?  Hat jemand schon was aus dem Display heraus gelockt ? 
Bei mir liegen die beiden Dinger (128 und 132) rum und ich weiß momentan 
nichts damit anzufangen. Gibts schon irgendwelche Libraries oder 
Routinen ?

Thomas

Bei mir ist ein 128x64 in einem Breadboard am Laufen. Wie schon weiter 
oben erwähnt, muss man einen Display-Buffer im µC vorhalten, weil man 
nur schreibend aufs Display zugreifen kann, deshalb ist meine Wahl auf 
den Mega-32 gefallen. Bin momentan dabei, eine kleine Grafik-Library 
zusammenzubasteln, ist nichts weltbewegendes, sobald man einen "plot" 
zusammen hat...

Hallo,

ich hab ein 132er hier in Verbindung mit einem ARM Cortex-M3 am laufen 
über SPI. Klappt super und sieht gut aus. Bei Bedarf kann ich den 
Quelltext (in C) posten (der bedarf aber noch überarbeitung).
Ich hab ein paar GLCD Libs von Atmel portiert und etwas erweitert.

Grüße

Genau so sieht es bei mir auch aus.
Ich finde das ziemlich fies, dass man nicht vom Display lesen kann, 
nicht mal den Status, so weiß ich nicht einmal wo das Problem liegt. 
Vielleicht nur eine kleine Leitung falsch? Man weiß es leider nicht...
Aber wenn ich mir wenigstens beim Code sicher sein könnte, wäre das 
schon mal ein Fortschritt!

Meine Initialisierung:

------------------------------------------------------------------------
Reset HIGH
200ms warten
Reset LOW
------------------------------------------------------------------------
spi_master_send_char(0x40); // Display start line 0

spi_master_send_char(0xA1); // ADC reverse

spi_master_send_char(0xC0); // Normal COM0~COM63

spi_master_send_char(0xA6); // Display normal

spi_master_send_char(0xA2); // Set bias 1/9 (Duty 1/65)

spi_master_send_char(0x2F); // Booster, Regulator and Follower on

spi_master_send_char(0xF8); // Set internal Booster to 4x
spi_master_send_char(0x00);

spi_master_send_char(0x27); // Contrast set
spi_master_send_char(0x81);
spi_master_send_char(0x16);

spi_master_send_char(0xAC); // No indicator
spi_master_send_char(0x00);

spi_master_send_char(0xAF); // Display on
------------------------------------------------------------------------

Die spi_master_send_char(unsigned char) sieht so aus:


void spi_master_send_char (unsigned char c)
{
  SPDR = c;                    // sende Zeichen
  while (!(SPSR & (1<<SPIF)))  // warten bis Senden moeglich
  {
  }
  _delay_us(100);
}

(vorher natürlich spi init)
------------------------------------------------------------------------



Den A0-Pin habe ich mal dauerhaft auf LOW, da man zur initialisierung 
keine Displaydaten benötigt.
Um zu testen, ob meine Initialisierung klappt, habe ich mit dem 4. 
Befehl rumgespielt: 0xA6 soll alle Pixel ausschalten, 0xA5 alle an (wohl 
für invertierten Modus gedacht)

Ist meine Initialisierung so OK? Die ist aus dem Datenblatt ("Single 
Supply") aber laut anderen Usern hier im Forum nimmt EA das nicht so 
genau mit den Beispielen (bei z.B. 2x16-Displays oder so hat das 
angeblich nicht 100% gestimmt...)

Also der µC sendet irgendwas (eine Test-LED blitzt auf), das weiß ich, 
mehr weiß ich aber nicht, hab leider kein Oszi.


Kann mir / uns jemand weiterhelfen?

Grüße,
Sebastian

Ich bin am verzweifeln! In einer Woche muss mein Display laufen, ich 
brauche das für ein Projekt...

Ich hab einen Fehler in meiner Initialisierung gefunden und zwar hab ich 
aus Versehen die Invertierung des RESET-Pins nicht beachtet. Muss also 
erst LOW, dann HIGH sein.

Wenn jemand irgend eine Idee hat, bitte sofort melden. Ich stehe unter 
Zeitdruck... Man findet im Internet wirklich fast gar nix zu diesem 
Display. Ich komme mir irgendwie verar***t vor...

Grüße,
Sebastian

Hallo,

ah ja, es tut sich was. Hat jemand das Ding auch schon mit BASCOM zum 
Laufen gebracht ?  Ich kann leider kein ASM oder C :(

Thomas

Martin, du bist genial! :D
Danke für deinen Initialisierungscode, der anscheinend nicht nur mir 
half...

Ich weiß zwar nicht was ich jetzt wirklich anders gemacht habe, aber 
mein DOGM scheint sich auf magische Weise initialisiert zu haben. :) Ich 
habe jetzt, wenn ich nach dem Initialisieren A0 auf HIGH setze, ein 
Standbild mit zufälligen Pixeln, wohl einfach ein zufälliger RAM-Inhalt. 
Immerhin!

Jetzt habe ich aber noch einen kleinen Anschlag auf dich vor:

Ich möchte nicht, dass jetzt der Eindruck entsteht dass ich andere für 
mich arbeiten lasse (du siehtst ja auch dass ich mich bemüht habe; der 
Code oben ist ja meiner), aber ich möchte einfach nur nichts falsch 
machen! Wenn das Display jetzt kaputt gehen würde wäre ich im Eimer :( 
weil das ganze ne Projektarbeit ist und bis übernächste Woche fertig 
sein muss. (Das Projekt ist ansonsten fast fertig, nur bisher läuft die 
Grafikausgabe über ein "virtuelles Display" am PC)

Also wärst du jetzt mein Gott, wenn du mir nur noch eine Funktion posten 
könntest, um das Display-RAM einmal komplett zu schreiben. Sprich: Ich 
habe meine 1024 Bytes im RAM vom µC und möchte dieses Frame senden. Ich 
bin mir nur unsicher mit den Befehlen zum Starten & Beenden eines Frames 
und wie ich den Zeiger automatisch inkrementieren kann... das wäre es ja 
dann quasi auch schon. Desweiteren habe ich keinen Überblick über das 
Timing bzw wann es eine Rolle spielt. Ich muss gestehen, dass ich noch 
nie mit einem Grafikdisplay gearbeitet habe.

Und nochmals vielen vielen Dank für deine Bemühungen!! Ich weiß das sehr 
zu schätzen.

Grüße,
Sebastian

Ok, ich hab mich jetzt doch getraut :)

Folgender Code setzt alle Pixel. (als Beispiel)
Es hat funktioniert, aber kann man das so lassen oder sollte man noch 
irgendetwas verändern?
PB3 ist bei mir A0, ich habe (noch) keine so tollen Funktionen/Makros 
geschrieben :)

------------------------------------------------------------------------
uint8_t page;
uint8_t column;

for (page = 0; page < 8; page++)
{
  //SPI: DISPLAY DATA
  PORTB &= ~(1<<PB3); // A0 = LOW (SPI: Command)

  spi_master_send_char(0xB0 + page); //Set page address to <page>
  spi_master_send_char(0x10 + 0); //Set column address to 0 (4 MSBs)
  spi_master_send_char(0x00 + 0); //Set column address to 0 (4 LSBs)



  //SPI: DISPLAY DATA
  PORTB |= (1<<PB3); // A0 = HIGH (SPI: Display Data)

  for (column = 0; column < 128; column++)
    spi_master_send_char(0xFF); //Set all pixels
}
------------------------------------------------------------------------

Grüße,
Sebastian

Juhu! Ich habs! :)

Und damit ich nicht der einzige glückliche bin, hier mein Code. Ich 
hoffe jemand kann was damit anfangen. Ich freue mich über Feedback.

( Bitte nicht verwirren lassen durch komische Kommentare in den
  Quelltexten, da ich da ständig hin und her kopiert und immer wieder
  gelöscht und auskommentiert habe...
  Außerdem könnten noch ein paar kleine Schönheitsfehler drin sein... )



In der ZIP-Datei im Anhang befinden sich folgende Dateien:

- driver_dogm128.h: Displayfunktionen, die die SPI-Master-Funktionen
  "spi_master_init()" und "spi_master_send_char()" voraussetzt.
- graphics.h: Grafikfunktionen (zwar wenige aber für das meiste
  ausreichend): einzelne Pixel, Linien, Rechtecke und Text zeichnen
  (sogar variable Zeichenbreite :) )
- font.h: die Schriftart für "graphics.h" (wird im Flash gespeichert),
  Sonderzeichen wie Umlaute siehe Kommentare in dieser Datei.


Erläuterungen:

Im µC werden 1024 Bytes RAM für den Displayinhalt reserviert. (daher 
(meines Wissens nach) erst ab ATmega32 mit 2KB RAM möglich!) Alle 
Grafikfunktionen "zeichnen" in diesen RAM-Bereich.

Benutzt wird das ganze so, dass einfach "graphics.h" eingebunden wird 
(der Displaytreiber wird von graphics.h selbst eingebunden) und mittels 
"g_init()" (SPI muss zuvor initialisiert sein) das Display initialisiert 
und dessen Displayinhalt gelöscht wird.
Ein Frame wird mit "g_end_frame()" abgeschlossen, d.h. dann wird der 
RAM-Inhalt vom µC zum Display übertragen.
Möchte man den RAM-Inhalt löschen, so ruft man "g_clear()" auf, diese 
sendet den leeren Displayinhalt sofort an das Display. Möchte man dies 
nicht, sondern möchte gleich wieder ein Frame zeichnen (ohne dass 
zwischendurch das Display selbst geleert wird), so verwendet man 
"g_clear_dont_refresh()".

Alle anderen graphics-Funktionen erklären sich von selbst:
g_draw_pixel(x, y);             (Pixel aktivieren)
g_clear_pixel(x, y);            (Pixel deaktivieren)
g_draw_line_h(x, y, length);    (horizontale Linie)
g_draw_line_v(x, y, length);    (vertikale Linie)
g_draw_rect(x, y, w, h);        (Rechteckrahmen)
g_fill_rect(x, y, w, h);        (gefülltes Rechteck)
g_draw_string(x, y, *s, trans); (Text, trans gibt an, ob der Hintergrund
                                 transparent sein soll (0 = alle Pixel
                                 beachten, 1 = nur Pixel setzen))

Die Variable "g_inverted" invertiert, falls sie 1 ist, alle 
Grafikbefehle, um z.b. weißen Text auf schwarzem Hintergrund zu 
schreiben, weiße Linien zu malen, usw.

Nicht vergessen: in "driver_dogm128.h" sind natürlich die 
Präprozessor-Definitionen für die I/O-Ports A0 und RESET anzupassen.
Verwendet man mehrere SPI-Slaves, so muss man noch Code für das Slave 
Select einfügen (in "dogm_send()").

Sollte jemand Fehler entdecken oder Verbesserungsvorschläge haben, oder 
sonst ein Feedback geben möchte, bitte posten. Danke!



Viel Spaß!

Grüße,
Sebastian

Reichen bei diesem Display Widerstände zur Pegelanpassung aus (5V -> 
3.3V)?

Hallo,

hat einer das Ding auch schon mit BASCOM zum Laufen gebracht ?  Verstehe 
leider von C nicht so viel :(

Thomas

@ Philipp Putzer:
Ob die Daten brauchbar sind, die du hast, hängt von deinen 
implementierten Grafikfunktionen ab. Ich habe meine komplett selbst 
geschrieben und mich an keine "Standards" gehalten. Bei Schriftarten 
macht es aufgrund von variablen Breiten und konstanten Höhen Sinn, diese 
in "Spalten" zu je 8 Pixeln Höhe zu speichern. Bitmaps speichere ich 
übrigens horizontal, ähnlich wie auch Windows-BMP's im 1-Bit-Modus 
gespeichert sind. So sieht meine Funktion zum Zeichnen von Bitmaps aus:


void g_draw_bitmap_from_flash(uint8_t _x, uint8_t _y, uint16_t addr)
{
  uint8_t w = pgm_read_byte(addr++); //width
  uint8_t h = pgm_read_byte(addr++); //height
  uint8_t s = pgm_read_byte(addr++); //scanlength
  uint8_t p; //position in data row (in bytes)
  uint8_t x; //x position of current pixel relative to _x
  uint8_t y; //y position of current pixel relative to _y
  uint8_t d; //read data

  for (y = 0; y < h; y++)
  {
    for (p = 0; p < s; p++)
    {
      d = pgm_read_byte(addr + (uint16_t)s*(uint16_t)y + (uint16_t)p);
      for (x = p*8; x < p*8+8 && x < w; x++)
      {
        if (d & 1<<(x-p*8))
          g_draw_pixel(x+_x, y+_y);
        else
          g_clear_pixel(x+_x, y+_y);
      }
    }
  }
}



Ein "Bitmap" baut sich folgendermaßen auf:

const uint8_t bitmap_beispiel[] PROGMEM = {
  // HEADER:
  // image width
  24,
  // image height
  8,
  // scanlength (in bytes):
  3,

  // DATA (1 bit = 1 pixel):
  /*
   Hier folgen die Bitmapdaten mit 1 Byte je 8 Pixeln in Reihe.
   Das LSB ist der linke der 8 Pixel, das MSB der rechte.
   Die Breite wird auf volle 8 Pixel gerundet und eine Zeile hat
   soviel Bytes, wie bei <scanlength> eingestellt, die exakte
   Breite lässt sich dennoch bei <image width> einstellen.
   Die Zeilen werden sequentiell von oben nach unten gespeichert
   (im Gegensatz zu Windows-BMP's).
   Maximale Bitmapgröße: 256x256 Pixel.
  */
};

Hallo.

Hat noch niemand die Dinger mit BASCOM zum Laufen gebracht ?

Thomas

22,60 ist ganz schön teuer für so ein kleines LCD, oder ? Natürlich 
nichts im Vergleich zu den viermal so großen und teuren 240x128 T6963C.
Aber wieso nicht Handydisplays nehmen? Wegen sicherer Bezugsquelle?

> 22,60 ist ganz schön teuer für so ein kleines LCD

Und das ist nur der Preis ohne Beleuchtung. Die weisse Beleuchtung 
kostet noch mal 20,10 EUR.

und??? ich bin verzweifel daran das DOGM128x64 ans laufen zu bekommen.
hier bascom 1.11.9.2 im einsatz...
ausserdem möchte ich den Controller KS0108 ans laufen bekommen...

> ich bin neu in der Microcontroller welt ...

Wäre es nicht sinnvoller, erstmal ein Projekt "deutsche Rechtschreibung 
und Grammatik" in dieser Schule zu machen?

Da kommt einem ja die Weihnachtsgans wieder hoch....

Hi

>Wäre es nicht sinnvoller, erstmal ein Projekt "deutsche Rechtschreibung
>und Grammatik" in dieser Schule zu machen?

>Da kommt einem ja die Weihnachtsgans wieder hoch....

Volle Zustimmung. Aber die Ernüchterung kommt spätestens dann, wenn er 
merkt, das ein Compiler/Assembler sehr nachtragend auf solche 
Nachlässigkeiten reagiert.

MfG Spess

Hallo!

Ich hab eine Frage und zwar hab ich zwar nicht genau das selbe Display 
jedoch den selben Controllerbaustein und ich hab hier oben gelesen das 
Sebastian die Ausgabe über ein virtuelles Display am PC gemacht hat und 
wollte wissen wo ich sowas finde?? Muss ebenfalls mein Projekt machen 
und unbedingt programmieren, jedoch habe ich einen Fehler in der 
Schaltung, muss aber unbedingt programmieren bis ich  die Schaltung neu 
machen kann und mir würde deswegen so win virtuelles Display zum testen 
sehr entgegenkommen!!!

Bitte um rasche Hilfe!!! Danke

Hallo,

zwar schon eine weile her.. aber was ist denn nun aus dem kontrastarmen 
Display geworden? Habe gerade exakt das gleiche Problem.. oder weis 
jemand was bei diesem Fehler einzustellen ist? Also verschiedene 
Kontrastwerte bringen keine Lösung...

Mfg Tobi