MKR 1000 WiFi Battery Life

Determine the duration of a rechargeable battery.

Introduction

This tutorial gives an overview on how to determine the duration of a rechargeable battery connected to an Arduino MKR1000. Using a simple formula, it is possible to calculate how long a charge can last. The duration is related to the current drawn by the board under different conditions that depend on the sketch and the hardware functionalities used. In this example we use a LiPo battery rated at 1400mAh.

What You Will Learn

  • Learn how to calculate and determine the battery life of a rechargeable battery.

Hardware & Software Needed

The Circuit

The battery is connected to the board through the on-board JST connector

The circuit for this tutorial
The circuit for this tutorial

Note

The charging circuit on the MKR1000 board has a charge current fixed at 350mA and a standby charge time of 4 hours. LiPo batteries should not be charged with a current higher than a half of the total capacity. MKR1000 is therefore designed to use batteries with 'at least 700mAh' of capacity. The maximum capacity is not critical, but bigger batteries require more time to fully charge, therefore we suggest a maximum of 1400-1500mAh.

Computing Battery Life Formula

Computing how long a battery can last is generally speaking quite simple. Each rechargeable battery has its capacity printed on its package, expressed in mAh. This value means that the battery is able to provide the current stated for one hour and after that it will be depleted. If we draw less current, the battery will take more time to discharge. If we know the average current consumption of our circuit we can compute the battery life, expressed in hour using the following formula:

Battery Life = (Battery Capacity) / (Average Current Consumption) * 0.7

If we want the worst case for battery life duration, we can use the maximum current absorbed by our circuit instead of the average one:

Battery Life = (Battery Capability) / (Maximum Current Consumption) * 0.7

Note

Please note that the factor of 0.7 makes allowances for external factors which can affect battery life for out of specs usage (deep discharge under suggested voltage, mechanical stress etc).

MKR1000 Current Consumption

The main feature of the MKR1000 board that affects battery life is the Wi-Fi connectivity: it absorbs roughly 100mA when connected to an Access Point and data transfers are on-going. If the Wi-Fi module is not initialized, it is automatically set into low power mode. The consumption of the micro-controller is about 20mA. A sketch using Wi-Fi connection has therefore an average current absorption of 120mA. If we run this information in our formula we get:

Application Run Time = Battery Life = (1400mAh) / (120mA) * 0.7 = 8.16h

Programming the Board

1. First, let's make sure we have correct the drivers installed. If we are using the Web Editor, we do not need to install anything. If we are using an offline editor, we need to install it manually. This can be done by navigating to Tools > Board > Board Manager.... Here we need to look for the Arduino SAMD boards (32-bits ARM Cortex M0+) and install it.

2. To successfully run the code on the board you need to load two libraries:

#include <SPI.h>

#include <WiFi101.h>

Go to Tools > Manage libraries... then search for the libraries and install them and upload the sketch below to the board.

The estimation of the MKR100's battery consumption mentioned above has been made running the sketch listed below.

1/*
2
3 Repeating WiFi Web Client
4
5 This sketch connects to a a web server and makes a request
6
7 using an Arduino WiFi shield.
8
9 Circuit:
10
11 * WiFi shield attached to pins SPI pins and pin 7
12
13 created 23 April 2012
14
15 modified 31 May 2012
16
17 by Tom Igoe
18
19 modified 13 Jan 2014
20
21 by Federico Vanzati
22
23 http://arduino.cc/en/Tutorial/WiFiWebClientRepeating
24
25 This code is in the public domain.
26
27 */
28
29#include <SPI.h>
30#include <WiFi101.h>
31
32#include "arduino_secrets.h"
33///////please enter your sensitive data in the Secret tab/arduino_secrets.h
34char ssid[] = SECRET_SSID; // your network SSID (name)
35char pass[] = SECRET_PASS; // your network password (use for WPA, or use as key for WEP)
36int keyIndex = 0; // your network key Index number (needed only for WEP)
37
38int status = WL_IDLE_STATUS;
39
40// Initialize the WiFi client library
41
42WiFiClient client;
43
44// server address:
45char server[] = "example.org";
46//IPAddress server(64,131,82,241);
47
48unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
49
50const unsigned long postingInterval = 10L * 1000L; // delay between updates, in milliseconds
51
52void setup() {
53
54 //Initialize serial and wait for port to open:
55
56 Serial.begin(9600);
57
58 while (!Serial) {
59
60 ; // wait for serial port to connect. Needed for native USB port only
61
62 }
63
64 // check for the presence of the shield:
65
66 if (WiFi.status() == WL_NO_SHIELD) {
67
68 Serial.println("WiFi shield not present");
69
70 // don't continue:
71
72 while (true);
73
74 }
75
76 // attempt to connect to WiFi network:
77
78 while ( status != WL_CONNECTED) {
79
80 Serial.print("Attempting to connect to SSID: ");
81
82 Serial.println(ssid);
83
84 // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
85
86 status = WiFi.begin(ssid, pass);
87
88 // wait 10 seconds for connection:
89
90 delay(10000);
91
92 }
93
94 // you're connected now, so print out the status:
95
96 printWiFiStatus();
97}
98
99void loop() {
100
101 // if there's incoming data from the net connection.
102
103 // send it out the serial port. This is for debugging
104
105 // purposes only:
106
107 while (client.available()) {
108
109 char c = client.read();
110
111 Serial.write(c);
112
113 }
114
115 // if ten seconds have passed since your last connection,
116
117 // then connect again and send data:
118
119 if (millis() - lastConnectionTime > postingInterval) {
120
121 httpRequest();
122
123 }
124
125}
126
127// this method makes a HTTP connection to the server:
128void httpRequest() {
129
130 // close any connection before send a new request.
131
132 // This will free the socket on the WiFi shield
133
134 client.stop();
135
136 // if there's a successful connection:
137
138 if (client.connect(server, 80)) {
139
140 Serial.println("connecting...");
141
142 // send the HTTP PUT request:
143
144 client.println("GET / HTTP/1.1");
145
146 client.println("Host: example.org");
147
148 client.println("User-Agent: ArduinoWiFi/1.1");
149
150 client.println("Connection: close");
151
152 client.println();
153
154 // note the time that the connection was made:
155
156 lastConnectionTime = millis();
157
158 }
159
160 else {
161
162 // if you couldn't make a connection:
163
164 Serial.println("connection failed");
165
166 }
167}
168
169void printWiFiStatus() {
170
171 // print the SSID of the network you're attached to:
172
173 Serial.print("SSID: ");
174
175 Serial.println(WiFi.SSID());
176
177 // print your WiFi shield's IP address:
178
179 IPAddress ip = WiFi.localIP();
180
181 Serial.print("IP Address: ");
182
183 Serial.println(ip);
184
185 // print the received signal strength:
186
187 long rssi = WiFi.RSSI();
188
189 Serial.print("signal strength (RSSI):");
190
191 Serial.print(rssi);
192
193 Serial.println(" dBm");
194}

Testing It Out

After you have uploaded the code, compute your application's current consumption by the means of an ammeter. To do this you can use the following circuit.

Measure the consumption with an ammeter
Measure the consumption with an ammeter

Once you have the ammeter reading you can use the formula we used before.

Troubleshoot

If the code is not working, there are some common issues we can troubleshoot:

  • The wiring is incorrect.
  • The battery is not charged.
  • You have not installed or included all of the libraries.

Conclusion

In this tutorial we have learned to calculate and determine the duration of a rechargeable battery using the Arduino MKR1000. The battery life is affected by the sketch that is running on the Arduino, try using different sketches and see how the result differ depending on what sketch you run!