while(1);
}  
##80C198 HSO0_CAM#
##80C194 HSO0_CAM#
##80C198 HSO1_CAM#
##80C194 HSO1_CAM#
##80C198 HSO2_CAM#
##80C194 HSO2_CAM#
##80C198 HSO3_CAM#
##80C194 HSO3_CAM#
##80C198 HSO4_CAM#
##80C194 HSO4_CAM#
##80C198 HSO5_CAM#
##80C194 HSO5_CAM#
##80C196KB HSO0_CAM#
##80C196KC HSO0_CAM#
##80C196KD HSO0_CAM#
##80C196KB HSO1_CAM#
##80C196KC HSO1_CAM#
##80C196KD HSO1_CAM#
##80C196KB HSO2_CAM#
##80C196KC HSO2_CAM#
##80C196KD HSO2_CAM#
##80C196KB HSO3_CAM#
##80C196KC HSO3_CAM#
##80C196KD HSO3_CAM#
##80C196KB HSO4_CAM#
##80C196KC HSO4_CAM#
##80C196KD HSO4_CAM#
##80C196KB HSO5_CAM#
##80C196KC HSO5_CAM#
##80C196KD HSO5_CAM#
$$ifp$ 80C198 || 80C194 || 80C196KB
#pragma model(kb)
$$end$
$$ifp$ 80C196KC || 80C196KD
#pragma model(kc)
$$end$
#include <80c196kd.h>

void init_hso$$HSO_NUMBER$_cam(void)
{
/*
* HSO $$HSO_NUMBER$ module configuration:
$$ifn$ hso_command.3 && hso_command.5
*   HSO event       = $%8hso_command.0-2$set hso0 pin$set hso1 pin$set hso2 pin $set hso3 pin$set hso4 pin$set hso5 pin$set pins hso0 and hso1$set pins hso2 and hso3$
$$end$
$$ifn$ hso_command.3 &! hso_command.5
*   HSO event       = $%8hso_command.0-2$clear hso0 pin$clear hso1 pin$clear hso2 pin$clear hso3 pin$clear hso4 pin$clear hso5 pin$clear pins hso0 and hso1$clear pins hso2 and hso3$
$$end$
$$if$ hso_command.3
*   HSO event       = $%8hso_command.0-2$program software timer 0$ program software timer 1$program software timer 2$program software timer 3$set pins hso0-5$$reset timer 2$start an A/D conversion$
$$end$
*   event interrupt = $%thso_command.4$enabled$disabled$
*   reference timer = $%thso_command.6$timer 2$timer 1$
*   locked event    = $%thso_command.7$yes$no$
$$if$ (RELATIVE == 1)
*   execution time  = $%thso_command.6$timer 2$timer 1$ + $$hso_time$h
$$end$
$$if$ (RELATIVE == O)
*   execution time  = $$hso_time$
$$end$
*/

  _WriteSFR   (hso_command, 0x$$HSO_COMMAND$);
$$if$ (RELATIVE == 1)
  hso_time = $%thso_command.6$timer2$timer1$ + 0x$$HSO_TIME$;
$$end$
$$if$ (RELATIVE == 0)
  _WriteSFR   (hso_time, 0x$$hso_time$);
$$end$   
}
void main(void)
{
  init_hso$$HSO_NUMBER$_cam();
  while(1);
}
##80C198 BIU#
##80C194 BIU#
##80C198 BIU#
##80C194 BIU#
##80C198 PM#
##80C194 PM#
##80C198 CODE#
##80C194 CODE#
##80C196KB BIU#
##80C196KD BIU#
##80C196KC BIU#
##80C196KB PM#
##80C196KD PM#
##80C196KC PM#
##80C196KB CODE#
##80C196KD CODE#
##80C196KC CODE#
$$ifp$ 80C198 || 80C194 || 80C196KB
#pragma model(kb)
$$end$
$$ifp$ 80C196KC || 80C196KD
#pragma model(kc)
$$end$
#include <80c196kd.h>

/*
* Chip configuration:
*   number of wait states  = $%4ccr.4-5$1$2$3$ready pin controlled$
$$ifp$ 80C198 || 80C194
*   bus control mode       = $%tccr.3$address valid strobe$standard bus control$
$$end$
$$ifp$ 80C196KB || 80C196KC || 80C196KD
*   bus control mode       = $%4ccr.2-3$Address valid with write strobe$Address valid strobe$Write strobe$Standard bus control$
$$end$
*   programming protection = $%4ccr.6-7$read and write$read only$write only$none$
*   power-down mode        = $%tccr.0$enabled$disabled$
$$ifp$ 80C196KB || 80C196KC || 80C196KD
*   buswidth control       = $%tccr.1$dynamic mode$8-bit$
*   hold/holda protocol    = $%twsr.7$enabled$disabled$
$$end$
*/

static const unsigned int ccr = 0x20$$ccr$;
#pragma locate (ccr = 0x2018)

