Program Code
Back


main.c



//Yee Yik & Andreas Lundgren
//Digital Project Fall 2001
//Group 16

//Main program
 
#include "IO-reg.h"
#include "checkNumPad.h"
#include "LCD_driver.h"
#include "buttonHandler.h"
#include "measureMode.h"

char writePosition;
unsigned int adjustmentNumber;
unsigned long measuredTime;
unsigned int nbrOverflow;
unsigned int deltaF;

void main (void) {

    char button;
    unsigned int temp_nbrOf;  //temparary store # of overflow so we can restore the original value later
 
    /*Initialise the LCD*/
    initLCD();
    //set position to kolumn 1, row 2.
    writePosition = 0x40;

    //set PORTA, bit 3, as input
    PACTL &= 0xF7;

    //Turn flash trigger off.
    PORTD &= 0xEF;   

    //set PORTD, bit 4, as output, rest as input
    DDRD |= 0x10;
    DDRD &= 0xD0;
   
    measuredTime = 0;
    adjustmentNumber = 0;
    nbrOverflow = 0;
    deltaF = 0;

    while (1){
    /*Check if a buton is pressed, and use the result to display on LCD right away
      then wait for the bouncing of 0&1 result from button pressing to stop,
      wait for button is released,
      and wait for the bouncing result from releasing button to stop*/

    if ((PORTA & 8) != 0){
        PORTB &= 0xF7; //Turn light diode off;
        if ((PORTA & 4) != 0){
          startMeasure();
          measuredTime = nbrOverflow;
          measuredTime = measuredTime * 0xFFFF;
          measuredTime = measuredTime + deltaF;
          write_long_position(0, measuredTime);
        } else {
          temp_nbrOf = nbrOverflow;
          startShooting();
          nbrOverflow = temp_nbrOf;
        }
        while ((PORTA & 8) != 0){} // Waiting for button to be released
    }
    PORTB |= 0x08; //Turn light diode on;
   
    button = checkNumPad(); 
    if ((button) > 0){
        button_handler(button);
        wait_bouncing();
        wait_button_release();
        wait_bouncing();
    }  //end of if (button is pressed)     
    } //end of while loop
}


buttonHandler.h



void button_handler(char button);
char *long_to_string(long number);


buttonHandler.c



//Yee Yik & Andreas Lundgren
//Digital Project Fall 2001
//Group 16

/*Button handler program
  Get a button 1-16 and handles it.*/
 
#include "LCD_driver.h"

extern char writePosition;
extern int adjustmentNumber;
extern long measuredTime;
extern unsigned int nbrOverflow;
extern unsigned int deltaF;


char *long_to_string(long number)
{
  char string[11];
  short pos2 = 9;
 
  while (number > 0)
  {
      string[pos2] = (number % 10) + '0';
      number = number / 10;
      pos2--;
  }
  string[10] = 0;
  return &string[++pos2];
}

//char button_handler(char button, char writePosition)
void button_handler(char button)
{
  switch (button)
  {
      case 1:
        break;
      case 2:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 7;
            write_character_position(writePosition,'7');
            writePosition++;
        }
        break;
      case 3:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 4;
            write_character_position(writePosition,'4');
            writePosition++;
        }
        break;
      case 4:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 1;
            write_character_position(writePosition,'1');
            writePosition++;
        }
        break;
      case 5:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 0;
            write_character_position(writePosition,'0');
            writePosition++;
        }
        break;
      case 6:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 8;
            write_character_position(writePosition,'8');
            writePosition++;
        }
        break;
      case 7:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 5;
            write_character_position(writePosition,'5');
            writePosition++;
        }
        break;
      case 8:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 2;
            write_character_position(writePosition,'2');
            writePosition++;
        }
        break;
      case 9:
        break;
      case 10:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 9;
            write_character_position(writePosition,'9');
            writePosition++;
        }
        break;
      case 11:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 6;
            write_character_position(writePosition,'6');
            writePosition++;
        }
        break;
      case 12:
        if (writePosition < 0x44){
            adjustmentNumber = (adjustmentNumber * 10) + 3;
            write_character_position(writePosition,'3');
            writePosition++;
        }
        break;
      case 13: //a backspace button
        if (writePosition > 0x40){
            write_character_position(--writePosition, 20);  //write a space to the position
            adjustmentNumber = (adjustmentNumber / 10);
        }
        break;
      case 14:
        break;
      case 15:  //minus sign
        if ((measuredTime - adjustmentNumber) > 0){
            clear_display();
            measuredTime = measuredTime - adjustmentNumber;
            if (deltaF < adjustmentNumber)
              nbrOverflow--;
            deltaF = deltaF - adjustmentNumber;
            write_long_position(0x0,measuredTime);
            writePosition = 0x40;
            adjustmentNumber = 0;
        }
        break;
      case 16:  //plus sign
        clear_display();
        measuredTime = measuredTime + adjustmentNumber;
        deltaF = deltaF + adjustmentNumber;
        if (deltaF < adjustmentNumber)                                                                                                                                                                                                                                                                                                                                                               
            nbrOverflow++;
        write_long_position(0x0,measuredTime);
        writePosition = 0x40;
        adjustmentNumber = 0;
        break;
  }
 
}


