Home / Tutorials / WiFiNINA Library Examples

WiFiNINA Library Examples

The WiFi library for boards with a NINA WiFi module. Works with the MKR WiFi 1010, MKR Vidor 4000, Uno WiFi Rev2, Nano 33 IoT and the Nano RP2040 Connect.

Last revision 06/21/2023

The WiFiNINA library is designed for Arduino boards using a NINA W-10 series module. In this article you will find a series of examples that can be uploaded to your board.

You can also visit the WiFiNINA GitHub repository to learn more about this library.

Hardware Required

Circuit

Most examples in this article uses no external circuit, only the board itself is required.

Please note: these three boards use dedicated pins to communicate and select the WiFi module, therefore you have no restriction in the usage of the available digital pins connected to the header pins.

Examples

WiFiNINA AP Simple Web Server

In this example, a simple web server lets you blink an LED via the web. This example uses the beginAP() function to set up an access point without relying on a local WiFI network. This example will print the IP address of your WiFi module to the Arduino Software (IDE) serial monitor. Once you know the IP address of our board, you can open that address in a web browser to turn on and off the LED on pin 9.

If the IP address of your shield is yourAddress:

http://yourAddress/H turns the LED on
http://yourAddress/L turns it off

The default address of the board in AP mode is 192.168.4.1. When you load this sketch, the WiFi module creates an Access Point with the name specified as SSID in arduino_secrets.h. Connect to it using the password specified as PASS.

1/*
2
3  WiFi Web Server LED Blink
4
5  A simple web server that lets you blink an LED via the web.
6
7  This sketch will create a new access point (with no password).
8
9  It will then launch a new server and print out the IP address
10
11  to the Serial monitor. From there, you can open that address in a web browser
12
13  to turn on and off the LED on pin 13.
14
15  If the IP address of your board is yourAddress:
16
17    http://yourAddress/H turns the LED on
18
19    http://yourAddress/L turns it off
20
21  created 25 Nov 2012
22
23  by Tom Igoe
24
25  adapted to WiFi AP by Adafruit
26
27 */
28
29#include <SPI.h>
30#include <WiFiNINA.h>
31#include "arduino_secrets.h"
32///////please enter your sensitive data in the Secret tab/arduino_secrets.h
33char ssid[] = SECRET_SSID;        // your network SSID (name)
34char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
35int keyIndex = 0;                // your network key Index number (needed only for WEP)
36
37int led =  LED_BUILTIN;
38int status = WL_IDLE_STATUS;
39
40WiFiServer server(80);
41
42void setup() {
43
44  //Initialize serial and wait for port to open:
45
46  Serial.begin(9600);
47
48  while (!Serial) {
49
50    ; // wait for serial port to connect. Needed for native USB port only
51
52  }
53
54  Serial.println("Access Point Web Server");
55
56  pinMode(led, OUTPUT);      // set the LED pin mode
57
58  // check for the WiFi module:
59
60  if (WiFi.status() == WL_NO_MODULE) {
61
62    Serial.println("Communication with WiFi module failed!");
63
64    // don't continue
65
66    while (true);
67
68  }
69
70  String fv = WiFi.firmwareVersion();
71
72  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
73
74    Serial.println("Please upgrade the firmware");
75
76  }
77
78  // by default the local IP address of will be 192.168.4.1
79
80  // you can override it with the following:
81
82  // WiFi.config(IPAddress(10, 0, 0, 1));
83
84  // print the network name (SSID);
85
86  Serial.print("Creating access point named: ");
87
88  Serial.println(ssid);
89
90  // Create open network. Change this line if you want to create an WEP network:
91
92  status = WiFi.beginAP(ssid, pass);
93
94  if (status != WL_AP_LISTENING) {
95
96    Serial.println("Creating access point failed");
97
98    // don't continue
99
100    while (true);
101
102  }
103
104  // wait 10 seconds for connection:
105
106  delay(10000);
107
108  // start the web server on port 80
109
110  server.begin();
111
112  // you're connected now, so print out the status
113
114  printWiFiStatus();
115}
116
117void loop() {
118
119  // compare the previous status to the current status
120
121  if (status != WiFi.status()) {
122
123    // it has changed update the variable
124
125    status = WiFi.status();
126
127    if (status == WL_AP_CONNECTED) {
128
129      // a device has connected to the AP
130
131      Serial.println("Device connected to AP");
132
133    } else {
134
135      // a device has disconnected from the AP, and we are back in listening mode
136
137      Serial.println("Device disconnected from AP");
138
139    }
140
141  }
142
143
144
145  WiFiClient client = server.available();   // listen for incoming clients
146
147  if (client) {                             // if you get a client,
148
149    Serial.println("new client");           // print a message out the serial port
150
151    String currentLine = "";                // make a String to hold incoming data from the client
152
153    while (client.connected()) {            // loop while the client's connected
154
155      if (client.available()) {             // if there's bytes to read from the client,
156
157        char c = client.read();             // read a byte, then
158
159        Serial.write(c);                    // print it out the serial monitor
160
161        if (c == '\n') {                    // if the byte is a newline character
162
163          // if the current line is blank, you got two newline characters in a row.
164
165          // that's the end of the client HTTP request, so send a response:
166
167          if (currentLine.length() == 0) {
168
169            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
170
171            // and a content-type so the client knows what's coming, then a blank line:
172
173            client.println("HTTP/1.1 200 OK");
174
175            client.println("Content-type:text/html");
176
177            client.println();
178
179            // the content of the HTTP response follows the header:
180
181            client.print("Click <a href=\"/H\">here</a> turn the LED on<br>");
182
183            client.print("Click <a href=\"/L\">here</a> turn the LED off<br>");
184
185            // The HTTP response ends with another blank line:
186
187            client.println();
188
189            // break out of the while loop:
190
191            break;
192
193          }
194
195          else {      // if you got a newline, then clear currentLine:
196
197            currentLine = "";
198
199          }
200
201        }
202
203        else if (c != '\r') {    // if you got anything else but a carriage return character,
204
205          currentLine += c;      // add it to the end of the currentLine
206
207        }
208
209        // Check to see if the client request was "GET /H" or "GET /L":
210
211        if (currentLine.endsWith("GET /H")) {
212
213          digitalWrite(led, HIGH);               // GET /H turns the LED on
214
215        }
216
217        if (currentLine.endsWith("GET /L")) {
218
219          digitalWrite(led, LOW);                // GET /L turns the LED off
220
221        }
222
223      }
224
225    }
226
227    // close the connection:
228
229    client.stop();
230
231    Serial.println("client disconnected");
232
233  }
234}
235
236void printWiFiStatus() {
237
238  // print the SSID of the network you're attached to:
239
240  Serial.print("SSID: ");
241
242  Serial.println(WiFi.SSID());
243
244  // print your WiFi shield's IP address:
245
246  IPAddress ip = WiFi.localIP();
247
248  Serial.print("IP Address: ");
249
250  Serial.println(ip);
251
252  // print where to go in a browser:
253
254  Serial.print("To see this page in action, open a browser to http://");
255
256  Serial.println(ip);
257
258}

WiFiNINA Connect No Encryption

This example shows you how to connect to an open (not encrypted) 802.11b/g network with one of the boards that support this library. Your Arduino Software (IDE) serial monitor will provide information about the connection once it has connected.

You should have access to a 802.11b/g wireless network that connects to the internet for this example. You will need to change the network settings in the sketch to correspond to your particular networks SSID.

