typedef struct an funktion übergeben

[Ma B. (drumstick)]

Hallo Allerseits!

Ich arbeite mit dem uVision von Keil und dem STM32F103VDT6.

Ich habe verschiedene Variablen in einem typedef struct angelegt. Diese 
Variablen möchte ich jetzt der gleichen Funktion nacheinander übergeben.

typedef struct  {
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
                  BOOL                cal_OK;
                  int                 MotDistCal_PulsesMax;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                  int                 ShttrueIdx[CNTSHT];
                  int                 Nmbr_of_Shttr;
                }
                tSetup;

extern tSetup     Setup;

void set_in_Flasht(tSetup data)
{
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR |   FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  FLASH_ProgramWord(flshBseAdr, data);
  FLASH_Lock();
}

set_in_Flash(Setup.Nmbr_of_Shttr);

Fehlermeldung:

tsk_functions.c(1234): error:  #167: argument of type "int" is 
incompatible with parameter of type "tSetup"
compiling flash_functions.c...
flash_functions.c(98): error:  #167: argument of type "tSetup" is 
incompatible with parameter of type "uint32_t"



Was habe ich noch nicht verstanden? Habe von einem Beispiel aus dem 
Forum abgeschaut!


Danke und Gruss!

M.B.

[Peter II (Gast)]

> set_in_Flash(Setup.Nmbr_of_Shttr);
die function will doch die komplette stuct nicht nur ein teil von ihr.

set_in_Flash(Setup);

das ganze ist aber wenig effizent, weil dabei eine kopie der struct 
angelegt wird. Hier sollte man mit zeigern oder Referenzen arbeiten.

[Tom M. (Gast)]

M. B. schrieb:
> tsk_functions.c(1234): error:  #167: argument of type "int" is
> incompatible with parameter of type "tSetup"

Zeig mal Zeile 1234 und den Prototypen der dort aufgerufenen Funktion.

> compiling flash_functions.c...
> flash_functions.c(98): error:  #167: argument of type "tSetup" is
> incompatible with parameter of type "uint32_t"

Zeig mal Zeile 98 und den Prototypen der dort aufgerufenen Funktion.

[Ma B. (drumstick)]

Es hat sich noch ein Fehler eingeschlichen:

falsch:  set_in_Flasht()

richtig: set_in_Flash()

[Ma B. (drumstick)]

Zeile 1234:

set_in_Flash(Setup.Nmbr_of_Shttr);

Zeile 98:

FLASH_ProgramWord(flshBseAdr, data);

[Stefan E. (sternst)]

Anscheinend willst du einfach nur dies haben:

void set_in_Flash(int data)

[Ma B. (drumstick)]

extern void set_in_Flash(tSetup data);


FLASH_ProgramWord(flshBseAdr, data);  // ist aus StandartLib

[Ma B. (drumstick)]

Aber ich übergebe Variablen von unterschiedlichen Datentypen!?

[casud (Gast)]

Richtig, wenn auch nicht besonders sinnvoll:

Zeile 1234:

set_in_Flash(Setup);

Zeile 98:

FLASH_ProgramWord(flshBseAdr, data.Nmbr_of_Shttr);

[Ma B. (drumstick)]

ja, so gehts. Jetzt aber schauen, wenn ich die anderen Variablen auch 
noch übergebe...

[Ma B. (drumstick)]

Wie würdest Du den das lösen.. ich speichere mehre Variablen ins Flash. 
Die Variablen haben unterschiedliche Datentypen. Ich möchte ja nur eine 
Funktion erstellen.?


Danke und Gruss!

[Ma B. (drumstick)]

Zeile 1234:

set_in_Flash(Setup);

Zeile 98:

FLASH_ProgramWord(flshBseAdr, data.Nmbr_of_Shttr);

Das funktioniert aber wieder nicht!

[AVerr (Gast)]

Wenn du die Größe deines Structs ( in int ) weisst, dann kannst du das 
über einen Pointer machen:

typedef struct  {
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
                  BOOL                cal_OK;
                  int                 MotDistCal_PulsesMax;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                  int                 ShttrueIdx[CNTSHT];
                  int                 Nmbr_of_Shttr;
                }
                tSetup;

void set_in_Flash(tSetup *setup)
{
  uint32_t *pData = (uint32_t *)setup;
  uint8_t i;

  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR |   FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);

  for(i=0; i<GROESSE_STRUCT; i++)
    FLASH_ProgramWord(flshBseAdr, pData[i]);

  FLASH_Lock();
}

