RI-R6C-001A and Tag-it HF Sandard transponders

#define HF_ASIC_GLOBALS
#include "includes.h"

/******************************************************************************
 *
 * File Name: HFASIC.c
 * Copyright Texas Instruments, Inc. 2003. All rights reserved
 *
 * Description:
 *    This file contains the routines that implement the basic HF ASIC
 *    interface.
 *
 * Revision History:
 *
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/


// Added the following conditional to allow the released library files to compile with no warnings
// For internal use the DEBUG_MODE can be added into the Project files globals and have the warnings appear
#ifndef DEBUG_MODE
  #pragma warn-       // Disable warnings
#endif

//static BOOLEAN setThreshold = FALSE;

//uchar hfAsicTimeout = 1;

#ifdef HAVE_14443_B
  extern INT16U *T1A_ptr;
#endif

static BOOLEAN AsicReplyCriteria(void)
{
  return ( ( SCLOCK_High() ) && ( DOUT_High() ) );
  //return FALSE;
}

// isLsbFirst shall be set TRUE if bits are collected LS bit first.
static unsigned char Local_ASIC_Receive_Bits(BOOLEAN isLsbFirst, uchar fwi, uchar wtxm, INT16U initByteCount, uchar initBitCount)
{
  unsigned int delay_count;
  unsigned char ES2_Detected = FALSE;
  register uchar data_in;
  register uchar *pChar;
  register uchar mask;

  HF_ASIC.rcvdBytes = initByteCount;
  HF_ASIC.rcvdXtraBits = initBitCount;

  if ( (initByteCount == 0) && (initBitCount == 0) )
    HF_ASIC.Buffer[0] = 0;


  // Wait until SCLOCK goes high and then wait until DOUT also goes high.
  // When this happens, event S2 has occurred.
  data_in = FrameWaitTimer(fwi, wtxm, AsicReplyCriteria );  // 2.5 us

  // If there was an error (i.e. ERROR_TOKEN_NOT_PRESENT or ERROR_HF_ASIC_ABORTED)...
  if (data_in != ERROR_NONE)
    return data_in;           // Return error status

  data_in = Get_DOUT();

  // S2 Detected. Now wait for S2 completion => SCLOCK goes low.
  delay_count = 500;                    // Delay
  if (data_in != 0)
  {
    while (1)
    {
      if (!SCLOCK_High())
        break;

      // If DOUT goes low during SCLOCK pulse.....
      if ( !DOUT_High() )
      {
        // If SCLOCK is still high...
        if (SCLOCK_High())
          ES2_Detected = TRUE;
      }

      if (!SCLOCK_High())
        break;

      if (M_ERR_High())
        return ERROR_COLLISION_DETECT;

      if (!SCLOCK_High())
        break;

      // If DOUT goes low during SCLOCK pulse.....
      if ( (!DOUT_High()) )
      {
        // If SCLOCK is still high...
        if (SCLOCK_High())
          ES2_Detected = TRUE;
      }

      if (!SCLOCK_High())
        break;

      delay_count--;

      if (delay_count == 0)
        return ERROR_HF_ASIC_RECEIVE_TIMEOUT;
    }
  }
  else
  {
    while (1)
    {
      if (!SCLOCK_High())
        break;

      if (M_ERR_High())
        return ERROR_COLLISION_DETECT;

      delay_count--;

      if (!SCLOCK_High())
        break;

      if (delay_count == 0)
        return ERROR_HF_ASIC_RECEIVE_TIMEOUT;
    }
  }

  // Start receiving data now.
  while ((!ES2_Detected) && (!Abort_Module()))
  {
    if (M_ERR_High())
      return ERROR_COLLISION_DETECT;

    pChar = (HF_ASIC.Buffer + HF_ASIC.rcvdBytes);
    pChar[1] = 0;

    mask = 1 << ( (isLsbFirst) ? HF_ASIC.rcvdXtraBits : (7 - HF_ASIC.rcvdXtraBits) );

    // Wait until SCLOCK goes high and then collect data or check for ES2
    delay_count = 1500;                  // Delay
    while (1)
    {
      if (SCLOCK_High())
        break;
      if (delay_count == 0)
        return ERROR_HF_ASIC_RECEIVE_TIMEOUT;
      if (SCLOCK_High())
        break;
      if (M_ERR_High())
        return ERROR_COLLISION_DETECT;
      delay_count--;
    }

    // Store incoming bit into the receive buffer
    data_in = Get_DOUT();

    if (data_in != 0)
      *pChar |= mask;

    HF_ASIC.rcvdXtraBits = (HF_ASIC.rcvdXtraBits + 1) & 0x07;

    if (HF_ASIC.rcvdXtraBits == 0)
      HF_ASIC.rcvdBytes++;

    if (M_ERR_High())
      return ERROR_COLLISION_DETECT;

    delay_count = 2000;
    if (data_in != 0)
    {
      while (1)
      {
        if (!SCLOCK_High())
          break;

        // If DOUT goes low during SCLOCK pulse.....
        if ( !DOUT_High() )
        {
          // If SCLOCK is still high...
          if (SCLOCK_High())
            ES2_Detected = TRUE;
        }

        if (!SCLOCK_High())
          break;

        if (M_ERR_High())
          return ERROR_COLLISION_DETECT;

        if (!SCLOCK_High())
          break;

        // If DOUT goes low during SCLOCK pulse.....
        if ( (!DOUT_High()) )
        {
          // If SCLOCK is still high...
          if (SCLOCK_High())
            ES2_Detected = TRUE;
        }

        if (!SCLOCK_High())
          break;

        delay_count--;

        if (delay_count == 0)
          return ERROR_HF_ASIC_RECEIVE_TIMEOUT;
      }
    }
    else
    {
      while (1)
      {
        if (!SCLOCK_High())
          break;

        if (M_ERR_High())
          return ERROR_COLLISION_DETECT;

        delay_count--;

        if (!SCLOCK_High())
          break;

        if (delay_count == 0)
          return ERROR_HF_ASIC_RECEIVE_TIMEOUT;
      }
    }
  }

  if (Abort_Module())
    return ERROR_HF_ASIC_ABORTED;

  return ERROR_NONE;
} // End of Local_ASIC_Receive_Bits()


/******************************************************************************
 * Function Name: HF_ASIC_Send_S1()
 *
 * Description:
 *    This function will send a "S1" according to the definition in RI-R6C-001A
 *   HF Reader System Series 6000, S6700 Multiprotocol transceiver IC, reference
 *   guide, pages 18 and 19.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
void HF_ASIC_Send_S1(void)
{
  Clear_SCLOCK();                       // SCLOCK = 0
  Clear_DIN();                          // DIN = 0

  // Set SCLOCK and wait 5 cycles - at least 300 ns delay
  Set_SCLOCK();                         // SCLOCK = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Set DIN and wait 5 cycles - at least 300 ns delay
  Set_DIN();                            // DIN = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
} // End of HF_ASIC_Send_S1()


/******************************************************************************
 * Function Name: HF_ASIC_Send_ES1()
 *
 * Description:
 *    This function will send a "ES1" according to the definition in RI-R6C-001A
 *   HF Reader System Series 6000, S6700 Multiprotocol transceiver IC, reference
 *   guide, pages 18 and 19.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
void HF_ASIC_Send_ES1(void)
{
  Clear_SCLOCK();                       // SCLOCK = 0
  Set_DIN();                            // DIN = 1

  // Set SCLOCK and wait 5 cycles - at least 300 ns delay
  Set_SCLOCK();                         // SCLOCK = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Set DIN and wait 5 cycles - at least 300 ns delay
  Clear_DIN();                            // DIN = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  Clear_SCLOCK();                       // SCLOCK = 0
} // End of HF_ASIC_Send_ES1()


/******************************************************************************
 * Function Name: HF_ASIC_Send_Bit()
 *
 * Description:
 *    This function will send a bit according to the definition in RI-R6C-001A
 *   HF Reader System Series 6000, S6700 Multiprotocol transceiver IC, reference
 *   guide, pages 18 and 19.
 *
 * Parameters:
 *    uchar   bit_val   indicates whether a 0 or 1 should be sent
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
void HF_ASIC_Send_Bit(unsigned char bit_val)
{
	INT16U loop_cnt;
	
  // Wait until DOUT goes low - DOUT low means FIFO is not full
 // while (DOUT_High()) { }
	loop_cnt = 0;
	while(1)
	{
     if (!DOUT_High())
       break;
     loop_cnt++;
     // Check for condition where the HFASIC locks up with DOUT high
     // Just go on and hope for the best
     if( loop_cnt == 0xFFFF)
       break; 
	}

  Clear_SCLOCK();                       // SCLOCK = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  if (bit_val)
  {
    // Send a 1 bit
    Set_DIN();                            // DIN = 1
  }
  else
  {
    // Send a 0 bit
    Clear_DIN();                          // DIN = 0
  }
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Set SCLOCK and wait 10 cycles - at least 600 ns delay
  Set_SCLOCK();                         // SCLOCK = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  Clear_SCLOCK();                       // SCLOCK = 0
} // End of HF_ASIC_Send_Bit()


/******************************************************************************
 * Function Name: HF_ASIC_Transmitter_On()
 *
 * Description:
 *    This function will turn on the transmitter (carrier frequency 13.56 MHz)
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, page 20.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
void HF_ASIC_Transmitter_On(void)
{
  HF_ASIC_Send_S1();
  HF_ASIC_Send_Bit(1);
  HF_ASIC_Send_ES1();
  hfAsicXmitState = 1;
} // End of HF_ASIC_Transmitter_On()


/******************************************************************************
 * Function Name: HF_ASIC_Transmitter_Off()
 *
 * Description:
 *    This function will turn off the transmitter (carrier frequency 13.56 MHz)
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, page 20. The sequence
 *  to turn off transmitter is S1, 1, ES1 where the 1 is a bit not a byte.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
 void HF_ASIC_Transmitter_Off(void)
{
  Clear_SCLOCK();                       // SCLOCK = 0
  Clear_DIN();                          // DIN = 0

  // Set SCLOCK and wait 5 cycles - at least 300 ns delay
  Set_SCLOCK();                         // SCLOCK = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Set DIN and wait 5 cycles - at least 300 ns delay
  Set_DIN();                            // DIN = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Clear DIN and wait 5 cycles - at least 300 ns delay
  Clear_DIN();                            // DIN = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  Clear_SCLOCK();                       // SCLOCK = 0
  hfAsicXmitState = 0;
} // End of HF_ASIC_Transmitter_Off()


/******************************************************************************
 * Function Name: HF_ASIC_Send_TRAN1()
 *
 * Description:
 *    This function will send a TRAN1 sequence to the HF ASIC
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, page 26.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
 void HF_ASIC_Send_TRAN1(void)
{
  Clear_SCLOCK();                       // SCLOCK = 0
  Clear_DIN();                          // DIN = 0

  // Set DIN and wait 5 cycles - at least 600 ns delay
  Set_DIN();                            // DIN = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Clear DIN and wait 5 cycles - at least 600 ns delay
  Clear_DIN();                            // DIN = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  Make_SCLOCK_Input();

  Set_DIN();                            // DIN = 1

} // End of HF_ASIC_Send_TRAN1()


/******************************************************************************
 * Function Name: HF_ASIC_Send_TRAN2()
 *
 * Description:
 *    This function will send a TRAN2 sequence to the HF ASIC
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, page 27.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
void HF_ASIC_Send_TRAN2(void)
{
  // Clear DIN and wait 5 cycles - at least 300 ns delay
  Clear_DIN();                          // DIN = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  // Wait until SCLOCK gies low
  while (SCLOCK_High()) {}

  // Set DIN and wait 9 cycles - at least 600 ns delay
  Set_DIN();                            // DIN = 1
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Clear DIN and wait 9 cycles - at least 600 ns delay
  Clear_DIN();                            // DIN = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  Make_SCLOCK_Output();

//  Set_DIN();                            // DIN = 1

} // End of HF_ASIC_Send_TRAN2()


/******************************************************************************
 * Function Name: HF_ASIC_Read_Bit()
 *
 * Description:
 *    This function will read a bit from the HF ASIC 8-bit FIFO
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, pages 22, 24 and 25.
 *  This can only be used in the register mode and not in one of the defined
 *  modes or the direct mode (page 19).
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    uchar   0 or a 1 depending on the bit read from the HF ASIC interface.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char HF_ASIC_Read_Bit(void)
{
  unsigned char rcv_data = 0;

  Clear_SCLOCK();                       // SCLOCK = 0
  Clear_DIN();                          // DIN = 0
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");

  // Set SCLOCK and wait 1 cycle - at least 74 ns delay
  Set_SCLOCK();                         // SCLOCK = 1
  #asm("NOP");

  // Get the value of DIN
  rcv_data = Get_DOUT();

  // Wait 5 cycles and clear SCLOCK
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  #asm("NOP");
  Clear_SCLOCK();                       // SCLOCK = 0

  return rcv_data;
} // End of HF_ASIC_Read_Bit()


/******************************************************************************
 * Function Name: HF_ASIC_Receive_Bits()
 *
 * Description:
 *    This function will read a bit from the HF ASIC 8-bit FIFO
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, pages 22, 24 and 25.
 *  This can not be used in the register mode or the direct mode. This can be
 *  used in one of the defined modes (page 19, table 5 bit values 001 through
 *  100). This detects manchestor decoder error.
 *
 * Parameters:
 *    BOOLEAN   isLsbFirst  TRUE if bits are to be collected lsb first
 *    uchar     fwi         Frame Wait Integer (per ISO14443 standard)
 *    uchar     wtxm        Wait Time eXtension Multiplier (per ISO14443 standard)
 *
 * Returns:
 *    uchar   Error code. Received data shall be stored in HF_ASIC.Buffer[].
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char HF_ASIC_Receive_Bits(BOOLEAN isLsbFirst, uchar fwi, uchar wtxm)
{
  unsigned char retVal;
  INT_DISABLE(TIMR0_COMP);

  retVal = Local_ASIC_Receive_Bits(isLsbFirst, fwi, wtxm, 0, 0);

  INT_ENABLE(TIMR0_COMP);

  return (retVal);

} // End of HF_ASIC_Receive_Bits()



/******************************************************************************
 * Function Name: HF_ASIC_Write()
 *
 * Description:
 *    This function will send data_len bytes to the HF ASIC 8-bit FIFO
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide. This is the main
 *  portal for the HF ASIC interface. The command byte (argument cmd) will
 *  indicate the mode in which the data should be sent and also the actions.
 *
 * Parameters:
 *    uchar   cmd       The command byte of the HF ASIC interface protocol.
 *    uchar   data_len  #bytes to be sent.
 *    uchar*  data_ptr  pointer to the data to be sent.
 *    uchar   fwi       Frame Wait Integer (per ISO14443 standard)
 *    uchar   wtxm      Wait Time eXtension Multiplier (per ISO14443 standard)
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char HF_ASIC_Write(uchar cmd,
                            uchar data_len,
                            uchar *data_ptr,
                            uchar fwi,
                            uchar wtxm)
{
  unsigned char return_value;

  if ((REGISTER_MODE & cmd) == REGISTER_MODE)
  {
    // Handle register mode communication
    return_value = Handle_Tag_Comm(cmd, ( ((INT16U)data_len) << 3 ), data_ptr, fwi, wtxm, TRUE, HF_ASIC_FRAME_DEFAULT);
  }
  else if (((CONFIG_MODE & cmd) != CONFIG_MODE) &&
            ((CONFIG_MODE & cmd) <= ISO14443_A_MODE))
  {
    // Normal mode communication with HF ASIC in-built modes
    #asm("CLC");               // Insert opcode to clear the carry bit.
    switch (cmd & MODE_MASK)
    {
        case TAG_IT_MODE :
        case ISO15693_1OUT4_MODE :
        case ISO15693_1OUT256_MODE :
        case ISO14443_A_MODE :
          return_value = Handle_Tag_Comm(cmd, ( ((INT16U)data_len) << 3 ), data_ptr, fwi, wtxm, TRUE, HF_ASIC_FRAME_DEFAULT);
          break;

        case DIRECT_MODE :
#ifdef HAVE_14443_B
          return_value = Handle_Direct_Mode(cmd, data_len, data_ptr, fwi, wtxm);
#else
          return_value = ERROR_INVALID_RF_FORMAT;
#endif
          break;
    }
  }
  else if ((CONFIG_MODE & cmd) == CONFIG_MODE)
  {
    #asm("CLC");               // Insert opcode to clear the carry bit.
    switch (cmd & MODE_MASK)
    {
      case READ_CONFIG_REGISTER :
        return_value = Handle_Read_Reg(cmd, data_len, data_ptr);
        break;

      case POWER_DOWN :
        return_value = Handle_Power_Down(cmd, data_len, data_ptr);
        break;

      default :
        return_value = Handle_Write_Reg(cmd, data_len, data_ptr);
        break;
    }
  }

  return return_value;
} // End of HF_ASIC_Write()


/******************************************************************************
 * Function Name: Handle_Tag_Comm()
 *
 * Description:
 *    This function will send num_bits bits to the RF interface
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide. This is the main
 *  portal for the RF interface. The command byte (argument cmd) will
 *  indicate the mode in which the data should be sent and also the actions.
 *
 * Parameters:
 *    uchar   cmd         The command byte of the HF ASIC interface protocol.
 *    INT16U  num_bits    #bits to be sent.
 *    uchar*  data_ptr    pointer to the data to be sent.
 *    uchar   fwi         Frame Wait Integer (per ISO14443 standard)
 *    uchar   wtxm        Wait Time eXtension Multiplier (per ISO14443 standard)
 *    BOOLEAN isLsbFirst  TRUE if bits are to be sent least-significant bit 1st
 *    BOOLEAN frameType   Used to request ISO14443A parity and split bytes
 *
 *  Bit oriented frame has no CRC but has parity bit for each byte. It is
 *  described in detail in ISO14443A - 3 spec. The HF_ASIC.rcvdXtraBits value
 *  returned is a special case and it reflects the number of bits in data_ptr
 *  array that can be sent with an anticollision packet without collision.
 *  HF_ASIC.rcvdBytes contents are meaningless for bit oriented frame.
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char Handle_Tag_Comm(uchar cmd,
                              INT16U num_bits,
                              uchar *data_ptr,
                              uchar fwi,
                              uchar wtxm,
                              BOOLEAN isLsbFirst,
                              BOOLEAN FrameRetType)
{
  INT16U srcIdx, destIdx;
  uchar srcMsk, destMsk;
  register uchar indx;

  uchar temp, temp1, parity;
  INT16U response_location;
  INT16U count, num_bytes;
  uchar ret_val;
  uchar frameType;

  ret_val = ERROR_NONE;
  frameType = FrameRetType;

  // Send S1 to start with.
  HF_ASIC_Send_S1();

  // Send command
  if ((REGISTER_MODE & cmd) == REGISTER_MODE)
  {
    // Register mode - Command is just a bit. Send a '1' bit.
    HF_ASIC_Send_Bit(1);
  }
  else
  {
    // Normal mode - send the command byte.
    temp = cmd;
    for (indx = 0; indx < 8; indx++)
    {
      HF_ASIC_Send_Bit((temp & 0x80) >> 7);
      temp <<= 1;
    }
  }

  num_bytes = (num_bits >> 3);

  // Send data
  for (count = 0; (count < num_bytes); count++)
  {
    parity = 1;
    temp = data_ptr[count];

    for (indx = 0; indx < 8; indx++)
    {
      if (isLsbFirst)
      {
        if (temp & 0x01)
          parity++;

        HF_ASIC_Send_Bit(temp & 0x01);
        temp >>= 1;
      }
      else
      {
        if (temp & 0x80)
          parity++;

        HF_ASIC_Send_Bit((temp & 0x80) >> 7);
        temp <<= 1;
      }
    }

    switch (frameType)
    {
      case HF_ASIC_FRAME_14443A_BIT:
      {
        HF_ASIC.Buffer[count] = data_ptr[count];
        HF_ASIC.Buffer[count+1] = 0;
        /* NO BREAK */                                // Spill into next case
      }
      case HF_ASIC_FRAME_14443A_STD:
      {
        HF_ASIC_Send_Bit(parity & 0x01);
      }
    }
  }

  temp = data_ptr[count];

  if (frameType == HF_ASIC_FRAME_14443A_BIT)
  {
     if (num_bits & 0x0007)
       HF_ASIC.Buffer[count] = temp;

     response_location = num_bits;
  }
  else
    response_location = 0;

  // Send remaining bits in partial end byte
  for (count = (num_bits & 0x0007); (count > 0); count--)
  {
    if (isLsbFirst)
    {
      HF_ASIC_Send_Bit(temp & 0x01);
      temp >>= 1;
    }
    else
    {
      HF_ASIC_Send_Bit((temp & 0x80) >> 7);
      temp <<= 1;
    }
  }

  // Send ES1 to complete sending data to the HF ASIC.
  HF_ASIC_Send_ES1();

  // Transfer clock control to the HF ASIC
  HF_ASIC_Send_TRAN1();

  // Check for the end of our transmission
  for (count = 1200; (count != 0); count--)
  {
      if (M_ERR_High())
        break;
      if (Abort_Module())
      {
        // Reclaim clock control back from the HF ASIC
        HF_ASIC_Send_TRAN2();
        return ERROR_HF_ASIC_ABORTED;
      }
  }

  // If the HF ASIC did not indicate an end of transmission
  if (count == 0)
  {
    // Reclaim clock control back from the HF ASIC
    HF_ASIC_Send_TRAN2();
    return ERROR_HF_ASIC_RECEIVE_TIMEOUT;
  }

  // Receive data from the HF ASIC
  INT_DISABLE(TIMR0_COMP);

