timer.c

Go to the documentation of this file.

/* timer.c --- 
 * 
 * Filename: timer.c
 * Description: 
 * Author: Bryce Himebaugh
 * Maintainer: 
 * Created: Mon Oct 16 11:03:33 2006
 * Version: 
 * Last-Updated: 
 *           By: 
 *     Update #: 0
 * Keywords: 
 * Compatibility: 
 * 
 */

/* Commentary: 
 * 
 * 
 * 
 */

/* Change log:
 * 
 * 
 */

/* This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/* Code: */
#include <msp430x16x.h>
#include <vcs_bsp/vcsbsp.h>
#include <signal.h>

volatile unsigned long TB0_edge_time = 0;
volatile unsigned long vspeed4_period_uS = 0;
volatile int vspeed4_data_ready=0;
volatile int tick_10mS=0;

void init_timer_a(void) {
  // SMCLK/8 SOURCE 
  // Timer in Continuous Mode 
  // 1mS interrupt rate 
  TACTL=TASSEL1|ID1|ID0|MC1|TACLR; 
  TACCTL0=CCIE;            
  TACCR0=50000;              
}

interrupt (TIMERA0_VECTOR) Timer_A0_Handler(void) {
  TACCR0+=10000;
  tick_10mS=1;
}

void init_timer_b(void) {
  // Timer Setup
  TBCTL = TBSSEL1+ID1+ID0+TBIE;          // SMCLK/8, Enable the Timer B interrupt, Timer off

  // TB0 Capture Setup 
  TBCCTL0 = CM0+CCIS0+SCS+CAP+CCIE;      // Rising Edge, Synchronize, Enable Interrupt   
  TBCCTL3 = CM0+CCIS0+SCS+CAP+CCIE;      // Rising Edge, Synchronize, Enable Interrupt   

  // Start Timer B 
  TBCTL |= MC1;                          // Continuous 16 bit counter mode 
}

interrupt (TIMERB0_VECTOR) Timer_B0(void) {
  static unsigned int TB0_edge_last = 0;
  static int TB0_indicator = 0;
  static unsigned int TB0_filter_index=0;
  static unsigned long TB0_filter_bank[8] = {TB0_PERIOD_MAX,TB0_PERIOD_MAX,TB0_PERIOD_MAX,TB0_PERIOD_MAX,
                                             TB0_PERIOD_MAX,TB0_PERIOD_MAX,TB0_PERIOD_MAX,TB0_PERIOD_MAX};
  unsigned int TB0_temp;
  unsigned long TB0_accumulator=0;
  int i;
  
  // TB0 Vspeed 4
  TB0_temp = TBCCR0;                              // Latch the timer value in the event that another edge arrives. 
  if ((TBCTL&TBIFG) && (TB0_temp<0x7fff)) {       // Handle case of timer overflow pending. TB0 is higher priority. 
    TB0_edge_time += (unsigned long) 0xFFFF;      // Add in the overflow value. 
    TBCTL&=~TBIFG;                                // Clear the int flag so that we do not handle this rollover again
  }

  // 1 or more rollovers have occured. 
  if (TB0_edge_time) {                            
    TB0_edge_time += (unsigned long) 0xFFFF - (unsigned long) TB0_edge_last + (unsigned long) TB0_temp;
    TB0_edge_time -= (unsigned long) 0xFFFF;
  }
  // No rollovers have occured.
  else {
    TB0_edge_time = (unsigned long) TB0_temp - (unsigned long) TB0_edge_last; 
  }
  
  // Clamp the largest possible period to TB0_PERIOD_MAX
  if (TB0_edge_time > TB0_PERIOD_MAX) {
      TB0_edge_time=TB0_PERIOD_MAX;
  }

  // Filter the signal
  TB0_filter_bank[TB0_filter_index++] = TB0_edge_time; // grab the latest data
  TB0_filter_index&=0x07;                              // Wrap the index to make the array circular     
  for (i=0;i<8;i++) {                                  // sweep through the array
    TB0_accumulator+=TB0_filter_bank[i];               // Sum the terms in the filter array   
  }
  TB0_accumulator>>=3;                                 // Divide by the array length (8);
  
  // report the new data if the last piece has been read. Prevents read coherency issue with unsigned long. 
  if (!vspeed4_data_ready) {
    vspeed4_period_uS = TB0_accumulator;// TB0_edge_time;// TB0_accumulator; // 
    vspeed4_data_ready=1;
  }

  // prepare for the next edge. 
  TB0_edge_last = TB0_temp;
  TB0_edge_time = 0;

  // Blink the TB0 Led 
  if ((TB0_indicator^=1)) {
    DS1_ON;
  }
  else {
    DS1_OFF;
  }
}

interrupt (TIMERB1_VECTOR) Timer_B1(void) {
  static int gps_pulse_indicator=0;
  static int gps_pulse_timeout=0;

  switch (TBIV) {
  case 0x02: 
    // TB1 VSpeed3
    break;
  case 0x04:
    // TB2 VSpeed2  
    break;
  case 0x06:
    // TB3 VSpeed1  
    if (gps_pulse_indicator) {
      DS4_ON;
    }
    else {
      DS4_OFF;
    }
    gps_pulse_indicator^=1;
    gps_pulse_timeout=0;
    break;
  case 8:
    // Channel 4
    break;
  case 0x0A:
    // Channel 5
  case 0x0C:
    // Channel 6
    break;
  case 0x0E:
    // Timer Overflow 
    TB0_edge_time += (unsigned long) 0xFFFF;
    if (TB0_edge_time > TB0_PERIOD_MAX) {
      TB0_edge_time=TB0_PERIOD_MAX;
      if (!vspeed4_data_ready) {
        vspeed4_period_uS = TB0_edge_time;
        vspeed4_data_ready=1;
      }
    }
    if (gps_pulse_timeout>7) {
      DS4_OFF;                        // if we have not seen a transition in 500mS then turn off the indicator LED. 
    }
    else {
      gps_pulse_timeout++;
    }

    break;
  }
}


/* timer.c ends here */

---