wxchen/newspark110
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Chenwenxuan
2024-03-06 14:54:30 +08:00
commit edac2715f0
1525 changed files with 809982 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
device/SerialPort/Barometer.cpp Normal file
View File

@@ -0,0 +1,141 @@
#include "Barometer.h"
/* CRC 高位字节值表 */
static unsigned char auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
};
/* CRC低位字节值表*/
static unsigned char auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
0x43, 0x83, 0x41, 0x81, 0x80, 0x40
};
Barometer* Barometer::uniqueInstance = nullptr;
Barometer* Barometer::instance()
{
if (!uniqueInstance) {
uniqueInstance = new Barometer();
}
return uniqueInstance;
}
Barometer::Barometer()
{
}
Barometer::~Barometer()
{
}
unsigned short Barometer::CRC16(unsigned char *puchMsg, unsigned short usDataLen)
{
unsigned char uchCRCHi = 0xFF; /* 高CRC字节初始化 */
unsigned char uchCRCLo = 0xFF; /* 低CRC 字节初始化 */
unsigned uIndex; /* CRC循环中的索引 */
while (usDataLen--) /* 传输消息缓冲区 */
{
uIndex = uchCRCHi ^ *puchMsg++; /* 计算CRC */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
uchCRCLo = auchCRCLo[uIndex];
}
return static_cast<unsigned short>(uchCRCHi << 8 | uchCRCLo);
}
int Barometer::GetHeightValue(int deviceID,unsigned short addr,short *value)
{
unsigned char cmd[50];
unsigned short crcresult;
int ret;
cmd[0] = static_cast<unsigned char>(deviceID);
cmd[1] = 4;
cmd[2] = addr >> 8;
cmd[3] = addr & 0xff;
//cmd[2] = 00;
//cmd[3] = 0x10;
cmd[4] = 0;
cmd[5] = 1;
crcresult = CRC16(cmd, 6);
cmd[6] = (crcresult >> 8) & 0xff;
cmd[7] = crcresult & 0xff;
ret = SendCmd(reinterpret_cast<char*>(cmd), 8, reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
crcresult = CRC16(reinterpret_cast<unsigned char*>(revData), 3 + static_cast<unsigned char>(revData[2]));
cmd[1] = crcresult & 0xff;
cmd[0] = (crcresult >> 8) & 0xff;
//if ((revData[4 + revData[2]] == cmd[1]) && (revData[3 + revData[2]] == cmd[0]))
if ((static_cast<unsigned char>(revData[revDataLen-1]) == cmd[1]) && (static_cast<unsigned char>(revData[revDataLen-2]) == cmd[0]))
{
//*value = (revData[3] << 24) + (revData[4] << 16) + (revData[5] << 8) + revData[6];
// short value1;
// *value = (revData[3] << 8) + revData[4];
// value1 = (revData[3] << 8) + revData[4];
// short value2;
char buftmp[4];
buftmp[0] = revData[4];
buftmp[1] = revData[3];
memcpy_s(value,2,&buftmp[0],2);
//*value = (revData[3] << 8) + (revData[4]);
return 0;
}
return -1;
}
return ret;
}
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);

22
device/SerialPort/Barometer.h Normal file
View File

@@ -0,0 +1,22 @@
#ifndef BAROMETER_H
#define BAROMETER_H
#include "SerialPort.h"
#define BAROMETER Barometer::instance()
class Barometer:public Comm
{
private:
char revData[4096];
int revDataLen;
static Barometer* uniqueInstance;
public:
static Barometer* instance();
Barometer();
~Barometer();
unsigned short CRC16(unsigned char *puchMsg, unsigned short usDataLen);
int GetHeightValue(int deviceID,unsigned short addr,short *value);
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);
};
#endif

488
device/SerialPort/IPG_laser.cpp Normal file
View File

