AVR und 32Bit-Adressen

Frank Roggel Gast #5118711
Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich rechne eine CRC über meinen Programmcode und hab dazu eine 
Dummy-Section angelegt, deren Adresse mir anzeigt, wo der Programmcode 
aufhört:
1
const uint16_t  Dummy        __attribute__((section (".dummy"      ), used, unused)) = 0xAAAA;

2
const uint16_t  AddresseVonDummy  __attribute__((section (".addressevondummy"  ), used, unused)) = (uint16_t)&Dummy;

Der Wert AddresseVonDummy liegt an einer fixen Adresse im Hexfile, damit 
ich den Wert im Bootloader auslesen kann.

Das funktioniert einwandfrei, aber nur mit 16Bit-Adressen.

Wenn ich ganze für einen ATMega1284 bauen will, bräuchte ich 
32Bit-Adressen.
Wenn ich nun folgendes probiere
1
const uint16_t  Dummy        __attribute__((section (".dummy"      ), used, unused)) = 0xAAAA;

2
const uint32_t  AddresseVonDummy  __attribute__((section (".addressevondummy"  ), used, unused)) = (uint32_t)&Dummy;

steht in AddresseVonDummy immer noch 0x00000000 drinn.

Wie geht das?
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Frank Roggel Gast #5119130
Lesenswert?
• ▲
▼ 
A. K. schrieb:
> Eine Funktion, die eine CRC auf einen Datenblock im RAM berechnet,
> ist
> auf einem AVR  nicht für ROM einsetzbar. Das musst du Byte für Byte
> berechnen, indem du mit einem Pointer ins ROM jedes Byte holst.

Sicher, aber das hat nichts mit meinem Problem zu tun.

Mir geht es nur darum, wie ich auf einem AtMega1284 den Adressen 
jenseits der 64kByte darstellen kann.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Frank Roggel Gast #5119170
Lesenswert?
• ▲
▼ 
Jim M. schrieb:
> Wir lösen auf:
Schön wär's.


Ich hab folgenden Code:

1
const uint16_t  Dummy        __attribute__((section (".dummy"      ), used, unused)) = 0xAAAA;

2
const uint32_t  AddresseVonDummy32  __attribute__((section (".addressevondummy32"  ), used, unused)) = (uint32_t)&Dummy;

3
const uint16_t  AddresseVonDummy16  __attribute__((section (".addressevondummy16"  ), used, unused)) = (uint16_t)&Dummy;


Den kann ich auf einem ATMega644 oder auf einem ATMega1284 erzeugen, und 
es gibt immer das gleiche Ergebnis:
In AddresseVonDummy16 stehen die korrekten unteren 16Bit der Adresse von 
Dummy drinn.
In AddresseVonDummy32 steht 0x00000000 drinn.

Siehe Hexfile vom ATMega128P:
Dummy liegt an Adresse 0x0000050A.
AddresseVonDummy32 liegt an Adresse 0x1F7F4 und enthält 0x00000000.
AddresseVonDummy16 liegt an Adresse 0x1F7F8 und enthält 0x050A.

1
(...)

2
:02050A00AAAA9B

3
:020000021000EC

4
:04F7F4000000000011

5
:02F7F8000A0500

6
:00000001FF
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan E. #5119256
Lesenswert?
• ▲
▼ 
Frank Roggel schrieb:
> Wenn ich ganze für einen ATMega1284 bauen will, bräuchte ich
> 32Bit-Adressen.

Ich würde dafür einfach eine kleine Assembler-Datei in das Projekt 
integrieren:
1
  .global  AddresseVonDummy

2
  .section  .addressevondummy,"a",@progbits

3
  .type  AddresseVonDummy, @object

4
  .size  AddresseVonDummy, 4

5
AddresseVonDummy:

6
  .byte  lo8(Dummy)

7
  .byte  hi8(Dummy)

8
  .byte  hh8(Dummy)

9
  .byte  0



Kleiner Hinweis am Rande:
Es heißt eigentlich "Adresse" (mit einfachem d).
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Johann L. Persönliche Seite #5119456
Lesenswert?
• ▲
▼ 
Frank Roggel schrieb:
> const uint16_t  Dummy        __attribute__((section (".dummy"      ),

Schlecht, vermutlich eine Orphan Section.  Deren Position wird als durch 
implizite Regeln von ld für entsprechende Sections bestimmt.

Besser: definier ein eigenes Symbol in deinem Linker Skript.  Hat zudem 
den Vorteil, dass der CRC nicht nur über Code geht sondern auch über die 
Daten, welche zur Initialisierung des SRAM verwendet werden (also für 
.data und .rodata).

An die Adresse kommt man dann z.B. so:

1
#include <stdint.h>

2


3
extern uint8_t __data_load_end; // defined in ld script

4


5
uintptr_t getp (void)

6
{

7
    return (uintptr_t) &__data_load_end;

8
}

9


10
uint32_t getp32 (void)

11
{

12
    uint32_t addr;

13
    __asm ("ldi %A0, lo8(%1)" "\n\t"

14
           "ldi %B0, hi8(%1)" "\n\t"

15
           "ldi %C0, hh8(%1)"

16
           : "=d" (addr) : "i" (&__data_load_end));

17
    return addr;

18
}

19


20
extern const __memx uint8_t p24_memx[] __asm ("__data_load_end");

21


22
const __memx uint8_t* getp24_memx (void)

23
{

24
    return p24_memx;

25
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 9 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Dein Name und deine E-Mail-Adresse

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.