msr.c

非接触式M1卡读写器,读写源程序,可读S50/S70的卡

*                                                                           *
*  timer0 is use to get delay or try to successful connect                  *
*                                                                           *
*                                                                           *
****************************************************************************/

void isr_timer0(void) interrupt 1 using 2
{
  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) ////// MAXREPCNT=2
	  {
		RepCnt++;
		CALL_isr_UART();	 ///TI = 1
	  }
	  else
	  {
		RepCnt = 0;
		Quit = FALSE;
		SendReady = TRUE;
	  }
	}
#ifdef MMM
	LED(GELB, ON);
#endif
  }
}


/****************************************************************************
*                                                                           *
* Function:     isr_ext_intr1                                               *
*                                                                           *
* Input:        -                                                           *
* Output:       -                                                           *
*                                                                           *
*                                                                           *
****************************************************************************/

void isr_ext_intr1(void) interrupt 2
{
  PCON  |= 0x02;                // Power down
}


/****************************************************************************
*                                                                           *
* Function:     isr_UART                                                    *
*                                                                           *
* Input:        -                                                           *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void isr_UART(void) interrupt 4 using 1
{
	uchar c, i, j, len, cmd;
	uchar oldRecvState, chk;
	
	TOGGLE_WD();
	
	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;
					
						#ifdef MMM
							LED(GELB, OFF);
						#endif
				
						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  /////if (LLfReady)
		  			{
						CmdReceived = TRUE;
					}
				}
				else ////if (c == STX)
				{
		  			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];
				  					}
				  				}//BCC CHECK
				  				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(GRUEN, OFF);
									
									while (!TI);
									TI = Quit;
									break;
								}
							}
						}// CMD RIGHT OR ERROR
						SBUF = NAK;
						Quit = FALSE;
						while (!TI);
						TI = FALSE;
						break;
					}//if(DataDleReceived)
				}//if(c==ETX)
				
				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){
					#ifdef MMM
						LED(GELB, OFF);
					#endif
					
					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(GRUEN, 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;
		//RS485_DE = ON;
		LLfReady = TRUE;
		if (!CmdReceived)           // Send Response
		{
			if (Quit){
				if (QuitStatus != OK){
					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)
}


/****************************************************************************
*                                                                           *
* Function:     putchar                                                     *
*                                                                           *
* Input:        c                                                           *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void putchar(uchar c)
{
  SBUF = c;

  do
  {
	TOGGLE_WD();
  } while (!TI);

  TI = FALSE;
}


/***************************************************************************/