.#analyzedata.cpp.1.2

传感器读取程序

		{
			*bCanJudgeLeftSingleClick = false;
		}
		else
		{
			*bCanJudgeLeftSingleClick = true;
		}

		//判断右键单击
		if ((iBufPos - *iEndPos + BUFFER_SIZE) % BUFFER_SIZE <= SINGLE_RIGHT_LENGTH)
		{
			*bCanJudgeRightSingleClick = false;
		}
		else
		{
			*bCanJudgeRightSingleClick = true;
		}

		//如果所有动作都能判断则iEndPos重新置为-1 
		if (*bCanJudgeLeftDoubleClick && *bCanJudgeLeftSingleClick && *bCanJudgeRightSingleClick)
		{
			*iEndPos = -1;
			*ACTION = NOACTION;
		}
	}
}

/***************************************
函数功能: 判断是否为单击右键动作
***************************************/
bool IsRightSingleClick(RAWDATA *rdBuffer, int iBufPos, int *pEndPos, int *ACTION)
{
	int iCurrentPos = (iBufPos - SINGLE_RIGHT_LENGTH + BUFFER_SIZE) % BUFFER_SIZE;

	//还未初始化
	if (rdBuffer[iCurrentPos].m_z == 0)
		return false;

	int iMax = MIN_VALUE;
	int iMin = MAX_VALUE;


	while (iCurrentPos != iBufPos)
	{
		if (rdBuffer[iCurrentPos].m_z >= SINGLE_RIGHT_UP_VALVE && rdBuffer[iCurrentPos].m_z >= iMax)
		{
			iMax = rdBuffer[iCurrentPos].m_z;
		}

		else if (rdBuffer[iCurrentPos].m_z <= SINGLE_RIGHT_DOWN_VALVE && 
			rdBuffer[iCurrentPos].m_z <= iMin &&
			iMax != MIN_VALUE)
		{
			iMin = rdBuffer[iCurrentPos].m_z;
			*pEndPos = iCurrentPos;
		}

		iCurrentPos = (iCurrentPos + 1) % BUFFER_SIZE;
	}

	if (iMin <= SINGLE_RIGHT_DOWN_VALVE && iMax >= SINGLE_RIGHT_UP_VALVE)
	{
		*ACTION = RIGHT_SINGLE_CLICK;
		return true;
	}
	else
	{
		return false;
	}


}

/***************************************
函数功能: 判断是否为双击左键动作
***************************************/
bool IsLeftDoubleClick(RAWDATA *rdBuffer, int iBufPos, int *pEndPos, int *ACTION)
{
	int iCurrentPos = (iBufPos - DOUBLE_LEFT_LENGTH + BUFFER_SIZE) % BUFFER_SIZE;

	//还未初始化
	if (rdBuffer[iCurrentPos].m_z == 0)
		return false;

	int iFirstMax  = MIN_VALUE;
	int iFirstMin  = MAX_VALUE;
	int iSecondMax = MIN_VALUE;
	int iSecondMin = MAX_VALUE;



	while (iCurrentPos != iBufPos)
	{
		if (rdBuffer[iCurrentPos].m_z <= DOUBLE_LEFT_DOWN_VALVE && rdBuffer[iCurrentPos].m_z <= iFirstMin)
		{
			iFirstMin = rdBuffer[iCurrentPos].m_z;
		}

		else if (rdBuffer[iCurrentPos].m_z >= DOUBLE_LEFT_UP_VALVE && 
			rdBuffer[iCurrentPos].m_z >= iFirstMax &&
			iFirstMin != MAX_VALUE)
		{
			iFirstMax = rdBuffer[iCurrentPos].m_z;
		}

		else if (rdBuffer[iCurrentPos].m_z <= DOUBLE_LEFT_DOWN_VALVE &&
			rdBuffer[iCurrentPos].m_z <= iSecondMin &&
			iFirstMax != MIN_VALUE)
		{
			iSecondMin = rdBuffer[iCurrentPos].m_z;
			*pEndPos = iCurrentPos;
		}

		iCurrentPos = (iCurrentPos + 1) % BUFFER_SIZE;
	}

	if (iSecondMin <= DOUBLE_LEFT_DOWN_VALVE)
	{
		*ACTION = LEFT_DOUBLE_CLICK;
		return true;
	}
	else
	{
		return false;
	}

}

