$$ifp$ 80C196KT || 80C196KQ || 80C196KR || 80C196JR || 80C196JQ || 80C196JT
/*
 *  Copyright (c) 1995, Intel Corporation
 *
 *  $Workfile:   196kxc.cod  $
 *  $Revision:   1.4  $
 *  $Modtime:   Apr 12 1995 16:51:42  $
 *
 *  Purpose:
 *
 *
 *
 *
 *
 *  Compiler:       
 *
 *  Ext Packages:   
 *
 * 
 *
 */
196KR/JR/JQ/KQ/KT/NT/NP/JT
##80C196?? WRITE#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
  $$IFSTR$ REG_MNEM "CCR0"
#pragma CCB(0x$%XREG_VALUE & 0xFF$)
  $$END$
  $$IFSTR$ REG_MNEM "CCR1"
#pragma CCB($%cCCR0 & 0xff$$%Tccr0.4-7$$0$$%xREG_VALUE & 0xff$)
  $$END$
  $$IFSTR$ REG_MNEM "ccr2"
#pragma CCB($%cCCR0 & 0xff$$%Tccr0.4-7$$0$$%xCCR1 & 0xff$$%xREG_VALUE & 0xff$)
  $$END$
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
@@REG_MNEM@_$$REG_WSR$ = $%cREG_VALUE$;
  $$END$
  $$IFN$ REG_USEWSR
@@REG_MNEM@ = $%cREG_VALUE$;
  $$END$
$$END$
##80C196?? READ#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
The Chip Configuration Byte is a ROM location.
Select WRITE to configure CCB's
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
UserVar = @@REG_MNEM@_$$REG_WSR$;
  $$END$
  $$IFN$ REG_USEWSR
UserVar = @@REG_MNEM@;
  $$END$
$$END$
##80C196?? OR#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
The Chip Configuration Byte is a ROM location.
Select WRITE to configure CCB's
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
@@REG_MNEM@_$$REG_WSR$ |= $%cREG_VALUE$;
  $$END$
  $$IFN$ REG_USEWSR
@@REG_MNEM@ |= $%cREG_VALUE$;
  $$END$
$$END$
##80C196?? AND#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
The Chip Configuration Byte is a ROM location.
Select WRITE to configure CCB's
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
@@REG_MNEM@_$$REG_WSR$ &= $%cREG_VALUE$;
  $$END$
  $$IFN$ REG_USEWSR
@@REG_MNEM@ &= $%cREG_VALUE$;
  $$END$
$$END$
##80C196?? XOR#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
The Chip Configuration Byte is a ROM location.
Select WRITE to configure CCB's
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
@@REG_MNEM@_$$REG_WSR$ ^= $%cREG_VALUE$;
  $$END$
  $$IFN$ REG_USEWSR
@@REG_MNEM@ ^= $%cREG_VALUE$;
  $$END$
$$END$
##80C196?? TESTZ#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
The Chip Configuration Byte is a ROM location.
Select WRITE to configure CCB's
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
if(!(@@REG_MNEM@_$$REG_WSR$ & $%cREG_VALUE$))
  $$END$
  $$IFN$ REG_USEWSR
if(!(@@REG_MNEM@ & $%cREG_VALUE$))
  $$END$
{
  /* User Code */
}
$$END$
##80C196?? TESTNZ#
$$IFSTR$ REG_MNEM "CCR0" |STR "CCR1" |STR "CCR2"
The Chip Configuration Byte is a ROM location.
Select WRITE to configure CCB's
$$END$
$$ELSE$
  $$IF$ REG_USEWSR
wsr = $%cREG_WSR$;
if(@@REG_MNEM@_$$REG_WSR$ & $%cREG_VALUE$)
  $$END$
  $$IFN$ REG_USEWSR
if(@@REG_MNEM@ & $%cREG_VALUE$)
  $$END$
{
  /* User Code */
}
$$END$
##80C196NT AD#
##80C196NQ AD#
##80C196KT AD#
##80C196KQ AD#
##80C196KR AD#
##80C196JR AD#
##80C196JT AD#
##80C196JQ AD#
$$ifp$ 80C196KT || 80C196KQ || 80C196KR || 80C196JR || 80C196JQ || 80C196JT
#pragma model(KR)
$$end$
$$ifp$ 80C196NT || 80C196NQ
#pragma model(NT)
$$end$
#include <80c196kr.h>
#define  ATOD_BUSY            (ad_result & 0x08)
#define  GO_NOW               0x08
#define  GO_EPA               0x00
#define  TEN_BIT_MODE         0x00
#define  EIGHT_BIT_MODE       0x10
#define  THRESH_DETECT_LO     0x30
#define  THRESH_DETECT_HI     0x20

