[参考译文] MSP430FR5994：使用 UART 接收数据

///////////////////////   main.c  ///////////////////////////

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

unsigned char addr[30]="";



void pin_setup()
{
   // P1DIR |= BIT0; //Set P1.0 (red LED) to output
    P1DIR = 0x03; //Set P1.0 to output direction

    //P1OUT &=~0X02;
    PM5CTL0=LOCKLPM5;
}
void clk_setp()
{
     CSCTL0_H = CSKEY_H;
     CSCTL1 = DCOFSEL_6; //8MHz |DCOFSEL_0 -1MHz
     CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK;  // Set SMCLK = MCLK = DCO
     CSCTL3 = DIVA_1|DIVS__1|DIVM__1;
     CSCTL0_H = 0;
}

void RTC_clk_setup()
{
   /* P1DIR |= BIT0;
    P1OUT &= ~BIT0;// Set P1.0 as output*/
    PJSEL0 = BIT4 | BIT5;                   // Initialize LFXT pins
   // Disable the GPIO power-on default high-impedance mode to activate
   // previously configured port settings
    PM5CTL0 &= ~LOCKLPM5;

   // Configure LFXT 32kHz crystal
    CSCTL0_H = CSKEY_H;                     // Unlock CS registers
    CSCTL4 &= ~LFXTOFF;                     // Enable LFXT
     do
     {
        CSCTL5 &= ~LFXTOFFG;                  // Clear LFXT fault flag
        SFRIFG1 &= ~OFIFG;
     } while (SFRIFG1 & OFIFG);              // Test oscillator fault flag
       CSCTL0_H = 0;                           // Lock CS registers*/
}



void uart_config()
 {
     P2SEL0 &= ~(BIT0 | BIT1);
     P2SEL1 |= (BIT0 | BIT1);                // USCI_A0 UART operation
     PM5CTL0 &= ~LOCKLPM5;
     UCA0CTLW0=UCSWRST;//eUSCI in reset mode(disabling) and this will automatically SETS the UCTXIFG and RESETS the UCRXIFG,UCRXIE,UCTXIE
     UCA0CTLW0 |=UCSSEL__SMCLK;//CLOCK is SMCLK=8MHZ
     UCA0BRW = 52;
     UCA0MCTLW |= UCOS16 | UCBRF_1 | 0x49;
     UCA0CTLW0 &= ~UCSWRST;                  // Initialize eUSCI
     UCA0IE |= UCRXIE;                       // Enable USCI_A0 RX interrupt
 }

void print(unsigned char *str)
{
    strcpy(Data, str);
    size = strlen(Data);
    Tx_index=0;
    UCA0IE |= UCTXIE | UCTXCPTIE;
    UCA0TXBUF=Data[Tx_index];
    Tx_index++;
    __bis_SR_register(LPM0_bits|GIE);
    }


void RTC_init()
{
       print("SET TIME\r\n");
       RTC_clk_setup();
       RTCCTL0_H = RTCKEY_H;                   // Unlock RTC
       RTCCTL0_L = RTCTEVIE_L | RTCRDYIE_L;    // enable RTC read ready interrupt
                                               // enable RTC time event interrupt
       RTCCTL13 = RTCBCD | RTCHOLD | RTCMODE;  // RTC enable, BCD mode, RTC hold
       RTCYEAR = 0x2022;                       // Year = 0x2022
       RTCMON = 0x11;                           // Month = 0x10 = nov
       RTCDAY = 0x02;                          // Day = 0x26 = 26th
       RTCDOW = 0x03;                          // Day of week = 0x04 = thurs
       print("ENTER HOURS: \r\n");
       UCA0IE |= UCRXIE | UCTXCPTIE;
      __bis_SR_register(LPM0_bits | GIE);
       RTCHOUR = RXData; // Hour = 0x23
      // printf("%x",RTCHOUR);
       print("ENTER MINITUS: \r\n");
       UCA0IE |= UCRXIE | UCTXCPTIE;
       __bis_SR_register(LPM0_bits | GIE);
       RTCMIN = RXData;
      // printf("%x",RTCMIN);
       print("ENTER SECONDS: \r\n");
       UCA0IE |= UCRXIE | UCTXCPTIE;// Minute = 0x00
       __bis_SR_register(LPM0_bits | GIE);
       RTCSEC = RXData; // Seconds = 0x00
      // printf("%x",RTCSEC);
       RTCCTL13 &= ~(RTCHOLD);                 // Start RTC

     //  __bis_SR_register(LPM3_bits | GIE);     // Enter LPM3 mode w/ interrupts enabled
       __bis_SR_register(GIE);     // Enter LPM3 mode w/ interrupts enabled
       __no_operation();
       return 0;
}



