STM32 GCC unknown typename

#3691584
Lesenswert?

Hey Leute,

ich programmiere auf dem STM32F429 Bitfelder und Unions um meine 
CAN-Daten vernünftig in einen CAN-Frame zu packen. Habe bisher immer nur 
mit MinGW compiled und die exe im Kommandofenster von Windows ausgeführt 
um mir die Daten anzeigen zu lassen. Jetzt habe ich das Ganze in mein 
STM Projekt in CooCox kopiert und bekomme folgenden Fehler
1
 [cc] C:\Users\Willy\Documents\CURBe\Beispielprogramme Willy\STM_CAN_Interrupts\main.c:183:23: error: unknown type name 'PEBMessages'
2
 [cc]  void CAN_BitFieldInit(PEBMessages *Msg)
3
 [cc]                        ^

für diesen Code (Ausschnitt):
1
union PEBMessages
2
  {
3
    struct BF_SCH_CANHS_R_02  SCH_CANHS_R_02;
4
    struct BF_SCH_CANHS_R_03  SCH_CANHS_R_03;
5
    struct BF_SCH_CANHS_R_04  SCH_CANHS_R_04;
6
    struct BF_SCH_CANHS_R_07  SCH_CANHS_R_07;
7
    struct BF_SCH_CANHS_R_13  SCH_CANHS_R_13;
8
    struct BF_PEB_CANHS_R_01  PEB_CANHS_R_01;
9
    struct BF_PEB_CANHS_R_02  PEB_CANHS_R_02;
10
    struct BF_PEB_CANHS_R_03  PEB_CANHS_R_03;
11
    struct BF_PEB_CANHS_R_04  PEB_CANHS_R_04;
12
    struct BF_PEB_CANHS_R_05  PEB_CANHS_R_05;
13
    struct BF_LBC_CANHS_R_01  LBC_CANHS_R_01;
14
    struct BF_LBC_CANHS_R_03  LBC_CANHS_R_03;
15
    uint8_t           Bytes[8];
16
  };
17

18
void CAN_BitFieldInit(PEBMessages *Msg)
19
{
20
  uint8_t MsgSize = sizeof(PEBMessages);
21

22
  for (int i = 0; i < MsgSize; ++i)
23
  {
24
    Msg->Bytes[i] = 0;
25
  }
26
}

Das Problem scheint zu sein, dass er PEBMessages in der Funktion 
CAN_BitFieldInit nicht erkennt.

Habt Ihr eine Idee woran das liegen könnte?

Viele Grüße
Willy
Gast #3691596
Lesenswert?

Willy M. schrieb:
> sizeof(PEBMessages);
Es muss "sizeof(union PEBMessages)" sein in C. Nur in C++ kann man das 
"union" an der Stelle weglassen.

Willy M. schrieb:
> struct BF_SCH_CANHS_R_02  SCH_CANHS_R_02;
>     struct BF_SCH_CANHS_R_03  SCH_CANHS_R_03;
>     struct BF_SCH_CANHS_R_04  SCH_CANHS_R_04;
>     struct BF_SCH_CANHS_R_07  SCH_CANHS_R_07;
>     struct BF_SCH_CANHS_R_13  SCH_CANHS_R_13;
>     struct BF_PEB_CANHS_R_01  PEB_CANHS_R_01;
>     struct BF_PEB_CANHS_R_02  PEB_CANHS_R_02;
>     struct BF_PEB_CANHS_R_03  PEB_CANHS_R_03;
>     struct BF_PEB_CANHS_R_04  PEB_CANHS_R_04;
>     struct BF_PEB_CANHS_R_05  PEB_CANHS_R_05;
>     struct BF_LBC_CANHS_R_01  LBC_CANHS_R_01;
>     struct BF_LBC_CANHS_R_03  LBC_CANHS_R_03;
Was zum.... ist das?!?! Und das ist wohl kaum 8 Bytes groß?!
#3691763
Lesenswert?

Hi Willy,

ich kann dir leider zu deinem Problem nichts schreiben
habe aber deinen anderen Thread zu diesem Thema gelesen
und hier meine Frage :

warum machst du das ganze so kompliziert und compilier speziefisch ?

fülle deine Daten doch einfach in ein standard Array
und lass eine Funktion das zurechtkopieren in
das CAN-Byte-Format übernehmen

für die Rückwandlung brauchst du dann noch eine zweite Funktion

aber die zwei Funktionen sind schnell geschrieben
und das ganze wäre portabel und "lesbar"