#ifdef HAVE_14443_A
  if ((cmd & MODE_MASK) == (ISO14443_A_MODE | REGISTER_MODE))
  {
    ret_val = Manchester_Receive_Bits(BPSK_UL_BAUD_106, fwi,
                  wtxm, (response_location >> 3), ( ((uchar)response_location) & 0x07));
  }
  else
  {
    ret_val = Local_ASIC_Receive_Bits(isLsbFirst, fwi, wtxm,
                  (response_location >> 3), ( ((uchar)response_location) & 0x07));
  }
#else
  ret_val = Local_ASIC_Receive_Bits(isLsbFirst, fwi, wtxm,
                (response_location >> 3), ( ((uchar)response_location) & 0x07));
#endif

  INT_ENABLE(TIMR0_COMP);
  // Reclaim clock control back from the HF ASIC
  HF_ASIC_Send_TRAN2();

#ifdef HAVE_14443_A
  if ((ret_val == ERROR_NONE) &&
      (cmd & MODE_MASK) == (ISO14443_A_MODE | REGISTER_MODE))
  {
    // Short frames REQA/WUPA return ATQA in standard frames??
    if (frameType == HF_ASIC_FRAME_DEFAULT)
      frameType = HF_ASIC_FRAME_14443A_STD;

    // If ISO14443A parity frame, verify and remove parity bits.
    if (frameType != HF_ASIC_FRAME_DEFAULT)
    {
      if (frameType == HF_ASIC_FRAME_14443A_BIT)
      {
        srcIdx = destIdx = num_bytes;                         // Start at the first byte sent/received
        srcMsk = destMsk = 1 << ( num_bits & 0x0007);         // Start at the first bit sent/received
      }
      else if (frameType == HF_ASIC_FRAME_14443A_STD)
      {
        srcIdx = destIdx = 0;         // Start at the first byte sent/received
        srcMsk = destMsk = 1;         // Start at the first bit sent/received
        num_bytes = 0;
      }

      // While we have not traversed each (concatenated) message byte...
      while ( (srcIdx <= (HF_ASIC.rcvdBytes + num_bytes)) &&
              (ret_val == ERROR_NONE) )
      // Check and remove parity bits from message.
      {
        // If we are on the last byte...
        if (srcIdx == (HF_ASIC.rcvdBytes + num_bytes))
        {
          temp = (1 << HF_ASIC.rcvdXtraBits);
          indx = 0;
          if (temp > srcMsk)
          {
            temp1 = srcMsk;
            while (temp1 < temp)
            {
              temp1 <<= 1;
              indx++;
            }
          }
        }
        // Else, we are in the middle of the message...
        else
          indx = 8;                            // Perform operation on all bits in byte

        if (indx == 0)
          srcIdx++;

        parity = 0x01;                         // Initialize ODD parity

        // While we have not traversed each received data and parity bit in the byte...
        while (indx != 0)
        // Check parity (except for the first parity bit) and remove parity bits, shifting each data bit into position
        {
          indx--;
          // If the bit in question is a one...
          if (HF_ASIC.Buffer[srcIdx] & srcMsk)
          {
            HF_ASIC.Buffer[destIdx] |= destMsk;             // Place a 1 in the appropriate position
            parity ^= 0x01;                                 // Increment our running parity check
          }

          // Else, the bit is a zero...
          else
            HF_ASIC.Buffer[destIdx] &= ~destMsk;            // Place a 0 in the appropriate position

          srcMsk <<= 1;                                     // Prepare to get next bit

          // If we're done with a received raw byte...
          if (srcMsk == 0)
          {
            srcMsk = 0x01;                                  // Wrap around to the beginning of the next byte
            srcIdx++;                                       // Index to next received byte
          }

          destMsk <<= 1;                                    // Prepare to put next bit

          // If we're done with a processed byte...
          if (destMsk == 0)
          // Perform parity check (unless it is the first one)
          {
            destMsk = 0x01;                                  // Wrap around to the beginning of the next byte
            destIdx++;                                       // Index to next processed byte

            // If the parity bit is a one...
            if (HF_ASIC.Buffer[srcIdx] & srcMsk)
              temp = 1;                                      // Remember the 1

            // Else, the parity bit is a zero...
            else
              temp = 0;                                      // Remember the 0

            // If the parity does not match and this is not the first parity bit...
            if (temp != parity)
            {
              if (frameType == HF_ASIC_FRAME_14443A_BIT)
              {
                if  ( (srcIdx != destIdx) || (srcMsk != destMsk) )
                {
                  ret_val = ERROR_14443_A_UPLINK_PARITY;         // Return a parity error
                  indx = 0;                                      // Drop out of the loop
                }
              }
              else
              {
                ret_val = ERROR_14443_A_UPLINK_PARITY;         // Return a parity error
                indx = 0;                                      // Drop out of the loop
              }
            }

            srcMsk <<= 1;                                    // Prepare to get next bit

            // If we're done with a received raw byte...
            if (srcMsk == 0)
            {
              srcMsk = 0x01;                                 // Wrap around to the beginning of the next byte
              srcIdx++;                                      // Index to next received byte
            }
          }
        }
      }

      HF_ASIC.rcvdBytes = destIdx;                           // Adjust the number of bytes received

      indx = 0;                                              // Prepare to count the number of bits in the trailing partial byte

      // While we have not shifted the bit mask off yet...
      while (destMsk != 0)
      {
        indx++;                                              // Count a bit
        destMsk >>= 1;                                       // Shift the mask down one position
      }

      HF_ASIC.rcvdXtraBits = indx - 1;                       // Adjust the number of extra bits received
    }
  }
#endif

  return ret_val;                                          // Exit with status
} // End of Handle_Tag_Comm()



/******************************************************************************
 * Function Name: Handle_Read_Reg()
 *
 * Description:
 *    This function will read 1 byte of data from the HF ASIC interface
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide. This will store the
 *  data read into data_ptr[0].
 *
 * Parameters:
 *    uchar   cmd       The command byte of the HF ASIC interface protocol.
 *    uchar   data_len  #bytes to be sent.
 *    uchar*  data_ptr  pointer to the data to be sent.
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char Handle_Read_Reg(unsigned char cmd,
                              unsigned char data_len,
                              unsigned char *data_ptr)
{
  unsigned char temp, indx, count;

  // Send S1 to start with.
  HF_ASIC_Send_S1();

  // Send command
  temp = cmd;
  for (indx = 0; indx < 8; indx++)
  {
    HF_ASIC_Send_Bit((temp & 0x80) >> 7);
    temp <<= 1;
  }

  // Read data from the register
  temp = 0;
  indx = 0;
  count = 0;
  while (indx < data_len)
  {
    temp |= ( HF_ASIC_Read_Bit() << (indx & 0x07) );
    
    indx++;
    
    if ((indx & 0x07) == 0)
    {
      data_ptr[count++] = temp;
      temp = 0;
    }
  }

  if ((indx & 0x07) != 0)
    data_ptr[count] = temp;
    
  // Send ES1 to complete sending data to the HF ASIC.
  HF_ASIC_Send_ES1();

  return ERROR_NONE;
} // End of Handle_Read_Reg()


/******************************************************************************
 * Function Name: Handle_Write_Reg()
 *
 * Description:
 *    This function will write data_len bits of data to the HF ASIC interface
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide. This data to be
 *  written should be passed in through data_ptr.
 *  NOTE: One peculiarity of the HF ASIC interface is that the command byte is
 *    sent MS bit first but the rest of the data LS bit first.
 *
 * Parameters:
 *    uchar   cmd       The command byte of the HF ASIC interface protocol.
 *    uchar   data_len  #bytes to be sent.
 *    uchar*  data_ptr  pointer to the data to be sent.
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char Handle_Write_Reg(unsigned char cmd,
                              unsigned char data_len,
                              unsigned char *data_ptr)
{
  unsigned char temp, indx, count;

  // Send S1 to start with.
  HF_ASIC_Send_S1();

  // Send command - MS bit first
  temp = cmd;
  for (indx = 0; indx < 8; indx++)
  {
    HF_ASIC_Send_Bit((temp & 0x80) >> 7);
    temp <<= 1;
  }

  // Send data_len bits of data to the register - LS bit first
  count = 0;
  for (indx = 0; indx < data_len; indx++)
  {
    if ((indx & 0x07) == 0)
      temp = data_ptr[count++];
    HF_ASIC_Send_Bit(temp & 0x01);
    temp >>= 1;
  }

  // Send ES1 to complete sending data to the HF ASIC.
  HF_ASIC_Send_ES1();

  return ERROR_NONE;
} // End of Handle_Write_Reg()


/******************************************************************************
 * Function Name: Handle_Power_Down()
 *
 * Description:
 *    This function will turn off the HF ASIC and put it into low-power mode
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide.
 *
 * Parameters:
 *    uchar   cmd       The command byte of the HF ASIC interface protocol.
 *    uchar   data_len  #bytes to be sent.
 *    uchar*  data_ptr  pointer to the data to be sent.
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char Handle_Power_Down(unsigned char cmd,
                              unsigned char data_len,
                              unsigned char *data_ptr)
{
  unsigned char temp, indx;

  // Send S1 to start with.
  HF_ASIC_Send_S1();

  // Send command
  temp = cmd;
  for (indx = 0; indx < 8; indx++)
  {
    HF_ASIC_Send_Bit((temp & 0x80) >> 7);
    temp <<= 1;
  }

  // Send ES1 to complete sending data to the HF ASIC.
  HF_ASIC_Send_ES1();

  return ERROR_NONE;
} // End of Handle_Power_Down()


#ifdef HAVE_14443_B

/******************************************************************************
 * Function Name: Handle_Direct_Mode()
 *
 * Description:
 *    This function will put the HF ASIC into direct mode of operation
 *  according to the definition in RI-R6C-001A HF Reader System Series 6000,
 *  S6700 Multiprotocol transceiver IC, reference guide, page 23. This is useful
 *  to send data to the RF interface in a non-defined mode like ISO 14443-B.
 *
 * Parameters:
 *    uchar   cmd       The command byte of the HF ASIC interface protocol.
 *    uchar   data_len  #bytes to be sent.
 *    uchar*  data_ptr  pointer to the data to be sent.
 *    uchar   fwi       Frame Wait Integer (per ISO14443 standard)
 *    uchar   wtxm      Wait Time eXtension Multiplier (per ISO14443 standard)
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char Handle_Direct_Mode(uchar cmd,
                                 uchar data_len,
                                 uchar *data_ptr,
                                 uchar fwi,
                                 uchar wtxm)
{
  unsigned char temp, indx;
  //unsigned int delay_count;
  IntMaskType Interrupt_Table;                // Interrupt vector table
  uchar ret_val = ERROR_NONE;

  HF_ASIC.BPSK_Error_Code = ERR_BPSK_NO_ERROR;

  // Prepare downlink baudrate settings
  // Test code: next 1 line(s)
  ISO14443B_Downlink_Speed = ISO143B_BAUD_106; // Set it here for now
  switch (ISO14443B_Downlink_Speed)
  {
    case ISO143B_BAUD_106 :
      Tic_Per_Bit = BAUD_106_1_ETU;
      break;
    case ISO143B_BAUD_212 :
      Tic_Per_Bit = BAUD_212_1_ETU;
      break;
    case ISO143B_BAUD_424 :
      Tic_Per_Bit = BAUD_424_1_ETU;
      break;
    case ISO143B_BAUD_847 :
      Tic_Per_Bit = BAUD_847_1_ETU;
      break;
    default:
      Set_SCLOCK();
      Clear_SCLOCK();
      return ERROR_14443_DATA_INCORRECT;
  }

  // Prepare data stream for data transmission
  if (ISO14443B_Downlink_Speed != ISO143B_BAUD_847)
  {
    Prep_Data_14443B(data_len, data_ptr);
  }

  // Send S1 to start with.
  HF_ASIC_Send_S1();

  // Send command byte
  temp = cmd;
  for (indx = 0; indx < 8; indx++)
  {
    HF_ASIC_Send_Bit((temp & 0x80) >> 7);
    temp <<= 1;
  }

  // Send ES1 to complete sending data to the HF ASIC.
  HF_ASIC_Send_ES1();

  // Store current interrupt conditions and clear all interrupts
  InterruptMaskOperation(INT_MSK_OP_CLEAR_ALL, Interrupt_Table);

  // Krishna: Disable Timer1A interrupt for polling loop implementation of downlink
  INT_DISABLE(TIMR1_COMPA);

  if (ISO14443B_Downlink_Speed != ISO143B_BAUD_847)
  {
    // Set up Timer 1A to CTC mode for downlink transmission
    // Waveform generation mode #4, WGM1[3:0] = 0100b
    TCCR1A &= ~((1 << WGM11) | (1 << WGM10));
    TCCR1B &= ~(1 << WGM13);  // VERIFY TCCR1A
    TCCR1B |= (1 << WGM12);

    TIFR |= (1 << OCF1A);                 // Clear OCF1A flag
    // OC1A: Set on compare match
    TCCR1A |= ((1 << COM1A1) | (1 << COM1A0));
    TCCR1C |= (1 << FOC1A);               // Force compare match

    // OC1A to DIN: Toggle OC1A on compare match
    TCCR1A &= ~(1 << COM1A1);
    TCCR1A |= (1 << COM1A0);
  }

  // set SCLOCK = 1 to indicate data in direct mode
  Set_SCLOCK();

  // Transmit downlink signal
  if (ISO14443B_Downlink_Speed != ISO143B_BAUD_847)
  {
    Send_143B_Downlink();

    // OC1A to DIN: Normal pin now
    TCCR1A &= ~((1 << COM1A1) | (1 << COM1A0));
    PORTB |= (1 << PB5);
  }
  else
  {
    bpskBuf = (INT16U)data_ptr;          // Point to downlink data to be sent
    Send_143B_Downlink_847(data_len);
  }

  // Restore previous interrupt conditions
  InterruptMaskOperation(INT_MSK_OP_WRITE, Interrupt_Table);

  if (Abort_Module())
    ret_val = ERROR_HF_ASIC_ABORTED;

  // Receive BPSK signals
  // Baud Rate values: 0 - 106 kbps, 1 - 212kbps, 2 - 424kbps, 3 - 847 kbps

  // Kick watchdog
  Watchdog_Reset();

  // Extended_Frame_Wait_Time will have to be one of the arguments to BpskDecode()
  if (ret_val == ERROR_NONE)
  {
#ifdef ENABLE_SERIAL_ANALOG_CONFIG
    DRIVER_PORT |= (DRIVER1 | DRIVER2 | DRIVER3);
#endif

    HF_ASIC.rcvdBytes =
      BpskDecode(BPSK_UL_BAUD_106, fwi, wtxm, (uchar *)HF_ASIC.Buffer, (INT16U) HF_ASIC_BUF_SIZE);
    HF_ASIC.rcvdXtraBits = 0;

#ifdef ENABLE_SERIAL_ANALOG_CONFIG
    DRIVER_PORT ^= (DRIVER1 | DRIVER2 | DRIVER3);
#endif
  }
  

  // clear SCLOCK = 0 to indicate end of direct mode
  Clear_SCLOCK();

  if (HF_ASIC.BPSK_Error_Code == ERROR_NONE)
    return ERROR_NONE;
  else
    return (HF_ASIC.BPSK_Error_Code + ERROR_TRANSLATION_CONSTANT);
} // End of Handle_Direct_Mode()


/******************************************************************************
 * Function Name: Prep_Data_14443B()
 *
 * Description:
 *    This function will prepare the sequence of values to be loaded into the
 *  Timer 1A so that we can send data in direct mode to the HF ASIC interface
 *  to talk to ISO 14443B tokens. Timer 1A is set to Clear Timer on Compare (CTC)
 *  mode and the OC1A pin is toggled at each timer compare match. Knowing the
 *  ISO 14443-3B character and frame formats, the data can be broken down into
 *  a sequence of timed pin toggles.
 *    This function does not support data rates other than 106 kbps. It needs
 *  to support 212, 424 and 847 kbps. Timer1_ISR() would have to be modified to
 *  do the same too.
 *
 * Parameters:
 *    uchar   data_len  #bytes to be sent.
 *    uchar*  data_ptr  pointer to the data to be sent.
 *
 * Returns:
 *    uchar   Error code.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
unsigned char Prep_Data_14443B(unsigned char data_len,
                              unsigned char *data_ptr)
{
  unsigned char temp, indx;
  unsigned char Current_State = 0;
  unsigned int max_data_count;
  unsigned int data_count = 0;

  max_data_count = (unsigned int)data_len * 8;

  // Initialize T1A_Count array
  for (indx = 0; indx < T1A_COUNT_BUF_SIZE; indx++)
  {
    T1A_Count[indx] = 0;
  }

  T1A_indx = 0;
  // Start with a high to low transition
  T1A_Count[T1A_indx++] = 1 * (INT16U)Tic_Per_Bit;
  // Add SOF to the data stream
  T1A_Count[T1A_indx++] = 10 * (INT16U)Tic_Per_Bit;
  Current_State ^= 1;            // Toggle Current_State
  T1A_Count[T1A_indx++] = 2 * (INT16U)Tic_Per_Bit;

  // Add data bytes
  // Test each bit starting from the LSbit through MSbit.
  // For each bit same as the Current_State value add TIC_PER_BIT to
  // the current T1A_Count value.
  while (data_count < data_len)
  {
    // Add the start bit
    Current_State ^= 1;            // Toggle Current_State
    T1A_Count[T1A_indx] = 1 * (INT16U)Tic_Per_Bit;

    temp = data_ptr[data_count++];

    // bit_mask will be shifted left every loop. Once all bits are shifted
    // bit_mask value will be zero.
    for (indx = 0; indx < 8; indx++)
    {
      if (Current_State != (temp & 0x01))
      {
        Current_State ^= 1;            // Toggle Current_State
        T1A_indx++;
      }
      T1A_Count[T1A_indx] += 1 * (INT16U)Tic_Per_Bit;
      temp >>= 1;
    }

    if (Current_State == 0)
    {
      // Stop bit and EGT are high bits
      Current_State ^= 1;            // Toggle Current_State
      T1A_indx++;
    }
    T1A_Count[T1A_indx++] += 3 * (INT16U)Tic_Per_Bit; // Stop bit and EGT
  }

  // Add EOF to the data stream
  Current_State ^= 1;            // Toggle Current_State
  //T1A_indx++;
  T1A_Count[T1A_indx] = 10 * (INT16U)Tic_Per_Bit;

  // No modulation for (1 etu of low)
  Current_State ^= 1;            // Toggle Current_State
  T1A_indx++;
  T1A_Count[T1A_indx] = 1 * (INT16U)Tic_Per_Bit;
  Max_T1A_Value = T1A_indx;

  // Set timer counter value to zero and load the first delay into OCR1A.
  TCNT1 = 0;
  //T1A_indx = 0;                       // Commented for testing
  //OCR1A = T1A_Count[T1A_indx++];      // Commented for testing

  // Test code
  OCR1A = T1A_Count[0];
  T1A_ptr = &T1A_Count[1];
  // End test code
  return ERROR_NONE;
} // End of Prep_Data_14443B()

#endif // Matches "#ifdef HAVE_14443_B" located just above Handle_Direct_Mode() header

// Removed to eliminate warning because this function was neer called
#ifdef 0
/******************************************************************************
 * Function Name: Compute_Parity()
 *
 * Description:
 *    This function is used in Handle_Tag_Comm() function to compute odd parity
 *  for ISO14443A bit oriented packet.
 *
 * Parameters:
 *    uchar   x   byte to compute parity over.
 *
 * Returns:
 *    uchar   parity.
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
uchar Compute_Parity(uchar x)
{
  uchar indx, ret_val = 1;
  for (indx = 0; indx < 8; indx++)
  {
    if (x & 0x01)
      ret_val++;
    x >>= 1;
  }
  return ret_val & 0x01;
}
#endif

/******************************************************************************
 * Function Name: Initialize_HF_ASIC()
 *
 * Description:
 *    This function is used to start off the HF ASIC in a known mode. The HF ASIC
 *  does not have a built in "reset" mode so that the microcontroller can reset
 *  it. Sometimes the HF ASIC starts up with the DOUT pin held high and does
 *  not let it go. This code called in Initialize_Hardware() function will get
 *  the HF ASIC to turn the transmitter off and in the process send an "ES1"
 *  which resets (?) the input FIFO of the HF ASIC.
 *
 * Parameters:
 *    none
 *
 * Returns:
 *    none
 *
 * Revision History:
 *----------+----------+---------------+---------------------------------------
 *          | Version  |               |
 *   Date   | Modified |    Author     | Description
 *----------+----------+---------------+---------------------------------------
 *          |          |               |
 *----------+----------+---------------+---------------------------------------
 *****************************************************************************/
