Display mit Chip ST7789V Startprobleme

[Dirk F. (dirkf)]

Hallo,
ich brauche eure Hilfe,
bekomme das Dispay mit dem Chip ST7789V  nicht ans laufen.
Den u.g. Initialisierungscode kommt vom Displayliefgerant.

Ich möchte zum Anfang einfach mal nur ein paart Pixels setzen.....
Ja ich weiß, es gibt libs, aber ich möchte erst mal sehen, ob das 
Display überhaut etwas macht.
Die Hintergrundbeleuchtung geht an. Sonst passiert aber nichts auf dem 
Display.  Hier der Code:

void lcdput (unsigned char reg, unsigned char dat)
{
LCD_RS_Clear();                 // RS Pin Low = Command
SPI2Put (reg);                  // 1 Byte Command schreiben
LCD_RS_Set();                   // RS Pin High = Data
SPI2Put (dat);                  // 1 Byte Daten schreiben
}

void lcddata (unsigned char dat)
{
LCD_RS_Set();                   // RS Pin High = Data
SPI2Put (dat);                  // 1 Byte Daten schreiben
}

void display_initialize (void)     // TFT Touch SPI2  display Init
{
    
LCT_LIGHT_Set();                // Beleuchtung ein
        
LCD_RST_Clear();                // Reset LCD
delay_ms (120);  
LCD_RST_Set(); 
delay_ms (120);
           
SS_LCD_Clear();                 // Slave select Display on (low)

lcdput (0x36,0x00);             // Resister, Data

//------------------------------------------------------------------------------
                                // Data 03= RGB-4-4-4-bit input)
                                // Data 05= RGB-5-6-5-bit input)
                                // Data 06= RGB-6-6-6-bit input)
lcdput (0x3a,0x05);             // Resister, Data, 


lcdput (0xb2,0x0c);             // Resister, Data
lcdput (0xb2,0x0c);             // Resister, Data 
lcdput (0xb2,0x00);             // Resister, Data 
lcdput (0xb2,0x33);             // Resister, Data 
lcdput (0xb2,0x33);             // Resister, Data 

lcdput (0xb7 ,0x35 );             // Resister, Data
lcdput (0xbb ,0x2b );             // Resister, Data
lcdput (0xc0 ,0x2c );             // Resister, Data
lcdput (0xc2 ,0x01 );             // Resister, Data
lcdput (0xc3 ,0x11 );             // Resister, Data
lcdput (0x04 ,0x20 );             // Resister, Data
lcdput (0xc6 ,0x0f );             // Resister, Data
lcdput (0xd0 ,0xa4 );             // Resister, Data
lcdput (0xd0 ,0xa1);              

lcdput (0xe0 ,0xd0);             // Resister, Data
lcdput (0xe0 ,0x00);              // Resister, Data 
lcdput (0xe0 ,0x05);              // Resister, Data 
lcdput (0xe0 ,0x0e);              // Resister, Data 
lcdput (0xe0 ,0x0d);              // Resister, Data 
lcdput (0xe0 ,0x37);              // Resister, Data 
lcdput (0xe0 ,0x43);              // Resister, Data 
lcdput (0xe0 ,0x47);              // Resister, Data 
lcdput (0xe0 ,0x09);              // Resister, Data 
lcdput (0xe0 ,0x15);              // Resister, Data 
lcdput (0xe0 ,0x12);              // Resister, Data 
lcdput (0xe0 ,0x16);              // Resister, Data 
lcdput (0xe0 ,0x19);              // Resister, Data 
lcdput (0xe0 ,0x11);              // Resister, Data 

lcdput (0xe1 ,0xd0);              // Resister, Data 
lcdput (0xe1 ,0x00);              // Resister, Data 
lcdput (0xe1 ,0x05);              // Resister, Data 
lcdput (0xe1 ,0x0d);              // Resister, Data 
lcdput (0xe1 ,0x0c);              // Resister, Data 
lcdput (0xe1 ,0x2d);              // Resister, Data 
lcdput (0xe1 ,0x44);              // Resister, Data 
lcdput (0xe1 ,0x40);              // Resister, Data 
lcdput (0xe1 ,0x0e);              // Resister, Data 
lcdput (0xe1 ,0x1c);              // Resister, Data 
lcdput (0xe1 ,0x18);              // Resister, Data 
lcdput (0xe1 ,0x16);              // Resister, Data 
lcdput (0xe1 ,0x19);              // Resister, Data 

lcdput (0xe7 ,0x10);              // Resister, Data 
//lcdput (0x11 ,0x00);              // ? Resister, Data 
lcddata (0x11);              // ? Resister, Data 

delay_ms (120);
// lcdput (0x29 ,0x00);              // Display on  command 29
lcddata (0x29 );              // Display on  command 29
delay_ms (120);

//----------------Test-----------------------------------

int i;
lcddata  (0x2c); // Memory write
for (i=0;i<100;i++)
    {
    lcddata (0xf9);              // irgendwelche daten
    }



SS_LCD_Set();                    // SLave select Display off (high)
}

