Imports

The imports for the project will require the Pin class from the machine library and the utime library. The following shows the imports for the WiPy.

from machine import Pin
import utime

The imports for the Pyboard also require the Pin class from the pyb library as well as the delay function and ExtInt class. The ExtInt class is used to set up an interrupt for the button to fire when the button is pressed.

from pyb import Pin, delay, ExtInt

Setup

The setup code for this project will need to initialize the button and LED instances and then turn off all the LEDs (as a precaution) and turn on the green stoplight LED and the red walk signal LED. Listing 9-1 shows the code for setup and initialization.

Listing 9-1. Setup and Initialization of the Button and LEDs (WiPy)

# Setup the button and LEDs
button = Pin('P23', Pin.IN, Pin.PULL_UP)
led1 = Pin('P3', Pin.OUT)
led2 = Pin('P4', Pin.OUT)
led3 = Pin('P5', Pin.OUT)
led4 = Pin('P6', Pin.OUT)
led5 = Pin('P7', Pin.OUT)

# Setup lists for the LEDs
stoplight = [led1, led2, led3]
walklight = [led4, led5]

# Turn off the LEDs
for led in stoplight:
    led.value(0)
for led in walklight:
    led.value(0)

# Start with green stoplight and red walklight
stoplight[2].value(1)
walklight[0].value(1)

One thing to notice is how the button is initialized. This is a Pin object instance that is set up as an input (read) and the pull-up resistors are turned on. This allows the board to detect when the button is pressed because the value of the pin will be a positive value when the connection is made (the button is pressed).

Notice also I create a list that contains the LEDs for the stoplight and walk signal (named walklight in the code). This is mostly for demonstration so you can see how to manage lists of class objects. As you can see, it makes it easier to call the same function for all the objects in the list using a loop. Take note of this technique as you will need it from time to time in other projects.

The code for the Pyboard is largely the same. The differences include different pin numbers for the LEDs and buttons (see wiring diagram), different options for the initialization of the pins (Pin.OUT_PP instead of Pin.OUT), and the use of different functions for the Pin class: high() for value(1) and low() for value(0).

Functions

There are two functions needed for this part of the project. First, we need a function to cycle through the lights. Second, we need a function to monitor the button press. Let’s look at the cycle light function.

We will name the cycle lights function cycle_lights(). Recall we need to control how the lights change state. We do this with a specific cycle as described earlier. To recap, we call this function when we want to simulate changing the stoplight when the walk request button is pressed. Thus, this function will be called from the code for the button. Listing 9-2 shows the code for the cycle_lights() button. As you will see, the code is rather straightforward. The only tricky part may be the loop used to flash the yellow walk LED. Be sure to read through it so that you understand how it works.

Listing 9-2. The cycle_lights() Function (WiPy)

# We need a method to cycle the stoplight and walklight
#
# We toggle from green to yellow for 2 seconds
# then red for 20 seconds.
def cycle_lights():
    # Go yellow.
    stoplight[2].value(0)
    stoplight[1].value(1)
    # Wait 2 seconds
    utime.sleep(2)
    # Go red and turn on walk light
    stoplight[1].value(0)
    stoplight[0].value(1)
    utime.sleep_ms(500)  # Give the pedestrian a chance to see it
    walklight[0].value(0)
    walklight[1].value(1)
    # After 10 seconds, start blinking the walk light
    utime.sleep(1)
    for i in range(0,10):
        walklight[1].value(0)
        utime.sleep_ms(500)
        walklight[1].value(1)
        utime.sleep_ms(500)

    # Stop=green, walk=red
    walklight[1].value(0)
    walklight[0].value(1)
    utime.sleep_ms(500)  # Give the pedestrian a chance to see it
    stoplight[0].value(0)
    stoplight[2].value(1)

The code for the Pyboard is very similar with the changes as noted previously for controlling the LEDs and use of the delay() function instead of the utime class sleep functions.

We will name the button function button_pressed(). This function is used as a callback for the button press interrupt. Technically, we tell MicroPython to associate this method with the pin interrupt but we will see that in a moment. However, there is another element to this function that requires explanation.

When we use a component like a button and the user (you) press the button, the contacts in the button do not go from an off state to and on state instantaneously. There is a very small period where the value read is erratic. Thus, we cannot simply say, “when the pin goes high” because the value read on the pin may “bounce” from low to high (or high to low) rapidly. This is called bouncing. We can overcome this artificially with code (as well as other techniques) – called debouncing.

In this case, we can check the value of the pin (button) over time and only “trigger” the button press if and only if the value remains stable during that time. Code for debouncing the pin is shown in Listing 9-3. Notice in the loop we wait for a value of 50. This is 50 milliseconds. If the trigger is long enough, we call the cycle_lights() function.

Listing 9-3. The button_pressed() Function (WiPy)

def button_pressed(line):
    cur_value = button.value()
    active = 0
    while (active < 50):
        if button.value() != cur_value:
            active += 1
        else:
            active = 0
        utime.sleep_ms(1)
        print("")
    if active:
        cycle_lights()
    else:
        print("False press")

Finally, we need to set up the button to call the button_pressed() function when the board detects the interrupt. The following sets the callback function on the WiPy.

# Create an interrupt for the button
button.callback(Pin.IRQ_FALLING, button_pressed)

The code on the Pyboard is also a single line of code but in this case, we must use the ExtInt class to set up the interrupt handler as shown below.

# Create an interrupt for the button
e = ExtInt('X1', ExtInt.IRQ_FALLING, Pin.PULL_UP, button_pressed)

Now we’re all set to test the code. Go ahead and open a new file named ped_part1_wipy.py (or ped_part1_pyb.py for the Pyboard) and enter the code above. Listing 9-4 shows the complete code for part 1 of the project. If you’re using the Pyboard, it’s OK to cheat by looking at the complete listing at the end of the chapter.

Listing 9-4. Stoplight Simulation – Part 1 (WiPy)

# MicroPython for the IOT - Chapter 9
#
# Project 2: A MicroPython Pedestrian Crosswalk Simulator
#            Part 1 - controlling LEDs and button as input
#
# Required Components:
# - WiPy
# - (2) Red LEDs
# - (2) Yellow LEDs
# - (1) Green LED
# - (5) 220 Ohm resistors
# - (1) breadboard friendly momentary button
#
# Note: this only runs on the WiPy.
#
# Imports for the project
from machine import Pin
import utime

# Setup the button and LEDs
button = Pin('P23', Pin.IN, Pin.PULL_UP)
led1 = Pin('P3', Pin.OUT)
led2 = Pin('P4', Pin.OUT)
led3 = Pin('P5', Pin.OUT)
led4 = Pin('P6', Pin.OUT)
led5 = Pin('P7', Pin.OUT)

# Setup lists for the LEDs
stoplight = [led1, led2, led3]
walklight = [led4, led5]

# Turn off the LEDs
for led in stoplight:
    led.value(0)
for led in walklight:
    led.value(0)

# Start with green stoplight and red walklight
stoplight[2].value(1)
walklight[0].value(1)

# We need a method to cycle the stoplight and walklight
#
# We toggle from green to yellow for 2 seconds
# then red for 20 seconds.
def cycle_lights():
    # Go yellow.
    stoplight[2].value(0)
    stoplight[1].value(1)
    # Wait 2 seconds
    utime.sleep(2)
    # Go red and turn on walk light
    stoplight[1].value(0)
    stoplight[0].value(1)
    utime.sleep_ms(500)  # Give the pedestrian a chance to see it
    walklight[0].value(0)
    walklight[1].value(1)
    # After 10 seconds, start blinking the walk light
    utime.sleep(1)
    for i in range(0,10):
        walklight[1].value(0)
        utime.sleep_ms(500)
        walklight[1].value(1)
        utime.sleep_ms(500)

    # Stop=green, walk=red
    walklight[1].value(0)
    walklight[0].value(1)
    utime.sleep_ms(500)  # Give the pedestrian a chance to see it
    stoplight[0].value(0)
    stoplight[2].value(1)

# Create callback for the button
def button_pressed(line):
    cur_value = button.value()
    active = 0
    while (active < 50):
        if button.value() != cur_value:
            active += 1
        else:
            active = 0
        utime.sleep_ms(1)
        print("")
    if active:
        cycle_lights()
    else:
        print("False press")

# Create an interrupt for the button
button.callback(Pin.IRQ_FALLING, button_pressed)

Test and Debug the Code

Testing this part of the project requires copying the source code file to the board and then executing it. Since the code was written without a run() function, simply importing it is all you need to do to run the code. Be sure to check all connections before powering on the board. Recall, the command we use to import and run the code once we connect to the board is shown below.

>>> import ped_part1_wipy

Once imported, the code will run and you can press the button to see the lights cycle through the stages. If you do not see any of the lights on (the green stoplight and red walk signal should be on), check the setup and initialization code. If the lights do not cycle when the button is pressed, check the code for the button to ensure you have it correct. If they do not illuminate in order, you may have the pins wired incorrectly. Be sure to check all wiring connections when encountering problems, always powering off the board before disconnecting or reconnecting any wires or components.

When the project is working, try it out a few times to ensure it works as expected. Then you should congratulate yourself! You’ve just wired together several discrete electronic components and made a working simulation of a pedestrian walk button and stoplight. Cool!

Now, let’s kick this project up a notch and make it accessible over the Internet. After all, that is what IOT is all about!

Imports

We need a few more libraries in the import section. We need the socket library (renamed with an alias for clarity), the machine library, and the WLAN class from the network library. It is perfectly normal to write the imports this way, but with a little imagination you can simplify them. Do you see how? The following shows the complete import section for the WiPy.

from machine import Pin
import usocket as socket
import utime
import machine
from network import WLAN

The imports for the Pyboard are a bit shorter. We need to add the SPI library for the network board and the network library as well as the socket library. The following shows the complete import section for the Pyboard.

from pyb import Pin, delay, ExtInt, SPI
import network
import usocket as socket

Now, let’s look at the changes in the setup section.

Setup

For this part of the project, we need to add the code to connect our board to our network (or the Internet) via a wireless connection. We also need to place the HTML code here in the form of a string. This is typically where (and how) one defines a large string for use in Python. Using triple quotes on either side makes the string a documentation string (also called a docstring). See https://www.python.org/dev/peps/pep-0257/ for more details.

The networking code for the WiPy is the same code we saw earlier in the book. In this case, it sets up the wireless networking feature to connect to an existing wireless network rather than the default access point behavior of the WiPy. Listing 9-5 shows the network code for the WiPy.

Listing 9-5. Wireless Network Setup (WiPy)

# Setup the board to connect to our network.
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]))
        break

The networking code for the Pyboard is the same code we saw earlier in the book. In this case, it first sets up the SPI interface to a networking board (in this example a CC3000 breakout board), then initiates a wireless connection to an existing wireless network rather than the default access point behavior of the WiPy. Listing 9-6 shows the network code for the Pyboard.

Listing 9-6. Wireless Network Setup (Pyboard)

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

Another part of the setup is the HTML response code. This may seem like a difficult part of the code, but it is simple. We are constructing a string that we will send back to the client through the socket. This string contains HTML code starting with a header. Then, we supply a title (which appears in the title bar of your browser), some text to display on the page, and a form that contains the two buttons. These buttons are in a form that, when each is pressed, will send a HTML GET request through the socket to the server. Simple! Listing 9-7 shows the HTML string for the project. Again, don’t worry about the details. You can work on improving the web page later.

Listing 9-7. HTML Response String

# HTML web page for the project
HTML_RESPONSE = """<!DOCTYPE html>
<html>
  <head>
    <title>MicroPython for the IOT - Project 2</title>
  </head>
  <center><h2>MicroPython for the IOT - Project 2</h2></center><br>
  <center>A simple project to demonstrate how to control hardware over the Internet.</center><br><br>
  <form>
    <center>
        <button name="WALK" value="PLEASE" type="submit" style="height: 50px; width: 100px">REQUEST WALK</button>
        <br><br>
        <button name="shutdown" value="now" type="submit" style="height: 50px; width: 100px">Stop Server</button>
    </center>
  </form>
</html>
"""

Notice the buttons in the code (<button></button> tags). The name and value will be sent in the request to the server. The type of the button is defined as submit and when placed on a form, causes the client to post the form data to the server when the button is pressed. Finally, the string before the end tag is the label that will be displayed on the button.

If you’re concerned about this being a huge string that takes up memory, you’re right it is and it does. If you are planning a project that uses a large HTML response or perhaps several responses, you may want to consider storing those in a file (one response per file) and reading the data from a file before sending it to the client. This will save some data space and could make the difference for larger projects that use more memory.

Don’t be concerned about the number of lines used here. The whitespace is used for decoration (mostly) so if you wanted to reduce its overall visual size, you can remove the whitespace but it is common practice to indent the HTML code like this for easier reading.

There is one other important thing about using HTML on your MicroPython board that should be made clear: this example and many others you may find on the Internet should not be confused with a robust web server. More specifically, this example merely sends HTML back to the client once it detects a HTML GET method (request) from the client while listening on a network socket. So, this example is merely a simple HTML server and not a web server in the sense that it can do all manner of things a web server can do – it doesn’t. Thus, you should take care to code your projects to restrict operation to specific GET (or POST) requests and return the appropriate HTML response.

<html>
  <head>
    <title>MicroPython for the IOT - Project 2</title>
    <meta http-equiv="refresh" content="10">
  </head>
  <body>
    <p>Pedestrian Stoplight Simulation</p>
    <form>
        <img src="http://localhost:8000/red.png">
    </form>
  </body>
</html>

$ python -m SimpleHTTPServer
Serving HTTP on 0.0.0.0 port 8000 ...
127.0.0.1 - - [07/Aug/2017 14:42:30] "GET /red.png HTTP/1.1" 200 -

Now let’s look at how to make the run() function.

Functions

All that remains to do in the code is to change the code for the hardware button and make a run() function to contain the main portion of the code. In this project, that includes the code for setting up the socket and the listen and respond code. You can leave the button_pressed() function, but it is not needed. Listing 9-8 shows the code for the run() function.

Listing 9-8. The run() Function (WiPy)

# Setup the socket and respond to HTML requests
def run():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('', 80))
    sock.listen(5)
    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)
        # Process the request from the client. Payload should appear in pos 6.
        # Check for walk button click
        walk_clicked = (request[:17] == b'GET /?WALK=PLEASE')
        # Check for stop server button click
        stop_clicked = (request[:18] == b'GET /?shutdown=now')
        if walk_clicked:
            print('Requesting walk now!')
            cycle_lights()
        elif stop_clicked:
            server_on = False
            print("Goodbye!")
        client.send(HTML_RESPONSE)
        client.close()

Notice we begin the function with setting up the socket and binding it to port 80. The bind() function uses an empty string to instruct the socket to use the current IP address. Next, we tell the socket to listen on the socket with a five-second timeout using the listen(5) function. Then, we set a Boolean variable to loop over the listen and respond code while it is true. In this case, we use the Boolean and set it to False when the shutdown button is pressed.

Inside the loop is where things get interesting. The first thing we do is accept a connection from the socket using sock.accept(), which returns two items: the client object instance and the address of the client. We can print the address of the client for debugging purpose.

Next, we tell the client to receive up to 1024 bytes with the client.recv(1024) call. This will wait until there is a response from the client, so be aware this is not a preemptive loop – it will wait until the client responds. When the client does send data (like first connect or when a button is pressed), we can then search the string sent for the command.

Notice in the code we check for either the walk request searching for b'GET /?WALK=PLEASE' or the shutdown event searching for b'GET /?shutdown=now'. There is a bit of trickery going on here that warrants explanation. We use the request string as an array starting our search from the start for the number of characters in the string (17 or 18), which is represented with [:17] or [:18].

If the walk request is detected, we call the cycle_lights() function, which is unmodified from part 1. If the shutdown event is detected, we set the loop to terminate and then exit the run() function.

Take some time to read through the code until you understand how it works. When ready, go ahead and open a new file named ped_part2_wipy.py (or ped_part2_pyb.py for the Pyboard) and enter the code above.

Finally, you must remove the line of code that sets up the button callback (or on the Pyboard the ExtInt() call). It won’t hurt the code to leave it in, but since we’re not using the button, it is not needed and all unnecessary code should be removed.

Now, let’s look at the complete code for both the WiPy and Pyboard.