mainfrm.cpp

RFID温度签的源码

		{
			
			CHistoryDlg dlg;
			dlg.SetWarnTemp( m_LimitHigh, m_LimitLow );
			dlg.SetHistoryData( m_pTemperatureData, m_TemperatureCount +1 );
			dlg.SetRelationData( m_LowTemperature, m_HighTemperature, m_SumTemperature );
			dlg.SetTime( m_StartTime, m_TimeInterval );
			dlg.DoModal();
		}
		else
		{
			UINT nID = theApp.m_Lang == 0 ? IDS_STR_READ_HDATA_FAILED_CH : IDS_STR_READ_HDATA_FAILED;
			CString str;
			str.LoadString( nID );
			MessageBox( str );
		}
	}
	catch (CException* e)
	{
		e->ReportError();
	}
}

void CMainFrame::OnFigView()
{
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	if( pView )
	{
		U32 CardID = pView->GetSelectCardID();
		if( CardID <= 0 )
		{
			DWORD dwResID = IDS_STR_ASK_SELECT_CARD;
			if( theApp.m_Lang == 0 )
			{
				dwResID = IDS_STR_ASK_SELECT_CARD_CH;
			}

			CString str;
			str.LoadString( dwResID );
			MessageBox( str );
			return;
		}

		if( GetCardHistoryData( CardID ) )
		{
			if( pView )
			{
				pView->SetHistoryData( m_pTemperatureData, m_TemperatureCount );
				pView->m_FormStatic.SetStartTime( m_StartTime );
				pView->m_FormStatic.SetDisplayMode( 0 );
				pView->ActivePage( 0 );
			}
		}
		else
		{
			UINT nID = theApp.m_Lang == 0 ? IDS_STR_READ_HDATA_FAILED_CH : IDS_STR_READ_HDATA_FAILED;
			CString str;
			str.LoadString( nID );
			MessageBox( str );
		}
	}
}


void CMainFrame::OnStat()
{
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	U32 CardID = 0;
	if( pView )
	{
		CardID = pView->GetSelectCardID();
	}

	if( CardID != 0 )
	{
		char *pStr = NULL;
		TCHAR ch[128];

		CDlgStat dlg;
		dlg.m_str1.Format( _T("%d"), CardID );

		theApp.GetCardProductName( CardID, &pStr );
		//MultiByteToWideChar( CP_ACP, 0, pStr, strlen(pStr), ch, 128 ); 
		if( pStr )
		{
			strcpy( ch, pStr );
			dlg.m_str2.Format( _T("%s"), ch );
		}

		theApp.GetCardManufactureName( CardID, &pStr );
		//MultiByteToWideChar( CP_ACP, 0, pStr, strlen(pStr), ch, 128 );
		if( pStr )
		{
			strcpy( ch, pStr );
			dlg.m_str3.Format( _T("%s"), ch );
		}

		theApp.GetCardGroup( CardID, &pStr );
		//MultiByteToWideChar( CP_ACP, 0, pStr, strlen(pStr), ch, 128 );
		if( pStr )
		{
			strcpy( ch, pStr );
			dlg.m_str3.Format( _T("%s"), ch );
		}
		
		dlg.m_str4.Format( _T("%.2f"), m_HighTemperature);
		dlg.m_str5.Format( _T("%.2f"), m_LowTemperature );
		dlg.m_str6.Format( _T("%.2f"), m_SumTemperature / m_TemperatureCount );
		dlg.DoModal();
	}
	else
	{
		DWORD dwResID = IDS_STR_ASK_SELECT_CARD;
		if( theApp.m_Lang == 0 )
		{
			dwResID = IDS_STR_ASK_SELECT_CARD_CH;
		}

		CString str;
		str.LoadString( dwResID );
		MessageBox( str );
	}

}

void CMainFrame::OnUpdateDeviceMenu(CCmdUI *pCmdUI)
{
	pCmdUI->Enable( theApp.GetDevice()->IsOpen() );
}

typedef struct tagSetLEDFunction
{
	int nItem;
	CTemperatureView* pView;
	void* pOwner;
}SET_LED_FUNCTION;


UINT SetLEDFunction( void* Param )
{
	SET_LED_FUNCTION* p = (SET_LED_FUNCTION*)Param;
	SET_LED_FUNCTION* pDel = (SET_LED_FUNCTION*)(p->pOwner);
	Sleep( 10000 );
	p->pView->SetItemLEDStatus( p->nItem, FALSE );
	delete pDel;

	return 0;
}

