// Chapter 6 9S12C32 C programs
// Jonathan W. Valvano, 2/07/07
// This software accompanies the book,
// Embedded Microcomputer Systems: Real Time Interfacing, Second Edition
// published by Thomson Engineering, 2006


// MC9S12C32, CodeWarrior C
// PT3 input = external signal
unsigned short Time;   // incremented
void Init(void){
  asm sei       // make atomic
  TIOS &=~0x08; // PT3 input capture
  DDRT &=~0x08; // PT3 is input
  TSCR1 = 0x80; // enable TCNT
  TSCR2 = 0x01; // 500ns clock
  TCTL4 = (TCTL4&0x3F)|0x40;
  TIE |= 0x08;  // Arm IC3, rising
  TFLG1 = 0x08; // initially clear  
  Time = 0;  
  asm cli
}
void interrupt 11 IC3Han(void){ 
  TFLG1 = 0x08;   // acknowledge
  Time++;
}    
// Program 6.2. Periodic interrupt using input capture and an external clock.



								 
// MC9S12C32, CodeWarrior C
// PT1/IC1 input = external signal
// rising edge to rising edge
// resolution = 500ns 
// Range = 36 us to 32 ms, 
// no overflow checking
unsigned short Period;  // 500 ns units
unsigned short First;   // TCNT first edge
unsigned char Done;     // Set each rising 
void Init(void){
  asm sei         // make atomic 
  TIOS &=~0x02;   // PT1 input capture
  DDRT &=~0x02;   // PT1 is input
  TSCR1 = 0x80;   // enable TCNT
  TSCR2 = 0x01;   // 500ns clock
  TCTL4 = (TCTL4&0xF3)|0x04; // rising
  First = TCNT;   // first will be wrong
  Done = 0;       // set on subsequent
  TFLG1 = 0x02;   // Clear C1F 
  TIE |= 0x02;    // Arm IC1 
  asm cli
}
void interrupt 9 TC1handler(void){
  Period = TC1-First; // 500ns resolution  
  First = TC1;   // Setup for next
  TFLG1 = 0x02;  // ack by clearing C1F
  Done = 0xFF;
}
// Program 6.4. C language period measurement.


 


// MC9S12C32, CodeWarrior C
unsigned short MsPeriod,LsPeriod;    
unsigned short First;     
unsigned short Count;     
unsigned char Mode;
void interrupt 16 TOhandler(void){
  TFLG2 = 0x80;  // ack        
  Count++;
  if(Count==65535){ // 35 minutes
    MsPeriod=LsPeriod=65535;
    TIE=0x00; TSCR2=0x00;  // Disarm
    Mode = 2;      // done
  }
}
void interrupt 9 TIC1handler(void){
  if(Mode==0){ // first edge
    First = TC1; Count=0; 
    Mode=1;    
    if(((TC1&0x8000)==0)
       &&(TFLG2&0x80)) Count--;
  }
  else{        // second edge
    if(((TC1&0x8000)==0)
        &&(TFLG2&0x80)) Count++;
    Mode = 2;  // measurement done
    MsPeriod = Count; 
    LsPeriod = TC1-First;
    if(TC1<First){
      MsPeriod--; // borrow
    } 
    TIE=0x00; TSCR2=0x00; // Disarm
  } 
  TFLG1 = 0x02;   // ack, clear C1F
}
void Init(void){
  asm sei       // make atomic 
  TIOS &=~0x02;  // PT1 input capture
  DDRT &=~0x02;  // PT1 is input
  TSCR2 = 0x81 ; // Arm, TOF 30.517Hz 
  TSCR1 = 0x80;  // enable counter
  TFLG1 = 0x02;  // Clear C1F 
  TIE |= 0x02;   // Arm IC1, C1I=1
  TCTL4 = (TCTL4&0xF3)|0x04; // rising
  TFLG2 = 0x80;  // Clear TOF 
  Mode = 0;      // searching for first
  asm cli 
}
// Program 6.5. C language 32-bit period measurement.


