diff --git a/HSI_HexagonMI_EF3/HSI.cpp b/HSI_HexagonMI_EF3/HSI.cpp
index 07fbcd4..59f2864 100644
--- a/HSI_HexagonMI_EF3/HSI.cpp
+++ b/HSI_HexagonMI_EF3/HSI.cpp
@@ -632,7 +632,7 @@ HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_POSITION_XYZ_CACHE(UINT AxisTypes, HSI_
 }
 
 //===========================================================================
-HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_XYZ_CACHE(unsigned char* CacheData, int DataCount)
+HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_XYZ_CACHE(unsigned char* CacheData, int& DataCount)
 {
 	auto rStatus = HSI_STATUS_NORMAL;
 	if (g_pHSI_Motion)
diff --git a/HSI_HexagonMI_EF3/HSI.h b/HSI_HexagonMI_EF3/HSI.h
index 644bac0..c824e56 100644
--- a/HSI_HexagonMI_EF3/HSI.h
+++ b/HSI_HexagonMI_EF3/HSI.h
@@ -449,7 +449,7 @@ HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_SCAN_SET_DATA(UINT AxisTypes, HSI_SCAN_
                                                        double* dTrigDis); //扫描配置
 HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_SCAN_START(); //开始扫描
 HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_SCAN_STOP(); //停止扫描
-HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_XYZ_CACHE(unsigned char* CacheData, int DataCount);
+HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_XYZ_CACHE(unsigned char* CacheData, int& DataCount);
 // 第一阶段结束
 
 
diff --git a/HSI_HexagonMI_EF3/HSI_Motion.cpp b/HSI_HexagonMI_EF3/HSI_Motion.cpp
index 11b9fbc..eb0f469 100644
--- a/HSI_HexagonMI_EF3/HSI_Motion.cpp
+++ b/HSI_HexagonMI_EF3/HSI_Motion.cpp
@@ -3,6 +3,9 @@
 #include "HSI.h"
 #include "HSI_Sevenocean_EF3.h"
 #include "HSI_Motion.h"
+
+#include <cctype>
+
 #include "logger.h"
 #include "SevenOcean/CMMIO_SERIAL.h"
 #include "version.h"
@@ -783,6 +786,9 @@ HSI_STATUS HSI_Motion::Startup(HWND _hWnd, bool _bOfflineOnly)
 			//m_cSendData[3] = 0x03; // 10000 （0x27 0x10）对应1秒，3-4字节表示锁存周期
 			//m_cSendData[4] = 0xE8;
 
+			//m_cSendData[3] = 0x01; // 10000 （0x27 0x10）对应1秒，3-4字节表示锁存周期
+			//m_cSendData[4] = 0xF4;
+
 			// 10000 （0x27 0x10）对应1秒，3-4字节表示锁存周期
 			m_cSendData[3] = (m_axisLatchFrequency >> 8) & 0xFF;
 			m_cSendData[4] = m_axisLatchFrequency & 0xFF;
@@ -870,7 +876,6 @@ HSI_STATUS HSI_Motion::GetFirmwareVersion(byte* version)
 	return HSI_STATUS_NORMAL;
 }
 
-
 //===========================================================================
 /**
  * \brief 回家
@@ -3752,7 +3757,7 @@ HSI_STATUS HSI_Motion::SetPositionXyzCache(UINT AxisTypes, HSI_MOTION_MOVE_TYPE
  * \param DataCount 
  * \return 
  */
