paparazzi message protocol parse

最新推荐文章于 2021-04-20 17:26:54 发布
最新推荐文章于 2021-04-20 17:26:54 发布
阅读量955 收藏
点赞数
文章标签： paparazzi message p
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ss15/article/details/38704497
版权 
// 根据读取的 messages.xml 初始化msg格式存储结构数组
// xml解析使用了 CMarkup，可参见 http://www.firstobject.com/


BOOL CProtocol::InitTeleMsgDict_PPZ()
{
	// Function    : 根据 messages.xml 文件, 解析获取 ppz msg 的帧格式
	// Remark      : 解析 xml 文件获取的帧格式存储于 m_arMsgPPZ_Tele[] 结构数组当中

	int i, k, nFieldInx;
	BOOL blRet, blTmp;
	BYTE nTmp, nMsgID;
	CString strMsgName, strMsgId, strTmp;

	i = k = 0;
	nFieldInx = 0;
	nMsgID    = 0x00;
	nTmp      = 0x00;
	blRet     = TRUE;
	blTmp    = FALSE;

	#ifdef PROTOCOL_DBG
	TRACE(_T("\r\n>\r\n> CProtocol.InitTeleMsgDict_PPZ"));
	#endif
	
	m_MarkupXml.ResetPos();
	
	if(m_MarkupXml.FindElem(_T("protocol")))
	{
		blTmp = m_MarkupXml.IntoElem();								// to class
		
		for(i = 0; blTmp && i < 20 && m_MarkupXml.FindElem(); i++)	// Enum class
		{
			strTmp = m_MarkupXml.GetAttrib(_T("name"));		// <class name="telemetry">
			if(strTmp == _T("telemetry"))
			{
				blTmp = m_MarkupXml.IntoElem();						// to message
				
				for(k = 0; blTmp && k < 256 && m_MarkupXml.FindElem(); k++)	// enum msg
				{
					strTmp     = m_MarkupXml.GetTagName();
					strMsgName = m_MarkupXml.GetAttrib(_T("name"));
					strMsgId   = m_MarkupXml.GetAttrib(_T("id"));
					
					nMsgID = _ttoi(strMsgId);
					ASSERT(nMsgID > 0 && nMsgID < 256);

					m_arMsgPPZ_Tele[nMsgID].nMsgID = nMsgID;
					if(strMsgName.GetLength() >= MAX_MSGNM_PPZ - 1)
						strMsgName = strMsgName.Left(MAX_MSGNM_PPZ - 1);
					_tcscpy(m_arMsgPPZ_Tele[nMsgID].szMsgName, strMsgName);
					
					#ifdef PROTOCOL_DBG
					TRACE(_T("\r\n\r\n> Msg: %s (%d)"), strMsgName, nMsgID);
					#endif

					blTmp = m_MarkupXml.IntoElem();				// to field, <field name="utm_north" type="int32" unit="cm" alt_unit="m" /> 

					for(nFieldInx = 0; blTmp && m_MarkupXml.FindElem() && nFieldInx < MAX_FIELDCNTS_PPZ * 2; nFieldInx++)	// Enum field
					{
						if(nFieldInx < MAX_FIELDCNTS_PPZ)
						{
							// field name
							strTmp	= m_MarkupXml.GetAttrib(_T("name"));
							if(strTmp.GetLength() >= MAX_FIELDNM_PPZ - 1)
								strTmp = strTmp.Left(MAX_FIELDNM_PPZ - 1);
							_tcscpy(m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].szFieldNm, strTmp);
							
							// field type
							strTmp = m_MarkupXml.GetAttrib(_T("type"));
							nTmp   = GetFieldTyp_PPZ(strTmp);
							if(nTmp != PPZ_TYPE_UNKNOWN)
							{
								m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].nFieldTyp = nTmp;
							}
							else
							{
								m_strRunInfo.Format(_T("Error: Msg %s.%s: Unknown field type: %s (%d)"), 
													strMsgName, 
													m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].szFieldNm, 
													strTmp, 
													nTmp);
								
								TRACE(_T("\r\n> CProtocol.ParseMsg_PPZ - %s"), m_strRunInfo);
								blRet = FALSE;
							}
								
							// field unit
							strTmp= m_MarkupXml.GetAttrib(_T("alt_unit"));
							if(strTmp.GetLength() >= MAX_UNIT_PPZ - 1)
								strTmp = strTmp.Left(MAX_UNIT_PPZ - 1);
							_tcscpy(m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].szUnit, strTmp);

							// field coef
							strTmp = m_MarkupXml.GetAttrib(_T("alt_unit_coef"));
							m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].dFieldCoef = (float) _tcstod(strTmp, NULL);

							// 
							m_arMsgPPZ_Tele[nMsgID].nFieldCnts++;
							m_arMsgPPZ_Tele[nMsgID].nFrmLen += GetFieldLen_PPZ(m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].nFieldTyp);

						}
						else
						{
							m_strRunInfo.Format(_T("The counts of field overflow"));
							TRACE(_T("\r\n> CProtocol.ParseMsg_PPZ - %s"), m_strRunInfo);
							blRet = FALSE;
						}

						
						#ifdef PROTOCOL_DBG
						::Sleep(5);
						TRACE(_T("\r\n>     - %-16s:  Unit:%-8s, Type:%d  Coef:%f"), 
										m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].szFieldNm, 
										m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].szUnit, 
										m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].nFieldTyp, 
										m_arMsgPPZ_Tele[nMsgID].arFieldInfo[nFieldInx].dFieldCoef);
						#endif
						

					}	// enum field

					#ifdef PROTOCOL_DBG
					TRACE(_T("\r\n> Msg: field: %d  len: %d byte"), m_arMsgPPZ_Tele[nMsgID].nFieldCnts, m_arMsgPPZ_Tele[nMsgID].nFrmLen);
					#endif

					blTmp = m_MarkupXml.OutOfElem();
					ASSERT(blTmp);
				}	// enum msg

				blTmp = m_MarkupXml.OutOfElem();
				ASSERT(blTmp);

				break;
			}
		}

		blTmp = m_MarkupXml.OutOfElem();
		ASSERT(blTmp);
	}
	
	return blRet;
}


