Pekare till constant struct i flash (PIC) XC8

[slatte]

Detta problemet har jag:
Använder mig utav pic16f648A och XC8 kompilatorn

har denna struct deklarerad och initierad
Vilket omj ag har tolkat XC8 manualen rätt kommer att placera structen i flash minnet.

parameters.c

Kod: Markera allt

const struct parameters FLASH_parameter =
{
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint32 
    0,                          // uint8 
    0,                          // uint8 
    0,                          // uint8 
    {0,0,0,0,0,0,0,0,0,0},      // uint8 error_codes[10]
    0
};

parameters.h

Kod: Markera allt

struct parameters
{
    uint32 user_tag_0;
    uint32 user_tag_1;
    uint32 user_tag_2;
    uint32 user_tag_3;
    uint32 user_tag_4;
    uint32 user_tag_5;
    uint32 user_tag_6;
    uint32 user_tag_7;
    uint32 user_tag_8;
    uint32 user_tag_9;
    uint32 a;
    uint32 b;
    uint32 c;
    uint8 bah;
    uint8 bah_1;
    uint8 koko;
    uint8 koko;
    uint32 time;

extern const struct parameters FLASH_parameter;
};

Om jag nu skulle vilja läsa denna stuct med hjälp av en pekare som jag för övrigt är kass på så skulle jag vilja göra typ såhär:

i annan c fil:

Kod: Markera allt

uint8 *parameter_in_flash_p;
uint8 byte;

parameter_in_flash_p = &FLASH_parameter;
byte = *parameter_in_flash_p;

Hade då tänk mig att få första biten i FLASH_parameter.user_tag_0 sparad i variabeln byte.
Men detta får jag inte att fungera. dvs om jag skickar ut "byte" på uarten läser jag inte av "0x00" direkt.
Några tips på hur man kan lösa detta för detta fungerar inte för mig

Känns som att jag missar något basic här
Är fruktansvärt dålig på pekare också så det kan ju vara en förklaring.....

/Slatte

[Icecap]

Varför ställa till det med pekare? Eller - allt sånt är ju med pekare egentligen men man kan göra det svårt för sig eller lätt för sig.

Låt oss nu se lite här: Du verkar ha en typedef av "parameters" så den kan vi låta vara därhän.
Men jag är inte helt med på hur du använder det hela... "parameters" måste ju redan vara definierat som et struct... får du ingen felmeddelanden?

Kod: Markera allt

typedef struct
  {
  uint32 user_tag_0;
  uint32 user_tag_1;
  uint32 user_tag_2;
  uint32 user_tag_3;
  uint32 user_tag_4;
  uint32 user_tag_5;
  uint32 user_tag_6;
  uint32 user_tag_7;
  uint32 user_tag_8;
  uint32 user_tag_9;
  uint32 a;
  uint32 b;
  uint32 c;
  uint8 bah;
  uint8 bah_1;
  uint8 koko;
  uint8 koko;
  uint32 time;
  } T_PARAMETERS;

const T_PARAMETERS FLASH_parameter =
  {
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint32
    0,                          // uint8
    0,                          // uint8
    0,                          // uint8
    {0,0,0,0,0,0,0,0,0,0},      // uint8 error_codes[10]
    0
  };

På detta vis har du nu tillgång till "FLASH_parameters" och alla dess undervärden. Vill du t.ex. ha bah_1 är "adressen" till den "FLASH_parameters.bah_1".

Men vill du t.ex. kopiera den byte för byte får man ta till lite trick!
byte = *(uint8*)&FLASH_Parameters;
Då får du första byten i den minnesklump. Lite förklaring:
byte = *(uint8*)&FLASH_Parameters; // Här anger man "jag VET OM att det jag gör eg. är fel" vid att cast'a.
byte = *(uint8*)&FLASH_Parameters; // Här får jag en pekare till minnesklumpen
byte = *(uint8*)&FLASH_Parameters; // Här ber jag om innehållet i den adress

Men om du vill skanna igenom minnet, hur gör du då? Jo, enkelt:
byte = *(uint8*)(&FLASH_Parameters + Index);
Då kan du med Index stega igenom alla bytes i det minne. Med sizeof(T_PARAMETERS) kan du få veta hur många bytes den minnesklump är.

[swesysmgr]

const struct parameters* flashpekare=&FLASH_parameter;
char slask;
slask = flashpekare->a;

slask har nu värdet i a.

Sen vet jag inte om det är det smartaste sättet att göra om du bara skall ha en enda parameters struct och inte ett fält av 20 att rulla igenom eller liknande.

[Korken]

...

Då kan du med Index stega igenom alla bytes i det minne. Med sizeof(T_PARAMETERS) kan du få veta hur många bytes den minnesklump är.

OT:
Körs sizeof( ... ) vid compile-time eller vid runtime?

[slatte]

Kod: Markera allt

byte = *(uint8*)(&FLASH_Parameters + Index); 

Detta var precis det som´jag var ute efter, ska prova detta när jag kommer hem ifrån jobbet idag

I de flesta fall kommer jag nog precis som du säger Icecap bara att kopiera den byte för byte, så då kommer jag garanterat använda mig utav den här varianten.

Kod: Markera allt

byte = *(uint8*)(&FLASH_Parameters + Index);

Men tackar!

Får väl klura lite mer på pekaren innan jag förstår den tyvärr

[Icecap]

Korken: det är en preprocessor-grej, det är alltså vid kompileringen det sker. Du kan se värdet som en skriven konstant.

slatte: du kanske ska se det hela på et annat sätt? Jag har t.ex. en rutin som kan spara en block till EEPROM, den rutin behöver veta:
* Vilken startadress i EEPROM'et som gäller.
* Vilken startadress i minnet som gäller. Detta är då en pekare till en byte.
* Antal bytes som ska sparas.

När jag sedan kallar den är det enkelt, nu använder jag detta som exempel:
Save_EEPROM_Block(0, (uint8*)&FLASH_parameter, sizeof(FLASH_parameter));

och den är definierat på detta sätt:
void Save_EEPROM_Block(uint16 Startaddress, uint8* Source, uint16 Blocksize);

Fördelen vid detta sätt är att jag dels har en "universell" rutin till att spara till EEPROM (eller skriva ut eller sända på något vis eller vad jag vill) och dels att jag kan göra det med vad jag vill så länge jag kan "skaffa" en pekare till minnet som används.

[thebolt]

Kod: Markera allt

byte = *(uint8*)(&FLASH_Parameters + Index);

För att vara petig, det där kommer inte göra vad det är tänkt.. det kommer ge en pekare till nästa T_PARAMETERS block (dvs sizeof(T_PARAMETERS) bytes efter FLASH_Parameters.. iom att &FLASH_Parameters har typen T_PARAMETERS* och inkrementet på pekaren görs innan cast till uint8.. för att det ska bli rätt måste du göra

Kod: Markera allt

byte = *((uint8*)&FLASH_Parameters) + Index);

[Icecap]

thebolt: messerschmitt!

Men det finns ju en viss chans för att du har en aning rätt...