Merge pull request 'Release v2.1' (#16) from master into release

Reviewed-on: https://gitea.trabus322.eu/trabus322/hoymilesClient/pulls/16

CMakeLists.txt

@@ -3,9 +3,9 @@ project(hoymilesClient VERSION 0.1.0 LANGUAGES C CXX)
 
 # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 
-include_directories(inc inc/libmodbus inc/hoymiles inc/hoymiles/portParameters)
+include_directories(inc inc/libmodbus inc/hoymiles inc/hoymiles/portParameters inc/hoymiles/sunspecParameters)
 
-file(GLOB SOURCES src/*.cpp src/libmodbus/*.c src/hoymiles/*.cpp src/hoymiles/portParameters/*.cpp)
+file(GLOB SOURCES src/*.cpp src/libmodbus/*.c src/hoymiles/*.cpp src/hoymiles/portParameters/*.cpp src/hoymiles/sunspecParameters/*.cpp)
 
 add_executable(hoymilesClient_exec ${SOURCES})
 

inc/hoymiles/microinverter.h

@@ -7,11 +7,14 @@
 
 #include "modbus.h"
 #include "port.h"
+#include "sunspec.h"
 
 class Microinverter {
       private:
 	std::shared_ptr<class modbus> modbus;
 
+	Sunspec sunspec;
+
 	int startAddress;
 
       public:

inc/hoymiles/port.h

@@ -28,7 +28,7 @@ class Port {
 
 	// void updateParameters(std::vector<std::string> &parametersToGet, bool allParameters);
 
-	void setParametersFromMicroinverterArray(uint8_t *registers, int addressOffset);
+	void setParametersFromMicroinverterArray(uint16_t *registers, int addressOffset);
 
 	void printParameters(std::vector<std::string> &parametersToGet, bool allParameters, bool shortNames);
 };

inc/hoymiles/portParameters/portParameters.h

@@ -5,7 +5,7 @@
 
 class PortParameterMicroinverterSerialNumber : public PortParameterInt {
       private:
-	void setValueFromRegisters(uint8_t *registers, int addressOffset);
+	void setValueFromRegisters(uint16_t *registers, int addressOffset);
 
       public:
 	PortParameterMicroinverterSerialNumber();

inc/hoymiles/portParameters/portParametersGeneric.h

@@ -13,8 +13,10 @@ class PortParameter {
 	uint16_t parameterAddressOffset;
 	int registerSize;
 
+	std::string unit;
+
       public:
-	PortParameter(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize);
+	PortParameter(std::string name, std::string shortName, std::string unit, uint16_t parameterAddressOffset, int registerSize);
 
 	virtual ~PortParameter();
 
@@ -39,7 +41,7 @@ class PortParameter {
 
 	virtual std::string getOutputValue();
 
-	virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
+	virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
 
 	// void updateValue(std::shared_ptr<class modbus> modubs, uint16_t portStartAddress);
 };
@@ -49,22 +51,22 @@ class PortParameterFloat : public PortParameter {
 	int decimalPlaces;
 
       public:
-	PortParameterFloat(std::string name, std::string shortName, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize);
+	PortParameterFloat(std::string name, std::string shortName, std::string unit, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize);
 
 	std::string getOutputValue();
 
-	virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
+	virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
 };
 
 class PortParameterInt : public PortParameter {
       protected:
 
       public:
-	PortParameterInt(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize);
+	PortParameterInt(std::string name, std::string shortName, std::string unit, uint16_t parameterAddressOffset, int registerSize);
 
 	std::string getOutputValue();
 
-	virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
+	virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
 };
 
 #endif

inc/hoymiles/sunspec.h

@@ -0,0 +1,37 @@
+#ifndef SUNSPEC_H
+#define SUNSPEC_H
+
+#include <string>
+#include <stdint.h>
+#include <memory>
+#include <vector>
+
+#include "modbus.h"
+#include "sunspecParametersGeneric.h"
+
+class Sunspec {
+      protected:
+    std::shared_ptr<class modbus> 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, std::shared_ptr<class modbus> modbus);
+
+    uint16_t getAddress();
+};
+
+#endif

inc/hoymiles/sunspecParameters/sunspecParameters.h

@@ -0,0 +1,15 @@
+#ifndef SUNSPEC_PARAMETERS_H
+#define SUNSPEC_PARAMETERS_H
+
+#include "sunspecParametersGeneric.h"
+
+class SunspecParameterManufacturer : public SunspecParameterString32 {
+      protected:
+
+      public:
+    SunspecParameterManufacturer();
+
+    void setValueFromRegisters(uint16_t *registers, int addressOffset);
+};
+
+#endif

inc/hoymiles/sunspecParameters/sunspecParametersGeneric.h

@@ -0,0 +1,124 @@
+#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 setValueFromRegisters(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 setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+// class SunspecParameterUint16 : public SunspecParameter {
+//       protected:
+
+//       public:
+//     SunspecParameterUint16(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+class SunspecParameterString32 : public SunspecParameter {
+      protected:
+    std::string value;
+
+      public:
+    SunspecParameterString32(std::string name, int registerAddressOffset, int registerSize);
+
+    virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+};
+
+// class SunspecParameterString16 : public SunspecParameter {
+//       protected:
+//     std::string value;
+
+//       public:
+//     SunspecParameterString16(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+// class SunspecParameterSunssf : public SunspecParameter {
+//       protected:
+
+//       public:
+//     SunspecParameterSunssf(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+// class SunspecParameterInt16 : public SunspecParameter {
+//       protected:
+
+//       public:
+//     SunspecParameterInt16(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+// class SunspecParameterAcc32 : public SunspecParameter {
+//       protected:
+
+//       public:
+//     SunspecParameterAcc32(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+// class SunspecParameterFloat32 : public SunspecParameter {
+//       protected:
+
+//       public:
+//     SunspecParameterFloat32(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+// class SunspecParameterEnum16 : public SunspecParameter {
+//       protected:
+
+//       public:
+//     SunspecParameterEnum16(std::string name, int registerAddressOffset, int registerSize);
+
+//     virtual void setValueFromRegisters(uint16_t *registers, int addressOffset);
+// };
+
+#endif

src/hoymiles/dtu.cpp

@@ -33,23 +33,17 @@ std::string Dtu::modbusErrorMessage() { return this->modbus.get()->error_msg; }
 Dtu::~Dtu() { this->modbus.get()->modbus_close(); }
 
 void Dtu::populateMicroinverters() {
-	int portStartAddress = 0x1000;
-	uint16_t readArrayJoined[20];
-	uint8_t registers[40];
+	int portStartAddress = 0x4000;
+	uint16_t registers[19];
 
 	int registerCount;
-	registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 20, readArrayJoined);
+	registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 19, registers);
 
 	if (registerCount != 0) {
 		return;
 	}
 
 	while (registerCount == 0) {
-		for (int i{0}; i < 20; i ++) {
-			registers[2 * i] = (readArrayJoined[i] & 0xFF00) >> 8;
-			registers[(2 * i) + 1] = (readArrayJoined[i] & 0x00FF);
-		}
-
 		if(registers[0] != 12) {
 			break;
 		}
@@ -64,9 +58,9 @@ void Dtu::populateMicroinverters() {
 
 		this->getMicroinverterBySerialNumber(port.getParameterByName("microinverterSerialNumber").first.get()->getValue().first.i).first->ports.push_back(port);
 
-		portStartAddress += 0x0028;
+		portStartAddress += 0x0019;
 
-		registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 20, readArrayJoined);
+		registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 19, registers);
 	}
 }
 

src/hoymiles/microinverter.cpp

@@ -6,8 +6,9 @@
 
 #include "microinverter.h"
 #include "port.h"
+#include "sunspec.h"
 
-Microinverter::Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber) {
+Microinverter::Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber) : sunspec(40000, modbus) {
 	this->modbus = modbus;
 	this->startAddress = startAddress;
 	this->serialNumber = serialNumber;
@@ -23,25 +24,29 @@ Microinverter::Microinverter(std::shared_ptr<class modbus> modbus, int startAddr
 // }
 
 void Microinverter::updateParameters(std::vector<std::string> &parametersToGet, bool allParameters) {
-	int registersToRead = (this->ports.size() * 40) / 2;
-	uint16_t registersJoined[registersToRead];
-	uint8_t registers[registersToRead*2];
+	int portsRead = 0;
+	while (portsRead < this->ports.size()) {
+		int portsToRead = 0;
+		while (portsToRead * 0x0019 < (128 - 0x0019) && (portsToRead + portsRead) < this->ports.size()) {
+			portsToRead++;
+		}
 
-	int registerCount;
-	registerCount = this->modbus.get()->modbus_read_holding_registers(this->startAddress, registersToRead, registersJoined);
+		int registersToRead = (portsToRead * 0x0019);
+		uint16_t registers[registersToRead];
 
-	if(registerCount != 0) {
-		this->age++;
-		return;
-	}
+		int registerCount;
+		registerCount = this->modbus.get()->modbus_read_holding_registers(this->startAddress + (portsRead * 0x0019), registersToRead, registers);
 
-	for(int i{0}; i<registersToRead; i++) {
-		registers[2 * i] = (registersJoined[i] & 0xFF00) >> 8;
-		registers[(2 * i)+1] = (registersJoined[i] & 0x00FF);
-	}
+		if (registerCount != 0) {
+			this->age++;
+			return;
+		}
 
-	for(int i{0}; i<this->ports.size(); i++) {
-		this->ports.at(i).setParametersFromMicroinverterArray(registers, i * 40);
+		for (int i{0}; i < portsToRead; i++) {
+			this->ports.at(i).setParametersFromMicroinverterArray(registers, i * 0x0019);
+		}
+
+		portsRead += portsToRead;
 	}
 }
 
@@ -58,19 +63,19 @@ 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++;
 	}

src/hoymiles/port.cpp

@@ -123,7 +123,7 @@ void Port::fixCurrent() {
 // 	}
 // }
 
-void Port::setParametersFromMicroinverterArray(uint8_t *registers, int addressOffset) {
+void Port::setParametersFromMicroinverterArray(uint16_t *registers, int addressOffset) {
 	std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->parameters.begin();
 	while(parametersIterator != this->parameters.end()) {
 		parametersIterator->get()->setValueFromRegisters(registers, addressOffset);

src/hoymiles/portParameters/portParameters.cpp

@@ -5,42 +5,43 @@
 
 #include "portParameters.h"
 
-PortParameterMicroinverterSerialNumber::PortParameterMicroinverterSerialNumber() : PortParameterInt("microinverterSerialNumber", "mSN", 0x0001, 6) {}
+PortParameterMicroinverterSerialNumber::PortParameterMicroinverterSerialNumber() : PortParameterInt("microinverterSerialNumber", "mSN", "", 0x0001, 3) {}
 
-void PortParameterMicroinverterSerialNumber::setValueFromRegisters(uint8_t *registers, int addressOffset) {
+void PortParameterMicroinverterSerialNumber::setValueFromRegisters(uint16_t *registers, int addressOffset) {
 	std::string readValueString = "";
 	for (int i{0}; i < this->registerSize; i++) {
 		std::stringstream readValueStringStream;
-		readValueStringStream << std::hex << (int) registers[addressOffset + this->parameterAddressOffset + i];
+		readValueStringStream << std::hex << (int) ((registers[addressOffset + this->parameterAddressOffset + i] & 0xff00) > 8);
+		readValueStringStream << std::hex << (int) (registers[addressOffset + this->parameterAddressOffset + i] & 0x00ff);
 		readValueString.append(readValueStringStream.str());
 	}
 	this->value.i = std::stoll(readValueString);
 }
 
-PortParameterPortNumber::PortParameterPortNumber() : PortParameterInt("portNumber", "pN", 0x0007, 1) {}
+PortParameterPortNumber::PortParameterPortNumber() : PortParameterInt("portNumber", "pN", "", 0x0004, 1) {}
 
-PortParameterPvVoltage::PortParameterPvVoltage() : PortParameterFloat("pvVoltage", "pvU", 1, 0x0008, 2) {}
+PortParameterPvVoltage::PortParameterPvVoltage() : PortParameterFloat("pvVoltage", "pvU", "V", 1, 0x0005, 1) {}
 
-PortParameterPvCurrentMi::PortParameterPvCurrentMi() : PortParameterFloat("pvCurrentMI", "pvIMI", 1, 0x000a, 2) {}
+PortParameterPvCurrentMi::PortParameterPvCurrentMi() : PortParameterFloat("pvCurrentMI", "pvIMI", "A", 1, 0x0006, 1) {}
 
-PortParameterPvCurrentHm::PortParameterPvCurrentHm() : PortParameterFloat("pvCurrentHM", "pvIHM", 2, 0x000a, 2) {}
+PortParameterPvCurrentHm::PortParameterPvCurrentHm() : PortParameterFloat("pvCurrentHM", "pvIHM", "A", 2, 0x0006, 1) {}
 
-PortParameterGridVoltage::PortParameterGridVoltage() : PortParameterFloat("gridVoltage", "gU", 1, 0x000c, 2) {}
+PortParameterGridVoltage::PortParameterGridVoltage() : PortParameterFloat("gridVoltage", "gU", "V", 1, 0x0007, 1) {}
 
-PortParameterGridFrequency::PortParameterGridFrequency() : PortParameterFloat("gridFrequency", "gF", 2, 0x000e, 2) {}
+PortParameterGridFrequency::PortParameterGridFrequency() : PortParameterFloat("gridFrequency", "gF", "Hz", 2, 0x0008, 1) {}
 
-PortParameterPvPower::PortParameterPvPower() : PortParameterFloat("pvPower", "pvP", 1, 0x0010, 2) {}
+PortParameterPvPower::PortParameterPvPower() : PortParameterFloat("pvPower", "pvP", "W", 1, 0x0009, 1) {}
 
-PortParameterTodayProduction::PortParameterTodayProduction() : PortParameterInt("todayProduction", "tdP", 0x0012, 2) {}
+PortParameterTodayProduction::PortParameterTodayProduction() : PortParameterInt("todayProduction", "tdP", "Wh", 0x000A, 1) {}
 
-PortParameterTotalProduction::PortParameterTotalProduction() : PortParameterInt("totalProduction", "ttP", 0x0014, 4) {}
+PortParameterTotalProduction::PortParameterTotalProduction() : PortParameterInt("totalProduction", "ttP", "Wh", 0x000B, 2) {}
 
-PortParameterTemperature::PortParameterTemperature() : PortParameterFloat("temperature", "t", 1, 0x0018, 2) {}
+PortParameterTemperature::PortParameterTemperature() : PortParameterFloat("temperature", "t", "C", 1, 0x000D, 1) {}
 
-PortParameterOperatingStatus::PortParameterOperatingStatus() : PortParameterInt("operatingStatus", "oS", 0x001a, 2) {}
+PortParameterOperatingStatus::PortParameterOperatingStatus() : PortParameterInt("operatingStatus", "oS", "", 0x000e, 1) {}
 
-PortParameterAlarmCode::PortParameterAlarmCode() : PortParameterInt("alarmCode", "aC", 0x001c, 2) {}
+PortParameterAlarmCode::PortParameterAlarmCode() : PortParameterInt("alarmCode", "aC", "", 0x000f, 1) {}
 
-PortParameterAlarmCount::PortParameterAlarmCount() : PortParameterInt("alarmCount", "aCnt", 0x001e, 2) {}
+PortParameterAlarmCount::PortParameterAlarmCount() : PortParameterInt("alarmCount", "aCnt", "", 0x0010, 1) {}
 
-PortParameterLinkStatus::PortParameterLinkStatus() : PortParameterInt("linkStatus", "lS", 0x020, 2) {}
+PortParameterLinkStatus::PortParameterLinkStatus() : PortParameterInt("linkStatus", "lS", "", 0x011, 1) {}

src/hoymiles/portParameters/portParametersGeneric.cpp

@@ -8,9 +8,10 @@
 
 #include "portParametersGeneric.h"
 
-PortParameter::PortParameter(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize) {
+PortParameter::PortParameter(std::string name, std::string shortName, std::string unit, uint16_t parameterAddressOffset, int registerSize) {
 	this->name = name;
 	this->shortName = shortName;
+	this->unit = unit;
 
 	this->parameterAddressOffset = parameterAddressOffset;
 	this->registerSize = registerSize;
@@ -20,7 +21,7 @@ PortParameter::PortParameter(std::string name, std::string shortName, uint16_t p
 
 PortParameter::~PortParameter() {}
 
-void PortParameter::setValueFromRegisters(uint8_t *readArray, int portOffset) {}
+void PortParameter::setValueFromRegisters(uint16_t *readArray, int portOffset) {}
 
 std::pair<PortParameter::PortParameterValue, PortParameter::PortParameterValueType> PortParameter::getValue() {
     return std::pair<PortParameter::PortParameterValue, PortParameter::PortParameterValueType>(this->value, this->valueType);
@@ -46,7 +47,7 @@ std::string PortParameter::getOutputValue() {
 // 	}
 // }
 
-PortParameterFloat::PortParameterFloat(std::string name, std::string shortName, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, parameterAddressOffset, registerSize) {
+PortParameterFloat::PortParameterFloat(std::string name, std::string shortName, std::string unit, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, unit, parameterAddressOffset, registerSize) {
 	this->decimalPlaces = decimalPlaces;
 
 	this->valueType = Float;
@@ -54,7 +55,7 @@ PortParameterFloat::PortParameterFloat(std::string name, std::string shortName,
     this->value.f = 0;
 }
 
-void PortParameterFloat::setValueFromRegisters(uint8_t *registers, int addressOffset) {
+void PortParameterFloat::setValueFromRegisters(uint16_t *registers, int addressOffset) {
 	std::string readValueString{""};
 	for(int i{0}; i<this->registerSize; i++) {
 		std::stringstream readValueStringStream;
@@ -67,16 +68,16 @@ void PortParameterFloat::setValueFromRegisters(uint8_t *registers, int addressOf
 std::string PortParameterFloat::getOutputValue() {
 	std::stringstream valueStringStream;
 	valueStringStream << std::fixed << std::setprecision(this->decimalPlaces) << this->value.f;
-	return valueStringStream.str();
+	return valueStringStream.str().append(this->unit.c_str());
 }
 
-PortParameterInt::PortParameterInt(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, parameterAddressOffset, registerSize) {
+PortParameterInt::PortParameterInt(std::string name, std::string shortName, std::string unit, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, unit, parameterAddressOffset, registerSize) {
     this->valueType = Int;
 
     this->value.i = 0;
 }
 
-void PortParameterInt::setValueFromRegisters(uint8_t *registers, int addressOffset) {
+void PortParameterInt::setValueFromRegisters(uint16_t *registers, int addressOffset) {
 	std::string readValueString{""};
 	for (int i{0}; i < this->registerSize; i++) {
 		std::stringstream readValueStringStream;
@@ -87,5 +88,5 @@ void PortParameterInt::setValueFromRegisters(uint8_t *registers, int addressOffs
 }
 
 std::string PortParameterInt::getOutputValue() {
-	return std::to_string(this->value.i);
+	return std::to_string(this->value.i).append(this->unit.c_str());
 }

src/hoymiles/sunspec.cpp

@@ -0,0 +1,34 @@
+#include <string>
+#include <stdint.h>
+#include <memory>
+
+#include "sunspec.h"
+#include "modbus.h"
+#include "sunspecParameters.h"
+
+Sunspec::Sunspec(int address, std::shared_ptr<class modbus> modbus) {
+    this->modbus = modbus;
+    this->sunspecAddress = address;
+
+    this->populateParameters();
+
+    this->setValues();
+}
+
+void Sunspec::setValues() {
+    uint16_t registers[70];
+
+    int registerCount;
+    registerCount = this->modbus.get()->modbus_read_holding_registers(this->sunspecAddress, 70, registers);
+
+    std::vector<std::shared_ptr<SunspecParameter>>::iterator parametersIterator = this->parameters.begin();
+    while(parametersIterator != this->parameters.end()) {
+        parametersIterator->get()->setValueFromRegisters(registers, 0);
+        parametersIterator++;
+    }
+}
+
+void Sunspec::populateParameters() {
+    SunspecParameterManufacturer manufacturer{};
+    this->parameters.push_back(std::make_shared<SunspecParameterManufacturer>(manufacturer));
+}

src/hoymiles/sunspecParameters/sunspecParameters.cpp

@@ -0,0 +1,23 @@
+#include <stdint.h>
+#include <string>
+#include <sstream>
+
+#include "sunspecParameters.h"
+
+SunspecParameterManufacturer::SunspecParameterManufacturer() : SunspecParameterString32("manufacturer", 4, 16) {
+    this->valueType = string32;
+}
+
+void SunspecParameterManufacturer::setValueFromRegisters(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;
+}

src/hoymiles/sunspecParameters/sunspecParametersGeneric.cpp

@@ -0,0 +1,17 @@
+#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::setValueFromRegisters(uint16_t *registers, int addressOffset) {}
+
+std::pair<SunspecParameter::SunspecValue, SunspecParameter::SunspecValueType> SunspecParameter::getValue() {}
+
+SunspecParameterString32::SunspecParameterString32(std::string name, int registerAddressOffset, int registerSize) : SunspecParameter(name, registerAddressOffset, registerSize) {} 
+
+void SunspecParameterString32::setValueFromRegisters(uint16_t *registers, int addressOffset) {}

src/main.cpp

@@ -19,7 +19,7 @@ int main(int argc, char **argv) {
 	signal(SIGTERM, sigHandler);
 	signal(SIGABRT, sigHandler);
 
-	std::string version{"v2.0beta"};
+	std::string version{"v2.1"};
 	std::cout << version << std::endl;
 
 	CLI::App hoymilesClient{"Client for DTU-Pro/DTU-ProS"};