Servus,

probiere einen MSP430F1611 mit dem USART1 Modul mit dem PC über die
RS232 zu verbinden. Habe auch die Threads hier darüber gelesen, doch
irgendwo stehe ich an ?!?

#include <msp430x16x.h>

unsigned char answer1[] = "Buchstabe ";
unsigned char answer2[] = " gedrueckt\r\n";

char i, j;

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;             // watchdog aus
  
  P3OUT  =  0x00;                 //! - Clear Port
  P3DIR |=  0x7b;                 //! - P3.2,7 = input; rest = output
  P3SEL |=  0xce;                 //! - P3.0,4,5 = I/O function; rest = SPI & UART
  
  P6OUT  =  0x00;                 //! - Clear Port
  P6DIR |=  0xe0;                 //! - P6.5,6,7 = output; rest = input
  P6SEL |=  0x1f;                 //! - P6.5,6,7 = I/O function; rest = ADC 


  ME2 |= UTXE1 + URXE1;                 // TX- und RX-modul erst mal anschalten
  UCTL1 |= CHAR;                        // 8 data bits, 1 stop bit, no parity (8N1)
  UTCTL1|= SSEL0;                      // Clock source = ACLK
  UBR01  = 0x0d;                       // 32kHz/2400 = 13.6
  UBR11  = 0x00;                       //
  UMCTL1 = 0x6b;                       // Modulation
  UCTL1 &= ~SWRST;                      // USART freigeben
  IE2 |= URXIE1 + UTXIE1;               // TX- und RX-interrupts anschalten
  
  
  IFG2 &= ~UTXIFG1;                     // initales interrupt-flag loeschen
    __bis_SR_register(GIE);         //! - general interrupt enable
  
  while(1) {
  while (!(IFG1 & UTXIFG0));   // USART0 TX buffer ready?
   TXBUF0 = 'X';

} 
//  _BIS_SR(LPM3_bits + GIE);             // ab in den LPM3 mit interrupts ...
  

}

#pragma vector=UART1TX_VECTOR
__interrupt void usart1_tx (void)
{
  if (i < sizeof answer1-1)             // string schon zu ende?
    TXBUF1 = answer1[i++];              // string ausgeben
  else if (i == sizeof answer1-1)       // wenn erster string zu ende ...
    {
      TXBUF1 = RXBUF1;                  // ... dann den getippten buchstaben ausgeben
      i++;
    }
  else if (j < sizeof answer2-1)        // wenn auch der ausgegeben ist ...
    TXBUF1 = answer2[j++];              // ... dann den zweiten string ausgeben
}

#pragma vector=UART1RX_VECTOR
__interrupt void usart1_rx (void)
{
  i = 0;
  j = 0;
  TXBUF1 = answer1[i++];                // ersten buchstaben von answer1 ausgeben
}

Wenn ich debugge habe ich nichts erreicht, darum habe ich die Zeile mit
while(1) eingebaut um zu sehen ob der Buffer jemals ready ist, scheint
aber nicht der Fall zu sein ?!?

Der gepostete Code ist mit Sicherheit nicht der von Dir verwendete Code,
der nämlich lässt sich noch nicht einmal übersetzen.

Es fehlt eine schließende geschweifte Klammer, die die
while(1)-Statement in main() abschließt.

Außerdem verwendest Du diversen Pofel, der im Code weder definiert noch
deklariert ist.

Sorry, haben meinen deutlich längeren Code beim rumkopieren ändern
wollen, was scheinbar eine dumme Idee war. Habe in nun im Programm
geändert und oben nochmals gepostet....

Also bin für jeden Hinweis seeehr dankbar!

Und was willst Du mit:

while (!(IFG1 & UTXIFG0));   // USART0 TX buffer ready?
TXBUF0 = 'X';

Überall sonst initialisierst und verwendest Du USART1 ?!

> while (!(IFG1 & UTXIFG0));   // USART0 TX buffer ready?
Wieso UART0 ready wenn du UART1 verwenden willst? :)

> TXBUF0 = 'X';
Hier genauso, du willst auf UART1 senden, schiebst die Daten aber auf
UART0.

Richtig.... da verwende ich noch den falschen UART...

  while(1) {
  while (!(IFG2 & UTXIFG1));   // USART0 TX buffer ready?
   TXBUF1 = 'X';

} 

Aber leider bringt es keine Besserung....

Er sendet nicht, oder sendet er aber du bekommst nichts?

ich debugge mit IAR und er bleibt bei

while (!(IFG2 & UTXIFG1));  

 stehen....

Das hatten wir doch erst vor ein paar Tagen...

Wenn Du Sample-Code von TI verwendest, dann lies auch mal die
Beschreibung dazu durch!
Mit

  UTCTL1|= SSEL0;                      // Clock source = ACLK
  UBR01  = 0x0d;                       // 32kHz/2400 = 13.6
  UBR11  = 0x00;                       //
  UMCTL1 = 0x6b;                       // Modulation

brauchst Du zwingerdermaßen einen 32kHz Uhrenquarz an LFXT1!
Ich könnte wetten, Du verwendest den internen DCO, dann ist die USART
natürlich tot!

ZwiscEin 32.768KHz Quarz ist angeschlossen!!!!!

>ZwiscEin 32.768KHz Quarz ist angeschlossen!!!!!
Gut :-)
Wo ist er angeschlossen und läuft er auch (Oszi zur Hand)?

>ich debugge mit IAR und er bleibt bei
>while (!(IFG2 & UTXIFG1));
>stehen....
Ich glaube, er bleibt nur "scheinbar" stehen, Du hast schließlich den
TX-Interrupt freigegeben, d.h. sobald UTXIFG1==1 wird, wird die ISR
aufgerufen.

Laß die IRQ's zum testen erst mal deaktiviert!

1. Leider kein Oszi zur Hand :-(


2. Hmm ja kann die Interrupts schon einmal abschalten, aber
grundsätzlich wäre  das ja egal denn dann würde mein Breakpoint in der
Intrsubroutine doch auslösen oder?

Nach dem Motto "Ein reboot tut immer gut" läuft das Programm nun ohne
meckern, den Part:

  while(1) {
  while (!(IFG1 & UTXIFG0));   // USART0 TX buffer ready?
   TXBUF0 = 'X';

} 

habe ich weggelassen und was ich im Hyperterminal sende wird
zurückgegeben...

was der Fehler bisher war weis ich leider nicht :-/


Hat jemand übrigens ein Terminal-programm zu empfehlen?

> Hat jemand übrigens ein Terminal-programm zu empfehlen?
Für einfache Sachen verwende ich OC-Console

Putty ist ganz okay.

Hallo, ich würde auch gerne die USART1 hernehmen.
Allerdings bin ich absoluter Neuling in sachen C und MSP430.
Durch des hin und hergestopsel weis ich nu nich was richtig ist.
Kann veileicht einer nochmal den kompletten funktionierenden c-code
Posten?
Wär super. :-)

Schau doch mal hier:
http://focus.ti.com/mcu/docs/mcuflashtools.tsp?sec...
da stehn die Beispiel-Codes auch für USART1.

Bei mathar gibt's auch schöne Beispiele:
http://www.mathar.com/msp_usart1.html