1/*
2
3 This example connects to an unencrypted Wifi network.
4
5 Then it prints the MAC address of the board,
6
7 the IP address obtained, and other network details.
8
9 created 13 July 2010
10
11 by dlf (Metodo2 srl)
12
13 modified 31 May 2012
14
15 by Tom Igoe
16
17 */
18#include <SPI.h>
19#include <WiFiNINA.h>
20
21#include "arduino_secrets.h"
22///////please enter your sensitive data in the Secret tab/arduino_secrets.h
23char ssid[] = SECRET_SSID;        // your network SSID (name)
24int status = WL_IDLE_STATUS;     // the Wifi radio's status
25
26void setup() {
27
28  //Initialize serial and wait for port to open:
29
30  Serial.begin(9600);
31
32  while (!Serial) {
33
34    ; // wait for serial port to connect. Needed for native USB port only
35
36  }
37
38  // check for the WiFi module:
39
40  if (WiFi.status() == WL_NO_MODULE) {
41
42    Serial.println("Communication with WiFi module failed!");
43
44    // don't continue
45
46    while (true);
47
48  }
49
50  String fv = WiFi.firmwareVersion();
51
52  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
53
54    Serial.println("Please upgrade the firmware");
55
56  }
57
58  // attempt to connect to Wifi network:
59
60  while (status != WL_CONNECTED) {
61
62    Serial.print("Attempting to connect to open SSID: ");
63
64    Serial.println(ssid);
65
66    status = WiFi.begin(ssid);
67
68    // wait 10 seconds for connection:
69
70    delay(10000);
71
72  }
73
74  // you're connected now, so print out the data:
75
76  Serial.print("You're connected to the network");
77
78  printCurrentNet();
79
80  printWifiData();
81}
82
83void loop() {
84
85  // check the network connection once every 10 seconds:
86
87  delay(10000);
88
89  printCurrentNet();
90}
91
92void printWifiData() {
93
94  // print your board's IP address:
95
96  IPAddress ip = WiFi.localIP();
97
98  Serial.print("IP Address: ");
99
100  Serial.println(ip);
101
102  Serial.println(ip);
103
104  // print your MAC address:
105
106  byte mac[6];
107
108  WiFi.macAddress(mac);
109
110  Serial.print("MAC address: ");
111
112  printMacAddress(mac);
113
114  // print your subnet mask:
115
116  IPAddress subnet = WiFi.subnetMask();
117
118  Serial.print("NetMask: ");
119
120  Serial.println(subnet);
121
122  // print your gateway address:
123
124  IPAddress gateway = WiFi.gatewayIP();
125
126  Serial.print("Gateway: ");
127
128  Serial.println(gateway);
129}
130
131void printCurrentNet() {
132
133  // print the SSID of the network you're attached to:
134
135  Serial.print("SSID: ");
136
137  Serial.println(WiFi.SSID());
138
139  // print the MAC address of the router you're attached to:
140
141  byte bssid[6];
142
143  WiFi.BSSID(bssid);
144
145  Serial.print("BSSID: ");
146
147  printMacAddress(bssid);
148
149  // print the received signal strength:
150
151  long rssi = WiFi.RSSI();
152
153  Serial.print("signal strength (RSSI):");
154
155  Serial.println(rssi);
156
157  // print the encryption type:
158
159  byte encryption = WiFi.encryptionType();
160
161  Serial.print("Encryption Type:");
162
163  Serial.println(encryption, HEX);
164}
165
166void printMacAddress(byte mac[]) {
167
168  for (int i = 5; i >= 0; i--) {
169
170    if (mac[i] < 16) {
171
172      Serial.print("0");
173
174    }
175
176    Serial.print(mac[i], HEX);
177
178    if (i > 0) {
179
180      Serial.print(":");
181
182    }
183
184  }
185
186  Serial.println();
187}

WifiNINA Connect With WEP

This example shows you how to connect to a WEP encrypted 802.11b/g network with one of the boards that support this library. Your Arduino Software (IDE) serial monitor will provide information about the connection once it has connected.

WEP network passwords are hexadecimal strings known as keys. A WEP network can have 4 different keys; each key is assigned a "Key Index" value. For WEP encrypted networks, you need the SSID, the key, and key number.

1/*
2
3 This example connects to a WEP-encrypted Wifi network.
4
5 Then it prints the  MAC address of the Wifi module,
6
7 the IP address obtained, and other network details.
8
9 If you use 40-bit WEP, you need a key that is 10 characters long,
10
11 and the characters must be hexadecimal (0-9 or A-F).
12
13 e.g.  for 40-bit, ABBADEAF01 will work, but ABBADEAF won't work
14
15 (too short) and ABBAISDEAF won't work (I and S are not
16
17 hexadecimal characters).
18
19 For 128-bit, you need a string that is 26 characters long.
20
21 D0D0DEADF00DABBADEAFBEADED will work because it's 26 characters,
22
23 all in the 0-9, A-F range.
24
25 created 13 July 2010
26
27 by dlf (Metodo2 srl)
28
29 modified 31 May 2012
30
31 by Tom Igoe
32
33 */
34#include <SPI.h>
35#include <WiFiNINA.h>
36
37#include "arduino_secrets.h"
38///////please enter your sensitive data in the Secret tab/arduino_secrets.h
39char ssid[] = SECRET_SSID;        // your network SSID (name)
40char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
41int keyIndex = 0;                                // your network key Index number
42int status = WL_IDLE_STATUS;                     // the Wifi radio's status
43
44void setup() {
45
46  //Initialize serial and wait for port to open:
47
48  Serial.begin(9600);
49
50  while (!Serial) {
51
52    ; // wait for serial port to connect. Needed for native USB port only
53
54  }
55
56  // check for the WiFi module:
57
58  if (WiFi.status() == WL_NO_MODULE) {
59
60    Serial.println("Communication with WiFi module failed!");
61
62    // don't continue
63
64    while (true);
65
66  }
67
68  String fv = WiFi.firmwareVersion();
69
70  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
71
72    Serial.println("Please upgrade the firmware");
73
74  }
75
76  // attempt to connect to Wifi network:
77
78  while (status != WL_CONNECTED) {
79
80    Serial.print("Attempting to connect to WEP network, SSID: ");
81
82    Serial.println(ssid);
83
84    status = WiFi.begin(ssid, keyIndex, pass);
85
86    // wait 10 seconds for connection:
87
88    delay(10000);
89
90  }
91
92  // once you are connected :
93
94  Serial.print("You're connected to the network");
95
96  printCurrentNet();
97
98  printWifiData();
99}
100
101void loop() {
102
103  // check the network connection once every 10 seconds:
104
105  delay(10000);
106
107  printCurrentNet();
108}
109
110void printWifiData() {
111
112  // print your board's IP address:
113
114  IPAddress ip = WiFi.localIP();
115
116  Serial.print("IP Address: ");
117
118  Serial.println(ip);
119
120  Serial.println(ip);
121
122  // print your MAC address:
123
124  byte mac[6];
125
126  WiFi.macAddress(mac);
127
128  Serial.print("MAC address: ");
129
130  printMacAddress(mac);
131}
132
133void printCurrentNet() {
134
135  // print the SSID of the network you're attached to:
136
137  Serial.print("SSID: ");
138
139  Serial.println(WiFi.SSID());
140
141  // print the MAC address of the router you're attached to:
142
143  byte bssid[6];
144
145  WiFi.BSSID(bssid);
146
147  Serial.print("BSSID: ");
148
149  printMacAddress(bssid);
150
151  // print the received signal strength:
152
153  long rssi = WiFi.RSSI();
154
155  Serial.print("signal strength (RSSI):");
156
157  Serial.println(rssi);
158
159  // print the encryption type:
160
161  byte encryption = WiFi.encryptionType();
162
163  Serial.print("Encryption Type:");
164
165  Serial.println(encryption, HEX);
166
167  Serial.println();
168}
169
170void printMacAddress(byte mac[]) {
171
172  for (int i = 5; i >= 0; i--) {
173
174    if (mac[i] < 16) {
175
176      Serial.print("0");
177
178    }
179
180    Serial.print(mac[i], HEX);
181
182    if (i > 0) {
183
184      Serial.print(":");
185
186    }
187
188  }
189
190  Serial.println();
191}

WifiNINA Connect With WPA

This example shows you how to connect to a WPA2 Personal encrypted 802.11b/g network with one of the boards that support this library. Your Arduino Software (IDE) serial monitor will provide information about the connection once it has connected.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The module will not connect to networks using WPA2 Enterprise encryption.