[Wastl (hartundweichware)]

Dein Display braucht innerhalb einer Befehlssequenz einen Start, CS low, 
und einen Stop, CS high. Das kann ich in deinen Ausführungen nicht 
finden.

[Dirk F. (dirkf)]

Werde ich morgen mal testen.  Danke

[Wastl (hartundweichware)]

Anschließen musst du den CS natürlich auch.

[Wastl (hartundweichware)]

Warum schickst du das Display on  command mit der display data Funktion?

[Norbert (der_norbert)]

Mal abgesehen von deiner - hmmm, sagen wir ambitionierten - 
Initialisierung fällt zunächst Folgendes auf:

Dirk F. schrieb:
> lcddata  (0x2c); // Memory write

RAMWR ist ein Command und sollte nicht als Data gesendet werden.

Ich bin gerade fertig mit dem Schreiben eines Treibers für einen ST7735, 
der braucht als Initialisierung nur: SLPOUT, INVOFF, DISPON, NORON.

Deine

lcdput (0xe0 ,0xd0);             // Resister, Data
…

Orgie ist höchstwahrscheinlich sowohl unnötig, als auch fehlerhaft.
Nach GMCTRP1 und GMCTRP2 Command kommen normalerweise ganze Säcke voller 
Daten. Am Stück! Nicht Byteweise.

[Dirk F. (dirkf)]

Wastl schrieb:
> Anschließen musst du den CS natürlich auch.

Ja , hab ich.

Die Frage ist, wann muss ein _CS kommen ?
Für jedes Byte oder für eine Sequenz Command,Data1,Data2....

[Harry L. (mysth)]

Dirk F. schrieb:
> Die Frage ist, wann muss ein _CS kommen ?
Vor einer Sequenz, und nach der Sequenz zurücksetzen.

Das steht übrigens alles im Datenblatt des Controllers.

[Dirk F. (dirkf)]

Harry L. schrieb:
> Vor einer Sequenz, und nach der Sequenz zurücksetzen.

Als Anlage ein Teil der Anleitung vom Displaylieferanten, der aber 
leider keinen Support macht.
Als Beispiel der dritte Befehl 0xb2.

Ist das dann so richtig:
_CS  auf low
0xb2 als command senden
5 Byte (0x0c....0x33) als Data senden
_CS auf high

[Harry L. (mysth)]

Dirk F. schrieb:
> Ist das dann so richtig:
> _CS  auf low
> 0xb2 als command senden
> 5 Byte (0x0c....0x33) als Data senden
> _CS auf high

Ja.

[Norbert (der_norbert)]

Dirk F. schrieb:
> Ist das dann so richtig:
> _CS  auf low
> 0xb2 als command senden
> 5 Byte (0x0c....0x33) als Data senden
> _CS auf high

Zumindest beim ST7735 muss CS nicht dynamisch gesetzt werden.
Es reicht wenn man CS zum Anfang des Jahres auf Low setzt und im 
Anschluss kontinuierlich CMDs und DATA sendet. Gegen Silvester dann CS 
wieder auf High.

[Harry L. (mysth)]

Norbert schrieb:
> Zumindest beim ST7735 muss CS nicht dynamisch gesetzt werden.
> Es reicht wenn man CS zum Anfang des Jahres auf Low setzt und im
> Anschluss kontinuierlich CMDs und DATA sendet. Gegen Silvester dann CS
> wieder auf High.

