MSP430F6638 Battery Backup RTC_B

#include "inc/hw_memmap.h"
#include "rtc.h"
#include "sfr_sys.h"
#include "wdt.h"
#include "gpio.h"
#include "ucs.h"
#include "pmm.h"

void EnterLPM45(void);
void WakeUpLPM45(void);
void SetBAKMEM(void);

volatile Calendar newTime;
Calendar currentTime;

void main (void)
{
	int	lpm_flag = 0;
	
	WDT_hold(__MSP430_BASEADDRESS_WDT_A__);

	while(BAKCTL & LOCKBAK)                   // Unlock XT1 pins for operation
		BAKCTL &= ~(LOCKBAK);  
	
	if(SYSRSTIV == 0x08) {
		PMMCTL0_H = PMMPW_H;                      // open PMM
		PM5CTL0 &= ~LOCKIO;                       // Clear LOCKBAK and enable ports
		PMMCTL0_H = 0x00;                         // close PMM

		//Initialize LFXT1
		UCS_LFXT1Start(__MSP430_BASEADDRESS_UCS__,
			UCS_XT1_DRIVE3,
			UCS_XCAP_3
			);

		//Monitor high side is turned on
		PMM_enableSvmH(__MSP430_BASEADDRESS_PMM__);

		PMMCTL0_H = PMMPW_H;                      // open PMM
		SVSMHCTL |= SVSHMD + 5;                       // Clear LOCKBAK and enable ports
		PMMCTL0_H = 0x00;                         // close PMM

		PMM_enableSvmHInterrupt(__MSP430_BASEADDRESS_PMM__);
		
		lpm_flag = 1;
	}
	else {
		//Initialize LFXT1
		UCS_LFXT1Start(__MSP430_BASEADDRESS_UCS__,
			UCS_XT1_DRIVE3,
			UCS_XCAP_3
			);
		
		//Setup Current Time for Calendar
		currentTime.Seconds    = 0x00;
		currentTime.Minutes    = 0x26;
		currentTime.Hours      = 0x13;
		currentTime.DayOfWeek  = 0x03;
		currentTime.DayOfMonth = 0x20;
		currentTime.Month      = 0x07;
		currentTime.Year       = 0x2011;
		
		//Initialize Calendar Mode of RTC
		/*
		* Base Address of the RTC_A
		* Pass in current time, intialized above
		* Use BCD as Calendar Register Format
		*/
		RTC_calendarInit(__MSP430_BASEADDRESS_RTC_B__,
			currentTime,
			RTC_FORMAT_BCD);
		
		//Setup Calendar Alarm for 5:00pm on the 5th day of the week.
		//Note: Does not specify day of the week.
		//RTC_setCalendarAlarm(__MSP430_BASEADDRESS_RTC_B__,
		//    0x00,
		//    0x17,
		//    RTC_ALARMCONDITION_OFF,
		//    0x05);
		
		//Specify an interrupt to assert every minute
		//RTC_setCalendarEvent(__MSP430_BASEADDRESS_RTC_B__,
		//    RTC_CALENDAREVENT_MINUTECHANGE);
		
		//Enable interrupt for RTC Ready Status, which asserts when the RTC
		//Calendar registers are ready to read.
		//Also, enable interrupts for the Calendar alarm and Calendar event.
		//RTC_enableInterrupt(__MSP430_BASEADDRESS_RTC_B__,
		//    RTCRDYIE + RTCTEVIE + RTCAIE );
		RTC_enableInterrupt(__MSP430_BASEADDRESS_RTC_B__, RTCRDYIE + RTCOFIE );
		//RTC_definePrescaleEvent( __MSP430_BASEADDRESS_RTC_B__, RTC_PRESCALE_1, RTC_PSEVENTDIVIDER_128 );
		//RTC_enableInterrupt(__MSP430_BASEADDRESS_RTC_B__, RTC_PRESCALE_TIMER1_INTERRUPT );
		
		//Start RTC Clock
		RTC_startClock(__MSP430_BASEADDRESS_RTC_B__);
		
		//Monitor high side is turned on
		PMM_enableSvmH(__MSP430_BASEADDRESS_PMM__);

		PMMCTL0_H = PMMPW_H;                      // open PMM
		SVSMHCTL |= SVSHMD + 5;                       // Clear LOCKBAK and enable ports
		PMMCTL0_H = 0x00;                         // close PMM

		PMM_enableSvmHInterrupt(__MSP430_BASEADDRESS_PMM__);
		
		EnterLPM45();
	}

	//Set P1.0 to output direction
	GPIO_setAsOutputPin(__MSP430_BASEADDRESS_PORT7_R__,
		GPIO_PORT_P7,
		GPIO_PIN4+GPIO_PIN5
		);
	
	
	GPIO_setAsPeripheralModuleFunctionInputPin(__MSP430_BASEADDRESS_PORT7_R__,
		GPIO_PORT_P7,
		GPIO_PIN0 + GPIO_PIN1
		);
	
	//Enter LPM3 mode with interrupts enabled
	while(1) {
		if( lpm_flag ) {
			GPIO_toggleOutputOnPin(__MSP430_BASEADDRESS_PORT7_R__,
				GPIO_PORT_P7,
				GPIO_PIN5);
			
			__delay_cycles(100000);
		}
	}
}