-HSI_STATUS HSI_Motion::GetPositionXyzCache(unsigned char* CacheData, int DataCount)
+HSI_STATUS HSI_Motion::GetPositionXyzCache(unsigned char* CacheData, int& DataCount)
 {
 	auto rStatus = HSI_STATUS_NORMAL;
 	if (g_pHSI_Motion)
@@ -3767,7 +3772,6 @@ HSI_STATUS HSI_Motion::GetPositionXyzCache(unsigned char* CacheData, int DataCou
 			m_cSendData[1] = 0x05;
 			m_WriteByte = Send_Command(0, (const char*)m_cSendData, 2, 8); //期望回复8个字节，其中 4-7字节为点数量
 
-
 			//解析缓存点数量
 			if (m_SO7_Serial.m_iRecvState)
 			{
@@ -3789,24 +3793,31 @@ HSI_STATUS HSI_Motion::GetPositionXyzCache(unsigned char* CacheData, int DataCou
 				}
 			}
 
-			//读取锁存点
+			//读取锁存点，给出期望结果
 			m_cSendData[0] = 0x01;
 			m_cSendData[1] = 0x09;
-			m_WriteByte = Send_Command(0, (const char*)m_cSendData, 2, DataCount*12);
-
+			m_WriteByte = Send_Command(0, (const char*)m_cSendData, 2, DataCount * 12);
+			Sleep(100);
 
 			//读取点的字节数，每个点占用12个字节
-			if (m_SO7_Serial.m_iRecvBytes != DataCount * 12)
+			if (m_SO7_Serial.m_iRecvBytes != (DataCount * 12))
 			{
-				g_pLogger->SendAndFlushWithTime(L"[GetPositionXyzCache] m_iRecvBytes: %d  != Points: %d\n",
-				                                m_SO7_Serial.m_iRecvBytes, DataCount * 12);
+				m_SO7_Serial.m_RecvData[0] = 0xff;
+				memcpy(CacheData, m_SO7_Serial.m_RecvData, m_SO7_Serial.m_iRecvBytes); //返回内容
+
+				g_pLogger->SendAndFlushWithTime(L"[GetPositionXyzCache] m_iRecvBytes: %d != Points: %d\n", m_SO7_Serial.m_iRecvBytes, DataCount * 12);
 				rStatus = HSI_STATUS_FAILED;
 			}
 			else
 			{
-				memcpy(CacheData, m_SO7_Serial.m_RecvData, m_SO7_Serial.m_iRecvBytes);
-				m_SO7_Serial.m_iRecvState = FALSE;
-				rStatus = HSI_STATUS_FAILED;
+				m_SO7_Serial.m_RecvData[0] = 0xff;
+				memcpy(CacheData, m_SO7_Serial.m_RecvData, m_SO7_Serial.m_iRecvBytes); //返回内容
+
+				DataCount = m_SO7_Serial.m_iRecvBytes ; //返回点数
+				g_pLogger->SendAndFlushWithTime(L"[GetPositionXyzCache] m_iRecvBytes ok, Points: %d\n",
+					                                m_SO7_Serial.m_iRecvBytes);
+				m_SO7_Serial.m_iRecvState = FALSE; //将接收标志重置
+				rStatus = HSI_STATUS_NORMAL;
 			}
 		}
 		else
@@ -4061,10 +4072,11 @@ HSI_STATUS HSI_Motion::Load_EF3_Motion_Inifile(CString GoogolIniFile)
 				GetPrivateProfileString(L"JOG_SPEED", L"JOG_DRIVESPEED_" + strGear[i] + axisNum[j], L"10",
 				                        temp.GetBufferSetLength(50), 10, csAppPath);
 				float speed = (atof(T2A(temp)));
+				//printf("spedd:%.2F %S\n",speed, L"JOG_DRIVESPEED_" + strGear[i] + axisNum[j]); //调试打印
 				/*m_JogDriveSpeed[j][i] = GetPrivateProfileInt(L"JOG_SPEED", L"JOG_DRIVESPEED_" , 10, csAppPath);*/
 				//m_JogDriveSpeed[j][i] = speed / (m_Resolution[j] * 50);//速度转换为脉冲
 				m_JogDriveSpeed[j][i] = speed; //直接读取速度
-				g_pLogger->SendAndFlushWithTime(L"[Load_EF3_Motion_Inifile] m_JogDriveSpeed[%d][%d]: %d %ld\n", i, j,
+				g_pLogger->SendAndFlushWithTime(L"[Load_EF3_Motion_Inifile] m_JogDriveSpeed[%d][%d]: %.2f %ld\n", i, j,
 				                                speed, m_JogDriveSpeed[j][i]); //打印配置文件 档位速度
 
 				GetPrivateProfileString(L"JOG_SPEED", L"JOG_STARTSPEED_" + strGear[i] + axisNum[j], L"10",
@@ -4190,25 +4202,25 @@ HSI_STATUS HSI_Motion::Load_EF3_Config_Inifile(CString GoogolIniFile)
 		m_IsHavePattern = GetPrivateProfileInt(L"ASIX", L"ISHAVE_AXISPATTERN", 15, csAppPath);
 		m_AxisHomeDirection = GetPrivateProfileInt(L"ASIX", L"AXIS_HOMEDIRECTION", 15, csAppPath);
 		m_IsUseManualRunin = GetPrivateProfileInt(L"ASIX", L"IS_USEMANUALRUNIN", 0, csAppPath);
-		m_axisLatchFrequency = GetPrivateProfileInt(L"ASIX", L"AXIS_LATCHFREQUENCY", 1, csAppPath);
-		switch (m_axisLatchFrequency)
-		{
-		case 1:
-			m_axisLatchFrequency = 1000;
-			break;
-		case 2:
-			m_axisLatchFrequency = 2000;
-			break;
-		case 3:
-			m_axisLatchFrequency = 4000;
-			break;
-		case 4:
-			m_axisLatchFrequency = 8000;
-			break;
-		case 5:
-			m_axisLatchFrequency = 16000;
-			break;
-		} //锁存频率处理
+		m_axisLatchFrequency = GetPrivateProfileInt(L"ASIX", L"AXIS_LATCHFREQUENCY", 1000, csAppPath);
+		//switch (m_axisLatchFrequency)
+		//{
+		//case 1:
+		//	m_axisLatchFrequency = 1000;
+		//	break;
+		//case 2:
+		//	m_axisLatchFrequency = 2000;
+		//	break;
+		//case 3:
+		//	m_axisLatchFrequency = 4000;
+		//	break;
+		//case 4:
+		//	m_axisLatchFrequency = 8000;
+		//	break;
+		//case 5:
+		//	m_axisLatchFrequency = 16000;
+		//	break;
+		//} //锁存频率处理
 
 		m_IsUseExternalTrigger = GetPrivateProfileInt(L"FUNCTION", L"IS_USEEXTERNALTRIGGER", 1, csAppPath);
 		m_IsUseSixRingEightArea = GetPrivateProfileInt(L"FUNCTION", L"IS_USESIXRINGEIGHTAREA", 0, csAppPath);
@@ -6278,7 +6290,7 @@ HSI_STATUS HSI_Motion::DCCScanSetData(UINT AxisTypes, HSI_SCAN_MOTION_TYPE eType
 		m_cSendData[0] = 0x01;
 		m_cSendData[1] = 0x04;
 		m_WriteByte = Send_Command(0, (const char*)m_cSendData, 2);
-		Sleep(20);
+		Sleep(2000);//延时2秒，等待清空完成，EF3清空Flash比较慢
 		g_pLogger->SendAndFlushWithTime(L"[DCCScanSetData] Out\n");
 	}
 	ReleaseMutex(g_WR_ToMove_Mutex);
@@ -6407,11 +6419,12 @@ HSI_STATUS HSI_Motion::DCCScanStart()
 		//m_WriteByte = Send_Command(0, (const char*)m_SendDCCData, m_SendDataLength);
 
 		//启动定时扫描，此处清空旧缓存值
-		unsigned char m_cSendData[8] = { 0 };
+		unsigned char m_cSendData[8] = {0};
 		m_cSendData[0] = 0x01;
 		m_cSendData[1] = 0x04;
 		m_WriteByte = Send_Command(0, (const char*)m_cSendData, 2, 2);
 
+		Sleep(100);
 		//启动定时锁存的同时启动扫描外部IO
 		m_cSendData[0] = 0x01;
 		m_cSendData[1] = 0x02;
@@ -8935,13 +8948,16 @@ BOOL HSI_Motion::Send_Command(int com, const char* _SendData, DWORD SendDataLeng
 			g_pLogger->SendAndFlushWithTime(L"[Send_Command] m_SO7_Serial[%d].Send failed\n", com);
 			rStatus = FALSE;
 		}
-		//	Sleep(5);
-		//	m_SO7_Serial.OnReceive();
+		//Sleep(5);
+		//m_SO7_Serial.OnReceive();
 	}
 	ReleaseMutex(g_RW_Data_Mutex);
 	return rStatus;
 };
-
+//分3个层次处理该问题：ZZX
+//1、用户层：业务逻辑层面处理，并在发送的时候，给出期望回应值
+//2、发送层：保证发送成功，并对返回数据进行一定的判断，如果通讯超时，进行重发逻辑
+//3、接收数据线程，获得单包数据后，根据期望值进行拼包判断处理，返回拼包后的数据
 BOOL HSI_Motion::Send_Command(int com, const char* _SendData, DWORD SendDataLength, int expectType)
 {
 	BOOL rStatus = TRUE;
@@ -8997,15 +9013,57 @@ BOOL HSI_Motion::Send_Command(int com, const char* _SendData, DWORD SendDataLeng
 			                                SendDataLength);
 		}
 		m_SO7_Serial.m_iRecvState = false; //发送完毕，接收状态置为false，并开始等待EF3回复
-		m_SO7_Serial.m_iExpectBytes = expectType;
+		m_SO7_Serial.m_iExpectBytes = expectType; //给出期望结果，传递到下层，由下层进行拼包
+
 		//判断回复值，是否为ok 6F 6B 
 		int iRetrys = 0;
-		while (!m_SO7_Serial.m_iRecvState && iRetrys < 1000) //等待
+		while (!m_SO7_Serial.m_iRecvState && iRetrys < 100) //再次接收等待
 		{
 			iRetrys++;
 			Sleep(3);
 		}
-		g_pLogger->SendAndFlushWithTime(L"[Send_Command] iRetrys:%d\n", iRetrys);
+		g_pLogger->SendAndFlushWithTime(L"[Send_Command] Timeout Retrys:%d\n", iRetrys);
+
+		//两种情况，1、成功获得期望值；2、如果超时
+		if (m_SO7_Serial.m_iRecvState && (m_SO7_Serial.m_iRecvBytes == expectType))
+		{
+			rStatus = TRUE;
+			g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply OK, RecvBytes:%d, %S\n",
+			                                m_SO7_Serial.m_iRecvBytes,
+			                                m_SO7_Serial.HexToStr((const char*)m_SO7_Serial.m_RecvData,
+			                                                      m_SO7_Serial.m_iRecvBytes));
+	/*		g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply OK, RecvBytes:%d\n",
+				m_SO7_Serial.m_iRecvBytes);*/
+		}
+		else if (iRetrys > 100) //获取超时，重发
+		{
+			iRetrys = 0;
+			g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply Timeout ,ReSend\n");
+			int iWriteByte = m_SO7_Serial.Send(_SendData, SendDataLength); //再次重发，并等待回应
+			m_SO7_Serial.m_iRecvState = false; //发送完毕，接收状态置为false，并开始等待EF3回复
+			m_SO7_Serial.m_iExpectBytes = expectType; //给出期望结果，传递到下层，由下层进行拼包
+
+			while (!m_SO7_Serial.m_iRecvState && iRetrys < 100)
+			{
+				iRetrys++;
+				Sleep(2);
+			}
+
+			if (iRetrys > 100)
+			{
+				rStatus = HSI_STATUS_FAILED;
+				g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply Error!");
+			}
+			else //获得期望结果
+			{
+				rStatus = HSI_STATUS_NORMAL;
+				g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply OK, RecvBytes:%d, %s\n",
+				                                m_SO7_Serial.m_iRecvBytes,
+				                                m_SO7_Serial.HexToStr((const char*)m_SO7_Serial.m_RecvData,
+				                                                      m_SO7_Serial.m_iRecvBytes));
+			}
+		}
+
 		//发送完当前指令后，第一次结束完成标志
 		//if (m_SO7_Serial.m_iRecvBytes != expectType) //获取数量不等于期望数量，打印错误，并重发
 		//{
@@ -9033,7 +9091,6 @@ BOOL HSI_Motion::Send_Command(int com, const char* _SendData, DWORD SendDataLeng
 		//				Sleep(2);
 		//			}
 		//		}
-
 		//		if (iRetrys > 100)
 		//		{
 		//			rStatus = HSI_STATUS_FAILED;
@@ -9050,18 +9107,15 @@ BOOL HSI_Motion::Send_Command(int com, const char* _SendData, DWORD SendDataLeng
 		//	}
 		//}
 		//else
-		{
-			rStatus = FALSE;
-			g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply OK, RecvBytes:%d, %s\n",
-			                                m_SO7_Serial.m_iRecvBytes,
-			                                m_SO7_Serial.HexToStr((const char*)m_SO7_Serial.m_RecvData,
-			                                                      m_SO7_Serial.m_iRecvBytes));
-		}
+		//{
+		//	rStatus = FALSE;
+		//	g_pLogger->SendAndFlushWithTime(L"[Send_Command] EF3 Reply OK, RecvBytes:%d, %s\n",
+		//	                                m_SO7_Serial.m_iRecvBytes,
+		//	                                m_SO7_Serial.HexToStr((const char*)m_SO7_Serial.m_RecvData,
+		//	                                                      m_SO7_Serial.m_iRecvBytes));
+		//}
 	}
-
-	//打印串口返回值,该方式废弃
-	//Sleep(5);
-	//m_SO7_Serial.OnReceive();
+	
 
 	ReleaseMutex(g_RW_Data_Mutex);
 	return rStatus;
diff --git a/HSI_HexagonMI_EF3/HSI_Motion.h b/HSI_HexagonMI_EF3/HSI_Motion.h
index 0e608e5..63c236e 100644
--- a/HSI_HexagonMI_EF3/HSI_Motion.h
+++ b/HSI_HexagonMI_EF3/HSI_Motion.h
@@ -257,7 +257,7 @@ public:
 	HSI_STATUS SetPositionXyza(UINT AxisTypes, double PositionX, double PositionY, double PositionZ, double PositionA,
 	                           HSI_MOTION_MOVE_TYPE eType, double dFlyRadius);
 	HSI_STATUS SetPositionXyzCache(UINT AxisTypes, HSI_MOTION_MOVE_TYPE eType, int DataCount, Point* CacheData);
-	HSI_STATUS GetPositionXyzCache(unsigned char * CacheData, int DataCount);
+	HSI_STATUS GetPositionXyzCache(unsigned char* CacheData, int& DataCount);
 	HSI_STATUS GetPositionR(UINT AxisTypes, double& PositionR, double& Time);
 	HSI_STATUS SetPositionR(UINT AxisTypes, double PositionR, HSI_MOTION_AXIS_R_MOVE_TYPE DirectionType, bool bWait);
 	HSI_STATUS SetCircleInterpolate(double PositionX, double PositionY, double PositionZ); //圆弧插补
diff --git a/HSI_HexagonMI_EF3/SevenOcean/CMMIO_BASE.CPP b/HSI_HexagonMI_EF3/SevenOcean/CMMIO_BASE.CPP
index 688d2ad..049dd00 100644
--- a/HSI_HexagonMI_EF3/SevenOcean/CMMIO_BASE.CPP
+++ b/HSI_HexagonMI_EF3/SevenOcean/CMMIO_BASE.CPP
@@ -56,7 +56,7 @@ DWORD CMMIO::Send(CString buffer, BOOL needsResponse/*=FALSE*/)
 	return res;
 }
 
-// GetNextReceived() : Helper function, rreturns receives messages placed in the queue
+// GetNextReceived() : Helper function, returns receives messages placed in the queue
 //                     by LineReceive()
 //
 int CMMIO::GetNextReceived(char* inputBuf)
@@ -199,7 +199,7 @@ int CMMIO::AddReceived(const char* Buffer, DWORD Bytes)
 				// All done so out of the CriticalSection
 				++m_iNbMsgWaiting;
 			}
-			//			LeaveCriticalSection( &m_QueueLock );
+			// LeaveCriticalSection( &m_QueueLock );
 			pBuffer2 = &Buffer2[0]; // reset out buffer
 			count = 0;
 			bEventRequest = true;
