.#analyzedata.cpp.1.2

传感器读取程序

#include <windows.h>
#include <stdio.h>

#include "analyzedata.h"
#include "accelerator.h"

/***************************************
函数功能: 分析原始数据,并判断动作.包括:
(1) 将新读出的原始数据写入缓存
(2) 判断动作
***************************************/
void AnalyzeData(HWND hwnd, char *szRawData, int iLength, RAWDATA *rdBuffer, int *pBufPos, FILE *fout)
{
	POINT CurrentPos;

	FillRawDataBuffer(szRawData, rdBuffer, pBufPos);

    //识别画圈动作
	//RecognizeCycle(fout, rdBuffer, (*pBufPos - 1 + BUFFER_SIZE) % BUFFER_SIZE);


	//在FillRawDataBuffer函数里已经将pBufPos位置向前挪了一位,故这里要减一才是刚填充的值
	switch(JudgeAction(hwnd, rdBuffer,(*pBufPos - 1 + BUFFER_SIZE) % BUFFER_SIZE))
	{
	case RIGHT_SINGLE_CLICK:

		GetCursorPos(&CurrentPos);

		PostMessage(hwnd, AM_RBUTTONCLICK, NULL, MAKELPARAM(CurrentPos.x, CurrentPos.y));

		break;

	case LEFT_SINGLE_CLICK:

		GetCursorPos(&CurrentPos);

		PostMessage(hwnd, AM_LBUTTONCLICK, NULL, MAKELPARAM(CurrentPos.x, CurrentPos.y));

		break;

	case LEFT_DOUBLE_CLICK:

		GetCursorPos(&CurrentPos);

		PostMessage(hwnd, AM_LBUTTONDCLICK, NULL, MAKELPARAM(CurrentPos.x, CurrentPos.y));

		break;

	default:
		break;
	}


	

	//WriteDataToFile(fout, szRawData, iLength);

	//ShowDataOnScreen(szRawData, iLength);

}


/***************************************
函数功能: 填充RAWDATA缓存
***************************************/
void FillRawDataBuffer(char *szRawData, RAWDATA *rdBuffer, int *pBufPos)
{
	//这样判断的原因是担心输出错位,之前的读串口就是出的这个问题
	if (szRawData[0] == 'x')
	{
		rdBuffer[*pBufPos].m_x = (int)(unsigned char)szRawData[1];
	}
	else
	{
		MessageBox(NULL, "x错位!", "警告", MB_OK);
	}

	if (szRawData[2] == 'y')
	{
		rdBuffer[*pBufPos].m_y = (int)(unsigned char)szRawData[3];
	}
	else
	{
		MessageBox(NULL, "y错位!", "警告", MB_OK);
	}

	if (szRawData[4] == 'z')
	{
		rdBuffer[*pBufPos].m_z = (int)(unsigned char)szRawData[5];
	}
	else
	{
		MessageBox(NULL, "z错位!", "警告", MB_OK);
	}

	++(*pBufPos);
	if (*pBufPos > BUFFER_SIZE)
	{
		*pBufPos = 0;
	}


}

/***************************************
函数功能: 分析数据判断动作
***************************************/
int JudgeAction(HWND hwnd, RAWDATA *rdBuffer, int iBufPos)
{
	static int ACTION = NOACTION;
	static int iEndPos = -1;
	static bool bCanJudgeLeftSingleClick  = true;
	static bool bCanJudgeLeftDoubleClick  = true;
	static bool bCanJudgeRightSingleClick = true;

	CalculateRight(&bCanJudgeLeftDoubleClick, &bCanJudgeLeftSingleClick, &bCanJudgeRightSingleClick,
		rdBuffer, iBufPos, &iEndPos, &ACTION);

	if (bCanJudgeRightSingleClick && IsRightSingleClick(rdBuffer, iBufPos, &iEndPos, &ACTION)) 
	{
		return RIGHT_SINGLE_CLICK;
	}

	else if (bCanJudgeLeftDoubleClick && IsLeftDoubleClick(rdBuffer, iBufPos, &iEndPos, &ACTION))
	{
		return LEFT_DOUBLE_CLICK;
	}

	else if(bCanJudgeLeftSingleClick && IsLeftSingleClick(rdBuffer, iBufPos, &iEndPos, &ACTION))
	{
		return LEFT_SINGLE_CLICK;
	}

	MouseMove(hwnd, rdBuffer, iBufPos);

	return NOACTION;
}