BYTE CProtocol::Stream2Frame_PPZ(BYTE byteReceive)
{
	// Function    : 从串口数据流当中解析出 ppz frame
	// Parameters  : byteReceive - 当前接收的字符
	// Return value: 
	// Remark      : 解析成功返回解析出的 ppz msg id, 否则返回 0

	int i;
	BYTE nGotFrmID = 0x00;

	i = 0;
	ASSERT(m_nFrmDatInx < MAX_DLFRMLEN * 2 + 16);

	if(m_nFrmDatInx > MAX_DLFRMLEN * 2)
	{
		RevReset();
		TRACE(_T("\r\n\r\n> CProtocol.Stream2Frame_PPZ - Too error dat. get frame from data stream failed."));
	}


	if(byteReceive == FRAMEHEAD_PPZ && m_blIsFrm == FALSE)			               // 检测 0x99
	{
		#ifdef SERIALDBG
		TRACE(_T("%02X "), m_arTmpRevBuff[m_nCurRevByteInx]);					// for debug
		#endif
					
		m_blIsFrm    = TRUE;
		m_nFrmDatInx = 0;

		m_arTmpRevBuff[m_nFrmDatInx] = byteReceive;
		m_nFrmDatInx++;
	}
	else if(m_blIsFrm)
	{
		// 假设帧头标志匹配, 获取该数据帧的余下数据
		ASSERT(m_nFrmDatInx < MAX_DLFRMLEN);

		m_arTmpRevBuff[m_nFrmDatInx] = byteReceive;

		if(m_nFrmDatInx == PPZINX_LEN)
		{
			m_nPPZFrmLen = byteReceive;
			
			m_byteCk_A = m_byteCk_B = byteReceive;

			m_nInxCkA = m_nPPZFrmLen - 2;
			m_nInxCkB = m_nPPZFrmLen - 1;
			
			#ifdef PROTOCOL_DBG
			TRACE(_T("\r\n> CProtocol.Stream2Frame_PPZ - Frame len = %d, InxCKA = %d InxCKB = %d"), m_nPPZFrmLen, m_nInxCkA, m_nInxCkB);
			#endif
		}
		else if(m_nFrmDatInx == PPZINX_SENDERID)
		{
			m_nSenderID = byteReceive;
			
			m_byteCk_A += byteReceive;
			m_byteCk_B += m_byteCk_A;

			#ifdef PROTOCOL_DBG
			TRACE(_T("\r\n> CProtocol.Stream2Frame_PPZ - Sender ID = %d"), m_nSenderID);
			#endif
		}
		else if(m_nFrmDatInx == PPZINX_MSGID)
		{
			m_nMsgID = byteReceive;

			m_byteCk_A += byteReceive;
			m_byteCk_B += m_byteCk_A;

			#ifdef PROTOCOL_DBG
			TRACE(_T("\r\n> CProtocol.Stream2Frame_PPZ - Msg ID = %d (0x%02X)"), m_nMsgID, m_nMsgID);
			#endif
		}
		else if(m_nFrmDatInx < m_nInxCkA)
		{
			m_byteCk_A += byteReceive;
			m_byteCk_B += m_byteCk_A;
		}

		if(m_nFrmDatInx >= m_nInxCkB)
		{	// 假设当前已经接收到了一个完整帧

			ASSERT(m_nInxCkA < MAX_DLFRMLEN * 2 + 16 && m_nInxCkB < MAX_DLFRMLEN * 2 + 16);
			ASSERT(m_nInxCkA > -1 && m_nInxCkB > -1);

			if(m_arTmpRevBuff[m_nInxCkA] == m_byteCk_A && m_arTmpRevBuff[m_nInxCkB] == m_byteCk_B)
			{
				ASSERT(m_nPPZFrmLen > 0 && m_nPPZFrmLen <= MAX_DLFRMLEN);

				memset(m_arRevFrameBuff, 0x00, sizeof(m_arRevFrameBuff));
				memcpy(m_arRevFrameBuff, m_arTmpRevBuff, m_nPPZFrmLen);
				
				nGotFrmID = m_arRevFrameBuff[3];

				#ifdef PROTOCOL_DBG
				TRACE(_T("\r\n> CProtocol.Stream2Frame_PPZ - Rev frame:  "));
				for(i = 0; i < m_nPPZFrmLen; i++)
					TRACE(_T("%02X "), m_arRevFrameBuff[i]);
				TRACE(_T("\r\n> "));
				#endif
			}

			RevReset();
		}

		m_nFrmDatInx++;
	}

	return nGotFrmID;
}


