diff --git a/energymeters/energymeter.cpp b/energymeters/energymeter.cpp
index cfb94b5..2d5991b 100644
--- a/energymeters/energymeter.cpp
+++ b/energymeters/energymeter.cpp
@@ -39,7 +39,7 @@ EnergyMeter::EnergyMeter(ModbusRtuMaster *modbusMaster, int slaveAddress, const
     m_slaveAddress(slaveAddress),
     m_modbusRegisters(modbusRegisters)
 {
-
+    qCDebug(dcEnergyMeters()) << "EnergyMeter: Creating new meter connection, address:" << slaveAddress;
 }
 
 ModbusRtuMaster *EnergyMeter::modbusMaster()
@@ -114,14 +114,23 @@ bool EnergyMeter::getEnergyConsumed()
 
 bool EnergyMeter::getRegister(ModbusRegisterType type)
 {
-    if (!m_modbusRegisters.contains(type))
+    if (!m_modbusRegisters.contains(type)) {
+        qCWarning(dcEnergyMeters()) << "EnergyMeter: Register type not supported" << type;
+        setConnectionStatus(false);
         return false;
+    }
 
-    if (!m_modbusRtuMaster)
+    if (!m_modbusRtuMaster) {
+        qCWarning(dcEnergyMeters()) << "EnergyMeter: Modbus RTU interface not available";
+        setConnectionStatus(false);
         return false;
+    }
 
-    if (!m_modbusRtuMaster->connected())
+    if (!m_modbusRtuMaster->connected()) {
+        qCWarning(dcEnergyMeters()) << "EnergyMeter: Modbus RTU interface not connected";
+        setConnectionStatus(false);
         return false;
+    }
 
     ModbusRegisterDescriptor descriptor = m_modbusRegisters.value(type);
 
@@ -134,16 +143,9 @@ bool EnergyMeter::getRegister(ModbusRegisterType type)
     connect(reply, &ModbusRtuReply::finished, reply, &ModbusRtuReply::deleteLater);
     connect(reply, &ModbusRtuReply::finished, this, [reply, type, descriptor, this] {
         if (reply->error() != ModbusRtuReply::NoError) {
-            if (m_connected) {
-                m_connected = false;
-                emit connectedChanged(m_connected);
-            }
+            qCWarning(dcEnergyMeters()) << "EnergyMeter: Modbus RTU reply error" << reply->errorString();
+            setConnectionStatus(false);
             return;
-        } else {
-            if (!m_connected) {
-                m_connected = true;
-                emit connectedChanged(m_connected);
-            }
         }
         modbus_32_t value;
         value.u = 0;
@@ -153,9 +155,11 @@ bool EnergyMeter::getRegister(ModbusRegisterType type)
             if (descriptor.dataType() == "float") {
                 value.u = static_cast<float>(static_cast<uint32_t>(reply->result().at(0)) << 16 | reply->result().at(1));
             } else {
-                qCWarning(dcEnergyMeters()) << "Data type not supported" << descriptor.dataType();
+                qCWarning(dcEnergyMeters()) << "EnergyMeter: Data type not supported" << descriptor.dataType();
             }
         } else {
+            qCWarning(dcEnergyMeters()) << "EnergyMeter: Reply length invalid" << reply->result().length();
+            setConnectionStatus(false);
             return;
         }
 
@@ -214,6 +218,14 @@ bool EnergyMeter::getRegister(ModbusRegisterType type)
             qCWarning(dcEnergyMeters()) << "EnergyMeter: Modbus register type not handled" << type;
         }
     });
+    setConnectionStatus(true);
     return true;
 }
 
+void EnergyMeter::setConnectionStatus(bool connected)
+{
+    if (connected != m_connected) {
+        m_connected = connected;
+        emit connectedChanged(m_connected);
+    }
+}
diff --git a/energymeters/energymeter.h b/energymeters/energymeter.h
index 208fb23..974fb72 100644
--- a/energymeters/energymeter.h
+++ b/energymeters/energymeter.h
@@ -74,6 +74,7 @@ private:
     QHash<ModbusRegisterType, ModbusRegisterDescriptor> m_modbusRegisters;
 
     bool getRegister(ModbusRegisterType type);
