Densitron OLED

[marco (Gast)]

Hallo liebes Forum,

ich bin gerade dabei mein Densitron Oled Display anzusteuern. Leider 
erfolglos. Das Display bleibt tot. Bin meinen Code schon mehrmals 
durchgegangen. Finde den Fehler aber nicht.
Würde mich sehr freuen, wenn jemand kurz Zeit hätte meine 
Initialisierung anzugucken. Im Main möchte ich nur über den einen Taster 
einige Zeilen mit unterschiedlichem GrayScale Werten beschreiben. Über 
den anderen das Display löschen. Sonst passiert da nix.

Vielen Dank schon mal im voraus.

mfg marco

[u8glib (Gast)]

So mal über den Daumen gepeilt, gibt es bei Densitron mindestens 100 
verschiedene OLEDs. Daneben gibt es derzeit ca. 5-10 verschiedene 
Controller, die dabei eingesetzt werden. Deshalb wäre es sehr hilfreich, 
wenn wir wüssten, um welches Display es sich konkret handelt.

Grüße,
Oliver

[u8glib (Gast)]

Was man aber auch ohne das Display zu kennen sagen kann: Das 
Command/Data Signal und die Chip-Select Leitung werden definitiv falsch 
gesetzt.
Genaueres steht im Datenblatt des Controllers.

Der auskommentierte Code war definitiv richtiger.

Oliver

[marco (Gast)]

Ok, es handelt sich um das DD-128YO-1A.
Display controller: SSD1325

Zu dem Command/data Signal wollte ich noch sagen das ich während des 
gesamten Schreibvorgangs mit Daten oder Kommandos das CS oder D_C Signal 
nicht mehr verändere. Also z.B bei den Daten lasse ich D_C auf 1 und CS 
auf 0. Muss ich das denn in der SendData Routine wieder zurücksetzten um 
es dann wieder auf den richtigen Wert zu setzten? Fände ich irgendwie 
nicht logisch.

Habe trotzdem gerade gesehen, dass ich CS im Main.c auf 1 setze. Das 
muss natürlich auf 0.
Hab den Fehler gerade ausgebessert und nochmal durchlaufen lassen, hat 
aber nix geändert!?

[Knut B. (Firma: TravelRec.) (travelrec)]

Als erstes würde ich die Schaltung, insbesondere die 
Spannungsgenerierung für das Display sehen wollen oder hat das Teil 
schon einen Step-Up-Converter an Board.

[u8glib (Gast)]

Hallo

Wärend der Übertragung muss CS = 0 sein.
Wenn Befehle oder die Argumente der Befehle übertragen werden, dann muss 
D_C = 0 sein. Sollen Daten in das RAM des OLEDs geschrieben werden, muss 
D_C = 1 sein.

Grüße und frohes Fest,
Oliver

[marco (Gast)]

danke erstmal.

Ja es hat einen Step-Up-Wandler. Da hab ich besonders drauf geguckt bei 
der Auswahl meines Displays, weil ich mich nicht selbst um die 15V 
kümmern wollte.

Habe noch ein Paar Fehler endeckt. Im Main setze ich CS auf 1. Dass muss 
natürlich auf 0. Und auch in der SendData-Funktion setzte ich zum Schluß 
CS auf 1. Ist natürlich genauso quatsch. Nach diesen Korrekturen läuft 
aber immer noch nix.

Aber richtige Initialisierung hin oder her. Die meisten, die das erste 
mal ein Display ansteuern, schreiben doch hier im Forum, das sie erst 
mal einen Pixelbrei zu sehen bekommen. Meines ist jedoch komplett tot. 
Man sieht absulut nichts. Deshalb frage ich mich schon ob es vielleicht 
nicht doch an meiner Spannungsversorgung liegt??

Mit dem Kommando "Set Biasing Current" aktiviert man doch den 
DC/DC-Converter (siehe Display-Datenblatt, S.17). Sehe ich das richtig 
so?

Wenn ich den internen DC/DC-Converter einsetze, darf ich dann den 
Vcc-Pin einfach offen lassen?

[marco (Gast)]

Hat den keiner mehr einen Rat? Hätte doch so gern mein Display noch vor 
Jahresende zum laufen gebracht.

[Christopher (Gast)]

Hi,

ich bin auch gerade an einem Display mit SSD1325 Controler 
(VGY12864Z-S005 von Conrad) dran.

Will es parallel anschließen und wälze schon Datenblätter bevor ich 
alles da habe.


zu deiner Initialisierung:

// Display OFF
sendCommand(0xAE); 

//Set display clock divide and oscilator frequency    
sendCommand(0xB3);      
sendCommand(0x91);

geh ich mit

//Set Multiplexratio
sendCommand(0xA8);
sendCommand(0x50);

Der Controler kann 80 Zeilen ansprechen (0x50 = 80). Meiner Meinung nach 
(dem Datenblatt entnommen) sollte der Wert 0x40 sein (laut 
http://code.google.com/p/u8glib/source/browse/csrc/u8g_dev_ssd1325_nhd27oled_gr_new.c) 
sind es aber 0x3f.

//Set Display Offset
sendCommand(0xA2);
sendCommand(0x0);

Der Wert sollt 0x4C sein, warum? Keine Ahnung, habe ich aber in mehreren 
Initialisierungen so gefunden.. laut Datenblatt wäre aber eine 0x0 
richtig, gebe dich dir völlig recht, aber probiers mal mit 0x4C.

//Set Display Start-Line
sendCommand(0xA1);
sendCommand(0x0);

//Set Column Adress
sendCommand(0x15);
sendCommand(0x0);
sendCommand(0x3F);

//Set Row Adress
sendCommand(0x75);
sendCommand(0x0);
sendCommand(0x3F);

völlig korrekt

//Set Re-map
sendCommand(0xA0);
sendCommand(0x0);

Da sagen wieder mehrere Initalisierungen 0x52, siehe Datenblatt was da 
genau geschieht.

//Set Master Configurtation
sendCommand(0xAD);
sendCommand(0x02);

0x02 = "Select external VCC supply" und genau das wolltest du doch 
nicht?
0x03 wäre korrekt um den internen step-up wandler zu nutzen(?)

//Set Bias-Current for DC/DC-Converter
sendCommand(0xCF);
sendCommand(0xF0);

den Befehl gibt es laut meinem Datenblatt gar nicht! Was willst du da 
setzen?

//Set Current Range
sendCommand(0x85);

//Set Contrast Control
sendCommand(0x81);
sendCommand(0x7F);

jepp

//Set Row Period
sendCommand(0xB2);
sendCommand(0x46);

//Set Phase Length
sendCommand(0xB1);
sendCommand(0x28);

Keine Ahnung, aber wo nimmst du den Wert her?

Laut Datenblatt passen die Werte glaube ich nicht richtig zusammen.

Vielleicht korrekte Werte siehe u8g.

//Set Pre-Charge Voltage
sendCommand(0xBC);
sendCommand(0x10);

jepp

//Set VCOMH Voltage
sendCommand(0xBE);
sendCommand(0x02);

warum genau dieser Wert?

//Set VSL
sendCommand(0xBF);
sendCommand(0x0D);

Laut Datenblatt sind nur 0x02 und 0x0E zulässig... aber bei u8g wird 
auch 0x0D verwendet.. wer weiß..

//Set Display-Mode
sendCommand(0xA4);

korrekt


dann fehlen dir meiner Meinung nach (siehe u8g) die Befehle

- 0xB0 mit dem Wert 0x28,

- 0xB4 mit dem Wert ... gute Frage.. laut Datenblatt 0x03, aber hab 
alles von 0x00 bis 0x04 gesehen

- 0xB8 mit der Graustufen-Tabelle

Das war alles was mir jetzt auffiel... ich werde nächste Woche beginnen 
mein Display parallel anzusteuern, wie hast du es angeschlossen?

Dann kann ich dir auch hoffentlich mehr sagen.

[Christopher (Gast)]

Ok, Beiträge dazwischen nur überflogen.. jetzt weiß ich auch was für ein 
Display du benutzt.
Ein aktuelleres Datenblatt habe ich hier gefunden 
(http://www.newhavendisplay.com/app_notes/SSD1325.pdf)

Ob du in deiner main.c das CS auf 0 oder 1 setzt ändert an der 
Initialisierung nichts, du machst das ja nach oled_init().
ABER mir sind deine sendCommand und sendData Funktionen nicht schlüssig!

Kommando senden: RD = 1, CS = 0, D/C = 0
Daten senden: RD = 1, CS = 0, D/C = 1

[Christopher H. (roki)]

Ich hab mein Display angesteuert bekommen. Angeschlossen am LPT Port 
unter Linux. Für die Ansteuerung der einzelnen LPT Pins wurde die Lib 
"Parapin" verwendet.

CS wurde auf Masse gelegt, da es eh immer low sein muss/kann.
Wichtig war, dass Reset nicht dauerhaft auf low lag, sondern wirklich 
nur zur Initialisierung low gesetzt wurde, danach dauerhaft auf high.

OLED.h

#define pinRD   LP_PIN01

#define pinD1  LP_PIN02
#define pinD2  LP_PIN03
#define pinD3  LP_PIN04
#define pinD4  LP_PIN05
#define pinD5  LP_PIN06
#define pinD6  LP_PIN07
#define pinD7  LP_PIN08
#define pinD8  LP_PIN09

#define pinWR   LP_PIN14
#define pinDC   LP_PIN16
#define pinRES  LP_PIN17

OLED.c

void setData(uint8_t data) {

  ((data & 0x80)) ? set_pin(pinD8) : clear_pin(pinD8);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD7) : clear_pin(pinD7);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD6) : clear_pin(pinD6);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD5) : clear_pin(pinD5);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD4) : clear_pin(pinD4);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD3) : clear_pin(pinD3);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD2) : clear_pin(pinD2);
  data = data << 1;
  ((data & 0x80)) ? set_pin(pinD1) : clear_pin(pinD1);

}

