diff --git a/src/WiFi.cpp b/src/WiFi.cpp
index 7af1810..eb16f9f 100644
--- a/src/WiFi.cpp
+++ b/src/WiFi.cpp
@@ -38,201 +38,205 @@ void WiFiClass::init()
 
 const char* WiFiClass::firmwareVersion()
 {
-	return WiFiDrv::getFwVersion();
+    return WiFiDrv::getFwVersion();
+}
+
+uint32_t WiFiClass::firmwareVersionU32()
+{
+    return WiFiDrv::getFwVersionU32();
 }
 
 int WiFiClass::begin(const char* ssid)
 {
-	uint8_t status = WL_IDLE_STATUS;
-
-   if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)
-   {
-	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
-	   {
-		   feedWatchdog();
-		   delay(WL_DELAY_START_CONNECTION);
-		   status = WiFiDrv::getConnectionStatus();
-		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
-		     break;
-		   }
-	   }
-   }else
-   {
-	   status = WL_CONNECT_FAILED;
-   }
-   return status;
+    uint8_t status = WL_IDLE_STATUS;
+
+    if (WiFiDrv::wifiSetNetwork(ssid, strlen(ssid)) != WL_FAILURE)
+    {
+        for (unsigned long start = millis(); (millis() - start) < _timeout;)
+        {
+            feedWatchdog();
+            delay(WL_DELAY_START_CONNECTION);
+            status = WiFiDrv::getConnectionStatus();
+            if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+                break;
+            }
+        }
+    }else
+    {
+        status = WL_CONNECT_FAILED;
+    }
+    return status;
 }
 
 int WiFiClass::begin(const char* ssid, uint8_t key_idx, const char *key)
 {
-	uint8_t status = WL_IDLE_STATUS;
-
-	// set encryption key
-   if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)
-   {
-	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
-	   {
-		   feedWatchdog();
-		   delay(WL_DELAY_START_CONNECTION);
-		   status = WiFiDrv::getConnectionStatus();
-		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
-		     break;
-		   }
-	   }
-   }else{
-	   status = WL_CONNECT_FAILED;
-   }
-   return status;
+    uint8_t status = WL_IDLE_STATUS;
+
+    // set encryption key
+    if (WiFiDrv::wifiSetKey(ssid, strlen(ssid), key_idx, key, strlen(key)) != WL_FAILURE)
+    {
+        for (unsigned long start = millis(); (millis() - start) < _timeout;)
+        {
+            feedWatchdog();
+            delay(WL_DELAY_START_CONNECTION);
+            status = WiFiDrv::getConnectionStatus();
+            if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+                break;
+            }
+        }
+    }else{
+        status = WL_CONNECT_FAILED;
+    }
+    return status;
 }
 
 int WiFiClass::begin(const char* ssid, const char *passphrase)
 {
-	uint8_t status = WL_IDLE_STATUS;
+    uint8_t status = WL_IDLE_STATUS;
 
     // set passphrase
     if (WiFiDrv::wifiSetPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase))!= WL_FAILURE)
     {
-	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
- 	   {
-		   feedWatchdog();
- 		   delay(WL_DELAY_START_CONNECTION);
- 		   status = WiFiDrv::getConnectionStatus();
-		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
-		     break;
-		   }
- 	   }
+        for (unsigned long start = millis(); (millis() - start) < _timeout;)
+        {
+            feedWatchdog();
+            delay(WL_DELAY_START_CONNECTION);
+            status = WiFiDrv::getConnectionStatus();
+            if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+                break;
+            }
+        }
     }else{
-    	status = WL_CONNECT_FAILED;
+        status = WL_CONNECT_FAILED;
     }
     return status;
 }
 
 uint8_t WiFiClass::beginAP(const char *ssid)
 {
-	return beginAP(ssid, 1);
+    return beginAP(ssid, 1);
 }
 
 uint8_t WiFiClass::beginAP(const char *ssid, uint8_t channel)
 {
-	uint8_t status = WL_IDLE_STATUS;
-
-   if (WiFiDrv::wifiSetApNetwork(ssid, strlen(ssid), channel) != WL_FAILURE)
-   {
-	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
-	   {
-		   delay(WL_DELAY_START_CONNECTION);
-		   status = WiFiDrv::getConnectionStatus();
-		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
-		     break;
-		   }
-	   }
-   }else
-   {
-	   status = WL_AP_FAILED;
-   }
-   return status;
+    uint8_t status = WL_IDLE_STATUS;
+
+    if (WiFiDrv::wifiSetApNetwork(ssid, strlen(ssid), channel) != WL_FAILURE)
+    {
+        for (unsigned long start = millis(); (millis() - start) < _timeout;)
+        {
+            delay(WL_DELAY_START_CONNECTION);
+            status = WiFiDrv::getConnectionStatus();
+            if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+                break;
+            }
+        }
+    }else{
+        status = WL_AP_FAILED;
+    }
+    return status;
 }
 
 uint8_t WiFiClass::beginAP(const char *ssid, const char* passphrase)
 {
-	return beginAP(ssid, passphrase, 1);
+    return beginAP(ssid, passphrase, 1);
 }
 
 uint8_t WiFiClass::beginAP(const char *ssid, const char* passphrase, uint8_t channel)
 {
-	uint8_t status = WL_IDLE_STATUS;
+    uint8_t status = WL_IDLE_STATUS;
 
     // set passphrase
     if (WiFiDrv::wifiSetApPassphrase(ssid, strlen(ssid), passphrase, strlen(passphrase), channel)!= WL_FAILURE)
     {
-	   for (unsigned long start = millis(); (millis() - start) < _timeout;)
-	   {
- 		   delay(WL_DELAY_START_CONNECTION);
- 		   status = WiFiDrv::getConnectionStatus();
-		   if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
-		     break;
-		   }
- 	   }
+        for (unsigned long start = millis(); (millis() - start) < _timeout;)
+        {
+            delay(WL_DELAY_START_CONNECTION);
+            status = WiFiDrv::getConnectionStatus();
+            if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+                break;
+            }
+        }
     }else{
-    	status = WL_AP_FAILED;
+        status = WL_AP_FAILED;
     }
     return status;
 }
 
 uint8_t WiFiClass::beginEnterprise(const char* ssid, const char* username, const char* password)
 {
-	return beginEnterprise(ssid, username, password, "");
+    return beginEnterprise(ssid, username, password, "");
 }
 
 uint8_t WiFiClass::beginEnterprise(const char* ssid, const char* username, const char* password, const char* identity)
 {
-	return beginEnterprise(ssid, username, password, identity, "");
+    return beginEnterprise(ssid, username, password, identity, "");
 }
 
 uint8_t WiFiClass::beginEnterprise(const char* ssid, const char* username, const char* password, const char* identity, const char* ca)
 {
-	uint8_t status = WL_IDLE_STATUS;
-
-	// set passphrase
-	if (WiFiDrv::wifiSetEnterprise(0 /*PEAP/MSCHAPv2*/, ssid, strlen(ssid), username, strlen(username), password, strlen(password), identity, strlen(identity), ca, strlen(ca) + 1)!= WL_FAILURE)
-	{
-		for (unsigned long start = millis(); (millis() - start) < _timeout;)
-		{
-			delay(WL_DELAY_START_CONNECTION);
-			status = WiFiDrv::getConnectionStatus();
-			if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
-				break;
-			}
-		}
-	} else {
-		status = WL_CONNECT_FAILED;
-	}
-	return status;
+    uint8_t status = WL_IDLE_STATUS;
+
+    // set passphrase
+    if (WiFiDrv::wifiSetEnterprise(0 /*PEAP/MSCHAPv2*/, ssid, strlen(ssid), username, strlen(username), password, strlen(password), identity, strlen(identity), ca, strlen(ca) + 1)!= WL_FAILURE)
+    {
+        for (unsigned long start = millis(); (millis() - start) < _timeout;)
+        {
+            delay(WL_DELAY_START_CONNECTION);
+            status = WiFiDrv::getConnectionStatus();
+            if ((status != WL_IDLE_STATUS) && (status != WL_NO_SSID_AVAIL) && (status != WL_SCAN_COMPLETED)) {
+                break;
+            }
+        }
+    } else {
+        status = WL_CONNECT_FAILED;
+    }
+    return status;
 }
 
 void WiFiClass::config(IPAddress local_ip)
 {
-  // Assume the DNS server will be the machine on the same network as the local IP
-  // but with last octet being '1'
-  IPAddress dns = local_ip;
-  dns[3] = 1;
-  config(local_ip, dns);
+    // Assume the DNS server will be the machine on the same network as the local IP
+    // but with last octet being '1'
+    IPAddress dns = local_ip;
+    dns[3] = 1;
+    config(local_ip, dns);
 }
 
 void WiFiClass::config(IPAddress local_ip, IPAddress dns_server)
 {
-  // Assume the gateway will be the machine on the same network as the local IP
-  // but with last octet being '1'
-  IPAddress gateway = local_ip;
-  gateway[3] = 1;
-  config(local_ip, dns_server, gateway);
+    // Assume the gateway will be the machine on the same network as the local IP
+    // but with last octet being '1'
+    IPAddress gateway = local_ip;
+    gateway[3] = 1;
+    config(local_ip, dns_server, gateway);
 }
 
 void WiFiClass::config(IPAddress local_ip, IPAddress dns_server, IPAddress gateway)
 {
-  IPAddress subnet(255, 255, 255, 0);
-  config(local_ip, dns_server, gateway, subnet);
+    WiFiDrv::config(2, (uint32_t)local_ip, (uint32_t)gateway, 0);
+    WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
 }
 
 void WiFiClass::config(IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet)
 {
-	WiFiDrv::config(3, (uint32_t)local_ip, (uint32_t)gateway, (uint32_t)subnet);
-	WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
+    WiFiDrv::config(3, (uint32_t)local_ip, (uint32_t)gateway, (uint32_t)subnet);
+    WiFiDrv::setDNS(1, (uint32_t)dns_server, 0);
 }
 
 void WiFiClass::setDNS(IPAddress dns_server1)
 {
-	WiFiDrv::setDNS(1, (uint32_t)dns_server1, 0);
+    WiFiDrv::setDNS(1, (uint32_t)dns_server1, 0);
 }
 
 void WiFiClass::setDNS(IPAddress dns_server1, IPAddress dns_server2)
 {
-	WiFiDrv::setDNS(2, (uint32_t)dns_server1, (uint32_t)dns_server2);
+    WiFiDrv::setDNS(2, (uint32_t)dns_server1, (uint32_t)dns_server2);
 }
 
 void WiFiClass::setHostname(const char* name)
 {
-	WiFiDrv::setHostname(name);
+    WiFiDrv::setHostname(name);
 }
 
 int WiFiClass::disconnect()
