(msp430)gcc Preprocessor Macro Frage

[Eduard I. (eiten)]

Hallo zusammen,

ich bin gerade dabei, mich in den msp430 einzuarbeiten. Da habe ich nun 
folgendes Problem: von verschiedener Peripherie, zum Beispiel den eUSCIs 
(Enhanced Universal Serial Communication Interface) gibt's mehrere. 
Damit ich die Funktionen nicht mehrfach schreiben muss, wie zum Beispiel

void eUSCI_A0_softreset(void) {
  UCA0CTLW0 |= UCSWRST; 
}
void eUSCI_A1_softreset(void) {
  UCA1CTLW0 |= UCSWRST; 
}

habe ich mir vorgestellt, dass man vielleicht ein Makro schreiben kann, 
dass einen Parameter annimmt, so das folgendes möglich wird:

void eUSCI_Ax_softreset(uint8_t eusci_nr) {
  UCAxCTLW0(eusci_nr) |= UCSWRST;
}

Ich habe aber nicht rausgefunden, ob und wie das möglich ist. Folgendes 
funktioniert leider nicht:

#define UCAxCTLW0(x) UCA#xCTLW0

Irgendwelche Tips?

Danke und Gruss, Edi

[Clemens L. (c_l)]

#define UCAxCTLW0(x) UCA##x##CTLW0

Und das funktioniert nur mit einer Konstanten; ein Symbol 
UCAeusci_nrCTLW0 gibt es nicht.

Aber die Register jedes Modules liegen am gleichen Offset zur 
Basisadresse.
Im Header findest du folgende Definitionen:

#define __MSP430_BASEADDRESS_USCI_A0__ 0x05C0
...
#define UCA0CTLW0_            0x05C0    /* USCI A0 Control Word Register 0 */
...
#define __MSP430_BASEADDRESS_USCI_A1__ 0x0600
...
#define UCA1CTLW0_            0x0600    /* USCI A1 Control Word Register 0 */

Also prober folgendes:

#define UCAxCTLW0_OFFSET (UCA0CTLW0_ - __MSP430_BASEADDRESS_USCI_A0__)

static const uint16_t eusci_baseaddr[2] = {
  __MSP430_BASEADDRESS_USCI_A0__,
  __MSP430_BASEADDRESS_USCI_A1__,
};

static inline uint16_t readw(uint16_t addr) {
  return *(volatile uint16_t *)addr;
}
static inline void writew(uint16_t addr, uint16_t value) {
  *(volatile uint16_t *)addr = value;
}

void eUSCI_Ax_softreset(uint8_t eusci_nr) {
  uint16_t addr = eusci_baseaddr[eusci_nr] + UCAxCTLW0_OFFSET;
  writew(addr, readw(addr) | UCSWRST);
}

[Johann L. (gjlayde)]

Falls beide Communication Interfaces gleiches Layout im Speicher haben, 
ist ein Ansatz sich eine Struct zu definieren, und über diese 
zuzugreifen:

#include <stdint.h>

typedef struct
{
    uint16_t foo1;
    uint16_t bar2;
    uint16_t ctlw0;
    uint16_t ctlw1;
    // ...
} usci_t;

#define eUSCI_A0_addr 0xbeef
#define eUSCI_A1_addr 0xbabe

#define USCI_A0 ((volatile usci_t*) eUSCI_A0_addr)
#define USCI_A1 ((volatile usci_t*) eUSCI_A1_addr)

#define UCSWRST 0x0001

void eUSCI_A_softreset (volatile usci_t* usci)
{
    usci->ctlw0 |= UCSWRST;
}

int main (void)
{
    eUSCI_A_softreset (USCI_A0);
    eUSCI_A_softreset (USCI_A1);
}

Bei dieser Lösung muss man überall volatile mit angeben.  Alternativ 
kann man das volatile ins typedef mit aufnehmen, was aber lästig sein 
kann wenn man eine non-volatile Version von ucsi_t braucht.

Und je nach Anwendung kann es besser sein, die Funktionen "static 
inline" zu machen.

[Max G. (l0wside)]

Ausschnitt aus meiner tools.h:

/* Set/clear a bit on a port */
#define POUT_SET_(PORT,BIT,VAL) { if (VAL == 0) { P ## PORT ## OUT &= (~(1 << BIT)); } else { P ## PORT ## OUT |= (1 << BIT); } }
#define POUT_SET(PORT,BIT,VAL) POUT_SET_(PORT,BIT,VAL)

Funktioniert hervorragend und sollte auch (nach Anpassung) dein Problem 
lösen.