Problem mit pgm_read_byte_far

[Tom Berger (Gast)]

Hi,

bitte kann mir jemand helfen?

Ich habe in meinem Mega128 sehr viel statische Daten die im Flash
liegen. Mittlerweile sind es weit über 100k. So viel ich weis, kann ich
die nicht mehr mit der Funktion pgm_read_byte auslesen, da diese
Funktion nur eine short Adresse hat.

Jetzt bin ich gezwungen auf die Funktion pgm_read_byte_far
umszusteigen, die eine long Adresse hat. Doch leider bringt der
Compiler Fehlermeldungen z.B. warning: cast from pointer to integer of
diffrent size oder error: SFR_IO_ADDR undeclared (fist use this
function).
Was jemand was da schief läuft.

Hier mein Code (pseudo)

long pos;
unsigned char temp;

const unsigned char Array [xxx] PROGMEM = { "Datenbytes" };

temp = pgm_read_byte_far (&Array[pos]);

[mthomas (Gast)]

Zuerst: ist keine "Fehlermeldung", sondern "nur" eine Warnung. Aber
das hilft nicht wirklich. Soweit erinnert, verwaltet avr-gcc alle
Pointer mit 16bit, so auch die auf Flash/Progmem. Die *_far Funktionen
erwartet eine 32bit-Angabe (vgl. pgmspace.h). Ein Cast duerfte die
Warnung unterdruecken. Aber das ist wohl nur die "halbe Miete":
Soweit ich weiss, koennen mit PROGMEM nur Konstanten in den ersten 64kB
des Flash-Speichers angelegt werden, duerfte also bei 100kB noch von
anderer Stelle zu Problemen kommen.

[A.K. (Gast)]

"Ich habe in meinem Mega128 sehr viel statische Daten die im Flash
liegen. Mittlerweile sind es weit über 100k."

Eine andere µC-Familie (z.B. ARM7) mag in der Grössenordnung sinnvoller
sein. Grosse Daten/Programme sind nicht die Stärke von 8-Bit
Prozessoren.

[Peter (Gast)]

Hallo Tom,

ist zwar ne Weile her bei dir, aber ich habe gerade genau das gleiche
Problem. Hattest du damals eine Lösung gefunden?

Besten Dank,
Peter

[Günter R. (galileo14)]

"pgm_read_byte_far" will einen uint32_t-Wert als Parameter, daher
diese Warnung. Der normale Pointer-Mechanismus funktioniert hier nicht.
Man muß die Adresse in einen uint32_t packen und damit dann
"pgm_read_byte_far" aufrufen.

[Peter Sager (Gast)]

Hierzu braucht's folgendes Makro, welches einen 32 Bit Pointer auf die
Progmem Daten zurück liefert:

//----------------------------------------------------------
// Macros to access data defined in PROGMEM above 64kB
//----------------------------------------------------------
#define FAR(var)                                      \
({                                                    \
    uint_farptr_t tmp;                                \
                                                      \
    _asm_ __volatile__(                             \
                                                      \
            "ldi    %A0, lo8(%1)"           "\n\t"    \
            "ldi    %B0, hi8(%1)"           "\n\t"    \
            "ldi    %C0, hh8(%1)"           "\n\t"    \
            "clr    %D0"                    "\n\t"    \
        :                                             \
            "=d" (tmp)                                \
        :                                             \
            "p"  (&(var))                             \
    );                                                \
    tmp;                                              \
})
//----------------------------------------------------------

Dann kannst Du z.B. auf die folgende Weise auf die Daten zugreifen:

MyByte = pgm_read_byte_far(FAR(MyProgMemPointer));


@jörg (falls Du zufällig hier reinschauen solltest)

Ich sehe immer wieder Threads mit Leuten, die über dieses Problem
stolpern. Wäre es nicht sinnvoll, dieses Makro in <pgmspace.h>
aufzunehmen?

MfG Peter

[Peter (Gast)]

Besten Dank euch beiden!

In der Zwischenzeit hatte ich mir eine proprietäre Lösung gebastelt,
aber der Ansatz über das FAR Makro mit der Direktive hh8(...) ist
natürlich schöner.

Macht's gut,
Peter

[Tobi (Gast)]

Hi,

ich versuche nun schon eine ganze Weile das oben genannte Makro

//----------------------------------------------------------
// Macros to access data defined in PROGMEM above 64kB
//----------------------------------------------------------
#define FAR(var)                                      \
({                                                    \
    uint_farptr_t tmp;                                \
                                                      \
    asm volatile(                           \
                                                      \
            "ldi    %A0, lo8(%1)"           "\n\t"    \
            "ldi    %B0, hi8(%1)"           "\n\t"    \
            "ldi    %C0, hh8(%1)"           "\n\t"    \
            "clr    %D0"                    "\n\t"    \
        :                                             \
            "=d" (tmp)                                \
        :                                             \
            "p"  (&(var))                             \
    );                                                \
    tmp;                                              \
})
//----------------------------------------------------------

