simulationdoc.cpp

这是一个在wince下用evc开发的ad信号采集与显示以及信号模拟与分析的程序源码

// SimulationDoc.cpp : implementation of the CSimulationDoc class
//

#include "stdafx.h"
#include "Simulation.h"

#include "SimulationDoc.h"

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

/////////////////////////////////////////////////////////////////////////////
// CSimulationDoc

IMPLEMENT_DYNCREATE(CSimulationDoc, CDocument)

BEGIN_MESSAGE_MAP(CSimulationDoc, CDocument)
	//{{AFX_MSG_MAP(CSimulationDoc)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSimulationDoc construction/destruction

CSimulationDoc::CSimulationDoc()
{
	// TODO: add one-time construction code here
	m_pSRData=NULL;
	m_pWTData=NULL;
	m_pCOData=NULL;
	m_SRDataLen=0;
	m_WTDataLen=0;
	m_CODataLen=0;     
	m_SRMaxValue=0;
	m_SRMinValue=65535;
	m_WTMaxValue=0;
	m_WTMinValue=65535;
	m_COMaxValue=0;
	m_COMinValue=65535;
	m_Interval = 8;//200
	m_pSRShow = NULL;
	m_pWTShow = NULL;
	m_pCOShow = NULL;

	this->m_pSimuCOData=NULL;
	this->m_pSimuSRData=NULL;
	this->m_pSimuWTData=NULL;
	this->m_SRSimuDataLen=0;
	this->m_WTSimuDataLen=0;
	this->m_COSimuDataLen=0;

	m_ReadSRLen=0;
	m_ReadWTLen=0;

	memset(m_UpPoints,0,50*sizeof(long));
	memset(m_DownPoints,0,50*sizeof(long));
	this->m_LenUpPoints=0;
	this->m_LenDownPoints=0;

}

CSimulationDoc::~CSimulationDoc()
{
	if(m_pSRData)
	{
		free(m_pSRData);
		m_pSRData=NULL;
	}
	if(m_pWTData)
	{
		free(m_pWTData);
		m_pWTData=NULL;
	}
	if(m_pCOData)
	{
		free(m_pCOData);
		m_pCOData=NULL;
	}

	if(m_pSRShow)
	{
		free(m_pSRShow);
		m_pSRShow = NULL;
	}

	if(m_pWTShow)
	{
		free(m_pWTShow);
		m_pWTShow = NULL;
	}
	if(m_pCOShow)
	{
		free(m_pCOShow);
		m_pCOShow = NULL;
	}
}

BOOL CSimulationDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)

	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CSimulationDoc serialization

void CSimulationDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
	}
}

/////////////////////////////////////////////////////////////////////////////
// CSimulationDoc diagnostics

#ifdef _DEBUG
void CSimulationDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CSimulationDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CSimulationDoc commands
/*----------------------------------------------------------------------------
function：		从文件中读取数据
parameters：
pDataLen		通过指针传回读取的数据长度
strFileName		文件名字符串
return:			若正确读取则返回指向读取数据的指针，否则返回NULL
author:         唐富华
date:           2004.4.14
-----------------------------------------------------------------------------*/	
unsigned short* CSimulationDoc::ReadDataFromFile(long* pDataLen, CString strFileName)
{
	CFile myFile;
	unsigned short* pData=NULL;
	if(!myFile.Open( strFileName, CFile::modeRead | CFile::typeBinary))
	{
		AfxMessageBox(_T("Could not open the file:")+strFileName);
		return NULL;
	}
	else
	{
		long lFileLen = myFile.GetLength();
		pData = (unsigned short*)malloc(lFileLen);
		if(pData==NULL)
		{
			AfxMessageBox(_T("can't alloc memory when read file:")+strFileName);
			return NULL;
		}
		long len = myFile.ReadHuge(pData,lFileLen);
		myFile.Close();
		long DataLen = lFileLen/sizeof(unsigned short);
		*pDataLen=DataLen;
		return pData;
	}
}

