dlgpgasyncrdwr.cpp

1394测试程序

// DlgPgAsyncRdWr.cpp : implementation file
//

#include "stdafx.h"
#include "TestApp.h"
#include "DlgPgAsyncRdWr.h"
#include "ddx_ex.h"
//#include "DlgAllocateAddressRange.h"
//#include "NmDlgFileToAsync.h"
//#include "NmDlgAsyncToFile.h"
//#include "NmDlgAsyncSlave.h"
//#include "NmDlgRxSlave.h"
//#include "NmDlgTxSlave.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CDlgPgAsyncRdWr dialog


CDlgPgAsyncRdWr::CDlgPgAsyncRdWr(CWnd* pParent /*=NULL*/)
	: CDialogPage(CDlgPgAsyncRdWr::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDlgPgAsyncRdWr)		
	m_bIncrement = FALSE;
	m_bPingOrNoStatus = FALSE;
	m_nReadOrWrite = 0;
	m_dwGenerationCount = 0;
	m_bGeneration = TRUE;
	m_dwDataSize = 1024;
	//}}AFX_DATA_INIT
}


void CDlgPgAsyncRdWr::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDlgPgAsyncRdWr)
	DDX_Control(pDX, IDC_STATIC_READ_WRITE, m_StaticReadOrWrite);
	DDX_Control(pDX, IDC_BUTTON_READ_WRITE, m_ButtonReadOrWrite);
	DDX_Control(pDX, IDC_CHECK_READ_WRITE, m_ButtonPingOrNoStatus);
	DDX_Check(pDX, IDC_CHECK_INCREMENT, m_bIncrement);
	DDX_Check(pDX, IDC_CHECK_READ_WRITE, m_bPingOrNoStatus);
	DDX_Radio(pDX, IDC_RADIO_READ, m_nReadOrWrite);
	DDX_Text(pDX, IDC_EDIT_ASYNC_GENERATION_COUNT, m_dwGenerationCount);
	DDV_MinMaxDWord(pDX, m_dwGenerationCount, 0, 1000);
	DDX_Check(pDX, IDC_CHECK_Generation, m_bGeneration);
	//}}AFX_DATA_MAP

	UINT nIDPrompt = IDS_STRING_INVALID_NUM;
	LPCTSTR format;

	// address offset
	format = _T("0x%X");

	DDX_TextEx(pDX, IDC_EDIT_READ_OFFHI, format, m_dwOffHi, nIDPrompt);
	DDX_TextEx(pDX, IDC_EDIT_READ_OFFLO, format, m_dwOffLo, nIDPrompt);
	
	// data size and block size
	format = _T("%d");

	DDX_TextEx(pDX, IDC_EDIT_READ_DATASIZE, format, m_dwDataSize, nIDPrompt);
	DDX_TextEx(pDX, IDC_EDIT_READ_BLOCKSIZE, format, m_dwBlockSize, nIDPrompt);

	// flags

	// data values for write
	format = _T("0x%02X ");
	nIDPrompt = IDS_STRING_INVALID_BUFFER;
	DDX_TextEx(pDX, IDC_EDIT_WRITE_DATA, format, m_Buffer, nIDPrompt);

}


BEGIN_MESSAGE_MAP(CDlgPgAsyncRdWr, CDialog)
	//{{AFX_MSG_MAP(CDlgPgAsyncRdWr)
	ON_BN_CLICKED(IDC_BUTTON_READ_WRITE, OnButtonReadWrite)
	ON_BN_CLICKED(IDC_RADIO_WRITE, OnRadioWrite)
	ON_BN_CLICKED(IDC_RADIO_READ, OnRadioRead)
	ON_BN_CLICKED(IDC_CHECK_Generation, OnCHECKGeneration)
	ON_BN_CLICKED(IDC_BUTTON_CONTINOUT_READ, OnButtonContinoutRead)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDlgPgAsyncRdWr message handlers

BOOL CDlgPgAsyncRdWr::OnInitDialog() 
{
	CDialog::OnInitDialog();
	GetDlgItem(IDC_EDIT_WRITE_DATA)->EnableWindow(FALSE);
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CDlgPgAsyncRdWr::OnButtonReadWrite() 
{
	DWORD Status;
	if ( 0 == m_nReadOrWrite )
	{
		ASYNC_READ      asyncRead;
		/*
		typedef struct _ASYNC_READ {    
			ULONG           bGetGeneration;
			IO_ADDRESS      DestinationAddress;
			ULONG           nNumberOfBytesToRead;
			ULONG           nBlockSize;
			ULONG           fulFlags;
			ULONG           ulGeneration;//32位，共四个字节
			UCHAR           Data[1];//UCHAR 8位，一个字节
		} ASYNC_READ, *PASYNC_READ;
		typedef struct _NODE_ADDRESS {
			USHORT      NA_Node_Number:6;    // Bits 10-15
			USHORT      NA_Bus_Number:10;    // Bits 0-9
		} NODE_ADDRESS, *PNODE_ADDRESS;

		typedef struct _ADDRESS_OFFSET {
			USHORT        Off_High;
			ULONG         Off_Low;
		} ADDRESS_OFFSET, *PADDRESS_OFFSET;

		typedef struct _IO_ADDRESS {
			NODE_ADDRESS        IA_Destination_ID;
			ADDRESS_OFFSET      IA_Destination_Offset;
		} IO_ADDRESS, *PIO_ADDRESS;
		*/
/*
		time_t ltimeLa;
		_tzset();
		time( &ltimeLa );
*/
		//得到用户指定的值
		UpdateData(TRUE);
		if( m_bGeneration )
			asyncRead.bGetGeneration = TRUE;
		else asyncRead.bGetGeneration = FALSE;
		asyncRead.ulGeneration = m_dwGenerationCount;
		asyncRead.DestinationAddress.IA_Destination_Offset.Off_High = (USHORT)m_dwOffHi;
		asyncRead.DestinationAddress.IA_Destination_Offset.Off_Low = (ULONG)m_dwOffLo;
		asyncRead.nNumberOfBytesToRead = m_dwDataSize;
		asyncRead.nBlockSize = m_dwBlockSize;
		asyncRead.fulFlags = 0;
		if( m_bIncrement )
			asyncRead.fulFlags  |= ASYNC_FLAGS_NONINCREMENTING;
		if( m_bPingOrNoStatus )
			asyncRead.fulFlags |= ASYNC_FLAGS_PING;
	//	asyncRead.ulElapsedTime = 0;
		
		//开辟传给驱动的存储空间
		ULONG           ulBufferSize;
		PASYNC_READ     pAsyncRead = NULL;
	    
		ulBufferSize = sizeof(ASYNC_READ) + asyncRead.nNumberOfBytesToRead;//字节为单位
		pAsyncRead = (PASYNC_READ)LocalAlloc(LPTR, ulBufferSize);
		FillMemory(pAsyncRead, ulBufferSize, 0);//开辟的每一个字节都为零
		*pAsyncRead = asyncRead;
		
		LARGE_INTEGER  litmp ;
		LONGLONG  QPart1,QPart2 ;
		double  dfMinus, dfFreq, dfTim ;

		QueryPerformanceFrequency(&litmp) ; 
		 // 获得计数器的时钟频率
		dfFreq = (double)litmp.QuadPart ;

		QueryPerformanceCounter(&litmp) ; 
		 // 获得初始值
		QPart1 = litmp.QuadPart ;

		Status = g_CurrentDev.AsyncRead(pAsyncRead,ulBufferSize);

		QueryPerformanceCounter(&litmp) ; 
		 // 获得中止值
		QPart2 = litmp.QuadPart ;

		dfMinus = (double)(QPart2 - QPart1) ;
		dfTim = dfMinus / dfFreq ;  
		// 获得对应的时间值
		CString strTime;
		strTime.Format("%f秒 \r\n", dfTim);
		MessageBox(strTime);

		if ( Status == STATUS_SUCCESS ) 
		{
			//输出读入的数据			
			PrintOut("Read Data:"NL);

			ULONG ulElapsedTime = pAsyncRead->ulElapsedTime;
			CString str;
			str.Format("%d\n",ulElapsedTime);
			PrintOut(str.GetBufferSetLength( str.GetLength() ) );
			str.ReleaseBuffer();

			CString strOut;
			for (int i=0; i<(asyncRead.nNumberOfBytesToRead/sizeof(ULONG)); i++) 
			{
                PULONG ulTemp;
                ulTemp = (PULONG)&pAsyncRead->Data[i*sizeof(ULONG)];
				strOut.Format("Quadlet[0x%x] = 0x%x\r\n",i,(ULONG)*ulTemp);
                PrintOut(strOut.GetBufferSetLength( strOut.GetLength() ) );
				strOut.ReleaseBuffer();
            }
/*
			// write the results to output window
			PrintOut(NL"%d bytes successfully read:", BytesReturned);
			for (DWORD i=0; i<BytesReturned; i++) 
			{
				if ( (i % 4) == 0 ) {
					PrintOut(NL"  ");
				}
				PrintOut("0x%02X ", buf[i]);
			}

			CString str;
			str.Format(":%d",Err);		
			PrintOut( str.GetBufferSetLength( str.GetLength() ) );
			str.ReleaseBuffer();
			PrintOut(NL);
			*/
	 	}
		else 
		{
			Status = GetLastError();
			PrintOut(NL"AsyncRead failed"NL);
			PrintError(Status);
		}
		if( NULL != pAsyncRead )
			LocalFree(pAsyncRead);
/*			
		time_t ltimeLb;
		_tzset();
		time( &ltimeLb );

		double lLoadTime = ltimeLb - ltimeLa;	
		CString strLoadTime;
		strLoadTime.Format("%f秒 \r\n", lLoadTime);
		MessageBox(strLoadTime);*/
	}
	else if ( 1 == m_nReadOrWrite )
	{
		ASYNC_WRITE      asyncWrite;
		/*		
		typedef struct _ASYNC_WRITE {
			ULONG           bGetGeneration;
			IO_ADDRESS      DestinationAddress;
			ULONG           nNumberOfBytesToWrite;
			ULONG           nBlockSize;
			ULONG           fulFlags;
			ULONG           ulGeneration;
			UCHAR           Data[1];
		} ASYNC_WRITE, *PASYNC_WRITE;
		*/
		//得到用户指定的值
		UpdateData(TRUE);
		if( m_bGeneration )
			asyncWrite.bGetGeneration = TRUE;
		else asyncWrite.bGetGeneration = FALSE;
		asyncWrite.DestinationAddress.IA_Destination_ID.NA_Bus_Number = 0x3FF;
		asyncWrite.DestinationAddress.IA_Destination_ID.NA_Node_Number = 0;
		asyncWrite.DestinationAddress.IA_Destination_Offset.Off_High = (USHORT)m_dwOffHi;
		asyncWrite.DestinationAddress.IA_Destination_Offset.Off_Low = (ULONG)m_dwOffLo;
		asyncWrite.nNumberOfBytesToWrite = m_dwDataSize;
		asyncWrite.nBlockSize = m_dwBlockSize;
		asyncWrite.fulFlags = 0;
		if( m_bIncrement )
			asyncWrite.fulFlags |= ASYNC_FLAGS_NONINCREMENTING;
		if( m_bPingOrNoStatus )
			asyncWrite.fulFlags |= ASYNC_FLAGS_PING;
		asyncWrite.ulGeneration = m_dwGenerationCount;
		
		//开辟传给驱动的存储空间
		PASYNC_WRITE     pAsyncWrite = NULL;
		ULONG           ulBufferSize;

		ulBufferSize = sizeof(ASYNC_WRITE) + asyncWrite.nNumberOfBytesToWrite;
		pAsyncWrite = (PASYNC_WRITE)LocalAlloc(LPTR, ulBufferSize);
		FillMemory(pAsyncWrite, ulBufferSize, 0);
		*pAsyncWrite = asyncWrite;
		//填充要写的数据
		for (int i=0; i<asyncWrite.nNumberOfBytesToWrite/sizeof(ULONG); i++) 
		{
			CopyMemory((ULONG *)&pAsyncWrite->Data+i, (ULONG *)&i, sizeof(ULONG));
		}
/*		//输出写的数据
		for (i=0; i<(asyncWrite.nNumberOfBytesToWrite/sizeof(ULONG)); i++) 
		{
			PULONG ulTemp;

			ulTemp = (PULONG)&pAsyncWrite->Data[i*sizeof(ULONG)];
	  	}
*/
		LARGE_INTEGER  litmp ;
		LONGLONG  QPart1,QPart2 ;
		double  dfMinus, dfFreq, dfTim ;

		QueryPerformanceFrequency(&litmp) ; 
		 // 获得计数器的时钟频率
		dfFreq = (double)litmp.QuadPart ;

		QueryPerformanceCounter(&litmp) ; 
		 // 获得初始值
		QPart1 = litmp.QuadPart ;
		Status = g_CurrentDev.AsyncWrite(pAsyncWrite,ulBufferSize);
		
		QueryPerformanceCounter(&litmp) ; 
		 // 获得中止值
		QPart2 = litmp.QuadPart ;

		dfMinus = (double)(QPart2 - QPart1) ;
		dfTim = dfMinus / dfFreq ;  
		// 获得对应的时间值
		CString strTime;
		strTime.Format("%f秒 \r\n", dfTim);
		MessageBox(strTime);

		if ( Status == STATUS_SUCCESS ) 
		{
			PrintOut(NL"AsyncWrite Success!"NL);
		}
		else
		{
			Status = GetLastError();
			PrintOut(NL"AsyncWrite failed"NL);
			PrintError(Status);
		}
		if ( NULL != pAsyncWrite )
			LocalFree(pAsyncWrite);
	}
}

//WRITE 单选按钮
void CDlgPgAsyncRdWr::OnRadioWrite() 
{	
	if( 1 == m_nReadOrWrite )
		return;	
	m_StaticReadOrWrite.SetWindowText("to Address Offset");
	m_ButtonPingOrNoStatus.SetWindowText("No Status");
	m_ButtonReadOrWrite.SetWindowText("Async Write");
	GetDlgItem(IDC_EDIT_WRITE_DATA)->EnableWindow(TRUE);
	m_nReadOrWrite = 1;
	UpdateData(FALSE);
}

//READ 单选按钮
void CDlgPgAsyncRdWr::OnRadioRead() 
{
	if( 0 == m_nReadOrWrite )
		return;	
	m_StaticReadOrWrite.SetWindowText("from Address Offset");
	m_ButtonPingOrNoStatus.SetWindowText("Ping packet");
	m_ButtonReadOrWrite.SetWindowText("Async Read");
	GetDlgItem(IDC_EDIT_WRITE_DATA)->EnableWindow(FALSE);
	m_nReadOrWrite = 0;
	UpdateData(FALSE);
	
}

//使能m_dwGenerationCount
void CDlgPgAsyncRdWr::OnCHECKGeneration() 
{
	if( m_bGeneration )//以前为TRUE
	{
		m_bGeneration = FALSE;
		GetDlgItem(IDC_EDIT_ASYNC_GENERATION_COUNT)->EnableWindow(TRUE);
	}
	else//以前为FALSE
	{
		m_dwGenerationCount = 0;
		GetDlgItem(IDC_EDIT_ASYNC_GENERATION_COUNT)->EnableWindow(FALSE);
		m_bGeneration = TRUE;
	}
	UpdateData(FALSE);
}

void CDlgPgAsyncRdWr::OnButtonContinoutRead() 
{
	DWORD Status;
	if ( 0 == m_nReadOrWrite )
	{
		/*
		time_t ltimeLa;
		_tzset();
		time( &ltimeLa );*/
		BYTE data[100][1024];
//		for(int nTime = 0;nTime < 100;nTime++)
//		{
			ASYNC_READ      asyncRead;			

			//得到用户指定的值
			UpdateData(TRUE);
			if( m_bGeneration )
				asyncRead.bGetGeneration = TRUE;
			else asyncRead.bGetGeneration = FALSE;
			asyncRead.ulGeneration = m_dwGenerationCount;
			asyncRead.DestinationAddress.IA_Destination_Offset.Off_High = (USHORT)m_dwOffHi;
			asyncRead.DestinationAddress.IA_Destination_Offset.Off_Low = (ULONG)m_dwOffLo;
			asyncRead.nNumberOfBytesToRead = m_dwDataSize;
			asyncRead.nBlockSize = m_dwBlockSize;
			asyncRead.fulFlags = 0;
			if( m_bIncrement )
				asyncRead.fulFlags  |= ASYNC_FLAGS_NONINCREMENTING;
			if( m_bPingOrNoStatus )
				asyncRead.fulFlags |= ASYNC_FLAGS_PING;			
			asyncRead.ulElapsedTime = 0;
			
			//开辟传给驱动的存储空间
			ULONG           ulBufferSize;
			PASYNC_READ     pAsyncRead = NULL;
			
			ulBufferSize = sizeof(ASYNC_READ) + asyncRead.nNumberOfBytesToRead;//字节为单位
			pAsyncRead = (PASYNC_READ)LocalAlloc(LPTR, ulBufferSize);
			FillMemory(pAsyncRead, ulBufferSize, 0);//开辟的每一个字节都为零
			*pAsyncRead = asyncRead;
			//////
			LARGE_INTEGER  litmp ;
			LONGLONG  QPart1,QPart2 ;
			double  dfMinus, dfFreq, dfTim ;

			QueryPerformanceFrequency(&litmp) ; 
			 // 获得计数器的时钟频率
			dfFreq = (double)litmp.QuadPart ;

			QueryPerformanceCounter(&litmp) ; 
			 // 获得初始值
			QPart1 = litmp.QuadPart ;
			///////////
			for( int nn=0;nn<100;nn++ )
			{
				Status = g_CurrentDev.AsyncRead(pAsyncRead,ulBufferSize);
/*
				if ( Status == STATUS_SUCCESS ) 
				{
					//输出读入的数据			
					PrintOut("Read Data:"NL);
					ULONG ulElapsedTime = pAsyncRead->ulElapsedTime;
					CString str;
					str.Format("%d次：%d\n",nn,ulElapsedTime);
					PrintOut(str.GetBufferSetLength( str.GetLength() ) );
					str.ReleaseBuffer();
					/*
					CString strOut;
					for (int i=0; i<(asyncRead.nNumberOfBytesToRead/sizeof(ULONG)); i++) 
					{
						PULONG ulTemp;
						ulTemp = (PULONG)&pAsyncRead->Data[i*sizeof(ULONG)];
	//					data[nTime][i*sizeof(ULONG)] = pAsyncRead->Data[i*sizeof(ULONG)];
	//					data[nTime][i*sizeof(ULONG)+1] = pAsyncRead->Data[i*sizeof(ULONG)+1];
	//					data[nTime][i*sizeof(ULONG)+2] = pAsyncRead->Data[i*sizeof(ULONG)+2];
	//					data[nTime][i*sizeof(ULONG)+3] = pAsyncRead->Data[i*sizeof(ULONG)+3];
						strOut.Format("Quadlet[0x%x] = 0x%x\r\n",i,(ULONG)*ulTemp);
						PrintOut(strOut.GetBufferSetLength( strOut.GetLength() ) );
						strOut.ReleaseBuffer();
					}*/			/*
				}
				else 
				{
					Status = GetLastError();
				}*/
			}

			QueryPerformanceCounter(&litmp) ; 
			 // 获得中止值
			QPart2 = litmp.QuadPart ;

			dfMinus = (double)(QPart2 - QPart1) ;
			dfTim = dfMinus / dfFreq ;  
			// 获得对应的时间值
			CString strTime;
			strTime.Format("%f秒 \r\n", dfTim);
			MessageBox(strTime);

			if( NULL != pAsyncRead )
				LocalFree(pAsyncRead);
//		}
		/*
		time_t ltimeLb;
		 _tzset();
		time( &ltimeLb );

		double lLoadTime = ltimeLb - ltimeLa;
		
		CString strLoadTime;
		strLoadTime.Format("%f秒 \r\n", lLoadTime);
		MessageBox(strLoadTime);*/
/*		PrintOut(strLoadTime.GetBufferSetLength( strLoadTime.GetLength() ) );
		strLoadTime.ReleaseBuffer();*/		
	}
}