MSP430 PWM generation with Varied steps from Interrupt

Hi Everyone,

I've been working on MSP430 Launchpad from few weeks. I've got an issue with evaluating some code in a project which i'm working on.
Please read ahead and help,

1. I have to vary PWM duty cycle in 6 steps by detecting interrupt from P3.1 switch on MSP Launchpad. After this is successful, I've to incorporate IR sensor and have to vary PWM Duty Cycle from that,which is secondary issue.

2. I tried ISR and varying PWM by 7.5% to 45%. This 45% is giving us max required output voltage (1.4 V). That method is only giving 4 steps variation,not 6 steps. 

3. And the present code which i sent has Switch-Case statement in which i'm varying according to the count of the interrupts. This is also giving me only 4 step variation. 

4. Is there anything wrong i'm doing in the code? Or having other time period will resolve?

Is there any other method? Should i use normal polling method or Watchdog timer for the count? If yes, how?

Please help me out in this issue.

Here's the code:

#include "msp430g2553.h"

float D = 7.5;
int /*total*/count = 0;

void main (void)
{
	//float T, X, D = 7;
	WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT

	  P1DIR |= BIT2;                       // P1.2 output
	  P1SEL |= BIT2;                       // P1.2 options select

	  P1REN |= BIT3;
	  P1IE |= BIT3; 					// P1.3 interrupt enabled
	  P1IES |= BIT3;
	  P1IFG &= ~BIT3; 					// P1.3 IFG cleared
	  __enable_interrupt();				 // enable all interrupts

	  TA0CCR0 = 100;                          // PWM Period
	  TA0CCTL1 = OUTMOD_7;                      // CCR1 reset/set
//	  X = D/100; T = 512 * X;
	  TA0CCR1 = 7.5;
	  TA0CTL = TASSEL_2 + MC_1 + TACLR;

	  __bis_SR_register(LPM0_bits);             // Enter LPM0
	  __no_operation();                         // For debugger

	while(1) {}


 }



#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{
//		if ( TA0CCR1 == 45 ) {
//			P1IFG &= ~BIT3;              // P1.3 IFG cleared
//			P1IES ^= BIT3;
//		}          			// toggle the interrupt edge,
//
//			else {

			count++;
				switch( count )
				{
				case 1: D = 15;
//				TA0CCR1 = ( 100 * (D/100) );
//								TA0CTL = TASSEL_2 + MC_1 + TACLR;
//						P1IFG &= ~BIT3;              // P1.3 IFG cleared
//						P1IES ^= BIT3;         			// toggle the interrupt edge,
					break;

				case 2: D = 22.5;
//				TA0CCR1 = ( 100 * (D/100) );
//								TA0CTL = TASSEL_2 + MC_1 + TACLR;
//						P1IFG &= ~BIT3;              // P1.3 IFG cleared
//						P1IES ^= BIT3;         			// toggle the interrupt edge,
					break;

				case 3: D = 30;
//				TA0CCR1 = ( 100 * (D/100) );
//								TA0CTL = TASSEL_2 + MC_1 + TACLR;
//						P1IFG &= ~BIT3;              // P1.3 IFG cleared
//						P1IES ^= BIT3;         			// toggle the interrupt edge,
					break;

				case 4: D = 37.5;
//				TA0CCR1 = ( 100 * (D/100) );
//								TA0CTL = TASSEL_2 + MC_1 + TACLR;
//						P1IFG &= ~BIT3;              // P1.3 IFG cleared
//						P1IES ^= BIT3;         			// toggle the interrupt edge,
					break;

				case 5: D = 45;
//				TA0CCR1 = ( 100 * (D/100) );
//								TA0CTL = TASSEL_2 + MC_1 + TACLR;
//						P1IFG &= ~BIT3;              // P1.3 IFG cleared
//						P1IES ^= BIT3;         			// toggle the interrupt edge,
					break;

				default : D = 7.5;
//				TA0CCR1 = ( 100 * (D/100) );
//								TA0CTL = TASSEL_2 + MC_1 + TACLR;
//						  P1IFG &= ~BIT3;              // P1.3 IFG cleared
//						  P1IES ^= BIT3;         			// toggle the interrupt edge,
						  count = 0;
					break;
				}
				TA0CCR1 = ( 100 * (D/100) );
				TA0CTL = TASSEL_2 + MC_1 + TACLR;
				P1IFG &= ~BIT3;              // P1.3 IFG cleared
				P1IES ^= BIT3;         			// toggle the interrupt edge,
}
//}