CCS/MSP430F5529: send and receive chars via UART implementing interrupts

Hi Enzo,

Let me see if I can pull together a simple example of using TX and RX interrupts.

Thanks for your answer Dennis. I finally managed to figure it out. For any interested, I'll post the code below. 

#include <msp430.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>



// Have a look at both the .h and the .c file, there is code missing.
#include "USART_implement_me.h"



char *RBrx = NULL;
char *RBtx = NULL;

char recibido;
char envio;

volatile unsigned int time;
int delay = 10000; //100 ms.

/* The main function */
int main(void){

    WDTCTL = WDTPW + WDTHOLD;         // Detener WDT
    // You already lerned how to configure that button, remember?

    // Initialise the serial communication interface. Note that this now also sets up the interrupts!
    /* struct USART_configuration config_57600_8N1 = {57600, 8, 0, 1}; */ // You can use it

    struct USART_configuration config_57600_8N1 = {57600, 8, 0, 1};
    USART_Init(config_57600_8N1);

    P1DIR |= BIT0;                            // Set P1.0 to output direction
    P1OUT &= ~BIT0;

    P1REN |= BIT1;                            // Resistencia activa en P1.1 (S2)
    P1OUT |= BIT1;                            // Configurada como pull-up
    P1IES |= BIT1;                            // Interrupcion por flanco de bajada
//  P1IES &= ~BIT1;                         // P1.1 Lo/Hi edge
    P1IFG &= ~BIT1;                           // Baja flag de interrupcion de P1.1
    P1IE |= BIT1;                             // Habilita la interrupcion de P1.1


    __bis_SR_register(GIE);


    // Print a welcome message
    USART_Transmit_String("Please send some characters from your terminal.\r\n");


    while(1)
    {
        // Your program will only ask *if* a string was received. If yes, it will display this string.
        // If not, it will just skip and do other stuff until it is time to ask again.
        // Here you could do all kinds of other cool things. Remember, the step above
        // will be skipped in most iterations, so you have plenty of processing time here....
    }
}



// The initialisation function. Call it once from your main() program before
// issuing any USART commands with the functions below!

uint8_t USART_Init(struct USART_configuration config){


//           // SMCLK = 12MHz
//           UCSCTL3 |= SELREF_2;                      // Set DCO FLL reference = REFO
//           UCSCTL4 |= SELA_2;                        // Set ACLK = REFO

           __bis_SR_register(SCG0);                  // Disable the FLL control loop
           UCSCTL0 = 0x0000;                         // Set lowest possible DCOx, MODx
           UCSCTL1 = DCORSEL_5;                      // Select DCO range 24MHz operation
           UCSCTL2 = FLLD_1 + 374;                   // Set DCO Multiplier for 12MHz
                                                      // (N + 1) * FLLRef = Fdco
                                                      // (374 + 1) * 32768 = 12MHz
                                                      // Set FLL Div = fDCOCLK/2
           __bic_SR_register(SCG0);                  // Enable the FLL control loop

           // Worst-case settling time for the DCO when the DCO range bits have been
           // changed is n x 32 x 32 x f_MCLK / f_FLL_reference. See UCS chapter in 5xx
           // UG for optimization.
           // 32 x 32 x 12 MHz / 32,768 Hz = 375000 = MCLK cycles for DCO to settle
           __delay_cycles(375000);


           P4SEL = BIT5 + BIT4;              // P4.5,4 = USCI_A1 TXD/RXD
           UCA1CTL1 |= UCSWRST;              // **Put state machine in reset**
           UCA1CTL1 |= UCSSEL_2;             // CLK = SMCLK

           UCA1BR1 = 0x00;
           switch (config.baudrate) {
                       case 9600:
                           UCA1BR0 = 226;                   // 12MHz/9600=1250 (see User's Guide)
                           UCA1BR1 = 4;
                           UCA1MCTL = UCBRS_0 + UCBRF_0;    // Modulation UCBRSx=1, UCBRFx=0
                           break;

                       case 19200:
                           UCA1BR0 = 113;                   // 12MHz/19200=625 (see User's Guide)
                           UCA1BR1 = 2;
                           UCA1MCTL = UCBRS_0 + UCBRF_0;    // Modulation UCBRSx=0, UCBRFx=0
                           break;

                       case 38400:
                           UCA1BR0 = 56;                   // 12MHz/38400=312.4 (see User's Guide)
                           UCA1BR1 = 1;
                           UCA1MCTL = UCBRS_4 + UCBRF_0;    // Modulation UCBRSx=0, UCBRFx=0
                           break;

                       case 57600:
                           UCA1BR0 = 208;                   // 12MHz/57600=208.2 (see User's Guide)
                           UCA1MCTL = UCBRS_2 + UCBRF_0;    // Modulation UCBRSx=3, UCBRFx=0
                           break;

                       default:
                           UCA1BR0 = 208;                   // 12MHz/57600=208.2 (see User's Guide)
                           UCA1MCTL = UCBRS_2 + UCBRF_0;    // Modulation UCBRSx=3, UCBRFx=0
                           break;
                   }

                   switch (config.parity) {
                       case 1:
                           UCA1CTL0 |= UCPEN;
                           UCA1CTL0 |= UCPAR;
                           break;
                       case 2:
                           UCA1CTL0 |= UCPEN;
                           UCA1CTL0 &= ~UCPAR;
                           break;
                       default:
                           UCA1CTL0 &= ~UCPEN;
                           break;
                   }

                   if (config.databits== 7) {
                       UCA1CTL0 |= UC7BIT;
                   }
                   else {
                       UCA1CTL0 &= ~UC7BIT;
                   }

                   if (config.stopbits== 1) {
                       UCA1CTL0 &= ~UCSPB;
                   }
                   else {
                       UCA1CTL0 |= UCSPB;
                   }

                   UCA1CTL1 &= ~UCSWRST;                  // **Initialize USCI state machine**
                   UCA1IE |= UCRXIE;                      // Enable USCI_A1 RX interrupt
}


