inc/hoymiles/dtu.h

@@ -14,8 +14,6 @@ class Dtu {
 
 	std::vector<Microinverter> microinverters;
 
-	bool connected;
-
 	void populateMicroinverters();
 
 	std::pair<Microinverter *, bool> getMicroinverterBySerialNumber(long long serialNumber);
@@ -25,12 +23,12 @@ class Dtu {
 
 	bool isConnected();
 
-	// void updateMicroinverters();
+	bool modbusError();
+
+	std::string modbusErrorMessage();
 
 	void updateMicroinverters(std::vector<std::string> &parametersToGet, bool allParameters, std::vector<long long> &microinvertersToGet);
 
-	// void printMicroinverters();
-
 	void printMicroinverters(std::vector<std::string> &parametersToGet, bool allParameters, std::vector<long long> &microinvertersToGet, bool shortNames, bool printTodayProduction, bool printTotalProduction);
 
 	~Dtu();

inc/hoymiles/microinverter.h

@@ -12,14 +12,20 @@ class Microinverter {
       private:
 	std::shared_ptr<class modbus> modbus;
 
+	int startAddress;
+
       public:
-	Microinverter(std::shared_ptr<class modbus> modbus, long long serialNumber);
+	Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber);
 
 	long long serialNumber;
 
+	int age;
+
 	std::vector<Port> ports;
 
-	void updatePorts(std::vector<std::string> &parametersToGet, bool allParameters);
+	// void updatePorts(std::vector<std::string> &parametersToGet, bool allParameters);
+
+	void updateParameters(std::vector<std::string> &parametersToGet, bool allParameters);
 
 	void printPorts(std::vector<std::string> &parametersToGet, bool allParameters, bool shortNames);
 

inc/hoymiles/port.h

@@ -10,25 +10,25 @@
 
 class Port {
       private:
-	std::shared_ptr<class modbus> modbus;
-
 	void populateParameters();
 
 	void fixCurrent();
 	bool currentFixed;
 
-	void increaseParametersAge();
+	// void increaseParametersAge();
 
       public:
-	Port(std::shared_ptr<class modbus> modbus, uint16_t portStartAddress);
+	Port(int portStartAddress);
 
-	uint16_t portStartAddress;
+	int portStartAddress;
 
 	std::vector<std::shared_ptr<PortParameter>> parameters;
 
 	std::pair<std::shared_ptr<PortParameter>, bool> getParameterByName(std::string name);
 
-	void updateParameters(std::vector<std::string> &parametersToGet, bool allParameters);
+	// void updateParameters(std::vector<std::string> &parametersToGet, bool allParameters);
+
+	void setParametersFromMicroinverterArray(uint8_t *registers, int addressOffset);
 
 	void printParameters(std::vector<std::string> &parametersToGet, bool allParameters, bool shortNames);
 };

inc/hoymiles/portParameters/portParameters.h

@@ -5,16 +5,13 @@
 
 class PortParameterMicroinverterSerialNumber : public PortParameterInt {
       private:
-	void setValueFromRegisters(uint16_t *readArray, int registerCount);
+	void setValueFromRegisters(uint8_t *registers, int addressOffset);
 
       public:
 	PortParameterMicroinverterSerialNumber();
 };
 
 class PortParameterPortNumber : public PortParameterInt {
-      private:
-	void setValueFromRegisters(uint16_t *readArray, int registerCount);
-
       public:
 	PortParameterPortNumber();
 };

inc/hoymiles/portParameters/portParametersGeneric.h

@@ -13,8 +13,6 @@ class PortParameter {
 	uint16_t parameterAddressOffset;
 	int registerSize;
 
-	virtual void setValueFromRegisters(uint16_t *readArray, int registerCount);
-
       public:
 	PortParameter(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize);
 
@@ -35,35 +33,38 @@ class PortParameter {
 	std::string name;
 	std::string shortName;
 
-	int age;
+	// int age;
 
 	std::pair<PortParameterValue, PortParameterValueType> getValue();
 
 	virtual std::string getOutputValue();
 
-	void updateValue(std::shared_ptr<class modbus> modubs, uint16_t portStartAddress);
+	virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
+
+	// void updateValue(std::shared_ptr<class modbus> modubs, uint16_t portStartAddress);
 };
 
 class PortParameterFloat : public PortParameter {
       protected:
 	int decimalPlaces;
 
-	virtual void setValueFromRegisters(uint16_t *readArray, int registerCount);
-
       public:
 	PortParameterFloat(std::string name, std::string shortName, int decimalPlaces, uint16_t parameterAddressOffset, int registerSize);
 
 	std::string getOutputValue();
+
+	virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
 };
 
 class PortParameterInt : public PortParameter {
       protected:
-	virtual void setValueFromRegisters(uint16_t *readArray, int registerCount);
 
       public:
 	PortParameterInt(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize);
 
 	std::string getOutputValue();
+
+	virtual void setValueFromRegisters(uint8_t *registers, int addressOffset);
 };
 
 #endif

src/hoymiles/dtu.cpp

@@ -16,46 +16,57 @@ Dtu::Dtu(const char *ip_address, int port) {
 	this->modbus = std::make_shared<class modbus>(modbus);
 
 	if (!this->modbus.get()->modbus_connect()) {
-		std::cerr << "conn_error" << std::endl;
+		std::cerr << "NOT CONNECTED" << std::endl;
-		this->connected = false;
-	} else {
-		this->connected = true;
 	}
 
-	if (this->connected) {
+	if (this->modbus.get()->is_connected()) {
 		this->populateMicroinverters();
 	}
 }
 
-bool Dtu::isConnected() { return this->connected; }
+bool Dtu::isConnected() { return this->modbus.get()->is_connected(); }
+
+bool Dtu::modbusError() { return this->modbus.get()->err; }
+
+std::string Dtu::modbusErrorMessage() { return this->modbus.get()->error_msg; }
 
 Dtu::~Dtu() { this->modbus.get()->modbus_close(); }
 
 void Dtu::populateMicroinverters() {
-	uint16_t portStartAddress = 0x1000;
+	int portStartAddress = 0x1000;
-	uint16_t readArray[1];
+	uint16_t readArrayJoined[20];
+	uint8_t registers[40];
 
 	int registerCount;
-	registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress + 0x0021, 1, readArray);
+	registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 20, readArrayJoined);
-	while (registerCount != -1 && readArray[0] == 0x700) {
-		Port port{this->modbus, portStartAddress};
 
-		PortParameterMicroinverterSerialNumber portParameterMicroinverterSerialNumber{};
+	if (registerCount != 0) {
-		portParameterMicroinverterSerialNumber.updateValue(this->modbus, portStartAddress);
+		return;
-		long long serialNumber = portParameterMicroinverterSerialNumber.getValue().first.i;
-
-		std::pair<Microinverter *, bool> getMicroinverterBySerialNumber = this->getMicroinverterBySerialNumber(serialNumber);
-		if (getMicroinverterBySerialNumber.second) {
-			getMicroinverterBySerialNumber.first->ports.push_back(port);
-		} else {
-			Microinverter microinverter{this->modbus, serialNumber};
-			this->microinverters.push_back(microinverter);
-			this->microinverters.back().ports.push_back(port);
 	}
 
+	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;
+		}
+
+		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 + 0x0021, 1, readArray);
+		registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 20, readArrayJoined);
 	}
 }
 
