UART Zeichen einlesen

Gast #3537008
Lesenswert?

Hallo,

ich benutze einen MSP430F169 und habe da ein Problem mit der UART 
Kommunikation. Wollte mit Hilfe von HTerm 0.8.1 ein Zeichen senden und 
das mit dem MSP einlesen und auswerten. Das Problem sofern ich ein 
Zeichen sende wird wird es bei HTerm wieder als Echo ausgegeben. Habe 
die Schaltung nachgemessen und da war alles okay. Trennt man die TX 
Leitung wird der RX_Interrupt ausgelöst aber keine Zeichen eingelesen. 
Liegt das Problem bei HTerm, am Quellcode oder kann es an was anderen 
liegen? Danke schonmal für die Hilfe.

Quellcode:
1
#include <msp430.h> 
2

3
/*
4
 * main.c
5
 */
6

7
int main(void)
8
{
9
   volatile unsigned int i;
10
    WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
11
    P3SEL |= 0x30;                            // P3.4,5 = USART0 TXD/RXD
12
    BCSCTL1 &= ~XT2OFF;                       // XT2on
13
    do
14
    {
15
      IFG1 &= ~OFIFG;                        // Clear OSCFault flag
16
      for (i = 0xFF; i > 0; i--);           // Time for flag to set
17
    }
18
    while ((IFG1 & OFIFG));                   // OSCFault flag still set?
19

20
    BCSCTL2 |= SELM_2 + SELS;                 // MCLK = SMCLK = XT2 (safe)
21
    ME1 |= UTXE0 + URXE0;                     // Enable USART0 TXD/RXD
22
    UCTL0 |= CHAR;                            // 8-bit character
23
    UTCTL0 |= SSEL1;                          // UCLK = SMCLK
24
    UBR00 = 0x71;                             // 6MHz 9600
25
    UBR10 = 0x02;                             // 6MHz 9600
26
    UMCTL0 = 0x00;                            // modulation
27
    UCTL0 &= ~SWRST;                          // Initialize USART state machine
28
    IE1 |= URXIE0;                            // Enable USART0 RX interrupt
29

30
    _BIS_SR(LPM0_bits + GIE);                 // Enter LPM0 w/ interrupt
31
}
32

33
#pragma vector=USART0RX_VECTOR
34
__interrupt void usart0_rx (void)
35
{
36
   //while (!(IFG1 & UTXIFG0));                // USART0 TX buffer ready?
37
   char r = RXBUF0;              // schreibt den charackter in die Variable r
38
   if (r == 't')                // Wenn das zeichen == t
39
   {
40
    /*do anything*/
41
   }
42
}
Gast #3546886
Lesenswert?

User schrieb:
> Bekommst du Echo wenn du das Kabel alleine hast ohne was
> angeschlossen?
> Wenn du dein MSP430 alleine verbunden hast ohne das er Aktiv ist
> bekommst du den auch ein Echo?

Ich bekomme erst ein Echo wenn ich das Kabel mit der Platine verbinde. 
Auf der Platine ist aber kein Durchgang zwischen RX und TX.


Georg G. schrieb:
> lokales Echo ausgeschaltet?

Ist bei H-Term standardmäßig Echo an?
Gast #3555736
Lesenswert?

Ich habe ein ähnliches Problem habe auch msp430f169 habe die schaltung 
über einen FTDI FT232RT verbundnen damit ich den richtigen Pegel habe. 
@Christian das könnte dein Problem sein.

Ich habe jetzt das Problem wenn ich ein Zeichen mit H-Term sende bekomme 
es auch zurück sende ich 2 komme ich das nicht mehr Zurück und wenn ich 
das gesendete zeichen speichern will passirt garnichts


Code ist aus Code Examples von TI
1
#include <msp430.h>
2

3
int main(void)
4
{
5
  volatile unsigned int i;
6
  P3SEL |= 0x30;                            // P3.4,5 = USART0 TXD/RXD
7
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
8

9
  BCSCTL1 &= ~XT2OFF;                       // XT2on
10

11
  do
12
  {
13
  IFG1 &= ~OFIFG;                           // Clear OSCFault flag
14
  for (i = 0xFF; i > 0; i--);               // Time for flag to set
15
  }
16
  while ((IFG1 & OFIFG));                   // OSCFault flag still set?
17

18
  BCSCTL2 |= SELM_2 + SELS;                 // MCLK = SMCLK = XT2 (safe)
19

20
  ME1 |= UTXE0 + URXE0;                     // Enable USART0 TXD/RXD
21
  UCTL0 |= CHAR;                            // 8-bit character
22
  UTCTL0 |= SSEL1;                          // UCLK = SMCLK
23
  UBR00 = 0xA0;                             // 8Mhz/19200 ~ 417
24
  UBR10 = 0x01;                             //
25
  UMCTL0 = 0x00;                            // no modulation
26
  UCTL0 &= ~SWRST;                          // Initialize USART state machine
27
  IE1 |= URXIE0;                            // Enable USART0 RX interrupt
28

29
  _BIS_SR(LPM0_bits + GIE);                 // Enter LPM0 w/ interrupt
30
}
31

32
#pragma vector=USART0RX_VECTOR
33
__interrupt void usart0_rx (void)
34
{
35
  while (!(IFG1 & UTXIFG0));                // USART0 TX buffer ready?
36
  TXBUF0 = RXBUF0;                          // RXBUF0 to TXBUF0
37
/*hier passiert nichts*/
38
   char r = RXBUF0;              // schreibt den charackter in die Variable r
39
   if (r == 't')                // Wenn das zeichen == t
40
   {
41
    /*do anything*/
42
   }
43
}

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren