Einzelne Pixel bei TFT mit GC9306/ILI9341

[Axel V. (axel-f)]

Guten Abend,

seit einigen Tagen ärgere ich mich mit einem Display herum, auf dem sich 
einzelne Pixel nicht recht darstellen lassen wollen. Aber beginnen wir 
von vorn:

Display 24TQV058D, 320x240, SPI Ansteuerung
Controller: GC9306

Der GC9306 (GalaxyCore Inc.) scheint mir ein Klon des ILI9341 zu sein; 
jedenfalls sieht das Datenblatt exakt aus wie vom ILI abgeschrieben.

Bildschirm löschen: funktioniert.
Horizontale Linie: funktioniert.
Vertikale Linie: funktioniert.

Schräge Linie: funktioniert nicht! Es wird nur das letzte Pixel der 
Linie gesetzt. Einzelnes Pixel setzen funktioniert. Aber sobald ich ein 
zweites Pixel setzen will, wird nur das letzte Pixel gezeichnet und das 
auch noch mit invertierter Farbe!!
Ein ganz seltsames Verhalten. Habe alles mögliche ausprobiert. Habe das 
SPI-Timing x-Mal nachgemessen, habe das Timing drastisch verlangsamt, 
habe verschiedene Initialisierungen (die hier in diversen Bibliotheken 
existieren) getestet- keine Änderung.
Ist dieses Verhalten jemand bekannt, kann jemand sachdienliche Hinweise 
geben?
Bin auf dem Gebiet kein Neuling, habe div. TFT einfach zum Laufen 
bekommen; per SPI, parallel und auch RGB, kein Problem.

Danke schonmal,
Axel F.

[Planloser (Gast)]

Bei der Informationsfülle läßt sich gut raten...

- SPI: 4-line oder 3-line
- Welches Display
- Welcher Rechner/welche CPU/MCU
- Wo ist der Code

Ohne mehr Infos wird das nur Kaffeesatzleserei.
Der Fehler liegt höchstwahrscheinlich in der Software.

[Axel V. (axel-f)]

Hallo Planloser,
danke, dass Du mir helfen willst!

-Scchnittstelle ist nicht SPI wie irrtümlich angegeben, sondern 8Bit 
parallel. Die sog. 8080-I Schnittstelle lt. Datenblatt.
- Display ist ein 24TQV058D, stand so aber auch in meinem Post ;-) 
Darüber läßt sich kaum etwas im Netz finden, aber die Kollegin aus China 
war so freundlich, mir ein Datenblatt zu schicken. Meiner Meinung kaum 
die Elektronen wert, aber ich werde es anhängen.
- µController ist ein ATSAM4SD16C, also ein Cortex M4.

Der relevante Code:

/* Testprogramm SAM4S16C für TFT 24TQV058D
 *
 * 
 */

#include "asf.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "conf_pins.h"
#include "timer.h"
#include "gc9306.h"

uint32_t  status_GC9306;
volatile uint8_t ticks= 0;

/*  Write a byte as command to the display controller
 *  Requirement:  P_CS active, P_RD= 1, P_WR= 1;
 *  Results:    P_CS active, P_DATA= 0, P_RD= 1, P_WR= 1, P_RS= 0;
 */
void writeCommand_GC9306(uint8_t data)
{
  PIOC->PIO_SODR = P_WR | P_RD;
  PIOC->PIO_CODR = P_RS;
  PIOC->PIO_CODR = P_RS;
  PIOC->PIO_CODR = P_DATA;
  PIOC->PIO_SODR = data;
  PIOC->PIO_SODR = data;
  PIOC->PIO_CODR = P_WR;
  PIOC->PIO_CODR = P_WR;
  PIOC->PIO_SODR = P_WR;
  PIOC->PIO_SODR = P_WR;
}

/*  Write a byte as data (parameter) to the  display controller
 *  Requirement:  P_CS active, RD= 1, P_WR= 1;
 *  Results:    P_CS active, P_RD= 1, P_WR= 1, P_RS= 1;
 */
void writeData_GC9306(uint8_t data)
{
  PIOC->PIO_SODR = P_WR | P_RD;
  PIOC->PIO_SODR = P_RS;
  PIOC->PIO_CODR = P_DATA;
  PIOC->PIO_SODR = data;
  PIOC->PIO_OER = P_DATA;
  PIOC->PIO_CODR = P_WR;
  PIOC->PIO_SODR = data;
  PIOC->PIO_SODR = P_WR;
  PIOC->PIO_SODR = P_WR;
  PIOC->PIO_CODR = P_DATA;
}

