chap4.c

摩托罗拉Mc6811利程

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


// Program 4.3. This C function is nonreentrant because of the read-modify-write access to a global. 
unsigned int Money;  /* bank balance implemented as a global */
/* add 100 dollars */
void more(void){
	Money += 100;}

// Program 4.5. This C function is nonreentrant because of the write-read access to a global. 
int temp;  /* global temporary */
/* calculate x+2*d */
int mac(int x, int d){
	temp = x+2*d;    /* write to a global variable */
       return (temp);}  /* read from global */

// Program 4.7. This C function is nonreentrant because of the multi-step write access to a global. 
int info[2];  /* 32-bit global */
void set(int x, int y){
    info[0]=x;
    info[1]=y;}

// Program 4.11. This C function is reentrant because it disables interrupts during the critical section. 
int Empty;   /* -1 means empty, 0 means it contains something */
int Message; /*  data to be communicated */
int SEND(int data){ int OK;
char SaveSP;
   asm(" tpa\n staa %SaveSP\n sei"); /* make atomic, entering critical */
   OK=0;          /* Assume it is not OK */
   if(Empty){
       Message=data;
       Empty=0;  /*  signify it is now contains a message*/
       OK=-1;}   /* Successfull */
   asm(" ldaa %SaveSP\n tap");  /* end critical section */ 
   return(OK);}


// Program 4.14. Two pointer implementation of a FIFO. 
#define FifoSize 10    /* Number of 8 bit data in the Fifo less one */
char *PutPt;    /* Pointer of where to put next */
char *GetPt;    /* Pointer of where to get next
               /* FIFO is empty if PutPt=GetPt */
               /* FIFO is full  if PutPt+1=GetPt (with wrap) */
char Fifo[FifoSize];     /* The statically allocated fifo data */
void InitFifo(void) { char SaveSP;
 asm(" tpa\n staa %SaveSP\n sei"); /* make atomic, entering critical */
 PutPt=GetPt=&Fifo[0];  /* Empty when PutPt=GetPt */
 asm(" ldaa %SaveSP\n tap");      /* end critical section */
}
int PutFifo (char data) { char *Ppt; /* Temporary put pointer */
char SaveSP;
   asm(" tpa\n staa %SaveSP\n sei"); /* make atomic, entering critical */
   Ppt=PutPt;          /* Copy of put pointer */
   *(Ppt++)=data;      /* Try to put data into fifo */
   if (Ppt == &Fifo[FifoSize]) Ppt = &Fifo[0];  /* Wrap */
   if (Ppt == GetPt ) {
      asm(" ldaa %SaveSP\n tap"); /* end critical section */
      return(0);}    /* Failed, fifo was full */
    else{ 
      PutPt=Ppt;
      asm(" ldaa %SaveSP\n tap");  /* end critical section */
      return(-1);    /* Successful */ 
     }
}
int GetFifo (char *datapt) { char SaveSP;
   if (PutPt == GetPt ) {
        return(0);}    /* Empty if PutPt=GetPt */
   else{
       asm(" tpa\n staa %SaveSP\n sei"); /* make atomic, entering critical */
       *datapt=*(GetPt++);
       if (GetPt == &Fifo[FifoSize]) GetPt = &Fifo[0];
       asm(" ldaa %SaveSP\n tap");  /* end critical section */
       return(-1); }
}

// Program 4.18. C language routines to implement a two pointer with counter FIFO. 
/* Pointer,counter implementation of the FIFO */
#define FifoSize 10    /* Number of 8 bit data in the Fifo */
char *PutPt;    /* Pointer of where to put next */
char *GetPt;    /* Pointer of where to get next */
unsigned char Size;  /* Number of elements currently in the FIFO */
               /* FIFO is empty if Size=0 */
               /* FIFO is full  if Size=FifoSize */