@@ -0,0 +1,488 @@
#include "IPG_laser.h"
#include "deviceinfo.h"
#include "deviceproxy.h"
IPGLaser* IPGLaser::uniqueInstance = nullptr;
IPGLaser* IPGLaser::instance()
{
if (!uniqueInstance) {
uniqueInstance = new IPGLaser();
}
return uniqueInstance;
}
IPGLaser::IPGLaser()
{
}
IPGLaser::~IPGLaser()
{
}
int IPGLaser::LaserClose()
{
/*****写入数据*****/
/*激光器关闭*/
::EnterCriticalSection(&mCsRead);
char WriteBuff1[20] = {0};
WriteBuff1[0] = '$';
WriteBuff1[1] = '3';
WriteBuff1[2] = '1';
WriteBuff1[3] = 0x0D;
WriteBuff1[4] = 0;
int ret = SendCmd(reinterpret_cast<char*>(WriteBuff1), strlen(WriteBuff1) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret != 0)
{
::LeaveCriticalSection(&mCsRead);
return -1;
}
/*激光器使能关闭*/
char WriteBuff2[20] = {0};
WriteBuff2[0] = '$';
WriteBuff2[1] = '4';
WriteBuff2[2] = '3';
WriteBuff2[3] = 0x0D;
WriteBuff2[4] = 0;
ret = SendCmd(reinterpret_cast<char*>(WriteBuff2), strlen(WriteBuff2) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret != 0)
{
::LeaveCriticalSection(&mCsRead);
return -1;
}
::LeaveCriticalSection(&mCsRead);
DEVICE_INFO->printDeviceSystemInfo(QString("激光器关闭"));
return ret;
}
int IPGLaser::LaserOpen()
{
/*****写入数据*****/
/*激光使能打开*/
::EnterCriticalSection(&mCsRead);
char WriteBuff1[20] = {0};
WriteBuff1[0] = '$';
WriteBuff1[1] = '4';
WriteBuff1[2] = '2';
WriteBuff1[3] = 0x0D;
WriteBuff1[4] = 0;
int ret = SendCmd(reinterpret_cast<char*>(WriteBuff1), strlen(WriteBuff1) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret != 0)
{
::LeaveCriticalSection(&mCsRead);
return -1;
}
/*激光器出光*/
char WriteBuff2[20] = {0};
WriteBuff2[0] = '$';
WriteBuff2[1] = '3';
WriteBuff2[2] = '0';
WriteBuff2[3] = 0x0D;
WriteBuff2[4] = 0;
ret = SendCmd(reinterpret_cast<char*>(WriteBuff2), strlen(WriteBuff2) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret != 0)
{
::LeaveCriticalSection(&mCsRead);
return -1;
}
::LeaveCriticalSection(&mCsRead);
DEVICE_INFO->printDeviceSystemInfo(QString("激光器打开"));
return ret;
}
int IPGLaser::SetSingleParam(QString strCmd,QString Strvalue)
{
char WriteBuff[50] = {0};
if ((Strvalue.count() > 20) || (Strvalue.count() <= 0))
{
return -1;
}
if ((strCmd.count() > 20) || (strCmd.count() <= 1))
{
return -1;
}
Sleep(20);
::EnterCriticalSection(&mCsRead);
WriteBuff[0] = '$';
WriteBuff[1] = strCmd.at(0).toLatin1();
WriteBuff[2] = strCmd.at(1).toLatin1();
WriteBuff[3] = ';';
int i;
for (i=0;i<Strvalue.count();i++)
{
//if (Strvalue.at(i).toLatin1() != '\r')
WriteBuff[4 + i] = Strvalue.at(i).toLatin1();
}
WriteBuff[4 + i] = 0x0D;
int ret = SendCmd(reinterpret_cast<char*>(WriteBuff), strlen(WriteBuff) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
// if (revData[0] != '#')
// return -1;
}
::LeaveCriticalSection(&mCsRead);
return ret;
}
int IPGLaser::SwitchMode(bool flag)
{
char WriteBuff[50] = {0};
::EnterCriticalSection(&mCsRead);
if (flag)
{
WriteBuff[0] = '$';
WriteBuff[1] = 32;
WriteBuff[2] = 34;
WriteBuff[3] = ';';
WriteBuff[4] = 31;
WriteBuff[5] = 31;
WriteBuff[6] = 34;
WriteBuff[7] = 30;
WriteBuff[8] = 34;
WriteBuff[9] = 33;
WriteBuff[10] = 36;
WriteBuff[11] = 38;
WriteBuff[12] = 0x0D;
}
else
{
WriteBuff[0] = '$';
WriteBuff[1] = 32;
WriteBuff[2] = 34;
WriteBuff[3] = ';';
WriteBuff[4] = 31;
WriteBuff[5] = 31;
WriteBuff[6] = 34;
WriteBuff[7] = 31;
WriteBuff[8] = 32;
WriteBuff[9] = 36;
WriteBuff[10] = 38;
WriteBuff[11] = 38;
WriteBuff[12] = 0x0D;
}
Sleep(20);
int ret = SendCmd(reinterpret_cast<char*>(WriteBuff), strlen(WriteBuff) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
// if (revData[0] != '#')
// return -1;
}
::LeaveCriticalSection(&mCsRead);
return ret;
}
int IPGLaser::SetParam(int index)
{
int ret =0;
if (index == 1)
{
ret = IPGLASER->SetSingleParam("69",PulseDuration1);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition1);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power1);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump1);
if (ret != 0)
return ret;
}
else if (index == 2)
{
ret = IPGLASER->SetSingleParam("69",PulseDuration2);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition2);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power2);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump2);
if (ret != 0)
return ret;
}
else if (index == 3)
{
if (PulseDuration3 == "")
return -1;
ret = IPGLASER->SetSingleParam("69",PulseDuration3);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition3);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power3);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump3);
if (ret != 0)
return ret;
}
else if (index == 4)
{
if (PulseDuration4 == "")
return -1;
ret = IPGLASER->SetSingleParam("69",PulseDuration4);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition4);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power4);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump4);
if (ret != 0)
return ret;
}
else if (index == 5)
{
if (PulseDuration5 == "")
return -1;
ret = IPGLASER->SetSingleParam("69",PulseDuration5);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition5);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power5);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump5);
if (ret != 0)
return ret;
}
else if (index == 6)
{
if (PulseDuration6 == "")
return -1;
ret = IPGLASER->SetSingleParam("69",PulseDuration6);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition6);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power6);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump6);
if (ret != 0)
return ret;
}
else if (index == 7)
{
if (PulseDuration7 == "")
return -1;
ret = IPGLASER->SetSingleParam("69",PulseDuration7);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition7);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power7);
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump7);
if (ret != 0)
return ret;
}
else //if (index == 8)
{
if (PulseDuration8 == "")
return -1;
ret = IPGLASER->SetSingleParam("69",PulseDuration8);//68
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("28",PulseRepetition8);//29
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("32",Power8);//33
if (ret != 0)
return ret;
ret = IPGLASER->SetSingleParam("64",Prepump8);//65
if (ret != 0)
return ret;
}
return ret;
}
int IPGLaser::GetLaserSts()
{
char WriteBuff[50] = {0};
memset(revData,0,4096);
char tmpbuf[10] = {0};
::EnterCriticalSection(&mCsRead);
WriteBuff[0] = '$';
WriteBuff[1] = '4';
WriteBuff[2] = 0x0D;
int ret = SendCmd(reinterpret_cast<char*>(WriteBuff), strlen(WriteBuff) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
if (revDataLen < 3)
return -1;
memcpy_s(tmpbuf,10,&revData[2],revDataLen-3);
int value = atoi(tmpbuf);
return value;
}
::LeaveCriticalSection(&mCsRead);
return ret;
}
int IPGLaser::getIPGLaerPara(QString DevName)
{
QSettings *settings;//申明一个QSetting类函数
settings = new QSettings ("SerialDevSet.ini", QSettings::IniFormat);//构建函数
QString strKey;
strKey = "/"+DevName+"/com";
com = settings->value(strKey).toString();
if (com.length() > 4)
{
com = "\\\\.\\" + com ;
}
// strKey = "/"+DevName+"/baud";
// nBaudRate = settings->value(strKey).toInt();
// strKey = "/"+DevName+"/nParity";
// nParity = settings->value(strKey).toInt();
// strKey = "/"+DevName+"/nByteSize";
// nByteSize = settings->value(strKey).toInt();
// strKey = "/"+DevName+"/nStopBits";
// nStopBits = settings->value(strKey).toInt();
// if (nStopBits == 1)
// nStopBits = 0;
nBaudRate = 57600;
nParity = 0;
nByteSize = 8;
nStopBits = 0; //停止位1
//int ret = DEV->deCode_file(".\\Data\\laser_para1.txt");
int ret = DEV->deCode_file(".\\Data\\data.txt");
if (ret != 0)
return -1;
// Mode 1
// AM 50
// PP 10
// PG 6500
//QStringList list = DEV->deCodeString.split("\n"); // 按","为分隔符分割字符串，list的值为["apple", "banana", "pear"]
Power1 = getValueFromList(DEV->deCodeString,"PP1");
Power1_set= Power1;
Prepump1 = getValueFromList(DEV->deCodeString,"PG1");
PulseDuration1 = getValueFromList(DEV->deCodeString,"Mode1");
int tmp;
tmp = PulseDuration1.toInt() -1;
PulseDuration1 = QString::number(tmp);
PulseRepetition1 = getValueFromList(DEV->deCodeString,"AM1");
QString str;
str = getValueFromList(DEV->deCodeString,"PW1");
dstPower1 = str.toDouble();
PP_Enable = getValueFromList(DEV->deCodeString,"PP_Enable");
// ret = DEV->deCode_file(".\\Data\\laser_para2.txt");
// if (ret != 0)
// return -1;
Power2 = getValueFromList(DEV->deCodeString,"PP2");
Power2_set= Power2;
Prepump2 = getValueFromList(DEV->deCodeString,"PG2");
PulseDuration2 = getValueFromList(DEV->deCodeString,"Mode2");
PulseRepetition2 = getValueFromList(DEV->deCodeString,"AM2");
tmp = PulseDuration2.toInt() -1;
PulseDuration2 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW2");
dstPower2 = str.toDouble();
Power3 = getValueFromList(DEV->deCodeString,"PP3");
Prepump3 = getValueFromList(DEV->deCodeString,"PG3");
PulseDuration3 = getValueFromList(DEV->deCodeString,"Mode3");
PulseRepetition3 = getValueFromList(DEV->deCodeString,"AM3");
tmp = PulseDuration3.toInt() -1;
PulseDuration3 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW3");
dstPower3 = str.toDouble();
Power4 = getValueFromList(DEV->deCodeString,"PP4");
Prepump4 = getValueFromList(DEV->deCodeString,"PG4");
PulseDuration4 = getValueFromList(DEV->deCodeString,"Mode4");
PulseRepetition4 = getValueFromList(DEV->deCodeString,"AM4");
tmp = PulseDuration4.toInt() -1;
PulseDuration4 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW4");
dstPower4 = str.toDouble();
Power5 = getValueFromList(DEV->deCodeString,"PP5");
Prepump5 = getValueFromList(DEV->deCodeString,"PG5");
PulseDuration5 = getValueFromList(DEV->deCodeString,"Mode5");
PulseRepetition5 = getValueFromList(DEV->deCodeString,"AM5");
tmp = PulseDuration5.toInt() -1;
PulseDuration5 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW5");
dstPower5 = str.toDouble();
Power6 = getValueFromList(DEV->deCodeString,"PP6");
Prepump6 = getValueFromList(DEV->deCodeString,"PG6");
PulseDuration6 = getValueFromList(DEV->deCodeString,"Mode6");
PulseRepetition6 = getValueFromList(DEV->deCodeString,"AM6");
tmp = PulseDuration6.toInt() -1;
PulseDuration6 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW6");
dstPower6 = str.toDouble();
Power7 = getValueFromList(DEV->deCodeString,"PP7");
Prepump7 = getValueFromList(DEV->deCodeString,"PG7");
PulseDuration7 = getValueFromList(DEV->deCodeString,"Mode7");
PulseRepetition7 = getValueFromList(DEV->deCodeString,"AM7");
tmp = PulseDuration7.toInt() -1;
PulseDuration7 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW7");
dstPower7 = str.toDouble();
Power8 = getValueFromList(DEV->deCodeString,"PP8");
Prepump8 = getValueFromList(DEV->deCodeString,"PG8");
PulseDuration8 = getValueFromList(DEV->deCodeString,"Mode8");
PulseRepetition8 = getValueFromList(DEV->deCodeString,"AM8");
tmp = PulseDuration8.toInt() -1;
PulseDuration8 = QString::number(tmp);
str = getValueFromList(DEV->deCodeString,"PW8");
dstPower8 = str.toDouble();
// strKey = "/"+DevName+"/Power1";
// Power1 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/Prepump1";
// Prepump1 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/PulseDuration1";
// PulseDuration1 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/PulseRepetition1";
// PulseRepetition1 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/Power2";
// Power2 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/Prepump2";
// Prepump2 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/PulseDuration2";
// PulseDuration2 = settings->value(strKey).toString();
// strKey = "/"+DevName+"/PulseRepetition2";
// PulseRepetition2 = settings->value(strKey).toString();
return 0;
}
QString IPGLaser::getValueFromList(QString strDecode,QString strName)
{
QStringList list = strDecode.split("\n"); // 按","为分隔符分割字符串，list的值为["apple", "banana", "pear"]
for (int i=0;i<list.count();i++)
{
if (list[i].indexOf(strName) >=0)
{
QStringList list_son = list[i].split("=");
return list_son[1];
}
}
return "";
}