@@ -84,7 +95,7 @@ void Dtu::updateMicroinverters(std::vector<std::string> &parametersToGet, bool a
 	while (microinvertersToGetIterator != microinvertersToGet.end()) {
 		std::pair<Microinverter *, bool> microinverterPair = this->getMicroinverterBySerialNumber(*microinvertersToGetIterator);
 		if (microinverterPair.second) {
-			microinverterPair.first->updatePorts(parametersToGet, allParameters);
+			microinverterPair.first->updateParameters(parametersToGet, allParameters);
 		}
 		microinvertersToGetIterator++;
 	}
@@ -103,14 +114,16 @@ void Dtu::printMicroinverters(std::vector<std::string> &parametersToGet, 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: " << microinverterPair.first->serialNumber << std::endl;
+			std::cout << "  " << "Microinverter Data Age: " << microinverterPair.first->age << std::endl;
 			if (printTodayProduction) {
-				std::cout << "TodayProduction: " << microinverterPair.first->getTodayProduction() << std::endl;
+				std::cout << "  " << "TodayProduction: " << microinverterPair.first->getTodayProduction() << std::endl;
 			}
 			if (printTotalProduction) {
-				std::cout << "TotalProduction: " << microinverterPair.first->getTotalProduction() << std::endl;
+				std::cout << "  " << "TotalProduction: " << microinverterPair.first->getTotalProduction() << std::endl;
 			}
 			microinverterPair.first->printPorts(parametersToGet, allParameters, shortNames);
+			std::cout << std::endl;
 		}
 		microinvertersToGetIterator++;
 	}