@@ -226,6 +226,7 @@ void CMMIO::LineReceive(char* s, int nbCharAvail, BOOL ignoreDelimiter /*= FALSE
 			if ((!m_usesTerminator && i == nbCharAvail - 1) || (m_usesTerminator && c == m_terminator) ||
 				ignoreDelimiter)
 			{
+				printf("LineReceive got %d chars \n", CurrentPointer);
 				m_InputBuffer[CurrentPointer] = '\0';
 				AddReceived(m_InputBuffer, CurrentPointer);
 				CurrentPointer = 0;
diff --git a/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.CPP b/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.CPP
index 2995730..4f18ec1 100644
--- a/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.CPP
+++ b/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.CPP
@@ -189,6 +189,15 @@ DWORD CPSerial::Open()
 				if (SetupComm(m_PortHandle, 2048, 2048))
 				{
 					// Setup the event masks for the monitoring task
+					//	璁剧疆浣犲叧蹇冪殑浜嬩欢, 褰撴浜嬩欢鍙戠敓鏃�, 灏嗗緱鍒颁簨浠堕�氱煡, 閫氳繃SetCommMask鍑芥暟璁剧疆, SetCommMask鍑芥暟涓や釜鍙傛暟, 绗竴涓负涓插彛鍙ユ焺, 绗簩涓负浜嬩欢, 鍙�氳繃浣嶆垨鐨勬柟寮忔寚瀹氬涓簨浠�,濡備笅:
+					//	BOOL WINAPI SetCommMask(
+					//		__in HANDLE hFile,
+					//		__in DWORD dwEvtMask);
+
+					//绀轰緥浠ｇ爜:
+					//	SetCommMask(m_hCom, EV_RXCHAR);
+					//	EV_RXCHAR浜嬩欢鎸囧綋杈撳叆缂撳啿鍖哄唴鏈夋暟鎹椂, 閫氳繃WaitCommEvent鍑芥暟鍙幏寰楅�氱煡, 鍏朵粬浜嬩欢鍚岀悊, 鍏朵粬浜嬩欢杩樻湁EV_BREAK / EV_CTS / EV_RING绛�,
+
 					if (SetCommMask(m_PortHandle, EV_RXCHAR | EV_TXEMPTY | EV_BREAK |
 					                EV_CTS | EV_DSR | EV_ERR | EV_RLSD))
 					{
@@ -444,7 +453,7 @@ DWORD CPSerial::WritePort(const char* Buffer, DWORD Bytes)
 }
 
 
-//==========================================================================
+/////////////////////////////////////////////////////////////////////////////
 //鍗曠函璇诲彇鍗曞寘涓插彛鏁版嵁锛屾嫾鍖呭姛鑳藉湪涓婂眰瀹炵幇
 int CPSerial::ReadBlock(BYTE* abIn, int MaxLength)
 {
@@ -454,14 +463,26 @@ int CPSerial::ReadBlock(BYTE* abIn, int MaxLength)
 	ClearCommError(m_PortHandle, &dwErrorFlags, &ComStat);
 	if (dwErrorFlags > 0)
 	{
+		//PURGE_TXABORT | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_RXCLEAR
+		//鍒嗗埆琛ㄧず:
+		//绔嬪嵆涓柇鍐欐搷浣滃苟娓呯┖杈撳嚭缂撳啿鍖� | 娓呯┖杈撳嚭缂撳啿鍖� | 绔嬪嵆涓柇璇绘搷浣滃苟娓呯┖杈撳叆缂撳啿鍖� | 娓呯┖杈撳叆缂撳啿鍖�
 		PurgeComm(m_PortHandle, PURGE_RXABORT | PURGE_RXCLEAR);
 		return 0;
 	}
 	dwLength = (static_cast<DWORD>(MaxLength) < ComStat.cbInQue ? MaxLength : ComStat.cbInQue);
 	//memset(abIn, 0, MaxLength);
-	//濡傛灉鏈夊瓧绗﹀嵆璇诲叆, 杩欑绛栫暐涓嬫棤娉曡В鍐宠鍏ョ殑瀛楃涓嶆槸瀹屾暣鐨勪竴甯х殑闂 Bug
+	//濡傛灉鏈夊瓧绗﹀嵆璇诲叆, 杩欑绛栫暐涓嬫棤娉曡В鍐宠鍏ョ殑瀛楃涓嶆槸瀹屾暣鐨勪竴甯х殑闂
 	if (dwLength)
 	{
+		//BOOL ReadFile(
+		//	HANDLE hFile,            //鏂囦欢鐨勫彞鏌�
+		//	LPVOID lpBuffer,          //鐢ㄤ簬淇濆瓨璇诲叆鏁版嵁鐨勪竴涓紦鍐插尯
+		//	DWORD nNumberOfBytesToRead,    //瑕佽鍏ョ殑瀛楄妭鏁�
+		//	LPDWORD lpNumberOfBytesRead,    //鎸囧悜瀹為檯璇诲彇瀛楄妭鏁扮殑鎸囬拡
+		//	LPOVERLAPPED lpOverlapped
+		//	//濡傛枃浠舵墦寮�鏃舵寚瀹氫簡FILE_FLAG_OVERLAPPED锛岄偅涔堝繀椤伙紝鐢ㄨ繖涓弬鏁板紩鐢ㄤ竴涓壒娈婄殑缁撴瀯銆�
+		//	//璇ョ粨鏋勫畾涔変簡涓�娆″紓姝ヨ鍙栨搷浣溿�傚惁鍒欙紝搴斿皢杩欎釜鍙傛暟璁句负NULL
+		//);
 		JudgeRead = ReadFile(m_PortHandle, abIn, dwLength, &dwLength, &m_ReceiveOLap); //璇诲嚭瀛楃鑷砤bIn澶�
 		if (!JudgeRead)
 		{
@@ -469,10 +490,17 @@ int CPSerial::ReadBlock(BYTE* abIn, int MaxLength)
 			if (GetLastError() == ERROR_IO_PENDING)
 			{
 				// WaitForSingleObject(m_osRead.hEvent,INFINITE);
-				GetOverlappedResult(m_PortHandle, &m_ReceiveOLap, &dwLength, TRUE);
+				GetOverlappedResult(m_PortHandle, &m_ReceiveOLap, &dwLength, TRUE); //绛夊緟涓�娆″紓姝ヨ鍙栧畬鎴�
 				m_ReceiveOLap.Offset = 0;
 				// m_osRead.Offset=(m_osRead.Offset+dwLength)%MAXBLOCK;
+
+				//绛夊緟涓�娆″紓姝ユ搷浣滆秴鏃剁殑鎯呭喌涓嬶紝GetOverlappedResult杩斿洖FALSE锛屽悓鏃禛etLastError杩斿洖ERROR_IO_INCOMPLETE
+			/*	if (WaitForSingleObject(m_osRead.hEvent, 1000) == WAIT_TIMEOUT)
+				{
+					dwLength = 0;
+				}     */   
 			}
+			//寮傚父鎯呭喌
 			else
 			{
 				dwLength = 0;
@@ -482,9 +510,69 @@ int CPSerial::ReadBlock(BYTE* abIn, int MaxLength)
 	return dwLength;
 }
 
