SSD1963 - TFT-Controller - Pixel auslesen

[Frank B. (jeanluc7)]

Salut,

ich arbeite gerade an einem Grafik-Touchscreen-Terminal, das Teil eines 
größeren Projekts ist, um alten Elektronik-Experimentierkästen (Philips, 
Schuco, Kosmos) wieder neues Leben einzuhauchen. Das Projekt wird in 
einem anderen Forum beschrieben 
(http://server23.hostpoint.ch/~rigertc/rigert.com/ee-forum/viewtopic.php?f=35&t=1601). 
Das Grafik-Touchscreen-Terminal verwendet eine China-Standardplatine mit 
4,3"-TFT-Touchscreen und dem SSD1963 als Controller. Die Ansteuerung von 
außen zum Experimentieren erfolgt rein seriell und wird durch zwei MC's 
(644 für die Grafik und 88 für Touch/Tasten) geleistet. Das ganze 
basiert auf der UTFT-Library und bietet die Möglichkeit, mit ganz wenig 
Aufwand ein Terminal oder Diagramme oder Eingabeeelemente wie Menüs, 
Listen usw. zu nutzen. Unser Ziel ist, eine möglichst vielseitige 
Platine zu schaffen und den Nutzern den Einstieg möglichst einfach zu 
machen - soweit die Einführung zum Projekt. Ein paar Bilder habe ich 
angehängt. Codes dazu und die ganze Anleitung gibt's hier: 
https://www.dropbox.com/l/kX19SfyLe0x575egbAjxKc

Nun aber zu meinem Problem: Ich habe es bisher nicht geschafft, aus dem 
SSD1963 einzelne Pixeldaten auszulesen. Leider ist google hier nicht 
mein Freund - es gibt zwar die Doku, nach der es funktionieren sollte, 
aber keinen lauffähigen Codeteil, der zeigt, wie es richtig gemacht 
wird. Die Tipps, die ich finden konnte, führten zum folgenden Code:

unsigned int getPixel(unsigned int x0, unsigned int y0)
{ 
    unsigned int pixeldat, r /*, g, b */;
         
    setXY(x0,y0,x0,y0);
    LCD_Write_COM(0x2E);    // Read_Memory_Start
             
    sbi(PORTD, B_WR);
    sbi(PORTD, B_RS);
    
    set_direction_registers_read(); 
    PORTA = 0xFF;
    PORTC = 0xFF;
    
    pulse_low(PORTD, B_RD); //R_D = 0;  //dummy read   
    pulse_low(PORTD, B_RD); // R_D = 0;

    r = PINA; 
    pixeldat = (r << 8) + PINC;
    
/* 
    cbi(PORTD, B_RD); // R_D = 0;
    sbi(PORTD, B_RD); // R_D = 1;
    g = PINA;
    
    cbi(PORTD, B_RD); // R_D = 0;
    sbi(PORTD, B_RD); // R_D = 1;
    b = PINA;
*/     
     
  //pixeldat = (b<<11)+(g<<5)+(r<<0);
     
    set_direction_registers_write();
    sbi(PORTD, B_CS);     
    return pixeldat;   
}

Wie unschwer zu erraten ist, funktioniert er leider nicht. Es kommt 
immer dieselbe Farbe zurück. Ich habe die Routine benutzt, um ein 50x50 
Pixdel großes Rechteck auszulesen und zu "kopieren" - leider ohne 
Erfolg. Der "dummy read" im Code stammt bereits aus einem der Tipps zum 
Auslesen. Es funktioniert mit genauso wenig wie ohne.

Falls jemand das Auslesen des Speichers erfolgreich gelöst hat, würde 
ich mich über eine  Unterstützung freuen.

Viele Grüße,
Frank

[Mehmet K. (mkmk)]

Ich arbeite mit einem HX8352A Controller. Keine Ahnung wiesehr sich 
dieser mit Deinem SSD1963 deckt. Aber vielleicht gibt es Dir 'ne Idee.

#define LCD_REGISTER (*((volatile unsigned short *) 0x60000000)) // RS = 0 
#define LCD_RAM      (*((volatile unsigned short *) 0x60020000)) // RS = 1

//=================================
// WriteReg
//=================================
void MyLcd::WriteReg(unsigned lcd_register, unsigned lcd_register_value)
{
  LCD_REGISTER = lcd_register;
  asm("nop.w");
  LCD_RAM = lcd_register_value;
}

//=================================
// SetAddress
//=================================
void MyLcd::SetAddress(unsigned x1, unsigned y1, unsigned x2, unsigned y2)
{
// Column address start register R02~03h
// Column address end register   R04~05h
// Row address start register    R06~07h
// Row address end register      R08~09h

  this->WriteReg(0x02, x1 >> 8);
  this->WriteReg(0x03, x1);
  this->WriteReg(0x04, x2 >> 8);
  this->WriteReg(0x05, x2);
  this->WriteReg(0x06, y1 >> 8);
  this->WriteReg(0x07, y1);
  this->WriteReg(0x08, y2 >> 8);
  this->WriteReg(0x09, y2);
  LCD_REGISTER = 0x22;
}

//===================
// SetPixel
//===================
void MyLcd::SetPixel(unsigned x, unsigned y, unsigned color)
{
  this->SetAddress(x, y, x, y);
  this->WriteData(color);
}

//===================
// GetPixel
//===================
unsigned MyLcd::GetPixel(unsigned x, unsigned y)
{
  unsigned dummy;

  this->SetAddress(x, y, x, y);
  dummy = LCD_RAM;
  return LCD_RAM;
}

[Mehmet K. (mkmk)]

Vollstaendigkeitshalber:

//===================
// GetPixelArea
//===================
void MyLcd::GetPixelArea(unsigned x, unsigned y, unsigned breite, unsigned hoehe, uint16_t *ptr)
{
  volatile unsigned dummy;
  unsigned h = y + hoehe  -1;
  unsigned b = x + breite -1;

  this->SetAddress(x, y, b, h);
  dummy = LCD_RAM;
  for (int x = 0; x < (breite * hoehe); x++)
    *ptr++ = LCD_RAM;
}

//===================
// SetPixelArea
//===================
void MyLcd::SetPixelArea(unsigned x, unsigned y, unsigned breite, unsigned hoehe, uint16_t *ptr)
{
  unsigned h = y + hoehe  -1;
  unsigned b = x + breite -1;

  this->SetAddress(x, y, b, h);
  for (int x = 0; x < (breite * hoehe); x++)
    LCD_RAM = *ptr++;
}

[J. -. (Gast)]

>    setXY(x0,y0,x0,y0);
>    LCD_Write_COM(0x2E);    // Read_Memory_Start

Ich nehme mal an, Dein Problem ist bereits gelöst ;)
Falls nicht:
Wahrscheinlich wird beim setXY-Befehl nur das Fenster incl. Koordinaten 
zum Schreiben gültig(*).
Der LCD_Write_COM(0x2E) läuft dann ins Leere bzw liest kein Fenster, 
sondern nur ein einziges Pixel aus (das von x0,y0).
Ich habe den getXY-Command genauso aufgebaut wie den setXY, also erst 
die beiden Words für die columns, dann die beiden Words für die pages, 
und dann als einzigen Unterschied zum setXY nicht den 0x2C-Befehl zum 
Schreiben, sondern wie Du auch 0x2E zum Lesen.