Das kann man zwar so machen, spart aber kaum Zeit und erschwert im 
Fehlerfall die Fehlersuche ganz erheblich, da CS nicht nur als 
ChipSelect dient, sondern auch die Controller-interne State-Machine in 
einen definierten Zustand zwingt.

Daher ist es best-Practice CS lt. Datenblatt zu verwenden.

[Norbert (der_norbert)]

Harry L. schrieb:
> spart aber kaum Zeit

Jaaaaa, ich weiß worauf du hinaus willst. Das Problem ist aber das man 
erst den kompletten SPI FIFO bzw. dessen Entleerung abwarten muss bevor 
man CS hoch hebt. Das kann sich als durchaus lästig erweisen wenn man 
etwas wirklich Schnelles bauen möchte.
Deshalb lohnt es sich über einen Zwischenweg nachzudenken, eine 
komplette Zeichenoperation bestehend aus einem Sack voller CMDs und DATA 
zusammen zu fassen und diese Sequenz in /CS und CS zu kapseln.
Das Beste aus beiden Welten sozusagen.

[Dirk F. (dirkf)]

Hallo,
vielen Dank für die bisherigen Hinweise, die ich versucht habe 
umzusetzen.
Hier ist der neue Code.  Leider immer noch keine Reaktion im Display....
Bitte um weitere Hinweise.

void lcdcmd (unsigned char cmd)
{
LCD_RS_Clear();                   // RS Pin High = Data
SPI2Put (cmd);                  // 1 Byte Daten schreiben
}

void lcddat (unsigned char dat)
{
LCD_RS_Set();                   // RS Pin High = Data
SPI2Put (dat);                  // 1 Byte Daten schreiben
}

void lcd_cs_hi (void)
{
SS_LCD_Set();
delay_ms (1);
}

void lcd_cs_lo (void)
{
SS_LCD_Clear();
delay_ms (1);
}


void display_initialize (void)     // TFT Touch SPI2  display Init
{
LCT_LIGHT_Set();                // Beleuchtung ein
LCD_RST_Clear();                // Reset LCD
delay_ms (120);  
LCD_RST_Set(); 
delay_ms (120);
           
lcd_cs_lo ();
lcdcmd (0x36); lcddat(0x00);             
lcd_cs_hi ();

//------------------------------------------------------------------------------
                                // Data 03= RGB-4-4-4-bit input)
                                // Data 05= RGB-5-6-5-bit input)
                                // Data 06= RGB-6-6-6-bit input)
lcd_cs_lo (); 
lcdcmd (0x3a);lcddat(0x05);              
lcd_cs_hi ();

lcd_cs_lo ();
lcdcmd (0xb2);
lcddat(0x0c);             
lcddat(0x0c);              
lcddat(0x00);              
lcddat(0x33);              
lcddat(0x33);              
lcd_cs_hi ();

lcd_cs_lo (); lcdcmd (0xb7 ); lcddat(0x35 ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xbb ); lcddat(0x2b ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xc0 ); lcddat(0x2c ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xc2 ); lcddat(0x01 ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xc3 ); lcddat(0x11 ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0x04 ); lcddat(0x20 ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xc6 ); lcddat(0x0f ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xd0 ); lcddat(0xa4 ); lcd_cs_hi ();            
lcd_cs_lo (); lcdcmd (0xd0 ); lcddat(0xa1);  lcd_cs_hi ();            

lcd_cs_lo ();
lcdcmd (0xe0);
lcddat(0xd0);             
lcddat(0x00);               
lcddat(0x05);               
lcddat(0x0e);               
lcddat(0x0d);               
lcddat(0x37);               
lcddat(0x43);               
lcddat(0x47);               
lcddat(0x09);               
lcddat(0x15);               
lcddat(0x12);               
lcddat(0x16);               
lcddat(0x19);               
lcddat(0x11);               
lcd_cs_hi (); 

lcd_cs_lo ();
lcdcmd (0xe1 ); 
lcddat(0xd0);               
lcddat(0x00);               
lcddat(0x05);               
lcddat(0x0d);               
lcddat(0x0c);               
lcddat(0x2d);               
lcddat(0x44);               
lcddat(0x40);               
lcddat(0x0e);               
lcddat(0x1c);               
lcddat(0x18);               
lcddat(0x16);               
lcddat(0x19);               
lcd_cs_hi (); 

lcd_cs_lo (); lcdcmd (0xe7 ); lcddat(0x10);lcd_cs_hi ();               
lcd_cs_lo (); lcdcmd (0x11 );  lcd_cs_hi ();                    

delay_ms (120);
lcd_cs_lo (); lcdcmd (0x29 ); lcd_cs_hi ();   // Display on  command 29
delay_ms (120);

//----------------Test-----------------------------------
lcd_cs_lo ();
lcdcmd(0x2a);   // 0x2a = Spaltenadresse
lcddat(0x00);   // XS8..15 
lcddat(0x10);   // XS0..7
lcddat(0x00);   // XE8..15 
lcddat(0x20);   // XE0..7 
lcd_cs_hi ();

lcd_cs_lo ();
lcdcmd(0x2b);   // 0x2b = Zeilenadresse
lcddat(0x00);   // YS8..15 
lcddat(0x10);   // YS0..7
lcddat(0x00);   // YE8..15 
lcddat(0x20);   // YE0..7 
lcd_cs_hi ();

lcd_cs_lo ();
lcdcmd (0x2c );  // 2c = Memory write
int i;
for (i=0;i<100;i++)
    {
    lcddat (0xf9);              // irgendwelche daten
    }
lcd_cs_hi ();
}