1/*
2
3 This example connects to an unencrypted Wifi network.
4
5 Then it prints the  MAC address of the Wifi module,
6
7 the IP address obtained, and other network details.
8
9 created 13 July 2010
10
11 by dlf (Metodo2 srl)
12
13 modified 31 May 2012
14
15 by Tom Igoe
16
17 */
18#include <SPI.h>
19#include <WiFiNINA.h>
20
21#include "arduino_secrets.h"
22///////please enter your sensitive data in the Secret tab/arduino_secrets.h
23char ssid[] = SECRET_SSID;        // your network SSID (name)
24char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
25int status = WL_IDLE_STATUS;     // the Wifi radio's status
26
27void setup() {
28
29  //Initialize serial and wait for port to open:
30
31  Serial.begin(9600);
32
33  while (!Serial) {
34
35    ; // wait for serial port to connect. Needed for native USB port only
36
37  }
38
39  // check for the WiFi module:
40
41  if (WiFi.status() == WL_NO_MODULE) {
42
43    Serial.println("Communication with WiFi module failed!");
44
45    // don't continue
46
47    while (true);
48
49  }
50
51  String fv = WiFi.firmwareVersion();
52
53  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
54
55    Serial.println("Please upgrade the firmware");
56
57  }
58
59  // attempt to connect to Wifi network:
60
61  while (status != WL_CONNECTED) {
62
63    Serial.print("Attempting to connect to WPA SSID: ");
64
65    Serial.println(ssid);
66
67    // Connect to WPA/WPA2 network:
68
69    status = WiFi.begin(ssid, pass);
70
71    // wait 10 seconds for connection:
72
73    delay(10000);
74
75  }
76
77  // you're connected now, so print out the data:
78
79  Serial.print("You're connected to the network");
80
81  printCurrentNet();
82
83  printWifiData();
84
85}
86
87void loop() {
88
89  // check the network connection once every 10 seconds:
90
91  delay(10000);
92
93  printCurrentNet();
94}
95
96void printWifiData() {
97
98  // print your board's IP address:
99
100  IPAddress ip = WiFi.localIP();
101
102  Serial.print("IP Address: ");
103
104  Serial.println(ip);
105
106  Serial.println(ip);
107
108  // print your MAC address:
109
110  byte mac[6];
111
112  WiFi.macAddress(mac);
113
114  Serial.print("MAC address: ");
115
116  printMacAddress(mac);
117}
118
119void printCurrentNet() {
120
121  // print the SSID of the network you're attached to:
122
123  Serial.print("SSID: ");
124
125  Serial.println(WiFi.SSID());
126
127  // print the MAC address of the router you're attached to:
128
129  byte bssid[6];
130
131  WiFi.BSSID(bssid);
132
133  Serial.print("BSSID: ");
134
135  printMacAddress(bssid);
136
137  // print the received signal strength:
138
139  long rssi = WiFi.RSSI();
140
141  Serial.print("signal strength (RSSI):");
142
143  Serial.println(rssi);
144
145  // print the encryption type:
146
147  byte encryption = WiFi.encryptionType();
148
149  Serial.print("Encryption Type:");
150
151  Serial.println(encryption, HEX);
152
153  Serial.println();
154}
155
156void printMacAddress(byte mac[]) {
157
158  for (int i = 5; i >= 0; i--) {
159
160    if (mac[i] < 16) {
161
162      Serial.print("0");
163
164    }
165
166    Serial.print(mac[i], HEX);
167
168    if (i > 0) {
169
170      Serial.print(":");
171
172    }
173
174  }
175
176  Serial.println();
177}

WifiNINA Scan Networks

This example scans for 802.11b/g network with one of the boards that support this library. Your Arduino Software (IDE) serial monitor will print out information about the board and the networks it can see. It will not connect to a network.

Open your Arduino Software (IDE) serial monitor to view the networks the WiFi module can see. The shield may not see as many networks as your computer.

1/*
2
3 This example  prints the board's MAC address, and
4
5 scans for available Wifi networks using the NINA module.
6
7 Every ten seconds, it scans again. It doesn't actually
8
9 connect to any network, so no encryption scheme is specified.
10
11 Circuit:
12
13 * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
14
15 created 13 July 2010
16
17 by dlf (Metodo2 srl)
18
19 modified 21 Junn 2012
20
21 by Tom Igoe and Jaymes Dec
22
23 */
24
25#include <SPI.h>
26#include <WiFiNINA.h>
27
28void setup() {
29
30  //Initialize serial and wait for port to open:
31
32  Serial.begin(9600);
33
34  while (!Serial) {
35
36    ; // wait for serial port to connect. Needed for native USB port only
37
38  }
39
40  // check for the WiFi module:
41
42  if (WiFi.status() == WL_NO_MODULE) {
43
44    Serial.println("Communication with WiFi module failed!");
45
46    // don't continue
47
48    while (true);
49
50  }
51
52  String fv = WiFi.firmwareVersion();
53
54  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
55
56    Serial.println("Please upgrade the firmware");
57
58  }
59
60  // print your MAC address:
61
62  byte mac[6];
63
64  WiFi.macAddress(mac);
65
66  Serial.print("MAC: ");
67
68  printMacAddress(mac);
69}
70
71void loop() {
72
73  // scan for existing networks:
74
75  Serial.println("Scanning available networks...");
76
77  listNetworks();
78
79  delay(10000);
80}
81
82void listNetworks() {
83
84  // scan for nearby networks:
85
86  Serial.println("** Scan Networks **");
87
88  int numSsid = WiFi.scanNetworks();
89
90  if (numSsid == -1) {
91
92    Serial.println("Couldn't get a wifi connection");
93
94    while (true);
95
96  }
97
98  // print the list of networks seen:
99
100  Serial.print("number of available networks:");
101
102  Serial.println(numSsid);
103
104  // print the network number and name for each network found:
105
106  for (int thisNet = 0; thisNet < numSsid; thisNet++) {
107
108    Serial.print(thisNet);
109
110    Serial.print(") ");
111
112    Serial.print(WiFi.SSID(thisNet));
113
114    Serial.print("\tSignal: ");
115
116    Serial.print(WiFi.RSSI(thisNet));
117
118    Serial.print(" dBm");
119
120    Serial.print("\tEncryption: ");
121
122    printEncryptionType(WiFi.encryptionType(thisNet));
123
124  }
125}
126
127void printEncryptionType(int thisType) {
128
129  // read the encryption type and print out the name:
130
131  switch (thisType) {
132
133    case ENC_TYPE_WEP:
134
135      Serial.println("WEP");
136
137      break;
138
139    case ENC_TYPE_TKIP:
140
141      Serial.println("WPA");
142
143      break;
144
145    case ENC_TYPE_CCMP:
146
147      Serial.println("WPA2");
148
149      break;
150
151    case ENC_TYPE_NONE:
152
153      Serial.println("None");
154
155      break;
156
157    case ENC_TYPE_AUTO:
158
159      Serial.println("Auto");
160
161      break;
162
163    case ENC_TYPE_UNKNOWN:
164
165    default:
166
167      Serial.println("Unknown");
168
169      break;
170
171  }
172}
173
174void printMacAddress(byte mac[]) {
175
176  for (int i = 5; i >= 0; i--) {
177
178    if (mac[i] < 16) {
179
180      Serial.print("0");
181
182    }
183
184    Serial.print(mac[i], HEX);
185
186    if (i > 0) {
187
188      Serial.print(":");
189
190    }
191
192  }
193
194  Serial.println();
195}

WifiNINA Scan Networks Advanced

Open your Arduino Software (IDE) serial monitor to view the networks the WiFi module can see. The shield may not see as many networks as your computer, but it will show also the encryption type.

1/*
2
3  This example  prints the board's MAC address, and
4
5  scans for available WiFi networks using the NINA module.
6
7  Every ten seconds, it scans again. It doesn't actually
8
9  connect to any network, so no encryption scheme is specified.
10
11  BSSID and WiFi channel are printed
12
13  Circuit:
14
15  * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
16
17  This example is based on ScanNetworks
18
19  created 1 Mar 2017
20
21  by Arturo Guadalupi
22
23*/
24
25#include <SPI.h>
26#include <WiFiNINA.h>
27
28void setup() {
29
30  //Initialize serial and wait for port to open:
31
32  Serial.begin(9600);
33
34  while (!Serial) {
35
36    ; // wait for serial port to connect. Needed for native USB port only
37
38  }
39
40  // check for the WiFi module:
41
42  if (WiFi.status() == WL_NO_MODULE) {
43
44    Serial.println("Communication with WiFi module failed!");
45
46    // don't continue
47
48    while (true);
49
50  }
51
52  String fv = WiFi.firmwareVersion();
53
54  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
55
56    Serial.println("Please upgrade the firmware");
57
58  }
59
60  // print your MAC address:
61
62  byte mac[6];
63
64  WiFi.macAddress(mac);
65
66  Serial.print("MAC: ");
67
68  printMacAddress(mac);
69
70  // scan for existing networks:
71
72  Serial.println();
73
74  Serial.println("Scanning available networks...");
75
76  listNetworks();
77}
78
79void loop() {
80
81  delay(10000);
82
83  // scan for existing networks:
84
85  Serial.println("Scanning available networks...");
86
87  listNetworks();
88}
89
90void listNetworks() {
91
92  // scan for nearby networks:
93
94  Serial.println("** Scan Networks **");
95
96  int numSsid = WiFi.scanNetworks();
97
98  if (numSsid == -1)
99
100  {
101
102    Serial.println("Couldn't get a WiFi connection");
103
104    while (true);
105
106  }
107
108  // print the list of networks seen:
109
110  Serial.print("number of available networks: ");
111
112  Serial.println(numSsid);
113
114  // print the network number and name for each network found:
115
116  for (int thisNet = 0; thisNet < numSsid; thisNet++) {
117
118    Serial.print(thisNet + 1);
119
120    Serial.print(") ");
121
122    Serial.print("Signal: ");
123
124    Serial.print(WiFi.RSSI(thisNet));
125
126    Serial.print(" dBm");
127
128    Serial.print("\tChannel: ");
129
130    Serial.print(WiFi.channel(thisNet));
131
132    byte bssid[6];
133
134    Serial.print("\t\tBSSID: ");
135
136    printMacAddress(WiFi.BSSID(thisNet, bssid));
137
138    Serial.print("\tEncryption: ");
139
140    printEncryptionType(WiFi.encryptionType(thisNet));
141
142    Serial.print("\t\tSSID: ");
143
144    Serial.println(WiFi.SSID(thisNet));
145
146    Serial.flush();
147
148  }
149
150  Serial.println();
151}
152
153void printEncryptionType(int thisType) {
154
155  // read the encryption type and print out the name:
156
157  switch (thisType) {
158
159    case ENC_TYPE_WEP:
160
161      Serial.print("WEP");
162
163      break;
164
165    case ENC_TYPE_TKIP:
166
167      Serial.print("WPA");
168
169      break;
170
171    case ENC_TYPE_CCMP:
172
173      Serial.print("WPA2");
174
175      break;
176
177    case ENC_TYPE_NONE:
178
179      Serial.print("None");
180
181      break;
182
183    case ENC_TYPE_AUTO:
184
185      Serial.print("Auto");
186
187      break;
188
189    case ENC_TYPE_UNKNOWN:
190
191    default:
192
193      Serial.print("Unknown");
194
195      break;
196
197  }
198}
199
200void print2Digits(byte thisByte) {
201
202  if (thisByte < 0xF) {
203
204    Serial.print("0");
205
206  }
207
208  Serial.print(thisByte, HEX);
209}
210
211void printMacAddress(byte mac[]) {
212
213  for (int i = 5; i >= 0; i--) {
214
215    if (mac[i] < 16) {
216
217      Serial.print("0");
218
219    }
220
221    Serial.print(mac[i], HEX);
222
223    if (i > 0) {
224
225      Serial.print(":");
226
227    }
228
229  }
230
231  Serial.println();
232}

WifiNINA Simple Web Server WiFi

In this example, a simple web server lets you blink an LED via the web. This example will print the IP address of your WiFi module (once connected) to the Arduino Software (IDE) serial monitor. Once you know the IP address of our board, you can open that address in a web browser to turn on and off the LED on pin 9.

If you do not have an LED, you can use the built-in LED instead (just remember to change out "9" to "LED_BUILTIN")

If the IP address of your shield is yourAddress:

http://yourAddress/H turns the LED on
http://yourAddress/L turns it off

This example is written for a network using WPA encryption. For WEP or WPA, change the Wifi.begin() call accordingly.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The shield will not connect to networks using WPA2 Enterprise encryption.

1/*
2
3  WiFi Web Server LED Blink
4
5 A simple web server that lets you blink an LED via the web.
6
7 This sketch will print the IP address of your WiFi module (once connected)
8
9 to the Serial monitor. From there, you can open that address in a web browser
10
11 to turn on and off the LED on pin 9.
12
13 If the IP address of your board is yourAddress:
14
15 http://yourAddress/H turns the LED on
16
17 http://yourAddress/L turns it off
18
19 This example is written for a network using WPA encryption. For
20
21 WEP or WPA, change the Wifi.begin() call accordingly.
22
23 Circuit:
24
25 * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
26
27 * LED attached to pin 9
28
29 created 25 Nov 2012
30
31 by Tom Igoe
32
33 */
34#include <SPI.h>
35#include <WiFiNINA.h>
36
37#include "arduino_secrets.h"
38///////please enter your sensitive data in the Secret tab/arduino_secrets.h
39char ssid[] = SECRET_SSID;        // your network SSID (name)
40char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
41int keyIndex = 0;                 // your network key Index number (needed only for WEP)
42
43int status = WL_IDLE_STATUS;
44
45WiFiServer server(80);
46
47void setup() {
48
49  Serial.begin(9600);      // initialize serial communication
50
51  pinMode(9, OUTPUT);      // set the LED pin mode
52
53  // check for the WiFi module:
54
55  if (WiFi.status() == WL_NO_MODULE) {
56
57    Serial.println("Communication with WiFi module failed!");
58
59    // don't continue
60
61    while (true);
62
63  }
64
65  String fv = WiFi.firmwareVersion();
66
67  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
68
69    Serial.println("Please upgrade the firmware");
70
71  }
72
73  // attempt to connect to Wifi network:
74
75  while (status != WL_CONNECTED) {
76
77    Serial.print("Attempting to connect to Network named: ");
78
79    Serial.println(ssid);                   // print the network name (SSID);
80
81    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
82
83    status = WiFi.begin(ssid, pass);
84
85    // wait 10 seconds for connection:
86
87    delay(10000);
88
89  }
90
91  server.begin();                           // start the web server on port 80
92
93  printWifiStatus();                        // you're connected now, so print out the status
94}
95
96void loop() {
97
98  WiFiClient client = server.available();   // listen for incoming clients
99
100  if (client) {                             // if you get a client,
101
102    Serial.println("new client");           // print a message out the serial port
103
104    String currentLine = "";                // make a String to hold incoming data from the client
105
106    while (client.connected()) {            // loop while the client's connected
107
108      if (client.available()) {             // if there's bytes to read from the client,
109
110        char c = client.read();             // read a byte, then
111
112        Serial.write(c);                    // print it out the serial monitor
113
114        if (c == '\n') {                    // if the byte is a newline character
115
116          // if the current line is blank, you got two newline characters in a row.
117
118          // that's the end of the client HTTP request, so send a response:
119
120          if (currentLine.length() == 0) {
121
122            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
123
124            // and a content-type so the client knows what's coming, then a blank line:
125
126            client.println("HTTP/1.1 200 OK");
127
128            client.println("Content-type:text/html");
129
130            client.println();
131
132            // the content of the HTTP response follows the header:
133
134            client.print("Click <a href=\"/H\">here</a> turn the LED on pin 9 on<br>");
135
136            client.print("Click <a href=\"/L\">here</a> turn the LED on pin 9 off<br>");
137
138            // The HTTP response ends with another blank line:
139
140            client.println();
141
142            // break out of the while loop:
143
144            break;
145
146          } else {    // if you got a newline, then clear currentLine:
147
148            currentLine = "";
149
150          }
151
152        } else if (c != '\r') {  // if you got anything else but a carriage return character,
153
154          currentLine += c;      // add it to the end of the currentLine
155
156        }
157
158        // Check to see if the client request was "GET /H" or "GET /L":
159
160        if (currentLine.endsWith("GET /H")) {
161
162          digitalWrite(9, HIGH);               // GET /H turns the LED on
163
164        }
165
166        if (currentLine.endsWith("GET /L")) {
167
168          digitalWrite(9, LOW);                // GET /L turns the LED off
169
170        }
171
172      }
173
174    }
175
176    // close the connection:
177
178    client.stop();
179
180    Serial.println("client disconnected");
181
182  }
183}
184
185void printWifiStatus() {
186
187  // print the SSID of the network you're attached to:
188
189  Serial.print("SSID: ");
190
191  Serial.println(WiFi.SSID());
192
193  // print your board's IP address:
194
195  IPAddress ip = WiFi.localIP();
196
197  Serial.print("IP Address: ");
198
199  Serial.println(ip);
200
201  // print the received signal strength:
202
203  long rssi = WiFi.RSSI();
204
205  Serial.print("signal strength (RSSI):");
206
207  Serial.print(rssi);
208
209  Serial.println(" dBm");
210
211  // print where to go in a browser:
212
213  Serial.print("To see this page in action, open a browser to http://");
214
215  Serial.println(ip);
216}

WifiNINA Udp NTP Client

In this example, you will use your board's wifi capabilities to query a Network Time Protocol (NTP) server. In this way, your board can get the time from the Internet.

1/*
2
3 Udp NTP Client
4
5 Get the time from a Network Time Protocol (NTP) time server
6
7 Demonstrates use of UDP sendPacket and ReceivePacket
8
9 For more on NTP time servers and the messages needed to communicate with them,
10
11 see http://en.wikipedia.org/wiki/Network_Time_Protocol
12
13 created 4 Sep 2010
14
15 by Michael Margolis
16
17 modified 9 Apr 2012
18
19 by Tom Igoe
20
21 This code is in the public domain.
22
23 */
24
25#include <SPI.h>
26#include <WiFiNINA.h>
27#include <WiFiUdp.h>
28
29int status = WL_IDLE_STATUS;
30#include "arduino_secrets.h"
31///////please enter your sensitive data in the Secret tab/arduino_secrets.h
32char ssid[] = SECRET_SSID;        // your network SSID (name)
33char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
34int keyIndex = 0;            // your network key Index number (needed only for WEP)
35
36unsigned int localPort = 2390;      // local port to listen for UDP packets
37
38IPAddress timeServer(129, 6, 15, 28); // time.nist.gov NTP server
39
40const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
41
42byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
43
44// A UDP instance to let us send and receive packets over UDP
45
46WiFiUDP Udp;
47
48void setup() {
49
50  // Open serial communications and wait for port to open:
51
52  Serial.begin(9600);
53
54  while (!Serial) {
55
56    ; // wait for serial port to connect. Needed for native USB port only
57
58  }
59
60  // check for the WiFi module:
61
62  if (WiFi.status() == WL_NO_MODULE) {
63
64    Serial.println("Communication with WiFi module failed!");
65
66    // don't continue
67
68    while (true);
69
70  }
71
72  String fv = WiFi.firmwareVersion();
73
74  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
75
76    Serial.println("Please upgrade the firmware");
77
78  }
79
80  // attempt to connect to Wifi network:
81
82  while (status != WL_CONNECTED) {
83
84    Serial.print("Attempting to connect to SSID: ");
85
86    Serial.println(ssid);
87
88    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
89
90    status = WiFi.begin(ssid, pass);
91
92    // wait 10 seconds for connection:
93
94    delay(10000);
95
96  }
97
98  Serial.println("Connected to wifi");
99
100  printWifiStatus();
101
102  Serial.println("\nStarting connection to server...");
103
104  Udp.begin(localPort);
105}
106
107void loop() {
108
109  sendNTPpacket(timeServer); // send an NTP packet to a time server
110
111  // wait to see if a reply is available
112
113  delay(1000);
114
115  if (Udp.parsePacket()) {
116
117    Serial.println("packet received");
118
119    // We've received a packet, read the data from it
120
121    Udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer
122
123    //the timestamp starts at byte 40 of the received packet and is four bytes,
124
125    // or two words, long. First, esxtract the two words:
126
127    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
128
129    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
130
131    // combine the four bytes (two words) into a long integer
132
133    // this is NTP time (seconds since Jan 1 1900):
134
135    unsigned long secsSince1900 = highWord << 16 | lowWord;
136
137    Serial.print("Seconds since Jan 1 1900 = ");
138
139    Serial.println(secsSince1900);
140
141    // now convert NTP time into everyday time:
142
143    Serial.print("Unix time = ");
144
145    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
146
147    const unsigned long seventyYears = 2208988800UL;
148
149    // subtract seventy years:
150
151    unsigned long epoch = secsSince1900 - seventyYears;
152
153    // print Unix time:
154
155    Serial.println(epoch);
156
157    // print the hour, minute and second:
158
159    Serial.print("The UTC time is ");       // UTC is the time at Greenwich Meridian (GMT)
160
161    Serial.print((epoch  % 86400L) / 3600); // print the hour (86400 equals secs per day)
162
163    Serial.print(':');
164
165    if (((epoch % 3600) / 60) < 10) {
166
167      // In the first 10 minutes of each hour, we'll want a leading '0'
168
169      Serial.print('0');
170
171    }
172
173    Serial.print((epoch  % 3600) / 60); // print the minute (3600 equals secs per minute)
174
175    Serial.print(':');
176
177    if ((epoch % 60) < 10) {
178
179      // In the first 10 seconds of each minute, we'll want a leading '0'
180
181      Serial.print('0');
182
183    }
184
185    Serial.println(epoch % 60); // print the second
186
187  }
188
189  // wait ten seconds before asking for the time again
190
191  delay(10000);
192}
193
194// send an NTP request to the time server at the given address
195unsigned long sendNTPpacket(IPAddress& address) {
196
197  //Serial.println("1");
198
199  // set all bytes in the buffer to 0
200
201  memset(packetBuffer, 0, NTP_PACKET_SIZE);
202
203  // Initialize values needed to form NTP request
204
205  // (see URL above for details on the packets)
206
207  //Serial.println("2");
208
209  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
210
211  packetBuffer[1] = 0;     // Stratum, or type of clock
212
213  packetBuffer[2] = 6;     // Polling Interval
214
215  packetBuffer[3] = 0xEC;  // Peer Clock Precision
216
217  // 8 bytes of zero for Root Delay & Root Dispersion
218
219  packetBuffer[12]  = 49;
220
221  packetBuffer[13]  = 0x4E;
222
223  packetBuffer[14]  = 49;
224
225  packetBuffer[15]  = 52;
226
227  //Serial.println("3");
228
229  // all NTP fields have been given values, now
230
231  // you can send a packet requesting a timestamp:
232
233  Udp.beginPacket(address, 123); //NTP requests are to port 123
234
235  //Serial.println("4");
236
237  Udp.write(packetBuffer, NTP_PACKET_SIZE);
238
239  //Serial.println("5");
240
241  Udp.endPacket();
242
243  //Serial.println("6");
244}
245
246void printWifiStatus() {
247
248  // print the SSID of the network you're attached to:
249
250  Serial.print("SSID: ");
251
252  Serial.println(WiFi.SSID());
253
254  // print your board's IP address:
255
256  IPAddress ip = WiFi.localIP();
257
258  Serial.print("IP Address: ");
259
260  Serial.println(ip);
261
262  // print the received signal strength:
263
264  long rssi = WiFi.RSSI();
265
266  Serial.print("signal strength (RSSI):");
267
268  Serial.print(rssi);
269
270  Serial.println(" dBm");
271}

WifiNINA WiFi Chat Server

A simple server that distributes any incoming messages to all connected clients. To use, open a terminal window, telnet to your WiFi module's IP address, and type away. Any incoming text will be sent to all connected clients (including the one typing). Additionally, you will be able to see the client's input in your Arduino Software (IDE) serial monitor as well.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The shield will not connect to networks using WPA2 Enterprise encryption.

1/*
2
3 Chat  Server
4
5 A simple server that distributes any incoming messages to all
6
7 connected clients.  To use telnet to  your device's IP address and type.
8
9 You can see the client's input in the serial monitor as well.
10
11 This example is written for a network using WPA encryption. For
12
13 WEP or WPA, change the Wifi.begin() call accordingly.
14
15 Circuit:
16
17 * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
18
19 created 18 Dec 2009
20
21 by David A. Mellis
22
23 modified 31 May 2012
24
25 by Tom Igoe
26
27 */
28
29#include <SPI.h>
30#include <WiFiNINA.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)
36
37int keyIndex = 0;            // your network key Index number (needed only for WEP)
38
39int status = WL_IDLE_STATUS;
40
41WiFiServer server(23);
42
43boolean alreadyConnected = false; // whether or not the client was connected previously
44
45void setup() {
46
47  //Initialize serial and wait for port to open:
48
49  Serial.begin(9600);
50
51  while (!Serial) {
52
53    ; // wait for serial port to connect. Needed for native USB port only
54
55  }
56
57  // check for the WiFi module:
58
59  if (WiFi.status() == WL_NO_MODULE) {
60
61    Serial.println("Communication with WiFi module failed!");
62
63    // don't continue
64
65    while (true);
66
67  }
68
69  String fv = WiFi.firmwareVersion();
70
71  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
72
73    Serial.println("Please upgrade the firmware");
74
75  }
76
77  // attempt to connect to Wifi network:
78
79  while (status != WL_CONNECTED) {
80
81    Serial.print("Attempting to connect to SSID: ");
82
83    Serial.println(ssid);
84
85    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
86
87    status = WiFi.begin(ssid, pass);
88
89    // wait 10 seconds for connection:
90
91    delay(10000);
92
93  }
94
95  // start the server:
96
97  server.begin();
98
99  // you're connected now, so print out the status:
100
101  printWifiStatus();
102}
103
104void loop() {
105
106  // wait for a new client:
107
108  WiFiClient client = server.available();
109
110  // when the client sends the first byte, say hello:
111
112  if (client) {
113
114    if (!alreadyConnected) {
115
116      // clead out the input buffer:
117
118      client.flush();
119
120      Serial.println("We have a new client");
121
122      client.println("Hello, client!");
123
124      alreadyConnected = true;
125
126    }
127
128    if (client.available() > 0) {
129
130      // read the bytes incoming from the client:
131
132      char thisChar = client.read();
133
134      // echo the bytes back to the client:
135
136      server.write(thisChar);
137
138      // echo the bytes to the server as well:
139
140      Serial.write(thisChar);
141
142    }
143
144  }
145}
146
147void printWifiStatus() {
148
149  // print the SSID of the network you're attached to:
150
151  Serial.print("SSID: ");
152
153  Serial.println(WiFi.SSID());
154
155  // print your board's IP address:
156
157  IPAddress ip = WiFi.localIP();
158
159  Serial.print("IP Address: ");
160
161  Serial.println(ip);
162
163  // print the received signal strength:
164
165  long rssi = WiFi.RSSI();
166
167  Serial.print("signal strength (RSSI):");
168
169  Serial.print(rssi);
170
171  Serial.println(" dBm");
172}

WifiNINA WiFi Ping

This example connects to a encrypted WiFi network (WPA/WPA2) then it prints the MAC address of the WiFi module, the IP address obtained, and other network details. After this initial phase, the loop continuously pings a given host, specified by IP Address or name.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The module will not connect to networks using WPA2 Enterprise encryption.

1/*
2
3  This example connects to a encrypted WiFi network (WPA/WPA2).
4
5  Then it prints the  MAC address of the board,
6
7  the IP address obtained, and other network details.
8
9  Then it continuously pings given host specified by IP Address or name.
10
11  Circuit:
12
13  * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
14
15  created 13 July 2010
16
17  by dlf (Metodo2 srl)
18
19  modified 09 June 2016
20
21  by Petar Georgiev
22
23*/
24#include <SPI.h>
25#include <WiFiNINA.h>
26
27#include "arduino_secrets.h"
28///////please enter your sensitive data in the Secret tab/arduino_secrets.h
29char ssid[] = SECRET_SSID;        // your network SSID (name)
30char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
31int status = WL_IDLE_STATUS;     // the WiFi radio's status
32
33// Specify IP address or hostname
34
35String hostName = "www.google.com";
36int pingResult;
37
38void setup() {
39
40  // Initialize serial and wait for port to open:
41
42  Serial.begin(9600);
43
44  while (!Serial) {
45
46    ; // wait for serial port to connect. Needed for native USB port only
47
48  }
49
50  // check for the WiFi module:
51
52  if (WiFi.status() == WL_NO_MODULE) {
53
54    Serial.println("Communication with WiFi module failed!");
55
56    // don't continue
57
58    while (true);
59
60  }
61
62  String fv = WiFi.firmwareVersion();
63
64  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
65
66    Serial.println("Please upgrade the firmware");
67
68  }
69
70  // attempt to connect to WiFi network:
71
72  while ( status != WL_CONNECTED) {
73
74    Serial.print("Attempting to connect to WPA SSID: ");
75
76    Serial.println(ssid);
77
78    // Connect to WPA/WPA2 network:
79
80    status = WiFi.begin(ssid, pass);
81
82    // wait 5 seconds for connection:
83
84    delay(5000);
85
86  }
87
88  // you're connected now, so print out the data:
89
90  Serial.println("You're connected to the network");
91
92  printCurrentNet();
93
94  printWiFiData();
95}
96
97void loop() {
98
99  Serial.print("Pinging ");
100
101  Serial.print(hostName);
102
103  Serial.print(": ");
104
105  pingResult = WiFi.ping(hostName);
106
107  if (pingResult >= 0) {
108
109    Serial.print("SUCCESS! RTT = ");
110
111    Serial.print(pingResult);
112
113    Serial.println(" ms");
114
115  } else {
116
117    Serial.print("FAILED! Error code: ");
118
119    Serial.println(pingResult);
120
121  }
122
123  delay(5000);
124}
125
126void printWiFiData() {
127
128  // print your board's IP address:
129
130  IPAddress ip = WiFi.localIP();
131
132  Serial.print("IP address : ");
133
134  Serial.println(ip);
135
136  Serial.print("Subnet mask: ");
137
138  Serial.println((IPAddress)WiFi.subnetMask());
139
140  Serial.print("Gateway IP : ");
141
142  Serial.println((IPAddress)WiFi.gatewayIP());
143
144  // print your MAC address:
145
146  byte mac[6];
147
148  WiFi.macAddress(mac);
149
150  Serial.print("MAC address: ");
151
152  printMacAddress(mac);
153}
154
155void printCurrentNet() {
156
157  // print the SSID of the network you're attached to:
158
159  Serial.print("SSID: ");
160
161  Serial.println(WiFi.SSID());
162
163  // print the MAC address of the router you're attached to:
164
165  byte bssid[6];
166
167  WiFi.BSSID(bssid);
168
169  Serial.print("BSSID: ");
170
171  printMacAddress(bssid);
172
173  // print the received signal strength:
174
175  long rssi = WiFi.RSSI();
176
177  Serial.print("signal strength (RSSI): ");
178
179  Serial.println(rssi);
180
181  // print the encryption type:
182
183  byte encryption = WiFi.encryptionType();
184
185  Serial.print("Encryption Type: ");
186
187  Serial.println(encryption, HEX);
188
189  Serial.println();
190}
191
192void printMacAddress(byte mac[]) {
193
194  for (int i = 5; i >= 0; i--) {
195
196    if (mac[i] < 16) {
197
198      Serial.print("0");
199
200    }
201
202    Serial.print(mac[i], HEX);
203
204    if (i > 0) {
205
206      Serial.print(":");
207
208    }
209
210  }
211
212  Serial.println();
213}

WifiNINA WiFi SSL Client

This example creates a client object that connects and transfers data using always SSL.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The module will not connect to networks using WPA2 Enterprise encryption.

1/*
2
3This example creates a client object that connects and transfers
4
5data using always SSL.
6
7It is compatible with the methods normally related to plain
8
9connections, like client.connect(host, port).
10
11Written by Arturo Guadalupi
12
13last revision November 2015
14
15*/
16
17#include <SPI.h>
18#include <WiFiNINA.h>
19
20#include "arduino_secrets.h"
21///////please enter your sensitive data in the Secret tab/arduino_secrets.h
22char ssid[] = SECRET_SSID;        // your network SSID (name)
23char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
24int keyIndex = 0;            // your network key Index number (needed only for WEP)
25
26int status = WL_IDLE_STATUS;
27// if you don't want to use DNS (and reduce your sketch size)
28// use the numeric IP instead of the name for the server:
29//IPAddress server(74,125,232,128);  // numeric IP for Google (no DNS)
30char server[] = "www.google.com";    // name address for Google (using DNS)
31
32// Initialize the Ethernet client library
33// with the IP address and port of the server
34// that you want to connect to (port 80 is default for HTTP):
35
36WiFiSSLClient client;
37
38void setup() {
39
40  //Initialize serial and wait for port to open:
41
42  Serial.begin(9600);
43
44  while (!Serial) {
45
46    ; // wait for serial port to connect. Needed for native USB port only
47
48  }
49
50  // check for the WiFi module:
51
52  if (WiFi.status() == WL_NO_MODULE) {
53
54    Serial.println("Communication with WiFi module failed!");
55
56    // don't continue
57
58    while (true);
59
60  }
61
62  String fv = WiFi.firmwareVersion();
63
64  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
65
66    Serial.println("Please upgrade the firmware");
67
68  }
69
70  // attempt to connect to WiFi network:
71
72  while (status != WL_CONNECTED) {
73
74    Serial.print("Attempting to connect to SSID: ");
75
76    Serial.println(ssid);
77
78    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
79
80    status = WiFi.begin(ssid, pass);
81
82    // wait 10 seconds for connection:
83
84    delay(10000);
85
86  }
87
88  Serial.println("Connected to wifi");
89
90  printWiFiStatus();
91
92  Serial.println("\nStarting connection to server...");
93
94  // if you get a connection, report back via serial:
95
96  if (client.connect(server, 443)) {
97
98    Serial.println("connected to server");
99
100    // Make a HTTP request:
101
102    client.println("GET /search?q=arduino HTTP/1.1");
103
104    client.println("Host: www.google.com");
105
106    client.println("Connection: close");
107
108    client.println();
109
110  }
111}
112
113void loop() {
114
115  // if there are incoming bytes available
116
117  // from the server, read them and print them:
118
119  while (client.available()) {
120
121    char c = client.read();
122
123    Serial.write(c);
124
125  }
126
127  // if the server's disconnected, stop the client:
128
129  if (!client.connected()) {
130
131    Serial.println();
132
133    Serial.println("disconnecting from server.");
134
135    client.stop();
136
137    // do nothing forevermore:
138
139    while (true);
140
141  }
142}
143
144void printWiFiStatus() {
145
146  // print the SSID of the network you're attached to:
147
148  Serial.print("SSID: ");
149
150  Serial.println(WiFi.SSID());
151
152  // print your board's IP address:
153
154  IPAddress ip = WiFi.localIP();
155
156  Serial.print("IP Address: ");
157
158  Serial.println(ip);
159
160  // print the received signal strength:
161
162  long rssi = WiFi.RSSI();
163
164  Serial.print("signal strength (RSSI):");
165
166  Serial.print(rssi);
167
168  Serial.println(" dBm");
169}

WifiNINA WiFi Udp Send Receive String

This tutorial waits for a UDP packet on a local port. When a valid packet is received, an acknowledge packet is sent back to the client on a specified outgoing port. It relies on a WiFi connection made to your WiFi equipped board.

1/*
2
3  WiFi UDP Send and Receive String
4
5 This sketch wait an UDP packet on localPort using the WiFi module.
6
7 When a packet is received an Acknowledge packet is sent to the client on port remotePort
8
9 created 30 December 2012
10
11 by dlf (Metodo2 srl)
12
13 */
14
15#include <SPI.h>
16#include <WiFiNINA.h>
17#include <WiFiUdp.h>
18
19int status = WL_IDLE_STATUS;
20#include "arduino_secrets.h"
21///////please enter your sensitive data in the Secret tab/arduino_secrets.h
22char ssid[] = SECRET_SSID;        // your network SSID (name)
23char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
24int keyIndex = 0;            // your network key Index number (needed only for WEP)
25
26unsigned int localPort = 2390;      // local port to listen on
27
28char packetBuffer[256]; //buffer to hold incoming packet
29char  ReplyBuffer[] = "acknowledged";       // a string to send back
30
31WiFiUDP Udp;
32
33void setup() {
34
35  //Initialize serial and wait for port to open:
36
37  Serial.begin(9600);
38
39  while (!Serial) {
40
41    ; // wait for serial port to connect. Needed for native USB port only
42
43  }
44
45  // check for the WiFi module:
46
47  if (WiFi.status() == WL_NO_MODULE) {
48
49    Serial.println("Communication with WiFi module failed!");
50
51    // don't continue
52
53    while (true);
54
55  }
56
57  String fv = WiFi.firmwareVersion();
58
59  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
60
61    Serial.println("Please upgrade the firmware");
62
63  }
64
65  // attempt to connect to Wifi network:
66
67  while (status != WL_CONNECTED) {
68
69    Serial.print("Attempting to connect to SSID: ");
70
71    Serial.println(ssid);
72
73    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
74
75    status = WiFi.begin(ssid, pass);
76
77    // wait 10 seconds for connection:
78
79    delay(10000);
80
81  }
82
83  Serial.println("Connected to wifi");
84
85  printWifiStatus();
86
87  Serial.println("\nStarting connection to server...");
88
89  // if you get a connection, report back via serial:
90
91  Udp.begin(localPort);
92}
93
94void loop() {
95
96  // if there's data available, read a packet
97
98  int packetSize = Udp.parsePacket();
99
100  if (packetSize) {
101
102    Serial.print("Received packet of size ");
103
104    Serial.println(packetSize);
105
106    Serial.print("From ");
107
108    IPAddress remoteIp = Udp.remoteIP();
109
110    Serial.print(remoteIp);
111
112    Serial.print(", port ");
113
114    Serial.println(Udp.remotePort());
115
116    // read the packet into packetBufffer
117
118    int len = Udp.read(packetBuffer, 255);
119
120    if (len > 0) {
121
122      packetBuffer[len] = 0;
123
124    }
125
126    Serial.println("Contents:");
127
128    Serial.println(packetBuffer);
129
130    // send a reply, to the IP address and port that sent us the packet we received
131
132    Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
133
134    Udp.write(ReplyBuffer);
135
136    Udp.endPacket();
137
138  }
139}
140
141void printWifiStatus() {
142
143  // print the SSID of the network you're attached to:
144
145  Serial.print("SSID: ");
146
147  Serial.println(WiFi.SSID());
148
149  // print your board's IP address:
150
151  IPAddress ip = WiFi.localIP();
152
153  Serial.print("IP Address: ");
154
155  Serial.println(ip);
156
157  // print the received signal strength:
158
159  long rssi = WiFi.RSSI();
160
161  Serial.print("signal strength (RSSI):");
162
163  Serial.print(rssi);
164
165  Serial.println(" dBm");
166}

WifiNINA WiFi Web Client

This example shows you how to make a HTTP request using a WiFi module equipped board. It returns a Google search for the term "Arduino". The results of this search are viewable as HTML through your Arduino Software (IDE) serial window.

This example is written for a network using WPA encryption. For WEP or WPA, change the Wifi.begin() call accordingly.

1/*
2
3  Web client
4
5 This sketch connects to a website (http://www.google.com)
6
7 using the WiFi module.
8
9 This example is written for a network using WPA encryption. For
10
11 WEP or WPA, change the Wifi.begin() call accordingly.
12
13 This example is written for a network using WPA encryption. For
14
15 WEP or WPA, change the Wifi.begin() call accordingly.
16
17 Circuit:
18
19 * Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
20
21 created 13 July 2010
22
23 by dlf (Metodo2 srl)
24
25 modified 31 May 2012
26
27 by Tom Igoe
28
29 */
30
31#include <SPI.h>
32#include <WiFiNINA.h>
33
34#include "arduino_secrets.h"
35///////please enter your sensitive data in the Secret tab/arduino_secrets.h
36char ssid[] = SECRET_SSID;        // your network SSID (name)
37char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
38int keyIndex = 0;            // your network key Index number (needed only for WEP)
39
40int status = WL_IDLE_STATUS;
41// if you don't want to use DNS (and reduce your sketch size)
42// use the numeric IP instead of the name for the server:
43//IPAddress server(74,125,232,128);  // numeric IP for Google (no DNS)
44char server[] = "www.google.com";    // name address for Google (using DNS)
45
46// Initialize the Ethernet client library
47// with the IP address and port of the server
48// that you want to connect to (port 80 is default for HTTP):
49
50WiFiClient client;
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 WiFi module:
65
66  if (WiFi.status() == WL_NO_MODULE) {
67
68    Serial.println("Communication with WiFi module failed!");
69
70    // don't continue
71
72    while (true);
73
74  }
75
76  String fv = WiFi.firmwareVersion();
77
78  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
79
80    Serial.println("Please upgrade the firmware");
81
82  }
83
84  // attempt to connect to Wifi network:
85
86  while (status != WL_CONNECTED) {
87
88    Serial.print("Attempting to connect to SSID: ");
89
90    Serial.println(ssid);
91
92    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
93
94    status = WiFi.begin(ssid, pass);
95
96    // wait 10 seconds for connection:
97
98    delay(10000);
99
100  }
101
102  Serial.println("Connected to wifi");
103
104  printWifiStatus();
105
106  Serial.println("\nStarting connection to server...");
107
108  // if you get a connection, report back via serial:
109
110  if (client.connect(server, 80)) {
111
112    Serial.println("connected to server");
113
114    // Make a HTTP request:
115
116    client.println("GET /search?q=arduino HTTP/1.1");
117
118    client.println("Host: www.google.com");
119
120    client.println("Connection: close");
121
122    client.println();
123
124  }
125}
126
127void loop() {
128
129  // if there are incoming bytes available
130
131  // from the server, read them and print them:
132
133  while (client.available()) {
134
135    char c = client.read();
136
137    Serial.write(c);
138
139  }
140
141  // if the server's disconnected, stop the client:
142
143  if (!client.connected()) {
144
145    Serial.println();
146
147    Serial.println("disconnecting from server.");
148
149    client.stop();
150
151    // do nothing forevermore:
152
153    while (true);
154
155  }
156}
157
158void printWifiStatus() {
159
160  // print the SSID of the network you're attached to:
161
162  Serial.print("SSID: ");
163
164  Serial.println(WiFi.SSID());
165
166  // print your board's IP address:
167
168  IPAddress ip = WiFi.localIP();
169
170  Serial.print("IP Address: ");
171
172  Serial.println(ip);
173
174  // print the received signal strength:
175
176  long rssi = WiFi.RSSI();
177
178  Serial.print("signal strength (RSSI):");
179
180  Serial.print(rssi);
181
182  Serial.println(" dBm");
183}

