mainfrm.cpp

RFID温度签的源码

// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "Temperature.h"
#include "MainFrm.h"
#include "DeviceClient.h"
#include "ErrorCode.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#include "CommonMacro.h"
#include "MainFrm.h"
#include "TemperatureView.h"
#include "DlgReadData.h"
#include "DlgRelationSet.h"
#include "DlgStartCheck.h"
#include "time.h"
#include "HistoryDlg.h"
#include "TemperatureCalc.h"
#include "DlgStat.h"
#include "ExportFile.h"
#include "DlgCardStatistic.h"
#include "DlgWait.h"
#include "ManualScanDlg.h"
#include "TagPropertyDlg.h"


// CMainFrame
extern CTemperatureApp theApp;

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
	ON_WM_CREATE()
	ON_WM_SIZE()

	ON_COMMAND(ID_MANUAL_SCAN, &CMainFrame::OnManualScan)
	ON_COMMAND(ID_AUTO_SCAN, &CMainFrame::OnAutoScan)
	ON_COMMAND(ID_32781, &CMainFrame::OnReadData)
	ON_COMMAND(ID_32782, &CMainFrame::OnWriteData)
	ON_COMMAND(ID_TEMPERATURE_START, &CMainFrame::OnTemperatureStart)
	ON_COMMAND(ID_TEMPERATURE_END, &CMainFrame::OnTemperatureEnd)
	ON_COMMAND(ID_INFO_PRODUCT_NAME, &CMainFrame::OnInfoProductName)
	ON_COMMAND(ID_INFO_MANUFACTURE, &CMainFrame::OnInfoManufacture)
	ON_COMMAND(ID_LIST_VIEW, &CMainFrame::OnListView)
	ON_COMMAND(ID_FIG_VIEW, &CMainFrame::OnFigView)
	ON_UPDATE_COMMAND_UI(ID_MANUAL_SCAN, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_AUTO_SCAN, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_32781, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_32782, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_TEMPERATURE_START, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_TEMPERATURE_END, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_LIST_VIEW, &CMainFrame::OnUpdateDeviceMenu)
	ON_UPDATE_COMMAND_UI(ID_FIG_VIEW, &CMainFrame::OnUpdateDeviceMenu)
	ON_BN_CLICKED(ID_FLASH_LED, &CMainFrame::OnBtn1Clicked)
	ON_BN_CLICKED(ID_TOOL_BTN2, &CMainFrame::OnBtn2Clicked)
	ON_BN_CLICKED(ID_TOOL_BTN3, &CMainFrame::OnBtn3Clicked)

	ON_COMMAND(ID_GROUP, &CMainFrame::OnGroup)
	ON_COMMAND(ID_TAGDATA_STATISTIC, &CMainFrame::OnTagdataStatistic)
	ON_COMMAND(ID_TAGDATA_TAGPROPERTY, &CMainFrame::OnTagdataTagproperty)
	ON_COMMAND(ID_HISTORY_READDATA, &CMainFrame::OnHistoryReadData)
	ON_COMMAND(ID_RETURN_MAIN, &CMainFrame::OnReturnMain)
END_MESSAGE_MAP()

static UINT indicators[] =
{
	ID_SEPARATOR,           // status line indicator
};


// CMainFrame construction/destruction

CMainFrame::CMainFrame() :
	m_CardCount(0),
		m_TemperatureCount( 0 ),
		m_CurrentCardID( 0 ),
		m_pTemperatureData( NULL ),
		m_LowTemperature(0.0),
		m_HighTemperature(0.0),
		m_SumTemperature(0.0),
		m_uiStartTime(0),
		m_HighTempIndex( 0 ),
		m_LowTempIndex( 0 ),
		m_LimitHigh( 25.0 ),
		m_LimitLow( -20.0 )
{
	// TODO: add member initialization code here
}

CMainFrame::~CMainFrame()
{
	if( m_pTemperatureData )
	{
		delete[] m_pTemperatureData;
		m_pTemperatureData = NULL;
	}
}


int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
		| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	if( m_Bitmap.LoadBitmap( IDB_BITMAP1 ) )
	{
		if( m_ImageList.Create(16, 15, ILC_COLOR8, 0, 3 ) )
		{
			//m_ImageList.SetBkColor( RGB(192,192,192) );
			if( m_ImageList.Add( &m_Bitmap, RGB(255,0,255) ) == 0 )
			{
				m_wndToolBar.GetToolBarCtrl().SetImageList(&m_ImageList);
			}
		}
	}
	//if( m_ImageList.Create( IDB_BITMAP1, 16, 5, RGB(192,192,192) ) )
	//{
	//	m_wndToolBar.GetToolBarCtrl().SetImageList(&m_ImageList);
	//}

	//if (!m_wndStatusBar.Create(this) ||
	//	!m_wndStatusBar.SetIndicators(indicators,
	//	  sizeof(indicators)/sizeof(UINT)))
	//{
	//	TRACE0("Failed to create status bar\n");
	//	return -1;      // fail to create
	//}

	// TODO: Delete these three lines if you don't want the toolbar to be dockable
	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockControlBar(&m_wndToolBar);

	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CFrameWnd::PreCreateWindow(cs) )
		return FALSE;
	
	cs.style &= ~FWS_ADDTOTITLE;   

	return TRUE;
}


// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CFrameWnd::Dump(dc);
}

#endif //_DEBUG


// CMainFrame message handlers

BOOL g_IsSetWindowSize = FALSE;

void CMainFrame::OnSize(UINT nType, int cx, int cy)
{
	CFrameWnd::OnSize(nType, cx, cy);

	//CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	//if( pView  ) //&& g_IsSetWindowSize == FALSE )
	//{
	//	if( IsWindow(pView->m_hWnd) )
	//	{
	//		pView->MoveWindow( 0, 0, cx, cy );
	//		g_IsSetWindowSize = TRUE;
	//	}
	//}
}


UINT ScanCardThreadFunction( void* pParam )
{
	return 0;
}

void CMainFrame::OnFinalRelease()
{
	// TODO: 在此添加专用代码和/或调用基类

	CFrameWnd::OnFinalRelease();
}

CString g_strScanTime;

void CMainFrame::OnManualScan()
{
	//CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	//if( pView )
	//{
	//	pView->ActivePage( 0 );
	//}
	//return;

	INT_DATA_SCAN ScanData;
	U8 Count;
	U8 IsOver = FALSE;
	U32 u32Ret;
	int i=0;
	BOOL IsRepeat;

	DWORD dwData = 0;

	CManualScanDlg dlg;
	CString strStatus;

	if( theApp.m_Lang == 0 )
	{
		strStatus.LoadString( IDS_STRUNKNOWN_CH );
	}
	else
	{
		strStatus.LoadString( IDS_STRUNKNOWN );
	}

	int nDlgRet = (int)(dlg.DoModal());
	if( nDlgRet != 1 )
	{
		return;
	}

	Sleep( 500 );
	if( dlg.GetIsLED() && dlg.GetIsGroupCheck() )
	{
		TCHAR ch[128];
		char* pStr;
		dwData = dlg.GetComboData();
		theApp.GetCardGroup(dwData, &pStr );

		if( pStr )
		{
			memset( ch, 0, sizeof(ch) );
			//MultiByteToWideChar( CP_ACP, 0, pStr, strlen(pStr), ch, 128 );
			strStatus = pStr ;
		}		
	}

	BOOL IsOnlyCheckLED = FALSE;
	if( dlg.GetIsLED() && ( dlg.GetIsGroupCheck() == FALSE ) )
	{
		IsOnlyCheckLED = TRUE;
	}

	BOOL IsOnlyLED = FALSE;
	if( dlg.GetIsLED() )
	{
		IsOnlyLED = TRUE;
	}

	CDeviceClient* pDeviceClient = theApp.GetDevice();

	do 
	{
		if( pDeviceClient == NULL )	break;
		if( pDeviceClient->IsOpen() == FALSE )	break;
		pDeviceClient->ClearBuffer();
		CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
		if( pView )
		{
			pView->DeleteAllItems();
		}
		
		SYSTEMTIME tm;
		GetLocalTime( &tm );
		CTime time = CTime(tm.wYear, tm.wMonth, tm.wDay, tm.wHour, tm.wMinute, tm.wSecond );
		CString strTime;
		if( theApp.m_Lang == 0 )
		{
			g_strScanTime.LoadString( IDS_STR_SCANTIME_CH );
		}
		else
		{
			g_strScanTime.LoadString( IDS_STR_SCANTIME );
		}
		strTime.Format( _T("%d-%d-%d %d:%d:%d"), 
			time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(), time.GetSecond() );
		g_strScanTime += strTime;
		pView->SetStaticText( g_strScanTime );


		u32Ret = pDeviceClient->ScanCard( 2, 0, LOWORD( dwData), &Count, &ScanData, &IsOver );
		if( u32Ret != RETURN_NO_ERROR )	break;

		if( u32Ret == RETURN_NO_ERROR && IsOver == FALSE )
		{
			
			if( pView )
			{
				pView->ActivePage( 1 );
				m_CardCount = 0;
				
				TCHAR chTemp1[32];
				CString chTemp2;
				TCHAR chTemp3[32];
				TCHAR chTemp4[128];
				U32 CardID;
				int nLoID = -1;
				int index = 0;
				int nHiID = -1;
				while ( u32Ret == RETURN_NO_ERROR && IsOver == FALSE )
				{
					CardID = ((((U16)ScanData.u8ID[0]) << 8 ) & 0xFF00) | ((ScanData.u8ID[1] & 0x00FF));

					// NO LED  小于20000的卡号不显示出来，
					// LED 大于等于20000的卡号不显示出来
					BOOL IsAdd = TRUE;
					if( IsOnlyLED )
					{
						if( CardID < 20000 )	IsAdd = FALSE;
					}
					else
					{
						if( CardID >= 20000 )	IsAdd = FALSE;
					}

					if ( CardID > 100 && IsAdd )
					{
						IsRepeat = AddCard( CardID, ScanData.u8AD );
						if( IsRepeat == FALSE )
						{

							DWORD nKey =  CardID;

							_stprintf( chTemp1, _T("%d"), CardID );

							if( ScanData.u8TemperatureData2[0] != 0 && ScanData.u8TemperatureData2[1] != 0 )
							{
								_stprintf( chTemp3, _T("%.2f"), CDeviceClient::GetActualTemperature( 
									ScanData.u8AD,
									ScanData.u8TemperatureData2[0],
									ScanData.u8TemperatureData2[1]) );

								chTemp2.LoadString( IDS_STR_STATUS_WORK );
							}
							else
							{
								chTemp2.LoadString( IDS_STR_STATUS_SLEEP );
								memset( chTemp3, 0, sizeof(chTemp3) );
							}

						if( IsOnlyCheckLED )
						{
							U32 u32GroupVal = MAKE_U32( ScanData.u8TemperatureData1[0], ScanData.u8TemperatureData1[1], 0 , 0 );
							char* pStr;
					
							BOOL bRet = theApp.GetCardGroup( u32GroupVal, &pStr );
							if( bRet && u32GroupVal == 0 )
							{
								bRet = FALSE;
							}
							if( bRet )
							{
								memset( chTemp4, 0, sizeof(chTemp4) );
								//MultiByteToWideChar( CP_ACP, 0, pStr, strlen(pStr), chTemp4, 128 ); 
								strcpy( chTemp4, pStr );
							}
							else
							{
								if( theApp.m_Lang == 0 )
								{
									strStatus.LoadString( IDS_STRUNKNOWN_CH );
								}
								else
								{
									strStatus.LoadString( IDS_STRUNKNOWN );
								}

								_tcscpy( chTemp4, strStatus );
							}
						}
						else
						{
						_tcscpy( chTemp4, strStatus );
						}

						pView->PushBackToList( CardID, chTemp1, chTemp2, chTemp3, chTemp4 );
						}

						i++;
					}
					ZeroMemory( &ScanData,sizeof(ScanData));
					u32Ret = pDeviceClient->GetScanData( &ScanData, &IsOver );
				}
			}
		}

		if( u32Ret != RETURN_NO_ERROR )
		{
			UINT nRCLang = theApp.m_Lang == 0 ? IDS_STR_MANUAL_FAILED_CH : IDS_STR_MANUAL_FAILED;
			CString str;
			str.LoadString( nRCLang );
			MessageBox( str );
		}

		m_CardCount = i;

	} while( 0 );
}