79
device/SerialPort/IPG_laser.h Normal file
View File

@@ -0,0 +1,79 @@
#ifndef IPGLASER_H
#define IPGLASER_H
#include "SerialPort.h"
#define IPGLASER IPGLaser::instance()
class IPGLaser:public Comm
{
private:
char revData[4096];
int revDataLen;
static IPGLaser* uniqueInstance;
public:
QString PP_Enable;
QString Power1;
QString Prepump1;
QString PulseDuration1;
QString PulseRepetition1;
double dstPower1;
QString Power1_set;
QString Power2;
QString Prepump2;
QString PulseDuration2;
QString PulseRepetition2;
double dstPower2;
QString Power2_set;
QString Power3;
QString Prepump3;
QString PulseDuration3;
QString PulseRepetition3;
double dstPower3;
QString Power4;
QString Prepump4;
QString PulseDuration4;
QString PulseRepetition4;
double dstPower4;
QString Power5;
QString Prepump5;
QString PulseDuration5;
QString PulseRepetition5;
double dstPower5;
QString Power6;
QString Prepump6;
QString PulseDuration6;
QString PulseRepetition6;
double dstPower6;
QString Power7;
QString Prepump7;
QString PulseDuration7;
QString PulseRepetition7;
double dstPower7;
QString Power8;
QString Prepump8;
QString PulseDuration8;
QString PulseRepetition8;
double dstPower8;
static IPGLaser* instance();
IPGLaser();
~IPGLaser();
int SetSingleParam(QString strCmd,QString Strvalue);
int SetParam(int index);
int GetLaserSts();
int LaserOpen();
int LaserClose();
int SwitchMode(bool flag);
int getIPGLaerPara(QString DevName);
QString getValueFromList(QString strDecode,QString strName);
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);
};
#endif

62
device/SerialPort/PanasonicHeightFind.cpp Normal file
View File

@@ -0,0 +1,62 @@
#include "PanasonicHeightFind.h"
PanasonicHeightFind* PanasonicHeightFind::uniqueInstance = nullptr;
PanasonicHeightFind* PanasonicHeightFind::instance()
{
if (!uniqueInstance) {
uniqueInstance = new PanasonicHeightFind();
}
return uniqueInstance;
}
PanasonicHeightFind::PanasonicHeightFind()
{
}
PanasonicHeightFind::~PanasonicHeightFind()
{
}
int PanasonicHeightFind::SetLaser(int deviceID,int value)
{
int ret;
int CR = 0xd;
char cmd[50];//%03#WLR+00000**D %03$WLR**D %03!XX**D
sprintf_s(cmd,50,"%%%02dWLR+%05d**%X",deviceID,value,CR);
ret = SendCmd(cmd, static_cast<unsigned short>(strlen(cmd)) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret== 0)
{
if (revData[3] == '$')
ret = 0;
else
ret = -1;
}
return ret;
}
int PanasonicHeightFind::GetHeightValue(int deviceID,double *value)
{
//% 0 3 # R M D * * CR % 0 3 $ R M D - 0 1 2 3 4 5 6 * * CR
int ret;
int CR = 0xd;
char cmd[50];
sprintf_s(cmd,50,"%%%02dRMD**%X",deviceID,CR);
ret = SendCmd(cmd, static_cast<unsigned short>(strlen(cmd)) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret== 0)
{
if (revData[3] == '$')
{
memset(cmd,0,50);
memcpy_s(cmd,50,&revData[7],8);
*value = atof(cmd);
*value = *value / 10000;
ret = 0;
}
else
ret = -1;
}
return ret;
}
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);

22
device/SerialPort/PanasonicHeightFind.h Normal file
View File

@@ -0,0 +1,22 @@
#ifndef PANASONICHEIGHTFIND_H
#define PANASONICHEIGHTFIND_H
#include "SerialPort.h"
#define PANHEIGHTFIND PanasonicHeightFind::instance()
class PanasonicHeightFind:public Comm
{
private:
char revData[4096];
int revDataLen;
static PanasonicHeightFind* uniqueInstance;
public:
static PanasonicHeightFind* instance();
PanasonicHeightFind();
~PanasonicHeightFind();
int SetLaser(int deviceID,int value);
int GetHeightValue(int deviceID,double *value);
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);
};
#endif

73
device/SerialPort/PowerAttenuator.cpp Normal file
View File

@@ -0,0 +1,73 @@
#include "PowerAttenuator.h"
PowerAttenuator* PowerAttenuator::uniqueInstance = nullptr;
PowerAttenuator* PowerAttenuator::instance()
{
if (!uniqueInstance) {
uniqueInstance = new PowerAttenuator();
}
return uniqueInstance;
}
PowerAttenuator::PowerAttenuator()
{
}
PowerAttenuator::~PowerAttenuator()
{
}
int PowerAttenuator::GetSts(int * value)
{
int ret;
char cmd[50] = "o\r";
::EnterCriticalSection(&mCsRead);
memset(revData,0,4096);
ret = SendCmd(cmd, 2,reinterpret_cast<unsigned char*>(revData), &revDataLen);
//revData[revDataLen - 2] = 0;
if (revData[1] == '0')
*value = 0;
else
*value = 1;
::LeaveCriticalSection(&mCsRead);
return ret;
}
int PowerAttenuator::GetPos(int * value)
{
int ret;
::EnterCriticalSection(&mCsRead);
char cmd[50] = "o\r";
memset(revData,0,4096);
ret = SendCmd(cmd, 2,reinterpret_cast<unsigned char*>(revData), &revDataLen);
revData[revDataLen - 2] = 0;
//if (revData[1] == '0')
*value = atoi(&revData[3]);
//else
// *value = 1;
::LeaveCriticalSection(&mCsRead);
return ret;
}
int PowerAttenuator::setPos(int value)
{
int ret;
char cmd[50];
sprintf_s(cmd, "g %d\r", value);
ret = SendCmd(cmd, static_cast<unsigned short>(strlen(cmd)) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
return ret;
}
int PowerAttenuator::setRPos(int value)
{
int ret;
::EnterCriticalSection(&mCsRead);
char cmd[50];
sprintf_s(cmd, "m %d\r", value);
ret = SendCmd(cmd, static_cast<unsigned short>(strlen(cmd)) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
::LeaveCriticalSection(&mCsRead);
return ret;
}
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);

23
device/SerialPort/PowerAttenuator.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef POWERATTENUATOR_H
#define POWERATTENUATOR_H
#include "SerialPort.h"
#define POWERMATT PowerAttenuator::instance()
class PowerAttenuator:public Comm
{
private:
char revData[4096];
int revDataLen;
static PowerAttenuator* uniqueInstance;
public:
static PowerAttenuator* instance();
PowerAttenuator();
~PowerAttenuator();
int GetSts(int * value);
int GetPos(int * value);
int setPos(int value);
int setRPos(int value);
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);
};
#endif

105
device/SerialPort/PowerMeter.cpp Normal file
View File

