Forum: Mikrocontroller und Digitale Elektronik MSP439F149, beide UARTs verwenden;


MSP439F149, beide UARTs verwenden;
von debugger (Gast)

Lesenswert?
• ▲
▼ 
Hallo,

ich möchte bei einem MSP430F149 beide UARTS verwenden.
Testweise soll jeder UART ein Zeichen empfangen und zurückschicken.
Wenn jeweils nur ein UART verwendet wird, klappt das auch einwandfrei.
Wenn aber in einem Programm beide UARTS aktiviert werden, wird nichts 
mehr zurückgeschickt.
Hat jemand eine Idee, woran das liegen könnte ?
Beeinflussen sich die beiden UARTS eventuell gegenseitig ?

Hier der Sourcecode (wird mit dem mspgcc erfolgreich compiliert) :


#include <msp430x14x.h>
#include <signal.h>

int main(void)
  {
    WDTCTL = WDTPW + WDTHOLD; // Watchdog abschalten

    //P3SEL = 0x00;   //
    P3SEL |= 0x30;  // P3.4 und P3.5 als USART0 TXD/RXD 0x30 =  d48 = 
b00110000
    P3SEL |= 0xC0;  // P3.6 und P3.7 als USART1 TXD/RXD 0xC0 = d192 = 
b11000000

    P3DIR |= 0x10;  // Port P3.4 (TX UART0) auf Ausgang setzen, 0x10 = 
d16 = b00010000   |= Bitweise ODER-Verknüpfung
    P3DIR |= 0x40;  // Port P3.6 (TX UART1) auf Ausgang setzen, 0x40 = 
d64 = b01000000   |= Bitweise ODER-Verknüpfung

      // Modul-Enable-Register (initialisieren), TX- und RX-modul erst 
mal anschalten
    ME1 |= UTXE0 + URXE0;     // TX- und RX-modul erst mal anschalten,
    ME2 |= UTXE1 + URXE1;     // Modul-Enable-Register (initialisieren) 
:  .\msp430x14x.h:79:#define ME2_ 0x0005  /* Module Enable 2 */

    UCTL0 |= CHAR;            // Bit 4 (0..7) setzen, Übertragung mit 
8-bit langen Zeichen,
    UCTL1 |= CHAR;            // Bit 4 (0..7) setzen, Übertragung mit 
8-bit langen Zeichen,

    UTCTL0 |= SSEL0;          //  Clock Source select für UART-Clock, 
ACKL als UCLK festlegen, UCLK = ACLK
    UTCTL1 |= SSEL0;          // UCLK = ACLK

    UBR00 = 0x03;             // 0x03=9600 Baud / 0x06=4800 Baud / 
0x0D=2400 Baud  // Baud-Rate Register 0,  9600 baud aus 32.768 kHz 
erzeugen
    UBR01 = 0x03;             // 0x03=9600 Baud / 0x06=4800 Baud / 
0x0D=2400 Baud

    UBR10 = 0x00;             // Baud-Rate Register 1, siehe application 
note tabelle 2, seite 10
    UBR11 = 0x00;             // Baud-Rate Register 1, siehe application 
note tabelle 2, seite 10

      // uart calculator: http://mspgcc.sourceforge.net/baudrate.html
    UMCTL0 = 0x4A;            // Modulation Control Register, Korrektur 
der Division  0x4A=9600 Baud / 0x77=4800 Baud / 0x6D=2400 Baud
    UMCTL1 = 0x4A;            // 0x29 Modulation Control Register, 
Korrektur der Division, 0x4A=9600 Baud / 0x77=4800 Baud / 0x6D=2400 Baud

      // .\usart.h:31:#define SWRST 0x01 = d1 = b00000001
    UCTL0 &= ~SWRST;          // USART0 freigeben durch Zurücksetzen des 
Software Reset Bits
    UCTL1 &= ~SWRST;          // USART1 freigeben durch Zurücksetzen des 
Software Reset Bits

    IE1 |= (URXIE0 + UTXIE0); // Interrupts an
    IE2 |= (URXIE1 + UTXIE1); // Interrupts an    |= Bitweise 
ODER-Verknüpfung

    IFG1 &= ~UTXIFG0;         // TX-Interruptflag loeschen  (&= ~ 
bedeutet BIC)
    IFG2 &= ~UTXIFG1;         // TX-Initiales Interrupt-Flag löschen 
(Bit 5 IFG2 = USART0 transmitter ready)

    //IFG1 &= ~URXIFG0;         // RX-Interruptflag loeschen  (&= ~ 
bedeutet BIC)
    //IFG2 &= ~URXIFG1;         // RX-Initiales Interrupt-Flag löschen 
(Bit 5 IFG2 = USART0 transmitter ready)
    //IFG1 |= URXIFG0;         // RX-Interruptflag loeschen  (&= ~ 