@@ -242,45 +246,45 @@ int WiFiClass::disconnect()
 
 void WiFiClass::end(void)
 {
-	WiFiDrv::wifiDriverDeinit();
+    WiFiDrv::wifiDriverDeinit();
 }
 
 uint8_t* WiFiClass::macAddress(uint8_t* mac)
 {
-	uint8_t* _mac = WiFiDrv::getMacAddress();
-	memcpy(mac, _mac, WL_MAC_ADDR_LENGTH);
+    uint8_t* _mac = WiFiDrv::getMacAddress();
+    memcpy(mac, _mac, WL_MAC_ADDR_LENGTH);
     return mac;
 }
-   
+
 IPAddress WiFiClass::localIP()
 {
-	IPAddress ret;
-	WiFiDrv::getIpAddress(ret);
-	return ret;
+    IPAddress ret;
+    WiFiDrv::getIpAddress(ret);
+    return ret;
 }
 
 IPAddress WiFiClass::subnetMask()
 {
-	IPAddress ret;
-	WiFiDrv::getSubnetMask(ret);
-	return ret;
+    IPAddress ret;
+    WiFiDrv::getSubnetMask(ret);
+    return ret;
 }
 
 IPAddress WiFiClass::gatewayIP()
 {
-	IPAddress ret;
-	WiFiDrv::getGatewayIP(ret);
-	return ret;
+    IPAddress ret;
+    WiFiDrv::getGatewayIP(ret);
+    return ret;
 }
 
 IPAddress WiFiClass::dnsIP(int n)
 {
-  if (n > 1)
-    return IPAddress(0,0,0,0);
-  IPAddress dnsip0;
-  IPAddress dnsip1;
-  WiFiDrv::getDNS(dnsip0, dnsip1);
-  return n ? dnsip1 : dnsip0;
+    if (n > 1)
+        return IPAddress(0,0,0,0);
+    IPAddress dnsip0;
+    IPAddress dnsip1;
+    WiFiDrv::getDNS(dnsip0, dnsip1);
+    return n ? dnsip1 : dnsip0;
 }
 
 const char* WiFiClass::SSID()