// MC9S12C32
unsigned short Measure(void) { 
unsigned short Rising;
  TCTL4 = (TCTL4&0xCF)|0x10; // Rising 
  TFLG1 = 0x04;   // clear C2F 
  PORTB&=~0x80;
  PORTB|= 0x80;   // rising edge on PB7 
  while(TFLG1&0x04==0){}; // wait for rise
  Rising = TC2;   // TCNT at rising edge 
  TFLG1 = 0x04;   // clear C2F 
  TCTL4 = (TCTL4&0xCF)|0x20; // Falling
  while(TFLG1&0x04==0){}; // wait for fall
  return(TC2-Rising-1000); } 
void Init(void){
  DDRB |= 0x80;  // PB7 is output
  TIOS &=~0x04;  // clear bit 2
  DDRT &=~0x04;  // PT2 is input capture
  TSCR1 =0x80;   // enable
  TSCR2 =0x01;   // 500 ns clock
  TIE = 0x00;}   // no interrupts
// Program 6.7. C language pulse-width measurement.


 


// MC9S12C32, CodeWarrior C
unsigned short PW;     // units of 500 ns 
unsigned short Rising; // TCNT at rising
unsigned char Done;  // Set each falling
void interrupt 9 TC1handler(void){
  if(PTT&0x02){    // PT1=1 if rising
    Rising = TC1;  // Setup for next
  }
  else{   
    PW = TC1-Rising; // measurement 
    Done = 0xFF;     
  }
  TFLG1 = 0x02;   // ack, clear C1F 
} 
void Init(void) { 
  asm sei      // make atomic
  TIOS &=~0x02;   // clear bit 1
  DDRT &=~0x02;   // PT1 is input capture
  TSCR1 =0x80;    // enable
  TSCR2 =0x01;    // 500 ns clock
  TCTL4|=0x0C;    // Both edges IC1
  TIE |= 0x02;    // arm IC1
  TFLG1 = 0x02;   // clear C1F 
  Done = 0;
  asm cli
}      
// Program 6.8. C language pulse-width measurement.

// MC9S12C32, CodeWarrior C
unsigned short PW;   // units of 500 ns 
unsigned char Done;  // Set each falling

void interrupt 9 TIC1handler(void){
  TFLG1 = 0x02;  // ack C1F
  PW = TC1-TC2;  // from rise to fall
  Done = 0xFF;
} 
void Init(void) { 
  asm sei       // make atomic
  TIOS &=~0x06;   // clear bits 2,1
  DDRT &=~0x06;   // PT2,PT1 input captures
  TSCR1 = 0x80;   // enable
  TSCR2 = 0x01;   // 500 ns clock
  TCTL4 =(TCTL4&0xCF)|0x10; // IC2 Rise
  TCTL4 =(TCTL4&0xF3)|0x08; // IC1 Fall
  Done = 0;     // set on the falling edge
  TIE |= 0x02;  // arm IC1, not IC2
  TFLG1 = 0x02; // clear C1F 
  asm cli
}    
// Program 6.9. C language pulse-width measurement using two input captures.
 
 
 


// MC9S12C32, CodeWarrior C
unsigned short Period;   // in usec 
// Number of Cycles Low and High  
void interrupt 11 TC3handler(void){ 
  TFLG1 = 0x08;     // ack C3F 
  TC3 = TC3+Period; // calculate Next
}
void ritual(void) { 
  asm sei        // make atomic
  TIOS |= 0x08;  // enable OC3
  DDRT |= 0x08;  // PT3 is output
  TSCR1 = 0x80;  // enable
  TSCR2 = 0x01;  // 500 ns clock
  TCTL2 = (TCTL2&0x3F)|0x40; // toggle
  TIE |= 0x08;   // Arm output compare 3
  TFLG1 = 0x08;  // Initially clear C3F
  TC3 = TCNT+50; // First one in 25 us
  asm cli 
} 
//  Program 6.11. C language squarewave using output compare.
 
