fk4428.c

2106卡的程序

/********2000.9.22******************/
#include <reg52.h>
#include <intrins.h>
#include <string.h>
#include "fk.h"

#define  TOGGLE_WD()       _nop_()
#define  RdVCC    (bUseSAM? PVCC:ICVCC)
#define  VCC(x);  bUseSAM?(PVCC=(x)):(ICVCC=(x));

#define  RdIO     (bUseSAM? PIO:ICIO)
#define  IO(x);   bUseSAM?(PIO=(x)):(ICIO=(x));

#define  RST(x);  bUseSAM?(PRST=(x)):(ICRST=(x));

volatile BYTE  ptr;
volatile BYTE  RPtr;

#define BaudVal  -95
#define StrtVal  -27

volatile BYTE XmtDat;  //Send Data
volatile BYTE RcvDat;  //Receive Data
volatile BYTE BitCnt;  //Rcv/Send Count
volatile BYTE Flags;   //flag
volatile bit  TxFlag;  
volatile bit  RxFlag;
volatile bit  RxErr;
volatile bit  RcvRdy;
volatile bit  Parity;
volatile bit  CPUState;
volatile bit  bUseSAM;

// Global Variables
volatile bit             DataDleReceived;
volatile bit             CmdValid;

volatile BYTE  idata SerBuffer[SERBUFLEN];

volatile BYTE   data    RecvState;
volatile BYTE   data    Index;
volatile BYTE   data    Timer0Cnt;

// Local Variables
static BYTE __Mode     =0xD6; //Old MMM200 is 0xC6,New MMM200 is 0xD6
static BYTE __Divider  =0x0E;
static BYTE mif_control=0x0C;

//Global Prototypes
BYTE Check_ICSW();
void cmd_execution(void);
/****************************************************************************
* Function:     isr_ext0                                                    *
****************************************************************************/
void isr_ex0(void) interrupt 0
{
}
/****************************************************************************
* Function:     isr_timer0                                                  *
****************************************************************************/
void isr_timer0(void) interrupt 1
{
  TOGGLE_WD();
  if (Timer0Cnt)
  {
    --Timer0Cnt;
  }else{
    STOP_T0();
    RecvState=RECV_STX;
  }
}
/****************************************************************************
* Function:     isr_ext1                                                    *
****************************************************************************/
void isr_ext1(void) interrupt 2
{
}
/****************************************************************************
* Function:     isr_timer1                                                  *
****************************************************************************/
void isr_timer1(void) interrupt 3
{
  BitCnt--;
  if(RxFlag)		//RxBit
  {
    if(BitCnt==0)
    {
      if(!RdIO)
        RxErr=1;        //not valid stopbit
      IO(1);  
      RxFlag=0;
      RcvRdy=1;         //Receive finish
      TR1=FALSE;        //Close TR1
    }else if(BitCnt==1)
    {
      ACC=RcvDat;
      if(_testbit_(P)!=RdIO)  //not valid Parity bit
      { 
        IO(0);
        RxErr=1;
      }
    }else if(BitCnt==10)
    {
      if(RdIO)
        RxErr=1;      //not valid startbit
    }else{
      RcvDat=RcvDat>>1;
      if(RdIO)
        RcvDat=RcvDat|0x80;
    }
  }
  if(TxFlag)        //TxBit
  {
    if(BitCnt==0)
    {
      TxFlag=0;     //Send finish
      TR1=FALSE;
    }else if(BitCnt==1)
    {
      IO(1);       //Stopbit
    }else if(BitCnt==2)
    {
      bUseSAM?(PIO=Parity):(ICIO=Parity);      
      IO(Parity);
    }else{
      XmtDat=XmtDat>>1;
      IO(CY);
    }
  }
}
/****************************************************************************
* Function:     isr_UART                                                    *
****************************************************************************/
void isr_UART(void) interrupt 4
{
  BYTE c,j,i,len,chk;

  TOGGLE_WD();

  START_T0(T_500_ms*2*30);  //30s
  if (RI)
  {
    c  = SBUF;
    RI = FALSE;
    switch (RecvState)
    {                           // Receive Command
      case RECV_STX:
        if (c == STX)
        {
          SBUF = DLE;
          Index = 0;
          DataDleReceived = 0;
          RecvState = RECV_DATA_DLE_ETX;
          while (!TI);
          TI = FALSE;
          START_T0(T_500_ms);
        }else{
          CALL_isr_T0();
          RecvState = RECV_STX;
        }
        break;
      case RECV_DATA_DLE_ETX:
        if (c == DLE)
        {
          if (!DataDleReceived)
          {
            DataDleReceived = TRUE;
            RecvState = RECV_DATA_DLE_ETX;
            START_T0(T_500_ms);
            break;
          }else{
            DataDleReceived = FALSE;
          }
        }else if (c == ETX)
        {
          if (DataDleReceived)
          {
            DataDleReceived = FALSE;
            len = SerBuffer[LENGTH];
            chk = 0;
            for (i = 0; i < Index; i++)
              chk ^= SerBuffer[i];
            if (chk == 0)
            { 
              STOP_T0();
              NOP20(); 
              SBUF = DLE;
              while (!TI);
              TI = FALSE;
              CmdValid = 0xa5;
              break;
            }else
            {
             NOP20();
              SBUF = NAK;
              while (!TI);
              TI = FALSE;
              RecvState = RECV_STX;
              break;
            }
          } //end DATADLERECEIVED
        }   //END ETX
        if (Index < SERBUFLEN)
          SerBuffer[Index++] = c;
        RecvState = RECV_DATA_DLE_ETX;
        START_T0(T_500_ms);
        break;
                            // Handshake for sending Response
      case RECV_DLE:
        if (c == DLE)
        {
          NOP20();
          for (j = 0; j < (HEADER + SerBuffer[LENGTH] + 1); j++)
          {
            SBUF = SerBuffer[j];
            while (!TI);
            TI = FALSE;
            if (SerBuffer[j] == DLE)
            {
              NOP20(); 
              SBUF = DLE;
              while (!TI);
              TI = FALSE;
            }
          }
          NOP20();
          SBUF = DLE;
          while (!TI);
          TI = FALSE;
           NOP20();
          SBUF = ETX;
          while (!TI);
          TI = FALSE;
          RecvState = RECV_DLE_OR_NAK;
   
           START_T0(T_500_ms);
        }else{
          CALL_isr_T0();
          RecvState = RECV_STX;          
        }
        break;
      case RECV_DLE_OR_NAK:
        RecvState = RECV_STX;      
        if (c == DLE)
        {
        }else{
          CALL_isr_T0();
        }
        break;
      default:
        CALL_isr_T0();
        RecvState = RECV_STX;        
        break;
    }
  } // end if (RI)

  if (TI && !RI)
  {
      TI = FALSE;
      len = HEADER + SerBuffer[LENGTH];
      len = 3+ SerBuffer[LENGTH];
      SerBuffer[0]=0;      
      chk = 0;
      for (i = 0; i < len; i++)
      chk ^= SerBuffer[i];
      SerBuffer[len] =chk;
      NOP20();
      SBUF = STX;
      while (!TI);
      TI = FALSE;
      START_T0(T_500_ms);      
      RecvState = RECV_DLE;
    }                        // Handshake for receiving Command
}
/****************************************************************************
* Function:     isr_timer2                                                  *
****************************************************************************/
void isr_timer2(void) interrupt 5
{
}
void delay_8us_NOP(void)
{
  _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
}
void delay_15us_NOP(void)
{
  _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
}
void delay_50us(BYTE _50us)
{
  register BYTE i;

  for(i=0;i<_50us;i++)
  {
    _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();
    _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();
    _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();
    _nop_();_nop_();  _nop_();_nop_();  _nop_();_nop_();  _nop_();
  } 
}      
void delay_10ms(WORD _10ms)
{
  register WORD i;

  for(i=0;i<_10ms;i++)
  {
    delay_50us(255); //50*200=10,000
    _nop_();_nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();_nop_(); 
    _nop_();_nop_();_nop_();_nop_();_nop_();
    _nop_();_nop_();_nop_();_nop_();_nop_();    
    _nop_();_nop_();_nop_();_nop_();_nop_();        
    _nop_();_nop_();_nop_();_nop_();_nop_();
  }
}