BOOLEAN Initialize_HF_ASIC(void)
{
  uchar asicArr[2];

  Make_SCLOCK_Output();
  
  HF_ASIC_Transmitter_Off();
  // Write Analog Test config - page 17
  // 0xF2 below is shown in HFASIC documents as 0100 1111 binary. Interpretation below:
  // 1 - Manchester decoder, 0 is enable, 1 is disable
  // 1 - baud rate, 0 is low, 1 is high
  // 1 - Modulation, 0 is FM, 1 is AM
  // 1 - Modulation index, 0 is 10%, 1 is 100%
  // 100 - ISO 14443 Mode A
  // 0 - Low power, 0 is Normal mode, 1 is Lpower mode
  asicArr[0] = 0x72;
  Handle_Write_Reg(0x7D, 8, asicArr);

  asicArr[0] = 0x83;                            // Prepare to restore default settings of LtcDelay and MSBs of TimingOffset
  asicArr[1] = 0x06;                            // Prepare to restore default settings of LSBs of TimingOffset
  Handle_Write_Reg(0x7B, 13, asicArr);          // Write timing settings to ASIC

  // Prepare to restore defaults of bypass switches
  // Write Analog Test config - page 18
  // 0x0000 below is shown in HFASIC documents as 0000 0000 0 binary. Interpretation below:
  // 0 - Second LP filter, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - Second HP filter, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - Second gain block, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - First LP filter, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - First HP filter, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - First gain block, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - Detector, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - All filters and gain blocks, 0 is Normal, 1 is Bypass if BypassUser = 1
  // 0 - BypassUser, 0 is Default config, 1 is User control
  asicArr[1] = asicArr[0] = 0;
  Handle_Write_Reg(0x77, 9, asicArr);

  asicArr[1] = asicArr[0] = 0;                  // Prepare to restore defaults of AM section
  Handle_Write_Reg(0x74, 11, asicArr);          // Disable any previous manual manipulation of time constants and thresholds

  HF_ASIC_Transmitter_On();
  HF_ASIC_Transmitter_Off();

  Handle_Read_Reg(READ_CONFIG_REGISTER, 8, asicArr);
  
  return ( (asicArr[0] == 0x72) ? TRUE : FALSE );
}
 
// Added the following conditional to allow the released library files to compile with no warnings
// For internal use the DEBUG_MODE can be added into the Project files globals and have the warnings appear
#ifndef DEBUG_MODE
  #pragma warn+       // Enable warnings
#endif