/*  Write a byte pixel data to the controller
 *  Requirement:  P_CS active, P_RD= 1, P_WR= 1, P_RS= 1;
 *  Results:    P_CS active, P_RD= 1, P_WR= 1, P_RS= 1;
 */
void writeFRAM_GC9306(uint8_t data)
{
  PIOC->PIO_SODR = P_RS;
  PIOC->PIO_SODR = P_RD;
  PIOC->PIO_CODR = P_WR | P_DATA;
  PIOC->PIO_CODR = P_WR;
  PIOC->PIO_CODR = P_WR;
  PIOC->PIO_CODR = P_DATA;
  PIOC->PIO_SODR = data;
  PIOC->PIO_SODR = data;
  PIOC->PIO_SODR = data;
  PIOC->PIO_SODR = P_WR;
  PIOC->PIO_SODR = P_WR;
}

void setOrientation_GC9306(uint8_t orientation)
{
  writeCommand_GC9306(MEM_ACCESS); /* Memory Data Access Control */

  switch(orientation)
  {
    case 1:
      writeData_GC9306(0x68); /* MX + MV */
      displayGC9306.width  = RES_Y;
      displayGC9306.height = RES_X;
      break;

    case 2:
      writeData_GC9306(0xC8); /* MY + MX */
      displayGC9306.width  = RES_X;
      displayGC9306.height = RES_Y;
      break;

    case 3:
      writeData_GC9306(0xA8); /* MY + MV */
      displayGC9306.width  = RES_Y;
      displayGC9306.height = RES_X;
      break;

    default:
      writeData_GC9306(0x08); /* None */
      displayGC9306.width  = RES_X;
      displayGC9306.height = RES_Y;
      break;
  }
}


uint32_t lcd_gc9306_init(void)
{
  /* Hardware reset */
  delay_ms(150);
  PIOC->PIO_SODR = P_RSTn;      /* Reset OFF */
  delay_ms(250);            /* Wait before use */

  P_CS_AKTIV;
  writeCommand_GC9306(DISPLAY_OFF);
  delay_ms(150);
  /* Software reset; Wait minimum 120ms */
  /* Sleep out; Wait minimum 120ms */

  writeCommand_GC9306(SLEEP_OUT);
  delay_ms(150);
  /* Set the orientation and the gamma */
  setOrientation_GC9306(0);

  writeCommand_GC9306(PIXEL_FMT); writeData_GC9306(0x06);      // 18 Bits per Pixel
  delay_ms(150);
  /* Display ON; Wait 100ms before start */
  writeCommand_GC9306(DISPLAY_ON);
  delay_ms(150);

  P_CS_INAKTIV;

  return 0;
} /* lcdst_init */

