Bit Bezeichnungen in enum eintragen?!

[Jan H. (janiiix3)]

Guten Morgen!

enum dspCr1Bits
{
  DSP_CR1_CLRSS_TO1  = 1<<0,
  DSP_CR1_CLEARSS1  = 1<<4,  
  DSP_CR1_ENVREF1    = 1<<5,
  DSP_CR1_TC1    = 1<<6,
};

Wie man laut Bild oben sieht, hat dieses Register (32 Bit, okay das kann 
man im Bild jetzt nicht erkennen, egal) [0..3] 4 Bit´s.
Dies wollte Ich nun mit "enum" niederschreiben.(die anderen Bits sollen 
folgen..)

Ist das so optimal wie Ich das vor habe?

[Mark (Gast)]

Im Prinzip kann man das so machen. enums oder defines sind typisch zum 
Definieren von Konstanten.

Aber, DSP_CR1_CLRSS_TO1 in deinem Beispiel ist wahrscheinlich falsch. 
Das umfast 4 Bits und vermutlich macht eine Definition als Bit-Maske 
oder mehrere individuelle Werte (maximal 8) mehr Sinn.

[Jan H. (janiiix3)]

Mark schrieb:
> Im Prinzip kann man das so machen. enums oder defines sind typisch
> zum
> Definieren von Konstanten.
>
> Aber, DSP_CR1_CLRSS_TO1 in deinem Beispiel ist wahrscheinlich falsch.
> Das umfast 4 Bits und vermutlich macht eine Definition als Bit-Maske
> oder mehrere individuelle Werte (maximal 8) mehr Sinn.
Wie würdest du das machen?

[Mark (Gast)]

Mehr als

>> Bit-Maske oder mehrere individuelle Werte

kann ich nicht sagen. Zu mehr müsste man die Funktion und Anwendung 
besser kennen.

[A. S. (Gast)]

struct sConfigReg
{
    uint32 CLRSS_TO1 : 4;
    uint32 ClearSS1  : 1;
    uint32 ENVREF1   : 1;
    uint32 TC1       : 3;
};

...
/* Mapping einer Variable auf das HW-Register,  */
volatile struct sConfigReg ConfigReg @ 0x800200;
/* keine Ahnung, wie es bei Dir geht */
...

    ...
    ConfigReg.CLRSS_TO1 = 3;
    ConfigReg.ClearSS1  = 0;
    ...

[Jan H. (janiiix3)]

Der Chip hat mega viele Register mit vielen unterschiedlichen Bits.

typedef struct
{
  /*
  *  DSP Control Register
  */
  uint32_t dspCRx[12];
  
  /* 
  *  DFE Control Register 
  */
  uint32_t dfeCRx[2]; 
  
  /* 
  *  DSP IRQ (Interrupt Control Mask) Register
  */
  uint32_t dspIRQx[2]; 

  /* 
  *  DSP Status Register
  */
  uint32_t dspSREGx[2]; 
  
  /*
  *  UART/SPI control register
  */
  uint32_t usREGx[3];
  
  /*
  *  DSP live event
  */
  uint32_t dspEVx[2];
  
}stpm32_t;

Kann man die Bitfelder auch auf Array´s anwenden?

[Jan H. (janiiix3)]

Achim S. schrieb:
> ...
> /* Mapping einer Variable auf das HW-Register,  */
> volatile struct sConfigReg ConfigReg @ 0x800200;
> /* keine Ahnung, wie es bei Dir geht */

> [/c]
Was genau soll das bezwecken? Was macht '@'?

[Klaus (Gast)]

Bei den PICs machen die das so:

#define NVMCON NVMCON
extern volatile uint16_t  NVMCON __attribute__((__sfr__));
__extension__ typedef struct tagNVMCONBITS {
  union {
    struct {
      uint16_t NVMOP:4;
      uint16_t :8;
      uint16_t NVMSIDL:1;
      uint16_t WRERR:1;
      uint16_t WREN:1;
      uint16_t WR:1;
    };
    struct {
      uint16_t NVMOP0:1;
      uint16_t NVMOP1:1;
      uint16_t NVMOP2:1;
      uint16_t NVMOP3:1;
    };
  };
} NVMCONBITS;
extern volatile NVMCONBITS NVMCONbits __attribute__((__sfr__));

MfG Klaus

[Jan H. (janiiix3)]

Werde es jetzt so lösen..

enum dspCr11Bits
{
  DSP_CR11_AH_UP2    = 1UL<<0,
  DSP_CR11_OFA2    = 1UL<<12,
  DSP_CR11_OFAF2    = 1UL<<22,
};

enum dspCr12Bits
{
  DSP_CR12_AH_DOWN_2  = 1UL<<0,
  DSP_CR12_OFR2    = 1UL<<12,
  DSP_CR12_OFS2    = 1UL<<22,  
};

enum dfeCR1Bits
{
  DFE_CR1_ENV1    = 1UL<<0,
  DFE_CR1_ENC1    = 1UL<<16,
  DFE_CR1_GAIN1    = 1UL<<26,
};

enum dfeCR2Bits
{
  DFE_CR2_ENV2    = 1UL<<0,
  DFE_CR2_ENC2    = 1UL<<16,
  DFE_CR2_GAIN2    = 1UL<<26,
};

enum dspIRQ1Bits
{
  DSP_IRQ1_PH1_PH2_IRQ_CR    = 1UL<<0,
  DSP_IRQ1_PH2_IRQ_CR      = 1UL<<4,
  DSP_IRQ1_PH1_IRQ_CR      = 1UL<<12,
  DSP_IRQ1_C1_IRQ_CR      = 1UL<<20,
  DSP_IRQ1_V1_IRQ_CR      = 1UL<<24,
  DSP_IRQ1_TAMPER        = 1UL<<30,
};

enum dspIRQ2Bits
{
  DSP_IRQ2_PH1_PH2_IRQ_CR    = 1UL<<0,
  DSP_IRQ2_PH2_IRQ_CR      = 1UL<<4,
  DSP_IRQ2_PH1_IRQ_CR      = 1UL<<12,
  DSP_IRQ2_C1_IRQ_CR      = 1UL<<20,
  DSP_IRQ2_V1_IRQ_CR      = 1UL<<24,
  DSP_IRQ2_TAMPER        = 1UL<<30,
};

enum dspSR1Bits
{
  DSP_SR1_PH1_PH2_STATUS    = 1UL<<0,
  DSP_SR1_PH2_IRQ_STATUS    = 1UL<<4,
  DSP_SR1_PH1_IRQ_STATUS    = 1UL<<12,
  DSP_SR1_C1_IRQ_STATUS    = 1UL<<20,
  DSP_SR1_V1_IRQ_STATUS    = 1UL<<24,
  DSP_SR1_TAMPER        = 1UL<<30,
};

enum dspSR2Bits
{
  DSP_SR2_PH1_PH2_STATUS    = 1UL<<0,
  DSP_SR2_PH2_IRQ_STATUS    = 1UL<<4,
  DSP_SR2_PH1_IRQ_STATUS    = 1UL<<12,
  DSP_SR2_C1_IRQ_STATUS    = 1UL<<20,
  DSP_SR2_V1_IRQ_STATUS    = 1UL<<24,
  DSP_SR2_TAMPER        = 1UL<<30,
};

enum usREG1
{
  US_REG1_CRC_POLYNOMINAL      = 1UL<<0,
  US_REG1_NOISE_DETECTION_ENABLE  = 1UL<<8,
  US_REG1_BREAK_ON_ERROR      = 1UL<<9,
  US_REG1_CRC_ENABLE        = 1UL<<14,
  US_REG1_LSB_FIRST        = 1UL<<15,
  US_REG1_TIME_OUT        = 1UL<<16,
};

enum usREG2
{
  US_REG2_BAUD_RATE        = 1UL<<0,
  US_REG2_FRAME_DELAY        = 1UL<<16  
};

typedef struct
{
  /*
  *  DSP Control Register
  */
  struct 
  {
    enum dspCr1Bits    bitsReg1;
    enum dspCr2Bits    bitsReg2;
    enum dspCr3Bits    bitsReg3;
    enum dspCr4Bits    bitsReg4;
    enum dspCr5Bits    bitsReg5;
    enum dspCr6Bits    bitsReg6;
    enum dspCr7Bits    bitsReg7;
    enum dspCr8Bits    bitsReg8;
    enum dspCr9Bits    bitsReg9;
    enum dspCr10Bits  bitsReg10;
    enum dspCr11Bits  bitsReg11;
    enum dspCr12Bits  bitsReg12;
    uint32_t reg[12];
  }dspControl;
  
  
  /* 
  *  DFE Control Register 
  */
  struct
  {
    enum dfeCR1Bits    bitsReg1;
    enum dfeCR2Bits    bitsReg2;
    uint32_t reg[2];
  }dfeControl;
  
  /* 
  *  DSP IRQ Register
  */
  struct  
  {
    enum dspIRQ1Bits bitsReg1;
    enum dspIRQ2Bits bitsReg2;
    uint32_t reg[2];
  }dspInterrupt;

  /* 
  *  DSP Status Register
  */
  struct  
  {
    enum dspSR1Bits  bitsReg1;
    enum dspSR2Bits  bitsReg2;    
    uint32_t reg[2];
  }dspStatus;
  
  /*
  *  UART/SPI control register
  */
  struct  
  {
    enum usREG1  bitsReg1;
    enum usREG2  bitsReg2;
    uint32_t reg[3];
  }uartSpiControl;
  
  /*
  *  DSP live event
  */
  struct  
  {
    uint32_t reg[2];
  }dspLiveEvent;
  
}stpm32_t;

[A. S. (Gast)]

Jan H. schrieb:
> Kann man die Bitfelder auch auf Array´s anwenden?

Ja.

struct sConfigReg ConfigReg[12];

 ist problemlos möglich.


Jan H. schrieb:
>> volatile struct sConfigReg ConfigReg @ 0x800200;
> Was genau soll das bezwecken? Was macht '@'?
naja, irgendwie muss der Compiler wissen, dass dieses Register an einer 
konkreten Stelle im Speicher steht. Dafür hat jeder Compiler seine 
eigene Notation.


Jan H. schrieb:
> struct
>   {
>     enum dfeCR1Bits    bitsReg1;
>     enum dfeCR2Bits    bitsReg2;
>     uint32_t reg[2];
>   }dfeControl

Bist Du sicher, dass Du in Deinem Code struct, Union und Bitfelder 
auseinander hälst? Ich fürchte, Du möchtest Das Array jeweils alternativ 
zu den enums, oder?

[Jan H. (janiiix3)]

Achim S. schrieb:
> Jan H. schrieb:
>>> volatile struct sConfigReg ConfigReg @ 0x800200;
>> Was genau soll das bezwecken? Was macht '@'?
> naja, irgendwie muss der Compiler wissen, dass dieses Register an einer
> konkreten Stelle im Speicher steht. Dafür hat jeder Compiler seine
> eigene Notation.
Ich programmiere mit Atmel Studio 7, wie mache Ich das dort?

Achim S. schrieb:
> Jan H. schrieb:
>> struct
>>   {
>>     enum dfeCR1Bits    bitsReg1;
>>     enum dfeCR2Bits    bitsReg2;
>>     uint32_t reg[2];
>>   }dfeControl
>
> Bist Du sicher, dass Du in Deinem Code struct, Union und Bitfelder
> auseinander hälst? Ich fürchte, Du möchtest Das Array jeweils alternativ
> zu den enums, oder?
Ich möchte zu dem jeweiligen Register vom Chip die Bits haben. Daher 
habe Ich in jedem struct das dafür geschriebene "enum" mit in die 
jeweilige struct mit eingeführt.

[Jan H. (janiiix3)]

Achim S. schrieb:
> Jan H. schrieb:
>> Kann man die Bitfelder auch auf Array´s anwenden?
>
> Ja.struct sConfigReg ConfigReg[12]; ist problemlos möglich.
Und wie?

[Eric B. (beric)]

Achim S. schrieb:
>

> struct sConfigReg
> {
>     uint32 CLRSS_TO1 : 4;
>     uint32 ClearSS1  : 1;
>     uint32 ENVREF1   : 1;
>     uint32 TC1       : 3;
> };
...

Und dann hoffen/wissen ob der Compiler das Bitfield CLRSS_TO1 in den 
höchsten oder niedrigsten vier Bits im Register legt.

[Jan H. (janiiix3)]

Eric B. schrieb:
> Achim S. schrieb:
>>> struct sConfigReg
>> {
>>     uint32 CLRSS_TO1 : 4;
>>     uint32 ClearSS1  : 1;
>>     uint32 ENVREF1   : 1;
>>     uint32 TC1       : 3;
>> };
> ...
> Und dann hoffen/wissen ob der Compiler das Bitfield CLRSS_TO1 in den
> höchsten oder niedrigsten vier Bits im Register legt.
Wie genau funktioniert das? Wenn ich 12 Arrayelemente habe?
Oder wird so das ganze "Array Struct" definiert? Dann hätten ja alle 12 
Arraymitglieder diese Zuordnung?

[A. S. (Gast)]

Eric B. schrieb:
> Und dann hoffen/wissen ob der Compiler das Bitfield CLRSS_TO1 in den
> höchsten oder niedrigsten vier Bits im Register legt

Nein. Das stellt man sicher, indem man
- die Anleitung des Compilers dazu liest
- es exemplarisch ausprobiert
- es per assert überwacht

Und wer bitfelder nicht mag, weil sie nicht portabel sind, lässt es. 
Wobei ich das Argument bei den Registern eines Prozessors nicht 
wirklich stichhaltig finde.

Jan H. schrieb:
> Ja.struct sConfigReg ConfigReg[12]; ist problemlos möglich.
> Und wie?
Wenn du

     struct sConfigReg ConfigReg[12];

schreibst, werden 12 Register je 32 Bit angelegt, die alle die gleiche 
Bitstruktur haben. (sofern max. 32Bit darin definiert wurden).

Du kannst dann z.B. "ConfigReg[3].CLRSS_TO1 = 4;" schreiben.

Hast Du denn jeweils n gleiche Bitfelder?

[Helmut A. (Gast)]

D

Achim S. schrieb:
> struct sConfigReg ConfigReg[12];
> schreibst, werden 12 Register je 32 Bit angelegt, die alle die gleiche
> Bitstruktur haben. (sofern max. 32Bit darin definiert wurden).
>
> Du kannst dann z.B. "ConfigReg[3].CLRSS_TO1 = 4;" schreiben.
>
> Hast Du denn jeweils n gleiche Bitfelder?
Das ist ja eben die Sache. Die Register haben alle andere Bits.
Dann klappt das so nicht oder?

[Jan H. (janiiix3)]

Helmut A. schrieb:
> D
>
> Achim S. schrieb:
>> struct sConfigReg ConfigReg[12];
>> schreibst, werden 12 Register je 32 Bit angelegt, die alle die gleiche
>> Bitstruktur haben. (sofern max. 32Bit darin definiert wurden).
>>
>> Du kannst dann z.B. "ConfigReg[3].CLRSS_TO1 = 4;" schreiben.
>>
>> Hast Du denn jeweils n gleiche Bitfelder?
> Das ist ja eben die Sache. Die Register haben alle andere Bits.
> Dann klappt das so nicht oder?

Stehst du vor dem gleichen Problem?

[Heiko L. (zer0)]

Achim S. schrieb:
> Wobei ich das Argument bei den Registern eines Prozessors nicht
> wirklich stichhaltig finde.

Naja, so ein volatiles Bitfeld kann glaube ich ganz, ganz übel nach 
hinten losgehen, was den generierten Code angeht. Wenn man einen 
uint32_t in Bits zerschnitten hat, soll der Compiler dann nur ein Byte 
davon updaten, wenn er kann oder immer alles auf einmal?

[Jan H. (janiiix3)]

Heiko L. schrieb:
> Achim S. schrieb:
>> Wobei ich das Argument bei den Registern eines Prozessors nicht
>> wirklich stichhaltig finde.
>
> Naja, so ein volatiles Bitfeld kann glaube ich ganz, ganz übel nach
> hinten losgehen, was den generierten Code angeht. Wenn man einen
> uint32_t in Bits zerschnitten hat, soll der Compiler dann nur ein Byte
> davon updaten, wenn er kann oder immer alles auf einmal?
???
Wenn man es verODERt? Was geht das verloren?
Es soll nur das Bit gesetzt werden was gerade benötigt wird.

[Heiko L. (zer0)]

struct S {
 uint32_t a : 8;
 uint32_t b : 24;
};

Man könnte z.B. auf die Idee kommen, einen Byte-Write daraus zu machen, 
wenn nur a geschrieben wird. Im Falle von Hardware-Registern kann es 
aber einen echten Unterschied machen, ob die restlichen Felder noch 
einmal mitgeschrieben werden oder nicht, bzw. können solche 1/4-Writes 
auf Register -Locations auch ganz verboten sein. Da muss man echt 
entweder seinem Compiler echt Vertrauen bzw. ihn im Griff haben oder 
Vorsichtig sein, was man mit solchen Variablen tut.

Zum Beispiel sollte

void f() {
 S s = *reg;
 s.a = 3;
 *reg = s;
}

relativ sicher sein, auch wenn man bei gcc das 
"-fstrict-volatile-bitfields" vergessen hat oder sich da mal wieder ein 
Fehler eingeschlichen hat.

[Jan H. (janiiix3)]

Da bleibe Ich lieber bei den "enum´s" das macht glaube Ich weniger 
Fehler und ist später auch deutlich übersichtlicher (für mich 
jedenfalls)..