$$if$ AD_TEST.0
/*   convert_atod performs a 10-bit atod conversion and is used by 
     the init routine to calculate the offset error.  This routine 
     waits until the atod busy bit is cleared before and after the 
     conversion. Interrupts should be disabled and the AD_TIME 
     should be initialized prior to calling this routine.     */

unsigned int convert_10bit_atod(void)
{
 while(ATOD_BUSY);
 ad_command =  GO_NOW | TEN_BIT_MODE;
 zero_reg=zero_reg+zero_reg;     /*  needed for 4 state delay  */
 zero_reg=zero_reg+zero_reg;     /*  needed for 4 state delay  */
 while(ATOD_BUSY);
 return((ad_result >> 6));
}
$$end$
void init_atod_converter()
{
$$ifn$ ad_command.5 
/*
* init_atod_converter:
*    Programs the A/D conversion speed and sample time by writing
*    CONV to ad_test.4-0 and SAM to ad_test.7-5.   
*
     $$if$ ad_command.4
*    CONV = (Tconv * Fosc - 3) / 16 - 1
*    SAM = (Tsam * Fosc - 2) / 8
     $$end$
     $$ifn$ ad_command.4
*    CONV = (Tconv * Fosc - 3) / 20 - 1
*    SAM = (Tsam * Fosc -2) / 8
     $$end$
*
*    Sample time (Tsam) = @@SAMP_TM@ microseconds
*    Conversion time (Tconv) = @@CONV_TM@ microseconds
*/
$$end$

ad_time = 0x$$AD_TIME$;

$$ifn$ AD_TEST.0 &! AD_TEST.3
/*
*  An offset adjustment of $%TAD_TEST.2$+2.5 mV$0.0 mV$ will be added to the 
*  conversion result.
$$end$
$$ifn$ AD_TEST.0 && AD_TEST.3
/*
*  An offset adjustment of $%TAD_TEST.2$-5.0 mV$-2.5 mV$ will be added to the
*  conversion result.
$$end$

$$if$ AD_TEST.0
/*
* A/D Test reference is $%TAD_TEST.1$VREF$ANGND$
$$end$
*
$$ifn$ AD_TEST.0 &! AD_TEST.3
* A/D Offset adjustment = $%TAD_TEST.2$+2.5 mV$0.0 mV$
*
$$end$
$$ifn$ AD_TEST.0 && AD_TEST.3
* A/D Offset adjustment = $%TAD_TEST.2$-5.0 mV$-2.5 mV$
*
$$end$
$$if$ AD_TEST.0
* A/D Offset adjustment is run time calculated.
*
$$end$
*/

 clrbit(int_mask,5);          /*clear bit 5 to disable atod interrupt*/
$$if$ AD_TEST.0

#define   ATOD_TEST_ENABLE    0x0$$AD_TEST.0$
#define   ATOD_TEST_GND       0x00
#define   ATOD_TEST_VREF      0x02
#define   OFFSET_0_0_mV       0x00
#define   OFFSET_2_5_mV       0x04
#define   OFFSET_NEG_2_5_mV   0x08
#define   OFFSET_NEG_5_0_mV   0x0C

     $$ifn$ AD_TEST.1
/*   This offset calculation code is used to calculate the zero
     offset error and add a offset to correct it.  First it checks
     the the highest offset and works down to the lowest
     offset until a zero reading is obtained at ANGND
     specified channel if test mode is disable.   */

  ad_test = ATOD_TEST_ENABLE | ATOD_TEST_GND | OFFSET_2_5_mV;
  if(convert_10bit_atod())
     {
     ad_test = ATOD_TEST_ENABLE | ATOD_TEST_GND | OFFSET_0_0_mV;
     if(convert_10bit_atod())
        {
        ad_test = ATOD_TEST_ENABLE | ATOD_TEST_GND | OFFSET_NEG_2_5_mV;
        if(convert_10bit_atod())
           {
           ad_test = OFFSET_NEG_5_0_mV;
           }
        }
    }
     $$end$
     $$if$ AD_TEST.1


/*   This offset calculation code is used to calculate the full
     scale offset error and add a offset to correct it.  First
     it checks the the lowest offset and works up to the highest
     offset until a full scale reading is obtained at VREF if
     test mode is disable.   */

  ad_test = ATOD_TEST_ENABLE | ATOD_TEST_VREF | OFFSET_NEG_5_0_mV;
  if(convert_10bit_atod() != 0x3ff)
     {
     ad_test = ATOD_TEST_ENABLE | ATOD_TEST_VREF | OFFSET_NEG_2_5_mV;
     if(convert_10bit_atod() != 0x3ff)
        {
        ad_test = ATOD_TEST_ENABLE | ATOD_TEST_VREF | OFFSET_0_0_mV;
        if(convert_10bit_atod() != 0x3ff)
           {
           ad_test = OFFSET_2_5_mV;
           }
        }
    }
     $$end$         /*  end if vref reference */
ad_test &= 0xFC;   /*  Clear Test mode. */
$$end$         /*  end if calculate  */
$$ifn$ AD_TEST.0
ad_test = 0x$$AD_TEST$;   /*  Set Test mode. */
$$end$

/*
* The A/D conversion complete interrupt is enabled by setting
* INT_MASK.5 and disabled by clearing INT_MASK.5.
*
* A/D Interrupt is $%EINT_MASK.5$
*/

$$if$ INT_MASK.5
 setbit(int_mask,5);
$$end$
}

