Why Do I Need to Learn Python?

Recall that I stated that the volume of Python examples for the Raspberry Pi and other low-cost computing boards is vast. So much so that you can find Python code snippets to do just about anything you want when learning to work with the GPIO.

It would be very sad if Windows 10 IoT enthusiasts could not take advantage of the wealth of information available for programming the Raspberry Pi with Python. Fortunately, this is not the case! Indeed, many of the Python examples can be adapted for use on Windows 10 IoT Core. You may need to change the modules included (I’ll explain this later), and you may be limited to working with GPIO, but by and large you can reuse that Python code in your own solutions! Thus, learning Python is a powerful resource for developing applications for Windows 10 IoT Core.

Furthermore, you can often develop your Python scripts using the interpreter on the Raspberry Pi prior to building your Windows 10 solution. This is why I covered the topic in Chapter 3. Using the interpreter with a basic script on the Raspberry Pi is faster and less error-prone than developing it in Visual Studio and deploying it. This is because since Python is interpreted, the Visual Studio tools cannot catch all of the problems or errors in your code before you deploy and run it. Using the interpreter (either on Windows or Raspberry Pi if you’re using GPIO) allows you to correct any syntax errors before wasting effort in remote debugging (which can fail for simple syntax errors).

Installing Python on Windows 10

How can you use it to write Windows 10 IoT applications? Fortunately, a Python interpreter is available for Windows 10 and indeed for the Windows 10 IoT Core. In fact, in order to use Python for your IoT projects, you need to download and install the following tools and components (if you haven’t already).

• Python 3.5 for Windows: http://www.python.org/downloads

• Python Tools for Visual Studio (PTVS): https://github.com/microsoft/ptvs/releases

• Python UWP SDK (pyuwpsdk.vsix): https://github.com/ms-iot/python/releases

• Python Windows Devices (pywindevices.zip) modules: https://github.com/ms-iot/python/releases

First and foremost, you must install Python 3.5 on your PC. If you have an older version, such as 2.6, 2.7, or even 3.4, you should uninstall them (if you don’t need them). This is because the PTVS requires Python 3.5 and ignore the older versions. If you attempt to work with Python solutions with an older version of Python, you may get some strange build or deployment errors or your solution will fail to run on the IoT device. Follow the instructions on the link to download and install Python 3.5.

Next, you need the Python Tools for Visual Studio. This is a third-party component that you can download and install but must do so in order to see the Python projects in the new project dialog tree. Follow the instructions on the web site to download and install PTVS. Note that this installation could take a while depending on your Internet connection and processor speed.

Next, you need to install the SDK for Python UWP applications. This is a Visual Studio plugin that you can install by double-clicking the file or by installing it via Visual Studio 2015.

Finally, you need the Python modules for the GPIO and other libraries. These are found in the pywindevices.zip file. Simply download this file and extract the files in a common place that you can find when building your solutions. For example, I placed mine in a folder (pywindevices) in the root of the Visual Studio project directory.

OK, once these prerequisites are complete, you’re ready to start wiring Python Windows 10 IoT solutions!

Should you require more in-depth knowledge of Python, there are a number of excellent books on the topic. The following lists a few of my favorites. A great resource is the documentation on the Python site ( www.python.org/doc/ ) .

• Pro Python, 2nd Edition, by J. Burton Browning and Marty Alchin (Apress, 2014)

• Learning Python, 5th Edition, by Mark Lutz (O’Reilly Media, 2013)

• Automate the Boring Stuff with Python: Practical Programming for Total Beginners by Al Sweigart (No Starch Press, 2015)

The Basics

Python is a very easy language to learn with very few constructs that are even mildly difficult to learn. Rather than toss out a sample application, let’s approach learning the basics of Python in a Python-like way: one step at a time.

The first thing you should learn is that Python does not use a code block demarcated with symbols like other languages. More specifically, code that is local to a construct, such as a function or conditional or loop is designated using indentation. Thus, the lines below that are indented (by spaces or, gag, tabs⁴) so that the starting characters align for the code body of the construct. The following shows this concept in action.

if (expr1):
    print("inside expr1")
    print("still inside expr1")
else:
    print("inside else")
    print("still inside else")

print("in outer level")

Here you see a conditional, or if, statement. Notice that the function call print() (a common way to display output to the console) is indented. This signals the interpreter that the lines belong to the construct above it. For example, the two print statements that mention expr1 form the code block for the if condition (expression evaluates to true). Similarly, the next two print statements form the code block for the else condition. Finally, the non-indented lines are not part of the conditional and thus are executed after either the if or else depending on the expression evaluation.

As you can see, indentation is a key concept to learn when writing Python. Even though it is very simple, making mistakes in indentation can result in code executing that you did not expect or worse errors from the interpreter.

There is one special symbol that you will encounter frequently. Notice the use of the colon (:) in the preceding code. This symbol is used to terminate a construct and signals the interpreter that the declaration is complete and the body of the code block follows.

Now let’s look at how you can use variables in your programs (scripts).

# Numbers
float_value = 9.75
integer_value = 5

# Strings
my_string = "He says, he's already got one."

print("Floating number: {0}".format(float_value))
print("Integer number: {0}".format(integer_value))
print(my_string)

import os
import sys
import mysql.utilities.common.server
import _wingpio as gpio

#
# Windows 10 for the IoT
#
# Example Python application.
#
# Created by Dr. Charles Bell
#

zip = 35012               # Zip or postal code      
address1= "123 Main St."  # Store the street address

Arithmetic

You can perform a number of mathematical operations in Python, including the usual primitives but also logical operations and operations used to compare values. Rather than discuss these in detail, I provide a quick reference in Table 7-2 that shows the operation and example of how to use the operation.

Bitwise operations produce a result on the values performed on each bit. Logical operators (and, or) produce a value that is either true or false and are often used with expressions or conditions.

Now that you understand variables and types, the operations permitted on them, and expressions, let’s look at how to use them in flow control statements.

Flow Control Statements

Flow control statements change the execution of the program. They can be conditionals that use expressions that restrict execution to only those cases where the expression evaluates true (or negated), special constructs that allow you to repeat a block of code (loops), and the use of functions to switch context to perform some special operations. You’ve already seen how functions work so let’s look at conditional and loop statements.

if (expr1):
    # execute only if expr1 is true
elif ((expr2) || (expr3)):
    # execute only if expr1 is false *and* either expr2 or expr3 is true
else:
    # execute if both sets of if conditions evaluate to false

while (expression):
   # do something here

for variable_name in list:
  # do something here

for i in range(2,9):
   # do something here

Functions

Python allows you to use modularization in your code. While it supports object-oriented programming by way of classes (a more advanced feature that you are unlikely to encounter for most Python GPIO examples), on a more fundamental level you can break your code into smaller chunks using functions.

Functions use a special keyword construct (rare in Python) to define a function. You simply use def followed by a name and a parameter list in parenthesis. The colon is used to terminate the declaration. The following shows an example.

def print_dictionary(the_dictionary):
    for key, value in the_dictionary.items():
      print("'{0}': {1}".format(key, value))

You may be wondering what this strange code does. Note that the loop is assigning two values from the result of the items() function . This is a special function available from the dictionary object. (Yes, dictionaries are objects! So are tuples, lists, and many other data structures.) The items() function returns the key, value pairs; hence, the names of the variables.

The next line prints out the values. The use of formatting strings where the curly braces define the parameter number starting at 0 is common for Python 3.x applications. See the Python documentation for more information about formatting strings.

Here the body of the function is indented. All statements indented under this function declaration belong to the function and are executed when the function is called. You can call functions by name providing any parameters as follows.

print_dictionary(my_dictionary)  

This example, when executed, generates the following output as shown in Figure 7-1. I generated this by writing the function in the Python interpreter on my PC and executing it. To run the interpreter, search for Python and select the Python command window. Thus, this demonstrates how to use the Python interpreter to execute Python code on the fly (as you type each line and press Enter).

Figure 7-1. Using the Python interpreter

Now let’s look at some commonly used data structures, including this strange thing called a dictionary.

Basic Data Structures

What you have learned so far about Python is enough to write the most basic programs and indeed more than enough to tackle the example project later in this chapter. However, when you start needing to operate on data (either from the user or from sensors and similar sources), you need a way to organize and store data and operations on the data in memory. The following introduces three data structures in order of complexity: lists, tuples, and so forth. Next, I demonstrate the three that you encounter most frequently.

# List
my_list = ["abacab", 575, "rex, the wonder dog", 24, 5, 6]
my_list.append("end")
my_list.insert(0,"begin")
for item in my_list:
  print("{0}".format(item))

# Tuple
my_tuple = (0,1,2,3,4,5,6,7,8,"nine")
for item in my_tuple:
  print("{0}".format(item))
if 7 in my_tuple:
  print("7 is in the list")

# Dictionary
my_dictionary = {
  'first_name': vChuck",
  'last_name': "Bell",
  'age': 36,
  'my_ip': (192,168,1,225),
  42: "What is the meaning of life?",
}
# Access the keys:
print(my_dictionary.keys())
# Access the items (key, value) pairs
print(my_dictionary.items())
# Access the values
print(my_dictionary.values())
# Create a list of dictionaries
my_addresses = [my_dictionary]

[42, 'first_name', 'last_name', 'age', 'my_ip']
[(42, 'what is the meaning of life?'), ('first_name', 'Chuck'), ('last_name', 'Bell'), ('age', 36), ('my_ip', (192, 168, 1, 225))]
['what is the meaning of life?', 'Chuck', 'Bell', 36, (192, 168, 1, 225)]
'42': what is the meaning of life?
'first_name': Chuck
'last_name': Bell
'age': 36
'my_ip': (192, 168, 1, 225)

Required Components

The following lists the components that you need. All of these are available in the Microsoft Internet of Things Pack for the Raspberry Pi from Adafruit. If you do not have that kit, you can find these components separately on the Adafruit web site ( www.adafruit.com ), from SparkFun ( www.sparkfun.com ), or any electronics store that carries electronic components.

• 560 ohm 5% 1/4W resistor (green, blue, brown stripes⁶)

• Diffused 10mm red LED (or similar)

• Breadboard (mini, half, or full sized)

• (2) male-to-female jumper wires

You may notice that this is the same set of components that you used in Chapter 3.

Set up the Hardware

Begin by placing the breadboard next to your Raspberry Pi and power the Raspberry Pi off orienting the Raspberry Pi with the label facing you (GPIO pins in the upper-left). Next, take one of the jumper wires and connect the female connector to pin 6 on the GPIO. The pins are numbered left-to-right starting with the lower left pin. Thus, the left two pins are 1 and 2 with pin 1 below pin 2. Connect the other wire to pin 7 on the GPIO.

Next, plug the resistor into the breadboard with each pin on one side of the center groove. You can choose whichever area you want on the breadboard. Next, connect the LED so that the long leg is plugged into the same row as the resistor and the other pin on another row. Finally, connect the wire from pin 6 to the same row as the negative side of the LED and the wire from pin 7 to the row with the resistor. Figure 7-2 shows how all of the components are wired together. Be sure to study this drawing and double-check your connections prior to powering on your Raspberry Pi. Once you’re satisfied everything is connected correctly, you’re ready to power on the Raspberry Pi and write the code.

Figure 7-2. Wiring the LED to a Raspberry Pi

Since you are building a headed application, you'll also need a keyboard, mouse, and monitor connected to the Raspberry Pi.

OK, now you have the hardware set up, so it’s time to start writing the code.

Write the Code

Begin by opening a new project template. Choose Python ➤ Windows IoT Core in the tree and the Background Application (IoT) template in the list. This template creates a new solution with all of the source files and resources you need for a UWP headed application. Figure 7-3 shows the project template that you need. Use BlinkPythonStyle for the project name.

Figure 7-3. New Project dialog—Background Application (IoT)

Once the project is open, you see a number of files like any other project. However, Python projects only have the one source code file named StartupTask.py. You can rename this file by right-clicking it, but it isn’t necessary for our example. Go ahead and open that file now (just double-click it in the tree). Notice that the file is empty save for a single comment line (you can overwrite that).

The first thing you need to do is add a reference to the GPIO Python module. Remember that this is contained in the pywindevices.zip file from CPython UWP SDK. If you haven’t already done so, download the file and extract the files in a directory you can remember.

To add the reference, Right-click the References item in the project and choose Add Reference.... Once the dialog opens, click Browse and then navigate to the folder where you extracted the files. In that folder are subfolders for ARM or x86 builds. Choose the folder that matches your board (e.g., ARM for Raspberry Pi). Once selected, you see all of the available modules.

The module you want is named _wingpio. There are two versions of the reference; one for release builds (_wingpio.pyd) and one for debug builds (_wingpio_d.pyd). I recommend using the debug version until your application runs correctly. Figure 7-4 shows the dialog you can use to add the reference.

Figure 7-4. Adding the Python module references

Now you can return to the code file and add the modules you want to use. You need two: the GPIO module and the time module. You can add them as follows .

import _wingpio as gpio # The GPIO library
import time             # Time functions

Next, you can write the code to create some variables that you need and to initialize the GPIO module. The code to do this is as follows.

BLINK_TIME = 30.0       # blink for 30 seconds
GPIO_PIN = 4            # GPIO4 (not pin #4)
pin_val = gpio.HIGH     # Store pin value (high/low)
elapsed_time = 0        # Store time in seconds

# Setup the
gpio.setup(GPIO_PIN, gpio.OUT, gpio.PUD_OFF, gpio.HIGH)

Here you have a variable to store how long you want to blink the LED, a variable to store the GPIO pin number (GPIO4), a variable to store the GPIO value (high/low), and a variable to store how much time has passed.

As you may have anticipated, you are going to implement the code to turn the LED on and off in a loop. The following shows the loop that you will use.

# Run the blink series for
while (elapsed_time < BLINK_TIME):
    # If LED is on, turn it off
    if pin_val == gpio.HIGH:
        pin_val = gpio.LOW
        gpio.output(led_pin, pin_val)
    # else, turn it on
    else:
        pin_val = gpio.HIGH
        gpio.output(led_pin, pin_val)

    # Sleep for 1/2 second
    time.sleep(1)
    elapsed_time = elapsed_time + 1

Notice that you simply turn the GPIO pin on (high) if it is off or off (low) if it is on. At the end of the loop, you sleep (pause) for one second and sum the time. Thus, the loop simply toggles from one state (on) to the other (off) thereby blinking the LED.

Finally, you clean up the GPIO object when the loop ends.

# Close down and cleanup the GPIO
gpio.cleanup()

That's it! You’ve finished the code. Listing 7-1 shows the complete code.

Listing 7-1. Python Blink LED Script

import _wingpio as gpio # The GPIO library
import time             # Time functions

BLINK_TIME = 30.0       # blink for 30 seconds
GPIO_PIN = 4            # GPIO4 (not pin #4)
pin_val = gpio.HIGH     # Store pin value (high/low)
elapsed_time = 0        # Store time in seconds

# Setup the GPIO
gpio.setup(GPIO_PIN, gpio.OUT, gpio.PUD_OFF, gpio.HIGH)

# Run the blink series for
while (elapsed_time < BLINK_TIME):
    # If LED is on, turn it off
    if pin_val == gpio.HIGH:
        pin_val = gpio.LOW
        gpio.output(GPIO_PIN, pin_val)
    # else, turn it on
    else:
        pin_val = gpio.HIGH
        gpio.output(GPIO_PIN, pin_val)

    # Sleep for 1/2 second
    time.sleep(1)
    elapsed_time = elapsed_time + 1

# Close down and cleanup the GPIO
gpio.cleanup()

As you can see, the code is much smaller than the C++ or C# examples from the previous chapters. You do not need to build the code (Python is interpreted). Indeed, building the code only performs some very high-level checks and does not check the validity of the code.

OK, now you’re ready to deploy the application to your device. Go ahead and set everything up and power on your device.

Deploy and Set as Startup

Once the Raspberry Pi has booted, you’re ready to deploy the application to it (or other device). Recall from Chapter 4, that you have to set up the debug settings to specify the IP address of your Raspberry Pi. Fortunately, you only have to change two items as indicated in Figure 7-5. Note that you may not need to set the remote port (5678 is the default). Remember to choose ARM for the platform. Click Apply and then OK to close the dialog.

Figure 7-5. Setting Debug Settings for deployment

Notice that you use the IP address for the device. You can also use the computer name if you know that. Also, unlike the C++ example, you do not specify a port here. Instead, you must select port 5678. This is a special port that the Python debugger responds to when you deploy your application.

Once these are set, you can deploy the application from the Build menu. When complete, you’ll get messages like the following from the Output window .

------ Deploy started: Project: BlinkPythonStyle, Configuration: Debug ARM ------                                                                                          
Creating a new clean layout...
Copying files: Total 16 mb to layout...
Checking whether required frameworks are installed...
Framework: Microsoft.VCLibs.140.00.Debug/ARM, app package version 14.0.22929.0 is not currently installed.
Installing missing frameworks...
Registering the application to run from layout...
Deployment complete (33566ms). Full package name: "BlinkPythonStyle_1.0.0.0_arm__2v0q544fdcg4c"
========== Build: 0 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========
========== Deploy: 1 succeeded, 0 failed, 0 skipped ==========

If your deployment succeeded, you may expect to see something happen on the Raspberry Pi, but you won’t see anything. That’s normal. A headless application must be set as a startup application in order to execute. You can set the startup application via the Windows Device Portal, but it is much easier to use a command-line tool on the device. Plus, while you can set the startup application with the Device Portal, you cannot start the application. This is an unfortunate limitation of the Device Portal currently. It can only start headed applications. As a workaround, in the Processes page, you can use Run command to execute this command to start a background application (by specifying it as one of the startup apps).

Recall that you use Putty (or a similar application) to connect to the device via SSH. The command is iostartup. Listing 7-2 shows the help output for the command, including all of the options to work with startup applications. As you can see, it is very comprehensive.

Listing 7-2. Help Output for iostartup Command

C:DataUsersadministrator>iotstartup
Usage:
  IotStartup [list|add|remove|startup] ([headed|headless]) (std::regex regular expression with implied ^ prepended)
  IotStartup [help|-?|-h|--help]

Examples:
  IotStartup list                   // list installed applications
  IotStartup list headed            // list installed headed applications
  IotStartup list headless          // list installed headless applications
  IotStartup list MyApp             // list installed applications that match pattern MyApp
  IotStartup add headed MyApp       // add headed application that matches pattern MyApp. Pattern must match only one application.
  IotStartup add headless Task1     // add headless applications that match pattern Task1
  IotStartup remove headless Task1  // remove headless applications that match pattern Task1
  IotStartup startup                // list headed and headless applications registered for startup
  IotStartup startup MyApp          // list headed and headless applications registered for startup that match pattern MyApp
  IotStartup startup headed MyApp   // list headed applications registered for startup that match MyApp
  IotStartup startup headless Task1 // list headless applications registered for startup that match Task1

You can see what applications are set for startup (they execute when the device is booted) using the iostartup startup command, as shown next. This command lists all of the applications that start on boot, grouped by headless or headed applications. Notice that you do not have to use the complete name for the application. You can just use the first few characters, or to be safer, the base name you used in Visual Studio.

C:DataUsersadministrator>iotstartup startup
Headed   : IoTCoreDefaultApp_1w720vyc4ccym!App
No headless applications registered

To add an application that has been deployed to the device as a startup application, simply add the name of the application to the command, as shown next. Here you add the application and then use the command again without a name to verify that it has started.

C:DataUsersadministrator>iotstartup add headless BlinkPythonStyle
Added Headless: BlinkPythonStyle_1.0.0.0_arm__2v0q544fdcg4c

C:DataUsersadministrator>iotstartup startup
Headed   : IoTCoreDefaultApp_1w720vyc4ccym!App
Headless : BlinkPythonStyle_1.0.0.0_arm__2v0q544fdcg4c

The application should start running at this point. If it doesn’t start, try rebooting the device. You can reboot the device via the command line with the following command. For information about other command-line commands, see https://ms-iot.github.io/content/en-US/win10/tools/CommandLineUtils.htm .

shutdown /r /t 0

To remove your application from the startup list, execute the following command.

iotstartup remove headless BlinkPythonStyle

If the LED is still not blinking after the reboot, double-check your wiring and ensure that you chose pin 4 in the code and pin 7 on the pin header (recall that the pin is named GPIO 4 but it is pin #7 on the header).

Once you get it working, you see the LED blink for 30 seconds and then the application stops. If this happens as expected, congratulations, you’ve just written your first Python application that uses the GPIO header to power some electronics!