From 0a6464178bbce3dd0ea99255224e5a1ea33e7679 Mon Sep 17 00:00:00 2001
From: Ake Hedman <akhe@grodansparadis.com>
Date: Thu, 12 Dec 2024 23:20:53 +0100
Subject: [PATCH] Fixed some annoying warnings

---
 src/common/sockettcp.c                    |   2 +-
 src/vscp/common/mdf.cpp                   |  24 +-
 src/vscp/common/register.cpp              |  36 +-
 src/vscp/common/vscp-bootdevice-pic1.cpp  |   6 +-
 src/vscp/common/vscp-bootdevice-vscp.cpp  | 425 +++++++++++++++-------
 src/vscp/common/vscp-bootdevice-vscp.h    |   2 +-
 src/vscp/common/vscp-client-base.cpp      |   4 +-
 src/vscp/common/vscp-client-base.h        |  31 +-
 src/vscp/common/vscp-client-canal.cpp     |  12 +-
 src/vscp/common/vscp-client-mqtt.cpp      |  18 +-
 src/vscp/common/vscp-client-multicast.cpp |  20 +-
 src/vscp/common/vscp-client-socketcan.cpp |  93 +++--
 src/vscp/common/vscp-client-socketcan.h   |  22 +-
 src/vscp/common/vscp-client-tcp.cpp       |   2 +-
 src/vscp/common/vscp-client-udp.cpp       |  20 +-
 src/vscp/common/vscp-client-ws1.cpp       |   8 +-
 src/vscp/common/vscp-client-ws2.cpp       |  36 +-
 src/vscp/common/vscpcanaldeviceif.cpp     |   4 +-
 src/vscp/common/vscphelper.cpp            |  18 +-
 src/vscp/common/vscphelper.h              |   2 +-
 20 files changed, 520 insertions(+), 265 deletions(-)