checkNumPad.h



char sweep(void);
void wait_bouncing(void);
void wait_button_release(void);
char checkNumPad (void);


checkNumPad.c


//Yee Yik & Andreas Lundgren
//Digital Project Fall 2001
//Group 16

/*Keypad input program
  Read input from keypad and send corresponding signal to LCD*/
 
#include "IO-reg.h"

char sweep() {
 
  if ((PORTD & 0x0F) == 0)
    return 0;
   
  else if ((PORTD & 0x01) != 0 )
        return 1;
   
  else if  ((PORTD & 0x02) != 0 )
    return 2;
   
  else if ((PORTD & 0x04) != 0)
    return 3;
   
  else if ((PORTD & 0x08) != 0)
    return 4;
   
  else
    return 0; 
   
} //end of sweep()

char checkNumPad () {
 
    char button = 0;
    //set PORTB to 1000xxxx (ie set PB7 to 1)
    PORTB &= 0x0F; 
    PORTB |= 0x80;
 
    if ((button = sweep()) > 0)  //some button is pressed
      return button;
 
    //set PORTB to 0100xxxx (ie set PB6 = 1)
    PORTB &= 0x0F; 
    PORTB |= 0x40;
   
    if ((button = sweep()) > 0)  //some button is pressed
      return (button + 4);
 
    //set PORTB to 0010xxxx (ie set PB5 = 1)
    PORTB &= 0x0F; 
    PORTB |= 0x20;
 
    if ((button = sweep()) > 0)  //some button is pressed
      return (button + 8);
 
 
    //set PORTB to 0001xxxx (ie set PB4 = 1)
    PORTB &= 0x0F; 
    PORTB |= 0x10;
 
    if ((button = sweep()) > 0)  //some button is pressed
      return (button + 12);
 
  return 0;
   
} //end of checkNumPad()

void wait_bouncing() {

  char i;
  //For-loop is 26 clk:s, i=100 & 8 MHz => 300 us
  for (i = 100; i >0; i--)
  {}
} //end of wait_release()

void wait_button_release() {
  while (checkNumPad() > 0)
  {}
} //end of wait_button_release()


LCD_driver.h



void write_character_position(char pos, char ch);
  //write character ch at position pos on the LCD
void write_string_position(char pos, char *string);
  //write string of character at position pos on the LCD
void write_long_position(char pos, long number);
  //write long at position po on the LCD
void clear_display(void);
  //clear display
void initLCD(void);

//temporary
void put_character(char ch);


LCD_driver.c



#include "int6811.h"
#include "io6811.h"

char ch;
int x;

void testBF (void)
{
    DDRC = 0;
    PORTB &= 0xF8;  //retain other value in PB[3:7]
    PORTB |= 0x03;  //set E = 1, R/W = 1, RS = 0
    while (PORTC&0x80) { }  //wait until busy flag is off
}

void put(char ch)
{
    PORTC = ch;
    DDRC = 0xFF;  //enable PORTC as output
    PORTB |= 0x01; //set Enable to 1, ie read from PORTC
    PORTB &=0xFE;  //set Enable to 0, other value unchange
    DDRC = 0;      //disable PORTC as output         
}

void set_command(void)
{
    PORTB &= 0xF9;  //write to instruction register, RS = 0, R/W = 0, E = x
}

void set_character(void)
{
    PORTB |= 0x04;
    PORTB &= 0xFD;  //write to data register, RS = 1, R/W = 0, E = x
}

void put_command(char ch)
{
    testBF();
    set_command();
    put(ch);
}

void put_character(char ch)
{
    testBF();
    set_character();
    put(ch);
}

void wait_15ms(void)
{
    for (x = 4700; x != 0; x--); {}
    //for-loop is 26 clk:s
}
         
void initLCD(void)
{
    wait_15ms();
    set_command();
    put(0x38);
    wait_15ms();
    put(0x38);
    wait_15ms();
    put(0x38);
    put_command(0x38);
    put_command(0x01);
    put_command(0x06);   
    put_command(0x0C);
}

void clear_display()
{
  put_command(0x01);
}