[Dirk F. (dirkf)]

Oh sorry. Das war noch falsch. Jetzt gehts....

void lcd_cs_hi (void)
{
delay_ms (1);
SS_LCD_Set();
}

[Thomas F. (igel)]

Norbert schrieb:
> Das Problem ist aber das man
> erst den kompletten SPI FIFO bzw. dessen Entleerung abwarten muss bevor
> man CS hoch hebt.

Hättest du das nicht schon letzte Woche schreiben können? ;-)

Hab gerade angefangen einen Textausgabe für ILI9341 auf einem STM32 zu 
schreiben (gibts schon, aber ich will es selber lernen).
Dabei bin ich über 2h genau an diesem Problem festgehangen: Auf dem DSO 
habe ich mir den Anfang der SPI-Kommunikation angesehen - passt 
eigentlich alles.
Bis irgendwann mal zum Ende der Sequenz gescrollt habe und dort auf CS 
gestoßen bin.

Norbert schrieb:
> eine  komplette Zeichenoperation bestehend aus einem Sack voller CMDs
> und DATA zusammen zu fassen und diese Sequenz in /CS und CS zu kapseln.

Mal sehen wie ich das noch einbauen kann.
Das wird dann wohl auf unterschiedliche Senderoutinen rauslaufen...

[Falk B. (falk)]

Dirk F. schrieb:
> Bitte um weitere Hinweise.

lcd_cs_lo (); lcdcmd (0xb7 ); lcddat(0x35 ); lcd_cs_hi ();

Die Klammern gehören bei Funktionen immer direkt ohne Leerzeichen an den 
Namen.

Wirst du nach Zeichanzahl bezahlt? Schon mal was von einem Array gehört?
Das löst zwar nicht dein Problem, verbessert deinen Programmierstil aber 
sichtbar. Eher so.

uint8_t sequence1[] = {0xe1, 0xd0, 0x00, 0x05, 0x0d, 0x0c, 0x2d, 0x44, 0x40, 0x0e, 0x1c, 0x18, 0x16, 0x19};

lcdcmd_long(sequence1, sizeof(sequence1)); 

void lcdcmd_long(const uint8_t *data, uint16_t cnt) {
    
    lcd_cs_lo();
    lcdcmd(*data++);
    for(cnt--; cnt > 0; cnt--) {
        lcddat(*data++);
    }
    lcd_cs_hi();
}

[Dirk F. (dirkf)]

Danke Falk.
Ja stimmt.  Wollte nur erst mal "quick and dirty" sehen, ob das Display 
überhaupt etwas macht, um Layoutfehler auszuschließen.
Jetzt ist es ansprechbar, dann kommt Optiomierung.