diff --git a/src/common/sockettcp.c b/src/common/sockettcp.c
index 5d5885e63..ea66e13f4 100644
--- a/src/common/sockettcp.c
+++ b/src/common/sockettcp.c
@@ -2572,7 +2572,7 @@ stcp_connect_remote_impl( const char *host,
                             int port,
                             struct stcp_secure_options *secure_options,
                             int bUseSSL,
-                            int timeout )
+                            int /*timeout*/ )
 {
     struct stcp_connection *conn = NULL;
     int sock;
diff --git a/src/vscp/common/mdf.cpp b/src/vscp/common/mdf.cpp
index 50d80a256..f85102265 100644
--- a/src/vscp/common/mdf.cpp
+++ b/src/vscp/common/mdf.cpp
@@ -1827,7 +1827,7 @@ void
 CMDF::writeMap_json(std::ofstream &fout,
                     std::map<std::string, std::string> *pmap,
                     const std::string &tag,
-                    bool bCommaAtEnd)
+                    bool /*bCommaAtEnd*/)
 {
   if ((nullptr != pmap) && pmap->size()) {
     fout << "," << std::endl;
@@ -1919,7 +1919,7 @@ CMDF::save_xml(const std::string &path)
     }
 
     if ((cnt = pManufacturer->getPhoneObjCount())) {
-      for (int i = 0; i < cnt; i++) {
+      for (size_t i = 0; i < cnt; i++) {
         CMDF_Item *pitem = pManufacturer->getPhoneObj(i);
         if (nullptr != pitem) {
           fout << "<telephone>" << std::endl;
@@ -1932,7 +1932,7 @@ CMDF::save_xml(const std::string &path)
     }
 
     if ((cnt = pManufacturer->getFaxObjCount())) {
-      for (int i = 0; i < cnt; i++) {
+      for (size_t i = 0; i < cnt; i++) {
         CMDF_Item *pitem = pManufacturer->getFaxObj(i);
         if (nullptr != pitem) {
           fout << "<fax>" << std::endl;
@@ -1945,7 +1945,7 @@ CMDF::save_xml(const std::string &path)
     }
 
     if ((cnt = pManufacturer->getEmailObjCount())) {
-      for (int i = 0; i < cnt; i++) {
+      for (size_t i = 0; i < cnt; i++) {
         CMDF_Item *pitem = pManufacturer->getEmailObj(i);
         if (nullptr != pitem) {
           fout << "<email>" << std::endl;
@@ -1958,7 +1958,7 @@ CMDF::save_xml(const std::string &path)
     }
 
     if ((cnt = pManufacturer->getWebObjCount())) {
-      for (int i = 0; i < cnt; i++) {
+      for (size_t i = 0; i < cnt; i++) {
         CMDF_Item *pitem = pManufacturer->getWebObj(i);
         if (nullptr != pitem) {
           fout << "<web>" << std::endl;
@@ -1971,7 +1971,7 @@ CMDF::save_xml(const std::string &path)
     }
 
     if ((cnt = pManufacturer->getSocialObjCount())) {
-      for (int i = 0; i < cnt; i++) {
+      for (size_t i = 0; i < cnt; i++) {
         CMDF_Item *pitem = pManufacturer->getSocialObj(i);
         if (nullptr != pitem) {
           fout << "<social>" << std::endl;
@@ -1999,7 +1999,7 @@ CMDF::save_xml(const std::string &path)
 
   std::deque<CMDF_Picture *> *pPictureQueue = getPictureObjList();
   if ((nullptr != pPictureQueue) && (pPictureQueue->size())) {
-    size_t pos = 0;
+    //size_t pos = 0;
     for (auto it = pPictureQueue->begin(); it != pPictureQueue->end(); it++) {
       CMDF_Picture *pPicture = *it;
       fout << "<picture name=\"" << pPicture->getName() << "\" ";
@@ -2013,7 +2013,7 @@ CMDF::save_xml(const std::string &path)
 
   std::deque<CMDF_Video *> *pVideoQueue = getVideoObjList();
   if ((nullptr != pVideoQueue) && (pVideoQueue->size())) {
-    size_t pos = 0;
+    //size_t pos = 0;
     for (auto it = pVideoQueue->begin(); it != pVideoQueue->end(); it++) {
       CMDF_Video *pVideo = *it;
       fout << "<video name=\"" << pVideo->getName() << "\" ";
@@ -2027,7 +2027,7 @@ CMDF::save_xml(const std::string &path)
 
   std::deque<CMDF_Manual *> *pManualQueue = getManualObjList();
   if ((nullptr != pManualQueue) && (pManualQueue->size())) {
-    size_t pos = 0;
+    //size_t pos = 0;
     for (auto it = pManualQueue->begin(); it != pManualQueue->end(); it++) {
       CMDF_Manual *pManual = *it;
       fout << "<manual name=\"" << pManual->getName() << "\" ";
@@ -2042,7 +2042,7 @@ CMDF::save_xml(const std::string &path)
 
   std::deque<CMDF_Firmware *> *pFirmwareQueue = getFirmwareObjList();
   if ((nullptr != pFirmwareQueue) && (pFirmwareQueue->size())) {
-    size_t pos = 0;
+    //size_t pos = 0;
     for (auto it = pFirmwareQueue->begin(); it != pFirmwareQueue->end(); it++) {
       CMDF_Firmware *pFirmware = *it;
       fout << "<firmware name=\"" << pFirmware->getName() << "\" ";
@@ -2065,7 +2065,7 @@ CMDF::save_xml(const std::string &path)
 
   std::deque<CMDF_Driver *> *pDriverQueue = getDriverObjList();
   if ((nullptr != pDriverQueue) && (pDriverQueue->size())) {
-    size_t pos = 0;
+    //size_t pos = 0;
     for (auto it = pDriverQueue->begin(); it != pDriverQueue->end(); it++) {
       CMDF_Driver *pDriver = *it;
       fout << "<driver name=\"" << pDriver->getName() << "\" ";
@@ -2113,7 +2113,7 @@ CMDF::save_xml(const std::string &path)
   // get pages
   std::set<uint16_t> pages;
   std::deque<CMDF_Register *> *pregs = getRegisterObjList();
-  uint32_t nPageCnt                  = getPages(pages);
+  //uint32_t nPageCnt                  = getPages(pages);
 
   // Go throu pages
   for (auto itr : pages) {
diff --git a/src/vscp/common/register.cpp b/src/vscp/common/register.cpp
index 060dffec4..df99ae37e 100644
--- a/src/vscp/common/register.cpp
+++ b/src/vscp/common/register.cpp
@@ -79,7 +79,7 @@ vscp_readLevel1Register(CVscpClient &client,
   int rv = VSCP_ERROR_ERROR;
   vscpEventEx ex;
 
-  CVscpClient::connType conntype = client.getType();
+  //CVscpClient::connType conntype = client.getType();
   uint8_t nickname               = guidNode.getNickname();
   uint8_t ifoffset               = guidInterface.isNULL() ? 0 : 16;
 
@@ -160,7 +160,7 @@ vscp_writeLevel1Register(CVscpClient &client,
 {
   int rv = VSCP_ERROR_ERROR;
   vscpEventEx ex;
-  CVscpClient::connType conntype = client.getType();
+  //CVscpClient::connType conntype = client.getType();
   uint8_t nickname               = guidNode.getNickname();
   uint8_t ifoffset               = guidInterface.isNULL() ? 0 : 16;
 
@@ -247,7 +247,7 @@ vscp_readLevel1RegisterBlock(CVscpClient &client,
   int rv         = VSCP_ERROR_ERROR;
   uint8_t rcvcnt = 0; // Number of registers read
   vscpEventEx ex;
-  CVscpClient::connType conntype = client.getType();
+  //CVscpClient::connType conntype = client.getType();
   uint8_t nickname               = guidNode.getNickname();
   uint8_t ifoffset               = guidInterface.isNULL() ? 0 : 16;
 
@@ -374,13 +374,13 @@ vscp_writeLevel1RegisterBlock(CVscpClient &client,
                               uint32_t timeout)
 {
   int rv                         = VSCP_ERROR_SUCCESS;
-  CVscpClient::connType conntype = client.getType();
+  //CVscpClient::connType conntype = client.getType();
   uint8_t nickname               = guidNode.getNickname();
   uint8_t ifoffset               = guidInterface.isNULL() ? 0 : 16;
   int reg                        = -99;
   int count                      = 0;
   vscpEventEx ex;
-  uint8_t offset_data = 0;
+  //uint8_t offset_data = 0;
   std::map<uint8_t, uint8_t> startmap;
 
   // The startregs map contains reg, count for each sequence start
@@ -439,7 +439,7 @@ vscp_writeLevel1RegisterBlock(CVscpClient &client,
       }
 
       uint32_t startTime    = vscp_getMsTimeStamp();
-      uint32_t callbackTime = vscp_getMsTimeStamp();
+      //uint32_t callbackTime = vscp_getMsTimeStamp();
 
       // Wait for reponse
 
@@ -598,7 +598,7 @@ vscp_scanSlowForDevices(CVscpClient &client,
   uint8_t offset = guidIf.isNULL() ? 0 : 16;
   int rv         = VSCP_ERROR_SUCCESS;
   vscpEventEx ex;
-  CVscpClient::connType conntype = client.getType();
+  //CVscpClient::connType conntype = client.getType();
 
   memset(&ex, 0, sizeof(vscpEventEx));
   ex.vscp_class = VSCP_CLASS1_PROTOCOL + (guidIf.isNULL() ? 0 : 512);
@@ -1035,7 +1035,7 @@ vscp_getDeviceInfoHtml(CMDF &mdf, CStandardRegisters &stdregs)
 
     html += "<br><b>Pictures</b><ul>";
 
-    for (int i = 0; i < mdf.getPictureCount(); i++) {
+    for (size_t i = 0; i < mdf.getPictureCount(); i++) {
       html += "<li><a href=\"";
       html += mdf.getPictureObj(i)->getUrl();
       html += "\">";
@@ -1056,7 +1056,7 @@ vscp_getDeviceInfoHtml(CMDF &mdf, CStandardRegisters &stdregs)
 
     html += "<br><b>Videos</b><ul>";
 
-    for (int i = 0; i < mdf.getVideoCount(); i++) {
+    for (size_t i = 0; i < mdf.getVideoCount(); i++) {
       html += "<li><a href=\"";
       html += mdf.getVideoObj(i)->getUrl();
       html += "\">";
@@ -1077,7 +1077,7 @@ vscp_getDeviceInfoHtml(CMDF &mdf, CStandardRegisters &stdregs)
 
     html += "<br><b>Firmware</b><ul>";
 
-    for (int i = 0; i < mdf.getFirmwareCount(); i++) {
+    for (size_t i = 0; i < mdf.getFirmwareCount(); i++) {
       html += "<li><a href=\"";
       html += mdf.getFirmwareObj(i)->getUrl();
       html += "\">";
@@ -1098,7 +1098,7 @@ vscp_getDeviceInfoHtml(CMDF &mdf, CStandardRegisters &stdregs)
 
     html += "<br><b>Drivers</b><ul>";
 
-    for (int i = 0; i < mdf.getDriverCount(); i++) {
+    for (size_t i = 0; i < mdf.getDriverCount(); i++) {
       html += "<li><a href=\"";
       html += mdf.getDriverObj(i)->getUrl();
       html += "\">";
@@ -1119,7 +1119,7 @@ vscp_getDeviceInfoHtml(CMDF &mdf, CStandardRegisters &stdregs)
 
     html += "<br><b>Manuals</b><ul>";
 
-    for (int i = 0; i < mdf.getManualCount(); i++) {
+    for (size_t i = 0; i < mdf.getManualCount(); i++) {
       html += "<li><a href=\"";
       html += mdf.getManualObj(i)->getUrl();
       html += "\">";
@@ -1140,7 +1140,7 @@ vscp_getDeviceInfoHtml(CMDF &mdf, CStandardRegisters &stdregs)
 
     html += "<br><b>Setup wizards</b><ul>";
 
-    for (int i = 0; i < mdf.getSetupCount(); i++) {
+    for (size_t i = 0; i < mdf.getSetupCount(); i++) {
       html += "<li><a href=\"";
       html += mdf.getSetupObj(i)->getUrl();
       html += "\">";
@@ -1812,8 +1812,8 @@ CUserRegisters::remoteVarFromRegToString(CMDF_RemoteVariable &remoteVar, std::st
         for (int i = 0; i < remoteVar.getTypeByteCount(); i++) {
           buf[i] = ppage->getReg(remoteVar.getOffset() + i);
         }
-        uint32_t n = VSCP_UINT32_SWAP_ON_LE(*((uint32_t *) buf));
-        float f    = *((float *) ((uint8_t *) &n));
+        //uint32_t n = VSCP_UINT32_SWAP_ON_LE(*((uint32_t *) buf));
+        //float f    = *((float *) ((uint8_t *) &n));
         strValue   = vscp_str_format("%f", *((float *) buf));
         free(buf);
       }
@@ -1826,8 +1826,8 @@ CUserRegisters::remoteVarFromRegToString(CMDF_RemoteVariable &remoteVar, std::st
         for (int i = 0; i < remoteVar.getTypeByteCount(); i++) {
           buf[i] = ppage->getReg(remoteVar.getOffset() + i);
         }
-        uint64_t n = VSCP_UINT32_SWAP_ON_LE(*((uint32_t *) buf));
-        double f   = *((double *) ((uint8_t *) &n));
+        //uint64_t n = VSCP_UINT32_SWAP_ON_LE(*((uint32_t *) buf));
+        //double f   = *((double *) ((uint8_t *) &n));
         strValue   = vscp_str_format("%g", *((double *) buf));
 
         free(buf);
@@ -1889,7 +1889,7 @@ CUserRegisters::remoteVarFromStringToReg(CMDF_RemoteVariable &remoteVar, std::st
         for a level I device but that is not a problem as they never
         will be written to the device.
       */
-      for (int i = 0; i < strValue.length(); i++) {
+      for (size_t i = 0; i < strValue.length(); i++) {
         ppage->putReg(remoteVar.getOffset() + i, strValue[i]);
       }
     } break;
diff --git a/src/vscp/common/vscp-bootdevice-pic1.cpp b/src/vscp/common/vscp-bootdevice-pic1.cpp
index ecfdcc63f..68639dfea 100644
--- a/src/vscp/common/vscp-bootdevice-pic1.cpp
+++ b/src/vscp/common/vscp-bootdevice-pic1.cpp
@@ -228,7 +228,7 @@ CBootDevice_PIC1::deviceInfo(void)
 //
 
 int
-CBootDevice_PIC1::deviceInit(cguid& ourguid, uint16_t devicecode, bool bAbortOnFirmwareCodeFail)
+CBootDevice_PIC1::deviceInit(cguid& ourguid, uint16_t /*devicecode*/, bool bAbortOnFirmwareCodeFail)
 {
   int rv;
 
@@ -664,7 +664,7 @@ CBootDevice_PIC1::checkResponseLevel1(uint32_t response_id)
 //
 
 int
-CBootDevice_PIC1::checkResponseLevel2(uint32_t id)
+CBootDevice_PIC1::checkResponseLevel2(uint32_t /*id*/)
 {
   int rv;
   vscpEventEx ex;
@@ -877,7 +877,7 @@ CBootDevice_PIC1::writeFirmwareBlock(uint32_t start, uint32_t end)
 //
 
 int
-CBootDevice_PIC1::deviceLoad(std::function<void(int, const char *)> statusCallback, bool bAbortOnFirmwareCodeFail)
+CBootDevice_PIC1::deviceLoad(std::function<void(int, const char *)> /*statusCallback*/, bool /*bAbortOnFirmwareCodeFail*/)
 {
   //bool bRun = true;
   int rv;
diff --git a/src/vscp/common/vscp-bootdevice-vscp.cpp b/src/vscp/common/vscp-bootdevice-vscp.cpp
index 3a42f82bd..7e8e991c3 100644
--- a/src/vscp/common/vscp-bootdevice-vscp.cpp
+++ b/src/vscp/common/vscp-bootdevice-vscp.cpp
@@ -35,7 +35,7 @@
 
 #include <stdio.h>
 
-#define CRC16
+#define CRC_CCITT
 #include <crc.h>
 
 #include <spdlog/async.h>
@@ -47,6 +47,11 @@
 #include <iostream>
 #include <sstream>
 
+///////////////////////////////////////////////////////////////////////////////
+// CTORS
+//
+
+// Level I
 CBootDevice_VSCP::CBootDevice_VSCP(CVscpClient *pclient,
                                    uint8_t nodeid,
                                    std::function<void(int, const char *)> statusCallback,
@@ -57,6 +62,7 @@ CBootDevice_VSCP::CBootDevice_VSCP(CVscpClient *pclient,
   init();
 }
 
+// Level I over interface
 CBootDevice_VSCP::CBootDevice_VSCP(CVscpClient *pclient,
                                    uint8_t nodeid,
                                    cguid &guidif,
@@ -68,6 +74,7 @@ CBootDevice_VSCP::CBootDevice_VSCP(CVscpClient *pclient,
   init();
 }
 
+// Level II
 CBootDevice_VSCP::CBootDevice_VSCP(CVscpClient *pclient,
                                    cguid &guid,
                                    std::function<void(int, const char *)> statusCallback,
@@ -211,17 +218,11 @@ CBootDevice_VSCP::deviceInfo(void)
 //
 
 int
-CBootDevice_VSCP::deviceInit(cguid &ourguid, uint16_t devicecode, bool bAbortOnFirmwareCodeFail)
+CBootDevice_VSCP::deviceInit(cguid & /*ourguid*/, uint16_t /*devicecode*/, bool bAbortOnFirmwareCodeFail)
 {
   int rv;
   vscpEventEx ex;
 
-  // Save our local GUID
-  m_ourguid = ourguid;
-
-  // Save Firmware device code 
-  m_firmwaredeviceCode = devicecode;
-
   // Read standard registers
   if (VSCP_ERROR_SUCCESS != m_stdRegs.init(*m_pclient, m_guid, m_guidif, nullptr, REGISTER_DEFAULT_TIMEOUT)) {
     spdlog::error("VSCP bootloader: Failed to read standard registers");
@@ -245,16 +246,17 @@ CBootDevice_VSCP::deviceInit(cguid &ourguid, uint16_t devicecode, bool bAbortOnF
     Must be the same as the firmware we try to load is intended for
   */
   if (m_firmwaredeviceCode != m_stdRegs.getFirmwareDeviceCode()) {
-    spdlog::warn("Firmware device code is not equal! Firmware: {0} Device: {1}",
+    spdlog::warn("Firmware device code is not equal! Firmware: {0} Device: {1} (disable requirement in configuration)",
                  m_firmwaredeviceCode,
                  m_stdRegs.getFirmwareDeviceCode());
     if (nullptr != m_statusCallback) {
-      m_statusCallback(-1,
-                        vscp_str_format(
-                          "Firmware device code is not equal! Firmware: {0} Device: {1}", 
-                            m_firmwaredeviceCode, 
-                            m_stdRegs.getFirmwareDeviceCode())
-                          .c_str());                       
+      m_statusCallback(
+        -1,
+        vscp_str_format(
+          "Firmware device code is not equal! Firmware: {0} Device: {1} (disable requirement in configuration)",
+          m_firmwaredeviceCode,
+          m_stdRegs.getFirmwareDeviceCode())
+          .c_str());
     }
     if (bAbortOnFirmwareCodeFail) {
       return VSCP_ERROR_PARAMETER;
@@ -298,7 +300,7 @@ CBootDevice_VSCP::deviceInit(cguid &ourguid, uint16_t devicecode, bool bAbortOnF
     return rv;
   }
 
-  // OK now in bootmode - return
+  // OK now in bootmode - return if valid block data
   m_blockSize = construct_unsigned32(ex.data[0], ex.data[1], ex.data[2], ex.data[3]);
   m_numBlocks = construct_unsigned32(ex.data[4], ex.data[5], ex.data[6], ex.data[7]);
   spdlog::debug("VSCP bootloader: Confirmed, device is in boot mood.");
@@ -340,12 +342,13 @@ CBootDevice_VSCP::writeBlockStart(uint32_t block, uint8_t type)
   cguid node_guid;
   m_stdRegs.getGUID(node_guid);
 
-  ex.sizeData = 8;
+  ex.sizeData = 6;
   ex.data[0]  = (block >> 24) & 0xff;
   ex.data[1]  = (block >> 16) & 0xff;
   ex.data[2]  = (block >> 8) & 0xff;
   ex.data[3]  = block & 0xff;
   ex.data[4]  = type;
+  ex.data[5]  = 0;
 
   if (VSCP_ERROR_SUCCESS != (rv = m_pclient->send(ex))) {
     spdlog::error("VSCP bootloader: Failed to send start block transfer event {0}", rv);
@@ -355,16 +358,20 @@ CBootDevice_VSCP::writeBlockStart(uint32_t block, uint8_t type)
     return rv;
   }
 
+
+
   // Wait for response on start block transfer event
   if (VSCP_ERROR_SUCCESS !=
       (rv = checkResponse(ex, node_guid, VSCP_TYPE_PROTOCOL_START_BLOCK_ACK, VSCP_TYPE_PROTOCOL_START_BLOCK_NACK))) {
     spdlog::error("VSCP bootloader: Negative response from block start request {0}", rv);
     if (nullptr != m_statusCallback) {
-      m_statusCallback(-1, "VSCP bootloader: Negative response from block start request");
+      m_statusCallback(-1,
+                       vscp_str_format("VSCP bootloader: Negative response from block start request %d", rv).c_str());
     }
     return rv;
   }
 
+
   return VSCP_ERROR_SUCCESS;
 }
 
@@ -386,7 +393,7 @@ CBootDevice_VSCP::programBlock(uint32_t block)
   cguid node_guid;
   m_stdRegs.getGUID(node_guid);
 
-  ex.sizeData = 8;
+  ex.sizeData = 4;
   ex.data[0]  = (block >> 24) & 0xff;
   ex.data[1]  = (block >> 16) & 0xff;
   ex.data[2]  = (block >> 8) & 0xff;
@@ -400,14 +407,14 @@ CBootDevice_VSCP::programBlock(uint32_t block)
     return rv;
   }
 
-  // Wait for response on start block transfer event
+  // Wait for response on program block data
   if (VSCP_ERROR_SUCCESS != (rv = checkResponse(ex,
                                                 node_guid,
                                                 VSCP_TYPE_PROTOCOL_PROGRAM_BLOCK_DATA_ACK,
                                                 VSCP_TYPE_PROTOCOL_PROGRAM_BLOCK_DATA_NACK))) {
-    spdlog::error("VSCP bootloader: Negative response from block start request {0}", rv);
+    spdlog::error("VSCP bootloader: Negative response from ProgramBlock. {0}", rv);
     if (nullptr != m_statusCallback) {
-      m_statusCallback(-1, "VSCP bootloader: Negative response from block start request");
+      m_statusCallback(-1, vscp_str_format("VSCP bootloader: Negative response from ProgramBlock. %d", rv).c_str());
     }
     return rv;
   }
@@ -452,10 +459,10 @@ CBootDevice_VSCP::writeChunk(const uint8_t *paddr, uint16_t size)
 
   // Wait for response on start block transfer event
   if (VSCP_ERROR_SUCCESS !=
-      (rv = checkResponse(ex, node_guid, VSCP_TYPE_PROTOCOL_START_BLOCK_ACK, VSCP_TYPE_PROTOCOL_START_BLOCK_NACK))) {
-    spdlog::error("VSCP bootloader: Negative response from block start request {0}", rv);
+      (rv = checkResponse(ex, node_guid, VSCP_TYPE_PROTOCOL_BLOCK_CHUNK_ACK, VSCP_TYPE_PROTOCOL_BLOCK_CHUNK_NACK))) {
+    spdlog::error("VSCP bootloader: Negative response from block chunk send {0}", rv);
     if (nullptr != m_statusCallback) {
-      m_statusCallback(-1, "VSCP bootloader: Negative response from block start request");
+      m_statusCallback(-1, vscp_str_format("VSCP bootloader: Negative response from block chunk send", rv).c_str());
     }
     return rv;
   }
@@ -468,12 +475,15 @@ CBootDevice_VSCP::writeChunk(const uint8_t *paddr, uint16_t size)
 //
 
 int
-CBootDevice_VSCP::writeBlock(const uint8_t *paddr)
+CBootDevice_VSCP::writeBlock(uint32_t block, const uint8_t *paddr)
 {
-  int rv;
-  // vscpEventEx ex;
+  int rv = VSCP_ERROR_SUCCESS;
   cguid guid;
-  uint32_t nChunks;
+  uint32_t nChunks = 1;
+  vscpEventEx ex;
+
+  cguid node_guid;
+  m_stdRegs.getGUID(node_guid);
 
   if (m_blockSize > m_chunkSize) {
     nChunks = m_blockSize / m_chunkSize;
@@ -482,34 +492,59 @@ CBootDevice_VSCP::writeBlock(const uint8_t *paddr)
       nChunks++;
     }
   }
-  else {
-    // There is just one chunk
-    // We have taken care of chunk > block in init
-    nChunks = 1;
-  }
 
   for (uint32_t chunk = 0; chunk < nChunks; chunk++) {
 
-    spdlog::debug("Loading memory chunk on remote device. chunk={0} {1:X} ", chunk, chunk * m_chunkSize);
+    spdlog::debug("VSCP bootloader: memory chunk on remote device. chunk={0} {1:X} ", chunk, chunk * m_chunkSize);
     if (nullptr != m_statusCallback) {
-      m_statusCallback((100 * chunk) / nChunks,
-                       vscp_str_format("Loading memory chunk on remote device. chunk = %d.", chunk).c_str());
+      m_statusCallback(
+        -1 /*(100 * chunk) / nChunks*/,
+        // vscp_str_format("VSCP bootloader: Loading memory chunk on remote device. chunk = %d.", chunk).c_str()
+        "");
     }
 
-    if (VSCP_ERROR_SUCCESS != writeChunk(paddr + (m_chunkSize * nChunks), m_chunkSize)) {
-      spdlog::error("Failed to write chunk to remote device. rv={}", rv);
+    if (VSCP_ERROR_SUCCESS != (rv = writeChunk(paddr + (chunk * m_chunkSize), m_chunkSize))) {
+      spdlog::error("VSCP bootloader: Failed to write chunk to remote device. rv={}", rv);
       if (nullptr != m_statusCallback) {
-        m_statusCallback((100 * chunk) / nChunks,
-                         vscp_str_format("Failed to write chunk to remote device rv=%d.", rv).c_str());
+        m_statusCallback(
+          (100 * chunk) / nChunks,
+          vscp_str_format("VSCP bootloader: Failed to write chunk %lu/%lu to remote device rv=%d.", chunk, nChunks, rv)
+            .c_str());
+        spdlog::error("VSCP bootloader: Failed to write chunk {0}/{1} to remote device rv={2}.", chunk, nChunks, rv);
       }
       break;
     }
 
-    paddr += m_chunkSize;
-
   } // for
 
-  return VSCP_ERROR_SUCCESS;
+  // Wait for data block ACK/NACK response
+  if (VSCP_ERROR_SUCCESS !=
+      (rv = checkResponse(ex, node_guid, VSCP_TYPE_PROTOCOL_BLOCK_DATA_ACK, VSCP_TYPE_PROTOCOL_BLOCK_DATA_NACK))) {
+    spdlog::error("VSCP bootloader: NACK received for data block {0}", rv);
+    if (nullptr != m_statusCallback) {
+      m_statusCallback(-1, "VSCP bootloader: NACK received for data block");
+    }
+  }
+
+  // Check that the crc is equal
+  uint16_t crc_block    = crcFast(paddr, m_blockSize);
+  uint16_t crc_packet   = construct_unsigned16(ex.data[0], ex.data[1]);
+  uint32_t block_packet = construct_unsigned32(ex.data[2], ex.data[3], ex.data[4], ex.data[5]);
+
+  if ((crc_packet != crc_block) || (block_packet != block)) {
+    spdlog::error("VSCP bootloader: CRC error for block. CRC Packet={0:0X} CRC_Block={1:0X}", crc_packet, crc_block);
+    if (nullptr != m_statusCallback) {
+      m_statusCallback(
+        -1,
+        vscp_str_format("VSCP bootloader: CRC error for block CRC Packet=%04X CRC_Block=%04X", crc_packet, crc_block)
+          .c_str());
+    }
+    return VSCP_ERROR_INVALID_FRAME; // TODO: Change to CRC error
+  }
+
+  // We have a valid block
+
+  return rv;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -517,9 +552,9 @@ CBootDevice_VSCP::writeBlock(const uint8_t *paddr)
 //
 
 int
-CBootDevice_VSCP::deviceLoad(std::function<void(int, const char *)> statusCallback, bool bAbortOnFirmwareCodeFail)
+CBootDevice_VSCP::deviceLoad(std::function<void(int, const char *)> /*statusCallback*/, bool /*bAbortOnFirmwareCodeFail*/)
 {
-  int rv;
+  int rv = VSCP_ERROR_SUCCESS;
   std::string strStatus;
 
   m_checksum = 0;
@@ -532,115 +567,226 @@ CBootDevice_VSCP::deviceLoad(std::function<void(int, const char *)> statusCallba
   m_checksum = 0;
 
   // Iterate over memory types
-  for (int pos = 0; pos < NUMBER_OF_MEMORY_TYPES; pos++) {
+  for (int memtype = 0; memtype < NUMBER_OF_MEMORY_TYPES; memtype++) {
 
-    spdlog::error("writeFirmwareBlock: Handling memory range {0}", memory_range[pos].type);
+    spdlog::debug("VSCP bootloader: Memory type {0}", m_memory_range[memtype].type);
     if (nullptr != m_statusCallback) {
-      m_statusCallback(-1,
-                       vscp_str_format("writeFirmwareBlock: Handling memory range %d", memory_range[pos].type).c_str());
+      m_statusCallback(-1, vscp_str_format("VSCP bootloader: Memory type %d", m_memory_range[memtype].type).c_str());
     }
 
     uint32_t minAddr;
     uint32_t maxAddr;
 
-    // Fetch min and max address for selected memory range
+    // Fetch min and max address for selected memory type
     if (VSCP_ERROR_SUCCESS !=
-        (rv = getMinMaxForRange(memory_range[pos].beginning, memory_range[pos].end, &minAddr, &maxAddr))) {
-      spdlog::error("writeFirmwareBlock: Failed to get min max range for block {0:X}-{1:X} rv=%d",
-                    minAddr,
-                    maxAddr,
-                    rv);
+        (rv = getMinMaxForRange(m_memory_range[memtype].start, m_memory_range[memtype].end, &minAddr, &maxAddr))) {
+      spdlog::error("VSCP bootloader: Failed to get min max range for memory type {0} rv={1}", memtype, rv);
       if (nullptr != m_statusCallback) {
         m_statusCallback(
           -1,
-          vscp_str_format("writeFirmwareBlock: Failed to get min max range for block. rv=%d", rv).c_str());
+          vscp_str_format("VSCP bootloader: Failed to get min max range for memory type %d. rv=%d", memtype, rv)
+            .c_str());
       }
-      return rv;
+      continue;
     }
 
-    // If there is a memory range to work with
-    if (maxAddr > minAddr) {
+    // Check if there is any data to write
+    if (maxAddr <= minAddr) {
+      spdlog::error("VSCP bootloader: No data to write for memory type {0} block {1:X}-{2:X}.",
+                    memtype,
+                    m_memory_range[memtype].start,
+                    m_memory_range[memtype].end);
+      if (nullptr != m_statusCallback) {
+        m_statusCallback(-1,
+                         vscp_str_format("VSCP bootloader: No data to write for memory type %d block %X-%X.",
+                                         memtype,
+                                         m_memory_range[memtype].start,
+                                         m_memory_range[memtype].end)
+                           .c_str());
+      }
+      continue;
+    }
+
+    /*
+      The block where the first bytes of the image is located.
+    */
+    uint32_t startBlock = minAddr / m_blockSize;
+    spdlog::debug("VSCP bootloader: Startblock {0}.", startBlock);
 
-      /*!
-        The number of blocks to transfer count from the first byte to the
-        last byte. The lowest address may need to be adjusted to a block
-        boundary. There is no ned to do this for the upper address
-      */
-      minAddr -= (minAddr % m_blockSize); // Adjust to block boundary
+    /*
+      The number of blocks to transfer count from the first byte to the
+      last byte. The lowest address may need to be adjusted to a block
+      boundary. There is no need to do this for the upper address
+    */
+    uint32_t nBlocks = (maxAddr - minAddr) / m_blockSize;
 
-      uint32_t nBlocks = (maxAddr - minAddr) / m_blockSize;
-      // A not completely full packet also count
-      if (0 != ((maxAddr - minAddr) % m_blockSize)) {
-        nBlocks++;
+    // A not completely full packet also count
+    if (0 != ((maxAddr - minAddr) % m_blockSize)) {
+      nBlocks++;
+    }
+
+    spdlog::debug("VSCP bootloader: Number of blocks {0}.", nBlocks);
+
+    /*
+      Allocate buffer memory for the block
+      Some notes to remember (and handle):
+       - Blocksize can be less than data size (ChunkSize) for a frame (8/512)
+    */
+    uint8_t *pbuf = new uint8_t[m_blockSize * nBlocks];
+    if (nullptr == pbuf) {
+      spdlog::error("VSCP bootloader: Failed to allocate memory for block {0:X}-{1:X}.", minAddr, maxAddr);
+      if (nullptr != m_statusCallback) {
+        m_statusCallback(
+          -1,
+          vscp_str_format("VSCP bootloader: Failed to allocate memory for block {0:X}-{1:X}.", minAddr, maxAddr)
+            .c_str());
       }
+      return VSCP_ERROR_MEMORY;
+    }
 
-      uint32_t startBlock = (minAddr - memory_range[pos].beginning) / m_blockSize;
+    // Init the memory image. Fill unused positions with 0xff
+    // After fill we have a block with data that is
+    // offset memory_range[pos].beginning
+    if (VSCP_ERROR_SUCCESS != (rv = fillMemoryBuffer(pbuf,
+                                                     m_blockSize * nBlocks,
+                                                     m_memory_range[memtype].start,
+                                                     m_memory_range[memtype].end,
+                                                     startBlock * m_blockSize))) {
+      spdlog::error("VSCP bootloader: Failed to fill memory buffer with data.");
+      if (nullptr != m_statusCallback) {
+        m_statusCallback(
+          -1,
+          vscp_str_format("VSCP bootloader: Failed to fill memory buffer with with data rv=%d", rv).c_str());
+      }
+      delete[] pbuf;
+      return rv;
+    }
 
-      /*
-        Some notes to remember (and handle):
-         - Blocksize can be less than data size (ChunkSize) for a frame (8/512)
-         - A block size that is less than
-      */
-      uint8_t *pbuf = new uint8_t[memory_range[pos].end - memory_range[pos].beginning + 1];
+    spdlog::debug("VSCP bootloader: Filled memory buffer with with data.");
+    m_statusCallback(-1, vscp_str_format("VSCP bootloader: Filled memory buffer with with data.").c_str());
 
-      // Init the memory image. Fill unused positions with 0xff
-      // After fill we have a block with data that is that is
-      // offset memory_range[pos].beginning
-      if (VSCP_ERROR_SUCCESS != (rv = fillMemoryBuffer(pbuf, m_blockSize, memory_range[pos].beginning))) {
-        spdlog::error("writeFirmwareBlock: Failed to fill code block with data.");
-        if (nullptr != m_statusCallback) {
-          m_statusCallback(
-            -1,
-            vscp_str_format("writeFirmwareBlock: Failed to fill code block with data rv=%d", rv).c_str());
-        }
-        delete[] pbuf;
-        return rv;
+    // Write blocks to remote device
+
+    uint32_t block = 0;
+    while (block < nBlocks) {
+
+      spdlog::debug("VSCP bootloader: Start block {0} of {1}.", block, nBlocks);
+      if (nullptr != m_statusCallback) {
+        m_statusCallback(
+          -1,
+          vscp_str_format("VSCP bootloader: Start block %lu of %lu", (unsigned long) block, (unsigned long) nBlocks)
+            .c_str());
       }
 
-      // Write blocks to remote device
+      // ----------------------------------------------------------------------
 
-      uint32_t block = 0;
-      while (block < nBlocks) {
+      int trycnt = 3; // We give block transfer + program three tries for each block
+      while (trycnt > 0) {
 
         /*!
           * * * start block * * *
 
-          Startblock is the first block in an area. The block number
-          is given and also memory type. Blocknumbers can skip
+          Startblock is the first block in an area. The block number6
+          is given and also memory type. It is possible to skip
           blocks that should not be written.
          */
-        if (VSCP_ERROR_SUCCESS != (rv = writeBlockStart(block, memory_range[pos].type))) {
+        if (VSCP_ERROR_SUCCESS != (rv = writeBlockStart(block, m_memory_range[memtype].type))) {
+          spdlog::error("VSCP bootloader: Failed to write block {0}, memory-type={1}, rv={3}.", block, memtype, rv);
+          if (nullptr != m_statusCallback) {
+            m_statusCallback(-1,
+                             vscp_str_format("VSCP bootloader: Failed to write block %lu, memory-type=%d, rv=%d",
+                                             (unsigned long) block,
+                                             memtype,
+                                             rv)
+                               .c_str());
+          }
+          trycnt--;
+          if (trycnt > 0) {
+            spdlog::debug("VSCP bootloader: Retry block start {0}.", block);
+            continue;
+          }
+          // Last try failed
           delete[] pbuf;
           return rv;
         }
 
+        spdlog::debug("VSCP bootloader: Block start succeeded {0}.", block);
+        if (nullptr != m_statusCallback) {
+          m_statusCallback(
+            -1,
+            vscp_str_format("VSCP bootloader: Block start succeeded %lu ", (unsigned long) block).c_str());
+        }
+
+        // for (int i = 0; i < m_blockSize; i++) {
+        //   printf("%02X ", pbuf[block * m_blockSize + i]);
+        //   if (i % 8 == 7) {
+        //     printf("\n");
+        //   }
+        // }
+
         // Write the block
-        if (VSCP_ERROR_SUCCESS != (rv = writeBlock(pbuf + (block * m_blockSize)))) {
+        if (VSCP_ERROR_SUCCESS != (rv = writeBlock(block, pbuf + (block * m_blockSize)))) {
           spdlog::error("VSCP bootloader: Failed to write block {0}", rv);
           if (nullptr != m_statusCallback) {
-            m_statusCallback(-1, "VSCP bootloader: Failed to write block");
+            m_statusCallback(
+              -1,
+              vscp_str_format("VSCP bootloader: Failed to write block %lu rv=%d", (unsigned long) block, rv).c_str());
           }
+          trycnt--;
+          if (trycnt > 0) {
+            spdlog::debug("VSCP bootloader: Retry write block {0}.", block);
+            continue;
+          }
+          // Last try failed
           delete[] pbuf;
           return rv;
         }
 
+        spdlog::debug("VSCP bootloader: Write block succeeded {0}.", block);
+
         // Program the block
         if (VSCP_ERROR_SUCCESS != (rv = programBlock(block))) {
+          spdlog::error("VSCP bootloader: Program block failed. block={0} rv={1}", block, rv);
+          if (nullptr != m_statusCallback) {
+            m_statusCallback(
+              -1,
+              vscp_str_format("VSCP bootloader: Program block failed. block=%lu rv=%d", (unsigned long) block, rv)
+                .c_str());
+          }
+          trycnt--;
+          if (trycnt > 0) {
+            spdlog::debug("VSCP bootloader: Retry block start {0}.", block);
+            continue;
+          }
+          // Last try failed
           delete[] pbuf;
           return rv;
         }
 
-        // Next block
-        block++;
+        spdlog::debug("VSCP bootloader: Program block succeeded {0}.", block);
+        // Update transfer status
+        if (nullptr != m_statusCallback) {
+          m_statusCallback(
+            (100 * block) / nBlocks,
+            vscp_str_format("VSCP bootloader: Program block succeeded %lu ", (unsigned long) block).c_str());
+        }
+        // Done
+        trycnt = 0;
 
-      } // Writing blocks
+      } // while block
 
-      delete[] pbuf;
+      // ----------------------------------------------------------------------
+
+      // Next block
+      block++;
+
+    } // Writing blocks
+
+    delete[] pbuf;
 
-    } // There is bytes to write
   } // for memory types
 
-  return VSCP_ERROR_TIMEOUT;
+  return rv;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -651,7 +797,6 @@ int
 CBootDevice_VSCP::deviceReboot(void)
 {
   // int rv;
-
   return VSCP_ERROR_SUCCESS;
 }
 
@@ -687,32 +832,66 @@ CBootDevice_VSCP::checkResponse(vscpEventEx &ex,
 
       rv = m_pclient->receive(ex);
 
-      spdlog::debug("VSCP Bootloader: Received event: class={0} type={1} size={2}",
+      cguid evguid(ex.GUID);
+
+      spdlog::debug("VSCP Bootloader: Received event: class={0} type={1} size={2} ev.guid={3} guid={4}",
                     ex.vscp_class,
                     ex.vscp_type,
-                    ex.sizeData);
+                    ex.sizeData,
+                    evguid.toString(),
+                    guid.toString());
 
-      // Is this a read/write reply from the node?
-      if ((VSCP_CLASS1_PROTOCOL == ex.vscp_class) && (response_event_ack == ex.vscp_type) && guid.isSameGUID(ex.GUID)) {
-        // ACK response
-        spdlog::debug("VSCP Bootloader: ACK received.");
-        if (nullptr != m_statusCallback) {
-          m_statusCallback(-1, "VSCP Bootloader:ACK received");
+      if (m_pclient->isFullLevel2()) {
+
+        // Is this an ack reply from the node?
+        if ((VSCP_CLASS1_PROTOCOL == ex.vscp_class) && (response_event_ack == ex.vscp_type) &&
+            guid.isSameGUID(ex.GUID)) {
+          // ACK response
+          spdlog::debug("VSCP bootloader: Check response: Level II ACK received.");
+          if (nullptr != m_statusCallback) {
+            m_statusCallback(-1, "VSCP bootloader: Check response: Level II ACK received");
+          }
+          rv = VSCP_ERROR_SUCCESS;
+          break;
+        }
+
+        // Is this a nack reply from the node?
+        if ((VSCP_CLASS1_PROTOCOL == ex.vscp_class) && (response_event_nack == ex.vscp_type) &&
+            guid.isSameGUID(ex.GUID)) {
+          // NACK response
+          spdlog::error("VSCP bootloader: Check response: Level II NACK received.");
+          rv = VSCP_ERROR_NACK;
+          break;
         }
-        rv = VSCP_ERROR_SUCCESS;
-        break;
       }
+      else {
+
+        // Level I - Only LSB byte (nickname id) is of interest
+
+        // ACK received?
+        if ((VSCP_CLASS1_PROTOCOL == ex.vscp_class) && (response_event_ack == ex.vscp_type) &&
+            guid[15] == ex.GUID[15]) {
+          // ACK response
+          spdlog::debug("VSCP bootloader: Check response: Level I ACK received. nickname={0} ev.nickname={1}",
+                        guid[15],
+                        ex.GUID[15]);
+          rv = VSCP_ERROR_SUCCESS;
+          break;
+        }
 
-      // Is this a read/write reply from the node?
-      if ((VSCP_CLASS1_PROTOCOL == ex.vscp_class) && (response_event_nack == ex.vscp_type) &&
-          guid.isSameGUID(ex.GUID)) {
-        // NACK response
-        spdlog::debug("VSCP Bootloader: NACK received.");
-        if (nullptr != m_statusCallback) {
-          m_statusCallback(-1, "VSCP Bootloader: NACK received.");
+        // NACK received?
+        if ((VSCP_CLASS1_PROTOCOL == ex.vscp_class) && (response_event_nack == ex.vscp_type) &&
+            guid[15] == ex.GUID[15]) {
+          // ACK response
+          spdlog::error("VSCP bootloader: Check response: Level I NACK received. nickname={0} ev.nickname={1}",
+                        guid[15],
+                        ex.GUID[15]);
+          if (nullptr != m_statusCallback) {
+            m_statusCallback(-1, "VSCP bootloader: Check response: Level I NACK received");
+          }
+          rv = VSCP_ERROR_SUCCESS;
+          break;
         }
-        rv = VSCP_ERROR_NACK;
-        break;
       }
     }
   } // while
diff --git a/src/vscp/common/vscp-bootdevice-vscp.h b/src/vscp/common/vscp-bootdevice-vscp.h
index 9b5aad907..6eeaac774 100644
--- a/src/vscp/common/vscp-bootdevice-vscp.h
+++ b/src/vscp/common/vscp-bootdevice-vscp.h
@@ -256,7 +256,7 @@ class CBootDevice_VSCP : public CBootDevice {
     @param paddr Address to beginning of data to write
     @return VSCP_ERROR_SUCCESS on success.
   */
-  int writeBlock(const uint8_t *paddr);
+  int writeBlock(uint32_t block, const uint8_t *paddr);
 
   /*!
     Check response event
diff --git a/src/vscp/common/vscp-client-base.cpp b/src/vscp/common/vscp-client-base.cpp
index 1d189a3bb..7bbc9aab2 100644
--- a/src/vscp/common/vscp-client-base.cpp
+++ b/src/vscp/common/vscp-client-base.cpp
@@ -35,6 +35,7 @@
 #include <list>
 #include <string>
 
+#include <vscphelper.h>
 #include "vscp-client-base.h"
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -84,4 +85,5 @@ CVscpClient::setCallbackEx(std::function<void(vscpEventEx &ex, void *pobj)> call
   m_bActiveCallbackEx = true;
   
   return VSCP_ERROR_SUCCESS;
-};
\ No newline at end of file
+};
+
diff --git a/src/vscp/common/vscp-client-base.h b/src/vscp/common/vscp-client-base.h
index 9b7a47586..c5f470da3 100644
--- a/src/vscp/common/vscp-client-base.h
+++ b/src/vscp/common/vscp-client-base.h
@@ -129,18 +129,43 @@ class CVscpClient {
   */
   virtual int receive(vscpEvent &ev) = 0;
 
+  /*!
+      Blocking receive of VSCP event ex from remote host
+      @param ev VSCP event that will get the result.
+      @param timeout Timeout in milliseconds. Zero is no wait. Default is 100 ms.
+      @return Return VSCP_ERROR_SUCCESS of OK and error code else.
+  */
+  virtual int receiveBlocking(vscpEvent &ev, long timeout = 100) = 0;
+
   /*!
       Receive VSCP event ex from remote host
       @return Return VSCP_ERROR_SUCCESS of OK and error code else.
   */
   virtual int receive(vscpEventEx &ex) = 0;
 
+  /*!
+     Blocking receive of VSCP event ex from remote host
+     @param ex VSCP event ex that will get the result.
+     @param timeout Timeout in milliseconds. Zero is no wait. Default is 100 ms.
+     @return Return VSCP_ERROR_SUCCESS of OK and error code else.
+ */
+  virtual int receiveBlocking(vscpEventEx &ex, long timeout = 100) = 0;
+
   /*!
       Receive CAN(AL) message from remote host
+      @param msg CANAL message that will get the result.
       @return Return VSCP_ERROR_SUCCESS of OK and error code else.
   */
   virtual int receive(canalMsg &msg) = 0;
 
+  /*!
+      Blocking receive of VSCP event ex from remote host
+      @param msg CANAL message that will get the result.
+      @param timeout Timeout in milliseconds. Zero is no wait. Default is 100 ms.
+      @return Return VSCP_ERROR_SUCCESS of OK and error code else.
+  */
+  virtual int receiveBlocking(canalMsg &msg, long timeout = 100) = 0;
+
   /*!
       Set interface filter
       @param filter VSCP Filter to set.
@@ -287,7 +312,7 @@ class CVscpClient {
     @param Pointer to object to set
   */
 
- void setCallbackObj(void *pobj) { m_callbackObject = pobj; };
+  void setCallbackObj(void *pobj) { m_callbackObject = pobj; };
 
   /*!
     Return Callback object
@@ -296,7 +321,6 @@ class CVscpClient {
   void *getCallbackObj(void) { return m_callbackObject; };
 
 public:
-
   /*!
       Callback for events
   */
@@ -308,7 +332,6 @@ class CVscpClient {
   std::function<void(vscpEventEx &ex, void *pobj)> m_callbackex;
 
 protected:
-
   /// Type of connection object
   connType m_type = CVscpClient::connType::NONE;
 
@@ -328,8 +351,6 @@ class CVscpClient {
   */
   void *m_callbackObject;
 
-  
-
   /// Name for connection object
   std::string m_name;
 
diff --git a/src/vscp/common/vscp-client-canal.cpp b/src/vscp/common/vscp-client-canal.cpp
index 38f145b6e..dfaa43c87 100644
--- a/src/vscp/common/vscp-client-canal.cpp
+++ b/src/vscp/common/vscp-client-canal.cpp
@@ -359,7 +359,7 @@ vscpClientCanal::receive(canalMsg &msg)
 {
   int rv;
   //canalMsg canalMsg;
-  uint8_t guid[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+  //uint8_t guid[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
   spdlog::debug("CANAL CLIENT: Poll for event ex.");
 
@@ -433,9 +433,9 @@ vscpClientCanal::clear()
 //
 
 int
-vscpClientCanal::getversion(uint8_t *pmajor, uint8_t *pminor, uint8_t *prelease, uint8_t *pbuild)
+vscpClientCanal::getversion(uint8_t * /*pmajor*/, uint8_t * /*pminor*/, uint8_t * /*prelease*/, uint8_t * /*pbuild*/)
 {
-  uint32_t ver = m_canalif.CanalGetDllVersion();
+  //uint32_t ver = m_canalif.CanalGetDllVersion();
 
   return VSCP_ERROR_SUCCESS;
 }
@@ -445,7 +445,7 @@ vscpClientCanal::getversion(uint8_t *pmajor, uint8_t *pminor, uint8_t *prelease,
 //
 
 int
-vscpClientCanal::getinterfaces(std::deque<std::string> &iflist)
+vscpClientCanal::getinterfaces(std::deque<std::string> & /*iflist*/ )
 {
   // No interfaces available
   return VSCP_ERROR_SUCCESS;
@@ -467,7 +467,7 @@ vscpClientCanal::getwcyd(uint64_t &wcyd)
 //
 
 void
-vscpClientCanal::setConnectionTimeout(uint32_t timeout)
+vscpClientCanal::setConnectionTimeout(uint32_t /*timeout*/)
 {
   ;
 }
@@ -487,7 +487,7 @@ vscpClientCanal::getConnectionTimeout(void)
 //
 
 void
-vscpClientCanal::setResponseTimeout(uint32_t timeout)
+vscpClientCanal::setResponseTimeout(uint32_t /*timeout*/)
 {
   ;
 }
diff --git a/src/vscp/common/vscp-client-mqtt.cpp b/src/vscp/common/vscp-client-mqtt.cpp
index df951d458..a1b185b07 100644
--- a/src/vscp/common/vscp-client-mqtt.cpp
+++ b/src/vscp/common/vscp-client-mqtt.cpp
@@ -83,7 +83,7 @@ workerThread(void *pObj);
 */
 
 int
-password_callback(char *buf, int size, int rwflag, void *userdata)
+password_callback(char *buf, int size, int /*rwflag*/, void *userdata)
 {
   // Check pointers
   if ((nullptr == buf) || (nullptr == userdata)) {
@@ -191,7 +191,7 @@ mqtt_on_connect_flags(struct mosquitto *mosq, void *pData, int rv, int flags)
 
 #if LIBMOSQUITTO_MAJOR > 1 || (LIBMOSQUITTO_MAJOR == 1 && LIBMOSQUITTO_MINOR >= 6)
 static void
-mqtt_on_connect_v5(struct mosquitto *mosq, void *pData, int rv, int flags, const mosquitto_property *props)
+mqtt_on_connect_v5(struct mosquitto *mosq, void *pData, int rv, int flags, const mosquitto_property * /*props*/)
 {
   // Check for valid handle
   if (nullptr == mosq) {
@@ -247,7 +247,7 @@ mqtt_on_disconnect(struct mosquitto *mosq, void *pData, int rv)
 
 #if LIBMOSQUITTO_MAJOR > 1 || (LIBMOSQUITTO_MAJOR == 1 && LIBMOSQUITTO_MINOR >= 6)
 static void
-mqtt_on_disconnect_v5(struct mosquitto *mosq, void *pData, int rv, const mosquitto_property *props)
+mqtt_on_disconnect_v5(struct mosquitto *mosq, void *pData, int rv, const mosquitto_property * /*props*/)
 {
   // Check for valid handle
   if (nullptr == mosq) {
@@ -301,7 +301,7 @@ mqtt_on_publish(struct mosquitto *mosq, void *pData, int mid)
 
 #if LIBMOSQUITTO_MAJOR > 1 || (LIBMOSQUITTO_MAJOR == 1 && LIBMOSQUITTO_MINOR >= 6)
 static void
-mqtt_on_publish_v5(struct mosquitto *mosq, void *pData, int mid, int reason_code, const mosquitto_property *props)
+mqtt_on_publish_v5(struct mosquitto *mosq, void *pData, int mid, int reason_code, const mosquitto_property * /*props*/)
 {
   // Check for valid handle
   if (nullptr == mosq) {
@@ -367,7 +367,7 @@ static void
 mqtt_on_message_v5(struct mosquitto *mosq,
                    void *pData,
                    const struct mosquitto_message *pMsg,
-                   const mosquitto_property *props)
+                   const mosquitto_property * /*props*/)
 {
   // Check for valid handle
   if (nullptr == mosq) {
@@ -435,7 +435,7 @@ mqtt_on_subscribe_v5(struct mosquitto *mosq,
                      int mid,
                      int qos_count,
                      const int *granted_qos,
-                     const mosquitto_property *props)
+                     const mosquitto_property * /*props*/)
 {
   // Check for valid handle
   if (nullptr == mosq) {
@@ -491,7 +491,7 @@ mqtt_on_unsubscribe(struct mosquitto *mosq, void *pData, int mid)
 
 #if LIBMOSQUITTO_MAJOR > 1 || (LIBMOSQUITTO_MAJOR == 1 && LIBMOSQUITTO_MINOR >= 6)
 static void
-mqtt_on_unsubscribe_v5(struct mosquitto *mosq, void *pData, int mid, const mosquitto_property *props)
+mqtt_on_unsubscribe_v5(struct mosquitto *mosq, void *pData, int mid, const mosquitto_property * /*props*/)
 {
   // Check for valid handle
   if (nullptr == mosq) {
@@ -2859,7 +2859,7 @@ vscpClientMqtt::getversion(uint8_t *pmajor, uint8_t *pminor, uint8_t *prelease,
 //
 
 int
-vscpClientMqtt::getinterfaces(std::deque<std::string> &iflist)
+vscpClientMqtt::getinterfaces(std::deque<std::string> & /*iflist*/)
 {
   // No interfaces available
   return VSCP_ERROR_SUCCESS;
@@ -2956,7 +2956,7 @@ win_usleep(__int64 usec)
 static void *
 workerThread(void *pObj)
 {
-  uint8_t guid[]          = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+  //uint8_t guid[]          = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   vscpClientMqtt *pClient = (vscpClientMqtt *) pObj;
   //  if (nullptr == pif) return nullptr;
 
diff --git a/src/vscp/common/vscp-client-multicast.cpp b/src/vscp/common/vscp-client-multicast.cpp
index a067a391b..b8912aafa 100644
--- a/src/vscp/common/vscp-client-multicast.cpp
+++ b/src/vscp/common/vscp-client-multicast.cpp
@@ -64,7 +64,7 @@ std::string vscpClientMulticast::getConfigAsJson(void)
 // initFromJson
 //
 
-bool vscpClientMulticast::initFromJson(const std::string& config)
+bool vscpClientMulticast::initFromJson(const std::string& /*config*/)
 {
     return true;
 }
@@ -101,7 +101,7 @@ bool vscpClientMulticast::isConnected(void)
 // send
 //
 
-int vscpClientMulticast::send(vscpEvent &ev)
+int vscpClientMulticast::send(vscpEvent & /*ev*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -110,7 +110,7 @@ int vscpClientMulticast::send(vscpEvent &ev)
 // send
 //
 
-int vscpClientMulticast::send(vscpEventEx &ex)
+int vscpClientMulticast::send(vscpEventEx & /*ex*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -136,7 +136,7 @@ vscpClientMulticast::send(canalMsg &msg)
 // receive
 //
 
-int vscpClientMulticast::receive(vscpEvent &ev)
+int vscpClientMulticast::receive(vscpEvent & /*ev*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -145,7 +145,7 @@ int vscpClientMulticast::receive(vscpEvent &ev)
 // receive
 //
 
-int vscpClientMulticast::receive(vscpEventEx &ex)
+int vscpClientMulticast::receive(vscpEventEx & /*ex*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -175,7 +175,7 @@ vscpClientMulticast::receive(canalMsg &msg)
 // setfilter
 //
 
-int vscpClientMulticast::setfilter(vscpEventFilter &filter)
+int vscpClientMulticast::setfilter(vscpEventFilter & /*filter*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -220,7 +220,7 @@ int vscpClientMulticast::getversion(uint8_t *pmajor,
 // getinterfaces
 //
 
-int vscpClientMulticast::getinterfaces(std::deque<std::string> &iflist)
+int vscpClientMulticast::getinterfaces(std::deque<std::string> & /*iflist*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -229,7 +229,7 @@ int vscpClientMulticast::getinterfaces(std::deque<std::string> &iflist)
 // getwcyd
 //
 
-int vscpClientMulticast::getwcyd(uint64_t &wcyd)
+int vscpClientMulticast::getwcyd(uint64_t & /*wcyd*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -238,7 +238,7 @@ int vscpClientMulticast::getwcyd(uint64_t &wcyd)
 // setConnectionTimeout
 //
 
-void vscpClientMulticast::setConnectionTimeout(uint32_t timeout)
+void vscpClientMulticast::setConnectionTimeout(uint32_t /*timeout*/)
 {
     ;
 }
@@ -256,7 +256,7 @@ uint32_t vscpClientMulticast::getConnectionTimeout(void)
 // setResponseTimeout
 //
 
-void vscpClientMulticast::setResponseTimeout(uint32_t timeout)
+void vscpClientMulticast::setResponseTimeout(uint32_t /*timeout*/)
 {
     ;
 }
diff --git a/src/vscp/common/vscp-client-socketcan.cpp b/src/vscp/common/vscp-client-socketcan.cpp
index d5a4ce31d..f45dc1699 100644
--- a/src/vscp/common/vscp-client-socketcan.cpp
+++ b/src/vscp/common/vscp-client-socketcan.cpp
@@ -167,7 +167,7 @@ vscpClientSocketCan::~vscpClientSocketCan()
 //
 
 int
-vscpClientSocketCan::init(const std::string &interface, const std::string &guid, unsigned long flags, uint32_t timeout)
+vscpClientSocketCan::init(const std::string &interface, const std::string &guid, unsigned long flags, uint32_t /*timeout*/)
 {
   m_interface = interface;
   m_guid.getFromString(guid);
@@ -490,7 +490,7 @@ vscpClientSocketCan::send(canalMsg &msg)
 int
 vscpClientSocketCan::receive(vscpEvent &ev)
 {
-  int rv;
+  int rv = VSCP_ERROR_SUCCESS;
 
   // Check if there are any events waiting
   if (!m_receiveList.size()) {
@@ -508,7 +508,7 @@ vscpClientSocketCan::receive(vscpEvent &ev)
   pthread_mutex_unlock(&m_mutexReceiveQueue);
   vscp_deleteEvent(pev);
 
-  return VSCP_ERROR_SUCCESS;
+  return rv;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -535,7 +535,7 @@ vscpClientSocketCan::receive(vscpEventEx &ex)
 int
 vscpClientSocketCan::receive(canalMsg &msg)
 {
-  int rv;
+  int rv = VSCP_ERROR_SUCCESS;
 
   // Check if there are any events waiting
   if (!m_receiveList.size()) {
@@ -555,20 +555,36 @@ vscpClientSocketCan::receive(canalMsg &msg)
   vscp_deleteEvent(pev);
   pev = nullptr;
 
-  return VSCP_ERROR_SUCCESS;
+  return rv;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// receive
+// receiveBlocking
 //
 
 int
-vscpClientSocketCan::receiveBlocking(vscpEventEx &ex, long timeout)
+vscpClientSocketCan::receiveBlocking(vscpEvent &ev, long timeout)
 {
-  int rv;
-  vscpEvent ev;
+  if (-1 == vscp_sem_wait(&m_semReceiveQueue, timeout)) {
+    if (errno == ETIMEDOUT) {
+      return VSCP_ERROR_TIMEOUT;
+    }
+    else {
+      return VSCP_ERROR_ERROR;
+    }
+  }
+
+  return receive(ev);
+}
 
-  if (-1 == (rv = vscp_sem_wait(&m_semReceiveQueue, timeout))) {
+///////////////////////////////////////////////////////////////////////////////
+// receiveBlocking
+//
+
+int
+vscpClientSocketCan::receiveBlocking(vscpEventEx &ex, long timeout)
+{
+  if (-1 == vscp_sem_wait(&m_semReceiveQueue, timeout)) {
     if (errno == ETIMEDOUT) {
       return VSCP_ERROR_TIMEOUT;
     }
@@ -577,17 +593,26 @@ vscpClientSocketCan::receiveBlocking(vscpEventEx &ex, long timeout)
     }
   }
 
-  // pthread_mutex_lock(&m_mutexReceiveQueue);
-  // if (m_inqueue.size()) {
-  //   *pex = m_inqueue.dequeue();
-  //   pthread_mutex_unlock(&m_mutexReceiveQueue);
-  //   spdlog::trace("[btest::getEventEx] {0:X}:{1:X}", (*pex)->vscp_class, (*pex)->vscp_type);
+  return receive(ex);
+}
 
-  if (VSCP_ERROR_SUCCESS != (rv = receive(ev))) {
-    return rv;
+///////////////////////////////////////////////////////////////////////////////
+// receiveBlocking
+//
+
+int
+vscpClientSocketCan::receiveBlocking(canalMsg &msg, long timeout)
+{
+  if (-1 == vscp_sem_wait(&m_semReceiveQueue, timeout)) {
+    if (errno == ETIMEDOUT) {
+      return VSCP_ERROR_TIMEOUT;
+    }
+    else {
+      return VSCP_ERROR_ERROR;
+    }
   }
 
-  return (vscp_convertEventToEventEx(&ex, &ev) ? VSCP_ERROR_SUCCESS : VSCP_ERROR_ERROR);
+  return receive(msg);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -595,19 +620,21 @@ vscpClientSocketCan::receiveBlocking(vscpEventEx &ex, long timeout)
 //
 
 int
-vscpClientSocketCan::setfilter(vscpEventFilter &filter)
+vscpClientSocketCan::setfilter(vscpEventFilter & /*filter*/)
 {
-  int rv;
+  int rv = VSCP_ERROR_SUCCESS;
 
-  uint32_t _filter = ((unsigned long) filter.filter_priority << 26) | ((unsigned long) filter.filter_class << 16) |
-                     ((unsigned long) filter.filter_type << 8) | filter.filter_GUID[0];
+  // uint32_t _filter = ((unsigned long) filter.filter_priority << 26) | ((unsigned long) filter.filter_class << 16) |
+  //                    ((unsigned long) filter.filter_type << 8) | filter.filter_GUID[0];
   // if ( CANAL_ERROR_SUCCESS == (rv = m_canalif.CanalSetFilter(_filter))) {
   //     return rv;
   // }
 
-  uint32_t _mask = ((unsigned long) filter.mask_priority << 26) | ((unsigned long) filter.mask_class << 16) |
-                   ((unsigned long) filter.mask_type << 8) | filter.mask_GUID[0];
-  return 0; // m_canalif.CanalSetMask(_mask);
+  // uint32_t _mask = ((unsigned long) filter.mask_priority << 26) | ((unsigned long) filter.mask_class << 16) |
+  //                  ((unsigned long) filter.mask_type << 8) | filter.mask_GUID[0];
+  // m_canalif.CanalSetMask(_mask);
+
+  return rv; 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -636,7 +663,7 @@ vscpClientSocketCan::clear()
 //
 
 int
-vscpClientSocketCan::getversion(uint8_t *pmajor, uint8_t *pminor, uint8_t *prelease, uint8_t *pbuild)
+vscpClientSocketCan::getversion(uint8_t * /*pmajor*/, uint8_t * /*pminor*/, uint8_t * /*prelease*/, uint8_t * /*pbuild*/)
 {
   // uint32_t ver = m_canalif.CanalGetDllVersion();
 
@@ -648,7 +675,7 @@ vscpClientSocketCan::getversion(uint8_t *pmajor, uint8_t *pminor, uint8_t *prele
 //
 
 int
-vscpClientSocketCan::getinterfaces(std::deque<std::string> &iflist)
+vscpClientSocketCan::getinterfaces(std::deque<std::string> &/*iflist*/)
 {
   // No interfaces available
   return VSCP_ERROR_SUCCESS;
@@ -670,7 +697,7 @@ vscpClientSocketCan::getwcyd(uint64_t &wcyd)
 //
 
 void
-vscpClientSocketCan::setConnectionTimeout(uint32_t timeout)
+vscpClientSocketCan::setConnectionTimeout(uint32_t /*timeout*/)
 {
   ;
 }
@@ -690,7 +717,7 @@ vscpClientSocketCan::getConnectionTimeout(void)
 //
 
 void
-vscpClientSocketCan::setResponseTimeout(uint32_t timeout)
+vscpClientSocketCan::setResponseTimeout(uint32_t /*timeout*/)
 {
   ;
 }
@@ -765,13 +792,13 @@ workerThread(void *pData)
 {
   int mtu, enable_canfd = 1;
   fd_set rdfs;
-  struct timeval tv;
+  //struct timeval tv;
   struct sockaddr_can addr;
   struct ifreq ifr;
-  struct cmsghdr *cmsg;
+  //struct cmsghdr *cmsg;
   struct canfd_frame frame;
-  char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
-  const int canfd_on = 1;
+  //char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
+  //const int canfd_on = 1;
 
   vscpClientSocketCan *pObj = (vscpClientSocketCan *) pData;
   if (NULL == pObj) {
diff --git a/src/vscp/common/vscp-client-socketcan.h b/src/vscp/common/vscp-client-socketcan.h
index 224eae312..dfbe27fa2 100644
--- a/src/vscp/common/vscp-client-socketcan.h
+++ b/src/vscp/common/vscp-client-socketcan.h
@@ -149,24 +149,44 @@ class vscpClientSocketCan : public CVscpClient {
   */
   virtual int receive(vscpEvent &ev);
 
+  /*!
+      Blocking receive of VSCP event ex from remote host
+      @param ev VSCP event ex that will get the result.
+      @param timeout Timeout in milliseconds. Default is 100 ms.
+      @return Return VSCP_ERROR_SUCCESS of OK and error code else.
+  */
+  virtual int receiveBlocking(vscpEvent &ev, long timeout = 100 );
+
   /*!
       Receive VSCP event ex from remote host
+      @param ex VSCP event ex that will get the result.
       @return Return VSCP_ERROR_SUCCESS of OK and error code else.
   */
   virtual int receive(vscpEventEx &ex);
 
   /*!
       Blocking receive of VSCP event ex from remote host
+      @param ex VSCP event ex that will get the result.
+      @param timeout Timeout in milliseconds. Default is 100 ms.
       @return Return VSCP_ERROR_SUCCESS of OK and error code else.
   */
-  virtual int receiveBlocking(vscpEventEx &ex, long timeout);
+  virtual int receiveBlocking(vscpEventEx &ex, long timeout = 100 );
 
   /*!
       Receive CAN(AL) message from remote host
+      @param msg CANAL message that will get the result.
       @return Return VSCP_ERROR_SUCCESS of OK and error code else.
   */
   virtual int receive(canalMsg &msg);
 
+  /*!
+      Receive blocking CAN(AL) message from remote host
+      @param msg CANAL message that will get the result.
+      @param timeout Timeout in milliseconds. Default is 100 ms.
+      @return Return VSCP_ERROR_SUCCESS of OK and error code else.
+  */
+  virtual int receiveBlocking(canalMsg &msg, long timeout = 100);
+
   /*!
       Set interface filter
       @param filter VSCP Filter to set.
diff --git a/src/vscp/common/vscp-client-tcp.cpp b/src/vscp/common/vscp-client-tcp.cpp
index a5efbad55..9111cccc3 100644
--- a/src/vscp/common/vscp-client-tcp.cpp
+++ b/src/vscp/common/vscp-client-tcp.cpp
@@ -475,7 +475,7 @@ vscpClientTcp::getinterfaces(std::deque<std::string> &iflist)
 //
 
 int
-vscpClientTcp::getwcyd(uint64_t &wcyd)
+vscpClientTcp::getwcyd(uint64_t & /*wcyd*/)
 {
   return VSCP_ERROR_SUCCESS;
 }
diff --git a/src/vscp/common/vscp-client-udp.cpp b/src/vscp/common/vscp-client-udp.cpp
index bc226755c..44a65f875 100644
--- a/src/vscp/common/vscp-client-udp.cpp
+++ b/src/vscp/common/vscp-client-udp.cpp
@@ -64,7 +64,7 @@ std::string vscpClientUdp::getConfigAsJson(void)
 // initFromJson
 //
 
-bool vscpClientUdp::initFromJson(const std::string& config)
+bool vscpClientUdp::initFromJson(const std::string& /*config*/)
 {
     return true;
 }
@@ -100,7 +100,7 @@ bool vscpClientUdp::isConnected(void)
 // send
 //
 
-int vscpClientUdp::send(vscpEvent &ev)
+int vscpClientUdp::send(vscpEvent & /*ev*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -109,7 +109,7 @@ int vscpClientUdp::send(vscpEvent &ev)
 // send
 //
 
-int vscpClientUdp::send(vscpEventEx &ex)
+int vscpClientUdp::send(vscpEventEx & /*ex*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -135,7 +135,7 @@ vscpClientUdp::send(canalMsg &msg)
 // receive
 //
 
-int vscpClientUdp::receive(vscpEvent &ev)
+int vscpClientUdp::receive(vscpEvent & /*ev*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -144,7 +144,7 @@ int vscpClientUdp::receive(vscpEvent &ev)
 // receive
 //
 
-int vscpClientUdp::receive(vscpEventEx &ex)
+int vscpClientUdp::receive(vscpEventEx & /*ex*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -174,7 +174,7 @@ vscpClientUdp::receive(canalMsg &msg)
 // setfilter
 //
 
-int vscpClientUdp::setfilter(vscpEventFilter &filter)
+int vscpClientUdp::setfilter(vscpEventFilter & /*filter*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -219,7 +219,7 @@ int vscpClientUdp::getversion(uint8_t *pmajor,
 // getinterfaces
 //
 
-int vscpClientUdp::getinterfaces(std::deque<std::string> &iflist)
+int vscpClientUdp::getinterfaces(std::deque<std::string> & /*iflist*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -228,7 +228,7 @@ int vscpClientUdp::getinterfaces(std::deque<std::string> &iflist)
 // getwcyd
 //
 
-int vscpClientUdp::getwcyd(uint64_t &wcyd)
+int vscpClientUdp::getwcyd(uint64_t & /*wcyd*/)
 {
     return VSCP_ERROR_SUCCESS;
 }
@@ -237,7 +237,7 @@ int vscpClientUdp::getwcyd(uint64_t &wcyd)
 // setConnectionTimeout
 //
 
-void vscpClientUdp::setConnectionTimeout(uint32_t timeout)
+void vscpClientUdp::setConnectionTimeout(uint32_t /*timeout*/)
 {
     ;
 }
@@ -255,7 +255,7 @@ uint32_t vscpClientUdp::getConnectionTimeout(void)
 // setResponseTimeout
 //
 
-void vscpClientUdp::setResponseTimeout(uint32_t timeout)
+void vscpClientUdp::setResponseTimeout(uint32_t /*timeout*/)
 {
     ;
 }
diff --git a/src/vscp/common/vscp-client-ws1.cpp b/src/vscp/common/vscp-client-ws1.cpp
index 61e5e3208..52fdd3379 100644
--- a/src/vscp/common/vscp-client-ws1.cpp
+++ b/src/vscp/common/vscp-client-ws1.cpp
@@ -209,7 +209,7 @@ vscpClientWs1::getConfigAsJson(void)
 //
 
 bool
-vscpClientWs1::initFromJson(const std::string &config)
+vscpClientWs1::initFromJson(const std::string & /*config*/)
 {
   return true;
 }
@@ -254,7 +254,7 @@ vscpClientWs1::connect(void)
   std::deque<std::string> args;
   std::string reply;
   char ebuf[100]   = { 0 };
-  const char *path = "/ws1";
+  //const char *path = "/ws1";
 
   // m_conn = mg_connect_websocket_client( m_host.c_str(),
   //                                        m_port,
@@ -318,7 +318,7 @@ vscpClientWs1::connect(void)
   args.clear();
   vscp_split(args, reply, ";");
 
-  if ((args.size() >= 2) && ("+" != args.at(0)) || ("AUTH1" != args.at(1))) {
+  if ((args.size() >= 2) && (("+" != args.at(0)) || ("AUTH1" != args.at(1)))) {
     printf("Invalid response on AUTH\n");
     disconnect();
     return VSCP_ERROR_TIMEOUT;
@@ -748,7 +748,7 @@ vscpClientWs1::getinterfaces(std::deque<std::string> &iflist)
     return VSCP_ERROR_OPERATION_FAILED;
   }
 
-  for (int i = 3; i < args.size(); i++) {
+  for (size_t i = 3; i < args.size(); i++) {
     std::string str = args.front();
     args.pop_front();
     iflist.push_back(str);
diff --git a/src/vscp/common/vscp-client-ws2.cpp b/src/vscp/common/vscp-client-ws2.cpp
index a3e80dd17..e7e8bbbe9 100644
--- a/src/vscp/common/vscp-client-ws2.cpp
+++ b/src/vscp/common/vscp-client-ws2.cpp
@@ -222,7 +222,7 @@ vscpClientWs2::getConfigAsJson(void)
 //
 
 bool
-vscpClientWs2::initFromJson(const std::string &config)
+vscpClientWs2::initFromJson(const std::string & /*config*/)
 {
   return true;
 }
@@ -265,8 +265,8 @@ int
 vscpClientWs2::connect(void)
 {
   json j;
-  char ebuf[100]   = { 0 };
-  const char *path = "/ws2";
+  char ebuf[100] = { 0 };
+  // const char *path = "/ws2";
 
   // m_conn = mg_connect_websocket_client( m_host.c_str(),
   //                                        m_port,
@@ -462,8 +462,9 @@ vscpClientWs2::send(vscpEvent &ev)
   // Check return value
   json j = m_msgReceiveQueue.front();
   m_msgReceiveQueue.pop_front();
-  if ("+" != j["type"])
-    VSCP_ERROR_OPERATION_FAILED;
+  if ("+" != j["type"]) {
+    return VSCP_ERROR_OPERATION_FAILED;
+  }
 
   return VSCP_ERROR_SUCCESS;
 }
@@ -519,8 +520,9 @@ vscpClientWs2::send(vscpEventEx &ex)
   // Check return value
   json j = m_msgReceiveQueue.front();
   m_msgReceiveQueue.pop_front();
-  if ("+" != j["type"])
-    VSCP_ERROR_OPERATION_FAILED;
+  if ("+" != j["type"]) {
+    return VSCP_ERROR_OPERATION_FAILED;
+  }
 
   return VSCP_ERROR_SUCCESS;
 }
@@ -672,8 +674,9 @@ vscpClientWs2::setfilter(vscpEventFilter &filter)
   // Check return value
   json j = m_msgReceiveQueue.front();
   m_msgReceiveQueue.pop_front();
-  if ("+" != j["type"])
-    VSCP_ERROR_OPERATION_FAILED;
+  if ("+" != j["type"]) {
+    return VSCP_ERROR_OPERATION_FAILED;
+  }
 
   return VSCP_ERROR_SUCCESS;
 }
@@ -726,8 +729,9 @@ vscpClientWs2::getversion(uint8_t *pmajor, uint8_t *pminor, uint8_t *prelease, u
   // Check return value
   json j = m_msgReceiveQueue.front();
   m_msgReceiveQueue.pop_front();
-  if ("+" != j["type"])
-    VSCP_ERROR_OPERATION_FAILED;
+  if ("+" != j["type"]) {
+    return VSCP_ERROR_OPERATION_FAILED;
+  }
 
   // Version is delivered as array on form [major,minor,release,build]
 
@@ -790,8 +794,9 @@ vscpClientWs2::getinterfaces(std::deque<std::string> &iflist)
   // Check return value
   json j = m_msgReceiveQueue.front();
   m_msgReceiveQueue.pop_front();
-  if ("+" != j["type"])
-    VSCP_ERROR_OPERATION_FAILED;
+  if ("+" != j["type"]) {
+    return VSCP_ERROR_OPERATION_FAILED;
+  }
 
   std::deque<std::string> args = j["args"];
   iflist                       = args;
@@ -829,8 +834,9 @@ vscpClientWs2::getwcyd(uint64_t &wcyd)
   // Check return value
   json j = m_msgReceiveQueue.front();
   m_msgReceiveQueue.pop_front();
-  if ("+" != j["type"])
-    VSCP_ERROR_OPERATION_FAILED;
+  if ("+" != j["type"]) {
+    return VSCP_ERROR_OPERATION_FAILED;
+  }
 
   std::deque<std::string> args = j["args"];
   if (!args.size()) {
diff --git a/src/vscp/common/vscpcanaldeviceif.cpp b/src/vscp/common/vscpcanaldeviceif.cpp
index c252e7144..40f9b354d 100644
--- a/src/vscp/common/vscpcanaldeviceif.cpp
+++ b/src/vscp/common/vscpcanaldeviceif.cpp
@@ -418,7 +418,7 @@ startInitXMLParser(void *data, const char *name, const char **attr)
 }
 
 static void
-endInitXMLParser(void *data, const char *name)
+endInitXMLParser(void * /*data*/, const char * /*name*/)
 {
     depth_init_parser--;
 }
@@ -658,7 +658,7 @@ startCanalXMLParser(void *data, const char *name, const char **attr)
 }
 
 static void
-endCanalXMLParser(void *data, const char *name)
+endCanalXMLParser(void * /*data*/, const char * /*name*/)
 {
     depth_canal_parser--;
 }
diff --git a/src/vscp/common/vscphelper.cpp b/src/vscp/common/vscphelper.cpp
index 7a820db91..3dd5c2cc8 100644
--- a/src/vscp/common/vscphelper.cpp
+++ b/src/vscp/common/vscphelper.cpp
@@ -859,7 +859,7 @@ vscp_safe_encode_str(const std::string &str)
 //
 
 bool
-vscp_XML_Escape(char *dst, size_t dst_len, const char *src)
+vscp_XML_Escape(char * /*dst*/, size_t /*dst_len*/, const char * /*src*/)
 {
   /*const char escapeCharTbl[6]      = { '&', '\'', '\"', '>', '<', '\0' };
   const char *const escapeSeqTbl[] = {
@@ -1810,7 +1810,7 @@ vscp_getMeasurementFloat64AsString(std::string &strValue, const vscpEvent *pEven
 //
 
 bool
-vscp_getMeasurementWithZoneAsString(const vscpEvent *pEvent, std::string &strValue)
+vscp_getMeasurementWithZoneAsString(const vscpEvent *pEvent, std::string & /*strValue*/)
 {
   int offset = 0;
 
@@ -2417,8 +2417,8 @@ bool
 vscp_convertIntegerToNormalizedEventData(uint8_t *pdata,
                                          uint16_t *psize,
                                          uint64_t val64,
-                                         uint8_t unit,
-                                         uint8_t sensoridx)
+                                         uint8_t /*unit*/,
+                                         uint8_t /*sensoridx*/)
 {
   uint8_t i;
   uint8_t data[8];
@@ -4795,7 +4795,7 @@ startEventXMLParser(void *data, const char *name, const char **attr)
 }
 
 static void
-endEventXMLParser(void *data, const char *name)
+endEventXMLParser(void * /*data*/, const char * /*name*/)
 {
   depth_event_parser--;
 }
@@ -4942,7 +4942,7 @@ startEventExXMLParser(void *data, const char *name, const char **attr)
 }
 
 static void
-endEventExXMLParser(void *data, const char *name)
+endEventExXMLParser(void * /*data*/, const char * /*name*/)
 {
   depth_eventex_parser--;
 }
@@ -5624,7 +5624,7 @@ startFilterMaskXMLParser(void *data, const char *name, const char **attr)
 }
 
 static void
-endFilterMaskXMLParser(void *data, const char *name)
+endFilterMaskXMLParser(void * /*data*/, const char * /*name*/)
 {
   depth_filtermask_parser--;
 }
@@ -5887,7 +5887,7 @@ vscp_convertCanalToEventEx(vscpEventEx *pvscpEventEx, const canalMsg *pcanalMsg,
 //
 
 bool
-vscp_convertEventToCanal(canalMsg *pcanalMsg, const vscpEvent *pvscpEvent, uint8_t mode)
+vscp_convertEventToCanal(canalMsg *pcanalMsg, const vscpEvent *pvscpEvent, uint8_t /*mode*/)
 {
   unsigned char nodeid = 0;
   short sizeData       = 0;
@@ -5962,7 +5962,7 @@ vscp_convertEventToCanal(canalMsg *pcanalMsg, const vscpEvent *pvscpEvent, uint8
 //
 
 bool
-vscp_convertEventExToCanal(canalMsg *pcanalMsg, const vscpEventEx *pvscpEventEx, uint8_t mode)
+vscp_convertEventExToCanal(canalMsg *pcanalMsg, const vscpEventEx *pvscpEventEx, uint8_t /*mode*/)
 {
   bool rv;
 
diff --git a/src/vscp/common/vscphelper.h b/src/vscp/common/vscphelper.h
index 95e2d0ef3..936190803 100644
--- a/src/vscp/common/vscphelper.h
+++ b/src/vscp/common/vscphelper.h
@@ -255,7 +255,7 @@ vscp_mem_usage(double &vm_usage, double &resident_set);
 
     @param sem Pointer to semaphore to wait for
     @param waitms Time in milliseconds to wait. Max 3999 ms.
-    return 0 is semaphore is signaled, -1 if error. errno
+    @return Return 0 if semaphore is signaled, -1 if error. errno
     is set accordingly. ETIMEDOUT is returned for timeout.
 */
 int