/*
* A/D Channel Number is $$AD_COMMAND.0-2$
* Conversion Start Time is $%TAD_COMMAND.3$immediately$by EPA$
* Threshold Detect is $%EAD_COMMAND.5$
$$if$ AD_COMMAND.5
* Detection level is Detect $%TAD_COMMAND.4$LOW$HIGH$
$$end$
$$ifn$ AD_COMMAND.5
* Conversion type: $%TAD_COMMAND.4$8 bit$10 bit$
$$end$
*/
$$ifn$ INT_MASK.5
/*   convert_atod performs an atod conversion and.  This routine 
     waits until the atod busy bit is cleared before and after the 
     conversion. Interrupts should be disabled and the AD_TIME 
     should be initialized prior to calling this routine.     */

$%tAD_COMMAND.3$unsigned int$void$ convert_atod(unsigned char channel)
{
 while(ATOD_BUSY);
     $$ifn$ AD_COMMAND.5
 ad_command =  channel | $%tAD_COMMAND.3$GO_NOW$GO_EPA$ | $%tAD_COMMAND.4$EIGHT$TEN$_BIT_MODE;
     $$end$
     $$if$ AD_COMMAND.5
 ad_command =  channel | $%tAD_COMMAND.3$GO_NOW$GO_EPA$ | THRESH_DETECT_$%tAD_COMMAND.4$LO$HI$;
     $$end$
     $$if$ AD_COMMAND.3
 zero_reg=zero_reg+zero_reg;     /*  needed for 4 state delay  */
 zero_reg=zero_reg+zero_reg;     /*  needed for 4 state delay  */
 while(ATOD_BUSY);
          $$ifn$ AD_COMMAND.5 &! AD_COMMAND.4
 return((ad_result >> 6));
          $$end$
          $$ifn$ AD_COMMAND.5 && AD_COMMAND.4
 return(ad_result_hi);
          $$end$
          $$if$ AD_COMMAND.5
 return(ad_result);
          $$end$
     $$end$
}
$$end$

void main(void)
{
$$ifn$ INT_MASK.5 && AD_COMMAND.3
unsigned int result;
$$end$
     /*   Initialize the atod unit  */
 init_atod_converter();
$$if$ INT_MASK.5
 enable();
 ad_command = $%TAD_COMMAND.3$GO_NOW$GO_EPA$ | 0x0$$AD_COMMAND.0-2$ /* channel number */ |
$$if$ AD_COMMAND.5
              $%TAD_COMMAND.4$THRESH_DETECT_LO$THRESH_DETECT_HI$;
$$end$
$$ifn$ AD_COMMAND.5
              $%TAD_COMMAND.4$EIGHT_BIT_MODE$TEN_BIT_MODE$;
$$end$

 while(1);     /*  Wait around for the interrupt  */
$$end$
$$ifn$ INT_MASK.5 && AD_COMMAND.3
 result = convert_atod(0x0$$AD_COMMAND.0-2$);
 while(1);
$$end$
$$ifn$ INT_MASK.5 &! AD_COMMAND.3
 convert_atod(0x0$$AD_COMMAND.0-2$);
 while(1);   /*   wait for epa to generate atod.  The result
                  should be serviced by an interrupt.  */
$$end$
}
$$if$ INT_MASK.5
#pragma interrupt(atod_interrupt=0x05)

