From 5d577cb2a30bf18ef64ec11cbc3ac8cc4732ad5f Mon Sep 17 00:00:00 2001 From: Hr_adore_me Date: Mon, 17 Jun 2024 13:30:41 +0800 Subject: [PATCH] first_version --- ._thread.h | Bin 0 -> 4096 bytes camera.cpp | 236 +++++ camera.h | 48 + correct.cpp | 49 + correct.h | 29 + imagewin.cpp | 30 + imagewin.h | 26 + imagewin.ui | 21 + main.cpp | 11 + relistwidget_item.cpp | 23 + relistwidget_item.h | 42 + showpic.cpp | 647 +++++++++++++ showpic.h | 69 ++ showpic.ui | 127 +++ src/modbus-data.c | 233 +++++ src/modbus-private.h | 116 +++ src/modbus-rtu-private.h | 76 ++ src/modbus-rtu.c | 1299 ++++++++++++++++++++++++++ src/modbus-rtu.h | 42 + src/modbus-tcp-private.h | 44 + src/modbus-tcp.c | 929 ++++++++++++++++++ src/modbus-tcp.h | 52 ++ src/modbus-version.h | 53 ++ src/modbus.c | 1911 ++++++++++++++++++++++++++++++++++++++ src/modbus.h | 293 ++++++ src/modbus.lib | Bin 0 -> 16390 bytes thread.cpp | 457 +++++++++ thread.h | 129 +++ widget.cpp | 1054 +++++++++++++++++++++ widget.h | 109 +++ widget.ui | 776 ++++++++++++++++ wooden.pro | 91 ++ wooden.pro.user | 318 +++++++ 33 files changed, 9340 insertions(+) create mode 100644 ._thread.h create mode 100644 camera.cpp create mode 100644 camera.h create mode 100644 correct.cpp create mode 100644 correct.h create mode 100644 imagewin.cpp create mode 100644 imagewin.h create mode 100644 imagewin.ui create mode 100644 main.cpp create mode 100644 relistwidget_item.cpp create mode 100644 relistwidget_item.h create mode 100644 showpic.cpp create mode 100644 showpic.h create mode 100644 showpic.ui create mode 100644 src/modbus-data.c create mode 100644 src/modbus-private.h create mode 100644 src/modbus-rtu-private.h create mode 100644 src/modbus-rtu.c create mode 100644 src/modbus-rtu.h create mode 100644 src/modbus-tcp-private.h create mode 100644 src/modbus-tcp.c create mode 100644 src/modbus-tcp.h create mode 100644 src/modbus-version.h create mode 100644 src/modbus.c create mode 100644 src/modbus.h create mode 100644 src/modbus.lib create mode 100644 thread.cpp create mode 100644 thread.h create mode 100644 widget.cpp create mode 100644 widget.h create mode 100644 widget.ui create mode 100644 wooden.pro create mode 100644 wooden.pro.user diff --git a/._thread.h b/._thread.h new file mode 100644 index 0000000000000000000000000000000000000000..4bec9d5469a1014902f8bd2f01c299c8d5e8cc61 GIT binary patch literal 4096 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWIUt(=a103vvYvJF zKST$^0-$mMG%bukK2%&PIX_n~v7jI)RWB#8xTLf=H6VLRbWEkZB G{|5kE)homR literal 0 HcmV?d00001 diff --git a/camera.cpp b/camera.cpp new file mode 100644 index 0000000..2437b79 --- /dev/null +++ b/camera.cpp @@ -0,0 +1,236 @@ +#include "camera.h" + +#define FIRST_DEVICE_INDEX 1 +//#define SETTING_PATH "C:/Program Files/Teledyne DALSA/Sapera/CamFiles/User/202298_first.ccf" +#define SETTING_PATH "C:/Program Files/Teledyne DALSA/Sapera/CamFiles/User/abc.ccf" + +extern void onImageDataCallback(SapXferCallbackInfo *pInfo); +extern void onImageCorrectCallback(SapXferCallbackInfo *pInfo); + +camera::camera() +{ + +} + +bool camera::enumDevic(char *serverName) +{ + int devicecount = SapManager::GetServerCount(); + if(devicecount < 1) + { + qDebug() << "no device found"; + return false; + } + + SapManager::GetServerName(FIRST_DEVICE_INDEX, serverName, CORSERVER_MAX_STRLEN); + qDebug() << serverName; + + return true; +} + +bool camera::creatObjects(char *serverName) +{ + m_loc = new SapLocation(serverName, 1); + m_pAcq = new SapAcquisition(*m_loc, SETTING_PATH); + m_buffer = new SapBuffer(1, m_pAcq); +// m_trans = new SapAcqToBuf(m_pAcq, m_buffer, onImageDataCallback, NULL); + + if(false == m_pAcq->Create()) + { + destroyObjects(); + qDebug() << "create pAcq device failed"; + return false; + } + + if(false == m_buffer->Create()) + { + destroyObjects(); + qDebug() << "create buff failed"; + return false; + } + +// if(false == m_trans->Create()) +// { +// destroyObjects(); +// qDebug() << "create transport failed"; +// return false; +// } + + qDebug() << "create object success"; + return true; + +} + +void camera::destroyObjects() +{ + if(m_trans && *m_trans) + { + m_trans->Destroy(); + qDebug() << "1"; + } + if(c_trans && *c_trans) + { + c_trans->Destroy(); + qDebug() << "2"; + } + if(m_buffer && *m_buffer) + { + m_buffer->Destroy(); + qDebug() << "3"; + } + if(m_pAcq && *m_pAcq) + { + m_pAcq->Destroy(); + qDebug() << "4"; + } + +} + +bool camera::openCamera() +{ + char serverName[CORSERVER_MAX_STRLEN]; + if(!enumDevic(serverName)) + { + qDebug() << "enum device failed"; + return false; + } + + if(!creatObjects(serverName)) + return false; + + qDebug() << "open device success"; + + return true; +} + +void camera::closeCamera() +{ + destroyObjects(); + if(m_trans) + { + delete m_trans; + qDebug() << "5"; + } + if(c_trans) + { + delete c_trans; + qDebug() << "6"; + } + if(m_buffer) + { + delete m_buffer; + qDebug() << "7"; + } + if(m_pAcq) + { + delete m_pAcq; + qDebug() << "8"; + } + +} + +bool camera::startCapture() +{ + bool success; + m_trans = new SapAcqToBuf(m_pAcq, m_buffer, onImageDataCallback, NULL); + if(false == m_trans->Create()) + { + destroyObjects(); + if(m_trans && *m_trans) + { + m_trans->Destroy(); + } + qDebug() << "create transport failed"; + return false; + } + success = m_trans->Grab(); + if(success == false) + { + qDebug() << "grab failed"; + return false; + } + return true; +} + +bool camera::stopCapture() +{ + bool success; + success = m_trans->Freeze(); + if(success == false) + { + qDebug() << "stop capture failed"; + return false; + } + m_trans->Wait(5000); + if(m_trans && *m_trans) + { + m_trans->Destroy(); + } + return true; +} + +bool camera::startCorrect() +{ + bool success; + qDebug() << "start correct"; + c_trans = new SapAcqToBuf(m_pAcq, m_buffer, onImageCorrectCallback, NULL); + if(false == c_trans->Create()) + { + destroyObjects(); + if(c_trans && *c_trans) + { + c_trans->Destroy(); + } + qDebug() << "create c_transport failed"; + return false; + } + qDebug() << "create c_trans"; + success = c_trans->Grab(); + if(success == false) + { + qDebug() << "start correct failed"; + return false; + } + qDebug() << "c_trans grab"; + return true; +} + +bool camera::stopCorrect() +{ + bool success; + success = c_trans->Freeze(); + if(success == false) + { + qDebug() << "stop correct failed"; + return false; + } + c_trans->Wait(5000); + + if(c_trans && *c_trans) + { + c_trans->Destroy(); + } + + return true; +} + +//没用 +bool camera::interTricapture() +{ + m_pAcq->SetParameter(CORACQ_PRM_INT_LINE_TRIGGER_FREQ, 8, TRUE);//内触发信号频率 + m_pAcq->SetParameter(CORACQ_PRM_INT_LINE_TRIGGER_ENABLE, TRUE, TRUE);//内触发 + + bool success; + success = m_trans->Grab(); + if(success == false) + { + qDebug() << "inter trigger capture failed"; + return false; + } + m_trans->Wait(5000); + return true; +} + + + + + diff --git a/camera.h b/camera.h new file mode 100644 index 0000000..e46a561 --- /dev/null +++ b/camera.h @@ -0,0 +1,48 @@ +#ifndef CAMERA_H +#define CAMERA_H + +#include +#include "SapClassBasic.h" +#include +#include "thread.h" +class camera +{ +public: + camera(); + bool enumDevic(char* serverName); + bool creatObjects(char* serverName); + void destroyObjects(); + bool openCamera(); + void closeCamera(); + bool startCapture(); + bool stopCapture(); + bool interTricapture(); + + bool startCorrect(); + bool stopCorrect(); + + bool capture_black_flag = false; + bool capture_white_flag = false; + bool ret_SCaptrue = false; + bool ret_SCorrect = false; + cv::Mat white_mat; + cv::Mat black_mat; + cv::Mat eps; + SapTransfer *c_trans; + float* white_buf = nullptr; + float* black_buf = nullptr; + + SapLocation *m_loc; + SapAcquisition *m_pAcq; + SapBuffer *m_buffer; + SapTransfer *m_trans; + + SapTransfer *l_trans; + std::queue imgqueue; + cv::Mat calibrated_img; + int rgb_height; +private: + +}; + +#endif // CAMERA_H diff --git a/correct.cpp b/correct.cpp new file mode 100644 index 0000000..e1e0d4f --- /dev/null +++ b/correct.cpp @@ -0,0 +1,49 @@ +#include "correct.h" + +correct::correct() +{ + is_corrected = false; + correction_ratio_r = 1; + correction_ratio_g = 1; + correction_ratio_b = 1; +} + +void correct::get_rgb(cv::Mat img) +{ + int b_temp = 0; + int g_temp = 0; + int r_temp = 0; + for(int i=0; i(i, j)[0]; + g_temp += (int)img.at(i, j)[1]; + r_temp += (int)img.at(i, j)[2]; + } + } + b = b_temp / (img.cols * img.rows); + g = g_temp / (img.cols * img.rows); + r = r_temp / (img.cols * img.rows); +} + +void correct::cal_correction_ratio() +{ + correction_ratio_b = b / b_base; + correction_ratio_g = g / g_base; + correction_ratio_r = r / r_base; + qDebug() << "correction ratio" << correction_ratio_b << correction_ratio_g << correction_ratio_r; +} + +void correct::correct_img(cv::Mat img) +{ + for(int i=0; i(j, i)[0] * correction_ratio_b) > 255 ? img.at(j, i)[0] = 255 : img.at(j, i)[0] *= correction_ratio_b; + (img.at(j, i)[1] * correction_ratio_b) > 255 ? img.at(j, i)[1] = 255 : img.at(j, i)[1] *= correction_ratio_b; + (img.at(j, i)[2] * correction_ratio_b) > 255 ? img.at(j, i)[2] = 255 : img.at(j, i)[2] *= correction_ratio_b; + } + } +} diff --git a/correct.h b/correct.h new file mode 100644 index 0000000..bf491e3 --- /dev/null +++ b/correct.h @@ -0,0 +1,29 @@ +#ifndef CORRECT_H +#define CORRECT_H + +#include "opencv2/opencv.hpp" +#include + +class correct +{ +private: + float correction_ratio; + float r; + float g; + float b; + float correction_ratio_r; + float correction_ratio_g; + float correction_ratio_b; + int b_base = 125.0f; + int g_base = 125.0f; + int r_base = 125.0f; + +public: + correct(); + bool is_corrected; + void get_rgb(cv::Mat img); + void cal_correction_ratio(); + void correct_img(cv::Mat img); +}; + +#endif // CORRECT_H diff --git a/imagewin.cpp b/imagewin.cpp new file mode 100644 index 0000000..e693726 --- /dev/null +++ b/imagewin.cpp @@ -0,0 +1,30 @@ +#include "imagewin.h" +#include "ui_imagewin.h" + +# pragma execution_character_set("utf-8") + +imageWin::imageWin(ListWidgetItemChild *item, QRect rect, QWidget *parent) : + QWidget(parent), + ui(new Ui::imageWin) +{ + ui->setupUi(this); + + qApp->installEventFilter(this); + this->setGeometry(rect);//设置显示图片窗口的x、y、w、h + this->setFixedSize(rect.width(), rect.height());//设置窗口固定大小 + this->setWindowIcon(item->icon()); + this->setWindowTitle("查看图片"); + this->setWindowModality(Qt::ApplicationModal);//阻塞除当前窗体外的其他所有窗体 + + //通过QLabel加载item上的图片 + QLabel *lab = new QLabel(this); + lab->setFixedSize(this->width(), this->height()); + lab->setPixmap(item->icon().pixmap(QSize(this->width(), this->height())).scaled(lab->width(),lab->height())); + + +} + +imageWin::~imageWin() +{ + delete ui; +} diff --git a/imagewin.h b/imagewin.h new file mode 100644 index 0000000..8943696 --- /dev/null +++ b/imagewin.h @@ -0,0 +1,26 @@ +#ifndef IMAGEWIN_H +#define IMAGEWIN_H + +#include +#include +#include +#include +#include "relistwidget_item.h" +namespace Ui { +class imageWin; +} + +class imageWin : public QWidget +{ + Q_OBJECT + +public: + explicit imageWin(ListWidgetItemChild *item, QRect rect, QWidget *parent = 0); + ~imageWin(); + + +private: + Ui::imageWin *ui; +}; + +#endif // IMAGEWIN_H diff --git a/imagewin.ui b/imagewin.ui new file mode 100644 index 0000000..91666bd --- /dev/null +++ b/imagewin.ui @@ -0,0 +1,21 @@ + + + + + imageWin + + + + 0 + 0 + 400 + 300 + + + + Form + + + + + diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..90b6d53 --- /dev/null +++ b/main.cpp @@ -0,0 +1,11 @@ +#include "widget.h" +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + Widget w; + w.show(); + + return a.exec(); +} diff --git a/relistwidget_item.cpp b/relistwidget_item.cpp new file mode 100644 index 0000000..50aab96 --- /dev/null +++ b/relistwidget_item.cpp @@ -0,0 +1,23 @@ +#include "relistwidget_item.h" + +ListWidgetItemChild::ListWidgetItemChild(QListWidget *parent) : + QListWidgetItem(parent) +{ +} + + +ListWidgetItemChild::~ListWidgetItemChild() +{ + +} + +ListWidgetRe::ListWidgetRe(QWidget *parent) : + QListWidget(parent) +{ + +} + +ListWidgetRe::~ListWidgetRe() +{ + +} diff --git a/relistwidget_item.h b/relistwidget_item.h new file mode 100644 index 0000000..106d225 --- /dev/null +++ b/relistwidget_item.h @@ -0,0 +1,42 @@ +#ifndef RELISTWIDGET_ITEM_H +#define RELISTWIDGET_ITEM_H + + +#include +#include +#include + +class ListWidgetItemChild : public QListWidgetItem +{ + +public: + explicit ListWidgetItemChild(QListWidget *parent = 0); + + ~ListWidgetItemChild(); + QString LBrightnessValue; + QString ARedGreenValue; + QString BYellowBlueValue; + + bool operator<(const QListWidgetItem &other) const + { + int a, b; + a = this->text().mid(9,3).toInt(); + b = other.text().mid(9,3).toInt(); + return a < b; + } + + +}; + +class ListWidgetRe : public QListWidget +{ + Q_OBJECT + friend class ListWidgetItemChild; + public: + explicit ListWidgetRe(QWidget *parent = nullptr); + ~ListWidgetRe(); + +Q_SIGNALS: +// void itemDoubleClicked(ListWidgetItemChild *item); +}; +#endif // RELISTWIDGET_ITEM_H diff --git a/showpic.cpp b/showpic.cpp new file mode 100644 index 0000000..7bad2b2 --- /dev/null +++ b/showpic.cpp @@ -0,0 +1,647 @@ +#include "showpic.h" +#include "ui_showpic.h" + + +# pragma execution_character_set("utf-8") + + + +using namespace std; +void deleteImage(QString folderPath, QString imageName); +QString FindImage(QString folderPath, QString imageName); + +extern QString DirPath; +//QString DirPath = "D:/picture/524test"; + + +QStringList GetFileNameList(const QString &strDirpath)//该函数的作用是获取一个目录下所有的文件名，并将文件名存储在QStringList中返回。 +{ + QDir dir(strDirpath); + QFileInfoList Info_list = dir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot); + QListIterator Iterator(Info_list); + QStringList strFileNameList; + QFileInfo Info; + while (Iterator.hasNext()) + { + Info = Iterator.next(); + if (Info.isFile()) + { + strFileNameList << Info.fileName(); + } + } + + //排序3.28 + qSort(strFileNameList.begin(), strFileNameList.end(), [](const QString& s1, const QString& s2){ + return s1.mid(3,2).toInt() < s2.mid(3,2).toInt(); }); + + return strFileNameList; +} + +showpic::showpic(char* buf1, QWidget *parent) : + QWidget(parent), +//showpic::showpic(QWidget *parent) : +// QWidget(parent), + ui(new Ui::showpic) +{ + ui->setupUi(this); +//切割char数组 + const char split[] = ","; + char* res = strtok(buf1, split);//image_name必须为char[] + while (res != NULL)//切割buf,将有用的数据全部在res_split内，可通过res_split.at(i)调用 + { +// qDebug() << "res" << res; + res_split.push_back(res);//?? + res = strtok(NULL, split);//?? + + } + qDebug() << "res_split.size()" << res_split.size(); + + LightPath = DirPath +"/light/"; + MiddlePath = DirPath +"/Middle/"; + DarkPath = DirPath +"/dark/"; + + QStringList listLight = GetFileNameList(LightPath);//应该是一个全局变量3.28 + QStringList listMiddle = GetFileNameList(MiddlePath); + QStringList listDark = GetFileNameList(DarkPath); + +// QStringList listLight = GetFileNameList("D:/wood_color317/data/2023318/light/");//应该是一个全局变量3.28 +// QStringList listMiddle = GetFileNameList("D:/wood_color317/data/2023318/middle/"); +// QStringList listDark = GetFileNameList("D:/wood_color317/data/2023318/dark/"); +//将90个lab值分三类 + QVector Light_lab; + QVector Middle_lab; + QVector Dark_lab; +/* for(int i = 0; i < 90; i++) + { + if(i < 30) + { + Light_lab.append(res_split.at(i)); +// qDebug() << Light_lab.at(i) << i; + + } + else if(i > 29 && i < 60) + { + Middle_lab.append(res_split.at(i)); +// qDebug() << Middle_lab.at(i-30) << i; + } + else if(i > 59 && i < 90) + { + Dark_lab.append(res_split.at(i)); +// qDebug() << Dark_lab.at(i-60) << i; + } + } + */ + for(int i = 0; i < (listLight.size() + listMiddle.size() + listDark.size()); i++) + { + if(i < listLight.size()) + { + Light_lab.append(res_split.at(i)); + qDebug() << Light_lab.at(i) << i; + + } + else if(i > (listLight.size() - 1) && i < (listLight.size() + listMiddle.size())) + { + Middle_lab.append(res_split.at(i)); + qDebug() << Middle_lab.at(i-listLight.size()) << i; + } + else /*if(i > (listLight.size() + listMiddle.size() - 1) && i < 90)*/ + { + Dark_lab.append(res_split.at(i)); + qDebug() << Dark_lab.at(i-listLight.size() - listMiddle.size()) << i; + } + } + listWidget = new ListWidgetRe(this); + listWidget->setViewMode(QListWidget::IconMode);//显示模式 + listWidget->setIconSize(QSize(400, 90));//设置图片大小 + listWidget->setSpacing(10);//间距 + listWidget->setResizeMode(QListView::Adjust);//适应布局调整 + listWidget->setMovement(QListView::Static);//不能移动 + + +// QString file = "D:/wood_color317/data/2023318/light/"; + QString file = LightPath; + LoadPicture(file, listLight, Light_lab); + +// QListWidgetItem *separate0 = new QListWidgetItem; +// separate0->setText("之后为中色"); +// separate0->setFlags(separate0->flags() & ~Qt::ItemIsEnabled & ~Qt::ItemIsSelectable); +// listWidget->addItem(separate0); + + +// file = "D:/wood_color317/data/2023318/middle/"; + file = MiddlePath; + LoadPicture(file, listMiddle, Middle_lab); + +// QListWidgetItem *separate1 = new QListWidgetItem; +// separate1->setFlags(separate0->flags() & ~Qt::ItemIsEnabled & ~Qt::ItemIsSelectable); +// separate1->setText("之后为深色"); +// listWidget->addItem(separate1); + +// file = "D:/wood_color317/data/2023318/dark/"; + file = DarkPath; + LoadPicture(file, listDark, Dark_lab); + + listWidget->sortItems(); + listWidget->setSelectionMode(QAbstractItemView::MultiSelection);//设置多选模式 + QVBoxLayout* VBox = new QVBoxLayout; + QHBoxLayout* HBox = new QHBoxLayout; + ui->pushButton->setFixedSize(140,70); + ui->pushButton_2->setFixedSize(140,70); + ui->pushButton_3->setFixedSize(140,70); + ui->pushButton_light->setFixedSize(140,70); + ui->pushButton_middle->setFixedSize(140,70); + ui->pushButton_dark->setFixedSize(140,70); + + + HBox->addWidget(ui->pushButton); + HBox->addWidget(ui->pushButton_2); + HBox->addWidget(ui->pushButton_3); + HBox->addWidget(ui->pushButton_light); + HBox->addWidget(ui->pushButton_middle); + HBox->addWidget(ui->pushButton_dark); + + + VBox->addWidget(listWidget); + VBox->addLayout(HBox); + + this->setLayout(VBox); + + connect(listWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(enlargeImage(QListWidgetItem*))); + + qDebug() << "showpic ready"; + + emit PictureReady(); + +} + +showpic::~showpic() +{ + delete ui; +} + +void showpic::enlargeImage(QListWidgetItem *item) +{ + + QRect rect = this->geometry();//获取当前窗口坐标及大小 x、y、w、h +// static_cast(listWidget->itemWidget(item)); + ListWidgetItemChild *item0 = static_cast(item); + //通过自定义的窗口显示图片 +// imageWin *showImageWidget = new imageWin(item , QRect(rect.x(), rect.y()+rect.y()*1/4, rect.width(), rect.height()*2/3)); + imageWin *showImageWidget = new imageWin(item0 , QRect(rect.x(), rect.y()+rect.y()*1/4, rect.width(), rect.height()*1.7/3)); + showImageWidget->show(); + + //显示条目名称 + qDebug() << item0->text(); + QString item_name = item0->text(); + if(item_name.at(4) != '.') + { + QString a = item_name.at(3); + a.append(item_name.at(4)); + qDebug() << "a" << a.toInt(); +// int b = a.toInt(); + int L = item0->LBrightnessValue.toInt(); + int A = item0->ARedGreenValue.toInt(); + int B = item0->BYellowBlueValue.toInt(); + qDebug() << "LAB" << L << A << B; + //显示色块 + cv::Mat mat = cv::Mat(100, 100, CV_8UC3, cv::Scalar(L, A, B)); + cv::cvtColor(mat, mat, cv::COLOR_Lab2BGR); + cv::imshow("sekuai", mat); + } + else + { + qDebug() << "--"; + } + +} +//rgb00.png175136163QQ +//拼图片路径，并添加到imageItem，再添加到listWidget +void showpic::LoadPicture(QString file, QStringList list, QVector lab) +{ + for(int i = 0; i < list.size(); i++) + { + qDebug() << lab.at(i) << i; + QString LAB = lab.at(i); + QString tmp = file + list.at(i);//拼出图片绝对路径 + + ListWidgetItemChild *imageItem = new ListWidgetItemChild; + imageItem->LBrightnessValue =LAB.mid(0,3); + imageItem->ARedGreenValue = LAB.mid(3,3); + imageItem->BYellowBlueValue = LAB.mid(6,3); + + imageItem->setIcon(QIcon(tmp)); + imageItem->setText(list.at(i) + LAB.mid(0,3) + LAB.mid(9,2)); +// qDebug() << "luminance1" << lab.at(i) << i; + if(LAB.mid(9,1) == LAB.mid(10,1)) + { + } + else + { + imageItem->setTextColor(Qt::red); + } + imageItem->setSizeHint(QSize(400, 120)); + listWidget->addItem(imageItem); + } + + +} +//rgb00.png000 +//bool showpic::CompareItem(ListWidgetItemChild *item1, ListWidgetItemChild *item2) +//{ +// int luminance1 = item1->text().mid(9,3).toInt(); +// qDebug() << "luminance1" << luminance1; +// int luminance2 = item2->text().mid(9,3).toInt(); +// qDebug() << "luminance2" << luminance2; + +// return luminance1 < luminance2; + +//} + + + +void showpic::on_pushButton_clicked() +{ + // 获取选中的item + QList selectedItems = listWidget->selectedItems(); +// QListWidgetItem *selectedItem = listWidget->currentItem(); + if (selectedItems.size() != 1) { + // 如果选中的item数量不等于2，则弹出提示框并返回 + QMessageBox::warning(this, "Error", "请至少选择一张图片"); + return; + } + //并从文件夹中删除 + QListWidgetItem* item1 = selectedItems[0]; + QString DelPicName = item1->text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; + deleteImage(DirPath, DelPicName); + + // 如果有选中的item，则删除它 + if (item1 != nullptr) { + delete item1; + } + +} + + + +void showpic::on_pushButton_2_clicked() +{ + + // 获取选中的两个item + QList selectedItems = listWidget->selectedItems(); + if (selectedItems.size() != 2) { + // 如果选中的item数量不等于2，则弹出提示框并返回 + QMessageBox::warning(this, "Error", "请选中2张图片进行操作：先选的图片插入到后选的后面"); + return; + } + QListWidgetItem* item1 = selectedItems[0]; + QListWidgetItem* item2 = selectedItems[1]; + + // 获取它们在listWidget中的位置 + int index1 = listWidget->row(item1); + int index2 = listWidget->row(item2); + qDebug() << "index1" << index1; + qDebug() << "index2" << index2; + + // 交换它们的位置,!!!!!!!!!有点问题 + listWidget->takeItem(index1); + listWidget->takeItem(index2); + listWidget->insertItem(index1, item2); + listWidget->insertItem(index2, item1); + + index1 = listWidget->row(item1); + index2 = listWidget->row(item2); + qDebug() << "index1new" << index1; + qDebug() << "index2new" << index2; + + // 取消选中状态 + item1->setSelected(false); + item2->setSelected(false); +} + +void showpic::on_pushButton_3_clicked() +{ + if(listWidget->currentItem() == nullptr) + { + QMessageBox::warning(this, "Error", "请点击一个图片进行操作"); + + return; + } + + QListWidgetItem *selectedItem = listWidget->currentItem(); + + + QString PicNamePath = FindImage(DirPath, selectedItem->text().mid(0, 9));// +// sprintf(PicNamePath, PicNamePath); + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data());// .toLatin1().data(): string转char* + + QInputDialog *inputDialog_item=new QInputDialog(this); + QStringList list; + list<<"浅色"<<"中色"<<"深色"; + bool getItem; + QString season = inputDialog_item->getItem(this,"选择文件夹","文件夹类别",list,0,false,&getItem); + if(getItem) + { + if("浅色" == season) + { + QString RePicName = LightPath + selectedItem->text().mid(0,9); + // PicImg.save(RePicName, "PNG", -1); + cv::imwrite(RePicName.toLatin1().data(), Pic); + //调用删除图片函数 + QString DelPicName = selectedItem->text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; + deleteImage(MiddlePath, DelPicName); + deleteImage(DarkPath, DelPicName); + + if (selectedItem != nullptr) { + delete selectedItem; + } + } + + if("中色" == season) + { + QString RePicName = MiddlePath + selectedItem->text().mid(0,9); + // PicImg.save(RePicName, "PNG", -1); + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = selectedItem->text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; + deleteImage(LightPath, DelPicName); + deleteImage(DarkPath, DelPicName); + + if (selectedItem != nullptr) { + delete selectedItem; + } + } + + if("深色" == season) + { + QString RePicName = DarkPath + selectedItem->text().mid(0,9); + // PicImg.save(RePicName, "PNG", -1); + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = selectedItem->text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; + deleteImage(LightPath, DelPicName); + deleteImage(MiddlePath, DelPicName); + + if (selectedItem != nullptr) { + delete selectedItem; + } + } + } +} + +//按键，多选移动rgb00.png000QQ +void showpic::on_pushButton_light_clicked() +{ + QList selectedItems = listWidget->selectedItems(); + + int Numbers = selectedItems.size(); + QListWidgetItem* Item = new QListWidgetItem[Numbers]; + for(int i = 0; i < Numbers; i++) + { +// qDebug() << + Item[i] = *selectedItems[i]; + if(Item[i].text().mid(12, 1) == 'Q') + { + return; + } + if(Item[i].text().mid(12, 1) == 'S') + { +// QString PicNamePath = FindImage("D:/2023/wooden/2023318/", Item[i].text().mid(0,9)); + QString PicNamePath = FindImage(DirPath, Item[i].text().mid(0,9)); + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data()); + +// QString RePicName = "D:/2023/wooden/2023318/light/" + Item[i].text().mid(0,9); + QString RePicName = LightPath + Item[i].text().mid(0,9); + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = Item[i].text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; +// deleteImage("D:/2023/wooden/2023318/dark/", DelPicName); + deleteImage(DarkPath, DelPicName); + if (selectedItems[i] != nullptr) { + delete selectedItems[i]; + } + } + + if(Item[i].text().mid(12, 1) == 'Z') + { +// QString PicNamePath = FindImage("D:/2023/wooden/2023318/", Item[i].text().mid(0,9)); + QString PicNamePath = FindImage(DirPath, Item[i].text().mid(0,9)); + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data()); + +// QString RePicName = "D:/2023/wooden/2023318/light/" + Item[i].text().mid(0,9); + QString RePicName = LightPath + Item[i].text().mid(0,9); + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = Item[i].text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; +// deleteImage("D:/2023/wooden/2023318/middle/", DelPicName); + deleteImage(MiddlePath, DelPicName); + + if (selectedItems[i] != nullptr) { + delete selectedItems[i]; + } + } + } +} + +void showpic::on_pushButton_middle_clicked() +{ + QList selectedItems = listWidget->selectedItems(); + + int Numbers = selectedItems.size(); + QListWidgetItem* Item = new QListWidgetItem[Numbers]; + for(int i = 0; i < Numbers; i++) + { + Item[i] = *selectedItems[i]; + if(Item[i].text().mid(12, 1) == 'Z') + { + return; + } + if(Item[i].text().mid(12, 1) == 'S') + { +// QString PicNamePath = FindImage("D:/2023/wooden/2023318/", Item[i].text().mid(0,9)); + QString PicNamePath = FindImage(DirPath, Item[i].text().mid(0,9)); + + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data()); + +// QString RePicName = "D:/2023/wooden/2023318/middle/" + Item[i].text().mid(0,9); + QString RePicName = MiddlePath + Item[i].text().mid(0,9); + + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = Item[i].text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; +// deleteImage("D:/2023/wooden/2023318/dark/", DelPicName); + deleteImage(DarkPath, DelPicName); + + if (selectedItems[i] != nullptr) { + delete selectedItems[i]; + } + } + + if(Item[i].text().mid(12, 1) == 'Q') + { +// QString PicNamePath = FindImage("D:/2023/wooden/2023318/", Item[i].text().mid(0,9)); + QString PicNamePath = FindImage(DirPath, Item[i].text().mid(0,9)); + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data()); + +// QString RePicName = "D:/2023/wooden/2023318/middle/" + Item[i].text().mid(0,9); + QString RePicName = MiddlePath + Item[i].text().mid(0,9); + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = Item[i].text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; +// deleteImage("D:/2023/wooden/2023318/light/", DelPicName); + deleteImage(LightPath, DelPicName); + + + if (selectedItems[i] != nullptr) { + delete selectedItems[i]; + } + } + } +} + +void showpic::on_pushButton_dark_clicked() +{ + QList selectedItems = listWidget->selectedItems(); + + int Numbers = selectedItems.size(); + QListWidgetItem* Item = new QListWidgetItem[Numbers]; + for(int i = 0; i < Numbers; i++) + { + Item[i] = *selectedItems[i]; + if(Item[i].text().mid(12, 1) == 'S') + { + return; + } + if(Item[i].text().mid(12, 1) == 'Q') + { +// QString PicNamePath = FindImage("D:/2023/wooden/2023318/", Item[i].text().mid(0,9)); + QString PicNamePath = FindImage(DirPath, Item[i].text().mid(0,9)); + + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data()); + +// QString RePicName = "D:/2023/wooden/2023318/dark/" + Item[i].text().mid(0,9); + QString RePicName = DarkPath + Item[i].text().mid(0,9); + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = Item[i].text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; +// deleteImage("D:/2023/wooden/2023318/light/", DelPicName); + deleteImage(LightPath, DelPicName); + + if (selectedItems[i] != nullptr) { + delete selectedItems[i]; + } + } + + if(Item[i].text().mid(12, 1) == 'Z') + { +// QString PicNamePath = FindImage("D:/2023/wooden/2023318/", Item[i].text().mid(0,9)); + QString PicNamePath = FindImage(DirPath, Item[i].text().mid(0,9)); + cv::Mat Pic = cv::imread(PicNamePath.toLatin1().data()); + +// QString RePicName = "D:/2023/wooden/2023318/dark/" + Item[i].text().mid(0,9); + QString RePicName = DarkPath + Item[i].text().mid(0,9); + + cv::imwrite(RePicName.toLatin1().data(), Pic); + + //调用删除图片函数 + QString DelPicName = Item[i].text().mid(0,9); + qDebug() << "DelPicName" << DelPicName; +// deleteImage("D:/2023/wooden/2023318/middle/", DelPicName); + deleteImage(MiddlePath, DelPicName); + + + if (selectedItems[i] != nullptr) { + delete selectedItems[i]; + } + } + } +} + +//从文件夹中删除图片 +void deleteImage(QString folderPath, QString imageName) { + QDir folder(folderPath); + QFileInfoList entries = folder.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot); + + for (const QFileInfo &entry : entries) { + if (entry.isFile() && entry.fileName() == imageName) { + // 找到了指定图片，删除它 + qDebug() << "entry.absoluteFilePath()" << entry.absoluteFilePath(); + if (QFile::remove(entry.absoluteFilePath())) { + QMessageBox::information(nullptr, "Success", "Image deleted successfully"); + } else { +// QMessageBox::warning(nullptr, "Error", "Failed to delete image"); + } + return; + } else if (entry.isDir()) { + // 递归进入子文件夹查找图片 + deleteImage(entry.absoluteFilePath(), imageName); + } + } + + // 如果遍历完当前文件夹和子文件夹都没有找到指定图片，则弹出失败提示框 +// QMessageBox::warning(nullptr, "Error", "Failed to find image"); +} + +QString FindImage(QString folderPath, QString imageName) +{ + + QDir folderDir(folderPath); + + // 获取文件夹中的所有文件和文件夹 + QStringList entries = folderDir.entryList(); + + // 遍历文件夹中的所有文件和文件夹 + foreach(QString entry, entries) + { + QString entryPath = folderPath + "/" + entry; + + // 如果是子文件夹，进入子文件夹查找图片 + if(QFileInfo(entryPath).isDir()) + { + QDir subFolderDir(entryPath); + QStringList subEntries = subFolderDir.entryList(); + + // 遍历子文件夹中的所有文件 + foreach(QString subEntry, subEntries) + { + QString subEntryPath = entryPath + "/" + subEntry; + + // 如果是目标图片，返回其绝对路径 + if(subEntry == imageName) + { + QString imagePath = QFileInfo(subEntryPath).absoluteFilePath(); + return imagePath; + } + } + } + // 如果是目标图片，返回其绝对路径 + else if(entry == imageName) + { + QString imagePath = QFileInfo(entryPath).absoluteFilePath(); + return imagePath; + } + } + + // 如果未找到目标图片，返回空字符串 + return ""; +} + + + + + diff --git a/showpic.h b/showpic.h new file mode 100644 index 0000000..27c4fbb --- /dev/null +++ b/showpic.h @@ -0,0 +1,69 @@ +#ifndef SHOWPIC_H +#define SHOWPIC_H + +#include +#include +#include +#include +#include +#include +#include +#include "opencv2/imgproc/types_c.h" +#include +#include +#include +#include +#include +#include +#include "relistwidget_item.h" +#include "imagewin.h" +#include + +namespace Ui { +class showpic; +} + +class showpic : public QWidget +{ + Q_OBJECT + +public: + explicit showpic(char*, QWidget *parent = 0); +// explicit showpic(QWidget *parent = 0); + ~showpic(); + QVector res_split;//存储分割后的字符串 + ListWidgetRe *listWidget; + + QString LightPath; + QString MiddlePath; + QString DarkPath; + void LoadPicture(QString file, QStringList list, QVector); +// bool CompareItem(ListWidgetItemChild* item1, ListWidgetItemChild* item2); + +public slots: + void enlargeImage(QListWidgetItem *item);//放大图片 + +signals: + void PictureReady(); + +private slots: + void on_pushButton_clicked(); + + void on_pushButton_2_clicked(); + + void on_pushButton_3_clicked(); + + void on_pushButton_light_clicked(); + + void on_pushButton_middle_clicked(); + + void on_pushButton_dark_clicked(); + +private: + Ui::showpic *ui; + + + +}; + +#endif // SHOWPIC_H diff --git a/showpic.ui b/showpic.ui new file mode 100644 index 0000000..34eb409 --- /dev/null +++ b/showpic.ui @@ -0,0 +1,127 @@ + + + showpic + + + + 0 + 0 + 1126 + 668 + + + + Form + + + + + 60 + 540 + 141 + 71 + + + + + 19 + + + + 删除 + + + + + + 290 + 540 + 181 + 71 + + + + + 19 + + + + 移动 + + + + + + 530 + 540 + 131 + 71 + + + + + 14 + + + + 改变所属分类 + + + + + + 700 + 540 + 131 + 71 + + + + + 14 + + + + 移入浅色 + + + + + + 850 + 540 + 131 + 71 + + + + + 14 + + + + 移入中色 + + + + + + 990 + 540 + 131 + 71 + + + + + 14 + + + + 移入深色 + + + + + + diff --git a/src/modbus-data.c b/src/modbus-data.c new file mode 100644 index 0000000..ce0667a --- /dev/null +++ b/src/modbus-data.c @@ -0,0 +1,233 @@ +/* + * Copyright © 2010-2014 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#include + +#ifndef _MSC_VER +# include +#else +# include "stdint.h" +#endif + +#include +#include + +#if defined(_WIN32) +# include +#else +# include +#endif + +//#include + +#include "modbus.h" + +#if defined(HAVE_BYTESWAP_H) +# include +#endif + +#if defined(__APPLE__) +# include +# define bswap_16 OSSwapInt16 +# define bswap_32 OSSwapInt32 +# define bswap_64 OSSwapInt64 +#endif + +#if defined(__GNUC__) +# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10) +# if GCC_VERSION >= 430 +// Since GCC >= 4.30, GCC provides __builtin_bswapXX() alternatives so we switch to them +# undef bswap_32 +# define bswap_32 __builtin_bswap32 +# endif +# if GCC_VERSION >= 480 +# undef bswap_16 +# define bswap_16 __builtin_bswap16 +# endif +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1400) +# define bswap_32 _byteswap_ulong +# define bswap_16 _byteswap_ushort +#endif + +#if !defined(bswap_16) +# warning "Fallback on C functions for bswap_16" +static inline uint16_t bswap_16(uint16_t x) +{ + return (x >> 8) | (x << 8); +} +#endif + +#if !defined(bswap_32) +# warning "Fallback on C functions for bswap_32" +static inline uint32_t bswap_32(uint32_t x) +{ + return (bswap_16(x & 0xffff) << 16) | (bswap_16(x >> 16)); +} +#endif + +/* Sets many bits from a single byte value (all 8 bits of the byte value are + set) */ +void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value) +{ + int i; + + for (i=0; i < 8; i++) { + dest[idx+i] = (value & (1 << i)) ? 1 : 0; + } +} + +/* Sets many bits from a table of bytes (only the bits between idx and + idx + nb_bits are set) */ +void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits, + const uint8_t *tab_byte) +{ + unsigned int i; + int shift = 0; + + for (i = idx; i < idx + nb_bits; i++) { + dest[i] = tab_byte[(i - idx) / 8] & (1 << shift) ? 1 : 0; + /* gcc doesn't like: shift = (++shift) % 8; */ + shift++; + shift %= 8; + } +} + +/* Gets the byte value from many bits. + To obtain a full byte, set nb_bits to 8. */ +uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, + unsigned int nb_bits) +{ + unsigned int i; + uint8_t value = 0; + + if (nb_bits > 8) { + /* Assert is ignored if NDEBUG is set */ + assert(nb_bits < 8); + nb_bits = 8; + } + + for (i=0; i < nb_bits; i++) { + value |= (src[idx+i] << i); + } + + return value; +} + +/* Get a float from 4 bytes (Modbus) without any conversion (ABCD) */ +float modbus_get_float_abcd(const uint16_t *src) +{ + float f; + uint32_t i; + + i = ntohl(((uint32_t)src[0] << 16) + src[1]); + memcpy(&f, &i, sizeof(float)); + + return f; +} + +/* Get a float from 4 bytes (Modbus) in inversed format (DCBA) */ +float modbus_get_float_dcba(const uint16_t *src) +{ + float f; + uint32_t i; + + i = ntohl(bswap_32((((uint32_t)src[0]) << 16) + src[1])); + memcpy(&f, &i, sizeof(float)); + + return f; +} + +/* Get a float from 4 bytes (Modbus) with swapped bytes (BADC) */ +float modbus_get_float_badc(const uint16_t *src) +{ + float f; + uint32_t i; + + i = ntohl((uint32_t)(bswap_16(src[0]) << 16) + bswap_16(src[1])); + memcpy(&f, &i, sizeof(float)); + + return f; +} + +/* Get a float from 4 bytes (Modbus) with swapped words (CDAB) */ +float modbus_get_float_cdab(const uint16_t *src) +{ + float f; + uint32_t i; + + i = ntohl((((uint32_t)src[1]) << 16) + src[0]); + memcpy(&f, &i, sizeof(float)); + + return f; +} + +/* DEPRECATED - Get a float from 4 bytes in sort of Modbus format */ +float modbus_get_float(const uint16_t *src) +{ + float f; + uint32_t i; + + i = (((uint32_t)src[1]) << 16) + src[0]; + memcpy(&f, &i, sizeof(float)); + + return f; +} + +/* Set a float to 4 bytes for Modbus w/o any conversion (ABCD) */ +void modbus_set_float_abcd(float f, uint16_t *dest) +{ + uint32_t i; + + memcpy(&i, &f, sizeof(uint32_t)); + i = htonl(i); + dest[0] = (uint16_t)(i >> 16); + dest[1] = (uint16_t)i; +} + +/* Set a float to 4 bytes for Modbus with byte and word swap conversion (DCBA) */ +void modbus_set_float_dcba(float f, uint16_t *dest) +{ + uint32_t i; + + memcpy(&i, &f, sizeof(uint32_t)); + i = bswap_32(htonl(i)); + dest[0] = (uint16_t)(i >> 16); + dest[1] = (uint16_t)i; +} + +/* Set a float to 4 bytes for Modbus with byte swap conversion (BADC) */ +void modbus_set_float_badc(float f, uint16_t *dest) +{ + uint32_t i; + + memcpy(&i, &f, sizeof(uint32_t)); + i = htonl(i); + dest[0] = (uint16_t)bswap_16(i >> 16); + dest[1] = (uint16_t)bswap_16(i & 0xFFFF); +} + +/* Set a float to 4 bytes for Modbus with word swap conversion (CDAB) */ +void modbus_set_float_cdab(float f, uint16_t *dest) +{ + uint32_t i; + + memcpy(&i, &f, sizeof(uint32_t)); + i = htonl(i); + dest[0] = (uint16_t)i; + dest[1] = (uint16_t)(i >> 16); +} + +/* DEPRECATED - Set a float to 4 bytes in a sort of Modbus format! */ +void modbus_set_float(float f, uint16_t *dest) +{ + uint32_t i; + + memcpy(&i, &f, sizeof(uint32_t)); + dest[0] = (uint16_t)i; + dest[1] = (uint16_t)(i >> 16); +} diff --git a/src/modbus-private.h b/src/modbus-private.h new file mode 100644 index 0000000..48b043e --- /dev/null +++ b/src/modbus-private.h @@ -0,0 +1,116 @@ +/* + * Copyright © 2010-2012 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef MODBUS_PRIVATE_H +#define MODBUS_PRIVATE_H + +#ifndef _MSC_VER +# include +# include +#else +# include "stdint.h" +# include +typedef int ssize_t; +#endif +#include +//#include + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* It's not really the minimal length (the real one is report slave ID + * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP + * communications to read many values or write a single one. + * Maximum between : + * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2) + * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2) + */ +#define _MIN_REQ_LENGTH 12 + +#define _REPORT_SLAVE_ID 180 + +#define _MODBUS_EXCEPTION_RSP_LENGTH 5 + +/* Timeouts in microsecond (0.5 s) */ +#define _RESPONSE_TIMEOUT 500000 +#define _BYTE_TIMEOUT 500000 + +typedef enum { + _MODBUS_BACKEND_TYPE_RTU=0, + _MODBUS_BACKEND_TYPE_TCP +} modbus_backend_type_t; + +/* + * ---------- Request Indication ---------- + * | Client | ---------------------->| Server | + * ---------- Confirmation Response ---------- + */ +typedef enum { + /* Request message on the server side */ + MSG_INDICATION, + /* Request message on the client side */ + MSG_CONFIRMATION +} msg_type_t; + +/* This structure reduces the number of params in functions and so + * optimizes the speed of execution (~ 37%). */ +typedef struct _sft { + int slave; + int function; + int t_id; +} sft_t; + +typedef struct _modbus_backend { + unsigned int backend_type; + unsigned int header_length; + unsigned int checksum_length; + unsigned int max_adu_length; + int (*set_slave) (modbus_t *ctx, int slave); + int (*build_request_basis) (modbus_t *ctx, int function, int addr, + int nb, uint8_t *req); + int (*build_response_basis) (sft_t *sft, uint8_t *rsp); + int (*prepare_response_tid) (const uint8_t *req, int *req_length); + int (*send_msg_pre) (uint8_t *req, int req_length); + ssize_t (*send) (modbus_t *ctx, const uint8_t *req, int req_length); + int (*receive) (modbus_t *ctx, uint8_t *req); + ssize_t (*recv) (modbus_t *ctx, uint8_t *rsp, int rsp_length); + int (*check_integrity) (modbus_t *ctx, uint8_t *msg, + const int msg_length); + int (*pre_check_confirmation) (modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length); + int (*connect) (modbus_t *ctx); + void (*close) (modbus_t *ctx); + int (*flush) (modbus_t *ctx); + int (*select) (modbus_t *ctx, fd_set *rset, struct timeval *tv, int msg_length); + void (*free) (modbus_t *ctx); +} modbus_backend_t; + +struct _modbus { + /* Slave address */ + int slave; + /* Socket or file descriptor */ + int s; + int debug; + int error_recovery; + struct timeval response_timeout; + struct timeval byte_timeout; + struct timeval indication_timeout; + const modbus_backend_t *backend; + void *backend_data; +}; + +void _modbus_init_common(modbus_t *ctx); +void _error_print(modbus_t *ctx, const char *context); +int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type); + +#ifndef HAVE_STRLCPY +size_t strlcpy(char *dest, const char *src, size_t dest_size); +#endif + +MODBUS_END_DECLS + +#endif /* MODBUS_PRIVATE_H */ diff --git a/src/modbus-rtu-private.h b/src/modbus-rtu-private.h new file mode 100644 index 0000000..a1d0473 --- /dev/null +++ b/src/modbus-rtu-private.h @@ -0,0 +1,76 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef MODBUS_RTU_PRIVATE_H +#define MODBUS_RTU_PRIVATE_H + +#ifndef _MSC_VER +#include +#else +#include "stdint.h" +#endif + +#if defined(_WIN32) +#include +#else +#include +#endif + +#define _MODBUS_RTU_HEADER_LENGTH 1 +#define _MODBUS_RTU_PRESET_REQ_LENGTH 6 +#define _MODBUS_RTU_PRESET_RSP_LENGTH 2 + +#define _MODBUS_RTU_CHECKSUM_LENGTH 2 + +#if defined(_WIN32) +#if !defined(ENOTSUP) +#define ENOTSUP WSAEOPNOTSUPP +#endif + +/* WIN32: struct containing serial handle and a receive buffer */ +#define PY_BUF_SIZE 512 +struct win32_ser { + /* File handle */ + HANDLE fd; + /* Receive buffer */ + uint8_t buf[PY_BUF_SIZE]; + /* Received chars */ + DWORD n_bytes; +}; +#endif /* _WIN32 */ + +typedef struct _modbus_rtu { + /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X. */ + char *device; + /* Bauds: 9600, 19200, 57600, 115200, etc */ + int baud; + /* Data bit */ + uint8_t data_bit; + /* Stop bit */ + uint8_t stop_bit; + /* Parity: 'N', 'O', 'E' */ + char parity; +#if defined(_WIN32) + struct win32_ser w_ser; + DCB old_dcb; +#else + /* Save old termios settings */ + struct termios old_tios; +#endif +#if HAVE_DECL_TIOCSRS485 + int serial_mode; +#endif +#if HAVE_DECL_TIOCM_RTS + int rts; + int rts_delay; + int onebyte_time; + void (*set_rts) (modbus_t *ctx, int on); +#endif + /* To handle many slaves on the same link */ + int confirmation_to_ignore; +} modbus_rtu_t; + +#endif /* MODBUS_RTU_PRIVATE_H */ diff --git a/src/modbus-rtu.c b/src/modbus-rtu.c new file mode 100644 index 0000000..190298e --- /dev/null +++ b/src/modbus-rtu.c @@ -0,0 +1,1299 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include + +#include "modbus-private.h" + +#include "modbus-rtu.h" +#include "modbus-rtu-private.h" + +#if HAVE_DECL_TIOCSRS485 || HAVE_DECL_TIOCM_RTS +#include +#endif + +#if HAVE_DECL_TIOCSRS485 +#include +#endif + +/* Table of CRC values for high-order byte */ +static const uint8_t table_crc_hi[] = { + 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 +}; + +/* Table of CRC values for low-order byte */ +static const uint8_t table_crc_lo[] = { + 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 +}; + +/* Define the slave ID of the remote device to talk in master mode or set the + * internal slave ID in slave mode */ +static int _modbus_set_slave(modbus_t *ctx, int slave) +{ + /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */ + if (slave >= 0 && slave <= 247) { + ctx->slave = slave; + } else { + errno = EINVAL; + return -1; + } + + return 0; +} + +/* Builds a RTU request header */ +static int _modbus_rtu_build_request_basis(modbus_t *ctx, int function, + int addr, int nb, + uint8_t *req) +{ + assert(ctx->slave != -1); + req[0] = ctx->slave; + req[1] = function; + req[2] = addr >> 8; + req[3] = addr & 0x00ff; + req[4] = nb >> 8; + req[5] = nb & 0x00ff; + + return _MODBUS_RTU_PRESET_REQ_LENGTH; +} + +/* Builds a RTU response header */ +static int _modbus_rtu_build_response_basis(sft_t *sft, uint8_t *rsp) +{ + /* In this case, the slave is certainly valid because a check is already + * done in _modbus_rtu_listen */ + rsp[0] = sft->slave; + rsp[1] = sft->function; + + return _MODBUS_RTU_PRESET_RSP_LENGTH; +} + +static uint16_t crc16(uint8_t *buffer, uint16_t buffer_length) +{ + uint8_t crc_hi = 0xFF; /* high CRC byte initialized */ + uint8_t crc_lo = 0xFF; /* low CRC byte initialized */ + unsigned int i; /* will index into CRC lookup */ + + /* pass through message buffer */ + while (buffer_length--) { + i = crc_hi ^ *buffer++; /* calculate the CRC */ + crc_hi = crc_lo ^ table_crc_hi[i]; + crc_lo = table_crc_lo[i]; + } + + return (crc_hi << 8 | crc_lo); +} + +static int _modbus_rtu_prepare_response_tid(const uint8_t *req, int *req_length) +{ + (*req_length) -= _MODBUS_RTU_CHECKSUM_LENGTH; + /* No TID */ + return 0; +} + +static int _modbus_rtu_send_msg_pre(uint8_t *req, int req_length) +{ + uint16_t crc = crc16(req, req_length); + req[req_length++] = crc >> 8; + req[req_length++] = crc & 0x00FF; + + return req_length; +} + +#if defined(_WIN32) + +/* This simple implementation is sort of a substitute of the select() call, + * working this way: the win32_ser_select() call tries to read some data from + * the serial port, setting the timeout as the select() call would. Data read is + * stored into the receive buffer, that is then consumed by the win32_ser_read() + * call. So win32_ser_select() does both the event waiting and the reading, + * while win32_ser_read() only consumes the receive buffer. + */ + +static void win32_ser_init(struct win32_ser *ws) +{ + /* Clear everything */ + memset(ws, 0x00, sizeof(struct win32_ser)); + + /* Set file handle to invalid */ + ws->fd = INVALID_HANDLE_VALUE; +} + +/* FIXME Try to remove length_to_read -> max_len argument, only used by win32 */ +static int win32_ser_select(struct win32_ser *ws, int max_len, + const struct timeval *tv) +{ + COMMTIMEOUTS comm_to; + unsigned int msec = 0; + + /* Check if some data still in the buffer to be consumed */ + if (ws->n_bytes > 0) { + return 1; + } + + /* Setup timeouts like select() would do. + FIXME Please someone on Windows can look at this? + Does it possible to use WaitCommEvent? + When tv is NULL, MAXDWORD isn't infinite! + */ + if (tv == NULL) { + msec = MAXDWORD; + } else { + msec = tv->tv_sec * 1000 + tv->tv_usec / 1000; + if (msec < 1) + msec = 1; + } + + comm_to.ReadIntervalTimeout = msec; + comm_to.ReadTotalTimeoutMultiplier = 0; + comm_to.ReadTotalTimeoutConstant = msec; + comm_to.WriteTotalTimeoutMultiplier = 0; + comm_to.WriteTotalTimeoutConstant = 1000; + SetCommTimeouts(ws->fd, &comm_to); + + /* Read some bytes */ + if ((max_len > PY_BUF_SIZE) || (max_len < 0)) { + max_len = PY_BUF_SIZE; + } + + if (ReadFile(ws->fd, &ws->buf, max_len, &ws->n_bytes, NULL)) { + /* Check if some bytes available */ + if (ws->n_bytes > 0) { + /* Some bytes read */ + return 1; + } else { + /* Just timed out */ + return 0; + } + } else { + /* Some kind of error */ + return -1; + } +} + +static int win32_ser_read(struct win32_ser *ws, uint8_t *p_msg, + unsigned int max_len) +{ + unsigned int n = ws->n_bytes; + + if (max_len < n) { + n = max_len; + } + + if (n > 0) { + memcpy(p_msg, ws->buf, n); + } + + ws->n_bytes -= n; + + return n; +} +#endif + +#if HAVE_DECL_TIOCM_RTS +static void _modbus_rtu_ioctl_rts(modbus_t *ctx, int on) +{ + int fd = ctx->s; + int flags; + + ioctl(fd, TIOCMGET, &flags); + if (on) { + flags |= TIOCM_RTS; + } else { + flags &= ~TIOCM_RTS; + } + ioctl(fd, TIOCMSET, &flags); +} +#endif + +static ssize_t _modbus_rtu_send(modbus_t *ctx, const uint8_t *req, int req_length) +{ +#if defined(_WIN32) + modbus_rtu_t *ctx_rtu = ctx->backend_data; + DWORD n_bytes = 0; + return (WriteFile(ctx_rtu->w_ser.fd, req, req_length, &n_bytes, NULL)) ? (ssize_t)n_bytes : -1; +#else +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + if (ctx_rtu->rts != MODBUS_RTU_RTS_NONE) { + ssize_t size; + + if (ctx->debug) { + fprintf(stderr, "Sending request using RTS signal\n"); + } + + ctx_rtu->set_rts(ctx, ctx_rtu->rts == MODBUS_RTU_RTS_UP); + usleep(ctx_rtu->rts_delay); + + size = write(ctx->s, req, req_length); + + usleep(ctx_rtu->onebyte_time * req_length + ctx_rtu->rts_delay); + ctx_rtu->set_rts(ctx, ctx_rtu->rts != MODBUS_RTU_RTS_UP); + + return size; + } else { +#endif + return write(ctx->s, req, req_length); +#if HAVE_DECL_TIOCM_RTS + } +#endif +#endif +} + +static int _modbus_rtu_receive(modbus_t *ctx, uint8_t *req) +{ + int rc; + modbus_rtu_t *ctx_rtu = ctx->backend_data; + + if (ctx_rtu->confirmation_to_ignore) { + _modbus_receive_msg(ctx, req, MSG_CONFIRMATION); + /* Ignore errors and reset the flag */ + ctx_rtu->confirmation_to_ignore = FALSE; + rc = 0; + if (ctx->debug) { + printf("Confirmation to ignore\n"); + } + } else { + rc = _modbus_receive_msg(ctx, req, MSG_INDICATION); + if (rc == 0) { + /* The next expected message is a confirmation to ignore */ + ctx_rtu->confirmation_to_ignore = TRUE; + } + } + return rc; +} + +static ssize_t _modbus_rtu_recv(modbus_t *ctx, uint8_t *rsp, int rsp_length) +{ +#if defined(_WIN32) + return win32_ser_read(&((modbus_rtu_t *)ctx->backend_data)->w_ser, rsp, rsp_length); +#else + return read(ctx->s, rsp, rsp_length); +#endif +} + +static int _modbus_rtu_flush(modbus_t *); + +static int _modbus_rtu_pre_check_confirmation(modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length) +{ + /* Check responding slave is the slave we requested (except for broacast + * request) */ + if (req[0] != rsp[0] && req[0] != MODBUS_BROADCAST_ADDRESS) { + if (ctx->debug) { + fprintf(stderr, + "The responding slave %d isn't the requested slave %d\n", + rsp[0], req[0]); + } + errno = EMBBADSLAVE; + return -1; + } else { + return 0; + } +} + +/* The check_crc16 function shall return 0 is the message is ignored and the + message length if the CRC is valid. Otherwise it shall return -1 and set + errno to EMBBADCRC. */ +static int _modbus_rtu_check_integrity(modbus_t *ctx, uint8_t *msg, + const int msg_length) +{ + uint16_t crc_calculated; + uint16_t crc_received; + int slave = msg[0]; + + /* Filter on the Modbus unit identifier (slave) in RTU mode to avoid useless + * CRC computing. */ + if (slave != ctx->slave && slave != MODBUS_BROADCAST_ADDRESS) { + if (ctx->debug) { + printf("Request for slave %d ignored (not %d)\n", slave, ctx->slave); + } + /* Following call to check_confirmation handles this error */ + return 0; + } + + crc_calculated = crc16(msg, msg_length - 2); + crc_received = (msg[msg_length - 2] << 8) | msg[msg_length - 1]; + + /* Check CRC of msg */ + if (crc_calculated == crc_received) { + return msg_length; + } else { + if (ctx->debug) { + fprintf(stderr, "ERROR CRC received 0x%0X != CRC calculated 0x%0X\n", + crc_received, crc_calculated); + } + + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _modbus_rtu_flush(ctx); + } + errno = EMBBADCRC; + return -1; + } +} + +/* Sets up a serial port for RTU communications */ +static int _modbus_rtu_connect(modbus_t *ctx) +{ +#if defined(_WIN32) + DCB dcb; +#else + struct termios tios; + speed_t speed; + int flags; +#endif + modbus_rtu_t *ctx_rtu = ctx->backend_data; + + if (ctx->debug) { + printf("Opening %s at %d bauds (%c, %d, %d)\n", + ctx_rtu->device, ctx_rtu->baud, ctx_rtu->parity, + ctx_rtu->data_bit, ctx_rtu->stop_bit); + } + +#if defined(_WIN32) + /* Some references here: + * http://msdn.microsoft.com/en-us/library/aa450602.aspx + */ + win32_ser_init(&ctx_rtu->w_ser); + + /* ctx_rtu->device should contain a string like "COMxx:" xx being a decimal + * number */ + ctx_rtu->w_ser.fd = CreateFileA(ctx_rtu->device, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + 0, + NULL); + + /* Error checking */ + if (ctx_rtu->w_ser.fd == INVALID_HANDLE_VALUE) { + if (ctx->debug) { + fprintf(stderr, "ERROR Can't open the device %s (LastError %d)\n", + ctx_rtu->device, (int)GetLastError()); + } + return -1; + } + + /* Save params */ + ctx_rtu->old_dcb.DCBlength = sizeof(DCB); + if (!GetCommState(ctx_rtu->w_ser.fd, &ctx_rtu->old_dcb)) { + if (ctx->debug) { + fprintf(stderr, "ERROR Error getting configuration (LastError %d)\n", + (int)GetLastError()); + } + CloseHandle(ctx_rtu->w_ser.fd); + ctx_rtu->w_ser.fd = INVALID_HANDLE_VALUE; + return -1; + } + + /* Build new configuration (starting from current settings) */ + dcb = ctx_rtu->old_dcb; + + /* Speed setting */ + switch (ctx_rtu->baud) { + case 110: + dcb.BaudRate = CBR_110; + break; + case 300: + dcb.BaudRate = CBR_300; + break; + case 600: + dcb.BaudRate = CBR_600; + break; + case 1200: + dcb.BaudRate = CBR_1200; + break; + case 2400: + dcb.BaudRate = CBR_2400; + break; + case 4800: + dcb.BaudRate = CBR_4800; + break; + case 9600: + dcb.BaudRate = CBR_9600; + break; + case 14400: + dcb.BaudRate = CBR_14400; + break; + case 19200: + dcb.BaudRate = CBR_19200; + break; + case 38400: + dcb.BaudRate = CBR_38400; + break; + case 57600: + dcb.BaudRate = CBR_57600; + break; + case 115200: + dcb.BaudRate = CBR_115200; + break; + case 230400: + /* CBR_230400 - not defined */ + dcb.BaudRate = 230400; + break; + case 250000: + dcb.BaudRate = 250000; + break; + case 460800: + dcb.BaudRate = 460800; + break; + case 500000: + dcb.BaudRate = 500000; + break; + case 921600: + dcb.BaudRate = 921600; + break; + case 1000000: + dcb.BaudRate = 1000000; + break; + default: + dcb.BaudRate = CBR_9600; + if (ctx->debug) { + fprintf(stderr, "WARNING Unknown baud rate %d for %s (B9600 used)\n", + ctx_rtu->baud, ctx_rtu->device); + } + } + + /* Data bits */ + switch (ctx_rtu->data_bit) { + case 5: + dcb.ByteSize = 5; + break; + case 6: + dcb.ByteSize = 6; + break; + case 7: + dcb.ByteSize = 7; + break; + case 8: + default: + dcb.ByteSize = 8; + break; + } + + /* Stop bits */ + if (ctx_rtu->stop_bit == 1) + dcb.StopBits = ONESTOPBIT; + else /* 2 */ + dcb.StopBits = TWOSTOPBITS; + + /* Parity */ + if (ctx_rtu->parity == 'N') { + dcb.Parity = NOPARITY; + dcb.fParity = FALSE; + } else if (ctx_rtu->parity == 'E') { + dcb.Parity = EVENPARITY; + dcb.fParity = TRUE; + } else { + /* odd */ + dcb.Parity = ODDPARITY; + dcb.fParity = TRUE; + } + + /* Hardware handshaking left as default settings retrieved */ + + /* No software handshaking */ + dcb.fTXContinueOnXoff = TRUE; + dcb.fOutX = FALSE; + dcb.fInX = FALSE; + + /* Binary mode (it's the only supported on Windows anyway) */ + dcb.fBinary = TRUE; + + /* Don't want errors to be blocking */ + dcb.fAbortOnError = FALSE; + + /* Setup port */ + if (!SetCommState(ctx_rtu->w_ser.fd, &dcb)) { + if (ctx->debug) { + fprintf(stderr, "ERROR Error setting new configuration (LastError %d)\n", + (int)GetLastError()); + } + CloseHandle(ctx_rtu->w_ser.fd); + ctx_rtu->w_ser.fd = INVALID_HANDLE_VALUE; + return -1; + } +#else + /* The O_NOCTTY flag tells UNIX that this program doesn't want + to be the "controlling terminal" for that port. If you + don't specify this then any input (such as keyboard abort + signals and so forth) will affect your process + + Timeouts are ignored in canonical input mode or when the + NDELAY option is set on the file via open or fcntl */ + flags = O_RDWR | O_NOCTTY | O_NDELAY | O_EXCL; +#ifdef O_CLOEXEC + flags |= O_CLOEXEC; +#endif + + ctx->s = open(ctx_rtu->device, flags); + if (ctx->s == -1) { + if (ctx->debug) { + fprintf(stderr, "ERROR Can't open the device %s (%s)\n", + ctx_rtu->device, strerror(errno)); + } + return -1; + } + + /* Save */ + tcgetattr(ctx->s, &ctx_rtu->old_tios); + + memset(&tios, 0, sizeof(struct termios)); + + /* C_ISPEED Input baud (new interface) + C_OSPEED Output baud (new interface) + */ + switch (ctx_rtu->baud) { + case 110: + speed = B110; + break; + case 300: + speed = B300; + break; + case 600: + speed = B600; + break; + case 1200: + speed = B1200; + break; + case 2400: + speed = B2400; + break; + case 4800: + speed = B4800; + break; + case 9600: + speed = B9600; + break; + case 19200: + speed = B19200; + break; + case 38400: + speed = B38400; + break; +#ifdef B57600 + case 57600: + speed = B57600; + break; +#endif +#ifdef B115200 + case 115200: + speed = B115200; + break; +#endif +#ifdef B230400 + case 230400: + speed = B230400; + break; +#endif +#ifdef B460800 + case 460800: + speed = B460800; + break; +#endif +#ifdef B500000 + case 500000: + speed = B500000; + break; +#endif +#ifdef B576000 + case 576000: + speed = B576000; + break; +#endif +#ifdef B921600 + case 921600: + speed = B921600; + break; +#endif +#ifdef B1000000 + case 1000000: + speed = B1000000; + break; +#endif +#ifdef B1152000 + case 1152000: + speed = B1152000; + break; +#endif +#ifdef B1500000 + case 1500000: + speed = B1500000; + break; +#endif +#ifdef B2500000 + case 2500000: + speed = B2500000; + break; +#endif +#ifdef B3000000 + case 3000000: + speed = B3000000; + break; +#endif +#ifdef B3500000 + case 3500000: + speed = B3500000; + break; +#endif +#ifdef B4000000 + case 4000000: + speed = B4000000; + break; +#endif + default: + speed = B9600; + if (ctx->debug) { + fprintf(stderr, + "WARNING Unknown baud rate %d for %s (B9600 used)\n", + ctx_rtu->baud, ctx_rtu->device); + } + } + + /* Set the baud rate */ + if ((cfsetispeed(&tios, speed) < 0) || + (cfsetospeed(&tios, speed) < 0)) { + close(ctx->s); + ctx->s = -1; + return -1; + } + + /* C_CFLAG Control options + CLOCAL Local line - do not change "owner" of port + CREAD Enable receiver + */ + tios.c_cflag |= (CREAD | CLOCAL); + /* CSIZE, HUPCL, CRTSCTS (hardware flow control) */ + + /* Set data bits (5, 6, 7, 8 bits) + CSIZE Bit mask for data bits + */ + tios.c_cflag &= ~CSIZE; + switch (ctx_rtu->data_bit) { + case 5: + tios.c_cflag |= CS5; + break; + case 6: + tios.c_cflag |= CS6; + break; + case 7: + tios.c_cflag |= CS7; + break; + case 8: + default: + tios.c_cflag |= CS8; + break; + } + + /* Stop bit (1 or 2) */ + if (ctx_rtu->stop_bit == 1) + tios.c_cflag &=~ CSTOPB; + else /* 2 */ + tios.c_cflag |= CSTOPB; + + /* PARENB Enable parity bit + PARODD Use odd parity instead of even */ + if (ctx_rtu->parity == 'N') { + /* None */ + tios.c_cflag &=~ PARENB; + } else if (ctx_rtu->parity == 'E') { + /* Even */ + tios.c_cflag |= PARENB; + tios.c_cflag &=~ PARODD; + } else { + /* Odd */ + tios.c_cflag |= PARENB; + tios.c_cflag |= PARODD; + } + + /* Read the man page of termios if you need more information. */ + + /* This field isn't used on POSIX systems + tios.c_line = 0; + */ + + /* C_LFLAG Line options + + ISIG Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals + ICANON Enable canonical input (else raw) + XCASE Map uppercase \lowercase (obsolete) + ECHO Enable echoing of input characters + ECHOE Echo erase character as BS-SP-BS + ECHOK Echo NL after kill character + ECHONL Echo NL + NOFLSH Disable flushing of input buffers after + interrupt or quit characters + IEXTEN Enable extended functions + ECHOCTL Echo control characters as ^char and delete as ~? + ECHOPRT Echo erased character as character erased + ECHOKE BS-SP-BS entire line on line kill + FLUSHO Output being flushed + PENDIN Retype pending input at next read or input char + TOSTOP Send SIGTTOU for background output + + Canonical input is line-oriented. Input characters are put + into a buffer which can be edited interactively by the user + until a CR (carriage return) or LF (line feed) character is + received. + + Raw input is unprocessed. Input characters are passed + through exactly as they are received, when they are + received. Generally you'll deselect the ICANON, ECHO, + ECHOE, and ISIG options when using raw input + */ + + /* Raw input */ + tios.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); + + /* C_IFLAG Input options + + Constant Description + INPCK Enable parity check + IGNPAR Ignore parity errors + PARMRK Mark parity errors + ISTRIP Strip parity bits + IXON Enable software flow control (outgoing) + IXOFF Enable software flow control (incoming) + IXANY Allow any character to start flow again + IGNBRK Ignore break condition + BRKINT Send a SIGINT when a break condition is detected + INLCR Map NL to CR + IGNCR Ignore CR + ICRNL Map CR to NL + IUCLC Map uppercase to lowercase + IMAXBEL Echo BEL on input line too long + */ + if (ctx_rtu->parity == 'N') { + /* None */ + tios.c_iflag &= ~INPCK; + } else { + tios.c_iflag |= INPCK; + } + + /* Software flow control is disabled */ + tios.c_iflag &= ~(IXON | IXOFF | IXANY); + + /* C_OFLAG Output options + OPOST Postprocess output (not set = raw output) + ONLCR Map NL to CR-NL + + ONCLR ant others needs OPOST to be enabled + */ + + /* Raw ouput */ + tios.c_oflag &=~ OPOST; + + /* C_CC Control characters + VMIN Minimum number of characters to read + VTIME Time to wait for data (tenths of seconds) + + UNIX serial interface drivers provide the ability to + specify character and packet timeouts. Two elements of the + c_cc array are used for timeouts: VMIN and VTIME. Timeouts + are ignored in canonical input mode or when the NDELAY + option is set on the file via open or fcntl. + + VMIN specifies the minimum number of characters to read. If + it is set to 0, then the VTIME value specifies the time to + wait for every character read. Note that this does not mean + that a read call for N bytes will wait for N characters to + come in. Rather, the timeout will apply to the first + character and the read call will return the number of + characters immediately available (up to the number you + request). + + If VMIN is non-zero, VTIME specifies the time to wait for + the first character read. If a character is read within the + time given, any read will block (wait) until all VMIN + characters are read. That is, once the first character is + read, the serial interface driver expects to receive an + entire packet of characters (VMIN bytes total). If no + character is read within the time allowed, then the call to + read returns 0. This method allows you to tell the serial + driver you need exactly N bytes and any read call will + return 0 or N bytes. However, the timeout only applies to + the first character read, so if for some reason the driver + misses one character inside the N byte packet then the read + call could block forever waiting for additional input + characters. + + VTIME specifies the amount of time to wait for incoming + characters in tenths of seconds. If VTIME is set to 0 (the + default), reads will block (wait) indefinitely unless the + NDELAY option is set on the port with open or fcntl. + */ + /* Unused because we use open with the NDELAY option */ + tios.c_cc[VMIN] = 0; + tios.c_cc[VTIME] = 0; + + if (tcsetattr(ctx->s, TCSANOW, &tios) < 0) { + close(ctx->s); + ctx->s = -1; + return -1; + } +#endif + + return 0; +} + +int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCSRS485 + modbus_rtu_t *ctx_rtu = ctx->backend_data; + struct serial_rs485 rs485conf; + + if (mode == MODBUS_RTU_RS485) { + // Get + if (ioctl(ctx->s, TIOCGRS485, &rs485conf) < 0) { + return -1; + } + // Set + rs485conf.flags |= SER_RS485_ENABLED; + if (ioctl(ctx->s, TIOCSRS485, &rs485conf) < 0) { + return -1; + } + + ctx_rtu->serial_mode = MODBUS_RTU_RS485; + return 0; + } else if (mode == MODBUS_RTU_RS232) { + /* Turn off RS485 mode only if required */ + if (ctx_rtu->serial_mode == MODBUS_RTU_RS485) { + /* The ioctl call is avoided because it can fail on some RS232 ports */ + if (ioctl(ctx->s, TIOCGRS485, &rs485conf) < 0) { + return -1; + } + rs485conf.flags &= ~SER_RS485_ENABLED; + if (ioctl(ctx->s, TIOCSRS485, &rs485conf) < 0) { + return -1; + } + } + ctx_rtu->serial_mode = MODBUS_RTU_RS232; + return 0; + } +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } + + /* Wrong backend and invalid mode specified */ + errno = EINVAL; + return -1; +} + +int modbus_rtu_get_serial_mode(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCSRS485 + modbus_rtu_t *ctx_rtu = ctx->backend_data; + return ctx_rtu->serial_mode; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_get_rts(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + return ctx_rtu->rts; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_set_rts(modbus_t *ctx, int mode) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + + if (mode == MODBUS_RTU_RTS_NONE || mode == MODBUS_RTU_RTS_UP || + mode == MODBUS_RTU_RTS_DOWN) { + ctx_rtu->rts = mode; + + /* Set the RTS bit in order to not reserve the RS485 bus */ + ctx_rtu->set_rts(ctx, ctx_rtu->rts != MODBUS_RTU_RTS_UP); + + return 0; + } else { + errno = EINVAL; + return -1; + } +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } + /* Wrong backend or invalid mode specified */ + errno = EINVAL; + return -1; +} + +int modbus_rtu_set_custom_rts(modbus_t *ctx, void (*set_rts) (modbus_t *ctx, int on)) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu = ctx->backend_data; + ctx_rtu->set_rts = set_rts; + return 0; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_get_rts_delay(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu; + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + return ctx_rtu->rts_delay; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +int modbus_rtu_set_rts_delay(modbus_t *ctx, int us) +{ + if (ctx == NULL || us < 0) { + errno = EINVAL; + return -1; + } + + if (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU) { +#if HAVE_DECL_TIOCM_RTS + modbus_rtu_t *ctx_rtu; + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + ctx_rtu->rts_delay = us; + return 0; +#else + if (ctx->debug) { + fprintf(stderr, "This function isn't supported on your platform\n"); + } + errno = ENOTSUP; + return -1; +#endif + } else { + errno = EINVAL; + return -1; + } +} + +static void _modbus_rtu_close(modbus_t *ctx) +{ + /* Restore line settings and close file descriptor in RTU mode */ + modbus_rtu_t *ctx_rtu = ctx->backend_data; + +#if defined(_WIN32) + /* Revert settings */ + if (!SetCommState(ctx_rtu->w_ser.fd, &ctx_rtu->old_dcb) && ctx->debug) { + fprintf(stderr, "ERROR Couldn't revert to configuration (LastError %d)\n", + (int)GetLastError()); + } + + if (!CloseHandle(ctx_rtu->w_ser.fd) && ctx->debug) { + fprintf(stderr, "ERROR Error while closing handle (LastError %d)\n", + (int)GetLastError()); + } +#else + if (ctx->s != -1) { + tcsetattr(ctx->s, TCSANOW, &ctx_rtu->old_tios); + close(ctx->s); + ctx->s = -1; + } +#endif +} + +static int _modbus_rtu_flush(modbus_t *ctx) +{ +#if defined(_WIN32) + modbus_rtu_t *ctx_rtu = ctx->backend_data; + ctx_rtu->w_ser.n_bytes = 0; + return (PurgeComm(ctx_rtu->w_ser.fd, PURGE_RXCLEAR) == FALSE); +#else + return tcflush(ctx->s, TCIOFLUSH); +#endif +} + +static int _modbus_rtu_select(modbus_t *ctx, fd_set *rset, + struct timeval *tv, int length_to_read) +{ + int s_rc; +#if defined(_WIN32) + s_rc = win32_ser_select(&((modbus_rtu_t *)ctx->backend_data)->w_ser, + length_to_read, tv); + if (s_rc == 0) { + errno = ETIMEDOUT; + return -1; + } + + if (s_rc < 0) { + return -1; + } +#else + while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) { + if (errno == EINTR) { + if (ctx->debug) { + fprintf(stderr, "A non blocked signal was caught\n"); + } + /* Necessary after an error */ + FD_ZERO(rset); + FD_SET(ctx->s, rset); + } else { + return -1; + } + } + + if (s_rc == 0) { + /* Timeout */ + errno = ETIMEDOUT; + return -1; + } +#endif + + return s_rc; +} + +static void _modbus_rtu_free(modbus_t *ctx) { + if (ctx->backend_data) { + free(((modbus_rtu_t *)ctx->backend_data)->device); + free(ctx->backend_data); + } + + free(ctx); +} + +const modbus_backend_t _modbus_rtu_backend = { + _MODBUS_BACKEND_TYPE_RTU, + _MODBUS_RTU_HEADER_LENGTH, + _MODBUS_RTU_CHECKSUM_LENGTH, + MODBUS_RTU_MAX_ADU_LENGTH, + _modbus_set_slave, + _modbus_rtu_build_request_basis, + _modbus_rtu_build_response_basis, + _modbus_rtu_prepare_response_tid, + _modbus_rtu_send_msg_pre, + _modbus_rtu_send, + _modbus_rtu_receive, + _modbus_rtu_recv, + _modbus_rtu_check_integrity, + _modbus_rtu_pre_check_confirmation, + _modbus_rtu_connect, + _modbus_rtu_close, + _modbus_rtu_flush, + _modbus_rtu_select, + _modbus_rtu_free +}; + +modbus_t* modbus_new_rtu(const char *device, + int baud, char parity, int data_bit, + int stop_bit) +{ + modbus_t *ctx; + modbus_rtu_t *ctx_rtu; + + /* Check device argument */ + if (device == NULL || *device == 0) { + fprintf(stderr, "The device string is empty\n"); + errno = EINVAL; + return NULL; + } + + /* Check baud argument */ + if (baud == 0) { + fprintf(stderr, "The baud rate value must not be zero\n"); + errno = EINVAL; + return NULL; + } + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + if (ctx == NULL) { + return NULL; + } + + _modbus_init_common(ctx); + ctx->backend = &_modbus_rtu_backend; + ctx->backend_data = (modbus_rtu_t *)malloc(sizeof(modbus_rtu_t)); + if (ctx->backend_data == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + ctx_rtu = (modbus_rtu_t *)ctx->backend_data; + + /* Device name and \0 */ + ctx_rtu->device = (char *)malloc((strlen(device) + 1) * sizeof(char)); + if (ctx_rtu->device == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + strcpy(ctx_rtu->device, device); + + ctx_rtu->baud = baud; + if (parity == 'N' || parity == 'E' || parity == 'O') { + ctx_rtu->parity = parity; + } else { + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + ctx_rtu->data_bit = data_bit; + ctx_rtu->stop_bit = stop_bit; + +#if HAVE_DECL_TIOCSRS485 + /* The RS232 mode has been set by default */ + ctx_rtu->serial_mode = MODBUS_RTU_RS232; +#endif + +#if HAVE_DECL_TIOCM_RTS + /* The RTS use has been set by default */ + ctx_rtu->rts = MODBUS_RTU_RTS_NONE; + + /* Calculate estimated time in micro second to send one byte */ + ctx_rtu->onebyte_time = 1000000 * (1 + data_bit + (parity == 'N' ? 0 : 1) + stop_bit) / baud; + + /* The internal function is used by default to set RTS */ + ctx_rtu->set_rts = _modbus_rtu_ioctl_rts; + + /* The delay before and after transmission when toggling the RTS pin */ + ctx_rtu->rts_delay = ctx_rtu->onebyte_time; +#endif + + ctx_rtu->confirmation_to_ignore = FALSE; + + return ctx; +} diff --git a/src/modbus-rtu.h b/src/modbus-rtu.h new file mode 100644 index 0000000..214a888 --- /dev/null +++ b/src/modbus-rtu.h @@ -0,0 +1,42 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef MODBUS_RTU_H +#define MODBUS_RTU_H + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5 + * RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes + */ +#define MODBUS_RTU_MAX_ADU_LENGTH 256 + +MODBUS_API modbus_t* modbus_new_rtu(const char *device, int baud, char parity, + int data_bit, int stop_bit); + +#define MODBUS_RTU_RS232 0 +#define MODBUS_RTU_RS485 1 + +MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode); +MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx); + +#define MODBUS_RTU_RTS_NONE 0 +#define MODBUS_RTU_RTS_UP 1 +#define MODBUS_RTU_RTS_DOWN 2 + +MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode); +MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx); + +MODBUS_API int modbus_rtu_set_custom_rts(modbus_t *ctx, void (*set_rts) (modbus_t *ctx, int on)); + +MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us); +MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx); + +MODBUS_END_DECLS + +#endif /* MODBUS_RTU_H */ diff --git a/src/modbus-tcp-private.h b/src/modbus-tcp-private.h new file mode 100644 index 0000000..55edf26 --- /dev/null +++ b/src/modbus-tcp-private.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef MODBUS_TCP_PRIVATE_H +#define MODBUS_TCP_PRIVATE_H + +#define _MODBUS_TCP_HEADER_LENGTH 7 +#define _MODBUS_TCP_PRESET_REQ_LENGTH 12 +#define _MODBUS_TCP_PRESET_RSP_LENGTH 8 + +#define _MODBUS_TCP_CHECKSUM_LENGTH 0 + +/* In both structures, the transaction ID must be placed on first position + to have a quick access not dependant of the TCP backend */ +typedef struct _modbus_tcp { + /* Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b + (page 23/46): + The transaction identifier is used to associate the future response + with the request. This identifier is unique on each TCP connection. */ + uint16_t t_id; + /* TCP port */ + int port; + /* IP address */ + char ip[16]; +} modbus_tcp_t; + +#define _MODBUS_TCP_PI_NODE_LENGTH 1025 +#define _MODBUS_TCP_PI_SERVICE_LENGTH 32 + +typedef struct _modbus_tcp_pi { + /* Transaction ID */ + uint16_t t_id; + /* TCP port */ + int port; + /* Node */ + char node[_MODBUS_TCP_PI_NODE_LENGTH]; + /* Service */ + char service[_MODBUS_TCP_PI_SERVICE_LENGTH]; +} modbus_tcp_pi_t; + +#endif /* MODBUS_TCP_PRIVATE_H */ diff --git a/src/modbus-tcp.c b/src/modbus-tcp.c new file mode 100644 index 0000000..f8ef4e8 --- /dev/null +++ b/src/modbus-tcp.c @@ -0,0 +1,929 @@ +/* + * Copyright © 2001-2013 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#if defined(_WIN32) +# define OS_WIN32 +/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later. + * minwg32 headers check WINVER before allowing the use of these */ +# ifndef WINVER +# define WINVER 0x0501 +# endif +#endif + +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif +#include +#include + +#if defined(_WIN32) +/* Already set in modbus-tcp.h but it seems order matters in VS2005 */ +# include +# include +# define SHUT_RDWR 2 +# define close closesocket +#else +# include +# include + +#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ < 5) +# define OS_BSD +# include +#endif + +# include +# include +# include +# include +# include +#endif + +#if !defined(MSG_NOSIGNAL) +#define MSG_NOSIGNAL 0 +#endif + +#if defined(_AIX) && !defined(MSG_DONTWAIT) +#define MSG_DONTWAIT MSG_NONBLOCK +#endif + +#include "modbus-private.h" + +#include "modbus-tcp.h" +#include "modbus-tcp-private.h" + +#ifdef OS_WIN32 +static int _modbus_tcp_init_win32(void) +{ + /* Initialise Windows Socket API */ + WSADATA wsaData; + + if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) { + fprintf(stderr, "WSAStartup() returned error code %d\n", + (unsigned int)GetLastError()); + errno = EIO; + return -1; + } + return 0; +} +#endif + +static int _modbus_set_slave(modbus_t *ctx, int slave) +{ + /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */ + if (slave >= 0 && slave <= 247) { + ctx->slave = slave; + } else if (slave == MODBUS_TCP_SLAVE) { + /* The special value MODBUS_TCP_SLAVE (0xFF) can be used in TCP mode to + * restore the default value. */ + ctx->slave = slave; + } else { + errno = EINVAL; + return -1; + } + + return 0; +} + +/* Builds a TCP request header */ +static int _modbus_tcp_build_request_basis(modbus_t *ctx, int function, + int addr, int nb, + uint8_t *req) +{ + modbus_tcp_t *ctx_tcp = ctx->backend_data; + + /* Increase transaction ID */ + if (ctx_tcp->t_id < UINT16_MAX) + ctx_tcp->t_id++; + else + ctx_tcp->t_id = 0; + req[0] = ctx_tcp->t_id >> 8; + req[1] = ctx_tcp->t_id & 0x00ff; + + /* Protocol Modbus */ + req[2] = 0; + req[3] = 0; + + /* Length will be defined later by set_req_length_tcp at offsets 4 + and 5 */ + + req[6] = ctx->slave; + req[7] = function; + req[8] = addr >> 8; + req[9] = addr & 0x00ff; + req[10] = nb >> 8; + req[11] = nb & 0x00ff; + + return _MODBUS_TCP_PRESET_REQ_LENGTH; +} + +/* Builds a TCP response header */ +static int _modbus_tcp_build_response_basis(sft_t *sft, uint8_t *rsp) +{ + /* Extract from MODBUS Messaging on TCP/IP Implementation + Guide V1.0b (page 23/46): + The transaction identifier is used to associate the future + response with the request. */ + rsp[0] = sft->t_id >> 8; + rsp[1] = sft->t_id & 0x00ff; + + /* Protocol Modbus */ + rsp[2] = 0; + rsp[3] = 0; + + /* Length will be set later by send_msg (4 and 5) */ + + /* The slave ID is copied from the indication */ + rsp[6] = sft->slave; + rsp[7] = sft->function; + + return _MODBUS_TCP_PRESET_RSP_LENGTH; +} + + +static int _modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length) +{ + return (req[0] << 8) + req[1]; +} + +static int _modbus_tcp_send_msg_pre(uint8_t *req, int req_length) +{ + /* Substract the header length to the message length */ + int mbap_length = req_length - 6; + + req[4] = mbap_length >> 8; + req[5] = mbap_length & 0x00FF; + + return req_length; +} + +static ssize_t _modbus_tcp_send(modbus_t *ctx, const uint8_t *req, int req_length) +{ + /* MSG_NOSIGNAL + Requests not to send SIGPIPE on errors on stream oriented + sockets when the other end breaks the connection. The EPIPE + error is still returned. */ + return send(ctx->s, (const char *)req, req_length, MSG_NOSIGNAL); +} + +static int _modbus_tcp_receive(modbus_t *ctx, uint8_t *req) { + return _modbus_receive_msg(ctx, req, MSG_INDICATION); +} + +static ssize_t _modbus_tcp_recv(modbus_t *ctx, uint8_t *rsp, int rsp_length) { + return recv(ctx->s, (char *)rsp, rsp_length, 0); +} + +static int _modbus_tcp_check_integrity(modbus_t *ctx, uint8_t *msg, const int msg_length) +{ + return msg_length; +} + +static int _modbus_tcp_pre_check_confirmation(modbus_t *ctx, const uint8_t *req, + const uint8_t *rsp, int rsp_length) +{ + /* Check transaction ID */ + if (req[0] != rsp[0] || req[1] != rsp[1]) { + if (ctx->debug) { + fprintf(stderr, "Invalid transaction ID received 0x%X (not 0x%X)\n", + (rsp[0] << 8) + rsp[1], (req[0] << 8) + req[1]); + } + errno = EMBBADDATA; + return -1; + } + + /* Check protocol ID */ + if (rsp[2] != 0x0 && rsp[3] != 0x0) { + if (ctx->debug) { + fprintf(stderr, "Invalid protocol ID received 0x%X (not 0x0)\n", + (rsp[2] << 8) + rsp[3]); + } + errno = EMBBADDATA; + return -1; + } + + return 0; +} + +static int _modbus_tcp_set_ipv4_options(int s) +{ + int rc; + int option; + + /* Set the TCP no delay flag */ + /* SOL_TCP = IPPROTO_TCP */ + option = 1; + rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, + (const void *)&option, sizeof(int)); + if (rc == -1) { + return -1; + } + + /* If the OS does not offer SOCK_NONBLOCK, fall back to setting FIONBIO to + * make sockets non-blocking */ + /* Do not care about the return value, this is optional */ +#if !defined(SOCK_NONBLOCK) && defined(FIONBIO) +#ifdef OS_WIN32 + { + /* Setting FIONBIO expects an unsigned long according to MSDN */ + u_long loption = 1; + ioctlsocket(s, FIONBIO, &loption); + } +#else + option = 1; + ioctl(s, FIONBIO, &option); +#endif +#endif + +#ifndef OS_WIN32 + /** + * Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's + * necessary to workaround that problem. + **/ + /* Set the IP low delay option */ + option = IPTOS_LOWDELAY; + rc = setsockopt(s, IPPROTO_IP, IP_TOS, + (const void *)&option, sizeof(int)); + if (rc == -1) { + return -1; + } +#endif + + return 0; +} + +static int _connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, + const struct timeval *ro_tv) +{ + int rc = connect(sockfd, addr, addrlen); + +#ifdef OS_WIN32 + int wsaError = 0; + if (rc == -1) { + wsaError = WSAGetLastError(); + } + + if (wsaError == WSAEWOULDBLOCK || wsaError == WSAEINPROGRESS) { +#else + if (rc == -1 && errno == EINPROGRESS) { +#endif + fd_set wset; + int optval; + socklen_t optlen = sizeof(optval); + struct timeval tv = *ro_tv; + + /* Wait to be available in writing */ + FD_ZERO(&wset); + FD_SET(sockfd, &wset); + rc = select(sockfd + 1, NULL, &wset, NULL, &tv); + if (rc <= 0) { + /* Timeout or fail */ + return -1; + } + + /* The connection is established if SO_ERROR and optval are set to 0 */ + rc = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen); + if (rc == 0 && optval == 0) { + return 0; + } else { + errno = ECONNREFUSED; + return -1; + } + } + return rc; +} + +/* Establishes a modbus TCP connection with a Modbus server. */ +static int _modbus_tcp_connect(modbus_t *ctx) +{ + int rc; + /* Specialized version of sockaddr for Internet socket address (same size) */ + struct sockaddr_in addr; + modbus_tcp_t *ctx_tcp = ctx->backend_data; + int flags = SOCK_STREAM; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + +#ifdef SOCK_NONBLOCK + flags |= SOCK_NONBLOCK; +#endif + + ctx->s = socket(PF_INET, flags, 0); + if (ctx->s == -1) { + return -1; + } + + rc = _modbus_tcp_set_ipv4_options(ctx->s); + if (rc == -1) { + close(ctx->s); + ctx->s = -1; + return -1; + } + + if (ctx->debug) { + printf("Connecting to %s:%d\n", ctx_tcp->ip, ctx_tcp->port); + } + + addr.sin_family = AF_INET; + addr.sin_port = htons(ctx_tcp->port); + addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip); + rc = _connect(ctx->s, (struct sockaddr *)&addr, sizeof(addr), &ctx->response_timeout); + if (rc == -1) { + close(ctx->s); + ctx->s = -1; + return -1; + } + + return 0; +} + +/* Establishes a modbus TCP PI connection with a Modbus server. */ +static int _modbus_tcp_pi_connect(modbus_t *ctx) +{ + int rc; + struct addrinfo *ai_list; + struct addrinfo *ai_ptr; + struct addrinfo ai_hints; + modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + + memset(&ai_hints, 0, sizeof(ai_hints)); +#ifdef AI_ADDRCONFIG + ai_hints.ai_flags |= AI_ADDRCONFIG; +#endif + ai_hints.ai_family = AF_UNSPEC; + ai_hints.ai_socktype = SOCK_STREAM; + ai_hints.ai_addr = NULL; + ai_hints.ai_canonname = NULL; + ai_hints.ai_next = NULL; + + ai_list = NULL; + rc = getaddrinfo(ctx_tcp_pi->node, ctx_tcp_pi->service, + &ai_hints, &ai_list); + if (rc != 0) { + if (ctx->debug) { + fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc)); + } + errno = ECONNREFUSED; + return -1; + } + + for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) { + int flags = ai_ptr->ai_socktype; + int s; + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + +#ifdef SOCK_NONBLOCK + flags |= SOCK_NONBLOCK; +#endif + + s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol); + if (s < 0) + continue; + + if (ai_ptr->ai_family == AF_INET) + _modbus_tcp_set_ipv4_options(s); + + if (ctx->debug) { + printf("Connecting to [%s]:%s\n", ctx_tcp_pi->node, ctx_tcp_pi->service); + } + + rc = _connect(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen, &ctx->response_timeout); + if (rc == -1) { + close(s); + continue; + } + + ctx->s = s; + break; + } + + freeaddrinfo(ai_list); + + if (ctx->s < 0) { + return -1; + } + + return 0; +} + +/* Closes the network connection and socket in TCP mode */ +static void _modbus_tcp_close(modbus_t *ctx) +{ + if (ctx->s != -1) { + shutdown(ctx->s, SHUT_RDWR); + close(ctx->s); + ctx->s = -1; + } +} + +static int _modbus_tcp_flush(modbus_t *ctx) +{ + int rc; + int rc_sum = 0; + + do { + /* Extract the garbage from the socket */ + char devnull[MODBUS_TCP_MAX_ADU_LENGTH]; +#ifndef OS_WIN32 + rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT); +#else + /* On Win32, it's a bit more complicated to not wait */ + fd_set rset; + struct timeval tv; + + tv.tv_sec = 0; + tv.tv_usec = 0; + FD_ZERO(&rset); + FD_SET(ctx->s, &rset); + rc = select(ctx->s+1, &rset, NULL, NULL, &tv); + if (rc == -1) { + return -1; + } + + if (rc == 1) { + /* There is data to flush */ + rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, 0); + } +#endif + if (rc > 0) { + rc_sum += rc; + } + } while (rc == MODBUS_TCP_MAX_ADU_LENGTH); + + return rc_sum; +} + +/* Listens for any request from one or many modbus masters in TCP */ +int modbus_tcp_listen(modbus_t *ctx, int nb_connection) +{ + int new_s; + int enable; + int flags; + struct sockaddr_in addr; + modbus_tcp_t *ctx_tcp; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx_tcp = ctx->backend_data; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + + flags = SOCK_STREAM; + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + + new_s = socket(PF_INET, flags, IPPROTO_TCP); + if (new_s == -1) { + return -1; + } + + enable = 1; + if (setsockopt(new_s, SOL_SOCKET, SO_REUSEADDR, + (char *)&enable, sizeof(enable)) == -1) { + close(new_s); + return -1; + } + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + /* If the modbus port is < to 1024, we need the setuid root. */ + addr.sin_port = htons(ctx_tcp->port); + if (ctx_tcp->ip[0] == '0') { + /* Listen any addresses */ + addr.sin_addr.s_addr = htonl(INADDR_ANY); + } else { + /* Listen only specified IP address */ + addr.sin_addr.s_addr = inet_addr(ctx_tcp->ip); + } + if (bind(new_s, (struct sockaddr *)&addr, sizeof(addr)) == -1) { + close(new_s); + return -1; + } + + if (listen(new_s, nb_connection) == -1) { + close(new_s); + return -1; + } + + return new_s; +} + +int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection) +{ + int rc; + struct addrinfo *ai_list; + struct addrinfo *ai_ptr; + struct addrinfo ai_hints; + const char *node; + const char *service; + int new_s; + modbus_tcp_pi_t *ctx_tcp_pi; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx_tcp_pi = ctx->backend_data; + +#ifdef OS_WIN32 + if (_modbus_tcp_init_win32() == -1) { + return -1; + } +#endif + + if (ctx_tcp_pi->node[0] == 0) { + node = NULL; /* == any */ + } else { + node = ctx_tcp_pi->node; + } + + if (ctx_tcp_pi->service[0] == 0) { + service = "502"; + } else { + service = ctx_tcp_pi->service; + } + + memset(&ai_hints, 0, sizeof (ai_hints)); + /* If node is not NULL, than the AI_PASSIVE flag is ignored. */ + ai_hints.ai_flags |= AI_PASSIVE; +#ifdef AI_ADDRCONFIG + ai_hints.ai_flags |= AI_ADDRCONFIG; +#endif + ai_hints.ai_family = AF_UNSPEC; + ai_hints.ai_socktype = SOCK_STREAM; + ai_hints.ai_addr = NULL; + ai_hints.ai_canonname = NULL; + ai_hints.ai_next = NULL; + + ai_list = NULL; + rc = getaddrinfo(node, service, &ai_hints, &ai_list); + if (rc != 0) { + if (ctx->debug) { + fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc)); + } + errno = ECONNREFUSED; + return -1; + } + + new_s = -1; + for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) { + int flags = ai_ptr->ai_socktype; + int s; + +#ifdef SOCK_CLOEXEC + flags |= SOCK_CLOEXEC; +#endif + + s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol); + if (s < 0) { + if (ctx->debug) { + perror("socket"); + } + continue; + } else { + int enable = 1; + rc = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, + (void *)&enable, sizeof (enable)); + if (rc != 0) { + close(s); + if (ctx->debug) { + perror("setsockopt"); + } + continue; + } + } + + rc = bind(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen); + if (rc != 0) { + close(s); + if (ctx->debug) { + perror("bind"); + } + continue; + } + + rc = listen(s, nb_connection); + if (rc != 0) { + close(s); + if (ctx->debug) { + perror("listen"); + } + continue; + } + + new_s = s; + break; + } + freeaddrinfo(ai_list); + + if (new_s < 0) { + return -1; + } + + return new_s; +} + +int modbus_tcp_accept(modbus_t *ctx, int *s) +{ + struct sockaddr_in addr; + socklen_t addrlen; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + addrlen = sizeof(addr); +#ifdef HAVE_ACCEPT4 + /* Inherit socket flags and use accept4 call */ + ctx->s = accept4(*s, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC); +#else + ctx->s = accept(*s, (struct sockaddr *)&addr, &addrlen); +#endif + + if (ctx->s == -1) { + return -1; + } + + if (ctx->debug) { + printf("The client connection from %s is accepted\n", + inet_ntoa(addr.sin_addr)); + } + + return ctx->s; +} + +int modbus_tcp_pi_accept(modbus_t *ctx, int *s) +{ + struct sockaddr_storage addr; + socklen_t addrlen; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + addrlen = sizeof(addr); +#ifdef HAVE_ACCEPT4 + /* Inherit socket flags and use accept4 call */ + ctx->s = accept4(*s, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC); +#else + ctx->s = accept(*s, (struct sockaddr *)&addr, &addrlen); +#endif + + if (ctx->s == -1) { + return -1; + } + + if (ctx->debug) { + printf("The client connection is accepted.\n"); + } + + return ctx->s; +} + +static int _modbus_tcp_select(modbus_t *ctx, fd_set *rset, struct timeval *tv, int length_to_read) +{ + int s_rc; + while ((s_rc = select(ctx->s+1, rset, NULL, NULL, tv)) == -1) { + if (errno == EINTR) { + if (ctx->debug) { + fprintf(stderr, "A non blocked signal was caught\n"); + } + /* Necessary after an error */ + FD_ZERO(rset); + FD_SET(ctx->s, rset); + } else { + return -1; + } + } + + if (s_rc == 0) { + errno = ETIMEDOUT; + return -1; + } + + return s_rc; +} + +static void _modbus_tcp_free(modbus_t *ctx) { + free(ctx->backend_data); + free(ctx); +} + +const modbus_backend_t _modbus_tcp_backend = { + _MODBUS_BACKEND_TYPE_TCP, + _MODBUS_TCP_HEADER_LENGTH, + _MODBUS_TCP_CHECKSUM_LENGTH, + MODBUS_TCP_MAX_ADU_LENGTH, + _modbus_set_slave, + _modbus_tcp_build_request_basis, + _modbus_tcp_build_response_basis, + _modbus_tcp_prepare_response_tid, + _modbus_tcp_send_msg_pre, + _modbus_tcp_send, + _modbus_tcp_receive, + _modbus_tcp_recv, + _modbus_tcp_check_integrity, + _modbus_tcp_pre_check_confirmation, + _modbus_tcp_connect, + _modbus_tcp_close, + _modbus_tcp_flush, + _modbus_tcp_select, + _modbus_tcp_free +}; + + +const modbus_backend_t _modbus_tcp_pi_backend = { + _MODBUS_BACKEND_TYPE_TCP, + _MODBUS_TCP_HEADER_LENGTH, + _MODBUS_TCP_CHECKSUM_LENGTH, + MODBUS_TCP_MAX_ADU_LENGTH, + _modbus_set_slave, + _modbus_tcp_build_request_basis, + _modbus_tcp_build_response_basis, + _modbus_tcp_prepare_response_tid, + _modbus_tcp_send_msg_pre, + _modbus_tcp_send, + _modbus_tcp_receive, + _modbus_tcp_recv, + _modbus_tcp_check_integrity, + _modbus_tcp_pre_check_confirmation, + _modbus_tcp_pi_connect, + _modbus_tcp_close, + _modbus_tcp_flush, + _modbus_tcp_select, + _modbus_tcp_free +}; + +modbus_t* modbus_new_tcp(const char *ip, int port) +{ + modbus_t *ctx; + modbus_tcp_t *ctx_tcp; + size_t dest_size; + size_t ret_size; + +#if defined(OS_BSD) + /* MSG_NOSIGNAL is unsupported on *BSD so we install an ignore + handler for SIGPIPE. */ + struct sigaction sa; + + sa.sa_handler = SIG_IGN; + if (sigaction(SIGPIPE, &sa, NULL) < 0) { + /* The debug flag can't be set here... */ + fprintf(stderr, "Could not install SIGPIPE handler.\n"); + return NULL; + } +#endif + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + if (ctx == NULL) { + return NULL; + } + _modbus_init_common(ctx); + + /* Could be changed after to reach a remote serial Modbus device */ + ctx->slave = MODBUS_TCP_SLAVE; + + ctx->backend = &_modbus_tcp_backend; + + ctx->backend_data = (modbus_tcp_t *)malloc(sizeof(modbus_tcp_t)); + if (ctx->backend_data == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + ctx_tcp = (modbus_tcp_t *)ctx->backend_data; + + if (ip != NULL) { + dest_size = sizeof(char) * 16; + ret_size = strlcpy(ctx_tcp->ip, ip, dest_size); + if (ret_size == 0) { + fprintf(stderr, "The IP string is empty\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + if (ret_size >= dest_size) { + fprintf(stderr, "The IP string has been truncated\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + } else { + ctx_tcp->ip[0] = '0'; + } + ctx_tcp->port = port; + ctx_tcp->t_id = 0; + + return ctx; +} + + +modbus_t* modbus_new_tcp_pi(const char *node, const char *service) +{ + modbus_t *ctx; + modbus_tcp_pi_t *ctx_tcp_pi; + size_t dest_size; + size_t ret_size; + + ctx = (modbus_t *)malloc(sizeof(modbus_t)); + if (ctx == NULL) { + return NULL; + } + _modbus_init_common(ctx); + + /* Could be changed after to reach a remote serial Modbus device */ + ctx->slave = MODBUS_TCP_SLAVE; + + ctx->backend = &_modbus_tcp_pi_backend; + + ctx->backend_data = (modbus_tcp_pi_t *)malloc(sizeof(modbus_tcp_pi_t)); + if (ctx->backend_data == NULL) { + modbus_free(ctx); + errno = ENOMEM; + return NULL; + } + ctx_tcp_pi = (modbus_tcp_pi_t *)ctx->backend_data; + + if (node == NULL) { + /* The node argument can be empty to indicate any hosts */ + ctx_tcp_pi->node[0] = 0; + } else { + dest_size = sizeof(char) * _MODBUS_TCP_PI_NODE_LENGTH; + ret_size = strlcpy(ctx_tcp_pi->node, node, dest_size); + if (ret_size == 0) { + fprintf(stderr, "The node string is empty\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + if (ret_size >= dest_size) { + fprintf(stderr, "The node string has been truncated\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + } + + if (service != NULL) { + dest_size = sizeof(char) * _MODBUS_TCP_PI_SERVICE_LENGTH; + ret_size = strlcpy(ctx_tcp_pi->service, service, dest_size); + } else { + /* Empty service is not allowed, error catched below. */ + ret_size = 0; + } + + if (ret_size == 0) { + fprintf(stderr, "The service string is empty\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + if (ret_size >= dest_size) { + fprintf(stderr, "The service string has been truncated\n"); + modbus_free(ctx); + errno = EINVAL; + return NULL; + } + + ctx_tcp_pi->t_id = 0; + + return ctx; +} diff --git a/src/modbus-tcp.h b/src/modbus-tcp.h new file mode 100644 index 0000000..abaef27 --- /dev/null +++ b/src/modbus-tcp.h @@ -0,0 +1,52 @@ +/* + * Copyright © 2001-2010 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef MODBUS_TCP_H +#define MODBUS_TCP_H + +#include "modbus.h" + +MODBUS_BEGIN_DECLS + +#if defined(_WIN32) && !defined(__CYGWIN__) +/* Win32 with MinGW, supplement to */ +#include +#if !defined(ECONNRESET) +#define ECONNRESET WSAECONNRESET +#endif +#if !defined(ECONNREFUSED) +#define ECONNREFUSED WSAECONNREFUSED +#endif +#if !defined(ETIMEDOUT) +#define ETIMEDOUT WSAETIMEDOUT +#endif +#if !defined(ENOPROTOOPT) +#define ENOPROTOOPT WSAENOPROTOOPT +#endif +#if !defined(EINPROGRESS) +#define EINPROGRESS WSAEINPROGRESS +#endif +#endif + +#define MODBUS_TCP_DEFAULT_PORT 502 +#define MODBUS_TCP_SLAVE 0xFF + +/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5 + * TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes + */ +#define MODBUS_TCP_MAX_ADU_LENGTH 260 + +MODBUS_API modbus_t* modbus_new_tcp(const char *ip_address, int port); +MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection); +MODBUS_API int modbus_tcp_accept(modbus_t *ctx, int *s); + +MODBUS_API modbus_t* modbus_new_tcp_pi(const char *node, const char *service); +MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection); +MODBUS_API int modbus_tcp_pi_accept(modbus_t *ctx, int *s); + +MODBUS_END_DECLS + +#endif /* MODBUS_TCP_H */ diff --git a/src/modbus-version.h b/src/modbus-version.h new file mode 100644 index 0000000..0218973 --- /dev/null +++ b/src/modbus-version.h @@ -0,0 +1,53 @@ +/* + * Copyright © 2010-2014 Stéphane Raimbault + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef MODBUS_VERSION_H +#define MODBUS_VERSION_H + +/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MAJOR (3) + +/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MINOR (1) + +/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */ +#define LIBMODBUS_VERSION_MICRO (6) + +/* The full version, like 1.2.3 */ +#define LIBMODBUS_VERSION 3.1.6 + +/* The full version, in string form (suited for string concatenation) + */ +#define LIBMODBUS_VERSION_STRING "3.1.6" + +/* Numerically encoded version, eg. v1.2.3 is 0x010203 */ +#define LIBMODBUS_VERSION_HEX ((LIBMODBUS_VERSION_MAJOR << 16) | \ + (LIBMODBUS_VERSION_MINOR << 8) | \ + (LIBMODBUS_VERSION_MICRO << 0)) + +/* Evaluates to True if the version is greater than @major, @minor and @micro + */ +#define LIBMODBUS_VERSION_CHECK(major,minor,micro) \ + (LIBMODBUS_VERSION_MAJOR > (major) || \ + (LIBMODBUS_VERSION_MAJOR == (major) && \ + LIBMODBUS_VERSION_MINOR > (minor)) || \ + (LIBMODBUS_VERSION_MAJOR == (major) && \ + LIBMODBUS_VERSION_MINOR == (minor) && \ + LIBMODBUS_VERSION_MICRO >= (micro))) + +#endif /* MODBUS_VERSION_H */ diff --git a/src/modbus.c b/src/modbus.c new file mode 100644 index 0000000..be98c4f --- /dev/null +++ b/src/modbus.c @@ -0,0 +1,1911 @@ +/* + * Copyright © 2001-2011 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + * + * This library implements the Modbus protocol. + * http://libmodbus.org/ + */ + +#include +#include +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#endif + +//#include + +#include "modbus.h" +#include "modbus-private.h" + +/* Internal use */ +#define MSG_LENGTH_UNDEFINED -1 + +/* Exported version */ +const unsigned int libmodbus_version_major = LIBMODBUS_VERSION_MAJOR; +const unsigned int libmodbus_version_minor = LIBMODBUS_VERSION_MINOR; +const unsigned int libmodbus_version_micro = LIBMODBUS_VERSION_MICRO; + +/* Max between RTU and TCP max adu length (so TCP) */ +#define MAX_MESSAGE_LENGTH 260 + +/* 3 steps are used to parse the query */ +typedef enum { + _STEP_FUNCTION, + _STEP_META, + _STEP_DATA +} _step_t; + +const char *modbus_strerror(int errnum) { + switch (errnum) { + case EMBXILFUN: + return "Illegal function"; + case EMBXILADD: + return "Illegal data address"; + case EMBXILVAL: + return "Illegal data value"; + case EMBXSFAIL: + return "Slave device or server failure"; + case EMBXACK: + return "Acknowledge"; + case EMBXSBUSY: + return "Slave device or server is busy"; + case EMBXNACK: + return "Negative acknowledge"; + case EMBXMEMPAR: + return "Memory parity error"; + case EMBXGPATH: + return "Gateway path unavailable"; + case EMBXGTAR: + return "Target device failed to respond"; + case EMBBADCRC: + return "Invalid CRC"; + case EMBBADDATA: + return "Invalid data"; + case EMBBADEXC: + return "Invalid exception code"; + case EMBMDATA: + return "Too many data"; + case EMBBADSLAVE: + return "Response not from requested slave"; + default: + return strerror(errnum); + } +} + +void _error_print(modbus_t *ctx, const char *context) +{ + if (ctx->debug) { + fprintf(stderr, "ERROR %s", modbus_strerror(errno)); + if (context != NULL) { + fprintf(stderr, ": %s\n", context); + } else { + fprintf(stderr, "\n"); + } + } +} + +static void _sleep_response_timeout(modbus_t *ctx) +{ + /* Response timeout is always positive */ +#ifdef _WIN32 + /* usleep doesn't exist on Windows */ + Sleep((ctx->response_timeout.tv_sec * 1000) + + (ctx->response_timeout.tv_usec / 1000)); +#else + /* usleep source code */ + struct timespec request, remaining; + request.tv_sec = ctx->response_timeout.tv_sec; + request.tv_nsec = ((long int)ctx->response_timeout.tv_usec) * 1000; + while (nanosleep(&request, &remaining) == -1 && errno == EINTR) { + request = remaining; + } +#endif +} + +int modbus_flush(modbus_t *ctx) +{ + int rc; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + rc = ctx->backend->flush(ctx); + if (rc != -1 && ctx->debug) { + /* Not all backends are able to return the number of bytes flushed */ + printf("Bytes flushed (%d)\n", rc); + } + return rc; +} + +/* Computes the length of the expected response */ +static unsigned int compute_response_length_from_request(modbus_t *ctx, uint8_t *req) +{ + int length; + const int offset = ctx->backend->header_length; + + switch (req[offset]) { + case MODBUS_FC_READ_COILS: + case MODBUS_FC_READ_DISCRETE_INPUTS: { + /* Header + nb values (code from write_bits) */ + int nb = (req[offset + 3] << 8) | req[offset + 4]; + length = 2 + (nb / 8) + ((nb % 8) ? 1 : 0); + } + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: + case MODBUS_FC_READ_HOLDING_REGISTERS: + case MODBUS_FC_READ_INPUT_REGISTERS: + /* Header + 2 * nb values */ + length = 2 + 2 * (req[offset + 3] << 8 | req[offset + 4]); + break; + case MODBUS_FC_READ_EXCEPTION_STATUS: + length = 3; + break; + case MODBUS_FC_REPORT_SLAVE_ID: + /* The response is device specific (the header provides the + length) */ + return MSG_LENGTH_UNDEFINED; + case MODBUS_FC_MASK_WRITE_REGISTER: + length = 7; + break; + default: + length = 5; + } + + return offset + length + ctx->backend->checksum_length; +} + +/* Sends a request/response */ +static int send_msg(modbus_t *ctx, uint8_t *msg, int msg_length) +{ + int rc; + int i; + + msg_length = ctx->backend->send_msg_pre(msg, msg_length); + + if (ctx->debug) { + for (i = 0; i < msg_length; i++) + printf("[%.2X]", msg[i]); + printf("\n"); + } + + /* In recovery mode, the write command will be issued until to be + successful! Disabled by default. */ + do { + rc = ctx->backend->send(ctx, msg, msg_length); + if (rc == -1) { + _error_print(ctx, NULL); + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) { + int saved_errno = errno; + + if ((errno == EBADF || errno == ECONNRESET || errno == EPIPE)) { + modbus_close(ctx); + _sleep_response_timeout(ctx); + modbus_connect(ctx); + } else { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + errno = saved_errno; + } + } + } while ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) && + rc == -1); + + if (rc > 0 && rc != msg_length) { + errno = EMBBADDATA; + return -1; + } + + return rc; +} + +int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length) +{ + sft_t sft; + uint8_t req[MAX_MESSAGE_LENGTH]; + int req_length; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (raw_req_length < 2 || raw_req_length > (MODBUS_MAX_PDU_LENGTH + 1)) { + /* The raw request must contain function and slave at least and + must not be longer than the maximum pdu length plus the slave + address. */ + errno = EINVAL; + return -1; + } + + sft.slave = raw_req[0]; + sft.function = raw_req[1]; + /* The t_id is left to zero */ + sft.t_id = 0; + /* This response function only set the header so it's convenient here */ + req_length = ctx->backend->build_response_basis(&sft, req); + + if (raw_req_length > 2) { + /* Copy data after function code */ + memcpy(req + req_length, raw_req + 2, raw_req_length - 2); + req_length += raw_req_length - 2; + } + + return send_msg(ctx, req, req_length); +} + +/* + * ---------- Request Indication ---------- + * | Client | ---------------------->| Server | + * ---------- Confirmation Response ---------- + */ + +/* Computes the length to read after the function received */ +static uint8_t compute_meta_length_after_function(int function, + msg_type_t msg_type) +{ + int length; + + if (msg_type == MSG_INDICATION) { + if (function <= MODBUS_FC_WRITE_SINGLE_REGISTER) { + length = 4; + } else if (function == MODBUS_FC_WRITE_MULTIPLE_COILS || + function == MODBUS_FC_WRITE_MULTIPLE_REGISTERS) { + length = 5; + } else if (function == MODBUS_FC_MASK_WRITE_REGISTER) { + length = 6; + } else if (function == MODBUS_FC_WRITE_AND_READ_REGISTERS) { + length = 9; + } else { + /* MODBUS_FC_READ_EXCEPTION_STATUS, MODBUS_FC_REPORT_SLAVE_ID */ + length = 0; + } + } else { + /* MSG_CONFIRMATION */ + switch (function) { + case MODBUS_FC_WRITE_SINGLE_COIL: + case MODBUS_FC_WRITE_SINGLE_REGISTER: + case MODBUS_FC_WRITE_MULTIPLE_COILS: + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: + length = 4; + break; + case MODBUS_FC_MASK_WRITE_REGISTER: + length = 6; + break; + default: + length = 1; + } + } + + return length; +} + +/* Computes the length to read after the meta information (address, count, etc) */ +static int compute_data_length_after_meta(modbus_t *ctx, uint8_t *msg, + msg_type_t msg_type) +{ + int function = msg[ctx->backend->header_length]; + int length; + + if (msg_type == MSG_INDICATION) { + switch (function) { + case MODBUS_FC_WRITE_MULTIPLE_COILS: + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: + length = msg[ctx->backend->header_length + 5]; + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: + length = msg[ctx->backend->header_length + 9]; + break; + default: + length = 0; + } + } else { + /* MSG_CONFIRMATION */ + if (function <= MODBUS_FC_READ_INPUT_REGISTERS || + function == MODBUS_FC_REPORT_SLAVE_ID || + function == MODBUS_FC_WRITE_AND_READ_REGISTERS) { + length = msg[ctx->backend->header_length + 1]; + } else { + length = 0; + } + } + + length += ctx->backend->checksum_length; + + return length; +} + + +/* Waits a response from a modbus server or a request from a modbus client. + This function blocks if there is no replies (3 timeouts). + + The function shall return the number of received characters and the received + message in an array of uint8_t if successful. Otherwise it shall return -1 + and errno is set to one of the values defined below: + - ECONNRESET + - EMBBADDATA + - EMBUNKEXC + - ETIMEDOUT + - read() or recv() error codes +*/ + +int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type) +{ + int rc; + fd_set rset; + struct timeval tv; + struct timeval *p_tv; + int length_to_read; + int msg_length = 0; + _step_t step; + + if (ctx->debug) { + if (msg_type == MSG_INDICATION) { + printf("Waiting for an indication...\n"); + } else { + printf("Waiting for a confirmation...\n"); + } + } + + /* Add a file descriptor to the set */ + FD_ZERO(&rset); + FD_SET(ctx->s, &rset); + + /* We need to analyse the message step by step. At the first step, we want + * to reach the function code because all packets contain this + * information. */ + step = _STEP_FUNCTION; + length_to_read = ctx->backend->header_length + 1; + + if (msg_type == MSG_INDICATION) { + /* Wait for a message, we don't know when the message will be + * received */ + if (ctx->indication_timeout.tv_sec == 0 && ctx->indication_timeout.tv_usec == 0) { + /* By default, the indication timeout isn't set */ + p_tv = NULL; + } else { + /* Wait for an indication (name of a received request by a server, see schema) */ + tv.tv_sec = ctx->indication_timeout.tv_sec; + tv.tv_usec = ctx->indication_timeout.tv_usec; + p_tv = &tv; + } + } else { + tv.tv_sec = ctx->response_timeout.tv_sec; + tv.tv_usec = ctx->response_timeout.tv_usec; + p_tv = &tv; + } + + while (length_to_read != 0) { + rc = ctx->backend->select(ctx, &rset, p_tv, length_to_read); + if (rc == -1) { + _error_print(ctx, "select"); + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) { + int saved_errno = errno; + + if (errno == ETIMEDOUT) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } else if (errno == EBADF) { + modbus_close(ctx); + modbus_connect(ctx); + } + errno = saved_errno; + } + return -1; + } + + rc = ctx->backend->recv(ctx, msg + msg_length, length_to_read); + if (rc == 0) { + errno = ECONNRESET; + rc = -1; + } + + if (rc == -1) { + _error_print(ctx, "read"); + if ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) && + (errno == ECONNRESET || errno == ECONNREFUSED || + errno == EBADF)) { + int saved_errno = errno; + modbus_close(ctx); + modbus_connect(ctx); + /* Could be removed by previous calls */ + errno = saved_errno; + } + return -1; + } + + /* Display the hex code of each character received */ + if (ctx->debug) { + int i; + for (i=0; i < rc; i++) + printf("<%.2X>", msg[msg_length + i]); + } + + /* Sums bytes received */ + msg_length += rc; + /* Computes remaining bytes */ + length_to_read -= rc; + + if (length_to_read == 0) { + switch (step) { + case _STEP_FUNCTION: + /* Function code position */ + length_to_read = compute_meta_length_after_function( + msg[ctx->backend->header_length], + msg_type); + if (length_to_read != 0) { + step = _STEP_META; + break; + } /* else switches straight to the next step */ + case _STEP_META: + length_to_read = compute_data_length_after_meta( + ctx, msg, msg_type); + if ((msg_length + length_to_read) > (int)ctx->backend->max_adu_length) { + errno = EMBBADDATA; + _error_print(ctx, "too many data"); + return -1; + } + step = _STEP_DATA; + break; + default: + break; + } + } + + if (length_to_read > 0 && + (ctx->byte_timeout.tv_sec > 0 || ctx->byte_timeout.tv_usec > 0)) { + /* If there is no character in the buffer, the allowed timeout + interval between two consecutive bytes is defined by + byte_timeout */ + tv.tv_sec = ctx->byte_timeout.tv_sec; + tv.tv_usec = ctx->byte_timeout.tv_usec; + p_tv = &tv; + } + /* else timeout isn't set again, the full response must be read before + expiration of response timeout (for CONFIRMATION only) */ + } + + if (ctx->debug) + printf("\n"); + + return ctx->backend->check_integrity(ctx, msg, msg_length); +} + +/* Receive the request from a modbus master */ +int modbus_receive(modbus_t *ctx, uint8_t *req) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->receive(ctx, req); +} + +/* Receives the confirmation. + + The function shall store the read response in rsp and return the number of + values (bits or words). Otherwise, its shall return -1 and errno is set. + + The function doesn't check the confirmation is the expected response to the + initial request. +*/ +int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); +} + +static int check_confirmation(modbus_t *ctx, uint8_t *req, + uint8_t *rsp, int rsp_length) +{ + int rc; + int rsp_length_computed; + const int offset = ctx->backend->header_length; + const int function = rsp[offset]; + + if (ctx->backend->pre_check_confirmation) { + rc = ctx->backend->pre_check_confirmation(ctx, req, rsp, rsp_length); + if (rc == -1) { + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + return -1; + } + } + + rsp_length_computed = compute_response_length_from_request(ctx, req); + + /* Exception code */ + if (function >= 0x80) { + if (rsp_length == (offset + 2 + (int)ctx->backend->checksum_length) && + req[offset] == (rsp[offset] - 0x80)) { + /* Valid exception code received */ + + int exception_code = rsp[offset + 1]; + if (exception_code < MODBUS_EXCEPTION_MAX) { + errno = MODBUS_ENOBASE + exception_code; + } else { + errno = EMBBADEXC; + } + _error_print(ctx, NULL); + return -1; + } else { + errno = EMBBADEXC; + _error_print(ctx, NULL); + return -1; + } + } + + /* Check length */ + if ((rsp_length == rsp_length_computed || + rsp_length_computed == MSG_LENGTH_UNDEFINED) && + function < 0x80) { + int req_nb_value; + int rsp_nb_value; + + /* Check function code */ + if (function != req[offset]) { + if (ctx->debug) { + fprintf(stderr, + "Received function not corresponding to the request (0x%X != 0x%X)\n", + function, req[offset]); + } + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + errno = EMBBADDATA; + return -1; + } + + /* Check the number of values is corresponding to the request */ + switch (function) { + case MODBUS_FC_READ_COILS: + case MODBUS_FC_READ_DISCRETE_INPUTS: + /* Read functions, 8 values in a byte (nb + * of values in the request and byte count in + * the response. */ + req_nb_value = (req[offset + 3] << 8) + req[offset + 4]; + req_nb_value = (req_nb_value / 8) + ((req_nb_value % 8) ? 1 : 0); + rsp_nb_value = rsp[offset + 1]; + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: + case MODBUS_FC_READ_HOLDING_REGISTERS: + case MODBUS_FC_READ_INPUT_REGISTERS: + /* Read functions 1 value = 2 bytes */ + req_nb_value = (req[offset + 3] << 8) + req[offset + 4]; + rsp_nb_value = (rsp[offset + 1] / 2); + break; + case MODBUS_FC_WRITE_MULTIPLE_COILS: + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: + /* N Write functions */ + req_nb_value = (req[offset + 3] << 8) + req[offset + 4]; + rsp_nb_value = (rsp[offset + 3] << 8) | rsp[offset + 4]; + break; + case MODBUS_FC_REPORT_SLAVE_ID: + /* Report slave ID (bytes received) */ + req_nb_value = rsp_nb_value = rsp[offset + 1]; + break; + default: + /* 1 Write functions & others */ + req_nb_value = rsp_nb_value = 1; + } + + if (req_nb_value == rsp_nb_value) { + rc = rsp_nb_value; + } else { + if (ctx->debug) { + fprintf(stderr, + "Quantity not corresponding to the request (%d != %d)\n", + rsp_nb_value, req_nb_value); + } + + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + + errno = EMBBADDATA; + rc = -1; + } + } else { + if (ctx->debug) { + fprintf(stderr, + "Message length not corresponding to the computed length (%d != %d)\n", + rsp_length, rsp_length_computed); + } + if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_PROTOCOL) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + errno = EMBBADDATA; + rc = -1; + } + + return rc; +} + +static int response_io_status(uint8_t *tab_io_status, + int address, int nb, + uint8_t *rsp, int offset) +{ + int shift = 0; + /* Instead of byte (not allowed in Win32) */ + int one_byte = 0; + int i; + + for (i = address; i < address + nb; i++) { + one_byte |= tab_io_status[i] << shift; + if (shift == 7) { + /* Byte is full */ + rsp[offset++] = one_byte; + one_byte = shift = 0; + } else { + shift++; + } + } + + if (shift != 0) + rsp[offset++] = one_byte; + + return offset; +} + +/* Build the exception response */ +static int response_exception(modbus_t *ctx, sft_t *sft, + int exception_code, uint8_t *rsp, + unsigned int to_flush, + const char* template, ...) +{ + int rsp_length; + + /* Print debug message */ + if (ctx->debug) { + va_list ap; + + va_start(ap, template); + vfprintf(stderr, template, ap); + va_end(ap); + } + + /* Flush if required */ + if (to_flush) { + _sleep_response_timeout(ctx); + modbus_flush(ctx); + } + + /* Build exception response */ + sft->function = sft->function + 0x80; + rsp_length = ctx->backend->build_response_basis(sft, rsp); + rsp[rsp_length++] = exception_code; + + return rsp_length; +} + +/* Send a response to the received request. + Analyses the request and constructs a response. + + If an error occurs, this function construct the response + accordingly. +*/ +int modbus_reply(modbus_t *ctx, const uint8_t *req, + int req_length, modbus_mapping_t *mb_mapping) +{ + int offset; + int slave; + int function; + uint16_t address; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + int rsp_length = 0; + sft_t sft; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + offset = ctx->backend->header_length; + slave = req[offset - 1]; + function = req[offset]; + address = (req[offset + 1] << 8) + req[offset + 2]; + + sft.slave = slave; + sft.function = function; + sft.t_id = ctx->backend->prepare_response_tid(req, &req_length); + + /* Data are flushed on illegal number of values errors. */ + switch (function) { + case MODBUS_FC_READ_COILS: + case MODBUS_FC_READ_DISCRETE_INPUTS: { + unsigned int is_input = (function == MODBUS_FC_READ_DISCRETE_INPUTS); + int start_bits = is_input ? mb_mapping->start_input_bits : mb_mapping->start_bits; + int nb_bits = is_input ? mb_mapping->nb_input_bits : mb_mapping->nb_bits; + uint8_t *tab_bits = is_input ? mb_mapping->tab_input_bits : mb_mapping->tab_bits; + const char * const name = is_input ? "read_input_bits" : "read_bits"; + int nb = (req[offset + 3] << 8) + req[offset + 4]; + /* The mapping can be shifted to reduce memory consumption and it + doesn't always start at address zero. */ + int mapping_address = address - start_bits; + + if (nb < 1 || MODBUS_MAX_READ_BITS < nb) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal nb of values %d in %s (max %d)\n", + nb, name, MODBUS_MAX_READ_BITS); + } else if (mapping_address < 0 || (mapping_address + nb) > nb_bits) { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in %s\n", + mapping_address < 0 ? address : address + nb, name); + } else { + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + rsp[rsp_length++] = (nb / 8) + ((nb % 8) ? 1 : 0); + rsp_length = response_io_status(tab_bits, mapping_address, nb, + rsp, rsp_length); + } + } + break; + case MODBUS_FC_READ_HOLDING_REGISTERS: + case MODBUS_FC_READ_INPUT_REGISTERS: { + unsigned int is_input = (function == MODBUS_FC_READ_INPUT_REGISTERS); + int start_registers = is_input ? mb_mapping->start_input_registers : mb_mapping->start_registers; + int nb_registers = is_input ? mb_mapping->nb_input_registers : mb_mapping->nb_registers; + uint16_t *tab_registers = is_input ? mb_mapping->tab_input_registers : mb_mapping->tab_registers; + const char * const name = is_input ? "read_input_registers" : "read_registers"; + int nb = (req[offset + 3] << 8) + req[offset + 4]; + /* The mapping can be shifted to reduce memory consumption and it + doesn't always start at address zero. */ + int mapping_address = address - start_registers; + + if (nb < 1 || MODBUS_MAX_READ_REGISTERS < nb) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal nb of values %d in %s (max %d)\n", + nb, name, MODBUS_MAX_READ_REGISTERS); + } else if (mapping_address < 0 || (mapping_address + nb) > nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in %s\n", + mapping_address < 0 ? address : address + nb, name); + } else { + int i; + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + rsp[rsp_length++] = nb << 1; + for (i = mapping_address; i < mapping_address + nb; i++) { + rsp[rsp_length++] = tab_registers[i] >> 8; + rsp[rsp_length++] = tab_registers[i] & 0xFF; + } + } + } + break; + case MODBUS_FC_WRITE_SINGLE_COIL: { + int mapping_address = address - mb_mapping->start_bits; + + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_bits) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_bit\n", + address); + } else { + int data = (req[offset + 3] << 8) + req[offset + 4]; + + if (data == 0xFF00 || data == 0x0) { + mb_mapping->tab_bits[mapping_address] = data ? ON : OFF; + memcpy(rsp, req, req_length); + rsp_length = req_length; + } else { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, FALSE, + "Illegal data value 0x%0X in write_bit request at address %0X\n", + data, address); + } + } + } + break; + case MODBUS_FC_WRITE_SINGLE_REGISTER: { + int mapping_address = address - mb_mapping->start_registers; + + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_register\n", + address); + } else { + int data = (req[offset + 3] << 8) + req[offset + 4]; + + mb_mapping->tab_registers[mapping_address] = data; + memcpy(rsp, req, req_length); + rsp_length = req_length; + } + } + break; + case MODBUS_FC_WRITE_MULTIPLE_COILS: { + int nb = (req[offset + 3] << 8) + req[offset + 4]; + int nb_bits = req[offset + 5]; + int mapping_address = address - mb_mapping->start_bits; + + if (nb < 1 || MODBUS_MAX_WRITE_BITS < nb || nb_bits * 8 < nb) { + /* May be the indication has been truncated on reading because of + * invalid address (eg. nb is 0 but the request contains values to + * write) so it's necessary to flush. */ + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal number of values %d in write_bits (max %d)\n", + nb, MODBUS_MAX_WRITE_BITS); + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_bits) { + rsp_length = response_exception( + ctx, &sft, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_bits\n", + mapping_address < 0 ? address : address + nb); + } else { + /* 6 = byte count */ + modbus_set_bits_from_bytes(mb_mapping->tab_bits, mapping_address, nb, + &req[offset + 6]); + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + /* 4 to copy the bit address (2) and the quantity of bits */ + memcpy(rsp + rsp_length, req + rsp_length, 4); + rsp_length += 4; + } + } + break; + case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: { + int nb = (req[offset + 3] << 8) + req[offset + 4]; + int nb_bytes = req[offset + 5]; + int mapping_address = address - mb_mapping->start_registers; + + if (nb < 1 || MODBUS_MAX_WRITE_REGISTERS < nb || nb_bytes != nb * 2) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal number of values %d in write_registers (max %d)\n", + nb, MODBUS_MAX_WRITE_REGISTERS); + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_registers\n", + mapping_address < 0 ? address : address + nb); + } else { + int i, j; + for (i = mapping_address, j = 6; i < mapping_address + nb; i++, j += 2) { + /* 6 and 7 = first value */ + mb_mapping->tab_registers[i] = + (req[offset + j] << 8) + req[offset + j + 1]; + } + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + /* 4 to copy the address (2) and the no. of registers */ + memcpy(rsp + rsp_length, req + rsp_length, 4); + rsp_length += 4; + } + } + break; + case MODBUS_FC_REPORT_SLAVE_ID: { + int str_len; + int byte_count_pos; + + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + /* Skip byte count for now */ + byte_count_pos = rsp_length++; + rsp[rsp_length++] = _REPORT_SLAVE_ID; + /* Run indicator status to ON */ + rsp[rsp_length++] = 0xFF; + /* LMB + length of LIBMODBUS_VERSION_STRING */ + str_len = 3 + strlen(LIBMODBUS_VERSION_STRING); + memcpy(rsp + rsp_length, "LMB" LIBMODBUS_VERSION_STRING, str_len); + rsp_length += str_len; + rsp[byte_count_pos] = rsp_length - byte_count_pos - 1; + } + break; + case MODBUS_FC_READ_EXCEPTION_STATUS: + if (ctx->debug) { + fprintf(stderr, "FIXME Not implemented\n"); + } + errno = ENOPROTOOPT; + return -1; + break; + case MODBUS_FC_MASK_WRITE_REGISTER: { + int mapping_address = address - mb_mapping->start_registers; + + if (mapping_address < 0 || mapping_address >= mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data address 0x%0X in write_register\n", + address); + } else { + uint16_t data = mb_mapping->tab_registers[mapping_address]; + uint16_t and = (req[offset + 3] << 8) + req[offset + 4]; + uint16_t or = (req[offset + 5] << 8) + req[offset + 6]; + + data = (data & and) | (or & (~and)); + mb_mapping->tab_registers[mapping_address] = data; + memcpy(rsp, req, req_length); + rsp_length = req_length; + } + } + break; + case MODBUS_FC_WRITE_AND_READ_REGISTERS: { + int nb = (req[offset + 3] << 8) + req[offset + 4]; + uint16_t address_write = (req[offset + 5] << 8) + req[offset + 6]; + int nb_write = (req[offset + 7] << 8) + req[offset + 8]; + int nb_write_bytes = req[offset + 9]; + int mapping_address = address - mb_mapping->start_registers; + int mapping_address_write = address_write - mb_mapping->start_registers; + + if (nb_write < 1 || MODBUS_MAX_WR_WRITE_REGISTERS < nb_write || + nb < 1 || MODBUS_MAX_WR_READ_REGISTERS < nb || + nb_write_bytes != nb_write * 2) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, rsp, TRUE, + "Illegal nb of values (W%d, R%d) in write_and_read_registers (max W%d, R%d)\n", + nb_write, nb, MODBUS_MAX_WR_WRITE_REGISTERS, MODBUS_MAX_WR_READ_REGISTERS); + } else if (mapping_address < 0 || + (mapping_address + nb) > mb_mapping->nb_registers || + mapping_address < 0 || + (mapping_address_write + nb_write) > mb_mapping->nb_registers) { + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, rsp, FALSE, + "Illegal data read address 0x%0X or write address 0x%0X write_and_read_registers\n", + mapping_address < 0 ? address : address + nb, + mapping_address_write < 0 ? address_write : address_write + nb_write); + } else { + int i, j; + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + rsp[rsp_length++] = nb << 1; + + /* Write first. + 10 and 11 are the offset of the first values to write */ + for (i = mapping_address_write, j = 10; + i < mapping_address_write + nb_write; i++, j += 2) { + mb_mapping->tab_registers[i] = + (req[offset + j] << 8) + req[offset + j + 1]; + } + + /* and read the data for the response */ + for (i = mapping_address; i < mapping_address + nb; i++) { + rsp[rsp_length++] = mb_mapping->tab_registers[i] >> 8; + rsp[rsp_length++] = mb_mapping->tab_registers[i] & 0xFF; + } + } + } + break; + + default: + rsp_length = response_exception( + ctx, &sft, MODBUS_EXCEPTION_ILLEGAL_FUNCTION, rsp, TRUE, + "Unknown Modbus function code: 0x%0X\n", function); + break; + } + + /* Suppress any responses when the request was a broadcast */ + return (ctx->backend->backend_type == _MODBUS_BACKEND_TYPE_RTU && + slave == MODBUS_BROADCAST_ADDRESS) ? 0 : send_msg(ctx, rsp, rsp_length); +} + +int modbus_reply_exception(modbus_t *ctx, const uint8_t *req, + unsigned int exception_code) +{ + int offset; + int slave; + int function; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + int rsp_length; + int dummy_length = 99; + sft_t sft; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + offset = ctx->backend->header_length; + slave = req[offset - 1]; + function = req[offset]; + + sft.slave = slave; + sft.function = function + 0x80; + sft.t_id = ctx->backend->prepare_response_tid(req, &dummy_length); + rsp_length = ctx->backend->build_response_basis(&sft, rsp); + + /* Positive exception code */ + if (exception_code < MODBUS_EXCEPTION_MAX) { + rsp[rsp_length++] = exception_code; + return send_msg(ctx, rsp, rsp_length); + } else { + errno = EINVAL; + return -1; + } +} + +/* Reads IO status */ +static int read_io_status(modbus_t *ctx, int function, + int addr, int nb, uint8_t *dest) +{ + int rc; + int req_length; + + uint8_t req[_MIN_REQ_LENGTH]; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + req_length = ctx->backend->build_request_basis(ctx, function, addr, nb, req); + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int i, temp, bit; + int pos = 0; + int offset; + int offset_end; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length + 2; + offset_end = offset + rc; + for (i = offset; i < offset_end; i++) { + /* Shift reg hi_byte to temp */ + temp = rsp[i]; + + for (bit = 0x01; (bit & 0xff) && (pos < nb);) { + dest[pos++] = (temp & bit) ? TRUE : FALSE; + bit = bit << 1; + } + + } + } + + return rc; +} + +/* Reads the boolean status of bits and sets the array elements + in the destination to TRUE or FALSE (single bits). */ +int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest) +{ + int rc; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_BITS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many bits requested (%d > %d)\n", + nb, MODBUS_MAX_READ_BITS); + } + errno = EMBMDATA; + return -1; + } + + rc = read_io_status(ctx, MODBUS_FC_READ_COILS, addr, nb, dest); + + if (rc == -1) + return -1; + else + return nb; +} + + +/* Same as modbus_read_bits but reads the remote device input table */ +int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest) +{ + int rc; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_BITS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many discrete inputs requested (%d > %d)\n", + nb, MODBUS_MAX_READ_BITS); + } + errno = EMBMDATA; + return -1; + } + + rc = read_io_status(ctx, MODBUS_FC_READ_DISCRETE_INPUTS, addr, nb, dest); + + if (rc == -1) + return -1; + else + return nb; +} + +/* Reads the data from a remove device and put that data into an array */ +static int read_registers(modbus_t *ctx, int function, int addr, int nb, + uint16_t *dest) +{ + int rc; + int req_length; + uint8_t req[_MIN_REQ_LENGTH]; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + if (nb > MODBUS_MAX_READ_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers requested (%d > %d)\n", + nb, MODBUS_MAX_READ_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, function, addr, nb, req); + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int offset; + int i; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length; + + for (i = 0; i < rc; i++) { + /* shift reg hi_byte to temp OR with lo_byte */ + dest[i] = (rsp[offset + 2 + (i << 1)] << 8) | + rsp[offset + 3 + (i << 1)]; + } + } + + return rc; +} + +/* Reads the holding registers of remote device and put the data into an + array */ +int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest) +{ + int status; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers requested (%d > %d)\n", + nb, MODBUS_MAX_READ_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + status = read_registers(ctx, MODBUS_FC_READ_HOLDING_REGISTERS, + addr, nb, dest); + return status; +} + +/* Reads the input registers of remote device and put the data into an array */ +int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, + uint16_t *dest) +{ + int status; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_READ_REGISTERS) { + fprintf(stderr, + "ERROR Too many input registers requested (%d > %d)\n", + nb, MODBUS_MAX_READ_REGISTERS); + errno = EMBMDATA; + return -1; + } + + status = read_registers(ctx, MODBUS_FC_READ_INPUT_REGISTERS, + addr, nb, dest); + + return status; +} + +/* Write a value to the specified register of the remote device. + Used by write_bit and write_register */ +static int write_single(modbus_t *ctx, int function, int addr, const uint16_t value) +{ + int rc; + int req_length; + uint8_t req[_MIN_REQ_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, function, addr, (int) value, req); + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + /* Used by write_bit and write_register */ + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + return rc; +} + +/* Turns ON or OFF a single bit of the remote device */ +int modbus_write_bit(modbus_t *ctx, int addr, int status) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return write_single(ctx, MODBUS_FC_WRITE_SINGLE_COIL, addr, + status ? 0xFF00 : 0); +} + +/* Writes a value in one register of the remote device */ +int modbus_write_register(modbus_t *ctx, int addr, const uint16_t value) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return write_single(ctx, MODBUS_FC_WRITE_SINGLE_REGISTER, addr, value); +} + +/* Write the bits of the array in the remote device */ +int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *src) +{ + int rc; + int i; + int byte_count; + int req_length; + int bit_check = 0; + int pos = 0; + uint8_t req[MAX_MESSAGE_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_WRITE_BITS) { + if (ctx->debug) { + fprintf(stderr, "ERROR Writing too many bits (%d > %d)\n", + nb, MODBUS_MAX_WRITE_BITS); + } + errno = EMBMDATA; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_WRITE_MULTIPLE_COILS, + addr, nb, req); + byte_count = (nb / 8) + ((nb % 8) ? 1 : 0); + req[req_length++] = byte_count; + + for (i = 0; i < byte_count; i++) { + int bit; + + bit = 0x01; + req[req_length] = 0; + + while ((bit & 0xFF) && (bit_check++ < nb)) { + if (src[pos++]) + req[req_length] |= bit; + else + req[req_length] &=~ bit; + + bit = bit << 1; + } + req_length++; + } + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + + return rc; +} + +/* Write the values from the array to the registers of the remote device */ +int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *src) +{ + int rc; + int i; + int req_length; + int byte_count; + uint8_t req[MAX_MESSAGE_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (nb > MODBUS_MAX_WRITE_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Trying to write to too many registers (%d > %d)\n", + nb, MODBUS_MAX_WRITE_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_WRITE_MULTIPLE_REGISTERS, + addr, nb, req); + byte_count = nb * 2; + req[req_length++] = byte_count; + + for (i = 0; i < nb; i++) { + req[req_length++] = src[i] >> 8; + req[req_length++] = src[i] & 0x00FF; + } + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + return rc; +} + +int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask) +{ + int rc; + int req_length; + /* The request length can not exceed _MIN_REQ_LENGTH - 2 and 4 bytes to + * store the masks. The ugly substraction is there to remove the 'nb' value + * (2 bytes) which is not used. */ + uint8_t req[_MIN_REQ_LENGTH + 2]; + + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_MASK_WRITE_REGISTER, + addr, 0, req); + + /* HACKISH, count is not used */ + req_length -= 2; + + req[req_length++] = and_mask >> 8; + req[req_length++] = and_mask & 0x00ff; + req[req_length++] = or_mask >> 8; + req[req_length++] = or_mask & 0x00ff; + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + /* Used by write_bit and write_register */ + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + } + + return rc; +} + +/* Write multiple registers from src array to remote device and read multiple + registers from remote device to dest array. */ +int modbus_write_and_read_registers(modbus_t *ctx, + int write_addr, int write_nb, + const uint16_t *src, + int read_addr, int read_nb, + uint16_t *dest) + +{ + int rc; + int req_length; + int i; + int byte_count; + uint8_t req[MAX_MESSAGE_LENGTH]; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + if (write_nb > MODBUS_MAX_WR_WRITE_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers to write (%d > %d)\n", + write_nb, MODBUS_MAX_WR_WRITE_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + + if (read_nb > MODBUS_MAX_WR_READ_REGISTERS) { + if (ctx->debug) { + fprintf(stderr, + "ERROR Too many registers requested (%d > %d)\n", + read_nb, MODBUS_MAX_WR_READ_REGISTERS); + } + errno = EMBMDATA; + return -1; + } + req_length = ctx->backend->build_request_basis(ctx, + MODBUS_FC_WRITE_AND_READ_REGISTERS, + read_addr, read_nb, req); + + req[req_length++] = write_addr >> 8; + req[req_length++] = write_addr & 0x00ff; + req[req_length++] = write_nb >> 8; + req[req_length++] = write_nb & 0x00ff; + byte_count = write_nb * 2; + req[req_length++] = byte_count; + + for (i = 0; i < write_nb; i++) { + req[req_length++] = src[i] >> 8; + req[req_length++] = src[i] & 0x00FF; + } + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int offset; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length; + for (i = 0; i < rc; i++) { + /* shift reg hi_byte to temp OR with lo_byte */ + dest[i] = (rsp[offset + 2 + (i << 1)] << 8) | + rsp[offset + 3 + (i << 1)]; + } + } + + return rc; +} + +/* Send a request to get the slave ID of the device (only available in serial + communication). */ +int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest) +{ + int rc; + int req_length; + uint8_t req[_MIN_REQ_LENGTH]; + + if (ctx == NULL || max_dest <= 0) { + errno = EINVAL; + return -1; + } + + req_length = ctx->backend->build_request_basis(ctx, MODBUS_FC_REPORT_SLAVE_ID, + 0, 0, req); + + /* HACKISH, addr and count are not used */ + req_length -= 4; + + rc = send_msg(ctx, req, req_length); + if (rc > 0) { + int i; + int offset; + uint8_t rsp[MAX_MESSAGE_LENGTH]; + + rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); + if (rc == -1) + return -1; + + rc = check_confirmation(ctx, req, rsp, rc); + if (rc == -1) + return -1; + + offset = ctx->backend->header_length + 2; + + /* Byte count, slave id, run indicator status and + additional data. Truncate copy to max_dest. */ + for (i=0; i < rc && i < max_dest; i++) { + dest[i] = rsp[offset + i]; + } + } + + return rc; +} + +void _modbus_init_common(modbus_t *ctx) +{ + /* Slave and socket are initialized to -1 */ + ctx->slave = -1; + ctx->s = -1; + + ctx->debug = FALSE; + ctx->error_recovery = MODBUS_ERROR_RECOVERY_NONE; + + ctx->response_timeout.tv_sec = 0; + ctx->response_timeout.tv_usec = _RESPONSE_TIMEOUT; + + ctx->byte_timeout.tv_sec = 0; + ctx->byte_timeout.tv_usec = _BYTE_TIMEOUT; + + ctx->indication_timeout.tv_sec = 0; + ctx->indication_timeout.tv_usec = 0; +} + +/* Define the slave number */ +int modbus_set_slave(modbus_t *ctx, int slave) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->set_slave(ctx, slave); +} + +int modbus_get_slave(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->slave; +} + +int modbus_set_error_recovery(modbus_t *ctx, + modbus_error_recovery_mode error_recovery) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + /* The type of modbus_error_recovery_mode is unsigned enum */ + ctx->error_recovery = (uint8_t) error_recovery; + return 0; +} + +int modbus_set_socket(modbus_t *ctx, int s) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx->s = s; + return 0; +} + +int modbus_get_socket(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->s; +} + +/* Get the timeout interval used to wait for a response */ +int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + *to_sec = ctx->response_timeout.tv_sec; + *to_usec = ctx->response_timeout.tv_usec; + return 0; +} + +int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec) +{ + if (ctx == NULL || + (to_sec == 0 && to_usec == 0) || to_usec > 999999) { + errno = EINVAL; + return -1; + } + + ctx->response_timeout.tv_sec = to_sec; + ctx->response_timeout.tv_usec = to_usec; + return 0; +} + +/* Get the timeout interval between two consecutive bytes of a message */ +int modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + *to_sec = ctx->byte_timeout.tv_sec; + *to_usec = ctx->byte_timeout.tv_usec; + return 0; +} + +int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec) +{ + /* Byte timeout can be disabled when both values are zero */ + if (ctx == NULL || to_usec > 999999) { + errno = EINVAL; + return -1; + } + + ctx->byte_timeout.tv_sec = to_sec; + ctx->byte_timeout.tv_usec = to_usec; + return 0; +} + +/* Get the timeout interval used by the server to wait for an indication from a client */ +int modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + *to_sec = ctx->indication_timeout.tv_sec; + *to_usec = ctx->indication_timeout.tv_usec; + return 0; +} + +int modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec) +{ + /* Indication timeout can be disabled when both values are zero */ + if (ctx == NULL || to_usec > 999999) { + errno = EINVAL; + return -1; + } + + ctx->indication_timeout.tv_sec = to_sec; + ctx->indication_timeout.tv_usec = to_usec; + return 0; +} + +int modbus_get_header_length(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->header_length; +} + +int modbus_connect(modbus_t *ctx) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + return ctx->backend->connect(ctx); +} + +void modbus_close(modbus_t *ctx) +{ + if (ctx == NULL) + return; + + ctx->backend->close(ctx); +} + +void modbus_free(modbus_t *ctx) +{ + if (ctx == NULL) + return; + + ctx->backend->free(ctx); +} + +int modbus_set_debug(modbus_t *ctx, int flag) +{ + if (ctx == NULL) { + errno = EINVAL; + return -1; + } + + ctx->debug = flag; + return 0; +} + +/* Allocates 4 arrays to store bits, input bits, registers and inputs + registers. The pointers are stored in modbus_mapping structure. + + The modbus_mapping_new_start_address() function shall return the new allocated + structure if successful. Otherwise it shall return NULL and set errno to + ENOMEM. */ +modbus_mapping_t* modbus_mapping_new_start_address( + unsigned int start_bits, unsigned int nb_bits, + unsigned int start_input_bits, unsigned int nb_input_bits, + unsigned int start_registers, unsigned int nb_registers, + unsigned int start_input_registers, unsigned int nb_input_registers) +{ + modbus_mapping_t *mb_mapping; + + mb_mapping = (modbus_mapping_t *)malloc(sizeof(modbus_mapping_t)); + if (mb_mapping == NULL) { + return NULL; + } + + /* 0X */ + mb_mapping->nb_bits = nb_bits; + mb_mapping->start_bits = start_bits; + if (nb_bits == 0) { + mb_mapping->tab_bits = NULL; + } else { + /* Negative number raises a POSIX error */ + mb_mapping->tab_bits = + (uint8_t *) malloc(nb_bits * sizeof(uint8_t)); + if (mb_mapping->tab_bits == NULL) { + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_bits, 0, nb_bits * sizeof(uint8_t)); + } + + /* 1X */ + mb_mapping->nb_input_bits = nb_input_bits; + mb_mapping->start_input_bits = start_input_bits; + if (nb_input_bits == 0) { + mb_mapping->tab_input_bits = NULL; + } else { + mb_mapping->tab_input_bits = + (uint8_t *) malloc(nb_input_bits * sizeof(uint8_t)); + if (mb_mapping->tab_input_bits == NULL) { + free(mb_mapping->tab_bits); + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_input_bits, 0, nb_input_bits * sizeof(uint8_t)); + } + + /* 4X */ + mb_mapping->nb_registers = nb_registers; + mb_mapping->start_registers = start_registers; + if (nb_registers == 0) { + mb_mapping->tab_registers = NULL; + } else { + mb_mapping->tab_registers = + (uint16_t *) malloc(nb_registers * sizeof(uint16_t)); + if (mb_mapping->tab_registers == NULL) { + free(mb_mapping->tab_input_bits); + free(mb_mapping->tab_bits); + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_registers, 0, nb_registers * sizeof(uint16_t)); + } + + /* 3X */ + mb_mapping->nb_input_registers = nb_input_registers; + mb_mapping->start_input_registers = start_input_registers; + if (nb_input_registers == 0) { + mb_mapping->tab_input_registers = NULL; + } else { + mb_mapping->tab_input_registers = + (uint16_t *) malloc(nb_input_registers * sizeof(uint16_t)); + if (mb_mapping->tab_input_registers == NULL) { + free(mb_mapping->tab_registers); + free(mb_mapping->tab_input_bits); + free(mb_mapping->tab_bits); + free(mb_mapping); + return NULL; + } + memset(mb_mapping->tab_input_registers, 0, + nb_input_registers * sizeof(uint16_t)); + } + + return mb_mapping; +} + +modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, + int nb_registers, int nb_input_registers) +{ + return modbus_mapping_new_start_address( + 0, nb_bits, 0, nb_input_bits, 0, nb_registers, 0, nb_input_registers); +} + +/* Frees the 4 arrays */ +void modbus_mapping_free(modbus_mapping_t *mb_mapping) +{ + if (mb_mapping == NULL) { + return; + } + + free(mb_mapping->tab_input_registers); + free(mb_mapping->tab_registers); + free(mb_mapping->tab_input_bits); + free(mb_mapping->tab_bits); + free(mb_mapping); +} + +#ifndef HAVE_STRLCPY +/* + * Function strlcpy was originally developed by + * Todd C. Miller to simplify writing secure code. + * See ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3 + * for more information. + * + * Thank you Ulrich Drepper... not! + * + * Copy src to string dest of size dest_size. At most dest_size-1 characters + * will be copied. Always NUL terminates (unless dest_size == 0). Returns + * strlen(src); if retval >= dest_size, truncation occurred. + */ +size_t strlcpy(char *dest, const char *src, size_t dest_size) +{ + register char *d = dest; + register const char *s = src; + register size_t n = dest_size; + + /* Copy as many bytes as will fit */ + if (n != 0 && --n != 0) { + do { + if ((*d++ = *s++) == 0) + break; + } while (--n != 0); + } + + /* Not enough room in dest, add NUL and traverse rest of src */ + if (n == 0) { + if (dest_size != 0) + *d = '\0'; /* NUL-terminate dest */ + while (*s++) + ; + } + + return (s - src - 1); /* count does not include NUL */ +} +#endif diff --git a/src/modbus.h b/src/modbus.h new file mode 100644 index 0000000..fbe20bc --- /dev/null +++ b/src/modbus.h @@ -0,0 +1,293 @@ +/* + * Copyright © 2001-2013 Stéphane Raimbault + * + * SPDX-License-Identifier: LGPL-2.1+ + */ + +#ifndef MODBUS_H +#define MODBUS_H + +/* Add this for macros that defined unix flavor */ +#if (defined(__unix__) || defined(unix)) && !defined(USG) +#include +#endif + +#ifndef _MSC_VER +#include +#else +#include "stdint.h" +#endif + +#include "modbus-version.h" + +#if defined(_MSC_VER) +# if defined(DLLBUILD) +/* define DLLBUILD when building the DLL */ +# define MODBUS_API __declspec(dllexport) +# else +# define MODBUS_API __declspec(dllimport) +# endif +#else +# define MODBUS_API +#endif + +#ifdef __cplusplus +# define MODBUS_BEGIN_DECLS extern "C" { +# define MODBUS_END_DECLS } +#else +# define MODBUS_BEGIN_DECLS +# define MODBUS_END_DECLS +#endif + +MODBUS_BEGIN_DECLS + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef OFF +#define OFF 0 +#endif + +#ifndef ON +#define ON 1 +#endif + +/* Modbus function codes */ +#define MODBUS_FC_READ_COILS 0x01 +#define MODBUS_FC_READ_DISCRETE_INPUTS 0x02 +#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03 +#define MODBUS_FC_READ_INPUT_REGISTERS 0x04 +#define MODBUS_FC_WRITE_SINGLE_COIL 0x05 +#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06 +#define MODBUS_FC_READ_EXCEPTION_STATUS 0x07 +#define MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F +#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10 +#define MODBUS_FC_REPORT_SLAVE_ID 0x11 +#define MODBUS_FC_MASK_WRITE_REGISTER 0x16 +#define MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17 + +#define MODBUS_BROADCAST_ADDRESS 0 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12) + * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0) + * (chapter 6 section 11 page 29) + * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0) + */ +#define MODBUS_MAX_READ_BITS 2000 +#define MODBUS_MAX_WRITE_BITS 1968 + +/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15) + * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D) + * (chapter 6 section 12 page 31) + * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B) + * (chapter 6 section 17 page 38) + * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79) + */ +#define MODBUS_MAX_READ_REGISTERS 125 +#define MODBUS_MAX_WRITE_REGISTERS 123 +#define MODBUS_MAX_WR_WRITE_REGISTERS 121 +#define MODBUS_MAX_WR_READ_REGISTERS 125 + +/* The size of the MODBUS PDU is limited by the size constraint inherited from + * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256 + * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server + * address (1 byte) - CRC (2 bytes) = 253 bytes. + */ +#define MODBUS_MAX_PDU_LENGTH 253 + +/* Consequently: + * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256 + * bytes. + * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes. + * so the maximum of both backend in 260 bytes. This size can used to allocate + * an array of bytes to store responses and it will be compatible with the two + * backends. + */ +#define MODBUS_MAX_ADU_LENGTH 260 + +/* Random number to avoid errno conflicts */ +#define MODBUS_ENOBASE 112345678 + +/* Protocol exceptions */ +enum { + MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01, + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS, + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE, + MODBUS_EXCEPTION_ACKNOWLEDGE, + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY, + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE, + MODBUS_EXCEPTION_MEMORY_PARITY, + MODBUS_EXCEPTION_NOT_DEFINED, + MODBUS_EXCEPTION_GATEWAY_PATH, + MODBUS_EXCEPTION_GATEWAY_TARGET, + MODBUS_EXCEPTION_MAX +}; + +#define EMBXILFUN (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION) +#define EMBXILADD (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS) +#define EMBXILVAL (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE) +#define EMBXSFAIL (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE) +#define EMBXACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE) +#define EMBXSBUSY (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY) +#define EMBXNACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE) +#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY) +#define EMBXGPATH (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH) +#define EMBXGTAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET) + +/* Native libmodbus error codes */ +#define EMBBADCRC (EMBXGTAR + 1) +#define EMBBADDATA (EMBXGTAR + 2) +#define EMBBADEXC (EMBXGTAR + 3) +#define EMBUNKEXC (EMBXGTAR + 4) +#define EMBMDATA (EMBXGTAR + 5) +#define EMBBADSLAVE (EMBXGTAR + 6) + +extern const unsigned int libmodbus_version_major; +extern const unsigned int libmodbus_version_minor; +extern const unsigned int libmodbus_version_micro; + +typedef struct _modbus modbus_t; + +typedef struct _modbus_mapping_t { + int nb_bits; + int start_bits; + int nb_input_bits; + int start_input_bits; + int nb_input_registers; + int start_input_registers; + int nb_registers; + int start_registers; + uint8_t *tab_bits; + uint8_t *tab_input_bits; + uint16_t *tab_input_registers; + uint16_t *tab_registers; +} modbus_mapping_t; + +typedef enum +{ + MODBUS_ERROR_RECOVERY_NONE = 0, + MODBUS_ERROR_RECOVERY_LINK = (1<<1), + MODBUS_ERROR_RECOVERY_PROTOCOL = (1<<2) +} modbus_error_recovery_mode; + +MODBUS_API int modbus_set_slave(modbus_t* ctx, int slave); +MODBUS_API int modbus_get_slave(modbus_t* ctx); +MODBUS_API int modbus_set_error_recovery(modbus_t *ctx, modbus_error_recovery_mode error_recovery); +MODBUS_API int modbus_set_socket(modbus_t *ctx, int s); +MODBUS_API int modbus_get_socket(modbus_t *ctx); + +MODBUS_API int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec); +MODBUS_API int modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec); + +MODBUS_API int modbus_get_header_length(modbus_t *ctx); + +MODBUS_API int modbus_connect(modbus_t *ctx); +MODBUS_API void modbus_close(modbus_t *ctx); + +MODBUS_API void modbus_free(modbus_t *ctx); + +MODBUS_API int modbus_flush(modbus_t *ctx); +MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag); + +MODBUS_API const char *modbus_strerror(int errnum); + +MODBUS_API int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest); +MODBUS_API int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest); +MODBUS_API int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest); +MODBUS_API int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest); +MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status); +MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, const uint16_t value); +MODBUS_API int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data); +MODBUS_API int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data); +MODBUS_API int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask); +MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb, + const uint16_t *src, int read_addr, int read_nb, + uint16_t *dest); +MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest); + +MODBUS_API modbus_mapping_t* modbus_mapping_new_start_address( + unsigned int start_bits, unsigned int nb_bits, + unsigned int start_input_bits, unsigned int nb_input_bits, + unsigned int start_registers, unsigned int nb_registers, + unsigned int start_input_registers, unsigned int nb_input_registers); + +MODBUS_API modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, + int nb_registers, int nb_input_registers); +MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping); + +MODBUS_API int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length); + +MODBUS_API int modbus_receive(modbus_t *ctx, uint8_t *req); + +MODBUS_API int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp); + +MODBUS_API int modbus_reply(modbus_t *ctx, const uint8_t *req, + int req_length, modbus_mapping_t *mb_mapping); +MODBUS_API int modbus_reply_exception(modbus_t *ctx, const uint8_t *req, + unsigned int exception_code); + +/** + * UTILS FUNCTIONS + **/ + +#define MODBUS_GET_HIGH_BYTE(data) (((data) >> 8) & 0xFF) +#define MODBUS_GET_LOW_BYTE(data) ((data) & 0xFF) +#define MODBUS_GET_INT64_FROM_INT16(tab_int16, index) \ + (((int64_t)tab_int16[(index) ] << 48) + \ + ((int64_t)tab_int16[(index) + 1] << 32) + \ + ((int64_t)tab_int16[(index) + 2] << 16) + \ + (int64_t)tab_int16[(index) + 3]) +#define MODBUS_GET_INT32_FROM_INT16(tab_int16, index) ((tab_int16[(index)] << 16) + tab_int16[(index) + 1]) +#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1]) +#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \ + do { \ + tab_int8[(index)] = (value) >> 8; \ + tab_int8[(index) + 1] = (value) & 0xFF; \ + } while (0) +#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \ + do { \ + tab_int16[(index) ] = (value) >> 16; \ + tab_int16[(index) + 1] = (value); \ + } while (0) +#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \ + do { \ + tab_int16[(index) ] = (value) >> 48; \ + tab_int16[(index) + 1] = (value) >> 32; \ + tab_int16[(index) + 2] = (value) >> 16; \ + tab_int16[(index) + 3] = (value); \ + } while (0) + +MODBUS_API void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value); +MODBUS_API void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits, + const uint8_t *tab_byte); +MODBUS_API uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, unsigned int nb_bits); +MODBUS_API float modbus_get_float(const uint16_t *src); +MODBUS_API float modbus_get_float_abcd(const uint16_t *src); +MODBUS_API float modbus_get_float_dcba(const uint16_t *src); +MODBUS_API float modbus_get_float_badc(const uint16_t *src); +MODBUS_API float modbus_get_float_cdab(const uint16_t *src); + +MODBUS_API void modbus_set_float(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_abcd(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_dcba(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_badc(float f, uint16_t *dest); +MODBUS_API void modbus_set_float_cdab(float f, uint16_t *dest); + +#include "modbus-tcp.h" +#include "modbus-rtu.h" + +MODBUS_END_DECLS + +#endif /* MODBUS_H */ diff --git a/src/modbus.lib b/src/modbus.lib new file mode 100644 index 0000000000000000000000000000000000000000..2490d0db2b9eaedae992e2362d0404d3ed2c2228 GIT binary patch literal 16390 zcmc&)O>7)R7Jhbq2wpaukN^q!o7hhL6aRb0KZ)ZwBr7ElLSzC$2&oy*w389znc1Fk z2qzGGjX31Qfdhv5&+TQ9YOQoVY`q9Ul!E&03amnn?9ueZza8j zcchtb1fBW}@sLKp6g0LEfM|THps`!{j1VtnO}s7XF5d5Y-o;n1ytaJRJOB6B&n;iPa`m-k zZ>?TlS#N^pU4G-zC0h<33I!p)df|=BuXyLrUOkHjm9>T^&Aq1I@>VLXrnef@*SwVv zT0W$SHn7F&NL0IAswzjmM#zXKk+BZ3u}fsxu2$>CmS!S3ZcVSaQYzc(lAT~vF0B+D zHiDgCvr;UV95#ZTU{fj=R~$Bit=Uk&>Mds+x2E3mSl!ifCDdAOvJ-H$mMa@a%au@T zxyjaWYX19P&{~hXDSp?qP$L}EO+Tm)|Sk&rX~bzC`Xtf&(fyy zOzoIwX;ayy^=1nvs%d13oVIA>mHle*gSZb_?IMX~DeDu-<@_c~L!w#I*J+g+F;e`l zX`zN!tu$MHEmq_#OSf1m`3*JcNjG9?x)RN6RN`_uOVg!78WmSH7}sSHA8<7k>xf*%C+zzh6R{e~Z?&*~Ccw#|C!Jzw=@SRu*MbVGby zm$NM0z;8C{wWja2Dr<3=euU%_hkB7ZOqFI*ewVGd2A1Qv< zwW{@|8oMR&rfIAOzETh`y1csHRJB?aZ<+@6L)l+hzZTb>adgdA5Dt8$7&A1z0DC0d z+{B8EV{2AwjdigZ()BstwhH`fw15R__Y#6IwrwLyWGeDohnAL5vwuIR;Fbw@Y;heK z$DtX480w1cu%Z2+p)Xht-KZebfblh}wPN!8$0EwRBevw zOs({$PaRam?UMhGb-$^GiY?IW(2w{P=A+_wmzIYs#cCy33s=6l5z@pE8upE#{!Q}rxU90mQJ3-CkFe+B2>ToWe190=4~*fadI6RT0QZoFj{)pG4)8J34+8+d z<9!wHpUwho$2jhtd4QXE{}rh`g0eio?J0ndrUAa11n9y0Z%7A`cOT_9765i2EsO%Z zc^cpse7=LR?AJpW*JGJur!dAJ#+Vl0FChPO#9x|0ok4)_5bI^UKj_2yAbr~p@D|cH zDE|!YzQi*3jR9;O2e^gz^NU#487v#`xAFeq1hxq==dfNie13>HpCJ8+b-sZ%KO?<8 z0dN-y(+$uC-7o?tU<^iKI~<3nUy$*b2&xv{inz_0-xEWl5VWuzg`qWBy&@3o5dW=b;KvqYU z;j9+;TN<<>wgT>1Yz@lBxmOS>KyJ=0GcyRa z6kJOW6(|-Ek(YBDxt1Pf=~#M{(6RK8aKojAlr~seNX50ZgnU;B-E_w%iRlXxL}?MN zW72XAQs%Tv-ZyK-r-u?7#sJ2U(s%i4lPuk%jCo?mDBq<^jNW)y8GAYA2Blssiia-~ z$nj@#^t`BYT3Q-Yv9(O4Vrz*~VjIqlp}NK%6WgPX2^~2hJtq@+B4>~gIxbmSq)4tM zDT;A8D`_3ODfW&dFW#d|hs85*%qdBuki)}jn{S79rVEN~oI#7>c4B2K_F(Zubar7m znaEn@JmdB{9E+i?t?Eohs|9x^hRBuSWe&v9c7fPVLmCmX=`IpQYTkxsnu}mYcIL)( z3rty`kW?;r1*W2O0v21Fkg5=ELJ~V=+L1VM+L2J7b|FWfc4}#t^`m7t$^kQ0v@A0g zrk5RxEa@zDlNWDI0l#QGD&vJ*eLa0OHZ;|2`%sn{9xAd^L%|*^SF0lG-sm(tKOdcI zzuR-EYYRNWtEUTNVT>~=)Eo;3O#kcR6=Pm}xD~y~`x5MWX{=H%wu=22O^a(U-u{F1 zlX!(Kcwd5vJ5moLV{tu$w}(hSiP!LV337M3@o6_kv~=~TMh(E8T~8s4ilb{M2C83F zo_)1a3hK@JYAZLmJe0e1@$xG|tp5@g8BzfljfYRW@ONAIq(HEyrTSU}tNKNytLxFD z2#zf1qPlfM)Z!&f0ubkV#0lF*I9no4o^+6*bP9??{3G-uFDeUj0rHJ*-EakeA1B^@ zQln%lKQI6NK%=BP93}q_Yew~RkCJjIQa@~zVBSSsG)n#zy~sO_lFj(~S-$BZtV7~K zJsXDE=GN5g4C^&9xBiO=;tRWbEoE+D)=OM84ry-ji_I;}8i|Ya?nf{3{v>-hOOGBz z+$S{(^99+RIr`@f&C5$TJ0CsTAGU2ryjF^hE1S=4f4Tgu8|eTdb>Z3=?LeYUaYtAw zt?Fi2V#D1LQr_LFeb}lk9Empb3`jj@8}|j7z0Dcl2~)JV>Z;zOU3hqCr{V+!#VU{y zHJWS&YCocGbD>5dNC%klvS?t^ICGSl##1&ULo~k1`nyuI=8O zN$`qzl!oV3syCzd*;$fK&6WU^5$9Az`HU;aJ&cqOoLJCzxp~>V7w-N*yp@ z^_a1(Dc<=-6ZeTArp<^08lp%qsus2XCDVHKppB)cE*Y?T%+{-Eam^tOm$IU&^!8hr zHdYUtNG#*JS(rz3Ozpou9bu+;s~pE35(~VqRf9##~AHrpMfPoBU0WJ5Zn4H%*D22Nf{KGp&uI2I}VKV8&c%;`CZIs{QervgaCiB5r05X2OZMnK_tACt{~L zn6zxjl!5r?WkaS7AuzjDAf_TzKw42yA;!MJNI)ZIH#SjyZ^I3D% zW9PnV!NR703Mhof*ukb`Bu~50v<;3z&epcH(}_h3ElLjX2DXiul6g6kh^RHP=YP3M BRp +#include +#include +#include +#include + +int index = 0; +extern camera *m_camera; +extern correct *m_correct; + +extern uint8_t learning_flag; +extern Process_img * process_img; +cv::Mat mat_1; +cv::Mat mat_2; +cv::Mat img_pop; +extern int save_flag; +int m_index1; +QSemaphore usebuff(0); +QSemaphore read_to_send(0); +//unsigned char *send_buf; +char *recv_buf; + +extern uint8_t adjust_correct_flag; + +#define WHITE_IMAGE_PATH "C:/Users/USER/Desktop/wood_aduiduiduiplus/build-wooden-Desktop_Qt_5_9_5_MSVC2017_64bit-Release/white" +#define BLACK_IMAGE_PATH "C:/Users/USER/Desktop/wood_aduiduiduiplus/build-wooden-Desktop_Qt_5_9_5_MSVC2017_64bit-Release/black" +#define correct_path "D:/correct.png" +int get_height(cv::Mat img) +{ + int b_temp = 0; + float b_avg = 0.0; + int i, j; + for(i = 0; i < img.rows; i++) + { + for(j = 0; j < img.cols; j++) + { + b_temp += (int)img.at(i, j)[0]; + } + b_avg = b_temp / 4096.0f; + if(b_avg == 0) + { +// qDebug() << i; + return i; + } + b_temp = 0; + } + return -1; +} + +//采集 +void onImageDataCallback(SapXferCallbackInfo *pInfo) +{ + qDebug() << "enter to calback" ; + if(pInfo) + { + + unsigned char *pData; + int width = m_camera->m_buffer->GetWidth(); + int height = m_camera->m_buffer->GetHeight(); + qDebug() << "enter to calback: limian"; + + m_camera->m_buffer->GetAddress((void**)&pData); + cv::Mat img(height, width, CV_8UC3, pData); + img.convertTo(img, CV_32FC3); + m_camera->calibrated_img = (img - m_camera->black_mat) / (m_camera->white_mat - m_camera->black_mat + m_camera->eps); + m_camera->calibrated_img *= 255; + m_camera->calibrated_img.convertTo(m_camera->calibrated_img, CV_8UC3); + + m_camera->rgb_height = get_height(img); +// qDebug() << "rgb_height: " << rgb_height; + + if(m_camera->rgb_height < 3000 && m_camera->rgb_height > 500 && !adjust_correct_flag) + { + + m_camera->imgqueue.push(m_camera->calibrated_img); + +// m_camera->imgqueue.push(mat_2); +// emit process_img->show_img(mat_1); + // usebuff.release(); + // if(!learning_flag) + // read_to_send.release(); + } + else if(adjust_correct_flag) + { + img.convertTo(img, CV_8UC3); + mat_1 = img; + usebuff.release(); + } + else if(m_camera->rgb_height == 0 || m_camera->rgb_height == -1) + { + + m_camera->m_buffer->Clear(); + return; + } + } +} + +//校正 +void onImageCorrectCallback(SapXferCallbackInfo *pInfo) +{ + qDebug() <<"11111111222222222333333333"; + qDebug() << " onImageCorrectCallback start "; + //采集黑白帧 + if(pInfo) + { + qDebug() << "pInfo"; + if( m_camera->capture_black_flag || m_camera->capture_white_flag ) + { + qDebug() << "flag"; + + unsigned char pdata_rgb; + void* pDataAddr_rgb = &pdata_rgb; + m_camera->m_buffer->GetAddress(&pDataAddr_rgb); + cv::Mat img(4096, 3000, CV_8UC3,pDataAddr_rgb); + img.convertTo(img, CV_32FC3); + if( m_camera->capture_black_flag ) + { + qDebug() << "capture_black_flag"; + m_camera->capture_black_flag = false; + m_camera->black_mat = img; + qDebug() << "img"; + FILE* fp = fopen(BLACK_IMAGE_PATH, "wb"); + fwrite(m_camera->black_mat.data, 4096*3000*3*4, 1, fp); + fclose(fp); + qDebug() << "black frame acquisition OK!"; + } + else if( m_camera->capture_white_flag ) + { + m_camera->capture_white_flag = false; + m_camera->white_mat = img; + FILE* fp = fopen(WHITE_IMAGE_PATH, "wb"); + fwrite(m_camera->white_mat.data, 4096*3000*3*4, 1, fp); + fclose(fp); + qDebug() << " white frame acquisition OK!"; + } + } + } + + // Widget::getInstance()->set(); +} + +Process_img::Process_img(QObject *parent) : QThread(parent), m_stop(false) +{ + +} + +void Process_img::run() +{ + qDebug() << "process_imgID: " << currentThreadId(); + + while(1) + { + stop_mutex.lock(); + if(m_stop) + { + stop_mutex.unlock(); + qDebug() << "process thread quit______________________"; + return; + } + stop_mutex.unlock(); + + if(m_camera->imgqueue.size()>1) + { + + + // read_to_send.acquire(); //没有mat_2就阻塞 + + m_camera->imgqueue.pop(); + qDebug()<<"the wood image's queue size: "<imgqueue.size(); + img_pop = m_camera->imgqueue.front(); + img_pop = m_camera->calibrated_img(cv::Rect(0, 0, 4096, m_camera->rgb_height)); //4096 + + int save_count = 0; + save_count++; + + if(save_flag && save_count == 1) + { + qDebug() << "1111111111111"; + // QDateTime time = QDateTime::currentDateTime(); + // QString str = time.toString("yyyyMMddhhmmss"); + // QString filepath = SAVE_IMAGE_PATH + str + ".png"; + // qDebug() << filepath; + // cv::imwrite(filepath.toLatin1().data(), img); + + char fileName[64]; + sprintf(fileName, "D:/save_image/rgb%d.bmp", m_index1); + + m_index1++; + qDebug() << fileName; + cv::imwrite(fileName, img_pop); + save_count = 0; + + } + + emit process_img->show_img(img_pop); + usebuff.release(); + if(!learning_flag) + read_to_send.release(); + + } + +// if(!usebuff.tryAcquire()) +// continue; + + } + +} + +void Process_img::exitThread() +{ + stop_mutex.lock(); + m_stop = true; + stop_mutex.unlock(); +} + + +Adjust_para::Adjust_para(QObject *parent) : QThread(parent), is_stop(false), correct_flag(false) +{ + +} + +void Adjust_para::run() +{ + while(1) + { + stop_mutex.lock(); + if(is_stop) + { + stop_mutex.unlock(); + qDebug() << "adjust thread qiut_______________________"; + return; + } + stop_mutex.unlock(); + if(!usebuff.tryAcquire()) + continue; + + qDebug() << "234"; + + emit(send_image_debug(mat_1)); + + correct_mutex.lock(); + + qDebug() << "aabbbbbbbcccccc"; + + if(correct_flag) + { + cv::imwrite(correct_path, mat_1); + correct_flag = false; + } + correct_mutex.unlock(); + } +} + +void Adjust_para::get_correct_signal() +{ + correct_mutex.lock(); + correct_flag = true; +// qDebug() << "llllllllllll"; + correct_mutex.unlock(); +} + +void Adjust_para::exitThread() +{ + stop_mutex.lock(); + is_stop = true; + stop_mutex.unlock(); +} + + +SendThread::SendThread(QObject *parent) : QThread(parent) +{ + +} + + +void SendThread::run() +{ + bool is_timeout; + cv::Mat temp_img; + unsigned char* send_buf; + + send_server = new QTcpServer(); + send_server->listen(QHostAddress::Any, 21122); + qDebug() << "sendthread waiting connect....."; + send_server->waitForNewConnection(50000, &is_timeout); + if(is_timeout) + { + qDebug() << "sendthread time out"; + return; + } + send_socket = send_server->nextPendingConnection(); + qDebug() << "sendsocket new connection"; + + while(1) + { + if(!usebuff.tryAcquire()) + continue; + read_to_send.acquire(); + temp_img = img_pop; +// emit process_img->show_img(img_pop); + + + + send_buf = (uint8_t*)malloc(temp_img.cols * temp_img.rows * 3 + 16); + memset(send_buf, 0, temp_img.cols * temp_img.rows * 3 + 16); + + uint16_t width = temp_img.cols; + uint16_t height = temp_img.rows; + uint32_t data_len = width * height * 3 + 8; + + //协议 + send_buf[0] = 0xAA; + // 总体报文长度 + for(int i = 1; i<= 4; i++) + send_buf[i] = (uint8_t)(data_len >> 8 * (4 - i)); + // 数据和指令部分 + send_buf[5] = ' '; + send_buf[6] = ' '; + send_buf[7] = 'I'; + send_buf[8] = 'M'; + send_buf[9] = (uint8_t)(height>>8) & 0xFF; + send_buf[10] = (uint8_t)height; + send_buf[11] = (uint8_t)(width>>8) & 0xFF; + send_buf[12] = (uint8_t)width; + memcpy(send_buf + 13, temp_img.data, temp_img.cols*temp_img.rows*3+4); + // 末尾校验位、协议位 + send_buf[temp_img.cols * temp_img.rows*3 + 13] = 0xFF; + send_buf[temp_img.cols * temp_img.rows*3 + 14] = 0xFF; + send_buf[temp_img.cols * temp_img.rows*3 + 15] = 0xBB; + + send_socket->write((const char*)send_buf, (temp_img.cols * temp_img.rows * 3 + 16)*sizeof(unsigned char)); + send_socket->flush(); + + qDebug() << "====send success===="; + + + free(send_buf); + + + } + +// +} + + + +RecvThread::RecvThread(QObject *parent) : QThread(parent) +{ + +} + + +void RecvThread::run() +{ + bool is_timeout; + char buf[1100] = {0}; + int len = 0; + recv_server = new QTcpServer(); + recv_server->listen(QHostAddress::Any, 21123); + qDebug() << "recvthread waiting connect....."; + + recv_server->waitForNewConnection(50000, &is_timeout); + if(is_timeout == true) + { + qDebug() << "recvthread time out"; + return; + } + recv_socket = recv_server->nextPendingConnection(); + qDebug() << "recvthread new connection"; + while(1) + { + /*** +// memset(buf, 0, 10); +// recv_socket->waitForReadyRead(-1); //没有东西就阻塞 +// len = recv_socket->read(buf, 10); + +//// emit read_plc(); + +// if(len < 0) +// { +// qDebug() << "receive data error"; +// } +// else +// { +// qDebug() << "receive :" << len; +// FILE* fp; +// fp = fopen("C:/Users/USER/Desktop/1.txt", "a+"); +// fwrite(buf, 1, 1, fp); +// fclose(fp); +// } + +// emit send_sortingResult(buf); +***/ + memset(buf, 0, 1100);//初始化为0 + recv_socket->waitForReadyRead(-1);//阻塞 + qDebug() << "======receive success======"; + len = recv_socket->read(buf, 1100); + qDebug() << "len" << len; + char buf1[1100] = {0}; + for(int i = 0; i < 1080; i++) + { +// qDebug() << "buf" << buf[i] << i; + buf1[i] = buf[i+6]; + } + + if(len < 0) + { +// qDebug() << "receiv data error"; + } + else if(len < 10) + { +// qDebug() << "receive:" << len; + emit send_sortingResult(buf); + } + else + { + qDebug() << "KM"; + //需要把获得的buf数据发送到showpic里 + emit SendPicInfo(buf1); + } + } + + +} + +RestartThread::RestartThread(QObject *parent) : QThread(parent), restr_flag(false) +{ + +} + +void RestartThread::run() +{ + while(1) + { + restr_mutex.lock(); + if(restr_flag) + { +// restr_mutex.unlock(); + m_camera->openCamera(); + qDebug() << "aa"; + restr_flag = false; + qDebug() << "bb"; + } + msleep(1); + restr_mutex.unlock(); + msleep(1); + } +} + +void RestartThread::restr_fun() +{ + restr_mutex.lock(); + restr_flag = true; + restr_mutex.unlock(); +} diff --git a/thread.h b/thread.h new file mode 100644 index 0000000..de99da5 --- /dev/null +++ b/thread.h @@ -0,0 +1,129 @@ +#ifndef THREAD_H +#define THREAD_H + +#include +#include "opencv2/opencv.hpp" +#include +#include "SapClassBasic.h" +#include "camera.h" +#include +#include +#include "correct.h" +#include +#include + +//#define REALWIDTH 500 +//#define READHEIGHT real_height +//#define HEIGHT 500 + +class QModbusClient; +class QModbusReply; + +static int count; + +void onImageDataCallback(SapXferCallbackInfo *pInfo); +void onImageCorrectCallback(SapXferCallbackInfo *pInfo); + +class Process_img : public QThread +{ + Q_OBJECT + +private: + QMutex stop_mutex; + bool m_stop; + +protected: + void run(); + +public: + explicit Process_img(QObject *parent = nullptr); + void exitThread(); + +signals: + void show_img(cv::Mat); + +public slots: +}; + + + +class Adjust_para: public QThread +{ + Q_OBJECT + +private: + QMutex stop_mutex; + bool is_stop; + bool correct_flag; + QMutex correct_mutex; + +protected: + void run(); + +public: + explicit Adjust_para(QObject *parent = nullptr); + void exitThread(); + +signals: + void send_image_debug(cv::Mat); + + +public slots: + void get_correct_signal(); +}; + + + +class SendThread: public QThread +{ + Q_OBJECT + +protected: + void run(); + +public: + explicit SendThread(QObject *parent = NULL); + QTcpServer *send_server; + QTcpSocket *send_socket; +}; + + +class RecvThread: public QThread +{ + Q_OBJECT + +protected: + void run(); + +public: + explicit RecvThread(QObject *parent = NULL); + QTcpServer *recv_server; + QTcpSocket *recv_socket; + +public slots: + +signals: + void send_sortingResult(char*); + void SendPicInfo(char*); +// void read_plc(); +}; + +class RestartThread: public QThread +{ + Q_OBJECT + +private: + QMutex restr_mutex; + bool restr_flag; + +protected: + void run(); + +public: + explicit RestartThread(QObject *parent = NULL); + void restr_fun(); + +}; + + +#endif // THREAD_H diff --git a/widget.cpp b/widget.cpp new file mode 100644 index 0000000..8327c82 --- /dev/null +++ b/widget.cpp @@ -0,0 +1,1054 @@ +#include "widget.h" +#include "ui_widget.h" +#include +#include +#include +#include "thread.h" +#include +#include +#include +//#include +#include "src/modbus.h" + +# pragma execution_character_set("utf-8") + +#define ResultPath "D:/Log.txt" +Process_img * process_img; + +modbus_t* plc1; +camera *m_camera = nullptr; +correct *m_correct = nullptr; + +extern QSemaphore usebuff; +QSemaphore plc_signal(0); +int save_flag; //保存标志位 + +uint8_t learning_flag; +uint8_t light_flag; +uint8_t middle_flag; +uint8_t dark_flag; +int m_index; + +uint8_t adjust_exit_flag; +uint8_t adjust_correct_flag; +uint8_t restart_flag; + +int a = 0, b = 0, c = 0; + +#define SAVE_IMAGE_PATH "E:/527picture/" +#define WHITE_IMAGE_PATH "C:/Users/USER/Desktop/wood_aduiduiduiplus/build-wooden-Desktop_Qt_5_9_5_MSVC2017_64bit-Release/white" +#define BLACK_IMAGE_PATH "C:/Users/USER/Desktop/wood_aduiduiduiplus/build-wooden-Desktop_Qt_5_9_5_MSVC2017_64bit-Release/black" + +#define CORRECT_WIDTH 4096 +#define CORRECT_HEIGHT 3000 +#define Train_number 30 + +#define changeModel_path "D:/wood_color317/models" + +QString DirPath = "D:/picture/527paper"; + +Widget::Widget(QWidget *parent) : + QWidget(parent), + ui(new Ui::Widget) +{ + +// qDebug() << "1111111111111111"; + ui->setupUi(this); + m_camera = new camera; + init_window(); + plc_connect(); + ui->btn_Tab2_stop->setEnabled(false); + save_flag = 0; + send_thread = new SendThread(); + recv_thread = new RecvThread(); + send_thread->start(); + recv_thread->start(); + connect_signals(); + ui->btn_Tab2_light->setEnabled(false); + ui->btn_Tab2_middle->setEnabled(false); + ui->btn_Tab2_dark->setEnabled(false); + ui->btn_Tab2_train->setEnabled(false); + + ui->btn_Tab2_Preprocessing->setEnabled(false); + ui->btn_Tab2_show->setEnabled(false); + + learning_flag = 0; + light_flag = 0; + middle_flag = 0; + dark_flag = 0; + adjust_exit_flag = 0; + adjust_correct_flag = 0; + restart_flag = 0; + + restart_thread = new RestartThread(); + restart_thread->start(); + + ui->btn_Tab4_black->hide(); + ui->btn_Tab2_start_2->hide(); + ui->btn_Tab2_start_3->hide(); + ui->btn_Tab2_start_4->hide(); + + ui->btn_Tab4_wbcorrect->setEnabled(false); + ui->btn_Tab4_exit->setEnabled(false); + +} + +Widget::~Widget() +{ + delete ui; + delete [] m_camera->black_buf; + delete [] m_camera->white_buf; + +} + +void Widget::plc_connect() +{ + int status = -1; + plc1 = modbus_new_rtu("COM7", 115200, 'N', 8, 1); + modbus_set_slave(plc1, 4); //设置modbus从机地址 + status = modbus_connect(plc1); + if(status == -1) + { + qDebug() << "modbus connect failed"; + } + modbus_set_response_timeout(plc1, 0, 1000000); + qDebug() << "status" << status; + qDebug() << "connect plc success"; +} + +void Widget::connect_signals() +{ + //Tab_1 + connect(ui->btn_Tab1_1, SIGNAL(clicked()), this, SLOT(btn_Tab1_1_click())); + connect(ui->btn_Tab1_2, SIGNAL(clicked()), this, SLOT(btn_Tab1_2_click())); + //Tab_2 + connect(ui->btn_Tab2_mainMenu, SIGNAL(clicked()), this, SLOT(btn_Tab2_mainMenu_click())); + connect(ui->btn_Tab2_start, SIGNAL(clicked()), this, SLOT(btn_Tab2_start_click())); + connect(ui->btn_Tab2_stop, SIGNAL(clicked()), this, SLOT(btn_Tab2_stop_click())); + + connect(ui->btn_Tab2_autoLearning, SIGNAL(clicked()), this, SLOT(btn_Tab2_autoLearning_click())); + connect(ui->btn_Tab2_light, SIGNAL(clicked()), this, SLOT(btn_Tab2_light_click())); + connect(ui->btn_Tab2_middle, SIGNAL(clicked()), this, SLOT(btn_Tab2_middle_click())); + connect(ui->btn_Tab2_dark, SIGNAL(clicked()), this, SLOT(btn_Tab2_dark_click())); + connect(ui->btn_Tab2_train, SIGNAL(clicked()), this, SLOT(btn_Tab2_train_click())); + + //Tab_3 + connect(ui->btn_Tab3_cameraParasettings, SIGNAL(clicked()), this, SLOT(btn_Tab3_cameraParasettings_click())); + connect(ui->btn_Tab3_mainMenu, SIGNAL(clicked()), this, SLOT(btn_Tab3_mainMenu_click())); + connect(ui->btn_Tab3_saveImg, SIGNAL(clicked()), this, SLOT(btn_Tab3_saveImg_click())); + connect(ui->btn_Tab3_changeModel, SIGNAL(clicked()), this, SLOT(btn_Tab3_changeModel_click())); + //Tab_4 + connect(ui->btn_Tab4_return, SIGNAL(clicked()), this, SLOT(btn_Tab4_return_click())); + connect(ui->btn_Tab4_getCorrect, SIGNAL(clicked()), this, SLOT(btn_Tab4_getCorrect_click())); + + connect(ui->btn_Tab4_black, SIGNAL(clicked()), this, SLOT(btn_Tab4_black_click())); + connect(ui->btn_Tab4_white, SIGNAL(clicked()), this, SLOT(btn_Tab4_white_click())); + connect(ui->btn_Tab4_wbcorrect, SIGNAL(clicked()), this, SLOT(btn_Tab4_wbcorrect_click())); + + //Tab_5 + connect(ui->btn_Tab5_skip, SIGNAL(clicked()), this, SLOT(btn_Tab5_skip_click())); + + + + connect(recv_thread, SIGNAL(SendPicInfo(char*)), this, SLOT(showPic(char*)), Qt::BlockingQueuedConnection); + +} + +void Widget::init_window() +{ + ui->tabWidget->findChildren().at(0)->hide(); + ui->btn_Tab2_dark->hide(); + ui->tabWidget->setCurrentIndex(4); + + if(!m_camera->openCamera()) + { + qDebug() << "open camera failed"; + return; + } + + //校正 + m_camera->white_mat = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, cv::Scalar(0, 0, 0)); + m_camera->black_mat = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, cv::Scalar(0, 0, 0)); + m_camera->eps = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, cv::Scalar(0.00000001, 0.00000001, 0.00000001)); + m_camera->white_buf = new float[CORRECT_WIDTH*CORRECT_HEIGHT*3*4]; + m_camera->black_buf = new float[CORRECT_WIDTH*CORRECT_HEIGHT*3*4]; + + FILE* fp; + fp = fopen(WHITE_IMAGE_PATH, "rb"); + fread(m_camera->white_buf, 4, CORRECT_WIDTH*CORRECT_HEIGHT*3*4, fp); + fclose(fp); + fp = fopen(BLACK_IMAGE_PATH, "rb"); + fread(m_camera->black_buf, 4, CORRECT_WIDTH*CORRECT_HEIGHT*3*4, fp); + fclose(fp); + + m_camera->white_mat = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, m_camera->white_buf); + m_camera->black_mat = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, m_camera->black_buf); + + skip = new QTimer(); + connect(skip, SIGNAL(timeout()), this, SLOT(skip_Notime())); + skip->start(30000); + +} + +//Tab1 +void Widget::btn_Tab1_1_click() +{ + ui->tabWidget->setCurrentIndex(1); +} + +void Widget::btn_Tab1_2_click() +{ + ui->tabWidget->setCurrentIndex(2); +} + +//Tab2 +void Widget::showlabel(cv::Mat img) +{ +// qDebug() << count++; +// qDebug() << "save_flag: " << save_flag; + int counter = 0; + counter++; +// qDebug() << "counter: " << counter; +// if(save_flag && counter == 1) +// { +//// QDateTime time = QDateTime::currentDateTime(); +//// QString str = time.toString("yyyyMMddhhmmss"); +//// QString filepath = SAVE_IMAGE_PATH + str + ".png"; +//// qDebug() << filepath; +//// cv::imwrite(filepath.toLatin1().data(), img); + +// char fileName[64]; +// sprintf(fileName, "D:/save_image/rgb%d.png", m_index); + +// m_index++; +// qDebug() << fileName; +// cv::imwrite(fileName, img); +// counter = 0; + +// } + + static uint8_t light_index = 0; + if(learning_flag && counter == 1 && light_flag) + { + qDebug() << "learning light saved"; + qDebug() << "light_index: " << light_index; + char str[32]; + + //使用sprintf补0，QString使用.toLatin1().data()改变Path的格式 + char file[16]; + sprintf(file, "rgb%02d.png", light_index);//定义图片保存名file + QString Name = QString(QLatin1String(file)); + QString fileName = DirPath + "//hua//" + Name;//形如D://2023//wooden//2023318//light//rgb00.png + + sprintf(str, "light number:%d", ++light_index); + if(light_index == Train_number) + { + cv::imwrite(fileName.toLatin1().data(), img); + ui->label_showSorting->setText("花纹木板采集完成"); + m_camera->stopCapture(); + ui->btn_Tab2_middle->setEnabled(true); + light_flag = 0; + } + else + { + QString s = QString(str); + ui->label_showSorting->setText(s); + qDebug() << fileName; + cv::imwrite(fileName.toLatin1().data(), img); + } + counter = 0; + } + + static uint8_t middle_index = 0; + if(learning_flag && counter == 1 && middle_flag) + { + qDebug() << "learning middle saved"; + qDebug() << "middle_index: " << middle_index; + char str[32]; + char file[16]; + sprintf(file, "rgb%02d.png", middle_index + 30);//定义图片保存名file + QString Name = QString(QLatin1String(file)); + QString fileName = DirPath + "//zhi//" + Name; + +// sprintf(fileName, "E:/autoLearning/middle/rgb%02d.png", middle_index); + sprintf(str, "middle number:%d", ++middle_index); + if(middle_index == Train_number) + { + cv::imwrite(fileName.toLatin1().data(), img); + ui->label_showSorting->setText("直纹木板采集完成"); + m_camera->stopCapture(); + ui->btn_Tab2_dark->setEnabled(true); + middle_flag = 0; + } + else + { + QString s = QString(str); + ui->label_showSorting->setText(s); + qDebug() << fileName; + cv::imwrite(fileName.toLatin1().data(), img); + } + counter = 0; + } + +// static uint8_t dark_index = 0; +// if(learning_flag && counter == 1 && dark_flag) +// { +// qDebug() << "learning dark saved"; +// qDebug() << "dark_index: " << dark_index; +// char str[32]; +// char file[16]; +// sprintf(file, "rgb%02d.png", dark_index + 60);//定义图片保存名file +// QString Name = QString(QLatin1String(file)); +// QString fileName = DirPath + "//dark//" + Name; +//// sprintf(fileName, "E:/autoLearning/dark/rgb%02d.png", dark_index); +// sprintf(str, "dark number:%d", ++dark_index); +// if(dark_index == Train_number) +// { +// cv::imwrite(fileName.toLatin1().data(), img); +// ui->label_showSorting->setText("深色木板采集完成"); +// m_camera->stopCapture(); +// ui->btn_Tab2_Preprocessing->setEnabled(true); +// dark_flag = 0; +// } +// else +// { +// QString s = QString(str); +// ui->label_showSorting->setText(s); +// qDebug() << fileName; +// cv::imwrite(fileName.toLatin1().data(), img); +// } +// counter = 0; +// } + +// char fileName[64]; +// sprintf(fileName, "E:/88/rgb%d.png", m_index++); +// cv::imwrite(fileName, img); + + cv::cvtColor(img, img, CV_BGR2RGB); + const unsigned char *pSrc = (const unsigned char*)img.data; + QImage image(pSrc, img.cols, img.rows, img.step, QImage::Format_RGB888); + pix = QPixmap::fromImage(image.scaled(ui->showlabel->width(), ui->showlabel->height(), Qt::KeepAspectRatio)); + ui->showlabel->setPixmap(pix); + ui->showlabel->show(); +// Sleep(150); + m_camera->m_buffer->Clear(); +} + +void Widget::btn_Tab2_start_click() +{ + + learning_flag = 0; +// m_camera->m_pAcq->SetParameter(CORACQ_PRM_FRAME_LENGTH, CORACQ_VAL_FRAME_LENGTH_VARIABLE, TRUE); + process_img = new Process_img(this); + connect(process_img, SIGNAL(show_img(cv::Mat)), this, SLOT(showlabel(cv::Mat)), Qt::BlockingQueuedConnection); + connect(recv_thread, SIGNAL(send_sortingResult(char*)), this, SLOT(showlabelSorting(char*)), Qt::BlockingQueuedConnection); +// connect(recv_thread, SIGNAL(SendPicInfo(char*)), this, SLOT(showPic(char*)), Qt::BlockingQueuedConnection); + + m_camera->startCapture(); + process_img->start(); + + ui->btn_Tab2_start->setEnabled(false); + ui->btn_Tab2_stop->setEnabled(true); +//打印分选时间戳 + QDateTime curDateTime = QDateTime::currentDateTime(); + QString tmp1 =curDateTime.toString("yyyy-MM-dd hh:mm:ss"); + QByteArray tmp2 = tmp1.toLatin1(); + tmp2.append(QString::fromUtf8("开始分选\n")); + int len = tmp2.size(); + char* ch = tmp2.data(); + FILE* fp; + fp = fopen(ResultPath, "a+"); + fwrite(ch, len, 1, fp); + + fclose(fp); + ch = NULL; + +} + +void Widget::btn_Tab2_stop_click() +{ + qDebug() << "S: " << a; + qDebug() << "Z: " << b; + qDebug() << "Q: " << c; + +/***************打印时间戳分选结果(形如Q:0 Z:0 S:0 sum:0)*************/ + FILE* fp; + fp = fopen(ResultPath, "a+"); + QString Result = "Q:" + QString::number(c) + " Z:" + QString::number(b) + " S:" + QString::number(a) + " sum:" + QString::number(count); + char* ch = Result.toLatin1().data(); + int len = Result.size(); + fwrite(ch, len, 1, fp); + + QDateTime curDateTime = QDateTime::currentDateTime(); + QString tmp1 =curDateTime.toString("\nyyyy-MM-dd hh:mm:ss"); + QByteArray tmp2 = tmp1.toLatin1(); + tmp2.append(QString::fromUtf8("结束分选\n\n")); + len = tmp2.size(); + ch = tmp2.data(); + + fwrite(ch, len, 1, fp); + + fclose(fp); + ch = NULL; +/*** **** ***** **** ***/ + disconnect(process_img, SIGNAL(show_img(cv::Mat)), this, SLOT(showlabel(cv::Mat))); + disconnect(recv_thread, SIGNAL(send_sortingResult(char*)), this, SLOT(showlabelSorting(char*))); + qDebug() << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + + m_camera->stopCapture(); +// a->closeCamera(); + process_img->exitThread(); + process_img->wait(); + if(process_img->isFinished()) + qDebug() <<"process thread finish"; + delete process_img; + + ui->btn_Tab2_start->setEnabled(true); + ui->btn_Tab2_stop->setEnabled(false); + + a = 0; + b = 0; + c = 0; + count = 0; +} + +void Widget::btn_Tab2_mainMenu_click() +{ + ui->tabWidget->setCurrentIndex(0); +} + +void Widget::showlabelSorting(char *buf) +{ + + uint16_t tmp = 0; +// qDebug() << "AAAAAAAAAAA"; + switch(buf[0]) + { + case 'H': + ++a; +// qDebug() << "S:" << a; + tmp = 0; + ui->label_showSorting->setText(QString::fromStdString("花纹")); + if(modbus_write_registers(plc1, 0x400002, 1, &tmp) == -1) + qDebug() << "dark write error"; + qDebug() << "识别结果:" << tmp; + Sleep(10); + tmp = 1; + if(modbus_write_registers(plc1, 0x400001, 1, &tmp) == -1) + qDebug() << "R1 error"; + break; + + case 'Z': + ++b; +// qDebug() << "Z:" << b; + tmp = 1; + ui->label_showSorting->setText(QString::fromStdString("直纹")); + if(modbus_write_registers(plc1, 0x400002, 1, &tmp) == -1) + qDebug() << "middle write error"; + qDebug() << "识别结果:" << tmp; + Sleep(10); + tmp = 1; + if(modbus_write_registers(plc1, 0x400001, 1, &tmp) == -1) + qDebug() << "R1 error"; + break; + +// case 'Q': +// ++c; +//// qDebug() << "Q:" << c; +// tmp = 2; +// ui->label_showSorting->setText(QString::fromStdString("浅色 ")); +// if(modbus_write_registers(plc1, 0x400002, 1, &tmp) == -1) +// qDebug() << "light write error"; +// qDebug() << "识别结果:" << tmp; +// Sleep(10); +// tmp = 1; +// if(modbus_write_registers(plc1, 0x400001, 1, &tmp) == -1) +// qDebug() << "R1 error"; +// break; + + case 'A': + ui->label_showSorting->setText(QString::fromStdString("训练模型完成")); + break; + + case 'D': + ui->label_showSorting->setText(QString::fromStdString("切换模型完成")); + break; + + default: + break; + } + +} + + + +void Widget::btn_Tab2_autoLearning_click() +{ + //创建存图文件夹 + QString DirName = QInputDialog::getText(this,"存图路径","请输入文件夹名称（英文与数字）：",QLineEdit::Normal); + if(DirName.size() == 0) + { + QMessageBox::warning(NULL, "警告", "输入图片文件夹名为空,请重新操作！"); + return; + } + //创建文件夹 + DirPath = "D:/picture/" + DirName;//DirPath设置全局变量523 + QDir dir(DirPath); + if (!dir.exists()) + { + dir.mkdir(DirPath); + } + else + { + QMessageBox::warning(NULL, "警告", "输入图片文件夹名重复,请重新操作！"); + return; + } + + ui->btn_Tab2_light->setEnabled(true); + learning_flag = 1; + ui->label_showSorting->setText(QString::fromStdString("请点击保存浅色 ")); +} + +void Widget::btn_Tab2_light_click() +{ + QString DirPathLight = DirPath + "/hua"; + QDir dir(DirPathLight); + if (!dir.exists()) + { + dir.mkdir(DirPathLight); + } + + light_flag = 1; + ui->label_showSorting->setText(QString::fromStdString("请放花纹木板")); + process_img = new Process_img(this); + connect(process_img, SIGNAL(show_img(cv::Mat)), this, SLOT(showlabel(cv::Mat)), Qt::BlockingQueuedConnection); + + m_camera->startCapture(); + process_img->start(); + ui->btn_Tab2_light->setEnabled(false); + +} + +void Widget::btn_Tab2_middle_click() +{ + QString DirPathMiddle = DirPath + "/zhi"; + QDir dir(DirPathMiddle); + if (!dir.exists()) + { + dir.mkdir(DirPathMiddle); + } + ui->label_showSorting->setText(QString::fromStdString("请放直纹木板")); + middle_flag = 1; + m_camera->startCapture(); + + ui->btn_Tab2_middle->setEnabled(false); + +} + +void Widget::btn_Tab2_dark_click() +{ + QString DirPathDark = DirPath + "/dark"; + QDir dir(DirPathDark); + + if (!dir.exists()) + { + dir.mkdir(DirPathDark); + } + + dark_flag = 1; + ui->label_showSorting->setText(QString::fromStdString("请放深色木板")); + + m_camera->startCapture(); + + ui->btn_Tab2_dark->setEnabled(false); + +} + + +void Widget::on_btn_Tab2_Preprocessing_clicked() +{ + + char fileName[64]; + +// QString DirPathSolid = "D:/picture/524test/"; +// sprintf(fileName, DirPathSolid.toLatin1().data()); + + sprintf(fileName, DirPath.toLatin1().data()); + + + uint8_t* sendbuf = new uint8_t[strlen(fileName)+12]; + sendbuf[0] = 0xAA; + sendbuf[1] = 0x00; + sendbuf[2] = 0x00; + sendbuf[3] = 0x00; + sendbuf[4] = strlen(fileName)+4; + sendbuf[5] = ' '; + sendbuf[6] = ' '; + sendbuf[7] = 'K'; + sendbuf[8] = 'M'; + memcpy(sendbuf+9, fileName, strlen(fileName)); + sendbuf[strlen(fileName) + 9] = 0xFF; + sendbuf[strlen(fileName) + 10] = 0xFF; + sendbuf[strlen(fileName) + 11] = 0xBB; + + send_thread->send_socket->write((const char*)sendbuf, strlen(fileName) + 12); + send_thread->send_socket->flush(); + qDebug() << "====send DirName success===="; + + +} + +void Widget::showPic(char* buf1) +{ + qDebug() << "111"; + pic = new showpic(buf1); + + connect(pic, SIGNAL(PictureReady()), this, SLOT(PictureProcess())); + + ui->btn_Tab2_show->setEnabled(true); + ui->btn_Tab2_Preprocessing->setEnabled(false); +} + +void Widget::on_btn_Tab2_show_clicked() +{ + pic->show(); + //522 + ui->btn_Tab2_show->setEnabled(false); + ui->btn_Tab2_train->setEnabled(true); +} + + +void Widget::btn_Tab2_train_click() +{ + ui->btn_Tab2_train->setEnabled(false); + disconnect(process_img, SIGNAL(show_img(cv::Mat)), this, SLOT(showlabel(cv::Mat))); + process_img->exitThread(); + process_img->wait(); + if(process_img->isFinished()) + qDebug() <<"process thread finish"; + delete process_img; + + char fileName[64]; + sprintf(fileName, DirPath.toLatin1().data()); + +// uint8_t* sendbuf = new uint8_t[strlen(fileName)+12]; +//// uint8_t sendbuf[strlen(fileName) + 12]; +// sendbuf[0] = 0xAA; +// sendbuf[1] = 0x00; +// sendbuf[2] = 0x00; +// sendbuf[3] = 0x00; +// sendbuf[4] = 0x13; +// sendbuf[5] = ' '; +// sendbuf[6] = ' '; +// sendbuf[7] = 'T'; +// sendbuf[8] = 'R'; +// memcpy(sendbuf+9, fileName, 15); +// sendbuf[strlen(fileName) + 9] = 0xFF; +// sendbuf[strlen(fileName) + 10] = 0xFF; +// sendbuf[strlen(fileName) + 11] = 0xBB; + +// send_thread->send_socket->write((const char*)sendbuf, strlen(fileName) + 12); +// send_thread->send_socket->flush(); +// qDebug() << "====send fileName success===="; + + + //先定义 标题，提示框 + QString ModelName = QInputDialog::getText(this,"命名","请给本次训练的模型命名：",QLineEdit::Normal); + if(ModelName.size() == 0) + { + QMessageBox::warning(NULL, "警告", "输入模型名为空,请重新操作！"); + return; + } + + QString cut = "$"; + QString Dir_ModelName = DirPath + cut + ModelName; + + qDebug() << "Dir+DirName" << Dir_ModelName; + int len = Dir_ModelName.length(); + uint8_t* assign_buf = new uint8_t[len+12]; + char* ba = Dir_ModelName.toLatin1().data(); + + if(len > 0) + { + assign_buf[0] = 0xAA; + assign_buf[1] = 0x00; + assign_buf[2] = 0x00; + assign_buf[3] = 0x00; + assign_buf[4] = len+4; + assign_buf[5] = ' '; + assign_buf[6] = ' '; + assign_buf[7] = 'T'; + assign_buf[8] = 'R'; + memcpy(assign_buf+9, ba, len); + assign_buf[len+9] = 0xFF; + assign_buf[len+10] = 0xFF; + assign_buf[len+11] = 0xBB; + send_thread->send_socket->write((const char*)assign_buf, len+12); + send_thread->send_socket->flush(); + qDebug() << "====send fileName success===="; + } + else + { + return; + } +} + + + +//Tab3 +void Widget::btn_Tab3_cameraParasettings_click() +{ + ui->tabWidget->setCurrentIndex(3); + //设置相机参数 + //设置相机采集模式 + +} + +void Widget::btn_Tab3_mainMenu_click() +{ + ui->tabWidget->setCurrentIndex(0); +} + +void Widget::showimage_test(cv::Mat img) +{ +// cv::cvtColor(img, img, CV_BGRA2BGR); +// cv::Mat img_gray; +// cv::cvtColor(img, img_gray, CV_RGB2BGRA); + + cv::cvtColor(img, img, CV_BGR2RGB); + int value = 0; + for(int i=300; i<400; i++) + { + for(int j=300; j<400; j++) + { + value += img.ptr(i)[j]; + } + } + float bringhtness = value / 10000.0; + ui->label_Tab4_2->setText(QString("%1").arg(bringhtness)); + const unsigned char *pSrc = (const unsigned char*)img.data; + QImage image(pSrc, img.cols, img.rows, img.step, QImage::Format_RGB888); + pix_test = QPixmap::fromImage(image.scaled(ui->showlabel_set->width(), ui->showlabel_set->height(), Qt::KeepAspectRatio)); + ui->showlabel_set->setPixmap(pix_test); + ui->showlabel_set->show(); + +} + +void Widget::btn_Tab3_saveImg_click() +{ + if(save_flag == 1) + { + save_flag = 0; + ui->btn_Tab3_saveImg->setText(QString::fromStdString("保存图片 ")); + } + else + { + save_flag = 1; + ui->btn_Tab3_saveImg->setText(QString::fromStdString(" 不要保存图片 ")); + } +} + +void Widget::btn_Tab3_changeModel_click() +{ + QString fileName = QFileDialog::getOpenFileName(NULL, "切换模型", changeModel_path, "*.p"); + int len = fileName.length(); + uint8_t* assign_buf = new uint8_t[len+12]; + char* ba = fileName.toLatin1().data(); + if(len > 0) + { + assign_buf[0] = 0xAA; + assign_buf[1] = 0x00; + assign_buf[2] = 0x00; + assign_buf[3] = 0x00; + assign_buf[4] = len+4; + assign_buf[5] = ' '; + assign_buf[6] = ' '; + assign_buf[7] = 'M'; + assign_buf[8] = 'D'; + memcpy(assign_buf+9, ba, len); + assign_buf[len+9] = 0xFF; + assign_buf[len+10] = 0xFF; + assign_buf[len+11] = 0xBB; + send_thread->send_socket->write((const char*)assign_buf, len+12); + send_thread->send_socket->flush(); + } + else + { + return; + } +} + +//Tab4 +void Widget::btn_Tab4_return_click() +{ + if(restart_flag) + { + + ui->btn_Tab4_return->setEnabled(false); + restart_thread->restr_fun(); + restart_flag = 0; + + connect(dafei, SIGNAL(timeout()), this, SLOT(dafei_slot())); + ui->btn_Tab4_return->setText("参数设置"); + dafei->start(20000); + ui->btn_Tab4_return->setEnabled(true); + } + else + { + ui->tabWidget->setCurrentIndex(2); + + } + +} + +void Widget::dafei_slot() +{ + ui->btn_Tab4_white->setEnabled(true); + ui->btn_Tab4_getCorrect->setEnabled(true); + dafei->stop(); + ui->btn_Tab4_return->setText("返回"); + ui->tabWidget->setCurrentIndex(2); +} + +void Widget::btn_Tab4_getCorrect_click() +{ + m_camera->m_pAcq->SetParameter(CORACQ_PRM_EXT_FRAME_TRIGGER_ENABLE, FALSE, TRUE); + m_camera->m_pAcq->SetParameter(CORACQ_PRM_FRAME_LENGTH, CORACQ_VAL_FRAME_LENGTH_FIX, TRUE); + adjust_exit_flag = 1; + adjust_correct_flag = 1; + adjust_para = new Adjust_para(this); + connect(adjust_para, SIGNAL(send_image_debug(cv::Mat)), this, SLOT(showimage_test(cv::Mat)), Qt::BlockingQueuedConnection); + connect(this, SIGNAL(correct_signal()), adjust_para, SLOT(get_correct_signal())); + m_camera->startCapture(); + adjust_para->start(); + qDebug() << "get correct"; +// emit correct_signal(); + + ui->btn_Tab4_white->setEnabled(false); + ui->btn_Tab4_exit->setEnabled(true); + ui->btn_Tab4_return->setEnabled(false); + +} + +void Widget::on_btn_Tab4_exit_clicked() +{ + disconnect(adjust_para, SIGNAL(send_image_debug(cv::Mat)), this, SLOT(showimage_test(cv::Mat))); + disconnect(this, SIGNAL(correct_signal()), adjust_para, SLOT(get_correct_signal())); + m_camera->stopCapture(); + + adjust_para->exitThread(); + adjust_para->wait(); + if(adjust_para->isFinished()) + { + qDebug() << "dajust_para thread finish"; + } + delete adjust_para; + + adjust_exit_flag = 0; + adjust_correct_flag = 0; + //更改相机触发模式为外触发 + if(m_camera->m_pAcq->SetParameter(CORACQ_PRM_FRAME_LENGTH, 0x00000002, FALSE)) + qDebug() << "set success"; + else + qDebug() << "set error"; + m_camera->m_pAcq->SetParameter(CORACQ_PRM_EXT_FRAME_TRIGGER_ENABLE, TRUE, TRUE); + + if(m_camera->m_buffer && *m_camera->m_buffer) + { + m_camera->m_buffer->Destroy(); + qDebug() << "1111"; + } + + if(m_camera->m_pAcq && *m_camera->m_pAcq) + { + m_camera->m_pAcq->Destroy(); + qDebug() << "2222"; + } + + if(m_camera->m_trans) + { + delete m_camera->m_trans; + qDebug() << "3333"; + } + + if(m_camera->m_buffer) + { + delete m_camera->m_buffer; + qDebug() << "4444"; + } + + if(m_camera->m_pAcq) + { + delete m_camera->m_pAcq; + qDebug() << "5555"; + } + + if(m_camera->m_loc) + { + delete m_camera->m_loc; + qDebug() << "6666"; + } + + restart_flag = 1; + ui->btn_Tab4_return->setEnabled(true); + +} + +void Widget::PictureProcess() +{ + ui->label_showSorting->setText(QString::fromStdString("图片预处理完成")); +} + +void Widget::btn_Tab4_black_click() +{ + qDebug() << "black start"; +// ui->btn_Tab4_black->setDisabled(true); +// ui->btn_Tab4_white->setDisabled(true); + + //加锁 + m_camera->capture_black_flag = true; +// m_camera->ret_SCorrect = m_camera->startCorrect(); + qDebug() << "black end"; +} + + +void Widget::btn_Tab4_white_click() +{ + m_camera->m_pAcq->SetParameter(CORACQ_PRM_EXT_FRAME_TRIGGER_ENABLE, FALSE, TRUE); + m_camera->m_pAcq->SetParameter(CORACQ_PRM_FRAME_LENGTH, CORACQ_VAL_FRAME_LENGTH_FIX, TRUE); + m_camera->capture_white_flag = true; + m_camera->startCorrect(); + + ui->btn_Tab4_getCorrect->setEnabled(false); + ui->btn_Tab4_wbcorrect->setEnabled(true); + ui->btn_Tab4_return->setEnabled(false); + +} + + +void Widget::btn_Tab4_wbcorrect_click() +{ + m_camera->stopCorrect(); + //更改相机触发模式为外触发 + m_camera->m_pAcq->SetParameter(CORACQ_PRM_FRAME_LENGTH, CORACQ_VAL_FRAME_LENGTH_VARIABLE, TRUE); + m_camera->m_pAcq->SetParameter(CORACQ_PRM_EXT_FRAME_TRIGGER_ENABLE, TRUE, TRUE); + + + FILE* fp; + fp = fopen(WHITE_IMAGE_PATH, "rb"); + fread(m_camera->white_buf, 4, CORRECT_WIDTH*CORRECT_HEIGHT*3*4, fp); + fclose(fp); + fp = fopen(BLACK_IMAGE_PATH, "rb"); + fread(m_camera->black_buf, 4, CORRECT_WIDTH*CORRECT_HEIGHT*3*4, fp); + fclose(fp); + + m_camera->white_mat = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, m_camera->white_buf); + m_camera->black_mat = cv::Mat(CORRECT_HEIGHT, CORRECT_WIDTH, CV_32FC3, m_camera->black_buf); + + if(m_camera->m_buffer && *m_camera->m_buffer) + { + m_camera->m_buffer->Destroy(); + qDebug() << "aaaa"; + } + + if(m_camera->m_pAcq && *m_camera->m_pAcq) + { + m_camera->m_pAcq->Destroy(); + qDebug() << "bbbb"; + } + + if(m_camera->c_trans) + { + delete m_camera->c_trans; + qDebug() << "cccc"; + } + + if(m_camera->m_buffer) + { + delete m_camera->m_buffer; + qDebug() << "dddd"; + } + + if(m_camera->m_pAcq) + { + delete m_camera->m_pAcq; + qDebug() << "eeee"; + } + + if(m_camera->m_loc) + { + delete m_camera->m_loc; + qDebug() << "ffff"; + } + + restart_flag = 1; + ui->btn_Tab4_return->setEnabled(true); + +} + +void Widget::on_btn_Tab2_start_2_clicked() +{ +// write_modbus(0x400001, 2); +// write_modbus(0x400002, 2); + char fileName[64]; + sprintf(fileName, "E:/autoLearning"); + int len = strlen(fileName); + qDebug() << len; +} + +void Widget::on_btn_Tab2_start_3_clicked() +{ +// write_modbus(0x400001, 1); +// uint16_t tmp = 900; +// int ret = modbus_write_registers(plc1, 0x400002, 1, &tmp); +// if(ret == -1) +// qDebug() << "write error"; +// else +// qDebug() << "write success"; + + uint16_t tmp = 0; + uint16_t arr[9] = {0x400001, 0x400002, 0x400003, 0x400004, 0x400005, 0x400006, 0x400007, 0x400008, 0x400009}; + for(int i = 0; i < 9; i++) + { + tmp = i; + int ret = modbus_write_registers(plc1, arr[i], 1, &tmp); + if(ret == -1) + qDebug() << "write error"; + else + qDebug() << "write success"; + Sleep(100); + } + +} + +void Widget::on_btn_Tab2_start_4_clicked() +{ +// write_modbus(0x400001, 0); + uint16_t tmp = 2; + int ret = modbus_read_registers(plc1, 0x400002, 1, &tmp); + if(ret == -1) + qDebug() << "write error"; + else + qDebug() << "read success: " <tabWidget->setCurrentIndex(0); + skip->stop(); + disconnect(skip, SIGNAL(timeout()), this, SLOT(skip_Notime())); + delete skip; +} + +void Widget::skip_Notime() +{ + ui->tabWidget->setCurrentIndex(0); + disconnect(skip, SIGNAL(timeout()), this, SLOT(skip_Notime())); + delete skip; +} + + + + + diff --git a/widget.h b/widget.h new file mode 100644 index 0000000..e95d13f --- /dev/null +++ b/widget.h @@ -0,0 +1,109 @@ +#ifndef WIDGET_H +#define WIDGET_H + +#define WIN32_LEAN_AND_MEAN +#include +#include "camera.h" +#include "opencv2/opencv.hpp" +#include "opencv2/imgproc/types_c.h" +#include +#include "correct.h" +#include +#include +#include +#include +#include +#include "showpic.h" + +#pragma comment(lib,"ws2_32.lib") + +class QModbusClient; +class QModbusReply; + +namespace Ui { +class Widget; +} + +class Widget : public QWidget +{ + Q_OBJECT + +public: + explicit Widget(QWidget *parent = 0); + ~Widget(); + void plc_connect(); + +private slots: + //button + //Tab_1 + void btn_Tab1_1_click(); + void btn_Tab1_2_click(); + + //Tab_2 + void showlabel(cv::Mat); + void btn_Tab2_start_click(); + void btn_Tab2_stop_click(); + void btn_Tab2_mainMenu_click(); + void showlabelSorting(char*); + void btn_Tab2_autoLearning_click(); + void btn_Tab2_light_click(); + void btn_Tab2_middle_click(); + void btn_Tab2_dark_click(); + void on_btn_Tab2_Preprocessing_clicked(); + void on_btn_Tab2_show_clicked(); + void btn_Tab2_train_click(); + void showPic(char*); + //Tab_3 + void btn_Tab3_cameraParasettings_click(); + void btn_Tab3_mainMenu_click(); + void showimage_test(cv::Mat); + void btn_Tab3_saveImg_click(); + void btn_Tab3_changeModel_click(); + //Tab_4 + void btn_Tab4_return_click(); + void btn_Tab4_getCorrect_click(); + void btn_Tab4_black_click(); + void btn_Tab4_white_click(); + void btn_Tab4_wbcorrect_click(); + void on_btn_Tab2_start_2_clicked(); + void on_btn_Tab2_start_3_clicked(); + void on_btn_Tab2_start_4_clicked(); + + void dafei_slot(); + + //Tab_5 + void btn_Tab5_skip_click(); + void skip_Notime(); + + void on_btn_Tab4_exit_clicked(); + + //picture + void PictureProcess(); + + + +private: + Ui::Widget *ui; + + Adjust_para * adjust_para; + QPixmap pix; + QPixmap pix_test; + SendThread *send_thread = nullptr; + RecvThread *recv_thread = nullptr; + + QTimer *skip; + + QTimer* dafei = new QTimer; + void connect_signals(); + void init_window(); + + RestartThread *restart_thread = nullptr; + + showpic *pic = nullptr; + +signals: + void correct_signal(); +}; + + +#endif // WIDGET_H diff --git a/widget.ui b/widget.ui new file mode 100644 index 0000000..fd5fe6b --- /dev/null +++ b/widget.ui @@ -0,0 +1,776 @@ + + + Widget + + + + 0 + 0 + 1038 + 701 + + + + Widget + + + + + 0 + 0 + 1041 + 701 + + + + + Arial + 9 + + + + background-color: rgb(218, 239, 252); + + + 1 + + + + Tab 1 + + + + + 200 + 90 + 631 + 121 + + + + + Arial + 72 + + + + color:rgb(0, 0, 0); +background-color: rgb(153, 204, 153); +border-radius: 50px; + + + 木地板分选 + + + Qt::AlignCenter + + + + + + 190 + 440 + 211 + 81 + + + + + 36 + + + + color: rgb(153, 102, 51); +border-radius:20px; +background-color:rgb(170, 214, 255); +border-width:4px; + + + 分选页面 + + + + + + 630 + 440 + 211 + 81 + + + + + 36 + + + + color: rgb(153, 102, 51); +border-radius:20px; +background-color:rgb(170, 214, 255); +border-width:4px; + + + 详细设置 + + + + + + Tab 2 + + + + + 0 + 0 + 611 + 431 + + + + background-color: rgb(0, 0, 0); + + + TextLabel + + + + + + 670 + 498 + 121 + 61 + + + + + 22 + + + + 开始 + + + + + + 870 + 498 + 121 + 61 + + + + + 22 + + + + 结束 + + + + + + 40 + 498 + 150 + 61 + + + + + 24 + + + + color: rgb(238, 238, 236); +border-radius:15px; +background-color: rgb(136, 138, 133); +border-width:4px; + + + 主菜单 + + + + + + 0 + 430 + 611 + 51 + + + + + Arial + 33 + + + + color:rgb(0, 0, 0); +background-color: rgb(153, 204, 153); +border-radius: 50px; + + + + + + Qt::AlignCenter + + + + + + 640 + 20 + 381 + 381 + + + + 自学习 + + + + + 30 + 50 + 121 + 61 + + + + + 22 + + + + 自学习 + + + + + + 30 + 140 + 121 + 61 + + + + + 22 + + + + 保存花纹 + + + + + + 220 + 140 + 121 + 61 + + + + + 22 + + + + 保存直纹 + + + + + + 30 + 230 + 121 + 61 + + + + + 22 + + + + 保存深色 + + + + + + 220 + 310 + 121 + 61 + + + + + 22 + + + + 训练模型 + + + + + + 220 + 230 + 121 + 61 + + + + + 17 + + + + 图片预处理 + + + + + + 30 + 310 + 121 + 61 + + + + + 17 + + + + 图片展示 + + + + + + + 520 + 580 + 121 + 61 + + + + + 22 + + + + light + + + + + + 670 + 580 + 121 + 61 + + + + + 22 + + + + middle + + + + + + 820 + 580 + 121 + 61 + + + + + 22 + + + + dark + + + + + + 页 + + + + + 0 + 30 + 180 + 58 + + + + + 30 + + + + color: rgb(238, 238, 236); +background-color: rgb(204, 0, 0); +border-radius:10px; + + + 详细设置 + + + Qt::AlignCenter + + + + + + 210 + 140 + 211 + 61 + + + + color: rgb(238, 238, 236); +border-radius:10px; +background-color: rgb(136, 138, 133); +font: 24pt "Ubuntu"; +border-width:4px; + + + 相机校正 + + + + + + 820 + 560 + 150 + 61 + + + + color: rgb(238, 238, 236); +border-radius:10px; +background-color: rgb(136, 138, 133); +font: 24pt "Ubuntu"; +border-width:4px; + + + 主菜单 + + + + + + 570 + 140 + 211 + 61 + + + + color: rgb(238, 238, 236); +border-radius:10px; +background-color: rgb(136, 138, 133); +font: 24pt "Ubuntu"; +border-width:4px; + + + 保存图片 + + + + + + 210 + 260 + 211 + 61 + + + + color: rgb(238, 238, 236); +border-radius:10px; +background-color: rgb(136, 138, 133); +font: 24pt "Ubuntu"; +border-width:4px; + + + 切换模型 + + + + + + 页 + + + + + 730 + 560 + 261 + 51 + + + + + 24 + + + + color: rgb(238, 238, 236); +background-color: rgb(136, 138, 133); +border-radius:10px; + + + 返回 + + + + + + 0 + 0 + 591 + 401 + + + + background-color: rgb(0, 0, 0); + + + TextLabel + + + + + + 150 + 530 + 281 + 101 + + + + + 17 + + + + 亮度值 + + + + + + 250 + 550 + 141 + 71 + + + + + + + + + + 660 + 130 + 121 + 61 + + + + + 22 + + + + 黑场采集 + + + + + + 810 + 130 + 121 + 61 + + + + + 22 + + + + 白场采集 + + + + + + 810 + 210 + 121 + 61 + + + + + 22 + + + + 黑白校正 + + + + + + 310 + 430 + 211 + 61 + + + + + 22 + + + + 停止显示 + + + + + + 30 + 430 + 211 + 61 + + + + + 22 + + + + 显示图像亮度 + + + + + + 页 + + + + + 30 + 90 + 971 + 121 + + + + + Arial + 64 + + + + color:rgb(0, 0, 0); +background-color: rgb(153, 204, 153); +border-radius: 50px; + + + 木地板颜色分选系统 + + + Qt::AlignCenter + + + + + + 270 + 310 + 441 + 51 + + + + + Arial + 33 + + + + color:rgb(0, 0, 0); +background-color: rgb(255, 192, 203); +border-radius: 50px; + + + 光源预热中... + + + Qt::AlignCenter + + + + + + 840 + 540 + 121 + 61 + + + + + 22 + + + + 忽略 + + + + + + + + + diff --git a/wooden.pro b/wooden.pro new file mode 100644 index 0000000..cf7b7ae --- /dev/null +++ b/wooden.pro @@ -0,0 +1,91 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2022-03-18T10:12:37 +# +#------------------------------------------------- + +QT += core gui network serialbus serialport + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +TARGET = wooden +TEMPLATE = app + +LIBS += -Ldll -lws2_32 + +# The following define makes your compiler emit warnings if you use +# any feature of Qt which as been marked as deprecated (the exact warnings +# depend on your compiler). Please consult the documentation of the +# deprecated API in order to know how to port your code away from it. +DEFINES += QT_DEPRECATED_WARNINGS + +# You can also make your code fail to compile if you use deprecated APIs. +# In order to do so, uncomment the following line. +# You can also select to disable deprecated APIs only up to a certain version of Qt. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + + +SOURCES += \ + main.cpp \ + widget.cpp \ + camera.cpp \ + thread.cpp \ + correct.cpp \ + src/modbus.c \ + src/modbus-data.c \ + src/modbus-rtu.c \ + src/modbus-tcp.c \ + showpic.cpp \ + relistwidget_item.cpp \ + imagewin.cpp + +HEADERS += \ + widget.h \ + camera.h \ + thread.h \ + correct.h \ + src/modbus.h \ + src/modbus-private.h \ + src/modbus-rtu.h \ + src/modbus-rtu-private.h \ + src/modbus-tcp.h \ + src/modbus-tcp-private.h \ + src/modbus-version.h \ + showpic.h \ + relistwidget_item.h \ + imagewin.h + +FORMS += \ + widget.ui \ + showpic.ui \ + imagewin.ui + +#LIBS += -LC:/opencv/build/x64/vc15/lib -lopencv_world453 + +#INCLUDEPATH += C:/opencv/build/include \ +# += C:/opencv/build/include/opencv2 + +#LIBS += -LC:/Users/lzy/Downloads/opencv/build/x64/vc15/lib -lopencv_world453 + +#INCLUDEPATH += C:/Users/lzy/Downloads/opencv/build/include \ +# += C:/Users/lzy/Downloads/opencv/build/include/opencv2 + +LIBS += -LC:/Users/USER/Downloads/opencv/build/x64/vc15/lib -lopencv_world453 + +INCLUDEPATH += C:/Users/USER/Downloads/opencv/build/include \ + += C:/Users/USER/Downloads/opencv/build/include/opencv2 + +LIBS += -L'C:/Program Files/Teledyne DALSA/Sapera/Lib/Win64' -lSapClassBasic +LIBS += -L'C:/Program Files/Teledyne DALSA/Sapera/Lib/Win64' -lcorapi + +INCLUDEPATH += 'C:/Program Files/Teledyne DALSA/Sapera/Include' +DEPENDPATH += 'C:/Program Files/Teledyne DALSA/Sapera/Include' +INCLUDEPATH += 'C:/Program Files/Teledyne DALSA/Sapera/Classes/Basic' +DEPENDPATH += 'C:/Program Files/Teledyne DALSA/Sapera/Classes/Basic' + +DISTFILES += \ + src/modbus.lib + + + + diff --git a/wooden.pro.user b/wooden.pro.user new file mode 100644 index 0000000..3e99014 --- /dev/null +++ b/wooden.pro.user @@ -0,0 +1,318 @@ + + + + + + EnvironmentId + {9e31907b-3cc3-479e-b8f2-f24c1d383612} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + true + false + 0 + true + true + 0 + 8 + true + 1 + true + true + true + false + + + + ProjectExplorer.Project.PluginSettings + + + + ProjectExplorer.Project.Target.0 + + Desktop Qt 5.9.5 MSVC2017 64bit + Desktop Qt 5.9.5 MSVC2017 64bit + qt.595.win64_msvc2017_64_kit + 1 + 0 + 0 + + C:/Users/USER/Desktop/wood9.3/build-wooden-Desktop_Qt_5_9_5_MSVC2017_64bit-Debug + + + true + qmake + + QtProjectManager.QMakeBuildStep + true + + false + false + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + + 2 + 构建 + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + + 1 + 清理 + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Debug + + Qt4ProjectManager.Qt4BuildConfiguration + 2 + true + + + D:/522/wood_aduiduiduiplus + + + true + qmake + + QtProjectManager.QMakeBuildStep + false + + false + false + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + + 2 + 构建 + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + + 1 + 清理 + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Release + + Qt4ProjectManager.Qt4BuildConfiguration + 0 + true + + + C:/Users/USER/Desktop/wood9.3/build-wooden-Desktop_Qt_5_9_5_MSVC2017_64bit-Profile + + + true + qmake + + QtProjectManager.QMakeBuildStep + true + + false + true + false + + + true + Make + + Qt4ProjectManager.MakeStep + + false + + + + 2 + 构建 + + ProjectExplorer.BuildSteps.Build + + + + true + Make + + Qt4ProjectManager.MakeStep + + true + clean + + + 1 + 清理 + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Profile + + Qt4ProjectManager.Qt4BuildConfiguration + 0 + true + + 3 + + + 0 + 部署 + + ProjectExplorer.BuildSteps.Deploy + + 1 + 在本地部署 + + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + false + false + 1000 + + true + + false + false + false + false + true + 0.01 + 10 + true + 1 + 25 + + 1 + true + false + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + 2 + + wooden + + Qt4ProjectManager.Qt4RunConfiguration:D:/522/wood_aduiduiduiplus/wooden/wooden.pro + true + + wooden.pro + false + + D:/522/wood_aduiduiduiplus + 3768 + false + true + false + false + true + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 18 + + + Version + 18 + +