CCS/MSP430I2041: UART occasionally gives weird data inside the terminal

This kind of thing usually suggests a clock which is running right at the borderline. (Of course, it could also be a software bug which occasionally walks on a buffer.)

UARTs are typically more forgiving at lower speeds. Does this go away if you slow the link down?

I was using a baud rate of 38400 before, but lowering it to 9600 did not solve the issue. 

What is strange is that it is *only* the decimal point.

Have you tried looking at the byte you received to see if there is any pattern to it?

You could also use a logic analyzer to see just what is in the serial stream to see if it is on the receiving or transmitting side.

Yes. I agree with Keith that if you can use logic analyzer to see if you are getting the correct data on the serial stream.

Thanks,

Yiding

Using a logic analyzer I have noticed that the issue is on the transmitting side. I have added an array (Teststring) to the code wich follows the value of the data at the index where the decimal point is supposed to be. I have noticed that the value changes after the 'while (UCA0STATW&UCBUSY); // Wait until data has been send' line.

void UART_Send(char Data[])
{
    Teststring[0] = Data[1];
	while (Data[u] != '\0') // '\0' (null) character means end of data
    {
    	if(u == 0)
    		Teststring[1] = Data[1];
		if(u == 1)
    		Teststring[5] = Data[u];
		UCA0TXBUF = Data[u];
    	if(u == 0)
    		Teststring[2] = Data[1];
		if(Data[1] != 0x2E && u == 1)
    		__no_operation();
        while (UCA0STATW&UCBUSY); // Wait until data has been send
    	if(u == 0)
    		Teststring[3] = Data[1];
        u++;
    	if(u == 1)
    		Teststring[4] = Data[1];
    }
    UCA0TXBUF = ';';
    while (UCA0STATW&UCBUSY); // Wait until data has been send
    UCA0TXBUF = 0x20; // Space (SP)
    u = 0;
}

Are all the globals (especially u!) volatile?

I did not define them as volatile variables.

Update: after disabling the interrupts before sending a string, the occurance of the weird characters has significanty decreased, from once every 30 lines to once every 630 lines (on average). 

From the first response:

"(Of course, it could also be a software bug which occasionally walks on a buffer.)"