void CProtocol::RevReset()
{
	memset(m_arTmpRevBuff, 0x00, sizeof(m_arTmpRevBuff));
	
	m_blIsFrm	 = FALSE;
	m_nFrmDatInx = 0;
	
	m_nInxCkA    = -1;
	m_nInxCkB    = -1;  
	
	m_byteCk_A   = 0x00;
	m_byteCk_B   = 0x00;
}


BYTE CProtocol::ParseTeleMsg_PPZ(BYTE nMsgID)
{
	// Function    : 从接收到的 ppz 数据帧当中将 telemetry class 当中帧字段解析出来并存放于 m_arMsgPPZ_Tele 当中
	// Parameters  : 
	// Return value: 解析成功返回当前解析的消息 nMsgID 当中所包含的 field 数量 
	//               若解析失败或解析的 msg 不属于 class telemetry, 则返回 0

	int i, nFieldCnts, nPayloadLen;
	BYTE nParseFields;
	BYTE nFieldLen, nFieldTyp;
	BYTE arTemp[8];
	
	BOOL blNoArray;

	BYTE *pPayload;
	BYTE *pCurFieldBuff;

	blNoArray     = TRUE;

	nPayloadLen   = 0;
	nParseFields  = 0;

	pPayload      = NULL;
	pCurFieldBuff = NULL;

	nFieldLen = nFieldTyp = 0;
	memset(arTemp, 0x00, sizeof(arTemp));

	if(nMsgID < 0x01)
		return nParseFields;

	ASSERT(nMsgID < MAX_MSGCNTS_PPZ);
	nFieldCnts = m_arMsgPPZ_Tele[nMsgID].nFieldCnts;
	ASSERT(nFieldCnts < MAX_FIELDCNTS_PPZ);

	pPayload      = m_arRevFrameBuff + OFFSET_PAYLOAD;
	pCurFieldBuff = pPayload;

	for(i = 0; i < nFieldCnts; i++)
	{
		nFieldTyp = m_arMsgPPZ_Tele[nMsgID].arFieldInfo[i].nFieldTyp;
		nFieldLen = GetFieldLen_PPZ(nFieldTyp);

		if(nFieldLen > 0)
		{
			memset(arTemp, 0x00, sizeof(arTemp));

			ASSERT(nFieldLen <= 8);
			ASSERT(pCurFieldBuff);

			memcpy(arTemp, pCurFieldBuff, nFieldLen);
			m_arMsgPPZ_Tele[nMsgID].arFieldInfo[i].dFieldValue = GetFieldValue_PPZ(nFieldTyp, arTemp);

			pCurFieldBuff += nFieldLen;			// 字段缓冲区指针
			nPayloadLen   += nFieldLen;

			ASSERT(nPayloadLen <= m_nPPZFrmLen - LEN_NONEPAYLOAD);
		}
		else
		{
			blNoArray = FALSE;

			if(nFieldTyp == PPZ_TYPE_UINT8_ARRAY)
				;
			else if(nFieldTyp == PPZ_TYPE_UINT16_ARRAY)
				;
			else if(nFieldTyp == PPZ_TYPE_INT16_ARRAY)
				;
			else if(nFieldTyp == PPZ_TYPE_UINT32_ARRAY)
				;
		}

		nParseFields++;

	}

	if(blNoArray)
		if(nPayloadLen + LEN_NONEPAYLOAD != m_nPPZFrmLen)
			nParseFields = 0;

	return nParseFields;
}