/***************************************
函数功能: 判断是否为单击左键动作
***************************************/
bool IsLeftSingleClick(RAWDATA *rdBuffer, int iBufPos, int *pEndPos, int *ACTION)
{
	int iCurrentPos = (iBufPos - SINGLE_LEFT_LENGTH + BUFFER_SIZE) % BUFFER_SIZE;

	//还未初始化
	if (rdBuffer[iCurrentPos].m_z == 0)
		return false;

	int iMax = MIN_VALUE;
	int iMin = MAX_VALUE;


	while (iCurrentPos != iBufPos)
	{
		if (rdBuffer[iCurrentPos].m_z <= SINGLE_LEFT_DOWN_VALVE && rdBuffer[iCurrentPos].m_z <= iMin)
		{
			iMin = rdBuffer[iCurrentPos].m_z;
		}
		
		else if (rdBuffer[iCurrentPos].m_z >= SINGLE_LEFT_UP_VALVE && 
				 rdBuffer[iCurrentPos].m_z >= iMax &&
				 iMin != MAX_VALUE)
		{
			iMax = rdBuffer[iCurrentPos].m_z;
			*pEndPos = iCurrentPos;
		}

		iCurrentPos = (iCurrentPos + 1) % BUFFER_SIZE;
	}

	if (iMin <= SINGLE_LEFT_DOWN_VALVE && iMax >= SINGLE_LEFT_UP_VALVE)
	{
		*ACTION = LEFT_SINGLE_CLICK;
		return true;
	}
	else
	{
		return false;
	}

}