// MC9S12C32, CodeWarrior C
unsigned short High; // Cycles High
unsigned short Low;  // Cycles Low  
// Period is High+Low Cycles
void interrupt 11 TC3handler (void){
  TFLG1 = 0x08;     // ack C3F 
  if(PTT&0x08){     // PT3 is now high 
    TC3 = TC3+High; // 1 for High cyc
  }
  else{             // PT3 is now low
    TC3 = TC3+Low;  // 0 for Low cycles 
  }
}
void Init(void){ 
  asm sei        // make atomic
  TIOS |= 0x08;  // enable OC3
  DDRT |= 0x08;  // PT3 is output
  TSCR1 = 0x80;  // enable
  TSCR2 = 0x01;  // 500 ns clock
  TIE |= 0x08;   // Arm output compare 3
  TFLG1 = 0x08;  // Initially clear C3F
  TCTL2 = (TCTL2&0x3F)|0x40; // toggle
  TC3 = TCNT+50; // first right away 
  asm cli 
}
// Program 6.13. C language pulse-width modulated squarewave using output compare.



 

// MC9S12C32
void Pulse(unsigned short Delay,
     unsigned short Width){
  asm sei         // make atomic
  TIOS |= 0x08;   // enable OC3
  DDRT |= 0x08;   // PT3 is output
  TSCR1 = 0x80;   // enable
  TSCR2 = 0x01;   // 500 ns clock
  TC7 = TCNT+Delay;
  TC3 = TC7+Width;
  OC7M = 0x08;    // connect OC7 to PT3
  OC7D = 0x08;    // PT3=1 when TC7=TCNT  
  TCTL2=(TCTL2&0x3F)|0x80; 
// PT3=0 when TC3=TCNT
  TFLG1 = 0x08;    // Clear C3F 
  TIE |= 0x08;     // Arm C3F
  asm cli
}
void interrupt 11 TC3handler(void){
  OC7M = 0;  // disconnect OC7 from PT3
  OC7D = 0; 
  TCTL2 &=~0xC0;  // disable OC3
  TIE &= ~0x08;   // disarm C3F
}  
//Program 6.14. C language delayed pulse output using output compare.

 


// MC9S12C32, CodeWarrior C
void interrupt 9 TC1handler(void){
  Count++;      // number of rising edges 
  TFLG1 = 0x02; // ack, clear C1F
}
#define Rate 20000  //  10 ms 
void interrupt 13 TC5handler(void){
  TFLG1= 0x20;      // Acknowledge 
  TC5 =  TC5+Rate;  // every 10 ms 
  Freq = Count;     // 100 Hz units
  Done = 0xff;
  Count = 0;        // Setup for next
} 
void Init(void) { 
  asm sei       // make atomic 
  TIOS |= 0x20; // enable OC5
  TSCR1 = 0x80; // enable
  TSCR2 = 0x01; // 500 ns clock          
  TIE |= 0x22;  // Arm OC5 and IC1
  TC5 = TCNT+Rate;   // First in 10 ms 
  TCTL4 = (TCTL4&0xF3)|0x04; 
/* C1F set on rising edges */
  Count = 0;    // Set up for first 
  Done = 0;     // Set on measurements 
  TFLG1 = 0x22; // clear C5F, C1F 
  asm cli 
}
// Program 6.15. C language frequency measurement.
 


// MC9S12C32, CodeWarrior C
#define RESOLUTION 2000
void interrupt 11 TC3handler(void){  
  TFLG1 = 0x08;         // Acknowledge 
  TC3 = TC3+RESOLUTION; // every 1 ms 
  Cnt++;
  if(Cnt==0) OverFlow=0xFF;
}
void interrupt 9 TC1handler(void){
  TFLG1 = 0x02;   // ack, clear C1F
  if(OverFlow){
    Period = 65535; // greater than 65535
    OverFlow = 0;
  }
  else
    Period = Cnt;
  Cnt = 0;   // start next measurement
  Done = 0xFF;
}
void Ritual(void){
  asm sei        // make atomic 
  TIOS |= 0x08;  // enable OC3
  TSCR1  = 0x80; // enable
  TSCR2 = 0x01;  // 500 ns clock          
  TFLG1 = 0x0A;  // Clear C3F,C1F 
  TIE = 0x0A;    // Arm OC3 and IC1 
  TCTL4 = (TCTL4&0xF3)|0x04; 
/* C1F set on rising edges */
  while((TFLG1&0x02)==0); // wait rising
  TFLG1 = 0x02;    // Clear C1F 
  TC3 = TCNT+RESOLUTION;
  Cnt=0; OverFlow=0; Done=0;
  asm cli 
} 
// Program 6.16. C language implementation of period measurement.
 