double CProtocol::GetFieldValue_PPZ(int nFieldTyp, BYTE arData[])
{
	double dRet = 0.0;

	uint8_t		uDat_1;
	uint16_t	uDat_2;
	uint32_t	uDat_4;
	uint64_t	uDat_8;
	
	int8_t		Dat_1;
	int16_t		Dat_2;
	int32_t		Dat_4;
	int64_t		Dat_8;
	
	float		fDat;
	double		dDat;

	uDat_1 = 0;
	uDat_2 = 0;
	uDat_4 = 0;
	uDat_8 = 0;
	
	Dat_1  = 0;
	Dat_2  = 0;
	Dat_4  = 0;
	Dat_8  = 0;
	
	fDat   = 0.0;
	dDat   = 0.0;

	if(nFieldTyp == PPZ_TYPE_CHAR || nFieldTyp == PPZ_TYPE_UINT8_T)
	{
		memcpy(&uDat_1, arData, 1);
		dRet = (double) uDat_1;
	}
	else if(nFieldTyp == PPZ_TYPE_INT8_T)
	{
		memcpy(&Dat_1, arData, 1);
		dRet = (double) Dat_1;
	}
	else if(nFieldTyp == PPZ_TYPE_UINT16_T)
	{
		memcpy(&uDat_2, arData, 2);
		dRet = (double) uDat_2;
	}
	else if(nFieldTyp == PPZ_TYPE_INT16_T)
	{
		memcpy(&Dat_2, arData, 2);
		dRet = (double) Dat_2;
	}
	else if(nFieldTyp == PPZ_TYPE_UINT32_T)
	{
		memcpy(&uDat_4, arData, 4);
		dRet = (double) uDat_4;
	}
	else if(nFieldTyp == PPZ_TYPE_INT32_T)
	{
		memcpy(&Dat_4, arData, 4);
		dRet = (double) Dat_4;
	}
	else if(nFieldTyp == PPZ_TYPE_UINT64_T)
	{
		// 此处一定要注意, dRet 并不是变量的真正数值, 而是容纳变量的一个容器
		memcpy(&uDat_8, arData, 8);
		memcpy(&dRet, arData, 8);
	}
	else if(nFieldTyp == PPZ_TYPE_INT64_T)
	{	// 此处一定要注意, dRet 并不是变量的真正数值, 而是容纳变量的一个容器
		memcpy(&Dat_8, arData, 8);
		dRet = (double) Dat_8;
	}
	else if(nFieldTyp == PPZ_TYPE_FLOAT)
	{
		memcpy(&fDat, arData, 4);
		dRet = (double) fDat;
	}
	else if(nFieldTyp == PPZ_TYPE_DOUBLE)
	{
		memcpy(&dDat, arData, 8);
		dRet = dDat;
	}

	return dRet;
}


