main.c

RFID 函数接口的部分设计

	  if (Timer0Cnt)
	  {
		--Timer0Cnt;
	  }
	  else
	  {
		STOP_T0();
	
	#ifdef AUTODELAY
		if (DelayRate < MAXDELAYRATE && CmdCnt > 0)
		{
		  DelayRate++;
		  DelayRateLocked = FALSE;
		}
	#endif
	
		RecvState = RECV_STX;
	
		if (!SendReady && LLfReady)
		{
		  if (RepCnt < MAXREPCNT)
		  {
			RepCnt++;
			CALL_isr_UART();
		  }
		  else
		  {
			RepCnt = 0;
			Quit = FALSE;
			SendReady = TRUE;
		  }
		}
	  }
	}
	
	
	/****************************************************************************
	*                                                                           *
	* Function:     isr_UART                                                    *
	*                                                                           *
	* Input:        -                                                           *
	* Output:       -                                                           *
	*                                                                           *
	* Description:                                                              *
	*                                                                           *
	* Diese Interrupt-Funktion wird vom UART aufgerufen und bearbeitet das      *
	* serielle Protokoll.                                                       *
	*                                                                           *
	****************************************************************************/
	
	void 	isr_UART (void) interrupt 4 using 1
	{
	  uchar c, i, j, len, cmd;
	  uchar oldRecvState, chk;
	
	  if (RI)
	  {
		STOP_T0();
	
		c  = SBUF;
	
		RI = FALSE;
	
		oldRecvState = RecvState;
		RecvState = RECV_STX;
	
		switch (oldRecvState)
		{                           // Receive Command
	
		  case RECV_STX:
			if (c == STX)
			{
			  if (LLfReady)
			  {
				SBUF = DLE;
				LED = OFF;
				Index = 0;
				DataDleReceived = FALSE;
				RecvState = RECV_DATA_DLE_ETX;
	
				while (!TI);
				TI = FALSE;
	
				if (RI)
				{
				  RI = FALSE;
				  if (SBUF == NAK)
				  {
					CALL_isr_T0();
					break;
				  }
				}
				START_T0(T_533_ms);
			  }
			  else
			  {
				CmdReceived = TRUE;
			  }
			}
			else
			{
			  CALL_isr_T0();
			}
			break;
	
		  case RECV_DATA_DLE_ETX:
			if (c == DLE)
			{
			  if (!DataDleReceived)
			  {
				DataDleReceived = TRUE;
				RecvState = RECV_DATA_DLE_ETX;
				START_T0(T_533_ms);
				break;
			  }
			  else
			  {
				DataDleReceived = FALSE;
			  }
			}
			else if (c == ETX)
			{
			  if (DataDleReceived)
			  {
				DataDleReceived = FALSE;
				cmd = SerBuffer[COMMAND];
				len = SerBuffer[LENGTH];
	
				if (cmd >= MINCMDNR && cmd <= MAXCMDNR &&
					len <= MAXDATA && Index == (HEADER + CheckByteCnt + len))
				{
				  if (len == CmdLenTab[cmd - MINCMDNR] ||
					  cmd == 0x4C && len == 18 		   ||
					  cmd == 0x4F && len == 1)
				  {
					if (CheckByteCnt == BCC_CHECKBYTECNT)
					{
					  chk = 0;
	
					  for (i = 0; i < Index; i++)
					  {
						chk ^= SerBuffer[i];
					  }
					}
					else // CRC16
					{
					  Crc = CRC_PRESET;
	
					  for (i = 0; i < Index; i++)
					  {
						Crc = Crc ^((uint)SerBuffer[i] << 8);
	
						for (j = 0; j < 8; j++)
						{
						  if (Crc & 0x8000)
						  {
							Crc = (Crc << 1) ^ CRC_POLYNOM;
						  }
						  else
						  {
							Crc = (Crc << 1);
						  }
						}
					  }
					  chk = (uchar)Crc | (Crc >> 8);
					}
					if (chk == 0)
					{
					  SBUF = DLE;
	
					  SendReady = FALSE;
					  LLfReady = FALSE;
					  CmdValid = !Quit;
					  if (CmdValid)
					  {
						SeqNr = SerBuffer[SEQNR];
	#ifdef AUTODELAY
	
						if (CmdCnt < AUTODELAY_FALLBACK)
						{
						  CmdCnt++;
						}
						else
						{
						  CmdCnt = 0;
						  if (!DelayRateLocked && DelayRate > 0)
						  {
							DelayRateLocked = TRUE;
							DelayRate--;
						  }
						}
	#endif
					  }
					  LED = OFF;
	
					  while (!TI);
					  TI = Quit;
	
					  break;
					}
				  }
				}
				SBUF = NAK;
	
				Quit = FALSE;
				while (!TI);
				TI = FALSE;
	
				break;
			  }
			}
	
			if (Index < SERBUFLEN)
			{
			  SerBuffer[Index++] = c;
			}
			RecvState = RECV_DATA_DLE_ETX;
			START_T0(T_533_ms);
			break;
	
									// Handshake for sending Response
		  case RECV_DLE:
			if (c == DLE)
			{
			  LED = OFF;
			  for (c = 0; c < (HEADER + SerBuffer[LENGTH] + CheckByteCnt); c++)
			  {
				SBUF = SerBuffer[c];
	
				while (!TI);
				TI = FALSE;
	
				if (RI)
				{
				  break;
				}
	
	#ifdef AUTODELAY
				for (i = 0; i < DelayRate; i++)
				{
				  delay_8us_NOP();
				}
	#endif
				if (SerBuffer[c] == DLE)
				{
				  SBUF = DLE;
	
				  while (!TI);
				  TI = FALSE;
				}
			  }
			  if (RI)
			  {
				RI = FALSE;
				if (SBUF == NAK)
				{
				  CALL_isr_T0();
				  break;
				}
			  }
	
	#ifdef AUTODELAY
			  for (i = 0; i < DelayRate; i++)
			  {
				delay_8us_NOP();
			  }
	#endif
			  SBUF = DLE;
	
			  while (!TI);
			  TI = FALSE;
	
			  if (RI)
			  {
				RI = FALSE;
				if (SBUF == NAK)
				{
				  CALL_isr_T0();
				  break;
				}
			  }
	
	#ifdef AUTODELAY
			  for (i = 0; i < DelayRate; i++)
			  {
				delay_8us_NOP();
			  }
	#endif
			  SBUF = ETX;
	
			  while (!TI);
			  TI = FALSE;
	
			  RecvState = RECV_DLE_OR_NAK;
	
			  START_T0(T_533_ms);
			}
			else if (c == STX)
			{
			  CmdReceived = TRUE;
			  CmdValid = FALSE;
			  CALL_isr_UART();
			}
			else
			{
			  CALL_isr_T0();
			}
			break;
	
		  case RECV_DLE_OR_NAK:
			if (c == DLE)
			{
			  RepCnt = 0;
			  Quit = FALSE;
			  SendReady = TRUE;
	
			  LED = ON;
			}
			else if (c == STX)
			{
			  CmdReceived = TRUE;
			  CmdValid = FALSE;
			  CALL_isr_UART();
			}
			else
			{
			  CALL_isr_T0();
			}
			break;
	
		  default:
			CALL_isr_T0();
			break;
	
		}
	  } // end if (RI)
	
	
	  if (TI && !RI)
	  {
		TI = FALSE;
	
	       	LLfReady = TRUE;
	
		if (!CmdReceived)        	// Send Response
		{
		  if (Quit)
		  {
			if (QuitStatus)
			{
			  SerBuffer[SEQNR] = SeqNr;
			}
			SerBuffer[STATUS] = QUIT;
			SerBuffer[LENGTH] = 0;
		  }
	
		  len = HEADER + SerBuffer[LENGTH];
	
		  if (CheckByteCnt == BCC_CHECKBYTECNT)
		  {
			chk = 0;
	
			for (i = 0; i < len; i++)
			{
			  chk ^= SerBuffer[i];
			}
	
			SerBuffer[len] = chk;
		  }
		  else // CRC16
		  {
			Crc = CRC_PRESET;
	
			for (i = 0; i < len; i++)
			{
			  Crc = Crc ^((uint)SerBuffer[i] << 8);
	
			  for (j = 0; j < 8; j++)
			  {
				if (Crc & 0x8000)
				{
				  Crc = (Crc << 1) ^ CRC_POLYNOM;
				}
				else
				{
				  Crc = (Crc << 1);
				}
			  }
			}
			SerBuffer[len]     = (uchar)(Crc >> 8);
			SerBuffer[len + 1] = (uchar) Crc;
		  }
	
		  SBUF = STX;
	
		  RecvState = RECV_DLE;
		}
		else                        // Handshake for receiving Command
		{
		  SBUF = DLE;
	
		  CmdReceived = FALSE;
		  Quit = TRUE;
		  QuitStatus = SerBuffer[STATUS];
		  Index = 0;
		  DataDleReceived = FALSE;
		  RecvState = RECV_DATA_DLE_ETX;
		}
		while (!TI);
		TI = FALSE;
	
		START_T0(T_533_ms);
	
	  } // end if (TI)
	}
	
	
	/***************************************************************************/