基于Kinect体感器控制的机械臂项目记录

已于 2022-09-14 16:23:41 修改
阅读量1.1k 收藏 15
点赞数 4
分类专栏： 笔记 文章标签： c++ 开发语言 嵌入式硬件
于 2022-09-14 16:17:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kyleeeeeeeeee/article/details/126851545
版权

基于Kinect体感器控制的机械臂

项目介绍

研究生新生开学，偷得两日闲，记录一下本科期间自己参与的一个项目。本f项目是在实验室的人型机器人的基础上进行的创新性开发。硬件部分为Kinect二代体感器，多自由度桌面小型机械臂两部分。软件同样分为两部分。本人主要负责上位机的代码。

上位机代码说明

上位机代码可以分为识别和发送两部分：

  1. 识别部分：调用了Kinect体感器的API进行人体骨架识别并获骨骼点坐标。
  2. 发送部分：该部分使用了蓝牙串口通讯。

1.识别部分

1.1GetPosition.cpp

这部分代码是直接与下位机进行通讯，主要思路是，先对桌面机械臂每舵机进行编号，同时对一条手臂上的关节点与舵机对应。在发送关节角度时，先对计算所得角度的合理性进行判断。通讯格式是以舵机编号开头，后接关节角度，存为字符型数组。

//   
///   
/// @file    GetPosition.cpp    
///   
///  
/// 本文件为获取骨骼坐标并输出角度的实现代码  

/// @author:  KC     
/// @date :   2020/10/27
///   
///   
//  


#include"pch.h"
#include<iostream>
#include<windows.h>
#include<kinect.h>
#include<DirectXMath.h>
#include"SerialPort.h"
#include"kinectJointFilter.h"

using namespace std;
using namespace Sample;
using namespace DirectX;


template <class Interface> //释放指针模板类
inline void SafeRelease(Interface *& pInterfaceToRelease)
{
	if (pInterfaceToRelease)
	{
		pInterfaceToRelease->Release();
		pInterfaceToRelease = NULL;
	}
}

/*角度计算*/
FLOAT Angle(const DirectX::XMVECTOR* vec, JointType jointA, JointType jointB, JointType jointC)
{
	float angle = 0.0f;

	XMVECTOR vBA = XMVectorSubtract(vec[jointB], vec[jointA]);
	XMVECTOR vBC = XMVectorSubtract(vec[jointB], vec[jointC]);

	XMVECTOR vAngle = XMVector3AngleBetweenVectors(vBA, vBC);

	angle = XMVectorGetX(vAngle) * 180.0 * XM_1DIVPI;    // XM_1DIVPI: An optimal representation of 1 / π

	return angle;
}

/*串口发送*/
void PortSend(int flag, int t)
{
	char aa[15] = "#001";
	CSerialPort mySerialPort;
	if (!mySerialPort.InitPort(7))
	{
		cout << "initPort fail !" << endl;
	}
	else
	{
		cout << "initPort success !" << endl;
	}

	if (!mySerialPort.OpenListenThread())
	{
		cout << "OpenListenThread fail !" << endl;
	}
	else
	{
		cout << "OpenListenThread success !" << endl;
	}
	if (flag == 1)
	{
		char aa[15] = "#001P";
		aa[5] = (char)('0' + (t / 1000));
		aa[6] = (char)('0' + (t % 1000) / 100);
		aa[7] = (char)('0' + (t % 100) / 10);
		aa[8] = (char)('0' + (t % 10));
		aa[9] = 'T';
		aa[10] = '1';
		aa[11] = '0';
		aa[12] = '0';
		aa[13] = '0';
		aa[14] = '!';
		mySerialPort.WriteData((unsigned char *)&aa, 15);
	}
	else if (flag == 2)
	{
		char aa[15] = "#002P";
		aa[5] = (char)('0' + (t / 1000));
		aa[6] = (char)('0' + (t % 1000) / 100);
		aa[7] = (char)('0' + (t % 100) / 10);
		aa[8] = (char)('0' + (t % 10));
		aa[9] = 'T';
		aa[10] = '1';
		aa[11] = '0';
		aa[12] = '0';
		aa[13] = '0';
		aa[14] = '!';
		mySerialPort.WriteData((unsigned char *)&aa, 15);
	}
	else if (flag == 3)
	{
		char aa[15] = "#003P";
		aa[5] = (char)('0' + (t / 1000));
		aa[6] = (char)('0' + (t % 1000) / 100);
		aa[7] = (char)('0' + (t % 100) / 10);
		aa[8] = (char)('0' + (t % 10));
		aa[9] = 'T';
		aa[10] = '1';
		aa[11] = '0';
		aa[12] = '0';
		aa[13] = '0';
		aa[14] = '!';
		mySerialPort.WriteData((unsigned char *)&aa, 15);
	}
	else if (flag == 4)
	{
		char aa[15] = "#004P";
		aa[5] = (char)('0' + (t / 1000));
		aa[6] = (char)('0' + (t % 1000) / 100);
		aa[7] = (char)('0' + (t % 100) / 10);
		aa[8] = (char)('0' + (t % 10));
		aa[9] = 'T';
		aa[10] = '1';
		aa[11] = '0';
		aa[12] = '0';
		aa[13] = '0';
		aa[14] = '!';
		mySerialPort.WriteData((unsigned char *)&aa, 15);
	}
}

void delay(float x)
{
	LARGE_INTEGER litmp;

	LONGLONG QPart1, QPart2;

	double dfMinus, dfFreq, dfTim;

	QueryPerformanceFrequency(&litmp);

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

	QueryPerformanceCounter(&litmp);

	QPart1 = litmp.QuadPart;// 获得初始值

	do
	{
		QueryPerformanceCounter(&litmp);

		QPart2 = litmp.QuadPart;//获得中止值

		dfMinus = (double)(QPart2 - QPart1);

		dfTim = dfMinus / dfFreq;// 获得对应的时间值，单位为秒

	} while (dfTim < x);
}

// output operator for CameraSpacePoint
ostream& operator<<(ostream& rOS, const CameraSpacePoint& rPos)
{
	rOS << "(" << rPos.X << "/" << rPos.Y << "/" << rPos.Z << ")";
	return rOS;
}
// output operator for Vector4
ostream& operator<<(ostream& rOS, const Vector4& rVec)
{
	rOS << "(" << rVec.x << "/" << rVec.y << "/" << rVec.z << "/" << rVec.w << ")";
	return rOS;
}

