What Is the Cloud?

Simply stated,¹ the cloud is a name tagged to services available via the Internet. These can be servers you can access (running as a virtual machine on a larger server), systems that provide access to a specific software or environment, or resources such as disks or IP addresses that you can attach to other resources. The technologies behind the cloud include grid computing (distributed processing), virtualization, and networking. The correct scientific term is cloud computing. Although a deep dive into cloud computing is beyond the scope of this book, it is enough to understand that you can use cloud computing services to store your sensor data.

What Is Cloud Computing Then?

The term cloud computing is sadly overused and has become a marketing term for some. True cloud computing solutions are services that are provided to subscribers (customers) via a combination of virtualization, grid computing (distributed processing and storage), and facilities to support virtualized hardware and software, such as IP addresses that are tied to the subscription rather than a physical device. Thus, you can use and discard resources on the fly to meet your needs.

These resources, services, and features are priced by usage patterns (called subscription plans or tiers), in which you can pay for as little or as much as you need. For example, if you need more processing power, you can move up to a subscription level that offers more CPU cores, more memory, and so forth. Thus, you only pay for what you need, which means that organizations can potentially save a great deal on infrastructure.

A classic example of this benefit is a case where an organization experiences a brief and intense level of work that requires additional resources to keep their products and services viable. Using the cloud, organizations can temporarily increase their infrastructure capability and, once the peak has passed, scale things back to normal. This is a lot better than having to rent or purchase a ton of hardware for that one event.

Sadly, there are some vendors that offer cloud solutions (typically worded as cloud enabled or simply cloud) that fall far short of being a complete solution. In most cases, they are nothing more than yesterday’s Internet-based storage and visualization. Fortunately, Microsoft Azure is authentic: a full cloud computing solution with an impressive array of features to support almost any cloud solution you can dream up.

How Does the Cloud Help IoT?

OK, so now that we know what cloud systems are, how do they help me with my IoT projects? There are a variety of ways, but most common are mechanisms for storing and presenting your data rather than storing it locally or even remotely on another system such as a dedicated database server. That is, you can send the data you collect from your sensors to the cloud for storage and even use additional cloud services to view the data using charts, graphs, or just plain text. The sky is the limit with respect to how you can present your data.

But storing data isn’t the only feature you can leverage in the cloud. There are other services that you can use to link to yet other services to form a solution. For example, most paid IoT cloud systems provide features that can “talk” to each other allowing you to link them together to quickly build a solution. The features are often called components rather than services, but both terms apply.

For example, in Microsoft Azure, you can store your data with one of several components and then link it to others that allow you to modify the data via queries, others to route the data to other places (even to another cloud service vendor), and to one of several components for displaying the data. Yes, it really is a set of building blocks like that.

Now that we’ve had a general overview of cloud systems, let’s look at those that support IoT projects directly.

IoT Cloud Services Available

IoT projects offer an amazing opportunity to expand our knowledge of the world around us and to observe events from all over the world no matter where we are located. To address these capabilities, IoT cloud services provide an array of services that you can leverage in your applications.

There are services for collecting data, managing your devices, performing analytics, and even application and processing extensions for you to exploit. For example, some vendors include complete user management where you can provide user accounts for people to log in and use your cloud solution and see your data.

For our beginning IoT projects, we will be focusing on a subset of these services, which can be grouped into several categories. Let’s look at a few of the most common services you may want to start using right away.

Pico WiFi Modules

Most are made to work as an external module that you have to program separately and then use either a serial or similar code library to transfer data back and forth. This is the same concept as connecting your Pico to another microcontroller, which isn’t sufficient for getting started quickly or making it easy.

Let’s discover a bit more about each of these options.

ESP8266 WiFi Module for Raspberry Pi Pico

This module is a WiFi add-on that allows you to connect your Pico to the Internet via an intermediate module. Specifically, the ESP8266 WiFi Module has an ESP-12 chip onboard that is designed to process commands via a serial connection. Figure 13-1 shows the module. Notice the ESP-12 module on the right. There are also two buttons used for programming the ESP-12 module (reset and boot). On the bottom of the board is a set of female headers that permit you to attach the module directly to your Pico or use it with the Pico Omnibus host board that we’ve seen in previous chapters (https://shop.pimoroni.com/products/pico-omnibus).

The module is controlled via UART AT commands supporting the TCP/UDP communication protocol. The following shows an excerpt from one of the sample code files found on the product website:

sendCMD("AT","OK")

sendCMD("AT+CWMODE=3","OK")

sendCMD("AT+CWJAP=""+SSID+"",""+password+""","OK",20000)

sendCMD("AT+CIFSR","OK")

sendCMD("AT+CIPSTART="TCP",""+ServerIP+"","+Port,"OK",10000)

sendCMD("AT+CIPMODE=1","OK")

sendCMD("AT+CIPSEND",">"

As you can see, we are not using any special libraries; rather, we’re sending AT commands over a UART (think serial) connection to the module. While this helps eliminate GPIO issues (pins used by modules that you need for other modules), it is a bit tedious to program TCP/IP connections this way. Fortunately, there are several working examples on the product website.²

See www.waveshare.com/wiki/Pico-ESP8266 for documentation and more information about using this module.

DiP-Pi WiFi Master for Raspberry Pi Pico

This module is similar to the last module in that it also has a female header on the bottom to allow you to connect it to your Pico, and it supports a similar WT8266 WiFi chip that you access via AT commands. Figure 13-2 shows the DiP-Pi WiFi Master.

Sadly, while there are WiFi code examples listed on their list of examples (https://dip-pi.com/ready-to-use-examples), the WiFi links are not active, suggesting there may be examples in the future. However, the operating manual for the product has details on the features of the WiFi module as well as links to the AT commands supported.

See https://dip-pi.com/installation-and-operating-manuals to download the documentation for this module.

Maker Pi Pico Base

We first saw the Maker Pi Pico Base in Chapter 1. Recall, it supports Grove modules as well as a host of other nice features. While it does not have a WiFi module, the Pico Base has a special connector on the right side that allows you to connect an ESP-01 module to the board to provide Internet capabilities. Figure 13-3 shows the base with the ESP-01 connector highlighted.

Like the other modules, this requires programming the ESP-01 via AT commands similar to the ESP8266 WiFi Module. Fortunately, you can load MicroPython on the ESP-01 and write your Python code to connect to the Internet. Sadly, there are no examples on the product website at this time to show you how to do that, but you could follow similar examples from the other modules as a guide.

If you already own a Maker Pi Pico Base and an ESP-01 (or similar module), this may be the least expensive option. So long as you can sort the AT commands, you can make this option work for you.

See https://github.com/CytronTechnologies/MAKER-PI-PICO for documentation and more information about using this module.

Pico Wireless Pack

The Pico Wireless Pack is another excellent product of pimoroni.com. The module has the familiar female header on the bottom so that you can use it to connect directly to your Pico. It also has an SD card! Wow.

While it too is based on an ESP32 chip, you do not have to use AT commands to access it. In fact, Pimoroni provides a custom MicroPython uf2 image that contains all of the Pimoroni Pico–specific libraries including the network library. Figure 13-4 shows the Pico Wireless Pack.

The Pico Wireless Pack is a departure from the last modules that require you to use AT codes to control the onboard ESP processor. Instead, we can use a library designed to simplify the use of the WiFi module. To illustrate the difference in how it is programmed, the following shows the same code as the preceding AT command example. Which one do you think is more intuitive?

import project8.ppwhttp as ppwhttp

WIFI_SSID = "your SSID here!"

WIFI_PASS = "Your PSK here!"

ppwhttp.start_wifi(WIFI_SSID, WIFI_PASS)

This is much easier to understand than using the AT commands, unless, of course, you are proficient in their use.

There is also a user-configurable button, an RGB LED, and an SD card reader on the module, which is a nice touch. See https://shop.pimoroni.com/products/pico-wireless-pack for documentation and more information about using this module.

Caution

The documentation for the Pico Wireless Pack states that the library for the SD card is experimental, but so long as you use it for base file reading and writing, you should not have a problem.

Using the Pico Wireless Pack

To use the Pico Wireless Pack, you must download all of the Pimoroni-specific libraries and set up your Pico to use them, which is a potentially time-consuming process. Fortunately, you can avoid all that and simply download their custom Pico boot image and copy it to your Pico.

You can refer to Chapter 1 for how to set up your Pico to use the new boot image, but, briefly, you simply remove the Pico from your PC, press and hold the BOOTSEL button, then connect the Pico to your PC. Once the Pico opens as a drive, you can copy the .uf2 file to the drive and then remove the Pico and reconnect it.

Unlike some of the other WiFi offerings for the Pico, the Pico Wireless Pack has several simple examples available on the Pimoroni GitHub site. You can find example WiFi code for the Wireless Pack at https://github.com/pimoroni/pimoroni-pico/tree/main/micropython/examples/pico_wireless.

Let’s look at a couple of simple examples so we can ensure the module is working on our WiFi. One is a simple utility, but the other is a nifty example of how you can build a simple web server and run it on your Pico. Specifically, it is a simple HTTP (hypertext transfer protocol³) listener that accepts commands on a specific port and responds by sending preformatted HTML back to the client.

We won’t go through the code at this time; rather, we will concentrate on the mechanics of getting the examples to work. We will see more about the details of how the HTTP server works in a later section.

Download the entire repo by visiting https://github.com/pimoroni/pimoroni-pico and clicking the Code button and choosing Download Zip. Once downloaded, you can unzip the file and navigate to the folder to see the code for the examples.

We will look at two examples. The first is a simple WiFi scanner that finds the WiFi access points within the area. To use this example, open Thonny and navigate to the <download dir> pimoroni-pico/tree/main/micropython/examples/pico_wireless where <download dir> refers to the location on your PC where you downloaded and unzipped the GitHub code.

Once you determine your Pico can find your wireless network, you can then test it further by running the rgb_http.py example. This example lets you control the RGB LED on the Pico Wireless Pack using your browser. It demonstrates how you can control hardware over the Internet, which is a large part of what the IoT is all about!

Once you run the server, connect to it with the IP address and port shown in the output using your web browser on your PC. Using the information in the preceding example, you would use http://192.168.1.20:80 in the URL box. Your browser would then connect to the HTTP server on the Pico and display the web page.

Go ahead and try it out. Open your browser and specify the IP address shown in the console output. Figure 13-5 shows what you should see in your browser window.

If you do not see the web page, be sure to double-check that your PC is connected to the same network as your Pico. This can happen if you have multiple WiFi networks, or your PC is hardwired to a networking device on another network.

You can now use the drop-down boxes to change the value for each of the red, green, and blue variables. You can use the drop-down or type in a specific value for each. Let’s try several examples. Just type in the value for each of the boxes and then click Set LED. For example, you could try the base colors such as red (255,0,0), green (0,255,0), and blue (0,0,255). You should see the RGB LED on the Pico Wireless Pack change to match the values you entered.

Once that works, you are ready to start adding networking to your projects. Let’s look at some of the projects in this book and see how we can turn them into simple IoT projects.

Set Up the Hardware

Notice the jumper wires need to be the M/F type since the GPIO on the Pico Omnibus has male pins. Go ahead and plug your Pico into the Pico Omnibus and the Pico Wireless Pack onto the right side of the board. We will use the left-side GPIO headers for the LEDs. But use care, because the GPIO header rows are reversed to make it easy to add modules designed to mount to the bottom of the Pico. Thus, you must read the label on the Pico Omnibus carefully to ensure you use the correct pins.

Figure 13-6 shows the Pico Omnibus with the Pico Wireless Pack installed. Notice the left side (Deck 1) is where you will connect the jumper wires for the LEDs.

Figure 13-7 shows a schematic of how the wiring should be oriented for the Pico Omnibus to the breadboard hosting the LEDs.

Once you have the code wired, you are ready to start writing the code.

Write the Code

The code for this example will use the core code from the project in Chapter 7, but we will not be using the main() function. Rather, we will see how to use the Pimoroni library to create a simple HTTP server (also called a listener). The code will send a short HTML-based response (a simple web page) to the client that includes a form containing a single button for the walk request. The listener will listen on port 80.

We will also see an advanced technique using the threading library available on the Pico. As you will see, this library permits us to execute a function in a second core processor on the Pico. It is an excellent way to keep two things going at the same time and get a bit more processing at the same time.

The concept of the HTML server is quite simple. The code listens for a connection on the socket port and then receives the request (in this case, in the form of an HTML GET method) and sends an HTML response (the web page). If the button is pressed, the walk cycle will commence by calling the cycle_lights() function from the Chapter 7 project.

If you’ve never used HTML code before, don’t worry as the example code will provide everything you need. You don’t have to learn HTML for this chapter, but a basic knowledge would be helpful if you want to elaborate on the project or use the HTML server concept for your own projects. A reliable source of information about HTML can be found at www.w3schools.com/html/.

Since this is all new code, we will step through all of the parts so you can see how it works, but we will skip the code for controlling the LEDs. Please refer to Chapter 7 if you have not completed that project.

We will create a new file named pedestrian_crossing_web.py. Go ahead and open a new file in Thonny if you want to follow along.

Let’s begin with the code needed for the import section.

Execute

Before executing the project, be sure to upload the pedestrian_crossing_web.py to the root of the Pico onboard drive. You also need to create a project7 folder on the Pico and upload the Pico Wireless Pack library (ppwhttp.py) file into that folder. Finally, you also need to upload the secrets.py file from the Pico Wireless Pack library and modify it to include your WiFi SSID and password. Upload this file to the root of the Pico onboard drive.

Notice in this case the IP address is 192.168.1.20. All we need to do is put that in our browser as shown in Figure 13-8.

Once you enter the URL, you should see a web page like the image shown. If you don’t, be sure to check the HTML in your code to ensure it is exactly like what is shown; otherwise, the page may not display properly. You should also ensure the network your PC is connected to can reach the network to which your board is connected. If your home office is set up like mine, there may be several WiFi networks you can use. It is best if your board and your PC are on the same network (and same subnet).

Once you get that sorted out, verify the green LED for the stoplight is on and the red LED for the pedestrian crossing is on. All other LEDs are off. If you do not see something similar, go back and check your connections again.

Now go ahead and click the button. Remember, the walk button will engage, and you will see the lights cycle, but you won’t be able to do anything until the walk cycle is complete. This is because we don’t return the response HTML until after the cycle is complete (see the code to convince yourself).

Notice in the output window in Thonny there are debug messages printed for each time the client connects (the code accepts the connection and GET request) as well as a statement about what it is doing. You should see something similar.

Now, let’s look at a second example.

Set Up the Hardware

Notice the jumper wires need to be the F/F type since the GPIO on the Pico Omnibus has male pins and the soil moisture sensors also have male pins. Go ahead and plug your Pico into the Pico Omnibus and the Pico Wireless Pack onto the right side of the board like we did in the last example.

Figure 13-10 shows a schematic of how the wiring should be oriented for the Pico Omnibus to the breadboard hosting the soil moisture sensors.

Once you have the code wired, you are ready to start writing the code.

Write the Code

The code for this example will use some of the code from the project in Chapter 8. We will use the read_timer.py file without changes. We must modify the SoilMoisture class (soil_moisture.py) to work with a file instead of storing the values read in memory. Finally, we will not need the display library.

However, there are two additional libraries we will need for this project. We will need a library for the SD card and another for the RTC module.

Once again, the SD card support on the Pico Wireless Pack is considered experimental, but the basic operations for file reading and writing work just fine. While Pimoroni does not currently supply a MicroPython library, we can find one elsewhere. The library that works best is found at https://forums.pimoroni.com/t/pico-wireless-how-to-access-sd-card/17751/3. Simply open Thonny and create a new file, then copy the code from the website into the file and name it sdcard.py. You will upload this file to the project8 folder on the Pico later.

The library for the RTC module can be found on the vendor’s website in the form of a zip file (www.waveshare.com/w/upload/2/26/Pico-rtc-ds3231_code.zip). Download the file and unzip it and then locate the file named ds3231.py in the python folder. You will upload this file to the project8 folder on the Pico later.

However, the library function named read_time() prints a string for the time. That won’t work for us since we need to get the time either as a tuple like we did in Chapter 8 or, since the read_time() function already formats the datetime for printing, return the string instead. Thus, you will need to modify this class slightly for use with this project.

Notice we are only changing the print() statement to return the string without the day of the week.

Now that we have the libraries we need and the RTC library modified, let’s start by looking at the main code.

Execute

Before executing the project, be sure to upload the main.py and secrets.py files to the root of the Pico onboard drive. Remember to modify the secrets.py file to include your WiFi SSID and password. You also need to create a project8 folder on the Pico and upload the Pico Wireless Pack library (ppwhttp.py), the modified library for the RTC (ds3231.py), the soil moisture class (soil_moisture.py), the SD card library (sdcard.py), and the read timer class (read_timer.py) files into that folder. Finally, you also need to upload the secrets.py file from the Pico Wireless Pack library. Upload this file to the root of the Pico onboard drive.

Notice in this case the IP address is 192.168.1.20. All we need to do is put that in our browser as shown in Figure 13-11.

Once you enter the URL, you should see a web page like the image shown. If you don’t, be sure to check the HTML in your code to ensure it is exactly like what is shown; otherwise, the page may not display properly.

If everything is working, you can click refresh in your browser to read all of the values read from the file including those in the cache. Or you can wait until the meta tag refresh fires, which will automatically refresh the page. Neat!

Improving the Code

Once you have both examples working, congratulations. You have just created your first complete IoT projects. How cool is that?