+    void setConnectionStatus(bool connected);
 
 signals:
     void connectedChanged(bool connected);
diff --git a/energymeters/integrationpluginenergymeters.cpp b/energymeters/integrationpluginenergymeters.cpp
index 91eb130..78903cd 100644
--- a/energymeters/integrationpluginenergymeters.cpp
+++ b/energymeters/integrationpluginenergymeters.cpp
@@ -126,7 +126,7 @@ void IntegrationPluginEnergyMeters::discoverThings(ThingDiscoveryInfo *info)
     }
     uint slaveAddress = info->params().paramValue(m_discoverySlaveAddressParamTypeIds.value(info->thingClassId())).toUInt();
     if (slaveAddress > 254 || slaveAddress == 0) {
-        info->finish(Thing::ThingErrorInvalidParameter, tr("Modbus slave address must be between 1 and 254"));
+        info->finish(Thing::ThingErrorInvalidParameter, QT_TR_NOOP("Modbus slave address must be between 1 and 254"));
         return;
     }
     Q_FOREACH(ModbusRtuMaster *modbusMaster, hardwareManager()->modbusRtuResource()->modbusRtuMasters()) {
@@ -174,7 +174,7 @@ void IntegrationPluginEnergyMeters::setupThing(ThingSetupInfo *info)
     EnergyMeter *meter = new EnergyMeter(hardwareManager()->modbusRtuResource()->getModbusRtuMaster(uuid), address, m_registerMaps.value(thing->thingClassId()), this);
     connect(info, &ThingSetupInfo::aborted, meter, &EnergyMeter::deleteLater);
     connect(meter, &EnergyMeter::consumedEnergyReceived, info, [this, info, meter] (double energy) {
-        qCDebug(dcEnergyMeters()) << "Consumed energy receieved" << energy << "Setup finished";
+        qCDebug(dcEnergyMeters()) << "Consumed energy received" << energy << "Setup finished";
         connect(meter, &EnergyMeter::connectedChanged, this, &IntegrationPluginEnergyMeters::onConnectionStateChanged);
         connect(meter, &EnergyMeter::voltageL1Received, this, &IntegrationPluginEnergyMeters::onVoltageL1Received);
         connect(meter, &EnergyMeter::voltageL2Received, this, &IntegrationPluginEnergyMeters::onVoltageL2Received);
@@ -209,15 +209,18 @@ void IntegrationPluginEnergyMeters::postSetupThing(Thing *thing)
     }
 
     if (!m_reconnectTimer) {
+        qCDebug(dcEnergyMeters()) << "Starting reconnect timer";
         m_reconnectTimer = hardwareManager()->pluginTimerManager()->registerTimer(5);
         connect(m_reconnectTimer, &PluginTimer::timeout, this, [this] {
             foreach (Thing *thing, myThings()) {
                 if (m_connectionStateTypeIds.contains(thing->thingClassId())) {
                     if (!thing->stateValue(m_connectionStateTypeIds.value(thing->thingClassId())).toBool()) {
                         EnergyMeter *meter = m_energyMeters.value(thing);
-                        if (!meter)
+                        if (!meter) {
+                            qCWarning(dcEnergyMeters()) << "On reconnect timer, could not find any EnergyMeter connection for" << thing->name();
                             continue;
-
+                        }
+                        qCDebug(dcEnergyMeters()) << "On reconnect timer, restarting update cycle for" << thing->name();
                         startUpdateCycle(meter);
                     }
                 }
@@ -247,6 +250,7 @@ void IntegrationPluginEnergyMeters::startUpdateCycle(EnergyMeter *meter)
 {
     if (m_updateCycleInProgress.contains(meter)) {
         if (m_updateCycleInProgress.value(meter)) {
+            qCWarning(dcEnergyMeters()) << "Update cycle not startet, update cycle already in progress";
             return;
         }
     }