MSP430 - serielle schnittstelle laeuft net -> TAKTPROBLEM???

[johannes (Gast)]

Moin!

Ich hab den ganzen Tag am code rumgeschraubt und an meinen
MSP430F437IPZ an die Pins XIN und XOUT nen 32 kHz oszillator
angetuetert (gehause natuerlich gegrounded..)
Ich verwende keine externen kapazitaeten weil mein MSP die auf
software-anweisung hin intern zuschaltet.
das ganze laeuft aber immer noch nicht!
Ich bin die ganze geschichte mal schrittweise durchgegangen und das
programm haengt sich imm bei der character-zuweisung (ch = 'a';)
auf.
hat irgendwer von euch ne erklaerung dafuer? initialisiere ich
ueberhaupt den takt richtig - (ich erwaehne schliesslich nur bei der
USART inititalisierung dass ich den ACLK nutzen moechte - muss ich den
eventuell schon vorher aktivieren?)?


Ich bin fuer jede hilfe dankbar!



und hier nu der code:






#include <msp430x43x.h>
#include <stdio.h>




int main(void)
{
  char ch;

  WDTCTL = WDTPW + WDTHOLD;     // Stop watchdog timer

  P2SEL |= (BIT4 + BIT5);  //UTXD0 and URXD0 = activated
  P2DIR |= 0x1A;  //P2.4, P2.3 & P2.1 = outputs

  SCFQCTL = SCFQ_M;                   // Frequency modulation disabled

  FLL_CTL0 |= XCAP14PF;                     // Configure load caps

  U0CTL |= SWRST;   // Software-Reset activated
  U0CTL |= CHAR;     //no parity; 1 stop bits; 8-bit data;
LISTEN=disabled;
                    //UART mode; Idle-line MP protocol;
//  U0TCTL = 0x18;   // UCLKI=UCLK; ACLK; UART receive start-edge
feature; data
  UTCTL0 = SSEL0;    // UCLK = ACLK
  U0BR0 = 0x03;      // 9600 Baud
  U0BR1 = 0x00;
  UMCTL0 = 0x4A;

  U0IFG &= ~URXIFG0;                    // Clear USART0 RX interrupt
flag
  U0IFG |= UTXIFG0;                    // Clear USART0 TX interrupt
flag
  U0CTL &= ~(SWRST);                    // 8-bit character - clr SWRST
bit
  U0IE |= URXIE0+UTXIE0;                // Enable USART0 RX + TX
interrupt
  //U0IE |= U0RXIE;                       // Enable USART0 RX
interrupt
  U0ME |= UTXE0+URXE0 ;                 // Enabled USART0 TXD/RXD

  _BIS_SR(LPM4_bits + GIE);    //enable maskable interrupts and enter
LPM4

/*  UTCTL0 = SSEL0;                     // UCLK = ACLK
  UBR00 = 0x03;                         // 32k/9600
  UBR10 = 0x00;                         //
  UMCTL0 = 0x4a;                        //  */


  P2OUT = 0x02;
  ch = 'a';

  while (1)
  {
    while ((U0IFG&UTXIFG0)==0);            // wait till TX buf empty
    U0TXBUF = ch;
    P2OUT |= 0x08;
  } //while

}// main



// USART 0 Receive interrupt service routine
#pragma vector=USART0RX_VECTOR
__interrupt void USART0RX (void)
{
   char temp;

   temp=U0RXBUF;
   P2OUT = 0x08;

}

[Mario (Gast)]

Hi Johannes,

ich schon wieder :-)

Wie schon im anderen Thread erwähnt, ist es immens wichtig, bei der
USART-Konfiguration die im Datenblatt erwähnte Reihenfolge
einzuhalten:

1) SWRST setzen
2) Alle USART-Register (incl. UCTL0) setzen, während SWRST = 1
3) USART-Module im MEx-Register enablen (URXEx / UTXEx)
4) SWRST zurücksetzen
5) optional: Interrupts in IEx freigeben (URXIEx / UTXIEx)

Stimmt die Reihenfolge nicht, verhält sich die USART nicht so, wie sie
soll (selbst alles schon erlebt - gibt ne lustige Fehlersuche).

Außerdem: Wenn du LPM4 setzt, wird die CPU und der MCLK abgeschalten,
d.h. das Hauptprogramm BLEIBT STEHEN und du kommst nie in deine
while(1)-Schleife rein. Lass den _BIS..-Befehl mal weg und setze nur
das GIE-Bit (müsste mit _EINT(); funktionieren).

Grüße, Mario

[thomas.o (Gast)]

hallo!

hast du dir schon mal die C-Demos von TI angesehen?
da findest du ein programm, welches ein empfangenes Zeichen
zurücksendet! Probier das mal aus. Ist aber für einen MSP430F449
geschrieben. Eventuell musst du ein bisschen ändern. Da der 449 und der
von dir verwendete 437 ein gemeinsames Datenblatt haben, glaube ich ohne
nachzusehen, dass es auch so funktionieren wird.

hier mal der code:

//******************************************************************************
//  MSP-FET430P440 Demo - USART0, 2400 UART Ultra-low Pwr Echo ISR,
32kHz ACLK
//
//  Description: Echo a received character, RX ISR used. In the
Mainloop UART0
//  is made ready to receive one character with interrupt active. The
Mainloop
//  waits in LPM3. The UART0 ISR forces the Mainloop to exit LPM3
after
//  receiving one character which echo's back the received character.
//  Baud rate divider with 32768Hz XTAL @2400 = 32768/2400 = ~13.65
(00Dh|6Bh)
//  ACLK = LFXT1 = 32768Hz, MCLK = SMCLK = default DCO = 32 x ACLK =
1048576Hz
//  //* An external watch crystal between XIN & XOUT is required for
ACLK *//  
//
//                MSP430F449
//             -----------------
//         /|\|              XIN|-
//          | |                 | 32kHz
//          --|RST          XOUT|-
//            |                 |
//            |             P2.4|----------->
//            |                 | 2400 - 8N1
//            |             P2.5|<-----------
//
//
//  M. Buccini
//  Texas Instruments Inc.
//  Feb 2005
//  Built with IAR Embedded Workbench Version: 3.21A
//*****************************************************************************
#include <msp430x44x.h>

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  FLL_CTL0 |= XCAP18PF;                     // Configure load caps
  P2SEL |= 0x30;                            // P2.4,5 = USART0 TXD/RXD
  ME1 |= UTXE0 + URXE0;                     // Enable USART0 TXD/RXD
  UCTL0 |= CHAR;                            // 8-bit character
  UTCTL0 |= SSEL0;                          // UCLK = ACLK
  UBR00 = 0x0D;                             // 32k/2400 - 13.65
  UBR10 = 0x00;
  UMCTL0 = 0x6B;                            // Modulation
  UCTL0 &= ~SWRST;                          // Initialize USART state
machine
  IE1 |= URXIE0;                            // Enable USART0 RX
interrupt

  // Mainloop
  for (;;)
  {
    _BIS_SR(LPM3_bits + GIE);               // Enter LPM3 w/interrupt
    while (!(IFG1 & UTXIFG0));              // USART0 TX buffer ready?
    TXBUF0 = RXBUF0;                        // RXBUF0 to TXBUF0
  }
}

// UART0 RX ISR will for exit from LPM3 in Mainloop
#pragma vector=UART0RX_VECTOR
__interrupt void usart0_rx (void)
{
  _BIC_SR_IRQ(LPM3_bits);                   // Clear LPM3 bits from
0(SR)
}

Hier ist es jetzt auf 2400 Bit/s eingestellt. Du solltest den Clock
dievider auf UBR00 = 0x03 setzen für 9600 Bit/s

mfg,
thomas