nur so als TIP...ich will dich von deinem "union-Modell"
nicht abbringen :-)

Gruss Uwe
#3691959
Lesenswert?

Hallo,

danke für Eure Antworten :) Also manchmal sieht man wirklich den Wald 
vor lauter Bäumen nicht... Ich wäre nie drauf, dass ich das union in 
sizeof vergessen habe. Ich habe kurzerhand mit typedef einen neuen 
Datentyp "erstell". Damit hat er dann auch nicht mehr gemeckert :)

@Uwe:

Das mit den Funktionen stimmt vermutlich. Das ganze ist für einen 80kW 
Umrichter gedacht. Die CAN-Bytes werden leider im Motorola Format, also 
Big-Endian verschickt. Hier vielleicht mal ein Ausschnit so eines 
Bitfeldes.
1
struct BF_SCH_CANHS_R_02
2
     {
3
       uint64_t BatteryVoltage      : 8;
4
       uint64_t : 24;
5
       uint64_t DCDCActivation      : 2;
6
       uint64_t : 14;
7
       uint64_t DCDCVoltageRegulation  : 7;
8
       uint64_t WakeUpType        : 1;
9
       uint64_t SCH_WakeUpSleepCommand  : 2;
10
       uint64_t APCStatus        : 2;
11
       uint64_t ETS_SleepMode      : 2;
12
       uint64_t             : 2;
13
     };
14

15
struct BF_PEB_CANHS_R_03
16
     {
17
       uint64_t               : 1;
18
       uint64_t DCDCTemp           : 7;
19
       uint64_t               : 2;
20
       uint64_t PEBInterlockState      : 2;
21
       uint64_t ElecMachineWorkingMode    : 2;
22
       uint64_t VerlogStatus        : 2;
23
       uint64_t ElecMachineSpeedCRC    : 8;
24
       uint64_t               : 2;
25
       uint64_t PEB_CANHS_R_03_Port1    : 1;
26
       uint64_t DCDCDefault        : 3;
27
       uint64_t               : 2;
28
       uint64_t ElecMachineSpeedClock    : 4;
29
       uint64_t ElecMachineSpeed       : 12;
30
       uint64_t ElecMachineMaxGenTorque  : 8;
31
       uint64_t ElecMachineMaxMotorTorque  : 8;
32
     };

Auslesen tue ich das ganze rückwärts, d.h. das letzte Byte der union
wird in das erste Byte der CAN-Nachricht geschrieben, das vorletzte in 
das zweite, usw.

Ich wüsste nicht, wie ich das einfach in eine Funktion schreibe, die das 
für ca. 15 Nachrichten immer entsprechnend verrückt und mir die Daten 
zurechtbastelt. Dafür bin ich nicht Programmierer genug ;)
Gast #3693285
Lesenswert?

Rufus Τ. Firefly schrieb:
> Markus F. schrieb:
>> Sieht aber gar nicht so aus ...
>
> Da jede der einzelnen Strukturen (struct BF_irgendwas) eines sein
> dürfte, ist dieser Teil des Ansatzes schon in Ordnung.
Nur dass ein struct immer ein Vielfaches von Bytes und immer mindestens 
1 Byte groß ist, und nicht 13bits oder so groß sein kann. Dadurch ist 
die Sammlung an structs immer mindestens 12 Bytes groß, aber wird per 
Union auf 8 Bytes gemappt. Das klappt also nicht...
Persönliche Seite #3693849
Lesenswert?

Dr. Sommer schrieb:
> Dadurch ist die Sammlung an structs immer mindestens 12 Bytes groß

Die 12 kommt woher?
1
struct BF_PEB_CANHS_R_03
2
     {
3
       uint64_t               : 1;
4
       uint64_t DCDCTemp           : 7;
5
       uint64_t               : 2;
6
       uint64_t PEBInterlockState      : 2;
7
       uint64_t ElecMachineWorkingMode    : 2;
8
       uint64_t VerlogStatus        : 2;
9
       uint64_t ElecMachineSpeedCRC    : 8;
10
       uint64_t               : 2;
11
       uint64_t PEB_CANHS_R_03_Port1    : 1;
12
       uint64_t DCDCDefault        : 3;
13
       uint64_t               : 2;
14
       uint64_t ElecMachineSpeedClock    : 4;
15
       uint64_t ElecMachineSpeed       : 12;
16
       uint64_t ElecMachineMaxGenTorque  : 8;
17
       uint64_t ElecMachineMaxMotorTorque  : 8;
18
     };

ist 8 Byte groß. Wie also kommst Du auf 12?

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren