msp430/main.c

   1 #include <msp430.h>
   2
   3 static volatile unsigned int ADC_Result;
   4 static volatile unsigned int irq_events = 0;
   5 enum {ev_btn1 = 0, ev_btn2, ev_pir1, ev_pir2, ev_tmr, ev_adc, ev_MAX};
   6
   7 int main(void)
   8 {
   9         int Duty_Cycle = 1;
  10         int Increment = 1;
  11         unsigned int Time_Count = 0;
  12         unsigned int Time_Left = 5;
  13
  14         WDTCTL = WDTPW | WDTHOLD;       // stop watchdog timer
  15         // Configure GPIO Out
  16         P1DIR |= BIT0|BIT1|BIT2;        // Set LEDs & PWM to output direction
  17         P1OUT &= ~(BIT0|BIT1);          // P1.0&1 LEDs off
  18         P1SEL1 |= BIT2;                 // P1.2 PWM out
  19
  20         // Configure GPIO In
  21         P2DIR &= ~(BIT3|BIT7);          // Buttons
  22         P2OUT |= BIT3|BIT7;             // Pull up
  23         P2REN |= BIT3|BIT7;             // Enable pull-up
  24         P2IES |= BIT3|BIT7;             // INT on Hi->Lo edge
  25         P2IE  |= BIT3|BIT7;             // INT enable
  26
  27         P2DIR &= ~(BIT2|BIT5);          // PIR Sensors
  28         P2OUT &= ~(BIT2|BIT5);          // Pull down
  29         P2REN |= BIT2|BIT5;             // Enable pull-down
  30         P2IES &= ~(BIT2|BIT5);          // INT on Lo->Hi edge
  31         P2IE  |= BIT2|BIT5;             // INT enable
  32
  33         // Configure ADC A7 pin
  34         SYSCFG2 |= ADCPCTL7;
  35
  36         // Configure ADC10
  37         ADCCTL0 |= ADCSHT_2 | ADCON;    // ADCON, S&H=16 ADC clks
  38         ADCCTL1 |= ADCSHP;              // ADCCLK = MODOSC; sampling timer
  39         ADCCTL2 |= ADCRES;              // 10-bit conversion results
  40         ADCMCTL0 |= ADCINCH_7;          // A7 ADC input select; Vref=AVCC
  41         ADCIE |= ADCIE0;                // Enable ADC conv complete interrupt
  42
  43         // Configure timer A0 for PWM
  44         TA0CCR0 = 10000-1;              // PWM Period
  45         TA0CCTL2 = OUTMOD_7;            // CCR2 reset/set
  46         TA0CCR2 = 500;                  // CCR2 PWM duty cycle
  47         TA0CTL = TASSEL__SMCLK | MC__UP | TACLR;        // SMCLK, up mode, clear TAR
  48
  49         //Configure timer A1 for counting time
  50         TA1CTL |= TASSEL__SMCLK | MC__CONTINUOUS | TACLR | TAIE;        // SMCLK, no divider, continuous mode
  51
  52         // Disable the GPIO power-on default high-impedance mode to activate
  53         // previously configured port settings
  54         PM5CTL0 &= ~LOCKLPM5;
  55
  56         while(1)
  57         {
  58                 unsigned int events;
  59
  60                 _disable_interrupts();
  61                 events = irq_events;
  62                 irq_events = 0;
  63                 _enable_interrupts();
  64
  65                 // Button 2 or PIR events initiate light measurement and tuns on green led
  66                 if (events & (1<<ev_btn2|1<<ev_pir1|1<<ev_pir2)) {
  67                         if (Duty_Cycle > 1) {
  68                                 Time_Left = 15;
  69                                 continue;
  70                         }
  71                         ADCCTL0 |= ADCENC | ADCSC;      // Sampling and conversion start
  72                         P1OUT |= BIT1;  // Set P1.1 LED on
  73                 }
  74
  75                 // End of light measurement, set new Duty_Cycle and zero increment and tuns off green led
  76                 if (events & 1<<ev_adc) {
  77                         P1OUT &= ~BIT1; // Clear P1.1 LED off
  78                         if (Time_Left)
  79                                 continue;
  80                         if (ADC_Result < 200)
  81                                 continue;
  82                         Time_Left = 15;
  83                         Increment = 1;
  84                 }
  85
  86                 // Button 1 sets non-zero increment (and toggles it)
  87                 if (events & 1<<ev_btn1) {
  88                         if (Duty_Cycle > 5000) {
  89                                 Time_Left = 0;
  90                                 Increment = -1;
  91                         } else {
  92                                 Time_Left = 15;
  93                                 Increment = 1;
  94                         }
  95                 }
  96
  97                 // Timer event (100 ms) changed duty cycle and flashes red led
  98                 if (events & 1<<ev_tmr) {
  99                         if (Time_Count++ > 10) {
 100                                 Time_Count = 0;
 101                                 P1OUT ^= BIT0;
 102                                 if (Time_Left)
 103                                         Time_Left--;
 104                                 else if (Duty_Cycle > 1)
 105                                         Increment = -1;
 106                         }
 107                         if (Increment == 0)
 108                                 continue;
 109                         else if (Increment > 0)
 110                                 Duty_Cycle *= 2;
 111                         else if (Increment < 0)
 112                                 Duty_Cycle /= 2;
 113                         if (Duty_Cycle < 1) {
 114                                 Duty_Cycle = 1;
 115                                 Increment = 0;
 116                         }
 117                         if (Duty_Cycle > (10000-1)) {
 118                                 Duty_Cycle = 10000-1;
 119                                 Increment = 0;
 120                         }
 121                         TA0CCR2 = Duty_Cycle;
 122                 }
 123                 __bis_SR_register(LPM0_bits | GIE);
 124                 __no_operation();
 125         }
 126         return 0; /* not reached */
 127 }
 128
 129 // TIMER interrupt routine
 130 #if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
 131 #pragma vector = TIMER1_A1_VECTOR
 132 __interrupt void Timer_A (void)
 133 #elif defined(__GNUC__)
 134 void __attribute__ ((interrupt(TIMER1_A1_VECTOR))) Timer_A (void)
 135 #else
 136 #error Compiler not supported!
 137 #endif
 138 {
 139         switch(__even_in_range(TA1IV,TA1IV_TAIFG))
 140         {
 141                 case TA1IV_NONE:
 142                         break;  // No interrupt
 143                 case TA1IV_TACCR1:
 144                         break;  // CCR1 not used
 145                 case TA1IV_TACCR2:
 146                         break;  // CCR2 not used
 147                 case TA1IV_TAIFG:
 148                         irq_events |= 1<<ev_tmr;
 149                         __bic_SR_register_on_exit(LPM0_bits);   // Clear CPUOFF bit from LPM0
 150                         break;
 151                 default:
 152                         break;
 153         }
 154         //if (Time_Count++ > 1000) {
 155         //    Time_Count = 0;
 156         //    __bic_SR_register_on_exit(LPM0_bits);     // Clear CPUOFF bit from LPM0
 157         //}
 158 }
 159
 160 // ADC interrupt service routine
 161 #if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
 162 #pragma vector=ADC_VECTOR
 163 __interrupt void ADC_ISR(void)
 164 #elif defined(__GNUC__)
 165 void __attribute__ ((interrupt(ADC_VECTOR))) ADC_ISR (void)
 166 #else
 167 #error Compiler not supported!
 168 #endif
 169 {
 170         switch(__even_in_range(ADCIV,ADCIV_ADCIFG))
 171         {
 172                 case ADCIV_NONE:
 173                         break;
 174                 case ADCIV_ADCOVIFG:
 175                         break;
 176                 case ADCIV_ADCTOVIFG:
 177                         break;
 178                 case ADCIV_ADCHIIFG:
 179                         break;
 180                 case ADCIV_ADCLOIFG:
 181                         break;
 182                 case ADCIV_ADCINIFG:
 183                         break;
 184                 case ADCIV_ADCIFG:
 185                         ADC_Result = ADCMEM0;
 186                         irq_events |= 1<<ev_adc;
 187                         __bic_SR_register_on_exit(LPM0_bits);   // Clear CPUOFF bit from LPM0
 188                         break;
 189                 default:
 190                         break;
 191         }
 192 }
 193
 194 // GPIO interrupt service routine
 195 #if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
 196 #pragma vector=PORT2_VECTOR
 197 __interrupt void Port_2(void)
 198 #elif defined(__GNUC__)
 199 void __attribute__ ((interrupt(PORT2_VECTOR))) Port_2 (void)
 200 #else
 201 #error Compiler not supported!
 202 #endif
 203 {
 204         if (P2IFG & BIT3) {
 205                 irq_events |= 1<<ev_btn1;
 206                 P2IFG &= ~BIT3; // Clear P1.3 IFG
 207         }
 208         if (P2IFG & BIT7) {
 209                 irq_events |= 1<<ev_btn2;
 210                 P2IFG &= ~BIT7; // Clear P1.3 IFG
 211         }
 212         if (P2IFG & BIT2) {
 213                 irq_events |= 1<<ev_pir1;
 214                 P2IFG &= ~BIT2; // Clear P1.4 IFG
 215         }
 216         if (P2IFG & BIT5) {
 217                 irq_events |= 1<<ev_pir2;
 218                 P2IFG &= ~BIT5; // Clear P1.7 IFG
 219         }
 220         __bic_SR_register_on_exit(LPM3_bits);   // Exit LPM3
 221 }