chap8.c

Motorola 6812芯片开发的接口程序。

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

// Program 8.1. The MC68HC812A4 Port J initialization.
// MC68HC812A4
// PortJ bit 1 is connected to a switch to +5, using internal pull-down
// PortJ bit 0 is connected to a switch to 0, using internal pull-up
void Initialization(void){
    DDRJ  &= 0xFC;   // PJ1-0 inputs
    KPOLJ |= 0x03;   // flags set on the rise of PJ1, PJ0
    KWIEJ &= 0xFC;   // disarm PJ1, PJ0
    KWIFJ =  0x03;   // clear flags
    PUPSJ =  (PUPSJ&0xFC)|0x01; // pull-down on PJ1, pull-up on PJ0
    PUPEJ |= 0x03;}  // enable pull-up and pull-down

// Program 8.3. Switch debouncing using C software.
// MC68HC812A4
void WaitPress(void){
     while (PORTT&0x$08);        
// Loop here until switch is pressed 
     TC5=TCNT+20000;    // 10ms delay 
     while((TFLG1&0x20)==0);}  
// wait for switch to stop bouncing

void WaitRelease(void){
     while ((PORTT&0x$08)==0);        
// Loop here until switch is released 
     TC5=TCNT+20000;    // 10ms delay 
     while((TFLG1&0x20)==0);}  
// wait for switch to stop bouncing

void ritual(void) { 
  TIOS|=0x20;     // enable OC5
  TSCR=0x90;      // enable, fast clear
  TMSK2=0x32;     // 500 ns clock
  DDRT &= 0xF7;}  // PT3 is input

// Program 8.5. Another example of switch debouncing using C software.
// MC68HC812A4
unsigned char ReadPT3(void){
unsigned char old;
  old=PORTT&0x08;   // Current value
  TC5=TCNT+20000;   // 10ms delay 
  while((TFLG1&0x20)==0){  
// unchanged for 10ms?
     if(old<>(PORTT&0x08)){ // changed?
       old=PORTT&0x08;    // New value 
       TC5=TCNT+20000;}   // restart delay 
  }
  return(old);}
void ritual(void) { 
  TIOS|=0x20;     // enable OC5
  TSCR=0x90;      // enable, fast clear
  TMSK2=0x32;     // 500 ns clock
  DDRT &= 0xF7;}  // PT3 is input

//Program 8.6. Switch debouncing using interrupts in C software.
// MC68HC812A4
// counts the number of button pushes
// signal connected to IC3=PT3
unsigned int count; // times pushed
#define wait 20000  // bounce wait (cyc) 
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){
    TMSK1=0x08;    // Arm IC3, disarm OC5
    TFLG1=0x08;    // clear C3F 
    if(PORTT&0x08==0) count++;} 
// new count if PT3=0 
#pragma interrupt_handler TIC3handler()
void TIC3handler(void){
    TMSK1=0x20;     // Disarm IC3, Arm OC5
    TC5=TCNT+wait;} // clear C5F 
void Ritual(void){
    asm(" sei");  // make atomic 
    TIOS=(TIOS&0xF7)|0x20; // enable OC5,IC3
    TSCR=0x90;      // enable, fast clear
    TMSK2=0x32;     // 500 ns clock
    DDRT=(DDRT&0xF7)|0x20; // PT3 is input
    TMSK1=0x08;   // Arm IC3, disarm OC5
    TFLG1=0x08;   // clear C3F 
    TCTL4 = (TCTL4&0x3F)|0x40;  // rising
    count=0; 
    asm(" cli"); }

// Program 8.7. Another example of switch debouncing using interrupts in C software.
// MC68HC812A4
// counts the number of button pushes
// signal connected to IC3=PT3
unsigned int count; // times pushed
char LastState; // looking for touch?
// true means open, looking for a touch
// false means closed, looking for release  
#define wait 20000  // bounce wait (cyc) 
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){
    TMSK1=0x08;    // Arm IC3, disarm OC5
    TFLG1=0x08;}   // clear C3F 
#pragma interrupt_handler TIC3handler()
void TIC3handler(void){
    if(LastState){
       count++; // a touch has occurred 
       LastState=0;} 
    else
       LastState=1; // release occurred
    TMSK1=0x20;     // Disarm IC3, Arm OC5
    TC5=TCNT+wait;} // clear C5F 
void Ritual(void){
    asm(" sei");  // make atomic 
    TIOS=(TIOS&0xF7)|0x20; // enable OC5,IC3
    TSCR=0x90;      // enable, fast clear
    TMSK2=0x32;     // 500 ns clock
    DDRT=(DDRT&0xF7)|0x20; // PT3 is input
    TMSK1=0x08;   // Arm IC3, disarm OC5
    TFLG1=0x08;   // clear C3F 
    TCTL4 = (TCTL4&0x3F)|0x40;  // rising
    count=0; 
    LastState=PORTT&0x08;
    asm(" cli"); }

