调整一下

diff --git a/Core/AdcFilter.c b/Core/AdcFilter.c
index 0c43834..046089b 100644
--- a/Core/AdcFilter.c
+++ b/Core/AdcFilter.c
@@ -1,14 +1,13 @@
 
 #include "AdcFilter.h"
-#include "math.h"
 
-/// <summary>初始化滤波器</summary>
+/** @brief 初始化滤波器 */
 bool AdcFilterInit(AdcFilter_t* filter, short size)
 {
     if(filter == NULL)return false;
     if(size < 4)size = 4;
     
-    filter->Data = (short*)malloc(sizeof(short)*size);
+    filter->Data = (short*)GlobleMalloc(sizeof(short)*size);
     if(filter->Data == NULL)return false;
 
     memset(filter->Data, 0, sizeof(short)*size);
@@ -17,10 +16,12 @@ bool AdcFilterInit(AdcFilter_t* filter, short size)
     return true;
 }
 
-/// <summary>滤波数据</summary>
-/// <param name="filter">滤波器</param>
-/// <param name="data">原始数据</param>
-/// <returns>数据放入成功</returns>
+/**
+ * @brief 滤波数据
+ * @param filter 滤波器
+ * @param data 原始数据
+ * @return 数据放入成功
+ */
 bool AdcFilterPush(AdcFilter_t* filter,short data)
 {
     if(filter == NULL)return false;
@@ -35,11 +36,13 @@ bool AdcFilterPush(AdcFilter_t* filter,short data)
     return true;
 }
 
-/// <summary>滤波数据</summary>
-/// <param name="filter">滤波器</param>
-/// <param name="valueMax">X Y 的最大值，绝对值</param>
-/// <param name="outRange">换算为这个范围，ADC数值转换为对外输出范围，绝对值</param>
-/// <returns>滤波之后的数据</returns>
+/**
+ * @brief 滤波数据
+ * @param filter 滤波器
+ * @param valueMax X Y 的最大值，绝对值
+ * @param outRange 换算为这个范围，ADC数值转换为对外输出范围，绝对值
+ * @return 滤波之后的数据
+ */
 short AdcFilterCalc(AdcFilter_t* filter, int valueMax, int outRange)
 {
     // 滤波
@@ -48,9 +51,11 @@ short AdcFilterCalc(AdcFilter_t* filter, int valueMax, int outRange)
     int max = INT32_MIN;
     for(int i = 0; i < filter->Size; i++)
     {
-        sum += filter->Data[i];
-        if(filter->Data[i] < min)min = filter->Data[i];
-        if(filter->Data[i] > max)max = filter->Data[i];
+        volatile short data = filter->Data[i];
+
+        sum += data;
+        if(data < min)min = data;
+        if(data > max)max = data;
     }
     // 去除最大最小值
     sum -= min;
@@ -60,7 +65,76 @@ short AdcFilterCalc(AdcFilter_t* filter, int valueMax, int outRange)
     int result = sum / (filter->Size - 2);
 
     // 范围转换
+    if(valueMax == outRange)return result;
     result = (result * outRange) / valueMax;
     return (short)result;
 }
 
+
+/** @brief 初始化ADC范围,计算完K B之后会调整 adc Min Max 范围 */
+bool AdcScopeInit(AdcScope_t* scope, ushort adcMin, ushort adcMax, int valueMin, int valueMax)
+{
+    scope->ValueMax = valueMax;
+	scope->ValueMin = valueMin;
+	scope->AdcMax = adcMax;
+	scope->AdcMin = adcMin;
+    // 计算K和B值
+    scope->K = (float)(valueMax - valueMin) / (adcMax - adcMin);
+    scope->B = valueMin - (scope->K * adcMin);
+    
+    return true;
+}
+
+/**
+ * @brief 范围矫正
+ * @param filter 滤波器
+ * @param scope 范围
+ * @param fixThr 修正阈值，ADC抖动大于这个值，不进行范围矫正
+ * @return double 
+ */
+double AdcScopeCalc_Double(AdcFilter_t* filter,AdcScope_t* scp,int fixThr)
+{
+    if(scp->K < 0.0)return -1;
+
+    int adc = AdcFilterCalc(filter, 4096,4096);
+    // 超出修正范围返回 -1
+    if(adc + fixThr < scp->AdcMin)return -1;
+    if(adc - fixThr > scp->AdcMax)return -1;
+    // 超出范围，修正范围
+    if(adc < scp->AdcMin)adc = scp->AdcMin;
+    if(adc > scp->AdcMax)adc = scp->AdcMax;
+    // 计算
+    int result = adc * scp->K + scp->B;
+    // 结果限定一下，避免因为K B 计算不准，导致结果超出范围
+    if(result < scp->ValueMin)return scp->ValueMin;
+    if(result > scp->ValueMax)return scp->ValueMax;
+
+    return result;
+}
+
+/**
+ * @brief 范围矫正
+ * @param filter 滤波器
+ * @param scope 范围
+ * @param fixThr 修正阈值，ADC抖动大于这个值，不进行范围矫正
+ * @return int 
+ */
+int AdcScopeCalc(AdcFilter_t* filter,AdcScope_t* scp,int fixThr)
+{
+    if(scp->K < 0.0)return -1;
+
+    int adc = AdcFilterCalc(filter, 4096,4096);
+    // 超出修正范围返回 -1
+    if(adc + fixThr < scp->AdcMin)return -1;
+    if(adc - fixThr > scp->AdcMax)return -1;
+    // 超出范围，修正范围
+    if(adc < scp->AdcMin)adc = scp->AdcMin;
+    if(adc > scp->AdcMax)adc = scp->AdcMax;
+    // 计算
+    int result = (int)(adc * scp->K + scp->B);
+    // 结果限定一下，避免因为K B 计算不准，导致结果超出范围
+    if(result < scp->ValueMin)return scp->ValueMin;
+    if(result > scp->ValueMax)return scp->ValueMax;
+
+    return result;
+}

diff --git a/Core/AdcFilter.h b/Core/AdcFilter.h
index f64c6b2..c2aeed8 100644
--- a/Core/AdcFilter.h
+++ b/Core/AdcFilter.h
@@ -2,7 +2,7 @@
 
 #include "Type.h"
 
-/// <summary>滤波器</summary>
+/** @brief 滤波器 */
 typedef struct
 {
     short* Data;
@@ -11,19 +11,60 @@ typedef struct
 }AdcFilter_t;
 
 
-/// <summary>初始化滤波器</summary>
+/** @brief 初始化滤波器 */
 bool AdcFilterInit(AdcFilter_t* filter, short size);
 
-/// <summary>滤波数据</summary>
-/// <param name="filter">滤波器</param>
-/// <param name="data">原始数据</param>
-/// <returns>数据放入成功</returns>
+/**
+ * @brief 滤波数据
+ * @param filter 滤波器
+ * @param data 原始数据
+ * @return 数据放入成功
+ */
 bool AdcFilterPush(AdcFilter_t* filter,short data);
 
-/// <summary>滤波数据</summary>
-/// <param name="filter">滤波器</param>
-/// <param name="valueMax">X Y 的最大值，绝对值</param>
-/// <param name="outRange">换算为这个范围，ADC数值转换为对外输出范围，绝对值</param>
-/// <returns>滤波之后的数据</returns>
+/**
+ * @brief 滤波数据
+ * @param filter 滤波器
+ * @param valueMax X Y 的最大值，绝对值
+ * @param outRange 换算为这个范围，ADC数值转换为对外输出范围，绝对值
+ * @return 滤波之后的数据
+ */
 short AdcFilterCalc(AdcFilter_t* filter, int valueMax, int outRange);
 
+/** @brief ADC范围 */
+// 注意：AdcMin AdcMax K 都是正数，K B 是计算加速
+typedef struct
+{
+    ushort AdcMin;
+    ushort AdcMax;
+
+    int ValueMin;
+    int ValueMax;
+
+    // Y = KX + B
+    double K;
+    // Y = KX + B
+    double B;
+}AdcScope_t;
+
+/** @brief 初始化ADC范围,计算K B */
+bool AdcScopeInit(AdcScope_t* scope, ushort adcMin, ushort adcMax, int valueMin, int valueMax);
+
+/**
+ * @brief 范围矫正
+ * @param filter 滤波器
+ * @param scope 范围
+ * @param fixThr 修正阈值，ADC抖动大于这个值，不进行范围矫正
+ * @return double 
+ */
+double AdcScopeCalc_Double(AdcFilter_t* filter,AdcScope_t* scp,int fixThr);
+
+/**
+ * @brief 范围矫正
+ * @param filter 滤波器
+ * @param scope 范围
+ * @param fixThr 修正阈值，ADC抖动大于这个值，不进行范围矫正
+ * @return int 
+ */
+int AdcScopeCalc(AdcFilter_t* filter,AdcScope_t* scope,int fixThr);
+

diff --git a/Core/Array.c b/Core/Array.c
index f6b5454..4a2c0c0 100644
--- a/Core/Array.c
+++ b/Core/Array.c
@@ -88,7 +88,7 @@ int ArrayIndexOfBuff(Buffer_t* src, Buffer_t* sub)
 	if (src == NULL)return -1;
 	if (sub == NULL)return -1;
 
-	return ArrayIndexOf(src->p, src->len, sub->p, sub->len);
+	return ArrayIndexOf(src->Data, src->Len, sub->Data, sub->Len);
 }
 
 int ArrayIndexOfBuff2(Buffer2_t* src, Buffer2_t* sub)
@@ -96,7 +96,7 @@ int ArrayIndexOfBuff2(Buffer2_t* src, Buffer2_t* sub)
 	if (src == NULL)return -1;
 	if (sub == NULL)return -1;
 
-	return ArrayIndexOf(src->data, src->len, sub->data, sub->len);
+	return ArrayIndexOf(src->Data, src->Len, sub->Data, sub->Len);
 }
 
 int ArrayLastIndexOf(byte* src, int srclen, byte* sub, int sublen)
@@ -136,7 +136,7 @@ int ArrayLastIndexOfBuff(Buffer_t* src, Buffer_t* sub)
 	if (src == NULL)return -1;
 	if (sub == NULL)return -1;
 
-	return ArrayLastIndexOf(src->p, src->len, sub->p, sub->len);
+	return ArrayLastIndexOf(src->Data, src->Len, sub->Data, sub->Len);
 }
 
 int ArrayLastIndexOfBuff2(Buffer2_t* src, Buffer2_t* sub)
@@ -144,7 +144,7 @@ int ArrayLastIndexOfBuff2(Buffer2_t* src, Buffer2_t* sub)
 	if (src == NULL)return -1;
 	if (sub == NULL)return -1;
 
-	return ArrayLastIndexOf(src->data, src->len, sub->data, sub->len);
+	return ArrayLastIndexOf(src->Data, src->Len, sub->Data, sub->Len);
 }
 
 void ArrayReverse(byte* data, int len)
@@ -173,14 +173,14 @@ void ArrayReverseBuff(Buffer_t* buff)
 {
 	if (buff == NULL)return;
 
-	ArrayReverse(buff->p, buff->len);
+	ArrayReverse(buff->Data, buff->Len);
 }
 
 void ArrayReverseBuff2(Buffer2_t* buff)
 {
 	if (buff == NULL)return;
 
-	ArrayReverse(buff->data, buff->len);
+	ArrayReverse(buff->Data, buff->Len);
 }
 
 void ArraySortByte(byte* data, int len)
@@ -295,11 +295,13 @@ int HexToArray(char* hex, int len, byte* bs)
 	return len;
 }
 
-/// <summary>二分法查询</summary>
-/// <param name="array">从小到大排序的数组</param>
-/// <param name="len">数组长度</param>
-/// <param name="value">查询值</param>
-/// <returns>返回第一个有效值。 -1 未找到</returns>
+/**
+ * @brief 二分法查询
+ * @param array 从小到大排序的数组
+ * @param len 数组长度
+ * @param value 查询值
+ * @return 返回第一个有效值。 -1 未找到
+ */
 int DichotomyFind_Int(int* array, int len, int value)
 {
 	if (array == NULL)return -1;
@@ -331,12 +333,14 @@ int DichotomyFind_Int(int* array, int len, int value)
 	}
 }
 
-/// <summary>二分法，从结构体查询</summary>
-/// <param name="array">结构体数组，按照KEY从小到大排序</param>
-/// <param name="len">结构体长度</param>
-/// <param name="func">获取KEY方法</param>
-/// <param name="key">查询项</param>
-/// <returns>返回第一个有效值。 -1 未找到</returns>
+/**
+ * @brief 二分法，从结构体查询
+ * @param array 结构体数组，按照KEY从小到大排序
+ * @param len 结构体长度
+ * @param func 获取KEY方法
+ * @param key 查询项
+ * @return 返回第一个有效值。 -1 未找到
+ */
 int DichotomyFind_Obj(void* array, int len, DichotomyGetKey func, int key)
 {
 	if (array == NULL)return -1;

diff --git a/Core/Array.h b/Core/Array.h
index 514cc14..e68d262 100644
--- a/Core/Array.h
+++ b/Core/Array.h
@@ -1,6 +1,7 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
+#include "Buffer.h"
 
 // 返回第一个符合的位置
 // 没有找到返回 -1
@@ -42,24 +43,28 @@ int ArrayToHex(byte* bs, int len, char* hex);
 int HexToArray(char* hex, int len, byte* bs);
 
 
-/// <summary>二分法查询</summary>
-/// <param name="array">从小到大排序的数组</param>
-/// <param name="len">数组长度</param>
-/// <param name="value">查询值</param>
-/// <returns>返回第一个有效值。 -1 未找到</returns>
+/**
+ * @brief 二分法查询
+ * @param array 从小到大排序的数组
+ * @param len 数组长度
+ * @param value 查询值
+ * @return 返回第一个有效值。 -1 未找到
+ */
 int DichotomyFind_Int(int* array, int len, int value);
 
 
 
-/// <summary>提取KEY。二分法查询结构体时使用</summary>
+/** @brief 提取KEY。二分法查询结构体时使用 */
 typedef int(*DichotomyGetKey)(void* array, int idx);
 
-/// <summary>二分法，从结构体查询</summary>
-/// <param name="array">结构体数组，按照KEY从小到大排序</param>
-/// <param name="len">结构体长度</param>
-/// <param name="func">获取KEY方法</param>
-/// <param name="key">查询项</param>
-/// <returns>返回第一个有效值。 -1 未找到</returns>
+/**
+ * @brief 二分法，从结构体查询
+ * @param array 结构体数组，按照KEY从小到大排序
+ * @param len 结构体长度
+ * @param func 获取KEY方法
+ * @param key 查询项
+ * @return 返回第一个有效值。 -1 未找到
+ */
 int DichotomyFind_Obj(void* array, int len, DichotomyGetKey func, int key);
 
 /*

diff --git a/Core/BackMemory.c b/Core/BackMemory.c
index b44673a..c5a7431 100644
--- a/Core/BackMemory.c
+++ b/Core/BackMemory.c
@@ -1,4 +1,4 @@
-
+
 #include "BackMemory.h"
 #include "Debug.h"
 

diff --git a/Core/BackMemory.h b/Core/BackMemory.h
index 230fd7a..2ad2b8b 100644
--- a/Core/BackMemory.h
+++ b/Core/BackMemory.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 /*
 实现目标/目的： 纯软件实现后备寄存器 BackupRegister  （见Lib_L2目录）

diff --git a/Core/Base64.h b/Core/Base64.h
index 7578052..89dac6f 100644
--- a/Core/Base64.h
+++ b/Core/Base64.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 

diff --git a/Core/BitHelper.c b/Core/BitHelper.c
index 23c3303..6a4e025 100644
--- a/Core/BitHelper.c
+++ b/Core/BitHelper.c
@@ -1,10 +1,12 @@
-
+
 #include "BitHelper.h"
 
-/// <summary>获取数组中的bit值</summary>
-/// <param name="idx">位置</param>
-/// <param name="data">数据源</param>
-/// <returns>1true,0false</returns>
+/**
+ * @brief 获取数组中的bit值
+ * @param idx 位置
+ * @param data 数据源
+ * @return 1true,0false
+ */
 __inline bool GetBit(byte* data, int idx)
 {
 	if (data == NULL)return false;
@@ -19,10 +21,12 @@ __inline bool GetBit(byte* data, int idx)
 	return true;
 }
 
-/// <summary>设置bit</summary>
-/// <param name="data"></param>
-/// <param name="idx"></param>
-/// <param name="value"></param>
+/**
+ * @brief 设置bit
+ * @param data
+ * @param idx
+ * @param value
+ */
 __inline void SetBit(byte* data, int idx, bool value)
 {
 	if (data == NULL)return;
@@ -45,16 +49,19 @@ __inline void SetBit(byte* data, int idx, bool value)
 	data[(idx >> 3)] = dat;
 }
 
-/// <summary>设置多bit</summary>
-/// <param name="dst">目标</param>
-/// <param name="dst_offset">目标偏移量</param>
-/// <param name="src">源</param>
-/// <param name="src_offset">源偏移量</param>
-/// <param name="bits">需要set的数量</param>
-void SetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits)
+/**
+ * @brief 设置多bit
+ * @param dst 目标
+ * @param dst_offset 目标偏移量
+ * @param src 源
+ * @param src_offset 源偏移量
+ * @param bits 需要set的数量
+ * @return 是否完成了
+ */
+bool SetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits)
 {
-	if (dst == NULL)return;
-	if (src == NULL)return;
+	if (dst == NULL)return false;
+	if (src == NULL)return false;
 
 	for (int i = 0; i < bits; i++)
 	{
@@ -64,9 +71,11 @@ void SetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits)
 		src_offset++;
 		dst_offset++;
 	}