uint8_t lcdGC9306_setWindow(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
{
  Union16    d;
  /* Accept: 0 <= x1 <= x2 < activeDisplay->width */
  if(x2 < x1) return 1;
  if(x2 >= displayGC9306.width) return 1;

  /* Accept: 0 <= y1 <= y2 < activeDisplay->height */
  if(y2 < y1) return 1;
  if(y2 >= displayGC9306.height) return 1;

  /* Set column address */
  d.u16= x1;
  writeCommand_GC9306(COL_ADRESS);
  writeData_GC9306(d.u8[1]); writeData_GC9306(d.u8[0]);
  d.u16= x2;
  writeData_GC9306(d.u8[1]); writeData_GC9306(d.u8[0]);

  /* Set row address */
  d.u16= y1;
  writeCommand_GC9306(PAGE_ADRESS);
  writeData_GC9306(d.u8[1]); writeData_GC9306(d.u8[0]);
  d.u16= y2;
  writeData_GC9306(d.u8[1]); writeData_GC9306(d.u8[0]);

  /* Activate RAW write */
  writeCommand_GC9306(RAM_WRITE);
  PIOC->PIO_SODR = P_RS;
  return 0;
} /* lcdst_setWindow */

void lcdGC9306_drawPx(uint16_t x, uint16_t y, uint8_t r, uint8_t g, uint8_t b)
{
  if(lcdGC9306_setWindow(x, y, x, y)) return;

  writeFRAM_GC9306(r); writeFRAM_GC9306(g); writeFRAM_GC9306(b);
} /* lcdst_drawPx */

void lcdGC9306_drawHLine(uint16_t x, uint16_t y, uint16_t l, uint8_t r, uint8_t g, uint8_t b)
{
  /* Draw only in the display space */
  if(l == 0) return;
  if((x+l-1) >= displayGC9306.width) l = displayGC9306.width - x;

  /* Draw the line */
  if(lcdGC9306_setWindow(x, y, x+l-1, y)) return;
  while(l--) {writeFRAM_GC9306(r); writeFRAM_GC9306(g); writeFRAM_GC9306(b);}
} /* lcdst_drawHLine */

void lcdGC9306_drawVLine(uint16_t x, uint16_t y, uint16_t l, uint8_t r, uint8_t g, uint8_t b)
{
  /* Draw only in the display space */
  if(l == 0) return;
  if((y+l-1) >= displayGC9306.height) l = displayGC9306.height - y;

  /* Draw the line */
  if(lcdGC9306_setWindow(x, y, x, y+l-1)) return;
  while(l--) {writeFRAM_GC9306(r); writeFRAM_GC9306(g); writeFRAM_GC9306(b);}
} /* lcdst_drawVLine */

/****************************************************************/

int main(void)
{
  // zunächst die INIT's
  sysclk_init();
  init_PINS();
  irq_initialize_vectors();
  cpu_irq_enable();
  delay_ms(200);
  status_GC9306= lcd_gc9306_init();

  P_CS_AKTIV;
  lcdGC9306_drawScreen(GC9306_BLACK);
  P_CS_INAKTIV;

  UNUSED(x); UNUSED(y); UNUSED(w); UNUSED(z); UNUSED(u);
  PIOA->PIO_SODR = EN_VBL;

  while (1)
  {
    if( sekunde)
    {
      sekunde = 0;
      P_CS_AKTIV;
      lcdGC9306_drawScreen(GC9306_BLACK);    // dauert 52 ms

      lcdGC9306_drawPx(20, 25, 255, 165,   0);        // Befehl 1
      lcdGC9306_drawHLine(5, 35, 120, 255, 165,   0); // Befehl 2
      lcdGC9306_drawPx(25, 30, 255, 165,   0);        // Befehl 3
      lcdGC9306_drawPx(20, 45, 255, 165,   0);        // Befehl 4
      lcdGC9306_drawPx(20, 65, 255, 165,   0);        // Befehl 5

      P_CS_INAKTIV;
    }
  }
}

Die Low-Level Routinen haben einige Füll-Befehle, um die Zugriffe 
einfach mal zu verlangsamen. Aber auch ohne diese Füller werden die 
Timings eingehalten!

Tests, die ich u.a. durchgeführt habe:
- Nur Befehl 1: 1 Pixel Orange auf Pos. (20, 25).
- Nur Befehl 2: hor. Linie ab (5, 35) , 120 Px lang in Orange.
- Befehl 1+2: hor. Linie ab (5, 35) , 120 Px lang in Grün(!), kein 
weiteres Pixel.
- Befehle 1-5: hor. Linie ab (5, 35) , 120 Px lang; dazu 1 Pixel bei 
(20, 65) beides in Grün.

Das Zeichnen auf diesen kleinen Displays geht ja immer nach dem gleichen 
Prinzip: Fensterbereich setzen, mit Pixel(n) füllen, fertig. Bei einem 
anderen Display (das mit SPI) ging das ohne Probleme. Selbst Schrift und 
Bitmaps kein Problem. Aber hier... Meine Hoffnung war, daß jemand schon 
mal dasselbe Problem hatte.

[Johannes S. (Gast)]

vielleicht ist die Größe 0 für einen Pixel zu klein? Hier wird für den 
Pixel x1=x2 und y1=y2 gesetzt, in anderen Libs habe ich sowas:
setAddrWindow(x,y,x+1,y+1);

[Axel V. (axel-f)]

Ja, exakt das Gleiche habe ich mir auch schon überlegt und ausprobiert- 
selbiger Effekt. Ich hatte auch das Fenster auf (x,y,x+10,y+10), sollte 
ja nichts schaden, auch wenn nur ein Pixel gezeichnet wird. Bringt 
nichts.

Weiterer Versuch von mir:
drawHLine mit Länge 1: nichts wird gezeichnet,
drawHLine mit Länge 2: 1 Pixel wird gezeichnet.

[Johannes S. (Gast)]

ohne alles gelesen zu haben, kann das Display überhaupt 3*8 Bit 
Farbtiefe? Und ist es dafür initialisiert? Ich habe ein ILI9341 und das 
wird mit 16 Bit, RGB565, betrieben.
Edit:
Lt. DB kann der ILI bis 18 Bit Farbtiefe.

[Axel V. (axel-f)]

Bei mir im init:
writeCommand_GC9306(PIXEL_FMT); writeData_GC9306(0x06);      // 18 Bits 
per Pixel

Dann wird per Farbe 1 Byte gesendet, wovon der GC9306 die oberen 6 Bit 
verwendet.