@@ -290,8 +294,8 @@ const char* WiFiClass::SSID()
 
 uint8_t* WiFiClass::BSSID(uint8_t* bssid)
 {
-	uint8_t* _bssid = WiFiDrv::getCurrentBSSID();
-	memcpy(bssid, _bssid, WL_MAC_ADDR_LENGTH);
+    uint8_t* _bssid = WiFiDrv::getCurrentBSSID();
+    memcpy(bssid, _bssid, WL_MAC_ADDR_LENGTH);
     return bssid;
 }
 
@@ -308,28 +312,26 @@ uint8_t WiFiClass::encryptionType()
 
 int8_t WiFiClass::scanNetworks()
 {
-	uint8_t attempts = 10;
-	uint8_t numOfNetworks = 0;
+    uint8_t attempts = 10;
+    uint8_t numOfNetworks = 0;
 
-	if (WiFiDrv::startScanNetworks() == WL_FAILURE)
-		return WL_FAILURE;
- 	do
- 	{
- 		delay(2000);
- 		numOfNetworks = WiFiDrv::getScanNetworks();
- 	}
-	while (( numOfNetworks == 0)&&(--attempts>0));
-	return numOfNetworks;
+    if (WiFiDrv::startScanNetworks() == WL_FAILURE)
+        return WL_FAILURE;
+    do {
+        delay(2000);
+        numOfNetworks = WiFiDrv::getScanNetworks();
+    }while (( numOfNetworks == 0)&&(--attempts>0));
+    return numOfNetworks;
 }
 
 const char* WiFiClass::SSID(uint8_t networkItem)
 {
-	return WiFiDrv::getSSIDNetoworks(networkItem);
+    return WiFiDrv::getSSIDNetoworks(networkItem);
 }
 
 int32_t WiFiClass::RSSI(uint8_t networkItem)
 {
-	return WiFiDrv::getRSSINetoworks(networkItem);
+    return WiFiDrv::getRSSINetoworks(networkItem);
 }
 
 uint8_t WiFiClass::encryptionType(uint8_t networkItem)