// Program 8.9. C software interface of a direct connection keyboard.
// MC68HC812A4
unsigned int KEY;    // current pattern 
#define wait 20000   // bounce time (cyc)
void Ritual(void){
     asm(" sei");    // make atomic 
     TIOS|=0x20;     // enable OC5
     TSCR=0x90;      // enable, fast clear
     TMSK2=0x32;     // 500 ns clock
     TMSK1&=0xDF;    // Disarm OC5
     DDRH=DDRJ=0;    // H,J are key inputs
     KWIEH=KWIEJ=0xFF; // all 16 are armed  
     KPOLJ=0;          // falling edge       
     PUPEJ=0;          // regular input
     KeyBoard();       // Initially read 
     asm(" cli"); }
void KeyBoard(void){
     KWIFH=KWIFJ=0xFF;       // clear flags
     KEY=(PORTJ<<8)+PORTH;}  // Set global
#pragma interrupt_handler KeyHhandler()
void KeyHhandler(void){
     KWIEH=KWIEJ=0x00; // all 16 are disarmed  
     TMSK1|=0x20;      // Arm OC5 
     TC5=TCNT+wait;
     TFLG1=0x20;}      // clear C5F
#pragma interrupt_handler KeyJhandler()
void KeyJhandler(void){
     KWIEH=KWIEJ=0x00; // all 16 are disarmed  
     TMSK1|=0x20;      // Arm OC5 
     TC5=TCNT+wait;
     TFLG1=0x20;}      // clear C5F
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){
   TMSK1&=0xDF;  // Disarm OC5
   KWIEH=KWIEJ=0xFF; // all 16 are rearmed  
   KeyBoard();}      // Read keys

// Program 8.10. C software interface of a direct connection keyboard using periodic polling.
// MC68HC812A4
unsigned int Key;     // current pattern 
#define period 20000  // 10ms polling
unsigned int KeyBoard(void){
    return((PORTH<<8)+PORTJ);} // pattern
void Ritual(void){
    asm(" sei");    // make atomic 
    TIOS|=0x20;     // enable OC5
    TSCR=0x90;      // enable, fast clear
    TMSK2=0x32;     // 500 ns clock
    TMSK1|=0x20;    // Arm OC5
    DDRH=DDRJ=0;    // H,J are key inputs
    PUPEJ=0;        // regular input
    Key=KeyBoard(); // read 16 keys  
    TC5=TCNT+period;
    asm(" cli"); }
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){ 
     Key=KeyBoard();    // Current pattern
     TC5=TC5+period;}   // ack OC5F 

// Program 8.12. C software interface of a matrix scanned keyboard.
// MC68HC812A4
const struct Row
{   unsigned char out; 
    unsigned char direction;
    unsigned char keycode[4];}
#typedef const struct Row RowType;
RowType ScanTab[5]={
{   0x70, 0x80, "abcd" }, // row 3
{   0xB0, 0x40, "efgh" }, // row 2
{   0xD0, 0x20, "ijkl" }, // row 1
{   0xE0, 0x10, "mnop" }, // row 0
{   0x00, 0x00, "    " }};
void Ritual(void){ // PJ3-PJ0 are inputs
    DDRJ=0x00;}    // PJ7-PJ4 are oc outputs
/* Returns ASCII code for key pressed, 
   Num is the number of keys pressed  
   both equal zero if no key pressed */
unsigned char Scan(unsigned int *Num){ 
RowType *pt; unsigned char column,key; int j;
  (*Num)=0; key=0;    // default values  
  pt=&ScanTab[0];
  while(pt->out){
    PORTJ=pt->out;  // select row 
    DDRJ=pt->direction;  // one output 
    column=PORTJ;   // read columns
    for(j=3; j>=0; j--){
      if((column&0x01)==0){ 
        key=pt->keycode[j]; 
        (*Num)++;}
      column>>=1;} // shift into position 
    pt++; }
  return key;}

// Program 8.14. C software interface of a multiplexed keyboard.
// MC68HC812A4
// PJ7-PJ4 row output 
// PJ3-PJ0 column inputs 
unsigned char Key;    // current pattern 
unsigned char PreviousKey;  // 10ms ago 
#define period 20000        // 10 ms 
unsigned char KeyScan(void){  
    unsigned char key,row;
    key=0;    // means no key pressed
    for(row=0;row<16;row++){
          PORTJ=row<<4;  // Select row 
          if((PORTJ&0x0F)!=0x0F){ 
               key=PORTJ^0x0F; }}   
    return(key);}
void Ritual(void){
     asm(" sei");   // make ritual atomic 
     DDRJ=$F0;   
     PreviousKey=Key=KeyScan(); // read
     TMSK1|=0x20;        // Arm OC5 
     TIOS|=OC5;     // enable OC5
     TSCR|=0x80;    // enable
     TMSK2=0x32;    // 500 ns clock
     TC5=TCNT+wait;
     TFLG1=0x20;     // clear OC5F 
     asm(" cli"); }
#pragma interrupt_handler TOC5handler()
void TOC5handler(void){ 
unsigned char NewKey;
     NewKey=KeyScan();  // Current pattern  
     if(NewKey==PreviousKey) Key=NewKey;
     PreviousKey=NewKey;