//---------------------------------------------------------------------
|
#include <stdio.h> /*标准输入输出定义*/
|
#include <stdlib.h> /*标准函数库定义*/
|
#include <string.h>
|
#include <unistd.h> /*Unix 标准函数定义*/
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
//---------------------------------------------------------------------
|
#include <termios.h> /*PPSIX 终端控制定义*/
|
#include <fcntl.h> /*文件控制定义*/
|
#include <unistd.h> /*Unix 标准函数定义*/
|
#include <linux/serial.h>
|
#include <sys/ioctl.h>
|
|
#include "uart_driver.h"
|
|
Uart_Driver::Uart_Driver(QObject *parent) :
|
QThread(parent)
|
{
|
|
}
|
|
//---------------------------------------------------------------------
|
/**
|
*@brief 设置串口通信速率
|
*@param fd 类型 int 打开串口的文件句柄
|
*@param speed 类型 int 串口速度
|
*@return void
|
*/
|
//---------------------------------------------------------------------
|
//---------------------------------------------------------------------
|
int speed_arr[] = { B115200, B57600, B38400, B19200, B9600};
|
int name_arr[] = { 115200, 57600, 38400, 19200, 9600};
|
void Uart_Driver::set_speed(int fd, int speed)
|
{
|
int status;
|
struct termios Opt;
|
tcgetattr(fd, &Opt);
|
for ( unsigned int i= 0; i < sizeof(speed_arr) / sizeof(int); i++)
|
{
|
if(speed == name_arr[i])
|
{
|
tcflush(fd, TCIOFLUSH);
|
cfsetispeed(&Opt, speed_arr[i]);
|
cfsetospeed(&Opt, speed_arr[i]);
|
status = tcsetattr(fd, TCSANOW, &Opt);
|
if(status != 0)
|
{
|
perror("tcsetattr fd1");
|
return;
|
}
|
tcflush(fd,TCIOFLUSH);
|
}
|
}
|
}
|
//---------------------------------------------------------------------
|
/**
|
*@brief 设置串口数据位，停止位和效验位
|
*@param fd 类型 int 打开的串口文件句柄
|
*@param databits 类型 int 数据位 取值 为 7 或者8
|
*@param stopbits 类型 int 停止位 取值为 1 或者2
|
*@param parity 类型 int 效验类型 取值为N,E,O,,S
|
*/
|
//---------------------------------------------------------------------
|
int Uart_Driver::set_Parity(int fd,int databits,int stopbits,int parity)
|
{
|
struct termios options;
|
if(tcgetattr(fd, &options) != 0)
|
{
|
perror("SetupSerial 1");
|
return(-1);
|
}
|
|
//--------------- 二进制传输模式 -------------------------
|
options.c_iflag = 0;
|
options.c_oflag = 0;
|
//------------------------------------------------------
|
|
options.c_cflag &= ~CSIZE;
|
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);/*Input*/
|
options.c_oflag &= ~OPOST;/*Output*/
|
switch (databits) /*设置数据位数*/
|
{
|
case 7:
|
options.c_cflag |= CS7;
|
break;
|
case 8:
|
options.c_cflag |= CS8;
|
break;
|
default:
|
fprintf(stderr,"Unsupported data size\n");
|
return (-1);
|
}
|
switch (parity)
|
{
|
case 'n':
|
case 'N':
|
options.c_cflag &= ~PARENB; /* Clear parity enable */
|
options.c_iflag &= ~INPCK; /* Enable parity checking */
|
break;
|
case 'o':
|
case 'O':
|
options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/
|
options.c_iflag |= INPCK; /* Disnable parity checking */
|
break;
|
case 'e':
|
case 'E':
|
options.c_cflag |= PARENB; /* Enable parity */
|
options.c_cflag &= ~PARODD; /* 转换为偶效验*/
|
options.c_iflag |= INPCK; /* Disnable parity checking */
|
break;
|
case 'S':
|
case 's': /*as no parity*/
|
options.c_cflag &= ~PARENB;
|
options.c_cflag &= ~CSTOPB;
|
break;
|
default:
|
fprintf(stderr,"Unsupported parity\n");
|
return (-1);
|
}
|
/* 设置停止位*/
|
switch (stopbits)
|
{
|
case 1:
|
options.c_cflag &= ~CSTOPB;
|
break;
|
case 2:
|
options.c_cflag |= CSTOPB;
|
break;
|
default:
|
fprintf(stderr,"Unsupported stop bits\n");
|
return (-1);
|
}
|
/* Set input parity option */
|
if (parity != 'n')
|
options.c_iflag |= INPCK;
|
|
tcflush(fd, TCIFLUSH);
|
options.c_cc[VTIME] = 0; /* 0.1S */
|
options.c_cc[VMIN] = 0;
|
/* Update the options and do it NOW */
|
if (tcsetattr(fd,TCSANOW,&options) != 0)
|
{
|
perror("SetupSerial 3");
|
return (-1);
|
}
|
return (0);
|
}
|
//---------------------------------------------------------------------
|
int Uart_Driver::OpenDev(const char *Dev)
|
{
|
FD = open(Dev, O_RDWR|O_NOCTTY|O_NDELAY);
|
|
return FD;
|
}
|
//---------------------------------------------------------------------
|
void Uart_Driver::SetDevAttr(int bitrate, char bitlen,
|
char stopbitlen, char checktype)
|
{
|
if(FD < 0)
|
return;
|
|
set_speed(FD, bitrate);
|
|
if(set_Parity(FD, bitlen, stopbitlen, checktype) < 0)
|
{
|
qDebug("Set Parity Error\n");
|
}
|
|
|
if(fcntl(FD, F_SETFL, FNDELAY) < 0)//非阻塞，覆盖前面open的属性
|
{
|
qDebug("fcntl failed\n");
|
}
|
}
|
//---------------------------------------------------------------------
|
int Uart_Driver::WriteDev(void *buf, int len)
|
{
|
if(FD < 0)
|
return 0;
|
|
return write(FD, (char *)buf, len);
|
}
|
//---------------------------------------------------------------------
|
int Uart_Driver::ReadDev(void *buf, int len)
|
{
|
if(FD < 0)
|
return 0;
|
|
char *pbuff = (char *)buf;
|
return (read(FD, pbuff, len));
|
}
|
//---------------------------------------------------------------------
|
//---------------------------------------------------------------------
|
|
int Uart_Driver::ReadData(void *buf, const int len, const int timeout_ms)
|
{
|
quint16 rx_len = 0;
|
quint16 rx_time_out = 0;
|
quint8 *p_rxdata = (quint8 *)buf;
|
|
quint8 rx_databuff[512] = {0};
|
quint16 bytes = 0;
|
|
int timeout_5ms = timeout_ms/5;
|
|
while(1)
|
{
|
ioctl(FD, FIONREAD, &bytes); //确认字节数
|
|
if(bytes > 512){
|
bytes = 512;
|
}
|
|
if(bytes > 0){
|
int rlen = ReadDev(&rx_databuff, bytes);
|
|
if(rlen > 0){
|
for(int i=0;i<rlen;i++)
|
{
|
if(rx_len < len){
|
p_rxdata[rx_len++] = rx_databuff[i];
|
}
|
else
|
break;
|
}
|
|
rx_time_out = 0;
|
}
|
}
|
else{
|
if(rx_len>0 && rx_time_out>40) //收到了部分字节后,字节之间超时 x*5ms
|
{
|
qDebug("rx_len = %d",rx_len);
|
|
/*
|
qDebug("******* 5 ********");
|
for(int n=0;n<5;n++){
|
qDebug("0x%2X",rx_databuff[n]);
|
}
|
*/
|
|
return rx_len;
|
}
|
|
if(rx_time_out > timeout_5ms) //接收超时 timeout_5ms * 5ms
|
{
|
return CommRxError;
|
}
|
}
|
|
if(rx_len >= len){
|
return CommOK;
|
}
|
|
rx_time_out++;
|
|
msleep(5);
|
}
|
}
|
|
void Uart_Driver::ClearRxBuff(void)
|
{
|
int bytes = 0;
|
int rxlen = 0;
|
char tmp[64] = {0};
|
|
while(1)
|
{
|
ioctl(FD, FIONREAD, &bytes); //确认字节数
|
|
if(bytes > 0){
|
rxlen = ReadDev(tmp, 64);
|
if(rxlen>0)
|
continue;
|
else
|
return;
|
}
|
else
|
return;
|
}
|
}
|
|
int Uart_Driver::ModBusRead( const quint8 device_addr,const quint16 data_addr,const quint16 read_data_num,
|
void *read_data_buf, const quint16 timeout_ms)
|
{
|
int res = CommOK;
|
|
quint8 txData[16] = {0};
|
quint8 rxData[264] = {0};
|
|
txData[0] = device_addr;
|
txData[1] = FUNC_CODE_READ;
|
txData[2] = data_addr/256;
|
txData[3] = data_addr%256;
|
txData[4] = read_data_num/256;
|
txData[5] = read_data_num%256;
|
unsigned short crc = CRC16::CalModbusCRC16(txData,6);
|
txData[6] = (quint8)(crc>>8);
|
txData[7] = (quint8)crc;
|
|
const quint16 tx_data_len = 8;
|
quint16 rx_data_len = 0;
|
|
/*
|
if(device_addr>1){
|
for(int n=0;n<8;n++){
|
qDebug("0x%02X",txData[n]);
|
}
|
}
|
*/
|
|
ClearRxBuff();
|
|
if(tx_data_len != WriteDev(txData, tx_data_len))
|
res = CommTxError;
|
|
rx_data_len = read_data_num*2+5;
|
if(rx_data_len>264)
|
rx_data_len = 264;
|
|
if(CommOK == res)
|
{
|
res = ReadData(rxData, rx_data_len, timeout_ms);
|
}
|
|
if(CommOK == res)
|
{
|
crc = rxData[rx_data_len-2];
|
crc = (crc<<8) + rxData[rx_data_len-1];
|
|
if(crc == CRC16::CalModbusCRC16(rxData, rx_data_len-2))
|
{
|
if(NULL != read_data_buf)
|
{
|
quint8 *pRecvData = (quint8 *)read_data_buf;
|
for (quint8 i = 3; i<rx_data_len-2; i++)
|
{
|
*pRecvData++ = rxData[i];
|
}
|
}
|
}
|
else
|
{
|
res = CommDataError;
|
}
|
}
|
|
if(CommOK != res){
|
if(device_addr < 254){
|
qDebug("ModBusRead error,devaddr:%d,errorcode:%d",device_addr,res);
|
}
|
}
|
|
return res;
|
}
|
|
int Uart_Driver::ModBusMultiWrite(const quint8 device_addr, const quint16 data_addr,quint16 *wr_data_buf,
|
const quint16 WriteDataNum, const quint16 timeout_ms)
|
{
|
int res = CommOK;
|
|
quint8 txData[128] = {0};
|
quint8 rxData[16] = {0};
|
|
quint16 wrdatanum = WriteDataNum;
|
|
if(wrdatanum>48)
|
wrdatanum = 48;
|
|
quint16 lenth = 0;
|
|
txData[lenth++] = device_addr;
|
txData[lenth++] = FUNC_CODE_MULTI_WRITE; //多点写
|
txData[lenth++] = data_addr/256;
|
txData[lenth++] = data_addr%256;
|
txData[lenth++] = wrdatanum/256;
|
txData[lenth++] = wrdatanum%256;
|
txData[lenth++] = wrdatanum*2;
|
|
for(int i=0;i<wrdatanum;i++)
|
{
|
txData[lenth++] = wr_data_buf[i]/256;
|
txData[lenth++] = wr_data_buf[i]%256;
|
}
|
|
unsigned short crc = CRC16::CalModbusCRC16(txData,lenth);
|
|
txData[lenth++] = (quint8)(crc>>8);
|
txData[lenth++] = (quint8)crc;
|
|
/*
|
qDebug("******* 4 ********");
|
for(int n=0;n<lenth;n++){
|
qDebug("0x%X",txData[n]);
|
}
|
*/
|
|
const quint16 rx_data_len = 8;
|
quint16 rx_data = 0;
|
|
ClearRxBuff();
|
|
if(lenth != WriteDev(txData, lenth))
|
res = CommTxError;
|
|
if(CommOK == res)
|
{
|
res = ReadData(rxData, rx_data_len, timeout_ms);
|
}
|
|
if(CommOK == res)
|
{
|
crc = rxData[rx_data_len-2];
|
crc = (crc<<8) + rxData[rx_data_len-1];
|
|
if(crc == CRC16::CalModbusCRC16(rxData, rx_data_len-2))
|
{
|
rx_data = (quint16)(rxData[4]<<8)+rxData[5];
|
if(0 == rx_data) //pass==1
|
res = CommWrFailError;
|
}
|
else
|
{
|
res = CommDataError;
|
}
|
}
|
else if(res > 0)
|
{
|
int dl = res;
|
|
if(dl >= 5)
|
{
|
crc = rxData[dl-2];
|
crc = (crc<<8) + rxData[dl-1];
|
|
if(crc == CRC16::CalModbusCRC16(rxData, dl-2))
|
{
|
res = CommOK;
|
}
|
else
|
{
|
res = CommDataError;
|
}
|
}
|
else
|
res = CommDataError;
|
}
|
|
if(CommOK != res){
|
qDebug("ModBusMultiWrite error,devaddr:%d,errorcode:%d",device_addr,res);
|
}
|
|
return res;
|
}
|
|
int Uart_Driver::ModBusSingleWrite( const quint8 device_addr,const quint16 data_addr,
|
const quint16 wr_data, const quint16 timeout_ms )
|
{
|
int res = CommOK;
|
|
quint8 txData[16] = {0};
|
quint8 rxData[16] = {0};
|
|
txData[0] = device_addr;
|
txData[1] = FUNC_CODE_SINGLE_WRITE;
|
txData[2] = data_addr/256;
|
txData[3] = data_addr%256;
|
txData[4] = wr_data/256;
|
txData[5] = wr_data%256;
|
|
unsigned short crc = CRC16::CalModbusCRC16(txData,6);
|
txData[6] = (quint8)(crc>>8);
|
txData[7] = (quint8)crc;
|
|
const quint16 rx_data_len = 8;
|
const quint16 tx_data_len = 8;
|
quint16 rx_data = 0;
|
|
ClearRxBuff();
|
|
if(tx_data_len != WriteDev(txData, tx_data_len))
|
res = CommTxError;
|
|
if(CommOK == res)
|
{
|
res = ReadData(rxData, rx_data_len, timeout_ms);
|
}
|
|
if(CommOK == res)
|
{
|
crc = rxData[rx_data_len-2];
|
crc = (crc<<8) + rxData[rx_data_len-1];
|
|
if(crc == CRC16::CalModbusCRC16(rxData, rx_data_len-2))
|
{
|
rx_data = (quint16)(rxData[4]<<8)+rxData[5];
|
if(0 == rx_data) //pass==1
|
res = CommWrFailError;
|
}
|
else
|
{
|
res = CommDataError;
|
}
|
}
|
|
if(CommOK != res){
|
qDebug("ModBusSingleWrite error,devaddr:%d,errorcode:%d",device_addr,res);
|
}
|
|
return res;
|
}
|
|
int Uart_Driver::Tx_Rx_Data(void *txdata, const int txlen, void *rxdata, const int timeout_ms)
|
{
|
ClearRxBuff();
|
|
WriteDev(txdata, txlen);
|
|
quint16 rx_len = 0;
|
quint16 rx_time_out = 0;
|
quint8 *p_rxdata = (quint8 *)rxdata;
|
|
quint8 rx_databuff[512] = {0};
|
quint16 bytes = 0;
|
|
int timeout_5ms = timeout_ms/5;
|
|
while(1)
|
{
|
ioctl(FD, FIONREAD, &bytes); //确认字节数
|
|
if(bytes > 512){
|
bytes = 512;
|
}
|
|
if(bytes > 0){
|
int rlen = ReadDev(&rx_databuff, bytes);
|
|
if(rlen > 0){
|
for(int i=0;i<rlen;i++)
|
{
|
if(rx_len < 1024)
|
p_rxdata[rx_len++] = rx_databuff[i];
|
}
|
|
rx_time_out = 0;
|
}
|
}
|
else{
|
if(rx_len>0 && rx_time_out>40) //收到了部分字节后,字节之间超时 x*5ms
|
{
|
return rx_len;
|
}
|
|
if(rx_time_out > timeout_5ms) //接收超时 timeout_5ms * 5ms
|
{
|
return 0;
|
}
|
}
|
|
rx_time_out++;
|
|
msleep(5);
|
}
|
|
return 0;
|
}
|
|
int Uart_Driver::Tx_Rx_Data_ESP32(void *txdata, const int txlen, void *rxdata, const int rxlen)
|
{
|
ClearRxBuff();
|
|
WriteDev(txdata, txlen);
|
|
quint16 rx_len = 0;
|
quint16 rx_time_out = 0;
|
quint8 *p_rxdata = (quint8 *)rxdata;
|
|
quint8 rx_databuff[512] = {0};
|
quint16 bytes = 0;
|
|
while(1)
|
{
|
ioctl(FD, FIONREAD, &bytes); //确认字节数
|
|
if(bytes > 512){
|
bytes = 512;
|
}
|
|
if(bytes > 0){
|
int rlen = ReadDev(&rx_databuff, bytes);
|
|
if(rlen > 0){
|
for(int i=0;i<rlen;i++)
|
{
|
if(rx_len < rxlen)
|
p_rxdata[rx_len++] = rx_databuff[i];
|
}
|
|
rx_time_out = 0;
|
}
|
}
|
else{
|
if(rx_len >= rxlen){
|
return 0;
|
}
|
|
if(rx_len>0 && rx_time_out>40) //收到了部分字节后,字节之间超时 x*5ms
|
{
|
return rx_len;
|
}
|
|
if(rx_time_out > 120) //接收超时 x * 5ms
|
{
|
return -1;
|
}
|
}
|
|
rx_time_out++;
|
|
msleep(5);
|
}
|
|
return 0;
|
}
|
|
int Uart_Driver::ReadData_ESP32(void *rxdata, const int timeout_ms)
|
{
|
quint16 rx_len = 0;
|
quint16 rx_time_out = 0;
|
quint8 *p_rxdata = (quint8 *)rxdata;
|
|
quint8 rx_databuff[512] = {0};
|
quint16 bytes = 0;
|
|
int timeout_5ms = timeout_ms/5;
|
|
while(1)
|
{
|
ioctl(FD, FIONREAD, &bytes); //确认字节数
|
|
if(bytes > 512){
|
bytes = 512;
|
}
|
|
if(bytes > 0){
|
|
//qDebug("bytes = %d",bytes);
|
|
int rlen = ReadDev(&rx_databuff, bytes);
|
|
if(rlen > 0){
|
|
//qDebug("rlen = %d",rlen);
|
|
for(int i=0;i<rlen;i++)
|
{
|
if(rx_len < 1000)
|
p_rxdata[rx_len++] = rx_databuff[i];
|
}
|
|
rx_time_out = 0;
|
}
|
}
|
else{
|
if(rx_len>0)
|
{
|
if(rx_time_out>timeout_5ms){
|
return rx_len;
|
}
|
}
|
else{
|
return 0;
|
}
|
}
|
|
rx_time_out++;
|
|
msleep(5);
|
}
|
|
return 0;
|
}
|