// MC9S12C32, CodeWarrior C
#define PERIOD 50000  //  25 ms 
void interrupt 9 TC1handler(void){
  Count++;       // number of rising edges
  TFLG1 = 0x02;  // ack, clear C1F
}
void interrupt 13 TC5handler(void){ 
  TFLG1 = 0x20;      // Acknowledge 
  TC5 = TC5+PERIOD;  // every 25 ms
  if (++FourHundred==400){
    Freq = Count;    //  0.1 Hz units 
    FourHundred = 0;
    Done = 0xff;
    Count = 0;     // Setup for next
  }
}
void Init(void) { 
asm sei          // make atomic 
  TIOS| = 0x20;  // enable OC5
  TSCR1  = 0x80; // enable
  TSCR2 = 0x02;  // 500 ns clock          
  TIE = 0x22;    // Arm OC5 and IC1 
  TCTL4 = (TCTL4&0xF3)|0x04; // rising
  Count = 0;     // Set up for first
  Done = 0;      // Set on measurement
  FourHundred = 0;
  TC5 = TCNT+PERIOD; // First in 25 ms 
  TFLG1 = 0x22;      // Clear C5F,C1F 
asm cli 
}
// Program 6.17. C language implementation of frequency measurement.

// MC9S12C32 C
// 10ms PWM on PT0
void PWM_Init(void){
  MODRR |= 0x01;   // PT0 with PWM
  PWME |= 0x01;    // enable channel 0
  PWMPOL |= 0x01;  // PT0 high then low
  PWMCLK |= 0x01;  // Clock SA
  PWMPRCLK = (PWMPRCLK&0xF8)|0x04; // A=E/16
  PWMSCLA = 5;     // SA=A/10, 0.25*160=40us
  PWMPER0 = 250;   // 10ms period
  PWMDTY0 = 0;     // initially off
}
// Set the duty cycle on PT0 output
void PWM_Duty0(unsigned char duty){
  PWMDTY0 = duty; // 0 to 250
}
// Program 6.20 Implementation of an 8-bit PWM output.

// MC9S12C32 C
// 1s PWM on PT3
void PWM_Init(void){
  MODRR |= 0x08;  // PT3 with PWM
  PWME |= 0x08;   // enable channel 3
  PWMPOL |= 0x08; // PT3 high then low
  PWMCLK &=~0x08; // Clock B
  PWMCTL |= 0x20; // Concatenate 2+3
  PWMPRCLK = (PWMPRCLK&0x8F)|0x60; // B=E/64
  PWMPER23 = 62500; // 1s period
  PWMDTY23 = 0;     // initially off
}
// Set the duty cycle on PT3 output
void PWM_Duty(unsigned short duty){
  PWMDTY23 = duty; // 0 to 62500
}
// Program 6.21 Implementation of an 8-bit PWM output.





//  Program 6.3. Periodic interrupt using input capture and an external clock.
// MC68HC812A4
// PT3 input = external signal
unsigned int TIME;   // incremented
void Init(void){
asm(" sei");   // make atomic
   TIOS &= 0xF7; // PT3 input capture
   DDRT &= 0xF7; // PT3 is input
   TSCR = 0x80;  // enable TCNT
   TMSK2= 0x32;  // 500ns clock
   TCTL4 = (TCTL4&0x3F)|0x40;
   TMSK1 |= 0x08;  // Arm IC3
   TFLG1=0x08; // initially clear  
   TIME=0;  
asm(" cli");}
#pragma interrupt_handler IC3Han
void IC3Han(void){ 
    if((TFLG1&0x08)==0) asm(" swi");
    TFLG1=0x08;   // acknowledge
    TIME++;} 


//  Program 6.6. C language period measurement.
// MC68HC812A4
// PT1/IC1 input = external signal
// rising edge to rising edge
// resolution = 500ns 
// Range = 36 µs to 32 ms, 
// no overflow checking
// IC1 interrupt each period,
unsigned int Period;  // units of 500 ns
unsigned int First;   // TCNT first edge
unsigned char Done;   // Set each rising 
void Ritual(void){
    asm(" sei");    // make atomic 
    TIOS &= 0xFD;   // PT1 input capture
    DDRT &= 0xFD;   // PT1 is input
    TSCR = 0x80;    // enable TCNT
    TMSK2= 0x32;    // 500ns clock
    TCTL4 = (TCTL4&0xF3)|0x04; // rising
    First = TCNT;   // first will be wrong
    Done=0;         // set on subsequent
    TFLG1 = 0x02;   // Clear C1F 
    TMSK1 |= 0x02;  // Arm IC1 
    asm(" cli");}
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
    Period=TC1-First;   
    First=TC1;   // Setup for next
    TFLG1=0x02;  // ack by clearing C1F
    Done=0xFF;}