/*   The atod_interrupt routine will be vectored to if interrupts
     $$if$ AD_COMMAND.5
     are enabled and a threshold has been detected.  */
     $$end$
     $$ifn$ AD_COMMAND.5
     are enabled and a atod conversion has completed.  */
     $$end$

void atod_interrupt()
{
     $$ifn$ AD_COMMAND.5 &! AD_COMMAND.4
 unsigned int result;  /* used for temporary storage  */
 result = (ad_result >> 6);

/*  result can now be stored or acted upon by user's code  */
     $$end$
     $$ifn$ AD_COMMAND.5 && AD_COMMAND.4
 unsigned char result;  /* used for temporary storage  */
 result = (ad_result_hi);

/*  result can now be stored or acted upon by user's code  */
     $$end$
     $$if$ AD_COMMAND.5

/*  The users code can now act upon the detected $%TAD_COMMAND.4$low$high$ threshold  */
     $$end$
}
$$end$
##80C196NT IO_EP#
##80C196NQ IO_EP#
#pragma model(NT)
#include <80c196kr.h>

#define   EXT_BUS_A16    0x01
#define   EXT_BUS_A17    0x02
#define   EXT_BUS_A18    0x04
#define   EXT_BUS_A19    0x08
#define   EXT_BUS_A20    0x10
#define   EXT_BUS_A21    0x20
#define   EXT_BUS_A22    0x40
#define   EXT_BUS_A23    0x80

#define   LSIO_0         0x00
#define   LSIO_1         0x00
#define   LSIO_2         0x00
#define   LSIO_3         0x00
#define   LSIO_4         0x00
#define   LSIO_5         0x00
#define   LSIO_6         0x00
#define   LSIO_7         0x00

#define   IO_INPUT0      0x01
#define   IO_INPUT1      0x02
#define   IO_INPUT2      0x04
#define   IO_INPUT3      0x08
#define   IO_INPUT4      0x10
#define   IO_INPUT5      0x20
#define   IO_INPUT6      0x40
#define   IO_INPUT7      0x80
#define   IO_OUTPUT0     0x00
#define   IO_OUTPUT1     0x00
#define   IO_OUTPUT2     0x00
#define   IO_OUTPUT3     0x00
#define   IO_OUTPUT4     0x00
#define   IO_OUTPUT5     0x00
#define   IO_OUTPUT6     0x00
#define   IO_OUTPUT7     0x00

void init_eport(void)
{
 ep_reg = 0x$$EP_REG$;   /*  initial value in ep_reg  */
 ep_dir = $%TEP_DIR.0$IO_INPUT0$IO_OUTPUT0$ | $%TEP_DIR.1$IO_INPUT1$IO_OUTPUT1$  |
          $%TEP_DIR.2$IO_INPUT2$IO_OUTPUT2$ | $%TEP_DIR.3$IO_INPUT3$IO_OUTPUT3$  |
          $%TEP_DIR.4$IO_INPUT4$IO_OUTPUT4$ | $%TEP_DIR.5$IO_INPUT5$IO_OUTPUT5$  |
          $%TEP_DIR.6$IO_INPUT6$IO_OUTPUT6$ | $%TEP_DIR.7$IO_INPUT7$IO_OUTPUT7$;
 ep_mode = $%TEP_MODE.0$EXT_BUS_A16$LSIO_0$ | $%TEP_MODE.1$EXT_BUS_A17$LSIO_1$ |
           $%TEP_MODE.2$EXT_BUS_A18$LSIO_2$ | $%TEP_MODE.3$EXT_BUS_A19$LSIO_3$ |
           $%TEP_MODE.4$EXT_BUS_A20$LSIO_4$ | $%TEP_MODE.5$EXT_BUS_A21$LSIO_5$ |
           $%TEP_MODE.6$EXT_BUS_A22$LSIO_6$ | $%TEP_MODE.7$EXT_BUS_A23$LSIO_7$;
}
##80C196NT EPA#
##80C196NQ EPA#
##80C196KT EPA#
##80C196KQ EPA#
##80C196KR EPA#