[modbus.sungrow] Added some more registers

bundles/org.openhab.binding.modbus.sungrow/src/main/java/org/openhab/binding/modbus/sungrow/internal/ConversionConstants.java

@@ -29,14 +29,43 @@ final class ConversionConstants {
     private ConversionConstants() {
     }
 
+    /**
+     * Multiplicand for 0.001.
+     */
+    static final BigDecimal DIV_BY_THOUSAND = new BigDecimal(BigInteger.ONE, 3);
+
+    /**
+     * Multiplicand for 0.01.
+     */
+    static final BigDecimal DIV_BY_HUNDRED = new BigDecimal(BigInteger.ONE, 2);
+
     /**
      * Multiplicand for 0.1.
      */
     static final BigDecimal DIV_BY_TEN = new BigDecimal(BigInteger.ONE, 1);
 
+    /**
+     * Multiplicand for 1.
+     */
+    static final BigDecimal ONE = BigDecimal.ONE;
+    /**
+     * Multiplicand for 10.
+     */
+    static final BigDecimal MULTI_BY_TEN = new BigDecimal(BigInteger.ONE, -1);
+
+    /**
+     * Multiplicand for 100.
+     */
+    static final BigDecimal MULTI_BY_HUNDRED = new BigDecimal(BigInteger.ONE, -2);
+
+    /**
+     * Multiplicand for 1.000.
+     */
+    static final BigDecimal MULTI_BY_THOUSAND = new BigDecimal(BigInteger.ONE, -3);
+
     /**
      * Value conversion from Celsius to Kelvin.
      */
     static final Function<BigDecimal, BigDecimal> CELSIUS_TO_KELVIN = (BigDecimal celsius) -> celsius
-            .add(new BigDecimal(273.15f));
+            .add(new BigDecimal("273.15"));
 }

bundles/org.openhab.binding.modbus.sungrow/src/main/java/org/openhab/binding/modbus/sungrow/internal/SungrowInverterHandler.java

@@ -12,13 +12,17 @@
  */
 package org.openhab.binding.modbus.sungrow.internal;
 
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.openhab.binding.modbus.handler.BaseModbusThingHandler;
+import org.openhab.binding.modbus.sungrow.internal.mapper.impl.DeviceTypeMapper;
+import org.openhab.binding.modbus.sungrow.internal.mapper.impl.OutputTypeMapper;
 import org.openhab.core.io.transport.modbus.AsyncModbusFailure;
 import org.openhab.core.io.transport.modbus.AsyncModbusReadResult;
 import org.openhab.core.io.transport.modbus.ModbusBitUtilities;
@@ -69,6 +73,12 @@ private ModbusReadRequestBlueprint initReadRequest(Deque<SungrowInverterRegister
                     tries //
             );
         }
+
+        @Override
+        public String toString() {
+            return "first: " + registers.getFirst().getRegisterNumber() + ", last: "
+                    + registers.getLast().getRegisterNumber();
+        }
     }
 
     private final Logger logger = LoggerFactory.getLogger(SungrowInverterHandler.class);