//  Program 6.10. C language 32-bit period measurement.
// MC68HC812A4
unsigned int MsPeriod,LsPeriod;    
unsigned int First;     
unsigned int Count;     
unsigned char Mode;
#pragma interrupt_handler TOhandler()
void TOhandler(void){
     TFLG2=0x80;         
     Count++;
     if(Count==65535){ // 35 minutes
        MsPeriod=LsPeriod=65535;
        TMSK1=0x00; 
        TMSK2=0x00;  // Disarm
        Mode=2;}}
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
  if(Mode==0){
    First = TC1; Count=0; Mode=1;
    if(((TC1&0x8000)==0)
       &&(TFLG2&0x80)) Count--;}
    else {
      if(((TC1&0x8000)==0)
        &&(TFLG2&0x80))Count++;
      MsPeriod=Count; Mode=2;
      LsPeriod=TC1-First;
      if (TC1<First) MsPeriod--; 
      TMSK1=0x00; TMSK2=0x00;} // Disarm 
  TFLG1=0x02;}  // ack, clear C1F
void Ritual(void){
  asm(" sei");    // make atomic 
  TIOS &= 0xFD;   // PT1 input capture
  DDRT &= 0xFD;   // PT1 is input
  TMSK2=0xB2 ;    // Arm, TOF 30.517Hz 
  TSCR=0x80;      // enable counter
  TFLG1 = 0x02;   // Clear C1F 
  TMSK1 |= 0x02;  // Arm IC1, C1I=1
  TCTL4 = (TCTL4&0xFC)|0x04; // rising
  TFLG2 = 0x80;   // Clear TOF 
  Mode=0; 
  asm(" cli"); }

//  Program 6.13. C language pulse width measurement.
// MC68HC812A4
unsigned int Measure(void) { 
unsigned int Rising;
 TCTL4=(TCTL4&0xCF)|0x10; // Rising edge
 TFLG1=0x04;      // clear C2F 
 PORTB&=0x7F;
 PORTB|=0x80;     // rising edge on PB7 
 while(TFLG1&0x04==0){}; // Wait for rise
 Rising=TC2;     // TCNT at rising edge 
 TCTL4=(TCTL4&0xCF)|0x20; // Falling edge
 while(TFLG1&0x04==0){}; // Wait for fall
 return(TC2-Rising-1000); } 
void Init(void){
 DDRB|=0x80;  // PB7 is output
 TIOS&=0xFB;  // clear bit 2
 DDRT&=0xFB;  // PT2 is input capture
 TSCR=0x90;   // enable, fast clear
 TMSK2=0x32;  // 500 ns clock
 TMSK1=0x00;}     // no interrupts

//  Program 6.15. C language pulse width measurement.
// MC68HC812A4
unsigned int PW;     // units of 500 ns 
unsigned int Rising; // TCNT at rising
unsigned char Done;  // Set each falling
#define PT1 0x02     // the input signal 
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
  if(PORTT&PT1){    // PT1=1 if rising
     Rising=TC1;}   // Setup for next
  else{   
     PW=TC1-Rising; // the measurement 
     Done=0xFF;}    // ack, fast clr C1F=0 
void Ritual(void) { 
 asm(" sei");  // make atomic
 TIOS&=~PT1;   // clear bit 1
 DDRT&=~PT1;   // PT1 is input capture
 TSCR=0x90;    // enable, fast clear
 TMSK2=0x32;   // 500 ns clock
 TCTL4|=0x0C;  // Both edges IC1
 TMSK1|=0x02;  // arm IC1
 TFLG1=0x02;   // clear C1F 
 Done=0;
 asm(" cli");}