Noch was:

geht nicht:

for (i=0;i<62000;i++)
    {
    lcddat(0xff);              // Bildschirm löschen
    }

funktioniert:

for (i=0;i<62000;i++)
    {
    lcd_cs_lo();               // Slave select low
    lcddat(0xff);              // Bildschirm löschen
    lcd_cs_hi();               // Slave select high
    }

[Dirk F. (dirkf)]

Also nochmal großes Danke an das Forum hier.
Mir wurde mal wieder geholfen :-)

[Falk B. (falk)]

Dirk F. schrieb:
> funktioniert:for (i=0;i<62000;i++)
>     {
>     lcd_cs_lo();               // Slave select low
>     lcddat(0xff);              // Bildschirm löschen
>     lcd_cs_hi();               // Slave select high
>     }

Ist aber Unfug! Man muss nicht für jedes Byte einen komplette CS-Zyklus 
durchlaufen, schon gar nicht, wenn du bei jedem CS Wechsel 1ms wartest!
Warum machst du nicht das Offensichtliche?

lcd_cs_lo();
for (i=0; i<62000; i++) lcddat(0xff);
lcd_cs_hi();

[Dirk F. (dirkf)]

Falk B. schrieb:
> Warum machst du nicht das Offensichtliche?

Stimmt. Läuft auch so-

Habe auch die Wartezeit von 1 ms auf 20us reduziert.

[Falk B. (falk)]

Dirk F. schrieb:
> Habe auch die Wartezeit von 1 ms auf 20us reduziert.

Naja, ein Workaround. Was für einen Controller hast du? Und an welcher 
Schnittstelle hängt dein LCD? SPI oder UART im SPI Modus? Man kann das 
Ende der Übertragung in einem Register abfragen, dann ist die Wartezeit 
immer minimal.

[Dirk F. (dirkf)]

Falk B. schrieb:
> Was für einen Controller hast du?

PIC32MZ.  Display am SPI mit 1 MHz

Falk B. schrieb:
> Ende der Übertragung in einem Register abfragen, dann ist die Wartezeit
> immer minimal.
Ja kommt später noch....

[Falk B. (falk)]

Dirk F. schrieb:
>> Ende der Übertragung in einem Register abfragen, dann ist die Wartezeit
>> immer minimal.
> Ja kommt später noch....

Wieso? Das ist elementar und einfach und man baut das gleich ein.

[Dirk F. (dirkf)]

Falk B. schrieb:
> Wieso? Das ist elementar und einfach und man baut das gleich ein.

Habs jetzt so gemacht. Funktioniert:

void lcdput (unsigned char dat)
{
int dummy;
SS_LCD_Clear();                 // Slave select low
SPI2Put (dat);                  // 1 Byte Daten schreiben
while(SPI2STATbits.SPIRBE);     // Warten so lange wie Empfangspuffer leer ist
dummy = SPI2BUF;                // Puffer leeren 
dummy = dummy;                  // sonst meckert compiler
SS_LCD_Set();                   // Slave select high
}

Komisch ist, dass die Sache mit dem !SPI2STATbits.SPITBE (Transmit 
Puffer nicht Empty)  nicht funktioniert..

[Norbert (der_norbert)]

Dirk F. schrieb:
> Komisch ist, dass die Sache mit dem !SPI2STATbits.SPITBE (Transmit
> Puffer nicht Empty)  nicht funktioniert..

Der Puffer/FIFO kann durchaus schon leer sein während die Hardware noch 
die letzten Bits raus schiebt. Beim RP2040 nehme ich gerne das SPI busy 
flag um das zu erkennen.

[Dirk F. (dirkf)]

Norbert schrieb:
> Der Puffer/FIFO kann durchaus schon leer sein während die Hardware noch
> die letzten Bits raus schiebt.

Ja das ist genau so eine Falle, in die man reintappen kann.
Und wenn man dann wie beim Display kaum Diagnosemöglichkeiten hat und 
LCD einfach keine Reaktion von sich gibt, kann das schnell frustrierend 
werden.....