MSP430FR6989 UART TX interrupt reenable?

Sammy Lin said:

... I thought all I had to do was reenable the TX interrupts...  

You may also need to load another string into "send_buffer[]", and make "current_send" point to the beginning of that buffer.

Yes, OCY is right. If current_send still points to the end of the string where the '\0' is located, there won't be any new transmission, of course. You have to reset it:

case USCI_UART_UCTXIFG:
  if( send_buffer[current_send] != '\0' )
    UCA1TXBUF = send_buffer[current_send++];
  else
  {
    UCA1IE &= ~UCTXIE;
    current_send = 0;
  {

  break;

Dennis

"UCA1TXBUF = send_buffer[current_send++];" 

This worked. Though I'd still like to understand why. Can you explain?

Could you please upload the complete code for testing? Do you work with the MSP-EXP430FR6989 LaunchPad?

Dennis,

Here is my clumsy attempt to let CPU go to sleep until the last bit of a string left the TXD shift resister.

#include <msp430fr6989.h>

const char msg[] = "This is a test.\r\n";
const char * ptr;
volatile int bytes_in_queue;

int main(void)
{
  WDTCTL = WDTPW + WDTHOLD;
  PM5CTL0 &= ~LOCKLPM5;
    
  P3SEL0 |=  0x30;                      // assign UCA1TXD and UCA1RXD pins

  P1OUT = 0;
  P1DIR = BIT0;                         // use LED to indicate TXD status

  UCA1CTLW0 |= UCSWRST;
  UCA1CTLW0 = UCSWRST|UCSSEL__SMCLK;
  UCA1BRW = 6;
  UCA1MCTLW = 0x2081;
  UCA1CTLW0 &= ~UCSWRST;

  __delay_cycles(10000L);
 
  bytes_in_queue = 0;
  ptr = msg;
  UCA1IE = UCTXIE|UCTXCPTIE; 
  
  P1OUT |= BIT0;                        // indicate begin TXD
  __bis_SR_register(CPUOFF|GIE);
  P1OUT &= ~BIT0;                       // indicate TXD complete

// ... ... ... ... ...  

  __delay_cycles(10000L);
}

#pragma vector = USCI_A1_VECTOR
__interrupt void usci_a1_isr (void)
{
  switch (__even_in_range(UCA1IV, 8))
  {
  case USCI_NONE:
    break;
  case USCI_UART_UCRXIFG:
    break;
  case USCI_UART_UCTXIFG:
    if (*ptr)
    {
      UCA1TXBUF_L = *ptr++;
      bytes_in_queue++;
    }
    break;
  case USCI_UART_UCSTTIFG:
    break;
  case USCI_UART_UCTXCPTIFG:
    if ((--bytes_in_queue) == 0)
      __bic_SR_register_on_exit(CPUOFF|GIE);
    break;
  }
}

Maybe my project ASCIImage for the JMG-Day can give some further ideas. It uses the UART as well and it toggles between two data containers that are sent out interrupt driven. The project can be found here:

It is a very long project description, but quite detailed. I start the transmission like this:

void send_ascii_image( const uint8_t * ascii_image_pointer )               // Function starts sending an image
{
  image_x_count = 1;                                                       // First byte is sent from this function
  image_y_count = 0;                                                       // Reset y counter
  image_pointer = ascii_image_pointer;                                     // Copy address of ASCII image

  LED2_GREEN_ON;                                                           // Light up green LED
  UART_CLEAR_TX_IFG;                                                       // Clear pending TX interrupt flag
  UART_ENABLE_TX_IR;                                                       // Enable TX interrupts

  UART_TX_BUFFER = *(image_pointer + ASCII_IMAGE_DATA_START);              // Send first byte of image
}

As you can see, I first clear any pending TXIFG, then enable the TX interrupts and copy the first byte into the TX buffer.

Dennis