//  Program 6.17. C language pulse width measurement using two input captures.
// MC68HC812A4
unsigned int PW;     // units of 500 ns 
unsigned char Done;  // Set each falling
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
  TFLG1=0x02;  // ack C1F
  PW=TC1-TC2;  // the measurement 
  Done=0xFF;}  
void Ritual(void) { 
 asm(" sei");  // make atomic
 TIOS&=0xF9;   // clear bits 2,1
 DDRT&=0xF9;   // PT2,PT1 input captures
 TSCR=0x80;    // enable
 TMSK2=0x32;   // 500 ns clock
 TCTL4=(TCTL4&0xCF)|0x10; // IC2 Rise
 TCTL4=(TCTL4&0xF3)|0x08; // IC1 Fall
 Done=0;   // set on the falling edge
 TMSK1|=0x02;  // arm IC1, not IC2
 TFLG1=0x02;   // clear C1F 
 asm(" cli");}

//   Program 6.21. C language periodic interrupt using output compare.
// MC68HC812A4
#define Rate 2000
#define OC5  0x20
unsigned int Time;  // Inc every 1ms 
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){
   TFLG1=OC5;       // ack OC5F 
   TC5=TC5+Rate;    // Executed every 1 ms
   Time++; }

void ritual(void) { 
asm(" sei");     // make atomic
  TIOS|=OC5;     // enable OC5
  TSCR|=0x80;    // enable
  TMSK2=0x32;    // 500 ns clock
  TMSK1|=OC5;    // Arm output compare 5
  Time = 0;
  TFLG1=OC5;     // Initially clear C5F
  TC5=TCNT+Rate; // First one in 1 ms
asm(" cli"); }

//   Program 6.24. C language squarewave using output compare.
// MC68HC812A4
unsigned int Period;   // Period in usec 
// Number of Cycles Low and number High  
#pragma interrupt_handler TOC3handler()
void TOC3handler(void){ 
   TFLG1=0x08;       // ack OC3F 
   TC3=TC3+Period;}  // calculate Next
void ritual(void) { 
asm(" sei");     // make atomic
  TIOS|=0x08;    // enable OC3
  DDRT|=0x08;    // PT3 is output
  TSCR=0x80;     // enable
  TMSK2=0x32;    // 500 ns clock
  TCTL2 = (TCTL2&0x3F)|0x40;  
// PT3 toggle on each interrupt 
  TMSK1|=0x08;   // Arm output compare 3
  TFLG1=0x08;    // Initially clear C3F
  TC3=TCNT+50;   // First one in 25 us
asm(" cli"); }

//  Program 6.27. C language pulse-width modulated squarewave using output compare.
// MC68HC812A4
unsigned int High; // Num of Cycles High
unsigned int Low;  // Num of Cycles Low  
// Period is High+Low Cycles
#pragma interrupt_handler TOC3handler()
void TOC3handler(void){
   TFLG1=0x08;        // ack OC3F 
   if(TCTL2&0x40){    // PT3 is now high 
      TC3=TC3+High;   // 1 for High cyc
      TCTL2&=0xBF;}   // clear on next
   else {             // PT3 is now low
      TC3=TC3+Low;    // 0 for Low cycles 
      TCTL2|=0x40;}}  // set on next int
void ritual(void){ 
  asm(" sei");   // make atomic
  TIOS|=0x08;    // enable OC3
  DDRT|=0x08;   // PT3 is output
  TSCR=0x80;     // enable
  TMSK2=0x32;    // 500 ns clock
  TMSK1|=0x08;   // Arm output compare 3
  TFLG1=0x08;    // Initially clear C3F
  TCTL2|= 0xC0;  // PT3 set on next int
  TC3 = TCNT+50; // first right away 
  asm(" cli"); }
void main(void){ 
     High=8000; Low=2000;
     ritual();
     while(1);}

// Program 6.28. C language delayed pulse output using output compare.
// MC68HC812A4
void Pulse(unsigned int Delay,
     unsigned int Width){
  asm(" sei");  // make atomic
  TIOS|=0x08;   // enable OC3
  DDRT|=0x08;   // PT3 is output
  TSCR=0x90;    // enable, fast clear
  TMSK2=0x32;   // 500 ns clock
  TC7=TCNT+Delay;
  TC3=TC7+Width;
  OC7M=0x08;    // connect OC7 to PT3
  OC7D=0x08;    // PT3=1 when TC7=TCNT  
  TCTL2=(TCTL2&0x3F)|0x80; 
// PT3=0 when TC3=TCNT
  TFLG1 = 0x08;     // Clear C3F 
  TMSK1|= 0x08;     // Arm C3F
  asm(" cli");}