void init_HoldEnable(void)
{
   wsr = wsr $%twsr.7$|$&$ $%twsr.7$0x80$0x7f$;
}
void main(void)
{
  init_HoldEnable();
$$if$ ccr.0
  /*   The following will put the processor in power down mode */
  power_down();
$$end$  
  while(1);
}
##80C194 ICU#
##80C198 ICU#
##80C196KB ICU#
##80C196KC ICU#
##80C196KD ICU#
$$ifp$ 80C198 || 80C194 || 80C196KB
#pragma model(kb)
$$end$
$$ifp$ 80C196KC || 80C196KD
#pragma model(kc)
$$end$
#include <80c196kd.h>

/* Initialize Interrupt Vectors. */

 #define   TOVF_INT             0
 #define   AD_INT               1
 #define   HSI_DATA_AVAIL_INT   2
 #define   HSO_INT              3
 #define   HSI0_INT             4
 #define   SW_TIMER_INT         5
 #define   SERIAL_INT           6
 #define   EXT_INT              7
 #define   TRAP_INT             8
 #define   UNIMPLEMENTED_INT    9
 #define   TXD_INT              24
 #define   RXD_INT              25
 #define   HSI_FIFO4_INT        26
 #define   TIMER2_CAPT_INT      27
 #define   T2OVF_INT            28
 #define   EXT1_INT             29
 #define   HSI_FIFO_FULL_INT    30
 #define   NONMASKABLE_INT      31

void init_interrupts(void)
{
/*
* Timer overflow interrupt          = $%tint_mask.0$enabled$disabled$
$$ifp$ 80C198 || 80C196KB || 80C196KC || 80C196KD
* A/D conversion complete interrupt = $%tint_mask.1$enabled$disabled$
$$end$
* HSI data available interrupt      = $%tint_mask.2$enabled$disabled$
* HSO interrupt                     = $%tint_mask.3$enabled$disabled$
* HSI.0 pin interrupt               = $%tint_mask.4$enabled$disabled$
* Timer interrupt                   = $%tint_mask.5$enabled$disabled$
* Serial port interrupt             = $%tint_mask.6$enabled$disabled$
* External interrupt                = $%tint_mask.7$enabled$disabled$
* Transmit interrupt                = $%tint_mask1.0$enabled$disabled$
* Receive interrupt                 = $%tint_mask1.1$enabled$disabled$
* HSI fifo 4 interrupt              = $%tint_mask1.2$enabled$disabled$
$$ifp$ 80C196KB || 80C196KC || 80C196KD
* Timer 2 capture interrupt         = $%tint_mask1.3$enabled$disabled$
$$end$
* Timer 2 overflow interrupt        = $%tint_mask1.4$enabled$disabled$
* External Interrupt 1              = $%tint_mask1.5$enabled$disabled$
* HSI fifo full interrupt           = $%tint_mask1.6$enabled$disabled$
*/

  int_mask = 0x$$int_mask$;
  int_mask1 = 0x$$int_mask1$;

$$if$ psw.1
/* Enabled global interrupt bit. */

  enable ();
$$end$
}
$$if$ int_mask.0

/*
* The following code is an interrupt service routine
* shell for the timer overflow interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.0$tovf_isr$error_isr$ = TOVF_INT)
$$if$ int_mask.0
void tovf_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.1

/*
* The following code is an interrupt service routine
* shell for the A/D conversion complete interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.1$ad_isr$error_isr$ = AD_INT)
$$if$ int_mask.1
void ad_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.2

/*
* The following code is an interrupt service routine
* shell for the HSI data available interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.2$hsi_data_avail_isr$error_isr$ = HSI_DATA_AVAIL_INT)
$$if$ int_mask.2
void hsi_data_avail_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.3

/*
* The following code is an interrupt service routine
* shell for the HSO interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.3$hso_isr$error_isr$ = HSO_INT)
$$if$ int_mask.3
void hso_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.4

/*
* The following code is an interrupt service routine
* shell for the HSI.0 pin interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.4$hsi0_isr$error_isr$ = HSI0_INT)
$$if$ int_mask.4
void hsi0_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.5

/*
* The following code is an interrupt service routine
* shell for the timer interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.5$sw_timer_isr$error_isr$ = SW_TIMER_INT)
$$if$ int_mask.5
void sw_timer_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.6

/*
* The following code is an interrupt service routine
* shell for the serial port interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.6$serial_isr$error_isr$ = SERIAL_INT)
$$if$ int_mask.6
void serial_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask.7

/*
* The following code is an interrupt service routine
* shell for the external interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask.7$ext_isr$error_isr$ = EXT_INT)
$$if$ int_mask.7
void ext_isr(void)
{
   /* User code goes here */
}
$$end$

/*
* The following code is an interrupt service routine
* shell for the trap interrupt.
*/

#pragma interrupt (trap_isr = TRAP_INT)
void trap_isr(void)
{
   /* User code goes here */
}

/*
* The following code is an interrupt service routine
* shell for the unimplemented opcode interrupt.
*/

#pragma interrupt (unimplemented_isr = UNIMPLEMENTED_INT)
void unimplemented_isr(void)
{
   /* User code goes here */
}
$$if$ int_mask1.0

