commit 829412b83499c2beffa81f633e60a094ebbfa8f5 Author: wumin Date: Thu Jul 18 22:46:32 2024 +0800 first commit20240712 diff --git a/camera.cpp b/camera.cpp new file mode 100644 index 0000000..877464f --- /dev/null +++ b/camera.cpp @@ -0,0 +1,665 @@ +#include "camera.h" +#include "thread.h" +#include +// 使用std::vector存储所有帧的数据 + +//外部引用的标志位 save_flag 存图标志位 RGB 光谱是否需要保存图 （不能单独存一个 RGB 或 光谱 ， 只能要存全存 除非再加标志位） +//spec_flag 没用到 +extern int save_flag; +extern bool spec_flag; +tomato tomato; + +//RGB相机的回调函数 +void __stdcall onImageDataCallBackFunc(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser); +void __stdcall onOfflineCallBackFunc(unsigned int nMsgType, void* pUser); +void __stdcall onImageDataCallBackFunc1(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser); +void __stdcall onOfflineCallBackFunc1(unsigned int nMsgType, void* pUser); +void __stdcall onImageDataCallBackFunc2(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser); +void __stdcall onOfflineCallBackFunc2(unsigned int nMsgType, void* pUser); + +//光谱相机的回调函数 +extern void __stdcall RTRGBViewCallback(void* pContext, unsigned char* pRData, unsigned char* pGData, unsigned char* pBData, unsigned long dataLength); +extern void __stdcall RTSpecStreamingCallback(void *pContext, unsigned char *pData, unsigned long dataLength); + +//三个相机是否连接上的标志位 在 initcamera 里面的 opencamera 函数有返回值 负责修改 ui界面的 "是否连接" 标志位 +int camStatusret; +int camStatusret1; +int camStatusret2; + +//果蔬标志位 +extern int fruit_flag; +CameraL::CameraL(QObject *parent) : QObject(parent) +{ + +} + + +//初始化相机 +bool CameraL::initCameraL() +{ + /* + * 枚举设备 + * */ + int device_num = enum_device(); + qDebug()<<"找到相机: "<SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff; + //根据第四位 ip 来创建 camera_handle + //camera_handle 相当于 一个指向相机的指针 这个指针就代表相机 + switch (ip4) + { + case 100: + MV_CC_CreateHandle(&camera_handle1, device_list.pDeviceInfo[i]); + break; + case 150: + MV_CC_CreateHandle(&camera_handle, device_list.pDeviceInfo[i]); + break; + case 200: + MV_CC_CreateHandle(&camera_handle2, device_list.pDeviceInfo[i]); + break; + default: + break; + } + pstDeviceInfo++; + } + return true; +} + +bool CameraL::open_camera() +{ + int ret = MV_CC_OpenDevice(camera_handle); + int ret1 = MV_CC_OpenDevice(camera_handle1); + int ret2 = MV_CC_OpenDevice(camera_handle2); + camStatusret2=0; + camStatusret1=0; + camStatusret=0; + if(ret != MV_OK||ret1 != MV_OK||ret2 != MV_OK) + { + return false; + camStatusret2=0; + camStatusret1=0; + camStatusret=0; + } + + return true; +} + +bool CameraL::open_camera2() +{ + /* + * 导入配置文件（相机） + **/ + bool isOk = import_config_file(); + // set_ROI(0, 668, 1000, 2448); + if(!isOk) + { + qDebug()<<"import config file failed"; + if(camera_handle != NULL) + { + destroy_handle(); + } + if(camera_handle1 != NULL) + { + destroy_handle1(); + } + if(camera_handle2 != NULL) + { + destroy_handle2(); + } + return false;; + } + + isOk = register_image_callback(onImageDataCallBackFunc,onImageDataCallBackFunc1,onImageDataCallBackFunc2); + qDebug()<<"注册回调成功: "<<"isOk: "< m_iHeight || m_cslGreen > m_iHeight || m_cslBlue > m_iHeight + || m_cslRed <= 0 || m_cslGreen <= 0 || m_cslBlue <= 0) + { + m_cslRed = m_iHeight * 3 / 4; + m_cslGreen = m_iHeight / 2; + m_cslBlue = m_iHeight / 4; + } + RTSetRGBselect(m_cslRed, m_cslGreen, m_cslBlue); + RTAddRGBCallback(RTRGBViewCallback, nullptr); + RTAddStreamingCallback(RTSpecStreamingCallback,nullptr); + return true; +} + +//这个 cal 函数 是光谱相机的回调函数内触发的一个槽函数 可以在 thread 里面的光谱相机的回调找到 +bool SpecCamera::cal(unsigned char *pData) +{ + test_count++; + //假设筛选后的ROI 为 30 * 100 宽 * 谱段数 + //按右上角为数据初始点 900像素点 每一行第 900 个像素点 第 73 个谱段 + + + + unsigned short* spec_total_data = new unsigned short[30 * 13]; //宽 * 谱段数 + + unsigned short* spec_short_data = (unsigned short *)pData; + int Band[13]={8,9,10,48,49,50,77,80,103,108,115,143,145}; + for(int k=0;k<13;k++) + { + memcpy(spec_total_data + k * 30, spec_short_data + 900 + (Band[k] - 1) * 2048, 30 * sizeof(unsigned short)); + } + if (test_count < 26) + { + SpecData_vector.push_back(spec_total_data); + } + else + { + delete[] spec_total_data; // 释放内存以防止内存泄漏 + } + + + + return true; +} + + +//光谱相机内置函数 不用管 +bool SpecCamera::stop_capture() +{ + if (RTIsCameraWorking()) + { + RTStopSingleCapture(); + } + return true; +} + +bool SpecCamera::trigger_open() +{ + bool ret = RT_SetBool(L"Camera.TriggerIn", true); //设置相机外触发 + + if(ret==false) + { + qDebug()<<"trigger is not open:"< +#include "MvCameraControl.h" +#include "SpectrolDll.h" +#include "QDebug" +#include "QImage" +#include +typedef void(*imageCallbackFunc)(unsigned char * , MV_FRAME_OUT_INFO_EX* , void* ); +typedef void(*exceptionCallbackFunc)(unsigned int , void* ); + +//三个相机的配置文件位置 也是绝对路径 +//三个相机用6个配置文件原因 ：百香果的相机参数是700曝光 番茄的相机参数是1500曝光 所以不同的果蔬对应不同的相机参数 +#define CAMERApassion_left_config "./CameraConfig/PFleft.mfs" +#define CAMERApassion_right_config "./CameraConfig/PFright.mfs" +#define CAMERAtoppassion_top2_config "./CameraConfig/PFtop.mfs" + +#define CAMERA_CONFIG_PATH "./CameraConfig/tomatoLeft.mfs" +#define CAMERA2_CONFIG_PATH "./CameraConfig/tomatoTop.mfs" +#define CAMERAtop_CONFIG_PATH "./CameraConfig/tomatoRight.mfs" + +class tomato +{ +public: + unsigned int count=0; + QImage img1; + QImage img2; + QImage img3; + QImage img4; + QImage img5; +}; + +//相机的参数 +struct Camera_param //相机参数在此添加，在构造函数中给出默认值，设置参数需要刷新,左侧 +{ + float exposure_time; + float gain; + int white_balance_ratio; + //... other params +}; + +struct Camera_paramR //相机参数在此添加，在构造函数中给出默认值，设置参数需要刷新，右侧 +{ + float exposure_time; + float gain; + int white_balance_ratio; + //... other params +}; + +struct Camera_paramTop //相机参数在此添加，在构造函数中给出默认值，设置参数需要刷新，顶部 +{ + float exposure_time; + float gain; + int white_balance_ratio; + //... other params +}; + +//创建相机类 所有相机有关的函数、参数都在这里 +class CameraL : public QObject +{ + Q_OBJECT +private: + void* camera_handle; //设备句柄 + void* camera_handle1; + void* camera_handle2; + MV_CC_DEVICE_INFO_LIST device_list; //设备列表 + Camera_param camera_param; + unsigned int ip4; //用于保存ipv4地址的第4位，即192.168.0.100中的100 + int i; +public: + explicit CameraL(QObject *parent = nullptr); + bool initCameraL(); + uint32_t enum_device(); + bool print_device_info(); + bool select_device(); + + + bool destroy_handle(); + bool destroy_handle1(); + bool destroy_handle2(); + + + + bool open_camera(); //初始化中的打开 + + bool open_camera2(); //与开始采集关联 + bool start_capture(); + bool close_camera(); + bool set_acquisition_mode(); + bool set_test_acquisition_mode(); + bool set_ROI(int offset_x, int offset_y, int width, int height); + bool stop_capture(); + bool register_image_callback(imageCallbackFunc onImageDataCallBackFunc,imageCallbackFunc onImageDataCallBackFunc1,imageCallbackFunc onImageDataCallBackFunc2); + bool register_offline_callback(exceptionCallbackFunc onOfflineCallBackFunc,exceptionCallbackFunc onOfflineCallBackFunc1,exceptionCallbackFunc onOfflineCallBackFunc2); + + bool import_config_file(); + bool save_config_file(); + bool set_param(Camera_param value); + Camera_param get_param(); + std::queue leftImgQueue; + std::queue rightImgQueue; + std::queue topImgQueue; + std::queue topImgTQueue; + std::queue topImgMQueue; + std::queue topImgBQueue; + std::queue tomatoQueue; + +//信号 信号跟槽函数 +signals: +// void send_RgbimageL(cv::Mat img,unsigned int count); + void send_Rgbimage(QImage& img); + void send_Rgbimage1(QImage& img); + + void send_Rgbimage2(QImage& img,QImage& img1,QImage& img2); + + void send_camerastatus(int ret,int ret1,int ret2); + + + + +public slots: +}; + +//光谱相机类 +class SpecCamera : public QObject +{ + Q_OBJECT +public: + explicit SpecCamera(QObject *parent = nullptr); + bool init_SpecCamera(); + bool cal(unsigned char* pData); + bool stop_capture(); + bool trigger_open(); + int m_iWidth; //相机采集数据宽度 + int m_iHeight; //相机采集数据高度 + unsigned short* specfullImage; + const int totalFrames = 30; // 假设需要拼接30帧来形成一张图 + // std::vector frameData; + int vector_flag; + // int nsize = 35*25*13; + std::vector SpecData_vector;//给容器开辟空间 + int test_count = 0; + //CameraSetting + float m_fWaveLengthMin; //起点光谱波长 + float m_fWaveLengthMax; //终点光谱波长 + float m_fExpTime; //曝光时间 + float m_fGain; //增益 + + float m_iFrameRate; //帧速 + + //GenralSetting + int m_cslRed; //红色波长序号 + int m_cslGreen; //绿色波长序号 + int m_cslBlue; //蓝色波长序号 + unsigned int m_uiDepth; + + unsigned short* m_pusSaveBuffer; + unsigned char* m_pRefreshBuffer; //RGB + + unsigned char* m_specBuffer; //光谱 + + long m_iDrawCount = 0; + + + bool start_capture(); + std::queue specImgQueue; + + +private: + + +signals: + void show_SpecImg(QImage); + + + +}; +#endif // CAMERA_H diff --git a/debug/tomato1227.exe b/debug/tomato1227.exe new file mode 100644 index 0000000..71529a9 Binary files /dev/null and b/debug/tomato1227.exe differ diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..73198de --- /dev/null +++ b/main.cpp @@ -0,0 +1,16 @@ +#include "widget.h" + +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + try { + Widget w; + w.show(); + return a.exec(); + } catch (const ExpiredException& e) { + QMessageBox::critical(nullptr, "程序过期", e.what()); + return -1; + } +} 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/thread.cpp b/thread.cpp new file mode 100644 index 0000000..9ec9a11 --- /dev/null +++ b/thread.cpp @@ -0,0 +1,716 @@ +#include "thread.h" +#include "camera.h" +#include "QMutex" +#include "QSemaphore" +#include // 引入Qt处理字节序的头文件 +#include +#include "QTimer" +#include +#include + +QImage image[5]; + +//三个线程实例化对象 +ProcessImg *processimg; +SendThread *sendthread; +RecvThread *recvthread; + +QMutex judge_connect_mutex; + +//RGB相机类跟光谱相机类实例化对象 +CameraL *cameraL; +SpecCamera *speccamera; + +bool is_connected; +extern tomato tomato; + +//TCP协议 +extern QTcpServer server; +extern QTcpSocket *clientSocket; +extern int start_flag; + +bool spec_flag = 0; +extern bool is_timeout; +extern modbus_t* CZ; +QMutex imgR_muex; + +//外部引用管道 +HANDLE hPipe; +HANDLE specPipe; +HANDLE RPipe; +QString pipeName = "\\\\.\\pipe\\rgb_receive"; +QString pipeName2 = "\\\\.\\pipe\\spec_receive"; +QString rePipe = "\\\\.\\pipe\\rgb_send"; + +extern int save_flag; +extern int fruit_flag; +uint countimgR = 1; +uint countimgL = 1; +uint countimgTopT = 1; +uint countimgTopM = 1; +uint countimgTopB = 1; + +int ImgQueue_Alignment = 1; +//右侧相机回调 +extern void __stdcall onImageDataCallBackFunc1(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser) +{ + + if (pFrameInfo) //帧信息有效 + { + + + + //img 原始图 + QImage img(pData,pFrameInfo->nWidth,pFrameInfo->nHeight,QImage::Format_RGB888); //构造图像 + //复制临时图 为了后续处理 + QImage tempimg = img; + tempimg = tempimg.rgbSwapped(); + QImage queueImg = tempimg; + QString filePath = "./image/R"; + QString imagePath = QString("%1/%2.bmp").arg(filePath).arg(countimgR); + if(save_flag) + { + tempimg.save(imagePath); + } + + emit cameraL->send_Rgbimage(tempimg); + countimgR++; + // cameraL->rightImgQueue.push(queueImg); + // qDebug()<<"右侧相机队列长度： "<rightImgQueue.size(); + + } + return ; + +} + +extern void __stdcall onOfflineCallBackFunc1(unsigned int nMsgType, void* pUser) +{ + //qDebug()<<"camera offline"; + judge_connect_mutex.lock(); + is_connected = false; + judge_connect_mutex.unlock(); + return; +} + +//左侧相机回调 +extern void __stdcall onImageDataCallBackFunc2(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser) +{ + if (pFrameInfo) + { + // qDebug()<<"左侧相机帧号: "<nFrameNum; + QImage imgL(pData,pFrameInfo->nWidth,pFrameInfo->nHeight,QImage::Format_RGB888); + + QImage tempimg = imgL; + tempimg = tempimg.rgbSwapped(); + QImage queueImg = tempimg; + QString filePath = "./image/L"; + QString imagePath = QString("%1/%2.bmp").arg(filePath).arg(countimgL); + if(save_flag) + { + tempimg.save(imagePath); + } + + countimgL++; + + emit cameraL->send_Rgbimage1(tempimg); + + // cameraL->leftImgQueue.push(queueImg); + // qDebug()<<"左侧相机队列长度： "<leftImgQueue.size(); + + + } + return ; +} + +extern void __stdcall onOfflineCallBackFunc2(unsigned int nMsgType, void* pUser) +{ + judge_connect_mutex.lock(); + is_connected = false; + judge_connect_mutex.unlock(); + return; +} + +//顶部相机回调（ip[4] 200） 数据指针 数据是8位 图像默认格式是BGR 当前帧的结构体 +extern void __stdcall onImageDataCallBackFunc(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser) +{ + + if (pFrameInfo) //帧信息有效 + { + qDebug()<<"彩色相机触发次数:"<nWidth,pFrameInfo->nHeight,QImage::Format_RGB888); //构造图像 + + /* + * 裁切图片三等分 + * */ + int width = imgT.width(); + int height = imgT.height(); + int partHeight = height / 3; + + QImage topPart = imgT.copy(0, 0, width, partHeight); + QImage middlePart = imgT.copy(0, partHeight, width, partHeight); + QImage bottomPart = imgT.copy(0, 2 * partHeight, width, partHeight); + + /* + * 颜色转换+存图 + * */ + QImage tempimg = bottomPart; + tempimg = tempimg.rgbSwapped(); + QImage queueImg = tempimg; + QString filePath = "./image/T/bottom"; + QString imagePath = QString("%1/%2.bmp").arg(filePath).arg(countimgTopB); + if(save_flag) + { + tempimg.save(imagePath); + + } + countimgTopB++; + + QImage tempimg1 = middlePart; + tempimg1 = tempimg1.rgbSwapped(); + QImage queueImg1 = tempimg1; + QString filePath1 = "./image/T/middle"; + QString imagePath1 = QString("%1/%2.bmp").arg(filePath1).arg(countimgTopM); + if(save_flag) + { + tempimg1.save(imagePath1); + } + + countimgTopM++; + + QImage tempimg2 = topPart; + tempimg2 = tempimg2.rgbSwapped(); + QImage queueImg2 = tempimg2; + QString filePath2 = "./image/T/top"; + QString imagePath2 = QString("%1/%2.bmp").arg(filePath2).arg(countimgTopT); + if(save_flag) + { + tempimg2.save(imagePath2); + } + + countimgTopT++; + + emit cameraL->send_Rgbimage2(tempimg,tempimg1,tempimg2); + + cameraL->topImgTQueue.push(queueImg); + cameraL->topImgMQueue.push(queueImg1); + cameraL->topImgBQueue.push(queueImg2); + } + return ; +} + +extern void __stdcall onOfflineCallBackFunc(unsigned int nMsgType, void* pUser) +{ + //qDebug()<<"camera offline"; + judge_connect_mutex.lock(); + is_connected = false; + judge_connect_mutex.unlock(); + return; +} + +int spec_count; +//光谱相机的回调函数 拿到数据后触发信号 并转到曹函数 cal（） 处理数据 如果放在回调处理数据会很慢 +void __stdcall RTSpecStreamingCallback(void *pContext, unsigned char *pData, unsigned long dataLength) +{ + if(pData) + { + // spec_count++; + // qDebug()<<"光谱相机触发次数:"<cal(pData); + + } + else + { + pData = nullptr; + } + } + return; +} + +//显示光谱伪彩色 不用管 +void __stdcall RTRGBViewCallback(void* pContext, unsigned char* pRData, unsigned char* pGData, unsigned char* pBData, unsigned long dataLength) +{ + unsigned short* pShortRData = (unsigned short*)pRData; + unsigned short* pShortGData = (unsigned short*)pGData; + unsigned short* pShortBData = (unsigned short*)pBData; + + unsigned short m_usCurrentMax = 1; + unsigned short m_usCurrentMin = 65535; + + for (int i = 0; i < speccamera->m_iWidth; i++) //拉伸 + { + if (pShortRData[i] > m_usCurrentMax) + m_usCurrentMax = pShortRData[i]; + if (pShortGData[i] > m_usCurrentMax) + m_usCurrentMax = pShortGData[i]; + if (pShortBData[i] > m_usCurrentMax) + m_usCurrentMax = pShortBData[i]; + if (pShortRData[i] < m_usCurrentMin) + m_usCurrentMin = pShortRData[i]; + if (pShortGData[i] < m_usCurrentMin) + m_usCurrentMin = pShortGData[i]; + if (pShortBData[i] < m_usCurrentMin) + m_usCurrentMin = pShortBData[i]; + } + int iLineByte = (speccamera->m_iWidth * 3 + 3) / 4 * 4; //字节对齐 + memcpy(speccamera->m_pusSaveBuffer, speccamera->m_pusSaveBuffer + iLineByte, (speccamera->m_iHeight - 1)*iLineByte*sizeof(unsigned short)); + for (int i = speccamera->m_iWidth - 1; i >= 0; i = i - 1) + { + int sel = (speccamera->m_iHeight - 1)* iLineByte + i * 3; + if (sel < iLineByte * speccamera->m_iHeight ) + { + speccamera->m_pusSaveBuffer[sel + 2] = pShortRData[i]; + speccamera->m_pusSaveBuffer[sel + 1] = pShortGData[i]; + speccamera->m_pusSaveBuffer[sel + 0] = pShortBData[i]; + } + } //拷贝 + speccamera->m_iDrawCount++; + + + // qDebug()<<"speccamera->m_iDrawCount: "<m_iDrawCount; + for (int i = 0; i < speccamera->m_iHeight; i++) + { + for (int j = 0; j < speccamera->m_iWidth; j++) + { + if (m_usCurrentMax - m_usCurrentMin*0.9 == 0) + { + speccamera->m_pRefreshBuffer[i*iLineByte+j*3 + 0] = 0; + speccamera->m_pRefreshBuffer[i*iLineByte+j*3 + 1] = 0; + speccamera->m_pRefreshBuffer[i*iLineByte+j*3 + 2] = 0; + + } + else + { + speccamera->m_pRefreshBuffer[i*iLineByte+j*3 + 0] = (speccamera->m_pusSaveBuffer[i*iLineByte+j*3 + 2]-m_usCurrentMin*0.9)*255.0/(m_usCurrentMax-m_usCurrentMin*0.9); + speccamera->m_pRefreshBuffer[i*iLineByte+j*3 + 1] = (speccamera->m_pusSaveBuffer[i*iLineByte+j*3 + 1]-m_usCurrentMin*0.9)*255.0/(m_usCurrentMax-m_usCurrentMin*0.9); + speccamera->m_pRefreshBuffer[i*iLineByte+j*3 + 2] = (speccamera->m_pusSaveBuffer[i*iLineByte+j*3 + 0]-m_usCurrentMin*0.9)*255.0/(m_usCurrentMax-m_usCurrentMin*0.9); + } + } + } + + + QImage image(speccamera->m_pRefreshBuffer,speccamera->m_iWidth, speccamera->m_iHeight, QImage::Format_RGB888); + // speccamera->specImgQueue.push(speccamera->m_pRefreshBuffer); + + emit speccamera->show_SpecImg(image); + + return; +} + + +ProcessImg::ProcessImg(QObject *parent) : QThread(parent) +{ + +} + +ProcessImg::~ProcessImg() +{ + +} + +void ProcessImg::exitThread() +{ + stop_mutex.lock(); + m_stop = true; + stop_mutex.unlock(); +} + +//光谱数据处理线程 当 槽函数 cal（） 收集到指定数量的照片 也就是 满足 if (speccamera->frameData.size() == speccamera->totalFrames) +//就会进行处理 +void ProcessImg::run() +{ + while(1) + { + // 检查是否已收集到足够的帧 + if (speccamera->SpecData_vector.size() == 25) + { + // 处理这些帧，例如拼接成一张大图 + // qDebug()<<"25行光谱图开始拼接、存队列"; + spec_count++; + msleep(100); + speccamera->test_count = 0; + // qDebug()<<"光谱相机触发次数"<specfullImage = new unsigned short[30 * 25 * 13];//宽 * 高 * 谱段数 + + + for (int i = 0; i < 25; i++) + { + // qDebug()<<"容量："<SpecData_vector.capacity(); + // qDebug()<<"容量实际大小："<SpecData_vector.size(); + memcpy(speccamera->specfullImage + i * 30 * 13, speccamera->SpecData_vector[i], 30 * 13 * sizeof(unsigned short)); + } + speccamera->specImgQueue.push(speccamera->specfullImage); + // qDebug()<<"光谱入队成功"; + + if(save_flag) + { + static int file_index = 1; + std::string spec_filename = "./image/specImg/spec" + std::to_string(file_index); + FILE *fp = fopen(spec_filename.c_str(), "wb"); + int ret = fwrite(speccamera->specfullImage, 1, 30 * 25 * 13 * sizeof(unsigned short), fp); + std::fflush(fp); + fclose(fp); + file_index++; + qDebug()<<"save img success"; + qDebug()<<"test_count: "<test_count; + } + + speccamera->SpecData_vector.clear(); + speccamera->test_count = 0; + } + } +} + +//接收线程 +RecvThread::RecvThread(QObject *parent) : QThread(parent) +{ + + +} + +RecvThread::~RecvThread() +{ + +} + + + +//通过 pipe 管道 从python端读取数据 +void RecvThread::run() +{ + + + + while (1) + { + // 读取4字节的数据长度信息 + DWORD bytesRead; + quint32 dataLength; + QByteArray lengthBytes(4, 0); + + + + BOOL success = ReadFile(RPipe, lengthBytes.data(), 4, &bytesRead, NULL); + if (!success || bytesRead != 4) + { + qDebug() << "Failed to read length from pipe:" << GetLastError(); + CloseHandle(RPipe); + return; + } + + + QDataStream lengthStream(lengthBytes); + lengthStream.setByteOrder(QDataStream::BigEndian); + lengthStream >> dataLength; + + // qDebug() << "应该接收到的数据长度:" << dataLength; + + // 根据读取到的数据长度，读取对应长度的数据 + QByteArray data(dataLength, 0); + success = ReadFile(RPipe, data.data(), dataLength, &bytesRead, NULL); + if (!success || bytesRead != dataLength) { + qDebug() << "Failed to read data from pipe:" << GetLastError(); + CloseHandle(RPipe); + return; + } + + // qDebug() << "接收到的数据长度:" << bytesRead; + + // 解析数据 + QDataStream dataStream(data); + dataStream.setByteOrder(QDataStream::BigEndian); + + // 解析命令和其他数据 + QString cmd; + quint16 brix, diameter, defectNum, height, width; + quint8 greenPercentage, weight; + quint32 totalDefectArea; + + char cmdChars[2]; + dataStream.readRawData(cmdChars, 2); + cmd = QString::fromLatin1(cmdChars, 2).trimmed().toUpper(); + + // 判断指令是否为 "RE" + if (cmd == "RE") + { + // qDebug() << "Received 'RE' command. Processing accordingly."; + // 继续解析其他数据 + dataStream >> brix >> greenPercentage >> diameter >> weight >> defectNum >> totalDefectArea >> height >> width; + + // qDebug() << "命令:" << cmd; + // qDebug() << "Brix:" << brix << ", Green Percentage:" << greenPercentage << ", Diameter:" << diameter; + // qDebug() << "Weight:" << weight << ", Defect Number:" << defectNum << ", Total Defect Area:" << totalDefectArea; + // qDebug() << "Height:" << height << ", Width:" << width; + // // 剩余的数据为图像数据 + // qDebug() << "data: " <pos(); + + QByteArray imageData = data.right(data.size() - dataStream.device()->pos()); + // qDebug() << "imageData size: " << imageData.size(); + + QImage imageResult((uchar*)imageData.constData(), width, height, QImage::Format_RGB888); + if (!imageResult.isNull()) { + // qDebug() << "Image loaded successfully"; + QImage swappedImage = imageResult.rgbSwapped(); + emit recv_Data(brix,greenPercentage,diameter,weight,defectNum,totalDefectArea,height,width,swappedImage); + // imageResult.save("D:/WeChat Files/wxid_jjgh0jfum83v12/FileStorage/File/2024-06/1.png"); + } + else + { + qDebug() << "Error: Failed to load image from raw data"; + } + // qDebug() << "接收并处理完成"; + + } + } +} + + + + +SendThread::SendThread(QObject *parent) : QThread(parent) +{ + +} + +SendThread::~SendThread() +{ + + +} + +bool SendThread::sendData(HANDLE &hPipe, const QByteArray &data) +{ + DWORD bytesWritten; + if (!WriteFile(hPipe, data.constData(), static_cast(data.size()), &bytesWritten, nullptr) || bytesWritten == 0) { + DWORD dwError = GetLastError(); + qDebug()<<"第"<topImgTQueue.size()>15) + { + QElapsedTimer timer; + timer.start(); + //数据对齐 + if(ImgQueue_Alignment) + { + cameraL->topImgMQueue.pop(); + cameraL->topImgMQueue.pop(); + + cameraL->topImgBQueue.pop(); + cameraL->topImgBQueue.pop(); + cameraL->topImgBQueue.pop(); + + cameraL->topImgTQueue.pop(); + + ImgQueue_Alignment = 0; + } + + QImage temp[5]; + temp[0] = cameraL->topImgTQueue.front(); + cameraL->topImgTQueue.pop(); + qDebug()<<"顶部相机顶队列大小："<topImgTQueue.size(); + temp[1] = cameraL->topImgMQueue.front(); + cameraL->topImgMQueue.pop(); + qDebug()<<"顶部相机中队列大小："<topImgMQueue.size(); + temp[2] = cameraL ->topImgBQueue.front(); + cameraL -> topImgBQueue.pop(); + qDebug()<<"顶部相机下队列大小："<topImgBQueue.size(); + // temp[3] = cameraL->leftImgQueue.front(); + // cameraL->leftImgQueue.pop(); + // qDebug()<<"左侧相机队列大小："<leftImgQueue.size(); + // temp[4] = cameraL->rightImgQueue.front(); + // cameraL->rightImgQueue.pop(); + // qDebug()<<"右侧相机队列大小："<rightImgQueue.size(); + //循环五次 将 temp[5] 中的所有图像数据转换为字节流 用于 pipe 管道发送 + + for(int i=0;i<3;i++) + { + // Qt_image_count ++; + // QString filePath = "C:/Users/succtech/Desktop/Qt_image"; + // QString imagePath = QString("%1/%2.bmp").arg(filePath).arg(Qt_image_count); + // temp[i].save(imagePath); + int width = temp[i].width(); + int height = temp[i].height(); + // qDebug()<<"原始图像字节: "<(temp[i].bits()), temp[i].byteCount()); + // qDebug()<<"现在图像字节: "<(imgData.size() + 6); + dataStream << length; + + if(fruit_flag) //百香果 + { + // 添加命令 + QString cmd = "PF"; + dataStream.writeRawData(cmd.toLocal8Bit().constData(), 2); + // Dimensions + dataStream << static_cast(height); + dataStream << static_cast(width); + + // Image data + dataStream.writeRawData(imgData.constData(), imgData.size()); + + if (!sendData(hPipe, dataToSend)) + { + qWarning() << "Failed to send data, attempting to reconnect..."; + specPipe = reconnect(pipeName2); + if (specPipe == INVALID_HANDLE_VALUE) return; + if (!sendData(specPipe, dataToSend)) return; + return; + } + + + //当第五张RGB图发送完之后，发送光谱图 + if(i==2) + { + unsigned short* specTemp = speccamera->specImgQueue.front(); + // qDebug()<<"光谱数据大小:"<specImgQueue.pop(); + // qDebug() << "光谱队列长度: " << speccamera->specImgQueue.size(); + + int specWidth = 30; + int specHeight = 25; + int specBands = 13; + + QByteArray specByte,specByte_tosend; + specByte.append(reinterpret_cast(specTemp), specWidth * specHeight * specBands * sizeof(unsigned short)); + qDebug()<<"specByte: "<(specByte.size() + 8); + spec_stream << length; + + // 添加命令 + QString cmd = "PF"; + spec_stream.writeRawData(cmd.toLocal8Bit().constData(), 2); + + // Dimensions + spec_stream << static_cast(specHeight); + spec_stream << static_cast(specWidth); + spec_stream << static_cast(specBands); + specByte_tosend.append(specByte); + if (!sendData(specPipe, specByte_tosend)) + { + qWarning() << "Failed to send data, attempting to reconnect..."; + specPipe = reconnect(pipeName2); + if (specPipe == INVALID_HANDLE_VALUE) return; + if (!sendData(specPipe, specByte_tosend)) return; + return; + } + // qDebug() << "write to spec_pipe." << specByte_tosend.size(); + msleep(10); + // qDebug() << "发送完成:"; + + } + + } + else //番茄 + { + // 添加命令 + QString cmd = "TO"; + dataStream.writeRawData(cmd.toLocal8Bit().constData(), 2); + // Dimensions + dataStream << static_cast(height); + dataStream << static_cast(width); + + // Image data + dataStream.writeRawData(imgData.constData(), imgData.size()); + + if (!sendData(hPipe, dataToSend)) + { + qWarning() << "Failed to send data, attempting to reconnect..."; + specPipe = reconnect(pipeName2); + if (specPipe == INVALID_HANDLE_VALUE) return; + if (!sendData(specPipe, dataToSend)) return; + return; + } + // if(i == 2) + // { + // // qDebug() << "光谱队列长度: " << speccamera->specImgQueue.size(); + // speccamera->specImgQueue.pop(); + // qDebug() << "发送完成:"; + + // } + } + // qint64 elapsed = timer.elapsed(); + // qDebug()<<"间隔时间"< +#include +#include "camera.h" +#include "queue" +#include "QMutex" +#include +#include +#include "src/modbus.h" +#include + +//处理线程 负责光谱相机的完整数据拼接 +class ProcessImg : public QThread +{ + Q_OBJECT +public: + explicit ProcessImg(QObject *parent = nullptr); + ~ProcessImg(); + + + void exitThread(); + QMutex stop_mutex; + + int spec_count; + + +protected: + void run(); +private: + bool m_stop; + + +signals: + + + +public slots: + +private: + +}; + +//发送线程 负责使用管道 pipe 给python端发送五张图片 +//五张图片分别为 顶部 上、中、下三张 左 右 两张 +//待修改： +//1、数据对齐 +class SendThread: public QThread +{ + Q_OBJECT + +protected: + void run(); + +public: + explicit SendThread(QObject *parent = NULL); + ~SendThread(); + + bool sendData(HANDLE &hPipe, const QByteArray &data); + + HANDLE reconnect(const QString &pipeName); + + int Yure_Flag = 1; + + int Qt_image_count = 0; +private: + + void SendImgToPython(); + +signals: + +private slots: + //void sendimg_topySlots(cv::Mat img1,cv::Mat img2,cv::Mat img3,cv::Mat img4,cv::Mat img5); +}; + +//接收线程 负责接收python端通过 pipe 返回的数据 长径 短径 缺陷数量 缺陷面积 并在窗口展示 +//待修改： +//1、具体返回值放在哪里 窗口位置需要调整 +//2、判断条件写死 具体数据写活 +class RecvThread: public QThread +{ + Q_OBJECT + +protected: + void run(); + +public: + explicit RecvThread(QObject *parent = NULL); + ~RecvThread(); + +public slots: + +signals: + + void recv_Data(quint16,quint8,quint16,quint8,quint16,quint32,quint16,quint16,QImage); + +}; + +#endif // THREAD_H diff --git a/tomato1227.pro b/tomato1227.pro new file mode 100644 index 0000000..86a976a --- /dev/null +++ b/tomato1227.pro @@ -0,0 +1,59 @@ +QT += core gui network + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +CONFIG += c++17 + +# You can make your code fail to compile if it uses deprecated APIs. +# In order to do so, uncomment the following line. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + +SOURCES += \ + camera.cpp \ + main.cpp \ + src/modbus-data.c \ + src/modbus-rtu.c \ + src/modbus-tcp.c \ + src/modbus.c \ + thread.cpp \ + widget.cpp + +HEADERS += \ + camera.h \ + src/modbus-private.h \ + src/modbus-rtu-private.h \ + src/modbus-rtu.h \ + src/modbus-tcp-private.h \ + src/modbus-tcp.h \ + src/modbus-version.h \ + src/modbus.h \ + thread.h \ + widget.h + +FORMS += \ + widget.ui + +# Default rules for deployment. +qnx: target.path = /tmp/$${TARGET}/bin +else: unix:!android: target.path = /opt/$${TARGET}/bin +!isEmpty(target.path): INSTALLS += target + + +DISTFILES += \ + src/modbus.lib +LIBS += -Ldll -lws2_32 + +#查看所有路径知否正确 RGB opencv 光谱相机 +#建议改成绝对路径 +# rgb camera SDK +LIBS += -LD:/porject/20240425/rgbcamera_sdk/Libraries/win64 -lMvCameraControl +INCLUDEPATH += D:/porject/20240425/rgbcamera_sdk/Includes +DEPENDPATH += D:/porject/20240425/rgbcamera_sdk/Includes + + + +# spec +INCLUDEPATH += D:/porject/20240425/RT_SDK/SDK/include +DEPENDPATH += D:/porject/20240425/RT_SDK/SDK/include +LIBS += -LD:/porject/20240425/RT_SDK/SDK/lib -lSpectrolDll + diff --git a/ui_widget.h b/ui_widget.h new file mode 100644 index 0000000..6973d74 --- /dev/null +++ b/ui_widget.h @@ -0,0 +1,863 @@ +/******************************************************************************** +** Form generated from reading UI file 'widget.ui' +** +** Created by: Qt User Interface Compiler version 5.15.2 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_WIDGET_H +#define UI_WIDGET_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class Ui_Widget +{ +public: + QGridLayout *gridLayout_10; + QTabWidget *tabWidget; + QWidget *tab_3; + QGridLayout *gridLayout_12; + QLabel *label; + QLabel *label_23; + QWidget *tab; + QGroupBox *groupBox_9; + QGridLayout *gridLayout_11; + QGroupBox *groupBox; + QLabel *label_14; + QWidget *layoutWidget_2; + QHBoxLayout *horizontalLayout_14; + QLabel *label_RGB; + QLabel *RGBstatus; + QLabel *label_RGB_3; + QLabel *RGBstatus_1; + QLabel *label_RGB_2; + QLabel *RGBstatus_2; + QLabel *label_9; + QLabel *spec_camera_status; + QLabel *label_11; + QLabel *plc_status; + QLabel *label_17; + QLabel *jxs_status; + QWidget *layoutWidget; + QVBoxLayout *verticalLayout_5; + QWidget *layoutWidget1; + QHBoxLayout *horizontalLayout_8; + QVBoxLayout *verticalLayout; + QHBoxLayout *horizontalLayout; + QLabel *label_26; + QPushButton *passionBtn; + QPushButton *tomatoBtn; + QPushButton *btn_start; + QPushButton *show_resoult; + QPushButton *btn_setparam; + QPushButton *btn_save; + QPushButton *view_results; + QPushButton *btn_quit; + QVBoxLayout *verticalLayout_2; + QGroupBox *groupBox_4; + QGridLayout *gridLayout_2; + QGroupBox *groupBox_2; + QGridLayout *gridLayout; + QLabel *label_topL; + QGroupBox *groupBox_3; + QGridLayout *gridLayout_3; + QLabel *label_topM; + QGroupBox *groupBox_5; + QGridLayout *gridLayout_4; + QLabel *label_topR; + QGroupBox *groupBox_6; + QGridLayout *gridLayout_5; + QLabel *showimg_right; + QGroupBox *groupBox_7; + QGridLayout *gridLayout_6; + QLabel *showimg_left; + QGroupBox *groupBox_8; + QGridLayout *gridLayout_7; + QLabel *spec_camera_show; + QWidget *tab_2; + QGroupBox *groupBox_11; + QGridLayout *gridLayout_13; + QLabel *label_28; + QSpinBox *exSpinBox_left; + QLabel *label_29; + QSpinBox *wbSpinBox_left_2; + QLabel *label_30; + QSpinBox *GainSpinBox_left; + QGroupBox *groupBox_13; + QGridLayout *gridLayout_16; + QLabel *label_38; + QSpinBox *exspinBox_top; + QLabel *label_39; + QSpinBox *wbspinBox_top; + QLabel *label_40; + QSpinBox *GainspinBox_top; + QGroupBox *groupBox_15; + QGridLayout *gridLayout_18; + QLabel *label_46; + QSpinBox *exspinBox_right; + QLabel *label_47; + QSpinBox *wbspinBox_right; + QLabel *label_48; + QSpinBox *GainspinBox_right; + QPushButton *btn_enterparam; + QPushButton *tab3_ReturnToMain; + QPushButton *choose_to; + QPushButton *choose_pa; + QLineEdit *InputNum1; + QLineEdit *InputNum5; + QLabel *label_5; + QLineEdit *InputNum4; + QPushButton *set_threshoid; + QLabel *label_32; + QLineEdit *InputNum3; + QLabel *label_33; + QLabel *label_10; + QLabel *label_18; + QLineEdit *InputNum2; + QLabel *label_12; + QLabel *label_21; + QWidget *tab_4; + QLabel *show_resultsImg; + QLabel *label_3; + QPushButton *tab4_ReturnToMain; + QPlainTextEdit *resoult_info_label; + QPushButton *choose_pa_2; + QLabel *label_13; + QPushButton *choose_to_2; + + void setupUi(QWidget *Widget) + { + if (Widget->objectName().isEmpty()) + Widget->setObjectName(QString::fromUtf8("Widget")); + Widget->resize(2000, 1038); + gridLayout_10 = new QGridLayout(Widget); + gridLayout_10->setObjectName(QString::fromUtf8("gridLayout_10")); + tabWidget = new QTabWidget(Widget); + tabWidget->setObjectName(QString::fromUtf8("tabWidget")); + tabWidget->setStyleSheet(QString::fromUtf8("")); + tab_3 = new QWidget(); + tab_3->setObjectName(QString::fromUtf8("tab_3")); + gridLayout_12 = new QGridLayout(tab_3); + gridLayout_12->setObjectName(QString::fromUtf8("gridLayout_12")); + label = new QLabel(tab_3); + label->setObjectName(QString::fromUtf8("label")); + QFont font; + font.setPointSize(36); + font.setBold(false); + label->setFont(font); + label->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + label->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter); + + gridLayout_12->addWidget(label, 1, 1, 2, 2); + + label_23 = new QLabel(tab_3); + label_23->setObjectName(QString::fromUtf8("label_23")); + label_23->setPixmap(QPixmap(QString::fromUtf8("H:/\351\241\271\347\233\256\344\273\243\347\240\201/tobacco/uppermachine-tobacco/image/njfu.jpg"))); + + gridLayout_12->addWidget(label_23, 0, 0, 1, 1); + + tabWidget->addTab(tab_3, QString()); + tab = new QWidget(); + tab->setObjectName(QString::fromUtf8("tab")); + groupBox_9 = new QGroupBox(tab); + groupBox_9->setObjectName(QString::fromUtf8("groupBox_9")); + groupBox_9->setGeometry(QRect(9, 9, 20, 20)); + gridLayout_11 = new QGridLayout(groupBox_9); + gridLayout_11->setObjectName(QString::fromUtf8("gridLayout_11")); + groupBox = new QGroupBox(tab); + groupBox->setObjectName(QString::fromUtf8("groupBox")); + groupBox->setGeometry(QRect(10, -20, 1961, 161)); + QFont font1; + font1.setPointSize(12); + groupBox->setFont(font1); + label_14 = new QLabel(groupBox); + label_14->setObjectName(QString::fromUtf8("label_14")); + label_14->setGeometry(QRect(330, 40, 511, 51)); + QFont font2; + font2.setFamily(QString::fromUtf8("\345\215\216\346\226\207\346\245\267\344\275\223")); + font2.setPointSize(36); + font2.setBold(false); + font2.setItalic(false); + label_14->setFont(font2); + label_14->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 36pt \"\345\215\216\346\226\207\346\245\267\344\275\223\";")); + label_14->setTextFormat(Qt::PlainText); + layoutWidget_2 = new QWidget(groupBox); + layoutWidget_2->setObjectName(QString::fromUtf8("layoutWidget_2")); + layoutWidget_2->setGeometry(QRect(2, 90, 841, 61)); + horizontalLayout_14 = new QHBoxLayout(layoutWidget_2); + horizontalLayout_14->setObjectName(QString::fromUtf8("horizontalLayout_14")); + horizontalLayout_14->setContentsMargins(0, 0, 0, 0); + label_RGB = new QLabel(layoutWidget_2); + label_RGB->setObjectName(QString::fromUtf8("label_RGB")); + QFont font3; + font3.setPointSize(12); + font3.setBold(true); + label_RGB->setFont(font3); + label_RGB->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout_14->addWidget(label_RGB); + + RGBstatus = new QLabel(layoutWidget_2); + RGBstatus->setObjectName(QString::fromUtf8("RGBstatus")); + RGBstatus->setStyleSheet(QString::fromUtf8("color: rgb(255, 0, 0);")); + + horizontalLayout_14->addWidget(RGBstatus); + + label_RGB_3 = new QLabel(layoutWidget_2); + label_RGB_3->setObjectName(QString::fromUtf8("label_RGB_3")); + label_RGB_3->setFont(font3); + label_RGB_3->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout_14->addWidget(label_RGB_3); + + RGBstatus_1 = new QLabel(layoutWidget_2); + RGBstatus_1->setObjectName(QString::fromUtf8("RGBstatus_1")); + RGBstatus_1->setStyleSheet(QString::fromUtf8("color: rgb(255, 0, 0);")); + + horizontalLayout_14->addWidget(RGBstatus_1); + + label_RGB_2 = new QLabel(layoutWidget_2); + label_RGB_2->setObjectName(QString::fromUtf8("label_RGB_2")); + label_RGB_2->setFont(font3); + label_RGB_2->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout_14->addWidget(label_RGB_2); + + RGBstatus_2 = new QLabel(layoutWidget_2); + RGBstatus_2->setObjectName(QString::fromUtf8("RGBstatus_2")); + RGBstatus_2->setStyleSheet(QString::fromUtf8("color: rgb(255, 0, 0);")); + + horizontalLayout_14->addWidget(RGBstatus_2); + + label_9 = new QLabel(layoutWidget_2); + label_9->setObjectName(QString::fromUtf8("label_9")); + label_9->setFont(font3); + label_9->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout_14->addWidget(label_9); + + spec_camera_status = new QLabel(layoutWidget_2); + spec_camera_status->setObjectName(QString::fromUtf8("spec_camera_status")); + spec_camera_status->setStyleSheet(QString::fromUtf8("color: rgb(255, 0, 0);")); + + horizontalLayout_14->addWidget(spec_camera_status); + + label_11 = new QLabel(layoutWidget_2); + label_11->setObjectName(QString::fromUtf8("label_11")); + label_11->setFont(font3); + label_11->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout_14->addWidget(label_11); + + plc_status = new QLabel(layoutWidget_2); + plc_status->setObjectName(QString::fromUtf8("plc_status")); + plc_status->setStyleSheet(QString::fromUtf8("color: rgb(255, 0, 0);")); + + horizontalLayout_14->addWidget(plc_status); + + label_17 = new QLabel(layoutWidget_2); + label_17->setObjectName(QString::fromUtf8("label_17")); + label_17->setFont(font3); + label_17->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout_14->addWidget(label_17); + + jxs_status = new QLabel(layoutWidget_2); + jxs_status->setObjectName(QString::fromUtf8("jxs_status")); + jxs_status->setStyleSheet(QString::fromUtf8("color: rgb(255, 0, 0);")); + + horizontalLayout_14->addWidget(jxs_status); + + layoutWidget = new QWidget(groupBox); + layoutWidget->setObjectName(QString::fromUtf8("layoutWidget")); + layoutWidget->setGeometry(QRect(790, 220, 574, 356)); + verticalLayout_5 = new QVBoxLayout(layoutWidget); + verticalLayout_5->setObjectName(QString::fromUtf8("verticalLayout_5")); + verticalLayout_5->setContentsMargins(0, 0, 0, 0); + layoutWidget1 = new QWidget(tab); + layoutWidget1->setObjectName(QString::fromUtf8("layoutWidget1")); + layoutWidget1->setGeometry(QRect(10, 140, 1951, 791)); + horizontalLayout_8 = new QHBoxLayout(layoutWidget1); + horizontalLayout_8->setObjectName(QString::fromUtf8("horizontalLayout_8")); + horizontalLayout_8->setContentsMargins(0, 0, 0, 0); + verticalLayout = new QVBoxLayout(); + verticalLayout->setObjectName(QString::fromUtf8("verticalLayout")); + horizontalLayout = new QHBoxLayout(); + horizontalLayout->setObjectName(QString::fromUtf8("horizontalLayout")); + label_26 = new QLabel(layoutWidget1); + label_26->setObjectName(QString::fromUtf8("label_26")); + label_26->setFont(font3); + label_26->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout->addWidget(label_26); + + passionBtn = new QPushButton(layoutWidget1); + passionBtn->setObjectName(QString::fromUtf8("passionBtn")); + passionBtn->setFont(font3); + passionBtn->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout->addWidget(passionBtn); + + tomatoBtn = new QPushButton(layoutWidget1); + tomatoBtn->setObjectName(QString::fromUtf8("tomatoBtn")); + tomatoBtn->setFont(font3); + tomatoBtn->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + horizontalLayout->addWidget(tomatoBtn); + + + verticalLayout->addLayout(horizontalLayout); + + btn_start = new QPushButton(layoutWidget1); + btn_start->setObjectName(QString::fromUtf8("btn_start")); + QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); + sizePolicy.setHorizontalStretch(0); + sizePolicy.setVerticalStretch(0); + sizePolicy.setHeightForWidth(btn_start->sizePolicy().hasHeightForWidth()); + btn_start->setSizePolicy(sizePolicy); + QFont font4; + font4.setFamily(QString::fromUtf8("\345\256\213\344\275\223")); + font4.setPointSize(30); + font4.setBold(false); + font4.setItalic(false); + btn_start->setFont(font4); + btn_start->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 30pt \"\345\256\213\344\275\223\";")); + + verticalLayout->addWidget(btn_start); + + show_resoult = new QPushButton(layoutWidget1); + show_resoult->setObjectName(QString::fromUtf8("show_resoult")); + sizePolicy.setHeightForWidth(show_resoult->sizePolicy().hasHeightForWidth()); + show_resoult->setSizePolicy(sizePolicy); + show_resoult->setFont(font4); + show_resoult->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 30pt \"\345\256\213\344\275\223\";")); + + verticalLayout->addWidget(show_resoult); + + btn_setparam = new QPushButton(layoutWidget1); + btn_setparam->setObjectName(QString::fromUtf8("btn_setparam")); + sizePolicy.setHeightForWidth(btn_setparam->sizePolicy().hasHeightForWidth()); + btn_setparam->setSizePolicy(sizePolicy); + btn_setparam->setFont(font4); + btn_setparam->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 30pt \"\345\256\213\344\275\223\";")); + + verticalLayout->addWidget(btn_setparam); + + btn_save = new QPushButton(layoutWidget1); + btn_save->setObjectName(QString::fromUtf8("btn_save")); + sizePolicy.setHeightForWidth(btn_save->sizePolicy().hasHeightForWidth()); + btn_save->setSizePolicy(sizePolicy); + btn_save->setFont(font4); + btn_save->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 30pt \"\345\256\213\344\275\223\";")); + + verticalLayout->addWidget(btn_save); + + view_results = new QPushButton(layoutWidget1); + view_results->setObjectName(QString::fromUtf8("view_results")); + sizePolicy.setHeightForWidth(view_results->sizePolicy().hasHeightForWidth()); + view_results->setSizePolicy(sizePolicy); + view_results->setFont(font4); + view_results->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 30pt \"\345\256\213\344\275\223\";")); + + verticalLayout->addWidget(view_results); + + btn_quit = new QPushButton(layoutWidget1); + btn_quit->setObjectName(QString::fromUtf8("btn_quit")); + sizePolicy.setHeightForWidth(btn_quit->sizePolicy().hasHeightForWidth()); + btn_quit->setSizePolicy(sizePolicy); + btn_quit->setFont(font4); + btn_quit->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);\n" +"font: 30pt \"\345\256\213\344\275\223\";")); + + verticalLayout->addWidget(btn_quit); + + + horizontalLayout_8->addLayout(verticalLayout); + + verticalLayout_2 = new QVBoxLayout(); + verticalLayout_2->setObjectName(QString::fromUtf8("verticalLayout_2")); + groupBox_4 = new QGroupBox(layoutWidget1); + groupBox_4->setObjectName(QString::fromUtf8("groupBox_4")); + groupBox_4->setFont(font3); + groupBox_4->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + gridLayout_2 = new QGridLayout(groupBox_4); + gridLayout_2->setObjectName(QString::fromUtf8("gridLayout_2")); + groupBox_2 = new QGroupBox(groupBox_4); + groupBox_2->setObjectName(QString::fromUtf8("groupBox_2")); + groupBox_2->setFont(font3); + gridLayout = new QGridLayout(groupBox_2); + gridLayout->setObjectName(QString::fromUtf8("gridLayout")); + label_topL = new QLabel(groupBox_2); + label_topL->setObjectName(QString::fromUtf8("label_topL")); + label_topL->setStyleSheet(QString::fromUtf8("background-color: rgb(170, 170, 255);")); + + gridLayout->addWidget(label_topL, 0, 0, 1, 1); + + + gridLayout_2->addWidget(groupBox_2, 0, 0, 1, 1); + + groupBox_3 = new QGroupBox(groupBox_4); + groupBox_3->setObjectName(QString::fromUtf8("groupBox_3")); + groupBox_3->setFont(font3); + gridLayout_3 = new QGridLayout(groupBox_3); + gridLayout_3->setObjectName(QString::fromUtf8("gridLayout_3")); + label_topM = new QLabel(groupBox_3); + label_topM->setObjectName(QString::fromUtf8("label_topM")); + label_topM->setStyleSheet(QString::fromUtf8("background-color: rgb(170, 170, 255);")); + + gridLayout_3->addWidget(label_topM, 0, 1, 1, 1); + + + gridLayout_2->addWidget(groupBox_3, 0, 1, 1, 1); + + groupBox_5 = new QGroupBox(groupBox_4); + groupBox_5->setObjectName(QString::fromUtf8("groupBox_5")); + groupBox_5->setFont(font3); + gridLayout_4 = new QGridLayout(groupBox_5); + gridLayout_4->setObjectName(QString::fromUtf8("gridLayout_4")); + label_topR = new QLabel(groupBox_5); + label_topR->setObjectName(QString::fromUtf8("label_topR")); + label_topR->setStyleSheet(QString::fromUtf8("background-color: rgb(170, 170, 255);")); + + gridLayout_4->addWidget(label_topR, 0, 0, 1, 1); + + + gridLayout_2->addWidget(groupBox_5, 0, 2, 1, 1); + + groupBox_6 = new QGroupBox(groupBox_4); + groupBox_6->setObjectName(QString::fromUtf8("groupBox_6")); + groupBox_6->setFont(font3); + gridLayout_5 = new QGridLayout(groupBox_6); + gridLayout_5->setObjectName(QString::fromUtf8("gridLayout_5")); + showimg_right = new QLabel(groupBox_6); + showimg_right->setObjectName(QString::fromUtf8("showimg_right")); + showimg_right->setStyleSheet(QString::fromUtf8("background-color: rgb(170, 170, 255);")); + + gridLayout_5->addWidget(showimg_right, 0, 0, 1, 1); + + + gridLayout_2->addWidget(groupBox_6, 1, 0, 1, 1); + + groupBox_7 = new QGroupBox(groupBox_4); + groupBox_7->setObjectName(QString::fromUtf8("groupBox_7")); + groupBox_7->setFont(font3); + gridLayout_6 = new QGridLayout(groupBox_7); + gridLayout_6->setObjectName(QString::fromUtf8("gridLayout_6")); + showimg_left = new QLabel(groupBox_7); + showimg_left->setObjectName(QString::fromUtf8("showimg_left")); + showimg_left->setStyleSheet(QString::fromUtf8("background-color: rgb(170, 170, 255);")); + + gridLayout_6->addWidget(showimg_left, 0, 0, 1, 1); + + + gridLayout_2->addWidget(groupBox_7, 1, 1, 1, 1); + + groupBox_8 = new QGroupBox(groupBox_4); + groupBox_8->setObjectName(QString::fromUtf8("groupBox_8")); + groupBox_8->setFont(font3); + gridLayout_7 = new QGridLayout(groupBox_8); + gridLayout_7->setObjectName(QString::fromUtf8("gridLayout_7")); + spec_camera_show = new QLabel(groupBox_8); + spec_camera_show->setObjectName(QString::fromUtf8("spec_camera_show")); + spec_camera_show->setStyleSheet(QString::fromUtf8("background-color: rgb(170, 170, 255);")); + + gridLayout_7->addWidget(spec_camera_show, 0, 0, 1, 1); + + + gridLayout_2->addWidget(groupBox_8, 1, 2, 1, 1); + + + verticalLayout_2->addWidget(groupBox_4); + + + horizontalLayout_8->addLayout(verticalLayout_2); + + horizontalLayout_8->setStretch(1, 1); + tabWidget->addTab(tab, QString()); + tab_2 = new QWidget(); + tab_2->setObjectName(QString::fromUtf8("tab_2")); + groupBox_11 = new QGroupBox(tab_2); + groupBox_11->setObjectName(QString::fromUtf8("groupBox_11")); + groupBox_11->setGeometry(QRect(40, 50, 531, 231)); + QFont font5; + font5.setPointSize(16); + font5.setBold(true); + groupBox_11->setFont(font5); + groupBox_11->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + gridLayout_13 = new QGridLayout(groupBox_11); + gridLayout_13->setObjectName(QString::fromUtf8("gridLayout_13")); + label_28 = new QLabel(groupBox_11); + label_28->setObjectName(QString::fromUtf8("label_28")); + label_28->setFont(font5); + label_28->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_13->addWidget(label_28, 0, 0, 1, 1); + + exSpinBox_left = new QSpinBox(groupBox_11); + exSpinBox_left->setObjectName(QString::fromUtf8("exSpinBox_left")); + QFont font6; + font6.setBold(true); + exSpinBox_left->setFont(font6); + exSpinBox_left->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_13->addWidget(exSpinBox_left, 0, 1, 1, 1); + + label_29 = new QLabel(groupBox_11); + label_29->setObjectName(QString::fromUtf8("label_29")); + label_29->setFont(font5); + label_29->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_13->addWidget(label_29, 1, 0, 1, 1); + + wbSpinBox_left_2 = new QSpinBox(groupBox_11); + wbSpinBox_left_2->setObjectName(QString::fromUtf8("wbSpinBox_left_2")); + wbSpinBox_left_2->setFont(font6); + wbSpinBox_left_2->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_13->addWidget(wbSpinBox_left_2, 1, 1, 1, 1); + + label_30 = new QLabel(groupBox_11); + label_30->setObjectName(QString::fromUtf8("label_30")); + label_30->setFont(font5); + label_30->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_13->addWidget(label_30, 2, 0, 1, 1); + + GainSpinBox_left = new QSpinBox(groupBox_11); + GainSpinBox_left->setObjectName(QString::fromUtf8("GainSpinBox_left")); + GainSpinBox_left->setFont(font6); + GainSpinBox_left->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_13->addWidget(GainSpinBox_left, 2, 1, 1, 1); + + groupBox_13 = new QGroupBox(tab_2); + groupBox_13->setObjectName(QString::fromUtf8("groupBox_13")); + groupBox_13->setGeometry(QRect(40, 350, 531, 231)); + groupBox_13->setFont(font5); + groupBox_13->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + gridLayout_16 = new QGridLayout(groupBox_13); + gridLayout_16->setObjectName(QString::fromUtf8("gridLayout_16")); + label_38 = new QLabel(groupBox_13); + label_38->setObjectName(QString::fromUtf8("label_38")); + label_38->setFont(font5); + label_38->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_16->addWidget(label_38, 0, 0, 1, 1); + + exspinBox_top = new QSpinBox(groupBox_13); + exspinBox_top->setObjectName(QString::fromUtf8("exspinBox_top")); + exspinBox_top->setFont(font6); + exspinBox_top->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_16->addWidget(exspinBox_top, 0, 1, 1, 1); + + label_39 = new QLabel(groupBox_13); + label_39->setObjectName(QString::fromUtf8("label_39")); + label_39->setFont(font5); + label_39->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_16->addWidget(label_39, 1, 0, 1, 1); + + wbspinBox_top = new QSpinBox(groupBox_13); + wbspinBox_top->setObjectName(QString::fromUtf8("wbspinBox_top")); + wbspinBox_top->setFont(font6); + wbspinBox_top->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_16->addWidget(wbspinBox_top, 1, 1, 1, 1); + + label_40 = new QLabel(groupBox_13); + label_40->setObjectName(QString::fromUtf8("label_40")); + label_40->setFont(font5); + label_40->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_16->addWidget(label_40, 2, 0, 1, 1); + + GainspinBox_top = new QSpinBox(groupBox_13); + GainspinBox_top->setObjectName(QString::fromUtf8("GainspinBox_top")); + GainspinBox_top->setFont(font6); + GainspinBox_top->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_16->addWidget(GainspinBox_top, 2, 1, 1, 1); + + groupBox_15 = new QGroupBox(tab_2); + groupBox_15->setObjectName(QString::fromUtf8("groupBox_15")); + groupBox_15->setGeometry(QRect(700, 60, 531, 231)); + groupBox_15->setFont(font5); + groupBox_15->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + gridLayout_18 = new QGridLayout(groupBox_15); + gridLayout_18->setObjectName(QString::fromUtf8("gridLayout_18")); + label_46 = new QLabel(groupBox_15); + label_46->setObjectName(QString::fromUtf8("label_46")); + label_46->setFont(font5); + label_46->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_18->addWidget(label_46, 0, 0, 1, 1); + + exspinBox_right = new QSpinBox(groupBox_15); + exspinBox_right->setObjectName(QString::fromUtf8("exspinBox_right")); + exspinBox_right->setFont(font6); + exspinBox_right->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_18->addWidget(exspinBox_right, 0, 1, 1, 1); + + label_47 = new QLabel(groupBox_15); + label_47->setObjectName(QString::fromUtf8("label_47")); + label_47->setFont(font5); + label_47->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_18->addWidget(label_47, 1, 0, 1, 1); + + wbspinBox_right = new QSpinBox(groupBox_15); + wbspinBox_right->setObjectName(QString::fromUtf8("wbspinBox_right")); + wbspinBox_right->setFont(font6); + wbspinBox_right->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_18->addWidget(wbspinBox_right, 1, 1, 1, 1); + + label_48 = new QLabel(groupBox_15); + label_48->setObjectName(QString::fromUtf8("label_48")); + label_48->setFont(font5); + label_48->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_18->addWidget(label_48, 2, 0, 1, 1); + + GainspinBox_right = new QSpinBox(groupBox_15); + GainspinBox_right->setObjectName(QString::fromUtf8("GainspinBox_right")); + GainspinBox_right->setFont(font6); + GainspinBox_right->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + + gridLayout_18->addWidget(GainspinBox_right, 2, 1, 1, 1); + + btn_enterparam = new QPushButton(tab_2); + btn_enterparam->setObjectName(QString::fromUtf8("btn_enterparam")); + btn_enterparam->setGeometry(QRect(710, 380, 161, 91)); + btn_enterparam->setFont(font5); + btn_enterparam->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + tab3_ReturnToMain = new QPushButton(tab_2); + tab3_ReturnToMain->setObjectName(QString::fromUtf8("tab3_ReturnToMain")); + tab3_ReturnToMain->setGeometry(QRect(1300, 820, 241, 91)); + tab3_ReturnToMain->setFont(font5); + tab3_ReturnToMain->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + choose_to = new QPushButton(tab_2); + choose_to->setObjectName(QString::fromUtf8("choose_to")); + choose_to->setGeometry(QRect(340, 710, 241, 141)); + choose_to->setFont(font5); + choose_to->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + choose_pa = new QPushButton(tab_2); + choose_pa->setObjectName(QString::fromUtf8("choose_pa")); + choose_pa->setGeometry(QRect(40, 710, 231, 141)); + choose_pa->setFont(font5); + choose_pa->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + InputNum1 = new QLineEdit(tab_2); + InputNum1->setObjectName(QString::fromUtf8("InputNum1")); + InputNum1->setGeometry(QRect(774, 720, 81, 30)); + QFont font7; + font7.setPointSize(16); + font7.setBold(false); + InputNum1->setFont(font7); + InputNum5 = new QLineEdit(tab_2); + InputNum5->setObjectName(QString::fromUtf8("InputNum5")); + InputNum5->setGeometry(QRect(1050, 780, 94, 30)); + InputNum5->setFont(font7); + label_5 = new QLabel(tab_2); + label_5->setObjectName(QString::fromUtf8("label_5")); + label_5->setGeometry(QRect(720, 630, 108, 21)); + label_5->setFont(font5); + InputNum4 = new QLineEdit(tab_2); + InputNum4->setObjectName(QString::fromUtf8("InputNum4")); + InputNum4->setGeometry(QRect(820, 780, 81, 30)); + InputNum4->setFont(font7); + set_threshoid = new QPushButton(tab_2); + set_threshoid->setObjectName(QString::fromUtf8("set_threshoid")); + set_threshoid->setGeometry(QRect(720, 830, 261, 91)); + set_threshoid->setStyleSheet(QString::fromUtf8("font: 30pt \"\345\256\213\344\275\223\";")); + label_32 = new QLabel(tab_2); + label_32->setObjectName(QString::fromUtf8("label_32")); + label_32->setGeometry(QRect(720, 780, 86, 31)); + label_32->setFont(font5); + InputNum3 = new QLineEdit(tab_2); + InputNum3->setObjectName(QString::fromUtf8("InputNum3")); + InputNum3->setGeometry(QRect(1140, 720, 91, 28)); + InputNum3->setFont(font7); + label_33 = new QLabel(tab_2); + label_33->setObjectName(QString::fromUtf8("label_33")); + label_33->setGeometry(QRect(940, 780, 86, 31)); + label_33->setFont(font5); + label_10 = new QLabel(tab_2); + label_10->setObjectName(QString::fromUtf8("label_10")); + label_10->setGeometry(QRect(717, 720, 43, 31)); + label_10->setFont(font5); + label_18 = new QLabel(tab_2); + label_18->setObjectName(QString::fromUtf8("label_18")); + label_18->setGeometry(QRect(870, 720, 43, 31)); + label_18->setFont(font5); + InputNum2 = new QLineEdit(tab_2); + InputNum2->setObjectName(QString::fromUtf8("InputNum2")); + InputNum2->setGeometry(QRect(930, 720, 81, 30)); + InputNum2->setFont(font7); + label_12 = new QLabel(tab_2); + label_12->setObjectName(QString::fromUtf8("label_12")); + label_12->setGeometry(QRect(40, 630, 141, 21)); + label_12->setFont(font5); + label_21 = new QLabel(tab_2); + label_21->setObjectName(QString::fromUtf8("label_21")); + label_21->setGeometry(QRect(1030, 720, 91, 31)); + label_21->setFont(font5); + tabWidget->addTab(tab_2, QString()); + tab_4 = new QWidget(); + tab_4->setObjectName(QString::fromUtf8("tab_4")); + show_resultsImg = new QLabel(tab_4); + show_resultsImg->setObjectName(QString::fromUtf8("show_resultsImg")); + show_resultsImg->setGeometry(QRect(10, 60, 816, 683)); + show_resultsImg->setStyleSheet(QString::fromUtf8("background-color: rgb(0, 0, 0);")); + label_3 = new QLabel(tab_4); + label_3->setObjectName(QString::fromUtf8("label_3")); + label_3->setGeometry(QRect(10, -10, 181, 81)); + label_3->setFont(font5); + tab4_ReturnToMain = new QPushButton(tab_4); + tab4_ReturnToMain->setObjectName(QString::fromUtf8("tab4_ReturnToMain")); + tab4_ReturnToMain->setGeometry(QRect(1530, 830, 291, 101)); + tab4_ReturnToMain->setStyleSheet(QString::fromUtf8("font: 30pt \"\345\256\213\344\275\223\";")); + resoult_info_label = new QPlainTextEdit(tab_4); + resoult_info_label->setObjectName(QString::fromUtf8("resoult_info_label")); + resoult_info_label->setGeometry(QRect(950, 60, 871, 681)); + resoult_info_label->setStyleSheet(QString::fromUtf8("font: 10pt \"\345\276\256\350\275\257\351\233\205\351\273\221\";")); + choose_pa_2 = new QPushButton(tab_4); + choose_pa_2->setObjectName(QString::fromUtf8("choose_pa_2")); + choose_pa_2->setGeometry(QRect(10, 830, 161, 91)); + choose_pa_2->setFont(font5); + choose_pa_2->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + label_13 = new QLabel(tab_4); + label_13->setObjectName(QString::fromUtf8("label_13")); + label_13->setGeometry(QRect(10, 750, 141, 21)); + label_13->setFont(font5); + choose_to_2 = new QPushButton(tab_4); + choose_to_2->setObjectName(QString::fromUtf8("choose_to_2")); + choose_to_2->setGeometry(QRect(210, 830, 161, 91)); + choose_to_2->setFont(font5); + choose_to_2->setStyleSheet(QString::fromUtf8("color: rgb(0, 0, 0);")); + tabWidget->addTab(tab_4, QString()); + + gridLayout_10->addWidget(tabWidget, 0, 0, 1, 1); + + + retranslateUi(Widget); + + tabWidget->setCurrentIndex(2); + + + QMetaObject::connectSlotsByName(Widget); + } // setupUi + + void retranslateUi(QWidget *Widget) + { + Widget->setWindowTitle(QCoreApplication::translate("Widget", "Widget", nullptr)); + label->setText(QCoreApplication::translate("Widget", "\346\236\234\350\224\254\345\210\206\351\200\211\347\240\224\345\217\221\345\233\242\351\230\237", nullptr)); + label_23->setText(QString()); + tabWidget->setTabText(tabWidget->indexOf(tab_3), QCoreApplication::translate("Widget", "Tab1", nullptr)); + groupBox_9->setTitle(QString()); + groupBox->setTitle(QString()); + label_14->setText(QCoreApplication::translate("Widget", "\346\236\234\350\224\254\345\210\206\351\200\211\347\240\224\345\217\221\345\233\242\351\230\237", nullptr)); + label_RGB->setText(QCoreApplication::translate("Widget", "\345\267\246\344\276\247\347\233\270\346\234\272", nullptr)); + RGBstatus->setText(QCoreApplication::translate("Widget", "\346\234\252\350\277\236\346\216\245", nullptr)); + label_RGB_3->setText(QCoreApplication::translate("Widget", "\345\217\263\344\276\247\347\233\270\346\234\272", nullptr)); + RGBstatus_1->setText(QCoreApplication::translate("Widget", "\346\234\252\350\277\236\346\216\245", nullptr)); + label_RGB_2->setText(QCoreApplication::translate("Widget", "\351\241\266\351\203\250\347\233\270\346\234\272", nullptr)); + RGBstatus_2->setText(QCoreApplication::translate("Widget", "\346\234\252\350\277\236\346\216\245", nullptr)); + label_9->setText(QCoreApplication::translate("Widget", "\345\205\211\350\260\261\347\233\270\346\234\272", nullptr)); + spec_camera_status->setText(QCoreApplication::translate("Widget", "\346\234\252\350\277\236\346\216\245", nullptr)); + label_11->setText(QCoreApplication::translate("Widget", "PLC", nullptr)); + plc_status->setText(QCoreApplication::translate("Widget", "\346\234\252\350\277\236\346\216\245", nullptr)); + label_17->setText(QCoreApplication::translate("Widget", " \346\234\272\346\242\260\346\211\213", nullptr)); + jxs_status->setText(QCoreApplication::translate("Widget", "\346\234\252\350\277\236\346\216\245", nullptr)); + label_26->setText(QCoreApplication::translate("Widget", "\345\275\223\345\211\215\345\210\206\351\200\211\346\236\234\350\224\254\357\274\232", nullptr)); + passionBtn->setText(QCoreApplication::translate("Widget", "\347\231\276\351\246\231\346\236\234", nullptr)); + tomatoBtn->setText(QCoreApplication::translate("Widget", "\347\225\252\350\214\204", nullptr)); + btn_start->setText(QCoreApplication::translate("Widget", "\345\274\200\345\247\213\351\207\207\351\233\206", nullptr)); + show_resoult->setText(QCoreApplication::translate("Widget", "\345\210\206\351\200\211\347\225\214\351\235\242", nullptr)); + btn_setparam->setText(QCoreApplication::translate("Widget", "\350\256\276\347\275\256\345\217\202\346\225\260", nullptr)); + btn_save->setText(QCoreApplication::translate("Widget", "\344\277\235\345\255\230\345\233\276\347\211\207", nullptr)); + view_results->setText(QCoreApplication::translate("Widget", "\346\237\245\347\234\213\347\273\223\346\236\234", nullptr)); + btn_quit->setText(QCoreApplication::translate("Widget", "\351\200\200\345\207\272\347\263\273\347\273\237", nullptr)); + groupBox_4->setTitle(QCoreApplication::translate("Widget", "\347\233\270\346\234\272", nullptr)); + groupBox_2->setTitle(QCoreApplication::translate("Widget", "\351\241\266\351\203\250\344\270\213", nullptr)); + label_topL->setText(QString()); + groupBox_3->setTitle(QCoreApplication::translate("Widget", "\351\241\266\351\203\250\344\270\255", nullptr)); + label_topM->setText(QString()); + groupBox_5->setTitle(QCoreApplication::translate("Widget", "\351\241\266\351\203\250\344\270\212", nullptr)); + label_topR->setText(QString()); + groupBox_6->setTitle(QCoreApplication::translate("Widget", "\345\267\246\344\276\247", nullptr)); + showimg_right->setText(QString()); + groupBox_7->setTitle(QCoreApplication::translate("Widget", "\345\217\263\344\276\247", nullptr)); + showimg_left->setText(QString()); + groupBox_8->setTitle(QCoreApplication::translate("Widget", "\345\205\211\350\260\261\347\233\270\346\234\272", nullptr)); + spec_camera_show->setText(QString()); + tabWidget->setTabText(tabWidget->indexOf(tab), QCoreApplication::translate("Widget", "Tab2", nullptr)); + groupBox_11->setTitle(QCoreApplication::translate("Widget", "\345\267\246\344\276\247\347\233\270\346\234\272", nullptr)); + label_28->setText(QCoreApplication::translate("Widget", "\346\233\235\345\205\211\346\227\266\351\227\264\357\274\232", nullptr)); + label_29->setText(QCoreApplication::translate("Widget", "\347\231\275\345\271\263\350\241\241\357\274\232", nullptr)); + label_30->setText(QCoreApplication::translate("Widget", "\345\242\236\347\233\212\357\274\232", nullptr)); + groupBox_13->setTitle(QCoreApplication::translate("Widget", "\351\241\266\344\276\247\347\233\270\346\234\272", nullptr)); + label_38->setText(QCoreApplication::translate("Widget", "\346\233\235\345\205\211\346\227\266\351\227\264\357\274\232", nullptr)); + label_39->setText(QCoreApplication::translate("Widget", "\347\231\275\345\271\263\350\241\241\357\274\232", nullptr)); + label_40->setText(QCoreApplication::translate("Widget", "\345\242\236\347\233\212\357\274\232", nullptr)); + groupBox_15->setTitle(QCoreApplication::translate("Widget", "\345\217\263\344\276\247\347\233\270\346\234\272", nullptr)); + label_46->setText(QCoreApplication::translate("Widget", "\346\233\235\345\205\211\346\227\266\351\227\264\357\274\232", nullptr)); + label_47->setText(QCoreApplication::translate("Widget", "\347\231\275\345\271\263\350\241\241\357\274\232", nullptr)); + label_48->setText(QCoreApplication::translate("Widget", "\345\242\236\347\233\212\357\274\232", nullptr)); + btn_enterparam->setText(QCoreApplication::translate("Widget", "\350\256\276\347\275\256\347\233\270\346\234\272\345\217\202\346\225\260", nullptr)); + tab3_ReturnToMain->setText(QCoreApplication::translate("Widget", " \350\277\224\345\233\236\344\270\273\347\225\214\351\235\242", nullptr)); + choose_to->setText(QCoreApplication::translate("Widget", "\347\225\252\350\214\204", nullptr)); + choose_pa->setText(QCoreApplication::translate("Widget", " \347\231\276\351\246\231\346\236\234", nullptr)); + InputNum1->setText(QString()); + InputNum5->setText(QString()); + label_5->setText(QCoreApplication::translate("Widget", "\351\230\210\345\200\274\346\240\207\345\207\206\357\274\232", nullptr)); + InputNum4->setText(QString()); + set_threshoid->setText(QCoreApplication::translate("Widget", " \350\256\276\345\256\232\351\230\210\345\200\274", nullptr)); + label_32->setText(QCoreApplication::translate("Widget", "\347\274\272\351\231\267\346\225\260\351\207\217", nullptr)); + label_33->setText(QCoreApplication::translate("Widget", "\347\274\272\351\231\267\351\235\242\347\247\257", nullptr)); + label_10->setText(QCoreApplication::translate("Widget", "\347\263\226\345\272\246", nullptr)); + label_18->setText(QCoreApplication::translate("Widget", "\347\233\264\345\276\204", nullptr)); + InputNum2->setText(QString()); + label_12->setText(QCoreApplication::translate("Widget", "\350\257\267\351\200\211\346\213\251\346\236\234\350\224\254\357\274\232", nullptr)); + label_21->setText(QCoreApplication::translate("Widget", "\351\242\234\350\211\262\345\215\240\346\257\224", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_2), QCoreApplication::translate("Widget", "Tab3", nullptr)); + show_resultsImg->setText(QString()); + label_3->setText(QCoreApplication::translate("Widget", "\345\244\204\347\220\206\347\273\223\346\236\234\345\233\276\357\274\232", nullptr)); + tab4_ReturnToMain->setText(QCoreApplication::translate("Widget", "\350\277\224\345\233\236\344\270\273\347\225\214\351\235\242", nullptr)); + choose_pa_2->setText(QCoreApplication::translate("Widget", " \347\231\276\351\246\231\346\236\234", nullptr)); + label_13->setText(QCoreApplication::translate("Widget", "\345\275\223\345\211\215\345\210\206\347\261\273\346\236\234\350\224\254\357\274\232", nullptr)); + choose_to_2->setText(QCoreApplication::translate("Widget", "\347\225\252\350\214\204", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_4), QCoreApplication::translate("Widget", "Tab4", nullptr)); + } // retranslateUi + +}; + +namespace Ui { + class Widget: public Ui_Widget {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_WIDGET_H diff --git a/widget.cpp b/widget.cpp new file mode 100644 index 0000000..a05e771 --- /dev/null +++ b/widget.cpp @@ -0,0 +1,663 @@ +#include "widget.h" +#include "ui_widget.h" +#include "camera.h" +#include +#include "QSemaphore" +#include "vector" +#include +#include +#define sys_file2 "./sys_daytime2.txt" +//外部引用 +extern ProcessImg *processimg; +extern SendThread *sendthread; +extern RecvThread *recvthread; + +extern CameraL *cameraL; +extern SpecCamera *speccamera; + +extern QSemaphore emptybuff; +extern tomato tomato; + +// c++的省略命名申明 +using namespace std; +bool is_timeout; + +int start_flag=1; +int save_flag=0; + +//0为番茄 1为百香果 +int fruit_flag; + +int resoult_count = 1; + +int i = 1; + + + +//外部用用 +extern int camStatusret; +extern int camStatusret1; +extern int camStatusret2; + +extern int img_count; +extern int img_count1; +extern int img_count2; +//定义管道名称 +extern HANDLE hPipe; +extern HANDLE specPipe; +extern HANDLE RPipe; +extern QString pipeName; +extern QString pipeName2; +extern QString rePipe; + +int pipe_counter=1; + + +//这是 Widge 的构造函数 在你点击运行之后 会执行 +Widget::Widget(QWidget *parent) + : QWidget(parent) + , ui(new Ui::Widget) +{ + ui->setupUi(this); + //直接导入本地时间（方法二） + + QFile daytime_file(sys_file2); + QDateTime lastDateTime; + if (daytime_file.open(QIODevice::ReadOnly | QIODevice::Text)) { + QString line; + QTextStream in(&daytime_file); + while (!in.atEnd()) { + line = in.readLine(); + } + QStringList parts = line.split(" - "); + if (parts.size() > 0) { + lastDateTime = QDateTime::fromString(parts.first(), "yyyy-MM-dd HH:mm:ss"); + } + daytime_file.close(); + } + if (lastDateTime.isValid() && lastDateTime > QDateTime::currentDateTime()) { + QMessageBox::about(this, "错误", "时间校验不通过"); + throw ExpiredException(); + } + QDateTime expiryDate = QDateTime::fromString("2024-08-01 14:00:00", "yyyy-MM-dd HH:mm:ss"); + QDateTime currentDate = QDateTime::currentDateTime(); + if (currentDate >= expiryDate) { + + throw ExpiredException(); + } + + //处理光谱数据的线程 + processimg = new ProcessImg(); + //发送给python端线程 + sendthread = new SendThread(); + //接收python端线程 + recvthread = new RecvThread(); + //new 代表给三个线程开辟空间 + + initparam(); + + /**连接相机*/ + cameraL = new CameraL(); + //初始化RGB相机 + bool RGB_ret = cameraL->initCameraL(); + + if(camStatusret ==0 && RGB_ret) + { + ui->RGBstatus->setText("已连接"); + ui->RGBstatus->setStyleSheet("QLabel{color:rgb(0,255,0);}"); + } + if(camStatusret1 ==0 && RGB_ret) + { + ui->RGBstatus_1->setText("已连接"); + ui->RGBstatus_1->setStyleSheet("QLabel{color:rgb(0,255,0);}"); + + } + if(camStatusret2 ==0 && RGB_ret) + { + ui->RGBstatus_2->setText("已连接"); + ui->RGBstatus_2->setStyleSheet("QLabel{color:rgb(0,255,0);}"); + } + + //初始化光谱相机 + speccamera = new SpecCamera(); + bool spec_ret = speccamera->init_SpecCamera(); + + if(spec_ret == true) + { + ui->spec_camera_status->setText("已连接"); + ui->spec_camera_status->setStyleSheet("QLabel{color:rgb(0,255,0);}"); + } + + //初始化称重模块 + connectModbus_CZ(); + + //初始化机械手 + connect_socket_Jxs(); + + //管道建立连接 + connectPipe(); +} + +Widget::~Widget() +{ + delete ui; +} + +//初始话参数 并非实际相机的参数 而是 ui 界面上的 tab3 上的控件参数 +void Widget::initparam() +{ + camStatusret=-1; + camStatusret1=-1; + camStatusret2=-1; + ui->tabWidget->setCurrentIndex(2); + setMinimumSize(QSize(1200, 600)); + setWindowState(Qt::WindowMaximized); +} + +void Widget::connectModbus_CZ() +{ + //称重模块 + CZ = modbus_new_tcp("192.168.101.110",2000); + modbus_set_slave(CZ, 1); //设置modbus从机地址 + int status = modbus_connect(CZ); + if(status == -1) + { + qDebug() << "modbus connect failed"; + } + else + { + ui->plc_status->setStyleSheet("QLabel{color:rgb(0,255,0);}"); + ui->plc_status->setText("已连接"); + } + modbus_set_response_timeout(CZ, 0, 1000000); +} + +void Widget::connect_socket_Jxs() +{ + server = new QTcpServer(); + server->listen(QHostAddress::Any, 21123); + + bool is_timeout; + server->waitForNewConnection(5000, &is_timeout); + + if(is_timeout == true) + { + qDebug() << "Jxs connect failed"; + return; + } + + socket = server->nextPendingConnection(); + + ui->jxs_status->setStyleSheet("QLabel{color:rgb(0,255,0);}"); + ui->jxs_status->setText("已连接"); +} + +void Widget::connectPipe() +{ + + // 创建并连接到命名管道 + hPipe = CreateFile( + (LPCWSTR)pipeName.utf16(), // 管道名称 + GENERIC_WRITE, // 写入访问 + 0, // 不共享 + NULL, // 默认安全属性 + OPEN_EXISTING, // 打开现有管道 + FILE_ATTRIBUTE_NORMAL, // 默认属性 + NULL // 没有模板文件 + ); + + + + + // 创建并连接到命名管道（光谱相机发送） + specPipe = CreateFile( + (LPCWSTR)pipeName2.utf16(), // 管道名称 + GENERIC_WRITE, // 写入访问 + 0, // 不共享 + NULL, // 默认安全属性 + OPEN_EXISTING, // 打开现有管道 + FILE_ATTRIBUTE_NORMAL, // 默认属性 + NULL // 没有模板文件 + ); + + + // 创建并连接到命名管道 + RPipe = CreateFile( + (LPCWSTR)rePipe.utf16(), // 管道名称 + GENERIC_READ, // 更改为读取访问 + 0, // 不共享 + NULL, // 默认安全属性 + OPEN_EXISTING, // 打开现有管道 + FILE_ATTRIBUTE_NORMAL, // 默认属性 + NULL // 没有模板文件 + ); + + if (RPipe == INVALID_HANDLE_VALUE) { + qWarning() << "Failed to open pipe for reading:" << GetLastError(); + return; + } + +} + + +//点击 ui 界面的开始按钮 +void Widget::on_btn_start_clicked() +{ + //start_flag 为 1 + if(start_flag) + { + QFile file(sys_file2); + if (file.open(QIODevice::Append | QIODevice::Text)) { + QTextStream out(&file); + out << QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss") << " - " << "\n"; + file.close(); + } + ui->btn_start->setStyleSheet("background-color: red;"); + + cameraL->open_camera2(); + cameraL->set_acquisition_mode(); + cameraL->start_capture(); + speccamera->start_capture(); + + //开启线程 也就是执行一次对应线程的 run() 函数 在 thread 里面有 即执行三个线程的 while（1） 死循环 一直监听 + processimg->start(); + sendthread->start(); + recvthread->start(); + + //连接信号跟槽函数 + connect(cameraL,SIGNAL(send_Rgbimage(QImage&)),this,SLOT(showimg(QImage&)),Qt::BlockingQueuedConnection); + connect(cameraL,SIGNAL(send_Rgbimage1(QImage&)),this,SLOT(showimg1(QImage&)),Qt::BlockingQueuedConnection); + connect(cameraL,SIGNAL(send_Rgbimage2(QImage&,QImage&,QImage&)),this,SLOT(showimg2(QImage&,QImage&,QImage&)),Qt::BlockingQueuedConnection); + connect(speccamera,SIGNAL(show_SpecImg(QImage)),this,SLOT(show_specImgSlots(QImage))); + connect(recvthread,SIGNAL(recv_Data(quint16,quint8,quint16,quint8,quint16,quint32,quint16,quint16,QImage)),this,SLOT(receiveDataSlots(quint16,quint8,quint16,quint8,quint16,quint32,quint16,quint16,QImage))); + + + + start_flag=0; + + ui->tabWidget->setCurrentIndex(3); + + // qDebug()<<"Start Success!"; + } + + //start_flag 为 0 + else + { + QFile file(sys_file2); + if (file.open(QIODevice::Append | QIODevice::Text)) { + QTextStream out(&file); + out << QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss") << " - " << "\n"; + file.close(); + } + ui->btn_start->setStyleSheet("background-color: white;"); + cameraL->stop_capture(); + speccamera->stop_capture(); + + disconnect(cameraL,SIGNAL(send_Rgbimage(QImage&)),this,SLOT(showimg(QImage&))); + disconnect(cameraL,SIGNAL(send_Rgbimage1(QImage&)),this,SLOT(showimg1(QImage&))); + disconnect(cameraL,SIGNAL(send_Rgbimage2(QImage&,QImage&,QImage&)),this,SLOT(showimg2(QImage&,QImage&,QImage&))); + disconnect(speccamera,SIGNAL(show_SpecImg(QImage)),this,SLOT(show_specImgSlots(QImage))); + disconnect(recvthread,SIGNAL(recv_Data(quint16,quint8,quint16,quint8,quint16,quint32,quint16,quint16,QImage)),this,SLOT(receiveDataSlots(quint16,quint8,quint16,quint8,quint16,quint32,quint16,quint16,QImage))); + ui->showimg_left->clear(); + ui->showimg_right->clear(); + ui->label_topL->clear(); + ui->label_topM->clear(); + ui->label_topR->clear(); + + start_flag=1; + + // qDebug() << "Stop Success!"; + } + +} + +//右侧 +void Widget::showimg(QImage& img) +{ + + pix = QPixmap::fromImage(img.scaled(ui->showimg_left->width(),ui->showimg_left->height(),Qt::KeepAspectRatio)); + ui->showimg_left->setScaledContents(true); + ui->showimg_left->setPixmap(pix); + ui->showimg_left->show(); +} + +//左侧 +void Widget::showimg1(QImage& img) +{ + + pix = QPixmap::fromImage(img.scaled(ui->showimg_right->width(),ui->showimg_right->height(),Qt::KeepAspectRatio)); + ui->showimg_right->setScaledContents(true); + ui->showimg_right->setPixmap(pix); + ui->showimg_right->show(); +} + +//顶部 +void Widget::showimg2(QImage& img,QImage& img1,QImage& img2) +{ + pix = QPixmap::fromImage(img.scaled(ui->label_topL->width(),ui->label_topL->height(),Qt::KeepAspectRatio)); + ui->label_topL->setScaledContents(true); + ui->label_topL->setPixmap(pix); + ui->label_topL->show(); + + pix1 = QPixmap::fromImage(img1.scaled(ui->label_topM->width(),ui->label_topM->height(),Qt::KeepAspectRatio)); + ui->label_topM->setScaledContents(true); + ui->label_topM->setPixmap(pix1); + ui->label_topM->show(); + + pix2 = QPixmap::fromImage(img2.scaled(ui->label_topR->width(),ui->label_topR->height(),Qt::KeepAspectRatio)); + ui->label_topR->setScaledContents(true); + ui->label_topR->setPixmap(pix2); + ui->label_topR->show(); +} + +void Widget::on_save_img_clicked() +{ + save_flag=1; +} + + +//退出 +void Widget::on_btn_quit_clicked() +{ + qApp->quit(); +} + + +//保存图片按钮 +void Widget::on_btn_save_clicked() +{ + if(!save_flag) + { + ui->btn_save->setStyleSheet("background-color: red;"); + save_flag=1; + } + else + { + ui->btn_save->setStyleSheet("background-color: white;"); + save_flag=0; + } +} + + +void Widget::on_btn_setparam_clicked() +{ + ui->tabWidget->setCurrentIndex(2); +} + +//导入参数 实际没用 因为相机参数会预先写死 并不会在运行途中更换 +void Widget::on_btn_enterparam_clicked() +{ + +} + + + +//接受线程收到数据 长径、短径等等 在 ui 界面显示 +void Widget::receiveDataSlots(quint16 brix,quint8 greenPercentage,quint16 diameter,quint8 weight,quint16 defectNum,quint32 totalDefectArea,quint16 height,quint16 width,QImage img) +{ + img = img.rgbSwapped(); + + pix = QPixmap::fromImage(img.scaled(ui->show_resultsImg->width(),ui->show_resultsImg->height(),Qt::KeepAspectRatio)); + ui->show_resultsImg->setScaledContents(true); + ui->show_resultsImg->setPixmap(pix); + ui->show_resultsImg->show(); + + float brix_float = brix; + float totalDefectArea_float = totalDefectArea; + float greenPercentage_float = greenPercentage; + float diameter_float = diameter; + // ui->Tdangdu_line->setText(QString::number(brix_float/1000)); // + // ui->Zhijing_line->setText(QString::number(diameter_float/100)); //cm + // ui->Shuliang_line->setText(QString::number(defectNum)); + // ui->Mianji_line->setText(QString::number(totalDefectArea_float/1000)); //cm^2 + // ui->Zhanbi_line->setText(QString::number(greenPercentage_float/100)); // + + //重量是g + //读取称重数据 + uint16_t read = 0; + modbus_read_registers(CZ,0x40000,1,&read); + qDebug()<<"称重数据"< 2) + { + level = 4; + } + else + { + if(read > 90) + { + level = 1; + } + else if(read < 65) + { + level = 3; + } + else + { + level = 2; + } + } + } + } + + } + //番茄 + else + { + if(diameter == 0) + { + level = 5; + } + else + { + if(defectNum != 0) + { + level = 5; + } + else + { + if(totalDefectArea_float/1000 >= Quexianmianji) + { + level = 5; + } + else + { + if(greenPercentage_float/100 >= Yansezhanbi) + { + if(diameter_float/100 >= Zhijing -2) + { + level = 3; + } + else + { + level = 4; + } + } + else + { + if(diameter_float/100 >= Zhijing) + { + level = 1; + } + else + { + level = 2; + } + } + } + } + } + } + + // ui->resoult_line->setText(QString::number(level)); + qDebug()<<"果子等级为:"<resoult_info_label->clear(); + } + + QString resout_info; + QString fruit_resoult_flag; + //百香果 + if(fruit_flag) + { + if(defectNum == 0) + { + fruit_resoult_flag = "有"; + } + else + { + fruit_resoult_flag = "无"; + } + resout_info = QString("当前百香果编号为：%1 糖度值为： %2 直径为： %3 %4皱缩 缺陷面积为： %5 最终识别结果为：%6 ").arg(resoult_count).arg(brix_float/1000).arg(diameter_float/100).arg(fruit_resoult_flag).arg(totalDefectArea_float/1000).arg(level); + ui->resoult_info_label->appendPlainText(resout_info); + } + //番茄 + else + { + if(defectNum == 0) + { + fruit_resoult_flag = "无"; + } + else + { + fruit_resoult_flag = "有"; + } + resout_info = QString("当前番茄编号为：%1 直径为： %2 %3裂口 缺陷面积为： %4 绿色占比为： %5 最终识别结果为：%6 ").arg(resoult_count).arg(diameter_float/100).arg(fruit_resoult_flag).arg(totalDefectArea_float/1000).arg(greenPercentage_float/100).arg(level); + ui->resoult_info_label->appendPlainText(resout_info); + } + + resoult_count++ ; + QFile file("./image/output.txt"); + if (file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) + { + QTextStream out(&file); + out << resout_info << "\n"; + file.close(); + } + i++; + + // 给机械手发送信息 + QString txt = QString("[X:0;Y:0;A:0;ATTR:%1;ID:%2]").arg(level).arg(fruit_flag); + QByteArray byteArray = txt.toUtf8(); + socket->write(byteArray); + // qDebug()<<"发送机械手信息等级为:"<spec_camera_show->width(),ui->spec_camera_show->height(),Qt::KeepAspectRatio)); + ui->spec_camera_show->setScaledContents(true); + ui->spec_camera_show->setPixmap(pix); + ui->spec_camera_show->show(); +} + + +void Widget::on_view_results_clicked() +{ + QString resoult_path = "C:/Users/succtech/Desktop/20240425/image"; + // 打开文件选择对话框，并设置默认路径 + QString filePath = QFileDialog::getOpenFileName(this, "查看结果", resoult_path); +} + +void Widget::on_tab4_ReturnToMain_clicked() +{ + ui->tabWidget->setCurrentIndex(1); +} + +void Widget::on_choose_pa_clicked() +{ + fruit_flag = 1; + //tab2 + ui->passionBtn->setStyleSheet("background-color: red;"); + ui->tomatoBtn->setStyleSheet("background-color: white;"); + + //tab3 + ui->choose_pa->setStyleSheet("background-color: red;"); + ui->choose_to->setStyleSheet("background-color: white;"); + + //tab4 + ui->choose_pa_2->setStyleSheet("background-color: red;"); + ui->choose_to_2->setStyleSheet("background-color: white;"); + + ui->tabWidget->setCurrentIndex(1); +} + +void Widget::on_choose_to_clicked() +{ + fruit_flag = 0; + //tab2 + ui->tomatoBtn->setStyleSheet("background-color: red;"); + ui->passionBtn->setStyleSheet("background-color: white;"); + + //tab3 + ui->choose_to->setStyleSheet("background-color: red;"); + ui->choose_pa->setStyleSheet("background-color: white;"); + + //tab4 + ui->choose_to_2->setStyleSheet("background-color: red;"); + ui->choose_pa_2->setStyleSheet("background-color: white;"); + + ui->tabWidget->setCurrentIndex(1); +} + +void Widget::on_tab3_ReturnToMain_clicked() +{ + ui->tabWidget->setCurrentIndex(1); +} + +void Widget::on_show_resoult_clicked() +{ + ui->tabWidget->setCurrentIndex(3); +} + +void Widget::on_set_threshoid_clicked() +{ + Tangdu = ui->InputNum1->text().toInt(); + Zhijing = ui->InputNum2->text().toInt(); + Yansezhanbi = ui->InputNum3->text().toInt(); + Quexianshuliang = ui->InputNum4->text().toInt(); + Quexianmianji = ui->InputNum5->text().toInt(); +} + diff --git a/widget.h b/widget.h new file mode 100644 index 0000000..a8ac332 --- /dev/null +++ b/widget.h @@ -0,0 +1,114 @@ +#ifndef WIDGET_H +#define WIDGET_H + +#include + +#include "QMessageBox" +#include "thread.h" +#include +#include "QMessageBox" +#include "src/modbus.h" + +#include +#define SAVE_IMAGE_PATH "F:/tomato/tomato1227/image/left" +QT_BEGIN_NAMESPACE + + + +//ui界面的类 窗口的各种控件（按钮、文字输入行、label等） +namespace Ui { class Widget; } +QT_END_NAMESPACE +class ExpiredException : public std::exception { +public: + const char* what() const throw() { + return "程序试用期已过，请联系供应商！"; + } +}; +class Widget : public QWidget +{ + Q_OBJECT + +public: + Widget(QWidget *parent = nullptr); + ~Widget(); + + int Tangdu; + int Zhijing = 7; + float Yansezhanbi = 0.3; + int Quexianshuliang = 0; + float Quexianmianji = 0.5; + + void initparam(); + + + + void connectModbus_CZ(); + + void connect_socket_Jxs(); + void connectPipe(); + + QTcpServer *server; + QTcpSocket *socket; + + modbus_t* CZ; + +private slots: + void on_btn_start_clicked(); + + void showimg1(QImage&); + void showimg(QImage&); + void showimg2(QImage&,QImage&,QImage&); + + + void on_save_img_clicked(); + + void on_btn_quit_clicked(); + + void on_btn_save_clicked(); + + void on_btn_setparam_clicked(); + + void on_btn_enterparam_clicked(); + + void receiveDataSlots(quint16,quint8,quint16,quint8,quint16,quint32,quint16,quint16,QImage); + + void show_specImgSlots(QImage); + + void on_view_results_clicked(); + + void on_tab4_ReturnToMain_clicked(); + + void on_choose_pa_clicked(); + + void on_choose_to_clicked(); + + void on_tab3_ReturnToMain_clicked(); + + void on_show_resoult_clicked(); + + void on_set_threshoid_clicked(); + +private: + Ui::Widget *ui; + //画板 负责接收QImage并显示 不能直接显示QImage变量 + QPixmap pix; + QPixmap pix1; + QPixmap pix2; + + int m_index; + + + + //存图标志位 + int save_img=0; + + //tcp变量 + + QTcpServer* server_to_lowermachine = nullptr; + QTcpSocket* lower_machine = nullptr; + volatile bool is_running = false; + + + +}; +#endif // WIDGET_H diff --git a/widget.ui b/widget.ui new file mode 100644 index 0000000..0013624 --- /dev/null +++ b/widget.ui @@ -0,0 +1,1491 @@ + + + Widget + + + + 0 + 0 + 2000 + 1038 + + + + Widget + + + + + + + + + 2 + + + + Tab1 + + + + + + + 36 + false + + + + color: rgb(0, 0, 0); + + + 果蔬分选研发团队 + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + + + + + + + + + + H:/项目代码/tobacco/uppermachine-tobacco/image/njfu.jpg + + + + + + + + Tab2 + + + + + 9 + 9 + 20 + 20 + + + + + + + + + + + 10 + -20 + 1961 + 161 + + + + + 12 + + + + + + + + + 330 + 40 + 511 + 51 + + + + + 华文楷体 + 36 + false + false + + + + color: rgb(0, 0, 0); +font: 36pt "华文楷体"; + + + 果蔬分选研发团队 + + + Qt::PlainText + + + + + + 2 + 90 + 841 + 61 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 左侧相机 + + + + + + + color: rgb(255, 0, 0); + + + 未连接 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 右侧相机 + + + + + + + color: rgb(255, 0, 0); + + + 未连接 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 顶部相机 + + + + + + + color: rgb(255, 0, 0); + + + 未连接 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 光谱相机 + + + + + + + color: rgb(255, 0, 0); + + + 未连接 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + PLC + + + + + + + color: rgb(255, 0, 0); + + + 未连接 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 机械手 + + + + + + + color: rgb(255, 0, 0); + + + 未连接 + + + + + + + + + 790 + 220 + 574 + 356 + + + + + + + + + 10 + 140 + 1951 + 791 + + + + + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 当前分选果蔬： + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 百香果 + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 番茄 + + + + + + + + + + 0 + 0 + + + + + 宋体 + 30 + false + false + + + + color: rgb(0, 0, 0); +font: 30pt "宋体"; + + + 开始采集 + + + + + + + + 0 + 0 + + + + + 宋体 + 30 + false + false + + + + color: rgb(0, 0, 0); +font: 30pt "宋体"; + + + 分选界面 + + + + + + + + 0 + 0 + + + + + 宋体 + 30 + false + false + + + + color: rgb(0, 0, 0); +font: 30pt "宋体"; + + + 设置参数 + + + + + + + + 0 + 0 + + + + + 宋体 + 30 + false + false + + + + color: rgb(0, 0, 0); +font: 30pt "宋体"; + + + 保存图片 + + + + + + + + 0 + 0 + + + + + 宋体 + 30 + false + false + + + + color: rgb(0, 0, 0); +font: 30pt "宋体"; + + + 查看结果 + + + + + + + + 0 + 0 + + + + + 宋体 + 30 + false + false + + + + color: rgb(0, 0, 0); +font: 30pt "宋体"; + + + 退出系统 + + + + + + + + + + + + 12 + true + + + + color: rgb(0, 0, 0); + + + 相机 + + + + + + + 12 + true + + + + 顶部下 + + + + + + background-color: rgb(170, 170, 255); + + + + + + + + + + + + + + 12 + true + + + + 顶部中 + + + + + + background-color: rgb(170, 170, 255); + + + + + + + + + + + + + + 12 + true + + + + 顶部上 + + + + + + background-color: rgb(170, 170, 255); + + + + + + + + + + + + + + 12 + true + + + + 左侧 + + + + + + background-color: rgb(170, 170, 255); + + + + + + + + + + + + + + 12 + true + + + + 右侧 + + + + + + background-color: rgb(170, 170, 255); + + + + + + + + + + + + + + 12 + true + + + + 光谱相机 + + + + + + background-color: rgb(170, 170, 255); + + + + + + + + + + + + + + + + + + + + Tab3 + + + + + 40 + 50 + 531 + 231 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 左侧相机 + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 曝光时间： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 白平衡： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 增益： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + + 40 + 350 + 531 + 231 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 顶侧相机 + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 曝光时间： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 白平衡： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 增益： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + + 700 + 60 + 531 + 231 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 右侧相机 + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 曝光时间： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 白平衡： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 增益： + + + + + + + + true + + + + color: rgb(0, 0, 0); + + + + + + + + + 710 + 380 + 161 + 91 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 设置相机参数 + + + + + + 1300 + 820 + 241 + 91 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 返回主界面 + + + + + + 340 + 710 + 241 + 141 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 番茄 + + + + + + 40 + 710 + 231 + 141 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 百香果 + + + + + + 774 + 720 + 81 + 30 + + + + + 16 + false + + + + + + + + + + 1050 + 780 + 94 + 30 + + + + + 16 + false + + + + + + + + + + 720 + 630 + 108 + 21 + + + + + 16 + true + + + + 阈值标准： + + + + + + 820 + 780 + 81 + 30 + + + + + 16 + false + + + + + + + + + + 720 + 830 + 261 + 91 + + + + font: 30pt "宋体"; + + + 设定阈值 + + + + + + 720 + 780 + 86 + 31 + + + + + 16 + true + + + + 缺陷数量 + + + + + + 1140 + 720 + 91 + 28 + + + + + 16 + false + + + + + + + 940 + 780 + 86 + 31 + + + + + 16 + true + + + + 缺陷面积 + + + + + + 717 + 720 + 43 + 31 + + + + + 16 + true + + + + 糖度 + + + + + + 870 + 720 + 43 + 31 + + + + + 16 + true + + + + 直径 + + + + + + 930 + 720 + 81 + 30 + + + + + 16 + false + + + + + + + + + + 40 + 630 + 141 + 21 + + + + + 16 + true + + + + 请选择果蔬： + + + + + + 1030 + 720 + 91 + 31 + + + + + 16 + true + + + + 颜色占比 + + + + + + Tab4 + + + + + 10 + 60 + 816 + 683 + + + + background-color: rgb(0, 0, 0); + + + + + + + + + 10 + -10 + 181 + 81 + + + + + 16 + true + + + + 处理结果图： + + + + + + 1530 + 830 + 291 + 101 + + + + font: 30pt "宋体"; + + + 返回主界面 + + + + + + 950 + 60 + 871 + 681 + + + + font: 10pt "微软雅黑"; + + + + + + 10 + 830 + 161 + 91 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 百香果 + + + + + + 10 + 750 + 141 + 21 + + + + + 16 + true + + + + 当前分类果蔬： + + + + + + 210 + 830 + 161 + 91 + + + + + 16 + true + + + + color: rgb(0, 0, 0); + + + 番茄 + + + + + + + + + +