int main(void)
{
    WDTCTL = WDTPW | WDTHOLD;               // Stop Watchdog Timer
    clk_setp();
    uart_config();
    RTC_init();
    pin_setup();
    while(1)
    {
        sprintf(addr, "%x:%x:%x\r\n", hours,mins,secs);
         print(addr);

        __delay_cycles(8000000);
       }
}



/////////////////////////  rtc.h   ////////////////////////////////


#include <msp430.h>
#include <stdint.h>
#include <stdbool.h>

volatile int Rx_index=0;
volatile unsigned int Rx_key=0;
volatile int Tx_index=0;
volatile unsigned int Tx_key=0;
int size=0;
unsigned char Data[15]="";
unsigned char RXData[5]="";
unsigned char time_1[]="11:45:00";
unsigned char time_2[]="11:47:00";
unsigned int hr=11;
unsigned int min1=45;
unsigned int min2=47;
int secs=0;
int hours=0;
int mins=0;
int day=0;
int month=0;
int year=0;

#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=RTC_C_VECTOR
__interrupt void RTC_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(RTC_C_VECTOR))) RTC_ISR (void)
#else
#error Compiler not supported!
#endif
{
    switch(__even_in_range(RTCIV, RTCIV__RT1PSIFG))
    {
        case RTCIV__NONE:      break;       // No interrupts
        case RTCIV__RTCOFIFG:  break;       // RTCOFIFG
        case RTCIV__RTCRDYIFG:              // RTCRDYIFG
            P1OUT ^= 0x01;// Toggles P1.0 every second
            hours=RTCHOUR;
            mins=RTCMIN;
            secs=RTCSEC;
            day=RTCDAY;
            month=RTCMON;
            year=RTCYEAR;
             break;
        case RTCIV__RTCTEVIFG:              // RTCEVIFG
            __no_operation();               // Interrupts every minute - SET BREAKPOINT HERE
            break;
        case RTCIV__RTCAIFG:   break;       // RTCAIFG
        case RTCIV__RT0PSIFG:  break;       // RT0PSIFG
        case RTCIV__RT1PSIFG:  break;       // RT1PSIFG
        default: break;
    }
}



#pragma vector = EUSCI_A0_VECTOR
__interrupt void USCI_A0_ISR(void)
{
    switch(__even_in_range(UCA0IV, USCI_UART_UCTXCPTIFG))
    {
        case USCI_NONE: break;
        case USCI_UART_UCRXIFG:
            Rx_key=0;
            RXData[Rx_index]=UCA0RXBUF;
            if((RXData[Rx_index] == '\x0d'/*'\r'*/) || (RXData[Rx_index] ==  '\n')||(RXData[Rx_index] == '\r'))
            {
                __bic_SR_register_on_exit(CPUOFF|GIE);
                UCA0IE &= ~UCRXIE;
                Rx_index=0;
                Rx_key=0;
                break;
            }
            Rx_index++;
            break;
        case USCI_UART_UCTXIFG:
            if(Tx_key==1)
            {
                if(Tx_index>size)
                {
                    __bic_SR_register_on_exit(CPUOFF|GIE);
                    UCA0IE &= ~UCTXIE;
                    UCA0IE &= ~UCTXCPTIE;
                    Tx_key=0;
                    break;
                }
                UCA0TXBUF = Data[Tx_index];
                Tx_index++;
                Tx_key=0;
            }
            break;
        case USCI_UART_UCSTTIFG: break;
        case USCI_UART_UCTXCPTIFG:
            Tx_key=1;
            UCA0IFG|=UCTXIFG;
            break;
        default: break;
    }
}

