Register ansprechen µC

[Dirk P. (crunso)]

Hallo Community,

ich möchte bei einem Mikrocontroller mittels einer Funktion einige 
Register ansprechen. Z.B. C1CTRL und C2CTRL. Jetzt möchte ich aber nicht 
eine funktion für C1CTRL und eine Funktion für C2CTRL schreiben, sondern 
eine mit Übergabeparameter welches Register ich ansprechen möchte.
Geht das? Wie setzt ich das zusammen das z.B. der Übergabeparameter 
nicht als "Name" gesehen wird.

Gruß Dirk

Beispiel:

bla (wert)
{
    CwertCTRL = 0x1;
}

Wert kann 1 oder 2 sein

[Manuel (Gast)]

In der Regel hast du eine Headerdatei mit defines, sprich du schreibst 
zwar den Namen als Parameter, es ist aber letztendlich in der Regel eine 
Zahl bzw. die Adresse des Registers.

[Klaus (Gast)]

Praktisch schaust Du einfach mal nach, wie Identifier wie C1CTRL 
letztlich deklariert und definiert sind.
Das kann unter Umständen über mehrere Preprozessor Makros und weitere 
C-Konstruktionen gehen. Wenn aber für den fraglichen uC der Compiler 
Ausdrücke mit C1CTRL als L-Wert akzeptiert muss am Ende gerade ein Typ 
herauskommen der als L-Wert geeignet ist.
Manchmal ist das ein wenig verwickelt, weil noch Hilfsdefinitionen von 
Makros oder Typen eine Rolle spielen können. CMSIS ist so ein Beispiel. 
Aber für nen AVR führt die Suche ziemlich schnell zum Ziel.

Der Typ ist dann auch der Parameter für die Funktion.

[(prx) A. K. (prx)]

Dirk P. schrieb:
> bla (wert)
> {
>     CwertCTRL = 0x1;
> }

Hast du die letzten Jahrzehnte verpennt? K&R Deklarationen sind seid 
einem Vierteljahrhundert veraltet.

[(prx) A. K. (prx)]

Mit einer für GCC spezifischen Erweiterung geht das u.U. auch ohne Blick 
auf das Register:

void bla(typeof C1CTRL *regPtr)
{
    *regPtr = 1;
}

und Aufruf per

    bla(&C2CTRL);

Mal vorausgesetzt, die haben beide den gleichen Typ.

[Dirk P. (crunso)]

Das verstehe ich nicht ganz.
Und wie ändere ich jetzt das je nach Übergabeparameter das C1 oder C2 
Register anspreche?

[Klaus (Gast)]

In dem Du die Funktion mit einem Parameter deklarierst, der dem Typ von 
C1CTRL entspricht. Dieser Funktion kannst Du dann "C1CTRL" als Wert 
übergeben.

Nimm an, C1CTRL sei als char * deklariert. Dann wäre die Funktion:

funktion (registertyp x) {

  x = 7;
}

[Dirk P. (crunso)]

Ahhh danke :)

[Clemens L. (c_l)]

Üblicherweise sind solche Registersymbole als "volatile" definiert, und 
benutzen irgendeine Compiler-spezifische Magie, um sie an eine feste 
Adresse zu legen:

volatile uint16_t C1CTRL __an_fester_adresse__(0x1234);

Für deinen Zeiger brauchst du die Adresse nicht, aber das "volatile" 
(oder was dort halt benutzt wird):

void funktion(volatile uint16_t *reg)
{
    *reg = 0x1;
}

    ...
    funktion(&C1CTRL);

[Karl H. (kbuchegg)]

Dirk P. schrieb:

>
> bla (wert)
> {
>     CwertCTRL = 0x1;
> }
>
> Wert kann 1 oder 2 sein


Und was gefällt dir jetzt an

void bla( uint8_t wert )
{
  if( wert == 1 )
    C1CTRL = 0x1;
  else if( wert == 2 )
    C2CTRL = 0x1;
}

nicht?

Nein. Du kannst nicht einen Variablennamen zur Laufzeit zusammen setzen 
lassen. Wenn das Programm läuft, existierten Variablennamen nicht mehr.

Normalerweise ist der Versuch so etwas machen zu wollen, ein starker 
Hinweis darauf, dass man eigentlich ein Array einsetzen will

registerPointerDatentyp Output[] = { &C1CTRL, &C2CTRL };

void bla( uint8_t wert )
{
  Output[wert-1] = 0x1;
}

[(prx) A. K. (prx)]

Dirk P. schrieb:
> Und wie ändere ich jetzt das je nach Übergabeparameter das C1 oder C2
> Register anspreche?

bla(&C1CTRL);
bla(&C2CTRL);

Je nach µC gibt es in den Headern statt vieler Einzelregister (z.B. AVR) 
oft Strukturen für die I/O-Module (z.B: ARM). Dann geht das z.B. so

void initUART(UART_REG_BLOCK *ptr)
{
   ptr->CTRL1  = ...;
   ptr->STATUS = ...;
}

und ruft das so auf
   initUART(&UART1);
   initUART(&UART2);

[(prx) A. K. (prx)]

Karl H. schrieb:
> Normalerweise ist der Versuch so etwas machen zu wollen, ein starker
> Hinweis darauf, dass man eigentlich ein Array einsetzen will

Aber dann bitte so oder ähnlich:

void bla( uint8_t wert )
{
  if (wert >= 1 && wert <= 2)
    Output[wert-1] = 0x1;
}

Inlined ist das auch nicht schlechter.

[(prx) A. K. (prx)]

Klaus schrieb:
> Nimm an, C1CTRL sei als char * deklariert.

Hast du schon mal ein µC-Register gesehen, das als Pointer deklariert 
wurde?

> Dann wäre die Funktion:
> funktion (registertyp x) {
>   x = 7;
> }

Also so?
  funktion (char *x) { x = 7; }
Das wär erstens ein Fehler und zweitens einfach nur nix.

[Bernd K. (prof7bit)]

Clemens L. schrieb:
> Üblicherweise sind solche Registersymbole als "volatile" definiert, und
> benutzen irgendeine Compiler-spezifische Magie, um sie an eine feste
> Adresse zu legen

Nein, keine Magie sondern ganz normales C.