From 527f96d4ef8e258e1f2f90c6c9b8b214bc555770 Mon Sep 17 00:00:00 2001 From: Peter M. Groen Date: Sun, 12 Jun 2022 12:15:52 +0200 Subject: [PATCH] Setting up working version --- src/ConnectionConfig.h | 110 +++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------- src/IModbusAdapter.h | 48 ++++++++++++++++++++++++------------------------ src/ModbusAdapter.cpp | 110 +++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------- src/ModbusAdapter.h | 73 +++++++++++++++++++++++++++++++++++++------------------------------------ stack/config.h | 165 --------------------------------------------------------------------------------------------------------------------------------------------------------------------- stack/modbus-data.c | 204 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ stack/modbus-private.h | 101 ----------------------------------------------------------------------------------------------------- stack/modbus-rtu-private.h | 34 ---------------------------------- stack/modbus-rtu.c | 987 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- stack/modbus-rtu.h | 34 ---------------------------------- stack/modbus-tcp-private.h | 39 --------------------------------------- stack/modbus-tcp.c | 866 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- stack/modbus-tcp.h | 24 ------------------------ stack/modbus-version.h | 34 ---------------------------------- stack/modbus.c | 1898 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- stack/modbus.h | 262 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 16 files changed, 171 insertions(+), 4818 deletions(-) delete mode 100644 stack/config.h delete mode 100644 stack/modbus-data.c delete mode 100644 stack/modbus-private.h delete mode 100644 stack/modbus-rtu-private.h delete mode 100644 stack/modbus-rtu.c delete mode 100644 stack/modbus-rtu.h delete mode 100644 stack/modbus-tcp-private.h delete mode 100644 stack/modbus-tcp.c delete mode 100644 stack/modbus-tcp.h delete mode 100644 stack/modbus-version.h delete mode 100644 stack/modbus.c delete mode 100644 stack/modbus.h diff --git a/src/ConnectionConfig.h b/src/ConnectionConfig.h index a2ffca6..d706226 100644 --- a/src/ConnectionConfig.h +++ b/src/ConnectionConfig.h @@ -7,7 +7,7 @@ #include /*! - * \brief The ConnectionPort enum. + * The ConnectionPort enum. * CP_EXTERNAL - the first serial port * CP_IOBUS - The second serial port through RJ45 connector * CP_TCP - TCP Connections @@ -20,7 +20,7 @@ enum class ConnectionPort : unsigned int }; /*! - * \brief The Parity enum. + * The Parity enum. * Used in a serial port context */ enum class Parity : unsigned int @@ -31,7 +31,7 @@ enum class Parity : unsigned int }; /*! - * \brief The ConnectionType enum. + * The ConnectionType enum. * Added for convenience, to distinguish between types. */ enum class ConnectionType : unsigned int @@ -42,7 +42,7 @@ enum class ConnectionType : unsigned int }; /*! - * \brief The ConnectionConfig class holds all the information we need to establish a proper connection. + * The ConnectionConfig class holds all the information we need to establish a proper connection. * It can be created by a configuration object and passed on to the ModBus stack. * By using this class, all the connectioninfo is within its context for convenience. * @@ -53,88 +53,88 @@ class ConnectionConfig { public: /*! - * \brief ConnectionConfig Constructor. Used to create a new serial connection. - * \param port - The portname given by its enum. - * \param baud - The port speed in a serial port context ( default = 115200 ) - * \param parity - The parity. ( Default : None, no parity ) - * \param dataBits - The number of databits. RTU uses 8 (0 - 255), ASCII uses 7 (0 - 127). Default is RTU - * \param stopBits - The number of stopbits used to detect the end of the frame. ( Default = 1 ) - * \param timeOut - Timeout in .1 secs. See the termios documentation for deviations on this. + * ConnectionConfig Constructor. Used to create a new serial connection. + * @param port - The portname given by its enum. + * @param baud - The port speed in a serial port context ( default = 115200 ) + * @param parity - The parity. ( Default : None, no parity ) + * @param dataBits - The number of databits. RTU uses 8 (0 - 255), ASCII uses 7 (0 - 127). Default is RTU + * @param stopBits - The number of stopbits used to detect the end of the frame. ( Default = 1 ) + * @param timeOut - Timeout in .1 secs. See the termios documentation for deviations on this. */ ConnectionConfig( ConnectionPort port, int baud = 115200, Parity parity = Parity::PAR_NONE, int dataBits = 8, int stopBits = 1, int timeOut = -1 ) - : m_port( port ) - , m_baudRate( baud ) - , m_parity( parity ) - , m_dataBits( dataBits ) - , m_stopBits( stopBits ) - , m_ipaddress() - , m_portnumber( -1 ) - , m_timeOut( timeOut ) - , m_conType( ConnectionType::CT_SERIAL ) + : port( port ) + , baudRate( baud ) + , parity( parity ) + , dataBits( dataBits ) + , stopBits( stopBits ) + , ipaddress() + , portnumber( -1 ) + , timeOut( timeOut ) + , connectionType( ConnectionType::CT_SERIAL ) {} /*! * \brief ConnectionConfig Constructor. Used to create a new TCP connection. - * \param port - The portname given by its enaum. ( Should be CP_TCP ) - * \param ip - The ip address of the ModBus device we want to connect to. - * \param portnum - The portnumber the ModBus device is using - * \param timeOut - Timeout in which a modbus device should respond. + * @param port - The portname given by its enaum. ( Should be CP_TCP ) + * @param ip - The ip address of the ModBus device we want to connect to. + * @param portnum - The portnumber the ModBus device is using + * @param timeOut - Timeout in which a modbus device should respond. */ ConnectionConfig( ConnectionPort port, const std::string &ip, int portnum, int timeOut = -1 ) - : m_port( port ) - , m_baudRate( -1 ) - , m_parity( Parity::PAR_NONE ) - , m_dataBits( -1 ) - , m_stopBits( -1 ) - , m_ipaddress( ip ) - , m_portnumber( portnum ) - , m_timeOut( timeOut ) - , m_conType( ConnectionType::CT_TCP ) + : port( port ) + , baudRate( -1 ) + , parity( Parity::PAR_NONE ) + , dataBits( -1 ) + , stopBits( -1 ) + , ipaddress( ip ) + , portnumber( portnum ) + , timeOut( timeOut ) + , connectionType( ConnectionType::CT_TCP ) {} // Getters and Setters. Implemented to avoid outside meddling on the member variables. - std::string getPort() const { return m_portMap.at(m_port); } ///< Get the translated portName. - ConnectionPort getPortEnum() const { return m_port; } ///< Get the portname Enum - int getBaudRate() const { return m_baudRate; } ///< Get the given baudrate as int. - char getParity() const { return m_parityMap.at(m_parity); } ///< Get the translated parity. - Parity getParityEnum() const { return m_parity; } ///< Get the parity Enum - int getDataBits() const { return m_dataBits; } ///< Get the number of databits ( 7 for ASCII, 8 for RTU ) - int getStopBits() const { return m_stopBits; } ///< Get the number of stopBits. ( de-facto = 1 ) + std::string getPort() const { return portMap.at(port); } ///< Get the translated portName. + ConnectionPort getPortEnum() const { return port; } ///< Get the portname Enum + int getBaudRate() const { return baudRate; } ///< Get the given baudrate as int. + char getParity() const { return parityMap.at( parity ); } ///< Get the translated parity. + Parity getParityEnum() const { return parity; } ///< Get the parity Enum + int getDataBits() const { return dataBits; } ///< Get the number of databits ( 7 for ASCII, 8 for RTU ) + int getStopBits() const { return stopBits; } ///< Get the number of stopBits. ( de-facto = 1 ) - std::string getIpAddress() const { return m_ipaddress; } ///< Get the ip-address as string - int getTcpPort() const { return m_portnumber; } ///< Get the tcp portnumber as int + std::string getIpAddress() const { return ipaddress; } ///< Get the ip-address as string + int getTcpPort() const { return portnumber; } ///< Get the tcp portnumber as int - int getTimeOut() const { return m_timeOut; } ///< Get the timeout as a multitude of 0.1 sec. - ConnectionType getType() const { return m_conType; } ///< Get the connection type ( Serial, TCP or Unknown ) + int getTimeOut() const { return timeOut; } ///< Get the timeout as a multitude of 0.1 sec. + ConnectionType getType() const { return connectionType; } ///< Get the connection type ( Serial, TCP or Unknown ) private: /// Serial connections - ConnectionPort m_port; ///< Member variable holding the portName Enum - int m_baudRate; ///< Member variable holding the Serial port Baudrate - Parity m_parity; ///< Member variable holding the Serial port Parity - int m_dataBits; ///< Member variable holding the number of databits - int m_stopBits; ///< Member variable holding the number of stopbits + ConnectionPort port; ///< Member variable holding the portName Enum + int baudRate; ///< Member variable holding the Serial port Baudrate + Parity parity; ///< Member variable holding the Serial port Parity + int dataBits; ///< Member variable holding the number of databits + int stopBits; ///< Member variable holding the number of stopbits /// TCP connections - std::string m_ipaddress; ///< Member variable holding the ip-address of the TCP-connection - int m_portnumber; ///< Member variable holding the portnumber of the TCP-connection + std::string ipaddress; ///< Member variable holding the ip-address of the TCP-connection + int portnumber; ///< Member variable holding the portnumber of the TCP-connection /// Generic - int m_timeOut; ///< Member variable holding the timeOut value - ConnectionType m_conType; ///< Member variable holding the connection type. + int timeOut; ///< Member variable holding the timeOut value + ConnectionType connectionType; ///< Member variable holding the connection type. /// Translation tables for portnames and parity. // ============================================================ // == Change accordingly to the devicenames on your platform == // ============================================================ - std::unordered_map m_portMap = + std::unordered_map portMap = { { ConnectionPort::CP_EXTERNAL, "/dev/ttyUSB0" }, { ConnectionPort::CP_IOBUS, "/dev/ttyUSB1" } }; - std::unordered_map m_parityMap = + std::unordered_map parityMap = { { Parity::PAR_EVEN, 'E' }, { Parity::PAR_ODD, 'O' }, diff --git a/src/IModbusAdapter.h b/src/IModbusAdapter.h index b496cf0..1637c62 100644 --- a/src/IModbusAdapter.h +++ b/src/IModbusAdapter.h @@ -15,7 +15,7 @@ using modbusData = std::vector>; class ConnectionConfig; /*! - * \brief The IModbusAdapter class provides an abstract way of using + * The IModbusAdapter class provides an abstract way of using * the modbus stack. Implemented as a pure virtual, it cannot be instantiated. * This represents a unique connection to either a serial bus or a TCP connection. */ @@ -30,55 +30,55 @@ public: virtual bool ModbusConnect( const ConnectionConfig &conncfg ) = 0; /*! - * \brief ModbusDisconnect + * ModbusDisconnect * Disconnect from the serial bus or the TCP connection, freeing its resources */ virtual bool ModbusDisconnect() = 0; /*! - * \brief Read data from a modbus device given by its parameters. - * \param slaveId - The Id of the ModbusDevice. - * \param functionCode - The code describing the action we want to perform on the device. + * Read data from a modbus device given by its parameters. + * @param slaveId - The Id of the ModbusDevice. + * @param functionCode - The code describing the action we want to perform on the device. * Given by an enum, provided by the modbus-stack. - * \param startAddress - Startaddres of the register we want to read. - * \param noOfItems - The number of items we expect back. - * \returns modbusData - A vector holding each register in an entry in the same order as they are received. + * @param startAddress - Startaddres of the register we want to read. + * @param noOfItems - The number of items we expect back. + * @returns modbusData - A vector holding each register in an entry in the same order as they are received. * Empty if no data was received. */ virtual modbusData ModbusReadData( int slaveId, int functionCode, int startAddress, int noOfItems ) = 0; /*! - * \brief Read data from the holdregisters ( or keep-registers ) of a modbus device. - * \param slaveId - The Id of the ModbusDevice. - * \param startAddress - Startaddres of the register we want to read. - * \param noOfItems - The number of items we expect back. - * \returns modbusData - A vector holding each register in an entry in the same order as they are received. + * Read data from the holdregisters ( or keep-registers ) of a modbus device. + * @param slaveId - The Id of the ModbusDevice. + * @param startAddress - Startaddres of the register we want to read. + * @param noOfItems - The number of items we expect back. + * @returns modbusData - A vector holding each register in an entry in the same order as they are received. * Empty if no data was received. */ virtual modbusData ModbusReadHoldReg( int slaveId, int startAddress, int noOfItems ) = 0; /*! - * \brief Write data to the device. - * \param slaveId - The Id of the Modbus device - * \param funtionCode - The code describing the action we want to perform on the device + * Write data to the device. + * @param slaveId - The Id of the Modbus device + * @param funtionCode - The code describing the action we want to perform on the device * given by an enum, provided by the modbus-stack. - * \param startAddress - Startaddres of the register we want to read. - * \param noOfItems - The number of items we expect to be written - * \param values - The values we want to write to the given device. Each vector-entry represents a single byte + * @param startAddress - Startaddres of the register we want to read. + * @param noOfItems - The number of items we expect to be written + * @param values - The values we want to write to the given device. Each vector-entry represents a single byte * and they will be sent in sequence. */ virtual void ModBusWriteData( int slaveId, int functionCode, int startAddress, int noOfItems, std::vectorvalues ) = 0; /*! - * \brief Indicates if this connection is alive. - * \return True if alive, false if not. + * Indicates if this connection is alive. + * @return True if alive, false if not. */ virtual bool isConnected() const = 0; /*! - * \brief returns the translated error code coming from the modbus stack. - * \param errnum - error Number coming from the stack. - * \return The translated error as a string. Empty if not resolvable. + * returns the translated error code coming from the modbus stack. + * @param errnum - error Number coming from the stack. + * @return The translated error as a string. Empty if not resolvable. */ virtual std::string ErrorString( int errnum ) const = 0; }; diff --git a/src/ModbusAdapter.cpp b/src/ModbusAdapter.cpp index fa9f194..0ddbad7 100644 --- a/src/ModbusAdapter.cpp +++ b/src/ModbusAdapter.cpp @@ -5,7 +5,7 @@ #include /// Added for memset functionality ModbusAdapter::ModbusAdapter() - : m_modbus( nullptr ) + : modbus( nullptr ) { this->InitBuffers(); } @@ -15,52 +15,52 @@ ModbusAdapter::~ModbusAdapter() } -bool ModbusAdapter::ModbusConnect( const ConnectionConfig &conncfg ) +bool ModbusAdapter::ModbusConnect( const ConnectionConfig &config ) { - if( m_connected ) + if( connected ) { this->ModbusDisconnect(); // Will already set m_connected } - m_connType = conncfg.getType(); + connectionType = config.getType(); - switch( m_connType ) + switch( connectionType ) { case ConnectionType::CT_SERIAL: - m_connected = this->ModbusConnectRTU( conncfg.getPort(), conncfg.getBaudRate(), conncfg.getParity(), conncfg.getDataBits(), conncfg.getStopBits(), conncfg.getTimeOut(), MODBUS_RTU_RTS_NONE ); + connected = this->ModbusConnectRTU( config.getPort(), config.getBaudRate(), config.getParity(), config.getDataBits(), config.getStopBits(), config.getTimeOut(), MODBUS_RTU_RTS_NONE ); break; case ConnectionType::CT_TCP: - m_connected = this->ModbusConnectTCP( conncfg.getIpAddress(), conncfg.getTcpPort(), 10 ); + connected = this->ModbusConnectTCP( config.getIpAddress(), config.getTcpPort(), 10 ); break; default: // throw a sensible message or return an errorcode. break; } - return m_connected; + return connected; } bool ModbusAdapter::ModbusDisconnect() { - if( m_modbus != nullptr ) + if( modbus != nullptr ) { - if( m_connected ) + if( connected ) { - modbus_close( m_modbus ); - modbus_free( m_modbus ); + modbus_close( modbus ); + modbus_free( modbus ); } // Clean up after ourselves. - m_modbus = nullptr; + modbus = nullptr; } - m_connected = false; + connected = false; return true; } modbusData ModbusAdapter::ModbusReadData( int slaveId, int functionCode, int startAddress, int noOfItems ) { - if( m_modbus == nullptr ) + if( modbus == nullptr ) { // No context return modbusData(); @@ -69,22 +69,22 @@ modbusData ModbusAdapter::ModbusReadData( int slaveId, int functionCode, int sta int resultValue = -1; bool is16Bit = false; - modbus_set_slave( m_modbus, slaveId ); + modbus_set_slave( modbus, slaveId ); // Request data from modbus. switch( functionCode ) { case MODBUS_FC_READ_COILS: - resultValue = modbus_read_bits( m_modbus, startAddress, noOfItems, m_dest ); + resultValue = modbus_read_bits( modbus, startAddress, noOfItems, m_dest ); break; case MODBUS_FC_READ_DISCRETE_INPUTS: - resultValue = modbus_read_input_bits( m_modbus, startAddress, noOfItems, m_dest ); + resultValue = modbus_read_input_bits( modbus, startAddress, noOfItems, m_dest ); break; case MODBUS_FC_READ_HOLDING_REGISTERS: - resultValue = modbus_read_registers( m_modbus, startAddress, noOfItems, m_dest16 ); + resultValue = modbus_read_registers( modbus, startAddress, noOfItems, m_dest16 ); break; case MODBUS_FC_READ_INPUT_REGISTERS: - resultValue = modbus_read_input_registers( m_modbus, startAddress, noOfItems, m_dest16 ); + resultValue = modbus_read_input_registers( modbus, startAddress, noOfItems, m_dest16 ); break; default: @@ -104,7 +104,7 @@ modbusData ModbusAdapter::ModbusReadData( int slaveId, int functionCode, int sta resultData.push_back( (is16Bit ? static_cast(m_dest16[index]) : static_cast(m_dest[index])) ); } - modbus_flush( m_modbus ); // flush data + modbus_flush( modbus ); // flush data this->ClearBuffers(); return resultData; @@ -112,7 +112,7 @@ modbusData ModbusAdapter::ModbusReadData( int slaveId, int functionCode, int sta modbusData ModbusAdapter::ModbusReadHoldReg( int slaveId, int startAddress, int noOfItems ) { - if( m_modbus == nullptr ) + if( modbus == nullptr ) { return modbusData(); } @@ -121,9 +121,9 @@ modbusData ModbusAdapter::ModbusReadHoldReg( int slaveId, int startAddress, int // -- Start Critical Section --- ?? // - modbus_set_slave( m_modbus, slaveId ); + modbus_set_slave( modbus, slaveId ); /// Request data from modbus - resultValue = modbus_read_registers( m_modbus, startAddress, noOfItems, m_dest16 ); + resultValue = modbus_read_registers( modbus, startAddress, noOfItems, m_dest16 ); /// Read the databuffers if( resultValue != noOfItems ) @@ -137,7 +137,7 @@ modbusData ModbusAdapter::ModbusReadHoldReg( int slaveId, int startAddress, int resultData.push_back( static_cast(m_dest16[index]) ); } - modbus_flush( m_modbus ); + modbus_flush( modbus ); this->ClearBuffers(); // -- End Critical Section --- ?? // @@ -147,7 +147,7 @@ modbusData ModbusAdapter::ModbusReadHoldReg( int slaveId, int startAddress, int void ModbusAdapter::ModBusWriteData( int slaveId, int functionCode, int startAddress, int noOfItems, std::vectorvalues ) { - if( m_modbus == nullptr ) + if( modbus == nullptr ) { // No modbus context. Sensible log-line and exit. return; @@ -171,31 +171,31 @@ void ModbusAdapter::ModBusWriteData( int slaveId, int functionCode, int startAdd int resultValue = -1; - modbus_set_slave( m_modbus, slaveId ); + modbus_set_slave( modbus, slaveId ); // Request data from modbus switch( functionCode ) { case MODBUS_FC_WRITE_SINGLE_COIL: - resultValue = modbus_write_bit( m_modbus, startAddress, values[0] ); + resultValue = modbus_write_bit( modbus, startAddress, values[0] ); noOfItems = 1; break; case MODBUS_FC_WRITE_SINGLE_REGISTER: - resultValue = modbus_write_register( m_modbus, startAddress, values[0] ); + resultValue = modbus_write_register( modbus, startAddress, values[0] ); noOfItems = 1; break; case MODBUS_FC_WRITE_MULTIPLE_COILS: - resultValue = modbus_write_bits( m_modbus, startAddress, noOfItems, data8 ); + resultValue = modbus_write_bits( modbus, startAddress, noOfItems, data8 ); break; case MODBUS_FC_WRITE_MULTIPLE_REGISTERS: - resultValue = modbus_write_bits( m_modbus, startAddress, noOfItems, data16 ); + resultValue = modbus_write_bits( modbus, startAddress, noOfItems, data16 ); break; } delete[] data8; delete[] data16; - modbus_flush(m_modbus); // Flush data. + modbus_flush(modbus); // Flush data. if( resultValue != noOfItems ) { @@ -205,7 +205,7 @@ void ModbusAdapter::ModBusWriteData( int slaveId, int functionCode, int startAdd bool ModbusAdapter::isConnected() const { - return m_connected; + return connected; } std::string ModbusAdapter::ErrorString( int errnum ) const @@ -235,37 +235,37 @@ std::string ModbusAdapter::ErrorString( int errnum ) const /* ============= PRIVATE METHODS ============= */ bool ModbusAdapter::ModbusConnectRTU( const std::string &serialport, int baud, char parity, int dataBits, int stopBits, int RTS, int timeOut ) { - m_modbus = modbus_new_rtu( serialport.c_str(), baud, parity, dataBits, stopBits, RTS ); + modbus = modbus_new_rtu( serialport.c_str(), baud, parity, dataBits, stopBits, RTS ); #ifdef LIB_MODBUS_DEBUG_OUTPUT // Do sensible logging through PRIVA_LOG m_modbus_set_debug( m_modbus, 1 ); #endif - if( m_modbus == nullptr ) + if( modbus == nullptr ) { // We can stop here. Nothing to be done as we don't have a valid context // Log to PRIVA_LOG - m_connected = false; - return m_connected; + connected = false; + return connected; } - else if( m_modbus && modbus_connect( m_modbus ) == -1 ) + else if( modbus && modbus_connect( modbus ) == -1 ) { // We could not connect to the selected serial port. // We can stop here. Nothing to be done as we don't have a valid connection - modbus_free( m_modbus ); - m_connected = false; - return m_connected; + modbus_free( modbus ); + connected = false; + return connected; } - m_connected = true; + connected = true; // Set recovery mode - modbus_set_error_recovery( m_modbus, MODBUS_ERROR_RECOVERY_PROTOCOL ); + modbus_set_error_recovery( modbus, MODBUS_ERROR_RECOVERY_PROTOCOL ); // Set the response timeout - modbus_set_response_timeout( m_modbus, timeOut, 0 ); + modbus_set_response_timeout( modbus, timeOut, 0 ); - return m_connected; + return connected; } bool ModbusAdapter::ModbusConnectTCP( const std::string &ip, int port, int timeOut ) @@ -276,37 +276,37 @@ bool ModbusAdapter::ModbusConnectTCP( const std::string &ip, int port, int timeO return false; } - m_modbus = modbus_new_tcp( ip.c_str(), port ); + modbus = modbus_new_tcp( ip.c_str(), port ); #ifdef LIB_MODBUS_DEBUG_OUTPUT // Do sensible logging through PRIVA_LOG m_modbus_set_debug( m_modbus, 1 ); #endif - if( m_modbus == nullptr ) + if( modbus == nullptr ) { // We can stop here. Nothing to be done as we don't have a valid context // Log to PRIVA_LOG return false; } - else if( m_modbus && modbus_connect( m_modbus ) == -1 ) + else if( modbus && modbus_connect( modbus ) == -1 ) { // We could not connect to the selected serial port. // We can stop here. Nothing to be done as we don't have a valid connection - modbus_free( m_modbus ); - m_connected = false; - return m_connected; + modbus_free( modbus ); + connected = false; + return connected; } - m_connected = true; + connected = true; // Set recovery mode - modbus_set_error_recovery( m_modbus, MODBUS_ERROR_RECOVERY_PROTOCOL ); + modbus_set_error_recovery( modbus, MODBUS_ERROR_RECOVERY_PROTOCOL ); // Set the response timeout - modbus_set_response_timeout( m_modbus, timeOut, 0 ); + modbus_set_response_timeout( modbus, timeOut, 0 ); - return m_connected; + return connected; } void ModbusAdapter::InitBuffers() diff --git a/src/ModbusAdapter.h b/src/ModbusAdapter.h index 4708f34..c8e02c1 100644 --- a/src/ModbusAdapter.h +++ b/src/ModbusAdapter.h @@ -13,78 +13,79 @@ #include #include -/// @brief The ModbusAdapter class represents a single modbus context. Each context will -/// result in an instance of this class. It is not intended to be -/// created directly but through a factory. The factory will create -/// the object and return the pointer to its interface. + +/// @class The ModbusAdapter class represents a single modbus context. Each context will +/// result in an instance of this class. It is not intended to be +/// created directly but through a factory. The factory will create +/// the object and return the pointer to its interface. class ModbusAdapter : public IModbusAdapter { public: /*! - * \brief Default constructor + * Default constructor */ explicit ModbusAdapter(); /*! - * \brief Default destructor + * Default destructor */ virtual ~ModbusAdapter(); /*! - * \brief /// Create a modbus connection, accepting a configuration object. + * Create a modbus connection, accepting a configuration object. */ - bool ModbusConnect( const ConnectionConfig &conncfg ) override; + bool ModbusConnect( const ConnectionConfig &config ) override; /*! - * \brief ModbusDisconnect + * ModbusDisconnect * Disconnect from the serial bus or the TCP connection, freeing its resources */ bool ModbusDisconnect() override; /*! - * \brief Read data from a modbus device given by its parameters. - * \param slaveId - The Id of the ModbusDevice. - * \param functionCode - The code describing the action we want to perform on the device. + * Read data from a modbus device given by its parameters. + * @param slaveId - The Id of the ModbusDevice. + * @param functionCode - The code describing the action we want to perform on the device. * Given by an enum, provided by the modbus-stack. - * \param startAddress - Startaddres of the register we want to read. - * \param noOfItems - The number of items we expect back. - * \returns modbusData - A vector holding each register in an entry in the same order as they are received. + * @param startAddress - Startaddres of the register we want to read. + * @param noOfItems - The number of items we expect back. + * @returns modbusData - A vector holding each register in an entry in the same order as they are received. * Empty if no data was received. */ modbusData ModbusReadData( int slaveId, int functionCode, int startAddress, int noOfItems ) override; /*! - * \brief Read data from the holdregisters ( or keep-registers ) of a modbus device. - * \param slaveId - The Id of the ModbusDevice. - * \param startAddress - Startaddres of the register we want to read. - * \param noOfItems - The number of items we expect back. - * \returns modbusData - A vector holding each register in an entry in the same order as they are received. + * Read data from the holdregisters ( or keep-registers ) of a modbus device. + * @param slaveId - The Id of the ModbusDevice. + * @param startAddress - Startaddres of the register we want to read. + * @param noOfItems - The number of items we expect back. + * @returns modbusData - A vector holding each register in an entry in the same order as they are received. * Empty if no data was received. */ modbusData ModbusReadHoldReg( int slaveId, int startAddress, int noOfItems ) override; /*! - * \brief Write data to the device. - * \param slaveId - The Id of the Modbus device - * \param funtionCode - The code describing the action we want to perform on the device + * Write data to the device. + * @param slaveId - The Id of the Modbus device + * @param funtionCode - The code describing the action we want to perform on the device * given by an enum, provided by the modbus-stack. - * \param startAddress - Startaddres of the register we want to read. - * \param noOfItems - The number of items we expect to be written - * \param values - The values we want to write to the given device. Each vector-entry represents a single byte + * @param startAddress - Startaddres of the register we want to read. + * @param noOfItems - The number of items we expect to be written + * @param values - The values we want to write to the given device. Each vector-entry represents a single byte * and they will be sent in sequence. */ void ModBusWriteData( int slaveId, int functionCode, int startAddress, int noOfItems, std::vectorvalues ) override; /*! - * \brief Indicates if this connection is alive. - * \return True if alive, false if not. + * Indicates if this connection is alive. + * @returns True if alive, false if not. */ bool isConnected() const override; /*! - * \brief returns the translated error code coming from the modbus stack. - * \param errnum - error Number coming from the stack. - * \return The translated error as a string. Empty if not resolvable. + * returns the translated error code coming from the modbus stack. + * @param errnum - error Number coming from the stack. + * @return The translated error as a string. Empty if not resolvable. */ std::string ErrorString( int errnum ) const override; @@ -96,11 +97,11 @@ private: // Methods void ClearBuffers(); private: // Members - ConnectionType m_connType { ConnectionType::CT_UNKNOWN }; ///> The type of connection this instance provides. Needed for administration - bool m_connected { false }; ///> Shows if the connection is still active. - modbus_t *m_modbus; ///> The actual low-level modbus instance as a raw-pointer. ( unique_pointer gives an error on this struct ) + ConnectionType connectionType { ConnectionType::CT_UNKNOWN }; ///> The type of connection this instance provides. Needed for administration + bool connected { false }; ///> Shows if the connection is still active. + modbus_t *modbus; ///> The actual low-level modbus instance as a raw-pointer. ( unique_pointer gives an error on this struct ) // Return value Buffers ( Room for improvement ) - uint8_t *m_dest; - uint16_t *m_dest16; + uint8_t *m_dest; + uint16_t *m_dest16; }; diff --git a/stack/config.h b/stack/config.h deleted file mode 100644 index 66546e4..0000000 --- a/stack/config.h +++ /dev/null @@ -1,165 +0,0 @@ -/* Define to 1 if you have the header file. */ -#define HAVE_ARPA_INET_H 1 - -/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you don't. */ -#define HAVE_DECL_TIOCSRS485 0 - -/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you don't. */ -#define HAVE_DECL_TIOCM_RTS 0 - -/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you don't. */ -#define HAVE_DECL___CYGWIN__ 0 - -/* Define to 1 if you have the header file. */ -#define HAVE_DLFCN_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_ERRNO_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_FCNTL_H 1 - -/* Define to 1 if you have the `fork' function. */ -#define HAVE_FORK 1 - -/* Define to 1 if you have the `getaddrinfo' function. */ -#define HAVE_GETADDRINFO 1 - -/* Define to 1 if you have the `gettimeofday' function. */ -#define HAVE_GETTIMEOFDAY 1 - -/* Define to 1 if you have the `inet_ntoa' function. */ -#define HAVE_INET_NTOA 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_INTTYPES_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_LIMITS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_LINUX_SERIAL_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_MEMORY_H 1 - -/* Define to 1 if you have the `memset' function. */ -#define HAVE_MEMSET 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NETDB_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NETINET_IN_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NETINET_TCP_H 1 - -/* Define to 1 if you have the `select' function. */ -#define HAVE_SELECT 1 - -/* Define to 1 if you have the `socket' function. */ -#define HAVE_SOCKET 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDINT_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDLIB_H 1 - -/* Define to 1 if you have the `strerror' function. */ -#define HAVE_STRERROR 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRINGS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRING_H 1 - -/* Define to 1 if you have the `strlcpy' function. */ -/* #undef HAVE_STRLCPY */ - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_IOCTL_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_SOCKET_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_STAT_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_TIME_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_TYPES_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_TERMIOS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_TIME_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_UNISTD_H 1 - -/* Define to 1 if you have the `vfork' function. */ -#define HAVE_VFORK 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_VFORK_H */ - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_WINSOCK2_H */ - -/* Define to 1 if `fork' works. */ -#define HAVE_WORKING_FORK 1 - -/* Define to 1 if `vfork' works. */ -#define HAVE_WORKING_VFORK 1 - -/* Define to the sub-directory in which libtool stores uninstalled libraries. - */ -#define LT_OBJDIR ".libs/" - -/* Name of package */ -#define PACKAGE "libmodbus" - -/* Define to the address where bug reports for this package should be sent. */ -#define PACKAGE_BUGREPORT "https://github.com/stephane/libmodbus/issues" - -/* Define to the full name of this package. */ -#define PACKAGE_NAME "libmodbus" - -/* Define to the full name and version of this package. */ -#define PACKAGE_STRING "libmodbus 3.1.0-1" - -/* Define to the one symbol short name of this package. */ -#define PACKAGE_TARNAME "modbus" - -/* Define to the home page for this package. */ -#define PACKAGE_URL "" - -/* Define to the version of this package. */ -#define PACKAGE_VERSION "1.0.0" - -/* Define to 1 if you have the ANSI C header files. */ -#define STDC_HEADERS 1 - -/* Define to 1 if you can safely include both and . */ -#define TIME_WITH_SYS_TIME 1 - -/* Version number of package */ -#define VERSION "1.0.0" - -/* Define to empty if `const' does not conform to ANSI C. */ -/* #undef const */ - -/* Define to `int' if does not define. */ -/* #undef pid_t */ - -/* Define to `unsigned int' if does not define. */ -/* #undef size_t */ - -/* Define as `fork' if `vfork' does not work. */ -/* #undef vfork */ diff --git a/stack/modbus-data.c b/stack/modbus-data.c deleted file mode 100644 index a789cf7..0000000 --- a/stack/modbus-data.c +++ /dev/null @@ -1,204 +0,0 @@ - -#include - -#include "stdint.h" - -#include -#include -#include -#include - -#include "modbus.h" - -#if defined(HAVE_BYTESWAP_H) -# include -#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 -#endif - -#if !defined(__CYGWIN__) && !defined(bswap_16) -#pragma message "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) -#pragma message "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/stack/modbus-private.h b/stack/modbus-private.h deleted file mode 100644 index 248a154..0000000 --- a/stack/modbus-private.h +++ /dev/null @@ -1,101 +0,0 @@ - -#pragma once - -# include -# include -#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; - 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 diff --git a/stack/modbus-rtu-private.h b/stack/modbus-rtu-private.h deleted file mode 100644 index 3dd901a..0000000 --- a/stack/modbus-rtu-private.h +++ /dev/null @@ -1,34 +0,0 @@ - -#pragma once - -#include -#include - -#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 - -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; - /* Save old termios settings */ - struct termios old_tios; - -#if HAVE_DECL_TIOCSRS485 - int serial_mode; -#endif - - /* To handle many slaves on the same link */ - int confirmation_to_ignore; -} modbus_rtu_t; diff --git a/stack/modbus-rtu.c b/stack/modbus-rtu.c deleted file mode 100644 index 770762f..0000000 --- a/stack/modbus-rtu.c +++ /dev/null @@ -1,987 +0,0 @@ - -#include -#include -#include -#include -#include -#include -#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 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 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 -} - -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 ) -{ - return read(ctx->s, rsp, rsp_length); -} - -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; - } - - 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 EMBADCRC. */ -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) -{ - struct termios tios; - speed_t speed; - int flags; - - 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); - } - - /* 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] = 10; // Set per default to 1 second - - if (tcsetattr(ctx->s, TCSANOW, &tios) < 0) { - close(ctx->s); - ctx->s = -1; - return -1; - } - 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; - memset(&rs485conf, 0x0, sizeof(struct serial_rs485)); - - if (mode == MODBUS_RTU_RS485) { - 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, 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 (ctx->s != -1) { - tcsetattr(ctx->s, TCSANOW, &ctx_rtu->old_tios); - close(ctx->s); - ctx->s = -1; - } -} - -static int _modbus_rtu_flush(modbus_t *ctx) -{ - return tcflush(ctx->s, TCIOFLUSH); -} - -static int _modbus_rtu_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) { - /* Timeout */ - errno = ETIMEDOUT; - return -1; - } - - return s_rc; -} - -static void _modbus_rtu_free(modbus_t *ctx) { - 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)); - _modbus_init_common(ctx); - ctx->backend = &_modbus_rtu_backend; - ctx->backend_data = (modbus_rtu_t *)malloc(sizeof(modbus_rtu_t)); - ctx_rtu = (modbus_rtu_t *)ctx->backend_data; - ctx_rtu->device = NULL; - - /* Device name and \0 */ - ctx_rtu->device = (char *)malloc((strlen(device) + 1) * sizeof(char)); - 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/stack/modbus-rtu.h b/stack/modbus-rtu.h deleted file mode 100644 index e6d22b9..0000000 --- a/stack/modbus-rtu.h +++ /dev/null @@ -1,34 +0,0 @@ - -#pragma once - -#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 - diff --git a/stack/modbus-tcp-private.h b/stack/modbus-tcp-private.h deleted file mode 100644 index af340ab..0000000 --- a/stack/modbus-tcp-private.h +++ /dev/null @@ -1,39 +0,0 @@ -#pragma once - -#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; - - diff --git a/stack/modbus-tcp.c b/stack/modbus-tcp.c deleted file mode 100644 index 861757e..0000000 --- a/stack/modbus-tcp.c +++ /dev/null @@ -1,866 +0,0 @@ - -#include -#include -#include -#include -#include -#include -#include - -# include -# include - -#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ < 5) -# define OS_BSD -# include -#endif - -# include -# include -# include -# include -# include - -#if !defined(MSG_NOSIGNAL) -#define MSG_NOSIGNAL 0 -#endif - -#include "modbus-private.h" - -#include "modbus-tcp.h" -#include "modbus-tcp-private.h" - -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) - option = 1; - ioctl(s, FIONBIO, &option); -#endif - - /** - * 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; - } - - 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); - - if (rc == -1 && errno == EINPROGRESS) - { - 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 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; - - 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]; - - rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT); - 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; - struct sockaddr_in addr; - modbus_tcp_t *ctx_tcp; - - if (ctx == NULL) - { - errno = EINVAL; - return -1; - } - - ctx_tcp = ctx->backend_data; - - new_s = socket(PF_INET, SOCK_STREAM, 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; - - 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 s; - - s = socket( ai_ptr->ai_family, ai_ptr->ai_socktype, 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) - { - close(*s); - *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) - { - close(*s); - *s = -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; - - ctx = (modbus_t *)malloc(sizeof(modbus_t) ); - _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) ); - 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)); - _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)); - 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/stack/modbus-tcp.h b/stack/modbus-tcp.h deleted file mode 100644 index c94f545..0000000 --- a/stack/modbus-tcp.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include "modbus.h" - -MODBUS_BEGIN_DECLS - -#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 - diff --git a/stack/modbus-version.h b/stack/modbus-version.h deleted file mode 100644 index f7d3c48..0000000 --- a/stack/modbus-version.h +++ /dev/null @@ -1,34 +0,0 @@ -#pragma once - -/* 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 (4) - -/* The full version, like 1.2.3 */ -#define LIBMODBUS_VERSION 3.1.4 - -/* The full version, in string form (suited for string concatenation) - */ -#define LIBMODBUS_VERSION_STRING "3.1.4" - -/* Numerically encoded version, like 0x010203 */ -#define LIBMODBUS_VERSION_HEX ((LIBMODBUS_VERSION_MAJOR << 24) | \ - (LIBMODBUS_VERSION_MINOR << 16) | \ - (LIBMODBUS_VERSION_MICRO << 8)) - -/* 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))) - - diff --git a/stack/modbus.c b/stack/modbus.c deleted file mode 100644 index b5a3700..0000000 --- a/stack/modbus.c +++ /dev/null @@ -1,1898 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "modbus.h" -#include "modbus-private.h" - -/* Internal use */ -#define MSG_LENGTH_UNDEFINED -1 - -/* 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 */ - /* 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; - } -} - -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, 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 a 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 */ - p_tv = NULL; - } - 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 mapping_address = address - mb_mapping->start_bits; - - if (nb < 1 || MODBUS_MAX_WRITE_BITS < 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 mapping_address = address - mb_mapping->start_registers; - - if (nb < 1 || MODBUS_MAX_WRITE_REGISTERS < nb) { - 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; - str_len = 3 + strlen(MODBUS_VERSION_STRING); - memcpy(rsp + rsp_length, "LMB" MODBUS_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 (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, int 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, 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, int 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; -} - -/* 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_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; -} - -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_ranges() 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/stack/modbus.h b/stack/modbus.h deleted file mode 100644 index 8e15a95..0000000 --- a/stack/modbus.h +++ /dev/null @@ -1,262 +0,0 @@ - -#pragma once - -/* Add this for macros that defined unix flavor */ -#if (defined(__unix__) || defined(unix)) && !defined(USG) -#include -#endif - -#include - -#define MODBUS_API - -#define MODBUS_VERSION_STRING "1.0.0" - -#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) - -typedef struct _modbus modbus_t; - -typedef struct { - 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_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_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, int 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, 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 - -- libgit2 0.21.4