Il modo in cui lo facciamo in uno dei nostri prodotti è così (il codice è basato sul compilatore IAR, quindi i pragmi potrebbero differire per te):

Abbiamo definito una struttura che contiene informazioni importanti dell'applicazione part (che si chiama mainpart nei nostri progetti):

  #pragma pack (push, 1) struct softwareRevision_t {uint8_t VersionSystem; uint8_t VersionFunction; uint8_t VersionError; uint8_t VersionCustomer; uint8_t BuildNumber; }; # pragma pack (pop) #pragma pack (push, 1) struct mainInfoStruct_t {softwareRevision_t softwareRevision; uint32_t startFunctionAddress; riserva uint8_t [27]; uint32_t bootControl; }; # pragma pack (pop)  

Questo contiene tra le altre cose uint32_t startFunctionAddress . Ora, affinché questa struttura sia utile, devi fare diverse cose:

1. Inizializzala con valori significativi nell'applicazione
2. Rendila const in modo che possa essere posizionato in flash
3. Dì al linker di posizionare la struttura sempre nella stessa identica posizione ogni volta che compili il tuo progetto
4. condividi la posizione e la struttura tra l'applicazione e la parte di avvio

Nella parte dell'applicazione:

Per condividere la posizione, abbiamo creato un file di intestazione che è incluso in entrambe le parti con una semplice definizione:

  #define MAIN_INFO_MEMORY_POSITION (0x0807FFD4)  

In un file .cpp della nostra applicazione creiamo un istanza della struttura che viene posizionata di conseguenza:

  #pragma location = MAIN_INFO_MEMORY_POSITIONextern __root const mainInfoStruct_t mainInfoStruct = {{1U, // mainInfo.softwareRevision.VersionSystem 0U, // mainInfo.softwareRevision.VersionFunction 0U, // mainInfo.softwareRevision.VersionError 0U, // mainInfo.softwareRevision.VersionCustomer 0U // mainInfo.softwareRevision.BuildNumber},
reinterpret_cast<uint32_t> ((&_start)), // mainInfo.startFunctionAddress {0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U , 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U}, // reserve 0xF0F0FFFFU // mainInfo.bootControl};  

Qui accadono diverse cose: #pragma location = MAIN_INFO_MEMORY_POSITION dice al linker dove posizionare la struttura successiva.

Il __root dice al nostro linker che questo simbolo deve essere mantenuto, anche se non è referenziato dal codice dell'applicazione (cosa che non è). Deve essere const altrimenti non verrebbe posizionato in flash (se non finisce in flash prova ad aggiungere un statico).

Quindi con questo abbiamo fatto tutto nell'applicazione.

Nella parte di avvio:

La parte di avvio ha bisogno di accedere alle informazioni sulla parte dell'applicazione struttura. Abbiamo racchiuso una classe attorno a tutta questa cosa, ma fondamentalmente un puntatore sarà sufficiente:

  volatile mainInfoStruct_t * pMainInfo = reinterpret_cast<mainInfoStruct_t * > (MAIN_INFO_MEMORY_POSITION); > 

  (reinterpret_cast<void (*) (void) > (pMainInfo->startFunctionAddress)) ();  

Note:

Nella nostra applicazione eseguiamo un controllo CRC su tutta la parte dell'applicazione che include mainInfoStruct, quindi non saltiamo nel nirvana è qualcosa è andato storto con l'aggiornamento.

La prima cosa che facciamo nella nostra applicazioneèimpostare lo stackpointer al valore con cui dovrebbe iniziare (puoi ottenerlo dal file di configurazione del linker o dal tuo vettore di interrupt tavolo). Altrimenti potresti finire con un overflow dello stack e danneggiare gli altri tuoi dati.

Questo non è un esempio minimale, ma potrebbe anche dare qualche suggerimento su ciò che potrebbe essere utile in una struttura condivisa.

Usiamo C ++, ci scusiamo per il reinterpret_cast s.

Grazie per i tuoi sforzi ...

Come ho affermato nella mia domanda, ho creato un'istanza di una struttura in una posizione fissa 0x0020100. utilizzando il seguente metodo.

  const struct CodeInfoStruct CodeInformation __attribute __ ((section (". ARM .__ at_0x0020100")));
 

Ma ho osservato che la struttura non è memorizzata in questa particolare posizione. Quindi, l'accesso all'indirizzo richiesto del puntatore a funzione che è stato memorizzato in questa struttura in questa posizione era sbagliato. La logica di accesso al codice dell'applicazione dal codice di avvio funziona perfettamente.

Il modo corretto per scrivere la struttura (qualsiasi dato / variabile) in una posizione specifica è il seguente:

  struct CodeInfoStruct __attribute __ ((section (".ArrSectioninflash"))) CodeInformation =
{
    &my_run_code
};
 

E aggiungi la sezione "ArrSectioninflash" nel file del linker come segue:

  .myBufBlock 0x00021000:
{
            KEEP (* (. ArrSectioninflash))
} > FLASH
 

Due possibili approcci:

• Rendi il file scaricato un binario ELF e analizza le sue intestazioni per determinare il "punto di ingresso" o un simbolo specifico.

• Basta far saltare il bootloader a un punto fisso specifico nel file scaricato, di solito l'inizio.Scrivi uno script del linker per mettere il punto di ingresso nel posto giusto.(Di solito questo finisce come un file "bin").