Posizionamento riga di codice scritto in XC8 su MPLABX

[demos81]

Salve a tutti,
mi trovo nella necessità di posizionare un paio di righe di codice di un progetto scritto in MPLABX (con compilatore XC8) in una ben precisa posizione della memoria programma del PIC.
Il tutto nasce per posizionare i comandi di rinvio alle funzioni di interrupt nelle posizioni 0x008 e 0x018 e preservare un codeoffset per il bootloader.
in pratica dovrei inserire nella posizione:
0x008 l'istruzione GOTO 0x408
0x018 l'istruzione GOTO 0x418

Ho già usato l'impostazione --CODEOFFSET del linker che purtroppo coinvolge tutto il programma per riservare lo spazio del bootloader ( e fin qui nessun problema) ma devo ancora ricollocare le 2 righe di codice sopra citate.

- Ho provato con la direttiva #pragma code ma non è riconosciuta dal compilatore.
- ho anche provato a creare delle funzioni di rimando in C ricollocate come segue... purtroppo però non vengono compilate a meno di inserire la funzione nel main... ma ovviamente non voglio richiamare l'interrupt dal main..

Codice: Seleziona tutto

void IntBassaPriorita(void) @0x018 {
#asm
    GOTO 0x418
#endasm
}

qualcuno ha qualche suggerimento?

[bobina]

Codice: Seleziona tutto

void IntBassaPriorita(void) @0x018 {
#asm
    GOTO 0x418
#endasm
}

Questo codice non funziona? Leggendo la guida microchip "MPLAB C18 to XC8 C Compiler Migration Guide" al paragrafo 3.14.1 che spiega come allocare variabili e funzioni e mostra la differenza su come veniva fatto in C18 e come si deve fare in XC8 e l'esempio riporta proprio questo

int calcOffset(int radius) @ 0x2000 {

però, ora che rileggo meglio credo che il tuo caso riguardando gli interrupt cade nel paragrafo 3.13 dove spiega che per definire gli interrupt a low priority bisogna definire la funzione nella seguente maniera

Codice: Seleziona tutto

void interrupt low_priority low_isr (void)
{
/* service routine body goes here */
}


Quel PDF è molto interessante per fare il porting dal vecchio C18 al nuovo XC8 ti consiglio di dargli un occhiata.

[demos81]

ciao bobina,
ho risolto e stasera che son a casa posto il codice.
in pratica l'esempio che fai tu funziona per le funzioni che vengono richiamate nel main() e che decidi di posizionare in un punto specifico.
Per gli interrupt , non avendo una specifica chiamata di funzione dentro al main non vengono compilate o comunque non viene tenuto in conto l'attributo @ (ho provato più volte ma nulla, non riuscivo a piazzare quelle due righe di codice asm dove volevo io senza che dovessi richiamarle in una funzione).

Alla fine son riuscito creando una sezione di codice indipendente con PSECT .

[demos81]

Salve,
qui di seguito il codice con cui son riuscito a posizionare alcune righe di codice nella parte iniziale della memoria programma (come per esempio il rinvio del vettore di interrupt) anche se tra le opzioni di MPLAB vi è inserito uno specifico CODEOFFSET per inibire al compilatore la sezione di memoria programma iniziale da 0x400 in poi.

Codice: Seleziona tutto

// File di definizione dei registri del micro.
#include "p18f47j53.h"

// Header di base da inserire in XC8
#include "xc.h"
//------------------------------------------------------------------------------
// Variabili globali
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
// Inserimento delle istruzioni asssembler di salto agli interrupt
//la definizione di PSECT fa si che le istruzioni siano compilate anche se non
//fanno riferimento a una specifica funzione richiamata dentro il main.
//sembra che il compilatore la veda come una sezione di codice "predefinita"
//------------------------------------------------------------------------------
#asm
PSECT INT_text
ORG 0x0000
GOTO 0x1000
ORG 0x0008
GOTO 0x1008
ORG 0x0018
GOTO 0x1018
#endasm

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt ad ALTA priorità
//------------------------------------------------------------------------------
void interrupt high_priority High_ISR(void) {
    // Verifica quale flag ha causato l' interrupt
    // Esegui la parte di codice di servizio relativo e
    // azzera il flag che ha causato l' interrupt per evitare ridondanza
    // ...
}

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt a BASSA priorità
//------------------------------------------------------------------------------

void interrupt low_priority Low_ISR(void) {
    // Verifica quale flag ha causato l' interrupt
    // Esegui la parte di codice di servizio relativo e
    // azzera il flag che ha causato l' interrupt per evitare ridondanza
    // ...

}

//------------------------------------------------------------------------------
// Prototipi delle funzioni
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// Funzioni
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
// MAIN FUNCTION
//------------------------------------------------------------------------------

void main(void) {
    // -------- Inizializzazione e attivazione delle periferiche --------
   
    // -------- Selezione ed abilitazione interrupt ------

    // -------- Ciclo infinito di funzionamento --------
    for (;;) {
/**/
    }
}

Se qualcuno vuol fare qualche considerazione o proporre soluzioni più pulite ,son qui per uno scambio di idee.