int main(int argc, char** argv[])
{
	// 1a. Get default Sensor
	cout << "Try to get default sensor" << endl;
	IKinectSensor* pSensor = nullptr;
	if (GetDefaultKinectSensor(&pSensor) != S_OK)
	{
		cerr << "Get Sensor failed" << endl;
		return -1;
	}

	// 1b. Open sensor
	cout << "Try to open sensor" << endl;
	if (pSensor->Open() != S_OK)
	{
		cerr << "Can't open sensor" << endl;
		return -1;
	}

	// 2a. Get frame source
	cout << "Try to get body source" << endl;
	IBodyFrameSource* pFrameSource = nullptr;
	if (pSensor->get_BodyFrameSource(&pFrameSource) != S_OK)
	{
		cerr << "Can't get body frame source" << endl;
		return -1;
	}

	// 2b. Get the number of body
	INT32 iBodyCount = 0;
	if (pFrameSource->get_BodyCount(&iBodyCount) != S_OK)
	{
		cerr << "Can't get body count" << endl;
		return -1;
	}
	cout << " > Can trace " << iBodyCount << " bodies" << endl;
	IBody** aBody = new IBody*[iBodyCount];
	for (int i = 0; i < iBodyCount; ++i)
		aBody[i] = nullptr;

	// 3a. get frame reader
	cout << "Try to get body frame reader" << endl;
	IBodyFrameReader* pFrameReader = nullptr;
	if (pFrameSource->OpenReader(&pFrameReader) != S_OK)
	{
		cerr << "Can't get body frame reader" << endl;
		return -1;
	}

	/******************************************************************************/
	/*holt双指数滤波器*/
	FilterDoubleExponential filter[BODY_COUNT];

	// 设置平滑参数
	for (int count = 0; count < iBodyCount; count++)
	{
		float smoothing = 0.25f;          // [0..1], lower values closer to raw data
		float correction = 0.25f;         // [0..1], lower values slower to correct towards the raw data
		float prediction = 0.25f;         // [0..n], the number of frames to predict into the future
		float jitterRadius = 0.03f;       // The radius in meters for jitter reduction
		float maxDeviationRadius = 0.05f; // The maximum radius in meters that filtered positions are allowed to deviate from raw data

		filter[count].Init(smoothing, correction, prediction, jitterRadius, maxDeviationRadius);
	}

	// 2b. release Frame source
	cout << "Release frame source" << endl;
	SafeRelease(pFrameSource);

	// Enter main loop
	int iStep = 0;
	while (iStep < 10000)
	{
		// 4a. Get last frame
		IBodyFrame* pFrame = nullptr;
		if (pFrameReader->AcquireLatestFrame(&pFrame) == S_OK)
		{
			++iStep;

			// 4b. get Body data
			if (pFrame->GetAndRefreshBodyData(iBodyCount, aBody) == S_OK)
			{
				int iTrackedBodyCount = 0;

				// 4c. for each body
				for (int i = 0; i < iBodyCount; i++)
				{
					IBody* pBody = aBody[i];

					// check if is tracked
					BOOLEAN bTracked = false;
					if ((pBody->get_IsTracked(&bTracked) == S_OK) && bTracked)
					{
						++iTrackedBodyCount;
						cout << "User " << i << " is under tracking" << endl;

						// get joint position
						Joint aJoints[JointType::JointType_Count];
						if (pBody->GetJoints(JointType::JointType_Count, aJoints) != S_OK)
						{
							cerr << "Get joints fail" << endl;
						}

						// get joint orientation
						JointOrientation aOrientations[JointType::JointType_Count];
						if (pBody->GetJointOrientations(JointType::JointType_Count, aOrientations) != S_OK)
						{
							cerr << "Get joints fail" << endl;
						}

						// 滤波接口
						filter[i].Update(aJoints);
						const DirectX::XMVECTOR* vec_1 = filter[i].GetFilteredJoints();//肘关节角度
						const DirectX::XMVECTOR* vec_2 = filter[i].GetFilteredJoints();//肩关节角度
						const DirectX::XMVECTOR* vec_3 = filter[i].GetFilteredJoints();//右手平动角

						//输出坐标
						/*右腕*/
						JointType WristRightJointType = JointType::JointType_WristRight;
						const Joint& WristRightJointPos = aJoints[WristRightJointType];
						const JointOrientation& WristRightJointOri = aOrientations[WristRightJointType];
						cout << " > WristRight is ";
						if (WristRightJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}
						if (WristRightJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}
						else
						{
							if (WristRightJointPos.TrackingState == TrackingState_Inferred)
							{
								cout << "inferred ";
							}
							else if (WristRightJointPos.TrackingState == TrackingState_Tracked)
							{
								cout << "tracked ";
							}
							cout << "at" << WristRightJointPos.Position << endl;
						}

						/*右肩*/
						JointType ShoulderRightJointType = JointType::JointType_ShoulderRight;
						const Joint& ShoulderRightJointPos = aJoints[ShoulderRightJointType];
						const JointOrientation& ShoulderRightJointOri = aOrientations[ShoulderRightJointType];

						cout << " > ShoulderRight is ";
						if (ShoulderRightJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						if (ShoulderRightJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						else
						{
							if (ShoulderRightJointPos.TrackingState == TrackingState_Inferred)
							{
								cout << "inferred ";
							}
							else if (ShoulderRightJointPos.TrackingState == TrackingState_Tracked)
							{
								cout << "tracked ";
							}

							cout << "at " << ShoulderRightJointPos.Position << endl;
						}
						/*右肘*/
						JointType ElbowRightJointType = JointType::JointType_ElbowRight;
						const Joint& ElbowRightJointPos = aJoints[ElbowRightJointType];
						const JointOrientation& ElbowRightJointOri = aOrientations[ElbowRightJointType];

						cout << " > ElbowRight is ";
						if (ElbowRightJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						if (ElbowRightJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						else
						{
							if (ElbowRightJointPos.TrackingState == TrackingState_Inferred)
							{
								cout << "inferred ";
							}
							else if (ElbowRightJointPos.TrackingState == TrackingState_Tracked)
							{
								cout << "tracked ";
							}

							cout << "at " << ElbowRightJointPos.Position << endl;
						}	

						/*左肘*/
						JointType ElbowLeftightJointType = JointType::JointType_ElbowLeft;
						const Joint& ElbowLeftJointPos = aJoints[ElbowLeftightJointType];
						const JointOrientation& ElbowLeftJointOri = aOrientations[ElbowLeftightJointType];

						cout << " > ElbowLeft is ";
						if (ElbowLeftJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						if (ElbowLeftJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						else
						{
							if (ElbowLeftJointPos.TrackingState == TrackingState_Inferred)
							{
								cout << "inferred ";
							}
							else if (ElbowLeftJointPos.TrackingState == TrackingState_Tracked)
							{
								cout << "tracked ";
							}

							cout << "at " << ElbowLeftJointPos.Position << endl;
						}

						/*左肩*/
						JointType ShoulderLeftJointType = JointType::JointType_ShoulderRight;
						const Joint& ShoulderLeftJointPos = aJoints[ShoulderLeftJointType];
						const JointOrientation& ShoulderLeftJointOri = aOrientations[ShoulderLeftJointType];

						cout << " > ShoulderRight is ";
						if (ShoulderLeftJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						if (ShoulderLeftJointPos.TrackingState == TrackingState_NotTracked)
						{
							cout << "not tracked" << endl;
						}

						else
						{
							if (ShoulderLeftJointPos.TrackingState == TrackingState_Inferred)
							{
								cout << "inferred ";
							}
							else if (ShoulderLeftJointPos.TrackingState == TrackingState_Tracked)
							{
								cout << "tracked ";
							}

							cout << "at " << ShoulderLeftJointPos.Position << endl;
						}


						/*计算角度*/
						/*肘*/
						int AngleForRightElbow = Angle(vec_1, JointType_WristRight, JointType_ElbowRight, JointType_ShoulderRight);
						/*肩*/
						int AngleForRightShoulder = Angle(vec_2, JointType_ElbowRight, JointType_ShoulderRight, JointType_ShoulderLeft);
						/*右手平动*/
						int Angle1_3 = Angle(vec_3, JointType_ElbowLeft, JointType_ShoulderLeft, JointType_ShoulderRight);


						/*显示与发送*/
						int P = 0;
						if ((AngleForRightElbow) && (AngleForRightElbow <= 180))
						{
							P = AngleForRightElbow * 11.1;
							P = P + 500;
							cout << "右手肘的角度：" << AngleForRightElbow << endl;
							cout << "对应舵机参数：" << P << endl;
							PortSend(3, P);
							Sleep(50);
							P = 0;
						}
						if ((AngleForRightShoulder) && (AngleForRightShoulder <= 180))
						{
							P = AngleForRightShoulder * 11.1;
							P = P + 500;
							cout << "右肩膀的角度：" << AngleForRightShoulder << endl;
							cout << "对应舵机参数：" << P << endl;
							PortSend(2, P);
							Sleep(50);
							P = 0;
						}
						if ((Angle1_3) && (Angle1_3 <= 180))
						{
							P = Angle1_3 * 11.1;
							P = P + 500;
							cout << "左手平动的角度：" << Angle1_3 << endl;
							cout << "对应舵机参数：" << P << endl;
							PortSend(1, P);
							Sleep(80);
							P = 0;
						}
					}
				}
				if (iTrackedBodyCount > 0)
					cout << "Total " << iTrackedBodyCount << " bodies in this time\n" << endl;
			}
			else
			{
				cerr << "Can't read body data" << endl;
			}
			// 4e. release frame
			SafeRelease(pFrame);
		}

	}
	// delete body data array
	delete[] aBody;

	// 3b. release frame reader
	cout << "Release frame reader" << endl;
	SafeRelease(pFrameReader);


	// 1c. Close Sensor
	cout << "close sensor" << endl;
	pSensor->Close();

	// 1d. Release Sensor
	cout << "Release sensor" << endl;
	SafeRelease(pSensor);

	return 0;
}

1.2 KinetJiointFilter.cpp

对骨骼点的坐标进行平滑滤波，减少出现数据急剧变化的情况。


#include "pch.h"
#include "KinectJointFilter.h"

using namespace Sample;
using namespace DirectX;

/* 两个浮点间的线性插值*/
inline FLOAT Lerp(FLOAT f1, FLOAT f2, FLOAT fBlend)
{
	return f1 + (f2 - f1) * fBlend;
}


// if joint is 0 it is not valid.
inline BOOL JointPositionIsValid(XMVECTOR vJointPosition)
{
	return (XMVectorGetX(vJointPosition) != 0.0f ||
		XMVectorGetY(vJointPosition) != 0.0f ||
		XMVectorGetZ(vJointPosition) != 0.0f);
}
/* Holt双指数平滑滤波器的实现双指数*/

void FilterDoubleExponential::Update(IBody* const pBody)
{
	assert(pBody);

	// Check for divide by zero. Use an epsilon of a 10th of a millimeter
	m_fJitterRadius = XMMax(0.0001f, m_fJitterRadius);

	TRANSFORM_SMOOTH_PARAMETERS SmoothingParams;

	UINT jointCapacity = 0;
	Joint joints[JointType_Count];

	pBody->GetJoints(jointCapacity, joints);
	for (INT i = 0; i < JointType_Count; i++)
	{
		SmoothingParams.fSmoothing = m_fSmoothing;
		SmoothingParams.fCorrection = m_fCorrection;
		SmoothingParams.fPrediction = m_fPrediction;
		SmoothingParams.fJitterRadius = m_fJitterRadius;
		SmoothingParams.fMaxDeviationRadius = m_fMaxDeviationRadius;

		// If inferred, we smooth a bit more by using a bigger jitter radius
		Joint joint = joints[i];
		if (joint.TrackingState == TrackingState::TrackingState_Inferred)
		{
			SmoothingParams.fJitterRadius *= 2.0f;
			SmoothingParams.fMaxDeviationRadius *= 2.0f;
		}

		Update(joints, i, SmoothingParams);
	}
}

void FilterDoubleExponential::Update(Joint joints[])
{
	// Check for divide by zero. Use an epsilon of a 10th of a millimeter
	m_fJitterRadius = XMMax(0.0001f, m_fJitterRadius);

	TRANSFORM_SMOOTH_PARAMETERS SmoothingParams;
	for (INT i = 0; i < JointType_Count; i++)
	{
		SmoothingParams.fSmoothing = m_fSmoothing;
		SmoothingParams.fCorrection = m_fCorrection;
		SmoothingParams.fPrediction = m_fPrediction;
		SmoothingParams.fJitterRadius = m_fJitterRadius;
		SmoothingParams.fMaxDeviationRadius = m_fMaxDeviationRadius;

		// If inferred, we smooth a bit more by using a bigger jitter radius
		Joint joint = joints[i];
		if (joint.TrackingState == TrackingState::TrackingState_Inferred)
		{
			SmoothingParams.fJitterRadius *= 2.0f;
			SmoothingParams.fMaxDeviationRadius *= 2.0f;
		}

		Update(joints, i, SmoothingParams);
	}

}

void FilterDoubleExponential::Update(Joint joints[], UINT JointID, TRANSFORM_SMOOTH_PARAMETERS smoothingParams)
{
	XMVECTOR vPrevRawPosition;
	XMVECTOR vPrevFilteredPosition;
	XMVECTOR vPrevTrend;
	XMVECTOR vRawPosition;
	XMVECTOR vFilteredPosition;
	XMVECTOR vPredictedPosition;
	XMVECTOR vDiff;
	XMVECTOR vTrend;
	XMVECTOR vLength;
	FLOAT fDiff;
	BOOL bJointIsValid;

	const Joint joint = joints[JointID];

	vRawPosition = XMVectorSet(joint.Position.X, joint.Position.Y, joint.Position.Z, 0.0f);
	vPrevFilteredPosition = m_pHistory[JointID].m_vFilteredPosition;
	vPrevTrend = m_pHistory[JointID].m_vTrend;
	vPrevRawPosition = m_pHistory[JointID].m_vRawPosition;
	bJointIsValid = JointPositionIsValid(vRawPosition);

	// If joint is invalid, reset the filter
	if (!bJointIsValid)
	{
		m_pHistory[JointID].m_dwFrameCount = 0;
	}

	// Initial start values
	if (m_pHistory[JointID].m_dwFrameCount == 0)
	{
		vFilteredPosition = vRawPosition;
		vTrend = XMVectorZero();
		m_pHistory[JointID].m_dwFrameCount++;
	}
	else if (m_pHistory[JointID].m_dwFrameCount == 1)
	{
		vFilteredPosition = XMVectorScale(XMVectorAdd(vRawPosition, vPrevRawPosition), 0.5f);
		vDiff = XMVectorSubtract(vFilteredPosition, vPrevFilteredPosition);
		vTrend = XMVectorAdd(XMVectorScale(vDiff, smoothingParams.fCorrection), XMVectorScale(vPrevTrend, 1.0f - smoothingParams.fCorrection));
		m_pHistory[JointID].m_dwFrameCount++;
	}
	else
	{
		// First apply jitter filter
		vDiff = XMVectorSubtract(vRawPosition, vPrevFilteredPosition);
		vLength = XMVector3Length(vDiff);
		fDiff = fabs(XMVectorGetX(vLength));

		if (fDiff <= smoothingParams.fJitterRadius)
		{
			vFilteredPosition = XMVectorAdd(XMVectorScale(vRawPosition, fDiff / smoothingParams.fJitterRadius),
				XMVectorScale(vPrevFilteredPosition, 1.0f - fDiff / smoothingParams.fJitterRadius));
		}
		else
		{
			vFilteredPosition = vRawPosition;
		}

		// Now the double exponential smoothing filter
		vFilteredPosition = XMVectorAdd(XMVectorScale(vFilteredPosition, 1.0f - smoothingParams.fSmoothing),
			XMVectorScale(XMVectorAdd(vPrevFilteredPosition, vPrevTrend), smoothingParams.fSmoothing));


		vDiff = XMVectorSubtract(vFilteredPosition, vPrevFilteredPosition);
		vTrend = XMVectorAdd(XMVectorScale(vDiff, smoothingParams.fCorrection), XMVectorScale(vPrevTrend, 1.0f - smoothingParams.fCorrection));
	}

	// Predict into the future to reduce latency
	vPredictedPosition = XMVectorAdd(vFilteredPosition, XMVectorScale(vTrend, smoothingParams.fPrediction));

	// Check that we are not too far away from raw data
	vDiff = XMVectorSubtract(vPredictedPosition, vRawPosition);
	vLength = XMVector3Length(vDiff);
	fDiff = fabs(XMVectorGetX(vLength));

	if (fDiff > smoothingParams.fMaxDeviationRadius)
	{
		vPredictedPosition = XMVectorAdd(XMVectorScale(vPredictedPosition, smoothingParams.fMaxDeviationRadius / fDiff),
			XMVectorScale(vRawPosition, 1.0f - smoothingParams.fMaxDeviationRadius / fDiff));
	}

	// Save the data from this frame
	m_pHistory[JointID].m_vRawPosition = vRawPosition;
	m_pHistory[JointID].m_vFilteredPosition = vFilteredPosition;
	m_pHistory[JointID].m_vTrend = vTrend;

	// Output the data
	m_pFilteredJoints[JointID] = vPredictedPosition;
	m_pFilteredJoints[JointID] = XMVectorSetW(m_pFilteredJoints[JointID], 1.0f);
}

1.3

这里是使用了别人的串并口通信类（作者信息见代码块）

//  
/// COPYRIGHT NOTICE  
/// Copyright (c) 2009, 华中科技大学tickTick Group  （版权声明）  
/// All rights reserved.  
///   
/// @file    SerialPort.cpp    
/// @brief   串口通信类的实现文件  
///  
/// 本文件为串口通信类的实现代码  
///  
/// @version 1.0     
/// @author  卢俊    
/// @E-mail：lujun.hust@gmail.com  
/// @date    2010/03/19  
///   
///  
///  修订说明：  
//  


#include "pch.h"
#include "SerialPort.h"  
#include <process.h>  
#include <iostream>  

/** 线程退出标志 */
bool CSerialPort::s_bExit = false;
/** 当串口无数据时,sleep至下次查询间隔的时间,单位:秒 */
const UINT SLEEP_TIME_INTERVAL = 5;

CSerialPort::CSerialPort(void)
	: m_hListenThread(INVALID_HANDLE_VALUE)
{
	m_hComm = INVALID_HANDLE_VALUE;
	m_hListenThread = INVALID_HANDLE_VALUE;

	InitializeCriticalSection(&m_csCommunicationSync);
	//std::cout << "Hello World1";
}

CSerialPort::~CSerialPort(void)
{
	CloseListenTread();
	ClosePort();
	DeleteCriticalSection(&m_csCommunicationSync);
	//std::cout << "Hello World2";
}

bool CSerialPort::InitPort(UINT portNo/*= 1*/, UINT baud /*= CBR_9600*/, char parity /*= 'N'*/,
	UINT databits /*= 8*/, UINT stopsbits/*= 1*/, DWORD dwCommEvents /*= EV_RXCHAR*/)
{
	
	/** 临时变量,将制定参数转化为字符串形式,以构造DCB结构 */
	char szDCBparam[50];
	sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopsbits);
	
	/** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
	if (!openPort(portNo))
	{
		return false;
	}

	/** 进入临界段 */
	EnterCriticalSection(&m_csCommunicationSync);

	/** 是否有错误发生 */
	BOOL bIsSuccess = TRUE;

	/** 在此可以设置输入输出的缓冲区大小,如果不设置,则系统会设置默认值.
	*  自己设置缓冲区大小时,要注意设置稍大一些,避免缓冲区溢出
	*/
	/*if (bIsSuccess )
	{
	bIsSuccess = SetupComm(m_hComm,10,10);
	}*/

	/** 设置串口的超时时间,均设为0,表示不使用超时限制 */
	COMMTIMEOUTS  CommTimeouts;
	CommTimeouts.ReadIntervalTimeout = 0;
	CommTimeouts.ReadTotalTimeoutMultiplier = 0;
	CommTimeouts.ReadTotalTimeoutConstant = 0;
	CommTimeouts.WriteTotalTimeoutMultiplier = 0;
	CommTimeouts.WriteTotalTimeoutConstant = 0;
	if (bIsSuccess)
	{
		bIsSuccess = SetCommTimeouts(m_hComm, &CommTimeouts);
	}

	DCB  dcb;
	if (bIsSuccess)
	{
		// 将ANSI字符串转换为UNICODE字符串  
		DWORD dwNum = MultiByteToWideChar(CP_ACP, 0, szDCBparam, -1, NULL, 0);
		wchar_t *pwText = new wchar_t[dwNum];
		if (!MultiByteToWideChar(CP_ACP, 0, szDCBparam, -1, pwText, dwNum))
		{
			bIsSuccess = TRUE;
		}

		/** 获取当前串口配置参数,并且构造串口DCB参数 */
		bIsSuccess = GetCommState(m_hComm, &dcb) && BuildCommDCB(pwText, &dcb);
		/** 开启RTS flow控制 */
		dcb.fRtsControl = RTS_CONTROL_ENABLE;

		/** 释放内存空间 */
		delete[] pwText;
	}

	if (bIsSuccess)
	{
		/** 使用DCB参数配置串口状态 */
		bIsSuccess = SetCommState(m_hComm, &dcb);
	}

	/**  清空串口缓冲区 */
	PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
	/** 离开临界段 */
	LeaveCriticalSection(&m_csCommunicationSync);
//std::cout << "Hello World";

	return bIsSuccess == TRUE;
	
	
}

bool CSerialPort::InitPort(UINT portNo, const LPDCB& plDCB)
{
	/** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
	if (!openPort(portNo))
	{
		return false;
	}

	/** 进入临界段 */
	EnterCriticalSection(&m_csCommunicationSync);

	/** 配置串口参数 */
	if (!SetCommState(m_hComm, plDCB))
	{
		return false;
	}

	/**  清空串口缓冲区 */
	PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

	/** 离开临界段 */
	LeaveCriticalSection(&m_csCommunicationSync);

	return true;
}

void CSerialPort::ClosePort()
{
	/** 如果有串口被打开，关闭它 */
	if (m_hComm != INVALID_HANDLE_VALUE)
	{
		CloseHandle(m_hComm);
		m_hComm = INVALID_HANDLE_VALUE;
	}
}

bool CSerialPort::openPort(UINT portNo)
{
	/** 进入临界段 */
	EnterCriticalSection(&m_csCommunicationSync);

	/** 把串口的编号转换为设备名 */
	char szPort[50];
	sprintf_s(szPort, "COM%d", portNo);

	/** 打开指定的串口 */
	m_hComm = CreateFileA(szPort,  /** 设备名,COM1,COM2等 */
		GENERIC_READ | GENERIC_WRITE, /** 访问模式,可同时读写 */
		0,                            /** 共享模式,0表示不共享 */
		NULL,                         /** 安全性设置,一般使用NULL */
		OPEN_EXISTING,                /** 该参数表示设备必须存在,否则创建失败 */
		0,
		0);

	/** 如果打开失败，释放资源并返回 */
	if (m_hComm == INVALID_HANDLE_VALUE)
	{
		LeaveCriticalSection(&m_csCommunicationSync);
		return false;
	}

	/** 退出临界区 */
	LeaveCriticalSection(&m_csCommunicationSync);

	return true;
}

bool CSerialPort::OpenListenThread()
{
	/** 检测线程是否已经开启了 */
	if (m_hListenThread != INVALID_HANDLE_VALUE)
	{
		/** 线程已经开启 */
		return false;
	}

	s_bExit = false;
	/** 线程ID */
	UINT threadId;
	/** 开启串口数据监听线程 */
	m_hListenThread = (HANDLE)_beginthreadex(NULL, 0, ListenThread, this, 0, &threadId);
	if (!m_hListenThread)
	{
		return false;
	}
	/** 设置线程的优先级,高于普通线程 */
	if (!SetThreadPriority(m_hListenThread, THREAD_PRIORITY_ABOVE_NORMAL))
	{
		return false;
	}

	return true;
}

bool CSerialPort::CloseListenTread()
{
	if (m_hListenThread != INVALID_HANDLE_VALUE)
	{
		/** 通知线程退出 */
		s_bExit = true;

		/** 等待线程退出 */
		Sleep(10);

		/** 置线程句柄无效 */
		CloseHandle(m_hListenThread);
		m_hListenThread = INVALID_HANDLE_VALUE;
	}
	return true;
}

UINT CSerialPort::GetBytesInCOM()
{
	DWORD dwError = 0;  /** 错误码 */
	COMSTAT  comstat;   /** COMSTAT结构体,记录通信设备的状态信息 */
	memset(&comstat, 0, sizeof(COMSTAT));

	UINT BytesInQue = 0;
	/** 在调用ReadFile和WriteFile之前,通过本函数清除以前遗留的错误标志 */
	if (ClearCommError(m_hComm, &dwError, &comstat))
	{
		BytesInQue = comstat.cbInQue; /** 获取在输入缓冲区中的字节数 */
	}

	return BytesInQue;
}

UINT WINAPI CSerialPort::ListenThread(void* pParam)
{
	/** 得到本类的指针 */
	CSerialPort *pSerialPort = reinterpret_cast<CSerialPort*>(pParam);

	// 线程循环,轮询方式读取串口数据  
	while (!pSerialPort->s_bExit)
	{
		UINT BytesInQue = pSerialPort->GetBytesInCOM();
		/** 如果串口输入缓冲区中无数据,则休息一会再查询 */
		if (BytesInQue == 0)
		{
			Sleep(SLEEP_TIME_INTERVAL);
			continue;
		}

		/** 读取输入缓冲区中的数据并输出显示 */
		char cRecved = 0x00;
		do
		{
			cRecved = 0x00;
			if (pSerialPort->ReadChar(cRecved) == true)
			{
				std::cout << cRecved;
				continue;
			}
		} while (--BytesInQue);
	}

	return 0;
}

bool CSerialPort::ReadChar(char &cRecved)
{
	BOOL  bResult = TRUE;
	DWORD BytesRead = 0;
	if (m_hComm == INVALID_HANDLE_VALUE)
	{
		return false;
	}

	/** 临界区保护 */
	EnterCriticalSection(&m_csCommunicationSync);

	/** 从缓冲区读取一个字节的数据 */
	bResult = ReadFile(m_hComm, &cRecved, 1, &BytesRead, NULL);
	if ((!bResult))
	{
		/** 获取错误码,可以根据该错误码查出错误原因 */
		DWORD dwError = GetLastError();

		/** 清空串口缓冲区 */
		PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
		LeaveCriticalSection(&m_csCommunicationSync);

		return false;
	}

	/** 离开临界区 */
	LeaveCriticalSection(&m_csCommunicationSync);

	return (BytesRead == 1);

}

bool CSerialPort::WriteData(unsigned char* pData, unsigned int length)
{
	BOOL   bResult = TRUE;
	DWORD  BytesToSend = 0;
	if (m_hComm == INVALID_HANDLE_VALUE)
	{
		return false;
	}

	/** 临界区保护 */
	EnterCriticalSection(&m_csCommunicationSync);

	/** 向缓冲区写入指定量的数据 */
	bResult = WriteFile(m_hComm, pData, length, &BytesToSend, NULL);
	if (!bResult)
	{
		DWORD dwError = GetLastError();
		/** 清空串口缓冲区 */
		PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
		LeaveCriticalSection(&m_csCommunicationSync);

		return false;
	}

	/** 离开临界区 */
	LeaveCriticalSection(&m_csCommunicationSync);

	return true;
}

1.4 SerialPort.h


#ifndef SERIALPORT_H_  
#define SERIALPORT_H_  

#include <Windows.h>  

/** 串口通信类
*
*  本类实现了对串口的基本操作
*  例如监听发到指定串口的数据、发送指定数据到串口
*/
class CSerialPort
{
public:
	CSerialPort(void);
	~CSerialPort(void);

public:

	/** 初始化串口函数
	*
	*  @param:  UINT portNo 串口编号,默认值为1,即COM1,注意,尽量不要大于9
	*  @param:  UINT baud   波特率,默认为9600
	*  @param:  char parity 是否进行奇偶校验,'Y'表示需要奇偶校验,'N'表示不需要奇偶校验
	*  @param:  UINT databits 数据位的个数,默认值为8个数据位
	*  @param:  UINT stopsbits 停止位使用格式,默认值为1
	*  @param:  DWORD dwCommEvents 默认为EV_RXCHAR,即只要收发任意一个字符,则产生一个事件
	*  @return: bool  初始化是否成功
	*  @note:   在使用其他本类提供的函数前,请先调用本函数进行串口的初始化
	*　　　　　   /n本函数提供了一些常用的串口参数设置,若需要自行设置详细的DCB参数,可使用重载函数
	*           /n本串口类析构时会自动关闭串口,无需额外执行关闭串口
	*  @see:
	*/
	bool InitPort(UINT  portNo = 1, UINT  baud = CBR_9600, char  parity = 'N', UINT  databits = 8, UINT  stopsbits = 1, DWORD dwCommEvents = EV_RXCHAR);

	/** 串口初始化函数
	*
	*  本函数提供直接根据DCB参数设置串口参数
	*  @param:  UINT portNo
	*  @param:  const LPDCB & plDCB
	*  @return: bool  初始化是否成功
	*  @note:   本函数提供用户自定义地串口初始化参数
	*  @see:
	*/
	bool InitPort(UINT  portNo, const LPDCB& plDCB);

	/** 开启监听线程
	*
	*  本监听线程完成对串口数据的监听,并将接收到的数据打印到屏幕输出
	*  @return: bool  操作是否成功
	*  @note:   当线程已经处于开启状态时,返回flase
	*  @see:
	*/
	bool OpenListenThread();

	/** 关闭监听线程
	*
	*
	*  @return: bool  操作是否成功
	*  @note:   调用本函数后,监听串口的线程将会被关闭
	*  @see:
	*/
	bool CloseListenTread();

	/** 向串口写数据
	*
	*  将缓冲区中的数据写入到串口
	*  @param:  unsigned char * pData 指向需要写入串口的数据缓冲区
	*  @param:  unsigned int length 需要写入的数据长度
	*  @return: bool  操作是否成功
	*  @note:   length不要大于pData所指向缓冲区的大小
	*  @see:
	*/
	bool WriteData(unsigned char* pData, unsigned int length);

	/** 获取串口缓冲区中的字节数
	*
	*
	*  @return: UINT  操作是否成功
	*  @note:   当串口缓冲区中无数据时,返回0
	*  @see:
	*/
	UINT GetBytesInCOM();

	/** 读取串口接收缓冲区中一个字节的数据
	*
	*
	*  @param:  char & cRecved 存放读取数据的字符变量
	*  @return: bool  读取是否成功
	*  @note:
	*  @see:
	*/
	bool ReadChar(char &cRecved);

private:

	/** 打开串口
	*
	*
	*  @param:  UINT portNo 串口设备号
	*  @return: bool  打开是否成功
	*  @note:
	*  @see:
	*/
	bool openPort(UINT  portNo);

	/** 关闭串口
	*
	*
	*  @return: void  操作是否成功
	*  @note:
	*  @see:
	*/
	void ClosePort();

	/** 串口监听线程
	*
	*  监听来自串口的数据和信息
	*  @param:  void * pParam 线程参数
	*  @return: UINT WINAPI 线程返回值
	*  @note:
	*  @see:
	*/
	static UINT WINAPI ListenThread(void* pParam);

private:

	/** 串口句柄 */
	HANDLE  m_hComm;

	/** 线程退出标志变量 */
	static bool s_bExit;

	/** 线程句柄 */
	volatile HANDLE    m_hListenThread;

	/** 同步互斥,临界区保护 */
	CRITICAL_SECTION   m_csCommunicationSync;       //!< 互斥操作串口  

};

#endif //SERIALPORT_H_ #pragma once

1.5 kinectJointFilter.h

/*双指数平滑滤波*/
#pragma once

#include<windows.h>
#include<kinect.h>
#include<DirectXmath.h>   //图形应用程序数学库
#include<queue>          //队列

namespace Sample
{
	typedef struct _TRANSFORM_SMOOTH_PARAMETERS
	{
		FLOAT fSmoothing;  /*越低与越接近原始数据*/
		FLOAT fCorrection; /*平滑参数，设置处理骨骼数据帧时的平滑量。值越大，平滑的越多，0表示不进行平滑；*/
		FLOAT fPrediction; /*预测超前期数，增大该值能减小滤波的延迟，但是会对突然的运动更敏感，容易造成过冲*/
		FLOAT fJitterRadius;/*抖动半径参数，设置修正的半径.如果关节点“抖动”超过了设置的这个半径，将会被纠正到这个半径之内*/
		FLOAT fMaxDeviationRadius;/*最大偏离半径参数，用来和抖动半径一起来设置抖动半径的最大边界*/
	}TRANSFORM_SMOOTH_PARAMETERS;

	// 霍尔特双指数平滑滤波器
	class FilterDoubleExponentialData
	{
	public:
		DirectX::XMVECTOR m_vRawPosition;
		DirectX::XMVECTOR m_vFilteredPosition;
		DirectX::XMVECTOR m_vTrend;
		DWORD    m_dwFrameCount;
	};

	class FilterDoubleExponential
	{
	public:
		FilterDoubleExponential() { Init(); }
		~FilterDoubleExponential() { Shutdown(); }

		void Init(FLOAT fSmoothing = 0.25f, FLOAT fCorrection = 0.25f, FLOAT fPrediction = 0.25f, FLOAT fJitterRadius = 0.03f, FLOAT fMaxDeviationRadius = 0.05f)
		{
			Reset(fSmoothing, fCorrection, fPrediction, fJitterRadius, fMaxDeviationRadius);
		}

		void Shutdown()
		{
		}

		void Reset(FLOAT fSmoothing = 0.25f, FLOAT fCorrection = 0.25f, FLOAT fPrediction = 0.25f, FLOAT fJitterRadius = 0.03f, FLOAT fMaxDeviationRadius = 0.05f)
		{
			assert(m_pFilteredJoints);
			assert(m_pHistory);

			m_fMaxDeviationRadius = fMaxDeviationRadius; // 最大预测半径的大小在过高时可以恢复到有噪声的数据
			m_fSmoothing = fSmoothing;                   // 平滑程度，过高会有明显延迟
			m_fCorrection = fCorrection;                 // 从预测中修正
			m_fPrediction = fPrediction;                 // 预测未来使用的数量。过高时过冲
			m_fJitterRadius = fJitterRadius;             // 消除抖动的半径的大小。过多的平滑会过高

			memset(m_pFilteredJoints, 0, sizeof(DirectX::XMVECTOR) * JointType_Count);
			memset(m_pHistory, 0, sizeof(FilterDoubleExponentialData) * JointType_Count);
		}

		void Update(IBody* const pBody);
		void Update(Joint joints[]);

		inline const DirectX::XMVECTOR* GetFilteredJoints() const { return &m_pFilteredJoints[0]; }

	private:
		DirectX::XMVECTOR m_pFilteredJoints[JointType_Count];
		FilterDoubleExponentialData m_pHistory[JointType_Count];
		FLOAT m_fSmoothing;
		FLOAT m_fCorrection;
		FLOAT m_fPrediction;
		FLOAT m_fJitterRadius;
		FLOAT m_fMaxDeviationRadius;

		void Update(Joint joints[], UINT JointID, TRANSFORM_SMOOTH_PARAMETERS smoothingParams);
	};
}

最后

上位机代码全部完成，cpp文件与h文件对应使用。最终效果实现简单的随动。

kyleeeeeeeeee
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kinect XBOX 360和六轴机械臂的实时映射
weixin_43889683的博客
06-20 1790
机械臂在现在工业自动化中充当着举足轻重的作用，通过RGB-D相机提取人体骨架信息，通过坐标变换将人体关节坐标从相机坐标系变换到方便计算关节角度的坐标系下完成对关节角度的计算。将角度信息通过TCP/IP协议传输给UR5机械臂，从而完成机械臂与手臂运动的实时映射。根据以上的叙述，本文以ROS为基础，完成了基于深度手臂与机械臂动作的实时模仿。从机械臂运动学的正逆解的推导，RGB-D相机对人体骨架的跟踪，到MoveIt！获取以上信息完成对机械臂的控制，得到了我们想要的运动。
kinect v2 和 usb摄像头 在aubo机械臂上实现 手眼标定
harrycomeon的博客
11-19 3129
一，配置环境 硬件： aubo_i5 工业机器人 Kinect V2 usb单目摄像头 软件： 注意我是将下面包安装在ros下工作目录的src文件夹下 1,aubo_robot 包（之前blog有安装教程） 2,iai_kinect2 （kinect v2的启动节点） 3.usb_cam（启动单目相机的驱动） 3,ros-kinetic-visp 4,vision_visp 5,aruco_ros...
Kinect2和六轴机械臂的实时映射（初步）
朱铭德的博客
11-17 1万+
本文暂时不贴代码，只是总结一下这两天的思路，做的过程中遇到的问题，尝试的各种方法以及结果。首先说下现阶段想要的一个效果吧：利用Kinect2采集人的骨架参数，实时映射到机械臂的几个自由度让其模仿人右臂的动作。Kinect2部分流程图大概如下：Created with Raphaël 2.1.0开始初始化选择对象检测骨架TCP/IP发送数据退出？结束yesno1）这里的初始化选择对象的意思是让电脑知道
【UR5机械臂Moveit避障】【4】UR5和kinectv2/realsense手眼标定（眼在手外）
最新发布
weixin_45702459的博客
05-29 1166
我这里是眼在手外，也就是相机在固定位置，如下图所示。把frame改为base，添加点云话题，就可以看见标定成功，至于说有点偏差，那是正常的，因为这种传统的手眼标定会有一系列的多种误差累积，觉得差的可以寻找新式的标定方法（本帖末尾会给出我找到的方法），现在有点偏差，到时候建包围盒建大一点就行。reference_frame和camera_frame，填相机rgb的frame，一般在rviz测试相机的时候可以看到除了xxx_link以外还有其他frame，填带有rgb，color的关于彩色的frame。
Kinova JACO2机械臂与Azure Kinect手眼标定及坐标点的变换
WCaiL的博客
08-12 3077
对于一个带有视觉的机器人系统，相机所获得的所有信息都是在相机坐标系下描述的。要想让机器人利用视觉系统得到的信息，首先就是要确定相机坐标系与机器人之间的相对关系，这便是机器人手眼标定的研究内容。
机器人抓取（三）—— Azure Kinect SDK 及 ROS 驱动安装
zxxRobot的博客
12-24 6870
Azure kinect 简介 Azure Kinect DK 文档 ROS package : Azure_Kinect_ROS_Driver 安装 Azure_Kinect_ROS_Driver # 下载 cd catkin_ws/src git clone https://github.com/microsoft/Azure_Kinect_ROS_Driver.git # 编译 cd catkin_ws catkin_make 修改 k4a_ros_device.h ？ 路径：Azure_Kine
基于Kinect体感器的康复机械手臂系统算法设计与实现
01-28
利用Kinect体感器获取人体右肩、右肘和右腕3个关节的三维坐标，计算得出所需控制参数。建立体感器与机械手臂之间通信机制，通过数据反馈调整所需控制参数。实现多自由度同时协调运动的康复型机械手臂控制方法。实验...
基于Kinect体感器的康复机械手臂系统算法设计与实现.pdf
09-21
基于Kinect体感器的康复机械手臂系统算法设计与实现.pdf
基于Kinect的体感跟随的机械手臂（电子设计小学期创新实验资料）.zip
03-09
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设...基于Kinect的体感跟随的机械手臂（电子设计小学期创新实验资料）.zip
kinect体感控制器原理解释.pdf
09-04
Kinect 体感控制器原理解释 Kinect 体感控制器是一种革命性的游戏控制器，使用光学、电磁学和其他技术来实现全新的游戏体验。下面是对 Kinect 体感控制器的原理和实现机制的详细解释： 1. Kinect 体感控制器的功能...
kinect深度距离误差_基于kinect深度图像的目标定位与识别.pdf
weixin_39630999的博客
01-11 464
·电气与自动化 · 周振,等 ·基于kinect深度图像的目标定位与识别基于kinect深度图像的目标定位与识别周振,杜姗姗(南京理工大学 计算机科学与工程学院,江苏 南京210094)摘　 要:针对颜色图像受光照及背景影响较大而较难识别目标的问题,利用深度图像作为目标载体,设计并实现了一种简单的目标识别方法。 该方法主要包括深度图像的轮廓提取算法和基于轮廓特征...
kinect体感控制器原理解释
05-31
kinect体感控制器原理解释 解释了kinect的结构 大家看看
上位机控制下位机（单片机+步进电机）
10-14
现实中Z轴电机有丝杠，电机还连着液晶屏。电机大概隔a秒走 b毫米，液晶屏也是显示一张图片a秒然后切换成下一张图片。这里面 的a和b都是可以换的。 我要实现它的原理，所以就是设计一个上位机软件，来控制步进电机和图片的显示。 我的上位机能够要控制电机走的间隔还有每次走的距离。有开始，也要有停止的选项。 还要能归位（反转回到原来的位置） 还有一部分就是液晶屏图片的显示，因为要和电机同步。 显示的图片我已经预先存在一个指定文件夹了，名称是001到100的编号。bmp格式
Kinect体感器原理
11-28
简述Kinect工作原理
手势控制机械臂
04-23
手势端：采用CC3220S作为控制核心，主要采集BMA222以及MPU6050的数据。运用了加速度以及陀螺仪的角度计算算法，之后进行了卡尔曼滤波处理，得到了较为精确的角度制（X轴，Y轴，Z轴）。在对滤波处理之后的值进行了范围转换，转换成-90°到90°，方便发送。其中Z轴数据需要地磁计校准，MPU6050无地磁计，所以舍去Z轴的数据。串口发送方面采用了简单的数据封装算法处理，将数字值转换成字符串在进行打包发送，防止数据丢失。 机械臂端：采用LPC54608作为控制核心。主要负责解析串口发送的数据，并控制舵机的运动。将串口的数据并进行解析，当数据出错时时会自动舍去的，然后转换成数字值，再根据每个舵机的动作范围，进行方为运动算法的处理。最后进行了消抖算法的处理，防止手的抖动造成机械臂的的连续抖动。液晶显示串口接收到的数据，显示采用了emwin库，实现起来更加简单。
使用Kinect和Arduino的手势控制机械臂-项目开发
03-30
这是一个Simulink模型，用于使用通过Kinect捕获的手势来控制机械臂； 使用伺服电机开发的机械臂。
UR3机械臂使用kinect2相机利用easy_hand手眼标定
SpengTAN的博客
05-15 2942
１.下载easy_handeye(标定的工具包) https://github.com/IFL-CAMP/easy_handeye 2.下载vision_visp(标定过程调用) https://github.com/lagadic/vision_visp 下载aruco_ros(标定过程调用) https://github.com/pal-robotics/aruco_ros 进入/cat...
【姿态检测】win10+Azure Kinect Dk 人体姿态跟踪使用教程
热门推荐
weixin_41977337的博客
05-07 1万+
由于项目需要，使用了Azure Kinect DK的深度相机设备，由于内含人体姿态检测的SDK，所以拿来玩一玩 设备文档介绍：https://docs.microsoft.com/zh-cn/azure/Kinect-dk/set-up-azure-kinect-dk 一、设备连接 硬件部分的连接示意图如下： 1、将电源连接器插入设备背面的电源插孔。将 USB 电源适配器连接到线缆的另一...
技能梳理27@体感机械臂
杨飞的博客
05-29 6092
最近在抽时间集中整理之前做过的东西，有纯粹入门学习的、课程设计的、老师项目的、帮忙同学的、业余瞎搞的、毕业设计的（自己和“他人”）、之前在破产公司搞的，所以难度质量啥的参差不齐，一些半成品残次品正在考虑要不要整理，都算上预计这个系列能更六七十篇吧 这次这个没怎么参与，属于帮同学的，舍友[赵硕](https://blog.csdn.net/qq_35661436?type=blog)搞的，他现在转java了。所以只有当时给整理的文档，具体工程忘保存了，有需要的可以去他博客管他要哈哈
使用kinect和arduino的手势控制机械臂-项目开发
09-21
手势控制是一种新兴的交互方式，结合Kinect和Arduino可以实现机械臂的手势控制。 首先，我们需要使用Kinect传感器来捕捉用户的手势。Kinect可以通过深度摄像头、RGB摄像头和红外线发射器来识别用户的身体姿势和动作。通过对Kinect SDK的编程，我们可以提取用户的手的位置和动作，包括抓取、放开、旋转等。 其次，我们将使用Arduino控制机械臂的运动。Arduino是一种开放源码的硬件平台，可以编程控制各种电子硬件设备。通过连接Kinect和Arduino，我们可以将用户的手势与机械臂的运动进行关联。我们可以将机械臂的动作编程为对应不同手势的响应，并通过Arduino控制电机和传感器来实现运动。 在项目开发过程中，我们需要先进行硬件的连接和搭建。将Kinect连接到电脑或主控设备，通过Arduino连接机械臂和电机。接下来，我们需要开发软件，使用Kinect SDK和Arduino IDE编程工具。通过编写代码来识别用户的手势，并将识别结果发送给Arduino进行机械臂的控制。我们还可以根据需要添加其他功能，例如手势的缩放和旋转等。 最后，在项目的测试阶段，我们需要验证系统的稳定性和准确性。通过不断调试和优化代码，确保机械臂能够准确地响应用户的手势。 总的来说，使用Kinect和Arduino的手势控制机械臂项目开发是一项复杂而有趣的工程。通过结合开源硬件和软件，我们可以实现更加灵活和直观的机器人控制方式，为工业自动化和人机交互领域带来创新的解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值