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]);
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.
"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.
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
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_tb=pgm_read_byte_far(FAR(array)+X);
So kannst Du sogar die Limitierung umgehen, dass mit dem Array-Index
maximal 32kByte Adressierbar
Viel Erfolg
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:
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.
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:
