rfidradiomanager.cpp

UHF RFID Reader Program

					TRACE(_T("ERROR: Tag response failed CRC check\n"));
#endif
					strTemp.Format(_T("Tag response failed CRC check"));
					theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);
				}
				else
				{
#ifdef _DEBUG
					TRACE(_T("ERROR: MAC responded with error 0x%.8x\n"), MacToHost32(pTagAccess->data[0]));
#endif
					switch(pTagAccess->data[0])
					{
					case 0x01:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_01);
						}
						break;
					case 0x02:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_02);
						}
						break;
					case 0x03:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_03);
						}
						break;
					case 0x04:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_04);
						}
						break;
					case 0x05:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_05);
						}
						break;
					case 0x06:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_06);
						}
						break;
					case 0x07:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_07);
						}
						break;
					case 0x0A:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_0A);
						}
						break;

					case 0x0B:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_0B);
						}
						break;

					case 0x0C:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_0C);
						}
						break;

					case 0x0D:
						{
							strTemp.LoadString(IDS_STRING_TAGACCESS_ERROR_0D);
						}
						break;
					default:
						{
							strTemp.Format(TEXT("Undefined Error"));
						}
						break;
					}
					theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);
				}
			}
			else
			{
				/* If it is a read, then extract the data from the packet             */
				switch(pTagAccess->command)
				{
				case RFID_18K6C_TAG_ACCESS_READ:
					{
						/* Calculate the length of the data portion of the packet         */
						INT32U dataLength = 
							/* The length of the packet beyond the common header          */
							MacToHost16(pTagAccess->cmn.pkt_len) * BYTES_PER_LEN_UNIT   + 
							/* Add back in the size of the common header                  */
							sizeof(RFID_PACKET_COMMON)                                  -
							/* Minus the fixed part of the access packet                  */
							sizeof(RFID_PACKET_18K6C_TAG_ACCESS)                        + 
							/* Add back data field in the packet                          */
							sizeof(pTagAccess->data)                                    -
							/* Subtract out the padding bytes                             */
							RFID_18K6C_TAG_ACCESS_PADDING_BYTES(pTagAccess->cmn.flags);
#ifdef _DEBUG
						TRACE(_T("Tag Access : Read %s\n"), CUtil::Hex2Str((INT8U*)pTagAccess->data, dataLength));
#endif

							strTemp.Format(_T("Read Command Success"), CUtil::Hex2Str((INT8U*)pTagAccess->data, dataLength));
							theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);
							
							strTemp.Format(_T("Read Data : %s"), CUtil::Hex2Str((INT8U*)pTagAccess->data, dataLength));
							theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);
//							AfxMessageBox(strTemp);
						break;
					}
				case RFID_18K6C_TAG_ACCESS_WRITE:
					{
						strTemp.Format(TEXT("Write Command Success"));
						theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);

#ifdef _DEBUG
						TRACE(_T("Tag Access : Write\n"));
#endif

						break;
					}
				case RFID_18K6C_TAG_ACCESS_LOCK:
					{
						strTemp.Format(TEXT("Lock Command Success"));
						theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);						
#ifdef _DEBUG
						TRACE(_T("Tag Access : Lock\n"));
#endif
						break;
					}
				case RFID_18K6C_TAG_ACCESS_KILL:
					{
						strTemp.Format(TEXT("Kill Command Success"));
						theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);
#ifdef _DEBUG
						TRACE(_T("Tag Access : Kill\n"));
#endif
						break;
					}
				default:
					{
#ifdef _DEBUG
						TRACE(_T("Tag Access Success\n"));
#endif
						break;
					}
				}

				pParms->operationSucceeded = 1;
			}
//			pParms->operationSucceeded = 1;
			break;
		}
	case RFID_PACKET_TYPE_COMMAND_END:
		{
			RFID_PACKET_COMMAND_END *cmdend = (RFID_PACKET_COMMAND_END *)packet;
			TRACE(_T("Packet type: RFID_PACKET_COMMAND_END\n"));
			TRACE(_T("Operation ended at millisecond %u\n"), MacToHost32(cmdend->ms_ctr));


			CString temp;
			if(cmdend->status)
			{
				temp.Format(_T("Fail to Command End %u / %u sec"), MacToHost32(cmdend->status), MacToHost32(cmdend->ms_ctr));
			}
			else
			{
				temp.Format(_T("#%u Command End"), m_nCmdCount);
			}

			TRACE(_T("Operation status: (%s)\n"), temp);

			// increase inventory count
			m_nCmdCount++;

			break;
		}
	case RFID_PACKET_TYPE_ANTENNA_CYCLE_BEGIN:
		TRACE(_T("Packet type: RFID_PACKET_ANTENNA_CYCLE_BEGIN\n"));
		break;
	case RFID_PACKET_TYPE_ANTENNA_CYCLE_END:
		TRACE(_T("Packet type: RFID_PACKET_ANTENNA_CYCLE_END\n"));
		break;
	case RFID_PACKET_TYPE_ANTENNA_BEGIN:
		{
			RFID_PACKET_ANTENNA_BEGIN *antennabegin = (RFID_PACKET_ANTENNA_BEGIN *)packet;
			TRACE(_T("Packet type: RFID_PACKET_ANTENNA_BEGIN\n"));
			TRACE(_T("Antenna ID: %u\n"), MacToHost32(antennabegin->antenna));

			m_nAntenna = MacToHost32(antennabegin->antenna) + 1;

			break;
		}
	case RFID_PACKET_TYPE_ANTENNA_END:
		{
			TRACE(_T("Packet type: RFID_PACKET_ANTENNA_END\n"));
			break;
		}
	case RFID_PACKET_TYPE_CARRIER_INFO:
		{
			RFID_PACKET_CARRIER_INFO* carrier_info = 
				(RFID_PACKET_CARRIER_INFO *)packet;
			TRACE(_T("Packet type: RFID_PACKET_TYPE_CARRIER_INFO\n"));
			TRACE(_T("Channel ID: %u\n"), MacToHost16(carrier_info->chan));

			m_nChannel = MacToHost16(carrier_info->chan);

			break;
		}
	case RFID_PACKET_TYPE_INVENTORY_CYCLE_BEGIN:
		{
			TRACE(_T("Packet type: RFID_PACKET_INVENTORY_CYCLE_BEGIN\n"));
			break;
		}
	case RFID_PACKET_TYPE_INVENTORY_CYCLE_END:
		{
			TRACE(_T("Packet type: RFID_PACKET_INVENTORY_CYCLE_END\n"));
			break;
		}
	case RFID_PACKET_TYPE_18K6C_INVENTORY_ROUND_BEGIN:
		TRACE(_T("Packet type: RFID_PACKET_18K6C_INVENTORY_ROUND_BEGIN\n"));
		break;
	case RFID_PACKET_TYPE_18K6C_INVENTORY_ROUND_END:
		TRACE(_T("Packet type: RFID_PACKET_18K6C_INVENTORY_ROUND_END\n"));
		break;
	case RFID_PACKET_TYPE_18K6C_INVENTORY:
		{
			RFID_PACKET_18K6C_INVENTORY *inv = 
				(RFID_PACKET_18K6C_INVENTORY *)packet;
			/* Calculate the length of the data portion of the packet         */
			int length =
				/* The length of the packet beyond the common header          */
				(MacToHost16(common->pkt_len)-1) * BYTES_PER_LEN_UNIT -
				/* Add back in the size of the common header                  */
				(common->flags >> 6);

			if(common->flags & 0x01)
				break;

			int padding_byte = (int)(common->flags & 0xC0);

#ifdef _DEBUG
			TRACE(_T("Packet type: RFID_PACKET_18K6C_INVENTORY\n"));
			TRACE(_T("Packet CRC was %s\n"), common->flags & 0x01 ? _T("invalid") : _T("valid"));
			TRACE(_T("Tag was inventoried at millisecond %u\n"), MacToHost32(inv->ms_ctr));
			TRACE(_T("Inventory data length: %u"), length);
			TRACE(_T("Inventory data is: "));
			CUtil::Hex2Str((INT8U *)inv->inv_data, length);
			TRACE(_T("\n"));
			TRACE(_T("read count: %u\n"), inv->count);
			TRACE(_T("trial count: %u\n"), inv->trial_count);
#endif
// 			if(m_radioFilterMode == RFID_RADIO_FILTER_GABAGE)
// 			{
// 
//  				if((length != 28) && (length != 32) && (length != 48))
// 				{
// 					break;
// 				}
// 			}

			POSITION pos = m_listRadio.FindIndex(0);
			CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

			if(pRadio->m_runStatus != RFID_INVENTORY)
			{
				CString strTemp = TEXT("Tag ID : ");
				CTagInfo lpTagInfo;// = new CTagInfo();

				lpTagInfo.SetTagMemory(inv->inv_data);

				strTemp += lpTagInfo.GetTagString();

				theApp.m_pMainWnd->SendMessage(WM_TAG_ACCESS, (WPARAM)(LPCTSTR)strTemp, 0);

#ifdef _WIN32_WCE
				if(m_radioBeepMode == RFID_RADIO_BEEP_MODE_ENABLE)
					m_waveBox->Play(0);
#endif
				break;
			}

			// Tag Data Process
			CTagInfo* lpTagInfo = new CTagInfo();

			lpTagInfo->SetTagMemory(inv->inv_data);
			lpTagInfo->SetTagReadCount(inv->count);
			lpTagInfo->SetTagTrialCount(inv->trial_count);
			lpTagInfo->SetTagAntenna(m_nAntenna);
			lpTagInfo->SetTagChannel(m_nChannel);
			lpTagInfo->SetTagRSSI(MacToHost16(inv->rssi));
			lpTagInfo->SetTagLNAGain(MacToHost16(inv->ana_ctrl1));
			lpTagInfo->SetTagReveiveTime(COleDateTime::GetCurrentTime());

#ifdef _WIN32_WCE
			if(m_radioBeepMode == RFID_RADIO_BEEP_MODE_ENABLE)
				m_waveBox->Play(0);
#endif

			m_pParent->SendMessage(WM_PROCESS_TAG, (WPARAM)lpTagInfo);

			break;

		}

	case RFID_PACKET_TYPE_TEMPERATURE_INFO:
		{
#ifdef _DEBUG
			TRACE(_T("Packet type: RFID_PACKET_TYPE_TEMPERATURE\n"));
#endif
			RFID_PACKET_TEMPERATURE_INFO* temp = (RFID_PACKET_TEMPERATURE_INFO*)packet;
			CString temperature, strDate;
			COleDateTime currentTime = COleDateTime::GetCurrentTime();

#ifdef _DEBUG
			TRACE(_T("Temperature status: (%u)\n"), temp->temperature);
#endif


			// calculate time stamp
			COleDateTimeSpan span = currentTime- m_oleStartDateTime;//COleDateTimeSpan(newTime.wDay, newTime.wHour, newTime.wMinute, newTime.wSecond);

#ifdef _WIN32_WCE
			temperature.Format(_T("(%u) "), temp->temperature);

			strDate.Format(TEXT("%s (%d)"),
				(LPCTSTR)span.Format(TEXT("%H:%M:%S")), span.GetDays());

			temperature += strDate;
#else
			temperature.Format(_T("Temperature status: (%u)\t"), temp->temperature);

			strDate.Format(TEXT("%s and %d days"),
				(LPCTSTR)span.Format(TEXT("%H:%M:%S")), span.GetDays());

			temperature += strDate;
#endif
			file.Write(temperature.GetBuffer(1024), temperature.GetLength() * sizeof(WCHAR));  // Excel 颇老 静扁 
			file.Flush();

			m_pParent->SendMessage(WM_STATUS_MSG,(WPARAM)(LPCTSTR)temperature);

			break;
		}

	default:
		TRACE(_T("Packet type %u not handled yet\n"), packetType);
		break;
	}
}

RFID_STATUS CRFIDRadioManager::GetRadioOperationMode(int nModule, RFID_RADIO_OPERATION_MODE* mode)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->GetRadioOperationMode(mode)))
			{
				TRACE1("RadioCancelOperation failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::SetRadioOperationMode(int nModule, RFID_RADIO_OPERATION_MODE mode)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->SetRadioOperationMode(mode)))
			{
				TRACE1("RadioCancelOperation failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::GetRadioResponseDataMode(int nModule, RFID_RESPONSE_MODE* mode)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->GetRadioResponseDataMode(mode)))
			{
				TRACE1("GetRadioResponseDataMode failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::SetRadioResponseDataMode(int nModule, RFID_RESPONSE_MODE mode)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->SetRadioResponseDataMode(mode)))
			{
				TRACE1("SetRadioResponseDataMode failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}


RFID_STATUS CRFIDRadioManager::GetRadioMacRegion(int nModule, RFID_MAC_REGION* region)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->GetMacRegion(region)))
			{
				TRACE1("GetMacRegion failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::SetRadioMacRegion(int nModule, RFID_MAC_REGION region)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->SetMacRegion(region)))
			{
				TRACE1("SetMacRegion failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

int	CRFIDRadioManager::GetRadioAntennaCount(int nModule)
{
//	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			return pRadio->GetAntennaCount();
	}

	return 0;	
}

RFID_STATUS CRFIDRadioManager::GetRadioAntennaPortStatus(int nModule, int antennaNumber, RFID_ANTENNA_PORT_STATUS* antennaStatus)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->GetAntennaPortStatus(antennaNumber, antennaStatus)))
			{
				TRACE1("GetAntennaPortStatus failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::SetRadioAntennaPortState(int nModule, int antennaNumber, RFID_ANTENNA_PORT_STATE antennaState)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->SetAntennaPortState(antennaNumber, antennaState)))
			{
				TRACE1("SetAntennaPortState failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::GetRadioAntennaPortConfiguration(int nModule, int antennaNumber, RFID_ANTENNA_PORT_CONFIG* antennaConf)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->GetAntennaPortConfiguration(antennaNumber, antennaConf)))
			{
				TRACE1("GetAntennaPortConfiguration failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS CRFIDRadioManager::SetRadioAntennaPortConfiguration(int nModule, int antennaNumber, RFID_ANTENNA_PORT_CONFIG antennaConf)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);
		CRFIDRadio* pRadio = (CRFIDRadio*)m_listRadio.GetAt(pos);

		if( pRadio != NULL )
			if(RFID_STATUS_OK != 
				(status = pRadio->SetAntennaPortConfiguration(antennaNumber, antennaConf)))
			{
				TRACE1("SetAntennaPortConfiguration failed:  RC = %d\n", status);
				return status;
			}
	}

	return status;	
}

RFID_STATUS	CRFIDRadioManager::GetRadioTransferTime(int nModule, INT32U* transferTime)
{
	RFID_STATUS status = RFID_STATUS_OK;

	if( m_pRadioEnum != NULL && m_pRadioEnum->countRadios != 0)
	{
		POSITION pos = m_listRadio.FindIndex(nModule);