[Peter II (Gast)]

AVerr schrieb:
> Wenn du die Größe deines Structs ( in int ) weisst, dann kannst du das
> über einen Pointer machen:

sizeof() wurde schon erfunden.

[Lueger (Gast)]

void set_in_Flasht(int data)
{
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | 
FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  FLASH_ProgramWord(flshBseAdr, data);
  FLASH_Lock();
}

Aufruf:

set_in_Flasht(12345);

Die orginale Funktion will aber einen Strukturpointer von dir wenn sie 
richtig definiert ist:

void set_in_Flasht(tSetup* data)
{
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | 
FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  FLASH_ProgramWord(flshBseAdr, data);
  FLASH_Lock();
}


Aufruf: set_in_Flasht(&Setup);

[Ma B. (drumstick)]

Lösungsansatz:

set_in_Flash(Setup);

void set_in_Flash(tSetup *Setup)
{
  
  uint32_t *pData = (uint32_t *)Setup;
  uint8_t i;
  int x = sizeof(tSetup);
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  for(i=0;i<x;i++)
  {
    FLASH_ProgramWord(flshBseAdr, pData[i]);
  }
  FLASH_Lock();
  
}

Fehlermeldung:

tsk_functions.c(1234): error:  #167: argument of type "tSetup" is 
incompatible with parameter of type "tSetup *"

[AVerr (Gast)]

set_in_Flash(&Setup);

und bei int x = sizeof(tSetup);
fehlt glaube ich noch ein /4, da sizeof die Größe in Bytes zurückgibt 
und du sie in int haben willst.

[Karl H. (kbuchegg)]

AVerr schrieb:
>

set_in_Flash(&Setup);

>
> und bei int x = sizeof(tSetup);
> fehlt glaube ich noch ein /4, da sizeof die Größe in Bytes zurückgibt
> und du sie in int haben willst.

wenn schon dann

   sizeof(tSetup)/sizeof(int)

und nicht /4


Allerdings frage ich mich, was der ganze Quatsch soll?

Wenn du sowieso die komplette Struktur sichern willst, warum suchst du 
dir dann nicht einen Ersatz für

  FLASH_ProgramWord

der eben nicht nur ein Word sondern einen kompletten Speicherbereich 
sichern kann?

[Ma B. (drumstick)]

Dies wäre natürlich die beste Lösung! Wusste nicht, dass es das gibt!

[Karl H. (kbuchegg)]

M. B. schrieb:
> Dies wäre natürlich die beste Lösung! Wusste nicht, dass es das gibt!

Ich weiß auch nicht ob es das in deinem System gibt.
Aber das Header File, aus dem die Funktion FLASH_ProgramWord stammt, die 
weiß es. Wenn es eine derartige Funktion gibt, dann ist sie dort drinnen 
aufgeführt.

Und ja: Auch in Systemheaderfiles darf man mit einem Editor 
hineinschauen. Und nochmals ja: es ist nicht verboten die Doku zu seinem 
Compiler zu lesen. Denn auch dort steht drinnen, welche Funktionen es 
gibt.

Das hier
> Habe von einem Beispiel aus dem Forum abgeschaut!
ist gut um eine Idee zu bekommen. Aber gleich danach steht das Studium 
der Hilfe (erste Anlaufstelle) oder des Headerfiles (zweite 
Anlaufstelle, wenn man mit der Hilfe alleine nicht weiterkommt)

[Karl H. (kbuchegg)]

Sind das diese Funktionen?
http://brawikov.narod.ru/StdPerLibSTM32F10x/group__FLASH__Exported__Functions.html

[Peter II (Gast)]

Karl Heinz Buchegger schrieb:
> wenn schon dann
>
>    sizeof(tSetup)/sizeof(int)
>
> und nicht /4

sollte es nicht besser

sizeof(tSetup)/sizeof(Word)

sein, denn die funktion heist FLASH_ProgramWord

[Ma B. (drumstick)]

@ Karl Heinz Buchegger:

Ja genau! Das sind sie! keine Funktion um den gesammten speicherbereich 
zu programmieren!

[Peter II (Gast)]

M. B. schrieb:
> keine Funktion um den gesammten speicherbereich
> zu programmieren!

zeigt doch mal welche funktionen es gibt.

[Karl H. (kbuchegg)]