void CMainFrame::OnBtn1Clicked()
{
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	CDeviceClient* pDeviceClient = theApp.GetDevice();
	SET_LED_FUNCTION* pParam = NULL;

	U32 u32Ret = -1;
	int nItem = 0;
	if( pView && pDeviceClient )
	{
		U32 CardID = pView->GetSelectCardID();
		nItem = pView->GetSelectItem();
		u32Ret = pDeviceClient->FlashLED( CardID, 10, 0xFF );
		pParam = new SET_LED_FUNCTION;
		pParam->nItem = nItem;
		pParam->pOwner = (void*)pParam;
		pParam->pView = pView;
	}

	if( u32Ret != RETURN_NO_ERROR )
	{
		UINT nRC = theApp.m_Lang == 0 ? IDS_STR_FLASH_ERROR_CH : IDS_STR_FLASH_ERROR;
		CString str;
		str.LoadString( IDS_STR_FLASH_ERROR );
		MessageBox( str );
	}
	else
	{
		if( pParam )
		{
			pView->SetItemLEDStatus( nItem, TRUE );
			AfxBeginThread( SetLEDFunction, pParam );
		}
	}
}

void CMainFrame::OnBtn2Clicked()
{
	OnReadData();
}

void CMainFrame::OnBtn3Clicked()
{
	//OnTagdataStatistic();
	//OnStat();
	OnListView();
}

BOOL CMainFrame::AddCard(unsigned int CardID, unsigned char AD )
{
	BOOL IsRepeat = FALSE;

	for( int i=0; i<m_CardCount; i++ )
	{
		if( m_CardID[i] == CardID )
		{
			IsRepeat = TRUE;
		}
	}

	if( IsRepeat == FALSE )
	{
		if( m_CardCount < MAX_CARD_COUNT - 1 )
		{
			m_CardID[m_CardCount] = CardID;
			m_CardAD[m_CardCount].CardID = CardID;
			m_CardAD[m_CardCount].AD = AD;
			m_CardCount++;
		}
	}

	return IsRepeat;
}

/*
void CMainFrame::OnReturn()
{
	g_StopSign = 1;
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	if( pView )
	{
		pView->ActivePage( 1 );
		pView->SetStaticText( g_strScanTime );
	}
}
*/

char g_TemperatureArray[65535];

BOOL CMainFrame::GetCardHistoryData( unsigned CardID )
{
	BOOL bRet = FALSE;

	if( 1 )//m_CurrentCardID != CardID )
	{
		U32 u32Ret = RETURN_NO_ERROR;
		CDeviceClient* pDeviceClient = theApp.GetDevice();

		unsigned char ucAD = 0;
		for( int iIndex = 0; iIndex < MAX_CARD_COUNT; iIndex++ )
		{
			if( CardID == m_CardAD[iIndex].CardID )
			{
				ucAD = m_CardAD[iIndex].AD;
				m_CurrentAD = ucAD;
				break;
			}
		}

		if( pDeviceClient )
		{
			U16			TemperatureCount;
			CARD_TIME	CardTime;
			U16			IntervalTime;
			U16			StartTemperature;
			U16			Index = 0;

			U32			ReadSize;
			U8			TemperatureArray[16];
			U16		ActualCount = 0;
			U16		ActualIndex = 0;

			pDeviceClient->ClearBuffer();
			u32Ret = pDeviceClient->GetTemperature(
				CardID, &TemperatureCount, &CardTime, &IntervalTime, &StartTemperature,
				TemperatureArray );

			TemperatureCount -= 10;
			if( u32Ret == RETURN_NO_ERROR )
			{
				m_StartTime[0] = CardTime.u8Year;
				m_StartTime[1] = CardTime.u8Month;
				m_StartTime[2] = CardTime.u8Day;
				m_StartTime[3] = CardTime.u8Hour;
				m_StartTime[4] = CardTime.u8Minute;
				m_StartTime[5] = 0;

				m_TimeInterval = IntervalTime*10;
				m_CurrentCardID = CardID;
				bRet = TRUE;
			}
			else
			{
				UINT nRC = theApp.m_Lang == 0 ? IDS_STR_GETDATA_FAILED_CH : IDS_STR_GETDATA_FAILED;
				CString str;
				str.LoadString( nRC );
				MessageBox( str );
			}
			try
			{
				if( u32Ret == RETURN_NO_ERROR )//sector no.1
				{
					//CTemperatureCalc Calc(ucAD);

					m_TemperatureCount = TemperatureCount;

					char* pTemperatureArray;
					//pTemperatureArray = new char[TemperatureCount];
					memset(g_TemperatureArray,0,65535);
					pTemperatureArray = g_TemperatureArray;
					memcpy( pTemperatureArray, TemperatureArray, TemperatureCount  > 5 ? 5 : TemperatureCount );
					ActualCount += 5;
					if( TemperatureCount > 5 )
					{
						Index = 5;
						ActualIndex = 5;
						u32Ret = RETURN_NO_ERROR;
						ReadSize = TemperatureCount - 5;
						while ( /*u32Ret == RETURN_NO_ERROR &&*/ ActualIndex < TemperatureCount && ReadSize > 0 )
						{
							u32Ret = pDeviceClient->GetTemperatureData( TemperatureArray, 16, &ReadSize );
							if( u32Ret == RETURN_NO_ERROR )
							{
								memcpy( pTemperatureArray+ActualCount, TemperatureArray, 16 );
								//Index += ( (TemperatureCount - Index + 1) > 16 ? 16 : (TemperatureCount - Index ) );
							}
							ActualCount += 16;
							ActualIndex += 16;
						}
					}
					if ( TemperatureCount > 1024*16 )
					{
						TemperatureCount = 1024*16;
						m_TemperatureCount = TemperatureCount;
					}

					m_TemperatureCount -= 1;

					ConvertTemperaturyData( StartTemperature, TemperatureCount, ucAD, pTemperatureArray, &m_pTemperatureData );
				}			}
			catch (CException* e)
			{
				e->ReportError();
			}

		}

		pDeviceClient->ClearBuffer();
	}

	return bRet;
}