void write_character_position(char pos, char ch)
{
    put_command(128+pos);   
    put_character(ch);
}

void write_string_position(char pos, char *string)
{
    put_command(128+pos);    //+0x40
    while (*string != 0)
    {                       
        put_character(*string);
        string++;
    }
}                           

void write_long_position(char pos, long number)
{
    char i = 15;
    if (number == 0){   
        write_character_position(pos+i,'0');
    }
    while (number != 0)
    {                       
        write_character_position(pos+i,(number % 10) + '0');
        number = number / 10;
        i--;
    }
}


measureMode.h



void startMeasure();
void startShooting();


measureMode.c



//Enable time capture interrupt from PORTA[0:1]
#include "IO-reg.h"
#include "Vectors.h"
#include

extern unsigned int nbrOverflow;
char waitingForInterrupt;
unsigned int foil1;
unsigned int foil2;
extern unsigned int deltaF;
char waitingForInterrupt2;   
char inMeasureMode;
unsigned int i;
   
/*MEASURE MODE*/   
void startMeasure() {
       
    waitingForInterrupt = 1;
    foil1 = foil2 = 0;
    inMeasureMode = 1;
 
    //Capture falling edge only
    TCTL2 |= 0x0A; //xxxx 1x1x
    TCTL2 &= 0xFA; //xxxx x0x0

    //clear flag first for PA0 & PA1
    TFLG1 = 0x03;
    //clear flag first for timer Overflow
    TFLG2 = 0x80;

    //Enable PORTA[0:1] for time capture
    TMSK1 |= 0x03; //xxxx xx11
   
    enable_interrupt();
   
//start
    while (waitingForInterrupt == 1) /*ADD IF TIME PASSED IS TOO LONG, THEN RETURN*/
    {
        wait_for_interrupt();
    }
   
    disable_interrupt();

    if (foil2 >= foil1)
      deltaF = foil2-foil1;
    else {
      deltaF = 0xFFFF - foil1 + foil2;
      nbrOverflow--;
    }
   
}  //end of startMeasure()


/*SHOOTING MODE*/
void startShooting() {

  waitingForInterrupt2 = 1;
  foil1 = 0;
  inMeasureMode = 0;
 
  //Turn flash trigger off.
  PORTD &= 0xEF;
 
  //Capture falling edge only
  TCTL2 |= 0x0A; //xxxx 1x1x
  TCTL2 &= 0xFA; //xxxx x0x0
 
  //clear flag first for PA0
  TFLG1 = 0x01;
  //clear flag first for timer Overflow
  TFLG2 = 0x80;
 
  //Enable PORTA[0] for time capture
  TMSK1 |= 0x01; //xxxx xxx1
 
  //set PA4 as output campare pin
  OC1M |= 0x10; 
   
  enable_interrupt();
 
//start 

  while(waitingForInterrupt2 == 1) {
    wait_for_interrupt();
  }

  disable_interrupt();
  for (i=0; i < 1000; i++){}
  //Turn flash trigger off.
  PORTD &= 0xEF;
}

//Timer Ovwerflow
interrupt void TO_interrupt()
{
    nbrOverflow++;
   
    //clear flag Timer Overflow
    TFLG2 = 0x80;
}

//PA0, first foil, interrupt which cause the system to start counting
interrupt void IC3_interrupt()
{
    //clear flag Timer Overflow
    TFLG2 = 0x80;

    foil1 = TIC3;    //store captured time from TIC 3 to foil1

    if (! inMeasureMode) {
      if (nbrOverflow > 0)
          TOC4 = foil1;
      else
          TOC4 = deltaF + foil1;
     
      //clear flag first for PA4
      TFLG1 = 0x10;
      //Enable OC4 interrupt
      TMSK1 |= 0x10;
    }  //end of if (!inMeasureMode)   
    else {
      //Enable Timer Overflow
      TMSK2 |= 0x80;
    }
   
    //clear flag first for PA0
    TFLG1 = 0x01;
    //Disable IC3 interrupt
    TMSK1 &= 0xFE; //xxxx xxx0

}

//end measurement
interrupt void IC2_interrupt()
{
    foil2 = TIC2;

    //clear flag first for PA1
    TFLG1 = 0x02;
    //Disable IC2 interrupts
    TMSK1 &= 0xFD; //xxxx xx0x
    //Disable Timer Ovewflow
    TMSK2 &= 0x7F;
   
    waitingForInterrupt = 0;
}