src/hoymiles/microinverter.cpp

@@ -7,16 +7,41 @@
 #include "microinverter.h"
 #include "port.h"
 
-Microinverter::Microinverter(std::shared_ptr<class modbus> modbus, 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->age = 0;
 }
 
-void Microinverter::updatePorts(std::vector<std::string> &parametersToGet, bool allParameters) {
+// void Microinverter::updatePorts(std::vector<std::string> &parametersToGet, bool allParameters) {
-	std::vector<Port>::iterator portsIterator = this->ports.begin();
+// 	int registersToRead = (this->ports.size() * 40) / 2;
-	while (portsIterator != this->ports.end()) {
+// 	uint16_t registersJoined[registersToRead];
-		portsIterator->updateParameters(parametersToGet, allParameters);
+
-		portsIterator++;
+// 	int registerCount = this->modbus.get()->modbus_read_holding_registers(this->startAddress, registersToRead, registersJoined);
+// }
+
+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 registerCount;
+	registerCount = this->modbus.get()->modbus_read_holding_registers(this->startAddress, registersToRead, registersJoined);
+
+	if(registerCount != 0) {
+		this->age++;
+		return;
+	}
+
+	for(int i{0}; i<registersToRead; i++) {
+		registers[2 * i] = (registersJoined[i] & 0xFF00) >> 8;
+		registers[(2 * i)+1] = (registersJoined[i] & 0x00FF);
+	}
+
+	for(int i{0}; i<this->ports.size(); i++) {
+		this->ports.at(i).setParametersFromMicroinverterArray(registers, i * 40);
 	}
 }
 
@@ -34,10 +59,7 @@ long long Microinverter::getTodayProduction() {
 
 	std::vector<Port>::iterator portsIterator = this->ports.begin();
 	while(portsIterator != this->ports.end()) {
-		if(portsIterator->getParameterByName("todayProduction").first->age > 0) {
+		result += portsIterator->getParameterByName("todayProduction").first.get()->getValue().first.i;
-			portsIterator->getParameterByName("todayProduction").first->updateValue(this->modbus, portsIterator->portStartAddress);
-		}
-		result += portsIterator->getParameterByName("todayProduction").first->getValue().first.i;
 		portsIterator++;
 	}
 
@@ -49,11 +71,7 @@ long long Microinverter::getTotalProduction() {
 
 	std::vector<Port>::iterator portsIterator = this->ports.begin();
 	while(portsIterator != this->ports.end()) {
-		if(portsIterator->getParameterByName("totalProduction").first->age > 0) {
+		result += portsIterator->getParameterByName("totalProduction").first.get()->getValue().first.i;
-			portsIterator->getParameterByName("totalProduction").first->updateValue(this->modbus, portsIterator->portStartAddress);
-		}
-		result += portsIterator->getParameterByName("totalProduction").first->getValue().first.i;
-		portsIterator++;
 		portsIterator++;
 	}
 

src/hoymiles/port.cpp

@@ -9,9 +9,7 @@
 #include "port.h"
 #include "portParameters.h"
 
-Port::Port(std::shared_ptr<class modbus> modbus, uint16_t portStartAddress) {
+Port::Port(int portStartAddress) {
-	this->modbus = modbus;
-
 	this->portStartAddress = portStartAddress;
 
 	this->currentFixed = false;
@@ -20,6 +18,8 @@ Port::Port(std::shared_ptr<class modbus> modbus, uint16_t portStartAddress) {
 }
 
 void Port::populateParameters() {
+	this->parameters.push_back(std::make_shared<PortParameterMicroinverterSerialNumber>());
+
 	this->parameters.push_back(std::make_shared<PortParameterPortNumber>());
 
 	this->parameters.push_back(std::make_shared<PortParameterPvVoltage>());
@@ -87,47 +87,56 @@ void Port::fixCurrent() {
 	}
 }
 
-void Port::increaseParametersAge() {
+// void Port::increaseParametersAge() {
+// 	std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->parameters.begin();
+// 	while(parametersIterator != this->parameters.end()) {
+// 		parametersIterator->get()->age++;
+// 		parametersIterator++;
+// 	}
+// }
+
+// void Port::updateParameters(std::vector<std::string> &parametersToGet, bool allParameters) {
+// 	this->increaseParametersAge();
+
+// 	if (allParameters && parametersToGet.size() < this->parameters.size()) {
+// 		std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->parameters.begin();
+// 		while (parametersIterator != this->parameters.end()) {
+// 			if (std::find(parametersToGet.begin(), parametersToGet.end(), parametersIterator->get()->name) == parametersToGet.end()) {
+// 				parametersToGet.push_back(parametersIterator->get()->name);
+// 			}
+// 			parametersIterator++;
+// 		}
+// 	}
+
+// 	std::vector<std::string>::iterator parametersToGetIterator = parametersToGet.begin();
+// 	while (parametersToGetIterator != parametersToGet.end()) {
+// 		std::pair<std::shared_ptr<PortParameter>, bool> parameterPair;
+
+// 		parameterPair = this->getParameterByName(*parametersToGetIterator);
+// 		if (parameterPair.second) {
+// 			parameterPair.first->updateValue(this->modbus, this->portStartAddress);
+// 		}
+
+// 		this->fixCurrent();
+
+// 		parametersToGetIterator++;
+// 	}
+// }
+
+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()->age++;
+		parametersIterator->get()->setValueFromRegisters(registers, addressOffset);
 		parametersIterator++;
 	}
 }
 
-void Port::updateParameters(std::vector<std::string> &parametersToGet, bool allParameters) {
-	this->increaseParametersAge();
-
-	if (allParameters && parametersToGet.size() < this->parameters.size()) {
-		std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->parameters.begin();
-		while (parametersIterator != this->parameters.end()) {
-			if (std::find(parametersToGet.begin(), parametersToGet.end(), parametersIterator->get()->name) == parametersToGet.end()) {
-				parametersToGet.push_back(parametersIterator->get()->name);
-			}
-			parametersIterator++;
-		}
-	}
-
-	std::vector<std::string>::iterator parametersToGetIterator = parametersToGet.begin();
-	while (parametersToGetIterator != parametersToGet.end()) {
-		std::pair<std::shared_ptr<PortParameter>, bool> parameterPair;
-
-		parameterPair = this->getParameterByName(*parametersToGetIterator);
-		if (parameterPair.second) {
-			parameterPair.first->updateValue(this->modbus, this->portStartAddress);
-		}
-
-		this->fixCurrent();
-
-		parametersToGetIterator++;
-	}
-}
-
 void Port::printParameters(std::vector<std::string> &parametersToGet, bool allParameters, bool shortNames) {
 	if (allParameters && parametersToGet.size() < this->parameters.size()) {
 		std::vector<std::shared_ptr<PortParameter>>::iterator parametersIterator = this->parameters.begin();
 		while (parametersIterator != this->parameters.end()) {
-			if (std::find(parametersToGet.begin(), parametersToGet.end(), parametersIterator->get()->name) != parametersToGet.end()) {
+			std::string temp{parametersIterator->get()->name};
+			if (std::find(parametersToGet.begin(), parametersToGet.end(), parametersIterator->get()->name) == parametersToGet.end()) {
 				parametersToGet.push_back(parametersIterator->get()->name);
 			}
 			parametersIterator++;
@@ -140,6 +149,10 @@ void Port::printParameters(std::vector<std::string> &parametersToGet, bool allPa
 	}
 
 	while (parametersToGetIterator != parametersToGet.end()) {
+		if(*parametersToGetIterator == "microinverterSerialNumber") {
+			parametersToGetIterator++;
+			continue;
+		}
 		std::pair<std::shared_ptr<PortParameter>, bool> parameterPair;
 
 		parameterPair = this->getParameterByName(*parametersToGetIterator);

src/hoymiles/portParameters/portParameters.cpp

@@ -7,14 +7,11 @@
 
 PortParameterMicroinverterSerialNumber::PortParameterMicroinverterSerialNumber() : PortParameterInt("microinverterSerialNumber", "mSN", 0x0001, 6) {}
 
-void PortParameterMicroinverterSerialNumber::setValueFromRegisters(uint16_t *readArray, int registerCount) {
+void PortParameterMicroinverterSerialNumber::setValueFromRegisters(uint8_t *registers, int addressOffset) {
-	uint16_t readValue;
 	std::string readValueString = "";
-	registerCount = std::ceil(registerCount/2);
+	for (int i{0}; i < this->registerSize; i++) {
-	for (int i{0}; i < registerCount; i++) {
-		readValue = readArray[i];
 		std::stringstream readValueStringStream;
-		readValueStringStream << std::hex << readValue;
+		readValueStringStream << std::hex << (int) registers[addressOffset + this->parameterAddressOffset + i];
 		readValueString.append(readValueStringStream.str());
 	}
 	this->value.i = std::stoll(readValueString);
@@ -22,15 +19,6 @@ void PortParameterMicroinverterSerialNumber::setValueFromRegisters(uint16_t *rea
 
 PortParameterPortNumber::PortParameterPortNumber() : PortParameterInt("portNumber", "pN", 0x0007, 1) {}
 
-void PortParameterPortNumber::setValueFromRegisters(uint16_t *readArray, int registerCount) {
-	if (registerCount > 0) {
-		this->value.i = readArray[0];
-		std::stringstream valueStringStream;
-		valueStringStream << std::hex << this->value.i;
-		this->value.i = valueStringStream.str().at(0) - '0';
-	}
-}
-
 PortParameterPvVoltage::PortParameterPvVoltage() : PortParameterFloat("pvVoltage", "pvU", 1, 0x0008, 2) {}
 
 PortParameterPvCurrentMi::PortParameterPvCurrentMi() : PortParameterFloat("pvCurrentMI", "pvIMI", 1, 0x000a, 2) {}

src/hoymiles/portParameters/portParametersGeneric.cpp

@@ -15,12 +15,12 @@ PortParameter::PortParameter(std::string name, std::string shortName, uint16_t p
 	this->parameterAddressOffset = parameterAddressOffset;
 	this->registerSize = registerSize;
 
-    this->age = 0;
+    // this->age = 0;
 }
 
 PortParameter::~PortParameter() {}
 
-void PortParameter::setValueFromRegisters(uint16_t *readArray, int registerCount) {}
+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);
@@ -30,21 +30,21 @@ std::string PortParameter::getOutputValue() {
 	return "yeet";
 }
 
-void PortParameter::updateValue(std::shared_ptr<class modbus> modbus, uint16_t portStartAddress) {
+// void PortParameter::updateValue(std::shared_ptr<class modbus> modbus, uint16_t portStartAddress) {
-	uint16_t readArray[this->registerSize];
+// 	uint16_t readArray[this->registerSize];
-	int registerCount;
+// 	int registerCount;
 	
-	registerCount = modbus.get()->modbus_read_holding_registers(portStartAddress + this->parameterAddressOffset, this->registerSize, readArray);
+// 	registerCount = modbus.get()->modbus_read_holding_registers(portStartAddress + this->parameterAddressOffset, this->registerSize, readArray);
 
-	if(registerCount != 0){
+// 	if(registerCount != 0){
-		this->age++;
+// 		this->age++;
-	}
+// 	}
-	else{
+// 	else{
-		registerCount = this->registerSize;
+// 		registerCount = this->registerSize;
-		this->setValueFromRegisters(readArray, registerCount);
+// 		this->setValueFromRegisters(readArray, registerCount);
-        this->age = 0;
+//         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;
@@ -54,17 +54,20 @@ PortParameterFloat::PortParameterFloat(std::string name, std::string shortName,
     this->value.f = 0;
 }
 
-void PortParameterFloat::setValueFromRegisters(uint16_t *readArray, int registerCount) {
+void PortParameterFloat::setValueFromRegisters(uint8_t *registers, int addressOffset) {
-    float temp = readArray[0];
+	std::string readValueString{""};
-    temp = temp / std::pow(10, this->decimalPlaces);
+	for(int i{0}; i<this->registerSize; i++) {
-	this->value.f = temp;
+		std::stringstream readValueStringStream;
+		readValueStringStream << (int) registers[addressOffset + this->parameterAddressOffset + i];
+		readValueString.append(readValueStringStream.str().c_str());
+	}
+	this->value.f = std::stoll(readValueString) / std::pow(10, this->decimalPlaces);
 }
 
 std::string PortParameterFloat::getOutputValue() {
-	std::string separator{"_age"};
 	std::stringstream valueStringStream;
 	valueStringStream << std::fixed << std::setprecision(this->decimalPlaces) << this->value.f;
-	return valueStringStream.str().append(separator.append(std::to_string(this->age)));
+	return valueStringStream.str();
 }
 
 PortParameterInt::PortParameterInt(std::string name, std::string shortName, uint16_t parameterAddressOffset, int registerSize) : PortParameter(name, shortName, parameterAddressOffset, registerSize) {
@@ -73,18 +76,16 @@ PortParameterInt::PortParameterInt(std::string name, std::string shortName, uint
     this->value.i = 0;
 }
 
-void PortParameterInt::setValueFromRegisters(uint16_t *readArray, int registerCount) {
+void PortParameterInt::setValueFromRegisters(uint8_t *registers, int addressOffset) {
-	uint16_t readValue;
+	std::string readValueString{""};
-	std::string readValueString = "";
+	for (int i{0}; i < this->registerSize; i++) {
-	registerCount = std::ceil(registerCount/2);
+		std::stringstream readValueStringStream;
-	for (int i{0}; i < registerCount; i++) {
+		readValueStringStream << (int) registers[addressOffset + this->parameterAddressOffset + i];
-		readValue = readArray[i];
+		readValueString.append(readValueStringStream.str().c_str());
-		readValueString.append(std::to_string(readValue));
 	}
 	this->value.i = std::stoll(readValueString);
 }
 
 std::string PortParameterInt::getOutputValue() {
-	std::string separator{"_age"};
+	return std::to_string(this->value.i);
-	return std::to_string(this->value.i).append(separator.append(std::to_string(this->age)));
 }

src/main.cpp

@@ -19,7 +19,7 @@ int main(int argc, char **argv) {
 	signal(SIGTERM, sigHandler);
 	signal(SIGABRT, sigHandler);
 
-	std::string version{"v1.0mt"};
+	std::string version{"v2.0beta"};
 	std::cout << version << std::endl;
 
 	CLI::App hoymilesClient{"Client for DTU-Pro/DTU-ProS"};
@@ -48,11 +48,11 @@ int main(int argc, char **argv) {
 	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;
+	bool microinvertersGetTodayProduction{false};
 	std::string microinvertersGetTodayProductionHelp{"Show today production for microinverters"};
 	hoymilesClient.add_flag<bool>("-t,--today_production", microinvertersGetTodayProduction, microinvertersGetTodayProductionHelp)->group("Microinverters");
 
-	bool microinvertersGetTotalProduction{};
+	bool microinvertersGetTotalProduction{false};
 	std::string microinvertersGetTotalProductionHelp{"Show total production for microinverters"};
 	hoymilesClient.add_flag<bool>("-T,--total_production", microinvertersGetTotalProduction, microinvertersGetTotalProductionHelp)->group("Microinverters");
 
@@ -82,6 +82,9 @@ int main(int argc, char **argv) {
 		dtu.printMicroinverters(parametersToGet, allParameters, microinvertersToGet, shortNames, microinvertersGetTodayProduction, microinvertersGetTotalProduction);
 		std::cout << std::endl;
 	}
+	// if(dtu.modbusError()) {
+	// 	std::cerr << dtu.modbusErrorMessage() << std::endl;
+	// }
 
 	return 0;
 }