Da gibts keine, die einen Speicherbereich programmiert. Aber sowas kann
man sich mit den vorhandenen Funktionen auch selber schreiben, solange
sizeof(x) eine gerade Zahl ist.

void FLASH_ProgramMemory( uint32_t Address, void* Data, size_t DataSize )
{
  DataSize /= sizeof( uint16_t );   // Halfword

  for( size_t i = 0; i < DataSize; i++ )
    FLASH_ProgramHalfWord( Address + i * sizeof( uint16_t ),
                           ((uint16_t*)pData)[i] );
}

  FLASH_ProgramMemory( flshBseAdr, &Setup, sizeof( Setup ) );

(uint16_t deswegen, weil ich die 'kleinere' Funktion genommen habe. Ist 
sichergestellt, dass sizeof(Setup) ein Vielfaches von sizeof(uint32_t) 
ist, dann kann man auch auf Word Behandlung ausweichen.

[Karl H. (kbuchegg)]

Peter II schrieb:
> Karl Heinz Buchegger schrieb:
>> wenn schon dann
>>
>>    sizeof(tSetup)/sizeof(int)
>>
>> und nicht /4
>
> sollte es nicht besser
>
> sizeof(tSetup)/sizeof(Word)
>
> sein, denn die funktion heist FLASH_ProgramWord

Ich weiß nicht, ob es einen Datentyp Word gibt. Wenn ja, wäre das die 
bessere Wahl. Aber auch die vorgegebene Program Funktion selber hat 
diese Signatur:

FLASH_Status   FLASH_ProgramWord (uint32_t Address, uint32_t Data)

Also explizit einen uint32_t als 'Word'

[Ma B. (drumstick)]

>

FLASH_ProgramHalfWord( Address + i * sizeof( uint16_t ),
                           ((uint16_t*)pData)[i] );

pData wäre Data


entweder ich bin zu blöd um Abzuschreiben oder es hat noch einen 
Fehler!?

Fehlermeldung:

flash_functions.c(97): error:  #254: type name is not allowed

for(size_t i = 0; i < DataSize;i++)

flash_functions.c(97): error:  #65: expected a ";"

for(size_t i = 0; i < DataSize;i++)

flash_functions.c(97): error:  #20: identifier "i" is undefined

for(size_t i = 0; i < DataSize;i++)

hat es mit dem size_t zu tun?

[Ma B. (drumstick)]

Beschreibung von Keil zu Fehler 254:


    type name is not allowed

    This occurs when a typedef name is being used directly in an 
expression:

    typedef int footype;

    int x = footype; // reports Error: #254: type name is not allowed

    To fix this, first create an instance of that type (for example, a 
variable of the new type):

    typedef int footype;
    footype bar = 1;
    int x = bar;

Das versteh ich jetzt nicht!

[Ma B. (drumstick)]

Lösung:

void FLASH_ProgramMemory(uint32_t Address, void* Data, size_t DataSize)
{
  size_t i;
  DataSize /= sizeof(uint16_t);
  
  for(i = 0; i < DataSize;i++)
  {
    FLASH_ProgramHalfWord(Address + i * sizeof(uint16_t), ((uint16_t*) Data)[i]);
  }

}

[Ma B. (drumstick)]

Aber im Flash an der Addresse 0x0805 F800     liegen jetzt nur 4 Wöter: 
70 02 00 20

es müssten aber 7 sein!!??


danke und Gruss!


M.B.

[Karl H. (kbuchegg)]

Wie groß ist

  sizeof( Setup )

?
Das sollten eigentlich Bytes sein. Mal sehen, was dein Compiler dazu 
meint.

[Ma B. (drumstick)]

x = sizeof(Setup);

x = 4

[Ma B. (drumstick)]

x = (sizeof(tSetup) / sizeof(int));

x = 2119

[Karl H. (kbuchegg)]

M. B. schrieb:
>

> x = sizeof(Setup);
>

>
> x = 4


Dann stimmt das aber nicht mit

typedef struct  {
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
                  BOOL                cal_OK;
                  int                 MotDistCal_PulsesMax;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                  int                 ShttrueIdx[CNTSHT];
                  int                 Nmbr_of_Shttr;
                }
                tSetup;


extern tSetup     Setup;

zusammen.
Hier kann Setup unmöglich eine sizeof() von 4 haben.
Hast du da irgendwo noch einen Pointer im Gebälk?
Du musst schon drauf achten:
  Nehme ich jetzt die sizeof von einem Strukturobjekt,
  oder ist das was ich habe ein Pointer auf so ein Objekt?

[Ma B. (drumstick)]

typedef struct  {
                  float motspd_max;     // [mm/s] normal full travelling speed
                  float motspd_cal_max; // [mm/s] Reference speed value 
                  float motspd_inc;     // [mm/s] Speed added when ramping up
                  float motspd_dec;     // [mm/s] Speed added when ramping down
  
                  tMotorCurrentSample MotI_TableCW[TRAV_MAXDIST_SAMPLES];  // = 2100
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
                  BOOL                cal_OK;
                  int                 MotDistCal_PulsesMax;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                  int                 ShttrueIdx[CNTSHT];
                  int                 Nmbr_of_Shttr;
                  int                 MotDir;
                }
                tSetup;

Wurde erweitert! Aber da müsste sizeof(Setup) noch grösser sein?

[Karl H. (kbuchegg)]

M. B. schrieb:

> Wurde erweitert! Aber da müsste sizeof(Setup) noch grösser sein?

Müsste es. 4 ist vollkommen unrealistisch.

[Ma B. (drumstick)]

hmm...

im setup.h file

typedef struct  {
                  float motspd_max;     // [mm/s] normal full travelling speed
                  float motspd_cal_max; // [mm/s] Reference speed value 
                  float motspd_inc;     // [mm/s] Speed added when ramping up
                  float motspd_dec;     // [mm/s] Speed added when ramping down
  
                  tMotorCurrentSample MotI_TableCW[TRAV_MAXDIST_SAMPLES];  // = 2100
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
                  BOOL                cal_OK;
                  int                 MotDistCal_PulsesMax;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                  int                 ShttrueIdx[CNTSHT];
                  int                 Nmbr_of_Shttr;
                  int                 MotDir;
                }
                tSetup;

//**************
extern tSetup     Setup;

im setup.c

tSetup  Setup;

im flash.h

extern void set_in_Flash(tSetup *setup);
extern void FLASH_ProgramMemory(uint32_t Address, void* Data, size_t DataSize);

im flash.c file

void FLASH_ProgramMemory(uint32_t Address, void* Data, size_t DataSize)
{
  size_t i;
  DataSize /= sizeof(uint16_t);
  
  for(i = 0; i < DataSize;i++)
  {
    FLASH_ProgramHalfWord(Address + i * sizeof(uint16_t), ((uint16_t*) Data)[i]);
  }

}



void set_in_Flash(tSetup *Setup)
{
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  FLASH_ProgramMemory(flshBseAdr, &Setup, sizeof(Setup));
  FLASH_Lock();
}

Funktionsaufruf in func.c file

set_in_Flash(&Setup);

[Ralf (Gast)]

> Müsste es. 4 ist vollkommen unrealistisch.
Wieso? Wenn es compiler-spezifisch als Pointer implementiert ist, dann 
ist 4 wieder realistisch...

Ralf

[Ralf (Gast)]

Nachtrag:
Probier mal bitte

x = sizeof(struct tSetup);

bzw.

x = sizeof(struct Setup);

Nur so interessehalber...

Ralf

[Ma B. (drumstick)]

x = sizeof(struct tSetup);

x = sizeof(struct Setup);

Bei beiden die gleiche Fehlermeldung!

flash_functions.c(114): error:  #70: incomplete type is not allowed


anbei x ist ein int!

[Ma B. (drumstick)]

70

    incomplete type is not allowed

    Example:

    typedef struct {
      unsigned char size;
      char string[];
    } FOO;

    By not declaring a size for the array in the structure, the compiler 
is not able to allocate a size of the structure. Incomplete types are 
allowed in --c99 mode.

[AVerr (Gast)]

Also, erstmal eine Fehlerquelle nebenbei:
Du hast eine globale Variable namens Setup, die per extern auch an 
flash.c/.h weitergegeben wird.
Die Funktion set_in_Flash hat auch einen Parameter namens Setup.
Das ist zwar für den Compiler kein Problem, aber birgt für den Leser 
eine Fehlerquelle, die man vermeiden könnte, indem du z.B. in 
set_in_Flash das setup klein schreibst.

Und dann fällt auch auf, warum bei

void set_in_Flash(tSetup *Setup)
{
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  FLASH_ProgramMemory(flshBseAdr, &Setup, sizeof(Setup));
  FLASH_Lock();
}

als Größe von Setup 4 rauskommt ... es ist die Größe eines Pointers und 
nicht vom struct.

Besser wäre:

void set_in_Flash(tSetup *setup)
{
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(flshBseAdr);
  FLASH_ProgramMemory(flshBseAdr, &Setup, sizeof(*setup));
  FLASH_Lock();
}

[AVerr (Gast)]

Kleine korrektur:

FLASH_ProgramMemory(flshBseAdr, &setup, sizeof(*setup));

im unteren Teil

[Ma B. (drumstick)]

set_in_Flash(&Setup);

dies bleibt!?

x = sizeof(*setup);

x = 8476

[Bernhard S. (b_spitzer)]

M. B. schrieb:
> x = 8476
Scheint zu stimmen, weil:
4Byte  float motspd_max;     // [mm/s] normal full travelling speed
4Byte  float motspd_cal_max; // [mm/s] Reference speed value
4Byte  float motspd_inc;     // [mm/s] Speed added when ramping up
4Byte  float motspd_dec;     // [mm/s] Speed added when ramping down

...2100 Elemente vom Typ tMotorCurrentSample sind wohl
4200Bytes MotI_TableCW[TRAV_MAXDIST_SAMPLES];  // = 2100
4200Bytes MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
1Byte BOOL                cal_OK;
4Byte int                 MotDistCal_PulsesMax;
4Byte float               MotDistCal_pmm;
wieviele auch immer tPIDparameter       PIDpar;
4Byte int                 ShttrueIdx[CNTSHT];
4Byte int                 Nmbr_of_Shttr;
4Byte int                 MotDir;
========
8437+Größe von tPIDparameter

Ziemlich dicker Struct.

tschuessle
Bernhard

[AVerr (Gast)]

Also wenn der struct wirklich die größe hat, wird dir eine memory page 
nicht reichen, da brauchst du 5 Stück.

Ist es denn nötig, diese ganzen Informationen in den Flash auszulagern ?

[Ma B. (drumstick)]

Morgen!

typedef struct  {
                  float   iMin; // Minimum allowable integrator state
                  float   iMax; // Maximum allowable integrator state
                  float   iGain;// integral gain
                  float   pGain;// proportional gain
                  float   dGain;// derivative gain
                }
        tPIDparameter;

typedef uint16_t tMotorCurrentSample ;

...2100 Elemente vom Typ tMotorCurrentSample sind wohl

4200Bytes MotI_TableCW[TRAV_MAXDIST_SAMPLES];  // = 2100
4200Bytes MotI_TableCCW[TRAV_MAXDIST_SAMPLES];

1Byte BOOL                cal_OK;
4Byte int                 ShttrueIdx[CNTSHT];
4Byte int                 Nmbr_of_Shttr;
4Byte int                 MotDir;


So habe es auf das Minimum eingegrenzt, vorerst!


Kann ich die " Tabellen MotI_TableCW[TRAV_MAXDIST_SAMPLES]", die ja 
4,2kB gross sind auf 3 Pages verteilen?

Danke und Gruss!

M.B.

[TypeDepp (Gast)]

Ralf schrieb:
> Nachtrag:
> Probier mal bittex = sizeof(struct tSetup);bzw.x = sizeof(struct Setup);
> Nur so interessehalber...
>
> Ralf

Als Entschuldige mal, das ist ja kompletter Unsinn.
Bitte Nachlesen Stichwort "typedef"!

[Ma B. (drumstick)]

x = sizeof(tMotorCurrentSample);

x = 2

[Ma B. (drumstick)]

@ Karl Heinz Buchegger

Die Funktion

void FLASH_ProgramMemory( uint32_t Address, void* Data, size_t DataSize )

speichert in eine Page mit der Startadresse "Address", was passiert, 
wenn ich eine 4,2kB grosse Variable so speichere? Die würde ja 3 Pages 
benötigen?

Ich gebe ja die Adresse der letzten Page an!

danke und Gruss!

[AVerr (Gast)]

M. B. schrieb:
> was passiert,
> wenn ich eine 4,2kB grosse Variable so speichere?

Er speichert um genau zu sein ab der Adresse, die du ihm übergibst.
D.h. wenn du bei der drittletzten Page anfängst, wird das auch auf die 
letzten 3 pages verteilt.
Aber dafür musst du die Funktion noch so anpassen, dass sie auch die 
letzten 3 pages löscht und nicht nur eine.