interrupt void OC4_interrupt()
{
    foil2 = TCNT;

    if (nbrOverflow == 0) {
      PORTD |= 0x10;  //Turn flash trigger on.
      waitingForInterrupt2 = 0; //Exit while-loop in startShooting()
      //Disable OC4 interrupts
      TMSK1 &= 0xEF; //xxx0 xxxx
    } else if (nbrOverflow == 1) {
      TOC4 = deltaF + foil2;
      nbrOverflow--;
    } else {
      TOC4 = foil2;
      nbrOverflow--;
    }
   
    //clear flag first for PA4
    TFLG1 = 0x10;
}


*           

CSTARTUP.S07

                                      *               
*                                                              *
*  This module contains the 68HC11 startup routine and          *
*  must usually be tailored to suit special hardware needs      *
*                                                              *
*  Note:  The routine ?SEG_INIT_L07 is now included in CSTARTUP *
*  The size of stack is set in the link-file (lnk6???.xcl)      *
*  The segment INTVEC is declared COMMON                        *
*                                                              *
*  Version:    3.30 [IHAW 11/Feb/92]                            *
*  Revised:    3.31 [IHAW 07/Jul/92] Bug in stack init          *
*  Revised:    3.32 [IJAR 06/Mar/93] Startup code for K4 added  *
*  Revised:    4.11 [IMAI 29/Oct/96] Updated for ICC6811 4.11  *
*  [SN 19/jan/98] Updated for Digitala projekt                  *
*                                                              *
*---------------------------------------------------------------*
    NAME    CSTARTUP
    EXTERN    ?C_EXIT    ; Where to go when program is done
 
    EXTERN    main        ; Where to begin execution

*---------------------------------------------------------------*
*  CSTACK - The C stack segment                                *
*                                                              *
*  Please look in the link-file ??????.xcl how to increment    *
*  the stack without having to reassemble cstartup.s07 !        *
*---------------------------------------------------------------*

    RSEG    CSTACK
    RMB    0        ; A bare minimum !!

*---------------------------------------------------------------*
*  Forward declarations of segments used in initialization      *
*---------------------------------------------------------------*

    RSEG    UDATA0
    RSEG    UDATA1
    RSEG    IDATA0
    RSEG    IDATA1
    RSEG    ECSTR
    RSEG    WCSTR
    RSEG    CDATA0
    RSEG    CDATA1
    RSEG    CCSTR
    RSEG    CONST
    RSEG    CSTR
    RSEG    TEMP

   
*---------------------------------------------------------------*
*  RCODE - Where the program actually starts                    *
*---------------------------------------------------------------*
    RSEG    RCODE
init_C:                     
    LDS    #$00FF    ; #$01FF for 68HC11E9
                      ; #$02FF for 68HC11E20

*---------------------------------------------------------------*
* If the 68HC11 OPTION register MUST be modified, here is the  *
* place to do it in order to meet the 64-cycle requirement.    *
* You can also do it in the beginning of main if You don't use  *
* seg_init                                                      *
*---------------------------------------------------------------*

    LDAA #$00          ;store value 00000000 in TMSK2 to set the speed of TCNT. (500 ns)
    STAA $1024

*---------------------------------------------------------------*
* If it is not a requirement that static/global data is set    *
* to zero or to some explicit value at startup, the next line  *
* of code can be deleted.                                      *
*---------------------------------------------------------------*
                                                                     
    BSR    seg_init

*---------------------------------------------------------------*
* If hardware must be initiated from assembly or if interrupts  *
* should be on when reaching main, this is the place to insert  *
* such code.                                                    *
*---------------------------------------------------------------*

    JSR    main        main()

*---------------------------------------------------------------*
* Now when we are ready with our C program (usually 6811        *
* programs are continouous) we must perform a system-dependent  *
* action.  In this simple case we jump to ?C_EXIT.              *
*---------------------------------------------------------------*
* DO NOT CHANGE NEXT LINE OF CSTARTUP IF YOU WANT TO RUN YOUR  *
* SOFTWARE WITH THE AID OF THE C-SPY HLL DEBUGGER.              *
*---------------------------------------------------------------*
    JMP    ?C_EXIT   


*---------------------------------------------------------------*
*  Copy initialized PROMmed code to shadow RAM and clear        *
*  uninitialized variables.                                    *
*---------------------------------------------------------------*
seg_init:

*---------------------------------------------------------------*
*  Zero out UDATA segments                                      *
*---------------------------------------------------------------*

    LDD    #.SFE.(UDATA0)
    SUBD    #.SFB.(UDATA0)
    BEQ    SKIP00
    XGDY
    LDX    #.SFB.(UDATA0)
    BSR    zero_mem
SKIP00

    LDD    #.SFE.(UDATA1)
    SUBD    #.SFB.(UDATA1)
    BEQ    SKIP01
    XGDY
    LDX    #.SFB.(UDATA1)
    BSR    zero_mem