+
+	return true;
 }
 
-/// <summary>字节bit倒序</summary>
+/** @brief 字节bit倒序 */
 byte BitReverse(byte data)
 {
 	byte res = 0;
@@ -81,7 +90,7 @@ byte BitReverse(byte data)
 	return res;
 }
 
-/// <summary>统计数组内所有bit 为1 的总数</summary>
+/** @brief 统计数组内所有bit 为1 的总数 */
 int BitCount(byte* data, int len)
 {
 	if (data == NULL)return 0;

diff --git a/Core/BitHelper.h b/Core/BitHelper.h
index 494db4c..3d89c38 100644
--- a/Core/BitHelper.h
+++ b/Core/BitHelper.h
@@ -1,28 +1,40 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 
-/// <summary>获取数组中的bit值</summary>
-/// <param name="idx">位置</param>
-/// <param name="data">数据源</param>
-/// <returns>1 true,0 false</returns>
+/**
+ * @brief 获取数组中的bit值
+ * @param idx 位置
+ * @param data 数据源
+ * @return 1 true,0 false
+ */
 bool GetBit(byte* data, int idx);
 
-/// <summary>设置bit</summary>
-/// <param name="idx">位置</param>
-/// <param name="value">设定值</param>
+/**
+ * @brief 设置bit
+ * @param idx 位置
+ * @param value 设定值
+ */
 void SetBit(byte* data, int idx, bool value);
 
-/// <summary>设置多bit</summary>
-/// <param name="dst">目标</param>
-/// <param name="dst_offset">目标偏移量</param>
-/// <param name="src">源</param>
-/// <param name="src_offset">源偏移量</param>
-/// <param name="bits">需要set的数量</param>
-void SetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits);
+/**
+ * @brief 设置多bit
+ * @param dst 目标
+ * @param dst_offset 目标偏移量
+ * @param src 源
+ * @param src_offset 源偏移量
+ * @param bits 需要set的数量
+ * @return 是否完成了
+ */
+bool SetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits);
 
-/// <summary>字节bit倒序</summary>
+/** @brief 字节bit倒序 */
 byte BitReverse(byte data);
 
-/// <summary>统计数组内所有bit 为1 的总数</summary>
+/** @brief 统计数组内所有bit 为1 的总数 */
 int BitCount(byte* data, int len);
+
+/*
+不用额外写 bool GetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits);
+直接用  SetBits(byte* dst, int dst_offset, byte* src, int src_offset, int bits);  即可。
+*/

diff --git a/Core/BitmapMlmeMem.c b/Core/BitmapMlmeMem.c
index f7109f8..dbfa3a4 100644
--- a/Core/BitmapMlmeMem.c
+++ b/Core/BitmapMlmeMem.c
@@ -1,4 +1,4 @@
-
+
 #include "BitmapMlmeMem.h"
 #ifdef DEBUG
 #include "Debug.h"

diff --git a/Core/BitmapMlmeMem.h b/Core/BitmapMlmeMem.h
index d369138..7256f6c 100644
--- a/Core/BitmapMlmeMem.h
+++ b/Core/BitmapMlmeMem.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 // #include "FreeRTOS.h"

diff --git a/Core/Buffer.c b/Core/Buffer.c
new file mode 100644
index 0000000..0a96a4a
--- /dev/null
+++ b/Core/Buffer.c
@@ -0,0 +1,65 @@
+
+#include "Buffer.h"
+#include "Debug.h"
+
+__inline void InitBuffer(Buffer_t* data)	{ memset(data, 0x00, sizeof(Buffer_t));	data->Free = GlobleFree;}
+__inline void InitBuffer2(Buffer2_t* data)	{ memset(data, 0x00, sizeof(Buffer2_t));data->Free = GlobleFree;}
+
+__inline void TryCleanBuffer(Buffer_t* data)
+{
+	if (data->NeedFree)
+	{
+#ifdef DEBUG
+		if (data->Free == NULL)ErrPrintf("TryCleanBuffer Free = NULL");
+		if (data->Data == NULL)ErrPrintf("TryCleanBuffer p = NULL");
+#endif
+		data->Free(data->Data);
+		data->NeedFree = false;
+	}
+}
+
+__inline void TryCleanBuffer2(Buffer2_t* data)
+{
+	if (data->NeedFree)
+	{
+#ifdef DEBUG
+		if (data->Free == NULL)ErrPrintf("TryCleanBuffer2 Free = NULL");
+		if (data->FreePoint == NULL)ErrPrintf("TryCleanBuffer2 p = NULL");
+#endif
+		data->Free(data->FreePoint);
+		data->NeedFree = false;
+	}
+}
+
+void ShowArray(char* name, byte* pdata, int datalen, int showlen)
+{
+#ifdef DEBUG
+	uint printlen = datalen > showlen ? showlen : datalen;
+	DebugPrintf("%s [%d] = ", name, datalen);
+
+	if (printlen > 32)
+	{
+		for (int i = 0; i < printlen; i++)
+		{
+			if (i % 32 == 0)DebugPrintf("\r\n");
+			DebugPrintf("%02X ", pdata[i]);
+		}
+	}
+	else
+	{
+		for (int i = 0; i < printlen; i++)DebugPrintf("%02X ", pdata[i]);
+	}
+
+	DebugPrintf(printlen == datalen ? "\r\n" : "...\r\n");
+#endif
+}
+
+void ShowBuff(Buffer_t* buff, int len)
+{
+	ShowArray("",buff->Data,buff->Len,len);
+}
+
+void ShowBuff2(Buffer2_t* buff, int len)
+{
+	ShowArray("", buff->Data, buff->Len, len);
+}

diff --git a/Core/Buffer.h b/Core/Buffer.h
new file mode 100644
index 0000000..9d1c111
--- /dev/null
+++ b/Core/Buffer.h
@@ -0,0 +1,37 @@
+#pragma once
+#include "Type.h"
+
+// 缓冲区
+typedef struct
+{
+	byte* Data;
+	int Len;
+	bool NeedFree;
+	FreeFunc Free;
+}Buffer_t;
+
+// 缓冲区, 用于从特定内存中抽取一部分数据。
+typedef struct
+{
+	// 数据指针
+	byte* Data;
+	// 数据长度
+	uint Len;
+
+	// 是否需要 Free
+	bool NeedFree;
+	// Free 函数指针
+	FreeFunc Free;
+	// Free 函数测参数  data在这其中。
+	byte* FreePoint;
+}Buffer2_t;
+
+void InitBuffer(Buffer_t* data);
+void InitBuffer2(Buffer2_t* data);
+
+void TryCleanBuffer(Buffer_t* data);
+void TryCleanBuffer2(Buffer2_t* data);
+
+void ShowBuff(Buffer_t* buff, int len);
+void ShowBuff2(Buffer2_t* buff, int len);
+

diff --git a/Core/CircularQueue.c b/Core/CircularQueue.c
index b7b8ff5..141a31a 100644
--- a/Core/CircularQueue.c
+++ b/Core/CircularQueue.c
@@ -1,4 +1,4 @@
-
+
 #include "CircularQueue.h"
 #ifdef DEBUG
 #include "Debug.h"
@@ -78,10 +78,12 @@ int CircularQueueWrites(CircularQueue_t* queue, byte* pdata, int len)
 	// return 0;
 }
 
-/// <summary>写7位压缩编码</summary>
-/// <param name="queue"></param>
-/// <param name="data"></param>
-/// <returns>返回写入的字节数</returns>
+/**
+ * @brief 写7位压缩编码
+ * @param queue
+ * @param data
+ * @return 返回写入的字节数
+ */
 int CircularQueueWriteCompressionUint(CircularQueue_t* queue, uint data)
 {
 	// 7位压缩编码。 取字节最高bit作为标记，标记后续字节还是不是内容。
@@ -217,10 +219,12 @@ bool CircularQueuePeeks(CircularQueue_t* queue, byte* pdata, int len)
 	return CircularQueueReads(queue, pdata, len, true) == len;
 }
 
-/// <summary>读7位压缩编码</summary>
-/// <param name="queue"></param>
-/// <param name="data">输出</param>
-/// <returns>返回读掉的长度</returns>
+/**
+ * @brief 读7位压缩编码
+ * @param queue
+ * @param data 输出
+ * @return 返回读掉的长度
+ */
 int CircularQueueReadCompressionUint(CircularQueue_t* queue, uint* data)
 {
 	// 7位压缩编码。 取字节最高bit作为标记，标记后续字节还是不是内容。
@@ -353,8 +357,10 @@ int CircularQueueIndexOf(CircularQueue_t* queue, byte* sub, int sublen)
 	return -1;
 }
 