void writeDisp(uint8_t data, uint8_t cmd) {

  set_pin(pinRD);
  change_pin(pinDC, (cmd == 1) ? LP_CLEAR : LP_SET);
  clear_pin(pinWR);

  setData(data);

  set_pin(pinWR);
  set_pin(pinDC);
}

void initalize() {

  clear_pin(pinRES);
  usleep(10);
  set_pin(pinRES);

  writeDisp(0xAE, CMD);

  writeDisp(0x15, CMD);           // Set Column Address
  writeDisp(0x00, CMD);           // Begin  0
  writeDisp(0x3f, CMD);           // End   64

  writeDisp(0x75, CMD);           // Set Row Address
  writeDisp(0x00, CMD);           // Begin  0
  writeDisp(0x4f, CMD);           // End   79

  writeDisp(0x86, CMD);           // Set Current Range

  writeDisp(0x81, CMD);
  writeDisp(0x7F, CMD);           // Set Contrast Control

  writeDisp(0xBE, CMD);           // Set VCOMH Voltage
  writeDisp(0x00, CMD);         

  writeDisp(0xBC, CMD);           // Set Precharge Voltage
  writeDisp(0x0F, CMD);

  writeDisp(0xA0, CMD);           // Set Re-map
  writeDisp(0x52, CMD); 

  writeDisp(0xA8, CMD);           // Set Multiplex Ratio
  writeDisp(0x4F, CMD);           // multiplex ratio N from 16MUX-80MUX //

  writeDisp(0xB1, CMD);           // Set Phase Length
  writeDisp(0x22, CMD);

  writeDisp(0xB2, CMD);           // Set Row Period
  writeDisp(0x46, CMD);

  writeDisp(0xB0, CMD);           // Set Pre-charge Compensation Enable
  writeDisp(0x08, CMD);

  writeDisp(0xB4, CMD);           // Set Pre-charge Compensation Level
  writeDisp(0x00, CMD);

  writeDisp(0xB3, CMD);           // Set Display Clock
  writeDisp(0xA0, CMD);

  writeDisp(0xBF, CMD);           // Set Segment Low Voltage (VSL)
  writeDisp(0x0D, CMD);

  writeDisp(0xB8, CMD);           // Set Gray Scale Table
  writeDisp(0x01, CMD);
  writeDisp(0x11, CMD);
  writeDisp(0x22, CMD);
  writeDisp(0x32, CMD);
  writeDisp(0x43, CMD);
  writeDisp(0x54, CMD);
  writeDisp(0x65, CMD);
  writeDisp(0x76, CMD);

  writeDisp(0xAD, CMD);           // Set Master Configuration
  writeDisp(0x02, CMD);

  writeDisp(0xA4, CMD);
  writeDisp(0xAF, CMD);
  writeDisp(0xE3, CMD);           //NOP

  drawRectanlge(0x00, 0x4f, 0x00, 0x3f, 0xff);
}

void drawRectanlge(uint8_t row_start, uint8_t row_end, uint8_t col_start,
    uint8_t col_end, uint8_t gray) {
  writeDisp(0x23, CMD);
  writeDisp(0x01, CMD);

  writeDisp(0x24, CMD);
  writeDisp(col_start, CMD);
  writeDisp(row_start, CMD);
  writeDisp(col_end, CMD);
  writeDisp(row_end, CMD);
  writeDisp(gray, CMD);
}

Weiterhin viel Erflog!