/****************************************************************************
* Function:     mifs_request                                                *
****************************************************************************/
BYTE mifs_request(BYTE _Mode, BYTE idata *_TagType)
{
  BYTE _Status;
  BYTE _RetCode;

  TOGGLE_WD();
  
  MCM_STACON   = _SOR | mif_control;
  MCM_BAUDRATE = __Divider;
  MCM_ENABLE   = _PEN | _PRE;
  MCM_MODE     = __Mode;
  MCM_STACON   = mif_control;
  MCM_RCODE    = 3;
  MCM_BCNTS    = 7;
  MCM_BCNTR    = 16;

  if (_Mode & ALL)
  {
    MCM_DATA = _REQUEST_ALL;
  }else{
    MCM_DATA = _REQUEST;
  }

  MCM_TOC =10 ;//TIMEOUT;
  while (!((_Status = MCM_STACON) & _DV)) TOGGLE_WD();
  MCM_TOC = 0;

  if (_Status & (_TE | _BE))
  {
    _TagType[0] = 0;
    _TagType[1] = 0;

    if (_Status & _TE)
    {
      _RetCode = W_NOTAG;
    }else{
      _RetCode = W_BITCNT;
      delay_50us(10);
    }
  }else{
    _TagType[0] = MCM_DATA;
    _TagType[1] = MCM_DATA;
    _RetCode    = OK;
  }
  return (_RetCode);
}
/****************************************************************************
* Function:     mifs_anticoll                                               *
****************************************************************************/
BYTE mifs_anticoll(BYTE _Bcnt, BYTE idata *_SNR)
{
  BYTE i;
  BYTE _SnrChk, _SnrChkTmp;
  BYTE _Status;
  BYTE _Retcode;

  TOGGLE_WD();

  MCM_BCNTS   = _Bcnt + 16;
  MCM_STACON  = _AC | mif_control;

  delay_50us(1);                        // Bug Delay: min. 35 鎠

  MCM_DATA    = 0x93;
  MCM_DATA    = ((2 + (_Bcnt >> 3)) << 4) | (_Bcnt & 0x07);

  for (i = SERNR_in - SERNR; i < ((_Bcnt + 7)/8 + SERNR_in - SERNR); i++)
  {
	MCM_DATA = _SNR[i];
  }

  MCM_TOC = 10;//TIMEOUT;
  while (!((_Status = MCM_STACON) & _DV)) TOGGLE_WD();
  MCM_TOC = 0;

  if (_Status & _TE)
  {
	_Retcode = W_NOTAG;
  }
  else
  {
	if (_Status & _BE)
	{
	  _Retcode = W_BITCNT;
	  delay_50us(10);
	}
	else
	{
	  for (i = 0, _SnrChkTmp = 0; i < 4; i++)
	  {
		_SNR[i] = MCM_DATA;
		_SnrChkTmp ^= _SNR[i];
	  }

	  _SnrChk = MCM_DATA;

	  if (_SnrChk != _SnrChkTmp)
	  {
		_Retcode = W_SERNR;
	  }
      else
      {
	_Retcode = OK;
      }
    }
  }

  return (_Retcode);
}
/****************************************************************************
* Function:     mifs_select                                                 *
****************************************************************************/
BYTE mifs_select(BYTE idata *_SNR, BYTE idata *_Size)
{
  BYTE _Status;
  BYTE _Retcode;

  TOGGLE_WD();

  MCM_ENABLE = _PEN | _CEN | _CRE | _PRE;
  MCM_BCNTS  = 56;
  MCM_BCNTR  = 8;
  MCM_DATA   = 0x93;
  MCM_DATA   = 0x70;

  MCM_DATA = _SNR[0];
  MCM_DATA = _SNR[1];
  MCM_DATA = _SNR[2];
  MCM_DATA = _SNR[3];

  MCM_DATA = _SNR[0] ^ _SNR[1] ^ _SNR[2] ^ _SNR[3];

  MCM_TOC = 10;//TIMEOUT;
  while (!((_Status = MCM_STACON) & _DV))TOGGLE_WD();
  MCM_TOC = 0;

  if (_Status & _TE)
  {
    _Retcode = W_NOTAG;
  }
  else
  {
    if (_Status & (_PE | _BE | _CE))
	{
	  if (_Status & _BE)
      {
	_Retcode = W_BITCNT;
	delay_50us(10);
	  }
      else
      {
	if (_Status & _PE)
		{
	  _Retcode = W_PARITY;
	}
	else
		{
	  _Retcode = W_CRC;
	}
      }
    }
    else
    {
	  *_Size   = MCM_DATA;
	  _Retcode = OK;
    }
  }

  return (_Retcode);
}
/****************************************************************************
* Function:     mifs_authentication                                         *
****************************************************************************/
BYTE mifs_authentication(BYTE _Mode, BYTE _SecNr)
{
  BYTE _Fkt;
  BYTE _Status;
  BYTE _Retcode;

  TOGGLE_WD();

  if (_Mode & KEYB)
  {
	_Fkt = 0x61;
	_SecNr |= _KEYB;
  }
  else
  {
	_Fkt = 0x60;
	_SecNr |= _KEYA;
  }

  MCM_TOC       = 10;//TIMEOUT;
  MCM_BCNTS     = 16;
  MCM_KEYSTACON = _AUTH | (_Mode & 0x03);
  MCM_KEYADR    = _AUTH | _SecNr;
  MCM_DATA      = _Fkt;
  MCM_DATA      = _SecNr << 2;

  while (!((_Status = MCM_STACON) & _DV))TOGGLE_WD();
  MCM_TOC = 0;

  if (_Status & (_TE | _AE | _PE | _BE))
  {
    if (_Status & _TE)
    {
      _Retcode = W_NOTAG;
    }
    else
    {
      if (_Status & _AE)
      {
		_Retcode = W_AUTH;
      }
      else
      {
	if (_Status & _PE)
	{
		  _Retcode = W_PARITY;
	}
		else
	{
	  delay_50us(10);
	  if ((MCM_DATA & 0x0A) == 0x00)
	  {
	    _Retcode = W_AUTH;
		  }
	  else
		  {
	    _Retcode = W_BITCNT;
		  }
	}
      }
    }