///////////////////////////////////////////////
///////////////////////////////////////////////


/***************************************
函数功能: 识别画圈动作
***************************************/
void RecognizeCycle(FILE *fout, RAWDATA *rdBuffer,int iBufPos)
{
	//三个方向的分位移
	static int xTotalDisplacement = 0;
	static int yTotalDisplacement = 0;
	static int zTotalDisplacement = 0;

	DisplacementAccumulation(rdBuffer[iBufPos].m_x, rdBuffer[iBufPos].m_y, rdBuffer[iBufPos].m_z,
		&xTotalDisplacement, &yTotalDisplacement, &zTotalDisplacement);

	
	WriteDataToFile(fout, xTotalDisplacement, yTotalDisplacement, zTotalDisplacement);


}



/***************************************
函数功能: 计算累积位移
***************************************/
void DisplacementAccumulation(int xRawdata, int yRawdata, int zRawdata,
							  int *xTotalDisplacement, int *yTotalDisplacement, int *zTotalDisplacement)
{
	static int xBuffer[3] = {0, 0, 0};
	static int yBuffer[3] = {0, 0, 0};
	static int zBuffer[3] = {0, 0, 0};
	static int iCurrentPos = 0;

	//三个方向的分速度
	int xVelocity, yVelocity, zVelocity;

	//三个方向的每个INTERVAL时间内移动的距离
	int xDisplacement, yDisplacement, zDisplacement;

	//前一次的分速度
	static int xLastVelocity = 0;
	static int yLastVelocity = 0;
	static int zLastVelocity = 0;

	xBuffer[iCurrentPos] = xRawdata;
	yBuffer[iCurrentPos] = yRawdata;
	zBuffer[iCurrentPos] = zRawdata;


	if (WhetherAccumulation(xBuffer, yBuffer, zBuffer, iCurrentPos))
	{
		CalculateVelocity(xRawdata, yRawdata, zRawdata,
			&xLastVelocity, &yLastVelocity, &zLastVelocity,
			&xVelocity, &yVelocity, &zVelocity);

		CalculateDisplacement(xRawdata, yRawdata, zRawdata,
			&xLastVelocity, &yLastVelocity, &zLastVelocity,
			&xDisplacement, &yDisplacement, &zDisplacement);

		*xTotalDisplacement += xDisplacement;
		*yTotalDisplacement += yDisplacement;
		*zTotalDisplacement += zDisplacement;

		xLastVelocity = xVelocity;
		yLastVelocity = yVelocity;
		zLastVelocity = zVelocity;

	}
	else
	{
		//*xTotalDisplacement = 0;
		//*yTotalDisplacement = 0;
		//*zTotalDisplacement = 0;

		xLastVelocity = 0;
		yLastVelocity = 0;
		zLastVelocity = 0;
	}

	iCurrentPos = (iCurrentPos + 1) % 3;


}

/***************************************
函数功能: 判断是否需要累加
***************************************/
bool WhetherAccumulation(int *xBuffer, int *yBuffer, int *zBuffer, int iCurrentPos)
{
	int i;
	bool bBetweenValve = false;

	for (i = 0; i < 3; ++i)
	{
		if (xBuffer[i] == 0)
		{
			return false;
		}
		else if (xBuffer[i] <= XSTILLVALUE_MAX && xBuffer[i] >= XSTILLVALUE_MIN)
		{
			bBetweenValve = true;
		}
		else if (xBuffer[i] > XSTILLVALUE_MAX || xBuffer[i] < XSTILLVALUE_MIN)
		{
			bBetweenValve = false;
			break;
		}
	}
	if (bBetweenValve)
	{
		return false;
	}

	for (i = 0; i < 3; ++i)
	{
		if (yBuffer[i] == 0)
		{
			return false;
		}
		else if (yBuffer[i] <= YSTILLVALUE_MAX && yBuffer[i] >= YSTILLVALUE_MIN)
		{
			bBetweenValve = true;
		}
		else if (yBuffer[i] > YSTILLVALUE_MAX || yBuffer[i] < YSTILLVALUE_MIN)
		{
			bBetweenValve = false;
			break;
		}
	}
	if (bBetweenValve)
	{
		return false;
	}

	for (i = 0; i < 3; ++i)
	{
		if (zBuffer[i] == 0)
		{
			return false;
		}
		else if (zBuffer[i] <= ZSTILLVALUE_MAX && zBuffer[i] >= ZSTILLVALUE_MIN)
		{
			bBetweenValve = true;
		}
		else if (zBuffer[i] > ZSTILLVALUE_MAX || zBuffer[i] < ZSTILLVALUE_MIN)
		{
			bBetweenValve = false;
			break;
		}
	}
	if (bBetweenValve)
	{
		return false;
	}

	return true;
}