bedeutet BIC)
    //IFG2 |= URXIFG1;         // RX-Initiales Interrupt-Flag löschen 
(Bit 5 IFG2 = USART0 transmitter ready)

    _EINT();  // Enable interrupts

    for(;;)
      {
        _BIS_SR(LPM3_bits);    // Enter LPM3 (common.h, Zeile 64), 
common.h:55:#define LPM3_bits SCG1+SCG0+CPUOFF
                               // SCG1 : System clock generator control 
bit 1, Bit 7 Statusregister (SR),
                               // SCG0 : System clock generator control 
bit 0, Bit 6 SR
                               // CPUOFF : CPU off bit, Bit 4 SR
                               // siehe SLAU049.pdf S. 3-11 und 5-4
                               // LPM3 :
                               // CPU is disabled, MCLK is disabled, 
SMCLK is disabled
                               // DCO oscillator is disabled, DCO’s 
dc-generator is disabled
                               // ACLK remains active
        //TXBUF0 = 'X';
        //TXBUF1 = 'Y';
        _NOP();                // Required only for C-spy
      }
  }
/*********************************************************************** 
****************************/

interrupt (UART1RX_VECTOR) usart1_rx(void)
  {
    char UART1_RX;

    UART1_RX = RXBUF1;
    while (!(IFG2 & UTXIFG1)); // warten, bis USART1 TX-buffer 
sendebereit
    TXBUF1 = UART1_RX;  // Echo des an UART1 empfangenen Zeichens 
(zurück über TX von UART1)
    TXBUF0 = UART1_RX;  // Über UART1 empfangenes Zeichen (auch) über 
UART0 ausgeben
    IFG2 &= ~UTXIFG1;   // Initiales Interrupt-Flag löschen (Bit 5 IFG2 
= USART0 transmitter ready)
  }
/*********************************************************************** 
****************************/

interrupt (UART0RX_VECTOR) usart0_rx(void)
  {
    char UART0_RX;

    UART0_RX = RXBUF0;
    while (!(IFG1 & UTXIFG0)); // warten, bis USART0 TX-buffer 
sendebereit
    TXBUF0 = UART0_RX;   // Echo des an UART0 empfangenen Zeichens 
(zurück über TX von UART0)
    TXBUF1 = UART0_RX;   // Über UART0 empfangenes Zeichen (auch) über 
UART1 ausgeben
    IFG1 &= ~UTXIFG0;    // Interruptflag loeschen  (&= ~ bedeutet BIC)
  }
/*********************************************************************** 
****************************/

Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
Re: MSP439F149, beide UARTs verwenden;
von test (Gast)

Lesenswert?
• ▲
▼ 
1
#include <msp430x14x.h>

2
#include <signal.h>

3
4
int main(void)

5
  {

6
    WDTCTL = WDTPW + WDTHOLD; // Watchdog abschalten

7
8
    //P3SEL = 0x00;   //

9
    P3SEL |= 0x30;  // P3.4 und P3.5 als USART0 TXD/RXD 0x30 =  d48 =

10
b00110000

11
    P3SEL |= 0xC0;  // P3.6 und P3.7 als USART1 TXD/RXD 0xC0 = d192 =

12
b11000000

13
14
    P3DIR |= 0x10;  // Port P3.4 (TX UART0) auf Ausgang setzen, 0x10 =

15
d16 = b00010000   |= Bitweise ODER-Verknüpfung

16
    P3DIR |= 0x40;  // Port P3.6 (TX UART1) auf Ausgang setzen, 0x40 =

17
d64 = b01000000   |= Bitweise ODER-Verknüpfung

18
19
      // Modul-Enable-Register (initialisieren), TX- und RX-modul erst

20
mal anschalten

21
    ME1 |= UTXE0 + URXE0;     // TX- und RX-modul erst mal anschalten,

22
    ME2 |= UTXE1 + URXE1;     // Modul-Enable-Register (initialisieren)

23
:  .\msp430x14x.h:79:#define ME2_ 0x0005  /* Module Enable 2 */

24
25
    UCTL0 |= CHAR;            // Bit 4 (0..7) setzen, Übertragung mit

26
8-bit langen Zeichen,

27
    UCTL1 |= CHAR;            // Bit 4 (0..7) setzen, Übertragung mit

28
8-bit langen Zeichen,

29
30
    UTCTL0 |= SSEL0;          //  Clock Source select für UART-Clock,

31
ACKL als UCLK festlegen, UCLK = ACLK

32
    UTCTL1 |= SSEL0;          // UCLK = ACLK

33
34
    UBR00 = 0x03;             // 0x03=9600 Baud / 0x06=4800 Baud /

35
0x0D=2400 Baud  // Baud-Rate Register 0,  9600 baud aus 32.768 kHz

36
erzeugen

37
    UBR01 = 0x03;             // 0x03=9600 Baud / 0x06=4800 Baud /

38
0x0D=2400 Baud

39
40
    UBR10 = 0x00;             // Baud-Rate Register 1, siehe application

41
note tabelle 2, seite 10

42
    UBR11 = 0x00;             // Baud-Rate Register 1, siehe application

43
note tabelle 2, seite 10

44
45
      // uart calculator: http://mspgcc.sourceforge.net/baudrate.html

46
    UMCTL0 = 0x4A;            // Modulation Control Register, Korrektur

47
der Division  0x4A=9600 Baud / 0x77=4800 Baud / 0x6D=2400 Baud

48
    UMCTL1 = 0x4A;            // 0x29 Modulation Control Register,

49
Korrektur der Division, 0x4A=9600 Baud / 0x77=4800 Baud / 0x6D=2400 Baud

50
51
      // .\usart.h:31:#define SWRST 0x01 = d1 = b00000001

52
    UCTL0 &= ~SWRST;          // USART0 freigeben durch Zurücksetzen des

53
Software Reset Bits

54
    UCTL1 &= ~SWRST;          // USART1 freigeben durch Zurücksetzen des

55
Software Reset Bits

56
57
    IE1 |= (URXIE0 + UTXIE0); // Interrupts an

58
    IE2 |= (URXIE1 + UTXIE1); // Interrupts an    |= Bitweise

59
ODER-Verknüpfung

60
61
    IFG1 &= ~UTXIFG0;         // TX-Interruptflag loeschen  (&= ~

62
bedeutet BIC)

