{"id":376,"date":"2017-06-24T23:13:51","date_gmt":"2017-06-24T13:13:51","guid":{"rendered":"http:\/\/bakke.online\/?p=376"},"modified":"2022-01-22T20:10:55","modified_gmt":"2022-01-22T09:10:55","slug":"esp8266-wifi-power-reduction-avoiding-network-scan","status":"publish","type":"post","link":"https:\/\/www.bakke.online\/index.php\/2017\/06\/24\/esp8266-wifi-power-reduction-avoiding-network-scan\/","title":{"rendered":"ESP8266 WiFi power reduction – Avoiding network scan"},"content":{"rendered":"

Last month I wrote a series of posts<\/a> about reducing the power consumption of the ESP8266, showing how I got the power consumption of a weather station down to 54\u00a0\u03bcAh per 5 minute reporting cycle.<\/p>\n

At the end of that, I thought further improvements would be mainly tweaks and fine tuning, but Tobias wrote a comment<\/a> explaining that it would be possible to avoid the initial network scan happening as part of the WiFi network association. \u00a0I’m happy to say that it is possible, and it works quite well indeed.<\/p>\n

<\/p>\n

Introducing the RTC and its memory<\/h3>\n

When the ESP8266 goes into deep sleep, a part of the chip called the RTC remains awake. \u00a0Its power consumption is extremely low,\u00a0so the ESP8266 does not use much power when in deep sleep. \u00a0This is the component responsible for generating the wakeup signal when our deep sleep times out. \u00a0That’s not the only benefit of the RTC, though. \u00a0It also has its own memory, which we can actually read from and write to from the main ESP8266 processor.<\/p>\n

WiFi quick connect<\/h3>\n

The WiFi.begin() method has an overload which accepts a WiFi channel number and a BSSID. \u00a0By passing these, the ESP8266 will attempt to connect to a specific WiFi access point on the channel given, thereby eliminating the need to scan for an access point advertising the requested network.<\/p>\n

How much time this will save depends on your network infrastructure, how many WiFi networks are active, how busy the network is and the signal strength. \u00a0It WILL save time, though, time in which the WiFi radio is active and drawing power from the batteries.<\/p>\n

Only problem is:<\/strong> How is the ESP8266 going to know which channel and BSSID to use when it wakes up, without doing a scan?<\/p>\n

That’s where we can use the memory in the RTC. \u00a0As the RTC remains powered during deep sleep, anything we write into its memory will still be there when the ESP wakes up again.<\/p>\n

So, when the ESP8266 wakes up, we’ll read the RTC memory and check if we have a valid configuration to use. \u00a0If we do, we’ll pass the additional parameters to WiFi.begin(). \u00a0If we don’t, we’ll just connect as normal. \u00a0As soon as the connection has been established, we can write the channel and BSSID into the RTC memory, ready for next time.<\/p>\n

Reading and writing this memory is explained in the RTCUserMemory<\/a> example in the Arduino board support package, and my code below is based on that example.<\/p>\n

How to do it<\/h3>\n

First we’ll need to define a structure that we can store in the RTC memory. \u00a0For the WiFi quick connect we only need to know the channel and BSSID. \u00a0We also need a checksum or signature to help identify good or bad data, and as the RTCUserMemory example is using a CRC32 checksum, I am doing the same. \u00a0CRC32 may be a bit overkill for such a small structure, and a signature word might have been more suitable. \u00a0However, having the CRC32 in place now will make it easier to extend the structure in the future.<\/p>\n

Define the structure at the global level of your sketch, so it is available from any method or function:<\/p>\n

\/\/ The ESP8266 RTC memory is arranged into blocks of 4 bytes. The access methods read and write 4 bytes at a time,<\/span>\n\/\/ so the RTC data structure should be padded to a 4-byte multiple.<\/span>\nstruct<\/span> {\n  uint32_t<\/span> crc32;   \/\/ 4 bytes<\/span>\n  uint8_t<\/span> channel;  \/\/ 1 byte,   5 in total<\/span>\n  uint8_t<\/span> bssid[6]; \/\/ 6 bytes, 11 in total<\/span>\n  uint8_t<\/span> padding;  \/\/ 1 byte,  12 in total<\/span>\n} rtcData;<\/pre>\n
The RTC memory is arranged into blocks of 4 bytes, so we pad the structure to a multiple of 4 bytes. \u00a0We lead with the CRC32 checksum, followed by a single byte for the channel and 6 bytes of BSSID. \u00a0(The BSSID is the MAC address of the WiFi access point.)<\/p>\n
In the setup() method, before enabling the WiFi, add this code to read the settings from the RTC memory and validate the CRC32 checksum. \u00a0If the settings are valid, we set the rtcValid flag.<\/p>\n
\/\/ Try to read WiFi settings from RTC memory<\/span>\nbool<\/span> rtcValid = false<\/span>;\nif<\/span>( ESP.rtcUserMemoryRead( 0, (uint32_t<\/span>*)&rtcData, sizeof<\/span>( rtcData ) ) ) {\n  \/\/ Calculate the CRC of what we just read from RTC memory, but skip the first 4 bytes as that's the checksum itself.<\/span>\n  uint32_t<\/span> crc = calculateCRC32( ((uint8_t<\/span>*)&rtcData) + 4, sizeof<\/span>( rtcData ) - 4 );\n  if<\/span>( crc == rtcData.crc32 ) {\n    rtcValid = true<\/span>;\n  }\n}<\/pre>\n
Next, replace the call to WiFi.begin() with the following:<\/p>\n
if<\/span>( rtcValid ) {\n  \/\/ The RTC data was good, make a quick connection<\/span>\n  WiFi<\/span><\/strong>.begin<\/span>( WLAN_SSID, WLAN_PASSWD, rtcData.channel, rtcData.ap_mac, true );\n}\nelse<\/span> {\n  \/\/ The RTC data was not valid, so make a regular connection<\/span>\n  WiFi<\/strong><\/span>.begin<\/span>( WLAN_SSID, WLAN_PASSWD );\n}<\/pre>\n
Quite simple, we check to see if we have valid data from RTC and if we do, we pass the additional information to WiFi.begin(). \u00a0Otherwise, just do a normal connection.<\/p>\n
The loop waiting for the WiFi connection to be established becomes a little more complicated as we’ll have to consider the possibility that the WiFi access point has changed channels, or that the access point itself has been changed. \u00a0So, if we haven’t established a connection after a certain number of loops, we’ll reset the WiFi and try again with a normal connection. \u00a0If, after 30 seconds, we still don’t have a connection we’ll go back to sleep and try again the next time we wake up. \u00a0After all, it could be that the WiFi network is temporarily unavailable and we don’t want to stay awake until it comes back. \u00a0Better to go back to sleep and hope things are better in the morning…<\/p>\n
int<\/span> retries = 0;\nint<\/span> wifiStatus = WiFi<\/strong><\/span>.status<\/span>();\nwhile<\/span>( wifiStatus != WL_CONNECTED ) {\n  retries++;\n  if<\/span>( retries == 100 ) {\n    \/\/ Quick connect is not working, reset WiFi and try regular connection<\/span>\n    WiFi<\/strong><\/span>.disconnect<\/span>();\n    delay<\/span>( 10 );\n    WiFi<\/strong><\/span>.forceSleepBegin<\/span>();\n    delay<\/span>( 10 );\n    WiFi<\/strong><\/span>.forceSleepWake<\/span>();\n    delay<\/span>( 10 );\n    WiFi<\/strong><\/span>.begin<\/span>( WLAN_SSID, WLAN_PASSWD );\n  }\n  if<\/span>( retries == 600 ) {\n    \/\/ Giving up after 30 seconds and going back to sleep<\/span>\n    WiFi<\/strong><\/span>.disconnect<\/span>( true<\/span> );\n    delay<\/span>( 1 );\n    WiFi<\/strong><\/span>.mode<\/span>( WIFI_OFF );\n    ESP.deepSleep( SLEEPTIME, WAKE_RF_DISABLED );\n    return<\/span>; \/\/ Not expecting this to be called, the previous call will never return.<\/span>\n  }\n  delay<\/span>( 50 );\n  wifiStatus = WiFi<\/strong><\/span>.status<\/span>();\n}<\/pre>\n
Once the WiFi is connected, we can get the channel and BSSID and stuff it into the RTC memory, ready for the next time we wake up.<\/p>\n
\/\/ Write current connection info back to RTC<\/span>\nrtcData.channel = WiFi<\/strong><\/span>.channel<\/span>();\nmemcpy<\/span>( rtcData.ap_mac, WiFi<\/strong><\/span>.BSSID<\/span>(), 6 ); \/\/ Copy 6 bytes of BSSID (AP's MAC address)<\/span>\nrtcData.crc32 = calculateCRC32( ((uint8_t<\/span>*)&rtcData) + 4, sizeof<\/span>( rtcData ) - 4 );\nESP.rtcUserMemoryWrite( 0, (uint32_t<\/span>*)&rtcData, sizeof<\/span>( rtcData ) );<\/pre>\n
And the calculateCRC32() method:<\/p>\n
uint32_t<\/span> calculateCRC32( const uint8_t<\/span> *data, size_t<\/strong><\/span> length<\/span> ) {\n  uint32_t<\/span> crc = 0xffffffff;\n  while<\/span>( length<\/span>-- ) {\n    uint8_t<\/span> c = *data++;\n    for<\/span>( uint32_t<\/span> i = 0x80; i > 0; i >>= 1 ) {\n      bool<\/span> bit<\/span> = crc & 0x80000000;\n      if<\/span>( c & i ) {\n        bit<\/span> = !bit<\/span>;\n      }\n\n      crc <<= 1;\n      if<\/span>( bit<\/span> ) {\n        crc ^= 0x04c11db7;\n      }\n    }\n  }\n\n  return<\/span> crc;\n}<\/pre>\n
Results<\/h3>\n
With this change, the wake time per reporting cycle has been reduced by 1 second, and the total power consumption is now down to 42.6\u03bcAh, 74% down from the starting point.
\n\"\"<\/a><\/p>\n
Many thanks to Tobias for pointing me in this direction.<\/p>\n","protected":false},"excerpt":{"rendered":"
Last month I wrote a series of posts about reducing the power consumption of the ESP8266, showing how I got the power consumption of a weather station down to 54\u00a0\u03bcAh per 5 minute reporting cycle. At the end of that, I thought further improvements would be mainly tweaks and fine tuning, but Tobias wrote a … Continue reading “ESP8266 WiFi power reduction – Avoiding network scan”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7,25,1],"tags":[8,27,9,23,24],"class_list":["post-376","post","type-post","status-publish","format-standard","hentry","category-arduino","category-the-notwork","category-uncategorized","tag-arduino","tag-energy-efficience","tag-esp8266","tag-internet-of-things","tag-notwork"],"_links":{"self":[{"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/posts\/376","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/comments?post=376"}],"version-history":[{"count":1,"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/posts\/376\/revisions"}],"predecessor-version":[{"id":1331,"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/posts\/376\/revisions\/1331"}],"wp:attachment":[{"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/media?parent=376"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/categories?post=376"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.bakke.online\/index.php\/wp-json\/wp\/v2\/tags?post=376"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}