[FAQ] MSP430f6779 Supply monitor intrrupt service routine SVSH and SVSL

Hello Sean Huang15 ABHISHEK PARIKH,

Thanks for your continuous support

Clicking the value in watch expression window we are changing its value. 

We have tested it with DC power supply also it is going into ISR when Supply is down to 2.8V but while running in continuous mode with SMPS as MSP430 power supply when I switch off it and switch it On again it goes into ISR write_SegC(). 

We have checked that while it is going from off to on state it once again goes into  write_SegC(). We have checked this using led at P1.0.

    void write_SegC(void)
    {
    	P1OUT |= BIT0;                           //LED ON

        unsigned int i;
        char *Flash_ptr;                        // Initialize Flash pointer

        Flash_ptr = (char *)0x1880;


        FCTL3 = FWKEY;                          // Clear Lock bit
//        FCTL1 = FWKEY | ERASE;                  // Set Erase bit


//        *Flash_ptr = 0;                         // Dummy write to erase Flash seg


        FCTL1 = FWKEY | WRT;                    // Set WRT bit for write operation


        for (i = 0; i < 20; i++)
        {
            *Flash_ptr++ = Flash_Data[i];             // Write value to flash
        }
        
        FCTL1 = FWKEY;                          // Clear WRT bit
        FCTL3 = FWKEY | LOCK;                   // Set LOCK bit
       P1OUT &= ~BIT0;                          // LED Off
    }
    }

Once when I switch off the power my LED blinks and after turning it on back it stays On. I have not used P1OUT anywhere else though.

Now Here is my full code

#include <msp430.h> 

/*
 * main.c
 */