相关结构定义：

// user define data
struct FIELD_PPZ
{
	TCHAR	szFieldNm[MAX_FIELDNM_PPZ];
	TCHAR	szUnit[MAX_UNIT_PPZ];
	BYTE    nFieldTyp;
	float	dFieldCoef;

	double  dFieldValue;
};

struct MSG_PPZ
{
	TCHAR	szMsgName[MAX_MSGNM_PPZ];
	BYTE	nMsgID;
	BYTE    nFieldCnts;
	BYTE    nFrmLen;
	
	FIELD_PPZ arFieldInfo[MAX_FIELDCNTS_PPZ];
};

static MSG_PPZ	m_arMsgPPZ_Tele[MAX_MSGCNTS_PPZ];








SGUav
关注
北斗协议解析（北三）SDK
无
03-25 1802
​公司属于北斗通信行业，平时开发时经常要接触到北斗协议。由于北斗通信相对于外界开发人员来说比较冷门，所以在早期开发时想要找到相关资料比较难，因此只好自己看协议慢慢摸索。现在经过了大量相关项目的洗礼之后对北三协议也略知一二就编写了一个北斗协议解析SDK，方便后续接手项目的同事和进行二次开发的客户实现需求，在这里也分享给各位同行及有志于从事本行业的朋友们交流学习
Linux C++使用TCP通信实现本地客户端与服务端传输文件数据（亲测可用）
ssz__的博客
05-07 2899
这个项目是在本地完成客户端与服务端的数据传输，做这个小项目的目的是为了引出下一个项目在同一局域网条件下，电脑和工控机进行远程无线通信。此时电脑为客户端，工控机为服务端。
Python网络通信~pop3接收邮件
桔子code 的博客
11-13 2894
在Python进阶教程m9b–网络通信–smtplib发送邮件一文中桔子菌给大家介绍了怎么用Python发送邮件，俗话说“来而不往非礼也”，有发就要有收，这篇文章将带大家熟悉下怎么用poplib和email模块接收邮件。 先做好准备工作，仍以163邮箱为例，首先需要先设置好邮箱的授权码，并找到邮箱的pop3服务器地址： 1、创建POP3()实例、登录 首先手动输入接收邮箱的地址和授权码，这里我们用到了getpass模块接收键盘输入的密码，这样密码不会显示在屏幕上，对比input()函数更...
protobuf的简单应用，json和protocol Buffer的转换简单例子
偏执狂才能生存！热忱比专业知识更重要.........
04-27 9490
protobuf的简单应用，json和protocol Buffer的转换简单例子
使用Protocol Buffers入门四步骤
yansmile1的专栏
02-20 4620
Protocol Buffers（简称protobuf）是谷歌的一项技术，用于将结构化的数据序列化、反序列化，经常用于网络传输。 protobuf是谷歌的Protocol Buffers的简称，用于结构化数据和字节码之间互相转换（序列化、反序列化，即实现从结构体转换为字节流（编码，向LIS发送消息时使用）以及从字节流转换为结构体（解码，从LIS接收消息时使用）的功能。），一般应用于网络传输，可支
ppz(paparazzi)开源飞控keil工程源码
11-29
《Paparazzi开源飞控在Keil平台的开发实践》 Paparazzi是一款源自法国的开源无人机控制系统，以其强大的功能和灵活的扩展性在无人机爱好者和开发者中备受推崇。"ppz(paparazzi)开源飞控keil工程源码"提供了将...
参赛-真正无人机神飞控paparazzi apogee,附SCH/PCB/源码-电路方案
04-20
Paparazzi 无人机视频一，教你怎么安装paparazzi系统 https://v.youku.com/v_show/id_XNjk1NDQ5ODM2.html Paparazzi 无人机视频二， paparazzi 安卓下的地面站 https://v.youku.com/v_show/id_XNjk1NDQ5ODIw.html ...
paparazzi的帮助手册
01-26
Paparazzi是一个自由和开源硬件和软件项目，其不仅仅只包括飞控板的软硬件，包括从稳压电源和GPS到卡尔曼滤波代码, 而是一个强大和不断扩大的地面空中软硬件群，包括数传电台，天线和一个高度进化的用户友好的地面...
paparazzi资料
12-06
《Paparazzi无人机控制系统详解》 Paparazzi是一个开源的多旋翼和固定翼无人机飞行控制系统，专为研究人员、爱好者以及专业人士设计。它的核心是飞控软件，能够在Linux系统下运行，提供了完整的飞行控制解决方案，...
Paparazzi! 1.0b11.dmg 用于制作网页屏幕截图。
03-29
狗仔队！是用于macOS的小型实用程序，用于制作网页屏幕截图。 狗仔队！ 1.0需要macOS 10.9或更高版本（当前版本：1.0b11）。 较旧的版本可在下载页面上找到。
在Python中使用protocol buffers参考指南
热门推荐
——
11-30 7万+
Protocol Buffer 入门: Python 本教程提供了一个Python程序员使用protocol buffers的基本的入门教程。通过创建一个简单的示例应用程序,它向您展示了如何 *在一个.proto文件中定义消息的格式。 *使用protocol buffer compiler。 *使用Python protocol buffer API去读写信息。 这不是一个在Pyth
Protocol Buffer介绍
neven7的专栏
07-12 3853
Protocol Buffer是什么？ Protocol Buffer为什么要用它？ Protocol Buffer如何使用它？
解析proto文件，生成协议号工具
foxの笔记本
04-20 1747
说明： 避免了手写协议号，解析proto文件，自动生成协议号cs文件， 提供unity项目使用 原理： 逐行读取proto文件， 判断首行是否设置@protocol_id_start =xxx字段，以该字段号作为协议起始 ，自加生成协议号 用template模板生成csharp文件 ps:设置protocol_id_start字段的目的是proto中会有非通信的消息结构，这些结构并不会参与通信，仅与业务逻辑相关，比如 玩家信息/邮件信息/装备信息等 这些结构建议统一放入...
调试protobuffer接口的神器——luapb
weixin_30955341的博客
01-16 508
luapb和云风写的lua-pbc(git://github.com/cloudwu/pbc.git)并不是一个东西。它们最主要的区别是：pbc虽然也不需要把.proto文件生成.js文件后使用，但是它却需要生成.pb文件；luapb是完全不需要生成任何中间文件，可以直接对.proto文件操作。 luapb是开源的一个小项目，源码也很小。github的连接为:https://gi...
Arduino自定义通信协议解析
面目全非，胸有丘壑 | Json Lee
03-04 1万+
上一篇文章给出了通信协议的设计。通信协议的格式如下： 协议首部 指令长度 控制指令 校验和 “控制指令”设计成如下格式： 设备类型 设备号 端口号 比如说上位机发送如下的格式的数据：AA0305020106，意思就是协议的首部为AA，指令长度为03，控制
Protocol Buffers 介绍（一）
Uncle Wang的专栏
09-23 4564
这段时间项目上接解到了Protocol
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpa
最新发布
09-17
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpaper
IMG_20240917_151703.jpg
09-17
IMG_20240917_151703.jpg
吉他谱_Pneuma - Tool.pdf
09-17
初级入门吉他谱 guitar tab
Paparazzi：开源飞行控制系统详解
"paparazzi是一个开源的飞行控制系统，主要应用于固定翼和多旋翼飞行器。它包含了丰富的模块支持，涵盖了从基础的飞行控制到高级功能如编队飞行和相机控制等。" 在paparazzi飞行控制系统中，各种模块是其核心组成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值