[参考译文] MSP430FR5994：MSP430FR5994

#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;
    UCA0CTLW0 |=UCSSEL__SMCLK;
    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


    print("ENTER HOURS: \r\n");
     __bis_SR_register(GIE);
    RTCHOUR = RXData;     // Hour = 0x23


    print("ENTER MINITUS: \r\n");    // Minute = 0x00
    __bis_SR_register(GIE);
    RTCMIN = RXData;


    print("ENTER SECONDS: \r\n"); 
    
    _bis_SR_register(GIE);
    RTCSEC = RXData;                  // Seconds = 0x00


    RTCCTL13 &= ~(RTCHOLD); // Start RTC
    __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;
        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;
    }
}

print("ENTER HOURS: \r\n");
 __bis_SR_register(GIE);
RTCHOUR = RXData;     // Hour = 0x23


print("ENTER MINITUS: \r\n");    // Minute = 0x00
__bis_SR_register(GIE);
RTCMIN = RXData;


print("ENTER SECONDS: \r\n"); 
    
_bis_SR_register(GIE);
RTCSEC = RXData;                  // Seconds = 0x00

 print("ENTER HOURS: \r\n");
       UCA0IE |= UCRXIE | UCTXCPTIE;
      __bis_SR_register(LPM0_bits | GIE);
       RTCHOUR = RXData; // Hour = 0x23
    
       print("ENTER MINITUS: \r\n");
       UCA0IE |= UCRXIE | UCTXCPTIE;
       __bis_SR_register(LPM0_bits | GIE);
       RTCMIN = RXData;
     
       print("ENTER SECONDS: \r\n");
       UCA0IE |= UCRXIE | UCTXCPTIE;// Minute = 0x00
       __bis_SR_register(LPM0_bits | GIE);
       RTCSEC = RXData; // Seconds = 0x00
    
       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;

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

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

unsigned char addr[30]="";
unsigned char receive_data[50];
unsigned char* hr;
unsigned char* mi;
unsigned char* se;



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);
}


char* RXdata()
  {
      int i=0;
      UCA0IE |= UCRXIE;
      __bis_SR_register(LPM0_bits | GIE);
      strcpy(receive_data,RXData);
      printf("receive_data=%s\n",receive_data);
      return receive_data;
  }



void RTC_init()
{
       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
     

       hr=RXdata();

       printf("hr=%s\r\n",hr);
       char * token1 = strtok(hr, " ");
       printf("token1 = %s\r\n",token1);
       int hrs=atoi(token1);
       printf("hrs = %d\r\n",hrs);
       RTCHOUR =hrs;


   
       char * token2 = strtok(NULL, " ");
       printf("token2 = %s\r\n",token2);
       int min=atoi(token2);
       printf("min = %d\r\n",min);
       RTCMIN=min;
      


       char * token3 = strtok(NULL, " ");
       printf("token3 = %s\r\n",token3);
       int sec=atoi(token3);
       printf("sec = %d\r\n",sec);
       RTCSEC =sec;


       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();

    while(1)
    {
        sprintf(addr, "TIME = %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[50]="";
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;
    }
}

  while(1)
            {

             if((RTCHOUR==10)&&(RTCMIN==15))
                             {
                                 P1OUT = 0x01;
                                 sprintf(addr, "TIME = %d:%d:%d   DATE = %d / %d / %d\r\n", hours,mins,secs,day,month,year);
                                 print(addr);
                             }
             else if((RTCHOUR==10)&&(RTCMIN==16))
                             {
                                 print("ENTER THE TIME\r\n");
                                // __bis_SR_register(CPUOFF | GIE);
                                // __disable_interrupt();
                                 
                                 RTC_init();
                                 sprintf(addr, "TIME = %d:%d:%d   DATE = %d / %d / %d\r\n", hours,mins,secs,day,month,year);
                                 print(addr);
                             }
             else
                             {
                            sprintf(addr, "TIME = %d:%d:%d   DATE = %d / %d / %d\r\n", hours,mins,secs,day,month,year);
                            print(addr);
                             }
                         __delay_cycles(8000000);
            }