/***************************************
函数功能: 鼠标移动.  包括:
(1)  将原始数据转化为计算位移时用的转化值
(2)  将数据过滤,主要用途是消抖
(3)  获取在x,y轴方向移动的距离
***************************************/
void MouseMove(HWND hwnd, RAWDATA *rdBuffer, int iBufPos)
{
	float xRawAcceleration, yRawAcceleration, zRawAcceleration;

	ConvertRawDateIntoAcceleration(&xRawAcceleration, 
		&yRawAcceleration,
		&zRawAcceleration,
		rdBuffer,
		iBufPos);

	Filter(&xRawAcceleration, &yRawAcceleration, &zRawAcceleration);

	//x,y轴移动的位移
	static float xTotalDistance = 0;
	static float yTotalDistance = 0;

	POINT CurrentPos;
	GetCursorPos(&CurrentPos);

	CurrentPos.x += GetXAxisMovementByPixel(xRawAcceleration, &xTotalDistance,CurrentPos.x);
	CurrentPos.y += GetYAxisMovementByPixel(yRawAcceleration, &yTotalDistance,CurrentPos.y);

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

/***************************************
函数功能: 将原始数据转化为加速度
***************************************/
void ConvertRawDateIntoAcceleration(float *pxAcceleration, float *pyAcceleration, float *pzAcceleration,
									RAWDATA *rdBuffer, int iBufPos)
{
	//将x,y互换,转化为屏幕的x,y轴方向
<<<<<<< analyzedata.cpp
	//Changed by MZH - 2008-4-1(b)
	//*pxAcceleration = (float)(rdBuffer[iBufPos].m_y);
	//*pyAcceleration = (float)(rdBuffer[iBufPos].m_x);
	//*pzAcceleration = (float)(rdBuffer[iBufPos].m_z);
	static FILE* dp = NULL;
	if (dp == NULL)
	{
		dp = fopen("dataprocess.txt","w");
	}
	//*pxAcceleration = ((float)rdBuffer[iBufPos].m_y) * range / ((float)dac) + expX;
	//*pyAcceleration = ((float)rdBuffer[iBufPos].m_x) * range / ((float)dac) + expY;
	//*pzAcceleration = ((float)rdBuffer[iBufPos].m_z) * range / ((float)dac);

		// 计算输出电压,每个轴的数值转换线性化模型，由在静止状态下测重力加速度后的电压输出最值确定
	// 具体最大最小电压输出，见MMA7260Q的datasheet
	float fXVoltage = fAX * ((float) rdBuffer[iBufPos].m_x) + fBX;
	float fYVoltage = fAY * ((float) rdBuffer[iBufPos].m_y) + fBY;
	float fZVoltage = fAZ * ((float) rdBuffer[iBufPos].m_z) + fBZ;

	
	// 根据MMA7260Q的datasheet中的公式: Vout = Voff + (Sensitivity * a),(UNIT: /g)
	*pxAcceleration = (fXVoltage - fVOFF) * g / SEN;
	*pyAcceleration = (fYVoltage - fVOFF) * g / SEN;
	*pzAcceleration = (fZVoltage - fVOFF) * g / SEN;

	fprintf(dp,"%f \t%f\t%f\n",*pxAcceleration, *pyAcceleration, *pzAcceleration);
	//Changed by MZH - 2008-4-1(e)
=======
	*pxAcceleration = (float)(rdBuffer[iBufPos].m_y);
	*pyAcceleration = (float)(rdBuffer[iBufPos].m_x);
	*pzAcceleration = (float)(rdBuffer[iBufPos].m_z);
>>>>>>> 1.2
}

/***************************************
函数功能: 将数据过滤,主要用途是消抖
***************************************/
void Filter(float *xAcceleration, float *yAcceleration, float *zAcceleration)
{
		//计算出x,y轴方向的相对速度,XSTILLVLUE和YSTILLVALUE是统计值,DIV是经验值
		//if是用来消抖,数据是统计值
		if (*xAcceleration <= XSTILLVALUE_MAX && *xAcceleration >= XSTILLVALUE_MIN)
		{
			*xAcceleration = 0;
		}
		else
		{
			*xAcceleration = (*xAcceleration - XSTILLVALUE) / XDIV;
		}

		if (*yAcceleration <= YSTILLVALUE_MAX && *yAcceleration >= YSTILLVALUE_MIN)
		{
			*yAcceleration = 0;
		}
		else
		{	
			*yAcceleration = (*yAcceleration - YSTILLVALUE) / YDIV;
		}

		if (*zAcceleration <= ZSTILLVALUE_MAX && *zAcceleration >= ZSTILLVALUE_MIN)
		{
			*zAcceleration = 0;
		}
		else
		{	
			*zAcceleration = (*zAcceleration - ZSTILLVALUE) / ZDIV;
		}

		*xAcceleration = -(*xAcceleration);
		*yAcceleration = -(*yAcceleration);

}


/***************************************
函数功能: 计算x轴方向移动的像素点
***************************************/
int GetXAxisMovementByPixel(float xAcceleration, float *xTotalDistance, int iCurrentXPos)
{
	float xDistance = xAcceleration * INTERVAL;
	*xTotalDistance += xDistance;

	if (abs(*xTotalDistance) >= 1.0)
	{
		//首先要判断是否移动到屏幕外
		if ((iCurrentXPos + (int)*xTotalDistance <= 0) ||
			(iCurrentXPos + (int)*xTotalDistance >= GetSystemMetrics(SM_CXSCREEN)))
		{
			*xTotalDistance = 0;
			return 0;
		}
		else
		{
			xDistance = *xTotalDistance;
			*xTotalDistance = 0;
			return (int)xDistance;
		}
	}
	else
	{
		return 0;
	}
}

/***************************************
函数功能: 计算y轴方向移动的像素点
***************************************/
int GetYAxisMovementByPixel(float yAcceleration, float *yTotalDistance, int iCurrentYPos)
{
	float yDistance = yAcceleration * INTERVAL;
	*yTotalDistance += yDistance;

	if (abs(*yTotalDistance) >= 1.0)
	{
		//首先要判断是否移动到屏幕外
		if ((iCurrentYPos + (int)*yTotalDistance <= 0) ||
			 (iCurrentYPos + (int)*yTotalDistance >= GetSystemMetrics(SM_CYSCREEN)))
		{
			*yTotalDistance = 0;
			return 0;
		}
		else
		{
			yDistance = *yTotalDistance;
			*yTotalDistance = 0;
			return (int)yDistance;
		}
	}
	else
	{
		return 0;
	}
}

/***************************************
函数功能: 将数据写入文件,用于分析
***************************************/
//void WriteDataToFile(FILE *fout, char *szRawData, int iLength)
//{
//	static int oldz = 194;
//	static int oldy = 136;
//
//	fprintf(fout, "%c \t %d \t\t %c \t %d \t %d \t\t %c \t %d \t %d \n ",
//		szRawData[0], (int)(unsigned char)szRawData[1],
//		szRawData[2], (int)(unsigned char)szRawData[3],
//		(int)(unsigned char)szRawData[3] - oldy,
//		szRawData[4], (int)(unsigned char)szRawData[5],
//		(int)(unsigned char)szRawData[5] - oldz);
//
//	oldy = (int)(unsigned char)szRawData[3];
//
//	oldz = (int)(unsigned char)szRawData[5];
//}
void WriteDataToFile(FILE *fout, int xDisplacement, int yDisplacement, int zDisplacement)
{
	fprintf(fout, "%d \t %d \t %d \n", xDisplacement, yDisplacement, zDisplacement);
}

/***************************************
函数功能: 将数据显示在屏幕,用于分析
***************************************/
void ShowDataOnScreen(char *szRawData, int iLength)
{
	//const int iScreenWidth = GetSystemMetrics(SM_CXFULLSCREEN);
	static DRAWONSCREEN dsBuffer[1000];
	static int xPos = 0;

	dsBuffer[xPos].m_x = (int)(unsigned char)szRawData[1];
	dsBuffer[xPos].m_y = (int)(unsigned char)szRawData[3];
	dsBuffer[xPos].m_z = (int)(unsigned char)szRawData[5];


	HDC hdc = GetWindowDC(NULL);

	SetPixel(hdc,xPos, 100 + dsBuffer[xPos].m_x, RGB(255, 126, 34));

	SetPixel(hdc,xPos, 300 + dsBuffer[xPos].m_x, RGB(0, 126, 255));

	SetPixel(hdc,xPos++, 500 + dsBuffer[xPos].m_x, RGB(158, 0, 34));

	if (xPos > 1000)
	{
		xPos = 0;
	}

	ReleaseDC(NULL, hdc);
}