float g_floatTemperatureArray[1024*17];
BOOL CMainFrame::ConvertTemperaturyData(unsigned int StartTemperature, 
										unsigned int TemperatureCount, U8 ADVal, 
										char* pTemperatureArray, float** pTempertureData )
{
	unsigned int i = 0;

	*pTempertureData = g_floatTemperatureArray;
	if( *pTempertureData == NULL )	return FALSE;

	CTemperatureCalc calc( ADVal );
	unsigned int nCurrentTemperature = StartTemperature;
	(*pTempertureData)[0]	= calc.GetTemperature( (U16)nCurrentTemperature );

	m_LowTemperature = 200;
	m_HighTemperature = -200;
	m_SumTemperature = 0;
	m_HighTempIndex = 0;
	m_LowTempIndex	= 0;

	for( i = 0; i < TemperatureCount; i++ )
	{

		if (pTemperatureArray[i] &0x80 ){
			nCurrentTemperature = StartTemperature - (((byte)pTemperatureArray[i])-128);

		}else

		nCurrentTemperature = StartTemperature + pTemperatureArray[i];
		(*pTempertureData)[i] = calc.GetTemperature( (U16)nCurrentTemperature );
		m_SumTemperature += (*pTempertureData)[i];

		if( m_HighTemperature < (*pTempertureData)[i] )	
		{
			m_HighTemperature = (*pTempertureData)[i];
			m_HighTempIndex = i;
		}

		if( m_LowTemperature > (*pTempertureData)[i] )
		{
			m_LowTemperature = (*pTempertureData)[i];
			m_LowTempIndex = i;
		}
	}

	return TRUE;
}

void CMainFrame::OnTagdataStatistic()
{
	CDlgCardStatistic dlg;
	dlg.SetCardList( m_CardID, m_CardCount );
	dlg.DoModal();
}


typedef struct tagWaitDlgParam 
{
	int*	pStopSign;
	HANDLE	hThreadHandle;
	CWnd*	pWnd;
	CDlgWait* pDlg;
}WAIT_DLG_PARAM;

UINT WaitDlgThread( void* Param )
{
	WAIT_DLG_PARAM* p = (WAIT_DLG_PARAM*)Param;

	for( int i=0; i<10; i++ )
	{
		Sleep( 500 );
	}

	int nTime = 0;
	while (1)
	{
		Sleep( 500 );
		if( *(p->pStopSign) == 1 || nTime > 2000 )
		{
			//p->pDlg->OnBnClickedOk();
			delete p->pDlg;
			break;
		}
		nTime++;
	}
	return 0;
}

int g_IsStopWaitDlg = 0;
WAIT_DLG_PARAM g_ParamWaitDlg;

void CMainFrame::StartWaitDlg()
{
	CDlgWait* pdlg = new CDlgWait;
	g_IsStopWaitDlg = 0;
	g_ParamWaitDlg.pStopSign = &g_IsStopWaitDlg;	
	g_ParamWaitDlg.pWnd = 0;
	g_ParamWaitDlg.pDlg = pdlg;
	AfxBeginThread( WaitDlgThread, &g_ParamWaitDlg );
	pdlg->Create( IDD_DLG_WAIT, this );
	pdlg->ShowWindow( SW_SHOW );
}

void CMainFrame::EndWaitDlg()
{
	g_IsStopWaitDlg = 1;
}

// 0 Chinese
// 1 English
void CMainFrame::SetRCLang( char nLang )
{
}


void CMainFrame::OnTagdataTagproperty()
{
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	CDeviceClient* pDeviceClient = theApp.GetDevice();

	U32 u32Ret = -1;
	int nItem = 0;
	if( pView && pDeviceClient )
	{
		U32 CardID = pView->GetSelectCardID();
		if( CardID <= 0 )
		{
			DWORD dwResID = IDS_STR_ASK_SELECT_CARD;
			if( theApp.m_Lang == 0 )
			{
				dwResID = IDS_STR_ASK_SELECT_CARD_CH;
			}

			CString str;
			str.LoadString( dwResID );
			MessageBox( str );
			return;
		}

		CTagPropertyDlg dlg;
		dlg.SetDeviceClient( pDeviceClient );
		dlg.SetCardID( CardID );
		dlg.DoModal();
	}
}

void CMainFrame::OnReturnMain()
{
	g_StopSign = 1;
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	if( pView )
	{
		pView->ActivePage( 1 );
		pView->SetStaticText( g_strScanTime );
	}
}