#pragma vector=RTC_VECTOR
__interrupt void RTC_ISR (void)
{
	while(BAKCTL & LOCKIO)                    // Unlock backup system
	BAKCTL &= ~(LOCKIO); 
	
	switch (__even_in_range(RTCIV,16)){
	case 0: break;  //No interrupts
	case 2:         //RTCRDYIFG
		//Toggle P1.0 every second
		GPIO_toggleOutputOnPin(__MSP430_BASEADDRESS_PORT7_R__,
			GPIO_PORT_P7,
			GPIO_PIN4);
		
		PM5CTL0 &= ~LOCKLPM5;
		LPM4_EXIT;
		break;
	case 4:         //RTCEVIFG
		//Interrupts every minute
		__no_operation();
		
		//Read out New Time a Minute Later BREAKPOINT HERE
		newTime = RTC_getCalendarTime(__MSP430_BASEADDRESS_RTC_B__);
		break;
	case 6:         //RTCAIFG
		//Interrupts 5:00pm on 5th day of week
		__no_operation();
		break;
	case 8: break;  //RT0PSIFG
	case 10: //RT1PSIFG
		//Toggle P1.0 every second
		GPIO_toggleOutputOnPin(__MSP430_BASEADDRESS_PORT7_R__,
			GPIO_PORT_P7,
			GPIO_PIN4);
		
		//RTCPS1CTL &= ~RT1PSIFG;
		
		PM5CTL0 &= ~LOCKLPM5;
		//LPM4_EXIT;
		break;
	case 12:	// RTCOFIFG 
		__no_operation();
		break; //
	case 14: break; //Reserved
	case 16: break; //Reserved
	default: break;
	}
	
	//RTCIV = 0;
}

#pragma vector=SYSNMI_VECTOR
__interrupt void SysNMI_ISR (void)
{
	switch( SYSSNIV ) {
	case	2 :	// SVMLIFG
		__no_operation();
		break;
	case	4 :	// SVMHIFG
		EnterLPM45();
		__no_operation();
		break;
	case	6 :	// SVSMLDLYIFG
		__no_operation();
		break;
	case	8 :	// SVSMHDLYIFG
		__no_operation();
		break;
	case	10 :	// VMAIFG
		__no_operation();
		break;
	case	12 :	// JMBINIFG
		__no_operation();
		break;
	}
}

void EnterLPM45(void)
{
  __enable_interrupt();
  PMMCTL0_H = PMMPW_H;                      // Open PMM Registers for write and set
  PMMCTL0_L |= PMMREGOFF;                   // PMMREGOFF
  __bis_SR_register(LPM4_bits);             // Enter LPM4.5 mode with interrupts
  __no_operation();                         // enabled
}

void WakeUpLPM45(void)
{
  PMMCTL0_H = PMMPW_H;                      // open PMM
  PM5CTL0 &= ~LOCKIO;                       // Clear LOCKBAK and enable ports
  PMMCTL0_H = 0x00;                         // close PMM

  // Restore Port settings
  P1OUT = 0x00;P2OUT = 0x00;P3OUT = 0x00;P4OUT = 0x00;P5OUT = 0x00;P6OUT = 0x00;
  P7OUT = 0x00;P8OUT = 0x00;P9OUT = 0x00;PJOUT = 0x00;
  P1DIR = 0xFF;P2DIR = 0xFF;P3DIR = 0xFF;P4DIR = 0xFF;P5DIR = 0xFF;P6DIR = 0xFF;
  P7DIR = 0xFF;P8DIR = 0xFF;P9DIR = 0xFF;PJDIR = 0xFF; 
  
  // Restore Clock so that BAKMEM will be read
  UCSCTL6 &= ~(XT1OFF);                     // XT1 On
  UCSCTL6 |= XCAP_3;                        // Internal load cap
  while(BAKCTL & LOCKBAK)                   // Unlock XT1 pins for operation
     BAKCTL &= ~(LOCKBAK);  
  do
  {
    UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG);
                                            // Clear XT2,XT1,DCO fault flags
    SFRIFG1 &= ~OFIFG;                      // Clear fault flags
  }while (SFRIFG1&OFIFG);                   // Test oscillator fault flag   
}

void SetBAKMEM(void)
{
  // Setup Clock
  UCSCTL6 &= ~(XT1OFF);                     // XT1 On
  UCSCTL6 |= XCAP_3;                        // Internal load cap
  while(BAKCTL & LOCKBAK)                   // Unlock XT1 pins for operation
     BAKCTL &= ~(LOCKBAK);  
  do
  {
    UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG);
                                            // Clear XT2,XT1,DCO fault flags
    SFRIFG1 &= ~OFIFG;                      // Clear fault flags
  }while (SFRIFG1&OFIFG);                   // Test oscillator fault flag

  // Set backup RAM values
  BAKMEM0 = 0x0000;
  BAKMEM1 = 0x1111;
  BAKMEM2 = 0x2222;
  BAKMEM3 = 0x3333;
  
  // Turn off Clock for LPM4.5 operation
  UCSCTL6 |= XT1OFF;                        // XT1 Off
}