getXY:

  TFT_Write_COM(CMD_SET_COL_ADDRESS); //0x2A
  TFT_Write_DATA((x1>>8) & 0xFF);
  TFT_Write_DATA(x1 & 0xFF);
  TFT_Write_DATA((x2>>8) & 0xFF);
  TFT_Write_DATA(x2);
  TFT_Write_COM(CMD_SET_PAGE_ADDRESS); //0x2B
  TFT_Write_DATA((y1>>8) & 0xFF);
  TFT_Write_DATA(y1);
  TFT_Write_DATA((y2>>8) & 0xFF);
  TFT_Write_DATA(y2);
  TFT_Write_COM(CMD_READ_MEM_START); //0x2E

Also Fenster setzen, und dann die Bytes für die Pixeldaten ohne weiteres 
Kommando abholen.
So geht es bei mir zumindest.

(*)was noch zu beweisen wäre: Setz doch mal mit setXY auf Deine maximale 
Displaygröße, also anstatt nur auf ein einzelndes Pixel(x0,y0) auf den 
ganzen Screen, z.B. bei 320x240-Display -> setXY(0,0,320-1,240-1).
Wenn Du dann danach dann 0x2E schickst, könnte es trotzdem klappen - hab 
ich ehrlich gesagt noch nicht probiert ;)

[Frank B. (jeanluc7)]

Salut,

mein Problem habe ich zwischenzeitlich leider noch nicht lösen können 
und deshalb die Funktion erst einmal außen vor gelassen.

Daher vielen Dank für deinen Tipp - ich werde es ausprobieren und dann 
berichten. Wäre echt klasse, wenn das Pixelauslesen dann auch endlich 
klappt.

Grüße, Frank

[J. -. (Gast)]

Das sollte schon gehen, mir ist noch beim Umschalten der Ports was 
aufgefallen:

unsigned int getPixel(unsigned int x0, unsigned int y0)
{ 
    unsigned int pixeldat, r /*, g, b */;  

    getXY(x0,y0,x0,y0);
             
    sbi(PORTD, B_WR);
    sbi(PORTD, B_RS);
    
    set_direction_registers_read(); 
//    PORTA = 0xFF; //pullups nicht notwendig
//    PORTC = 0xFF;
    
    pulse_low(PORTD, B_RD); //R_D = 0;  //dummy read   
    pulse_low(PORTD, B_RD); // R_D = 0;

    r = PINA; 
    pixeldat = (r << 8) | PINC; //+ geht aber auch

    pulse_high(PORTD, B_RD); // R_D = 1;

/* sonst knallt der Ausgangstreiber vom LCD auf die Ausgangstreiber vom AVR, wenn Du im nächsten Befehl umschaltest:*/
     
    set_direction_registers_write();
    sbi(PORTD, B_CS);     
    return pixeldat;   
}

