xhouse/LM-Middleware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

对获取EF3返回锁存点功能，基本实现

Browse Source
This commit is contained in:
zhengxuan.zhang
2022-12-01 16:03:30 +08:00
parent 65cb1d3804
commit d652f671db
11 changed files with 349 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files
HSI_HexagonMI_EF3/HSI.cpp
+1 -1
View File
@@ -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)
HSI_HexagonMI_EF3/HSI.h
+1 -1
View File
@@ -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);
// 第一阶段结束
HSI_HexagonMI_EF3/HSI_Motion.cpp
+106 -52
View File
@@ -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;
HSI_HexagonMI_EF3/HSI_Motion.h
+1 -1
View File
@@ -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); //圆弧插补
HSI_HexagonMI_EF3/SevenOcean/CMMIO_BASE.CPP
+3 -2
View File
@@ -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;
HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.CPP
+147 -38
View File
@@ -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); //读出字符至abIn处
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，同时GetLastError返回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; //异步输入输出结构体
//创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
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函数的最后一个参数设为TRUE
//函数会一直等待，直到读操作完成或由于错误而返回
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); //关闭并释放hEvent的内存
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);
}
HSI_HexagonMI_EF3/SevenOcean/CMMIO_SERIAL.H
+4 -3
View File
@@ -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];
};
HSI_HexagonMI_EF3/logger.cpp
+9 -3
View File
@@ -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[])
HSI_HexagonMI_EF3/version.h
+2 -2
View File
@@ -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 ")
HSI_SEVENOCEAN_EF1_CsTest/HSI/HSI.cs
+50 -49
View File
@@ -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
///////////////////////////////////////////////////////////////////////////////
HSI_SEVENOCEAN_EF1_CsTest/Program.cs
+25 -19
View File
@@ -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;