Problem mit pgm_read_byte_far

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.

"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.

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

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

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

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

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

invalid lvalue in unary '&'

Noch eine Idee ?

Weiss denn wirklich niemand was ich falsch mache ?

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:

1

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

Mit

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

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


MfGruß,

subitus

>... und wozu der doppelte cast?

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

Oliver