@@ -0,0 +1,105 @@
#include "PowerMeter.h"
PowerMeter* PowerMeter::uniqueInstanceMach = nullptr;
PowerMeter* PowerMeter::uniqueInstanceLight = nullptr;
PowerMeter* PowerMeter::MachInstance()
{
if (!uniqueInstanceMach) {
uniqueInstanceMach = new PowerMeter();
}
return uniqueInstanceMach;
}
PowerMeter* PowerMeter::LightInstance()
{
if (!uniqueInstanceLight) {
uniqueInstanceLight = new PowerMeter();
}
return uniqueInstanceLight;
}
PowerMeter::PowerMeter()
{
}
PowerMeter::~PowerMeter()
{
}
//int PowerMeter::GetValue(char *data, unsigned short data_len,float * Value)
int PowerMeter::GetValue(float * Value)
{
int ret;
char cmd[50];
char revBuf[50] = {0};
::EnterCriticalSection(&mCsRead);
memset(revData,0,4096);
sprintf_s(cmd, "$POW\r\n");
ret = SendCmd(reinterpret_cast<char*>(cmd), strlen(cmd) ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
//revData[strlen(revData) - 2] = 0;
memcpy_s(revBuf,50,revData,strlen(revData));
for (int i=0;i<(int)strlen(revData);i++)
{
if ((revData[i] == '\r') || (revData[i] == '\n'))
revBuf[i] = 0;
}
*Value = convert(revBuf);
}
::LeaveCriticalSection(&mCsRead);
return ret;
}
float PowerMeter::convert(char *num)
{
//printf("开始转换%s\n", num);
float num1 = 0.0, num2 = 0.0;
int sign = 1;
int exp = 1, cishu = 0;
//表示e后面是正号还是负号，正号为1，负号为-1
//cishu表示是几次饭
char *p = num;
if (*p == '-') {
sign = -1;
p++;
//如果小数是复数
}
while (isdigit(*p)) {
num1 = num1 * 10 + *p - '0';
p++;
//小数点前面的部分
}
//printf("num1:%f\n", num1);
float i = 0.1;
p++;
while (isdigit(*p)) {
num2 += i * (*p - '0');
i *= 0.1;
p++;
}
//小数点后面的部分
//printf("num2:%f\n", num2);
if (*p == 'e' || *p == 'E')
p++;
if (*p == '-') {
exp = -1;
p++;
}
else if (*p == '+')p++;
while (*p != '\0') {
cishu = cishu * 10 + *p - '0';
p++;
}
//printf("cishu:%d\n", cishu);
float result = sign * (num1 + num2);
if (exp == -1) i = 0.1;
else i = 10;
for (int j = 0; j < cishu; j++) result *= i;
return result;
}

24
device/SerialPort/PowerMeter.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef POWERMETER_H
#define POWERMETER_H
#include "SerialPort.h"
#define POWERMETERMACH PowerMeter::MachInstance()
#define POWERMETERLIGHT PowerMeter::LightInstance()
class PowerMeter:public Comm
{
private:
char revData[4096];
int revDataLen;
static PowerMeter* uniqueInstanceMach;
static PowerMeter* uniqueInstanceLight;
public:
static PowerMeter* MachInstance();
static PowerMeter* LightInstance();
PowerMeter();
~PowerMeter();
int GetValue(float * Value);
float convert(char *num);
// int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);
};
#endif

189
device/SerialPort/SerialPort.cpp Normal file
View File

@@ -0,0 +1,189 @@
#include "SerialPort.h"
#include <assert.h>
#define RETURN_ACK 0xac
Comm::Comm()
{
m_hComm = nullptr;
InitializeCriticalSection(&mCsRead);
}
Comm::~Comm()
{
if (m_hComm != nullptr)
{
CloseComm();
}
m_hComm = nullptr;
}
int Comm::getSerialSet(QString DevName)
{
QSettings *settings;//申明一个QSetting类函数
settings = new QSettings ("SerialDevSet.ini", QSettings::IniFormat);//构建函数
QString strKey;
strKey = "/"+DevName+"/com";
com = settings->value(strKey).toString();
if (com.length() > 4)
{
com = "\\\\.\\" + com ;
}
strKey = "/"+DevName+"/baud";
nBaudRate = settings->value(strKey).toInt();
strKey = "/"+DevName+"/nParity";
nParity = settings->value(strKey).toInt();
strKey = "/"+DevName+"/nByteSize";
nByteSize = settings->value(strKey).toInt();
strKey = "/"+DevName+"/nStopBits";
nStopBits = settings->value(strKey).toInt();
if (nStopBits == 1)
nStopBits = 0;
strKey = "/"+DevName+"/pidP";
pidP = settings->value(strKey).toFloat();
strKey = "/"+DevName+"/dstPower";
dstPower = settings->value(strKey).toFloat();
return 0;
}
/*
nParity: 0-4=None,Odd,Even,Mark,Space 校验位
nByteSize: Number of bits/byte, 4-8 数据位
nStopBits: 0,1,2 = 1, 1.5, 2 停止位
*/
bool Comm::OpenComm()
{
if (m_hComm != nullptr)
return true;
DCB dcb; // 串口控制块
COMMTIMEOUTS timeouts = { // 串口超时控制参数
100, // 读字符间隔超时时间: 100 ms
10, // 读操作时每字符的时间: 1 ms (n个字符总共为n ms)
500, // 基本的(额外的)读超时时间: 500 ms
10, // 写操作时每字符的时间: 1 ms (n个字符总共为n ms)
100 }; // 基本的(额外的)写超时时间: 100 ms
m_hComm = CreateFile(reinterpret_cast<const wchar_t *>(com.utf16()), // 串口名称或设备路径
GENERIC_READ | GENERIC_WRITE, // 读写方式
0, // 共享方式：独占
nullptr, // 默认的安全描述符
OPEN_EXISTING, // 创建方式
0, // 不需设置文件属性
nullptr); // 不需参照模板文件
if (m_hComm == INVALID_HANDLE_VALUE)
{
//printf("open error\n");
m_hComm = nullptr;
return FALSE; // 打开串口失败 这里要发送失败消息
}
if (!SetCommTimeouts(m_hComm, &timeouts)) // 设置超时
{
//printf("SetCommTimeouts error\n");
CloseComm();
return false;
}
if (!GetCommState(m_hComm, &dcb)) // 取DCB
{
//printf("GetCommState error\n");
CloseComm();
return false;
}
dcb.BaudRate = static_cast<unsigned long>(nBaudRate);
dcb.ByteSize = static_cast<unsigned char>(nByteSize);
dcb.Parity = static_cast<unsigned char>(nParity);
dcb.StopBits = static_cast<unsigned char>(nStopBits);
if (!SetCommState(m_hComm, &dcb)) // 设置DCB
{
//printf("SetCommState error\n");
CloseComm();
return false;
}
if (!SetupComm(m_hComm, 4096, 2048)) // 设置输入输出缓冲区大小
{
//printf("SetupComm error\n");
CloseComm();
return false;
}
PurgeComm(m_hComm, PURGE_TXABORT | PURGE_RXABORT |
PURGE_TXCLEAR | PURGE_RXCLEAR);
return TRUE;//这里发送成功消息
}
// 关闭串口
bool Comm::CloseComm()
{
bool ret = true;
if (m_hComm != nullptr)
ret = CloseHandle(m_hComm);
m_hComm = nullptr;
return ret;
}
int Comm::SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len)
{
DWORD dwNumWrite; // 串口发出的数据长度
DWORD dwNumRead; // 串口收到的数据长度
unsigned char rev_buf[4096];
DWORD RevDataLen = 0;
DWORD dwError = 0;
COMSTAT ComStat;
int count = 0;
if (data == nullptr)
{
return -1;
}
dwNumRead = 0;
memset(rev_buf, 0, sizeof(rev_buf));
PurgeComm(m_hComm, PURGE_TXABORT | PURGE_RXABORT |
PURGE_TXCLEAR | PURGE_RXCLEAR);
if (!WriteFile(m_hComm, data, static_cast<unsigned long>(data_len), &dwNumWrite, nullptr))
{
return -1;
}
// if (strcmp("mon\r", data) != 0)
// {
// return 0;
// }
while (TRUE)
{
Sleep(100);
ClearCommError(m_hComm, &dwError, &ComStat);
if ((ComStat.cbInQue >= 1))
{
if (!::ReadFile(m_hComm, rev_buf, ComStat.cbInQue, &RevDataLen, nullptr))
{
return -3;
}
else
{
*revData_len = static_cast<int>(RevDataLen);
memcpy_s(revData,RevDataLen,rev_buf,RevDataLen);
break;
}
}
count++;
if (count >= 20)
return -1;
}
return 0;
}

44
device/SerialPort/SerialPort.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include <tchar.h>
#include <math.h>
#include <iostream>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>
#include <QSettings>
#include <QString>
#include<QObject>
#include"base.h"
class Comm{
public:
HANDLE m_hComm;// 串口设备句柄
CRITICAL_SECTION mCsRead;
QString com;
int nBaudRate;
int nParity;
int nByteSize;
int nStopBits;
private:
public:
Comm(void);
~Comm(void);
float pidP;
float dstPower;
public:
//bool OpenComm(wchar_t* pPort);
bool OpenComm();
bool CloseComm();
int SendCmd(char *data, unsigned short data_len ,unsigned char * revData, int * revData_len);
int getSerialSet(QString DevName);
};

246
device/SerialPort/lightsource.cpp Normal file
View File

@@ -0,0 +1,246 @@
#include "lightsource.h"
#include "rs_settings.h"
LightSource* LightSource::UniqueInstance = nullptr;
LightSource* LightSource::Instance()
{
if (!UniqueInstance) {
UniqueInstance = new LightSource();
}
return UniqueInstance;
}
LightSource::~LightSource()
{
}
LightSource::LightSource()
{
}
int LightSource::getCheck(char * buf, int len,char * strAscii)
{
unsigned char data = 0;
data = static_cast<unsigned char>(buf[0]);
for (int i = 1;i < len; i++)
{
data = static_cast<unsigned char>(data ^ buf[i]);
}
getValueAscii(data, strAscii);
return 0;
}
int LightSource::getValueAscii(unsigned char value,char * strAscii)
{
char ascii_buf[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F',};
int high,low;
high = (value & 0xf0) >> 4;
low = value & 0x0f;
strAscii[0] = ascii_buf[high];
strAscii[1] = ascii_buf[low];
return 0;
}
int LightSource::SetBrightness(int chn)
{
int ret;
unsigned char data;
char cmd[50] = {0};
char ascii_buf[2];
if (m_hComm == nullptr)
{
bool ret = OpenComm();
if (!ret)
{
return -1;
}
}
int brightness;
RS_SETTINGS->beginGroup("device/LightSource");
brightness = RS_SETTINGS->readNumEntry("/brightnessFind");
RS_SETTINGS->endGroup();
data = static_cast<unsigned char>(brightness);
getValueAscii(data,ascii_buf);
cmd[0] = '#';
cmd[1] = '3';
cmd[2] = static_cast<char>(0x30 + chn);
cmd[3] = 0x30;
cmd[4] = ascii_buf[0];
cmd[5] = ascii_buf[1];
getCheck(cmd, 6, ascii_buf);
cmd[6] = ascii_buf[0];
cmd[7] = ascii_buf[1];
ret = SendCmd(reinterpret_cast<char*>(cmd), 8 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
if (revData[0] != '#')
return -1;
}
return ret;
}
int LightSource::LightOn(int chn)
{
int ret;
char cmd[50] = {0};
char ascii_buf[10];
char chn_char;
int chnNumber;
if (m_hComm == nullptr)
{
bool ret = OpenComm();
if (!ret)
{
return -1;
}
}
int brightness;
if (chn == 1)
{
RS_SETTINGS->beginGroup("device/LightSource");
brightness = RS_SETTINGS->readNumEntry("/brightnessFind");
RS_SETTINGS->endGroup();
chnNumber = chnFind;
}
else
{
RS_SETTINGS->beginGroup("device/LightSource");
brightness = RS_SETTINGS->readNumEntry("/brightnessGlobal");
RS_SETTINGS->endGroup();
chnNumber = chnGlobal;
}
sprintf_s(ascii_buf,10,"%04d",brightness);
if (chnNumber == 1)
{
chn_char = 'A';
}
else if (chnNumber == 2)
{
chn_char = 'B';
}
else if (chnNumber == 3)
{
chn_char = 'C';
}
else
{
chn_char = 'D';
}
cmd[0] = 'S';
cmd[1] = chn_char;
memcpy_s(&cmd[2],4,ascii_buf,4);
cmd[6] = '#';
ret = SendCmd(reinterpret_cast<char*>(cmd), 7 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
if (revData[0] != chn_char)
{
ret = SendCmd(reinterpret_cast<char*>(cmd), 8 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (revData[0] != chn_char)
return -1;
}
}
else
{
ret = SendCmd(reinterpret_cast<char*>(cmd), 7 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
}
return ret;
}
int LightSource::LightOff(int chn)
{
int ret;
char cmd[50] = {0};
char ascii_buf[10];
char chn_char;
int chnNumber;
if (m_hComm == nullptr)
{
bool ret = OpenComm();
if (!ret)
{
return -1;
}
}
int brightness = 0;
if (chn == 1)
{
chnNumber = chnFind;
}
else
{
chnNumber = chnGlobal;
}
sprintf_s(ascii_buf,10,"%04d",brightness);
if (chnNumber == 1)
{
chn_char = 'A';
}
else if (chnNumber == 2)
{
chn_char = 'B';
}
else if (chnNumber == 3)
{
chn_char = 'C';
}
else
{
chn_char = 'D';
}
cmd[0] = 'S';
cmd[1] = chn_char;
memcpy_s(&cmd[2],4,ascii_buf,4);
cmd[6] = '#';
ret = SendCmd(reinterpret_cast<char*>(cmd), 7 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (ret == 0)
{
if (revData[0] != chn_char)
{
ret = SendCmd(reinterpret_cast<char*>(cmd), 8 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
if (revData[0] != chn_char)
return -1;
}
}
else
{
ret = SendCmd(reinterpret_cast<char*>(cmd), 7 ,reinterpret_cast<unsigned char*>(revData), &revDataLen);
}
return ret;
}
int LightSource::getChnId(QString DevName)
{
QSettings *settings;//申明一个QSetting类函数
settings = new QSettings ("SerialDevSet.ini", QSettings::IniFormat);//构建函数
QString strKey;
strKey = "/"+DevName+"/chnFind";
chnFind = settings->value(strKey).toInt();
strKey = "/"+DevName+"/chnGlobal";
chnGlobal = settings->value(strKey).toInt();
return 0;
}

30
device/SerialPort/lightsource.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef LIGHTSOURCE_H
#define LIGHTSOURCE_H
#include "SerialPort.h"
#define LIGHTSOURCEFIND LightSource::Instance()
class LightSource:public Comm
{
private:
char revData[4096];
int revDataLen;
static LightSource* UniqueInstance;
int chnFind;
int chnGlobal;
public:
LightSource();
~LightSource();
static LightSource* Instance();
int SetBrightness(int chn);
int getValueAscii(unsigned char value,char * strAscii);
int getCheck(char * buf, int len,char * strAscii);
int LightOn(int chn);
int LightOff(int chn);
int getChnId(QString DevName);
};
#endif // LIGHTSOURCE_H

831
device/SerialPort/modbustcp.cpp Normal file
View File

@@ -0,0 +1,831 @@
#include "modbustcp.h"
#include "deviceproxy.h"
ModbusTCP* ModbusTCP::uniqueInstance = nullptr;
ModbusTCP* ModbusTCP::instance()
{
if (!uniqueInstance) {
uniqueInstance = new ModbusTCP();
}
return uniqueInstance;
}
ModbusTCP::ModbusTCP()
{
sockfd = INVALID_SOCKET;
sockfd_fl = INVALID_SOCKET;
sockfd_record = INVALID_SOCKET;
port = 502;
ipAddr = "";
ipAddr_fl = "";
ipAddr_record = "";
ipAddr_electric_resistance = "";
_seq_modbus = 0;
_seq_modbus_fl = 0;
stopFlag = false;
memset(RFID,0,50);
PLCSts[0] = -1;
PLCSts[1] = -1;
TransferPLCCmd.cmdAddr = 0;
TransferPLCCmd.cmdDelay = 0;
TransferPLCCmd.cmdWriteFlag = false;
SeparatePLCCmd.cmdAddr = 0;
SeparatePLCCmd.cmdDelay = 0;
SeparatePLCCmd.cmdWriteFlag = false;
WORD sockVersion = MAKEWORD(2, 2);
WSADATA data;
WSAStartup(sockVersion, &data);
InitializeCriticalSection(&mCsRead);
InitializeCriticalSection(&mCsRead_fl);
}
ModbusTCP::~ModbusTCP(void)
{
if (sockfd != INVALID_SOCKET)
{
CloseConn();
}
if (sockfd_fl != INVALID_SOCKET)
{
CloseConn_fl();
}
if (sockfd_record != INVALID_SOCKET)
{
CloseConn_record();
}
sockfd = INVALID_SOCKET;
sockfd_fl = INVALID_SOCKET;
sockfd_record = INVALID_SOCKET;
WSACleanup();
}
bool ModbusTCP::ConnPLC()
{
struct sockaddr_in server_addr;
char* ip;
QByteArray ba = ipAddr.toLatin1(); // must
ip=ba.data();
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET) {
//printf("Failed to create socket: %s\n", strerror(errno));
return false;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
//inet_pton(AF_INET, "server_ip", &server_addr.sin_addr.s_addr);
server_addr.sin_addr.s_addr = inet_addr(ip);
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
//printf("Failed to connect to server: %s\n", strerror(errno));
closesocket(sockfd);
return false;
}
return true;
}
bool ModbusTCP::ConnPLC_fl()
{
struct sockaddr_in server_addr;
char* ip;
QByteArray ba = ipAddr_fl.toLatin1(); // must
ip=ba.data();
sockfd_fl = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_fl == INVALID_SOCKET) {
//printf("Failed to create socket: %s\n", strerror(errno));
return false;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
//inet_pton(AF_INET, "server_ip", &server_addr.sin_addr.s_addr);
server_addr.sin_addr.s_addr = inet_addr(ip);
if (connect(sockfd_fl, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
//printf("Failed to connect to server: %s\n", strerror(errno));
closesocket(sockfd_fl);
return false;
}
return true;
}
bool ModbusTCP::ConnPLC_force()
{
struct sockaddr_in server_addr;
char* ip;
QByteArray ba = ipAddr_record.toLatin1(); // must
ip=ba.data();
sockfd_record = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_record == INVALID_SOCKET) {
//printf("Failed to create socket: %s\n", strerror(errno));
return false;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(6000);
//inet_pton(AF_INET, "server_ip", &server_addr.sin_addr.s_addr);
server_addr.sin_addr.s_addr = inet_addr(ip);
if (connect(sockfd_record, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
//printf("Failed to connect to server: %s\n", strerror(errno));
closesocket(sockfd_record);
return false;
}
return true;
}
bool ModbusTCP::ConnPLC_electric_resistance()
{
struct sockaddr_in server_addr;
char* ip;
//ipAddr_electric_resistance = "192.168.30.6";
QByteArray ba = ipAddr_electric_resistance.toLatin1(); // must AF_LOCAL
ip=ba.data();
sockfd_electric_resistance = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd_electric_resistance == INVALID_SOCKET) {
//printf("Failed to create socket: %s\n", strerror(errno));
return false;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(6677);
//inet_pton(AF_INET, "server_ip", &server_addr.sin_addr.s_addr);
server_addr.sin_addr.s_addr = inet_addr(ip);
if (connect(sockfd_electric_resistance, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
//printf("Failed to connect to server: %s\n", strerror(errno));
closesocket(sockfd_electric_resistance);
return false;
}
return true;
}
bool ModbusTCP::CloseConn()
{
bool ret = true;
if (sockfd != INVALID_SOCKET)
closesocket(sockfd);
sockfd = INVALID_SOCKET;
return ret;
}
bool ModbusTCP::CloseConn_fl()
{
bool ret = true;
if (sockfd_fl != INVALID_SOCKET)
closesocket(sockfd_fl);
sockfd_fl = INVALID_SOCKET;
return ret;
}
bool ModbusTCP::CloseConn_record()
{
bool ret = true;
if (sockfd_record != INVALID_SOCKET)
closesocket(sockfd_record);
sockfd_record = INVALID_SOCKET;
return ret;
}
bool ModbusTCP::CloseConn_electric_resistance()
{
bool ret = true;
if (sockfd_electric_resistance != INVALID_SOCKET)
closesocket(sockfd_electric_resistance);
sockfd_electric_resistance = INVALID_SOCKET;
return ret;
}
int ModbusTCP::SendCmdRead(unsigned int sockfd,char *data, unsigned short data_len)
{
//可能存在问题。
//1、接收按照数据长度接收，然后校验接收长度是否正确
//2、返回的数据，是否正确，是否要进行判断？
char rev_buf[4096];
int RevDataLen = 0;
//发送modbus请求
if (send(sockfd, data, data_len, 0) == -1) {
closesocket(sockfd);
return -1;
}
//printf("Sent request successfully.\n");
//接收modbus请求
RevDataLen = recv(sockfd, rev_buf, 4096, 0);
if (RevDataLen == -1) {
//printf("Failed to receive response: %s\n", strerror(errno));
closesocket(sockfd);
return -1;
}
int ret = DataDecode(rev_buf, RevDataLen);
return ret;
}
int ModbusTCP::SendCmdWrite(unsigned int sockfd,char *data, unsigned short data_len)
{
//可能存在问题。
//1、接收按照数据长度接收，然后校验接收长度是否正确
//2、返回的数据，是否正确，是否要进行判断？
char rev_buf[4096];
int RevDataLen = 0;
//发送modbus请求
if (send(sockfd, data, data_len, 0) == -1) {
closesocket(sockfd);
return -1;
}
//printf("Sent request successfully.\n");
//接收modbus请求
RevDataLen = recv(sockfd, rev_buf, 4096, 0);
if (RevDataLen == -1) {
//printf("Failed to receive response: %s\n", strerror(errno));
closesocket(sockfd);
return -1;
}
//int ret = Com_decode(rev_buf, RevDataLen);
return 0;
}
int ModbusTCP::SendCmdRead_fl(unsigned int sockfd,char *data, unsigned short data_len)
{
//可能存在问题。
//1、接收按照数据长度接收，然后校验接收长度是否正确
//2、返回的数据，是否正确，是否要进行判断？
char rev_buf[4096];
int RevDataLen = 0;
//发送modbus请求
if (send(sockfd, data, data_len, 0) == -1) {
closesocket(sockfd);
return -1;
}
//printf("Sent request successfully.\n");
//接收modbus请求
RevDataLen = recv(sockfd, rev_buf, 4096, 0);
if (RevDataLen == -1) {
//printf("Failed to receive response: %s\n", strerror(errno));
closesocket(sockfd);
return -1;
}
int ret = DataDecode(rev_buf, RevDataLen);
return ret;
}
int ModbusTCP::SendCmdWrite_fl(unsigned int sockfd,char *data, unsigned short data_len)
{
//可能存在问题。
//1、接收按照数据长度接收，然后校验接收长度是否正确
//2、返回的数据，是否正确，是否要进行判断？
char rev_buf[4096];
int RevDataLen = 0;
//发送modbus请求
if (send(sockfd, data, data_len, 0) == -1) {
closesocket(sockfd);
return -1;
}
//printf("Sent request successfully.\n");
//接收modbus请求
RevDataLen = recv(sockfd, rev_buf, 4096, 0);
if (RevDataLen == -1) {
//printf("Failed to receive response: %s\n", strerror(errno));
closesocket(sockfd);
return -1;
}
//int ret = Com_decode(rev_buf, RevDataLen);
return 0;
}
int ModbusTCP::DataDecode(char *data, int len)
{
if ((len >= 10) && (len <= 11))
{
return data[len-1];
}
else if (len > 11)
{
memset(MODBUSTCP->RFID,0,50);
memcpy(RFID,&data[9],len-9);
}
return 0;
}
int ModbusTCP::ModbusWrite(unsigned char cmd,unsigned short addr, unsigned short data)
{
int ret;
unsigned char sendBuf[50];//发送缓存
unsigned short temps = _seq_modbus++;//类似于TCP的seq序列号，让其自增即可
unsigned char* temp = reinterpret_cast<unsigned char*>(&temps);
//协议头
sendBuf[0] = *(temp + 1);//前两位为事务处理标识，2个字节的序列号
sendBuf[1] = *(temp);
sendBuf[2] = 0;//协议标识，两个字节，0000即为Modbus TCP协议
sendBuf[3] = 0;
sendBuf[4] = 0;//长度字段（前半部分字节）
sendBuf[5] = 6;//随后字节数
sendBuf[6] = 1;//单元标志，定义连接目的节点的其他设备（这个设备是1号，所以是0x01）
//以上是Modbus协议头部分
//协议体
sendBuf[7] = cmd;//Modbus功能码 ，这里是 写多个保持寄存器 操作
temps = addr;
sendBuf[8] = *(temp + 1); //写寄存器起始地址高字节
sendBuf[9] = *(temp); //写寄存器起始地址低字节（所以这里是往0x0100地址写寄存器）
//sendBuf[10] = 0x00; //写寄存器数量高字节
//sendBuf[11] = 0x01; //写寄存器数量低字节
//sendBuf[12] = 0x01; //数据长度
//写1个值到报文中
temps = data;
//sendBuf[10] = data;
sendBuf[10] = *(temp + 1);
sendBuf[11] = *(temp);
bool ret_conn = true;
::EnterCriticalSection(&mCsRead);
ret_conn = ConnPLC();
if (ret_conn)
ret = SendCmdWrite(sockfd,reinterpret_cast<char*>(sendBuf), 12);
else
{
CloseConn();
::LeaveCriticalSection(&mCsRead);
return -1;
}
CloseConn();
::LeaveCriticalSection(&mCsRead);
return ret;
}
int ModbusTCP::ModbusWrite_fl(unsigned char cmd,unsigned short addr, unsigned short data)
{
int ret;
unsigned char sendBuf[50];//发送缓存
unsigned short temps = _seq_modbus_fl++;//类似于TCP的seq序列号，让其自增即可
unsigned char* temp = reinterpret_cast<unsigned char*>(&temps);
//协议头
sendBuf[0] = *(temp + 1);//前两位为事务处理标识，2个字节的序列号
sendBuf[1] = *(temp);
sendBuf[2] = 0;//协议标识，两个字节，0000即为Modbus TCP协议
sendBuf[3] = 0;
sendBuf[4] = 0;//长度字段（前半部分字节）
sendBuf[5] = 6;//随后字节数
sendBuf[6] = 1;//单元标志，定义连接目的节点的其他设备（这个设备是1号，所以是0x01）
//以上是Modbus协议头部分
//协议体
sendBuf[7] = cmd;//Modbus功能码 ，这里是 写多个保持寄存器 操作
temps = addr;
sendBuf[8] = *(temp + 1); //写寄存器起始地址高字节
sendBuf[9] = *(temp); //写寄存器起始地址低字节（所以这里是往0x0100地址写寄存器）
//sendBuf[10] = 0x00; //写寄存器数量高字节
//sendBuf[11] = 0x01; //写寄存器数量低字节
//sendBuf[12] = 0x01; //数据长度
//写1个值到报文中
temps = data;
//sendBuf[10] = data;
sendBuf[10] = *(temp + 1);
sendBuf[11] = *(temp);
bool ret_conn = true;
::EnterCriticalSection(&mCsRead_fl);
ret_conn = ConnPLC_fl();
if (ret_conn)
ret = SendCmdWrite_fl(sockfd_fl,reinterpret_cast<char*>(sendBuf), 12);
else
{
CloseConn_fl();
::LeaveCriticalSection(&mCsRead_fl);
return -1;
}
CloseConn_fl();
::LeaveCriticalSection(&mCsRead_fl);
return ret;
}
int ModbusTCP::ModbusWrite_force(char * data, int len)
{
bool ret_conn = true;
//::EnterCriticalSection(&mCsRead_fl);
ret_conn = ConnPLC_force();
if (ret_conn)
{
if (send(sockfd_record, data, len, 0) == -1)
{
CloseConn_record();
qDebug()<< "result1: "<<data;
//::LeaveCriticalSection(&mCsRead_fl);
return -1;
}
else
{
qDebug()<< "result: "<<data;
CloseConn_record();
//::LeaveCriticalSection(&mCsRead_fl);
return 0;
}
}
else
{
CloseConn_record();
qDebug()<< "result2: "<<data;
//::LeaveCriticalSection(&mCsRead_fl);
return -1;
}
}
int ModbusTCP::ModbusWrite_electric_resistance(char * data, int len, char * rev_buf)
{
int RevDataLen = 0;
bool ret_conn = true;
// if (data[0] == 'G')
// {
// memset(array_pos,0,sizeof(array_pos));
// }
// ret_conn = ConnPLC_electric_resistance();
// if (ret_conn)
{
if (send(sockfd_electric_resistance, data, len, 0) == -1)
{
CloseConn_electric_resistance();
return -1;
}
else
{
if(strcmp(data,"***") == 0)
return 0;
RevDataLen = recv(sockfd_electric_resistance, rev_buf, 4096, 0);
if (RevDataLen == -1) {
closesocket(sockfd_electric_resistance);
return -1;
}
return RevDataLen;
}
}
// else
// {
// CloseConn_electric_resistance();
// qDebug()<< "result2: "<<data;
// //::LeaveCriticalSection(&mCsRead_fl);
// return -1;
// }
}
int ModbusTCP::ModbusRead(unsigned short addr,int dataLen)
{
int ret;
unsigned char sendBuf[50];//发送缓存
unsigned short temps = _seq_modbus++;//类似于TCP的seq序列号，让其自增即可
unsigned char* temp = reinterpret_cast<unsigned char*>(&temps);
//协议头
sendBuf[0] = *(temp + 1);//前两位为事务处理标识，2个字节的序列号
sendBuf[1] = *(temp);
sendBuf[2] = 0;//协议标识，两个字节，0000即为Modbus TCP协议
sendBuf[3] = 0;
sendBuf[4] = 0;//长度字段（前半部分字节）
sendBuf[5] = 6;//随后字节数
sendBuf[6] = 0x01;//单元标志，定义连接目的节点的其他设备（这个设备是1号，所以是0x01）
//以上是Modbus协议头部分
//协议体
sendBuf[7] = 0x03;//Modbus功能码 ，这里是读
temps = addr;
sendBuf[8] = *(temp + 1); //写寄存器起始地址高字节
sendBuf[9] = *(temp); //写寄存器起始地址低字节（所以这里是往0x0100地址写寄存器）
sendBuf[10] = 0x00; //长度
sendBuf[11] = dataLen; //写寄存器数量低字节
bool ret_conn = true;
::EnterCriticalSection(&mCsRead);
ret_conn = ConnPLC();
if (ret_conn)
ret = SendCmdRead(sockfd,reinterpret_cast<char*>(sendBuf), 12);
else
{
CloseConn();
::LeaveCriticalSection(&mCsRead);
return -1;
}
CloseConn();
::LeaveCriticalSection(&mCsRead);
return ret;
}
int ModbusTCP::ModbusRead_fl(unsigned short addr,int dataLen)
{
int ret;
unsigned char sendBuf[50];//发送缓存
unsigned short temps = _seq_modbus_fl++;//类似于TCP的seq序列号，让其自增即可
unsigned char* temp = reinterpret_cast<unsigned char*>(&temps);
//协议头
sendBuf[0] = *(temp + 1);//前两位为事务处理标识，2个字节的序列号
sendBuf[1] = *(temp);
sendBuf[2] = 0;//协议标识，两个字节，0000即为Modbus TCP协议
sendBuf[3] = 0;
sendBuf[4] = 0;//长度字段（前半部分字节）
sendBuf[5] = 6;//随后字节数
sendBuf[6] = 0x01;//单元标志，定义连接目的节点的其他设备（这个设备是1号，所以是0x01）
//以上是Modbus协议头部分
//协议体
sendBuf[7] = 0x03;//Modbus功能码 ，这里是读
temps = addr;
sendBuf[8] = *(temp + 1); //写寄存器起始地址高字节
sendBuf[9] = *(temp); //写寄存器起始地址低字节（所以这里是往0x0100地址写寄存器）
sendBuf[10] = 0x00; //长度
sendBuf[11] = dataLen; //写寄存器数量低字节
bool ret_conn = true;
::EnterCriticalSection(&mCsRead_fl);
ret_conn = ConnPLC_fl();
if (ret_conn)
ret = SendCmdRead_fl(sockfd_fl,reinterpret_cast<char*>(sendBuf), 12);
else
{
CloseConn_fl();
::LeaveCriticalSection(&mCsRead_fl);
return -1;
}
CloseConn_fl();
::LeaveCriticalSection(&mCsRead_fl);
return ret;
}
int ModbusTCP::TransferPLCRun(unsigned short addr,int delay)
{
if ((addr == 0) || (delay <= 0))
return -1;
if (TransferPLCCmd.cmdAddr != 0)
{
return -1;
}
else
{
TransferPLCCmd.cmdAddr = addr;
TransferPLCCmd.cmdDelay = delay;
TransferPLCCmd.cmdWriteFlag = false;
return 0;
}
}
int ModbusTCP::SeparatePLCRun(unsigned short addr,int delay)
{
if ((addr == 0) || (delay <= 0))
return -1;
if (SeparatePLCCmd.cmdAddr != 0)
{
return -1;
}
else
{
SeparatePLCCmd.cmdAddr = addr;
SeparatePLCCmd.cmdDelay = delay;
SeparatePLCCmd.cmdWriteFlag = false;
return 0;
}
}
int ModbusTCP::getModbusPara(QString DevName)
{
QSettings *settings;//申明一个QSetting类函数
settings = new QSettings ("SerialDevSet.ini", QSettings::IniFormat);//构建函数
QString strKey;
strKey = "/"+DevName+"/ipAddr";
ipAddr = settings->value(strKey).toString();
strKey = "/"+DevName+"/ipAddr_fl";
ipAddr_fl = settings->value(strKey).toString();
strKey = "/"+DevName+"/ipAddr_record";
ipAddr_record = settings->value(strKey).toString();
strKey = "/"+DevName+"/ipAddr_electric_resistance";
ipAddr_electric_resistance = settings->value(strKey).toString();
strKey = "/"+DevName+"/shangReadAddr";
shangReadAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/shangWriteAddr";
shangWriteAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/shangReadRFIDAddr";
shangReadRFIDAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/shangReadVacuumAddr";
shangReadVacuumAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/shangWriteHeartbeatAddr";
shangWriteHeartbeatAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/shangWriteVacuumAddr";
shangWriteVacuumAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/xiaReadAddr";
xiaReadAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/xiaWriteAddr";
xiaWriteAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/xiaReadStsAddr";
xiaReadStsAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/ReadTransferPLCStsAddr";
ReadTransferPLCStsAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/xiaWriteVacuumAddr";
xiaWriteVacuumAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/InitAddr";
InitAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/RunAddr";
RunAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/StopAddr";
StopAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
strKey = "/"+DevName+"/ClearAlarmAddr";
ClearAlarmAddr = static_cast<unsigned short>(settings->value(strKey).toInt());
return 0;
}
int ModbusTCP::Heartbeat(void)
{
int internal_read = 0;
int internal_write = 0;
int internal_sts = 0;
int ret_modbus;
int count = 0;
bool readFlag = false;
int fail_count[2] = {0};
int internal_TransferPLCCmd_sts = 0;
while (1)
{
internal_read++;
internal_write++;
internal_sts++;
if ((internal_read >= 240) && (readFlag))
{
ret_modbus = MODBUSTCP->ModbusRead(MODBUSTCP->shangWriteHeartbeatAddr, 1);
if (ret_modbus != 0)
{
count++;
}
else
{
count = 0;
MODBUSTCP->connFlag = true;
}
if (count >= 3)
{
MODBUSTCP->connFlag = false;
}
readFlag = false;
internal_write = 0;
}
if ((internal_write >= 20) && (!readFlag))
{
ret_modbus = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteHeartbeatAddr, 1);
internal_read = 0;
readFlag = true;
}
if (internal_sts >= 20)
{
ret_modbus = MODBUSTCP->ModbusRead(MODBUSTCP->xiaReadStsAddr, 1);
if (ret_modbus == -1)
{
fail_count[0]++;
if (fail_count[0] >= 3)
{
PLCSts[0] = -1;
}
}
else
{
fail_count[0] = 0;
PLCSts[0] = ret_modbus;
}
ret_modbus = MODBUSTCP->ModbusRead(MODBUSTCP->ReadTransferPLCStsAddr, 1);
TransferPLCSts = ret_modbus;
emit DEV->TransferPLCSGL(PLCSts[0]);
internal_sts = 0;
}
if (TransferPLCCmd.cmdAddr != 0)
{
if (TransferPLCCmd.cmdWriteFlag == false)
{
//发送写命令
ret_modbus = MODBUSTCP->ModbusWrite(0x05,TransferPLCCmd.cmdAddr, 0xff00);
TransferPLCCmd.cmdWriteFlag = true;
}
internal_TransferPLCCmd_sts++;
if ((internal_TransferPLCCmd_sts * 5) >= TransferPLCCmd.cmdDelay)
{
//发送清除命令
ret_modbus = MODBUSTCP->ModbusWrite(0x05,TransferPLCCmd.cmdAddr, 0);
TransferPLCCmd.cmdWriteFlag = false;
TransferPLCCmd.cmdAddr = 0;
TransferPLCCmd.cmdDelay = 0;
internal_TransferPLCCmd_sts = 0;
}
}
Sleep(5);
}
}
int ModbusTCP::Heartbeat_fl(void)
{
int internal_sts = 0;
int ret_modbus;
int fail_count[2] = {0};
int internal_SeparatePLCCmd_sts = 0;
while (1)
{
internal_sts++;
if (internal_sts >= 20)
{
ret_modbus = MODBUSTCP->ModbusRead_fl(MODBUSTCP->xiaReadStsAddr, 1);
if (ret_modbus == -1)
{
fail_count[1]++;
if (fail_count[1] >= 3)
{
PLCSts[1] = -1;
}
}
else
{
fail_count[1] = 0;
PLCSts[1] = ret_modbus;
}
emit DEV->SeparatePLCSGL(PLCSts[1]);
internal_sts = 0;
}
if (SeparatePLCCmd.cmdAddr != 0)
{
if (SeparatePLCCmd.cmdWriteFlag == false)
{
ret_modbus = MODBUSTCP->ModbusWrite_fl(0x05,SeparatePLCCmd.cmdAddr, 0xff00);
SeparatePLCCmd.cmdWriteFlag = true;
}
internal_SeparatePLCCmd_sts++;
if ((internal_SeparatePLCCmd_sts * 5) >= SeparatePLCCmd.cmdDelay)
{
//发送清除命令
ret_modbus = MODBUSTCP->ModbusWrite_fl(0x05,SeparatePLCCmd.cmdAddr, 0);
SeparatePLCCmd.cmdWriteFlag = false;
SeparatePLCCmd.cmdAddr = 0;
SeparatePLCCmd.cmdDelay = 0;
internal_SeparatePLCCmd_sts = 0;
}
}
Sleep(5);
}
}
/*
* 1、正常自动加工时，在工作线程跑上下料
* 2、在测试界面，使用线程（CreateThread），有运行标记
*/

111
device/SerialPort/modbustcp.h Normal file
View File

@@ -0,0 +1,111 @@
#ifndef MODBUSTCP_H
#define MODBUSTCP_H
#include <tchar.h>
#include <math.h>
#include <iostream>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>
#include <QSettings>
#include <QString>
#include<QObject>
#include"base.h"
struct PLC_COMMAND{
unsigned short cmdAddr;
bool cmdWriteFlag;
int cmdDelay;
};
#define MODBUSTCP ModbusTCP::instance()
class ModbusTCP
{
static ModbusTCP* uniqueInstance;
public:
static ModbusTCP* instance();
QString ipAddr_electric_resistance;
unsigned int sockfd;
unsigned int sockfd_fl;
unsigned int sockfd_record;
unsigned int sockfd_electric_resistance;
char RFID[50];
unsigned short height;
unsigned short shangReadAddr;
unsigned short shangWriteAddr;
unsigned short shangReadRFIDAddr;
unsigned short xiaWriteHeightAddr;
unsigned short shangWriteHeartbeatAddr;
unsigned short xiaReadAddr;
unsigned short xiaWriteAddr;
unsigned short xiaReadStsAddr;
unsigned short ReadTransferPLCStsAddr;
unsigned short InitAddr;
unsigned short RunAddr;
unsigned short StopAddr;
unsigned short ClearAlarmAddr;
bool connFlag{true};
int PLCSts[2];
int TransferPLCSts;
PLC_COMMAND TransferPLCCmd;
PLC_COMMAND SeparatePLCCmd;
CRITICAL_SECTION mCsRead;
CRITICAL_SECTION mCsRead_fl;
float array_pos[1000][2];
private:
QString ipAddr;
QString ipAddr_fl;
QString ipAddr_record;
unsigned short port;
unsigned short shangReadVacuumAddr;
unsigned short shangWriteVacuumAddr;
unsigned short xiaWriteVacuumAddr;
unsigned short _seq_modbus;
unsigned short _seq_modbus_fl;
public:
ModbusTCP();
~ModbusTCP(void);
public:
bool ConnPLC();
bool ConnPLC_fl();
bool ConnPLC_force();
bool ConnPLC_electric_resistance();
bool CloseConn();
bool CloseConn_fl();
bool CloseConn_record();
bool CloseConn_electric_resistance();
int SendCmdRead(unsigned int sockfd,char *data, unsigned short data_len);
int SendCmdWrite(unsigned int sockfd,char *data, unsigned short data_len);
int SendCmdRead_fl(unsigned int sockfd,char *data, unsigned short data_len);
int SendCmdWrite_fl(unsigned int sockfd,char *data, unsigned short data_len);
int DataDecode(char *data, int len);
int ModbusWrite(unsigned char cmd,unsigned short addr, unsigned short data);
int ModbusWrite_fl(unsigned char cmd,unsigned short addr, unsigned short data);
int ModbusWrite_force(char * data, int len);
int ModbusWrite_electric_resistance(char * data, int len, char * rev_buf);
int ModbusRead(unsigned short addr,int dataLen);
int ModbusRead_fl(unsigned short addr,int dataLen);
int getModbusPara(QString DevName);
int Heartbeat(void);
int Heartbeat_fl(void);
int TransferPLCRun(unsigned short addr,int delay);
int SeparatePLCRun(unsigned short addr,int delay);
bool stopFlag;
};
#endif // MODBUSTCP_H