char Fifo[FifoSize];     /* The statically allocated fifo data */
void InitFifo(void) { char SaveSP; 
 asm(" tpa\n staa %SaveSP\n sei");   /* make atomic, entering critical*/
 PutPt=GetPt=&Fifo[0];   /* Empty when Size==0 */
 Size=0;
 asm(" ldaa %SaveSP\n tap");  /* end critical section */
}
int PutFifo (char data) { char SaveSP;
   if (Size == FifoSize ) {
      return(0);}    /* Failed, fifo was full */
    else{
      asm(" tpa\n staa %SaveSP\n sei");   /* make atomic, entering critical*/
      Size++;
      *(PutPt++)=data;    /* put data into fifo */
      if (PutPt == &Fifo[FifoSize]) PutPt = &Fifo[0];  /* Wrap */
      asm(" ldaa %SaveSP\n tap");  /* end critical section */
      return(-1);    /* Successful */ 
     }
}
int GetFifo (char *datapt) { char SaveSP;
   if (Size == 0 ){ 
      return(0);}         /* Empty if Size=0 */
   else{
      asm(" tpa\n staa %SaveSP\n sei");   /* make atomic, entering critical*/
      *datapt=*(GetPt++); Size--;
      if (GetPt == &Fifo[FifoSize]) GetPt = &Fifo[0];
      asm(" ldaa %SaveSP\n tap");  /* end critical section */
      return(-1); }
}

// Program 4.22. C implementation of a two index with counter FIFO. 
/* Index,counter implementation of the FIFO */
#define FifoSize 10    /* Number of 8 bit data in the Fifo */
unsigned char PutI;    /* Index of where to put next */
unsigned char GetI;    /* Index of where to get next */
unsigned char Size;    /* Number of elements currently in the FIFO */
               /* FIFO is empty if Size=0 */
               /* FIFO is full  if Size=FifoSize */
char Fifo[FifoSize];     /* The statically allocated fifo data */
void InitFifo(void) {char SaveSP;
  asm(" tpa\n staa %SaveSP\n sei");   /* make atomic, entering critical*/
  PutI=GetI=Size=0;      /* Empty when Size==0 */
  asm(" ldaa %SaveSP\n tap");  /* end critical section */
}
int PutFifo (char data) { char SaveSP;
   if (Size == FifoSize ) 
      return(0);     /* Failed, fifo was full */
    else{ 
      asm(" tpa\n staa %SaveSP\n sei");   /* make atomic, entering critical*/
      Size++;
      Fifo[PutI++]=data;      /*  put data into fifo */
      if (PutI == FifoSize) PutI = 0;  /* Wrap */
      asm(" ldaa %SaveSP\n tap");  /* end critical section */
      return(-1);    /* Successful */ 
     }
}
int GetFifo (char *datapt) { char SaveSP;
   if (Size == 0 ) 
        return(0);     /* Empty if Size=0 */
   else{
        asm(" tpa\n staa %SaveSP\n sei"); /* make atomic, entering critical*/
        *datapt=Fifo[GetI++]; Size--;
        if (GetI == FifoSize) GetI = 0;
        asm(" ldaa %SaveSP\n tap");  /* end critical section */
        return(-1); }
}


// Program 4.30. Interrupting keyboard software. 
// MC68HC11A8
// PC6-PC0 inputs = keyboard DATA
// STRA=STROBE interrupt on rise
void Init(void){ 
unsigned char dummy;
asm(" sei");
    PIOC=0x42;   // EGA=1, STAI
    DDRC=0x80;   // STRA=STROBE  
    PORTC=0x00;  // PC7=0  
    dummy=PIOC;  dummy=PORTCL;
    InitFifo();
asm(" cli");}
#pragma interrupt_handler ExtHan()
void ExtHan(void){ 
    if((PIOC & STAF)==0)asm(" swi");
    PutFifo(PORTCL);} // ack

// Program 4.34. C language software interrupt for the printer. 
// MC68HC11A8
// PC6-PC0 outputs = printer DATA
// STRA=READY interrupt on rise
// STRB=START pulse out
unsigned char OK;   // 0=busy, 1=done
unsigned char Line[20]; //ASCII data
unsigned char *Pt;  // pointer to line
void Fill(unsigned char *p){
   Pt=&Line[0];   
   while((*Pt++)=(*p++)); // copy
   Pt=&Line[0];   // initialize pointer
   OK=0;}
unsigned char Get(void){
   return(*Pt++);}
