Internet of Things with Arduino Cookbook: Build exciting IoT projects using the Arduino platform

The first thing you need to do is to download the latest version of the Arduino IDE from the following address:

https://www.arduino.cc/en/Main/Software

This is what you should see, and you should be able to select your operating system:

You can now install the Arduino IDE, and open it on your computer. The Arduino IDE will be used through the whole book for several tasks. We will use it to write down all the code, but also to configure the Arduino boards and to read debug information back from those boards using the Arduino IDE Serial monitor.

What we need to install now is the board definition for the MKR1000 board that we are going to use in this book. To do that, open the Arduino boards manager by going to Tools | Boards | Boards Manager. In there, search for SAMD boards:

To install the board definition, just click on the little Install button next to the board definition.

You should now be able to select the Arduino/GenuinoMKR1000 board inside the Arduino IDE:

You are now completely set to develop Arduino projects using the Arduino IDE and the MKR1000 board. You can, for example, try to open an example sketch inside the IDE:

The Arduino IDE is the best tool to program a wide range of boards, including the MKR1000 board that we are going to use in this book. We will see that it is a great tool to develop Internet of Things projects with Arduino. As we saw in this recipe, the board manager makes it really easy to use new boards inside the IDE.

These are really the basics of the Arduino framework that we are going to use in the whole book to develop IoT projects.

The first option, which has been available since the advent of the Arduino platform, is to use a shield. A shield is basically an extension board that can be placed on top of the Arduino board. There are many shields available for Arduino. Inside the official collection of shields, you will find motor shields, prototyping shields, audio shields, and so on.

Some shields will add Internet connectivity to the Arduino boards, for example, the Ethernet shield or the Wi-Fi shield. This is an image of the Ethernet shield:

The other option is to use an external component, for example, a Wi-Fi chip mounted on a breakout board, and then connect this shield to Arduino.

There are many Wi-Fi chips available on the market. For example, Texas Instruments has a chip called the CC3000 that is really easy to connect to Arduino. This is an image of a breakout board for the CC3000 Wi-Fi chip:

Finally, there is the possibility of using one of the few Arduino boards that has an onboard Wi-Fi chip or Ethernet connectivity.

The first board of this type introduced by Arduino was the Arduino Yun board. It is a really powerful board, with an onboard Linux machine. However, it is also a bit complex to use compared to other Arduino boards.

Then, Arduino introduced the MKR1000 board, which is a board that integrates a powerful ARM Cortex M0+ process and a Wi-Fi chip on the same board, all in the small form factor.

Here is an image of this board:

Of course, there are other options to connect Arduino boards to the Web. One option that's becoming more and more popular is to use 3G or LTE to connect your Arduino projects to the Web, again using either shields or breakout boards. This solution has the advantage of not requiring an active Internet connection like a Wi-Fi router, and can be used anywhere, for example, outdoors.

Now that we have chosen a board that we will use in our IoT projects with Arduino, you can move on to the next recipe to actually learn how to use it.

For this project, you will need a few extra components in addition to the Arduino MKR1000 board and the usual breadboard and jumper wires:

We are now going to assemble the project. First, place the resistor in series with the photocell on the breadboard, next to the MKR1000 board.

Now, connect the other end of the resistor to GND on the MKR1000 board, and the other end of the photocell to the VCC pin of the Arduino board. Finally, connect the middle pin between the resistor and the photocell to analog pin A0 of the MKR1000.

This is the final result:

This project was really simple, and illustrated how to read data from an analog pin on the MKR1000 board. In this project, we simply read data on analog pin A0, and printed the readings on the Serial monitor. As the photocell is acting as a variable resistor (depending on the ambient light level), we are directly reading a signal that changes depending on the ambient light level.

You can now move on to the next recipe that will show you how to control outputs on the board, or even to the recipes. After that, you will learn how to send measurement data on the cloud.

To realize this recipe, we first need to have something to control. Here, I will just use a simple relay, but you can of course use components, such as a single LED.

This is the relay I used for this recipe:

We are now going to assemble the project for this recipe. First, plug the MKR1000 board into the breadboard. After that, connect the relay VCC pin to the VCC pin of the Arduino board, and the GND pin to the ground of the MKR1000. Finally, connect the SIG pin of the relay to pin 5 of the Arduino board. This is the final result:

The sketch simply uses the digitalWrite() function of the Arduino language to control the state of the pin to which the relay is connected, along with the delay() function, therefore switching the relay on and off continuously.

You can, of course, use what you learned in this project to control other output devices, such as LEDs. We are going to see in other recipes, later in this book, how to control larger output devices, such as lamps and other home appliances.

You can now continue to the next set of recipes, where we are actually going to connect the board to the Internet.

Before we can use the Wi-Fi chip that is on the board, we need an Arduino library to be able to control it. The library for this chip is called the WiFi101 library and you can find it inside the Arduino library manager.

To access the library manager, simply go to Sketch | Include Library | Manage Libraries inside the Arduino IDE. Then, type wifi101 to find the library:

To install the library from there, simply click on the Install button just next to the library version.

Let's now connect the board to your Wi-Fi network. The sketch is quite long here, so I have split it into three parts.

This is the main part of the sketch, which will actually connect your chip to your local Wi-Fi network:

// Libraries
#include <SPI.h>
#include <WiFi101.h>

// Credentials
char ssid[] = "wifi-name";     //  your network SSID (name)
char pass[] = "wifi-pass";  // your network password
int status = WL_IDLE_STATUS;     // the Wifi radio's status

void setup() {
  
  // Serial 
  Serial.begin(115200);

  // Attempt to connect to Wifi network:
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WPA SSID: ");
    Serial.println(ssid);
    
    // Connect to WPA/WPA2 network:
    status = WiFi.begin(ssid, pass);

    // Wait 10 seconds for connection:
    delay(10000);
  }

  // you're connected now, so print out the data:
  Serial.print("You're connected to the network");
  printCurrentNet();
  printWifiData();

}

void loop() {

  // Check the network connection once every 10 seconds:
  delay(10000);
  printCurrentNet();
}

What you actually need to change here are the following lines:

char ssid[] = "wifi-name";     //  your network SSID (name)
char pass[] = "wifi-pass";  // your network password

You need to change those lines to put your own Wi-Fi network's name and password. This is something you will have to do in all the sketches for the rest of this book, as we are always going to connect the Arduino board to the local Wi-Fi network.

Then, the following function will print data about your IP address:

void printWifiData() {
  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);
  Serial.println(ip);

  // print your MAC address:
  byte mac[6];
  WiFi.macAddress(mac);
  Serial.print("MAC address: ");
  Serial.print(mac[5], HEX);
  Serial.print(":");
  Serial.print(mac[4], HEX);
  Serial.print(":");
  Serial.print(mac[3], HEX);
  Serial.print(":");
  Serial.print(mac[2], HEX);
  Serial.print(":");
  Serial.print(mac[1], HEX);
  Serial.print(":");
  Serial.println(mac[0], HEX);

}

And this function will print data about the current Wi-Fi network to which your Arduino board is connected:

void printCurrentNet() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print the MAC address of the router you're attached to:
  byte bssid[6];
  WiFi.BSSID(bssid);
  Serial.print("BSSID: ");
  Serial.print(bssid[5], HEX);
  Serial.print(":");
  Serial.print(bssid[4], HEX);
  Serial.print(":");
  Serial.print(bssid[3], HEX);
  Serial.print(":");
  Serial.print(bssid[2], HEX);
  Serial.print(":");
  Serial.print(bssid[1], HEX);
  Serial.print(":");
  Serial.println(bssid[0], HEX);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.println(rssi);

  // print the encryption type:
  byte encryption = WiFi.encryptionType();
  Serial.print("Encryption Type:");
  Serial.println(encryption, HEX);
  Serial.println();
}

It's now time to finally test this sketch and connect your board to the Internet! You can get the whole sketch from the GitHub repository of the following book:

https://github.com/marcoschwartz/iot-arduino-cookbook