/*
* The following code is an interrupt service routine
* shell for the transmit interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask1.0$txd_isr$error_isr$ = TXD_INT)
$$if$ int_mask1.0
void txd_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask1.1

/*
* The following code is an interrupt service routine
* shell for the receive interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask1.1$rxd_isr$error_isr$ = RXD_INT)
$$if$ int_mask1.1
void rxd_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask1.2

/*
* The following code is an interrupt service routine
* shell for the HSI fifo 4 interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask1.2$hsi_fifo4_isr$error_isr$ = HSI_FIFO4_INT)
$$if$ int_mask1.2
void hsi_fifo4_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask1.3

/*
* The following code is an interrupt service routine
* shell for the timer 2 capture interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask1.3$timer2_capt_isr$error_isr$ = TIMER2_CAPT_INT)
$$if$ int_mask1.3
void timer2_capt_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask1.4

/*
* The following code is an interrupt service routine
* shell for the timer 2 overflow interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask1.4$t2ovf_isr$error_isr$ = T2OVF_INT)
$$if$ int_mask1.4
void t2ovf_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask1.5

/*
* The following code is an interrupt service routine
* shell for the external interrupt 1.
*/

$$end$
#pragma interrupt ($%tint_mask1.5$ext1_isr$error_isr$ = EXT1_INT)
$$if$ int_mask1.5
void ext1_isr(void)
{
   /* User code goes here */
}
$$end$
$$if$ int_mask1.6

/*
* The following code is an interrupt service routine
* shell for the HSI fifo full interrupt.
*/

$$end$
#pragma interrupt ($%tint_mask1.6$hsi_fifo_full_isr$error_isr$ = HSI_FIFO_FULL_INT)
$$if$ int_mask1.6
void hsi_fifo_full_isr(void)
{
   /* User code goes here */
}
$$end$

/*
* The following code is an interrupt service routine
* shell for the nonmaskable interrupt.
*/

#pragma interrupt (nonmaskable_isr = NONMASKABLE_INT)
void nonmaskable_isr(void)
{
   /* User code goes here */
}

$$if$ (int_mask < 256) || (int_mask1 < 128)
/*
* Interrupts that do not have interrupt service routines
* associated with them should use an error routine.
*/

void error_isr(void)
{
   /* User code goes here */
}
$$end$

void main(void)
{
  init_interrupts();
  while(1);
}
##80C194 ICU_ExtINTR#
##80C198 ICU_ExtINTR#
##80C196KB ICU_ExtINTR#
##80C196KC ICU_ExtINTR#
##80C196KD ICU_ExtINTR#
$$ifp$ 80C198 || 80C194 || 80C196KB
#pragma model(kb)
$$end$
$$ifp$ 80C196KC || 80C196KD
#pragma model(kc)
$$end$
#include <80c196kd.h>

#define EXTINT_SRC  1

/*
*  external interrupt source = $%tioc1.1$p0.7$extint pin$
*/

void init_extint_src(void)
{
_$%tioc1.1$Set$Clr$SFR_bit (ioc1, EXTINT_SRC);
}
void main(void)
{
  init_extint_src();
  while(1);
}
##80C196KC PTS#
##80C196KD PTS#
$$ifp$ 80C198 || 80C194 || 80C196KB
#pragma model(kb)
$$end$
$$ifp$ 80C196KC || 80C196KD
#pragma model(kc)
$$end$
#include <80c196kd.h>

/*
* PTS interrupts:
*   timer overflow interrupt          = $%tptssel.0$enabled$disabled$
*   A/D conversion complete interrupt = $%tptssel.1$enabled$disabled$
*   HSI data available interrupt      = $%tptssel.2$enabled$disabled$
*   HSO interrupt                     = $%tptssel.3$enabled$disabled$
*   HSI.0 pin interrupt               = $%tptssel.4$enabled$disabled$
*   software timer interrupt          = $%tptssel.5$enabled$disabled$
*   serial port interrupt             = $%tptssel.6$enabled$disabled$
*   external interrupt                = $%tptssel.7$enabled$disabled$
*   transmit interrupt                = $%tptssel.8$enabled$disabled$
*   receive interrupt                 = $%tptssel.9$enabled$disabled$
*   HSI fifo 4 interrupt              = $%tptssel.10$enabled$disabled$
*   timer 2 capture interrupt         = $%tptssel.11$enabled$disabled$
*   timer 2 overflow interrupt        = $%tptssel.12$enabled$disabled$
*   external interrupt 1              = $%tptssel.13$enabled$disabled$
*   HSI fifo full interrupt           = $%tptssel.14$enabled$disabled$
*/
void init_pts(void)
{
  _WriteSFR   (int_mask, 0x$$int_mask$);
  _WriteSFR   (int_mask1, 0x$$int_mask1$);
  _WriteSFR   (ptssel, 0x$$ptssel$);

$$if$ psw.2
  enable_pts();
$$end$
}
void main(void)
{ 
  init_pts();
  while(1);
}
##80C196KC PTS_Single#
##80C196KD PTS_Single#
#pragma model(kc)
#include <80c196kd.h>
/* 
*  Initialization Code for Single Transfer for 
*  PTS vector 0x$$PTS_VECTOR$
*/

/* 
*  Create typedef template for the single transfer control
*  block.