#pragma interrupt_handler TOC3handler()
void TOC3handler(void){
  OC7M=0;  // disconnect OC7 from PT3/OC3
  OC7D=0; 
  TCTL2&=0x3F;  // disable OC3
  TMSK1&=0xF7;} // disarm C3F  

//  Program 6.30. C language frequency measurement.
// MC68HC812A4
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
  Count++;      // number of rising edges 
  TFLG1=0x02;}  // ack, clear C1F
#define Rate 20000  //  10 ms 
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){
    TFLG1= 0x20;      // Acknowledge 
    TC5 = TC5+Rate;   // every 10 ms 
    Freq = Count;     // 100 Hz units
    Done = 0xff;
    Count = 0; }      // Setup for next 
void ritual(void) { 
asm(" sei");          // make atomic 
    TIOS|=0x20;   // enable OC5
    TSCR=0x80;    // enable
    TMSK2=0x32;   // 500 ns clock          
    TMSK1|=0x22;  // Arm OC5 and IC1
    TC5=TCNT+Rate;   // First in 10 ms 
    TCTL4 = (TCTL4&0xF3)|0x04; 
/* C1F set on rising edges */
    Count = 0;        // Set up for first 
    Done=0;          
/* Set on the subsequent measurements */ 
    TFLG1=0x22;   // clear OC5F 
asm(" cli"); }

//  Program 6.33. C language implementation of period measurement.
// MC68HC812A4
#define resolution 2000
#pragma interrupt_handler TOC3handler()
void TOC3handler(void){  
     TFLG1= 0x08;       // Acknowledge 
     TC3=TC3+resolution; // every 1 ms 
     Cnt++;
     if(Cnt==0) OverFlow=0xFF;}
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
     TFLG1=0x02;   // ack, clear C1F
     if(OverFlow){
         Period=65535;
         OverFlow=0;}
     else
         Period=Cnt;
     Cnt=0;
     Done=0xFF;}
void Ritual(void){
    asm(" sei");  // make atomic 
    TIOS| = 0x08;   // enable OC3
    TSCR  = 0x80;   // enable
    TMSK2 = 0x32;   // 500 ns clock          
    TFLG1 = 0x0A;   // Clear C3F,C1F 
    TMSK1 = 0x0A;   // Arm OC3 and IC1 
    TCTL4 = (TCTL4&0xF3)|0x04; 
/* C1F set on rising edges */
    while((TFLG1&0x02)==0); // wait rising
    TFLG1 = 0x02;    // Clear C1F 
    TC3=TCNT+resolution;
    Cnt=0; OverFlow=0; Done=0;
    asm(" cli"); } 

//  Program 6.36. C language implementation of frequency measurement.
// MC68HC812A4
#pragma interrupt_handler TIC1handler()
void TIC1handler(void){
  Count++;      // number of rising edges
  TFLG1=0x02;}  // ack, clear C1F
#define Rate 50000  //  25 ms 
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){ 
    TFLG1= 0x20;      // Acknowledge 
    TC5 = TC5+Rate;   // every 25 ms
    if (++FourHundred==400){
       Freq = Count;   //  0.1 Hz units 
       FourHundred=0;
       Done = 0xff;
       Count = 0; }}  // Setup for next
void ritual(void) { 
asm(" sei");    // make atomic 
    TIOS| = 0x20;   // enable OC5
    TSCR  = 0x80;   // enable
    TMSK2 = 0x32;   // 500 ns clock          
    TMSK1 = 0x22;   // Arm OC5 and IC1 
    TCTL4 = (TCTL4&0xF3)|0x04; 
/* C1F set on rising edges */
    TC5=TCNT+Rate;  // First in 25 ms 
    Count = 0;       // Set up for first
    Done=0;  // Set on subsequent meas
    FourHundred=0;
    TFLG1 = 0x22;   // Clear C5F,C1F 
asm(" cli"); }