High-Level Design

As we learned earlier, it is a good idea to create a design for each code module (class) we want to use. We will use the code module from the main code. Thus, we need functions to tell the class to read the sensors and a way to get the filename the class uses for the data.

Typically, one would design a code module to completely hide a file and all operations on it, but in this case the class is only concerned with reading the sensors and writing the data. Plus, since the main code needs to read the data and format it with HTML tags, it is more appropriate to place the read function in the main code. That is, you should strive to keep like code functions together, which helps maintaining the code. For example, keeping all the HTML code in one file makes modifying the HTML code (or reusing it) easier.

We will use a timer interrupt to read the sensors. This allows us to set up a function to be called periodically without the need to monitor or poll the time and call the function directly. We provide the clear log function as a convenience. Thus, we will only need two public functions: one to clear the log and another to fetch the filename. Aside from initializing the class, we only need to get the filename when we want to refresh the data (send it to the client). Table 10-3 shows the functions for the Plant Monitoring class.

Notice the first function named __init__(). This is the constructor for the class and will be called when the class is instantiated from our main code. Notice also the private methods are named with a single underscore.

The following sections explain the initialization code and the functions needed. We will see the complete code in a later section.

Setup and Initialization

In this section, we discuss the code we need to set up and initialize the code module. First, there are a few imports we need including those for the analog-to-digital converter, pin, secure disk (SD), timer, and the operating system libraries.

We will also need some constants defined for the class. Recall we want to classify the soil moisture read with an enumeration. To do so, we will need to use the thresholds we determined for the classification. We can use constants at the top of the file to make it easier to change them later should we need to adjust the code for use with other sensors or the conditions of our plants changes (different pot, soil, environment, etc.). We can use the same philosophy to set the name of the file to contain the data.

We also use a constant to define the frequency for reading the sensors. Since we will use a loop to read the sensor waiting 5 seconds for each read, we will need a minimum of 50-55 seconds to read 10 values. Thus, we cannot set the update frequency to anything less than about one minute. The frequency is in seconds. While you may want to set this to a low value for testing, you certainly do not want to check the soil moisture of your plants every minute. That is, how often to you check your plants normally? Once every few days or once a day? Why check it sooner than normal?

Finally, we need a function that converts a time structure to a string. Recall from an earlier example, we can use a simple format specification. We will use a module-level private function for that feature.

Listing 10-3 shows the code for the setup and initialization section . Place this at the top of the file.

Listing 10-3. Plant Monitor Class Setup and Initialization (WiPy)

from machine import ADC, Pin, SD, Timer
import os
import utime

# Thresholds for the sensors
LOWER_THRESHOLD = 500
UPPER_THRESHOLD = 2500
UPDATE_FREQ = 120   # seconds

# File name for the data
SENSOR_DATA = "plant_data.csv"

# Format the time (epoch) for a better view
def _format_time(tm_data):
    # Use a special shortcut to unpack tuple: *tm_data
    return "{0}-{1:0>2}-{2:0>2} {3:0>2}:{4:0>2}:{5:0>2}".format(*tm_data)

Constructor

The constructor for the class is where all the major work takes place. There are several things we need to do including the following.

• Normalize the location (path) of the data file

• Set up the sensors in a dictionary stored in a list

• Set up the timer interrupt to read the sensors periodically

We normalize the path to the data file by attempting to use the SD card. If the SD card cannot be found, we default to the flash drive. However, you should avoid writing data to the flash drive since the driver is smaller and can fill up, and writing to the flash drive increases the risk of corrupting the drive or causing problems during execution.

We use a dictionary for each sensor so we can define the pin for the sensor, pin for powering the sensor, sensor number (an arbitrary identification), and the location of the sensor. We then place the dictionaries in a list to make it easy to read all the sensors at the same time using a loop.

Finally, we set up an interrupt via the timer alarm class to read the sensors periodically. Listing 10-4 shows the code for the class constructor.

Listing 10-4. Plant Monitor Class Constructor (WiPy)

def __init__(self, rtc):
    self.rtc = rtc

    # Try to access the SD card and make the new path
    try:
        sd = SD()
        os.mount(sd, '/sd')
        self.sensor_file = "/sd/{0}".format(SENSOR_DATA)
        print("INFO: Using SD card for data.")
    except:
        print("ERROR: cannot mount SD card, reverting to flash!")
        self.sensor_file = SENSOR_DATA
    print("Data filename = {0}".format(self.sensor_file))

    # Setup the dictionary for each soil moisture sensor
    adc = ADC(0)
    soil_moisture1 = {
        'sensor': adc.channel(pin='P13', attn=3),
        'power': Pin('P19', Pin.OUT),
        'location': 'Green ceramic pot on top shelf',
        'num': 1,
    }
    soil_moisture2 = {
        'sensor': adc.channel(pin='P14', attn=3),
        'power': Pin('P20', Pin.OUT),
        'location': 'Fern on bottom shelf',
        'num': 2,
    }
    # Setup a list for each sensor dictionary
    self.sensors = [soil_moisture1, soil_moisture2]
    # Setup the alarm to read the sensors
    a = Timer.Alarm(handler=self._read_sensors, s=UPDATE_FREQ,
                    periodic=True)
    print("Plant Monitor class is ready...")

Notice the code for the timer alarm. Here we define the handler (callback) for the interrupt, the frequency using the constant we defined at the top of the tile, and set it to fire every N seconds (periodically).

Public Functions

There are only two public functions. The first, clear_log(), simply opens the file for writing and closes it. This effectively empties the file. The function is provided for convenience. The second function, get_filename(), simply returns the name of the file used to store data. This name is not the same as the name in the constant SENSOR_DATA because we normalized the path in the constructor as shown in the previous section.

Private Functions

There are three private functions. The _get_value() function is the same code from our threshold calibration code where we sample the sensor 10 times and average the value. The _read_sensors() function is the callback for the timer alarm interrupt that reads all the sensors we have defined and saves the data to the file. The _convert_value() function is a helper function to determine the classification of the soil based on the sensor data. This function returns a string or “dry”, “Ok”, or “wet”.

Complete Code

Now that we have seen all the parts of the code module, let’s look at the completed code. Listing 10-5 shows the complete code for the Plant Monitor code module. Once again, we can save this file as plant_monitor.py.

Listing 10-5. Plant Monitor Code Module Complete Code (WiPy)

# MicroPython for the IOT - Chapter 10
#
# Project 3: MicroPython Plant Monitoring
#
# Plant monitor class
#
# Note: this only runs on the WiPy.
from machine import ADC, Pin, SD, Timer
import os
import utime

# Thresholds for the sensors
LOWER_THRESHOLD = 500
UPPER_THRESHOLD = 2500
UPDATE_FREQ = 120   # seconds

# File name for the data
SENSOR_DATA = "plant_data.csv"

# Format the time (epoch) for a better view
def _format_time(tm_data):
    # Use a special shortcut to unpack tuple: *tm_data
    return "{0}-{1:0>2}-{2:0>2} {3:0>2}:{4:0>2}:{5:0>2}".format(*tm_data)

class PlantMonitor:
    """
    This class reads soil moisture from one or more sensors and writes the
    data to a comma-separated value (csv) file as specified in the constructor.
    """

    # Initialization for the class (the constructor)
    def __init__(self, rtc):
        self.rtc = rtc

        # Try to access the SD card and make the new path
        try:
            sd = SD()
            os.mount(sd, '/sd')
            self.sensor_file = "/sd/{0}".format(SENSOR_DATA)
            print("INFO: Using SD card for data.")
        except:
            print("ERROR: cannot mount SD card, reverting to flash!")
            self.sensor_file = SENSOR_DATA
        print("Data filename = {0}".format(self.sensor_file))

        # Setup the dictionary for each soil moisture sensor
        adc = ADC(0)
        soil_moisture1 = {
            'sensor': adc.channel(pin='P13', attn=3),
            'power': Pin('P19', Pin.OUT),
            'location': 'Green ceramic pot on top shelf',
            'num': 1,
        }
        soil_moisture2 = {
            'sensor': adc.channel(pin='P14', attn=3),
            'power': Pin('P20', Pin.OUT),
            'location': 'Fern on bottom shelf',
            'num': 2,
        }
        # Setup a list for each sensor dictionary
        self.sensors = [soil_moisture1, soil_moisture2]
        # Setup the alarm to read the sensors
        a = Timer.Alarm(handler=self._read_sensors, s=UPDATE_FREQ,
                        periodic=True)
        print("Plant Monitor class is ready...")

    # Clear the log
    def clear_log(self):
        log_file = open(self.sensor_file, 'w')
        log_file.close()

    # Get the filename we're using after the check for SD card
    def get_filename(self):
        return self.sensor_file

    # Read the sensor 10 times and average the values read
    def _get_value(self, sensor, power):
        total = 0
        # Turn power on
        power.value(1)
        for i in range (0,10):
            # Wait for sensor to power on and settle
            utime.sleep(5)
            # Read the value
            value = sensor.value()
            total += value
        # Turn sensor off
        power.value(0)
        return int(total/10)

    # Monitor the sensors, read the values and save them
    def _read_sensors(self, line):
        log_file = open(self.sensor_file, 'a')
        for sensor in self.sensors:
            # Read the data from the sensor and convert the value
            value = self._get_value(sensor['sensor'], sensor['power'])
            print("Value read: {0}".format(value))
            time_data = self.rtc.now()
            # datetime,num,value,enum,location
            log_file.write(
                "{0},{1},{2},{3},{4}
".format(_format_time(time_data),
                                               sensor['num'], value,
                                               self._convert_value(value),
                                               sensor['location']))
        log_file.close()

    # Convert the raw sensor value to an enumeration
    def _convert_value(self, value):
        # If value is less than lower threshold, soil is dry else if it
        # is greater than upper threshold, it is wet, else all is well.
        if (value <= LOWER_THRESHOLD):
            return "dry"
        elif (value >= UPPER_THRESHOLD):
            return "wet"
        return "ok"

Wow, that’s a lot of code! Take some time to read through it until you understand all the parts of the code.

Changes for the Pyboard

There are considerably more changes needed for this project to run on the Pyboard. The main reasons for this include the usual changes we need for the imports, the pin class high/low versus value, and differences in how we use the real-time clock. Finally, the Pyboard does not support timer alarm class interrupts so we must use a polling technique to read the sensors. This last change means we must make the read_sensors() function a public function so we can call it from the main code.

Since the changes are numerous, a difference file is nearly the same length as the actual code.² Thus, we will see the complete code for the Pyboard. Listing 10-6 shows the complete code for the code module with the differences needed to adapt the code module to the Pyboard (in bold). While most changes are minimal, if you are using the Pyboard or a Pyboard clone, take note of the pins used for the sensor.

Listing 10-6. Plant Monitor Code Module Complete Code (Pyboard)

# MicroPython for the IOT - Chapter 10
#
# Project 3: MicroPython Plant Monitoring
#
# Plant monitor class
#
# Note: this only runs on the Pyboard.                    
from pyb import ADC, delay, Pin, SD                    
import os                    
import pyb                    

# Thresholds for the sensors
LOWER_THRESHOLD = 500
UPPER_THRESHOLD = 2500
UPDATE_FREQ = 120   # seconds

# File name for the data
SENSOR_DATA = "plant_data.csv"

# Format the time (epoch) for a better view
def _format_time(tm_data):
    # Use a special shortcut to unpack tuple: *tm_data
    return "{0}-{1:0>2}-{2:0>2} {3:0>2}:{4:0>2}:{5:0>2}".format(*tm_data)

class PlantMonitor:
    """
    This class reads soil moisture from one or more sensors and writes the
    data to a comma-separated value (csv) file as specified in the constructor.
    """

    # Initialization for the class (the constructor)
    def __init__(self, rtc):
        self.rtc = rtc

        # Try to access the SD card and make the new path
        try:
            self.sensor_file = "/sd/{0}".format(filename)
            f = open(self.sensor_file, 'r')
            f.close()
            print("INFO: Using SD card for data.")
        except:
            print("ERROR: cannot mount SD card, reverting to flash!")
            self.sensor_file = SENSOR_DATA
        print("Data filename = {0}".format(self.sensor_file))

        # Setup the dictionary for each soil moisture sensor
        soil_moisture1 = {
            'sensor': ADC(Pin('X19')),
            'power': Pin('X20', Pin.OUT_PP),
            'location': 'Green ceramic pot on top shelf',
            'num': 1,
        }
        soil_moisture2 = {
            'sensor': ADC(Pin('X20')),
            'power': Pin('X21', Pin.OUT_PP),
            'location': 'Fern on bottom shelf',
            'num': 2,
        }
        # Setup a list for each sensor dictionary
        self.sensors = [soil_moisture1, soil_moisture2]
        # Setup the alarm to read the sensors
        self.alarm = pyb.millis()
        print("Plant Monitor class is ready...")

    # Clear the log
    def clear_log(self):
        log_file = open(self.sensor_file, 'w')
        log_file.close()

    # Get the filename we're using after the check for SD card
    def get_filename(self):
        return self.sensor_file

    # Read the sensor 10 times and average the values read
    def _get_value(self, sensor, power):
        total = 0
        # Turn power on
        power.high()
        for i in range (0,10):
            # Wait for sensor to power on and settle
            delay(5000)
            # Read the value
            value = sensor.read()
            total += value
        # Turn sensor off
        power.low()
        return int(total/10)

    # Monitor the sensors, read the values and save them
    def read_sensors(self):
        if pyb.elapsed_millis(self.alarm) < (UPDATE_FREQ * 1000):
            return
        self.alarm = pyb.millis()
        log_file = open(self.sensor_file, 'a')
        for sensor in self.sensors:
            # Read the data from the sensor and convert the value
            value = self._get_value(sensor['sensor'], sensor['power'])
            print("Value read: {0}".format(value))
            time_data = self.rtc.datetime()
            # datetime,num,value,enum,location
            log_file.write(
                "{0},{1},{2},{3},{4}
".format(_format_time(time_data),
                                               sensor['num'], value,
                                               self._convert_value(value),
                                               sensor['location']))
        log_file.close()

    # Convert the raw sensor value to an enumeration
    def _convert_value(self, value):
        # If value is less than lower threshold, soil is dry else if it
        # is greater than upper threshold, it is wet, else all is well.
        if (value <= LOWER_THRESHOLD):
            return "dry"
        elif (value >= UPPER_THRESHOLD):
            return "wet"
        return "ok"

Ok, now we’re ready to look at the main code.

HTML Code (Files)

We will store the HTML code needed in files to save memory. Recall by reading a row at a time – we do not have to take up space with the strings in our code. As your projects grow in complexity, this could become an issue. Thus, this project demonstrates a way to save some memory.

The HTML for this project creates a web page with a simple table that includes all the data in the file at the time of the request. To make things easier, we will use three files. The first file (named part1.html) will contain the HTML code up to the table rows; the second file (named plant_data.csv), which is populated by the PlantMonitor class; and the third (named part2.html) will contain the remaining HTML code.

The first file, part1.html, is shown in Listing 10-7. This file establishes the table HTML code. It also establishes characteristics for the table including text alignment, border size, and padding – all through cascading style (<style> tag). Don’t worry if this looks strange or alien. You can google for W3C standards to see how we use the tag to control the style of the web page.

Listing 10-7. HTML Code (part1.html)

<!DOCTYPE html>
<html>
  <head>
    <title>MicroPython for the IOT - Project 3</title>
    <meta http-equiv="refresh" content="30">
    <style>
      table, th, td {
          border: 1px solid black;
          border-collapse: collapse;
      }
      th, td {
          padding: 5px;
      }
      th {
          text-align: left;
      }
    </style>
  </head>
  <center><h2>MicroPython for the IOT - Project 3</h2></center><br>
  <center>A simple project to demonstrate how to retrieve sensor data over the Internet.</center>
  <center><br><b>Plant Monitoring Data</b><br><br>
    <table style="width:75%">
      <col width="180">
      <col width="120">
      <col width="100">
      <col width="100">
      <tr><th>Datetime</th><th>Sensor Number</th><th>Raw Value</th><th>Moisture</th><th>Location</th></tr>

Notice the table code. Again, don’t worry if this seems strange. It works and it is very basic. Those familiar with HTML may want to embellish and improve the code. The last line establishes the header for the table.

The second file, plant_data.csv, contains the data. We will use a constant to populate a properly formatted HTML table row. The following shows an example of what a row of data would look like in the file and how that data is transformed to HTML. We will see the HTML for the table row in the next section.

# Raw data
2017-08-08 20:26:17,1,78,dry,Small fern on bottom shelf
# HTML table row
<tr><td>2017-08-08 20:26:17</td><td>1</td><td>78</td><td>dry</td><td>Small fern on bottom shelf </td></tr>

The last file, part2.html, contains the closing tags so it isn’t very large. But since we’re reading from files, we include this file. The following shows the code in the second file.

    </table>
  </center>
</html>

So, how do we use these files? When we send a response back to the client (the web page), we read the first file sending one row at a time, then read the data file sending one row at a time, then read the last file sending one row at a time. We will use a helper function to read the data file. Listing 10-8 shows the code used to do this.

Listing 10-8. Reading the HTML and Data File (WiPy)

# Read HTML from file and send to client a row at a time.
def send_html_file(filename, client):
    html = open(filename, 'r')
    for row in html:
        client.send(row)
    html.close()

# Send the sensor data to the client.
def send_sensor_data(client, filename):
    send_html_file("part1.html", client)
    log_file = open(filename, 'r')
    for row in log_file:
        cols = row.strip("
").split(",") # split row by commas
        # build the table string if all parts are there
        if len(cols) >= 5:
            html = HTML_TABLE_ROW.format(cols[0], cols[1], cols[2],
                                         cols[3], cols[4])
            # send the row to the client
            client.send(html)
    log_file.close()
    send_html_file("part2.html", client)

Imports

The imports we need for the project include those for the real-time clock, sys, usocket, utime, machine, and WLAN. These are now quite familiar. The last line imports the PlantMonitor class from the plant_monitor code module. The complete list of imports is shown below. If you want to follow along, open a new file and name it plant_wipy.py.

# Imports for the project
from machine import RTC
import sys
import usocket as socket
import utime
import machine
from network import WLAN
from plant_monitor import PlantMonitor

We also need a string we can use to create the rows for the table. The HTML code that occurs before this line is saved in files as described above. The following shows the string used. Notice we use replacement syntax so that we can use the format() function to fill in the details.

# HTML web page for the project
HTML_TABLE_ROW = "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td></tr>"

Imports

We also want to connect the project to our network. We use the same code as we used in previous projects and examples but instead make it a function named connect(), which we will call from the main run() function. Be sure to change the SSID and password to match your network.

Network Time Protocol

Since we are saving data that has a time element (you want to know when you sampled the soil moisture), we need to store the date and time with the data. The easiest way to do this is to use a network time protocol (NPT) server : that is, provided the board is connected to the Internet. If it is not connected to the Internet, we must use a RTC module or initialize the onboard RTC at startup. We saw how to use a NTP server in Chapter 5. We repeat it in this project as a function named get_ntp(), which we will call from the main run() function.

The run() Function

The HTML server portion of the run() function is like the last project but instead of processing form requests, we send the web page back to the client by default. The only command supported is the CLEAR_LOG command, which requires specifying it on the URL on the client as described above.

Another difference is instead of placing code in the global section of the code file (so that it executes when we import the file in our REPL console or main.py file), we use functions to connect to the network, set up the NTP, and send the HTML code to the client. This is an escalation of complexity that you should start using as general practice. We did not see this in earlier projects so that we could concentrate on getting the code complete. When writing your own projects, be sure to use functions to contain code and call the functions from your other code.

Since this is different from the last project, we will look at the code. Listing 10-9 shows the code for the run() function.

Listing 10-9. Plant Monitor Run() Function (WiPy)

# Setup the socket and respond to HTML requests
def run():
    # Connect to the network
    if not connect():
        sys.exit(-1)

    # Setup the real time clock
    rtc = get_ntp()

    # Setup the plant monitoring object instance from the plant_monitoring class
    plants = PlantMonitor(rtc)
    filename = plants.get_filename()

    # Setup the HTML server
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('', 80))
    sock.listen(5)
    print("Ready for connections...")
    server_on = True
    while server_on:
        client, address = sock.accept()
        print("Got a connection from a client at: %s" % str(address))
        request = client.recv(1024)

        # Allow for clearing of the log, but be careful! The auto refresh
        # will resend this command if you do not clear it from your URL
        # line.

        if (request[:14] == b'GET /CLEAR_LOG'):
            print('Requesting clear log.')
            plants.clear_log()
        send_sensor_data(client, filename)
        client.close()
    sock.close()

Take a moment to read through this code. Notice how we implement the function in a more modular way. Not only does placing common code in functions help with how you break a problem down into parts, it also makes your main code (the run() function) shorter.

Let’s look at the completed code.

Complete Code

Now that we have seen all the parts of the code module, let’s look at the completed code. Listing 10-10 shows the complete code for the Plant Monitor code module. Once again, we can save this file as plant_wipy.py or plant_pyboard.py for the Pyboard).

Listing 10-10. Plant Monitor Main Code (WiPy)

# MicroPython for the IOT - Chapter 10
#
# Project 3: MicroPython Plant Monitoring
#
# Required Components:
# - WiPy
# - (N) Soil moisture sensors (one for each plant)
#
# Note: this only runs on the WiPy.
#
# Imports for the project
from machine import RTC
import sys
import usocket as socket
import utime
import machine
from network import WLAN
from plant_monitor import PlantMonitor

# HTML web page for the project
HTML_TABLE_ROW = "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td></tr>"

# Setup the board to connect to our network.
def connect():
    wlan = WLAN(mode=WLAN.STA)
    nets = wlan.scan()
    for net in nets:
        if net.ssid == 'YOUR_SSID':
            print('Network found!')
            wlan.connect(net.ssid, auth=(net.sec, 'YOUR_PASSWORD'), timeout=5000)
            while not wlan.isconnected():
                machine.idle() # save power while waiting
            print('WLAN connection succeeded!')
            print("My IP address is: {0}".format(wlan.ifconfig()[0]))
            return True
    return False

# Setup the real time clock with the NTP service
def get_ntp():
    rtc = RTC()
    print("Time before sync:", rtc.now())
    rtc.ntp_sync("pool.ntp.org")
    while not rtc.synced():
        utime.sleep(3)
        print("Waiting for NTP server...")
    print("Time after sync:", rtc.now())
    return rtc

# Read HTML from file and send to client a row at a time.
def send_html_file(filename, client):
    html = open(filename, 'r')
    for row in html:
        client.send(row)
    html.close()

# Send the sensor data to the client.
def send_sensor_data(client, filename):
    send_html_file("part1.html", client)
    log_file = open(filename, 'r')
    for row in log_file:
        cols = row.strip("
").split(",") # split row by commas
        # build the table string if all parts are there
        if len(cols) >= 5:
            html = HTML_TABLE_ROW.format(cols[0], cols[1], cols[2],
                                         cols[3], cols[4])
            # send the row to the client
            client.send(html)
    log_file.close()
    send_html_file("part2.html", client)

# Setup the socket and respond to HTML requests
def run():
    # Connect to the network
    if not connect():
        sys.exit(-1)

    # Setup the real time clock
    rtc = get_ntp()

    # Setup the plant monitoring object instance from the plant_monitoring class
    plants = PlantMonitor(rtc)
    filename = plants.get_filename()

    # Setup the HTML server
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('', 80))
    sock.listen(5)
    print("Ready for connections...")
    server_on = True
    while server_on:
        client, address = sock.accept()
        print("Got a connection from a client at: %s" % str(address))
        request = client.recv(1024)

        # Allow for clearing of the log, but be careful! The auto refresh
        # will resend this command if you do not clear it from your URL
        # line.

        if (request[:14] == b'GET /CLEAR_LOG'):
            print('Requesting clear log.')
            plants.clear_log()
        send_sensor_data(client, filename)
        client.close()
    sock.close()

Changes for the Pyboard

Like the code module previously, the changes needed to run the code on the Pyboard are numerous. The main reasons for this include the usual changes but also the code is quite different because we must use a polling method since there is no (easy) way to set up a timer interrupt like we did on the WiPy.

Since the changes are numerous, a difference file is nearly the same length as the actual code.³ Thus, we will see the complete code for the Pyboard. Listing 10-11 shows the complete code for the code module with the differences needed to adapt the code module to the Pyboard (in bold). While most changes are minimal, if you are using the Pyboard or a Pyboard clone, take note of the pins used for the sensor.

There are two major changes needed in the run() function. First, there is not NTP support in the Pyboard firmware so we must use an RTC module or initialize the onboard RTC each time we start the project. Second, since there is no way to set up a timer interrupt that permits access to files, we must change the HTML server to use a non-blocking socket technique. These changes are highlighted in bold.

Listing 10-11. Plant Monitor Main Code (Pyboard)

# MicroPython for the IOT - Chapter 10
#
# Project 3: MicroPython Plant Monitoring
#
# Required Components:
# - Pyboard
# - (N) Soil moisture sensors (one for each plant)
#
# Note: this only runs on the Pyboard.
#
# Imports for the project
from pyb import delay, SPI
from pyb import I2C
import network
import urtc
import usocket as socket
from plant_monitor import PlantMonitor

# Setup the I2C interface for the rtc
i2c = I2C(1, I2C.MASTER)
i2c.init(I2C.MASTER, baudrate=500000)

# HTML web page for the project
HTML_TABLE_ROW = "<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td></tr>"

# Setup the board to connect to our network.
def connect():
    nic = network.CC3K(SPI(2), Pin.board.Y5, Pin.board.Y4, Pin.board.Y3)
    # Replace the following with yout SSID and password
    print("Connecting...")
    nic.connect("YOUR_SSID", "YOUR_PASSWORD")
    while not nic.isconnected():
        delay(50)
    print("Connected!")
    print("My IP address is: {0}".format(nic.ifconfig()[0]))
    return True

# Read HTML from file and send to client a row at a time.
def send_html_file(filename, client):
    html = open(filename, 'r')
    for row in html:
        client.send(row)
    html.close()

# Send the sensor data to the client.
def send_sensor_data(client, filename):
    send_html_file("part1.html", client)
    log_file = open(filename, 'r')
    for row in log_file:
        cols = row.strip("
").split(",") # split row by commas
        # build the table string if all parts are there
        if len(cols) >= 5:
            html = HTML_TABLE_ROW.format(cols[0], cols[1], cols[2],
                                         cols[3], cols[4])
            # send the row to the client
            client.send(html)
            delay(50)
    log_file.close()
    send_html_file("part2.html", client)

# Setup the socket and respond to HTML requests
def run():
    # Connect to the network
    if not connect():
        sys.exit(-1)

    # Setup the real time clock
    rtc = urtc.DS1307(i2c)
    #
    # NOTE: We only need to set the datetime once. Uncomment these
    #       lines only on the first run of a new RTC module or
    #       whenever you change the battery.
    #       (year, month, day, weekday, hour, minute, second, millisecond)
    #start_datetime = (2017,07,20,4,9,0,0,0)
    #rtc.datetime(start_datetime)

    # Setup the plant monitoring object instance from the plant_monitoring class
    plants = PlantMonitor(rtc)
    filename = plants.get_filename()

    # Setup the HTML server
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('', 80))
    sock.setblocking(False)   # We must use polling for Pyboard.
    sock.listen(5)
    print("Ready for connections...")
    server_on = True
    while server_on:
        try:
            client, address = sock.accept()
        except OSError as err:
            # Do check for reading sensors here
            plants.read_sensors()
            delay(50)
            continue
        print("Got a connection from a client at: %s" % str(address))
        request = client.recv(1024)

        # Allow for clearing of the log, but be careful! The auto refresh
        # will resend this command if you do not clear it from your URL
        # line.

        if (request[:14] == b'GET /CLEAR_LOG'):
            print('Requesting clear log.')
            plants.clear_log()
        send_sensor_data(client, filename)
        client.close()
    sock.close()

Notice the try block in the run() function. The sock.accept() function will throw an exception when there is no client connected. This is different than how a blocking call works. A blocking call will simply wait until a client connects. Here, we must attempt to accept a connection and if it fails, continue waiting for a connection. That is, we cannot send the HTML to the client as there is not client!

These changes highlight the added difficulty in using the Pyboard and other MicroPython boards without networking support, those that require RTC modules, and those with limited support for timer alarm interrupts to permit quasi-asynchronous execution (it’s not really asynchronous). In other words, we can disconnect some of our code to be called (triggered) by interrupts.

Now, let’s run this project!

2017-08-08 20:26:17,1,78,dry,Small fern on bottom shelf on porch
2017-08-08 20:26:32,2,136,dry,Green pot creeper thing on floor in living room
2017-08-08 20:26:47,1,128,dry,Small fern on bottom shelf on porch
2017-08-08 20:27:02,2,112,dry,Green pot creeper thing on floor in living room