SKIP01

*---------------------------------------------------------------*
* Copy CDATA segments into IDATA segments                      *
*---------------------------------------------------------------*

    LDD    #.SFE.(CDATA0)
    SUBD    #.SFB.(CDATA0)
    BEQ    SKIP02
    LDX    #.SFB.(CDATA0)
    LDY    #.SFB.(IDATA0)
    BSR    copy_mem
SKIP02

    LDD    #.SFE.(CDATA1)
    SUBD    #.SFB.(CDATA1)
    BEQ    SKIP03
    LDX    #.SFB.(CDATA1)
    LDY    #.SFB.(IDATA1)
    BSR    copy_mem
SKIP03

*---------------------------------------------------------------*
* Copy CCSTR into ECSTR                                        *
*---------------------------------------------------------------*

    LDD    #.SFE.(CCSTR)
    SUBD    #.SFB.(CCSTR)
    BEQ    SKIP04
    LDX    #.SFB.(CCSTR)
    LDY    #.SFB.(ECSTR)
    BSR    copy_mem
SKIP04
    RTS                ; End of initialization

*---------------------------------------------------------------*
* Clear memory                                                  *
*---------------------------------------------------------------*
zero_mem:
    CLR    0,X
    INX
    DEY
    BNE    zero_mem
    RTS

*---------------------------------------------------------------*
*  Copy memory                                                  *
*  Copy (X) --> (Y), counter in D                              *
*---------------------------------------------------------------*
copy_mem:
    PSHA
    LDAA    0,X
    STAA    0,Y
    PULA   
    INX
    INY
    SUBD    #1
    BNE    copy_mem
    RTS



*---------------------------------------------------------------*
*  Interrupt vectors must be inserted by the user.    Here we  *
*  only used RESET.                                            *
*---------------------------------------------------------------*

    COMMON    INTVEC
                ; Assuming start address = FFD6 for 68HC11
    RMB    40

    FDB    init_C

    ENDMOD    init_C        ; 'init_C' is program entry address

*---------------------------------------------------------------*
* Function/module: exit(int code)                              *
*                                                              *
* When C-SPY is used this code will automatically be replaced  *
* by a 'debug' version of exit().                              *
*---------------------------------------------------------------*
    MODULE    exit

    PUBLIC    exit
    PUBLIC    ?C_EXIT

    RSEG    RCODE

?C_EXIT:
exit:
*---------------------------------------------------------------*
* The next line could be replaced by user defined code.        *
*---------------------------------------------------------------*
end_loop:
    BRA    end_loop

    END














/*                      - Vectors.h -

  This file defines the interrupt vector addresses of the 68HC11
  and appropriate function names that can be used with the interrupts.
  It is assumed that the segment INTVEC is located at address 0xFFD6.
*/

#pragma language=extended

#define INTVEC_START    0              /* Default for 68HC11 (must be matched
                                          to the value used at link-time)  */


                /*=======================*/
                /* Interrupt Definitions */
                /*=======================*/

                /* SCI Serial Communication Interface */
interrupt [INTVEC_START +  0] void SCI_interrupt(void);

                /* SPI Serial Transfer Complete */
interrupt [INTVEC_START +  2] void SPI_interrupt(void);

                /* Pulse Accumulator Input Edge */
interrupt [INTVEC_START +  4] void PAIE_interrupt(void);

                /* Pulse Accumulator Overflow */
interrupt [INTVEC_START +  6] void PAO_interrupt(void);

                /* Timer Overflow */
interrupt [INTVEC_START +  8] void TO_interrupt(void);

                /* Timer Output Compare 5 */
interrupt [INTVEC_START + 10] void OC5_interrupt(void);

                /* Timer Output Compare 4 */
interrupt [INTVEC_START + 12] void OC4_interrupt(void);

                /* Timer Output Compare 3 */
interrupt [INTVEC_START + 14] void OC3_interrupt(void);

                /* Timer Output Compare 2 */
interrupt [INTVEC_START + 16] void OC2_interrupt(void);

                /* Timer Output Compare 1 */
interrupt [INTVEC_START + 18] void OC1_interrupt(void);

                /* Timer Input Compare 4 */
interrupt [INTVEC_START + 10] void IC4_interrupt(void);

                /* Timer Input Compare 3 */
interrupt [INTVEC_START + 20] void IC3_interrupt(void);

                /* Timer Input Compare 2 */
interrupt [INTVEC_START + 22] void IC2_interrupt(void);

                /* Timer Input Compare 1 */
interrupt [INTVEC_START + 24] void IC1_interrupt(void);

                /* Real Time Interrupt */