zu verwenden um auf Konstanten mittels pgm_read_byte_far zuzugreifen.


Ich bekomme jedoch in dieser Zeile

uint8_t b = pgm_read_byte_far(FAR(&array[X]));

immer die Fehlermeldung

error: invalid lvalue in unary '&'

Was ist falsch an dieser Zeile ? Ich habe testweise auch mal

uint8_t b = pgm_read_byte_far(FAR(array[X]));

probiert, was aber nur zur dreifachen Ausgabe von

undefined reference to `r30'
undefined reference to `r30'
undefined reference to `r30'

führt. Wäre schön wenn mir hier jemand helfen könnte.

Gruss, Tobias

[Bernhard M. (boregard)]

probier mal:

uint8_t b = pgm_read_byte_far(FAR(&(array[X])));

[Tobi (Gast)]

Danke erstmal, aber das führt leider zum gleichen Fehler..

invalid lvalue in unary '&'

Noch eine Idee ?

[Tobi (Gast)]

Weiss denn wirklich niemand was ich falsch mache ?

[Peter (Gast)]

Wie hast du das Array deklariert, bzw. liegen die Array-Daten wirklich 
im FLASH? Das ist nämlich nicht ganz so trivial. Wenn man nicht gut 
aufpasst liegt zwar der Array-Pointer im Flash, nicht aber die Daten, 
oder umgekehrt.

Weitere Infos dazu findest Du in der Dokumentation zur Avr_LibC, im 
speziellen im Kapitel "9.10 Frequently Asked Questions"

Falls Dein "array" wirklich ein Pointer auf die gewünschte 
Progmem-Adresse ist, dann müsste es folgendermassen funktionieren:

uint8_t b = pgm_read_byte_far(FAR(array)+X);

So kannst Du sogar die Limitierung umgehen, dass mit dem Array-Index 
maximal 32kByte Adressierbar

Viel Erfolg

[Josef K. (josefk)]

Ich habe das gleiche Problem wie Tobi. Ich glaube aber meinen String 
richtig im Flash liegen zu haben:

const char spi_start[] PROGMEM = "Aktiviere SPI...";
//...
void funktion(PGM_P s)
{
//...
  c= pgm_read_byte_far(FAR(s));
}

Hat da jemand schon eine Lösung?

[Michael B. (betz)]

Hy!
Versuche gerade einen Bootloader mit dem Usb Treiber von Objective 
Development auf einem Mega128 zum laufen zu kriegen.
Ich bekomme mit dem Makro leider auch Probleme, erhalte 3 malig die 
Fehlermeldung:

undefined reference to `r30'

Aufgebaut hab ich das so:

#define GET_FAR_ADDRESS(var)                          \
({                                                    \
    uint_farptr_t tmp;                                \
                                                      \
    __asm__ __volatile__(                             \
                                                      \
            "ldi    %A0, lo8(%1)"           "\n\t"    \
            "ldi    %B0, hi8(%1)"           "\n\t"    \
            "ldi    %C0, hh8(%1)"           "\n\t"    \
            "clr    %D0"                    "\n\t"    \
        :                                             \
            "=d" (tmp)                                \
        :                                             \
            "p"  (&(var))                             \
    );                                                \
    tmp;                                              \
}) 
#define PRG_RDB(addr)   pgm_read_byte_far( GET_FAR_ADDRESS(addr) )

Der Aufruf sieht dann folgendermaßen aus:

uchar *r = usbMsgPtr;
uchar c = PRG_RDB(r);

Wie kommt der Compiler da auf die Idee r30 anzumeckern?

Viele Grüsse

[Johann L. (gjlayde)]

Es muss sichergestellt sein, daß (&(var)) oben zu einem Symbol auflöst, 
d.h die Adresse muss spätestens zur Link-Zeit feststehen. Ansonsten 
versucht gcc da wohl ein GPR einzusetzen, und dann stekt sowas da wie 
lo8(r30) oder so.

[Michael B. (betz)]

Hmm leider fehlt mir das nötige wissen über inline Assembler um da 
richtig durchzublicken.

Ich hab jetzt eine andere Lösung gefunden die für mich funktioniert:

#define PRG_RDB(addr)   pgm_read_byte_far(0x10000UL + (uint32_t) (uint16_t) addr)

[subitus (Gast)]

Mit

  'pgm_read_byte_far(0x10000UL + (uint32_t) (uint16_t) addr)'

lässt sich nur der Flash-Speicher zwischen 64k..128k adressieren.


MfGruß,

subitus

[Thomas K. (muetze1)]

... und wozu der doppelte cast?

[Oliver (Gast)]

>... und wozu der doppelte cast?

Für jedes Jahr seit dem letzten Beitrag in diesem Thread einen...

Oliver