Probleme bei Konvertierung von IAR zu GCC

[Felix (Gast)]

Hallo,

ich habe ein Problem bei der Umsetzung eines Codes vom IAR zum GCC.

Im IAR sieht es so aus:

__regvar __no_init volatile union{
                                  uchar R_flag0;
                                  struct{
                                         uchar
                                            bFlag_Packet_Transimit:1,
                                            bFlag_Calibration_Status:1;                                            
                                        };
                                 }@ 0x0f;

Im Prinzip wird doch dort das Register R15 gelocked, bis ein 
entsprechender Funktionsaufruf stattfindet der dieses Register dann 
nutzt. Was ich aber nicht verstehe ist dass eigentlich keine Instanz 
definiert ist.

Kann mir einer erklären was diese Funktion genau macht und wie ich sie 
auf dem GGC umsetzen kann?

Vielen Dank!

[Oliver (Gast)]

Das ist keine Funktion, sondern (vermutlich) die Deklaration einer 
globalen Variable im Register 15.

Und m.E. geht so etwas mit dem gcc nicht.

Oliver

[Karl H. (kbuchegg)]

__regvar  deutet zwar auf eine 'Variable in einem Register' hin, 
allerdings ist mir nicht ganz klar, warum ausgerechnet r15 da so einen 
Sonderfall haben soll. Die Bezeichnungen der Member deuten für mich eher 
darauf hin, dass es sich hier um ein Statusregister einer externen 
Komponente handelt, die irgendwie in den Adressraum eingeblendet wird.

Wenn das so nicht zu klären ist, wird man wohl nicht umhin kommen, den 
verwendenden Code zu studieren, wobei u.U auch die ganze Hardware 
drumherum, auf die hier IMHO Bezug genommen wird, berücksichtigt werden 
muss.

Zeig doch mal etwas mehr Code drumherum. Vielleicht bringt das etwas 
mehr Licht in die Sache.

[Felix (Gast)]

Hi, danke für die schnellen Antworten!

Im restlichen Code wird nur die Variable "bFlag_Packet_Transimit" aus 
dem union verwendet. Und die wird eigentlich nur als Schleifenbedingung 
genutzt.

Siehe hier:

#if debug_Master        
            if(bFlag_Packet_Transimit)
            { 
                output_ledRed^=true;
                A71_Fifo_Write(&send[0]);
                PORTB |= (1 << 3);
                RF_Setup_transmiter(); 
                while(GPIO1_WTR){};
                
                PORTB &= ~(1 << 3);
                
                bFlag_Packet_Transimit= false;                
                send_count    = 10;
            }

Dazu der Timer Interrupt der die Variable wieder setzt:

#pragma      vector = TIMER1_COMPA_vect
__interrupt  void  Timer1_CompareA_Entry(void)
{
        if(send_count)
        {
            if((--send_count) == 0x00)
            bFlag_Packet_Transimit    = true;
        }
}

Also nur ein festes Zeitintervall fürs Daten senden über einen 
Interrupt.

[Karl H. (kbuchegg)]

OK.
Sieht für mich so aus, als ob ich mit der Annahme eines memory mapped 
Devices falsch liege.

Sieht so aus, als ob da wer auf Biegen und Brechen den Compiler dazu 
brignen will, ein paar Flags in Register zu halten.

Ich denke die vernünftigste Entsprechung ist

volatile uint8_t bFlag_Packet_Transimit;
volatile uint8_t bFlag_Calibration_Status;

und den Rest überlässt man besser dem Compiler.


Wird bFlag_Calibration_Status ähnlich verwendet?

[Felix (Gast)]

Ja,

bflag_Calibration_Status wird ähnlich verwendet.

Hab gerade noch mal in den "System Header" Dateien des IAR Projekts 
gestöbert. Die hatte ich für den GCC nicht übernommen, weil ich da 
lieber die altbekannten nutzen wollte.

>ein paar Flags in Register zu halten.
Ein paar ist gut....;-)

Da sieht es überall so aus:

     /*  declare PortB */
__io union{
             uchar   PINB;
             struct{
                     uchar  inputBbit0:1,
                            inputBbit1:1,
                            inputBbit2:1,
                            inputBbit3:1,
                            inputBbit4:1,
                            inputBbit5:1,
                            inputBbit6:1,
                            inputBbit7:1;
                    };
           } @ 0x03;
__io union{
             uchar   DDRB;
             struct{
                     uchar  ddrBbit0:1,
                            ddrBbit1:1,
                            ddrBbit2:1,
                            ddrBbit3:1,
                            ddrBbit4:1,
                            ddrBbit5:1,
                            ddrBbit6:1,
                            ddrBbit7:1;
                    };
           } @ 0x04;