interrupt [INTVEC_START + 26] void RTI_interrupt(void);

                /* Interrupt ReQuest */
interrupt [INTVEC_START + 28] void IRQ_interrupt(void);

                /* eXtended Interrupt ReQuest */
interrupt [INTVEC_START + 30] void XIRQ_interrupt(void);

                /* SoftWare Interrupt */
interrupt [INTVEC_START + 32] void Software_interrupt(void);

                /* Illegal Opcode Trap */
interrupt [INTVEC_START + 34] void Illegal_Opcode(void);

/* Watchdog and Clock Monitor are defined i cstartup.s07 */ 


/* FILENAME: IO-reg.h


*
* Register and bit macro definitions for
* all HC11 types in A and E series.
*
* Uppdatering 990917: volatile bara för PORTCL, SPSR och SCSR.
*
*/

#define REG_BASE 0x1000

#define PORTA  (*(unsigned char *)(REG_BASE + 0x00))
#define PIOC    (*(unsigned char *)(REG_BASE + 0x02))
#define PORTC  (*(unsigned char *)(REG_BASE + 0x03))
#define PORTB  (*(unsigned char *)(REG_BASE + 0x04))
#define PORTCL  (*(volatile unsigned char *)(REG_BASE + 0x05))
#define DDRC    (*(unsigned char *)(REG_BASE + 0x07))
#define PORTD  (*(unsigned char *)(REG_BASE + 0x08))
#define DDRD    (*(unsigned char *)(REG_BASE + 0x09))
#define PORTE  (*(unsigned char *)(REG_BASE + 0x0A))
#define CFORC  (*(unsigned char *)(REG_BASE + 0x0B))
#define OC1M    (*(unsigned char *)(REG_BASE + 0x0C))
#define OC1D    (*(unsigned char *)(REG_BASE + 0x0D))
#define TCNT    (*(unsigned int *)(REG_BASE + 0x0E))
#define TIC1    (*(unsigned int *)(REG_BASE + 0x10))
#define TIC2    (*(unsigned int *)(REG_BASE + 0x12))
#define TIC3    (*(unsigned int *)(REG_BASE + 0x14))
#define TIC4    (*(unsigned int *)(REG_BASE + 0x1E))
#define TOC1    (*(unsigned int *)(REG_BASE + 0x16))
#define TOC2    (*(unsigned int *)(REG_BASE + 0x18))
#define TOC3    (*(unsigned int *)(REG_BASE + 0x1A))
#define TOC4    (*(unsigned int *)(REG_BASE + 0x1C))
#define TOC5    (*(unsigned int *)(REG_BASE + 0x1E))
#define TI4/O4  (*(unsigned int *)(REG_BASE + 0x1E))
#define TCTL1  (*(unsigned char *)(REG_BASE + 0x20))
#define TCTL2  (*(unsigned char *)(REG_BASE + 0x21))
#define TMSK1  (*(unsigned char *)(REG_BASE + 0x22))
#define TFLG1  (*(unsigned char *)(REG_BASE + 0x23))
#define TMSK2  (*(unsigned char *)(REG_BASE + 0x24))
#define TFLG2  (*(unsigned char *)(REG_BASE + 0x25))
#define PACTL  (*(unsigned char *)(REG_BASE + 0x26))
#define PACNT  (*(unsigned char *)(REG_BASE + 0x27))
#define SPCR    (*(unsigned char *)(REG_BASE + 0x28))
#define SPSR    (*(volatile unsigned char *)(REG_BASE + 0x29))
#define SPDR    (*(unsigned char *)(REG_BASE + 0x2A))
#define BAUD    (*(unsigned char *)(REG_BASE + 0x2B))
#define SCCR1  (*(unsigned char *)(REG_BASE + 0x2C))
#define SCCR2  (*(unsigned char *)(REG_BASE + 0x2D))
#define SCSR    (*(volatile unsigned char *)(REG_BASE + 0x2E))
#define SCDR    (*(unsigned char *)(REG_BASE + 0x2F))
#define ADCTL  (*(unsigned char *)(REG_BASE + 0x30))
#define ADR1    (*(unsigned char *)(REG_BASE + 0x31))
#define ADR2    (*(unsigned char *)(REG_BASE + 0x32))
#define ADR3    (*(unsigned char *)(REG_BASE + 0x33))
#define ADR4    (*(unsigned char *)(REG_BASE + 0x34))
#define BPROT  (*(unsigned char *)(REG_BASE + 0x35))
#define EPROG  (*(unsigned char *)(REG_BASE + 0x36))
#define OPTION  (*(unsigned char *)(REG_BASE + 0x39))
#define COPRST  (*(unsigned char *)(REG_BASE + 0x3A))
#define PPROG  (*(unsigned char *)(REG_BASE + 0x3B))
#define HPRIO  (*(unsigned char *)(REG_BASE + 0x3C))
#define INIT    (*(unsigned char *)(REG_BASE + 0x3D))
#define TEST1  (*(unsigned char *)(REG_BASE + 0x3E))
#define CONFIG  (*(unsigned char *)(REG_BASE + 0x3F))