WifiNINA WiFi Web Client Repeating

This example shows you how to make repeated HTTP requests using a WiFi equipped board. It connects to http://example.org. The content of the page is viewable through your Arduino Software (IDE) Serial Monitor window.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The shield will not connect to networks using WPA2 Enterprise encryption.

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

WifiNINA WiFi Web Server

In this example, you will use the WiFi module of your board to create a simple Web server. Using the WiFi 1010 library, your device will be able to answer a HTTP request received from the WiFI connection. After opening a browser and navigating to your WiFi's IP address, your board will respond with just enough HTML for a browser to display the input values from all six analog pins.

This example is written for a network using WPA encryption. For WEP or WPA, change the Wifi.begin() call accordingly.

For networks using WPA/WPA2 Personal encryption, you need the SSID and password. The shield will not connect to networks using WPA2 Enterprise encryption.

1/*
2  WiFi Web Server
3
4 A simple web server that shows the value of the analog input pins.
5
6 This example is written for a network using WPA encryption. For
7 WEP or WPA, change the Wifi.begin() call accordingly.
8
9 Circuit:
10 * Analog inputs attached to pins A0 through A5 (optional)
11
12 created 13 July 2010
13 by dlf (Metodo2 srl)
14 modified 31 May 2012
15 by Tom Igoe
16
17 */
18
19#include <SPI.h>
20#include <WiFiNINA.h>
21
22
23#include "arduino_secrets.h" 
24///////please enter your sensitive data in the Secret tab/arduino_secrets.h
25char ssid[] = SECRET_SSID;        // your network SSID (name)
26char pass[] = SECRET_PASS;    // your network password (use for WPA, or use as key for WEP)
27int keyIndex = 0;                 // your network key Index number (needed only for WEP)
28
29int status = WL_IDLE_STATUS;
30
31WiFiServer server(80);
32
33void setup() {
34  //Initialize serial and wait for port to open:
35  Serial.begin(9600);
36  while (!Serial) {
37    ; // wait for serial port to connect. Needed for native USB port only
38  }
39
40  // check for the WiFi module:
41  if (WiFi.status() == WL_NO_MODULE) {
42    Serial.println("Communication with WiFi module failed!");
43    // don't continue
44    while (true);
45  }
46
47  String fv = WiFi.firmwareVersion();
48  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
49    Serial.println("Please upgrade the firmware");
50  }
51
52  // attempt to connect to Wifi network:
53  while (status != WL_CONNECTED) {
54    Serial.print("Attempting to connect to SSID: ");
55    Serial.println(ssid);
56    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
57    status = WiFi.begin(ssid, pass);
58
59    // wait 10 seconds for connection:
60    delay(10000);
61  }
62  server.begin();
63  // you're connected now, so print out the status:
64  printWifiStatus();
65}
66
67
68void loop() {
69  // listen for incoming clients
70  WiFiClient client = server.available();
71  if (client) {
72    Serial.println("new client");
73    // an http request ends with a blank line
74    boolean currentLineIsBlank = true;
75    while (client.connected()) {
76      if (client.available()) {
77        char c = client.read();
78        Serial.write(c);
79        // if you've gotten to the end of the line (received a newline
80        // character) and the line is blank, the http request has ended,
81        // so you can send a reply
82        if (c == '\n' && currentLineIsBlank) {
83          // send a standard http response header
84          client.println("HTTP/1.1 200 OK");
85          client.println("Content-Type: text/html");
86          client.println("Connection: close");  // the connection will be closed after completion of the response
87          client.println("Refresh: 5");  // refresh the page automatically every 5 sec
88          client.println();
89          client.println("<!DOCTYPE HTML>");
90          client.println("<html>");
91          // output the value of each analog input pin
92          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
93            int sensorReading = analogRead(analogChannel);
94            client.print("analog input ");
95            client.print(analogChannel);
96            client.print(" is ");
97            client.print(sensorReading);
98            client.println("<br />");
99          }
100          client.println("</html>");
101          break;
102        }
103        if (c == '\n') {
104          // you're starting a new line
105          currentLineIsBlank = true;
106        } else if (c != '\r') {
107          // you've gotten a character on the current line
108          currentLineIsBlank = false;
109        }
110      }
111    }
112    // give the web browser time to receive the data
113    delay(1);
114
115    // close the connection:
116    client.stop();
117    Serial.println("client disconnected");
118  }
119}
120
121
122void printWifiStatus() {
123  // print the SSID of the network you're attached to:
124  Serial.print("SSID: ");
125  Serial.println(WiFi.SSID());
126
127  // print your board's IP address:
128  IPAddress ip = WiFi.localIP();
129  Serial.print("IP Address: ");
130  Serial.println(ip);
131
132  // print the received signal strength:
133  long rssi = WiFi.RSSI();
134  Serial.print("signal strength (RSSI):");
135  Serial.print(rssi);
136  Serial.println(" dBm");
137}

NINA Firmware

Firmware Version

It is important to check firmware version against WiFiNNINA library version so that they are both aligned. Having different versions of library and firmware may create compatibility issues.

Code

When you load the sketch on the board, it will wait for a serial monitor console to be opened on your computer, then it prints out the result of the check between the expected firmware and the one available. If everything is fine, then you can proceed with your tasks, otherwise you should update the firmware following this update procedure.

The sketch can be found in the snippet below:

1/*
2
3 * This example check if the firmware loaded on the NINA module
4
5 * is updated.
6
7 *
8
9 * Circuit:
10
11 * - Board with NINA module (Arduino MKR WiFi 1010, MKR VIDOR 4000 and UNO WiFi Rev.2)
12
13 *
14
15 * Created 17 October 2018 by Riccardo Rosario Rizzo
16
17 * This code is in the public domain.
18
19 */
20#include <SPI.h>
21#include <WiFiNINA.h>
22
23void setup() {
24
25  // Initialize serial
26
27  Serial.begin(9600);
28
29  while (!Serial) {
30
31    ; // wait for serial port to connect. Needed for native USB port only
32
33  }
34
35  // Print a welcome message
36
37  Serial.println("WiFiNINA firmware check.");
38
39  Serial.println();
40
41  // check for the WiFi module:
42
43  if (WiFi.status() == WL_NO_MODULE) {
44
45    Serial.println("Communication with WiFi module failed!");
46
47    // don't continue
48
49    while (true);
50
51  }
52
53  // Print firmware version on the module
54
55  String fv = WiFi.firmwareVersion();
56
57  String latestFv;
58
59  Serial.print("Firmware version installed: ");
60
61  Serial.println(fv);
62
63  latestFv = WIFI_FIRMWARE_LATEST_VERSION;
64
65  // Print required firmware version
66
67  Serial.print("Latest firmware version available : ");
68
69  Serial.println(latestFv);
70
71  // Check if the latest version is installed
72
73  Serial.println();
74
75  if (fv >= latestFv) {
76
77    Serial.println("Check result: PASSED");
78
79  } else {
80
81    Serial.println("Check result: NOT PASSED");
82
83    Serial.println(" - The firmware version on the module do not match the");
84
85    Serial.println("   version required by the library, you may experience");
86
87    Serial.println("   issues or failures.");
88
89  }
90}
91
92void loop() {
93
94  // do nothing
95}

Firmware Update

To update the firmware on your NINA module, you can visit the Firmware/Certificate uploader for u-Blox NINA modules tutorial for instructions.

Suggest changes

The content on docs.arduino.cc is facilitated through a public GitHub repository. If you see anything wrong, you can edit this page here.

Need support?

Help Center Ask the Arduino Forum Discover Arduino Discord

License

The Arduino documentation is licensed under the Creative Commons Attribution-Share Alike 4.0 license.

WiFiNINA Library Examples

Hardware Required

Circuit

Examples

WiFiNINA AP Simple Web Server

WiFiNINA Connect No Encryption

WifiNINA Connect With WEP

WifiNINA Connect With WPA

WifiNINA Scan Networks

WifiNINA Scan Networks Advanced

WifiNINA Simple Web Server WiFi

WifiNINA Udp NTP Client

WifiNINA WiFi Chat Server

WifiNINA WiFi Ping

WifiNINA WiFi SSL Client

WifiNINA WiFi Udp Send Receive String

WifiNINA WiFi Web Client

WifiNINA WiFi Web Client Repeating

WifiNINA WiFi Web Server

NINA Firmware

Firmware Version

Code

Firmware Update

Suggest changes

Need support?

License

ON THIS PAGE