@@ -339,12 +341,12 @@ uint8_t WiFiClass::encryptionType(uint8_t networkItem)
 
 uint8_t* WiFiClass::BSSID(uint8_t networkItem, uint8_t* bssid)
 {
-	return WiFiDrv::getBSSIDNetowrks(networkItem, bssid);
+    return WiFiDrv::getBSSIDNetowrks(networkItem, bssid);
 }
 
 uint8_t WiFiClass::channel(uint8_t networkItem)
 {
-	return WiFiDrv::getChannelNetowrks(networkItem);
+    return WiFiDrv::getChannelNetowrks(networkItem);
 }
 
 uint8_t WiFiClass::status()
@@ -354,69 +356,69 @@ uint8_t WiFiClass::status()
 
 uint8_t WiFiClass::reasonCode()
 {
-	return WiFiDrv::getReasonCode();
+    return WiFiDrv::getReasonCode();
 }
 
 int WiFiClass::hostByName(const char* aHostname, IPAddress& aResult)
 {
-	return WiFiDrv::getHostByName(aHostname, aResult);
+    return WiFiDrv::getHostByName(aHostname, aResult);
 }
 
 unsigned long WiFiClass::getTime()
 {
-	return WiFiDrv::getTime();
+    return WiFiDrv::getTime();
 }
 
 int WiFiClass::setTime(unsigned long unixTime)
 {
-	return WiFiDrv::setTime(unixTime);
+    return WiFiDrv::setTime(unixTime);
 }
 
 void WiFiClass::lowPowerMode()
 {
-	WiFiDrv::setPowerMode(1);
+    WiFiDrv::setPowerMode(1);
 }
 
 void WiFiClass::noLowPowerMode()
 {
-	WiFiDrv::setPowerMode(0);
+    WiFiDrv::setPowerMode(0);
 }
 
 int WiFiClass::ping(const char* hostname, uint8_t ttl)
 {
-	IPAddress ip;
+    IPAddress ip;
 
-	if (!hostByName(hostname, ip)) {
-		return WL_PING_UNKNOWN_HOST;
-	}
+    if (!hostByName(hostname, ip)) {
+        return WL_PING_UNKNOWN_HOST;
+    }
 
-	return ping(ip, ttl);
+    return ping(ip, ttl);
 }
 
 int WiFiClass::ping(const String &hostname, uint8_t ttl)
 {
-	return ping(hostname.c_str(), ttl);
+    return ping(hostname.c_str(), ttl);
 }
 
 int WiFiClass::ping(IPAddress host, uint8_t ttl)
 {
-	return WiFiDrv::ping(host, ttl);
+    return WiFiDrv::ping(host, ttl);
 }
 
 void WiFiClass::setTimeout(unsigned long timeout)
 {
-	_timeout = timeout;
+    _timeout = timeout;
 }
 
 void WiFiClass::setFeedWatchdogFunc(FeedHostProcessorWatchdogFuncPointer func)
 {
-  _feed_watchdog_func = func;
+    _feed_watchdog_func = func;
 }
 
 void WiFiClass::feedWatchdog()
 {
-  if (_feed_watchdog_func)
-	_feed_watchdog_func();
+    if (_feed_watchdog_func)
+        _feed_watchdog_func();
 }
 
 WiFiClass WiFi;
