www.mikrocontroller.net

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


Autor: debugger (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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)
  }
/*********************************************************************** 
****************************/

Autor: test (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#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)
  }
/***************************************************************************************************/

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.