int g_StopSign = 0;
typedef struct tagThreadParam 
{
	CTemperatureView* pView;
	CDeviceClient*		pDevice;
	CMainFrame*			pMainFrame;
	int					nInterval; // second
	int*				pStopSign;
	unsigned int		CardID;
}THREAD_PARAM;

THREAD_PARAM g_ThreadParam;

UINT AutoScanThreadFunction( void* Param )
{
	THREAD_PARAM* pData = (THREAD_PARAM*)Param;
	BOOL IsStop = FALSE;
	U32	 u32Ret = RETURN_NO_ERROR;
	INT_DATA_SCAN ScanData;
	U8 Count;
	U8 IsOver = FALSE;
	U32 CardID;
	float Temperature;
	BOOL isAdd = FALSE;
	do 
	{
		u32Ret = pData->pDevice->ClearBuffer();

		u32Ret = pData->pDevice->ScanCard( 2, 0, 0, &Count, &ScanData, &IsOver );
		if( u32Ret == RETURN_NO_ERROR )
		{
			while ( u32Ret == RETURN_NO_ERROR && IsOver == FALSE )
			{
				CardID = (((U16)ScanData.u8ID[0]) << 8 ) & 0xFF00 | (ScanData.u8ID[1] & 0x00FF);
				if( CardID == pData->CardID || !isAdd )
				{
					Temperature = CDeviceClient::GetActualTemperature( 
						ScanData.u8AD,
						ScanData.u8TemperatureData2[0],
						ScanData.u8TemperatureData2[1]);

					pData->pMainFrame->m_DynamicData.AddDynamicTemperature( Temperature );
					isAdd = TRUE;
					//break;
				}
				u32Ret = pData->pDevice->GetScanData( &ScanData, &IsOver );
			}			
		}
		else
		{
			//break;
		}

		pData->pView->RefreshView();

		//Sleep( 1000 );
		for( int i=0; i<pData->nInterval*2  ; i++ )
		{
			Sleep(500);
			if( *(pData->pStopSign) == 1 )	
			{
				IsStop = TRUE;
				break;
			}
		}

		if( IsStop )	
		{
			pData->pDevice->ClearBuffer();
			break;
		}

	} while(1);


	return 0;
}

void CMainFrame::OnAutoScan()
{
	U32 u32Ret;
	CTemperatureView *pView = (CTemperatureView*)this->GetActiveView();
	g_ThreadParam.pDevice = theApp.GetDevice();
	g_ThreadParam.pView	  = pView;
	g_ThreadParam.pMainFrame = this;
	g_ThreadParam.pStopSign = &g_StopSign;
	g_ThreadParam.CardID	= pView->GetSelectCardID();