-/////////////////////////////////////////////////////////////////////////////
-// ReceiveTask() : Internal function, this runs as a thread and provides the
-//                 OnRecieve and OnTransmit events
+int CPSerial::Receive(void* buf, int maxlen, bool sync)
+{
+	//HANDLE hCom = *(HANDLE*)m_PortHandle;
+
+	if (sync)
+	{
+		
+		//鍚屾鏂瑰紡
+		DWORD wCount = maxlen; //鎴愬姛璇诲彇鐨勬暟鎹瓧鑺傛暟
+		BOOL bReadStat = ReadFile(m_PortHandle, //涓插彛鍙ユ焺
+			buf, //鏁版嵁棣栧湴鍧�
+			wCount, //瑕佽鍙栫殑鏁版嵁鏈�澶у瓧鑺傛暟
+			&wCount, //DWORD*,鐢ㄦ潵鎺ユ敹杩斿洖鎴愬姛璇诲彇鐨勬暟鎹瓧鑺傛暟
+			NULL); //NULL涓哄悓姝ュ彂閫侊紝OVERLAPPED*涓哄紓姝ュ彂閫�
+		if (!bReadStat)
+		{
+			return 0;
+		}
+		return wCount;
+	}
+	else
+	{
+		
+		//寮傛鏂瑰紡
+		DWORD wCount = maxlen; //鎴愬姛璇诲彇鐨勬暟鎹瓧鑺傛暟
+		DWORD dwErrorFlags; //閿欒鏍囧織
+		COMSTAT comStat; //閫氳鐘舵��
+		OVERLAPPED m_osRead; //寮傛杈撳叆杈撳嚭缁撴瀯浣�
+
+		//鍒涘缓涓�涓敤浜嶰VERLAPPED鐨勪簨浠跺鐞嗭紝涓嶄細鐪熸鐢ㄥ埌锛屼絾绯荤粺瑕佹眰杩欎箞鍋�
+		memset(&m_osRead, 0, sizeof(m_osRead));
+		//m_osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, L"ReadEvent");
+
+		ClearCommError(m_PortHandle, &dwErrorFlags, &comStat); //娓呴櫎閫氳閿欒锛岃幏寰楄澶囧綋鍓嶇姸鎬�
+		if (!comStat.cbInQue)return 0; //濡傛灉杈撳叆缂撳啿鍖哄瓧鑺傛暟涓�0锛屽垯杩斿洖false
+
+		BOOL bReadStat = ReadFile(m_PortHandle, //涓插彛鍙ユ焺
+			buf, //鏁版嵁棣栧湴鍧�
+			wCount, //瑕佽鍙栫殑鏁版嵁鏈�澶у瓧鑺傛暟
+			&wCount, //DWORD*,鐢ㄦ潵鎺ユ敹杩斿洖鎴愬姛璇诲彇鐨勬暟鎹瓧鑺傛暟
+			&m_osRead); //NULL涓哄悓姝ュ彂閫侊紝OVERLAPPED*涓哄紓姝ュ彂閫�
+		if (!bReadStat)
+		{
+			if (GetLastError() == ERROR_IO_PENDING) //濡傛灉涓插彛姝ｅ湪璇诲彇涓�
+			{
+				//GetOverlappedResult鍑芥暟鐨勬渶鍚庝竴涓弬鏁拌涓篢RUE
+				//鍑芥暟浼氫竴鐩寸瓑寰咃紝鐩村埌璇绘搷浣滃畬鎴愭垨鐢变簬閿欒鑰岃繑鍥�
+				GetOverlappedResult(m_PortHandle, &m_osRead, &wCount, TRUE);
+
+			/*	memcpy(m_RecvData, buf, wCount);
+				m_iRecvBytes = wCount;
+				m_iRecvState = true;*/
+			}
+			else
+			{
+				ClearCommError(m_PortHandle, &dwErrorFlags, &comStat); //娓呴櫎閫氳閿欒
+				CloseHandle(m_osRead.hEvent); //鍏抽棴骞堕噴鏀緃Event鐨勫唴瀛�
+				return 0;
+			}
+		}
+		return wCount;
+	}
+}
 
 /*
 // C prototype : void HexToStr(char *pszDest, byte *pbSrc, int nLen)
@@ -510,19 +598,22 @@ void CPSerial::hex2str(char* pszDest, byte* pbSrc, int nLen)
 	pszDest[nLen * 2] = '\0';
 }
 
-#if 1
+/////////////////////////////////////////////////////////////////////////////
+// ReceiveTask() : Internal function, this runs as a thread and provides the
+//                 OnRecieve and OnTransmit events
 void CPSerial::ReceiveTask(void)
 {
 	//DWORD BytesWritten;
 	DWORD Events;
 	unsigned long State;
-
+	int temp_Packlen = 0; //涓存椂瀛樻斁鍖呴暱搴�
 	do
 	{
-		Sleep(2);
+		Sleep(3);
 		BYTE abIn[MAXBLOCK];
 		int len;
-		len = ReadBlock(abIn, MAXBLOCK); //鍗曞寘璇诲彇
+		//len = ReadBlock(abIn, MAXBLOCK); //璇诲彇涓�鍖呬覆鍙ｆ暟鎹�
+		len = Receive(abIn, MAXBLOCK, 0);//鏂瑰紡2
 		if ((len > 0) && (len < MAX_RECIEVE_BUFFER_SIZE))
 		{
 			//memset(m_RecvData, 0, m_iRecvBytes);
@@ -530,37 +621,54 @@ void CPSerial::ReceiveTask(void)
 			{
 				auto pszDest = new char[len * 2 + 1];
 				hex2str(pszDest, abIn, len);
-				printf("len=%d, m_iExpectBytes=%d, %s\n", len, m_iExpectBytes, pszDest);
+				printf("kaishi  len=%d, m_iExpectBytes=%d, %s\n", len, m_iExpectBytes, pszDest); //鎵撳嵃鍗曞寘鏁版嵁锛屾瘡娆″彲浠ヤ粠杩欓噷寰楀埌鍗曞寘鏁版嵁
 			}
-			if (m_iExpectBytes != 0) //褰撴湁鏈熸湜鍊兼椂锛岃繘琛屾嫾鍖�
-			{
-				//寰幆鎷煎寘
-				if (m_iRecvBytes < m_iExpectBytes)
-				{
-					while (m_iRecvBytes < m_iExpectBytes)
-					{
-						memcpy(m_RecvData + m_iRecvBytes, abIn, len);
-						m_iRecvBytes += len;
 
-						auto pszDest = new char[m_iRecvBytes * 2 + 1];
-						hex2str(pszDest, m_RecvData, m_iRecvBytes);
-						printf("11111=%d %s\n", m_iRecvBytes, pszDest);
-					}
-				}
-				else // 澶т簬绛変簬鏈熸湜杩斿洖鏁伴噺锛屾垚鍔�
-				{
-					memcpy(m_RecvData, abIn, len);
-					m_iRecvBytes = len;
-					m_iRecvState = TRUE;
-				}
-			}
-			else //鏃犳湡鏈涜繑鍥炴暟閲忔椂锛岄殢鏈鸿繑鍥炲崟鍖呮暟鎹�
+			// 绗竴灞傚垽鏂紝褰撳墠鎺ユ敹姝ｅソ涓烘湡鏈涜繑鍥�
+			if (len == m_iExpectBytes)
 			{
 				memcpy(m_RecvData, abIn, len);
 				m_iRecvBytes = len;
-				m_iRecvState = TRUE;
+				m_iRecvState = true;
+
+				printf("=====");
+				temp_Packlen = 0;
+			}
+
+			// 绗簩灞傚垽鏂紝褰撳墠鎺ユ敹涓烘湡鏈涜繑鍥炵殑涓�閮ㄥ垎
+			else if (len < m_iExpectBytes)
+			{
+				memcpy(m_RecvData + temp_Packlen, abIn, len);
+				temp_Packlen += len;
+
+				//鎵撳嵃鎷煎寘鍚庣殑鏁版嵁
+				auto pszDest = new char[m_iRecvBytes * 2 + 1];
+				hex2str(pszDest, m_RecvData, m_iRecvBytes);
+				printf("pinbao = %d %s\n", m_iRecvBytes, pszDest);
+
+				// 绗笁灞傚垽鏂紝褰撳墠鎺ユ敹涓烘湡鏈涜繑鍥炵殑鏈�鍚庝竴閮ㄥ垎
+				if (temp_Packlen == m_iExpectBytes)
+				{
+					m_iRecvBytes = temp_Packlen;
+					m_iRecvState = true;
+
+					printf("pinbao========");
+				}
+			}
+
+			// 绗洓灞傚垽鏂紝褰撳墠鎺ユ敹涓烘湡鏈涜繑鍥炵殑瓒呭嚭閮ㄥ垎,浠ュ疄闄呮帴鏀朵负鍑�
+			else if (len > m_iExpectBytes)
+			{
+				memcpy(m_RecvData, abIn, len);
+				m_iRecvBytes = len;
+				m_iRecvState = true;
+
+				printf(">>>>>>>>>>>>========");
+				temp_Packlen = 0;
 			}
 		}
+
+
 		//   Events=0;
 		//
 		//   // Wait for a comm event
@@ -614,7 +722,7 @@ void CPSerial::ReceiveTask(void)
 }
 
 
-#endif
+
 #if 0
 void CPSerial::ReceiveTask(void)
 {
@@ -685,9 +793,10 @@ void CPSerial::OnReceive()
 	char s[MAX_RECIEVE_BUFFER_SIZE] = {0};
 	s[1] = '\0';
 	CurrentPointer = 0;
+	int num = 0;
 	if (m_HandShake == CS_HANDSHAKE_FOR_TRESASTR_E)
 	{
-		int num = ReadPort(s, MAX_RECIEVE_BUFFER_SIZE);
+		num = ReadPort(s, MAX_RECIEVE_BUFFER_SIZE);
 		if ((num > 0) && (num < MAX_RECIEVE_BUFFER_SIZE))
 		{
 			if (m_IsWrtingData)
@@ -709,7 +818,7 @@ void CPSerial::OnReceive()
 	}
 	else
 	{
-		int num = ReadPort(s, m_iRecvCount);
+		num = ReadPort(s, m_iRecvCount);
 		printf("----Data received:: %d----\r\n", num);
 		if ((num > 0) && (num < MAX_RECIEVE_BUFFER_SIZE))
 		{
@@ -723,7 +832,7 @@ void CPSerial::OnReceive()
 			}
 		}
 	}
-	//LineReceive(s, num);
+	LineReceive(s, num);
 }
 
 
diff --git a/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.H b/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.H
index 91808e5..ac71c09 100644
--- a/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.H
+++ b/HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.H
@@ -130,6 +130,7 @@ public:
 	void hex2str(char* pszDest, byte* pbSrc, int nLen);
 	//字节数据转换为16进制字符串
 	CString HexToStr(const char* pData, int nLen);
+	int Receive(void* buf, int maxlen, bool sync);
 
 	DWORD Send(LPCSTR buffer, int l, BOOL needsResponse = FALSE) override;
 	//virtual DWORD Send(CString what);
@@ -191,9 +192,9 @@ public:
 	// BV Nov 2001: Made public
 	//	CRITICAL_SECTION m_QueueLock;
 	BOOL m_iRecvState; //接收状态 
-	INT m_iRecvBytes;  //接收字节数
-	INT m_iRecvCount;  //接收计数
-	INT m_iExpectBytes =0; //定义期望接收的数据长度
+	INT m_iRecvBytes; //接收字节数
+	INT m_iRecvCount; //接收计数
+	INT m_iExpectBytes = 0; //定义期望接收的数据长度
 	BOOL m_bDebug = true; //调试模式，默认关闭
 	unsigned char m_RecvData[MAX_RECIEVE_BUFFER_SIZE];
 };
diff --git a/HSI_HexagonMI_EF3/logger.cpp b/HSI_HexagonMI_EF3/logger.cpp
index 7314de0..d2813f9 100644
--- a/HSI_HexagonMI_EF3/logger.cpp
+++ b/HSI_HexagonMI_EF3/logger.cpp
@@ -65,7 +65,8 @@ void CLogger::SendAndFlush(LPCTSTR format, ...)
 	LeaveCriticalSection(&m_lockLogger);
 }
 
-//vswprintf_s()参考连接：https://www.educative.io/answers/what-is-vswprintfs-in-c
+//vswprintf_s()
+//参考连接：https://www.educative.io/answers/what-is-vswprintfs-in-c
 void CLogger::SendAndFlushWithTime(LPCTSTR format, ...)
 {
 	EnterCriticalSection(&m_lockLogger);
@@ -83,7 +84,13 @@ void CLogger::SendAndFlushWithTime(LPCTSTR format, ...)
 		va_list list;
 		//在C中，当无法列出传递函数的所有实参的类型和数目时，可以用省略号指定参数表
 		va_start(list, format);
-		length = vswprintf_s(m_Str2, 5000, format, list);
+		//vswprintf()函数将宽字符串写入宽字符串缓冲区
+
+		//ws:指定指向给定宽字符串缓冲区的指针，该缓冲区将存储结果
+		//len : 指定写回缓冲区的宽字符的最大长度，包括终止的空字符
+		//format : 指定指向空终止的宽字符串的指针
+		//arg : 指定标识变量参数列表的值
+		length = vswprintf(m_Str2, 5000, format, list);
 		CTime _cTime = CTime::GetCurrentTime();
 		CString csTime = _cTime.Format("[%Y/%m/%d %H:%M:%S");
 		struct _timeb timebuffer;
@@ -208,7 +215,6 @@ void DelFiles(string path)
 	while (!_findnext(handle, &fileinfo));
 
 	_findclose(handle);
-	return;
 }
 
 string ByteArrayToString(byte byteArray[])
diff --git a/HSI_HexagonMI_EF3/version.h b/HSI_HexagonMI_EF3/version.h
index dfec466..e860527 100644
--- a/HSI_HexagonMI_EF3/version.h
+++ b/HSI_HexagonMI_EF3/version.h
@@ -12,5 +12,5 @@
 #define HSI_VERSION_REVNUM              
 #define HSI_VERSION_BUILD_DATE        _T(__DATE__ )  
 #define HSI_VERSION_BUILD_TIME        _T(__TIME__ )  
-#define HSI_FILE_DESCRIPTION          "2022.11.28 / 16:48 "  
-#define HSI_FILE_CSDESCRIPTION        _T("2022.11.28 / 16:48 ")  
+#define HSI_FILE_DESCRIPTION          "2022.12.01 / 15:52 "  
+#define HSI_FILE_CSDESCRIPTION        _T("2022.12.01 / 15:52 ")  
diff --git a/HSI_SEVENOCEAN_EF1_CsTest/HSI/HSI.cs b/HSI_SEVENOCEAN_EF1_CsTest/HSI/HSI.cs
index 7eef5cc..0fb00cf 100644
--- a/HSI_SEVENOCEAN_EF1_CsTest/HSI/HSI.cs
+++ b/HSI_SEVENOCEAN_EF1_CsTest/HSI/HSI.cs
@@ -10,78 +10,78 @@ namespace HSI_SEVENOCEAN_EF1_CsTest.HSI
 		// >>>> In Interfaces
 		//引用回调
 		public delegate void PEventCallback(
-			Def.HSI_EVENT_TYPE eventType, Def.HSI_EVENT_RESPONSE_TYPE responseType, uint eventId, string eventData,
+			HSI_EVENT_TYPE eventType, HSI_EVENT_RESPONSE_TYPE responseType, uint eventId, string eventData,
 			ref uint eventCallbackId);
 
 		public static PEventCallback HsiCallback;
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_GET_INTERFACE_VERSION", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS GetInterfaceVersion(ref uint apiVersionMajor, ref uint apiVersionMinor);
+		public static extern HSI_STATUS GetInterfaceVersion(ref uint apiVersionMajor, ref uint apiVersionMinor);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_GET_MACHINE_INFO", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS GetMachineInfo(ref int numMachineTypes);
+		public static extern HSI_STATUS GetMachineInfo(ref int numMachineTypes);
 
 		//引用返回值表示一个方法的返回值是一个引用，而不是值类型对象的副本或者引用类型的地址，
 		//而一个方法要实现引用返回值，需要满足两个条件：
 		//1、返回值不能为void，且需要使用ref关键字(或者ref readonly表示只读)修饰返回类型
 		//2、方法的每一个return语句需要是一个ref引用
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_FIREWAREVERION", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS MotionGetFirewareVerion(IntPtr firewareVerion);
+		public static extern HSI_STATUS MotionGetFirewareVerion(IntPtr firewareVerion);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_STARTUP", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS Startup(IntPtr hWnd, bool bOfflineOnly);
+		public static extern HSI_STATUS Startup(IntPtr hWnd, bool bOfflineOnly);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_SET_EVENT_CALLBACK", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS SetEventCallback(PEventCallback pCallback);
+		public static extern HSI_STATUS SetEventCallback(PEventCallback pCallback);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_SHUTDOWM", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS Shutdown();
+		public static extern HSI_STATUS Shutdown();
 
 		// <<<< Out Interfacess
 		//事件回调函数
-		public static void EventCallback(Def.HSI_EVENT_TYPE eventType, Def.HSI_EVENT_RESPONSE_TYPE responseType,
+		public static void EventCallback(HSI_EVENT_TYPE eventType, HSI_EVENT_RESPONSE_TYPE responseType,
 			uint eventId, string eventData, ref uint eventCallbackId)
 		{
 			var msgBtn = MessageBoxButtons.OK;
 			switch (responseType)
 			{
-				case Def.HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_OK:
+				case HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_OK:
 					msgBtn = MessageBoxButtons.OK;
 					break;
-				case Def.HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_RETRY:
+				case HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_RETRY:
 					msgBtn = MessageBoxButtons.RetryCancel;
 					break;
-				case Def.HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_CANCEL:
+				case HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_CANCEL:
 					msgBtn = MessageBoxButtons.OKCancel;
 					break;
-				case Def.HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_YES:
+				case HSI_EVENT_RESPONSE_TYPE.HSI_EVENT_RESPONSE_YES:
 					msgBtn = MessageBoxButtons.YesNo;
 					break;
 			}
 
 			switch (eventType)
 			{
-				case Def.HSI_EVENT_TYPE.HSI_EVENT_NONE:
+				case HSI_EVENT_TYPE.HSI_EVENT_NONE:
 					break;
-				case Def.HSI_EVENT_TYPE.HSI_EVENT_ERROR:
+				case HSI_EVENT_TYPE.HSI_EVENT_ERROR:
 					break;
-				case Def.HSI_EVENT_TYPE.HSI_EVENT_FUNCTION:
-					var eventFunctionId = (Def.HSI_EVENT_FUNCTION_ID)eventId;
+				case HSI_EVENT_TYPE.HSI_EVENT_FUNCTION:
+					var eventFunctionId = (HSI_EVENT_FUNCTION_ID)eventId;
 					switch (eventFunctionId)
 					{
-						case Def.HSI_EVENT_FUNCTION_ID.HSI_EVENT_MOTION_DCC_HOME: //准备回家
+						case HSI_EVENT_FUNCTION_ID.HSI_EVENT_MOTION_DCC_HOME: //准备回家
 						{
 							MessageBox.Show(Resources.Interface_Tips_Home_Machine, Resources.Interface_Tips,
 								msgBtn, MessageBoxIcon.Information);
 							break;
 						}
-						case Def.HSI_EVENT_FUNCTION_ID.HSI_EVENT_DEBUG_LOG:
+						case HSI_EVENT_FUNCTION_ID.HSI_EVENT_DEBUG_LOG:
 						{
 							MessageBox.Show(eventData, Resources.Interface_Tips,
 								msgBtn, MessageBoxIcon.Information);
 							break;
 						}
-						case Def.HSI_EVENT_FUNCTION_ID.HSI_EVENT_MOVE_POINT: //定位完成
+						case HSI_EVENT_FUNCTION_ID.HSI_EVENT_MOVE_POINT: //定位完成
 						{
 							MessageBox.Show(Resources.Interface_Tips_Motion_Finished, Resources.Interface_Tips,
 								msgBtn, MessageBoxIcon.Information);
@@ -121,33 +121,34 @@ namespace HSI_SEVENOCEAN_EF1_CsTest.HSI
 		//public static extern Def.HSI_STATUS IsSupported(ref uint types);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_STARTUP", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS Startup(bool bHome);
+		public static extern HSI_STATUS Startup(bool bHome);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_IS_HOMED", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS IsHomed(ref bool bHomed);
+		public static extern HSI_STATUS IsHomed(ref bool bHomed);
 
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_SPEED_XYZ", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS GetSpeedXyz(ref double speed);
+		public static extern HSI_STATUS GetSpeedXyz(ref double speed);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_SET_SPEED_XYZ", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS SetSpeedXyz(double speed);
+		public static extern HSI_STATUS SetSpeedXyz(double speed);
 
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_DCC_SCAN_SET_DATA", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS DCCScanSetData(uint axisTypes, Def.HSI_SCAN_MOTION_TYPE eType, uint lTrigNumber, double[] dTrigDis);
+		public static extern HSI_STATUS DCCScanSetData(uint axisTypes, HSI_SCAN_MOTION_TYPE eType, uint lTrigNumber,
+			double[] dTrigDis);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_DCC_SCAN_START", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS DCCScanStart();
+		public static extern HSI_STATUS DCCScanStart();
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_DCC_SCAN_STOP", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS DCCScanStop();
+		public static extern HSI_STATUS DCCScanStop();
+
 
-	
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_POSITION_XYZ_CACHE", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS GetPositionXyzCache(IntPtr CacheData, int DataCount);
+		public static extern HSI_STATUS GetPositionXyzCache(IntPtr CacheData, ref int DataCount);
+
 
-		
 		//[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_SPEED_R", CharSet = CharSet.Unicode)]
 		//public static extern Def.HSI_STATUS GetSpeedR(ref double speed);
 
@@ -169,18 +170,18 @@ namespace HSI_SEVENOCEAN_EF1_CsTest.HSI
 		//public static extern Def.HSI_STATUS GetRefreshDeadBand(ref double deadband);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_JOG", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS Jog(uint axisTypes, double speed);
+		public static extern HSI_STATUS Jog(uint axisTypes, double speed);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_STOP_JOG", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS StopJog();
+		public static extern HSI_STATUS StopJog();
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_POSITION_XYZ", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS GetPositionXyz(
+		public static extern HSI_STATUS GetPositionXyz(
 			uint axisTypes, ref double positionX, ref double positionY, ref double positionZ, ref double time);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_SET_POSITION_XYZ", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS SetPositionXyz(
-			uint axisTypes, double positionX, double positionY, double positionZ, Def.HSI_MOTION_MOVE_TYPE eType,
+		public static extern HSI_STATUS SetPositionXyz(
+			uint axisTypes, double positionX, double positionY, double positionZ, HSI_MOTION_MOVE_TYPE eType,
 			double dFlyRadius);
 
 		//[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_POSITION_R", CharSet = CharSet.Unicode)]
@@ -191,16 +192,16 @@ namespace HSI_SEVENOCEAN_EF1_CsTest.HSI
 		//  uint axisTypes, double positionR, Def.HSI_MOTION_AXIS_R_MOVE_TYPE directionType, bool bWait);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_ABORT_MOTION", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS AbortMotion();
+		public static extern HSI_STATUS AbortMotion();
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_GET_DIO", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS GetDIO(uint ioChannel, ref uint status);
+		public static extern HSI_STATUS GetDIO(uint ioChannel, ref uint status);
 
 		//[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_SET_DIO", CharSet = CharSet.Unicode)]
 		//public static extern Def.HSI_STATUS SetDIO(uint ioChannel, uint status);
 
 		[DllImport("HSI.dll", EntryPoint = "HSI_MOTION_SHUTDOWN", CharSet = CharSet.Unicode)]
-		public static extern Def.HSI_STATUS Shutdown();
+		public static extern HSI_STATUS Shutdown();
 	}
 
 
@@ -383,18 +384,6 @@ namespace HSI_SEVENOCEAN_EF1_CsTest.HSI
 			HSI_ILLUMINATION_BULB_GRID = 4
 		}
 
-		public enum HSI_SCAN_MOTION_TYPE
-		{
-			HSI_SCAN_MOTION_LINEAR = 1,
-			HSI_SCAN_MOTION_CIRCULAR,
-			HSI_SCAN_MOTION_SPEC_LOCA = 100,//EF1
-			HSI_SCAN_MOTION_EQ_DIS,
-			HSI_SCAN_MOTION_EQ_DIS_II,
-			HSI_SCAN_MOTION_LINEAR_TEST,//测试使用
-			HSI_SCAN_MOTION_EQ_TEST,//测试使用
-			HSI_SCAN_MOTION_MANUAL_TEST //测试使用
-		};
-
 		///////////////////////////////////////////////////////////////////////////////
 		//Illumination API
 		///////////////////////////////////////////////////////////////////////////////
@@ -554,6 +543,18 @@ namespace HSI_SEVENOCEAN_EF1_CsTest.HSI
 			HSI_NOTIFY_PCDMIS_SHUTDOWN = 6
 		}
 
+		public enum HSI_SCAN_MOTION_TYPE
+		{
+			HSI_SCAN_MOTION_LINEAR = 1,
+			HSI_SCAN_MOTION_CIRCULAR,
+			HSI_SCAN_MOTION_SPEC_LOCA = 100, //EF1
+			HSI_SCAN_MOTION_EQ_DIS,
+			HSI_SCAN_MOTION_EQ_DIS_II,
+			HSI_SCAN_MOTION_LINEAR_TEST, //测试使用
+			HSI_SCAN_MOTION_EQ_TEST, //测试使用
+			HSI_SCAN_MOTION_MANUAL_TEST //测试使用
+		}
+
 		///////////////////////////////////////////////////////////////////////////////
 		// Interface API
 		///////////////////////////////////////////////////////////////////////////////
diff --git a/HSI_SEVENOCEAN_EF1_CsTest/Program.cs b/HSI_SEVENOCEAN_EF1_CsTest/Program.cs
index 248621a..ead278e 100644
--- a/HSI_SEVENOCEAN_EF1_CsTest/Program.cs
+++ b/HSI_SEVENOCEAN_EF1_CsTest/Program.cs
@@ -13,7 +13,6 @@ namespace HSI_SEVENOCEAN_EF1_CsTest
 
 		private static void Main(string[] args)
 		{
-			
 			//1 鑾峰彇HSI Dll鐗堟湰
 			uint major = Def.HSI_APIVersionMajor;
 			uint minjor = Def.HSI_APIVersionMinor;
@@ -37,7 +36,6 @@ namespace HSI_SEVENOCEAN_EF1_CsTest
 			rStatus = Interface.SetEventCallback(Interface.HsiCallback);
 			Console.WriteLine("SetEventCallback:{0}", rStatus); //浜嬩欢鍥炶皟鎴愬姛
 
-			
 
 			//if (Motion.IsActive(true))
 			{
@@ -46,23 +44,35 @@ namespace HSI_SEVENOCEAN_EF1_CsTest
 
 				//5 鑾峰彇EF3鍥轰欢鐗堟湰鍙�,寰呮祴璇�
 				//var EF3Version = new byte[20];
-				////IntPtr intPtrEF3Version = IntPtr.Zero;
 				//IntPtr intPtrEF3Version = Marshal.StringToHGlobalAnsi("");
 				//rStatus = Interface.MotionGetFirewareVerion(intPtrEF3Version);
 				//Console.WriteLine("Interface.MotionGetFirewareVerion: {0}", rStatus);
 				//Marshal.Copy(intPtrEF3Version, EF3Version, 0, EF3Version.Length);
 				//Console.WriteLine("EF3 FirewareVerion Version: {0}", Encoding.UTF8.GetString(EF3Version));
 
+				#region 鎵弿鍔熻兘娴嬭瘯
+				//鍚姩鎵弿
 				Motion.DCCScanStart();
+				
+				//鎵弿涓�
 				Thread.Sleep(10000);
 
+				//鎵弿缁撴潫
 				Motion.DCCScanStop();
-				IntPtr dataCache = IntPtr.Zero;
-				int pointCount = 0;
-				Motion.GetPositionXyzCache(dataCache, pointCount);
-				Console.WriteLine("pointCount = " + pointCount);
 
-				
+				//鑾峰彇鎵弿缁撴灉
+				var dataCache = Marshal.AllocHGlobal(1000);
+				var pointCount = 0;
+				var data = new byte[1000];
+				Motion.GetPositionXyzCache(dataCache, ref pointCount);
+				Console.WriteLine("pointCount = " + pointCount);
+				Marshal.Copy(dataCache, data, 0, pointCount);
+
+				//鎵撳嵃鎵弿鐐�
+				for (var i = 0; i < pointCount; i++) Console.WriteLine("Hex:{0} {1:X}", i, data[i]);
+
+				#endregion
+
 				//6 鏄惁鍥炲
 				//var bHomed = true;
 				//rStatus = Motion.IsHomed(ref bHomed);
@@ -80,13 +90,15 @@ namespace HSI_SEVENOCEAN_EF1_CsTest
 							dPos[0] += 10.0; //X杞�
 							dPos[1] += 20.0; //Y杞�
 							dPos[2] += 30.0; //Y杞�
-							rStatus = Motion.SetPositionXyz(Def.HSI_MOTION_AXIS_ALL, dPos[0], dPos[1], dPos[2],Def.HSI_MOTION_MOVE_TYPE.HSI_MOTION_MOVE_WAIT, 0.0);
+							rStatus = Motion.SetPositionXyz(Def.HSI_MOTION_AXIS_ALL, dPos[0], dPos[1], dPos[2],
+								Def.HSI_MOTION_MOVE_TYPE.HSI_MOTION_MOVE_WAIT, 0.0);
 							Console.WriteLine("Motion.SetPositionXyz:{0:f4},{1:f4},{2:f4} {3}", dPos[0], dPos[1],
 								dPos[2],
 								rStatus);
 							break;
 						case ConsoleKey.Enter:
-							rStatus = Motion.GetPositionXyz(Def.HSI_MOTION_AXIS_ALL, ref dPos[0], ref dPos[1], ref dPos[2], ref dTime);
+							rStatus = Motion.GetPositionXyz(Def.HSI_MOTION_AXIS_ALL, ref dPos[0], ref dPos[1],
+								ref dPos[2], ref dTime);
 							Console.WriteLine("Motion.GetPositionXyz:{0}", rStatus);
 							Console.WriteLine("Motion.XYZ:{0:f4},{1:f4},{2:f4}", dPos[0], dPos[1], dPos[2]);
 							break;
@@ -137,19 +149,13 @@ namespace HSI_SEVENOCEAN_EF1_CsTest
 						//鍔犲噺閫�
 						case ConsoleKey.Add:
 							SpeedGear += 0.2;
-							if (SpeedGear > 1.1)
-							{
-								SpeedGear = 1.1;
-							}
+							if (SpeedGear > 1.1) SpeedGear = 1.1;
 							Console.WriteLine("Motion.SpeedGera:{0}", SpeedGear);
 							break;
 
 						case ConsoleKey.Subtract:
 							SpeedGear -= 0.2;
-							if (SpeedGear < 0.1)
-							{
-								SpeedGear = 0.1;
-							}
+							if (SpeedGear < 0.1) SpeedGear = 0.1;
 							Console.WriteLine("Motion.SpeedGera:{0}", SpeedGear);
 							break;
 
@@ -162,7 +168,7 @@ namespace HSI_SEVENOCEAN_EF1_CsTest
 						case ConsoleKey.NumPad9:
 							var dPos1 = new double[3];
 							dPos1[0] = 100;
-							Motion.DCCScanSetData(1, Def.HSI_SCAN_MOTION_TYPE.HSI_SCAN_MOTION_EQ_DIS,7, dPos1);
+							Motion.DCCScanSetData(1, Def.HSI_SCAN_MOTION_TYPE.HSI_SCAN_MOTION_EQ_DIS, 7, dPos1);
 							break;
 						//case ConsoleKey.LeftArrow:
 						//	break;