WIP: Support Modbus Meters

.gitignore

@@ -33,3 +33,7 @@ stamp-h1
 
 # Debian packaging
 /debian/config.log
+
+.cproject
+.project
+.settings/

etc/vzlogger.conf

@@ -177,7 +177,78 @@
             "enabled": false,
             "skip": true,
             "protocol": "w1therm"
-        }
+        },
+		{
+			"enabled": false,
+			"protocol": "modbus",
+			"type": "rtu",
+			"device": "/dev/ttyUSB1",
+			"baudrate": 9600,
+			"devices": [ {
+				"id": 2,
+				"regmap": "imemeter"
+			},
+			{
+				"id": 1,
+				"regmap": "imemeter"
+			}],
+			"interval": 1,
+			"channels": [{
+				"uuid": "037bfe00-0fd1-11e6-a37c-a3524b8cd319",
+				"identifier": "2:CurrentPowerW",
+				"middleware": "http://localhost/middleware.php",
+			},
+			{
+				"uuid": "50fd47d0-53df-11e6-9e8d-6312e0309d6c",
+				"identifier": "2:TotalExpWh",
+				"middleware": "http://localhost/middleware.php",
+				"interval_factor": 300,
+			},
+			{
+				"uuid": "3e428540-60c4-11e6-b2f8-d91fd531def7",
+				"identifier": "1:CurrentPowerW",
+				"middleware": "http://localhost/middleware.php",
+			},
+			{
+				"uuid": "7073dcf0-60c4-11e6-afbb-c5206eac7c36",
+				"identifier": "1:TotalImpWh",
+				"middleware": "http://localhost/middleware.php",
+				"interval_factor": 30,
+			}]
+		},
+		// example Modbus Meter
+		{
+			"enabled": true,
+			"interval": 1,
+			"protocol": "modbus",
+			"type": "tcp",
+			"host": "192.168.1.86",
+			"devices": [{
+				"id": 255,
+				"regmap": "ohmpilot",
+			}],
+			"channels": [{
+					"api": "null",
+					"uuid": "5cb9ace0-523f-11e6-a133-2f12ad3ac451",
+					"identifier": "255:T",
+					"middleware": "http://localhost/middleware.php",
+					"interval_factor": 300
+			},
+			{
+					"api": "null",
+					"uuid": "6b9ec800-5241-11e6-bb2f-dd48308e74d8",
+					"identifier": "255:P",
+					"middleware": "http://localhost/middleware.php",
+			},
+			{
+					"api": "null",
+					"uuid": "3a00f4b0-53df-11e6-b09f-d350e12493ff",
+					"identifier": "255:E",
+					"middleware": "http://localhost/middleware.php",
+					"interval_factor": 300
+			}]
+
+		}
     ]
 }
 

include/Options.hpp

@@ -5,6 +5,7 @@
 #include <iostream>
 #include <list>
 #include <json-c/json.h>
+#include <common.h>
 
 class Option {
 
@@ -87,20 +88,45 @@ class OptionList { //: public List<Option> {
 	typedef std::list<Option>::iterator iterator;
 	typedef std::list<Option>::const_iterator const_iterator;
 
-	const Option& lookup(std::list<Option> const &options, const std::string &key) const;
-	const char *lookup_string(std::list<Option> const &options, const char *key) const;
-	const char *lookup_string_tolower(std::list<Option> const &options, const char *key) const;
-	int    lookup_int(std::list<Option> const &options, const char *key) const;
-	bool   lookup_bool(std::list<Option> const &options, const char *key) const;
-	double lookup_double(std::list<Option> const &options, const char *key) const;
-	struct json_object *lookup_json_array(std::list<Option> const &options, const char *key) const;
-	struct json_object *lookup_json_object(std::list<Option> const &options, const char *key) const; 
-	void dump(std::list<Option> const &options);
+	static const Option& lookup(std::list<Option> const &options, const std::string &key);
+	static const char *lookup_string(std::list<Option> const &options, const char *key);
+	static const char *lookup_string_tolower(std::list<Option> const &options, const char *key);
+	static int    lookup_int(std::list<Option> const &options, const char *key);
+	static bool   lookup_bool(std::list<Option> const &options, const char *key);
+	static double lookup_double(std::list<Option> const &options, const char *key);
+	static struct json_object *lookup_json_array(std::list<Option> const &options, const char *key);
+	static struct json_object *lookup_json_object(std::list<Option> const &options, const char *key);
+	static void dump(std::list<Option> const &options);
 
-	void parse();
+	static void parse();
 
 protected:
 
 };
 
+
+template <typename T, T (*L)(const std::list<Option> &, const char *)>
+T lookup_mandatory(const std::list<Option> &olist, const std::string &o, const std::string &errorcontext) {
+	T v;
+	try {
+		v = L(olist, o.c_str());
+	} catch (vz::VZException &e) {
+			print(log_error, "Missing mandatory option: %s", errorcontext.c_str(), o.c_str());
+			throw vz::OptionNotFoundException(e.reason());
+	}
+	return v;
+}
+
+template <typename T, T (*L)(const std::list<Option> &, const char *)>
+T lookup_optional(const std::list<Option> &olist, const std::string &o, const T &def) {
+	T v;
+	try {
+		v = L(olist, o.c_str());
+	} catch (vz::VZException &e) {
+		return def;
+	}
+	return v;
+}
+
+
 #endif /* _OPTIONS_H_ */

include/Reading.hpp

@@ -135,13 +135,33 @@ class NilIdentifier : public ReadingIdentifier {
 private:
 };
 
+class ModbusReadingIdentifier : public ReadingIdentifier {
+	unsigned _slaveid;
+	std::string _name;
+	void parse(const std::string& s);
+public:
+	ModbusReadingIdentifier()
+	:_slaveid(0) {}
+	ModbusReadingIdentifier(unsigned slave, const std::string& name)
+	: _slaveid(slave), _name(name) {}
+	ModbusReadingIdentifier(const std::string& conf);
+	virtual ~ModbusReadingIdentifier(){};
+
+	virtual size_t unparse(char *buffer, size_t n);
+	virtual bool operator==( ReadingIdentifier const &cmp) const;
+
+	virtual const std::string toString();
+
+};
+
 class Reading {
 
 public:
 	typedef vz::shared_ptr<Reading> Ptr;
 	Reading();
 	Reading(ReadingIdentifier::Ptr pIndentifier);
 	Reading(double pValue, struct timeval pTime, ReadingIdentifier::Ptr pIndentifier);
+	Reading(double pValue, ReadingIdentifier *pIndentifier);
 	Reading(const Reading &orig);
 
 	bool deleted() const { return _deleted; }

include/meter_protocol.hpp

@@ -38,5 +38,6 @@ typedef enum meter_procotol {
 	meter_protocol_ocr,
 	meter_protocol_w1therm,
 	meter_protocol_oms,
+	meter_protocol_modbus,
 } meter_protocol_t;
 #endif /* _meter_protocol_hpp_ */

include/protocols/MeterModbus.hpp

@@ -0,0 +1,122 @@
+/**
+ * @file MeterModbus.h
+ * @brief
+ *  Created on: Apr 25, 2016
+ * @author Florian Achleitner <[email protected]>
+ */
+#ifndef METERMODBUS_H_
+#define METERMODBUS_H_
+
+#include "protocols/Protocol.hpp"
+#include <modbus/modbus.h>
+#include <errno.h>
+#include <map>
+
+class ModbusException : public std::runtime_error {
+	int _errno;
+	std::string _what;
+public:
+	explicit ModbusException(const std::string& arg);
+	virtual const char *what() const noexcept override {
+		return _what.c_str();
+	}
+
+};
+
+class ModbusConnection
+{
+protected:
+	modbus_t *_ctx;
+	bool _connected;
+public:
+	typedef vz::shared_ptr<ModbusConnection> Ptr;
+	ModbusConnection() :
+		_ctx(NULL), _connected(false) {}
+	virtual ~ModbusConnection();
+	modbus_t *getctx() {
+		return _ctx;
+	}
+
+	virtual void open() = 0;
+	virtual void connect();
+	virtual void close();
+	virtual void read_registers(int addr, int nb, uint16_t *dest, unsigned slave);
+	virtual void debug(bool enable);
+private:
+	ModbusConnection(const ModbusConnection&) = delete;
+	ModbusConnection& operator= (const ModbusConnection&) = delete;
+};
+
+class ModbusRTUConnection : public ModbusConnection
+{
+	std::string _device;
+	int _baud;
+public:
+	ModbusRTUConnection(const std::string &device, int baud)
+	: _device(device), _baud(baud) {}
+	virtual void open();
+};
+
+class ModbusTCPConnection : public ModbusConnection
+{
+	std::string _ip;
+	int _port;
+public:
+	ModbusTCPConnection(const std::string &ip, int port = 502)
+	: _ip(ip), _port(port) {}
+	virtual void open();
+};
+
+class RegisterMap
+{
+public:
+	typedef vz::shared_ptr<RegisterMap> Ptr;
+	virtual ~RegisterMap() {}
+	virtual void read(std::vector<Reading>& rds, ModbusConnection::Ptr conn, unsigned id) = 0;
+	static Ptr findMap(const std::string &name) {
+		return maps.at(name)();
+	}
+private:
+	template <class T> static Ptr createMap() {
+		return Ptr(new T());
+	}
+
+	static std::map<std::string, Ptr (*)()> maps;
+};
+/**
+ *
+ */
+class MeterModbus: public vz::protocol::Protocol
+{
+public:
+	typedef unsigned slaveid_t;
+private:
+	ModbusConnection::Ptr _mbconn;
+	bool _libmodbus_debug;
+	typedef std::map<slaveid_t, RegisterMap::Ptr> SlaveRegMaps;
+	SlaveRegMaps _devices;
+
+	void create_rtu(const std::list<Option> &options);
+	void create_tcp(const std::list<Option> &options);
+public:
+	MeterModbus(const std::list<Option> &options);
+	virtual ~MeterModbus();
+	virtual int open();
+	virtual int close();
+	virtual ssize_t read(std::vector<Reading> &rds, size_t n);
+};
+
+
+class OpRegisterMap: public RegisterMap {
+public:
+	virtual ~OpRegisterMap() {}
+	virtual void read(std::vector<Reading>& rds, ModbusConnection::Ptr conn, unsigned id);
+};
+
+class IMEmeterRegisterMap: public RegisterMap {
+public:
+	virtual ~IMEmeterRegisterMap() {}
+	virtual void read(std::vector<Reading>& rds, ModbusConnection::Ptr conn, unsigned id);
+};
+
+#endif /* METERMODBUS_H_ */

src/CMakeLists.txt

@@ -53,6 +53,7 @@ if( MBUS_FOUND )
     target_link_libraries(vzlogger ${MBUS_LIBRARY})
 endif( MBUS_FOUND )
 target_link_libraries(vzlogger ${OCR_LIBRARIES})
+target_link_libraries(vzlogger modbus)
 
 if(LOCAL_SUPPORT)
 target_link_libraries(vzlogger ${MICROHTTPD_LIBRARY})
@@ -72,6 +73,7 @@ if( TARGET )
 endif( TARGET )
 target_link_libraries(vzlogger ${CURL_STATIC_LIBRARIES} ${CURL_LIBRARIES} ${GNUTLS_LIBRARIES} ${OPENSSL_LIBRARIES} )
 
+
 # add programs to the install target 
 INSTALL(PROGRAMS 
   ${CMAKE_CURRENT_BINARY_DIR}/vzlogger

src/Meter.cpp

@@ -46,6 +46,7 @@
 #ifdef OMS_SUPPORT
 #include "protocols/MeterOMS.hpp"
 #endif
+#include "protocols/MeterModbus.hpp"
 //#include <protocols/.h>
 
 #define METER_DETAIL(NAME, CLASSNAME, DESC, MAX_RDS, PERIODIC) {				\
@@ -72,6 +73,7 @@ static const meter_details_t protocols[] = {
 #ifdef OMS_SUPPORT
 	METER_DETAIL(oms, OMS, "OMS (M-BUS) protocol based devices", 100, false), // todo what is the max. amount of reading according to spec?
 #endif
+	METER_DETAIL(modbus, Modbus, "Modbus meter", 64, true),
 	//{} /* stop condition for iterator */
 	METER_DETAIL(none, NULL,NULL, 0,false),
 };
@@ -193,6 +195,10 @@ Meter::Meter(std::list<Option> pOptions) :
 		_identifier = ReadingIdentifier::Ptr(new ObisIdentifier());
 		break;
 #endif
+	case meter_protocol_modbus:
+		_protocol = vz::protocol::Protocol::Ptr(new MeterModbus(pOptions));
+		_identifier = ReadingIdentifier::Ptr(new ModbusReadingIdentifier());
+		break;
 		default:
 			break;
 	}