Compare commits
No commits in common. "master" and "microinverterTotalProduction" have entirely different histories.
master
...
microinver
33 changed files with 873 additions and 6719 deletions
|
|
@ -1,16 +1,13 @@
|
|||
cmake_minimum_required(VERSION 3.6.0)
|
||||
project(hoymilesClient VERSION 0.1.0 LANGUAGES C CXX)
|
||||
|
||||
add_subdirectory(src/libmodbus)
|
||||
|
||||
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
|
||||
|
||||
include_directories(inc inc/libmodbus inc/hoymiles inc/hoymiles/portParameters inc/hoymiles/sunspecParameters src/libmodbus/inc)
|
||||
include_directories(inc inc/libmodbus inc/hoymiles inc/hoymiles/portParameters)
|
||||
|
||||
file(GLOB SOURCES src/*.cpp src/libmodbus/*.c src/hoymiles/*.cpp src/hoymiles/portParameters/*.cpp src/hoymiles/sunspecParameters/*.cpp)
|
||||
file(GLOB SOURCES src/*.cpp src/libmodbus/*.c src/hoymiles/*.cpp src/hoymiles/portParameters/*.cpp)
|
||||
|
||||
add_executable(hoymilesClient_exec ${SOURCES})
|
||||
target_link_libraries(hoymilesClient_exec libmodbus)
|
||||
|
||||
# configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/inc/libmodbus/config.h)
|
||||
|
||||
|
|
|
|||
|
|
@ -10,46 +10,27 @@
|
|||
|
||||
class Dtu {
|
||||
private:
|
||||
modbus_t *modbus;
|
||||
std::shared_ptr<class modbus> modbus;
|
||||
|
||||
std::vector<Microinverter> microinverters;
|
||||
|
||||
Port dtuPort;
|
||||
|
||||
int rtuId;
|
||||
|
||||
bool connected;
|
||||
|
||||
void populateMicroinverters();
|
||||
|
||||
public:
|
||||
Dtu(const char *address, int id, bool rtu, bool tcp);
|
||||
|
||||
Dtu(modbus_t *modbus, int id);
|
||||
|
||||
std::pair<Microinverter *, bool> getMicroinverterBySerialNumber(long long serialNumber);
|
||||
|
||||
public:
|
||||
Dtu(const char *ip_address, int port);
|
||||
|
||||
bool isConnected();
|
||||
|
||||
bool modbusError();
|
||||
|
||||
std::string modbusErrorMessage();
|
||||
|
||||
void updateMicroinverters(std::vector<std::string> ¶metersToGet, bool allParameters, std::vector<long long> µinvertersToGet);
|
||||
|
||||
void printMicroinverters(std::vector<std::string> ¶metersToGet, bool allParameters, std::vector<long long> µinvertersToGet, bool shortNames, bool printTodayProduction, bool printTotalProduction);
|
||||
|
||||
void setStatusMicroinverters(uint16_t value, std::string statusName, std::vector<long long>& microinvertersToSet);
|
||||
|
||||
bool empty();
|
||||
|
||||
void listOfMicroinverters();
|
||||
|
||||
float getCurrentPower();
|
||||
|
||||
int getCurrentOnOff();
|
||||
|
||||
void turnOffMicroinverters();
|
||||
void turnOnMicroinverters();
|
||||
|
||||
void limitMicroinverters(uint16_t limit);
|
||||
|
||||
~Dtu();
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -7,20 +7,15 @@
|
|||
|
||||
#include "modbus.h"
|
||||
#include "port.h"
|
||||
#include "sunspec.h"
|
||||
|
||||
class Microinverter {
|
||||
private:
|
||||
modbus_t *modbus;
|
||||
|
||||
// Sunspec sunspec;
|
||||
std::shared_ptr<class modbus> modbus;
|
||||
|
||||
int startAddress;
|
||||
|
||||
int statusStartAddress;
|
||||
|
||||
public:
|
||||
Microinverter(modbus_t *modbus, int startAddress, long long serialNumber);
|
||||
Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber);
|
||||
|
||||
long long serialNumber;
|
||||
|
||||
|
|
@ -32,21 +27,11 @@ class Microinverter {
|
|||
|
||||
void updateParameters(std::vector<std::string> ¶metersToGet, bool allParameters);
|
||||
|
||||
void updateStatusParameters();
|
||||
|
||||
void printPorts(std::vector<std::string> ¶metersToGet, bool allParameters, bool shortNames);
|
||||
|
||||
long long getTodayProduction();
|
||||
|
||||
long long getTotalProduction();
|
||||
|
||||
void setStatus(std::vector<std::pair<int, uint16_t>> portsToSet, std::string statusName);
|
||||
|
||||
void setStatusWholeMicroinverter(uint16_t value, std::string statusName);
|
||||
|
||||
float getCurrentPower();
|
||||
|
||||
int getCurrentOnOff();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -6,7 +6,6 @@
|
|||
#include <vector>
|
||||
|
||||
#include "portParametersGeneric.h"
|
||||
#include "portParameters.h"
|
||||
#include "modbus.h"
|
||||
|
||||
class Port {
|
||||
|
|
@ -23,27 +22,15 @@ class Port {
|
|||
|
||||
int portStartAddress;
|
||||
|
||||
int statusPortStartAddress;
|
||||
|
||||
std::vector<std::shared_ptr<PortParameter>> parameters;
|
||||
|
||||
std::vector<std::shared_ptr<PortParameter>> statusParameters;
|
||||
|
||||
std::pair<std::shared_ptr<PortParameter>, bool> getParameterByName(std::string name);
|
||||
|
||||
std::pair<std::shared_ptr<PortParameter>, bool> getStatusByName(std::string name);
|
||||
|
||||
// void updateParameters(std::vector<std::string> ¶metersToGet, bool allParameters);
|
||||
|
||||
void setParametersFromMicroinverterArray(uint16_t *registers, int addressOffset);
|
||||
|
||||
void setStatusesFromMicroinverterArray(uint16_t *registers, int addressOffset);
|
||||
void setParametersFromMicroinverterArray(uint8_t *registers, int addressOffset);
|
||||
|
||||
void printParameters(std::vector<std::string> ¶metersToGet, bool allParameters, bool shortNames);
|
||||
|
||||
void turnOff(modbus_t *modbus);
|
||||
|
||||
bool isOff(modbus_t *modbus);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
class PortParameterMicroinverterSerialNumber : public PortParameterInt {
|
||||
private:
|
||||
void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
void setValueFromRegisters(uint8_t *registers, int addressOffset);
|
||||
|
||||
public:
|
||||
PortParameterMicroinverterSerialNumber();
|
||||
|
|
@ -81,14 +81,4 @@ class PortParameterLinkStatus : public PortParameterInt {
|
|||
PortParameterLinkStatus();
|
||||
};
|
||||
|
||||
class PortParameterOnOff : public PortParameterInt {
|
||||
public:
|
||||
PortParameterOnOff();
|
||||
};
|
||||
|
||||
class PortParameterLimitActivePower : public PortParameterInt {
|
||||
public:
|
||||
PortParameterLimitActivePower();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -13,13 +13,8 @@ class PortParameter {
|
|||
uint16_t parameterAddressOffset;
|
||||
int registerSize;
|
||||
|
||||
std::string unit;
|
||||
|
||||
bool r;
|
||||
bool w;
|
||||
|
||||
public:
|
||||
PortParameter(std::string name, std::string shortName, std::string unit, bool r, bool w, uint16_t parameterAddressOffset, int registerSize);
|
||||
PortParameter(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize);
|
||||
|
||||
virtual ~PortParameter();
|
||||
|
||||
|
|
@ -42,11 +37,9 @@ class PortParameter {
|
|||
|
||||
std::pair<PortParameterValue, PortParameterValueType> getValue();
|
||||
|
||||
PortParameter& writeValue(uint16_t value, modbus_t *modbus, int portStartAddress);
|
||||
|
||||
virtual std::string getOutputValue();
|
||||
|
||||
virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
|
||||
|
||||
// void updateValue(std::shared_ptr<class modbus> modubs, uint16_t portStartAddress);
|
||||
};
|
||||
|
|
@ -56,22 +49,22 @@ class PortParameterFloat : public PortParameter {
|
|||
int decimalPlaces;
|
||||
|
||||
public:
|
||||
PortParameterFloat(std::string name, std::string shortName, std::string unit, bool r, bool w, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize);
|
||||
PortParameterFloat(std::string name, std::string shortName, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize);
|
||||
|
||||
std::string getOutputValue();
|
||||
|
||||
virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
|
||||
};
|
||||
|
||||
class PortParameterInt : public PortParameter {
|
||||
protected:
|
||||
|
||||
public:
|
||||
PortParameterInt(std::string name, std::string shortName, std::string unit, bool r, bool w, uint16_t parameterAddressOffset, int registerSize);
|
||||
PortParameterInt(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize);
|
||||
|
||||
std::string getOutputValue();
|
||||
|
||||
virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
#ifndef SUNSPEC_H
|
||||
#define SUNSPEC_H
|
||||
|
||||
#include <string>
|
||||
#include <stdint.h>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "modbus.h"
|
||||
#include "sunspecParametersGeneric.h"
|
||||
|
||||
class Sunspec {
|
||||
protected:
|
||||
modbus_t *modbus;
|
||||
|
||||
std::vector<std::shared_ptr<SunspecParameter>> parameters;
|
||||
|
||||
std::string manufacturer;
|
||||
std::string model;
|
||||
std::string version;
|
||||
|
||||
std::string serialNumber;
|
||||
uint16_t deviceAddress;
|
||||
|
||||
int sunspecAddress;
|
||||
|
||||
void setValues();
|
||||
|
||||
void populateParameters();
|
||||
|
||||
public:
|
||||
Sunspec(int address, modbus_t *modbus);
|
||||
|
||||
uint16_t getAddress();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
#ifndef SUNSPEC_PARAMETERS_H
|
||||
#define SUNSPEC_PARAMETERS_H
|
||||
|
||||
#include "sunspecParametersGeneric.h"
|
||||
|
||||
class SunspecParameterManufacturer : public SunspecParameterString32 {
|
||||
protected:
|
||||
|
||||
public:
|
||||
SunspecParameterManufacturer();
|
||||
|
||||
void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
#ifndef SUNSPEC_PARAMETERS_GENERIC_H
|
||||
#define SUNSPEC_PARAMETERS_GENERIC_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
|
||||
class SunspecParameter {
|
||||
protected:
|
||||
std::string name;
|
||||
int registerAddressOffset;
|
||||
int registerSize;
|
||||
|
||||
public:
|
||||
SunspecParameter(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
virtual ~SunspecParameter();
|
||||
|
||||
enum SunspecValueType { uint32, uint16, string32, string16, sunssf, int16, acc32, float32, enum16 };
|
||||
|
||||
union SunspecValue {
|
||||
uint32_t u32;
|
||||
uint16_t u16;
|
||||
uint16_t ssf;
|
||||
int i16;
|
||||
uint16_t a32;
|
||||
float f;
|
||||
uint16_t e16;
|
||||
};
|
||||
|
||||
protected:
|
||||
SunspecValueType valueType;
|
||||
SunspecValue value;
|
||||
|
||||
public:
|
||||
|
||||
virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
|
||||
std::pair<SunspecValue, SunspecValueType> getValue();
|
||||
};
|
||||
|
||||
// class SunspecParameterUint32 : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterUint32(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
// class SunspecParameterUint16 : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterUint16(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
class SunspecParameterString32 : public SunspecParameter {
|
||||
protected:
|
||||
std::string value;
|
||||
|
||||
public:
|
||||
SunspecParameterString32(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
};
|
||||
|
||||
// class SunspecParameterString16 : public SunspecParameter {
|
||||
// protected:
|
||||
// std::string value;
|
||||
|
||||
// public:
|
||||
// SunspecParameterString16(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
// class SunspecParameterSunssf : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterSunssf(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
// class SunspecParameterInt16 : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterInt16(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
// class SunspecParameterAcc32 : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterAcc32(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
// class SunspecParameterFloat32 : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterFloat32(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
// class SunspecParameterEnum16 : public SunspecParameter {
|
||||
// protected:
|
||||
|
||||
// public:
|
||||
// SunspecParameterEnum16(std::string name, int registerAddressOffset, int registerSize);
|
||||
|
||||
// virtual void getValueFromRegisters(uint16_t *registers, int addressOffset);
|
||||
// };
|
||||
|
||||
#endif
|
||||
717
inc/modbus.h
Normal file
717
inc/modbus.h
Normal file
|
|
@ -0,0 +1,717 @@
|
|||
/* modbus.h
|
||||
*
|
||||
* Copyright (C) 20017-2021 Fanzhe Lyu <lvfanzhe@hotmail.com>, all rights reserved.
|
||||
*
|
||||
* modbuspp is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef MODBUSPP_MODBUS_H
|
||||
#define MODBUSPP_MODBUS_H
|
||||
|
||||
#include <cstring>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
|
||||
#ifdef ENABLE_MODBUSPP_LOGGING
|
||||
#include <cstdio>
|
||||
#define LOG(fmt, ...) printf("[ modbuspp ]" fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
#define LOG(...) (void)0
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
// WINDOWS socket
|
||||
#define _WINSOCK_DEPRECATED_NO_WARNINGS
|
||||
|
||||
#include <winsock2.h>
|
||||
#pragma comment(lib, "Ws2_32.lib")
|
||||
using X_SOCKET = SOCKET;
|
||||
// using ssize_t = int;
|
||||
|
||||
#define X_ISVALIDSOCKET(s) ((s) != INVALID_SOCKET)
|
||||
#define X_CLOSE_SOCKET(s) closesocket(s)
|
||||
#define X_ISCONNECTSUCCEED(s) ((s) != SOCKET_ERROR)
|
||||
|
||||
#else
|
||||
// Berkeley socket
|
||||
#include <unistd.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
using X_SOCKET = int;
|
||||
|
||||
#define X_ISVALIDSOCKET(s) ((s) >= 0)
|
||||
#define X_CLOSE_SOCKET(s) close(s)
|
||||
#define X_ISCONNECTSUCCEED(s) ((s) >= 0)
|
||||
#endif
|
||||
|
||||
using SOCKADDR = struct sockaddr;
|
||||
using SOCKADDR_IN = struct sockaddr_in;
|
||||
|
||||
#define MAX_MSG_LENGTH 260
|
||||
|
||||
///Function Code
|
||||
#define READ_COILS 0x01
|
||||
#define READ_INPUT_BITS 0x02
|
||||
#define READ_REGS 0x03
|
||||
#define READ_INPUT_REGS 0x04
|
||||
#define WRITE_COIL 0x05
|
||||
#define WRITE_REG 0x06
|
||||
#define WRITE_COILS 0x0F
|
||||
#define WRITE_REGS 0x10
|
||||
|
||||
///Exception Codes
|
||||
|
||||
#define EX_ILLEGAL_FUNCTION 0x01 // Function Code not Supported
|
||||
#define EX_ILLEGAL_ADDRESS 0x02 // Output Address not exists
|
||||
#define EX_ILLEGAL_VALUE 0x03 // Output Value not in Range
|
||||
#define EX_SERVER_FAILURE 0x04 // Slave Deive Fails to process request
|
||||
#define EX_ACKNOWLEDGE 0x05 // Service Need Long Time to Execute
|
||||
#define EX_SERVER_BUSY 0x06 // Server Was Unable to Accept MB Request PDU
|
||||
#define EX_NEGATIVE_ACK 0x07
|
||||
#define EX_MEM_PARITY_PROB 0x08
|
||||
#define EX_GATEWAY_PROBLEMP 0x0A // Gateway Path not Available
|
||||
#define EX_GATEWAY_PROBLEMF 0x0B // Target Device Failed to Response
|
||||
#define EX_BAD_DATA 0XFF // Bad Data lenght or Address
|
||||
|
||||
#define BAD_CON -1
|
||||
|
||||
/// Modbus Operator Class
|
||||
/**
|
||||
* Modbus Operator Class
|
||||
* Providing networking support and mobus operation support.
|
||||
*/
|
||||
class modbus
|
||||
{
|
||||
|
||||
public:
|
||||
bool err{};
|
||||
int err_no{};
|
||||
std::string error_msg;
|
||||
|
||||
modbus(std::string host, uint16_t port);
|
||||
~modbus();
|
||||
|
||||
bool modbus_connect();
|
||||
void modbus_close() const;
|
||||
|
||||
bool is_connected() const { return _connected; }
|
||||
|
||||
void modbus_set_slave_id(int id);
|
||||
|
||||
int modbus_read_coils(uint16_t address, uint16_t amount, bool *buffer);
|
||||
int modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer);
|
||||
int modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer);
|
||||
int modbus_read_input_registers(uint16_t address, uint16_t amount, uint16_t *buffer);
|
||||
|
||||
int modbus_write_coil(uint16_t address, const bool &to_write);
|
||||
int modbus_write_register(uint16_t address, const uint16_t &value);
|
||||
int modbus_write_coils(uint16_t address, uint16_t amount, const bool *value);
|
||||
int modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value);
|
||||
|
||||
private:
|
||||
bool _connected{};
|
||||
uint16_t PORT{};
|
||||
uint32_t _msg_id{};
|
||||
int _slaveid{};
|
||||
std::string HOST;
|
||||
|
||||
X_SOCKET _socket{};
|
||||
SOCKADDR_IN _server{};
|
||||
|
||||
#ifdef _WIN32
|
||||
WSADATA wsadata;
|
||||
#endif
|
||||
|
||||
void modbus_build_request(uint8_t *to_send, uint16_t address, int func) const;
|
||||
|
||||
int modbus_read(uint16_t address, uint16_t amount, int func);
|
||||
int modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value);
|
||||
|
||||
ssize_t modbus_send(uint8_t *to_send, size_t length);
|
||||
ssize_t modbus_receive(uint8_t *buffer) const;
|
||||
|
||||
void modbuserror_handle(const uint8_t *msg, int func);
|
||||
|
||||
void set_bad_con();
|
||||
void set_bad_input();
|
||||
};
|
||||
|
||||
/**
|
||||
* Main Constructor of Modbus Connector Object
|
||||
* @param host IP Address of Host
|
||||
* @param port Port for the TCP Connection
|
||||
* @return A Modbus Connector Object
|
||||
*/
|
||||
inline modbus::modbus(std::string host, uint16_t port = 502)
|
||||
{
|
||||
HOST = host;
|
||||
PORT = port;
|
||||
_slaveid = 1;
|
||||
_msg_id = 1;
|
||||
_connected = false;
|
||||
err = false;
|
||||
err_no = 0;
|
||||
error_msg = "";
|
||||
}
|
||||
|
||||
/**
|
||||
* Destructor of Modbus Connector Object
|
||||
*/
|
||||
inline modbus::~modbus(void) = default;
|
||||
|
||||
/**
|
||||
* Modbus Slave ID Setter
|
||||
* @param id ID of the Modbus Server Slave
|
||||
*/
|
||||
inline void modbus::modbus_set_slave_id(int id)
|
||||
{
|
||||
_slaveid = id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build up a Modbus/TCP Connection
|
||||
* @return If A Connection Is Successfully Built
|
||||
*/
|
||||
inline bool modbus::modbus_connect()
|
||||
{
|
||||
if (HOST.empty() || PORT == 0)
|
||||
{
|
||||
LOG("Missing Host and Port");
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG("Found Proper Host %s and Port %d", HOST.c_str(), PORT);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
if (WSAStartup(0x0202, &wsadata))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
_socket = socket(AF_INET, SOCK_STREAM, 0);
|
||||
if (!X_ISVALIDSOCKET(_socket))
|
||||
{
|
||||
LOG("Error Opening Socket");
|
||||
#ifdef _WIN32
|
||||
WSACleanup();
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG("Socket Opened Successfully");
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
const DWORD timeout = 20000;
|
||||
#else
|
||||
struct timeval timeout
|
||||
{
|
||||
};
|
||||
timeout.tv_sec = 20; // after 20 seconds connect() will timeout
|
||||
timeout.tv_usec = 0;
|
||||
#endif
|
||||
|
||||
setsockopt(_socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout));
|
||||
setsockopt(_socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
|
||||
_server.sin_family = AF_INET;
|
||||
_server.sin_addr.s_addr = inet_addr(HOST.c_str());
|
||||
_server.sin_port = htons(PORT);
|
||||
|
||||
if (!X_ISCONNECTSUCCEED(connect(_socket, (SOCKADDR *)&_server, sizeof(_server))))
|
||||
{
|
||||
LOG("Connection Error");
|
||||
#ifdef _WIN32
|
||||
WSACleanup();
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
LOG("Connected");
|
||||
_connected = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the Modbus/TCP Connection
|
||||
*/
|
||||
inline void modbus::modbus_close() const
|
||||
{
|
||||
X_CLOSE_SOCKET(_socket);
|
||||
#ifdef _WIN32
|
||||
WSACleanup();
|
||||
#endif
|
||||
LOG("Socket Closed");
|
||||
}
|
||||
|
||||
/**
|
||||
* Modbus Request Builder
|
||||
* @param to_send Message Buffer to Be Sent
|
||||
* @param address Reference Address
|
||||
* @param func Modbus Functional Code
|
||||
*/
|
||||
inline void modbus::modbus_build_request(uint8_t *to_send, uint16_t address, int func) const
|
||||
{
|
||||
to_send[0] = (uint8_t)(_msg_id >> 8u);
|
||||
to_send[1] = (uint8_t)(_msg_id & 0x00FFu);
|
||||
to_send[2] = 0;
|
||||
to_send[3] = 0;
|
||||
to_send[4] = 0;
|
||||
to_send[6] = (uint8_t)_slaveid;
|
||||
to_send[7] = (uint8_t)func;
|
||||
to_send[8] = (uint8_t)(address >> 8u);
|
||||
to_send[9] = (uint8_t)(address & 0x00FFu);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write Request Builder and Sender
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of data to be Written
|
||||
* @param func Modbus Functional Code
|
||||
* @param value Data to Be Written
|
||||
*/
|
||||
inline int modbus::modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value)
|
||||
{
|
||||
int status = 0;
|
||||
uint8_t *to_send;
|
||||
if (func == WRITE_COIL || func == WRITE_REG)
|
||||
{
|
||||
to_send = new uint8_t[12];
|
||||
modbus_build_request(to_send, address, func);
|
||||
to_send[5] = 6;
|
||||
to_send[10] = (uint8_t)(value[0] >> 8u);
|
||||
to_send[11] = (uint8_t)(value[0] & 0x00FFu);
|
||||
status = modbus_send(to_send, 12);
|
||||
}
|
||||
else if (func == WRITE_REGS)
|
||||
{
|
||||
to_send = new uint8_t[13 + 2 * amount];
|
||||
modbus_build_request(to_send, address, func);
|
||||
to_send[5] = (uint8_t)(7 + 2 * amount);
|
||||
to_send[10] = (uint8_t)(amount >> 8u);
|
||||
to_send[11] = (uint8_t)(amount & 0x00FFu);
|
||||
to_send[12] = (uint8_t)(2 * amount);
|
||||
for (int i = 0; i < amount; i++)
|
||||
{
|
||||
to_send[13 + 2 * i] = (uint8_t)(value[i] >> 8u);
|
||||
to_send[14 + 2 * i] = (uint8_t)(value[i] & 0x00FFu);
|
||||
}
|
||||
status = modbus_send(to_send, 13 + 2 * amount);
|
||||
}
|
||||
else if (func == WRITE_COILS)
|
||||
{
|
||||
to_send = new uint8_t[14 + (amount - 1) / 8];
|
||||
modbus_build_request(to_send, address, func);
|
||||
to_send[5] = (uint8_t)(7 + (amount + 7) / 8);
|
||||
to_send[10] = (uint8_t)(amount >> 8u);
|
||||
to_send[11] = (uint8_t)(amount & 0x00FFu);
|
||||
to_send[12] = (uint8_t)((amount + 7) / 8);
|
||||
for (int i = 0; i < (amount + 7) / 8; i++)
|
||||
to_send[13 + i] = 0; // init needed before summing!
|
||||
for (int i = 0; i < amount; i++)
|
||||
{
|
||||
to_send[13 + i / 8] += (uint8_t)(value[i] << (i % 8u));
|
||||
}
|
||||
status = modbus_send(to_send, 14 + (amount - 1) / 8);
|
||||
}
|
||||
delete[] to_send;
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Request Builder and Sender
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Data to Read
|
||||
* @param func Modbus Functional Code
|
||||
*/
|
||||
inline int modbus::modbus_read(uint16_t address, uint16_t amount, int func)
|
||||
{
|
||||
uint8_t to_send[12];
|
||||
modbus_build_request(to_send, address, func);
|
||||
to_send[5] = 6;
|
||||
to_send[10] = (uint8_t)(amount >> 8u);
|
||||
to_send[11] = (uint8_t)(amount & 0x00FFu);
|
||||
return modbus_send(to_send, 12);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Holding Registers
|
||||
* MODBUS FUNCTION 0x03
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Registers to Read
|
||||
* @param buffer Buffer to Store Data Read from Registers
|
||||
*/
|
||||
inline int modbus::modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
modbus_read(address, amount, READ_REGS);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, READ_REGS);
|
||||
if (err)
|
||||
return err_no;
|
||||
for (auto i = 0; i < amount; i++)
|
||||
{
|
||||
buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) << 8u;
|
||||
buffer[i] += (uint16_t)to_rec[10u + 2u * i];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Input Registers
|
||||
* MODBUS FUNCTION 0x04
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Registers to Read
|
||||
* @param buffer Buffer to Store Data Read from Registers
|
||||
*/
|
||||
inline int modbus::modbus_read_input_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
modbus_read(address, amount, READ_INPUT_REGS);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, READ_INPUT_REGS);
|
||||
if (err)
|
||||
return err_no;
|
||||
for (auto i = 0; i < amount; i++)
|
||||
{
|
||||
buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) << 8u;
|
||||
buffer[i] += (uint16_t)to_rec[10u + 2u * i];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Coils
|
||||
* MODBUS FUNCTION 0x01
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Coils to Read
|
||||
* @param buffer Buffer to Store Data Read from Coils
|
||||
*/
|
||||
inline int modbus::modbus_read_coils(uint16_t address, uint16_t amount, bool *buffer)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
if (amount > 2040)
|
||||
{
|
||||
set_bad_input();
|
||||
return EX_BAD_DATA;
|
||||
}
|
||||
modbus_read(address, amount, READ_COILS);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, READ_COILS);
|
||||
if (err)
|
||||
return err_no;
|
||||
for (auto i = 0; i < amount; i++)
|
||||
{
|
||||
buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) & 1u);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Input Bits(Discrete Data)
|
||||
* MODBUS FUNCITON 0x02
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Bits to Read
|
||||
* @param buffer Buffer to store Data Read from Input Bits
|
||||
*/
|
||||
inline int modbus::modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
if (amount > 2040)
|
||||
{
|
||||
set_bad_input();
|
||||
return EX_BAD_DATA;
|
||||
}
|
||||
modbus_read(address, amount, READ_INPUT_BITS);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
if (err)
|
||||
return err_no;
|
||||
for (auto i = 0; i < amount; i++)
|
||||
{
|
||||
buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) & 1u);
|
||||
}
|
||||
modbuserror_handle(to_rec, READ_INPUT_BITS);
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write Single Coils
|
||||
* MODBUS FUNCTION 0x05
|
||||
* @param address Reference Address
|
||||
* @param to_write Value to be Written to Coil
|
||||
*/
|
||||
inline int modbus::modbus_write_coil(uint16_t address, const bool &to_write)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
int value = to_write * 0xFF00;
|
||||
modbus_write(address, 1, WRITE_COIL, (uint16_t *)&value);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, WRITE_COIL);
|
||||
if (err)
|
||||
return err_no;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write Single Register
|
||||
* FUCTION 0x06
|
||||
* @param address Reference Address
|
||||
* @param value Value to Be Written to Register
|
||||
*/
|
||||
inline int modbus::modbus_write_register(uint16_t address, const uint16_t &value)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
modbus_write(address, 1, WRITE_REG, &value);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, WRITE_COIL);
|
||||
if (err)
|
||||
return err_no;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write Multiple Coils
|
||||
* MODBUS FUNCTION 0x0F
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Coils to Write
|
||||
* @param value Values to Be Written to Coils
|
||||
*/
|
||||
inline int modbus::modbus_write_coils(uint16_t address, uint16_t amount, const bool *value)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
uint16_t *temp = new uint16_t[amount];
|
||||
for (int i = 0; i < amount; i++)
|
||||
{
|
||||
temp[i] = (uint16_t)value[i];
|
||||
}
|
||||
modbus_write(address, amount, WRITE_COILS, temp);
|
||||
delete[] temp;
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, WRITE_COILS);
|
||||
if (err)
|
||||
return err_no;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write Multiple Registers
|
||||
* MODBUS FUNCION 0x10
|
||||
* @param address Reference Address
|
||||
* @param amount Amount of Value to Write
|
||||
* @param value Values to Be Written to the Registers
|
||||
*/
|
||||
inline int modbus::modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value)
|
||||
{
|
||||
if (_connected)
|
||||
{
|
||||
modbus_write(address, amount, WRITE_REGS, value);
|
||||
uint8_t to_rec[MAX_MSG_LENGTH];
|
||||
ssize_t k = modbus_receive(to_rec);
|
||||
if (k == -1)
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
modbuserror_handle(to_rec, WRITE_REGS);
|
||||
if (err)
|
||||
return err_no;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
set_bad_con();
|
||||
return BAD_CON;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Data Sender
|
||||
* @param to_send Request to Be Sent to Server
|
||||
* @param length Length of the Request
|
||||
* @return Size of the request
|
||||
*/
|
||||
inline ssize_t modbus::modbus_send(uint8_t *to_send, size_t length)
|
||||
{
|
||||
_msg_id++;
|
||||
return send(_socket, (const char *)to_send, (size_t)length, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Data Receiver
|
||||
* @param buffer Buffer to Store the Data Retrieved
|
||||
* @return Size of Incoming Data
|
||||
*/
|
||||
inline ssize_t modbus::modbus_receive(uint8_t *buffer) const
|
||||
{
|
||||
return recv(_socket, (char *)buffer, MAX_MSG_LENGTH, 0);
|
||||
}
|
||||
|
||||
inline void modbus::set_bad_con()
|
||||
{
|
||||
err = true;
|
||||
error_msg = "BAD CONNECTION";
|
||||
}
|
||||
|
||||
inline void modbus::set_bad_input()
|
||||
{
|
||||
err = true;
|
||||
error_msg = "BAD FUNCTION INPUT";
|
||||
}
|
||||
|
||||
/**
|
||||
* Error Code Handler
|
||||
* @param msg Message Received from the Server
|
||||
* @param func Modbus Functional Code
|
||||
*/
|
||||
inline void modbus::modbuserror_handle(const uint8_t *msg, int func)
|
||||
{
|
||||
err = false;
|
||||
error_msg = "NO ERR";
|
||||
if (msg[7] == func + 0x80)
|
||||
{
|
||||
err = true;
|
||||
switch (msg[8])
|
||||
{
|
||||
case EX_ILLEGAL_FUNCTION:
|
||||
error_msg = "1 Illegal Function";
|
||||
break;
|
||||
case EX_ILLEGAL_ADDRESS:
|
||||
error_msg = "2 Illegal Address";
|
||||
break;
|
||||
case EX_ILLEGAL_VALUE:
|
||||
error_msg = "3 Illegal Value";
|
||||
break;
|
||||
case EX_SERVER_FAILURE:
|
||||
error_msg = "4 Server Failure";
|
||||
break;
|
||||
case EX_ACKNOWLEDGE:
|
||||
error_msg = "5 Acknowledge";
|
||||
break;
|
||||
case EX_SERVER_BUSY:
|
||||
error_msg = "6 Server Busy";
|
||||
break;
|
||||
case EX_NEGATIVE_ACK:
|
||||
error_msg = "7 Negative Acknowledge";
|
||||
break;
|
||||
case EX_MEM_PARITY_PROB:
|
||||
error_msg = "8 Memory Parity Problem";
|
||||
break;
|
||||
case EX_GATEWAY_PROBLEMP:
|
||||
error_msg = "10 Gateway Path Unavailable";
|
||||
break;
|
||||
case EX_GATEWAY_PROBLEMF:
|
||||
error_msg = "11 Gateway Target Device Failed to Respond";
|
||||
break;
|
||||
default:
|
||||
error_msg = "UNK";
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif //MODBUSPP_MODBUS_H
|
||||
|
|
@ -1,7 +1,5 @@
|
|||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
#include "modbus.h"
|
||||
|
|
@ -11,105 +9,64 @@
|
|||
|
||||
#include "portParameters.h"
|
||||
|
||||
Dtu::Dtu(const char *address, int id, bool rtu, bool tcp) : dtuPort(0) {
|
||||
dtuPort.statusPortStartAddress = 0xd000;
|
||||
if (tcp) {
|
||||
this->modbus = modbus_new_tcp(address, id);
|
||||
}
|
||||
if (rtu) {
|
||||
this->modbus = modbus_new_rtu(address, 9600, 'N', 8, 1);
|
||||
modbus_rtu_set_serial_mode(this->modbus, MODBUS_RTU_RS485);
|
||||
Dtu::Dtu(const char *ip_address, int port) {
|
||||
class modbus modbus {
|
||||
ip_address, (uint16_t)port
|
||||
};
|
||||
this->modbus = std::make_shared<class modbus>(modbus);
|
||||
|
||||
if (!this->modbus.get()->modbus_connect()) {
|
||||
std::cerr << "NOT CONNECTED" << std::endl;
|
||||
}
|
||||
|
||||
this->connected = false;
|
||||
if (modbus_connect(this->modbus) == -1) {
|
||||
std::cerr << "[" << id << "] NOT_CONNECTED" << std::endl;
|
||||
} else {
|
||||
this->connected = true;
|
||||
if (rtu) {
|
||||
modbus_set_slave(this->modbus, id);
|
||||
}
|
||||
if (this->modbus.get()->is_connected()) {
|
||||
this->populateMicroinverters();
|
||||
}
|
||||
}
|
||||
|
||||
Dtu::Dtu(modbus_t *modbus, int id = -1) : dtuPort(0) {
|
||||
dtuPort.statusPortStartAddress = 0xd000;
|
||||
|
||||
this->modbus = modbus;
|
||||
this->rtuId = id;
|
||||
bool Dtu::isConnected() { return this->modbus.get()->is_connected(); }
|
||||
|
||||
this->connected = false;
|
||||
if (modbus_connect(this->modbus) == -1) {
|
||||
std::cerr << "[" << id << "] NOT_CONNECTED" << std::endl;
|
||||
} else {
|
||||
this->connected = true;
|
||||
if (id != -1) {
|
||||
modbus_set_slave(this->modbus, rtuId);
|
||||
}
|
||||
this->populateMicroinverters();
|
||||
}
|
||||
}
|
||||
bool Dtu::modbusError() { return this->modbus.get()->err; }
|
||||
|
||||
bool Dtu::isConnected() { return this->connected; }
|
||||
std::string Dtu::modbusErrorMessage() { return this->modbus.get()->error_msg; }
|
||||
|
||||
Dtu::~Dtu() {
|
||||
modbus_close(this->modbus);
|
||||
modbus_free(this->modbus);
|
||||
}
|
||||
Dtu::~Dtu() { this->modbus.get()->modbus_close(); }
|
||||
|
||||
void Dtu::populateMicroinverters() {
|
||||
if(this->rtuId != -1) {
|
||||
modbus_set_slave(this->modbus, this->rtuId);
|
||||
int portStartAddress = 0x1000;
|
||||
uint16_t readArrayJoined[20];
|
||||
uint8_t registers[40];
|
||||
|
||||
int registerCount;
|
||||
registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 20, readArrayJoined);
|
||||
|
||||
if (registerCount != 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
int portStartAddress = 0x4000;
|
||||
int registersToRead{19};
|
||||
uint16_t registers[registersToRead];
|
||||
|
||||
bool lastSuccesful{true};
|
||||
|
||||
int addressToSkip{-1};
|
||||
|
||||
while (portStartAddress <= (0x4000 + (0x0019 * 99))) {
|
||||
int registerCount{-1};
|
||||
int timesTried{0};
|
||||
while (((timesTried < 3) && (lastSuccesful && registerCount == -1) && portStartAddress != addressToSkip)) {
|
||||
registerCount = modbus_read_registers(this->modbus, portStartAddress, registersToRead, registers);
|
||||
timesTried++;
|
||||
}
|
||||
portStartAddress += 0x0019;
|
||||
if ((registers[0] == 12 && registerCount != -1) && portStartAddress != addressToSkip) {
|
||||
if (!lastSuccesful) {
|
||||
addressToSkip = portStartAddress;
|
||||
portStartAddress -= 2 * 0x0019;
|
||||
}
|
||||
lastSuccesful = true;
|
||||
Port port{portStartAddress};
|
||||
port.setParametersFromMicroinverterArray(registers, 0);
|
||||
|
||||
if (!this->getMicroinverterBySerialNumber(port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i).second) {
|
||||
Microinverter microinverter{this->modbus, portStartAddress, port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i};
|
||||
this->microinverters.push_back(microinverter);
|
||||
}
|
||||
|
||||
Microinverter *microinverter = this->getMicroinverterBySerialNumber(port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i).first;
|
||||
std::vector<Port>::iterator portsIterator = microinverter->ports.begin();
|
||||
bool valueExists{false};
|
||||
while (portsIterator != microinverter->ports.end() && !valueExists) {
|
||||
if (portsIterator->getParameterByName("portNumber").first.get()->getValue().first.i == port.getParameterByName("portNumber").first.get()->getValue().first.i) {
|
||||
valueExists = true;
|
||||
}
|
||||
portsIterator++;
|
||||
}
|
||||
if (!valueExists) {
|
||||
microinverter->ports.push_back(port);
|
||||
}
|
||||
} else {
|
||||
lastSuccesful = false;
|
||||
while (registerCount == 0) {
|
||||
for (int i{0}; i < 20; i ++) {
|
||||
registers[2 * i] = (readArrayJoined[i] & 0xFF00) >> 8;
|
||||
registers[(2 * i) + 1] = (readArrayJoined[i] & 0x00FF);
|
||||
}
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
||||
if(registers[0] != 12) {
|
||||
break;
|
||||
}
|
||||
|
||||
Port port{portStartAddress};
|
||||
port.setParametersFromMicroinverterArray(registers, 0);
|
||||
|
||||
if (!this->getMicroinverterBySerialNumber(port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i).second) {
|
||||
Microinverter microinverter{this->modbus, portStartAddress, port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i};
|
||||
this->microinverters.push_back(microinverter);
|
||||
}
|
||||
|
||||
this->getMicroinverterBySerialNumber(port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i).first->ports.push_back(port);
|
||||
|
||||
portStartAddress += 0x0028;
|
||||
|
||||
registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 20, readArrayJoined);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -126,9 +83,6 @@ std::pair<Microinverter *, bool> Dtu::getMicroinverterBySerialNumber(long long s
|
|||
}
|
||||
|
||||
void Dtu::updateMicroinverters(std::vector<std::string> ¶metersToGet, bool allParameters, std::vector<long long> µinvertersToGet) {
|
||||
if(this->rtuId != -1) {
|
||||
modbus_set_slave(this->modbus, this->rtuId);
|
||||
}
|
||||
if (microinvertersToGet.empty()) {
|
||||
std::vector<Microinverter>::iterator microinvertersIterator = this->microinverters.begin();
|
||||
while (microinvertersIterator != this->microinverters.end()) {
|
||||
|
|
@ -142,7 +96,6 @@ void Dtu::updateMicroinverters(std::vector<std::string> ¶metersToGet, bool a
|
|||
std::pair<Microinverter *, bool> microinverterPair = this->getMicroinverterBySerialNumber(*microinvertersToGetIterator);
|
||||
if (microinverterPair.second) {
|
||||
microinverterPair.first->updateParameters(parametersToGet, allParameters);
|
||||
microinverterPair.first->updateStatusParameters();
|
||||
}
|
||||
microinvertersToGetIterator++;
|
||||
}
|
||||
|
|
@ -161,86 +114,17 @@ void Dtu::printMicroinverters(std::vector<std::string> ¶metersToGet, bool al
|
|||
while (microinvertersToGetIterator != microinvertersToGet.end()) {
|
||||
std::pair<Microinverter *, bool> microinverterPair = this->getMicroinverterBySerialNumber(*microinvertersToGetIterator);
|
||||
if (microinverterPair.second) {
|
||||
std::cout << " "
|
||||
<< "Microinverter: " << microinverterPair.first->serialNumber << std::endl;
|
||||
std::cout << " "
|
||||
<< "Microinverter Data Age: " << microinverterPair.first->age << std::endl;
|
||||
std::cout << " " << "Microinverter: " << microinverterPair.first->serialNumber << std::endl;
|
||||
std::cout << " " << "Microinverter Data Age: " << microinverterPair.first->age << std::endl;
|
||||
if (printTodayProduction) {
|
||||
std::cout << " "
|
||||
<< "TodayProduction: " << microinverterPair.first->getTodayProduction() << "Wh" << std::endl;
|
||||
std::cout << " " << "TodayProduction: " << microinverterPair.first->getTodayProduction() << std::endl;
|
||||
}
|
||||
if (printTotalProduction) {
|
||||
std::cout << " "
|
||||
<< "TotalProduction: " << microinverterPair.first->getTotalProduction() << "Wh" << std::endl;
|
||||
std::cout << " " << "TotalProduction: " << microinverterPair.first->getTotalProduction() << std::endl;
|
||||
}
|
||||
microinverterPair.first->printPorts(parametersToGet, allParameters, shortNames);
|
||||
std::cout << std::endl;
|
||||
}
|
||||
microinvertersToGetIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
void Dtu::setStatusMicroinverters(uint16_t value, std::string statusName, std::vector<long long> µinvertersToSet) {
|
||||
if (microinvertersToSet.empty()) {
|
||||
std::vector<Microinverter>::iterator microinvertersIterator = this->microinverters.begin();
|
||||
while (microinvertersIterator != this->microinverters.end()) {
|
||||
microinvertersToSet.push_back(microinvertersIterator->serialNumber);
|
||||
microinvertersIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<long long>::iterator microinvertersToSetIterator = microinvertersToSet.begin();
|
||||
while (microinvertersToSetIterator != microinvertersToSet.end()) {
|
||||
std::pair<Microinverter *, bool> microinverterPair = this->getMicroinverterBySerialNumber(*microinvertersToSetIterator);
|
||||
if (microinverterPair.second) {
|
||||
microinverterPair.first->setStatusWholeMicroinverter(value, statusName);
|
||||
}
|
||||
microinvertersToSetIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
bool Dtu::empty() { return this->microinverters.empty(); }
|
||||
|
||||
void Dtu::listOfMicroinverters() {
|
||||
std::vector<Microinverter>::iterator microinvertersIterator = this->microinverters.begin();
|
||||
std::cout << "Microinverter list:" << std::endl;
|
||||
while (microinvertersIterator != this->microinverters.end()) {
|
||||
std::cout << " " << microinvertersIterator->serialNumber << std::endl;
|
||||
microinvertersIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
float Dtu::getCurrentPower() {
|
||||
std::vector<Microinverter>::iterator microinvertersIterator = this->microinverters.begin();
|
||||
float currentPower{0};
|
||||
while (microinvertersIterator != this->microinverters.end()) {
|
||||
currentPower += microinvertersIterator->getCurrentPower();
|
||||
microinvertersIterator++;
|
||||
}
|
||||
return currentPower;
|
||||
}
|
||||
|
||||
int Dtu::getCurrentOnOff() {
|
||||
if(this->microinverters.size() == 0) {
|
||||
return 0;
|
||||
}
|
||||
std::vector<Microinverter>::iterator microinvertersIterator = this->microinverters.begin();
|
||||
int currentOn{0};
|
||||
while(microinvertersIterator != this->microinverters.end()) {
|
||||
currentOn += microinvertersIterator->getCurrentOnOff();
|
||||
microinvertersIterator++;
|
||||
}
|
||||
float balance = currentOn / this->microinverters.size();
|
||||
if(balance >= 0.5) {
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void Dtu::turnOffMicroinverters() { this->dtuPort.getStatusByName("onOff").first.get()->writeValue(0, this->modbus, this->dtuPort.statusPortStartAddress); }
|
||||
|
||||
void Dtu::turnOnMicroinverters() { this->dtuPort.getStatusByName("onOff").first.get()->writeValue(1, this->modbus, this->dtuPort.statusPortStartAddress); }
|
||||
|
||||
void Dtu::limitMicroinverters(uint16_t limit) { this->dtuPort.getStatusByName("limitActivePower").first.get()->writeValue(limit, this->modbus, this->dtuPort.statusPortStartAddress); }
|
||||
}
|
||||
|
|
@ -6,15 +6,12 @@
|
|||
|
||||
#include "microinverter.h"
|
||||
#include "port.h"
|
||||
#include "sunspec.h"
|
||||
|
||||
Microinverter::Microinverter(modbus_t *modbus, int startAddress, long long serialNumber) {
|
||||
Microinverter::Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber) {
|
||||
this->modbus = modbus;
|
||||
this->startAddress = startAddress;
|
||||
this->serialNumber = serialNumber;
|
||||
|
||||
this->statusStartAddress = (((this->startAddress - 0x4000) / 0x0019) * 6) + 0xd006;
|
||||
|
||||
this->age = 0;
|
||||
}
|
||||
|
||||
|
|
@ -26,59 +23,25 @@ Microinverter::Microinverter(modbus_t *modbus, int startAddress, long long seria
|
|||
// }
|
||||
|
||||
void Microinverter::updateParameters(std::vector<std::string> ¶metersToGet, bool allParameters) {
|
||||
int portsRead = 0;
|
||||
while (portsRead < this->ports.size()) {
|
||||
int portsToRead = 0;
|
||||
while (portsToRead * 0x0019 < (128 - 0x0019) && (portsToRead + portsRead) < this->ports.size()) {
|
||||
portsToRead++;
|
||||
}
|
||||
int registersToRead = (this->ports.size() * 40) / 2;
|
||||
uint16_t registersJoined[registersToRead];
|
||||
uint8_t registers[registersToRead*2];
|
||||
|
||||
int registersToRead = (portsToRead * 0x0019);
|
||||
uint16_t registers[registersToRead];
|
||||
int registerCount;
|
||||
registerCount = this->modbus.get()->modbus_read_holding_registers(this->startAddress, registersToRead, registersJoined);
|
||||
|
||||
int registerCount;
|
||||
registerCount = modbus_read_registers(this->modbus, this->startAddress + (portsRead * 0x0019), registersToRead, registers);
|
||||
|
||||
if (registerCount == -1) {
|
||||
this->age++;
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i{0}; i < portsToRead; i++) {
|
||||
this->ports.at(i + portsRead).setParametersFromMicroinverterArray(registers, i * 0x0019);
|
||||
}
|
||||
|
||||
portsRead += portsToRead;
|
||||
if(registerCount != 0) {
|
||||
this->age++;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void Microinverter::updateStatusParameters() {
|
||||
int portsRead = 0;
|
||||
while (portsRead < this->ports.size()) {
|
||||
int portsToRead = 0;
|
||||
while (portsToRead * 6 < (128 - 6) && (portsToRead + portsRead) < this->ports.size()) {
|
||||
portsToRead++;
|
||||
}
|
||||
for(int i{0}; i<registersToRead; i++) {
|
||||
registers[2 * i] = (registersJoined[i] & 0xFF00) >> 8;
|
||||
registers[(2 * i)+1] = (registersJoined[i] & 0x00FF);
|
||||
}
|
||||
|
||||
int registersToRead = (portsToRead * 6);
|
||||
uint16_t registers[registersToRead];
|
||||
|
||||
int registerCount;
|
||||
registerCount = modbus_read_registers(this->modbus, this->statusStartAddress + (portsRead * 6), registersToRead, registers);
|
||||
|
||||
if (registerCount == -1) {
|
||||
this->age++;
|
||||
return;
|
||||
}
|
||||
else {
|
||||
this->age = 0;
|
||||
}
|
||||
|
||||
for (int i{0}; i < portsToRead; i++) {
|
||||
this->ports.at(i + portsRead).setStatusesFromMicroinverterArray(registers, i * 6);
|
||||
}
|
||||
|
||||
portsRead += portsToRead;
|
||||
for(int i{0}; i<this->ports.size(); i++) {
|
||||
this->ports.at(i).setParametersFromMicroinverterArray(registers, i * 40);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -95,71 +58,22 @@ long long Microinverter::getTodayProduction() {
|
|||
long long result{0};
|
||||
|
||||
std::vector<Port>::iterator portsIterator = this->ports.begin();
|
||||
while (portsIterator != this->ports.end()) {
|
||||
while(portsIterator != this->ports.end()) {
|
||||
result += portsIterator->getParameterByName("todayProduction").first.get()->getValue().first.i;
|
||||
portsIterator++;
|
||||
}
|
||||
|
||||
return result;
|
||||
return result;
|
||||
}
|
||||
|
||||
long long Microinverter::getTotalProduction() {
|
||||
long long result{0};
|
||||
|
||||
std::vector<Port>::iterator portsIterator = this->ports.begin();
|
||||
while (portsIterator != this->ports.end()) {
|
||||
while(portsIterator != this->ports.end()) {
|
||||
result += portsIterator->getParameterByName("totalProduction").first.get()->getValue().first.i;
|
||||
portsIterator++;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void Microinverter::setStatus(std::vector<std::pair<int, uint16_t>> portsToSet, std::string statusName) {
|
||||
std::vector<std::pair<int, uint16_t>>::iterator portsToSetIterator = portsToSet.begin();
|
||||
while(portsToSetIterator != portsToSet.end()) {
|
||||
try {
|
||||
if(this->ports.at(portsToSetIterator->first).getStatusByName(statusName).second) {
|
||||
this->ports.at(portsToSetIterator->first).getStatusByName(statusName).first->writeValue(portsToSetIterator->second, this->modbus, this->statusStartAddress);
|
||||
}
|
||||
}
|
||||
catch(const std::out_of_range& outOfRange) {
|
||||
std::cerr << outOfRange.what() << std::endl;
|
||||
}
|
||||
portsToSetIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
void Microinverter::setStatusWholeMicroinverter(uint16_t value, std::string statusName) {
|
||||
if(this->ports.begin() != this->ports.end()) {
|
||||
if(this->ports.begin()->getStatusByName(statusName).second) {
|
||||
this->ports.begin()->getStatusByName(statusName).first.get()->writeValue(value, this->modbus, this->ports.begin()->statusPortStartAddress);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
float Microinverter::getCurrentPower() {
|
||||
std::vector<Port>::iterator portsIterator = this->ports.begin();
|
||||
float currentPower{0};
|
||||
while(portsIterator != this->ports.end()) {
|
||||
currentPower += portsIterator->getParameterByName("pvPower").first.get()->getValue().first.f;
|
||||
portsIterator++;
|
||||
}
|
||||
return currentPower;
|
||||
}
|
||||
|
||||
int Microinverter::getCurrentOnOff() {
|
||||
std::vector<Port>::iterator portsIterator = this->ports.begin();
|
||||
int currentOn{0};
|
||||
while(portsIterator != this->ports.end()) {
|
||||
currentOn += portsIterator->getStatusByName("onOff").first.get()->getValue().first.i;
|
||||
portsIterator++;
|
||||
}
|
||||
float balance = currentOn / this->ports.size();
|
||||
if(balance >= 0.5) {
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -12,8 +12,6 @@
|
|||
Port::Port(int portStartAddress) {
|
||||
this->portStartAddress = portStartAddress;
|
||||
|
||||
this->statusPortStartAddress = (((this->portStartAddress - 0x4000) / 0x0019) * 6) + 0xd006;
|
||||
|
||||
this->currentFixed = false;
|
||||
|
||||
this->populateParameters();
|
||||
|
|
@ -49,10 +47,6 @@ void Port::populateParameters() {
|
|||
this->parameters.push_back(std::make_shared<PortParameterAlarmCount>());
|
||||
|
||||
this->parameters.push_back(std::make_shared<PortParameterLinkStatus>());
|
||||
|
||||
this->statusParameters.push_back(std::make_shared<PortParameterOnOff>());
|
||||
|
||||
this->statusParameters.push_back(std::make_shared<PortParameterLimitActivePower>());
|
||||
}
|
||||
|
||||
std::pair<std::shared_ptr<PortParameter>, bool> Port::getParameterByName(std::string name) {
|
||||
|
|
@ -71,22 +65,6 @@ std::pair<std::shared_ptr<PortParameter>, bool> Port::getParameterByName(std::st
|
|||
return result;
|
||||
}
|
||||
|
||||
std::pair<std::shared_ptr<PortParameter>, bool> Port::getStatusByName(std::string name) {
|
||||
std::pair<std::shared_ptr<PortParameter>, bool> result;
|
||||
result.second = false;
|
||||
|
||||
std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->statusParameters.begin();
|
||||
while (parametersIterator != this->statusParameters.end() && !result.second) {
|
||||
if (parametersIterator->get()->name == name) {
|
||||
result.first = *parametersIterator;
|
||||
result.second = true;
|
||||
}
|
||||
parametersIterator++;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void Port::fixCurrent() {
|
||||
if (this->currentFixed) {
|
||||
return;
|
||||
|
|
@ -102,7 +80,7 @@ void Port::fixCurrent() {
|
|||
if (this->getParameterByName("pvPower").first->getValue().first.f > this->getParameterByName("pvVoltage").first->getValue().first.f * this->getParameterByName("pvCurrentMI").first->getValue().first.f) {
|
||||
this->parameters.erase(std::find(this->parameters.begin(), this->parameters.end(), this->getParameterByName("pvCurrentHM").first));
|
||||
} else {
|
||||
this->parameters.erase(std::find(this->parameters.begin(), this->parameters.end(), this->getParameterByName("pvCurrentMI").first));
|
||||
this->parameters.erase(std::find(this->parameters.begin(), this->parameters.end(), this->getParameterByName("pvCurrentM").first));
|
||||
}
|
||||
this->currentFixed = true;
|
||||
}
|
||||
|
|
@ -145,19 +123,10 @@ void Port::fixCurrent() {
|
|||
// }
|
||||
// }
|
||||
|
||||
void Port::setParametersFromMicroinverterArray(uint16_t *registers, int addressOffset) {
|
||||
void Port::setParametersFromMicroinverterArray(uint8_t *registers, int addressOffset) {
|
||||
std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->parameters.begin();
|
||||
while (parametersIterator != this->parameters.end()) {
|
||||
parametersIterator->get()->getValueFromRegisters(registers, addressOffset);
|
||||
parametersIterator++;
|
||||
}
|
||||
this->fixCurrent();
|
||||
}
|
||||
|
||||
void Port::setStatusesFromMicroinverterArray(uint16_t *registers, int addressOffset) {
|
||||
std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->statusParameters.begin();
|
||||
while (parametersIterator != this->statusParameters.end()) {
|
||||
parametersIterator->get()->getValueFromRegisters(registers, addressOffset);
|
||||
while(parametersIterator != this->parameters.end()) {
|
||||
parametersIterator->get()->setValueFromRegisters(registers, addressOffset);
|
||||
parametersIterator++;
|
||||
}
|
||||
}
|
||||
|
|
@ -180,7 +149,7 @@ void Port::printParameters(std::vector<std::string> ¶metersToGet, bool allPa
|
|||
}
|
||||
|
||||
while (parametersToGetIterator != parametersToGet.end()) {
|
||||
if (*parametersToGetIterator == "microinverterSerialNumber") {
|
||||
if(*parametersToGetIterator == "microinverterSerialNumber") {
|
||||
parametersToGetIterator++;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -189,35 +158,14 @@ void Port::printParameters(std::vector<std::string> ¶metersToGet, bool allPa
|
|||
parameterPair = this->getParameterByName(*parametersToGetIterator);
|
||||
if (parameterPair.second) {
|
||||
std::cout << " ";
|
||||
if (shortNames) {
|
||||
if(shortNames) {
|
||||
std::cout << parameterPair.first->shortName;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
std::cout << parameterPair.first->name;
|
||||
}
|
||||
std::cout << ": " << parameterPair.first->getOutputValue() << " |";
|
||||
}
|
||||
parametersToGetIterator++;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<PortParameter>>::iterator statusesToGetIterator = this->statusParameters.begin();
|
||||
while (statusesToGetIterator != this->statusParameters.end()) {
|
||||
std::cout << " ";
|
||||
if (shortNames) {
|
||||
std::cout << statusesToGetIterator->get()->shortName;
|
||||
} else {
|
||||
std::cout << statusesToGetIterator->get()->name;
|
||||
}
|
||||
std::cout << ": " << statusesToGetIterator->get()->getOutputValue() << " |";
|
||||
statusesToGetIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
void Port::turnOff(modbus_t *modbus) { this->getStatusByName("onOff").first.get()->writeValue(0, modbus, this->statusPortStartAddress); }
|
||||
|
||||
bool Port::isOff(modbus_t *modbus) {
|
||||
if (this->getStatusByName("onOff").first.get()->getValue().first.i == 1) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -5,48 +5,42 @@
|
|||
|
||||
#include "portParameters.h"
|
||||
|
||||
PortParameterMicroinverterSerialNumber::PortParameterMicroinverterSerialNumber() : PortParameterInt("microinverterSerialNumber", "mSN", "", true, false, 0x0001, 3) {}
|
||||
PortParameterMicroinverterSerialNumber::PortParameterMicroinverterSerialNumber() : PortParameterInt("microinverterSerialNumber", "mSN", 0x0001, 6) {}
|
||||
|
||||
void PortParameterMicroinverterSerialNumber::getValueFromRegisters(uint16_t *registers, int addressOffset) {
|
||||
void PortParameterMicroinverterSerialNumber::setValueFromRegisters(uint8_t *registers, int addressOffset) {
|
||||
std::string readValueString = "";
|
||||
for (int i{0}; i < this->registerSize; i++) {
|
||||
std::stringstream readValueStringStream;
|
||||
readValueStringStream.fill('0');
|
||||
readValueStringStream << std::setw(2) << std::hex << (int) ((registers[addressOffset + this->parameterAddressOffset + i] & 0xff00) >> 8);
|
||||
readValueStringStream << std::setw(2) << std::hex << (int) (registers[addressOffset + this->parameterAddressOffset + i] & 0x00ff);
|
||||
readValueStringStream << std::hex << (int) registers[addressOffset + this->parameterAddressOffset + i];
|
||||
readValueString.append(readValueStringStream.str());
|
||||
}
|
||||
this->value.i = std::stoll(readValueString);
|
||||
}
|
||||
|
||||
PortParameterPortNumber::PortParameterPortNumber() : PortParameterInt("portNumber", "pN", "", true, false, 0x0004, 1) {}
|
||||
PortParameterPortNumber::PortParameterPortNumber() : PortParameterInt("portNumber", "pN", 0x0007, 1) {}
|
||||
|
||||
PortParameterPvVoltage::PortParameterPvVoltage() : PortParameterFloat("pvVoltage", "pvU", "V", true, false, 1, 0x0005, 1) {}
|
||||
PortParameterPvVoltage::PortParameterPvVoltage() : PortParameterFloat("pvVoltage", "pvU", 1, 0x0008, 2) {}
|
||||
|
||||
PortParameterPvCurrentMi::PortParameterPvCurrentMi() : PortParameterFloat("pvCurrentMI", "pvIMI", "A", true, false, 1, 0x0006, 1) {}
|
||||
PortParameterPvCurrentMi::PortParameterPvCurrentMi() : PortParameterFloat("pvCurrentMI", "pvIMI", 1, 0x000a, 2) {}
|
||||
|
||||
PortParameterPvCurrentHm::PortParameterPvCurrentHm() : PortParameterFloat("pvCurrentHM", "pvIHM", "A", true, false, 2, 0x0006, 1) {}
|
||||
PortParameterPvCurrentHm::PortParameterPvCurrentHm() : PortParameterFloat("pvCurrentHM", "pvIHM", 2, 0x000a, 2) {}
|
||||
|
||||
PortParameterGridVoltage::PortParameterGridVoltage() : PortParameterFloat("gridVoltage", "gU", "V", true, false, 1, 0x0007, 1) {}
|
||||
PortParameterGridVoltage::PortParameterGridVoltage() : PortParameterFloat("gridVoltage", "gU", 1, 0x000c, 2) {}
|
||||
|
||||
PortParameterGridFrequency::PortParameterGridFrequency() : PortParameterFloat("gridFrequency", "gF", "Hz", true, false, 2, 0x0008, 1) {}
|
||||
PortParameterGridFrequency::PortParameterGridFrequency() : PortParameterFloat("gridFrequency", "gF", 2, 0x000e, 2) {}
|
||||
|
||||
PortParameterPvPower::PortParameterPvPower() : PortParameterFloat("pvPower", "pvP", "W", true, false, 1, 0x0009, 1) {}
|
||||
PortParameterPvPower::PortParameterPvPower() : PortParameterFloat("pvPower", "pvP", 1, 0x0010, 2) {}
|
||||
|
||||
PortParameterTodayProduction::PortParameterTodayProduction() : PortParameterInt("todayProduction", "tdP", "Wh", true, false, 0x000A, 1) {}
|
||||
PortParameterTodayProduction::PortParameterTodayProduction() : PortParameterInt("todayProduction", "tdP", 0x0012, 2) {}
|
||||
|
||||
PortParameterTotalProduction::PortParameterTotalProduction() : PortParameterInt("totalProduction", "ttP", "Wh", true, false, 0x000B, 2) {}
|
||||
PortParameterTotalProduction::PortParameterTotalProduction() : PortParameterInt("totalProduction", "ttP", 0x0014, 4) {}
|
||||
|
||||
PortParameterTemperature::PortParameterTemperature() : PortParameterFloat("temperature", "t", "C", true, false, 1, 0x000D, 1) {}
|
||||
PortParameterTemperature::PortParameterTemperature() : PortParameterFloat("temperature", "t", 1, 0x0018, 2) {}
|
||||
|
||||
PortParameterOperatingStatus::PortParameterOperatingStatus() : PortParameterInt("operatingStatus", "oS", "", true, false, 0x000e, 1) {}
|
||||
PortParameterOperatingStatus::PortParameterOperatingStatus() : PortParameterInt("operatingStatus", "oS", 0x001a, 2) {}
|
||||
|
||||
PortParameterAlarmCode::PortParameterAlarmCode() : PortParameterInt("alarmCode", "aC", "", true, false, 0x000f, 1) {}
|
||||
PortParameterAlarmCode::PortParameterAlarmCode() : PortParameterInt("alarmCode", "aC", 0x001c, 2) {}
|
||||
|
||||
PortParameterAlarmCount::PortParameterAlarmCount() : PortParameterInt("alarmCount", "aCnt", "", true, false, 0x0010, 1) {}
|
||||
PortParameterAlarmCount::PortParameterAlarmCount() : PortParameterInt("alarmCount", "aCnt", 0x001e, 2) {}
|
||||
|
||||
PortParameterLinkStatus::PortParameterLinkStatus() : PortParameterInt("linkStatus", "lS", "", true, false, 0x011, 1) {}
|
||||
|
||||
PortParameterOnOff::PortParameterOnOff() : PortParameterInt("onOff", "of", "", true, true, 0x0000, 1) {}
|
||||
|
||||
PortParameterLimitActivePower::PortParameterLimitActivePower() : PortParameterInt("limitActivePower", "lAP", "%", true, true, 0x0001, 1) {}
|
||||
PortParameterLinkStatus::PortParameterLinkStatus() : PortParameterInt("linkStatus", "lS", 0x020, 2) {}
|
||||
|
|
@ -8,37 +8,45 @@
|
|||
|
||||
#include "portParametersGeneric.h"
|
||||
|
||||
PortParameter::PortParameter(std::string name, std::string shortName, std::string unit, bool r, bool w, uint16_t parameterAddressOffset, int registerSize) {
|
||||
PortParameter::PortParameter(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize) {
|
||||
this->name = name;
|
||||
this->shortName = shortName;
|
||||
this->unit = unit;
|
||||
|
||||
this->r = r;
|
||||
this->w = w;
|
||||
|
||||
this->parameterAddressOffset = parameterAddressOffset;
|
||||
this->registerSize = registerSize;
|
||||
|
||||
// this->age = 0;
|
||||
}
|
||||
|
||||
PortParameter::~PortParameter() {}
|
||||
|
||||
void PortParameter::getValueFromRegisters(uint16_t *readArray, int portOffset) {}
|
||||
void PortParameter::setValueFromRegisters(uint8_t *readArray, int portOffset) {}
|
||||
|
||||
std::pair<PortParameter::PortParameterValue, PortParameter::PortParameterValueType> PortParameter::getValue() {
|
||||
return std::pair<PortParameter::PortParameterValue, PortParameter::PortParameterValueType>(this->value, this->valueType);
|
||||
}
|
||||
|
||||
PortParameter& PortParameter::writeValue(uint16_t value, modbus_t *modbus, int portStartAddress) {
|
||||
int writeCount;
|
||||
writeCount = modbus_write_register(modbus, this->parameterAddressOffset + portStartAddress, value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::string PortParameter::getOutputValue() {
|
||||
return "yeet";
|
||||
}
|
||||
|
||||
PortParameterFloat::PortParameterFloat(std::string name, std::string shortName, std::string unit, bool r, bool w, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, unit, r, w, parameterAddressOffset, registerSize) {
|
||||
// void PortParameter::updateValue(std::shared_ptr<class modbus> modbus, uint16_t portStartAddress) {
|
||||
// uint16_t readArray[this->registerSize];
|
||||
// int registerCount;
|
||||
|
||||
// registerCount = modbus.get()->modbus_read_holding_registers(portStartAddress + this->parameterAddressOffset, this->registerSize, readArray);
|
||||
|
||||
// if(registerCount != 0){
|
||||
// this->age++;
|
||||
// }
|
||||
// else{
|
||||
// registerCount = this->registerSize;
|
||||
// this->setValueFromRegisters(readArray, registerCount);
|
||||
// this->age = 0;
|
||||
// }
|
||||
// }
|
||||
|
||||
PortParameterFloat::PortParameterFloat(std::string name, std::string shortName, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, parameterAddressOffset, registerSize) {
|
||||
this->decimalPlaces = decimalPlaces;
|
||||
|
||||
this->valueType = Float;
|
||||
|
|
@ -46,7 +54,7 @@ PortParameterFloat::PortParameterFloat(std::string name, std::string shortName,
|
|||
this->value.f = 0;
|
||||
}
|
||||
|
||||
void PortParameterFloat::getValueFromRegisters(uint16_t *registers, int addressOffset) {
|
||||
void PortParameterFloat::setValueFromRegisters(uint8_t *registers, int addressOffset) {
|
||||
std::string readValueString{""};
|
||||
for(int i{0}; i<this->registerSize; i++) {
|
||||
std::stringstream readValueStringStream;
|
||||
|
|
@ -59,16 +67,16 @@ void PortParameterFloat::getValueFromRegisters(uint16_t *registers, int addressO
|
|||
std::string PortParameterFloat::getOutputValue() {
|
||||
std::stringstream valueStringStream;
|
||||
valueStringStream << std::fixed << std::setprecision(this->decimalPlaces) << this->value.f;
|
||||
return valueStringStream.str().append(this->unit.c_str());
|
||||
return valueStringStream.str();
|
||||
}
|
||||
|
||||
PortParameterInt::PortParameterInt(std::string name, std::string shortName, std::string unit, bool r, bool w, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, unit, r, w, parameterAddressOffset, registerSize) {
|
||||
PortParameterInt::PortParameterInt(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, parameterAddressOffset, registerSize) {
|
||||
this->valueType = Int;
|
||||
|
||||
this->value.i = 0;
|
||||
}
|
||||
|
||||
void PortParameterInt::getValueFromRegisters(uint16_t *registers, int addressOffset) {
|
||||
void PortParameterInt::setValueFromRegisters(uint8_t *registers, int addressOffset) {
|
||||
std::string readValueString{""};
|
||||
for (int i{0}; i < this->registerSize; i++) {
|
||||
std::stringstream readValueStringStream;
|
||||
|
|
@ -79,5 +87,5 @@ void PortParameterInt::getValueFromRegisters(uint16_t *registers, int addressOff
|
|||
}
|
||||
|
||||
std::string PortParameterInt::getOutputValue() {
|
||||
return std::to_string(this->value.i).append(this->unit.c_str());
|
||||
return std::to_string(this->value.i);
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
#include <string>
|
||||
#include <stdint.h>
|
||||
#include <memory>
|
||||
|
||||
#include "sunspec.h"
|
||||
#include "modbus.h"
|
||||
#include "sunspecParameters.h"
|
||||
|
||||
Sunspec::Sunspec(int address, modbus_t *modbus) {
|
||||
this->modbus = modbus;
|
||||
this->sunspecAddress = address;
|
||||
|
||||
this->populateParameters();
|
||||
|
||||
this->setValues();
|
||||
}
|
||||
|
||||
void Sunspec::setValues() {
|
||||
uint16_t registers[2];
|
||||
|
||||
int registerCount;
|
||||
registerCount = modbus_read_registers(this->modbus, this->sunspecAddress, 2, registers);
|
||||
|
||||
std::vector<std::shared_ptr<SunspecParameter>>::iterator parametersIterator = this->parameters.begin();
|
||||
while(parametersIterator != this->parameters.end()) {
|
||||
parametersIterator->get()->getValueFromRegisters(registers, 0);
|
||||
parametersIterator++;
|
||||
}
|
||||
}
|
||||
|
||||
void Sunspec::populateParameters() {
|
||||
SunspecParameterManufacturer manufacturer{};
|
||||
this->parameters.push_back(std::make_shared<SunspecParameterManufacturer>(manufacturer));
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
|
||||
#include "sunspecParameters.h"
|
||||
|
||||
SunspecParameterManufacturer::SunspecParameterManufacturer() : SunspecParameterString32("manufacturer", 4, 16) {
|
||||
this->valueType = string32;
|
||||
}
|
||||
|
||||
void SunspecParameterManufacturer::getValueFromRegisters(uint16_t *registers, int addressOffset) {
|
||||
std::string readValue;
|
||||
|
||||
for(int i{0}; i<this->registerSize; i++) {
|
||||
std::stringstream readValueStringStream;
|
||||
readValueStringStream << (registers[addressOffset + this->registerAddressOffset + i] >> 8) << " ";
|
||||
readValueStringStream << (registers[addressOffset + this->registerAddressOffset + i] & 0x00FF) << " ";
|
||||
|
||||
readValue.append(readValueStringStream.str().c_str());
|
||||
}
|
||||
|
||||
this->value = readValue;
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
#include "sunspecParametersGeneric.h"
|
||||
|
||||
SunspecParameter::~SunspecParameter() {}
|
||||
|
||||
SunspecParameter::SunspecParameter(std::string name, int registerAddressOffset, int registerSize) {
|
||||
this->name = name;
|
||||
this->registerAddressOffset = registerAddressOffset;
|
||||
this->registerSize = registerSize;
|
||||
}
|
||||
|
||||
void SunspecParameter::getValueFromRegisters(uint16_t *registers, int addressOffset) {}
|
||||
|
||||
std::pair<SunspecParameter::SunspecValue, SunspecParameter::SunspecValueType> SunspecParameter::getValue() {
|
||||
return {this->value, this->valueType};
|
||||
}
|
||||
|
||||
SunspecParameterString32::SunspecParameterString32(std::string name, int registerAddressOffset, int registerSize) : SunspecParameter(name, registerAddressOffset, registerSize) {}
|
||||
|
||||
void SunspecParameterString32::getValueFromRegisters(uint16_t *registers, int addressOffset) {}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
include_directories(inc)
|
||||
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/inc/config.h)
|
||||
|
||||
file(GLOB SOURCES src/*.c)
|
||||
|
||||
add_library(libmodbus STATIC ${SOURCES})
|
||||
|
|
@ -1,291 +0,0 @@
|
|||
/* config.h.in. Generated from configure.ac by autoheader. */
|
||||
|
||||
/* Define to 1 if you have the `accept4' function. */
|
||||
#undef HAVE_ACCEPT4
|
||||
|
||||
/* Define to 1 if you have the <arpa/inet.h> header file. */
|
||||
#undef HAVE_ARPA_INET_H
|
||||
|
||||
/* Define to 1 if you have the <byteswap.h> header file. */
|
||||
#undef HAVE_BYTESWAP_H
|
||||
|
||||
/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you
|
||||
don't. */
|
||||
#undef HAVE_DECL_TIOCM_RTS
|
||||
|
||||
/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you
|
||||
don't. */
|
||||
#undef HAVE_DECL_TIOCSRS485
|
||||
|
||||
/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you
|
||||
don't. */
|
||||
#undef HAVE_DECL___CYGWIN__
|
||||
|
||||
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||
#undef HAVE_DLFCN_H
|
||||
|
||||
/* Define to 1 if you have the <errno.h> header file. */
|
||||
#undef HAVE_ERRNO_H
|
||||
|
||||
/* Define to 1 if you have the <fcntl.h> header file. */
|
||||
#undef HAVE_FCNTL_H
|
||||
|
||||
/* Define to 1 if you have the `getaddrinfo' function. */
|
||||
#undef HAVE_GETADDRINFO
|
||||
|
||||
/* Define to 1 if you have the `gettimeofday' function. */
|
||||
#undef HAVE_GETTIMEOFDAY
|
||||
|
||||
/* Define to 1 if you have the `inet_ntop' function. */
|
||||
#undef HAVE_INET_NTOP
|
||||
|
||||
/* Define to 1 if you have the `inet_pton' function. */
|
||||
#undef HAVE_INET_PTON
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#undef HAVE_INTTYPES_H
|
||||
|
||||
/* Define to 1 if you have the <limits.h> header file. */
|
||||
#undef HAVE_LIMITS_H
|
||||
|
||||
/* Define to 1 if you have the <linux/serial.h> header file. */
|
||||
#undef HAVE_LINUX_SERIAL_H
|
||||
|
||||
/* Define to 1 if you have the <minix/config.h> header file. */
|
||||
#undef HAVE_MINIX_CONFIG_H
|
||||
|
||||
/* Define to 1 if you have the <netdb.h> header file. */
|
||||
#undef HAVE_NETDB_H
|
||||
|
||||
/* Define to 1 if you have the <netinet/in.h> header file. */
|
||||
#undef HAVE_NETINET_IN_H
|
||||
|
||||
/* Define to 1 if you have the <netinet/tcp.h> header file. */
|
||||
#undef HAVE_NETINET_TCP_H
|
||||
|
||||
/* Define to 1 if you have the `select' function. */
|
||||
#undef HAVE_SELECT
|
||||
|
||||
/* Define to 1 if you have the `socket' function. */
|
||||
#undef HAVE_SOCKET
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#undef HAVE_STDINT_H
|
||||
|
||||
/* Define to 1 if you have the <stdio.h> header file. */
|
||||
#undef HAVE_STDIO_H
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#undef HAVE_STDLIB_H
|
||||
|
||||
/* Define to 1 if you have the `strerror' function. */
|
||||
#undef HAVE_STRERROR
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#undef HAVE_STRINGS_H
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#undef HAVE_STRING_H
|
||||
|
||||
/* Define to 1 if you have the `strlcpy' function. */
|
||||
#undef HAVE_STRLCPY
|
||||
|
||||
/* Define to 1 if you have the <sys/ioctl.h> header file. */
|
||||
#undef HAVE_SYS_IOCTL_H
|
||||
|
||||
/* Define to 1 if you have the <sys/params.h> header file. */
|
||||
#undef HAVE_SYS_PARAMS_H
|
||||
|
||||
/* Define to 1 if you have the <sys/socket.h> header file. */
|
||||
#undef HAVE_SYS_SOCKET_H
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#undef HAVE_SYS_STAT_H
|
||||
|
||||
/* Define to 1 if you have the <sys/time.h> header file. */
|
||||
#undef HAVE_SYS_TIME_H
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#undef HAVE_SYS_TYPES_H
|
||||
|
||||
/* Define to 1 if you have the <termios.h> header file. */
|
||||
#undef HAVE_TERMIOS_H
|
||||
|
||||
/* Define to 1 if you have the <time.h> header file. */
|
||||
#undef HAVE_TIME_H
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#undef HAVE_UNISTD_H
|
||||
|
||||
/* Define to 1 if you have the <wchar.h> header file. */
|
||||
#undef HAVE_WCHAR_H
|
||||
|
||||
/* Define to 1 if you have the <winsock2.h> header file. */
|
||||
#undef HAVE_WINSOCK2_H
|
||||
|
||||
/* Define to the sub-directory where libtool stores uninstalled libraries. */
|
||||
#undef LT_OBJDIR
|
||||
|
||||
/* Name of package */
|
||||
#undef PACKAGE
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#undef PACKAGE_BUGREPORT
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#undef PACKAGE_NAME
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#undef PACKAGE_STRING
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#undef PACKAGE_TARNAME
|
||||
|
||||
/* Define to the home page for this package. */
|
||||
#undef PACKAGE_URL
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#undef PACKAGE_VERSION
|
||||
|
||||
/* Define to 1 if all of the C90 standard headers exist (not just the ones
|
||||
required in a freestanding environment). This macro is provided for
|
||||
backward compatibility; new code need not use it. */
|
||||
#undef STDC_HEADERS
|
||||
|
||||
/* Enable extensions on AIX 3, Interix. */
|
||||
#ifndef _ALL_SOURCE
|
||||
# undef _ALL_SOURCE
|
||||
#endif
|
||||
/* Enable general extensions on macOS. */
|
||||
#ifndef _DARWIN_C_SOURCE
|
||||
# undef _DARWIN_C_SOURCE
|
||||
#endif
|
||||
/* Enable general extensions on Solaris. */
|
||||
#ifndef __EXTENSIONS__
|
||||
# undef __EXTENSIONS__
|
||||
#endif
|
||||
/* Enable GNU extensions on systems that have them. */
|
||||
#ifndef _GNU_SOURCE
|
||||
# undef _GNU_SOURCE
|
||||
#endif
|
||||
/* Enable X/Open compliant socket functions that do not require linking
|
||||
with -lxnet on HP-UX 11.11. */
|
||||
#ifndef _HPUX_ALT_XOPEN_SOCKET_API
|
||||
# undef _HPUX_ALT_XOPEN_SOCKET_API
|
||||
#endif
|
||||
/* Identify the host operating system as Minix.
|
||||
This macro does not affect the system headers' behavior.
|
||||
A future release of Autoconf may stop defining this macro. */
|
||||
#ifndef _MINIX
|
||||
# undef _MINIX
|
||||
#endif
|
||||
/* Enable general extensions on NetBSD.
|
||||
Enable NetBSD compatibility extensions on Minix. */
|
||||
#ifndef _NETBSD_SOURCE
|
||||
# undef _NETBSD_SOURCE
|
||||
#endif
|
||||
/* Enable OpenBSD compatibility extensions on NetBSD.
|
||||
Oddly enough, this does nothing on OpenBSD. */
|
||||
#ifndef _OPENBSD_SOURCE
|
||||
# undef _OPENBSD_SOURCE
|
||||
#endif
|
||||
/* Define to 1 if needed for POSIX-compatible behavior. */
|
||||
#ifndef _POSIX_SOURCE
|
||||
# undef _POSIX_SOURCE
|
||||
#endif
|
||||
/* Define to 2 if needed for POSIX-compatible behavior. */
|
||||
#ifndef _POSIX_1_SOURCE
|
||||
# undef _POSIX_1_SOURCE
|
||||
#endif
|
||||
/* Enable POSIX-compatible threading on Solaris. */
|
||||
#ifndef _POSIX_PTHREAD_SEMANTICS
|
||||
# undef _POSIX_PTHREAD_SEMANTICS
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */
|
||||
#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */
|
||||
#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_DFP_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_FUNCS_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */
|
||||
#ifndef __STDC_WANT_LIB_EXT2__
|
||||
# undef __STDC_WANT_LIB_EXT2__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC 24747:2009. */
|
||||
#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
|
||||
# undef __STDC_WANT_MATH_SPEC_FUNCS__
|
||||
#endif
|
||||
/* Enable extensions on HP NonStop. */
|
||||
#ifndef _TANDEM_SOURCE
|
||||
# undef _TANDEM_SOURCE
|
||||
#endif
|
||||
/* Enable X/Open extensions. Define to 500 only if necessary
|
||||
to make mbstate_t available. */
|
||||
#ifndef _XOPEN_SOURCE
|
||||
# undef _XOPEN_SOURCE
|
||||
#endif
|
||||
|
||||
|
||||
/* Version number of package */
|
||||
#undef VERSION
|
||||
|
||||
/* _ */
|
||||
#undef WINVER
|
||||
|
||||
/* Number of bits in a file offset, on hosts where this is settable. */
|
||||
#undef _FILE_OFFSET_BITS
|
||||
|
||||
/* Define for large files, on AIX-style hosts. */
|
||||
#undef _LARGE_FILES
|
||||
|
||||
/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
|
||||
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
|
||||
#define below would cause a syntax error. */
|
||||
#undef _UINT32_T
|
||||
|
||||
/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
|
||||
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
|
||||
#define below would cause a syntax error. */
|
||||
#undef _UINT8_T
|
||||
|
||||
/* Define to `__inline__' or `__inline' if that's what the C compiler
|
||||
calls it, or to nothing if 'inline' is not supported under any name. */
|
||||
#ifndef __cplusplus
|
||||
#undef inline
|
||||
#endif
|
||||
|
||||
/* Define to the type of a signed integer type of width exactly 64 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef int64_t
|
||||
|
||||
/* Define to `unsigned int' if <sys/types.h> does not define. */
|
||||
#undef size_t
|
||||
|
||||
/* Define to `int' if <sys/types.h> does not define. */
|
||||
#undef ssize_t
|
||||
|
||||
/* Define to the type of an unsigned integer type of width exactly 16 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef uint16_t
|
||||
|
||||
/* Define to the type of an unsigned integer type of width exactly 32 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef uint32_t
|
||||
|
||||
/* Define to the type of an unsigned integer type of width exactly 8 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef uint8_t
|
||||
|
|
@ -1,291 +0,0 @@
|
|||
/* config.h.in. Generated from configure.ac by autoheader. */
|
||||
|
||||
/* Define to 1 if you have the `accept4' function. */
|
||||
#undef HAVE_ACCEPT4
|
||||
|
||||
/* Define to 1 if you have the <arpa/inet.h> header file. */
|
||||
#undef HAVE_ARPA_INET_H
|
||||
|
||||
/* Define to 1 if you have the <byteswap.h> header file. */
|
||||
#undef HAVE_BYTESWAP_H
|
||||
|
||||
/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you
|
||||
don't. */
|
||||
#undef HAVE_DECL_TIOCM_RTS
|
||||
|
||||
/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you
|
||||
don't. */
|
||||
#undef HAVE_DECL_TIOCSRS485
|
||||
|
||||
/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you
|
||||
don't. */
|
||||
#undef HAVE_DECL___CYGWIN__
|
||||
|
||||
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||
#undef HAVE_DLFCN_H
|
||||
|
||||
/* Define to 1 if you have the <errno.h> header file. */
|
||||
#undef HAVE_ERRNO_H
|
||||
|
||||
/* Define to 1 if you have the <fcntl.h> header file. */
|
||||
#undef HAVE_FCNTL_H
|
||||
|
||||
/* Define to 1 if you have the `getaddrinfo' function. */
|
||||
#undef HAVE_GETADDRINFO
|
||||
|
||||
/* Define to 1 if you have the `gettimeofday' function. */
|
||||
#undef HAVE_GETTIMEOFDAY
|
||||
|
||||
/* Define to 1 if you have the `inet_ntop' function. */
|
||||
#undef HAVE_INET_NTOP
|
||||
|
||||
/* Define to 1 if you have the `inet_pton' function. */
|
||||
#undef HAVE_INET_PTON
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#undef HAVE_INTTYPES_H
|
||||
|
||||
/* Define to 1 if you have the <limits.h> header file. */
|
||||
#undef HAVE_LIMITS_H
|
||||
|
||||
/* Define to 1 if you have the <linux/serial.h> header file. */
|
||||
#undef HAVE_LINUX_SERIAL_H
|
||||
|
||||
/* Define to 1 if you have the <minix/config.h> header file. */
|
||||
#undef HAVE_MINIX_CONFIG_H
|
||||
|
||||
/* Define to 1 if you have the <netdb.h> header file. */
|
||||
#undef HAVE_NETDB_H
|
||||
|
||||
/* Define to 1 if you have the <netinet/in.h> header file. */
|
||||
#undef HAVE_NETINET_IN_H
|
||||
|
||||
/* Define to 1 if you have the <netinet/tcp.h> header file. */
|
||||
#undef HAVE_NETINET_TCP_H
|
||||
|
||||
/* Define to 1 if you have the `select' function. */
|
||||
#undef HAVE_SELECT
|
||||
|
||||
/* Define to 1 if you have the `socket' function. */
|
||||
#undef HAVE_SOCKET
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#undef HAVE_STDINT_H
|
||||
|
||||
/* Define to 1 if you have the <stdio.h> header file. */
|
||||
#undef HAVE_STDIO_H
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#undef HAVE_STDLIB_H
|
||||
|
||||
/* Define to 1 if you have the `strerror' function. */
|
||||
#undef HAVE_STRERROR
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#undef HAVE_STRINGS_H
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#undef HAVE_STRING_H
|
||||
|
||||
/* Define to 1 if you have the `strlcpy' function. */
|
||||
#undef HAVE_STRLCPY
|
||||
|
||||
/* Define to 1 if you have the <sys/ioctl.h> header file. */
|
||||
#undef HAVE_SYS_IOCTL_H
|
||||
|
||||
/* Define to 1 if you have the <sys/params.h> header file. */
|
||||
#undef HAVE_SYS_PARAMS_H
|
||||
|
||||
/* Define to 1 if you have the <sys/socket.h> header file. */
|
||||
#undef HAVE_SYS_SOCKET_H
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#undef HAVE_SYS_STAT_H
|
||||
|
||||
/* Define to 1 if you have the <sys/time.h> header file. */
|
||||
#undef HAVE_SYS_TIME_H
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#undef HAVE_SYS_TYPES_H
|
||||
|
||||
/* Define to 1 if you have the <termios.h> header file. */
|
||||
#undef HAVE_TERMIOS_H
|
||||
|
||||
/* Define to 1 if you have the <time.h> header file. */
|
||||
#undef HAVE_TIME_H
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#undef HAVE_UNISTD_H
|
||||
|
||||
/* Define to 1 if you have the <wchar.h> header file. */
|
||||
#undef HAVE_WCHAR_H
|
||||
|
||||
/* Define to 1 if you have the <winsock2.h> header file. */
|
||||
#undef HAVE_WINSOCK2_H
|
||||
|
||||
/* Define to the sub-directory where libtool stores uninstalled libraries. */
|
||||
#undef LT_OBJDIR
|
||||
|
||||
/* Name of package */
|
||||
#undef PACKAGE
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#undef PACKAGE_BUGREPORT
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#undef PACKAGE_NAME
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#undef PACKAGE_STRING
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#undef PACKAGE_TARNAME
|
||||
|
||||
/* Define to the home page for this package. */
|
||||
#undef PACKAGE_URL
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#undef PACKAGE_VERSION
|
||||
|
||||
/* Define to 1 if all of the C90 standard headers exist (not just the ones
|
||||
required in a freestanding environment). This macro is provided for
|
||||
backward compatibility; new code need not use it. */
|
||||
#undef STDC_HEADERS
|
||||
|
||||
/* Enable extensions on AIX 3, Interix. */
|
||||
#ifndef _ALL_SOURCE
|
||||
# undef _ALL_SOURCE
|
||||
#endif
|
||||
/* Enable general extensions on macOS. */
|
||||
#ifndef _DARWIN_C_SOURCE
|
||||
# undef _DARWIN_C_SOURCE
|
||||
#endif
|
||||
/* Enable general extensions on Solaris. */
|
||||
#ifndef __EXTENSIONS__
|
||||
# undef __EXTENSIONS__
|
||||
#endif
|
||||
/* Enable GNU extensions on systems that have them. */
|
||||
#ifndef _GNU_SOURCE
|
||||
# undef _GNU_SOURCE
|
||||
#endif
|
||||
/* Enable X/Open compliant socket functions that do not require linking
|
||||
with -lxnet on HP-UX 11.11. */
|
||||
#ifndef _HPUX_ALT_XOPEN_SOCKET_API
|
||||
# undef _HPUX_ALT_XOPEN_SOCKET_API
|
||||
#endif
|
||||
/* Identify the host operating system as Minix.
|
||||
This macro does not affect the system headers' behavior.
|
||||
A future release of Autoconf may stop defining this macro. */
|
||||
#ifndef _MINIX
|
||||
# undef _MINIX
|
||||
#endif
|
||||
/* Enable general extensions on NetBSD.
|
||||
Enable NetBSD compatibility extensions on Minix. */
|
||||
#ifndef _NETBSD_SOURCE
|
||||
# undef _NETBSD_SOURCE
|
||||
#endif
|
||||
/* Enable OpenBSD compatibility extensions on NetBSD.
|
||||
Oddly enough, this does nothing on OpenBSD. */
|
||||
#ifndef _OPENBSD_SOURCE
|
||||
# undef _OPENBSD_SOURCE
|
||||
#endif
|
||||
/* Define to 1 if needed for POSIX-compatible behavior. */
|
||||
#ifndef _POSIX_SOURCE
|
||||
# undef _POSIX_SOURCE
|
||||
#endif
|
||||
/* Define to 2 if needed for POSIX-compatible behavior. */
|
||||
#ifndef _POSIX_1_SOURCE
|
||||
# undef _POSIX_1_SOURCE
|
||||
#endif
|
||||
/* Enable POSIX-compatible threading on Solaris. */
|
||||
#ifndef _POSIX_PTHREAD_SEMANTICS
|
||||
# undef _POSIX_PTHREAD_SEMANTICS
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */
|
||||
#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */
|
||||
#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_DFP_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_FUNCS_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */
|
||||
#ifndef __STDC_WANT_LIB_EXT2__
|
||||
# undef __STDC_WANT_LIB_EXT2__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC 24747:2009. */
|
||||
#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
|
||||
# undef __STDC_WANT_MATH_SPEC_FUNCS__
|
||||
#endif
|
||||
/* Enable extensions on HP NonStop. */
|
||||
#ifndef _TANDEM_SOURCE
|
||||
# undef _TANDEM_SOURCE
|
||||
#endif
|
||||
/* Enable X/Open extensions. Define to 500 only if necessary
|
||||
to make mbstate_t available. */
|
||||
#ifndef _XOPEN_SOURCE
|
||||
# undef _XOPEN_SOURCE
|
||||
#endif
|
||||
|
||||
|
||||
/* Version number of package */
|
||||
#undef VERSION
|
||||
|
||||
/* _ */
|
||||
#undef WINVER
|
||||
|
||||
/* Number of bits in a file offset, on hosts where this is settable. */
|
||||
#undef _FILE_OFFSET_BITS
|
||||
|
||||
/* Define for large files, on AIX-style hosts. */
|
||||
#undef _LARGE_FILES
|
||||
|
||||
/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
|
||||
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
|
||||
#define below would cause a syntax error. */
|
||||
#undef _UINT32_T
|
||||
|
||||
/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
|
||||
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
|
||||
#define below would cause a syntax error. */
|
||||
#undef _UINT8_T
|
||||
|
||||
/* Define to `__inline__' or `__inline' if that's what the C compiler
|
||||
calls it, or to nothing if 'inline' is not supported under any name. */
|
||||
#ifndef __cplusplus
|
||||
#undef inline
|
||||
#endif
|
||||
|
||||
/* Define to the type of a signed integer type of width exactly 64 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef int64_t
|
||||
|
||||
/* Define to `unsigned int' if <sys/types.h> does not define. */
|
||||
#undef size_t
|
||||
|
||||
/* Define to `int' if <sys/types.h> does not define. */
|
||||
#undef ssize_t
|
||||
|
||||
/* Define to the type of an unsigned integer type of width exactly 16 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef uint16_t
|
||||
|
||||
/* Define to the type of an unsigned integer type of width exactly 32 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef uint32_t
|
||||
|
||||
/* Define to the type of an unsigned integer type of width exactly 8 bits if
|
||||
such a type exists and the standard includes do not define it. */
|
||||
#undef uint8_t
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_PRIVATE_H
|
||||
#define MODBUS_PRIVATE_H
|
||||
|
||||
// clang-format off
|
||||
#ifndef _MSC_VER
|
||||
# include <stdint.h>
|
||||
# include <sys/time.h>
|
||||
#else
|
||||
# include "stdint.h"
|
||||
# include <time.h>
|
||||
typedef int ssize_t;
|
||||
#endif
|
||||
// clang-format on
|
||||
#include <config.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#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);
|
||||
unsigned int (*is_connected)(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;
|
||||
int quirks;
|
||||
struct timeval response_timeout;
|
||||
struct timeval byte_timeout;
|
||||
struct timeval indication_timeout;
|
||||
const modbus_backend_t *backend;
|
||||
void *backend_data;
|
||||
};
|
||||
|
||||
void _modbus_init_common(modbus_t *ctx);
|
||||
void _error_print(modbus_t *ctx, const char *context);
|
||||
int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type);
|
||||
|
||||
#ifndef HAVE_STRLCPY
|
||||
size_t strlcpy(char *dest, const char *src, size_t dest_size);
|
||||
#endif
|
||||
|
||||
MODBUS_END_DECLS
|
||||
|
||||
#endif /* MODBUS_PRIVATE_H */
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_RTU_PRIVATE_H
|
||||
#define MODBUS_RTU_PRIVATE_H
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#include <stdint.h>
|
||||
#else
|
||||
#include "stdint.h"
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <termios.h>
|
||||
#endif
|
||||
|
||||
#define _MODBUS_RTU_HEADER_LENGTH 1
|
||||
#define _MODBUS_RTU_PRESET_REQ_LENGTH 6
|
||||
#define _MODBUS_RTU_PRESET_RSP_LENGTH 2
|
||||
|
||||
#define _MODBUS_RTU_CHECKSUM_LENGTH 2
|
||||
|
||||
#if defined(_WIN32)
|
||||
#if !defined(ENOTSUP)
|
||||
#define ENOTSUP WSAEOPNOTSUPP
|
||||
#endif
|
||||
|
||||
/* WIN32: struct containing serial handle and a receive buffer */
|
||||
#define PY_BUF_SIZE 512
|
||||
|
||||
struct win32_ser {
|
||||
/* File handle */
|
||||
HANDLE fd;
|
||||
/* Receive buffer */
|
||||
uint8_t buf[PY_BUF_SIZE];
|
||||
/* Received chars */
|
||||
DWORD n_bytes;
|
||||
};
|
||||
#endif /* _WIN32 */
|
||||
|
||||
typedef struct _modbus_rtu {
|
||||
/* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X. */
|
||||
char *device;
|
||||
/* Bauds: 9600, 19200, 57600, 115200, etc */
|
||||
int baud;
|
||||
/* Data bit */
|
||||
uint8_t data_bit;
|
||||
/* Stop bit */
|
||||
uint8_t stop_bit;
|
||||
/* Parity: 'N', 'O', 'E' */
|
||||
char parity;
|
||||
#if defined(_WIN32)
|
||||
struct win32_ser w_ser;
|
||||
DCB old_dcb;
|
||||
#else
|
||||
/* Save old termios settings */
|
||||
struct termios old_tios;
|
||||
#endif
|
||||
#if HAVE_DECL_TIOCSRS485
|
||||
int serial_mode;
|
||||
#endif
|
||||
#if HAVE_DECL_TIOCM_RTS
|
||||
int rts;
|
||||
int rts_delay;
|
||||
int onebyte_time;
|
||||
void (*set_rts)(modbus_t *ctx, int on);
|
||||
#endif
|
||||
/* To handle many slaves on the same link */
|
||||
int confirmation_to_ignore;
|
||||
} modbus_rtu_t;
|
||||
|
||||
#endif /* MODBUS_RTU_PRIVATE_H */
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_RTU_H
|
||||
#define MODBUS_RTU_H
|
||||
|
||||
#include "modbus.h"
|
||||
|
||||
MODBUS_BEGIN_DECLS
|
||||
|
||||
/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
|
||||
* RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes
|
||||
*/
|
||||
#define MODBUS_RTU_MAX_ADU_LENGTH 256
|
||||
|
||||
MODBUS_API modbus_t *
|
||||
modbus_new_rtu(const char *device, int baud, char parity, int data_bit, int stop_bit);
|
||||
|
||||
#define MODBUS_RTU_RS232 0
|
||||
#define MODBUS_RTU_RS485 1
|
||||
|
||||
MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode);
|
||||
MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx);
|
||||
|
||||
#define MODBUS_RTU_RTS_NONE 0
|
||||
#define MODBUS_RTU_RTS_UP 1
|
||||
#define MODBUS_RTU_RTS_DOWN 2
|
||||
|
||||
MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode);
|
||||
MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx);
|
||||
|
||||
MODBUS_API int modbus_rtu_set_custom_rts(modbus_t *ctx,
|
||||
void (*set_rts)(modbus_t *ctx, int on));
|
||||
|
||||
MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us);
|
||||
MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx);
|
||||
|
||||
MODBUS_END_DECLS
|
||||
|
||||
#endif /* MODBUS_RTU_H */
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_TCP_PRIVATE_H
|
||||
#define MODBUS_TCP_PRIVATE_H
|
||||
|
||||
#define _MODBUS_TCP_HEADER_LENGTH 7
|
||||
#define _MODBUS_TCP_PRESET_REQ_LENGTH 12
|
||||
#define _MODBUS_TCP_PRESET_RSP_LENGTH 8
|
||||
|
||||
#define _MODBUS_TCP_CHECKSUM_LENGTH 0
|
||||
|
||||
/* In both structures, the transaction ID must be placed on first position
|
||||
to have a quick access not dependent 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;
|
||||
|
||||
typedef struct _modbus_tcp_pi {
|
||||
/* Transaction ID */
|
||||
uint16_t t_id;
|
||||
/* TCP port */
|
||||
int port;
|
||||
/* Node */
|
||||
char *node;
|
||||
/* Service */
|
||||
char *service;
|
||||
} modbus_tcp_pi_t;
|
||||
|
||||
#endif /* MODBUS_TCP_PRIVATE_H */
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_TCP_H
|
||||
#define MODBUS_TCP_H
|
||||
|
||||
#include "modbus.h"
|
||||
|
||||
MODBUS_BEGIN_DECLS
|
||||
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
/* Win32 with MinGW, supplement to <errno.h> */
|
||||
#include <winsock2.h>
|
||||
#if !defined(ECONNRESET)
|
||||
#define ECONNRESET WSAECONNRESET
|
||||
#endif
|
||||
#if !defined(ECONNREFUSED)
|
||||
#define ECONNREFUSED WSAECONNREFUSED
|
||||
#endif
|
||||
#if !defined(ETIMEDOUT)
|
||||
#define ETIMEDOUT WSAETIMEDOUT
|
||||
#endif
|
||||
#if !defined(ENOPROTOOPT)
|
||||
#define ENOPROTOOPT WSAENOPROTOOPT
|
||||
#endif
|
||||
#if !defined(EINPROGRESS)
|
||||
#define EINPROGRESS WSAEINPROGRESS
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define MODBUS_TCP_DEFAULT_PORT 502
|
||||
#define MODBUS_TCP_SLAVE 0xFF
|
||||
|
||||
/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
|
||||
* TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes
|
||||
*/
|
||||
#define MODBUS_TCP_MAX_ADU_LENGTH 260
|
||||
|
||||
MODBUS_API modbus_t *modbus_new_tcp(const char *ip_address, int port);
|
||||
MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection);
|
||||
MODBUS_API int modbus_tcp_accept(modbus_t *ctx, int *s);
|
||||
|
||||
MODBUS_API modbus_t *modbus_new_tcp_pi(const char *node, const char *service);
|
||||
MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection);
|
||||
MODBUS_API int modbus_tcp_pi_accept(modbus_t *ctx, int *s);
|
||||
|
||||
MODBUS_END_DECLS
|
||||
|
||||
#endif /* MODBUS_TCP_H */
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_VERSION_H
|
||||
#define MODBUS_VERSION_H
|
||||
|
||||
/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */
|
||||
#define LIBMODBUS_VERSION_MAJOR (3)
|
||||
|
||||
/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */
|
||||
#define LIBMODBUS_VERSION_MINOR (1)
|
||||
|
||||
/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */
|
||||
#define LIBMODBUS_VERSION_MICRO (10)
|
||||
|
||||
/* The full version, like 1.2.3 */
|
||||
#define LIBMODBUS_VERSION 3.1.10
|
||||
|
||||
/* The full version, in string form (suited for string concatenation)
|
||||
*/
|
||||
#define LIBMODBUS_VERSION_STRING "3.1.10"
|
||||
|
||||
/* Numerically encoded version, eg. v1.2.3 is 0x010203 */
|
||||
#define LIBMODBUS_VERSION_HEX \
|
||||
((LIBMODBUS_VERSION_MAJOR << 16) | (LIBMODBUS_VERSION_MINOR << 8) | \
|
||||
(LIBMODBUS_VERSION_MICRO << 0))
|
||||
|
||||
/* Evaluates to True if the version is greater than @major, @minor and @micro
|
||||
*/
|
||||
#define LIBMODBUS_VERSION_CHECK(major, minor, micro) \
|
||||
(LIBMODBUS_VERSION_MAJOR > (major) || \
|
||||
(LIBMODBUS_VERSION_MAJOR == (major) && LIBMODBUS_VERSION_MINOR > (minor)) || \
|
||||
(LIBMODBUS_VERSION_MAJOR == (major) && LIBMODBUS_VERSION_MINOR == (minor) && \
|
||||
LIBMODBUS_VERSION_MICRO >= (micro)))
|
||||
|
||||
#endif /* MODBUS_VERSION_H */
|
||||
|
|
@ -1,329 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#ifndef MODBUS_H
|
||||
#define MODBUS_H
|
||||
|
||||
// clang-format off
|
||||
/* Add this for macros that defined unix flavor */
|
||||
#if (defined(__unix__) || defined(unix)) && !defined(USG)
|
||||
# include <sys/param.h>
|
||||
#endif
|
||||
|
||||
#ifndef _MSC_VER
|
||||
# include <stdint.h>
|
||||
#else
|
||||
# include "stdint.h"
|
||||
#endif
|
||||
|
||||
#include "modbus-version.h"
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# if defined(DLLBUILD)
|
||||
/* define DLLBUILD when building the DLL */
|
||||
# define MODBUS_API __declspec(dllexport)
|
||||
# else
|
||||
# define MODBUS_API __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define MODBUS_API
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
# define MODBUS_BEGIN_DECLS extern "C" {
|
||||
# define MODBUS_END_DECLS }
|
||||
#else
|
||||
# define MODBUS_BEGIN_DECLS
|
||||
# define MODBUS_END_DECLS
|
||||
#endif
|
||||
// clang-format on
|
||||
|
||||
MODBUS_BEGIN_DECLS
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#endif
|
||||
|
||||
#ifndef OFF
|
||||
#define OFF 0
|
||||
#endif
|
||||
|
||||
#ifndef ON
|
||||
#define ON 1
|
||||
#endif
|
||||
|
||||
/* Modbus function codes */
|
||||
#define MODBUS_FC_READ_COILS 0x01
|
||||
#define MODBUS_FC_READ_DISCRETE_INPUTS 0x02
|
||||
#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03
|
||||
#define MODBUS_FC_READ_INPUT_REGISTERS 0x04
|
||||
#define MODBUS_FC_WRITE_SINGLE_COIL 0x05
|
||||
#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
|
||||
#define MODBUS_FC_READ_EXCEPTION_STATUS 0x07
|
||||
#define MODBUS_FC_WRITE_MULTIPLE_COILS 0x0F
|
||||
#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
|
||||
#define MODBUS_FC_REPORT_SLAVE_ID 0x11
|
||||
#define MODBUS_FC_MASK_WRITE_REGISTER 0x16
|
||||
#define MODBUS_FC_WRITE_AND_READ_REGISTERS 0x17
|
||||
|
||||
#define MODBUS_BROADCAST_ADDRESS 0
|
||||
|
||||
/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
|
||||
* Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0)
|
||||
* (chapter 6 section 11 page 29)
|
||||
* Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0)
|
||||
*/
|
||||
#define MODBUS_MAX_READ_BITS 2000
|
||||
#define MODBUS_MAX_WRITE_BITS 1968
|
||||
|
||||
/* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
|
||||
* Quantity of Registers to read (2 bytes): 1 to 125 (0x7D)
|
||||
* (chapter 6 section 12 page 31)
|
||||
* Quantity of Registers to write (2 bytes) 1 to 123 (0x7B)
|
||||
* (chapter 6 section 17 page 38)
|
||||
* Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79)
|
||||
*/
|
||||
#define MODBUS_MAX_READ_REGISTERS 125
|
||||
#define MODBUS_MAX_WRITE_REGISTERS 123
|
||||
#define MODBUS_MAX_WR_WRITE_REGISTERS 121
|
||||
#define MODBUS_MAX_WR_READ_REGISTERS 125
|
||||
|
||||
/* The size of the MODBUS PDU is limited by the size constraint inherited from
|
||||
* the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256
|
||||
* bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server
|
||||
* address (1 byte) - CRC (2 bytes) = 253 bytes.
|
||||
*/
|
||||
#define MODBUS_MAX_PDU_LENGTH 253
|
||||
|
||||
/* Consequently:
|
||||
* - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256
|
||||
* bytes.
|
||||
* - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes.
|
||||
* so the maximum of both backend in 260 bytes. This size can used to allocate
|
||||
* an array of bytes to store responses and it will be compatible with the two
|
||||
* backends.
|
||||
*/
|
||||
#define MODBUS_MAX_ADU_LENGTH 260
|
||||
|
||||
/* Random number to avoid errno conflicts */
|
||||
#define MODBUS_ENOBASE 112345678
|
||||
|
||||
/* Protocol exceptions */
|
||||
enum {
|
||||
MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01,
|
||||
MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
|
||||
MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
|
||||
MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE,
|
||||
MODBUS_EXCEPTION_ACKNOWLEDGE,
|
||||
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY,
|
||||
MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE,
|
||||
MODBUS_EXCEPTION_MEMORY_PARITY,
|
||||
MODBUS_EXCEPTION_NOT_DEFINED,
|
||||
MODBUS_EXCEPTION_GATEWAY_PATH,
|
||||
MODBUS_EXCEPTION_GATEWAY_TARGET,
|
||||
MODBUS_EXCEPTION_MAX
|
||||
};
|
||||
|
||||
#define EMBXILFUN (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION)
|
||||
#define EMBXILADD (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS)
|
||||
#define EMBXILVAL (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE)
|
||||
#define EMBXSFAIL (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE)
|
||||
#define EMBXACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE)
|
||||
#define EMBXSBUSY (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY)
|
||||
#define EMBXNACK (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE)
|
||||
#define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY)
|
||||
#define EMBXGPATH (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH)
|
||||
#define EMBXGTAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET)
|
||||
|
||||
/* Native libmodbus error codes */
|
||||
#define EMBBADCRC (EMBXGTAR + 1)
|
||||
#define EMBBADDATA (EMBXGTAR + 2)
|
||||
#define EMBBADEXC (EMBXGTAR + 3)
|
||||
#define EMBUNKEXC (EMBXGTAR + 4)
|
||||
#define EMBMDATA (EMBXGTAR + 5)
|
||||
#define EMBBADSLAVE (EMBXGTAR + 6)
|
||||
|
||||
extern const unsigned int libmodbus_version_major;
|
||||
extern const unsigned int libmodbus_version_minor;
|
||||
extern const unsigned int libmodbus_version_micro;
|
||||
|
||||
typedef struct _modbus modbus_t;
|
||||
|
||||
typedef struct _modbus_mapping_t {
|
||||
int nb_bits;
|
||||
int start_bits;
|
||||
int nb_input_bits;
|
||||
int start_input_bits;
|
||||
int nb_input_registers;
|
||||
int start_input_registers;
|
||||
int nb_registers;
|
||||
int start_registers;
|
||||
uint8_t *tab_bits;
|
||||
uint8_t *tab_input_bits;
|
||||
uint16_t *tab_input_registers;
|
||||
uint16_t *tab_registers;
|
||||
} modbus_mapping_t;
|
||||
|
||||
typedef enum {
|
||||
MODBUS_ERROR_RECOVERY_NONE = 0,
|
||||
MODBUS_ERROR_RECOVERY_LINK = (1 << 1),
|
||||
MODBUS_ERROR_RECOVERY_PROTOCOL = (1 << 2)
|
||||
} modbus_error_recovery_mode;
|
||||
|
||||
typedef enum {
|
||||
MODBUS_QUIRK_NONE = 0,
|
||||
MODBUS_QUIRK_MAX_SLAVE = (1 << 1),
|
||||
MODBUS_QUIRK_REPLY_TO_BROADCAST = (1 << 2),
|
||||
MODBUS_QUIRK_ALL = 0xFF
|
||||
} modbus_quirks;
|
||||
|
||||
MODBUS_API int modbus_set_slave(modbus_t *ctx, int slave);
|
||||
MODBUS_API int modbus_get_slave(modbus_t *ctx);
|
||||
MODBUS_API int modbus_set_error_recovery(modbus_t *ctx,
|
||||
modbus_error_recovery_mode error_recovery);
|
||||
MODBUS_API int modbus_set_socket(modbus_t *ctx, int s);
|
||||
MODBUS_API int modbus_get_socket(modbus_t *ctx);
|
||||
|
||||
MODBUS_API int
|
||||
modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
|
||||
MODBUS_API int
|
||||
modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
|
||||
|
||||
MODBUS_API int
|
||||
modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
|
||||
MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
|
||||
|
||||
MODBUS_API int
|
||||
modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
|
||||
MODBUS_API int
|
||||
modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
|
||||
|
||||
MODBUS_API int modbus_get_header_length(modbus_t *ctx);
|
||||
|
||||
MODBUS_API int modbus_connect(modbus_t *ctx);
|
||||
MODBUS_API void modbus_close(modbus_t *ctx);
|
||||
|
||||
MODBUS_API void modbus_free(modbus_t *ctx);
|
||||
|
||||
MODBUS_API int modbus_flush(modbus_t *ctx);
|
||||
MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag);
|
||||
|
||||
MODBUS_API const char *modbus_strerror(int errnum);
|
||||
|
||||
MODBUS_API int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
|
||||
MODBUS_API int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
|
||||
MODBUS_API int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
|
||||
MODBUS_API int
|
||||
modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
|
||||
MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status);
|
||||
MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, const uint16_t value);
|
||||
MODBUS_API int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data);
|
||||
MODBUS_API int
|
||||
modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data);
|
||||
MODBUS_API int
|
||||
modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask);
|
||||
MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx,
|
||||
int write_addr,
|
||||
int write_nb,
|
||||
const uint16_t *src,
|
||||
int read_addr,
|
||||
int read_nb,
|
||||
uint16_t *dest);
|
||||
MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest);
|
||||
|
||||
MODBUS_API modbus_mapping_t *
|
||||
modbus_mapping_new_start_address(unsigned int start_bits,
|
||||
unsigned int nb_bits,
|
||||
unsigned int start_input_bits,
|
||||
unsigned int nb_input_bits,
|
||||
unsigned int start_registers,
|
||||
unsigned int nb_registers,
|
||||
unsigned int start_input_registers,
|
||||
unsigned int nb_input_registers);
|
||||
|
||||
MODBUS_API modbus_mapping_t *modbus_mapping_new(int nb_bits,
|
||||
int nb_input_bits,
|
||||
int nb_registers,
|
||||
int nb_input_registers);
|
||||
MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping);
|
||||
|
||||
MODBUS_API int
|
||||
modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length);
|
||||
|
||||
MODBUS_API int modbus_receive(modbus_t *ctx, uint8_t *req);
|
||||
|
||||
MODBUS_API int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp);
|
||||
|
||||
MODBUS_API int modbus_reply(modbus_t *ctx,
|
||||
const uint8_t *req,
|
||||
int req_length,
|
||||
modbus_mapping_t *mb_mapping);
|
||||
MODBUS_API int
|
||||
modbus_reply_exception(modbus_t *ctx, const uint8_t *req, unsigned int exception_code);
|
||||
MODBUS_API int modbus_enable_quirks(modbus_t *ctx, unsigned int quirks_mask);
|
||||
MODBUS_API int modbus_disable_quirks(modbus_t *ctx, unsigned int quirks_mask);
|
||||
|
||||
/**
|
||||
* 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) \
|
||||
(((int32_t) tab_int16[(index)] << 16) | (int32_t) tab_int16[(index) + 1])
|
||||
#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) \
|
||||
(((int16_t) tab_int8[(index)] << 8) | (int16_t) tab_int8[(index) + 1])
|
||||
#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \
|
||||
do { \
|
||||
((int8_t *) (tab_int8))[(index)] = (int8_t) ((value) >> 8); \
|
||||
((int8_t *) (tab_int8))[(index) + 1] = (int8_t) (value); \
|
||||
} while (0)
|
||||
#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \
|
||||
do { \
|
||||
((int16_t *) (tab_int16))[(index)] = (int16_t) ((value) >> 16); \
|
||||
((int16_t *) (tab_int16))[(index) + 1] = (int16_t) (value); \
|
||||
} while (0)
|
||||
#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \
|
||||
do { \
|
||||
((int16_t *) (tab_int16))[(index)] = (int16_t) ((value) >> 48); \
|
||||
((int16_t *) (tab_int16))[(index) + 1] = (int16_t) ((value) >> 32); \
|
||||
((int16_t *) (tab_int16))[(index) + 2] = (int16_t) ((value) >> 16); \
|
||||
((int16_t *) (tab_int16))[(index) + 3] = (int16_t) (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-rtu.h"
|
||||
#include "modbus-tcp.h"
|
||||
|
||||
MODBUS_END_DECLS
|
||||
|
||||
#endif /* MODBUS_H */
|
||||
|
|
@ -1,292 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
// clang-format off
|
||||
#ifndef _MSC_VER
|
||||
# include <stdint.h>
|
||||
#else
|
||||
# include "stdint.h"
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#if defined(_WIN32)
|
||||
# include <winsock2.h>
|
||||
#else
|
||||
# include <arpa/inet.h>
|
||||
#endif
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include "modbus.h"
|
||||
|
||||
#if defined(HAVE_BYTESWAP_H)
|
||||
# include <byteswap.h>
|
||||
#endif
|
||||
|
||||
#if defined(__APPLE__)
|
||||
# include <libkern/OSByteOrder.h>
|
||||
# define bswap_16 OSSwapInt16
|
||||
# define bswap_32 OSSwapInt32
|
||||
# define bswap_64 OSSwapInt64
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__)
|
||||
# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10)
|
||||
# if GCC_VERSION >= 430
|
||||
// Since GCC >= 4.30, GCC provides __builtin_bswapXX() alternatives so we switch to them
|
||||
# undef bswap_32
|
||||
# define bswap_32 __builtin_bswap32
|
||||
# endif
|
||||
# if GCC_VERSION >= 480
|
||||
# undef bswap_16
|
||||
# define bswap_16 __builtin_bswap16
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
|
||||
# define bswap_32 _byteswap_ulong
|
||||
# define bswap_16 _byteswap_ushort
|
||||
#endif
|
||||
|
||||
#if !defined(bswap_16)
|
||||
# warning "Fallback on C functions for bswap_16"
|
||||
static inline uint16_t bswap_16(uint16_t x)
|
||||
{
|
||||
return (x >> 8) | (x << 8);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(bswap_32)
|
||||
# warning "Fallback on C functions for bswap_32"
|
||||
static inline uint32_t bswap_32(uint32_t x)
|
||||
{
|
||||
return (bswap_16(x & 0xffff) << 16) | (bswap_16(x >> 16));
|
||||
}
|
||||
#endif
|
||||
// clang-format on
|
||||
|
||||
/* 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;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
a = (src[0] >> 8) & 0xFF;
|
||||
b = (src[0] >> 0) & 0xFF;
|
||||
c = (src[1] >> 8) & 0xFF;
|
||||
d = (src[1] >> 0) & 0xFF;
|
||||
|
||||
i = (a << 24) | (b << 16) | (c << 8) | (d << 0);
|
||||
memcpy(&f, &i, 4);
|
||||
|
||||
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;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
a = (src[0] >> 8) & 0xFF;
|
||||
b = (src[0] >> 0) & 0xFF;
|
||||
c = (src[1] >> 8) & 0xFF;
|
||||
d = (src[1] >> 0) & 0xFF;
|
||||
|
||||
i = (d << 24) | (c << 16) | (b << 8) | (a << 0);
|
||||
memcpy(&f, &i, 4);
|
||||
|
||||
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;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
a = (src[0] >> 8) & 0xFF;
|
||||
b = (src[0] >> 0) & 0xFF;
|
||||
c = (src[1] >> 8) & 0xFF;
|
||||
d = (src[1] >> 0) & 0xFF;
|
||||
|
||||
i = (b << 24) | (a << 16) | (d << 8) | (c << 0);
|
||||
memcpy(&f, &i, 4);
|
||||
|
||||
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;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
a = (src[0] >> 8) & 0xFF;
|
||||
b = (src[0] >> 0) & 0xFF;
|
||||
c = (src[1] >> 8) & 0xFF;
|
||||
d = (src[1] >> 0) & 0xFF;
|
||||
|
||||
i = (c << 24) | (d << 16) | (a << 8) | (b << 0);
|
||||
memcpy(&f, &i, 4);
|
||||
|
||||
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;
|
||||
uint8_t *out = (uint8_t *) dest;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
memcpy(&i, &f, sizeof(uint32_t));
|
||||
a = (i >> 24) & 0xFF;
|
||||
b = (i >> 16) & 0xFF;
|
||||
c = (i >> 8) & 0xFF;
|
||||
d = (i >> 0) & 0xFF;
|
||||
|
||||
out[0] = a;
|
||||
out[1] = b;
|
||||
out[2] = c;
|
||||
out[3] = d;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
uint8_t *out = (uint8_t *) dest;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
memcpy(&i, &f, sizeof(uint32_t));
|
||||
a = (i >> 24) & 0xFF;
|
||||
b = (i >> 16) & 0xFF;
|
||||
c = (i >> 8) & 0xFF;
|
||||
d = (i >> 0) & 0xFF;
|
||||
|
||||
out[0] = d;
|
||||
out[1] = c;
|
||||
out[2] = b;
|
||||
out[3] = a;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
uint8_t *out = (uint8_t *) dest;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
memcpy(&i, &f, sizeof(uint32_t));
|
||||
a = (i >> 24) & 0xFF;
|
||||
b = (i >> 16) & 0xFF;
|
||||
c = (i >> 8) & 0xFF;
|
||||
d = (i >> 0) & 0xFF;
|
||||
|
||||
out[0] = b;
|
||||
out[1] = a;
|
||||
out[2] = d;
|
||||
out[3] = c;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
uint8_t *out = (uint8_t *) dest;
|
||||
uint8_t a, b, c, d;
|
||||
|
||||
memcpy(&i, &f, sizeof(uint32_t));
|
||||
a = (i >> 24) & 0xFF;
|
||||
b = (i >> 16) & 0xFF;
|
||||
c = (i >> 8) & 0xFF;
|
||||
d = (i >> 0) & 0xFF;
|
||||
|
||||
out[0] = c;
|
||||
out[1] = d;
|
||||
out[2] = a;
|
||||
out[3] = b;
|
||||
}
|
||||
|
||||
/* 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);
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,974 +0,0 @@
|
|||
/*
|
||||
* Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||||
*/
|
||||
|
||||
// clang-format off
|
||||
#if defined(_WIN32)
|
||||
# define OS_WIN32
|
||||
/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later.
|
||||
* minwg32 headers check WINVER before allowing the use of these */
|
||||
# ifndef WINVER
|
||||
# define WINVER 0x0501
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#ifndef _MSC_VER
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <signal.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#if defined(_WIN32)
|
||||
/* Already set in modbus-tcp.h but it seems order matters in VS2005 */
|
||||
# include <winsock2.h>
|
||||
# include <ws2tcpip.h>
|
||||
# define SHUT_RDWR 2
|
||||
# define close closesocket
|
||||
# define strdup _strdup
|
||||
#else
|
||||
# include <sys/socket.h>
|
||||
# include <sys/ioctl.h>
|
||||
|
||||
#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ < 5)
|
||||
# define OS_BSD
|
||||
# include <netinet/in_systm.h>
|
||||
#endif
|
||||
|
||||
# include <netinet/in.h>
|
||||
# include <netinet/ip.h>
|
||||
# include <netinet/tcp.h>
|
||||
# include <arpa/inet.h>
|
||||
# include <netdb.h>
|
||||
#endif
|
||||
|
||||
#if !defined(MSG_NOSIGNAL)
|
||||
#define MSG_NOSIGNAL 0
|
||||
#endif
|
||||
|
||||
#if defined(_AIX) && !defined(MSG_DONTWAIT)
|
||||
#define MSG_DONTWAIT MSG_NONBLOCK
|
||||
#endif
|
||||
// clang-format on
|
||||
|
||||
#include "modbus-private.h"
|
||||
|
||||
#include "modbus-tcp-private.h"
|
||||
#include "modbus-tcp.h"
|
||||
|
||||
#ifdef OS_WIN32
|
||||
static int _modbus_tcp_init_win32(void)
|
||||
{
|
||||
/* Initialise Windows Socket API */
|
||||
WSADATA wsaData;
|
||||
|
||||
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
|
||||
fprintf(stderr,
|
||||
"WSAStartup() returned error code %d\n",
|
||||
(unsigned int) GetLastError());
|
||||
errno = EIO;
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int _modbus_set_slave(modbus_t *ctx, int slave)
|
||||
{
|
||||
int max_slave = (ctx->quirks & MODBUS_QUIRK_MAX_SLAVE) ? 255 : 247;
|
||||
|
||||
/* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */
|
||||
if (slave >= 0 && slave <= max_slave) {
|
||||
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)
|
||||
{
|
||||
/* Subtract 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)
|
||||
{
|
||||
unsigned int protocol_id;
|
||||
/* 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 */
|
||||
protocol_id = (rsp[2] << 8) + rsp[3];
|
||||
if (protocol_id != 0x0) {
|
||||
if (ctx->debug) {
|
||||
fprintf(stderr, "Invalid protocol ID received 0x%X (not 0x0)\n", protocol_id);
|
||||
}
|
||||
errno = EMBBADDATA;
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _modbus_tcp_set_ipv4_options(int s)
|
||||
{
|
||||
int rc;
|
||||
int option;
|
||||
|
||||
/* Set the TCP no delay flag */
|
||||
/* SOL_TCP = IPPROTO_TCP */
|
||||
option = 1;
|
||||
rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const void *) &option, sizeof(int));
|
||||
if (rc == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* If the OS does not offer SOCK_NONBLOCK, fall back to setting FIONBIO to
|
||||
* make sockets non-blocking */
|
||||
/* Do not care about the return value, this is optional */
|
||||
#if !defined(SOCK_NONBLOCK) && defined(FIONBIO)
|
||||
#ifdef OS_WIN32
|
||||
{
|
||||
/* Setting FIONBIO expects an unsigned long according to MSDN */
|
||||
u_long loption = 1;
|
||||
ioctlsocket(s, FIONBIO, &loption);
|
||||
}
|
||||
#else
|
||||
option = 1;
|
||||
ioctl(s, FIONBIO, &option);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef OS_WIN32
|
||||
/**
|
||||
* Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's
|
||||
* necessary to workaround that problem.
|
||||
**/
|
||||
/* Set the IP low delay option */
|
||||
option = IPTOS_LOWDELAY;
|
||||
rc = setsockopt(s, IPPROTO_IP, IP_TOS, (const void *) &option, sizeof(int));
|
||||
if (rc == -1) {
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _connect(int sockfd,
|
||||
const struct sockaddr *addr,
|
||||
socklen_t addrlen,
|
||||
const struct timeval *ro_tv)
|
||||
{
|
||||
int rc = connect(sockfd, addr, addrlen);
|
||||
|
||||
#ifdef OS_WIN32
|
||||
int wsaError = 0;
|
||||
if (rc == -1) {
|
||||
wsaError = WSAGetLastError();
|
||||
}
|
||||
|
||||
if (wsaError == WSAEWOULDBLOCK || wsaError == WSAEINPROGRESS) {
|
||||
#else
|
||||
if (rc == -1 && errno == EINPROGRESS) {
|
||||
#endif
|
||||
fd_set wset;
|
||||
int optval;
|
||||
socklen_t optlen = sizeof(optval);
|
||||
struct timeval tv = *ro_tv;
|
||||
|
||||
/* Wait to be available in writing */
|
||||
FD_ZERO(&wset);
|
||||
FD_SET(sockfd, &wset);
|
||||
rc = select(sockfd + 1, NULL, &wset, NULL, &tv);
|
||||
if (rc <= 0) {
|
||||
/* Timeout or fail */
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* The connection is established if SO_ERROR and optval are set to 0 */
|
||||
rc = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
|
||||
if (rc == 0 && optval == 0) {
|
||||
return 0;
|
||||
} else {
|
||||
errno = ECONNREFUSED;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Establishes a modbus TCP connection with a Modbus server. */
|
||||
static int _modbus_tcp_connect(modbus_t *ctx)
|
||||
{
|
||||
int rc;
|
||||
/* Specialized version of sockaddr for Internet socket address (same size) */
|
||||
struct sockaddr_in addr;
|
||||
modbus_tcp_t *ctx_tcp = ctx->backend_data;
|
||||
int flags = SOCK_STREAM;
|
||||
|
||||
#ifdef OS_WIN32
|
||||
if (_modbus_tcp_init_win32() == -1) {
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SOCK_CLOEXEC
|
||||
flags |= SOCK_CLOEXEC;
|
||||
#endif
|
||||
|
||||
#ifdef SOCK_NONBLOCK
|
||||
flags |= SOCK_NONBLOCK;
|
||||
#endif
|
||||
|
||||
ctx->s = socket(PF_INET, flags, 0);
|
||||
if (ctx->s < 0) {
|
||||
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);
|
||||
rc = inet_pton(addr.sin_family, ctx_tcp->ip, &(addr.sin_addr));
|
||||
if (rc <= 0) {
|
||||
if (ctx->debug) {
|
||||
fprintf(stderr, "Invalid IP address: %s\n", ctx_tcp->ip);
|
||||
}
|
||||
close(ctx->s);
|
||||
ctx->s = -1;
|
||||
return -1;
|
||||
}
|
||||
|
||||
rc =
|
||||
_connect(ctx->s, (struct sockaddr *) &addr, sizeof(addr), &ctx->response_timeout);
|
||||
if (rc == -1) {
|
||||
close(ctx->s);
|
||||
ctx->s = -1;
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Establishes a modbus TCP PI connection with a Modbus server. */
|
||||
static int _modbus_tcp_pi_connect(modbus_t *ctx)
|
||||
{
|
||||
int rc;
|
||||
struct addrinfo *ai_list;
|
||||
struct addrinfo *ai_ptr;
|
||||
struct addrinfo ai_hints;
|
||||
modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data;
|
||||
|
||||
#ifdef OS_WIN32
|
||||
if (_modbus_tcp_init_win32() == -1) {
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
memset(&ai_hints, 0, sizeof(ai_hints));
|
||||
#ifdef AI_ADDRCONFIG
|
||||
ai_hints.ai_flags |= AI_ADDRCONFIG;
|
||||
#endif
|
||||
ai_hints.ai_family = AF_UNSPEC;
|
||||
ai_hints.ai_socktype = SOCK_STREAM;
|
||||
ai_hints.ai_addr = NULL;
|
||||
ai_hints.ai_canonname = NULL;
|
||||
ai_hints.ai_next = NULL;
|
||||
|
||||
ai_list = NULL;
|
||||
rc = getaddrinfo(ctx_tcp_pi->node, ctx_tcp_pi->service, &ai_hints, &ai_list);
|
||||
if (rc != 0) {
|
||||
if (ctx->debug) {
|
||||
fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
|
||||
}
|
||||
errno = ECONNREFUSED;
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
|
||||
int flags = ai_ptr->ai_socktype;
|
||||
int s;
|
||||
|
||||
#ifdef SOCK_CLOEXEC
|
||||
flags |= SOCK_CLOEXEC;
|
||||
#endif
|
||||
|
||||
#ifdef SOCK_NONBLOCK
|
||||
flags |= SOCK_NONBLOCK;
|
||||
#endif
|
||||
|
||||
s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol);
|
||||
if (s < 0)
|
||||
continue;
|
||||
|
||||
if (ai_ptr->ai_family == AF_INET)
|
||||
_modbus_tcp_set_ipv4_options(s);
|
||||
|
||||
if (ctx->debug) {
|
||||
printf("Connecting to [%s]:%s\n", ctx_tcp_pi->node, ctx_tcp_pi->service);
|
||||
}
|
||||
|
||||
rc = _connect(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen, &ctx->response_timeout);
|
||||
if (rc == -1) {
|
||||
close(s);
|
||||
continue;
|
||||
}
|
||||
|
||||
ctx->s = s;
|
||||
break;
|
||||
}
|
||||
|
||||
freeaddrinfo(ai_list);
|
||||
|
||||
if (ctx->s < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static unsigned int _modbus_tcp_is_connected(modbus_t *ctx)
|
||||
{
|
||||
return ctx->s >= 0;
|
||||
}
|
||||
|
||||
/* Closes the network connection and socket in TCP mode */
|
||||
static void _modbus_tcp_close(modbus_t *ctx)
|
||||
{
|
||||
if (ctx->s >= 0) {
|
||||
shutdown(ctx->s, SHUT_RDWR);
|
||||
close(ctx->s);
|
||||
ctx->s = -1;
|
||||
}
|
||||
}
|
||||
|
||||
static int _modbus_tcp_flush(modbus_t *ctx)
|
||||
{
|
||||
int rc;
|
||||
int rc_sum = 0;
|
||||
|
||||
do {
|
||||
/* Extract the garbage from the socket */
|
||||
char devnull[MODBUS_TCP_MAX_ADU_LENGTH];
|
||||
#ifndef OS_WIN32
|
||||
rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT);
|
||||
#else
|
||||
/* On Win32, it's a bit more complicated to not wait */
|
||||
fd_set rset;
|
||||
struct timeval tv;
|
||||
|
||||
tv.tv_sec = 0;
|
||||
tv.tv_usec = 0;
|
||||
FD_ZERO(&rset);
|
||||
FD_SET(ctx->s, &rset);
|
||||
rc = select(ctx->s + 1, &rset, NULL, NULL, &tv);
|
||||
if (rc == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (rc == 1) {
|
||||
/* There is data to flush */
|
||||
rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, 0);
|
||||
}
|
||||
#endif
|
||||
if (rc > 0) {
|
||||
rc_sum += rc;
|
||||
}
|
||||
} while (rc == MODBUS_TCP_MAX_ADU_LENGTH);
|
||||
|
||||
return rc_sum;
|
||||
}
|
||||
|
||||
/* Listens for any request from one or many modbus masters in TCP */
|
||||
int modbus_tcp_listen(modbus_t *ctx, int nb_connection)
|
||||
{
|
||||
int new_s;
|
||||
int enable;
|
||||
int flags;
|
||||
struct sockaddr_in addr;
|
||||
modbus_tcp_t *ctx_tcp;
|
||||
int rc;
|
||||
|
||||
if (ctx == NULL) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
ctx_tcp = ctx->backend_data;
|
||||
|
||||
#ifdef OS_WIN32
|
||||
if (_modbus_tcp_init_win32() == -1) {
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
flags = SOCK_STREAM;
|
||||
|
||||
#ifdef SOCK_CLOEXEC
|
||||
flags |= SOCK_CLOEXEC;
|
||||
#endif
|
||||
|
||||
new_s = socket(PF_INET, flags, IPPROTO_TCP);
|
||||
if (new_s == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
enable = 1;
|
||||
if (setsockopt(new_s, SOL_SOCKET, SO_REUSEADDR, (char *) &enable, sizeof(enable)) ==
|
||||
-1) {
|
||||
close(new_s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
/* If the modbus port is < to 1024, we need the setuid root. */
|
||||
addr.sin_port = htons(ctx_tcp->port);
|
||||
if (ctx_tcp->ip[0] == '0') {
|
||||
/* Listen any addresses */
|
||||
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||
} else {
|
||||
/* Listen only specified IP address */
|
||||
rc = inet_pton(addr.sin_family, ctx_tcp->ip, &(addr.sin_addr));
|
||||
if (rc <= 0) {
|
||||
if (ctx->debug) {
|
||||
fprintf(stderr, "Invalid IP address: %s\n", ctx_tcp->ip);
|
||||
}
|
||||
close(new_s);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (bind(new_s, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
|
||||
close(new_s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (listen(new_s, nb_connection) == -1) {
|
||||
close(new_s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return new_s;
|
||||
}
|
||||
|
||||
int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection)
|
||||
{
|
||||
int rc;
|
||||
struct addrinfo *ai_list;
|
||||
struct addrinfo *ai_ptr;
|
||||
struct addrinfo ai_hints;
|
||||
const char *node;
|
||||
const char *service;
|
||||
int new_s;
|
||||
modbus_tcp_pi_t *ctx_tcp_pi;
|
||||
|
||||
if (ctx == NULL) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
ctx_tcp_pi = ctx->backend_data;
|
||||
|
||||
#ifdef OS_WIN32
|
||||
if (_modbus_tcp_init_win32() == -1) {
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ctx_tcp_pi->node[0] == 0) {
|
||||
node = NULL; /* == any */
|
||||
} else {
|
||||
node = ctx_tcp_pi->node;
|
||||
}
|
||||
|
||||
if (ctx_tcp_pi->service[0] == 0) {
|
||||
service = "502";
|
||||
} else {
|
||||
service = ctx_tcp_pi->service;
|
||||
}
|
||||
|
||||
memset(&ai_hints, 0, sizeof(ai_hints));
|
||||
/* If node is not NULL, than the AI_PASSIVE flag is ignored. */
|
||||
ai_hints.ai_flags |= AI_PASSIVE;
|
||||
#ifdef AI_ADDRCONFIG
|
||||
ai_hints.ai_flags |= AI_ADDRCONFIG;
|
||||
#endif
|
||||
ai_hints.ai_family = AF_UNSPEC;
|
||||
ai_hints.ai_socktype = SOCK_STREAM;
|
||||
ai_hints.ai_addr = NULL;
|
||||
ai_hints.ai_canonname = NULL;
|
||||
ai_hints.ai_next = NULL;
|
||||
|
||||
ai_list = NULL;
|
||||
rc = getaddrinfo(node, service, &ai_hints, &ai_list);
|
||||
if (rc != 0) {
|
||||
if (ctx->debug) {
|
||||
fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
|
||||
}
|
||||
errno = ECONNREFUSED;
|
||||
return -1;
|
||||
}
|
||||
|
||||
new_s = -1;
|
||||
for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
|
||||
int flags = ai_ptr->ai_socktype;
|
||||
int s;
|
||||
|
||||
#ifdef SOCK_CLOEXEC
|
||||
flags |= SOCK_CLOEXEC;
|
||||
#endif
|
||||
|
||||
s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol);
|
||||
if (s < 0) {
|
||||
if (ctx->debug) {
|
||||
perror("socket");
|
||||
}
|
||||
continue;
|
||||
} else {
|
||||
int enable = 1;
|
||||
rc =
|
||||
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void *) &enable, sizeof(enable));
|
||||
if (rc != 0) {
|
||||
close(s);
|
||||
if (ctx->debug) {
|
||||
perror("setsockopt");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
rc = bind(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
|
||||
if (rc != 0) {
|
||||
close(s);
|
||||
if (ctx->debug) {
|
||||
perror("bind");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
rc = listen(s, nb_connection);
|
||||
if (rc != 0) {
|
||||
close(s);
|
||||
if (ctx->debug) {
|
||||
perror("listen");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
new_s = s;
|
||||
break;
|
||||
}
|
||||
freeaddrinfo(ai_list);
|
||||
|
||||
if (new_s < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return new_s;
|
||||
}
|
||||
|
||||
int modbus_tcp_accept(modbus_t *ctx, int *s)
|
||||
{
|
||||
struct sockaddr_in addr;
|
||||
socklen_t addrlen;
|
||||
|
||||
if (ctx == NULL) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
addrlen = sizeof(addr);
|
||||
#ifdef HAVE_ACCEPT4
|
||||
/* Inherit socket flags and use accept4 call */
|
||||
ctx->s = accept4(*s, (struct sockaddr *) &addr, &addrlen, SOCK_CLOEXEC);
|
||||
#else
|
||||
ctx->s = accept(*s, (struct sockaddr *) &addr, &addrlen);
|
||||
#endif
|
||||
|
||||
if (ctx->s < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ctx->debug) {
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
if (inet_ntop(AF_INET, &(addr.sin_addr), buf, INET_ADDRSTRLEN) == NULL) {
|
||||
fprintf(stderr, "Client connection accepted from unparsable IP.\n");
|
||||
} else {
|
||||
printf("Client connection accepted from %s.\n", buf);
|
||||
}
|
||||
}
|
||||
|
||||
return ctx->s;
|
||||
}
|
||||
|
||||
int modbus_tcp_pi_accept(modbus_t *ctx, int *s)
|
||||
{
|
||||
struct sockaddr_in6 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 < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ctx->debug) {
|
||||
char buf[INET6_ADDRSTRLEN];
|
||||
if (inet_ntop(AF_INET6, &(addr.sin6_addr), buf, INET6_ADDRSTRLEN) == NULL) {
|
||||
fprintf(stderr, "Client connection accepted from unparsable IP.\n");
|
||||
} else {
|
||||
printf("Client connection accepted from %s.\n", buf);
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
if (ctx->backend_data) {
|
||||
free(ctx->backend_data);
|
||||
}
|
||||
free(ctx);
|
||||
}
|
||||
|
||||
static void _modbus_tcp_pi_free(modbus_t *ctx)
|
||||
{
|
||||
if (ctx->backend_data) {
|
||||
modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data;
|
||||
free(ctx_tcp_pi->node);
|
||||
free(ctx_tcp_pi->service);
|
||||
free(ctx->backend_data);
|
||||
}
|
||||
|
||||
free(ctx);
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
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_is_connected,
|
||||
_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_is_connected,
|
||||
_modbus_tcp_close,
|
||||
_modbus_tcp_flush,
|
||||
_modbus_tcp_select,
|
||||
_modbus_tcp_pi_free
|
||||
};
|
||||
|
||||
// clang-format on
|
||||
|
||||
modbus_t *modbus_new_tcp(const char *ip, int port)
|
||||
{
|
||||
modbus_t *ctx;
|
||||
modbus_tcp_t *ctx_tcp;
|
||||
size_t dest_size;
|
||||
size_t ret_size;
|
||||
|
||||
#if defined(OS_BSD)
|
||||
/* MSG_NOSIGNAL is unsupported on *BSD so we install an ignore
|
||||
handler for SIGPIPE. */
|
||||
struct sigaction sa;
|
||||
|
||||
sa.sa_handler = SIG_IGN;
|
||||
if (sigaction(SIGPIPE, &sa, NULL) < 0) {
|
||||
/* The debug flag can't be set here... */
|
||||
fprintf(stderr, "Could not install SIGPIPE handler.\n");
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
ctx = (modbus_t *) malloc(sizeof(modbus_t));
|
||||
if (ctx == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
_modbus_init_common(ctx);
|
||||
|
||||
/* Could be changed after to reach a remote serial Modbus device */
|
||||
ctx->slave = MODBUS_TCP_SLAVE;
|
||||
|
||||
ctx->backend = &_modbus_tcp_backend;
|
||||
|
||||
ctx->backend_data = (modbus_tcp_t *) malloc(sizeof(modbus_tcp_t));
|
||||
if (ctx->backend_data == NULL) {
|
||||
modbus_free(ctx);
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
ctx_tcp = (modbus_tcp_t *) ctx->backend_data;
|
||||
|
||||
if (ip != NULL) {
|
||||
dest_size = sizeof(char) * 16;
|
||||
ret_size = strlcpy(ctx_tcp->ip, ip, dest_size);
|
||||
if (ret_size == 0) {
|
||||
fprintf(stderr, "The IP string is empty\n");
|
||||
modbus_free(ctx);
|
||||
errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (ret_size >= dest_size) {
|
||||
fprintf(stderr, "The IP string has been truncated\n");
|
||||
modbus_free(ctx);
|
||||
errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
ctx_tcp->ip[0] = '0';
|
||||
}
|
||||
ctx_tcp->port = port;
|
||||
ctx_tcp->t_id = 0;
|
||||
|
||||
return ctx;
|
||||
}
|
||||
|
||||
modbus_t *modbus_new_tcp_pi(const char *node, const char *service)
|
||||
{
|
||||
modbus_t *ctx;
|
||||
modbus_tcp_pi_t *ctx_tcp_pi;
|
||||
|
||||
ctx = (modbus_t *) malloc(sizeof(modbus_t));
|
||||
if (ctx == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
_modbus_init_common(ctx);
|
||||
|
||||
/* Could be changed after to reach a remote serial Modbus device */
|
||||
ctx->slave = MODBUS_TCP_SLAVE;
|
||||
|
||||
ctx->backend = &_modbus_tcp_pi_backend;
|
||||
|
||||
ctx->backend_data = (modbus_tcp_pi_t *) malloc(sizeof(modbus_tcp_pi_t));
|
||||
if (ctx->backend_data == NULL) {
|
||||
modbus_free(ctx);
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
ctx_tcp_pi = (modbus_tcp_pi_t *) ctx->backend_data;
|
||||
ctx_tcp_pi->node = NULL;
|
||||
ctx_tcp_pi->service = NULL;
|
||||
|
||||
if (node != NULL) {
|
||||
ctx_tcp_pi->node = strdup(node);
|
||||
} else {
|
||||
/* The node argument can be empty to indicate any hosts */
|
||||
ctx_tcp_pi->node = strdup("");
|
||||
}
|
||||
|
||||
if (ctx_tcp_pi->node == NULL) {
|
||||
modbus_free(ctx);
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (service != NULL && service[0] != '\0') {
|
||||
ctx_tcp_pi->service = strdup(service);
|
||||
} else {
|
||||
/* Default Modbus port number */
|
||||
ctx_tcp_pi->service = strdup("502");
|
||||
}
|
||||
|
||||
if (ctx_tcp_pi->service == NULL) {
|
||||
modbus_free(ctx);
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ctx_tcp_pi->t_id = 0;
|
||||
|
||||
return ctx;
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
100
src/main.cpp
100
src/main.cpp
|
|
@ -1,11 +1,11 @@
|
|||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "CLI11.hpp"
|
||||
#include "modbus.h"
|
||||
|
|
@ -19,60 +19,38 @@ int main(int argc, char **argv) {
|
|||
signal(SIGTERM, sigHandler);
|
||||
signal(SIGABRT, sigHandler);
|
||||
|
||||
std::string version{"v2.5"};
|
||||
std::string version{"v1.0cf"};
|
||||
std::cout << version << std::endl;
|
||||
|
||||
CLI::App hoymilesClient{"Client for DTU-Pro/DTU-ProS"};
|
||||
|
||||
hoymilesClient.set_version_flag("-v,--version", version);
|
||||
|
||||
int rtuDeviceAddress{1};
|
||||
std::string rtuDeviceAddressHelp{"Address on RS485 {default: }" + std::to_string(rtuDeviceAddress) + "}"};
|
||||
hoymilesClient.add_option<int>("-a,--rt_device_address", rtuDeviceAddress, rtuDeviceAddressHelp)->group("Serial");
|
||||
std::string serialDeviceAddress{""};
|
||||
std::string serialDeviceAddressHelp{"Serial device address"};
|
||||
hoymilesClient.add_option<std::string>("-d,--serial_device_address", serialDeviceAddress, serialDeviceAddressHelp)->needs(hoymilesClient.get_option("-a"))->group("Serial");
|
||||
|
||||
bool rtuMode{false};
|
||||
std::string rtuModeHelp{"Work in RTU mode"};
|
||||
hoymilesClient.add_flag<bool>("-r,--rtu", rtuMode, rtuModeHelp)->needs(hoymilesClient.get_option("-d"))->group("Serial");
|
||||
|
||||
std::string ipAddress{"127.0.0.1"};
|
||||
std::string ipAddressHelp{"Ipv4 address of DTU {default: " + ipAddress + "}"};
|
||||
hoymilesClient.add_option<std::string>("-i,--ip_address", ipAddress, ipAddressHelp)->group("Networking");
|
||||
|
||||
bool tcpMode{false};
|
||||
std::string tcpModeHelp{"Work in Ipv4 mode"};
|
||||
hoymilesClient.add_flag<bool>("-t,--tcp", tcpMode, tcpModeHelp)->needs(hoymilesClient.get_option("-i"))->group("Networking");
|
||||
std::string ipAddressHelp{"ipv4 address of DTU {default: " + ipAddress + "}"};
|
||||
hoymilesClient.add_option<std::string>("-i,--ip_address", ipAddress, ipAddressHelp)->required()->group("Networking");
|
||||
|
||||
int port{502};
|
||||
std::string portHelp{"Port of DTU {default: " + std::to_string(port) + "}"};
|
||||
hoymilesClient.add_option<int>("-p,--port", port, portHelp)->group("Networking");
|
||||
|
||||
std::vector<std::string> parametersToGet{};
|
||||
std::string parametersToGetHelp{"List of parameters to fetch, delimited by ','; possible parameters:\n - pvVoltage [pvU]\n - pvCurrentMI [pvIMI]\n - pvCurrentHM [pvIHM]\n - gridVoltage [gU]\n - gridFrequency [gF]\n - pvPower [gP]\n - "
|
||||
"todayProduction [tdP]\n - totalProduction [ttP]\n - temperature [t]\n - operatingStatus [oS]\n - alarmCode [aC]\n - alarmCount [aCnt]\n - linkStatus [lS]"};
|
||||
std::string parametersToGetHelp{"List of parameters to fetch, delimited by ','; possible parameters:\n - pvVoltage [pvU]\n - pvCurrentMI [pvIMI]\n - pvCurrentHM [pvIHM]\n - gridVoltage [gU]\n - gridFrequency [gF]\n - pvPower [gP]\n - todayProduction [tdP]\n - totalProduction [ttP]\n - temperature [t]\n - operatingStatus [oS]\n - alarmCode [aC]\n - alarmCount [aCnt]\n - linkStatus [lS]"};
|
||||
hoymilesClient.add_option<std::vector<std::string>>("-P,--parameters", parametersToGet, parametersToGetHelp)->delimiter(',')->group("Parameters");
|
||||
|
||||
bool allParameters{false};
|
||||
bool allParameters = false;
|
||||
std::string allParametersHelp{"Fetch all parameters"};
|
||||
hoymilesClient.add_flag<bool>("-A,--all_parameters", allParameters, allParametersHelp)->group("Parameters");
|
||||
hoymilesClient.add_flag<bool>("-a,--all_parameters", allParameters, allParametersHelp)->group("Parameters");
|
||||
|
||||
bool shortNames{false};
|
||||
bool shortNames = false;
|
||||
std::string shortNamesHelp{"Print short parameter names"};
|
||||
hoymilesClient.add_flag<bool>("-s,--short", shortNames, shortNamesHelp)->group("Parameters");
|
||||
|
||||
bool getMicroinverters{false};
|
||||
std::string getMicroinvertersHelp{"Print all microinverters instead of getting parameters"};
|
||||
hoymilesClient.add_flag<bool>("-M,--get_microinverters", getMicroinverters, getMicroinvertersHelp)->group("Microinverters");
|
||||
|
||||
std::vector<long long> microinvertersToChoose{};
|
||||
std::string microinvertersToChooseHelp{"List of microinverters to work on, delimited by ','; if omitted, all are selected"};
|
||||
hoymilesClient.add_option<std::vector<long long>>("-m,--microinverters", microinvertersToChoose, microinvertersToChooseHelp)->delimiter(',')->group("Microinverters");
|
||||
std::vector<long long> microinvertersToGet{};
|
||||
std::string microinvertersToGetHelp{"List of microinverters to fetch, delimited by ','; if omitted, all are fetched"};
|
||||
hoymilesClient.add_option<std::vector<long long>>("-m,--microinverters", microinvertersToGet, microinvertersToGetHelp)->delimiter(',')->group("Microinverters");
|
||||
|
||||
bool microinvertersGetTodayProduction{false};
|
||||
std::string microinvertersGetTodayProductionHelp{"Show today production for microinverters"};
|
||||
hoymilesClient.add_flag<bool>("-D,--today_production", microinvertersGetTodayProduction, microinvertersGetTodayProductionHelp)->group("Microinverters");
|
||||
hoymilesClient.add_flag<bool>("-t,--today_production", microinvertersGetTodayProduction, microinvertersGetTodayProductionHelp)->group("Microinverters");
|
||||
|
||||
bool microinvertersGetTotalProduction{false};
|
||||
std::string microinvertersGetTotalProductionHelp{"Show total production for microinverters"};
|
||||
|
|
@ -82,17 +60,6 @@ int main(int argc, char **argv) {
|
|||
std::string ignoreNotConnectedHelp{"Ignore conn_error"};
|
||||
hoymilesClient.add_flag<bool>("-I,--ignore_conn_error", ignoreNotConnected, ignoreNotConnectedHelp)->group("Debug");
|
||||
|
||||
bool writeMode = false;
|
||||
std::string writeModeHelp{"Write instead of read"};
|
||||
hoymilesClient.add_flag<bool>("-w,--write", writeMode, writeModeHelp)->group("Write");
|
||||
|
||||
uint16_t writeValue;
|
||||
std::string writeValueHelp{"Value to write"};
|
||||
hoymilesClient.add_option<uint16_t>("-V,--value", writeValue, writeModeHelp)->group("Write")->needs(hoymilesClient.get_option("-w"));
|
||||
|
||||
std::string writeStatusName{};
|
||||
std::string writeStatusNameHelp{"Status to write"};
|
||||
hoymilesClient.add_option<std::string>("-S,--status", writeStatusName, writeStatusName)->group("Write")->needs(hoymilesClient.get_option("-w"));
|
||||
|
||||
try {
|
||||
hoymilesClient.parse(argc, argv);
|
||||
|
|
@ -102,56 +69,27 @@ int main(int argc, char **argv) {
|
|||
|
||||
std::cout << "Mapping out DTU" << std::endl;
|
||||
auto startTime = std::chrono::high_resolution_clock::now();
|
||||
std::string address;
|
||||
int id;
|
||||
if (tcpMode) {
|
||||
address = ipAddress;
|
||||
id = port;
|
||||
}
|
||||
if (rtuMode) {
|
||||
address = serialDeviceAddress;
|
||||
id = rtuDeviceAddress;
|
||||
}
|
||||
Dtu dtu{address.c_str(), id, rtuMode, tcpMode};
|
||||
Dtu dtu{ipAddress.c_str(), port};
|
||||
auto endTime = std::chrono::high_resolution_clock::now();
|
||||
std::cout << "DTU construction time: " << std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() << "ms" << std::endl;
|
||||
std::cout << std::endl << std::endl;
|
||||
|
||||
while ((!writeMode && !getMicroinverters) && (!dtu.empty() && ((dtu.isConnected() || ignoreNotConnected) && (!parametersToGet.empty() || allParameters)))) {
|
||||
time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
|
||||
|
||||
while ((dtu.isConnected() || ignoreNotConnected) && (!parametersToGet.empty() || allParameters)) {
|
||||
startTime = std::chrono::high_resolution_clock::now();
|
||||
dtu.updateMicroinverters(parametersToGet, allParameters, microinvertersToChoose);
|
||||
dtu.updateMicroinverters(parametersToGet, allParameters, microinvertersToGet);
|
||||
endTime = std::chrono::high_resolution_clock::now();
|
||||
|
||||
std::cout << "Pass time: " << std::put_time(localtime(&now), "%F %T") << std::endl;
|
||||
std::cout << "DTU update time: " << std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() << "ms" << std::endl;
|
||||
|
||||
dtu.printMicroinverters(parametersToGet, allParameters, microinvertersToChoose, shortNames, microinvertersGetTodayProduction, microinvertersGetTotalProduction);
|
||||
dtu.printMicroinverters(parametersToGet, allParameters, microinvertersToGet, shortNames, microinvertersGetTodayProduction, microinvertersGetTotalProduction);
|
||||
std::cout << std::endl;
|
||||
}
|
||||
// if(dtu.modbusError()) {
|
||||
// std::cerr << dtu.modbusErrorMessage() << std::endl;
|
||||
// }
|
||||
|
||||
if (getMicroinverters) {
|
||||
dtu.listOfMicroinverters();
|
||||
}
|
||||
|
||||
if (writeMode) {
|
||||
std::cout << "Starting DTU write" << std::endl;
|
||||
|
||||
startTime = std::chrono::high_resolution_clock::now();
|
||||
dtu.setStatusMicroinverters(writeValue, writeStatusName, microinvertersToChoose);
|
||||
endTime = std::chrono::high_resolution_clock::now();
|
||||
|
||||
std::cout << "DTU write time: " << std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() << "ms" << std::endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void sigHandler(int signal) {
|
||||
std::cerr << "Interrupted\n";
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue