GLCD mit T6963 Read-Data Problem

[Anubis (Gast)]

Hallo,

ich bräuchte mal eure Hilfe bei einem kleinem Problem mit einem 
Grafik-LCD.

Das Problem ist, dass ich Daten, die auf dem Display angezeigt werden, 
wieder zurück lesen möchte.

Es handelt sich hierbei um ein GLCD mit T6963.

Die Darstellung der Grafik ist kein Problem. Nur das Lesen. Ich bekomme 
immer nur den letzten übertragenen Befehl eingelesen.

Vielleicht hat jemand eine Idee???

//Header-Datei für PIC 16F876 einbinden
#include <16f877.h>
  
#include <Pfeil01.inc>            //Grafik-Datei


#define NotWR  PORTD.0
#define NotRD  PORTD.1
#define NotCE  PORTD.2
#define NotCD  PORTD.3
#define NotRST  PORTD.4
#define FontSel  PORTD.5

void Delay_ms(uns16);
void Delay_us(uns16);
void InitLCD(void);
void CheckBusy(void);
void WriteCommand(uns8);
void WriteData(uns8);
void ClearGraphicArea(void);
void Graphic(void);
void Verschieben(void);
uns8 ReadData(void);

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

void main()
{
 uns8 Wechsel = 1;
uns8 Pos = 0; 

 TRISD = 0;              //Port D als Ausgang
 PORTD = 255;
 T1CON = 0;              //Timer 1 Vorteiler 1:1
 NotRST = 0;
 Delay_ms(2);
 NotRST = 1;
 FontSel = 0;
 InitLCD();              //Display initialisieren
 
 Graphic();
 
 while(1)
 {
  Verschieben();
 }
}

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

void InitLCD(void)
{
 TRISC = 0xFF;            //Port C als Eingang (D0 bis D7)
 
 /*Grafik Home Adresse*/
 WriteData(0x81);
 WriteData(0x00);          //Adresse = 0x0081h
 WriteCommand(0x42);
 
 /*Grafik Area Set*/
 WriteData(0x10);
 WriteData(0x00);
 WriteCommand(0x43);
 
 /*Display im OR-Mode*/
 WriteCommand(0x80);
 
 /*Grafik an, Text aus, Cursor aus*/
 WriteCommand(0x98);
 
 /*Display löschen*/
 ClearGraphicArea();
 
}

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

void ClearGraphicArea(void)
{
 uns16 Counter2;
 
 /*Auto-Write deaktivieren*/
 WriteCommand(0xB2);
 
 
 /*Grafik-Bereich löschen(von 0x0081h bis 0x0400h*/
 /*Adress-Pointer auf 0x0081h setzen*/
 WriteData(0x81);
 WriteData(0x00);
 WriteCommand(0x24);
 
 /*Auto-Write aktivieren*/
 WriteCommand(0xB0);
 
 /* 16 Byte pro Zeile gelöscht werden (1 Byte = 8 Pixel) 128 Pixel=16 Byte*/
 /*bei 128x64 Pixel ergeben sich 64 Zeilen zu je 16 Byte = 1024 Byte */
 for(Counter2 = 0; Counter2 < 1024; Counter2++)
 {
  WriteData(0x00);          //0x00 == kein Zeichen
 }

 /*Auto-Write deaktivieren*/
 WriteCommand(0xB2); 
}

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

void Delay_ms(uns16 Milli)
{
 uns16 Durchgang;
 
 TMR1ON = 0;
 for(Durchgang = 0; Durchgang < Milli; Durchgang++)
 {
  TMR1H = 0xFC;
  TMR1L = 0x18;          //Timer 1 mit 64536 vorladen (1000 Durchgänge)
  TMR1IF = 0;
  TMR1ON = 1;
  while(!TMR1IF);
  TMR1ON = 0;
 }
}


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

void Delay_us(uns16 Mykro)
{
 uns8 Wert1, Wert2, Counter;
 uns16 Temp, Zeit;
 
 TMR1ON = 0;
 Zeit = 65536 - Mykro;
 Temp = Zeit & 0xFF00;      //oberes Nibble isolieren
 Wert1 = Temp >> 4;        //Rechtsverschiebung um 4 Bit
 Temp = Zeit & 0x00FF;      //unteres Nibble isolieren
 Wert2 = Temp;
 
 for(Counter = 0; Counter < Mykro; Counter++)
 {
  TMR1H = Wert1;
  TMR1L = Wert2;
  TMR1IF = 0;
  TMR1ON = 1;
  while(!TMR1IF);
  TMR1ON = 0;
 }
}


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

void CheckBusy(void)
{
 uns8 Status;
 
 TRISC = 255;          //Port C als Eingang
 NotCD = 1;
 NotCE = 1;
 NotRD = 1;
 NotWR = 1; 
 NotCE = 0;
 NotRD = 0;
 
 while((PORTC & 3) != 3);
 
 NotRD = 1;
 NotCE = 1;
 TRISC = 0;
}


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

void WriteCommand(uns8 Command)
{
 TRISC = 0;
 CheckBusy();
 PORTC = Command;
 NotCD = 1;
 NotRD = 1;
 NotCE = 0;
 NotWR = 0;
 #asm
 NOP                //Wartezeit von 1 Maschinenzyklus
 #endasm
 NotWR = 1;
 NotCE = 1;
}

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

void WriteData(uns8 Data)
{
 TRISC = 0;
 CheckBusy();
 PORTC = Data;
 NotCD = 0;
 NotRD = 1;
 NotCE = 0;
 NotWR = 0;
 #asm
 NOP
 #endasm
 NotWR = 1;
 NotCE = 1;
}

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

uns8 ReadData(void)
{
 uns8 Daten;
 
 TRISC = 255;              //Port C als Eingang
 CheckBusy();
 
 NotCD = 1;
 NotCD = 0;
 NotCE = 0;
 NotRD= 1;
 NotRD = 0;
 NotWR = 1;
 #asm
 NOP
 NOP
 NOP
 #endasm
 Daten = PORTC;
 NotRD = 1;
 NotCE = 1;
 return(Daten);
}


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

void Graphic(void)
{
 uns8 Innen, Aussen, AdrL, AdrH, Zaehler;
 uns16 Adresse, Hilfs;
 
 Adresse = 0x0081;
 Zaehler = 0;
 
 for(Aussen = 1; Aussen < 33; Aussen++)
 {
  /*16-Bit Adresse in zwei 8-Bit zerlegen*/
  Hilfs = Adresse & 0xFF00;
  AdrH = Hilfs >> 8;
  Hilfs = Adresse & 0x00FF;
  AdrL = Hilfs;
  
  /*Adress-Pointer setzen*/
  WriteData(AdrL);
  WriteData(AdrH);
  WriteCommand(0x24);
  
  for(Innen = 1; Innen < 5; Innen++)
  {
   WriteData(Pfeil01[Zaehler]);
   WriteCommand(0xC0);
   Zaehler++;
  }
  Adresse = Adresse + 16;        //Adresse für nächste Zeile
 }
}

/************************************************************************/
void Verschieben(void)
{
 uns8 DataBytes[7];
 uns8 Counter, DataTemp;
 
 /*Adress-Pointer setzen*/
 WriteData(0x81);
 WriteData(0x00);
 WriteCommand(0x24);
 ReadData();
}

[Anubis (Gast)]

Hallo,

hat keiner eine Idee???