chap13.c

摩托罗拉Mc6811利程

// Chapter 13 6811 C programs
// Jonathan W. Valvano
// This software accompanies the book,
// Embedded Microcomputer Systems: Real Time Interfacing
// published by Brooks Cole, 1999

// Program 13.1. C implementation of a Traffic Light Controller.
/* Port B bits 5-0 outputs that control the traffic signal */
const struct State {
  unsigned char Out;         /* Output to Port B */
  unsigned short Time;       /* Time in sec to wait */
  const struct State *Next;  /* Next state */
};
typedef const struct State StateType;
#define NorthRed_EastGreen  &fsm[0]
#define NorthRed_EastYellow &fsm[1]
#define NorthGreen_EastRed  &fsm[2]
#define NorthYellow_EastRed &fsm[3]
StateType fsm[4]={
/* NorthRed_EastGreen, wait= 3 min, next state */
  {0x21, 180, NorthRed_EastYellow},  
/* NorthRed_EastYellow, wait= 15 sec, next state */
  {0x22, 15, NorthGreen_EastRed},  
/* NorthGreen_EastRed, wait= 3 min, next state */
  {0x0C, 180, NorthYellow_EastRed},   
/* NorthYellow_EastRed, wait= 15 sec, next state */
  {0x14, 15, NorthRed_EastGreen}};
void main(void){ StatePtr *Pt;  /* Current State */
  Pt=NorthRed_EastGreen; /* Initial State */
  DDRB=0xFF;             /* Make Port B outputs  */
  while(1){
    PORTB=Pt->Out;    /* Perform output for this state */
    Wait(Pt->Time);   /* Time to wait in this state */
    Pt=Pt->Next;      /* Move to next state */
  }
};

// Program 13.2 Circular list used to spin a stepper motor.
/* Port B bits 3-0 outputs that control the stepper motor */
const struct State {
  unsigned char Out;         /* Output to Port B */
  const struct State *Next;  /* Next state */
};
typedef const struct State StateType;
#define S6  &fsm[0]
#define S5  &fsm[1]
#define S9  &fsm[2]
#define S10 &fsm[3]
StateType fsm[4]={
  {0x06, S5},  
  {0x05, S9},  
  {0x09, S10},  
  {0x0A, S6};
StatePtr *Pt;  /* Current State */
unsigned short Speed;

// Program 13.3 C software to spin a stepper motor at a constant speed.
// MC68HC11A8, ICC11 compiler
#define OC5  0x08
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){
  PORTB=Pt->Out; // output for this state 
  Pt=Pt->Next;   // Move to next state 
  TFLG1=OC5;     // Ack OC5F 
  TOC5=TOC5+Speed; // Executed every step 
 }

void ritual(void) { 
asm(" sei");    // make atomic
   TMSK1|=OC5;  // Arm output compare 5
   TFLG1=OC5;   // Initially clear OC5F
   Speed=10000; // initial speed
   Pt=S6;         // initial state
  TOC5=TCNT+2000; // First one in 1 ms
asm(" cli"); }

// Program 13.4 Port B is used to turn on the heater.
unsigned char Tlow,Thigh,T; int E;  // units in degrees C 
void Actuator(unsigned char relay){
  PORTB=relay;    // turns power on/off
}

// Program 13.5 Bang-bang temperature control software.
// MC68HC11A8, ICC11 compiler
#pragma interrupt_handler TOC5handler()
void TO5handler(void){
   T=SE(A2D(channel)); // estimated T 
   E=Tstar-T;          // error
   if(T<Tlow) 
     Actuator(0);   // too cold so off
   else if (T>Thigh)
     Actuator(1);   // too hot so on
// leave as is if Tlow<T<Thigh
   TOC5=TOC5+rate;  // periodic rate
   TFLG1=0x08; }    // ack OC5F

// Program 13.6 Incremental position control software.
// MC68HC11A8, ICC11 compiler
unsigned char Xstar,X; int E;   // in mm
#pragma interrupt_handler TOC5handler()
void TO5handler(void){ int new;
   X=SE(A2D(channel));  // estimated (mm)
   E=Xstar-X;     // error (mm)
   new=PORTB;     // promote to 16 bits
   if(E< -1)     new--; // decrease
   else if (E>1) new++; // increase
// leave as is if -1<E<1
   if(new<0)   new=0;    // underflow
   if(new>255) new=255;  // overflow
   PORTB=new;   // output to actuator
   TOC5=TOC5+rate; // establish periodic
   TFLG1=0x08; }       // ack OC5F

// Program 13.7 Integral position control software.
// MC68HC11A8, ICC11 compiler
unsigned int Time;  // Time in msec
unsigned int X;     // Est position in cm
unsigned int Xstar; // Desired pos in cm 
unsigned int U;     // Actuator duty cycle
unsigned int Cnt;   // once a sec
unsigned int Told;  // used to meas period
#pragma interrupt_handler TOC5handler()
void TOC5Handler(void){ int NewU;
  TFLG1=0x08;     // Ack OC5F 
  TOC5=TOC5+2000; // every 1 ms 
  Time++;     // used to measure period
  if((Cnt++)==1000){  // every 1 sec 
     Cnt=0;
// 0<X<100, 0<Xstar<100, 100<U<19900, so
// Minimum occurs when U=100,Xstar=0,X=100
//    Minimum NewU = -900
// Max occurs when U=19900,Xstar=100,X=0
//    Maximum NewU = 20900
// so NewU will be a valid signed int 
     NewU=U+10*(Xstar-X);
     if(NewU<100) NewU=100;  // Constrain
     if(NewU>19900) NewU=19900;
     U=NewU;  } }

// Program 13.8 PWM actuator control software.
// MC68HC11A8, ICC11 compiler
#pragma interrupt_handler TOC4handler()
void TOC4Handler(void){
    TFLG1=OC4F; /* Ack */
    if (TCTL1&0x04)   /* OL4 bit */
/* OL4=1, High for the next U cycles */
       TOC4=TOC4+U; 
    else
/* OL4=0, Low for the next 20000-U cyc */
       TOC4=TOC4+20000-U;   
    TCTL1^=0x04; }     /* Toggle OL4 */ 

// Program 13.9 Sensor measurement software.
// MC68HC11A8, ICC11 compiler
// Time is incremented every 1 ms, by OC5
// This handler is executed on rise
#pragma interrupt_handler TIC1handler()
void TIC1Handler(void){unsigned int p;
  TFLG1 = IC1F;  // Ack IC1F
  p = Time-Told; // period in msec
  X = p-10;    // estimated position (cm)
  Told=Time;
}

// Program 13.10 Initialization software.
// MC68HC11A8, ICC11 compiler
void ritual(void) { 
  asm(" sei");      /* atomic */
  OC1M=0; OC1D=0;     
  TCTL1=0x08; // Clear OC4 
  TCTL2=0x10; // capture on rise of IC1 
  TMSK1=OC5F+OC4F+IC1F; // Arm    
  U=10000;      // Initial U , half power
  Time = 0; Told=0;  Cnt=0;
  TFLG1=OC5F+OC4F+IC1F; // clear flags 
  TOC5=TCNT+2000; // First OC5 in 1 ms 
  TOC4=TCNT+100;  // First OC4 in 50us 
  asm(" cli");}

Program 13.11. Subtraction with overflow/underflow checking.
char Subtract(unsigned char N, unsigned char M){   
/* returns N-M */
unsigned int N16,M16; 
int Result16;
     N16=N;        /* Promote N,M */
     M16=M;
     Result16=N16-M16;   /* -255睷esult16