Now, make sure to change your Wi-Fi name and password inside the sketch, and then upload the sketch to the board. Immediately open the Serial monitor. This is what you should see:

If you can see something similar, congratulations, your board is now connected to your Wi-Fi network and to the Internet (assuming your Wi-Fi router is connected to the Internet).

The WiFi101 library makes it really easy to use the on-board Wi-Fi chip of the MKR1000 board, and to easily connect the board to the Internet. This is a very useful function that we are going to use in the whole book.

I now recommend checking the two remaining recipes in this chapter, to learn how to actually use the Internet connection of the board to interact with web services.

You do not need any extra steps here, simply make sure that you have the WiFi101 library installed.

Let's now see the sketch for this recipe. As it is really similar to the sketch of the previous recipe, I will only highlight the main pieces of code that were added here:

If you can see that, it means that the board has successfully grabbed the content of the web page and displayed it inside the Serial monitor.

The sketch uses the Wi-Fi client of the WiFi101 library, which is a very powerful object that we will use again in several chapters of this book.

I now recommend checking the next recipe, in which you will actually learn how to use the Wi-Fi client library to send data to a cloud server.

For this recipe, you will need the same configuration that we used in the recipe Interacting with basic sensors, but ? with a photocell connected to the Arduino board. Please refer to this recipe to know how to assemble the hardware for the project.

Let's now see the sketch that we will use for this chapter. It is actually very similar to the code for the previous chapter, so I will just highlight the important parts here.

As before, we define the server to which we want to connect the board. Here, we will use the dweet.io service:

char server[] = "dweet.io";

We also define an interval on which we will send data to the dweet.io servers:

unsigned long lastConnectionTime = 0;            
const unsigned long postingInterval = 10L * 1000L;

In the loop() function, we check if it is time to send data. If so, we measure the reading from the sensor, and send this to a function that will send the data:

if (millis() - lastConnectionTime > postingInterval) {

    // Measure light level
    int sensorData = analogRead(A0);

    // Send request
    httpRequest(sensorData);
  }

Let's now see the details of this function:

void httpRequest(int sensorData) {

  // Close existing connection
  client.stop();

  // Connect & send request
  if (client.connect(server, 80)) {
    
    Serial.println("connecting...");
    
    // Send the HTTP PUT request:
    client.println("GET /dweet/for/myarduino?light=" + String(sensorData) + " HTTP/1.1");
    client.println("Host: dweet.io");
    client.println("User-Agent: ArduinoWiFi/1.1");
    client.println("Connection: close");
    client.println();

    // Note the time that the connection was made:
    lastConnectionTime = millis();
  }
  else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
  }
}

As you can see, the function is very similar to what we did in the previous recipe. The main difference is that we pass the measured data as an argument when calling the dweet.io server.

You can now grab the code from the GitHub repository of this book, and upload it to the board.

Then, open the Serial monitor, and this is what you should see:

If you can see the 'succeeded' message, it means that the data has been correctly stored on the server.

To check that it was actually recorded, you can now go to the following URL:

https://dweet.io/get/latest/dweet/for/myarduino

You should see the answer in JSON format, meaning data was recorded from your board.

The Dweet.io service is a very useful (and free) web service to store data coming from your IoT project. We are going to use it extensively in the coming chapters of this book.

I now recommend that you move on to the next chapter, so you can start using what you learned in this introductory chapter to build actual IoT projects!

The first thing that can happen is that the board is not visible from the Arduino IDE, even if you have it connected to your computer via USB. Make sure that you are using a data USB cable: many cables nowadays are just for charging and don't actually allow data transfers. If you are using Windows, also make sure to refer to the Arduino website to install the required drivers.

If you can't connect the board to your local Wi-Fi router, make sure that you correctly entered your Wi-Fi name and password inside the sketch before uploading it to the board. The sketches of this book are made for WPA Wi-Fi networks, which are most of the networks out there. However, if you are still using a WEP network, make sure to check the Arduino WiFi101 example sketches to learn how to connect the board to a WEP network.