Hoffentlich klappt's ;)

[Torsten S. (tse)]

Der SSD1963 ist zwar fix beim Schreiben aber ziemlich lahm beim Lesen. 
bau mal ein paar Warteschleifen ein.

[Harald Ma. (Gast)]

Hallo zusammen !

Ich bin ein absoluter Anfänger was dieses Thema betrifft. Aber wir haben 
ein TFT Display des Typs SSD1963 und da ist ein SD Karten Slot drauf. 
Auf dem TFT ist ein Teil zum Bedienen vorbereitet und auf dem oberen 
Teil ist das Logo des Herstellers drauf, jetzt habe Ich die SD Karte 
entnommen und wollte dort unser Logo einfügen, aber leider hat es nicht 
geklappt da es nur Wirre Linien und Punkte anzeigt. Kann mir jemand von 
euch helfen ? Bitte !

[Harald Ma. (Gast)]

Hallo alle zusammen,

Ein Freak hat mal wieder ganze Arbeit geleistet! Vielen Dank er trägt
seinen Namen zurecht. Mein Problem ist soweit gelöst !
Vielen Dank

[Frank B. (jeanluc7)]

Hallo,
ich habe heute das Problem gelöst und kann nun aus dem 
SSD1963-Controller einzelne Pixel auslesen. Es ist aber tatsächlich ein 
wenig umständlich und steht so auch nicht in der Doku - vielleicht ist 
das der Grund, warum man bei google keine einzige funktionierende 
Version von getPixel findet.

unsigned int getPixel(int x,int y)
{
  unsigned char Hi, Lo;
  unsigned int color;

// erste Runde, liefert Lo-Byte
  cbi (PORTD, B_CS);
  setXY(x,y, x, y);
  LCD_Write_COM(0x2E);  // Read_Memory_Start
  set_direction_registers_read(); 

  cbi(PORTD, B_RD);  // Einmal Lesebefehl als Dummy absetzen
  NOP;
  sbi(PORTD, B_RD);
  cbi(PORTD, B_RD);
  Lo = PINC;
  sbi(PORTD, B_RD);

  set_direction_registers_write();
// zweite Runde, liefert Hi-Byte
  LCD_Write_COM(0x2E);  // Read_Memory_Start
  set_direction_registers_read(); 

  cbi(PORTD, B_RD);  // Einmal Lesebefehl als Dummy absetzen
  NOP;
  sbi(PORTD, B_RD);  
  cbi(PORTD, B_RD);
  Hi = PINA;
  sbi(PORTD, B_RD);

  set_direction_registers_write();
  sbi (PORTD, B_CS);    
// Farben zusammensetzen
  color = ((int)Hi << 8) + Lo;
  return color;
}

Die Pinbelegungen hängen natürlich davon ab, wie das Panel an den AVR 
angeschlossen ist, die grunsätzliche Vorgehensweise ist aber immer die 
selbe: es muss zweimal ausgelesen werden. Beim ersten Mal bekommt man 
ein gültiges Lo-Byte an den Pins D0-D7, beim zweiten Versuch ein 
gültiges Hi-Byte an den Pins D8-D15. Die jeweils korrespondierenden 
Bytes am jeweils anderen Port sind ungültig.

Außerdem streikt der Controller bei Farbwerten, bei denen Grün und Blau 
voll ausgesteuert sind - er liefert dann einfach Schwarz als Farbe. Es 
sieht so aus, als würde da ein Überlauf entstehen. Ich konnte mich hier 
darauf beschränken, einfach keine voll ausgesteuerten Farben mehr zu 
benutzen; ich ziehe immer das LSB von jeder Farbe ab, wenn sie maximal 
wird.

[Peter D. (peter_d592)]

Hi Frank - I am using a 5-inch TFT touch screen and the UTFT library 
from Rinky-Dink electronics with an Arduino Mega 2560, and I would like 
to add a getPixel() command. I am trying to use your code from your 
2015-01-24 14:12 post with the title "Solved: SSD1963 - TFT controller - 
read out pixels". I have added your code at the end of the UTFT.cpp, and 
included an entry in the header file, but I am having difficulties in 
converting your commands "set_direction_registers_read" and 
"set_direction_registers_write" into the appropriate commands understood 
by the rest of the UTFT library. There is a command 
"_set_direction_registers(mode)" which might be nearly the same, but I 
would be grateful if you could help. Can you point me to the source code 
for "set_direction_registers_read" and "set_direction_registers_write"? 
I can send you the UTFT.cpp and UTFT.h files if you think it would help 
- best regards - Peter