IoT and Arduino

It wouldn’t do to have a chapter with no code, so let’s look at one last project that introduces some really fun avenues you can explore on the way to creating your own gadgets. The Internet of Things is exploding, and Arduino is perfectly suited for playing in that space. Let’s look at a simplified version of my weather station project. We’ll use a WiFi-capable microcontroller to report sensor data to a cloud API.

The circuit for this project is fairly simple. We need a WiFi-capable microcontroller or a WiFi breakout that you can connect to your controller like we did with the RF breakout in “Importing Custom Libraries”. I chose the HUZZAH32 Feather from Adafruit. It has some impressive specs like more than 500KB of SRAM and 4MB of flash in addition to the integrated WiFi support. The sensor is the same TMP36 we used in “Sensors and Analog Input”. I also added an OLED display so I could watch the output without being tied to a computer to access the Serial Monitor, but this display is definitely optional. Figure 12-1 shows the wiring diagram and my actual “station” up and running on a breadboard.

Figure 12-1. Connecting the HUZZAH32, TMP36, and OLED

The OLED uses a library provided by Adafruit that you can import through the Manage Libraries dialog of the IDE. Enter SSD1306 in the search field and look for the “Adafruit SSD1306” library. It should be close to the top.

We also need to pick a cloud service provider and find a library for communicating with them. I use Adafruit.io for these types of projects, but any IoT cloud service will likely work. AWS, Google, and Azure all have IoT solutions, for example.

For Adafruit.io, we can use the Library Manager to find our communication library. Search for “adafruit io arduino” and then scroll down a bit to find the actual library called “Adafruit IO Arduino.” Installing this library requires quite a few dependencies, such as the HTTP and message queue libraries, but the Library Manager will handle that for you automatically and prompt you to install those dependencies. You might have some of the listed dependencies like the NeoPixel library already, but the Library Manager isn’t quite smart enough to show only the missing ones. When you do install the dependencies, though, only those that are missing will be added.

I won’t go through the details of signing up, but once you have an account with your chosen provider, you’ll almost certainly need a few credentials to configure the library. Adafruit.io, for example, requires a unique username and access key. Let’s put this cloud service information in a separate config.h file where we can also include our WiFi details:

#include "AdafruitIO_WiFi.h"

#define IO_USERNAME  "userNameGoesHere"
#define IO_KEY       "ioKeyGoesHere"
#define WIFI_SSID    "HomeWifi"
#define WIFI_PASS    "password"

Happily, that library also contains a more generic WiFi library as a dependency. That double duty is nice for us—we don’t have to go through separate steps to configure both the WiFi and our access to the cloud. But we do still have to do a little bit of setup work to make sure we can communicate with the cloud. We’ll add that code in with the stuff necessary to use our nifty OLED display in the setup() function. As always, feel free to type this in yourself, or grab ch12/temp_web/temp_web.ino:

#include <SPI.h>                                       
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Use credentials from config.h to set up our feed
#include "config.h"                                    
AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);
AdafruitIO_Feed *smallerc = io.feed("smallerc");

// Set up our OLED
#define SCREEN_WIDTH 128 // OLED width, in pixels
#define SCREEN_HEIGHT 32 // OLED height, in pixels
#define OLED_RESET     4 // Reset pin #
#define SCREEN_ADDRESS 0x3C // 128x32 screen
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,  
    &Wire, OLED_RESET);
char statusline[22] = "Starting...";

// A few things for keeping an average temperature reading
#define ADJUST 3.33 /* my office reads about 3 degrees C cold */
float total = 0.0;
int   count = 0;

void setup() {
  Serial.begin(115200);
  // SSD1306_SWITCHCAPVCC = generate voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));    
    for(;;); // Don't proceed, loop forever
  }

  // Show Adafruit splash screen initialized by the display library
  display.display();

  // Now set up the connection to adafruit.io
  Serial.print("Connecting to Adafruit IO");
  io.connect();                                        
  // wait for a connection
  while(io.status() < AIO_CONNECTED) {
    Serial.print(".");
    delay(500);
  }

  // we are connected
  Serial.println();
  Serial.println(io.statusText());

  // Set up our display for simple (if small) text
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(0, 0);     // Start at top-left corner
  display.cp437(true);         // Use 'Code Page 437' font
  display.println(statusline); // Show our starting status
  display.display();           // Update the actual display
}

void loop() {
  // put your main code here, to run repeatedly:
  int reading = analogRead(A2);                        
  float voltage = reading / 1024.0;
  if (count == 0) {
    total = voltage;
  } else {
    total += voltage;
  }
  count++;
  float avg = total / count;
  float tempC = (avg - 0.5) * 100;
  float tempF = tempC * 1.8 + 32;
  if (count % 100 == 0) {
    // Update our display every 10 seconds             
    display.clearDisplay();
    display.setCursor(0, 0);
    display.println(statusline);
    display.print(reading);
    display.print("  ");
    display.println(voltage);
    display.print(tempC);
    display.println("370 C");
    display.print(tempF);
    display.println("370 F");
    display.display();
    strcpy(statusline, "Reading...");
  }
  if (count % 600 == 0) {
    // Update our IoT feed every minute
    smallerc->save(tempF);                             
    strcpy(statusline, "Feed updated");
  }
  delay(100);
}

Include the various header files needed to communicate with the libraries that draw on our OLED.

With the credentials from config.h, create an I/O object (io) and establish a connection to the Adafruit IO service, then specify which feed we will update.

Instantiate our display object using constants and referencing the Wire library.

Attempt to connect to the display. If that fails, print an error message and do not continue. If you do get stuck here, it’s likely a problem in your wiring. Double-check the connections and make sure your display also has power.

Make sure we can use the feed from . Wait (potentially forever) until it’s ready. If you can’t connect, you might try using your credentials in a browser to verify the combination of user and key works. You can also test out your WiFi connection with a separate project. Under the File menu in the IDE, look for the Examples submenu, find your board, and pick something simple like HTTPClient.

Read the current analog value from our TMP36 sensor and update the average, running temperature.

Update our display with some nice text on the temperature and the current cloud status. The API for this display is similar to the functions we use with Serial.

Once a minute, report the simple temperature in Fahrenheit to our feed. The next time through loop(), we’ll note the update in our status line on the OLED.

You can certainly turn controllers like the HUZZAH32 into their own web servers and just get readings directly in your browser, but services like Adafuit.io make it easy to get fancier reports, such as the small graph of temperatures over a few minutes shown in Figure 12-2. These services typically support connecting to yet more services as well. For example, If This Then That (IFTTT) allows you to use events reported to Adafruit.io to trigger actions like sending an email or turning on smart home devices.

Figure 12-2. Graph of our reported temperatures

This little project is just the briefest of introductions to the Internet of Things. Heck, just the fun combinations possible through IFTTT could fill their own book. IoT books and blog posts abound, covering everything from user interface design for small devices to enterprise mesh configurations. This is a fun, dynamic area, and you certainly have the skills to dive in if you’re curious to learn more.

Arduino Source Code

There are so many neat Arduino projects out there and so many of their authors are doing it for the joy of creating. They put their hardware specs and source code online and actively participate in the Arduino forums. I heartily encourage you to read some of that source code. You have the skills to understand the code in those projects now, and seeing how other programmers tackle problems can help you learn new tricks.

You can also access the source code behind the many boards supported out of the gate by the Arduino IDE. The various ArduinoCore packages cover the C and C++ content that goes into the Arduino “language” we discussed in “The Arduino Environment”. It’ll be dense reading, to be sure, but you might be surprised how much of the basics you can pick up.