USB和以太网控制TOOL烧录的协议

armfly

应客户要求，公开部分协议。方便客户自行开发USB HID 接口或者以太网接口的PC软件，控制烧录器。
1、USB HID设备识别:

[C] 纯文本查看 复制代码

   /* Get Device's Capabilities */
        HidP_GetCaps(PreparsedData, &Capabilities);
        if ((Capabilities.UsagePage == 0xFF00) && (Capabilities.Usage == 0x0001))
        {
                WCHAR  wbuf[128];
                HidD_GetProductString(DevHandle, wbuf, sizeof(wbuf));

                if (wcsstr(wbuf, L"H7-TOOL HID Communication"))
                {

2、应用层协议为MODBUS RTU。
3、以太网包长按标准MODBUS RTU协议格式，变长。最大1024字节。
4、USB HID包长固定 1024字节，不足时后面补0即可。（注意写数据是写1025字节，首字节固定位0，有用数据从第2个单元开始）

烧录控制逻辑：

前提：用H7-TOOL的PC软件生成配置文件并下传到TOOL内部。自己记录好配置文件路径。

第1步：【06H功能码控制TOOL进入烧录界面】 Tx : 01 06 FF 7F 01 01 48 56
#define REG03_RESET_TO_BOOT     0xFF7F  /* 特殊寄存器，复位进入BOOT
值含义:
    #define JUMP_TO_APP                 0x0001  /* 复位，重新进入APP */
    #define JUMP_TO_PROGRAMMER_DO_ONCE  0x0008  /*  烧录1次 */
    #define PROG_ENTER_SINGLE           0x0101  /* 进入单路烧录 */
    #define PROG_ENTER_MUL_1_4          0x0102  /* 进入多路模式,1-4 */
    #define PROG_ENTER_MUL_1_3          0x0103  /* 进入多路模式,1-3 */
    #define PROG_ENTER_MUL_1_2          0x0104  /* 进入多路模式,1-2 */
    #define PROG_ENTER_MUL_1            0x0105  /* 进入多路模式,第1路 */
    #define PROG_ENTER_MUL_2            0x0106  /* 进入多路模式,第2路 */
    #define PROG_ENTER_MUL_3            0x0107  /* 进入多路模式,第3路 */
    #define PROG_ENTER_MUL_4            0x0108  /* 进入多路模式,第4路 *

第2步：【66H功能码修改缺省的烧录配置文件】
选择文件
        主机发送: 小程序数据
            01  ; 站号
            66  ; 功能码
            0001  ; 子功能, 3写脱机烧录启动文件。
            0000 0000 : 偏移地址 4字节
            0020 0000 : 数据长度 4字节
            ... 数据
            CCCC      : CRC16

        从机应答:
            01  ; 从机地址
            66  ; 功能码   
            0000  ; 子功能
            0000 0000 : 偏移地址 4字节
            0020 0000 : 数据长度 4字节

            00  ; 执行结果，0表示OK  1表示错误
            CCCC : CRC16
数据字段内容范例：  0:/H7-TOOL/Programmer/User/简配/V1.8a/简配数据采集终端.lua
GB2312编码，末尾补0，不加引号


第3步【06H功能码 启动烧录1次】
寄存器 0xFF7F  写入  0x0008
Tx : 01 06 FF 7F 00 08 89 C0

第4步【03H功能码查询烧录进度】
/* 脱机烧录状态字 - 只读。 写时无动作 */
#define REG03_PROG_STATE_HEAD       0x0800  /* 总体烧录状态  0=空闲，1=烧录中，2=烧录完成 */
#define REG03_PROG_STATE_1          0x0801  /* 第1路烧录状态 0=烧录中  1=OK  2=NG */
#define REG03_PROG_STATE_2          0x0802  /* 第2路烧录状态 */
#define REG03_PROG_STATE_3          0x0803  /* 第3路烧录状态 */
#define REG03_PROG_STATE_4          0x0804  /* 第4路烧录状态 */
#define REG03_PROG_STATE_5          0x0805  /* 第5路烧录状态 */
#define REG03_PROG_STATE_6          0x0806  /* 第6路烧录状态 */
#define REG03_PROG_STATE_7          0x0807  /* 第7路烧录状态 */
#define REG03_PROG_STATE_8          0x0808  /* 第8路烧录状态 */
#define REG03_PROG_STATE_9          0x0809  /* 第9路烧录状态 */
#define REG03_PROG_STATE_10         0x080A  /* 第10路烧录状态 */
#define REG03_PROG_STATE_11         0x080B  /* 第11路烧录状态 */
#define REG03_PROG_STATE_12         0x080C  /* 第12路烧录状态 */
#define REG03_PROG_STATE_13         0x080D  /* 第13路烧录状态 */
#define REG03_PROG_STATE_14         0x080E  /* 第14路烧录状态 */
#define REG03_PROG_STATE_15         0x080F  /* 第15路烧录状态 */
#define REG03_PROG_STATE_16         0x0810  /* 第16路烧录状态 */

第5步：【跳到第3步】，循环烧录。


D0-D9控制逻辑：
1、配置D0-D9的方向。 用06H功能码写如下寄存器
#define REG03_D0_GPIO_MODE          0x0140  /* DO口的GPIO模式 - 0=输入，1=输出 2=其他特殊功能 */
#define REG03_D1_GPIO_MODE          0x0141
#define REG03_D2_GPIO_MODE          0x0142
#define REG03_D3_GPIO_MODE          0x0143
#define REG03_D4_GPIO_MODE          0x0144
#define REG03_D5_GPIO_MODE          0x0145
#define REG03_D6_GPIO_MODE          0x0146
#define REG03_D7_GPIO_MODE          0x0147
#define REG03_D8_GPIO_MODE          0x0148
#define REG03_D9_GPIO_MODE          0x0149

2、设置D0-D9引脚状态 ，用05H功能码写单个引脚，用10H功能码写多个引脚
#define REG01_Y01 0x0000 /* D0输出状态，0表示断开，1表示闭合 */
#define REG01_Y02 0x0001 /* D1输出状态 */
#define REG01_Y03 0x0002 /* D2输出状态 */
#define REG01_Y04 0x0003 /* D3输出状态 */
#define REG01_Y05 0x0004 /* D4输出状态 */
#define REG01_Y06 0x0005 /* D5输出状态 */
#define REG01_Y07 0x0006 /* D6输出状态 */
#define REG01_Y08 0x0007 /* D7输出状态 */
#define REG01_Y09 0x0008 /* D8输出状态 */
#define REG01_Y10 0x0009 /* D9输出状态 */
注意: 生成配置文件时，机台接口请选择禁用。
SWD数据端口占用如下口线：
D8 : SWDIO
D6 : SWCLK
D4 : RESET
其余口
D7 : 单路模式占用，做启动信号
D1 : 多路模式占用，做启动信号

可用口：D0 D2 D3 D5 D6  D9
其中D9口有10K上拉电阻。


3、读取输出引脚状态。 用01H功能码读取 0000 - 0009 寄存器值
4、读取引脚输入状态。用02H功能码读取 0000 - 0009 寄存器值


其他相关功能：
【1】TOOL也有RS232串口、RS485串口、TTL串口控制烧录器的协议：

【新提醒】为方便客户通过PC软件控制烧录器，V2.15固件已实现RS232串口协议 - H7-TOOL开发工具 - 硬汉嵌入式论坛 - Powered by Discuz! (armbbs.cn)

【2】H7-TOOL标配的PC软件可以屏蔽多余功能，只保留烧录器功能。方法如下：


【3】H7-TOOL设备上电直接进入脱机烧录界面，其他界面禁止进入。
设置方法如下：
     
开机启动参数修改为： 单路烧录。

armfly

读取和控制UART\RTT的协议

[C] 纯文本查看 复制代码

PC软件定时执行 ReadPrint(0) 
通过 MODH_61H() 解析TOOL返回结果


/*
*********************************************************************************************************
*	函 数 名: udp_Send61H
*	功能说明: 发送61h指令,
*	形    参:
*	返 回 值: 无
*********************************************************************************************************
*/
void udp_Send61HEx(uint8_t _485Addr, uint16_t _func, uint32_t _rxlen,  uint16_t _txId, uint32_t _txlen, uint8_t *_txbuf)
{
    /*
        主机发送: 查询H7-TOOL有没printf数据上报，或者CAN, UART数据
            01  ; 站号
			61  ; 功能码
			0001  ; 子功能,
				H61_PRINT   		= 0,
				H61_RTT_VIEWER   	= 1,
				H61_UART	        = 2,
				H61_CAN  	        = 3,
			0020 0000 : 需要读取的数据最大长度 4字节 （0表示自动）
			0001 : 下传通道号
			0020 0000 : 需要携带下传的数据
            ... 数据
            CCCC      : CRC16

        从机应答:
            01  ; 从机地址
			61  ; 功能码
			0000 ; 子功能
			0020 0000 : 实际上报的数据长度 4字节 ， 0表示没有数据上报
			... 数据
            CCCC : CRC16
	*/
	uint8_t pos = 0;
	uint16_t crc;
	uint32_t i;

	g_tCmd.RS485Addr = _485Addr;

	if (_txlen > TX_BUF_SIZE - 10)
	{
		return;
	}

	g_tCmd.RxOk = 0;

	s_TxLen = 0;
	s_TxBuf[s_TxLen++] = g_tCmd.RS485Addr;
	s_TxBuf[s_TxLen++] = 0x61;			/* 功能码 */
	s_TxBuf[s_TxLen++] = _func >> 8;
	s_TxBuf[s_TxLen++] = _func >> 0;

	s_TxBuf[s_TxLen++] = _rxlen >> 24;
	s_TxBuf[s_TxLen++] = _rxlen >> 16;
	s_TxBuf[s_TxLen++] = _rxlen >> 8;
	s_TxBuf[s_TxLen++] = _rxlen >> 0;

	s_TxBuf[s_TxLen++] = _txId >> 8;
	s_TxBuf[s_TxLen++] = _txId >> 0;

	s_TxBuf[s_TxLen++] = _txlen >> 24;
	s_TxBuf[s_TxLen++] = _txlen >> 16;
	s_TxBuf[s_TxLen++] = _txlen >> 8;
	s_TxBuf[s_TxLen++] = _txlen >> 0;

	for (i = 0; i < _txlen; i++)
	{
		s_TxBuf[s_TxLen++] =  _txbuf[i];
	}

	crc = CRC16_Modbus(s_TxBuf, s_TxLen);
	s_TxBuf[s_TxLen++] = crc >> 8;
	s_TxBuf[s_TxLen++] = crc;

	udp_SendBuf(s_TxBuf,  s_TxLen);
}
void udp_Send61H(uint16_t _func, uint32_t _rxlen,  uint16_t _txId, uint32_t _txlen, uint8_t *_txbuf)
{
	 udp_Send61HEx(1, _func,   _rxlen,   _txId,  _txlen,  _txbuf);
}


// ReadPrint
void __fastcall TFormTcp::ReadPrint(uint32_t _func)
{
	uint16_t func;

	uint16_t PackagLen = 1024;

	if (g_tIniParam.CommInterface == COMM_IF_USB_COM)     /* USB虚拟串口 */
	{
		PackagLen = 1024;
	}
	else if (g_tIniParam.CommInterface == COMM_IF_RJ45)  /* 网口和WIFI , TCP UDP协议 */
	{
		PackagLen = 1024;
	}
	else if (g_tIniParam.CommInterface == COMM_IF_USB_HID)  /* USB HID */
	{
		PackagLen = 4096;
	}

	/*
		H61_PRINT   		= 0,
		H61_RTT_VIEWER   	= 1,
		H61_UART	        = 2,
		H61_CAN  	        = 3,
	*/
	func = H61_PRINT;
	while (g_tCmd.CmdStatus != 0 && FormTcp->RequestClose == 0)
	{
		// 通信异常处理
		if (g_tCmd.LinkStateErr == 1)
		{
			g_tCmd.CmdStatus = CMDS_INIT_COMM_PORT;
			return;
		}

		switch (g_tCmd.CmdStatus)
		{
			/*-------读print数据----------*/
			case CMDS_READ_PRINT:

				udp_Send61H(H61_PRINT + 0x100, 1024, 0, 0, 0);  // 高字节表示首发命令
				if (H7_WaitResponse(ACK_61H, MODS_CMD_TIMEOUT) == 0)
				{
					g_tCmd.CmdStatus++;
				}
				else
				{
					g_tCmd.CmdStatus = 0;
				}
				break;

			case CMDS_READ_PRINT + 1:
				if (func == H61_PRINT)
				{
					udp_Send61H(func, PackagLen, 0, 0, 0);
				}
				else  /* 可以携带数据下传 */
				{
					uint8_t txbuf[2048];
					uint32_t i;
					uint32_t len = 0;
					uint32_t TxWrite;
					//uint16_t ChanId = 0;

					if (func == H61_UART)
					{
						try
						{
							if (FormUart->fUartClearCounter == 1)
							{
								FormUart->fUartClearCounter = 0;
								func = func + 0x0100;
							}

							TxWrite =  g_tUartTerFifo.TxWrite;

							for (i = 0; i < 1000; i++)
							{
								if (g_tUartTerFifo.TxRead == TxWrite)
								{
									break;
								}

								txbuf[len++] = g_tUartTerFifo.TxBuf[g_tUartTerFifo.TxRead];
								if (++g_tUartTerFifo.TxRead >= TER_TX_FIFO_SIZE)
								{
									g_tUartTerFifo.TxRead = 0;
								}
							}

						}
						catch (Exception &e)
						{
//							AnsiString s;
//							s = "CMDS_READ_PRINT+1 异常 : func = " + IntToStr((int)func) ;
//							SendMsgPrint(s.c_str());
//
//							g_tCmd.CmdStatus = 0;
//							break;
						}
					}
					else if (func == H61_RTT_VIEWER)
					{
						TxWrite =  g_tRttTerFifo.TxWrite;
						for (i = 0; i < 1000; i++)
						{
							if (g_tRttTerFifo.TxRead == TxWrite)
							{
								break;
							}

							txbuf[len++] = g_tRttTerFifo.TxBuf[g_tRttTerFifo.TxRead];
							if (++g_tRttTerFifo.TxRead >= g_tRttTerFifo.TxFifoSize)
							{
								g_tRttTerFifo.TxRead = 0;
							}
						}
					}
					else if (func == H61_CAN)
					{
						try
						{
							if (FormCan->fCanClearCounter == 1)
							{
								FormCan->fCanClearCounter = 0;
								func = func + 0x0100;
							}

							TxWrite =  g_tCanTerFifo.TxWrite;

							for (i = 0; i < 1000; i++)
							{
								if (g_tCanTerFifo.TxRead == TxWrite)
								{
									break;
								}

								txbuf[len++] = g_tCanTerFifo.TxBuf[g_tCanTerFifo.TxRead];
								if (++g_tCanTerFifo.TxRead >= TER_TX_FIFO_SIZE)
								{
									g_tCanTerFifo.TxRead = 0;
								}
							}

						}
						catch (Exception &e)
						{
							AnsiString s;
							s = "CMDS_READ_PRINT+1 异常 : func = " + IntToStr((int)func) ;
							SendMsgPrint(s.c_str());

							g_tCmd.CmdStatus = 0;
							break;
						}
					}
					else if (func == H61_ADC)
					{
						try
						{
//							if (FormCan->fCanClearCounter == 1)
//							{
//								FormCan->fCanClearCounter = 0;
//								func = func + 0x0100;
//							}

							TxWrite =  g_tAdcFifo.TxWrite;

							for (i = 0; i < 1000; i++)
							{
								if (g_tAdcFifo.TxRead == TxWrite)
								{
									break;
								}

								txbuf[len++] = g_tAdcFifo.TxBuf[g_tAdcFifo.TxRead];
								if (++g_tAdcFifo.TxRead >= TER_TX_FIFO_SIZE)
								{
									g_tAdcFifo.TxRead = 0;
								}
							}

						}
						catch (Exception &e)
						{
							AnsiString s;
							s = "CMDS_READ_PRINT+1 异常 : func = " + IntToStr((int)func) ;
							SendMsgPrint(s.c_str());

							g_tCmd.CmdStatus = 0;
							break;
						}
					}

					else
					{
						g_tCmd.CmdStatus = 0;
						break;
					}

					//udp_Send61H(func, 1024, ChanId, len, txbuf);

					// modbus 虚拟从机需要发送
					{
						if (FormUart->mPCSendChanId >= 100)
						{
							udp_Send61H(func, PackagLen, FormUart->mPCSendChanId - 100, len, txbuf);

							/* 还原发送通道 */
							if (len > 0)
							{
								FormUart->mPCSendChanId = FormUart->ComboBoxSendUartNo->ItemIndex;
							}
						}
						else
						{
							//if (func == H61_RTT_VIEWER) bsp_AddLog(" READ_PRINT H61_RTT_VIEWER");
							//else if (func == H61_UART) bsp_AddLog(" READ_PRINT H61_UART");
							//else if (func == H61_CAN) bsp_AddLog(" READ_PRINT H61_CAN");

							udp_Send61H(func, PackagLen, FormUart->mPCSendChanId, len, txbuf);
						}
					}
				}

				try
				{
					if (H7_WaitResponse(ACK_61H, MODS_CMD_TIMEOUT) == 0)  // 通信成功 100 改为1秒
					{
						if (FormTcp->H61_RxNewData == 1) // 有新数据 继续读
						{
							if (g_tCmd.UserReq == 1)    /* 优先响应用户指令 */
							{
								g_tCmd.CmdStatus = CMDS_READ_PRINT + 2;
							}
							else
							{
								FormTcp->H61_RxNewData = 0;
								g_tCmd.CmdStatus = CMDS_READ_PRINT + 1;
							}
						}
						else
						{
							uint8_t MaxFunc;

							if (g_tDevPa.AppVer == 0) 	// 未读到APP 版本时
							{
								MaxFunc = H61_CAN;
							}
							else if (g_tDevPa.AppVer < 0x205) // V2.05才支持CAN
							{
								MaxFunc = H61_UART;
							}
							else if (g_tDevPa.AppVer < 0x222) // V2.22 才支持ADC1 ADC2
							{
								MaxFunc = H61_CAN;
							}
							else
							{
								MaxFunc = H61_ADC;
							}

							if (++func > MaxFunc)
							{
								g_tCmd.CmdStatus = CMDS_READ_PRINT + 2;  /* 6个通道数据采集完毕 */
							}
							else
							{
								g_tCmd.CmdStatus = CMDS_READ_PRINT + 1;
							}
						}
					}
					else  // 通信超时
					{
						//bsp_AddLog("  -1 Timeout ");

						SetCommState(-1);	/* 改变指示灯 */
						g_tCmd.CmdStatus = 0;
					}
				}
				catch (Exception &e)
				{
					AnsiString s;
					s = "H7_WaitResponse(ACK_61H)异常: " + e.Message;
					SendMsgPrint(s.c_str());

					g_tCmd.LinkStateErr = 1;
					g_tCmd.CmdStatus = CMDS_INIT_COMM_PORT;
					//g_tCmd.CmdStatus = 0;
				}
				break;

			case CMDS_READ_PRINT + 2:
				g_tCmd.CmdStatus = 0;
				break;

			default:
				g_tCmd.CmdStatus = 0;
				break;
		}
	}
}


// 解析 61H命令

void __fastcall TFormTcp::MODH_61H(uint8_t *_rx_buf, uint16_t _len)
{
	/*
			主机发送: 查询H7-TOOL有没printf数据上报，或者CAN, UART数据
				01  ; 站号
				61  ; 功能码
				0001  ; 子功能,   高byte = 1 表示需要清FIFO
					H61_PRINT   		= 0,
					H61_RTT_VIEWER   	= 1,
					H61_UART1	        = 2,
					H61_UART2	        = 3,
					H61_UART3	        = 4,
					H61_CAN  	        = 5,

					H61_ADC1            = 6
                    H61_ADC2            = 7
				0020 0000 : 需要读取的数据最大长度 4字节 （0表示自动）
				0020 0000 : 需要携带下传的数据
				... 数据
				CCCC      : CRC16

			从机应答:
				01  ; 从机地址
				61  ; 功能码
				0000 ; 子功能
				0020 0000 : 实际上报的数据长度 4字节 ， 0表示没有数据上报
				... 数据
				CCCC : CRC16
    */
	uint16_t func;
	uint8_t ch;
	uint32_t len;
	uint16_t pos;

	pos = 2;
	func = BEBufToUint16(&_rx_buf[pos]) & 0xFF;
	pos += 2;
	len = BEBufToUint32(&_rx_buf[pos]);
	pos += 4;

	if (func == H61_PRINT)
	{
		if (Form1->CheckBoxPause->Checked == false)
		{
			for (int i = 0; i < len; i++)
			{
				g_tPrintFifo.RxBuf[g_tPrintFifo.RxWrite] = _rx_buf[pos++];
				if (++g_tPrintFifo.RxWrite >= g_tPrintFifo.RxFifoSize)
				{
					g_tPrintFifo.RxWrite = 0;
				}
			}

			if (len > 0)
			{
				FormTcp->H61_RxNewData = 1; 	// 表示有新数据，通知轮询程序继续读
				if (g_tPrintFifo.NewMsg == 0)
				{
					g_tPrintFifo.NewMsg = 1;
					PostMessage(FormTcp->Handle, WM_USER_DISP_PRINT_STREAM, 0, 0);
				}
				else
				{
					g_tPrintFifo.NewMsg = 1;	// 速度慢了 来这里
					PostMessage(FormTcp->Handle, WM_USER_DISP_PRINT_STREAM, 0, 0);
				}
			}
		}

	}
	else if (func == H61_UART)
	{
		/* 先保存前8字节，TOOL记录的2个串口接收字节总数 */
		mTerUartRxCount1 = BEBufToUint32(_rx_buf + pos);  pos += 4;
		mTerUartRxCount2 = BEBufToUint32(_rx_buf + pos);  pos += 4;

		for (int i = 0; i < len - 8; i++)
		{
			g_tUartTerFifo.RxBuf[g_tUartTerFifo.RxWrite] = _rx_buf[pos++];
			if (++g_tUartTerFifo.RxWrite >= g_tUartTerFifo.RxFifoSize)
			{
				g_tUartTerFifo.RxWrite = 0;
			}
		}

		if (len > 8)
		{
			FormTcp->H61_RxNewData = 1; 	// 表示有新数据，通知轮询程序继续读

			if (g_tUartTerFifo.NewMsg == 0)
			{
				g_tUartTerFifo.NewMsg = 1;
				// PostMessage(FormTcp->Handle, WM_USER_DISP_UART_STREAM, 0, 0);
			}
			else
			{
				g_tUartTerFifo.NewMsg = 1;	// 速度慢了 来这里
			}
		}
	}
	else if (func == H61_CAN)
	{
		/* 先保存前8字节，TOOL记录的1个串口接收总行数 */
		mTerCanRxCount1 = BEBufToUint32(_rx_buf + pos);  pos += 4;
		mTerCanRxCount2 = BEBufToUint32(_rx_buf + pos);  pos += 4;

		for (int i = 0; i < len - 8; i++)
		{
			g_tCanTerFifo.RxBuf[g_tCanTerFifo.RxWrite] = _rx_buf[pos++];
			if (++g_tCanTerFifo.RxWrite >= g_tCanTerFifo.RxFifoSize)
			{
				g_tCanTerFifo.RxWrite = 0;
			}
		}

		if (len > 8)
		{
			FormTcp->H61_RxNewData = 1; 	// 表示有新数据，通知轮询程序继续读

			if (g_tCanTerFifo.NewMsg == 0)
			{
				g_tCanTerFifo.NewMsg = 1;
				//FormTcp->PostMsgCode(WM_USER_DISP_CAN_STREAM, 0);
			}
			else
			{
				g_tCanTerFifo.NewMsg = 1;	// 速度慢了 来这里
			}
		}
	}
	else if (func == H61_RTT_VIEWER)
	{
		for (int i = 0; i < len; i++)
		{
			g_tRttTerFifo.RxBuf[g_tRttTerFifo.RxWrite] = _rx_buf[pos++];
			if (++g_tRttTerFifo.RxWrite >= g_tRttTerFifo.RxFifoSize)
			{
				g_tRttTerFifo.RxWrite = 0;
			}

			if (g_tRttTerFifo.RxWrite == g_tRttTerFifo.RxRead)
			{
				/* fifo 满了 */
				g_tRttTerFifo.Full = 1;

				{
					unsigned int wParam;
					long lParam;

					wParam = (unsigned int)"FIFO满了";
					lParam = 0;
					SendMessage(FormTcp->Handle, WM_USER_RTT_MEMO1_DISP, wParam, lParam);
				}
			}
		}

		if (len > 0)
		{
			FormTcp->H61_RxNewData = 1; 	// 表示有新数据，通知轮询程序继续读

			if (g_tRttTerFifo.NewMsg == 0)
			{
				g_tRttTerFifo.NewMsg = 1;
				// PostMessage(FormTcp->Handle, WM_USER_DISP_RTT_STREAM, 0, 0);
			}
			else
			{
				g_tRttTerFifo.NewMsg = 1;	// 速度慢了 来这里
			}
		}
	}
}