/* Bit names for general use */
#define bit7    0x80
#define bit6    0x40
#define bit5    0x20
#define bit4    0x10
#define bit3    0x08
#define bit2    0x04
#define bit1    0x02
#define bit0    0x01

/* PORTA bit definitions 0x00 */
#define PA7    bit7
#define PA6    bit6
#define PA5    bit5
#define PA4    bit4
#define PA3    bit3
#define PA2    bit2
#define PA1    bit1
#define PA0    bit0

/* PIOC bit definitions 0x02 */
#define STAF    bit7
#define STAI    bit6
#define CWOM    bit5
#define HNDS    bit4
#define OIN    bit3
#define PLS    bit2
#define EGA    bit1
#define INVB    bit0

/* PORTC bit definitions 0x03 */
#define PC7    bit7
#define PC6    bit6
#define PC5    bit5
#define PC4    bit4
#define PC3    bit3
#define PC2    bit2
#define PC1    bit1
#define PC0    bit0

/* PORTB bit definitions 0x04 */
#define PB7    bit7
#define PB6    bit6
#define PB5    bit5
#define PB4    bit4
#define PB3    bit3
#define PB2    bit2
#define PB1    bit1
#define PB0    bit0

/* PORTCL bit definitions 0x05 */
#define PCL7    bit7
#define PCL6    bit6
#define PCL5    bit5
#define PCL4    bit4
#define PCL3    bit3
#define PCL2    bit2
#define PCL1    bit1
#define PCL0    bit0

/* DDRC bit definitions 0x07 */
#define DDC7    bit7
#define DDC6    bit6
#define DDC5    bit5
#define DDC4    bit4
#define DDC3    bit3
#define DDC2    bit2
#define DDC1    bit1
#define DDC0    bit0

/* PORTD bit definitions 0x08 */
#define PD5    bit5
#define PD4    bit4
#define PD3    bit3
#define PD2    bit2
#define PD1    bit1
#define PD0    bit0

/* DDRD bit definitions 0x09 */
#define DDD5    bit5
#define DDD4    bit4
#define DDD3    bit3
#define DDD2    bit2
#define DDD1    bit1
#define DDD0    bit0

/* PORTE bit definitions 0x0A */
#define PE7    bit7
#define PE6    bit6
#define PE5    bit5
#define PE4    bit4
#define PE3    bit3
#define PE2    bit2
#define PE1    bit1
#define PE0    bit0

/* CFORC bit definitions 0x0B */
#define FOC1    bit7
#define FOC2    bit6
#define FOC3    bit5
#define FOC4    bit4
#define FOC5    bit3

/* OC1M bit definitions 0x0C */
#define OC1M7  bit7
#define OC1M6  bit6
#define OC1M5  bit5
#define OC1M4  bit4
#define OC1M3  bit3

/* OC1D bit definitions 0x0D */
#define OC1D7  bit7
#define OC1D6  bit6
#define OC1D5  bit5
#define OC1D4  bit4
#define OC1D3  bit3

/* TCTL1 bit definition 0x20 */
#define OM2    bit7
#define OL2    bit6
#define OM3    bit5
#define OL3    bit4
#define OM4    bit3
#define OL4    bit2
#define OM5    bit1
#define OL5    bit0

/* TCTL2 bit definitions 0x21 */
#define EDG4B  bit7
#define EDG4A  bit6
#define EDG1B  bit5
#define EDG1A  bit4
#define EDG2B  bit3
#define EDG2A  bit2
#define EDG3B  bit1
#define EDG3A  bit0

/* TMSK1 bit definitions 0x22 */
#define OC1I    bit7
#define OC2I    bit6
#define OC3I    bit5
#define OC4I    bit4
#define I4O5I  bit3
#define IC1I    bit2
#define IC2I    bit1
#define IC3I    bit0

/* TFLG1 bit definitions 0x23 */
#define OC1F    bit7
#define OC2F    bit6
#define OC3F    bit5
#define OC4F    bit4
#define I4O5F  bit3
#define IC1F    bit2
#define IC2F    bit1
#define IC3F    bit0