/*----------------------------------------------------------------------------
function：		从数据中获取最大值
parameters：
pData			指向保存有原始数据的指针
DataLen         数据长度
return:			若数据指针不为空则返回最大值，否则返回0
author:         唐富华
date:           2004.4.14
-----------------------------------------------------------------------------*/	
int CSimulationDoc::GetMaxValue(unsigned short* pData,long DataLen)
{
	int MaxValue=0;
	if(pData==NULL)
	{
		AfxMessageBox(_T("the data pointer is NULL!"));
		return 0;
	}

	for(int i=0;i<DataLen;i++)
	{
		if(pData[i]>MaxValue)
			MaxValue=pData[i];
	}
	return MaxValue;
}

int CSimulationDoc::GetMaxValue(int* pData,long DataLen)
{
	int MaxValue=0;
	if(pData==NULL)
	{
		AfxMessageBox(_T("the data pointer is NULL!"));
		return 0;
	}

	for(int i=0;i<DataLen;i++)
	{
		if(pData[i]>MaxValue)
			MaxValue=pData[i];
	}
	return MaxValue;
}

/*----------------------------------------------------------------------------
function：		根据剪力和重力数据生成合力数据
parameters：	无
return:			若数据指针不为空则返回TRUE，否则返回FALSE
author:         唐富华
date:           2004.4.14
-----------------------------------------------------------------------------*/	
BOOL CSimulationDoc::GetCOData()
{
	if(!m_pSRData||!m_pWTData)
	{
		AfxMessageBox(_T("the data pointer is NULL!"));
		return FALSE;
	}

	if(m_SRDataLen>m_WTDataLen)
		m_CODataLen=m_WTDataLen;
	else
		m_CODataLen=m_SRDataLen;

	if(m_pCOData)
		free(m_pCOData);
	m_pCOData = (int*)malloc(m_CODataLen*sizeof(int));
	if(m_pCOData==NULL)
	{
		AfxMessageBox(_T("can't alloc memory when generate composite force"));
		return FALSE;
	}

	for(int i=0;i<m_CODataLen;i++)
	{
		m_pCOData[i]=m_pSRData[i]+m_pWTData[i];
	}
	return TRUE;
}

/*----------------------------------------------------------------------------
function：		根据间隔大小从原始数据中提取显示数据 
parameters：	
pData           指向原始数据的指针
len             原始数据的长度
return:			返回要显示的数据的指针
author:         唐富华
date:           2004.4.30
-----------------------------------------------------------------------------*/	
unsigned short* CSimulationDoc::GetShowData(unsigned short* pData,long len)
{
	if(!pData||len<1)
		return NULL;
	unsigned short* pTemp;
	long datalen=len/m_Interval+1;
	pTemp=(unsigned short*)malloc(datalen*sizeof(unsigned short));
	int m=0;
	for(int k=0;k<len;k++)
	{
		if(k%m_Interval==0)
		{
			pTemp[m]=pData[k];
			m++;
		}
	}
	return pTemp;
}
int* CSimulationDoc::GetShowData(int* pData,long len)
{
	if(!pData||len<1)
		return NULL;
	int* pTemp;
	long datalen=len/m_Interval+1;
	pTemp=(int*)malloc(datalen*sizeof(int));
	int m=0;
	for(int k=0;k<len;k++)
	{
		if(k%m_Interval==0)
		{
			pTemp[m]=pData[k];
			m++;
		}
	}
	return pTemp;
}

/*----------------------------------------------------------------------------
function：		对数组进行排序
parameters：	
pData           数据指针
len             数据长度
return:			无
author:         唐富华
date:           2004.4.16
-----------------------------------------------------------------------------*/	
void CSimulationDoc::Sort(unsigned short* pData,long len)
{
	int k;
	unsigned short t;
	for(int i=0;i<len-1;i++)
	{
		k=i;
		for(int j=i+1;j<len;j++)
		{
			if(pData[j]<pData[k]) k=j;
		}
		t=pData[k];pData[k]=pData[i];pData[i]=t;
	}
}

/*----------------------------------------------------------------------------
function：		窗口大小为5的中值滤波
parameters：	
pData           原始数据指针
len             数据长度
return:			无
author:         唐富华
date:           2004.4.16
-----------------------------------------------------------------------------*/	
void CSimulationDoc::MidValueFilter5(unsigned short* pData,long len)
{
	if(pData == NULL || len <= 0)
		return;
	unsigned short* pTemp;
	pTemp = (unsigned short*)malloc(len*sizeof(unsigned short));
	memcpy(pTemp,pData,len*sizeof(unsigned short));
	unsigned short window[5];
	for(int i=2;i<len-2;i++)
	{
		memcpy(window,pTemp+(i-2),5*sizeof(unsigned short));
		Sort(window,5);
		pData[i]=window[2];
	}
	free(pTemp);
}

/*----------------------------------------------------------------------------
function：		窗口大小为任意奇数的平滑滤波
parameters：	
pData           原始数据指针
len             数据长度
window          平滑窗口大小
return:			无
author:         唐富华
date:           2004.5.26
-----------------------------------------------------------------------------*/	
void CSimulationDoc::SmoothFilter(unsigned short* pData,long len,int window)
{
	if(pData == NULL || len <= 0||window<1)
		return;
	unsigned short* pTemp;
	pTemp = (unsigned short*)malloc(len*sizeof(unsigned short));
	memcpy(pTemp,pData,len*sizeof(unsigned short));
	for(int i=(window-1)/2;i<len-(window-1)/2;i++)
	{
		int sum=0;
		for(int j=-(window-1)/2;j<=(window-1)/2;j++)
		{
			sum+=pTemp[i+j];
		}
		pData[i]=sum/window;
	}
	free(pTemp);
}
void CSimulationDoc::SmoothFilter(int* pData,long len,int window)
{
	if(pData == NULL || len <= 0||window<1)
		return;
	int* pTemp;
	pTemp = (int*)malloc(len*sizeof(int));
	memcpy(pTemp,pData,len*sizeof(int));
	for(int i=(window-1)/2;i<len-(window-1)/2;i++)
	{
		int sum=0;
		for(int j=-(window-1)/2;j<=(window-1)/2;j++)
		{
			sum+=pTemp[i+j];
		}
		pData[i]=sum/window;
	}
	free(pTemp);
}

/*----------------------------------------------------------------------------
function：		按一定的间隔从采集数据缓冲区中提取数据到显示数据缓冲区
parameters：	无
return:			无
author:         唐富华
date:           2004.5.26
-----------------------------------------------------------------------------*/	
void CSimulationDoc::GetShowDataFromBuffer()
{
	int interval=BUFFERREAD_LEN/BUFFERSHOW_LEN;
	
	memset(m_ShowSRBuffer,0,BUFFERSHOW_LEN*sizeof(unsigned short));
	memset(m_ShowWTBuffer,0,BUFFERSHOW_LEN*sizeof(unsigned short));
	memset(m_ShowCOBuffer,0,BUFFERSHOW_LEN*sizeof(int));

	for(int i=0,j=0;i<BUFFERREAD_LEN;i++)
	{
		if(i%interval==0)
		{
			m_ShowSRBuffer[j]=m_ReadSRBuffer[i];
			m_ShowWTBuffer[j]=m_ReadWTBuffer[i];
			m_ShowCOBuffer[j]=m_ShowSRBuffer[j]+m_ShowWTBuffer[j];
			j++;
		}
	}
}
/*----------------------------------------------------------------------------
function：		根据动态分组和标准数据产生模拟数据
parameters：	无
return:			无
author:         唐富华
date:           2004.5.28
-----------------------------------------------------------------------------*/	
void CSimulationDoc::GenerateSimuData()
{

}

/*----------------------------------------------------------------------------
function：		将生成的模拟数据传送给模拟信号发生板，产生模拟信号
parameters：	无
return:			无
author:         唐富华
date:           2004.5.28
-----------------------------------------------------------------------------*/	
void CSimulationDoc::DAConvertion()
{
	//查询模拟数据是否已经产生
	if(!this->m_pSimuCOData||!this->m_pSimuSRData||!this->m_pSimuWTData)
	{
		return;
	}

	//查询模拟信号发生板是否准备就绪


	//将已生成的模拟数据传送给到模拟信号发生板的FIFO
	unsigned short data;
	for(int i=0;i<this->m_SRSimuDataLen;i++)
	{
		//先传送16位的剪力数据
		data = this->m_pSimuSRData[i];
		_asm
		{
			mov ax,data
			mov dx,1004h
			out dx,ax
		}

		//接着传送16位的重力数据
		data=this->m_pSimuWTData[i];
		_asm
		{
			mov ax,data
			mov dx,1004h
			out dx,ax
		}

		//不知是否需要延时

	}

}