c pointer / array problem bei GLCD

[Tobias J. (tobiasjohn)]

Hallo zusammen,

ich bin dabei ein Grafik-Display anzusteuern - was auch wunderbar geht.

Jetzt bin ich dabei ein Bitmap aus einem Array auszugeben
Das Array ist wie folgt aufgebaut:

const int8 Logo[] = {
0xF8, 0xFC, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,... }

Das möchte ich jetzt mit dieser Funktion ausgeben:

void display_bitmap(int16 *bitmap, unsigned char x, unsigned char y, unsigned char dx, unsigned char dy) {
  unsigned char i, j;
  int16 zhl = 0;
  for(j = 0; j < dy / 8; j++) {
    display_goto(x,y + j);
    for(i = 0; i < dx; i++) {
      display_write(bitmap++,DATA);
      //display_write(Logo[zhl++],DATA);
    }
  }
}

Wenn ich die Funktion aufrufe mit der auskommentierten Zeile 
(display_write(Logo[zhl++],DATA)) dann zeigt er mir das Logo auch an... 
Nur wenn ich die Funktion aufrufe und als Parameter das Logo angebe, 
dann kommt vom CCS-Compiler die Fehlermeldung "Attempt to create a 
pointer to a constant".

Der Aufruf erfolgt so:

display_bitmap(Logo,0,0,128,25);

Kann mir da jemand auf die Sprünge helfen?

Gruß,
 Tobias

[Peter (Gast)]

test mal mit:

void display_bitmap( const int16 *bitmap, ...

[Tobias J. (tobiasjohn)]

Peter schrieb:
> test mal mit:
>
> void display_bitmap( const int16 *bitmap, ...

Dann gibt es eine ganze Reihe von Fehlermeldungen vom Compiler...
"Expecting a close paren"

[Klaus W. (mfgkw)]

neben char* wie erwähnt wirst du ja nicht den Zeiger ausgeben wollen, 
sondern das, worauf er zeigt, oder?
Also ein Sternchen dazu (vermute ich): display_write(*bitmap++,DATA)

[Oliver (Gast)]

>const int8 Logo[]
und
>display_bitmap(int16 *bitmap...

passt nicht zusammen.

Was sagt er denn zu

display_bitmap(const int8 *bitmap...

Wenn es mit dem const Probleme gibt, lass es halt weg.

Oliver

[Tobias J. (tobiasjohn)]

Klaus Wachtler schrieb:
> neben char* wie erwähnt wirst du ja nicht den Zeiger ausgeben wollen,
> sondern das, worauf er zeigt, oder?
> Also ein Sternchen dazu (vermute ich): display_write(*bitmap++,DATA)

Das ist korrekt ;-)

Leider kommen dann auch nur wirre Zeichen am LCD an...

wieso klappt es mit "display_write(logo[zhl++])" und nicht mit pointer?

Gruß,
 Tobias

[Tobias J. (tobiasjohn)]

Oliver schrieb:
>>const int8 Logo[]
> und
>>display_bitmap(int16 *bitmap...
>
> passt nicht zusammen.
>
> Was sagt er denn zu
>

display_bitmap(const int8 *bitmap...

>
> Wenn es mit dem const Probleme gibt, lass es halt weg.
>
> Oliver

Das const einfach weglassen? Das ist ja auch keine Lösung, dann habe ich 
unnötig RAM verschwendet - der sowieso schon sehr klein ist.

[Karl H. (kbuchegg)]

Deine Funktion muss so aussehen

void display_bitmap( const int8 *bitmap,
                     unsigned char x, unsigned char y,
                     unsigned char dx, unsigned char dy)
{
  unsigned char i, j;

  for(j = 0; j < dy / 8; j++) {
    display_goto(x,y + j);
    for(i = 0; i < dx; i++) {
      display_write(*bitmap++,DATA);
    }
  }
}

[Tobias J. (tobiasjohn)]

Sobald ich das "const" vor "int8 *bitmap" schreibe bekomme ich über 40 
Fehlermeldungen "Expecting a close paren" vom CCS

[Oliver (Gast)]

>Das ist ja auch keine Lösung, dann habe ich
>unnötig RAM verschwendet - der sowieso schon sehr klein ist.

Aha...

Ich kenne den CCS-Compiler und dessen Umgang mit der 
AVR-Harvard-Architektur nicht, aber das könnte eine Ursache des Problems 
sein (abgesehen vom sowieso falschen Pointer-Typ). Was sagt den die 
Compiler-Doku, wie man mit FLASH-Pointern umzugehen hat? Landet jedes 
const automatisch im FLASH?

Oliver

[Oliver (Gast)]

Und alles zurück :-)

Ist ja gar kein AVR, sondern ein PIC. Wobei, die Problematik bleibt. 
Zugriff ins FLASH statt ins RAM.

Oliver

[Oliver (Gast)]

http://www.ccsinfo.com/faq.php?page=constant_data

Oliver

[Benedikt K. (benedikt)]

Sehe ich das richtig, dass der CCS keine Pointer auf Werte im Flash kann 
da er die Zugriffe auf den Flash zur Compilezeit erkennt und 
entsprechend umsetzt, womit obige Lösung nicht möglich wäre?

[Tobias J. (tobiasjohn)]

Das gleiche habe ich auch gerade im Manual gelesen...
dort steht aber noch folgendes:

Placing a string into ROM
const char cstring[6]={"hello"}
Creating pointers to constants
const char *cptr;
cptr = string;

Leider funktioniert das bei mir nicht...
Er sagt für die Zeile "const char *cptr" immer "Expecting ="


Sollte eine Lösung meines Problems wirklich nicht möglich sein?

[12er Dude (Gast)]

Hallo,

da kann ich mit dem Compiler fühlen.

Besser ist

...
const char *cptr = string;

Tschü Dude

[Karl H. (kbuchegg)]

12er Dude schrieb:
> Hallo,
>
> da kann ich mit dem Compiler fühlen.

Nicht wirklich.
Aus C-Sicht ist daran nichts falsches.

[Karl H. (kbuchegg)]

Tobias John schrieb:
> Sobald ich das "const" vor "int8 *bitmap" schreibe bekomme ich über 40
> Fehlermeldungen "Expecting a close paren" vom CCS

Was ist mit

void display_bitmap( const unsigned char *bitmap,
                     unsigned char x, unsigned char y,
                     unsigned char dx, unsigned char dy)
{
  ...
}

um mal die 'Unbekannte' int8 wegzubekommen.

[Tobias J. (tobiasjohn)]

Karl heinz Buchegger schrieb:
> Tobias John schrieb:
>> Sobald ich das "const" vor "int8 *bitmap" schreibe bekomme ich über 40
>> Fehlermeldungen "Expecting a close paren" vom CCS
> Was ist mit
>

> void display_bitmap( const unsigned char *bitmap,
>                      unsigned char x, unsigned char y,
>                      unsigned char dx, unsigned char dy)
> {
>   ...
> }
>

> um mal die 'Unbekannte' int8 wegzubekommen.

Gibt genau die gleichen Fehler...

[G. O. (aminox86)]

Die Funktion "display_write" übernimmt die fraglichen Daten "by value"
wie das Funktionieren der auskommentierten Zeile zeigt.
In der Zeile

 display_write(bitmap++,DATA);

wird der Zeiger einfach weitergeschaltet, ohne Arraydaten an die 
Funktion zu übergeben. Wie schon erwähnt, sollte die Zeile

 display_write(*bitmap++,DATA);

lauten.
Falls das Problem weiterhin besteht, ist es einen Versuch wert, mit 
einem
temporären Zeiger zu arbeiten:

void display_bitmap(int16 *bitmap,....)
{  int16 *t;
   .
   .
  t=bitmap;
   .
  display_write(*t++, DATA);
   .
  usw
}

mfg

[Tobias (Gast)]

Hat niemand eine Idee wie ich ein Bitmap mit dem CCS-Compiler aus dem 
ROM auslesen kann? Das muss doch gehen!

[Karl H. (kbuchegg)]

Tobias schrieb:
> Hat niemand eine Idee wie ich ein Bitmap mit dem CCS-Compiler aus dem
> ROM auslesen kann? Das muss doch gehen!

Doku lesen.
Du verlässt hier den Pfad dessen, was mit Standard-C Mitteln abgedeckt 
wird. Laut C-Standard ist

> void display_bitmap( const unsigned char *bitmap,
>                      unsigned char x, unsigned char y,
>                      unsigned char dx, unsigned char dy)
> {
>   ...
> }

richtig.
Allerdings dürfte dein Compiler const irgendwie speziell behandeln. Also 
bleibt dir nichts anderes übrig als die Doku zu studieren, was sich die 
Compilerbauer dabei gedacht haben.

Oder aber es findet sich zufällig jemand, der diesen Compiler benutzt 
und da schon mal durchgegangen ist.

[Oliver (Gast)]

>Hat niemand eine Idee wie ich ein Bitmap mit dem CCS-Compiler aus dem
>ROM auslesen kann? Das muss doch gehen!

Das Problem ist ja nicht das bitmap im Rom, sondern dessen Übergabe als 
Funktionsparameter.

Was sagt der Comiler denn hierzu:

void display_bitmap(const int8 bitmap[], unsigned char x, unsigned char y, unsigned char dx, unsigned char dy) {
  unsigned char i, j;
  int16 zhl = 0;
  for(j = 0; j < dy / 8; j++) {
    display_goto(x,y + j);
    for(i = 0; i < dx; i++) {
       display_write(bitmap[zhl++],DATA);
    }
  }
}

[Oliver (Gast)]

Oh mann...

Die CCS-Doku ist ja unterirdisch. Jede Menge Text, aber nicht zu 
verstehen, und sinnlose Minimal-Beispiele. Das oben gezeigte ist so 
eins, Schreibfehler drin (string != cstring), und anscheinend lässt es 
sich ja noch nicht mal kompilieren.

Egal, vermutlich geht das mit dem Rom-Zugriff über ein Kombination von 
label_adress(...) und read_program_memory(...). Vielleicht aber auch 
ganz anders, die Doku ist da mehr als kryptisch.

Oliver

[Tobias J. (tobiasjohn)]

Hab die LÖSUNG!

Eine Tabelle vom Typ "char ROM" mit den Daten des Bitmaps.

char ROM Logo[25][16] = {
0xF8, 0xFC, 0xFE, 0xFE, 0xFE, 0xFE,.... }

Die Funktion zum Bitmap schreiben sieht dann so aus:

void display_bitmap(char ROM *bitmap, unsigned char x, unsigned char y, unsigned char dx, unsigned char dy) {
  unsigned char i, j;
  for(j = 0; j < dy / 8; j++) {
    display_goto(x,y/8 + j);
    for(i = 0; i < dx; i++) {
      display_write(*(bitmap++),DATA);
    }
  }
}

Der Aufruf sieht nun so aus:

display_bitmap(Logo,0,20,128,25);

Gruß,
 Tobias