mc_timer.c

simulink real-time workshop for dragon12 development board from

  TSCR1 &= ~0x80;                    // stop timer (clear TEN bit)
  
}


/* set period for individual channels (OC) */
void TSetPeriod_OC(unsigned int channel, unsigned int reload_value) {

   switch(channel) {
        
      case 0:
        #if T0_MODE == TMode_OC
        TC0_ReloadValue = reload_value;
        TC0 = TC0_ReloadValue;
        #endif
        break;
      case 1:
        #if T1_MODE == TMode_OC
        TC1_ReloadValue = reload_value;
        TC1 = TC1_ReloadValue;
        #endif
        break;
      case 2:
        #if T2_MODE == TMode_OC
        TC2_ReloadValue = reload_value;
        TC2 = TC2_ReloadValue;
        #endif
        break;
      case 3:
        #if T3_MODE == TMode_OC
        TC3_ReloadValue = reload_value;
        TC3 = TC3_ReloadValue;
        #endif
        break;
      case 4:
        #if T4_MODE == TMode_OC
        TC4_ReloadValue = reload_value;
        TC4 = TC4_ReloadValue;
        #endif
        break;
      case 5:
        #if T5_MODE == TMode_OC
        TC5_ReloadValue = reload_value;
        TC5 = TC5_ReloadValue;
        #endif
        break;
      case 6:
        #if T6_MODE == TMode_OC
        TC6_ReloadValue = reload_value;
        TC6 = TC6_ReloadValue;
        #endif
        break;
      case 7:
        #if T7_MODE == TMode_OC
        TC7_ReloadValue = reload_value;
        TC7 = TC7_ReloadValue;
        #endif
        break;
        
   }

}


/* configure channels (OC/IC) */
void TChannel_Conf(unsigned int channel, unsigned int mode, float channelPeriod) {

unsigned int reload_value = (unsigned int)floor(65535 * channelPeriod / myECTperiod);

   switch(mode) {
    
      /* Output Compare mode */      
      case TMode_OC:
      
         /* set period */
         TSetPeriod_OC(channel, reload_value);
      
         TIOS  |= (0x01 << channel);			// Configure channel for output compare (OC) mode
         DDRT  |= (0x01 << channel);      // Port T, pin 'channel' is output
         
         //TCNT   = 0;                      // restart timer from scratch
         //TFLG1  = 0xff;                   // clear all pending interrupt requests 
      
      break;


      /* Input Capture mode */      
      case TMode_IC:
    
         TIOS  &= ~(0x01 << channel);			// Configure channel for input capture (IC) mode
         DDRT  &= ~(0x01 << channel);     // Port T, pin 'channel' is input
      
         /* configure for 'capture on rising edge' */
         if(channel < 4) {
        
            /* channels 0 - 3 */
            TCTL4 |=  (0x0001 << 2*channel);      // capture on rising edge (EDGxB|EDGxA = '01')
            TCTL4 &= ~(0x0002 << 2*channel);      // capture on rising edge (EDGxB|EDGxA = '01')
        
         } else {
        
            /* channels 4 - 7 */
            TCTL3 |=  (0x0001 << 2*(channel-4));  // capture on rising edge (EDGxB|EDGxA = '01')
            TCTL3 &= ~(0x0002 << 2*(channel-4));  // capture on rising edge (EDGxB|EDGxA = '01')
        
         }

   } /* switch(mode) */
  																				
}


/* enable o/p logic for individual channels (OC/IC) */
void TChannel_Enable(unsigned int channel) {

   /* start timer 'x' by enabling its interrupt (used to reload TCx)  */
   TFLG1 |= (0x01 << channel);           // clear event flag for channel 'x'
   TIE   |= (0x01 << channel);           // enable channel 'x' interrupt

}


/* stop individual channels (OC/IC) */
void TChannel_Disable(unsigned int channel) {

   /* stop timer 'x' by disabling the channel interrupt */
   TIE   &= ~(0x01 << channel);           // disable channel 'x' interrupt
   TFLG1 |=  (0x01 << channel);           // clear event flag for channel 'x'
   PTT   &= ~(0x01 << channel);           // Port T, pin 'channel' low

}


/* read out IC channel and scale to time */
float TChannel_ICresult(unsigned int channel) {

   switch(channel) {
        
     case 0:
       #if T0_MODE == TMode_IC
       return ((float)TC0_diff)/65535*myECTperiod;
       #endif
       break;
     case 1:
       #if T1_MODE == TMode_IC
       return ((float)TC1_diff)/65535*myECTperiod;
       #endif
       break;
     case 2:
       #if T2_MODE == TMode_IC
       return ((float)TC2_diff)/65535*myECTperiod;
       #endif
       break;
     case 3:
       #if T3_MODE == TMode_IC
       return ((float)TC3_diff)/65535*myECTperiod;
       #endif
       break;
     case 4:
       #if T4_MODE == TMode_IC
       return ((float)TC4_diff)/65535*myECTperiod;
       #endif
       break;
     case 5:
       #if T5_MODE == TMode_IC
       return ((float)TC5_diff)/65535*myECTperiod;
       #endif
       break;
     case 6:
       #if T6_MODE == TMode_IC
       return ((float)TC6_diff)/65535*myECTperiod;
       #endif
       break;
     case 7:
       #if T7_MODE == TMode_IC
       return ((float)TC7_diff)/65535*myECTperiod;
       #endif
       break;

   }
   
   /* should never reached */
   return -1.0;
      
}




/* interrupt service handlers for timer blocks - RFComms ISR is defined in 'radioServer.c' or 'radioClient.c' */
#pragma CODE_SEG __NEAR_SEG NON_BANKED /* Interrupt section for this module. Placement will be in NON_BANKED area. */


#if HAS_TIMERBLOCKS > 0


/* interrupt handler, timer 0 (vector 8) */
__interrupt void T0_ISR(void) {
  
  #if T0_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x01;    // toggle timer pin
    TC0 = (unsigned int)(TC0 + TC0_ReloadValue);
  #endif
  
  #if T0_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC0;

    if(TC0_Capture_last < TCx_latch)
      TC0_diff = TCx_latch - TC0_Capture_last;
    else
      TC0_diff = 65535 - TC0_Capture_last + TCx_latch;
    
    TC0_Capture_last = TCx_latch;
  #endif
  
  TFLG1 = 0x01;          // acknowledge interrupt (clears C0F)
  
}

/* interrupt handler, timer 1 (vector 9) */
__interrupt void T1_ISR(void) {
  
  
  #if T1_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x02;    // toggle timer pin
    TC1 = (unsigned int)(TC1 + TC1_ReloadValue);
  #endif
  
  #if T1_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC1;
    
    if(TC1_Capture_last < TCx_latch)
      TC1_diff = TCx_latch - TC1_Capture_last;
    else
      TC1_diff = 65535 - TC1_Capture_last + TCx_latch;
    
    TC1_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x02;          // acknowledge interrupt (clears C1F)
  
}

/* interrupt handler, timer 2 (vector 10) */
__interrupt void T2_ISR(void) {
  
  #if T2_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x04;    // toggle timer pin
    TC2 = (unsigned int)(TC2 + TC2_ReloadValue);
  #endif
  
  #if T2_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC2;
    
    if(TC2_Capture_last < TCx_latch)
      TC2_diff = TCx_latch - TC2_Capture_last;
    else
      TC2_diff = 65535 - TC2_Capture_last + TCx_latch;
    
    TC2_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x04;          // acknowledge interrupt (clears C2F)
  
}

/* interrupt handler, timer 3 (vector 11) */
__interrupt void T3_ISR(void) {
  
  #if T3_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x08;    // toggle timer pin
    TC3 = (unsigned int)(TC3 + TC3_ReloadValue);
  #endif
  
  #if T3_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC3;
    
    if(TC3_Capture_last < TCx_latch)
      TC3_diff = TCx_latch - TC3_Capture_last;
    else
      TC3_diff = 65535 - TC3_Capture_last + TCx_latch;
    
    TC3_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x08;          // acknowledge interrupt (clears C3F)
  
}

/* interrupt handler, timer 4 (vector 12) */
__interrupt void T4_ISR(void) {
  
  #if T4_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x10;    // toggle timer pin
    TC4 = (unsigned int)(TC4 + TC4_ReloadValue);
  #endif
  
  #if T4_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC4;
    
    if(TC4_Capture_last < TCx_latch)
      TC4_diff = TCx_latch - TC4_Capture_last;
    else
      TC4_diff = 65535 - TC4_Capture_last + TCx_latch;
    
    TC4_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x10;          // acknowledge interrupt (clears C4F)
  
}

/* interrupt handler, timer 5 (vector 13) */
__interrupt void T5_ISR(void) {
  
  #if T5_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x20;    // toggle timer pin
    TC5 = (unsigned int)(TC5 + TC5_ReloadValue);
  #endif
  
  #if T5_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC5;
    
    if(TC5_Capture_last < TCx_latch)
      TC5_diff = TCx_latch - TC5_Capture_last;
    else
      TC5_diff = 65535 - TC5_Capture_last + TCx_latch;
    
    TC5_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x20;          // acknowledge interrupt (clears C5F)
  
}

/* interrupt handler, timer 6 (vector 14) */
__interrupt void T6_ISR(void) {
  
  #if T6_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x40;    // toggle timer pin
    TC6 = (unsigned int)(TC6 + TC6_ReloadValue);
  #endif
  
  #if T6_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC6;
    
    if(TC6_Capture_last < TCx_latch)
      TC6_diff = TCx_latch - TC6_Capture_last;
    else
      TC6_diff = 65535 - TC6_Capture_last + TCx_latch;
    
    TC6_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x40;          // acknowledge interrupt (clears C6F)
  
}

/* interrupt handler, timer 7 (vector 15) */
__interrupt void T7_ISR(void) {
  
  #if T7_MODE == TMode_OC
    /* OC mode */
    PTT ^= 0x80;    // toggle timer pin
    TC7 = (unsigned int)(TC7 + TC7_ReloadValue);
  #endif
  
  #if T7_MODE == TMode_IC
    /* IC mode */
    TCx_latch = TC7;
    
    if(TC7_Capture_last < TCx_latch)
      TC7_diff = TCx_latch - TC7_Capture_last;
    else
      TC7_diff = 65535 - TC7_Capture_last + TCx_latch;
    
    TC7_Capture_last = TCx_latch;
  #endif

  TFLG1 = 0x80;          // acknowledge interrupt (clears C7F)
  
}

#endif /* HAS_TIMERBLOCKS */



/* the TOF interrupt handler is included whenever HAS_TIMERBLOCKS or HAS_RFCOMMS are non-zero */
/* timer overflow interrupt handler (vector 16) */
__interrupt void TOF_ISR(void) {

  /* count TOF interrupts */
  myTOFcounter++;
  
  TFLG2 = 0x80;          // acknowledge interrupt (clears TOF)
  
}



#pragma CODE_SEG DEFAULT
/* end of interrupt service handler section ===================================   */


#endif /* HAS_TIMERBLOCKS | HAS_RFCOMMS*/