UCA0IE |= UCTXIE | UCTXCPTIE;

//////////////////////// main.c  /////////////////////////////

#include <msp430.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <uart.h>
unsigned char data[20]="";
unsigned char receive_data;
 void pin_config()
 {
     P2SEL1|=BIT0|BIT1;
     P2SEL0 &=~BIT0|BIT1;
 }
 void clock_setup()
 {
     // Startup clock system with max DCO setting ~8MHz
     CSCTL0_H = CSKEY_H;                     // Unlock CS registers
    // CSCTL1 = DCOFSEL_3 | DCORSEL;           // Set DCO to 8MHz
     CSCTL1 = DCOFSEL_6 ;
     CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK;
     CSCTL3 = DIVA__1 | DIVS__1 | DIVM__1;   // Set all dividers
     CSCTL0_H = 0;
 }
 void UART_config()
 {
     UCA0CTLW0 = UCSWRST;                    // Put eUSCI in reset (p788)
     UCA0CTLW0 |= UCSSEL__SMCLK;             // CLK = SMCLK
     UCA0BRW = 52;                           
     UCA0MCTLW |= UCOS16 | UCBRF_1 | 0x49; 
     UCA0CTLW0 &= ~UCSWRST;                  // Initialize eUSCI
     _BIS_SR(GIE);
     UCA0IE = UCTXCPTIE;                       // Enable USCI_A0 RX interrupt
 }

 void RXdata()
 {
     UCA0IE |= UCRXIE;
     __bis_SR_register(LPM0_bits | GIE);
     data=RXData;

 }
 int main(void)
 {
     WDTCTL = WDTPW | WDTHOLD; // stop watchdog time
        pin_config();
        PM5CTL0&=~LOCKLPM5;
        clock_setup();
        UART_config();

        while(1)
        {
        RXdata();
        }
 }
 
 
 
 //////////////////////// uart.h  ///////////////////////////
 
 
 #include <msp430.h>
#include <stdint.h>
#include <stdbool.h>

volatile int Rx_index=0;
volatile unsigned int Rx_key=0;
volatile int Tx_index=0;
volatile unsigned int Tx_key=0;
int size=0;
unsigned char RXData[20]="";
unsigned char Data[15]="";

#pragma vector = EUSCI_A0_VECTOR
__interrupt void USCI_A0_ISR(void)
{
    switch(__even_in_range(UCA0IV, USCI_UART_UCTXCPTIFG))
    {
        case USCI_NONE: break;
        case USCI_UART_UCRXIFG:
            Rx_key=0;
            RXData[Rx_index]=UCA0RXBUF;
            if((RXData[Rx_index] == '\x0d'/*'\r'*/) || (RXData[Rx_index] ==  '\n')||(RXData[Rx_index] == '\r'))
            {
                __bic_SR_register_on_exit(CPUOFF|GIE);
                UCA0IE &= ~UCRXIE;
                Rx_index=0;
                Rx_key=0;
                break;
            }
            Rx_index++;
            break;
        case USCI_UART_UCTXIFG:
            if(Tx_key==1)
            {
                if(Tx_index>size)
                {
                    __bic_SR_register_on_exit(CPUOFF|GIE);
                    UCA0IE &= ~UCTXIE;
                    UCA0IE &= ~UCTXCPTIE;
                    Tx_key=0;
                    break;
                }
                UCA0TXBUF = Data[Tx_index];
                Tx_index++;
                Tx_key=0;
            }
            break;
        case USCI_UART_UCSTTIFG: break;
        case USCI_UART_UCTXCPTIFG:
            Tx_key=1;
            UCA0IFG|=UCTXIFG;
            break;
        default: break;
    }
}