/***************************************
函数功能: 计算速度
***************************************/
void CalculateVelocity(int xRawdata, int yRawdata, int zRawdata, 
					   int *xLastVelocity, int *yLastVelocity , int *zLastVelocity,
					   int *xVelocity, int *yVelocity, int *zVelocity)
{
	xRawdata -= XSTILLVALUE;
	yRawdata -= YSTILLVALUE;
	zRawdata -= ZSTILLVALUE;

	*xVelocity = *xLastVelocity + xRawdata * INTERVAL;
	*yVelocity = *yLastVelocity + yRawdata * INTERVAL;
	*zVelocity = *zLastVelocity + zRawdata * INTERVAL;
}

/***************************************
函数功能: 计算位移
***************************************/
void CalculateDisplacement(int xRawdata, int yRawdata, int zRawdata, 
						   int *xLastVelocity, int *yLastVelocity , int *zLastVelocity,
						   int *xDisplacement, int *yDisplacement, int *zDisplacement)
{
	xRawdata -= XSTILLVALUE;
	yRawdata -= YSTILLVALUE;
	zRawdata -= ZSTILLVALUE;

	*xDisplacement = *xLastVelocity * INTERVAL + xRawdata * INTERVAL * INTERVAL / 2;
	*yDisplacement = *yLastVelocity * INTERVAL + yRawdata * INTERVAL * INTERVAL / 2;
	*zDisplacement = *zLastVelocity * INTERVAL + zRawdata * INTERVAL * INTERVAL / 2;
}


///////////////////////////////////////////////
///////////////////////////////////////////////


/***************************************
函数功能: 判断是否有权利计算动作
***************************************/
void CalculateRight(bool *bCanJudgeLeftDoubleClick,
					bool *bCanJudgeLeftSingleClick,
					bool *bCanJudgeRightSingleClick,
					RAWDATA *rdBuffer, int iBufPos, int *iEndPos, int *ACTION)
{
	if (*iEndPos == -1)
	{
		*bCanJudgeLeftDoubleClick = true;
		*bCanJudgeLeftSingleClick = true;
	}
	else
	{
		//一个动作的结束位置为正弦波的阀值附近.例如单击右键动作的波形为先出现波峰再出现波谷的一个
		//周期的正弦波,动作结束位置就是波谷后的最接近阀值的位置
		switch(*ACTION)
		{
		case RIGHT_SINGLE_CLICK:

			if (rdBuffer[iBufPos].m_z <= SINGLE_RIGHT_DOWN_VALVE)
			{
				*iEndPos = iBufPos;
			}

			break;

		case LEFT_DOUBLE_CLICK:

			if (rdBuffer[iBufPos].m_z <= DOUBLE_LEFT_DOWN_VALVE)
			{
				*iEndPos = iBufPos;
			}

			break;

		case LEFT_SINGLE_CLICK:

			if (rdBuffer[iBufPos].m_z >= SINGLE_LEFT_UP_VALVE)
			{
				*iEndPos = iBufPos;
			}

			break;

		default:
			break;
		}

		//判断左键双击
		if ((iBufPos - *iEndPos + BUFFER_SIZE) % BUFFER_SIZE <= DOUBLE_LEFT_LENGTH && 
			*ACTION != LEFT_SINGLE_CLICK)
		{
			*bCanJudgeLeftDoubleClick = false;
		}
		else
			*bCanJudgeLeftDoubleClick = true;
		{
		}

		//判断左键单击
		if ((iBufPos - *iEndPos + BUFFER_SIZE) % BUFFER_SIZE <= SINGLE_LEFT_LENGTH)