__io union{
             uchar   PORTB;
             struct{
                     uchar  portBbit0:1,
                            portBbit1:1,
                            portBbit2:1,
                            portBbit3:1,
                            portBbit4:1,
                            portBbit5:1,
                            portBbit6:1,
                            portBbit7:1;
                    };
           } @ 0x05;
/****************************************/
     /*  declare PortC */
__io union{
             uchar   PINC;
             struct{
                     uchar  inputCbit0:1,
                            inputCbit1:1,
                            inputCbit2:1,
                            inputCbit3:1,
                            inputCbit4:1,
                            inputCbit5:1,
                            inputCbit6:1,
                            inputCbit7:1;
                    };
           } @ 0x06;
__io union{
             uchar   DDRC;
             struct{
                     uchar  ddrCbit0:1,
                            ddrCbit1:1,
                            ddrCbit2:1,
                            ddrCbit3:1,
                            ddrCbit4:1,
                            ddrCbit5:1,
                            ddrCbit6:1,
                            ddrCbit7:1;
                    };
           } @ 0x07;
__io union{
             uchar   PORTC;
             struct{
                     uchar  portCbit0:1,
                            portCbit1:1,
                            portCbit2:1,
                            portCbit3:1,
                            portCbit4:1,
                            portCbit5:1,
                            portCbit6:1,
                            portCbit7:1;
                    };
           } @ 0x08;
/****************************************/
     /*  declare PortD */
__io union{
             uchar   PIND;
             struct{
                     uchar  inputDbit0:1,
                            inputDbit1:1,
                            inputDbit2:1,
                            inputDbit3:1,
                            inputDbit4:1,
                            inputDbit5:1,
                            inputDbit6:1,
                            inputDbit7:1;
                    };
           } @ 0x09;
__io union{
             uchar   DDRD;
             struct{
                     uchar  ddrDbit0:1,
                            ddrDbit1:1,
                            ddrDbit2:1,
                            ddrDbit3:1,
                            ddrDbit4:1,
                            ddrDbit5:1,
                            ddrDbit6:1,
                            ddrDbit7:1;
                    };
           } @ 0x0a;
__io union{
             uchar   PORTD;
             struct{
                     uchar  portDbit0:1,
                            portDbit1:1,
                            portDbit2:1,
                            portDbit3:1,
                            portDbit4:1,
                            portDbit5:1,
                            portDbit6:1,
                            portDbit7:1;
                    };
           } @ 0x0b;

[Karl H. (kbuchegg)]

Das sieht mir nach unions aus, die einen einfacheren bitweisen Zugriff 
auf die PORT und PIN Register ermöglichen sollen.

Vom PeDa gibt es da eine schöne Technik, die zumindest in der Verwendung 
auf in etwa dasselbe hinauslaufen sollte. Leider hab ich da jetzt keinen 
Link dazu.

[Klaus (Gast)]

Wobei die zuletzt gezeigten Codeausschnitte, kein __regvar haben, und 
damit tatsächlich Memory-mapped-IO Register sind.

[Jörg W. (dl8dtl) (Moderator)]

Felix schrieb:
> Im restlichen Code wird nur die Variable "bFlag_Packet_Transimit" aus
> dem union verwendet.

Das heißt, die erzeugen damit sowas wie eine "Bit-Variable".
Möglicherweise gestatten sie (als Spracherweiterung) den Zugriff
auf den Feldnamen einer nichtinstanziierten union, solange der
Name halt im entsprechenden Namensraum eindeutig ist.  GCC bietet
eine leicht ähnliche Erweiterung an, bei der man innerhalb einer
union auf struct fields zugreifen kann, ohne dass die struct
selbst einen Namen bekommen hat:

#include <stdint.h>

union foo {
        struct {
                uint8_t bar: 7;
                uint8_t mumble: 1;
        };
        uint8_t all;
} foo;

uint8_t getit(void)
{
        if (foo.mumble)
                return foo.bar;
        else
                return 42;
}

[Felix (Gast)]

Danke für die ganzen Antworten!!!

Die beschriebene Routine von Jörg funktioniert, hab aber die ganzen 
Union Deklarationen weg gelassen und "normale" Variablen benutzt. Das 
Modul läuft weiterhin ohne Probleme, jetzt auch mit dem GCC ;-).

War für mich einfach übersichtlicher weil ich es so gewohnt bin und nen 
Vorteil durch diese Union Geschichte gab es jetzt hier nicht.

Die vereinfachte Bitweise Zugriffstechnik von PeDa würd mich aber 
interessieren. Vielleicht hat ja noch jemand den Link?


Gruß