63
    IFG2 &= ~UTXIFG1;         // TX-Initiales Interrupt-Flag löschen

64
(Bit 5 IFG2 = USART0 transmitter ready)

65
66
    //IFG1 &= ~URXIFG0;         // RX-Interruptflag loeschen  (&= ~

67
bedeutet BIC)

68
    //IFG2 &= ~URXIFG1;         // RX-Initiales Interrupt-Flag löschen

69
(Bit 5 IFG2 = USART0 transmitter ready)

70
    //IFG1 |= URXIFG0;         // RX-Interruptflag loeschen  (&= ~

71
bedeutet BIC)

72
    //IFG2 |= URXIFG1;         // RX-Initiales Interrupt-Flag löschen

73
(Bit 5 IFG2 = USART0 transmitter ready)

74
75
    _EINT();  // Enable interrupts

76
77
    for(;;)

78
      {

79
        _BIS_SR(LPM3_bits);    // Enter LPM3 (common.h, Zeile 64),

80
common.h:55:#define LPM3_bits SCG1+SCG0+CPUOFF

81
                               // SCG1 : System clock generator control

82
bit 1, Bit 7 Statusregister (SR),

83
                               // SCG0 : System clock generator control

84
bit 0, Bit 6 SR

85
                               // CPUOFF : CPU off bit, Bit 4 SR

86
                               // siehe SLAU049.pdf S. 3-11 und 5-4

87
                               // LPM3 :

88
                               // CPU is disabled, MCLK is disabled,

89
SMCLK is disabled

90
                               // DCO oscillator is disabled, DCO’s

91
dc-generator is disabled

92
                               // ACLK remains active

93
        //TXBUF0 = 'X';

94
        //TXBUF1 = 'Y';

95
        _NOP();                // Required only for C-spy

96
      }

97
  }

98
/***************************************************************************************************/

99
100
interrupt (UART1RX_VECTOR) usart1_rx(void)

101
  {

102
    char UART1_RX;

103
104
    UART1_RX = RXBUF1;

105
    while (!(IFG2 & UTXIFG1)); // warten, bis USART1 TX-buffer

106
sendebereit

107
    TXBUF1 = UART1_RX;  // Echo des an UART1 empfangenen Zeichens

108
(zurück über TX von UART1)

109
    TXBUF0 = UART1_RX;  // Über UART1 empfangenes Zeichen (auch) über

110
UART0 ausgeben

111
    IFG2 &= ~UTXIFG1;   // Initiales Interrupt-Flag löschen (Bit 5 IFG2

112
= USART0 transmitter ready)

113
  }

114
/***************************************************************************************************/

115
116
interrupt (UART0RX_VECTOR) usart0_rx(void)

117
  {

118
    char UART0_RX;

119
120
    UART0_RX = RXBUF0;

121
    while (!(IFG1 & UTXIFG0)); // warten, bis USART0 TX-buffer

122
sendebereit

123
    TXBUF0 = UART0_RX;   // Echo des an UART0 empfangenen Zeichens

124
(zurück über TX von UART0)

125
    TXBUF1 = UART0_RX;   // Über UART0 empfangenes Zeichen (auch) über

126
UART1 ausgeben

127
    IFG1 &= ~UTXIFG0;    // Interruptflag loeschen  (&= ~ bedeutet BIC)

128
  }

129
/***************************************************************************************************/


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.