-/// <summary>清空数据内容</summary>
-/// <param name="CQHandle"></param>
+/**
+ * @brief 清空数据内容
+ * @param CQHandle
+ */
 void CircularQueueClear(CircularQueue_t* queue)
 {
 	queue->pTail = queue->MemStart;
@@ -363,10 +369,11 @@ void CircularQueueClear(CircularQueue_t* queue)
 
 #include "Debug.h"
 
-/// <summary>打印队列内容</summary>
-/// <param name="CQHandle"></param>
-/// <param name="showlen">打印长度。 -1 表示全部</param>
-/// <returns></returns>
+/**
+ * @brief 打印队列内容
+ * @param CQHandle
+ * @param showlen 打印长度。 -1 表示全部
+ */
 void CircularQueueShow(CircularQueue_t* queue, int showlen)
 {
 	int currlen = CircularQueueGetLength(queue);

diff --git a/Core/CircularQueue.h b/Core/CircularQueue.h
index 81f4c81..85c0ca6 100644
--- a/Core/CircularQueue.h
+++ b/Core/CircularQueue.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 
@@ -24,10 +24,12 @@ int CircularQueueWrite(CircularQueue_t* CQHandle, byte data);
 // 写入多字节,返回写入字节数
 int CircularQueueWrites(CircularQueue_t* CQHandle, byte* pdata, int len);
 
-/// <summary>写7位压缩编码</summary>
-/// <param name="queue"></param>
-/// <param name="data"></param>
-/// <returns>返回写入的字节数</returns>
+/**
+ * @brief 写7位压缩编码
+ * @param queue
+ * @param data
+ * @return 返回写入的字节数
+ */
 int CircularQueueWriteCompressionUint(CircularQueue_t* queue, uint data);
 
 // 获取有效数据长度
@@ -48,10 +50,12 @@ bool CircularQueuePeek(CircularQueue_t* queue, byte* pdata);
 // 尝试读数据s，peek 多字节。要么不成功，要么全成功
 bool CircularQueuePeeks(CircularQueue_t* queue, byte* pdata, int len);
 
-/// <summary>读7位压缩编码</summary>
-/// <param name="queue"></param>
-/// <param name="data">输出</param>
-/// <returns>返回读掉的长度</returns>
+/**
+ * @brief 读7位压缩编码
+ * @param queue
+ * @param data 输出
+ * @return 返回读掉的长度
+ */
 int CircularQueueReadCompressionUint(CircularQueue_t* queue, uint* data);
 
 // 移位,环形队列，只允许往前 seek，不许后退。
@@ -63,12 +67,15 @@ uint CircularQueueSeek(CircularQueue_t* CQHandle, uint offset);
 // 查找数据位置。没有找到返回 -1
 int CircularQueueIndexOf(CircularQueue_t* CQHandle, byte* data, int len);
 
-/// <summary>清空数据内容</summary>
-/// <param name="CQHandle"></param>
+/**
+ * @brief 清空数据内容
+ * @param CQHandle
+ */
 void CircularQueueClear(CircularQueue_t* CQHandle);
 
-/// <summary>打印队列内容</summary>
-/// <param name="CQHandle"></param>
-/// <param name="showlen">打印长度。 -1 表示全部</param>
-/// <returns></returns>
+/**
+ * @brief 打印队列内容
+ * @param CQHandle
+ * @param showlen 打印长度。 -1 表示全部
+ */
 void CircularQueueShow(CircularQueue_t* CQHandle, int showlen);

diff --git a/Core/cJSON.c b/Core/cJSON.c
index 6e8c278..829f0f8 100644
--- a/Core/cJSON.c
+++ b/Core/cJSON.c
@@ -1,4 +1,4 @@
-
+
 #include "Type.h"
 #include "cJSON.h"
 

diff --git a/Core/cJSON.h b/Core/cJSON.h
index 026250c..9aeea37 100644
--- a/Core/cJSON.h
+++ b/Core/cJSON.h
@@ -1,4 +1,4 @@
-
+
 #pragma once
 
 #include "Type.h"

diff --git a/Core/ConfigBase.c b/Core/ConfigBase.c
index 91824a3..783892d 100644
--- a/Core/ConfigBase.c
+++ b/Core/ConfigBase.c
@@ -1,4 +1,4 @@
-
+
 #include "ConfigBase.h"
 #include "Flash.h"
 #include "Crc.h"
@@ -121,10 +121,11 @@ typedef struct
 	ushort Crc16;
 }FConfigItem_t;
 
-/// <summary>修正内部数据</summary>
-/// <param name="cfg">配置</param>
-/// <param name="idx">必要条件</param>
-/// <returns></returns>
+/**
+ * @brief 修正内部数据
+ * @param cfg 配置
+ * @param idx 必要条件
+ */
 static void FixFCfg(FConfigItem_t* cfg, ushort idx)
 {
 	cfg->Index = idx;
@@ -135,9 +136,10 @@ static void FixFCfg(FConfigItem_t* cfg, ushort idx)
 	// cfg->Crc16 = CaclcCRC16_MODBUS(p,sizeof(FConfigItem_t) - 2);
 }
 
-/// <summary>检查配置是否有效</summary>
-/// <param name="cfg"></param>
-/// <returns></returns>
+/**
+ * @brief 检查配置是否有效
+ * @param cfg
+ */
 static bool FCfgIsOK(FConfigItem_t* cfg) 
 {
 	if(cfg == NULL)return false;
@@ -152,10 +154,11 @@ static bool FCfgIsOK(FConfigItem_t* cfg)
 	return true;
 }
 
-/// <summary>所在块的块地址</summary>
-/// <param name="ctl"></param>
-/// <param name="idx"></param>
-/// <returns></returns>
+/**
+ * @brief 所在块的块地址
+ * @param ctl
+ * @param idx
+ */
 static uint FCfgSecAddr(FCfgCtrl_t* ctl,int idx)
 {
 	// 块个数
@@ -170,10 +173,11 @@ static uint FCfgSecAddr(FCfgCtrl_t* ctl,int idx)
 // #define FSECADDR(ctl,idx)  (ctl->FSecAddrs[(idx & ((1 << ctl->FSecBit) - 1)))])
 // FSECADDR FCfgSecAddr
 
-/// <summary>块内偏移量</summary>
-/// <param name="ctl"></param>
-/// <param name="idx"></param>
-/// <returns></returns>
+/**
+ * @brief 块内偏移量
+ * @param ctl
+ * @param idx
+ */
 static uint FSecOffset(FCfgCtrl_t* ctl,int idx)
 {
 	// 块内编号
@@ -190,13 +194,15 @@ static uint FSecOffset(FCfgCtrl_t* ctl,int idx)
 // #define FSECOFFSET(ctl,idx)  (sizeof(FConfigItem_t) * ((idx >> ctl->FSecBit) & (1 << ctl->FSecCfgBit) - 1))))
 // #define FSECOFFSET FSecOffset
 
-/// <summary>初始化</summary>
-/// <param name="ctl"></param>
-/// <param name="api">NOR FLASH 接口</param>
-/// <param name="sad">FLASH 块地址数组</param>
-/// <param name="sadlen">块数组长度</param>
-/// <param name="ccnt">块内 存放配置的份数</param>
-/// <returns>0 无错</returns>
+/**
+ * @brief 初始化
+ * @param ctl
+ * @param api NOR FLASH 接口
+ * @param sad FLASH 块地址数组
+ * @param sadlen 块数组长度
+ * @param ccnt 块内 存放配置的份数
+ * @return 0 无错
+ */
 int FCfgInit(FCfgCtrl_t* ctl, NorFlash_t* api, uint* sad, byte sadlen, byte ccnt)
 {
 	int err = 0;
@@ -235,10 +241,11 @@ int FCfgInit(FCfgCtrl_t* ctl, NorFlash_t* api, uint* sad, byte sadlen, byte ccnt
 	return err;
 }
 
-/// <summary>扫描整个 FLASH 存储区，找到最新且有效的配置取出来</summary>
-/// <param name="ctl"></param>
-/// <param name="cfg"></param>
-/// <returns></returns>
+/**
+ * @brief 扫描整个 FLASH 存储区，找到最新且有效的配置取出来
+ * @param ctl
+ * @param cfg
+ */
 bool FCfgLoad(FCfgCtrl_t* ctl, Config_t* cfg) 
 {
 	if(ctl == NULL)return false;
@@ -335,10 +342,11 @@ bool FCfgLoad(FCfgCtrl_t* ctl, Config_t* cfg)
 	return true;
 }
 
-/// <summary>写配置进去，地址为块首地址的时候擦除块。</summary>
-/// <param name="ctl"></param>
-/// <param name="cfg"></param>
-/// <returns></returns>
+/**
+ * @brief 写配置进去，地址为块首地址的时候擦除块。
+ * @param ctl
+ * @param cfg
+ */
 static bool FCfgWrite(FCfgCtrl_t* ctl, FConfigItem_t* cfg)
 {
 	if(ctl->FApi.FlashWrite == NULL)return false;
@@ -359,10 +367,11 @@ static bool FCfgWrite(FCfgCtrl_t* ctl, FConfigItem_t* cfg)
 	return ctl->FApi.FlashWrite(addr + offset, (byte*)cfg, sizeof(FConfigItem_t));
 }
 
-/// <summary>保存配置</summary>
-/// <param name="ctl"></param>
-/// <param name="cfg"></param>
-/// <returns></returns>
+/**
+ * @brief 保存配置
+ * @param ctl
+ * @param cfg
+ */
 bool FCfgSave(FCfgCtrl_t* ctl, Config_t* cfg)
 {
 	if(ctl == NULL)return false;
@@ -390,10 +399,11 @@ bool FCfgSave(FCfgCtrl_t* ctl, Config_t* cfg)
 	return res;
 }
 
-/// <summary>删除一个配置</summary>
-/// <param name="ctl"></param>
-/// <param name="idx"></param>
-/// <returns></returns>
+/**
+ * @brief 删除一个配置
+ * @param ctl
+ * @param idx
+ */
 bool FCfgClean(FCfgCtrl_t* ctl, int idx)
 {
 	if(ctl->FApi.FlashWrite == NULL)return false;
@@ -411,9 +421,10 @@ bool FCfgClean(FCfgCtrl_t* ctl, int idx)
 	return ctl->FApi.FlashWrite(addr+offset, (byte*)&magic, sizeof(magic));
 }
 
-/// <summary>擦除所有 FLASH 区域，一个不留</summary>
-/// <param name="ctl"></param>
-/// <returns></returns>
+/**
+ * @brief 擦除所有 FLASH 区域，一个不留
+ * @param ctl
+ */
 bool FCfgCleanAll(FCfgCtrl_t* ctl)
 {
 	if(ctl == NULL)return false;

diff --git a/Core/ConfigBase.h b/Core/ConfigBase.h
index 8ce565b..f0a42e6 100644
--- a/Core/ConfigBase.h
+++ b/Core/ConfigBase.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 
@@ -103,36 +103,42 @@ FCfgInit(&FCtl, &nfunc, secAddr, ArrayLength(secAddr), 8);
 
 */
 
-/// <summary>初始化</summary>
-/// <param name="ctl"></param>
-/// <param name="api">NOR FLASH 接口</param>
-/// <param name="sad">FLASH 块地址数组</param>
-/// <param name="sadlen">块数组长度</param>
-/// <param name="ccnt">块内 存放配置的份数</param>
-/// <returns>0 无错</returns>
+/**
+ * @brief 初始化
+ * @param ctl
+ * @param api NOR FLASH 接口
+ * @param sad FLASH 块地址数组
+ * @param sadlen 块数组长度
+ * @param ccnt 块内 存放配置的份数
+ * @return 0 无错
+ */
 int FCfgInit(FCfgCtrl_t* ctl, NorFlash_t* api, uint* sad, byte sadlen, byte ccnt);
 
-/// <summary>扫描整个 FLASH 存储区，找到最新且有效的配置取出来</summary>
-/// <param name="ctl"></param>
-/// <param name="cfg"></param>
-/// <returns></returns>
+/**
+ * @brief 扫描整个 FLASH 存储区，找到最新且有效的配置取出来
+ * @param ctl
+ * @param cfg
+ */
 bool FCfgLoad(FCfgCtrl_t* ctl, Config_t* cfg);
 
-/// <summary>保存配置</summary>
-/// <param name="ctl"></param>
-/// <param name="cfg"></param>
-/// <returns></returns>
+/**
+ * @brief 保存配置
+ * @param ctl
+ * @param cfg
+ */
 bool FCfgSave(FCfgCtrl_t* ctl, Config_t* cfg);
 
-/// <summary>删除一个配置，应该用不到</summary>
-/// <param name="ctl"></param>
-/// <param name="idx"></param>
-/// <returns></returns>
+/**
+ * @brief 删除一个配置，应该用不到
+ * @param ctl
+ * @param idx
+ */
 bool FCfgClean(FCfgCtrl_t* ctl, int idx);
 
-/// <summary>擦除所有 FLASH 区域，一个不留</summary>
-/// <param name="ctl"></param>
-/// <returns></returns>
+/**
+ * @brief 擦除所有 FLASH 区域，一个不留
+ * @param ctl
+ */
 bool FCfgCleanAll(FCfgCtrl_t* ctl);
 
 

diff --git a/Core/Convert.h b/Core/Convert.h
index 0ecd55a..0ebb6d3 100644
--- a/Core/Convert.h
+++ b/Core/Convert.h
@@ -1,4 +1,4 @@
-
+
 
 #ifndef __Convert_H__
 #define __Convert_H__

diff --git a/Core/Crc.c b/Core/Crc.c
index 840b7a1..2f70b47 100644
--- a/Core/Crc.c
+++ b/Core/Crc.c
@@ -1,4 +1,4 @@
-#include "stdint.h"
+#include "stdint.h"
 #include "Type.h"
 #ifdef DEBUG
 #include "Debug.h"

diff --git a/Core/Crc.h b/Core/Crc.h
index d91bfd0..e330ee3 100644
--- a/Core/Crc.h
+++ b/Core/Crc.h
@@ -1,4 +1,4 @@
-#ifndef __BSP_CRC_H
+#ifndef __BSP_CRC_H
 #define __BSP_CRC_H 	
 
 

diff --git a/Core/Debug.c b/Core/Debug.c
index 5666351..e5335ca 100644
--- a/Core/Debug.c
+++ b/Core/Debug.c
@@ -1,4 +1,4 @@
-#include "Debug.h"
+#include "Debug.h"
 // #include "Uart.h"
 
 #ifdef DEBUG
@@ -16,6 +16,11 @@ bool FputcRegister(FPutcFunc func)
 
 	for (int i = 0; i < ArrayLength(Fputs); i++)
 	{
+		if (Fputs[i] == func) return true;		
+	}
+
+	for (int i = 0; i < ArrayLength(Fputs); i++)
+	{
 		if (Fputs[i] == NULL)
 		{
 			Fputs[i] = func;
@@ -46,14 +51,14 @@ bool FputcUnRegister(FPutcFunc func)
 // 逐字节输出。 printf 的最终输出。
 int fputc(int ch, FILE* f)
 {
-	bool out = false;
+	// bool out = false;
 
 	for (int i = 0; i < ArrayLength(Fputs); i++)
 	{
 		if (Fputs[i] != NULL)
 		{
 			Fputs[i](ch,f); 
-			out = true;
+			// out = true;
 		}
 	}
 

diff --git a/Core/HardwareVersion.c b/Core/HardwareVersion.c
index f96372c..e207246 100644
--- a/Core/HardwareVersion.c
+++ b/Core/HardwareVersion.c
@@ -1,4 +1,4 @@
-
+
 #include "HardwareVersion.h"
 
 #include "Type.h"
@@ -61,10 +61,11 @@ uint GetHardwareVersion(void)
 	return minuint;
 }
 
-/// <summary>获取硬件版本,参考 HardwareVersion.c</summary>
-/// <param name="addr">固件起始地址</param>
-/// <param name="len">固件大小</param>
-/// <returns></returns>
+/**
+ * @brief 获取硬件版本,参考 HardwareVersion.c
+ * @param addr 固件起始地址
+ * @param len 固件大小
+ */
 uint GetHardwareVersion2(uint addr, int len)
 {
 	char* head = "HardwareTime/";

diff --git a/Core/HardwareVersion.h b/Core/HardwareVersion.h
index 30b57b8..1c1efd1 100644
--- a/Core/HardwareVersion.h
+++ b/Core/HardwareVersion.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 #include "HardwareInfo.h"
@@ -26,8 +26,9 @@ extern const char* HardwareTime;
 // 版本号使用电路板时间减去 2000-1-1 00:00:00 得到的分钟数。
 uint GetHardwareVersion(void);
 
-/// <summary>获取硬件版本</summary>
-/// <param name="addr">固件起始地址</param>
-/// <param name="len">固件大小</param>
-/// <returns></returns>
+/**
+ * @brief 获取硬件版本
+ * @param addr 固件起始地址
+ * @param len 固件大小
+ */
 uint GetHardwareVersion2(uint addr, int len);

diff --git a/Core/HotDataBase.c b/Core/HotDataBase.c
index 386513e..f425b1d 100644
--- a/Core/HotDataBase.c
+++ b/Core/HotDataBase.c
@@ -1,4 +1,4 @@
-
+
 #include "HotDataBase.h"
 #ifdef DEBUG
 #include "Debug.h"

diff --git a/Core/HotDataBase.h b/Core/HotDataBase.h
index 037bc32..8ce0e60 100644
--- a/Core/HotDataBase.h
+++ b/Core/HotDataBase.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 

diff --git a/Core/LengthFieldCodec.c b/Core/LengthFieldCodec.c
index 0177490..54b4b72 100644
--- a/Core/LengthFieldCodec.c
+++ b/Core/LengthFieldCodec.c
@@ -1,4 +1,4 @@
-
+
 #include "LengthFieldCodec.h"
 #include "CircularQueue.h"
 #include "Stream.h"

diff --git a/Core/LengthFieldCodec.h b/Core/LengthFieldCodec.h
index 0de5930..218f135 100644
--- a/Core/LengthFieldCodec.h
+++ b/Core/LengthFieldCodec.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 

diff --git a/Core/ModbusMaster.c b/Core/ModbusMaster.c
index b4f48db..4b3b9d4 100644
--- a/Core/ModbusMaster.c
+++ b/Core/ModbusMaster.c
@@ -11,7 +11,7 @@
 #include "SysHelper.h"
 #define FILE_ID  (2)
 
-// modbus rtu ��������
+// modbus rtu 主机部分
 #if 1
 
 bool RtuWriteReg(RtuMst_t* thiss, ushort addr, ushort regaddr, ushort data, int timeout)
@@ -114,7 +114,7 @@ bool RtuReadReg(RtuMst_t* thiss, ushort addr, ushort regaddr, ushort* data, int 
 		}
 		if (pklen < 0)
 		{
-			// ������ȥ��һ���ֽڣ�������
+			// 出错，去掉一个字节，往后找
 			CircularQueueSeek(queue, 1);
 		}
 
@@ -152,7 +152,7 @@ bool RtuReadRegs(RtuMst_t* thiss, ushort addr, ushort regaddr, byte* data, int d
 		}
 		if (pklen < 0)
 		{
-			// ������ȥ��һ���ֽڣ�������
+			// 出错，去掉一个字节，往后找
 			CircularQueueSeek(queue, 1);
 		}
 
@@ -164,42 +164,45 @@ bool RtuReadRegs(RtuMst_t* thiss, ushort addr, ushort regaddr, byte* data, int d
 #endif
 
 
-// ����һ����Ŀ�Ĵ��룬�����ο���
+// 另外一个项目的代码，仅供参考。
 #if 0
 
 #include "RS485_2.h"
 static RtuMst_t RtuMst = { 0 };
 static void _DelayMs(int ms) { vTaskDelay(pdMS_TO_TICKS(ms)); }
 
-/// <summary>ִ�ж���</summary>
-/// <param name="devAddr"></param>
-/// <param name="value">��ͣ</param>
-/// <param name="speed">�ٶ�</param>
-/// <returns></returns>
+/**
+ * @brief 执行动作
+ * @param devAddr
+ * @param value 启停
+ * @param speed 速度
+ */
 bool _C41B_Act(int devAddr, bool value, ushort speed)
 {
 	dTraceThiss(FILE_ID);
 
 	if (value)
 	{
-		// ���쳣
+		// 清异常
 		if (!RtuWriteReg(&RtuMst, devAddr, 0x2007, 0x0001, 100))return false;
 		vTaskDelay(pdMS_TO_TICKS(5));
-		// �����ٶ�
+		// 设置速度
 		if (!RtuWriteReg(&RtuMst, devAddr, 0x2002, speed, 100))return false;
 		vTaskDelay(pdMS_TO_TICKS(5));
 	}
 
-	// ��ͣ
+	// 启停
 	bool result = RtuWriteReg(&RtuMst, devAddr, 0x2001, value ? 0x0001 : 0x0000, 100);
-	// �Ӹ��ӳ٣��������߷�æ
+	// 加个延迟，避免总线繁忙
 	if (result) vTaskDelay(pdMS_TO_TICKS(5));
 	return result;
 }
 
-/// <summary>���������</summary>
-/// <param name="devAddr"></param>
-/// <returns>0-300 ֮�䣬-1 δ����</returns>
+/**
+ * @brief 读电机电流
+ * @param devAddr
+ * @return 0-300 之间，-1 未读到
+ */
 int _C41B_Is(int devAddr)
 {
 	ushort Is = 0;
@@ -208,9 +211,10 @@ int _C41B_Is(int devAddr)
 	return Is;
 }
 
-/// <summary>������ٶ�</summary>
-/// <param name="devAddr"></param>
-/// <returns></returns>
+/**
+ * @brief 读电机速度
+ * @param devAddr
+ */
 bool _C41B_Speed(int devAddr, short* spd)
 {
 	short speed = 0;
@@ -223,11 +227,11 @@ bool _C41B_Speed(int devAddr, short* spd)
 #include "BitHelper.h"
 #include "SysInfo.h"
 
-/// <summary>�豸״̬���������״̬����״̬����</summary>
+/** @brief 设备状态，根据这个状态进行状态跟踪 */
 static ushort _Enables = 0;
 
 #define __DEF_SPEED 1500
-/// <summary>���Ĭ���ٶ�</summary>
+/** @brief 电机默认速度 */
 static ushort _Speed = __DEF_SPEED;
 
 void _C41B_Task(void* param)
@@ -262,13 +266,13 @@ void _C41B_Task(void* param)
 			{
 				vTaskDelay(pdMS_TO_TICKS(50));
 
-				// Ŀ��״̬
+				// 目标状态
 				bool en = GetBit((byte*)&_Enables, i);
 				int devAddr = i + 3;
 
 				for (int j = 0; j < 5; j++)
 				{
-					// // ����
+					// // 电流
 					// short currspeed = 0;
 					// if (!_C41B_Speed(devAddr, &currspeed))
 					// {
@@ -276,13 +280,13 @@ void _C41B_Task(void* param)
 					// 	continue;
 					// }
 
-					// ��ǰ״̬
+					// 当前状态
 					// bool run = (currspeed != 0);
 
-					// �޸Ĺ�ȥ
+					// 修改过去
 					// if (run != en)
 					{
-						// �ɹ��Ͳ�������
+						// 成功就不尝试了
 						if (_C41B_Act(devAddr, en, _Speed))
 						{
 							DebugPrintf("_C41B_Act(%d,%s,%d) true\r\n", devAddr, en ? "true" : "false", _Speed);
@@ -312,7 +316,7 @@ void C41B_SetEnable(int idx, bool value)
 		return;
 	}
 
-	// û�б仯��
+	// 没有变化。
 	if (old == value)return;
 	if (_TaskHandle != NULL)vTaskResume(_TaskHandle);
 	DebugPrintf("C41B_SetEnable %d %s\r\n", idx, value ? "true" : "false");

diff --git a/Core/ModbusMaster.h b/Core/ModbusMaster.h
index fba5efa..9497ff7 100644
--- a/Core/ModbusMaster.h
+++ b/Core/ModbusMaster.h
@@ -3,16 +3,16 @@
 #include "Type.h"
 #include "CircularQueue.h"
 
-// modbus rtu ��������
+// modbus rtu 主机部分
 #if 1
 
 typedef struct
 {
-	/// <summary>����</summary>
+	/** @brief 发送 */
 	void(*Send)(byte* data, int len);
-	/// <summary>������</summary>
+	/** @brief 收数据 */
 	CircularQueue_t* RxQueue;
-	/// <summary>�ӳ٣��ȴ����ݣ�</summary>
+	/** @brief 延迟（等待数据） */
 	void(*Delay)(int ms);
 }RtuMst_t;
 
@@ -26,12 +26,16 @@ bool RtuReadRegs(RtuMst_t* thiss, ushort addr, ushort regaddr, byte* data, int d
 #endif
 
 /*
-/// <summary>C41B ��Ƶ����ͣ</summary>
-/// <param name="idx"></param>
-/// <param name="value"></param>
+/**
+ * @brief C41B 变频器启停
+ * @param idx
+ * @param value
+ */
 void C41B_SetEnable(int idx, bool value);
 
-/// <summary>�����ٶ�</summary>
-/// <param name="spd"></param>
+/**
+ * @brief 设置速度
+ * @param spd
+ */
 void C41B_SetSpeed(ushort spd);
 */

diff --git a/Core/ModbusRtuCodec.c b/Core/ModbusRtuCodec.c
index d0b79c1..f2cee83 100644
--- a/Core/ModbusRtuCodec.c
+++ b/Core/ModbusRtuCodec.c
@@ -121,9 +121,11 @@ int MrcSlaveGetLenStream(Stream_t* st)
 	return MrcSlaveGetLength(p, remain);
 }
 
-/// <summary>通过包头计算数据长度，不校验</summary>
-/// <param name="p">最少给3个字节的数组</param>
-/// <returns>理论上包长。-1 数据包类型不对，0 p为null</returns>
+/**
+ * @brief 通过包头计算数据长度，不校验
+ * @param p 最少给3个字节的数组
+ * @return 理论上包长。-1 数据包类型不对，0 p为null
+ */
 static int _masterCalcRxLen(byte* p)
 {
 	if (p == NULL)return 0;
@@ -235,9 +237,11 @@ int MrcMasterGetRxLenStream(Stream_t* st)
 	return MrcMasterGetRxLength(p, remain);
 }
 
-/// <summary>获取应答消息内负载数据的偏移量</summary>
-/// <param name="pkt">已经校验通过的数据包</param>
-/// <returns>返回偏移量，-1 消息类型错误，0 无负载数据</returns>
+/**
+ * @brief 获取应答消息内负载数据的偏移量
+ * @param pkt 已经校验通过的数据包
+ * @return 返回偏移量，-1 消息类型错误，0 无负载数据
+ */
 int MrcMasterGetRxPyOffset(byte* pkt)
 {
 	if (pkt == NULL)return 0;

diff --git a/Core/ModbusRtuCodec.h b/Core/ModbusRtuCodec.h
index fa8b476..8ed0128 100644
--- a/Core/ModbusRtuCodec.h
+++ b/Core/ModbusRtuCodec.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 #include "Stream.h"
@@ -65,9 +65,11 @@ int MrcMasterGetRxLength(byte* p, int len);
 int MrcMasterGetRxLenCircularQueue(CircularQueue_t* queue);
 int MrcMasterGetRxLenStream(Stream_t* st);
 
-/// <summary>获取应答消息内负载数据的偏移量</summary>
-/// <param name="pkt">已经校验通过的数据包</param>
-/// <returns>返回偏移量，-1 消息类型错误，0 无负载数据</returns>
+/**
+ * @brief 获取应答消息内负载数据的偏移量
+ * @param pkt 已经校验通过的数据包
+ * @return 返回偏移量，-1 消息类型错误，0 无负载数据
+ */
 int MrcMasterGetRxPyOffset(byte* pkt);
 
 

diff --git a/Core/ModbusSlave.c b/Core/ModbusSlave.c
index 6c1ee97..03648d8 100644
--- a/Core/ModbusSlave.c
+++ b/Core/ModbusSlave.c
@@ -17,11 +17,11 @@ void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sen
 	if (mrs == NULL)return;
 	if (mrs->SlaveAddr == NULL)return;
 
-	// �����õĻ�����
+	// 发送用的缓冲区
 	byte tx[264];
 	byte* txpy = tx + 8;
 
-	// �����ݰ�
+	// 解数据包
 	byte addr = p[0];
 	byte cmd = p[1];
 
@@ -29,23 +29,23 @@ void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sen
 	{
 		switch (cmd)
 		{
-		case 1:	// �������Ȧ
-		case 2: // ������
+		case 1:	// 读输出线圈
+		case 2: // 读输入
 		{
-			// ����һ�´��
+			// 处理一下大端
 			ushort	regaddr = (p[2] << 8) + p[3];
 			ushort	bitcnt = (p[4] << 8) + p[5];
 
-			// ��ջ�����
+			// 清空缓冲区
 			memset(txpy, 0x00, bitcnt / 8 + 1);
-			// �� bit �ռ�
+			// 读 bit 空间
 			if (mrs->BitAreas != NULL) AreaRead2(mrs->BitAreas, regaddr, txpy, bitcnt, true);
 			int txlen = MrcResult01a02(addr, cmd, txpy, bitcnt, tx, sizeof(tx));
 
 			LogShowArray("-> ", tx, txlen, 16);
 			if (mrs->Send != NULL) mrs->Send(tx, txlen, sendparam);
 		}break;
-		// д�����Ȧ
+		// 写输出线圈
 		case 5:
 		{
 			ushort regaddr = (p[2] << 8) + p[3];
@@ -57,7 +57,7 @@ void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sen
 			LogShowArray("-> ", p, pklen, 16);
 			if (mrs->Send != NULL) mrs->Send(p, pklen, sendparam);
 		}break;
-		// д�����ȦS
+		// 写输出线圈S
 		case 0x0f:
 		{
 			ushort regaddr = (p[2] << 8) + p[3];
@@ -69,17 +69,17 @@ void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sen
 			LogShowArray("-> ", tx, txlen, 16);
 			if (mrs->Send != NULL) mrs->Send(tx, txlen, sendparam);
 		}break;
-		case 3:	// ��������ּĴ���
-		case 4:	// ������Ĵ���
+		case 3:	// 读多个保持寄存器
+		case 4:	// 读输入寄存器
 		{
-			// ����һ�´��
+			// 处理一下大端
 			ushort	regaddr = (p[2] << 8) + p[3];
 			ushort	regcnt = (p[4] << 8) + p[5];
 
-			// ��ջ�����
+			// 清空缓冲区
 			memset(txpy, 0x00, regcnt * 2);
-			// �� byte �ռ�
-			// modbus ��ַ��Ӧ���� 2�ֽڣ���ַ��Ҫ X2 ��Ӧ�ֽڿռ䡣
+			// 读 byte 空间
+			// modbus 地址对应的是 2字节，地址需要 X2 对应字节空间。
 			if (mrs->ByteAreas != NULL) AreaRead2(mrs->ByteAreas, regaddr * 2, txpy, regcnt * 2, false);
 			int txlen = MrcResult03a04(addr, cmd, txpy, regcnt, tx, sizeof(tx));
 
@@ -87,12 +87,12 @@ void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sen
 			if (mrs->Send != NULL) mrs->Send(tx, txlen, sendparam);
 		}
 		break;
-		case 6:	// д�����Ĵ���
+		case 6:	// 写单个寄存器
 		{
 			ushort regaddr = (p[2] << 8) + p[3];
 			ushort regdata = (p[4] << 8) + p[5];
 
-			// modbus ��ַ��Ӧ���� 2�ֽڣ���ַ��Ҫ X2 ��Ӧ�ֽڿռ䡣
+			// modbus 地址对应的是 2字节，地址需要 X2 对应字节空间。
 			if (mrs->ByteAreas != NULL) AreaWrite2(mrs->ByteAreas, regaddr * 2, (byte*)&regdata, 2, false);
 
 			LogShowArray("-> ", p, pklen, 16);
@@ -103,7 +103,7 @@ void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sen
 			ushort regaddr = (p[2] << 8) + p[3];
 			ushort regcnt = (p[4] << 8) + p[5];
 
-			// modbus ��ַ��Ӧ���� 2�ֽڣ���ַ��Ҫ X2 ��Ӧ�ֽڿռ䡣
+			// modbus 地址对应的是 2字节，地址需要 X2 对应字节空间。
 			if (mrs->ByteAreas != NULL) AreaWrite2(mrs->ByteAreas, regaddr * 2, &p[7], regcnt * 2, false);
 			int txlen = MrcResult10(addr, regaddr, regcnt, tx, sizeof(tx));
 
@@ -120,11 +120,11 @@ void ModbusRtuTryProcess(CircularQueue_t* queue, const ModbusSlave_t* mrs, void*
 {
 	if (queue == NULL)return;
 
-	// ���ݰ�����
+	// 数据包长度
 	int pklen = MrcSlaveGetLenCircularQueue(queue);
-	// ������
+	// 不够长
 	if (pklen == 0)return;
-	// �������
+	// 有问题的包
 	if (pklen < 0) 
 	{
 		// byte data = 0;
@@ -134,11 +134,11 @@ void ModbusRtuTryProcess(CircularQueue_t* queue, const ModbusSlave_t* mrs, void*
 		return; 
 	}
 
-	// ������
+	// 读数据
 	byte* p = (byte*)GlobleMalloc(pklen + 4);
 	CircularQueueReads(queue, p, pklen, false);
 
-	// ��������
+	// 处理数据
 	ModbusRtuMsgProcess(mrs, p, pklen, sendparam);
 
 	// free
@@ -155,49 +155,49 @@ void ModbusTcpMsgProcess(const ModbusSlave_t* mrs, byte* pk, int pklen, void* se
 
 	byte* p = pk + 6;
 
-	// TCP ����Ҫ byte addr = p[0];
-	// ����Ҫ head��ԭ�����ص� head
+	// TCP 不需要 byte addr = p[0];
+	// 但是要 head，原样返回的 head
 	MtcHead_t* head = (MtcHead_t*)pk;
 	byte cmd = p[1];
 
-	// �����õĻ�����
+	// 发送用的缓冲区
 	byte tx[272];
 	byte* txpy = tx + 16;
 	// int txpylen = sizeof(tx) - 16;
 
 	switch (cmd)
 	{
-		// ������
+		// 读输入
 	case 2:
 	{
 		ushort	regaddr = (p[2] << 8) + p[3];
 		ushort	bitcnt = (p[4] << 8) + p[5];
 
-		// ��ջ�����
+		// 清空缓冲区
 		memset(txpy, 0x00, bitcnt / 8 + 1);
-		// �� bit �ռ�
+		// 读 bit 空间
 		if (mrs->BitAreas != NULL)AreaRead2(mrs->BitAreas, regaddr, txpy, bitcnt, true);
 		int txlen = MtcResult01a02(head, cmd, txpy, bitcnt, tx, sizeof(tx));
 
 		LogShowArray("-> ", tx, txlen, 16);
 		if (mrs->Send != NULL)mrs->Send(tx, txlen, sendparam);
 	}break;
-	// �������Ȧ
+	// 读输出线圈
 	case 1:
 	{
 		ushort	regaddr = (p[2] << 8) + p[3];
 		ushort	bitcnt = (p[4] << 8) + p[5];
 
-		// ��ջ�����
+		// 清空缓冲区
 		memset(txpy, 0x00, bitcnt / 8 + 1);
-		// �� bit �ռ�
+		// 读 bit 空间
 		if (mrs->BitAreas != NULL)AreaRead2(mrs->BitAreas, regaddr, txpy, bitcnt, true);
 		int txlen = MtcResult01a02(head, cmd, txpy, bitcnt, tx, sizeof(tx));
 
 		LogShowArray("-> ", tx, txlen, 16);
 		if (mrs->Send != NULL)mrs->Send(tx, txlen, sendparam);
 	}break;
-	// д�����Ȧ
+	// 写输出线圈
 	case 5:
 	{
 		ushort regaddr = (p[2] << 8) + p[3];
@@ -209,7 +209,7 @@ void ModbusTcpMsgProcess(const ModbusSlave_t* mrs, byte* pk, int pklen, void* se
 		LogShowArray("-> ", pk, pklen, 16);
 		if (mrs->Send != NULL)mrs->Send(pk, pklen, sendparam);
 	}break;
-	// д�����ȦS
+	// 写输出线圈S
 	case 0x0f:
 	{
 		ushort regaddr = (p[2] << 8) + p[3];
@@ -223,17 +223,17 @@ void ModbusTcpMsgProcess(const ModbusSlave_t* mrs, byte* pk, int pklen, void* se
 	}break;
 
 
-	case 3:	// ��������ּĴ���
-	case 4:	// ������Ĵ���
+	case 3:	// 读多个保持寄存器
+	case 4:	// 读输入寄存器
 	{
-		// ����һ�´��
+		// 处理一下大端
 		ushort	regaddr = (p[2] << 8) + p[3];
 		ushort	regcnt = (p[4] << 8) + p[5];
 
-		// ��ջ�����
+		// 清空缓冲区
 		memset(txpy, 0x00, regcnt * 2);
-		// �� byte �ռ�
-		// modbus ��ַ��Ӧ���� 2�ֽڣ���ַ��Ҫ X2 ��Ӧ�ֽڿռ䡣
+		// 读 byte 空间
+		// modbus 地址对应的是 2字节，地址需要 X2 对应字节空间。
 		if (mrs->ByteAreas != NULL)AreaRead2(mrs->ByteAreas, regaddr * 2, txpy, regcnt * 2, false);
 		int txlen = MtcResult03a04(head, cmd, txpy, regcnt, tx, sizeof(tx));
 
@@ -241,12 +241,12 @@ void ModbusTcpMsgProcess(const ModbusSlave_t* mrs, byte* pk, int pklen, void* se
 		if (mrs->Send != NULL)mrs->Send(tx, txlen, sendparam);
 	}
 	break;
-	case 6:	// д�����Ĵ���
+	case 6:	// 写单个寄存器
 	{
 		ushort regaddr = (p[2] << 8) + p[3];
 		ushort regdata = (p[4] << 8) + p[5];
 
-		// modbus ��ַ��Ӧ���� 2�ֽڣ���ַ��Ҫ X2 ��Ӧ�ֽڿռ䡣
+		// modbus 地址对应的是 2字节，地址需要 X2 对应字节空间。
 		if (mrs->ByteAreas != NULL)AreaWrite2(mrs->ByteAreas, regaddr * 2, (byte*)&regdata, 2, false);
 
 		LogShowArray("-> ", pk, pklen, 16);
@@ -257,7 +257,7 @@ void ModbusTcpMsgProcess(const ModbusSlave_t* mrs, byte* pk, int pklen, void* se
 		ushort regaddr = (p[2] << 8) + p[3];
 		ushort regcnt = (p[4] << 8) + p[5];
 
-		// modbus ��ַ��Ӧ���� 2�ֽڣ���ַ��Ҫ X2 ��Ӧ�ֽڿռ䡣
+		// modbus 地址对应的是 2字节，地址需要 X2 对应字节空间。
 		if (mrs->ByteAreas != NULL)AreaWrite2(mrs->ByteAreas, regaddr * 2, &p[7], regcnt * 2, false);
 		int txlen = MtcResult10(head, regaddr, regcnt, tx, sizeof(tx));
 
@@ -274,16 +274,16 @@ void ModbusTcpTryProcess(CircularQueue_t* queue, const ModbusSlave_t* mrs, void*
 	if (queue == NULL)return;
 
 	int pklen = MtcGetLenCircularQueue(queue);
-	// ������
+	// 不够长
 	if (pklen == 0)return;
-	// �������
+	// 有问题的包
 	if (pklen < 0) { CircularQueueSeek(queue, 1); return; }
 
-	// ������
+	// 读数据
 	byte* pk = (byte*)GlobleMalloc(pklen + 4);
 	CircularQueueReads(queue, pk, pklen, false);
 
-	// ��������
+	// 处理数据
 	ModbusTcpMsgProcess(mrs, pk, pklen, sendparam);
 
 	// free
@@ -292,16 +292,16 @@ void ModbusTcpTryProcess(CircularQueue_t* queue, const ModbusSlave_t* mrs, void*
 
 void ModbusUdpTryProcess(Stream_t* ms, const ModbusSlave_t* mrs, void* sendparam)
 {
-	// ��Ϊ UDP ���������ݰ�ճ�����⣬������һ���Ե��
-	// û��ʹ�� CircularQueue_t �������
-	// ʹ�� Stream_t  ����  Buffer �����ԡ�
-	// UDP ���ݰ��� TCP ��ȫ��ͬ��
+	// 因为 UDP 不存在数据包粘连问题，而且是一次性到达。
+	// 没有使用 CircularQueue_t 的情况。
+	// 使用 Stream_t  或者  Buffer 都可以。
+	// UDP 数据包与 TCP 完全相同。
 	if (ms == NULL)return;
 	// if (StreamRemian(ms) < 12)return;
 	int pklen = MtcGetLenStream(ms);
-	// ������ ���� ���ݰ������⡣
+	// 不够长 或者 数据包有问题。
 	if (pklen <= 0)return;
 
-	// ��������
+	// 处理数据
 	ModbusTcpMsgProcess(mrs, ms->MemStart + ms->Position, pklen, sendparam);
 }

diff --git a/Core/ModbusSlave.h b/Core/ModbusSlave.h
index 9ece7b2..3b07140 100644
--- a/Core/ModbusSlave.h
+++ b/Core/ModbusSlave.h
@@ -7,45 +7,54 @@
 
 typedef struct
 {
-	/// <summary>��վ��ַ,С�������ָ��</summary>
+	/** @brief 从站地址,小心这个是指针 */
 	byte* SlaveAddr;
-	/// <summary>���</summary>
+	/** @brief 位区域 */
 	Area_t* BitAreas;
-	/// <summary>�ֽ�����ע��modbus�Ĵ�����2�ֽ�</summary>
+	/** @brief 字节区域，注意modbus寄存器是2字节 */
 	Area_t* ByteAreas;
-	/// <summary>���ͺ�����param �ṩ���������Ŀ��ܣ����紮�ں�</summary>
+	/** @brief 发送函数，param 提供其他参数的可能，比如串口号 */
 	void(*Send)(byte* data, int len, void* param);
 }ModbusSlave_t;
 
-/// <summary>MODBUS RTU ���ݰ�����</summary>
-/// <param name="mrs"></param>
-/// <param name="p"></param>
-/// <param name="pklen"></param>
-/// <param name="sendparam">mrs->Send �����ĵ���������</param>
+/**
+ * @brief MODBUS RTU 数据包处理
+ * @param mrs
+ * @param p
+ * @param pklen
+ * @param sendparam mrs->Send 函数的第三个参数
+ */
 void ModbusRtuMsgProcess(const ModbusSlave_t* mrs, byte* p, int pklen, void* sendparam);
 
-/// <summary>���Դ��� MODBUS RTU ����</summary>
-/// <param name="queue"></param>
-/// <param name="mrs"></param>
-/// <param name="sendparam">mrs->Send �����ĵ���������</param>
+/**
+ * @brief 尝试处理 MODBUS RTU 数据
+ * @param queue
+ * @param mrs
+ * @param sendparam mrs->Send 函数的第三个参数
+ */
 void ModbusRtuTryProcess(CircularQueue_t* queue, const ModbusSlave_t* mrs, void* sendparam);
 
-/// <summary>MODBUS TCP ���ݰ�����</summary>
-/// <param name="mrs">ע�⣺��ʹ�� SlaveAddr �ֶ�</param>
-/// <param name="pk"></param>
-/// <param name="pklen"></param>
-/// <param name="sendparam">mrs->Send �����ĵ���������</param>
+/**
+ * @brief MODBUS TCP 数据包处理
+ * @param mrs 注意：不使用 SlaveAddr 字段
+ * @param pk
+ * @param pklen
+ * @param sendparam mrs->Send 函数的第三个参数
+ */
 void ModbusTcpMsgProcess(const ModbusSlave_t* mrs, byte* pk, int pklen, void* sendparam);
 
-/// <summary>���Դ��� MODBUS TCP ����</summary>
-/// <param name="queue"></param>
-/// <param name="mrs">ע�⣺��ʹ�� SlaveAddr �ֶ�</param>
-/// <param name="sendparam">mrs->Send �����ĵ���������</param>
+/**
+ * @brief 尝试处理 MODBUS TCP 数据
+ * @param queue
+ * @param mrs 注意：不使用 SlaveAddr 字段
+ * @param sendparam mrs->Send 函数的第三个参数
+ */
 void ModbusTcpTryProcess(CircularQueue_t* queue, const ModbusSlave_t* mrs, void* sendparam);
 
-/// <summary>���Դ��� MODBUS TCP/UDP ����</summary>
-/// <param name="ms"></param>
-/// <param name="mrs">ע�⣺��ʹ�� SlaveAddr �ֶ�</param>
-/// <param name="sendparam">mrs->Send �����ĵ���������</param>
-/// <remake>Modbus tcp/udp ���ݱ�������ͬ�ģ�udp ���� CircularQueue_t ����ճ�����⣬�� Stream_t �����</remake>
+/**
+ * @brief 尝试处理 MODBUS TCP/UDP 数据
+ * @param ms
+ * @param mrs 注意：不使用 SlaveAddr 字段
+ * @param sendparam mrs->Send 函数的第三个参数
+ */
 void ModbusUdpTryProcess(Stream_t* ms, const ModbusSlave_t* mrs, void* sendparam);

diff --git a/Core/ModbusTcpCodec.c b/Core/ModbusTcpCodec.c
index e84031a..1f4234e 100644
--- a/Core/ModbusTcpCodec.c
+++ b/Core/ModbusTcpCodec.c
@@ -38,9 +38,11 @@ int MtcGetLenStream(Stream_t* st)
 	return res;
 }
 
-/// <summary>获取应答消息内负载数据的偏移量</summary>
-/// <param name="pkt">已经校验通过的数据包</param>
-/// <returns>返回偏移量，-1 消息类型错误，0 无负载数据</returns>
+/**
+ * @brief 获取应答消息内负载数据的偏移量
+ * @param pkt 已经校验通过的数据包
+ * @return 返回偏移量，-1 消息类型错误，0 无负载数据
+ */
 int MtcMasterGetRxPyOffset(byte* pkt)
 {
 	if (pkt == NULL)return 0;

diff --git a/Core/ModbusTcpCodec.h b/Core/ModbusTcpCodec.h
index e514b02..dd0d67c 100644
--- a/Core/ModbusTcpCodec.h
+++ b/Core/ModbusTcpCodec.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 #include "Stream.h"
@@ -28,9 +28,11 @@ int MtcGetLength(byte* p, int len);
 int MtcGetLenCircularQueue(CircularQueue_t* queue);
 int MtcGetLenStream(Stream_t* st);
 
-/// <summary>获取应答消息内负载数据的偏移量</summary>
-/// <param name="pkt">已经校验通过的数据包</param>
-/// <returns>返回偏移量，-1 消息类型错误，0 无负载数据</returns>
+/**
+ * @brief 获取应答消息内负载数据的偏移量
+ * @param pkt 已经校验通过的数据包
+ * @return 返回偏移量，-1 消息类型错误，0 无负载数据
+ */
 int MtcMasterGetRxPyOffset(byte* pkt);
 
 #pragma pack(push)

diff --git a/Core/MyList.c b/Core/MyList.c
index 8abea7d..f1d94a7 100644
--- a/Core/MyList.c
+++ b/Core/MyList.c
@@ -1,4 +1,4 @@
-#include "MyList.h"
+#include "MyList.h"
 
 /**
  * 获取链表长度

diff --git a/Core/MyList.h b/Core/MyList.h
index 53746e8..d2ddfe9 100644
--- a/Core/MyList.h
+++ b/Core/MyList.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #ifndef __MyList_H__
 #define __MyList_H__

diff --git a/Core/MyString.c b/Core/MyString.c
index 0274844..eea3456 100644
--- a/Core/MyString.c
+++ b/Core/MyString.c
@@ -1,4 +1,4 @@
-
+
 #include "MyString.h"
 #include "Array.h"
 

diff --git a/Core/MyString.h b/Core/MyString.h
index 4765e12..f2206c9 100644
--- a/Core/MyString.h
+++ b/Core/MyString.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 

diff --git a/Core/RpcMsg.c b/Core/RpcMsg.c
index f3104ee..6949953 100644
--- a/Core/RpcMsg.c
+++ b/Core/RpcMsg.c
@@ -3,20 +3,22 @@
 // #include "Array.h"
 #include "Debug.h"
 
-// StreamCurrPoint() ����ȫ�������ٶ������١����ļ������жϺܶ࣬����ֱ��ȡָ��ͺá�
+// StreamCurrPoint() 更安全，但是速度慢不少。本文件参数判断很多，这里直接取指针就好。
 #define StCurPoint(st)  (&st->MemStart[st->Position])
 
 
-/// <summary>NewLife SRMP ���ݰ���ȡ����</summary>
-/// <param name="data">������</param>
-/// <param name="len">����������</param>
-/// <returns>�������ݰ����ȣ�С��0����ȡʧ��</returns>
+/**
+ * @brief NewLife SRMP 数据包获取长度
+ * @param data 缓冲区
+ * @param len 缓冲区长度
+ * @return 返回数据包长度；小于0，读取失败
+ */
 int SrmpTryGetLen(byte* data, int len)
 {
 	int remain = len;
 	if (remain < sizeof(SrmpHead_t))return -1;
 
-	// ��׼��
+	// 标准包
 	SrmpHead_t* head = (SrmpHead_t*)data;
 	int pklen = 0;
 
@@ -26,7 +28,7 @@ int SrmpTryGetLen(byte* data, int len)
 	}
 	else
 	{
-		// ��չ Head.LengthExt
+		// 扩展 Head.LengthExt
 		if (remain < sizeof(SrmpHead_t) + 4)return -1;
 
 		uint lenExt = 0;
@@ -39,17 +41,20 @@ int SrmpTryGetLen(byte* data, int len)
 	return pklen;
 }
 
-/// <summary>NewLife SRMP ���ݰ���ȡ����</summary>
-/// <param name="st">��</param>
-/// <returns></returns>
+/**
+ * @brief NewLife SRMP 数据包获取长度
+ * @param st 流
+ */
 int SrmpTryGetLen_Stream(Stream_t* st)
 {
 	return SrmpTryGetLen(StCurPoint(st), StreamRemian(st));
 }
 
-/// <summary>NewLife SRMP ���ݰ���ȡ����</summary>
-/// <param name="queue">�����</param>
-/// <returns>�������ݰ����ȣ�С��0����ȡʧ��</returns>
+/**
+ * @brief NewLife SRMP 数据包获取长度
+ * @param queue 环形队列
+ * @return 返回数据包长度；小于0，读取失败
+ */
 int SrmpTryGetLen_CircularQueue(CircularQueue_t* queue)
 {
 	byte cache[8];
@@ -80,10 +85,10 @@ int SrmpTryGetLen_CircularQueue(CircularQueue_t* queue)
 
 
 
-// Head.Flag �� 6bit ָ��ֵ��
+// Head.Flag 低 6bit 指定值。
 #define HEAD_FLAG_0_5  0x00
 
-// �������ݰ������� 65535 �ֽڵ����ݰ������� Head.LengthExt
+// 超大数据包，大于 65535 字节的数据包。启用 Head.LengthExt
 #define BIG_PKT 0
 
 
@@ -107,7 +112,7 @@ static int _RpcInit(byte* data, int datalen,
 	StreamInit(st, data, datalen);
 	StreamSeek(st, sizeof(SrmpHead_t), SeekBegin);
 
-	// action.length��7λѹ�����룩+ action
+	// action.length（7位压缩编码）+ action
 	StreamWriteCompressionUint(st, act_len);
 
 	rpc->Action = (char*)StCurPoint(st);
@@ -118,14 +123,14 @@ static int _RpcInit(byte* data, int datalen,
 		return -2;
 	}
 
-	// �����봦��
+	// 错误码处理
 	if ((errCode != 0) && replay)
 	{
 		rpc->Head->Flag |= 0x40;
 		StreamWriteUint(st, (uint)errCode);
 	}
 
-	// ���һ�����ȣ�����������⡣
+	// 检查一波长度，避免后续问题。
 	if (StreamRemian(st) < 4)
 	{
 		rpc->Payload = NULL;
@@ -143,12 +148,14 @@ static int _RpcInit(byte* data, int datalen,
 	return StreamRemian(st);
 }
 
-/// <summary>��װ RPC ͨѶ��ʽ</summary>
-/// <param name="data">�ڴ滺��</param>
-/// <param name="datalen">�ڴ��С</param>
-/// <param name="action">RPC ����</param>
-/// <param name="rpc">RPC ����</param>
-/// <returns>���ظ�����������󳤶�</returns>
+/**
+ * @brief 封装 RPC 通讯方式
+ * @param data 内存缓冲
+ * @param datalen 内存大小
+ * @param action RPC 名称
+ * @param rpc RPC 对象
+ * @return 返回负载允许的最大长度
+ */
 int RpcInit(byte* data, int datalen, char* action, RpcInfo_t* rpc)
 {
 	if (data == NULL)return -1;
@@ -162,13 +169,15 @@ int RpcInit(byte* data, int datalen, char* action, RpcInfo_t* rpc)
 #endif
 }
 
-/// <summary>��װ RPC ������Ϣ����</summary>
-/// <param name="data">�ڴ滺��</param>
-/// <param name="datalen">�ڴ��С</param>
-/// <param name="action">RPC ����</param>
-/// <param name="errCode">�����룬0�޴�</param>
-/// <param name="rpc">RPC ����</param>
-/// <returns>���ظ�����������󳤶�</returns>
+/**
+ * @brief 封装 RPC 返回消息构建
+ * @param data 内存缓冲
+ * @param datalen 内存大小
+ * @param action RPC 名称
+ * @param errCode 错误码，0无错
+ * @param rpc RPC 对象
+ * @return 返回负载允许的最大长度
+ */
 int RpcReplyInit(byte* data, int datalen, char* action, uint errCode, RpcInfo_t* rpc)
 {
 	if (data == NULL)return -1;
@@ -182,13 +191,15 @@ int RpcReplyInit(byte* data, int datalen, char* action, uint errCode, RpcInfo_t*
 #endif
 }
 
-/// <summary>�����ظ���Ϣ</summary>
-/// <param name="data">������</param>
-/// <param name="datalen">��������С</param>
-/// <param name="errCode">�����룬0�޴�</param>
-/// <param name="src">ԭ����Ϣ</param>
-/// <param name="dst">����������Ϣ</param>
-/// <returns>�������ߴ�</returns>
+/**
+ * @brief 创建回复消息
+ * @param data 缓冲区
+ * @param datalen 缓冲区大小
+ * @param errCode 错误码，0无错
+ * @param src 原有消息
+ * @param dst 创建的新消息
+ * @return 负载最大尺寸
+ */
 int RpcCreatReply(byte* data, int datalen, uint errCode, RpcInfo_t* src, RpcInfo_t* dst)
 {
 	if (data == NULL)return -1;
@@ -197,11 +208,11 @@ int RpcCreatReply(byte* data, int datalen, uint errCode, RpcInfo_t* src, RpcInfo
 	if (src->Action == NULL)return -1;
 #if BIG_PKT
 	if (datalen < 9 + 4)return -1;
-	// ��actionlen=0����С���ݰ� 9 + 4 �ֽڡ�
+	// （actionlen=0）最小数据包 9 + 4 字节。
 	if (src->ActionLen + 9 + 4 > datalen)return -1;
 #else
 	if (datalen < 9)return -1;
-	// ��actionlen=0����С���ݰ� 9�ֽڡ�
+	// （actionlen=0）最小数据包 9字节。
 	if (src->ActionLen + 9 > datalen)return -1;
 #endif
 
@@ -216,26 +227,28 @@ int RpcCreatReply(byte* data, int datalen, uint errCode, RpcInfo_t* src, RpcInfo
 	return pyMax;
 }
 
-/// <summary>����/���� RPC ���ݰ��ṹ</summary>
-/// <param name="rpc">RPC ����</param>
-/// <returns>����������Ϣ����</returns>
+/**
+ * @brief 修正/完善 RPC 数据包结构
+ * @param rpc RPC 对象
+ * @return 返回整条消息长度
+ */
 int RpcFix(RpcInfo_t* rpc)
 {
 	if (rpc == NULL)return -1;
 	if (rpc->Head == NULL)return -1;
 	if (rpc->Payload == NULL)return -1;
 
-	// ��䡾���س��ȡ�,�ڸ���ǰ��4�ֽ�
+	// 填充【负载长度】,在负载前面4字节
 	Stream_t pkst;
 	Stream_t* st = &pkst;
 	StreamInit(st, rpc->Payload - 4, 4);
 	StreamWriteUint(st, rpc->PayloadLen);
 
-	// ���ڴ�β-�ڴ�ͷ�� - ���ݰ�ͷ������
+	// （内存尾-内存头） - 数据包头部长度
 	SrmpHead_t* head = rpc->Head;
 	uint hLen = (uint)rpc->Payload + rpc->PayloadLen - (uint)head - sizeof(SrmpHead_t);
 
-	// �������ݰ�
+	// 正常数据包
 	if (hLen < 65535)
 	{
 		head->Length = hLen;
@@ -243,19 +256,19 @@ int RpcFix(RpcInfo_t* rpc)
 	}
 
 #if BIG_PKT
-	// �������ݰ��� ǰ������4�ֽڣ������ó���
-	// �ж� ��һ�ε��ñ�����
+	// 超长数据包。 前面空余的4字节，派上用场。
+	// 判断 第一次调用本函数
 	if ((uint)rpc->Action - (uint)rpc->Head - sizeof(SrmpHead_t) < 4)
 	{
 		byte* p = (byte*)rpc->Head;
 		SrmpHead_t* head = (SrmpHead_t*)(p - 4);
-		// �Ӻ�����ǰ copy �����ĸ������⣬ֱ���ϡ�
+		// 从后面往前 copy 不担心覆盖问题，直接上。
 		memcpy(head, rpc->Head, sizeof(SrmpHead_t));
-		// ���λ�λ��
+		// 移形换位。
 		rpc->Head = head;
 	}
 
-	// ���ȴ���
+	// 长度处理
 	head->Length = 0xffff;
 	StreamInit(st, (byte*)rpc->Head, 8);
 	StreamSeek(st, sizeof(SrmpHead_t), SeekCurrent);
@@ -263,15 +276,17 @@ int RpcFix(RpcInfo_t* rpc)
 
 	return hLen + sizeof(SrmpHead_t) + 4;
 #else
-	// ��֧�ֳ������ݰ�
+	// 不支持超大数据包
 	return 0;
 #endif
 }
 
-/// <summary>����/���� RPC ���ݰ��ṹ</summary>
-/// <param name="rpc">RPC ����</param>
-/// <param name="seq">��ϢSEQ���</param>
-/// <returns>����������Ϣ����</returns>
+/**
+ * @brief 修正/完善 RPC 数据包结构
+ * @param rpc RPC 对象
+ * @param seq 消息SEQ编号
+ * @return 返回整条消息长度
+ */
 int RpcFixWithSeq(RpcInfo_t* rpc, byte seq)
 {
 	if (rpc == NULL)return 0;
@@ -281,9 +296,11 @@ int RpcFixWithSeq(RpcInfo_t* rpc, byte seq)
 	return RpcFix(rpc);
 }
 
-/// <summary>��������Seqֵ</summary>
-/// <param name="data">���ݰ�</param>
-/// <param name="seq">Seq</param>
+/**
+ * @brief 设置数据Seq值
+ * @param data 数据包
+ * @param seq Seq
+ */
 void RpcPktSetSeq(byte* data, byte seq)
 {
 	if (data == NULL)return;
@@ -292,11 +309,13 @@ void RpcPktSetSeq(byte* data, byte seq)
 	head->Seq = seq;
 }
 
-/// <summary>���RPC����</summary>
-/// <param name="data">����</param>
-/// <param name="len">���ݴ�С</param>
-/// <param name="rpc">rpc����</param>
-/// <returns>С��0��ʾ����</returns>
+/**
+ * @brief 解包RPC数据
+ * @param data 数据
+ * @param len 数据大小
+ * @param rpc rpc解出位置
+ * @return 小于0表示出错
+ */
 int RpcPktParse(byte* data, int len, RpcInfo_t* rpc)
 {
 	if (data == NULL)return -1;
@@ -311,7 +330,7 @@ int RpcPktParse(byte* data, int len, RpcInfo_t* rpc)
 		if (head->Length + sizeof(SrmpHead_t) > len)return -2;
 	}
 
-	// FLAG ��־λ
+	// FLAG 标志位
 	if ((head->Flag & 0x80) != 0)rpc->Reply = true;
 	bool err = (head->Flag & 0x40) != 0;
 
@@ -319,18 +338,18 @@ int RpcPktParse(byte* data, int len, RpcInfo_t* rpc)
 	Stream_t* st = &pkst;
 	StreamInit(st, data, len);
 	StreamSeek(st, sizeof(SrmpHead_t), SeekBegin);
-	// ���� 64K ���������� Head.LengthExt ��
+	// 大于 64K 的包。长度在 Head.LengthExt 。
 	if (head->Length == 0xffff)
 	{
 		uint realLen;
 		if (StreamReadUint(st, &realLen) != 4)return -2;
-		// ���س���+��׼ͷ����+���ų����ֶ�
+		// 负载长度+标准头长度+扩张长度字段
 		if (realLen + sizeof(SrmpHead_t) + 4 > len)return -2;
 	}
 
 	rpc->Head = head;
 
-	// action.length��7λѹ�����룩+ action
+	// action.length（7位压缩编码）+ action
 	uint slen = 0;
 	StreamReadCompressionUint(st, &slen);
 	rpc->Action = (char*)StCurPoint(st);
@@ -353,7 +372,7 @@ int RpcPktParse(byte* data, int len, RpcInfo_t* rpc)
 	return 0;
 }
 
-/// <summary>��ӡRPC����</summary>
+/** @brief 打印RPC数据 */
 void RpcShow(RpcInfo_t* rpc)
 {
 	if (rpc == NULL)return;
@@ -361,7 +380,7 @@ void RpcShow(RpcInfo_t* rpc)
 	DebugPrintf("F %02X S %02X [%d]",
 		rpc->Head->Flag,rpc->Head->Seq,rpc->Head->Length);
 
-	// �����ַ���β���޸�Ϊ \0 , ��ԭ�� 
+	// 备份字符结尾，修改为 \0 , 还原。 
 	byte act_e = rpc->Action[rpc->ActionLen];
 	
 	DebugPrintf(" ACT ");

diff --git a/Core/RpcMsg.h b/Core/RpcMsg.h
index 1579566..d3368f8 100644
--- a/Core/RpcMsg.h
+++ b/Core/RpcMsg.h
@@ -4,147 +4,167 @@
 
 /*
 
-���ļ�ʵ�ֵĺ�����Ӧ
+本文件实现的函数对应
 DefaultMessage(Newlife.Core)  -> SrmpHead_t
 JsonEncoder(Newlife.Remoting) -> RpcInfo_t
-RpcInfo_t ��������ʵ�� ApiClient (�Խ�ApiServer)
+RpcInfo_t 可以用于实现 ApiClient (对接ApiServer)
 
-����c�������ƣ��޷�ʵ��JsonEncoder��JSON�����л�/�����л�����Ҫ�ⲿʵ�֡�
-���ĺ�����ʹ��ʾ�������Բο���
+由于c语言限制，无法实现JsonEncoder中JSON的序列化/反序列化，需要外部实现。
+本文后面有使用示例，可以参考。
 
-��λ�����ᳬ�� 65535 �ĸ��أ�Ĭ�ϲ�ʹ����չ���ȣ�����֧����Ҫ��.c�ļ��� BIG_PKT �궨�塣
+下位机不会超过 65535 的负载，默认不使用扩展长度，如需支持需要打开.c文件的 BIG_PKT 宏定义。
 
-����SrmpHead_t�е�Flag��DefaultMessage��bit0-5����ΪDataKinds,��ApiClient�д��ֶ�Ϊ0 ��
-��Newlife�������У�DataKinds����û��ʹ�ã����Դ˴�����������
+关于SrmpHead_t中的Flag，DefaultMessage对bit0-5定义为DataKinds,在ApiClient中此字段为0 。
+在Newlife相关组件中，DataKinds基本没有使用，所以此处不做处理。
 
 */
 
 #pragma pack(push)
 #pragma pack(1)
 
-// NewLife SRMP ��׼���ݰ�ͷ
+// NewLife SRMP 标准数据包头
 typedef struct
 {
-	// Flag Ϊλ��־
+	// Flag 为位标志
 	// bit7  0x80  Reply
 	// bit6  0x40  Error
-	// bit 0-5	   ���ݰ���ʽ��Ĭ��ʹ��0 
-	// �������
+	// bit 0-5	   数据包格式，默认使用0 
+	// 其他未定义
 	byte Flag;
-	// ���ݰ� Seq
+	// 数据包 Seq
 	byte Seq;
-	// ���ݳ��ȣ�С��
+	// 数据长度，小端
 	ushort Length;
 
-	// �������ݰ������� Length=0XFFFF��Ȼ�� LengthExt=ʵ�ʳ��ȡ�
+	// 超长数据包，会让 Length=0XFFFF，然后 LengthExt=实际长度。
 	// uint LengthExt;
 } SrmpHead_t;
 
 #pragma pack(pop)
 
-// Ҳ����д�� NewLifeHead_t
+// 也可以写成 NewLifeHead_t
 #define NewLifeHead_t SrmpHead_t
 
 #include "Stream.h"
 #include "CircularQueue.h"
 
-/// <summary>NewLife SRMP ���ݰ���ȡ����</summary>
-/// <param name="data">������</param>
-/// <param name="len">����������</param>
-/// <returns>�������ݰ����ȣ�С��0����ȡʧ��</returns>
+/**
+ * @brief NewLife SRMP 数据包获取长度
+ * @param data 缓冲区
+ * @param len 缓冲区长度
+ * @return 返回数据包长度；小于0，读取失败
+ */
 int SrmpTryGetLen(byte* data, int len);
 
-/// <summary>NewLife SRMP ���ݰ���ȡ����</summary>
-/// <param name="st">��</param>
-/// <returns></returns>
+/**
+ * @brief NewLife SRMP 数据包获取长度
+ * @param st 流
+ */
 int SrmpTryGetLen_Stream(Stream_t* st);
 
-/// <summary>NewLife SRMP ���ݰ���ȡ����</summary>
-/// <param name="queue">�����</param>
-/// <returns>�������ݰ����ȣ�С��0����ȡʧ��</returns>
+/**
+ * @brief NewLife SRMP 数据包获取长度
+ * @param queue 环形队列
+ * @return 返回数据包长度；小于0，读取失败
+ */
 int SrmpTryGetLen_CircularQueue(CircularQueue_t* queue);
 
 
 typedef struct
 {
-	// ͷ��
+	// 头部
 	SrmpHead_t* Head;
 
-	// ������Ϣ
+	// 返回消息
 	bool Reply;
-	// �������
+	// 错误代码
 	int ErrCode;
 
-	// ��������
+	// 动作名称
 	char* Action;
-	// �����ַ�������
+	// 动作字符串长度
 	uint ActionLen;
 
-	// ����
+	// 负载
 	byte* Payload;
-	// ���س��ȡ� 
+	// 负载长度。 
 	uint PayloadLen;
 }RpcInfo_t;
 
-/// <summary>��װ RPC ͨѶ��ʽ</summary>
-/// <param name="data">�ڴ滺��</param>
-/// <param name="datalen">�ڴ��С</param>
-/// <param name="action">RPC ����</param>
-/// <param name="rpc">RPC ����</param>
-/// <returns>���ظ�����������󳤶�</returns>
+/**
+ * @brief 封装 RPC 通讯方式
+ * @param data 内存缓冲
+ * @param datalen 内存大小
+ * @param action RPC 名称
+ * @param rpc RPC 对象
+ * @return 返回负载允许的最大长度
+ */
 int RpcInit(byte* data, int datalen, char* action, RpcInfo_t* rpc);
 
-/// <summary>��װ RPC ������Ϣ����</summary>
-/// <param name="data">�ڴ滺��</param>
-/// <param name="datalen">�ڴ��С</param>
-/// <param name="action">RPC ����</param>
-/// <param name="errCode">�����룬0�޴�</param>
-/// <param name="rpc">RPC ����</param>
-/// <returns>���ظ�����������󳤶�</returns>
+/**
+ * @brief 封装 RPC 返回消息构建
+ * @param data 内存缓冲
+ * @param datalen 内存大小
+ * @param action RPC 名称
+ * @param errCode 错误码，0无错
+ * @param rpc RPC 对象
+ * @return 返回负载允许的最大长度
+ */
 int RpcReplyInit(byte* data, int datalen, char* action, uint errCode, RpcInfo_t* rpc);
 
-/// <summary>�����ظ���Ϣ</summary>
-/// <param name="data">������</param>
-/// <param name="datalen">��������С</param>
-/// <param name="errCode">�����룬0�޴�</param>
-/// <param name="src">ԭ����Ϣ</param>
-/// <param name="dst">����������Ϣ</param>
-/// <returns>�������ߴ�</returns>
+/**
+ * @brief 创建回复消息
+ * @param data 缓冲区
+ * @param datalen 缓冲区大小
+ * @param errCode 错误码，0无错
+ * @param src 原有消息
+ * @param dst 创建的新消息
+ * @return 负载最大尺寸
+ */
 int RpcCreatReply(byte* data, int datalen, uint errCode, RpcInfo_t* src, RpcInfo_t* dst);
 
-/// <summary>����/���� RPC ���ݰ��ṹ</summary>
-/// <param name="rpc">RPC ����</param>
-/// <returns>����������Ϣ����</returns>
+/**
+ * @brief 修正/完善 RPC 数据包结构
+ * @param rpc RPC 对象
+ * @return 返回整条消息长度
+ */
 int RpcFix(RpcInfo_t* rpc);
 
-/// <summary>����/���� RPC ���ݰ��ṹ</summary>
-/// <param name="rpc">RPC ����</param>
-/// <param name="seq">��ϢSEQ���</param>
-/// <returns>����������Ϣ����</returns>
+/**
+ * @brief 修正/完善 RPC 数据包结构
+ * @param rpc RPC 对象
+ * @param seq 消息SEQ编号
+ * @return 返回整条消息长度
+ */
 int RpcFixWithSeq(RpcInfo_t* rpc, byte seq);
 
-/// <summary>��������Seqֵ</summary>
-/// <param name="data">���ݰ�</param>
-/// <param name="seq">Seq</param>
+/**
+ * @brief 设置数据Seq值
+ * @param data 数据包
+ * @param seq Seq
+ */
 void RpcPktSetSeq(byte* data, byte seq);
 
-/// <summary>���RPC����</summary>
-/// <param name="data">����</param>
-/// <param name="len">���ݴ�С</param>
-/// <param name="rpc">rpc����</param>
-/// <returns>С��0��ʾ����</returns>
+/**
+ * @brief 解包RPC数据
+ * @param data 数据
+ * @param len 数据大小
+ * @param rpc rpc解出位置
+ * @return 小于0表示出错
+ */
 int RpcPktParse(byte* data, int len, RpcInfo_t* rpc);
 
-/// <summary>��ӡRPC����</summary>
+/** @brief 打印RPC数据 */
 void RpcShow(RpcInfo_t* rpc);
 
 /*
 
-/// <summary>ƥ������/��ά��</summary>
-/// <param name="codestr">����/����</param>
-/// <param name="buff"></param>
-/// <param name="bufflen"></param>
-/// <returns></returns>
+/**
+ * @brief 匹配条码/二维码
+ * @param codestr 条码/二维码
+ * @param buff
+ * @param bufflen
+ */
 int BuildMatchMsg(char* codestr, int posi, byte* buff, int bufflen)
 {
 	char* qr = codestr;
@@ -176,7 +196,7 @@ int BuildMatchMsg(char* codestr, int posi, byte* buff, int bufflen)
 		result = pklen;
 	}
 
-	// ʹ�� cJSON_Delete ��ʹ�õ� free ����
+	// 使用 cJSON_Delete 内使用的 free 函数
 	if (cJSON_free)cJSON_free(msgbuff);
 	else GlobleFree(msgbuff);
 
@@ -184,11 +204,12 @@ int BuildMatchMsg(char* codestr, int posi, byte* buff, int bufflen)
 	return result;
 }
 
-/// <summary>ƥ������/��ά��</summary>
-/// <param name="codestr">����/����</param>
-/// <param name="buff"></param>
-/// <param name="bufflen"></param>
-/// <returns></returns>
+/**
+ * @brief 匹配条码/二维码
+ * @param codestr 条码/二维码
+ * @param buff
+ * @param bufflen
+ */
 int BuildMatchMsg(char* codestr, int posi, byte* buff, int bufflen)
 {
 	RpcInfo_t rpc;
@@ -201,12 +222,14 @@ int BuildMatchMsg(char* codestr, int posi, byte* buff, int bufflen)
 }
 
 
-/// <summary>�������ݰ�����</summary>
-/// <param name="data"></param>
-/// <param name="bufflen"></param>
+/**
+ * @brief 网络数据包处理
+ * @param data
+ * @param bufflen
+ */
 void NetDataProcess(byte* data, int bufflen)
 {
-	// ��С���ݳ��ȣ�����Ҫ������ͷ�����ɡ�
+	// 最小数据长度，起码要把数据头放满吧。
 	if (bufflen < sizeof(SrmpHead_t))return;
 
 	SrmpHead_t* head = (SrmpHead_t*)data;
@@ -221,16 +244,16 @@ void NetDataProcess(byte* data, int bufflen)
 		return;
 	}
 
-	// ���ַ������־\0 �����ƻ���Ϣ���ݣ�ȷ���������Ӱ���ʹ�á�
+	// 加字符串结标志\0 ，会破坏消息内容，确定不会造成影响才使用。
 	rpc.Action[rpc.ActionLen] = '\0';
 	rpc.Payload[rpc.PayloadLen] = '\0';
 
 	if (!rpc.Reply)
 	{
-		// ������Ϣ������
+		// 请求消息处理。
 		// DebugPrintf("RpcPktParse %d\r\n", err);
 
-		// ��֧�ֱ�����Ĵ���
+		// 不支持被请求的处理
 		static byte cache[80];
 		RpcInfo_t rs;
 		int maxlen = RpcCreatReply(cache, sizeof(cache), 400, &rpc, &rs);
@@ -247,15 +270,15 @@ void NetDataProcess(byte* data, int bufflen)
 	}
 	else
 	{
-		// �ظ���Ϣ����
-		//		�����ӡ����
+		// 回复消息处理
+		//		错误打印出来
 		if (rpc.ErrCode != 0)
 		{
 			DebugPrintf("Rev %s Err %d\r\n\t%s\r\n", rpc.Action, rpc.ErrCode, rpc.Payload);
 			return;
 		}
 
-		//		��action�б����ҵ���Ӧ�Ĵ����������д���
+		//		从action列表中找到对应的处理函数进行处理
 		DebugPrintf("Rev %s %d\r\n\t%s\r\n", rpc.Action, rpc.ErrCode, rpc.Payload);
 		for (int i = 0; i < sizeof(ActionProcess) / sizeof(ActionProcess[0]); i++)
 		{

diff --git a/Core/SHA1.c b/Core/SHA1.c
index ee1b615..c2b4e74 100644
--- a/Core/SHA1.c
+++ b/Core/SHA1.c
@@ -1,4 +1,4 @@
-#include "SHA1.h"
+#include "SHA1.h"
 
 uint swapInt32(uint value)
 {

diff --git a/Core/SHA1.h b/Core/SHA1.h
index 6d398fd..30c567e 100644
--- a/Core/SHA1.h
+++ b/Core/SHA1.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 #include <stddef.h>

diff --git a/Core/StateMachine.c b/Core/StateMachine.c
index 5dc14bb..0fd3064 100644
--- a/Core/StateMachine.c
+++ b/Core/StateMachine.c
@@ -1,17 +1,21 @@
 
 #include "StateMachine.h"
 
-/// <summary>初始化状态机</summary>
-/// <param name="sm"></param>
-/// <param name="items"></param>
+/**
+ * @brief 初始化状态机
+ * @param sm
+ * @param items
+ */
 void StateMachineInit(StateMachine_t* sm, SMItem_t* items)
 {
 	sm->Current = NULL;
 	sm->Next = items;
 }
 
-/// <summary>状态机主循环</summary>
-/// <param name="sm"></param>
+/**
+ * @brief 状态机主循环
+ * @param sm
+ */
 void StateMachineMain(StateMachine_t* sm)
 {
     if(sm == NULL)return;
@@ -43,9 +47,11 @@ void StateMachineMain(StateMachine_t* sm)
     }
 }
 
-/// <summary>切换状态</summary>
-/// <param name="sm"></param>
-/// <param name="next"></param>
+/**
+ * @brief 切换状态
+ * @param sm
+ * @param next
+ */
 void StateMachineGo(StateMachine_t* sm, SMItem_t* next)
 {
     if(next == NULL)return;
@@ -54,17 +60,17 @@ void StateMachineGo(StateMachine_t* sm, SMItem_t* next)
 
 /* 延迟状态举例
 
-/// <summary>延迟状态结构</summary>
+/** @brief 延迟状态结构 */
 typedef struct
 {
     SMItem_t DelayItem;
-    /// <summary>状态机主体，方便处理切换问题</summary>
+    /** @brief 状态机主体，方便处理切换问题 */
     StateMachine_t* SM;
-    /// <summary>延迟开始时间</summary>
+    /** @brief 延迟开始时间 */
     Time_t Start;
-    /// <summary>延时时间</summary>
+    /** @brief 延时时间 */
     int DelayMs;
-    /// <summary>延迟完成后进入的状态</summary>
+    /** @brief 延迟完成后进入的状态 */
     SMItem_t* Next;
 } SMDelay_t;
 

diff --git a/Core/StateMachine.h b/Core/StateMachine.h
index 41718d4..d9173af 100644
--- a/Core/StateMachine.h
+++ b/Core/StateMachine.h
@@ -6,22 +6,22 @@
 
 typedef struct SMItem
 {
-    /// <summary>状态名称</summary>
+    /** @brief 状态名称 */
     const char* Name;
 
-    /// <summary>进入状态时执行的动作</summary>
+    /** @brief 进入状态时执行的动作 */
     void(*Enter)(struct SMItem*, void* sm);
-    /// <summary>运行状态时执行的动作</summary>
+    /** @brief 运行状态时执行的动作 */
     void (*Run)(struct SMItem*, void* sm);
-    /// <summary>退出状态时执行的动作</summary>
+    /** @brief 退出状态时执行的动作 */
     void (*Exit)(struct SMItem*, void* sm);
 }SMItem_t;
 
 typedef struct
 {
-    /// <summary>当前状态</summary>
+    /** @brief 当前状态 */
     struct SMItem* Current;
-    /// <summary>下一个状态</summary>
+    /** @brief 下一个状态 */
     struct SMItem* Next;
 }StateMachine_t;
 

diff --git a/Core/Stream.h b/Core/Stream.h
index fcf5080..a203c9d 100644
--- a/Core/Stream.h
+++ b/Core/Stream.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 

diff --git a/Core/Type.c b/Core/Type.c
index 34edde6..5416add 100644
--- a/Core/Type.c
+++ b/Core/Type.c
@@ -1,5 +1,4 @@
-
-#include "Debug.h"
+
 #include "Type.h"
 
 #if defined ( __CC_ARM )
@@ -26,65 +25,3 @@ void SetGlobleMemOpt(MallocFunc malloc, FreeFunc free)
 	GlobleMemOpt.malloc = malloc;
 	GlobleMemOpt.free = free;
 }
-
-__inline void InitBuffer(Buffer_t* data)	{ memset(data, 0x00, sizeof(Buffer_t));	data->free = GlobleFree;}
-__inline void InitBuffer2(Buffer2_t* data)	{ memset(data, 0x00, sizeof(Buffer2_t));data->free = GlobleFree;}
-
-__inline void TryCleanBuffer(Buffer_t* data)
-{
-	if (data->needFree)
-	{
-#ifdef DEBUG
-		if (data->free == NULL)ErrPrintf("TryCleanBuffer Free = NULL");
-		if (data->p == NULL)ErrPrintf("TryCleanBuffer p = NULL");
-#endif
-		data->free(data->p);
-		data->needFree = false;
-	}
-}
-
-__inline void TryCleanBuffer2(Buffer2_t* data)
-{
-	if (data->needFree)
-	{
-#ifdef DEBUG
-		if (data->free == NULL)ErrPrintf("TryCleanBuffer2 Free = NULL");
-		if (data->freePoint == NULL)ErrPrintf("TryCleanBuffer2 p = NULL");
-#endif
-		data->free(data->freePoint);
-		data->needFree = false;
-	}
-}
-
-void ShowArray(char* name, byte* pdata, int datalen, int showlen)
-{
-#ifdef DEBUG
-	uint printlen = datalen > showlen ? showlen : datalen;
-	DebugPrintf("%s [%d] = ", name, datalen);
-
-	if (printlen > 32)
-	{
-		for (int i = 0; i < printlen; i++)
-		{
-			if (i % 32 == 0)DebugPrintf("\r\n");
-			DebugPrintf("%02X ", pdata[i]);
-		}
-	}
-	else
-	{
-		for (int i = 0; i < printlen; i++)DebugPrintf("%02X ", pdata[i]);
-	}
-
-	DebugPrintf(printlen == datalen ? "\r\n" : "...\r\n");
-#endif
-}
-
-void ShowBuff(Buffer_t* buff, int len)
-{
-	ShowArray("",buff->p,buff->len,len);
-}
-
-void ShowBuff2(Buffer2_t* buff, int len)
-{
-	ShowArray("", buff->data, buff->len, len);
-}

diff --git a/Core/Type.h b/Core/Type.h
index 73ef0ba..04e8508 100644
--- a/Core/Type.h
+++ b/Core/Type.h
@@ -1,6 +1,14 @@
-#ifndef __TYPE_H__
+#ifndef __TYPE_H__
 #define __TYPE_H__
 
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <cType.h>
+// #include <math.h>
+
 typedef char					sbyte;
 typedef unsigned char			byte;
 typedef unsigned short			ushort;
@@ -12,20 +20,6 @@ typedef unsigned long long int	uint64;
 typedef uint64 Time_t;
 #define Time_Max (UINT64_MAX - 60000)
 
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-#include <cType.h>
-// #include <math.h>
-
-// 没有参数和返回值的委托
-typedef void(*Func)(void);
-// 一个参数没有返回值的委托，一般param参数用作目标对象，调用者用静态函数包装成员函数
-typedef void(*Action)(void* param);
-typedef void(*Action2)(void*, void*);
-typedef void(*Action3)(void*, void*, void*);
 // 事件处理委托，一般sender表示事件发出者，param用作目标对象，调用者用静态函数包装成员函数
 typedef void(*EventHandler)(void* sender, void* param);
 
@@ -48,46 +42,13 @@ extern MemOptions_t GlobleMemOpt;
 // 一次设置 GlobleMalloc  GlobleFree  GlobleMemOpt
 void SetGlobleMemOpt(MallocFunc malloc, FreeFunc free);
 
-
-// 缓冲区
-typedef struct
-{
-	byte* p;
-	int len;
-	bool needFree;
-	FreeFunc free;
-}Buffer_t;
-
-// 缓冲区, 用于从特定内存中抽取一部分数据。
-typedef struct
-{
-	// 数据指针
-	byte* data;
-	// 数据长度
-	uint len;
-
-	// 是否需要 Free
-	bool needFree;
-	// Free 函数指针
-	FreeFunc free;
-	// Free 函数测参数  data在这其中。
-	byte* freePoint;
-}Buffer2_t;
-
-void InitBuffer(Buffer_t* data);
-void InitBuffer2(Buffer2_t* data);
-
-void TryCleanBuffer(Buffer_t* data);
-void TryCleanBuffer2(Buffer2_t* data);
-
-void ShowBuff(Buffer_t* buff, int len);
-void ShowBuff2(Buffer2_t* buff, int len);
-
-/// <summary>打印数组内容</summary>
-/// <param name="head">数组名称</param>
-/// <param name="pdata">数组指针</param>
-/// <param name="datalen">数组长度</param>
-/// <param name="showlen">打印长度</param>
+/**
+ * @brief 打印数组内容
+ * @param head 数组名称
+ * @param pdata 数组指针
+ * @param datalen 数组长度
+ * @param showlen 打印长度
+ */
 void ShowArray(char* name, byte* pdata, int datalen, int showlen);
 // 数组长度
 #define ArrayLength(arr) ((int)(sizeof(arr)/sizeof(arr[0])))

diff --git a/Core/Version.c b/Core/Version.c
index 543184f..3156fd5 100644
--- a/Core/Version.c
+++ b/Core/Version.c
@@ -1,4 +1,4 @@
-
+
 #include "Type.h"
 #ifdef DEBUG
 #include "Debug.h"
@@ -117,10 +117,11 @@ uint GetVersion(void)
 	return minuint;
 }
 
-/// <summary>获取软件版本,参考 Version.c</summary>
-/// <param name="addr">固件起始地址</param>
-/// <param name="len">固件大小</param>
-/// <returns></returns>
+/**
+ * @brief 获取软件版本,参考 Version.c
+ * @param addr 固件起始地址
+ * @param len 固件大小
+ */
 uint GetFwVersion(uint addr, int len)
 {
 	char* head = "FirmwareBuildTime/";

diff --git a/Core/Version.h b/Core/Version.h
index b091820..0f099a7 100644
--- a/Core/Version.h
+++ b/Core/Version.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "Type.h"
 #include "time.h"
@@ -39,10 +39,11 @@ tm_min		// 分 - 取值区间为[0,59]
 tm_sec		// 秒 - 取值区间为[0,59]
 */
 
-/// <summary>获取软件版本</summary>
-/// <param name="addr">固件起始地址</param>
-/// <param name="len">固件大小</param>
-/// <returns></returns>
+/**
+ * @brief 获取软件版本
+ * @param addr 固件起始地址
+ * @param len 固件大小
+ */
 uint GetFwVersion(uint addr, int len);
 
 
@@ -54,19 +55,21 @@ uint GetFwVersion(uint addr, int len);
 #define GITINFO "NO GIT"
 #endif
 
-/// <summary>GIT仓库信息</summary>
+/** @brief GIT仓库信息 */
 typedef struct
 {
-	/// <summary>git最后提交时间 减去 2000-1-1 00:00:00 得到的分钟数</summary>
+	/** @brief git最后提交时间 减去 2000-1-1 00:00:00 得到的分钟数 */
 	uint TimeMin;
-	/// <summary>提交对应的 SHA-1 值</summary>
+	/** @brief 提交对应的 SHA-1 值 */
 	byte Md5[20];
-	/// <summary>分支信息</summary>
+	/** @brief 分支信息 */
 	char* Branch;
 }GitVersion_t;
 
-/// <summary>获取GIT仓库的提交</summary>
-/// <param name="ver">版本信息</param>
-/// <returns>获取成功</returns>
+/**
+ * @brief 获取GIT仓库的提交
+ * @param ver 版本信息
+ * @return 获取成功
+ */
 bool GetGitVersion(GitVersion_t* ver);
 

diff --git a/Core/VirtualArea.c b/Core/VirtualArea.c
index 982c390..2643974 100644
--- a/Core/VirtualArea.c
+++ b/Core/VirtualArea.c
@@ -3,7 +3,7 @@
 #include "Stream.h"
 #include "BitHelper.h"
 
-// ���ռ��Ƿ��н���
+// 检测空间是否有交集
 static bool AreaCheck(Area_t* a1, Area_t* a2)
 {
 	uint a1end = a1->Addr + a1->Size;
@@ -20,7 +20,7 @@ static int min(int a, int b)
 	return b;
 }
 
-// �� src ������д�� dst �ڡ�
+// 将 src 的数据写到 dst 内。
 int AreaByteCopy(Area_t* dst, Area_t* src)
 {
 	Stream_t dstSt;
@@ -28,17 +28,17 @@ int AreaByteCopy(Area_t* dst, Area_t* src)
 
 	if (dst->Addr <= src->Addr)
 	{
-		// �� src ͷ����д�� dst ����λ�á�
+		// 从 src 头读，写到 dst 后面位置。
 		int posi = src->Addr - dst->Addr;
 		StreamSeek(&dstSt, posi, SeekBegin);
 
-		// dst �ռ�ʣ���Խ��,ȡ��Сֵ���ɡ�
+		// dst 空间剩余别越界,取最小值即可。
 		int remian = StreamRemian(&dstSt);
 		return StreamWriteBytes(&dstSt, src->Buff, min(remian, src->Size));
 	}
 	else
 	{
-		// �� src ���λ�ã�д�� dst ͷ����
+		// 从 src 半截位置，写到 dst 头部。
 		byte* src_p = src->Buff;
 		byte src_len = src->Size;
 
@@ -46,18 +46,18 @@ int AreaByteCopy(Area_t* dst, Area_t* src)
 		src_p += posi;
 		src_len -= posi;
 
-		// ����һ��ʣ���Խ�硣
+		// 控制一下剩余别越界。
 		int remain = StreamRemian(&dstSt);
 		return StreamWriteBytes(&dstSt, src_p, min(remain, src_len));
 	}
 }
 
-// �� src �� bit ����д�� dst �ڡ�
+// 将 src 的 bit 数据写到 dst 内。
 int AreaBitCopy(Area_t* dst, Area_t* src)
 {
 	if (dst->Addr <= src->Addr)
 	{
-		// �� src ͷ����д�� dst ����λ�á�
+		// 从 src 头读，写到 dst 后面位置。
 		int dst_offset = src->Addr - dst->Addr;
 
 		int cplen = min(dst->Size - dst_offset, src->Size);
@@ -78,10 +78,12 @@ int AreaBitCopy(Area_t* dst, Area_t* src)
 	}
 }
 
-/// <summary>������ռ����ݣ��ϲ������</summary>
-/// <param name="dst">Ŀ��ռ�</param>
-/// <param name="srcs">�ռ����飬���һ��� SIZE С�� 1</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 读多个空间数据，合并，半截
+ * @param dst 目标空间
+ * @param srcs 空间数组，最后一项的 SIZE 小于 1
+ * @param isBit 是否是bit空间
+ */
 void AreaRead(Area_t* dst, Area_t* srcs, bool isBit)
 {
 	if (dst->Init)dst->Init(dst);
@@ -102,12 +104,14 @@ void AreaRead(Area_t* dst, Area_t* srcs, bool isBit)
 	}
 }
 
-/// <summary>�Ӷ���ռ��ȡ����</summary>
-/// <param name="srcs">�����ռ�s</param>
-/// <param name="addr">����ַ</param>
-/// <param name="data">������</param>
-/// <param name="len">������</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 从多个空间读取数据
+ * @param srcs 被读空间s
+ * @param addr 读地址
+ * @param data 读缓冲
+ * @param len 读长度
+ * @param isBit 是否是bit空间
+ */
 void AreaRead2(Area_t* srcs, int addr, byte* data, int len, bool isBit)
 {
 	Area_t ar;
@@ -120,10 +124,12 @@ void AreaRead2(Area_t* srcs, int addr, byte* data, int len, bool isBit)
 	AreaRead(&ar, srcs, isBit);
 }
 
-/// <summary>д����ռ����ݣ��Ӵ�ռ��С�ռ䣬����� fresh һ��</summary>
-/// <param name="dsts">Ŀ��ռ����飬���һ��� SIZE С�� 1</param>
-/// <param name="src">Դ</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 写多个空间数据，从大空间拆到小空间，拆出来 fresh 一下
+ * @param dsts 目标空间数组，最后一项的 SIZE 小于 1
+ * @param src 源
+ * @param isBit 是否是bit空间
+ */
 void AreaWrite(Area_t* dsts, Area_t* src, bool isBit)
 {
 	if (src->Init)src->Init(src);
@@ -135,10 +141,10 @@ void AreaWrite(Area_t* dsts, Area_t* src, bool isBit)
 		if (AreaCheck(dsts, src))
 		{
 			if (dsts->Init)dsts->Init(dsts);
-			// �ֳ�ȥ
+			// 分出去
 			if (isBit)AreaBitCopy(dsts, src);
 			else AreaByteCopy(dsts, src);
-			// ˢ��һ�£����磺ʹ������
+			// 刷新一下，比如：使用数据
 			if (dsts->Fresh)dsts->Fresh(dsts);
 		}
 
@@ -146,12 +152,14 @@ void AreaWrite(Area_t* dsts, Area_t* src, bool isBit)
 	}
 }
 
-/// <summary>�����ռ�д����</summary>
-/// <param name="dsts">���</param>
-/// <param name="addr">д���ַ</param>
-/// <param name="data">�����</param>
-/// <param name="len">д�볤��</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 向多个空间写数据
+ * @param dsts 被写入
+ * @param addr 写入地址
+ * @param data 写入数据
+ * @param len 写入长度
+ * @param isBit 是否是bit空间
+ */
 void AreaWrite2(Area_t* dsts, int addr, byte* data, int len, bool isBit)
 {
 	Area_t ar;

diff --git a/Core/VirtualArea.h b/Core/VirtualArea.h
index a7b5b7b..1489c5a 100644
--- a/Core/VirtualArea.h
+++ b/Core/VirtualArea.h
@@ -3,112 +3,120 @@
 #include "Type.h"
 
 /*
-* ӳ��������ַ�ռ�����ݲ�����
-* ͨѶ�и�����ַ��д����������ҵ�����С�
-* ���� modbus ϵ�е�ͨѶ��
+* 映射的虚拟地址空间的数据操作。
+* 通讯中给定地址读写数据以驱动业务运行。
+* 比如 modbus 系列的通讯。
 */
 
-/// <summary>�ռ�Ƭ�ζ���</summary>
+/** @brief 空间片段定义 */
 typedef struct VirtualArea
 {
-	// ��ʼ�����ַ
+	// 起始虚拟地址
 	uint Addr;
-	// �ռ��С
+	// 空间大小
 	uint Size;
 
-	// ʵ�ʴ洢
+	// 实际存储
 	byte* Buff;
-	// ʹ�ÿռ�֮ǰ�Ĵ���,�����Լ�
+	// 使用空间之前的处理,传参自己
 	void(*Init)(struct VirtualArea* thiss);
-	// д�����ݺ�ˢ�£������Լ�
+	// 写入数据后刷新，传参自己
 	void(*Fresh)(struct VirtualArea* thiss);
 }Area_t;
 
-// �� src ������д�� dst �ڡ�
+// 将 src 的数据写到 dst 内。
 int AreaByteCopy(Area_t* dst, Area_t* src);
 
-// �� src �� bit ����д�� dst �ڡ�
+// 将 src 的 bit 数据写到 dst 内。
 int AreaBitCopy(Area_t* dst, Area_t* src);
 
-/// <summary>������ռ����ݣ��ϲ������</summary>
-/// <param name="dst">Ŀ��ռ�</param>
-/// <param name="srcs">�ռ����飬���һ��� SIZE С�� 1</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 读多个空间数据，合并，半截
+ * @param dst 目标空间
+ * @param srcs 空间数组，最后一项的 SIZE 小于 1
+ * @param isBit 是否是bit空间
+ */
 void AreaRead(Area_t* dst, Area_t* srcs, bool isBit);
 
-/// <summary>д����ռ����ݣ��Ӵ�ռ��С�ռ䣬����� fresh һ��</summary>
-/// <param name="dsts">Ŀ��ռ����飬���һ��� SIZE С�� 1</param>
-/// <param name="src">Դ</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 写多个空间数据，从大空间拆到小空间，拆出来 fresh 一下
+ * @param dsts 目标空间数组，最后一项的 SIZE 小于 1
+ * @param src 源
+ * @param isBit 是否是bit空间
+ */
 void AreaWrite(Area_t* dsts, Area_t* src, bool isBit);
 
 
-/// <summary>�Ӷ���ռ��ȡ����</summary>
-/// <param name="srcs">�����ռ�s</param>
-/// <param name="addr">����ַ</param>
-/// <param name="data">������</param>
-/// <param name="len">������</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 从多个空间读取数据
+ * @param srcs 被读空间s
+ * @param addr 读地址
+ * @param data 读缓冲
+ * @param len 读长度
+ * @param isBit 是否是bit空间
+ */
 void AreaRead2(Area_t* srcs, int addr, byte* data, int len, bool isBit);
 
-/// <summary>�����ռ�д����</summary>
-/// <param name="dsts">���</param>
-/// <param name="addr">д���ַ</param>
-/// <param name="data">�����</param>
-/// <param name="len">д�볤��</param>
-/// <param name="isBit">�Ƿ���bit�ռ�</param>
+/**
+ * @brief 向多个空间写数据
+ * @param dsts 被写入
+ * @param addr 写入地址
+ * @param data 写入数据
+ * @param len 写入长度
+ * @param isBit 是否是bit空间
+ */
 void AreaWrite2(Area_t* dsts, int addr, byte* data, int len, bool isBit);
 
 
 /*
-modbus �ο�ʹ�á�
+modbus 参考使用。
 
 void OutInit(Area_t* thiss)
 {
-	// �����״̬
+	// 读输出状态
 	static byte local[1];
 	thiss->Buff = local;
 }
 
 void OutFresh(Area_t* thiss)
 {
-	// ˢ�� IO ���
+	// 刷新 IO 输出
 }
 
 void InInit(Area_t* thiss)
 {
-	// ������״̬
+	// 读输入状态
 	static byte local[1];
 	thiss->Buff = local;
 }
 
 Area_t BitAreas[] =
 {
-	// ��Ȧ
+	// 线圈
 	{.Addr = 0x0000,.Size = 6,.Init = OutInit,.Fresh = OutFresh },
-	// ��ɢ����
+	// 离散输入
 	{.Addr = 0x2020,.Size = 6,.Init = InInit,.Fresh = NULL },
 	{.Size = 0 }
 };
 
 void InfoInit(Area_t* thiss)
 {
-	// ��Ʒ��Ϣ
+	// 产品信息
 }
 
-// ע�⣬����ĵ�ַ�� �ֽڵ�ַ������ modbus ��Ҫ X2 ����
+// 注意，这里的地址是 字节地址，碰到 modbus 需要 X2 处理
 Area_t ByteAreas[] =
 {
-	// �Ĵ���
+	// 寄存器
 	{.Addr = 0x8000,.Size = 16,.Init = InfoInit,.Fresh = NULL },
 	{.Size = 0 }
 };
 
-// bit ��Ȧ in/out ����
+// bit 线圈 in/out 操作
 AreaRead2(BitAreas, addr, data, len ,true);
 AreaWrite2(BitAreas, addr, data, len ,true);
 
-// �Ĵ�����������Ϊ�Ĵ����� short λ������ַ��Ҫ X 2 
+// 寄存器操作，因为寄存器是 short 位宽，地址需要 X 2 
 AreaRead2(BitAreas, regaddr * 2, data, regcnt * 2 ,true);
 AreaWrite2(BitAreas, regaddr * 2, data, regcnt * 2 ,true);