void write_SegC(void);
void copy_from_FlashC(void);
void PMM_config(void);
void UCS_config(void);
char Flash_Data[20] = {0,0,3,4,5,6,7,8,0,0,0,5,5,5,0,8,8,9,2,3};
char Flash_Data1[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int main(void) {
	 WDTCTL = WDTPW | WDTHOLD;	// Stop watchdog timer
	 P1DIR |= BIT0;
	 P1REN |= BIT6;
	 PMM_config();
	 UCS_config();
	 __delay_cycles(0x3600);

	while(1)
{

    copy_from_FlashC();
}
return 0;
}
void copy_from_FlashC(void)
    {
        unsigned int i;
        char *Flash_ptrC;
    //    char *Flash_ptrD;

        Flash_ptrC = (char *) 0x1880;           // Initialize Flash segment C ptr


       // Flash_ptrD = (char *) 0x1800;           // Initialize Flash segment D ptr
     //   Flash_ptrD = (char*) Flash_Data[0];

    //    FCTL3 = FWKEY;                          // Clear Lock bit
     //  FCTL1 = FWKEY | ERASE;                  // Set Erase bit
     //   *Flash_ptrD = 0;                        // Dummy write to erase Flash seg D
      //  FCTL1 = FWKEY | WRT;                    // Set WRT bit for write operation
    //    FCTL1 = FWKEY;
       FCTL4 = FWKEY | MGR0 ;

        for (i = 0; i < 20; i++)
        {

        	Flash_Data1[i] = *Flash_ptrC++;
        }

   //     FCTL1 = FWKEY;                          // Clear WRT bit
     //   FCTL3 = FWKEY | LOCK;                   // Set LOCK bit
    }


    void write_SegC(void)
    {
    	
    	P1OUT |= BIT0;

        unsigned int i;
        char *Flash_ptr;                        // Initialize Flash pointer

        Flash_ptr = (char *)0x1880;


        FCTL3 = FWKEY;                          // Clear Lock bit
//        FCTL1 = FWKEY | ERASE;                  // Set Erase bit


//        *Flash_ptr = 0;                         // Dummy write to erase Flash seg


        FCTL1 = FWKEY | WRT;                    // Set WRT bit for write operation


        for (i = 0; i < 20; i++)
        {
            *Flash_ptr++ = Flash_Data[i];             // Write value to flash
        }
        FCTL1 = FWKEY;                          // Clear WRT bit
        FCTL3 = FWKEY | LOCK;                   // Set LOCK bit
        P1OUT &= ~BIT0;
    }
    
    void PMM_config(void)
    {
    	//unlock PMM
          PMMCTL0_H=PMMPW_H;
          PMMCTL0_L|=PMMCOREV_3;
          //check voltage level
          switch(PMMCTL0&PMMCOREV_3)
          {
            //settings for highest core voltage settings
            case PMMCOREV_3:
              //setup high side supervisor and monitor
              SVSMHCTL=SVMHE|SVSHE|SVSHRVL_3|SVSMHRRL_7;
            break;
          }
          //clear interrupt flags
          PMMIFG&=~(SVMLIFG|SVMHIFG|SVMHVLRIFG|SVMLVLRIFG);
          //setup interrupts
         // PMMRIE|=SVMHIE|SVMHVLRIE;
          PMMRIE|=SVMLIE|SVMHIE|SVMHVLRIE|SVMLVLRIE;
          //lock PMM
          PMMCTL0_H=0;
    }
#pragma vector = SYSNMI_VECTOR
__interrupt void SYS_NMI(void)
{
  switch(SYSSNIV)
  	  {
		//core supply voltage monitor interrupt
		case SYSSNIV_SVMLIFG:
		  //event to report error
		  //set flag
		break;
		//input supply voltage monitor interrupt
		case SYSSNIV_SVMHIFG:
			 write_SegC();
		//	 PMM_config();
		//	 Clear_SegC(value);		// For testing only
			//event to report error
		  //set flag
		break;
		//core supply voltage monitor delay interrupt
		case SYSSNIV_DLYLIFG:
		break;
		//interrupt supply voltage monitor delay interrupt
		case SYSSNIV_DLYHIFG:
		break;
		//Vacant memory access interrupt
		case SYSSNIV_VMAIFG:
		break;
		//JTAG mailbox in interrupt
		case SYSSNIV_JMBINIFG:
		break;
		//JTAG mailbox out interrupt
		case SYSSNIV_JMBOUTIFG:
		break;
		//SVMLVLRIFGSVMHVLRIFG
		case SYSSNIV_VLRLIFG:
		  //clear interrupt flag bits
		  //unlock PMM
			//write_SegC();
		  PMMCTL0_H=PMMPW_H;
		  //clear interrupt flags
		  PMMIFG&=~(SVMLIFG|SVMLVLRIFG);
		  //lock PMM
		  PMMCTL0_H=0;
		break;
		//SVMHVLRIFGSVMHVLRIFG
		case SYSSNIV_VLRHIFG:
		  //clear interrupt flag bits
		  //unlock PMM
//			 write_SegC();
			PMMCTL0_H=PMMPW_H;
		  //clear interrupt flags
		  PMMIFG&=~(SVMHIFG|SVMHVLRIFG);
		  //lock PMM
		  PMMCTL0_H=0;
		 PMM_config();

		  break;
  	  }
}

void UCS_config(void)
{
		PMMCTL0_H = 0xA5;
		PMMCTL0_L = 0x03;
		UCSCTL0 = UCSCTL0 | 0x1F00;
		UCSCTL1 = UCSCTL1 & 0x0000;
		UCSCTL1 = UCSCTL1 | 0x0040;
		UCSCTL2 = UCSCTL2 & 0x0000 ; // FLL Divider
		UCSCTL2 = UCSCTL2 | 0x304F ; // for 20 MHz MCLK and 2.6 MHz SMCLK
		UCSCTL3 = 0x0000;

		UCSCTL4 = UCSCTL4 & 0X0000;
		UCSCTL4 = UCSCTL4 | 0X0043;

		//   UCSCTL5 = UCSCTL5 | 0x0040;
		//   UCSCTL6 =;
		//   UCSCTL7 =;
		//   UCSCTL8 =;
		//   PMMCTL0 = PMMCTL0 | 0x0003;
		//   UCSCTL2 = UCSCTL2 | 0X001F;
		//   UCSCTL6 = UCSCTL6 | 0X00B0;

		// Setup LFXT1
/*
			UCSCTL6 &= ~(XT1OFF);                   // XT1 On

			UCSCTL6 |= XCAP_3;                      // Internal load cap


		// Loop until XT1 fault flag is cleared


		do
			{
				UCSCTL6 &= ~(XT2OFFG | XT1LFOFFG | DCOFFG);
				// Clear XT2,XT1,DCO fault flags

				SFRIFG1 &= ~OFIFG;                  // Clear fault flags

			}
		while (SFRIFG1 & OFIFG);              // Test oscillator fault flag
		*/

//		P1SEL0 =  P1SEL0 | 0X34;
	//    P1SEL1 =  P1SEL1  & 0XCB;
//		P1DIR  = P1DIR | 0X34;
	 //   CPBD = 0X00;
}

Thanks In Advance

Regards

Dhara

Hello,

I will look into the issues described above, but just to quickly reference the PMM registers and Flash_Data questions. The registers can be modified and I've attached a graph from the datasheet describing the specific PMMCOREV_X values and supply voltage relations. As for the array, after changing it in the watch expression, did the program execute to write_SegC(void) first before copying over to Flash_Data1 in the copy_from_FlashC(void) function?

Sincerely,

Sean

Hello Sean Huang15  Clemens Ladisch

I have added another function for Vcoreup

void SetVCoreUp (unsigned int level)
    {
    // Open PMM registers for write access
    PMMCTL0_H = 0xA5;
    // Make sure no flags are set for iterative sequences
    while ((PMMIFG & SVSMHDLYIFG) == 0);
    while ((PMMIFG & SVSMLDLYIFG) == 0);
    // Set SVS/SVM high side new level
    SVSMHCTL = SVSHE + SVSHRVL0 * level + SVMHE + SVSMHRRL0 * level;
    // Set SVM low side to new level
    SVSMLCTL = SVSLE + SVMLE + SVSMLRRL0 * level;
    // Wait till SVM is settled
    while ((PMMIFG & SVSMLDLYIFG) == 0);
    // Clear already set flags
    PMMIFG &= ~(SVMLVLRIFG + SVMLIFG);
    // Set VCore to new level
    PMMCTL0_L = PMMCOREV0 * level;
    // Wait till new level reached
    if ((PMMIFG & SVMLIFG))
    while ((PMMIFG & SVMLVLRIFG) == 0);
    // Set SVS/SVM low side to new level
    SVSMLCTL = SVSLE + SVSLRVL0 * level + SVMLE + SVSMLRRL0 * level;
    // Lock PMM registers for write access
    PMMCTL0_H = 0x00;
    }

But my program stuck at second line 

while ((PMMIFG & SVSMHDLYIFG) == 0);

Thanks

Regards

Abhishek

The order of these operations appears to be wrong; the SVM delay interrupt flag will be set only after a change.

This is how it's done in TI's example code:

void SetVcoreUp (unsigned int level)
{
  // Open PMM registers for write
  PMMCTL0_H = PMMPW_H;              
  // Set SVS/SVM high side new level
  SVSMHCTL = SVSHE + SVSHRVL0 * level + SVMHE + SVSMHRRL0 * level;
  // Set SVM low side to new level
  SVSMLCTL = SVSLE + SVMLE + SVSMLRRL0 * level;
  // Wait till SVM is settled
  while ((PMMIFG & SVSMLDLYIFG) == 0);
  // Clear already set flags
  PMMIFG &= ~(SVMLVLRIFG + SVMLIFG);
  // Set VCore to new level
  PMMCTL0_L = PMMCOREV0 * level;
  // Wait till new level reached
  if ((PMMIFG & SVMLIFG))
    while ((PMMIFG & SVMLVLRIFG) == 0);
  // Set SVS/SVM low side to new level
  SVSMLCTL = SVSLE + SVSLRVL0 * level + SVMLE + SVSMLRRL0 * level;
  // Lock PMM registers for write access
  PMMCTL0_H = 0x00;
}

Hi Sean Huang15 (4399189) , Clemens Ladisch (508254)  and ABHISHEK PARIKH (4398096)

Thank you for your constant guidance and support..

I tried to set the VCore level with the above TI's example code but its not going to any of the ISR even when the supply is down to 1.4V..

Please suggest me way to do so..

Here is my code

#include <msp430.h> 

void write_SegC(void);
void copy_from_FlashC(void);
void PMM_config(void);
void UCS_config(void);
void SetVCoreUp(unsigned int);
//void SetVCoreUp(void);

char Flash_Data[20] = {0,0,3,4,5,6,7,8,0,0,0,5,5,5,0,8,8,9,2,3};
char Flash_Data1[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};


void main(void) {
     WDTCTL = WDTPW | WDTHOLD;  // Stop watchdog timer
     P1DIR |= BIT0;
     P1REN |= BIT6;

    SetVCoreUp(3);
    PMM_config();
    UCS_config();
while(1)
{
    copy_from_FlashC();
}
}

void PMM_config(void)
 {
        //check voltage level
       switch(PMMCTL0&PMMCOREV_3)
       {
         //settings for highest core voltage settings
         case PMMCOREV_3:
           //setup high side supervisor and monitor
           SVSMHCTL=SVMHE|SVSHE|SVSHRVL_3|SVSMHRRL_7;
         break;
       }
       //clear interrupt flags
       PMMIFG&=~(SVMLIFG|SVMHIFG|SVMHVLRIFG|SVMLVLRIFG|SVSMHDLYIFG);
       //setup interrupts
       PMMRIE|=SVMLIE|SVMHIE|SVMHVLRIE|SVMLVLRIE;
       //lock PMM
       PMMCTL0_H=0;
 }

void SetVCoreUp (unsigned int level)
{
  // Open PMM registers for write
  PMMCTL0_H = PMMPW_H;
  // Set SVS/SVM high side new level
  SVSMHCTL = SVSHE + SVSHRVL0 * level + SVMHE + SVSMHRRL0 * level;
  // Set SVM low side to new level
  SVSMLCTL = SVSLE + SVMLE + SVSMLRRL0 * level;
  // Wait till SVM is settled
  while ((PMMIFG & SVSMLDLYIFG) == 0);
  // Clear already set flags
  PMMIFG &= ~(SVMLVLRIFG + SVMLIFG);
  // Set VCore to new level
  PMMCTL0_L = PMMCOREV0 * level;
  // Wait till new level reached
  if ((PMMIFG & SVMLIFG))
    while ((PMMIFG & SVMLVLRIFG) == 0);
  // Set SVS/SVM low side to new level
  SVSMLCTL = SVSLE + SVSLRVL0 * level + SVMLE + SVSMLRRL0 * level;
  // Lock PMM registers for write access
  PMMCTL0_H = 0x00;
}



void copy_from_FlashC(void)
    {
        unsigned int i;
        char *Flash_ptrC;
    //    char *Flash_ptrD;

        Flash_ptrC = (char *) 0x1880;           // Initialize Flash segment C ptr


       // Flash_ptrD = (char *) 0x1800;           // Initialize Flash segment D ptr
     //   Flash_ptrD = (char*) Flash_Data[0];

        FCTL3 = FWKEY;                          // Clear Lock bit
     //  FCTL1 = FWKEY | ERASE;                  // Set Erase bit
     //   *Flash_ptrD = 0;                        // Dummy write to erase Flash seg D
      //  FCTL1 = FWKEY | WRT;                    // Set WRT bit for write operation
        FCTL1 = FWKEY;
       FCTL4 = FWKEY | MGR0 ;

        for (i = 0; i < 20; i++)
        {
       //     *Flash_ptrD++ = *Flash_ptrC++;      // copy value segment C to seg D
                Flash_Data1[i] = *Flash_ptrC++;
        }

        FCTL1 = FWKEY;                          // Clear WRT bit
        FCTL3 = FWKEY | LOCK;                   // Set LOCK bit
    }


    void write_SegC(void)
    {
        P1OUT |= BIT0;

        unsigned int i;
        char *Flash_ptr;                        // Initialize Flash pointer

        Flash_ptr = (char *)0x1880;

        FCTL3 = FWKEY;                          // Clear Lock bit
        FCTL1 = FWKEY | ERASE;                  // Set Erase bit
        *Flash_ptr = 0;                         // Dummy write to erase Flash seg
        FCTL1 = FWKEY | WRT;                    // Set WRT bit for write operation


        for (i = 0; i < 20; i++)
        {
            *Flash_ptr++ = Flash_Data[i];             // Write value to flash
        }

        FCTL1 = FWKEY;                          // Clear WRT bit
        FCTL3 = FWKEY | LOCK;                   // Set LOCK bit
        P1OUT &= ~BIT0;
    }

#pragma vector = SYSNMI_VECTOR
__interrupt void SYS_NMI(void)
{
  switch(SYSSNIV)
      {
        //core supply voltage monitor interrupt
        case SYSSNIV_SVMLIFG:
          //event to report error
          //set flag
        break;
        //input supply voltage monitor interrupt
        case SYSSNIV_SVMHIFG:
             write_SegC();
        //   Clear_SegC(value);     // For testing only
            //event to report error
          //set flag
        break;
        //core supply voltage monitor delay interrupt
        case SYSSNIV_DLYLIFG:
        	PMMIFG=0;
        	break;
        //interrupt supply voltage monitor delay interrupt
        case SYSSNIV_DLYHIFG:
        	PMMIFG=0;
        break;
        //Vacant memory access interrupt
        case SYSSNIV_VMAIFG:
        break;
        //JTAG mailbox in interrupt
        case SYSSNIV_JMBINIFG:
        break;
        //JTAG mailbox out interrupt
        case SYSSNIV_JMBOUTIFG:
        break;
        //SVMLVLRIFGSVMHVLRIFG
        case SYSSNIV_VLRLIFG:
          //clear interrupt flag bits
          //unlock PMM
          PMMCTL0_H=PMMPW_H;
          //clear interrupt flags
          PMMIFG&=~(SVMLIFG|SVMLVLRIFG);
          //lock PMM
          PMMCTL0_H=0;
        break;
        //SVMHVLRIFGSVMHVLRIFG
        case SYSSNIV_VLRHIFG:
          //clear interrupt flag bits
          //unlock PMM
          PMMCTL0_H=PMMPW_H;
          //clear interrupt flags
          PMMIFG&=~(SVMHIFG|SVMHVLRIFG);
          //lock PMM
          PMMCTL0_H=0;
        break;
      }
}

void UCS_config(void)
{
		//PMMCTL0_H = 0xA5;
		//PMMCTL0_L = 0x03;
		UCSCTL0 = UCSCTL0 | 0x1F00;
		UCSCTL1 = UCSCTL1 & 0x0000;
		UCSCTL1 = UCSCTL1 | 0x0040;
		UCSCTL2 = UCSCTL2 & 0x0000 ; // FLL Divider
		UCSCTL2 = UCSCTL2 | 0x304F ; // for 20 MHz MCLK and 2.6 MHz SMCLK
		UCSCTL3 = 0x0000;

		UCSCTL4 = UCSCTL4 & 0X0000;
		UCSCTL4 = UCSCTL4 | 0X0043;
}

Thanks in advance.

Dhara

Hi Dhara,

Just to provide additional info, your code runs into an error when modifying the SVSMHCTL register in the PMM_config() function when I try to step by step debug. Adding PMMCTL0_H=PMMPW_H; at the beginning of the function fixes that problem.

Sincerely,
Sean

Hi Dhara,

Dhara Pandya said:

Actually the supply to my controller board is 3.05 V..

That's fine. The DVCC supply voltage is internally regulated down to VCore. Since VCore has been specified as Level 3, DVCC can be between 2.4V and 3.6V to support a maximum MCLK frequency of 25MHz. For more information, see page 59 in the Datasheet and Figure 2-1 in the User's Guide.

Dhara Pandya said:

Is it possible to get in PMM ISR at the voltage drop of 2.4V level..??

Yes, this should be possible. Using the high side monitor, SVMH (not SVSH), I've been able to successfully enter the PMM ISR and turn off an LED when the VDCC supply voltage dropped to 2.7V (set by using SVSMHRRL = 5, see page 71 in the Datasheet). The PMM ISR is not entered during board startup. I'm using an external bench power supply.

However, the code (see attached) only works when the MSP-FET debugger is connected. When the MSP-FET is disconnected and DVCC is adjusted to 2.7V, the PMM ISR is not entered. The debugger seems to introduce some debugging limitations.

• Accessing the SYSSNIV register with the debugger may clear it (described in this E2E thread).
• According to Section 2.2.9.3 Wake-up Times in Debug Mode in the User's Guide, when the TEST/SBWTCK pin is high (debugger connected), wake-up times from LPM2, LPM3, and LPM4 may be different compared to when TEST/SBWTCK is low (debugger disconnected).
• Perhaps the TEST pin being high with the debugger connected doesn't allow the DCO to stop. I'm not using any LPMx modes in my code, so this shouldn't matter when the debugger is disconnected.

I'm currently looking into why this behavior is different, and I'll let you know what I find.

/* --COPYRIGHT--,BSD
 * Copyright (c) 2016, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * --/COPYRIGHT--*/
//****************************************************************************/
//! The device is set to core level 3. The PMM_setVcore function
//! also sets the SVS and SVM  (high & low side) modules as required for a
//! core setting of 3.
//!
//!
//!                MSP430F54xA
//!             -----------------
//!         /|\|                 |
//!          | |                 |
//!          --|RST              |
//!            |            Vcore|--> Monitor voltage on Vcore pin
//!            |             P1.0|-->LED
//!
//!
//! This example uses the following peripherals and I/O signals.  You must
//! review these and change as needed for your own board:
//! - PMM peripheral
//! - GPIO Port peripheral
//!
//! This example uses the following interrupt handlers.  To use this example
//! in your own application you must add these interrupt handlers to your
//! vector table.
//! - NONE.
//****************************************************************************/

#include "driverlib.h"

uint16_t status = STATUS_SUCCESS;

void UCS_config(void);
void PMM_config(void);

void main(void)
{
    //Stop WDT
    WDT_A_hold(WDT_A_BASE);

    //Change VCore to Level 3, this function takes care of the incremental steps
    status = PMM_setVCore(PMMCOREV_3);

	//Setup UCS
    UCS_config();

    //Configure PMM SVM to detect drop in DVCC
    PMM_config();

    // Set P1.0 (LED) to output direction
    P1OUT |= 0x01;

    //Turn on the LED
    P1DIR |= 0x01;

    //Continuous loop
    while(1)
    {
        //Delay
        //__delay_cycles(500000);
    }
}

void PMM_config(void)
{
	uint16_t PMMRIE_backup, SVSMHCTL_backup, SVSMLCTL_backup;

	//Check VCore level
	switch(PMMCTL0&PMMCOREV_3)
	{

	//Settings for highest VCore voltage
	case PMMCOREV_3:
		//The code flow for increasing the Vcore has been altered to work around
		//the erratum FLASH37.
		//Please refer to the Errata sheet to know if a specific device is affected
		//DO NOT ALTER THIS FUNCTION

		//Open PMM registers for write access
		HWREG8(PMM_BASE + OFS_PMMCTL0_H) = 0xA5;

		//Backup original register settings and disable interrupts
		PMMRIE_backup = HWREG16(PMM_BASE + OFS_PMMRIE);
		HWREG16(PMM_BASE + OFS_PMMRIE) &= ~(SVMHVLRPE | SVSHPE | SVMLVLRPE |
											SVSLPE | SVMHVLRIE | SVMHIE |
											SVSMHDLYIE | SVMLVLRIE | SVMLIE |
											SVSMLDLYIE
											);
		SVSMHCTL_backup = HWREG16(PMM_BASE + OFS_SVSMHCTL);
		SVSMLCTL_backup = HWREG16(PMM_BASE + OFS_SVSMLCTL);

		//Clear interrupt flags
		HWREG16(PMM_BASE + OFS_PMMIFG) = 0;

		//Set SVM highside to new level based on VCore, SVSMRRL_5 = 2.7V (typ)
		//See page 71 in the MSP430F6779 Datasheet for more information
		HWREG16(PMM_BASE + OFS_SVSMHCTL) = SVMHE | SVSHE | SVSMHRRL_5;

		//Wait until SVM highside is settled
		while((HWREG16(PMM_BASE + OFS_PMMIFG) & SVSMHDLYIFG) == 0)
		{
			;
		}

		//Clear all Flags
		HWREG16(PMM_BASE + OFS_PMMIFG) &= ~(SVMHVLRIFG | SVMHIFG | SVSMHDLYIFG |
											SVMLVLRIFG | SVMLIFG | SVSMLDLYIFG
											);

		//Restore PMM interrupt enable register and enable the SVM high side interrupt
		HWREG16(PMM_BASE + OFS_PMMRIE) = PMMRIE_backup | SVMHIE;

		//Lock PMM registers for write access
		HWREG8(PMM_BASE + OFS_PMMCTL0_H) = 0x00;

	 break;
	}
}

void UCS_config(void)
{
	UCSCTL0 = UCSCTL0 | 0x1F00;
	UCSCTL1 = UCSCTL1 & 0x0000;
	UCSCTL1 = UCSCTL1 | 0x0040;
	UCSCTL2 = UCSCTL2 & 0x0000 ; //FLL Divider
	UCSCTL2 = UCSCTL2 | 0x304F ; //for 20 MHz MCLK and 2.6 MHz SMCLK
	UCSCTL3 = 0x0000;
	UCSCTL4 = UCSCTL4 & 0X0000;
	UCSCTL4 = UCSCTL4 | 0X0043;
}

#pragma vector = SYSNMI_VECTOR
__interrupt void SYSNMI_ISR(void)
{
	switch(SYSSNIV)
  	{

  	//Open PMM registers for write access
  	//HWREG8(PMM_BASE + OFS_PMMCTL0_H) = 0xA5;

	/*//core supply voltage monitor interrupt
	case SYSSNIV_SVMLIFG:
		//event to report error
		//set flag
	break;*/

	//input supply voltage monitor interrupt
	case SYSSNIV_SVMHIFG:
		//event to report error

		//Turn on LED on target development board
		//P1DIR |= 0x01;

		//Turn off LED on target development board
		P1DIR &= ~(0x01);

	break;

	/*//core supply voltage monitor delay interrupt
	case SYSSNIV_DLYLIFG:
	break;

	//interrupt supply voltage monitor delay interrupt
	case SYSSNIV_DLYHIFG:
	break;

	//Vacant memory access interrupt
	case SYSSNIV_VMAIFG:
	break;

	//JTAG mailbox in interrupt
	case SYSSNIV_JMBINIFG:
	break;

	//JTAG mailbox out interrupt
	case SYSSNIV_JMBOUTIFG:
	break;

	//SVMLVLRIFGSVMHVLRIFG
	case SYSSNIV_VLRLIFG:
		//clear interrupt flag bits
		//unlock PMM
		PMMCTL0_H=PMMPW_H;
		//clear interrupt flags
		PMMIFG&=~(SVMLIFG|SVMLVLRIFG);
		//lock PMM
		PMMCTL0_H=0;
	break;

	//SVMHVLRIFGSVMHVLRIFG
	case SYSSNIV_VLRHIFG:
		//clear interrupt flag bits
		//unlock PMM
		PMMCTL0_H=PMMPW_H;
		//clear interrupt flags
		PMMIFG&=~(SVMHIFG|SVMHVLRIFG);
		//lock PMM
		PMMCTL0_H=0;
	break;*/

	//Lock PMM registers for write access
	HWREG8(PMM_BASE + OFS_PMMCTL0_H) = 0x00;
  	}
}

Regards,

James

MSP Customer Applications

Hi Dhara,

Dhara Pandya said:

Thats totally fine... Thanks alot for your constant help.. I will check out your suggestion at my end...

Sounds good!

Dhara Pandya said:

Also, I want to ask one more thing.. How can we calculate KW..?? Right now I am taking instantaneous current and voltage and multiplying them.. do i need to find phase of V & I (cos (phi) / power factor for KW)..??

To get started, I'd recommend taking a look at the following two resources. They discuss key parameters that need to be calculated during energy measurement.

If you haven't already, I'd also recommend taking a look at the MSP430 Energy Library features. Some featured outputs include reactive, active, and apparent energy and power. If you have any further questions about the Energy Library, I'd recommend opening a new thread to maximize visibility to the community and our experts.

Regards,

James

MSP Customer Applications