void Init(unsigned char *thePt){
asm(" sei");   // make atomic
   Fill(thePt); // copy data into global
   DDRC=0xFF;  // Port C outputs  
   PIOC=0x5E;  // arm out handshake
   PORTCL=Get(); // start first  
asm(" cli");}
#pragma interrupt_handler ExtHan()
void ExtHan(void){ unsigned char data;
    if((PIOC & STAF)==0)asm(" swi");
    if(data=Get())
       PORTCL=data;  // start next
    else{
       PIOC=0x1E;    // disarm
       OK=1;}}       // line complete  

// Program 4.36. C language software for the XIRQ interrupt. 
/* Power System interface 
   XIRQ requested on a rise of TooLow
   PB0, negative logic pulse, will acknowledge XIRQ
   PB1=1 will activate backup power */
#pragma interrupt_handler PowerLow()
void PowerLow(void){ PORTB=2; PORTB=3; }  /* Ack, turn on backup power */
void Ritual(void){
// Port B outputs 
      PORTB=0; PORTB=1; // Make XIRQ=1 
asm(" ldaa #0x10\n"
    "  tap");
}

// Program 4.39. C language implementation of interrupt polling on the 6811 using linked lists. 
const struct	Node{
	unsigned char *StatusPt;      /* Pointer to status register */
	unsigned char Amask;          /* And Mask */
	unsigned char Cmask;          /* Compare Mask */
	void (*Handler)(void);        /* Handler for this task */              
	const struct Node *NextPt;          /* Link to Next Node */
};
unsigned char CLdata,PIAAdata,PIABdata;
void STRAHan(void){    // regular functions that return (rts) when done
    CLdata=PORTCL;}
void PIAHanA(void){
    PIAAdata=ADATA;}  
void PIAHanB(void){
    PIABdata=BDATA;}
typedef const struct Node NodeType;
typedef NodeType * NodePtr;
NodeType sys[3]={
    {&PIOC, 0xFF, 0xC0, STRAHan, &sys[1]},
    {&ACNT, 0x87, 0x85, PIAHanA, &sys[2]},
    {&BCNT, 0x7C, 0x4C, PIAHanB, 0} };
#pragma interrupt_handler IRQHan()
void IRQHan(void){ NodePtr Pt; unsigned char Status;
 Pt=&sys[0];
 while(Pt){		// executes device handlers for all requests
    Status=*(Pt->StatusPt);
    if((Status&(Pt->Amask))==(Pt->Cmask)){
        (*Pt->Handler)();}     /* Execute handler */
    Pt=Pt->NextPt; } }  // returns after all devices have been polled
void main(void){ 
    while(1);} 
 

// Program 4.43. C language implementation of round robin polling on the 6811. 
NodeType sys[3]={
    {&PIOC, 0xFF, 0xC0, STRAHan, &sys[1]},
    {&ACNT, 0x87, 0x85, PIAHanA, &sys[2]},
    {&BCNT, 0x7C, 0x4C, PIAHanB, &sys[0]} };
NodePtr Pt=&sys[0];  // points to the one that got polled first at last interrupt
#pragma interrupt_handler IRQHan()
void IRQHan(void){  unsigned char Counter,Status;
 Counter=3;        // quit after three devices checked
 Pt=Pt->NextPt;    // rotates ABC BCA CAB polling orders
 while(Counter--){
    Status=*(Pt->StatusPt);
    if((Status&(Pt->Amask))==(Pt->Cmask)){
        (*Pt->Handler)();}     /* Execute handler */
    Pt=Pt->NextPt; } }


// Program 4.47. 6811 C language implementation of a periodic interrupt using real time interrupt. 
unsigned int Time;
#pragma interrupt_handler RTIHan()
void RTIHan(void){ 
   if((TFLG2&0x4F)!=0x40)asm(" swi"); /*  Illegal interrupt */
   TFLG2=RTIF;    /* Acknowledge by clearing RTIF */
   Time++;
 }
void Ritual(void){
     asm(" sei");    /* Make ritual atomic */
     PACTL=(0xFC&TMSK2)|2;    /* Set RTR to 2, 61.035Hz  */
     TMSK2|=RTII;             /* Arm RTI  */
     Time=0;      /* Initialize global data structures */
     asm(" cli");
}