diff --git a/src/WiFi.h b/src/WiFi.h
index 413b2dd..0f08607 100644
--- a/src/WiFi.h
+++ b/src/WiFi.h
@@ -53,6 +53,7 @@ class WiFiClass
      * Get firmware version
      */
     static const char* firmwareVersion();
+    uint32_t firmwareVersionU32();
 
 
     /* Start WiFi connection for OPEN networks
diff --git a/src/utility/wifi_drv.cpp b/src/utility/wifi_drv.cpp
index 6b41e49..ee9b97e 100644
--- a/src/utility/wifi_drv.cpp
+++ b/src/utility/wifi_drv.cpp
@@ -118,7 +118,7 @@ void WiFiDrv::wifiDriverDeinit()
 
 int8_t WiFiDrv::wifiSetNetwork(const char* ssid, uint8_t ssid_len)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(SET_NET_CMD, PARAM_NUMS_1);
     SpiDrv::sendParam((uint8_t*)ssid, ssid_len, LAST_PARAM);
@@ -150,7 +150,7 @@ int8_t WiFiDrv::wifiSetNetwork(const char* ssid, uint8_t ssid_len)
 
 int8_t WiFiDrv::wifiSetPassphrase(const char* ssid, uint8_t ssid_len, const char *passphrase, const uint8_t len)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(SET_PASSPHRASE_CMD, PARAM_NUMS_2);
     SpiDrv::sendParam((uint8_t*)ssid, ssid_len, NO_LAST_PARAM);
@@ -183,7 +183,7 @@ int8_t WiFiDrv::wifiSetPassphrase(const char* ssid, uint8_t ssid_len, const char
 
 int8_t WiFiDrv::wifiSetKey(const char* ssid, uint8_t ssid_len, uint8_t key_idx, const void *key, const uint8_t len)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(SET_KEY_CMD, PARAM_NUMS_3);
     SpiDrv::sendParam((uint8_t*)ssid, ssid_len, NO_LAST_PARAM);
@@ -216,7 +216,7 @@ int8_t WiFiDrv::wifiSetKey(const char* ssid, uint8_t ssid_len, uint8_t key_idx,
 
 void WiFiDrv::config(uint8_t validParams, uint32_t local_ip, uint32_t gateway, uint32_t subnet)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(SET_IP_CONFIG_CMD, PARAM_NUMS_4);
     SpiDrv::sendParam((uint8_t*)&validParams, 1, NO_LAST_PARAM);
@@ -247,7 +247,7 @@ void WiFiDrv::config(uint8_t validParams, uint32_t local_ip, uint32_t gateway, u
 
 void WiFiDrv::setDNS(uint8_t validParams, uint32_t dns_server1, uint32_t dns_server2)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(SET_DNS_CONFIG_CMD, PARAM_NUMS_3);
     SpiDrv::sendParam((uint8_t*)&validParams, 1, NO_LAST_PARAM);
@@ -302,7 +302,7 @@ void WiFiDrv::setHostname(const char* hostname)
 
 int8_t WiFiDrv::disconnect()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(DISCONNECT_CMD, PARAM_NUMS_1);
 
@@ -352,7 +352,7 @@ uint8_t WiFiDrv::getReasonCode()
 
 uint8_t WiFiDrv::getConnectionStatus()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_CONN_STATUS_CMD, PARAM_NUMS_0);
@@ -374,7 +374,7 @@ uint8_t WiFiDrv::getConnectionStatus()
 
 uint8_t* WiFiDrv::getMacAddress()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_MACADDR_CMD, PARAM_NUMS_1);
@@ -402,58 +402,58 @@ uint8_t* WiFiDrv::getMacAddress()
 
 void WiFiDrv::getIpAddress(IPAddress& ip)
 {
-	getNetworkData(_localIp, _subnetMask, _gatewayIp);
-	ip = _localIp;
+    getNetworkData(_localIp, _subnetMask, _gatewayIp);
+    ip = _localIp;
 }
 
- void WiFiDrv::getSubnetMask(IPAddress& mask)
- {
-	getNetworkData(_localIp, _subnetMask, _gatewayIp);
-	mask = _subnetMask;
- }
+void WiFiDrv::getSubnetMask(IPAddress& mask)
+{
+    getNetworkData(_localIp, _subnetMask, _gatewayIp);
+    mask = _subnetMask;
+}
 
- void WiFiDrv::getGatewayIP(IPAddress& ip)
- {
-	getNetworkData(_localIp, _subnetMask, _gatewayIp);
-	ip = _gatewayIp;
- }
+void WiFiDrv::getGatewayIP(IPAddress& ip)
+{
+    getNetworkData(_localIp, _subnetMask, _gatewayIp);
+    ip = _gatewayIp;
+}
 
- void WiFiDrv::getDNS(IPAddress& dnsip0, IPAddress& dnsip1)
- {
-   uint8_t ip0[WL_IPV4_LENGTH] = {0};
-   uint8_t ip1[WL_IPV4_LENGTH] = {0};
+void WiFiDrv::getDNS(IPAddress& dnsip0, IPAddress& dnsip1)
+{
+    uint8_t ip0[WL_IPV4_LENGTH] = {0};
+    uint8_t ip1[WL_IPV4_LENGTH] = {0};
 
-   tParam params[PARAM_NUMS_2] = { {0, (char*)ip0}, {0, (char*)ip1}};
+    tParam params[PARAM_NUMS_2] = { {0, (char*)ip0}, {0, (char*)ip1}};
 
-   WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
-   // Send Command
-   SpiDrv::sendCmd(GET_DNS_CONFIG_CMD, PARAM_NUMS_1);
+    // Send Command
+    SpiDrv::sendCmd(GET_DNS_CONFIG_CMD, PARAM_NUMS_1);
 
-   uint8_t _dummy = DUMMY_DATA;
-   SpiDrv::sendParam(&_dummy, sizeof(_dummy), LAST_PARAM);
+    uint8_t _dummy = DUMMY_DATA;
+    SpiDrv::sendParam(&_dummy, sizeof(_dummy), LAST_PARAM);
 
-   // pad to multiple of 4
-   SpiDrv::readChar();
-   SpiDrv::readChar();
+    // pad to multiple of 4
+    SpiDrv::readChar();
+    SpiDrv::readChar();
 
-   SpiDrv::spiSlaveDeselect();
-   //Wait the reply elaboration
-   SpiDrv::waitForSlaveReady();
-   SpiDrv::spiSlaveSelect();
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
 
-   // Wait for reply
-   SpiDrv::waitResponseParams(GET_DNS_CONFIG_CMD, PARAM_NUMS_2, params);
+    // Wait for reply
+    SpiDrv::waitResponseParams(GET_DNS_CONFIG_CMD, PARAM_NUMS_2, params);
 
-   SpiDrv::spiSlaveDeselect();
+    SpiDrv::spiSlaveDeselect();
 
-   dnsip0 = ip0;
-   dnsip1 = ip1;
- }
+    dnsip0 = ip0;
+    dnsip1 = ip1;
+}
 
 const char* WiFiDrv::getCurrentSSID()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_CURR_SSID_CMD, PARAM_NUMS_1);
@@ -483,7 +483,7 @@ const char* WiFiDrv::getCurrentSSID()
 
 uint8_t* WiFiDrv::getCurrentBSSID()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_CURR_BSSID_CMD, PARAM_NUMS_1);
@@ -511,7 +511,7 @@ uint8_t* WiFiDrv::getCurrentBSSID()
 
 int32_t WiFiDrv::getCurrentRSSI()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_CURR_RSSI_CMD, PARAM_NUMS_1);
@@ -540,7 +540,7 @@ int32_t WiFiDrv::getCurrentRSSI()
 
 uint8_t WiFiDrv::getCurrentEncryptionType()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_CURR_ENCT_CMD, PARAM_NUMS_1);
@@ -569,7 +569,7 @@ uint8_t WiFiDrv::getCurrentEncryptionType()
 
 int8_t WiFiDrv::startScanNetworks()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(START_SCAN_NETWORKS, PARAM_NUMS_0);
@@ -584,10 +584,10 @@ int8_t WiFiDrv::startScanNetworks()
     uint8_t _dataLen = 0;
 
     if (!SpiDrv::waitResponseCmd(START_SCAN_NETWORKS, PARAM_NUMS_1, &_data, &_dataLen))
-     {
-         WARN("error waitResponse");
-         _data = WL_FAILURE;
-     }
+    {
+        WARN("error waitResponse");
+        _data = WL_FAILURE;
+    }
 
     SpiDrv::spiSlaveDeselect();
 
@@ -597,7 +597,7 @@ int8_t WiFiDrv::startScanNetworks()
 
 uint8_t WiFiDrv::getScanNetworks()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(SCAN_NETWORKS, PARAM_NUMS_0);
@@ -618,18 +618,18 @@ uint8_t WiFiDrv::getScanNetworks()
 
 const char* WiFiDrv::getSSIDNetoworks(uint8_t networkItem)
 {
-	if (networkItem >= WL_NETWORKS_LIST_MAXNUM)
-		return (char*)NULL;
+    if (networkItem >= WL_NETWORKS_LIST_MAXNUM)
+        return (char*)NULL;
 
-	return _networkSsid[networkItem];
+    return _networkSsid[networkItem];
 }
 
 uint8_t WiFiDrv::getEncTypeNetowrks(uint8_t networkItem)
 {
-	if (networkItem >= WL_NETWORKS_LIST_MAXNUM)
-		return ENC_TYPE_UNKNOWN;
+    if (networkItem >= WL_NETWORKS_LIST_MAXNUM)
+        return ENC_TYPE_UNKNOWN;
 
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_IDX_ENCT_CMD, PARAM_NUMS_1);
@@ -718,11 +718,11 @@ uint8_t WiFiDrv::getChannelNetowrks(uint8_t networkItem)
 
 int32_t WiFiDrv::getRSSINetoworks(uint8_t networkItem)
 {
-	if (networkItem >= WL_NETWORKS_LIST_MAXNUM)
-		return 0;
-	int32_t	networkRssi = 0;
+    if (networkItem >= WL_NETWORKS_LIST_MAXNUM)
+        return 0;
+    int32_t	networkRssi = 0;
 
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(GET_IDX_RSSI_CMD, PARAM_NUMS_1);
@@ -744,12 +744,12 @@ int32_t WiFiDrv::getRSSINetoworks(uint8_t networkItem)
 
     SpiDrv::spiSlaveDeselect();
 
-	return networkRssi;
+    return networkRssi;
 }
 
 uint8_t WiFiDrv::reqHostByName(const char* aHostname)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
 
     // Send Command
     SpiDrv::sendCmd(REQ_HOST_BY_NAME_CMD, PARAM_NUMS_1);
@@ -783,11 +783,11 @@ uint8_t WiFiDrv::reqHostByName(const char* aHostname)
 
 int WiFiDrv::getHostByName(IPAddress& aResult)
 {
-	uint8_t  _ipAddr[WL_IPV4_LENGTH];
-	IPAddress dummy(0xFF,0xFF,0xFF,0xFF);
-	int result = 0;
+    uint8_t  _ipAddr[WL_IPV4_LENGTH];
+    IPAddress dummy(0xFF,0xFF,0xFF,0xFF);
+    int result = 0;
 
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(GET_HOST_BY_NAME_CMD, PARAM_NUMS_0);
 
@@ -802,8 +802,8 @@ int WiFiDrv::getHostByName(IPAddress& aResult)
     {
         WARN("error waitResponse");
     }else{
-    	aResult = _ipAddr;
-    	result = (aResult != dummy);
+        aResult = _ipAddr;
+        result = (aResult != dummy);
     }
     SpiDrv::spiSlaveDeselect();
     return result;
@@ -811,17 +811,17 @@ int WiFiDrv::getHostByName(IPAddress& aResult)
 
 int WiFiDrv::getHostByName(const char* aHostname, IPAddress& aResult)
 {
-	if (reqHostByName(aHostname))
-	{
-		return getHostByName(aResult);
-	}else{
-		return 0;
-	}
+    if (reqHostByName(aHostname))
+    {
+        return getHostByName(aResult);
+    }else{
+        return 0;
+    }
 }
 
 const char*  WiFiDrv::getFwVersion()
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(GET_FW_VERSION_CMD, PARAM_NUMS_0);
 
@@ -840,6 +840,28 @@ const char*  WiFiDrv::getFwVersion()
     return fwVersion;
 }
 
+uint32_t  WiFiDrv::getFwVersionU32()
+{
+    WAIT_FOR_SLAVE_SELECT();
+    // Send Command
+    SpiDrv::sendCmd(GET_FW_VERSION_U32_CMD, PARAM_NUMS_0);
+
+    SpiDrv::spiSlaveDeselect();
+    //Wait the reply elaboration
+    SpiDrv::waitForSlaveReady();
+    SpiDrv::spiSlaveSelect();
+
+    // Wait for reply
+    uint8_t _data[4] = {0,0,0,0};
+    uint8_t _dataLen = 0;
+    if (!SpiDrv::waitResponseCmd(GET_FW_VERSION_U32_CMD, PARAM_NUMS_1, _data, &_dataLen))
+    {
+        WARN("error waitResponse");
+    }
+    SpiDrv::spiSlaveDeselect();
+    return _data[0] << 16| _data[1] << 8 | _data[2];
+}
+
 uint32_t WiFiDrv::getTime()
 {
     WAIT_FOR_SLAVE_SELECT();
@@ -1239,7 +1261,7 @@ void WiFiDrv::analogWrite(uint8_t pin, uint8_t value)
 
 int8_t WiFiDrv::downloadFile(const char* url, uint8_t url_len, const char *filename, uint8_t filename_len)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     // Send Command
     SpiDrv::sendCmd(DOWNLOAD_FILE, PARAM_NUMS_2);
     SpiDrv::sendParam((uint8_t*)url, url_len, NO_LAST_PARAM);
@@ -1302,7 +1324,7 @@ int8_t WiFiDrv::downloadOTA(const char* url, uint8_t url_len)
 
 int8_t WiFiDrv::renameFile(const char * old_file_name, uint8_t const old_file_name_len, const char * new_file_name, uint8_t const new_file_name_len)
 {
-	WAIT_FOR_SLAVE_SELECT();
+    WAIT_FOR_SLAVE_SELECT();
     /* Send Command */
     SpiDrv::sendCmd(RENAME_FILE, PARAM_NUMS_2);
     SpiDrv::sendParam((uint8_t*)old_file_name, old_file_name_len, NO_LAST_PARAM);
diff --git a/src/utility/wifi_drv.h b/src/utility/wifi_drv.h
index ecd58a1..42c5ac3 100644
--- a/src/utility/wifi_drv.h
+++ b/src/utility/wifi_drv.h
@@ -278,6 +278,7 @@ class WiFiDrv
      * result: version as string with this format a.b.c
      */
     static const char* getFwVersion();
+    static uint32_t getFwVersionU32();
 
     static uint32_t getTime();
     static int setTime(uint32_t epochTime);
diff --git a/src/utility/wifi_spi.h b/src/utility/wifi_spi.h
index d4d11da..b862937 100644
--- a/src/utility/wifi_spi.h
+++ b/src/utility/wifi_spi.h
@@ -118,6 +118,7 @@ enum {
     PREFERENCES_GETTYPE      = 0x5D,
 
     // regular format commands
+    GET_FW_VERSION_U32_CMD   = 0x5E,
     SET_TIME_CMD             = 0x5F,
 
     // regular format commands