@@ -88,7 +98,6 @@ private List<ModbusRequest> buildRequests(int tries) {
         int currentRequestFirstRegister = 0;
 
         for (SungrowInverterRegisters channel : SungrowInverterRegisters.values()) {
-
             if (currentRequest.isEmpty()) {
                 currentRequest.add(channel);
                 currentRequestFirstRegister = channel.getRegisterNumber();
@@ -97,8 +106,8 @@ private List<ModbusRequest> buildRequests(int tries) {
                         + channel.getRegisterCount();
                 if (sizeWithRegisterAdded > ModbusConstants.MAX_REGISTERS_READ_COUNT) {
                     requests.add(new ModbusRequest(currentRequest, getSlaveId(), tries));
-                    currentRequest = new ArrayDeque<>();
 
+                    currentRequest = new ArrayDeque<>();
                     currentRequest.add(channel);
                     currentRequestFirstRegister = channel.getRegisterNumber();
                 } else {
@@ -110,7 +119,8 @@ private List<ModbusRequest> buildRequests(int tries) {
         if (!currentRequest.isEmpty()) {
             requests.add(new ModbusRequest(currentRequest, getSlaveId(), tries));
         }
-        logger.debug("Created {} modbus request templates.", requests.size());
+        logger.debug("Created {} modbus request templates:\n\t{}", requests.size(),
+                requests.stream().map(ModbusRequest::toString).collect(Collectors.joining("\n\t")));
         return requests;
     }
 
@@ -144,6 +154,9 @@ public void modbusInitialize() {
         }
 
         this.updateStatus(ThingStatus.UNKNOWN);
+
+        this.updateProperties(config);
+
         this.modbusRequests = this.buildRequests(config.maxTries);
 
         for (ModbusRequest request : modbusRequests) {
@@ -157,6 +170,60 @@ public void modbusInitialize() {
         }
     }
 
+    private void updateProperties(SungrowInverterConfiguration config) {
+        ModbusReadRequestBlueprint getVersionRequest = new ModbusReadRequestBlueprint(this.getSlaveId(),
+                ModbusReadFunctionCode.READ_INPUT_REGISTERS, //
+                4949, //
+                33, //
+                config.maxTries //
+        );
+        this.submitOneTimePoll(getVersionRequest, this::updateVersionProperties, this::readError);
+
+        ModbusReadRequestBlueprint getDeviceInfo = new ModbusReadRequestBlueprint(this.getSlaveId(),
+                ModbusReadFunctionCode.READ_INPUT_REGISTERS, //
+                4989, //
+                13, //
+                config.maxTries //
+        );
+        this.submitOneTimePoll(getDeviceInfo, this::updateDeviceInfoProperties, this::readError);
+    }
+
+    private void updateVersionProperties(AsyncModbusReadResult result) {
+        result.getRegisters().ifPresent(registers -> {
+            if (getThing().getStatus() != ThingStatus.ONLINE) {
+                updateStatus(ThingStatus.ONLINE);
+            }
+
+            long protocolNo = ModbusBitUtilities.extractUInt32(registers.getBytes(), 0);
+            getThing().setProperty("Protocol No", String.valueOf(protocolNo));
+            long protocolVersion = ModbusBitUtilities.extractUInt32(registers.getBytes(), 4);
+            getThing().setProperty("Protocol Version", String.valueOf(protocolVersion));
+            String certVersionArm = ModbusBitUtilities.extractStringFromRegisters(registers, 4, 28,
+                    StandardCharsets.UTF_8);
+            getThing().setProperty("Certification version number of ARM software", certVersionArm);
+            String certVersionDsp = ModbusBitUtilities.extractStringFromRegisters(registers, 19, 28,
+                    StandardCharsets.UTF_8);
+            getThing().setProperty("Certification version number of DSP software", certVersionDsp);
+        });
+    }
+
+    private void updateDeviceInfoProperties(AsyncModbusReadResult result) {
+        result.getRegisters().ifPresent(registers -> {
+            if (getThing().getStatus() != ThingStatus.ONLINE) {
+                updateStatus(ThingStatus.ONLINE);
+            }
+            String serialNumber = ModbusBitUtilities.extractStringFromRegisters(registers, 0, 20,
+                    StandardCharsets.UTF_8);
+            getThing().setProperty("Serial Number", serialNumber);
+            int deviceTypeCode = ModbusBitUtilities.extractUInt16(registers.getBytes(), 20);
+            getThing().setProperty("Device Type", DeviceTypeMapper.instance().map(deviceTypeCode));
+            int outputPower = ModbusBitUtilities.extractUInt16(registers.getBytes(), 22);
+            getThing().setProperty("Nominal Output Power", outputPower * 100 + " W");
+            int outputType = ModbusBitUtilities.extractUInt16(registers.getBytes(), 24);
+            getThing().setProperty("Output Type", OutputTypeMapper.instance().map(outputType));
+        });
+    }
+
     private void readSuccessful(ModbusRequest request, AsyncModbusReadResult result) {
         result.getRegisters().ifPresent(registers -> {
             if (getThing().getStatus() != ThingStatus.ONLINE) {