/* TMSK2 bit definitions 0x24 */
#define TOI    bit7
#define RTII    bit6
#define PAOVI  bit5
#define PAII    bit4
#define PR1    bit1
#define PR0    bit0

/* TFLG2 bit definitions 0x25 */
#define TOF    bit7
#define RTIF    bit6
#define PAOVF  bit5
#define PAIF    bit4

/* PACTL bit definitions 0x26 */
#define DDRA7  bit7
#define PAEN    bit6
#define PAMOD  bit5
#define PEDGE  bit4
#define DDRA3  bit3
#define I4O5    bit2
#define RTR1    bit1
#define RTR0    bit0

/* SPCR bit definitions 0x28 */
#define SPIE    bit7
#define SPE    bit6
#define DWOM    bit5
#define MSTR    bit4
#define CPOL    bit3
#define CPHA    bit2
#define SPR1    bit1
#define SPR0    bit0

/* SPSR bit definitions 0x29 */
#define SPIF    bit7
#define WCOL    bit6
#define MODF    bit4

/* BAUD bit definitions 0x2B */
#define TCLR    bit7
#define SCP2    bit6
#define SCP1    bit5
#define SCP0    bit4
#define RCKB    bit3
#define SCR2    bit2
#define SCR1    bit1
#define SCR0    bit0

/* SCCR1 bit definition 0x2C */
#define R8      bit7
#define T8      bit6
#define M      bit4
#define WAKE    bit3

/* SCCR2 bit definitions 0x2D */
#define TIE    bit7
#define TCIE    bit6
#define RIE    bit5
#define ILIE    bit4
#define TE      bit3
#define RE      bit2
#define RWU    bit1
#define SBK    bit0

/* SCSR  bit definitions 0x2E */
#define TDRE    bit7
#define TC      bit6
#define RDRF    bit5
#define IDLE    bit4
#define OR      bit3
#define NF      bit2
#define FE      bit1

/* SCDR bit definitions 0x2F */
#define R7T7    bit7
#define R6T6    bit6
#define R5T5    bit5
#define R4T4    bit4
#define R3T3    bit3
#define R2T2    bit2
#define R1T1    bit1
#define R0T0    bit0

/* ADCTL bit definitions 0x30 */
#define CCF    bit7
#define SCAN    bit5
#define MULT    bit4
#define CD      bit3
#define CC      bit2
#define CB      bit1
#define CA      bit0

/* BPROT bit definitions 0x35 */
#define PTCON  bit4
#define BPRT3  bit3
#define BPRT2  bit2
#define BPRT1  bit1
#define BPRT0  bit0

/* EPROG bit definitions 0x36      MC68HC(7)11E20 only */
#define MBE    bit7
/* ELAT defined in PPROG */
#define EXCOL  bit4
#define EXROW  bit3
#define T1      bit2
#define T0      bit1
#define PGM    bit0

/* OPTION bit definitions 0x39 */
#define ADPU    bit7
#define CSEL    bit6
#define IRQE    bit5
#define DLY    bit4
#define CME    bit3
#define CR1    bit1
#define CR0    bit0

/* PPROG bit definitions 0x3B */
#define ODD    bit7
#define EVEN    bit6
#define ELAT    bit5    /* MC68HC711E9 only */
#define BYTE    bit4
#define ROW    bit3
#define ERASE  bit2
#define EELAT  bit1
#define EEPGM  bit0
#define EPGM    bit0

/* HPRIO bit definitions 0x3C */
#define RBOOT  bit7
#define SMOD    bit6
#define MDA    bit5
#define IRVNE  bit4
#define PSEL3  bit3
#define PSEL2  bit2
#define PSEL1  bit1
#define PSEL0  bit0

/* INIT  bit definitions 0x3D */
#define RAM3    bit7
#define RAM2    bit6
#define RAM1    bit5
#define RAM0    bit4
#define REG3    bit3
#define REG2    bit2
#define REG1    bit1
#define REG0    bit0

/* TEST1 bit definitions 0x3E */
#define TILOP  bit7
#define OCCR    bit5
#define CBYP    bit4
#define DISR    bit3
#define FCM    bit2
#define FCOP    bit1
#define TCON    bit0

/* CONFIG bit definitions 0x3F */
#define EE3    bit7    /* MC68HC811E2 only */
#define EE2    bit6    /* MC68HC811E2 only */
#define EE1    bit5    /* MC68HC811E2 only */
#define EE0    bit4    /* MC68HC811E2 only */
#define NOSEC  bit3
#define NOCOP  bit2
#define ROMON  bit1    /* MC68HC11E9 and MC68HC11E8 only */
#define EPON    bit1    /* MC68HC711E9 only */
#define EEON    bit0