// Transmits a given string
void USART_Transmit_String(char* str)
{
    while(*str !=0x00){
             while(UCA1STAT&UCBUSY);
             UCA1TXBUF = *str;
             str++;
         }
}


void rotleftmem(char *p, size_t len, size_t lshift){

    unsigned char *d;
    size_t start;
    size_t dx, sx;
    size_t todo;
    unsigned char x;

    if (!len)
        return;
    lshift %= len;
    if (!lshift)
        return;

    d = p;
    todo = len;
    for (start = 0; todo; start++) {
        x = d[start];
        dx = start;
        while (1) {
            todo--;
            sx = dx + lshift;
            if (sx >= len || sx < dx /*overflow*/)
                sx -= len;
            if (sx == start) {
                d[dx] = x;
                break;
            }
            d[dx] = d[sx];
            dx = sx;
        }
    }
}




//build for strings ending with \n.
void RingBuffRX(char *string, char caracter){

    //Caso 1: No supero el tamaño de buffer.
    if (i < BufferSizeRX){

        if(caracter == '\n'){
            string[i] = '\0';
        }
        else if(caracter != '\n'){
            string[i] = caracter;
        }
        i++;
    }


    //Caso 2: Se supera el buffer.
    else if (i >= BufferSizeRX){

        if (j < BufferSizeRX){
            if (caracter != '\n'){
                string[j] = caracter;
            }
            else if(caracter == '\n'){
                *(string+BufferSizeRX) = '\0';
                rotleftmem(string, BufferSizeRX, j);
            }
            j++;

            if (j == BufferSizeRX){
                j = 0;
            }
        }
    }
}

// Get char from string
char USART_GetChar(char *string){

    char caracter;

    if (i < BufferSizeTX){
        caracter = string[i];
        }

    else if (i == BufferSizeTX){
        caracter = '\0';
    }
    i++;

    return caracter;
}


void RingBuffTX(char *rxbuf,char *txbuf){

    if (BufferSizeRX > BufferSizeTX){
        rotleftmem(rxbuf, BufferSizeRX, BufferSizeRX-BufferSizeTX);
    }
    memcpy(*txbuf, *rxbuf, BufferSizeTX+1);
}


void __attribute__((interrupt(USCI_A1_VECTOR))) USCI_A1_ISR(void) {
      switch(__even_in_range(UCA1IV,4)) {
      case 0:break;                                        // Vector 0 - no interrupt
      case 2:                                              // Vector 2 - RXIFG

          recibido = UCA1RXBUF;
          RingBuffRX(*RBrx,recibido);

          if (recibido == '\n'){
                USART_Transmit_String("Se recibio en el microc: \n\r");
                USART_Transmit_String(*RBrx);
                USART_Transmit_String("\n\r");

               //Limpiamos los indices tras el envío.
               i = 0, j = 0;

               UCA1IE |= UCTXIE;
          }

        break;
      case 4:                                             // Vector 4 - TXIFG

          USART_Transmit_String("Se envio a la terminal: \n\r");

          RingBuffTX(*RBrx, *RBtx);
          char enviar = USART_GetChar(*RBtx);
          while (enviar != '\0'){
              while(UCA1STAT&UCBUSY);
              UCA1TXBUF = enviar;
              enviar = USART_GetChar(*RBtx);
          }

          while(UCA1STAT&UCBUSY);
          UCA1TXBUF = '\r';
          UCA1TXBUF = '\n';

          //Limpiamos los indices y el buffer tras el envío.
          i = 0, j = 0;
          memset(*RBrx,0, sizeof RBrx);
          memset(*RBtx,0, sizeof RBtx);

        UCA1IE &= ~UCTXIE;
        break;
      default: break;
      }
}


// Add a ISR for a button here!
#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void){

    switch( __even_in_range( P1IV, P1IV_P1IFG7 )) {
    case P1IV_P1IFG1: // Pin 1 (button 2)

        if( !(P1IN & 0x02)){
            USART_Transmit_String("The button was pushed.\r\n");
            for(time = delay; time>0; time--);
            while(!(P1IN & 0x02));
            if((P1IN & 0x02)){
            USART_Transmit_String("The button was released.\r\n");
            }
        }
        break;
    default:   _never_executed();

    }

}