Introduction

Python is the language of choice for many developers and even more so for many hackers and makers. It’s widely regarded as a great first programming language for many reasons:

Interpreted language

Python is an interpreted language, meaning you can execute scripts directly through an interpreter instead of first compiling them into machine code. This adds the benefit of not having to explicitly declare variable types as we did in the Arduino IDE. The interpreter figures out for you which variables are ints, floats, etc.

The interactive shell

The Python interpreter can execute full Python scripts directly or as individual commands at an interactive shell. The shell presents a powerful way to develop scripts line by line without the hassle of writing a whole program around it.

The user community

The developer community around Python is enormous and incredibly active. From microcontrollers to web development to big data, there are libraries and communities that exist to help you get started and move you along.

In the last chapter, we used the Arduino IDE to control our circuits. In this chapter, we’ll use the Python programming language to perform those same exercises and even add a few more.

The only additional equipment that you’ll need is a smartphone or tablet—either iOS or Android—that is BLE enabled. It’s best if you can get your hands on an Android, as one of the exercises in this chapter (“Bluetooth-Controlled LED”) works for Android only.

“Hello, World” in Python

The best way to learn to program is to dive right in. Connect to the terminal on your Edison by using screen or Putty or ssh’ing in wirelessly (“Connecting”). Edison’s Yocto Linux distribution comes prepackaged with Python, so open the interactive shell simply by typing python at the command prompt. As the shell opens, you’ll be greeted with information about the Python version running on your Edison and a triple chevron (>>>), indicating that the interpreter is ready for your commands:

# python
Python 2.7.3 (default, Mar 31 2015, 14:39:49)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

At the prompt, issue the following command and then press Enter:

>>> print "Hello, World!"
Hello, World!

The interpreter executes your command and spits back the response in the same window. “Hello, World,” the quintessential first programming task, is so simple when compared to other languages, that it actually inspired an xkcd cartoon.

You can also use Python for simple and not-so-simple computations:

>>>  3+5 
8
>>>  import math
>>>  math.sqrt(20374)
142.73752134600068

The import statement is like the include statement we used in the Arduino IDE. It tells the interpreter to include the code from certain libraries or modules, making them available for use. You can also declare variables and perform operations on them:

>>>  a = 2
>>>  a*math.atan(12)
2.9753101898129106

The interactive Python shell also supports tab completion on functions, libraries, and variables. If you type math. and then press the Tab key twice, you’ll see all the functions available in the math module. Python also has a very useful built-in help statement:

>>>  help("sum")
Help on built-in function sum in module __builtin__:

sum(...)
    sum(sequence[, start]) -> value

    Returns the sum of a sequence of numbers (NOT strings)
    plus the value of parameter 'start' (which defaults to
    0).  When the sequence is empty, returns start.

If the help text is long, you can exit out of it by pressing the Enter key to scroll to the bottom or by pressing the q key.

Often you’ll probably want to execute standalone Python scripts or programs, which can be done by creating a text file with the .py extension and then calling it from the command line. To do so, first exit out of the interactive shell by hitting Ctrl+D or using the command exit().

Open a blank text file with the name HelloWorld.py using the text editor of your choice. Insert the following text, save the file, and close:

print “Hello, world!”
a = 10
a += 5
print a

Run the file and you’ll see that it outputs the print statements to the shell:

# python HelloWorld.py 
Hello, world!
15

Functions and Loops

As we saw in Chapter 3, functions are an incredibly useful coding tool. Functions in Python have a slightly different structure than in C++:

>>> def multiply(a,b):
...     return a*b
...
>>> a = multiply(10,6)
>>> a
60

Notice that you didn’t have to declare types for inputs or returns, but you did have to indent the return statement within the multiply function. If you left this out, you’d receive an error message:

>>> def m(a,b):
... a*b
  File "<stdin>", line 2
    a*b
    ^
IndentationError: expected an indented block

This is one of the biggest hurdles for beginners in coding with Python. Its coding structure is determined almost entirely by colons and whitespace. Any line introducing a block of code, such as a function declaration or if statement, should be finished with a colon. Everything within that block of code, starting with the next line, should be indented. When the indentation stops, the interpreter knows that the code block is over. It’s identical in purpose to surrounding our functions with the curly braces in the Arduino IDE.

Two constructs in Python will be important when you start translating your Arduino code into this new language: the for loop and the while loop. The for loop steps through its associated code block at each increment in the for statement;

for i in range(10):
    a = 2*i
    print a

The range function creates an array of 10 integers starting from 0:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

The code then steps through these values, multiplies each value by two, and then prints the result to the shell. You should see the even integers from 0 to 18 as the output of your for loop.

By contrast, the while loop executes its associated code so long as its condition is true. The following while loop performs the exact same action as the preceeding for loop:

i = 0
while (i < 10):
    a = 2*i
    print a
    i += 1

Changing this code to that in the following example will create a loop that runs indefinitely, since the condition will always be true. This is just like the loop() function in Arduino:

i = 0
while(True):
    a = 2*i
    print a
    i += 1

Use Ctrl+C to kill this code so that it doesn’t run forever.

Installing Libraries

There are an incredible number of libraries that add functionality to the standard Python distribution. They encompass everything from machine learning to image and audio processing and even web streaming. In fact, the Instagram website was built with Python’s Django library at its core.

If the standard Python distribution does not include a library you’d like to use, you can often install it using the package manager pip. To install pip, first use wget to grab the pip installation file get-pip.py:

# wget https://bootstrap.pypa.io/get-pip.py

Then, run the code you downloaded to install pip:

# python get-pip.py

A very useful library to have installed on Intel Edison is pyserial. Pyserial reads and writes serial data like the serial library we used in the Arduino IDE. You can install this library by calling pip at the command line:

# pip install pyserial

Similarly, should you wish to uninstall this package, just run the uninstall command:

# pip uninstall pyserial

We’ll explore many Python libraries later in the book; just know for now that if there’s a specific functionality you’re seeking, there’s probably a Python library you can install that provides it. And in 99% of cases, installing it will be just as easy as it was for pyserial.

Blink in Python

Let’s move our original Blink example into Python, blinking the onboard LED connected to pin 13. To make sure that your former Arduino sketches do not conflict with your new Python code, remove the stored Arduino sketches before beginning to program in Python:

# rm /sketch/*

Create the script blink.py, open it in a text editor, and add the following:

import mraa  
import time

ledPin = 13       
sleepTime = 0.2   # blink timing

x = mraa.Gpio(ledPin)
x.dir(mraa.DIR_OUT)

while True:     
    x.write(1)
    time.sleep(sleepTime)
    x.write(0)
    time.sleep(sleepTime)

This code performs the following actions:

The first two lines import the necessary libraries. The mraa library that we installed at the end of Chapter 2 gives Python the ability to interface with the Arduino board hardware. Time gives us access so the system clock.

The next four lines declare variables for the LED pin and blink time and then initialize the GPIO pin as an output.

The while loop writes the I/O pin, alternating to 1 (high) and 0 (low), sleeping for 0.2 seconds in between.

Save this program and run it, and you’ll see that the onboard LED connected to pin 13 will blink until you kill the program with Ctrl+C.

Most code in this chapter makes pretty heavy use of Intel’s mraa library. Libmraa is a library written in C/C++ with bindings to other languages such as JavaScript and Python. The goal is to allow easy interfaces with the I/Os on Galileo, Edison, and other platforms where port names and numberings automatically match the board that you are on.

# mkdir /etc/init.d
# cd /etc/init.d

#!/bin/sh
python /home/root/blink.py >> /dev/null 2>&1 &

# chmod +x automatic.sh

# update-rc.d automatic.sh defaults

# update-rc.d -f automatic.sh remove

Button-Controlled Blink

Digital inputs are handled by mraa as simply as digital outputs. To integrate a button into the blink circuit, recreate the circuit shown in Figure 3-7. The accompanying sketch that toggles the LED translates into Python as follows:

import mraa
import time

ledPin = 12       # LED pin number for mraa library
ledState = 0      # current state of led: off
buttonPin = 2     # button pin number for mraa library
buttonState = 0   # current state of button: not pressed

led = mraa.Gpio(ledPin)
led.dir(mraa.DIR_OUT)
button = mraa.Gpio(buttonPin)
button.dir(mraa.DIR_IN)

while True:
    if buttonState == 0 and button.read() == 1:
        ledState = 1 – button.read()
        led.write(ledState)
    buttonState = button.read()
    time.sleep(0.1)

This code should be fairly transparent based on the Arduino sketch you wrote before. In fact, most simple Arduino sketches will translate easily over to Python and should be extremely “readable.”

Bluetooth-Controlled LED

A far more interesting exercise is to use a Bluetooth connection from your smartphone to toggle an LED. For this example, you’ll use just the Arduino Breakout Board, toggling the onboard LED connected to pin 13. Unfortunately, exchanging serial data directly with Intel Edison will only work using an Android device, but the process of Bluetooth pairing will work with either iOS or Android. Whether you’re on Android or iOS, pair your device now. Later, you’ll do a BLE example that works with both systems, and you’ll need to be paired.

# rfkill unblock bluetooth
# rfkill list
0: phy0: wlan
        Soft blocked: no
        Hard blocked: no
1: brcmfmac-wifi: wlan
        Soft blocked: no
        Hard blocked: no
2: bcm43xx Bluetooth: bluetooth
        Soft blocked: no
        Hard blocked: no
3: hci0: bluetooth
        Soft blocked: no
        Hard blocked: no

# bluetoothctl
[NEW] Controller 98:4F:EE:02:F2:D2 edison [default]
[bluetooth]#

[bluetooth]# help
Available commands:
  list                       List available controllers
  show [ctrl]                Controller information
and more...

[bluetooth]# scan on
Discovery started
[CHG] Controller 98:4F:EE:02:F2:D2 Discovering: yes
[NEW] Device A8:66:7F:AB:AE:01 Stephanie Moyerman’s Nexus 5

[bluetooth]# scan off
[CHG] Device A8:66:7F:AB:AE:01 RSSI is nil
[CHG] Controller 98:4F:EE:02:F2:D2 Discovering: no
Discovery stopped
[bluetooth]# pair A8:66:7F:AB:AE:01
Attempting to pair with A8:66:7F:AB:AE:01

[bluetooth]# discoverable on
[bluetooth]# trust A8:66:7F:AB:AE:01

[bluetooth]# quit
[DEL] Controller 98:4F:EE:02:F2:D2 edison [default]

Exchanging Information

To handle the connection and information transfer between your phone and Edison, download the SPP-loopback.py made available from Intel’s developers. SPP stands for serial port profile, which emulates a serial cable for wireless communication such as Bluetooth. We’ll get to the loopback portion later:

# wget http://downloadmirror.intel.com/24909/eng/SPP-loopback.py

Run this code in the background:

# python SPP-loopback.py &

This program runs indefinitely, performing a few different functions. First, it waits for a Bluetooth connection from the phone. When the connection happens, it opens a socket for data transmit and receive. The code then transmits any data received from the phone back again with the prefix "looping back:". Finally, when the phone disconnects, the code closes the socket and starts all over again, waiting for a new connection. As long as this code is running, you can connect and disconnect from your phone at will.

To test it out, you’ll need an app that can transmit and receive data over Bluetooth. If you’re on Android, download the BlueTerm+ application from the Google Play Store. After downloading, open the application and tap on the three dots in the lower-right corner to bring up the menu. Select Connect Device and choose your Intel Edison from the list of possible options. The application will connect, and the status in the upper-right corner will change. This is shown in Figure 4-1. Once connected, anything you type will be transmitted to your Edison and then sent back to you, one character at a time. Get it? It loops back.

Figure 4-1. Example of using the Blueterm+ application before (left) and after (right) connecting to Intel Edison

Open this file using your favorite text editor. Note that it’s lines 45-47 where Intel Edison receives the characters from the Bluetooth transmission and loops them back out to the smartphone:

while True:
    data = server_sock.recv(1024)
    print("received: %s" % data)
server_sock.send("looping back: %s
" % data)

Instead of looping sent items back, you’re going to use the information to toggle the LED. I’ve modified the SPP-loopback.py for this purpose and put it on GitHub. Download it to your Intel Edison:

# wget https://raw.githubusercontent.com/smoyerman/Edison-Bluetooth-LED/master/SPP-blink.py --no-check-certificate

Open this file in a text editor to observe the changes. Lines 18-22 import the mraa library and declare the LED pin as an output, just as you have in prior examples:

# Initiate LED stuff
import mraa
ledPin = 13       # LED pin number for mraa library
led = mraa.Gpio(ledPin)
led.dir(mraa.DIR_OUT)

Lines 51-59 replace the loopback functionality with LED controls:

data = server_sock.recv(1024)  
if data == '1':   
  led.write(1)
  stringy = "LED is on
"
elif data == '0':  
  led.write(0)
  stringy = "LED is off
"
else:   
  stringy = "Unrecognized Command. Please send either 0 or 1 to toggle the LED.
"
server_sock.send(stringy)  

The data is first read from the socket as before.

If the incoming data from the phone is a 1 (read by Python as the string 1), Edison will turn the LED on, and the variable stringy will be updated accordingly.

If the incoming data from the phone is a 0, Edison will turn the LED off, and the variable stringy will be updated accordingly.

If any other data is received, the variable stringy will be set to an error message.

The variable stringy is sent back to the phone as a status update.

Try it! Run the program as you did with the loopback file:

# python SPP-blink.py &

Then connect using the BlueTerm+ app and send the LED commands. You should see the onboard LED toggle on and off as you send 1s and 0s. You can build upon this very simple example by adding more commands to the SPP-blink.py script and programming them to take on different actions.

Killing Programs

If the old SPP-loopback.py is still running, and it will be if you haven’t restarted your Edison, then you’ll need to kill it before initiating the new one. To do so, you can use the top command, which provides a dynamic, real-time view of what’s running on your system, and pipe the output to grep to find only what you’re looking for. For example, to find where the SPP-loopback.py program is running, enter the following command:

# top | grep "SPP-loopback.py"
   378   225 root     S    16776   2%   0% python SPP-loopback.py

Then kill the output with Ctrl+C. The first number in the returned line is the process ID of the SPP-loopback.py function. You can kill this function with the kill command:

# kill 378

If the program you’re wanting to kill is a Python program, like SPP_loopback.py, then you can also kill it with the following:

# killall python

Be warned, however. If you have other Python programs running, this command will definitely kill those, too.

The Potentiometer

You can transfer the analog I/O code over to Python just as easily as you transferred the digital I/O code. First, assemble your Intel Edison and breadboard as shown in Figure 3-11. Next, create a Python script, analog.py, with the following contents:

import mraa as m    

ledPinAnalog = 9    
potPinAnalog = 5;   # Analog in potentiometer pin A5

pot = m.Aio(potPinAnalog)   
led = m.Pwm(ledPinAnalog)
led.enable(True)

while(True):   
    potReading = pot.readFloat()
    led.write(potReading)

First, as always, you import the necessary mraa library.

Just as in the Arduino example, you declare your pin numbers.

Next, you initialize each pin with its respective function: analog input or PWM.

Loop indefinitely, reading the potentiometer value at each iteration and assigning it to the LED. The only real difference between this code and the Arduino code is the lack of a map function. While Arduino expects an integer in the range 0 to 255 for PWM input, mraa expects a float in the range 0 to 1. By using the readFloat() function, you automatically get a 0 to 1 scaled decimal back from our potentiometer. For reference, the read() function will return the unscaled 0 to 1,023 integer value for analog in.

I2C Accelerometer

To recreate the accelerometer examples in Python, wire the MMA8451 to the Intel Edison breakout as shown in Figure 3-12. Just as you did in the Arduino example, the first step in reading data from the accelerometer is to perform a check that the device is connected and addressable. Create a Python script with the following code to perform that check:

import mraa as m

# Init I2C
x = m.I2c(1)    

# Some addresses
MMA_i2caddr              = 0x1D      
MMA8451_REG_WHOAMI       = 0x0D
MMA_DEVID                = 0x1A

# Check that we're connected to the MMA8451 chip
try:
    x.address(MMA_i2caddr)     
    mma_id = x.readReg(MMA8451_REG_WHOAMI)    
    if not mma_id == MMA_DEVID:    
        print "Wrong device found! Dev ID = " + str(mma_id)
    else:        
        "MMA8451 Detected!"
except:
    print "MMA Device Not Connected!"

Create an I2C object using the mraa library.

Declare variables for the addresses and registers of the accelerometer.

Addresses the device at its known address.

Ask the device for its ID.

If the returned ID does not match the known ID of the MMA8451, then the script prints an error message indicating what was detected.

If the returned ID matches the known ID of the MMA8451, the script prints the “MMA8451 Detected!” message.

Run the script, and you should receive the “MMA8541 Detected!” statement. If not, check your wiring.

# opkg install python-numpy

# git clone https://github.com/smoyerman/EdisonMMA8451.git
# cd EdisonMMA8451
# ls
MMA8451.py  README.md   example.py

import MMA8451 as mma8451   
import time

# Potential range values   
MMA8451_RANGE_8_G = 0b10    # +/- 8g
MMA8451_RANGE_4_G = 0b01    # +/- 4g
MMA8451_RANGE_2_G = 0b00    # +/- 2g (default value)

# Make accelerometer object
accel = mma8451.MMA8451()

# Check for MMA 8451    
ismma = accel.check8451()
if ismma == True:
    print "MMA 8451 Found!"
else:
    print "No MMA Found. What is this?!"

# Set up mma, default range is 2Gs
accel.setup()      
# Can declare a different range with
accel.setup(MMA8451_RANGE_8_G)

# Loop, read, and print out values
for i in range(10):    
    ax,ay,az = accel.readData()
    print "(" + str(round(ax,1)) + ", "
              + str(round(ay,1)) + ", "
              + str(round(az,1)) + ")"
    orientation = accel.readOrientation()
    print orientation
    time.sleep(0.1)

# python example.py
MMA 8451 Found!
Range = 2Gs
Range = 8Gs
(4.4, 0.1, -4.2)
Portrait Up Front
(-0.0, 0.2, 1.0)
Portrait Up Front
(-0.0, 0.2, 1.0)
and more...

SPI Screen

Driving displays over Python has significant advantages over C or C++. Python has amazing image manipulation and image-drawing libraries that make configuring shapes and scenes a cinch.

As with the accelerometer example, I’ve written a library in Python for our display screen. Use git to grab it now:

# git clone https://github.com/smoyerman/EdisonILI9341.git
# cd EdisonILI9341
# ls
ILI9341.py         README.md          example_shapes.py  photo.py

Open the file example_shapes.py to see how drawing to the screen works:

""" Drawing something """

import ILI9341   

disp = ILI9341.ILI9341()
disp.begin()   

disp.clear((255, 0, 0))   

drawing = disp.draw()   

# Draw some shapes.   
# Draw a blue ellipse with a green outline.
drawing.ellipse((10, 10, 110, 80), outline=(0,255,0), fill=(0,0,255))

# Draw a purple rectangle with yellow outline.
drawing.rectangle((10, 90, 110, 160), outline=(255,255,0), fill=(255,0,255))

# Draw a white X.
drawing.line((10, 170, 110, 230), fill=(255,255,255))
drawing.line((10, 230, 110, 170), fill=(255,255,255))

# Draw a cyan triangle with a black outline.
drawing.polygon([(10, 275), (110, 240), (110, 310)], outline=(0,0,0), fill=(0,255,255))

disp.display()   

Import the ILI9341 library and create an ILI object called disp.

Call the begin function, which sends the screen over 50 configuration commands and initializes the device.

The function clear sets the screen buffer to the specified (R,G,B) values but does not yet send the buffer to the display. In the case of this script, the function is setting the background color to pure red. If no input is specified to clear, the function buffers a black background by default.

The script gets interesting when you call the draw function, which returns a Python ImageDraw object. ImageDraw objects are essentially a canvas on which you can paint using ImageDraw functions.

The script then draws an ellipse, rectangle, two lines, and a polygon simply by specifying coordinates and colors of each shape.

Finally, calling display renders the actual image to the screen.

A full list of ImageDraw functions and a couple of quick examples can be found on the documentation page. You can even load images, such as JPEGs and PNGs, and draw on top of them. You’ll do an example of this in Chapter 5.

Run the example_shapes.py file and, after a second or two of configuration and initilization, the screen will render the shapes given in the script. This library and script are meant as a starting point for building larger interactive systems. Python has libraries and distributions that handle building interactive games and images, so get making!

BLE Beacon

The final example in this chapter is turning your Intel Edison into a Bluetooth Low Energy (BLE) beacon, a transmitter that will broadcast signals that can be heard by compatible or smart devices. No additional hardware is necessary for this exercise, just an Intel Edison compute module and any breakout board. Because beacons are typically used for location sensing and tracking, this particular example works great when you put Intel Edison on a smaller breakout board. Imagine your Edison on the SparkFun base and battery blocks as a keychain and serving as a locater for your keys!

# wget https://raw.githubusercontent.com/smoyerman/edison-ibeacon/master/ibeacon

#!/usr/bin/python

# chmod +x ibeacon

# ./ibeacon
Advertising on hci0 with:
       uuid: 0xE20A39F473F54BC4A12F17D1AD07A961
major/minor: 0/0 (0x0000/0x0000)
      power: 200 (0xC8)
LE set advertise enable on hci0 returned status 12

# ./ibeacon
Error: no such device: hci0 (try `hciconfig list')

# rfkill unblock bluetooth

# ./ibeacon --help

Going Further

In this chapter, we’ve seen a lot of examples of the flexibility and power of Python programming. From general programming to algorithms to peripheral devices, Python’s libraries and wide user community/support make it a really great environment for development and rapid prototyping. The following resources will help you to go further with Python and follow up on examples you’ve seen in this chapter:

Code Academy’s introductory Python course

I think the number of enrolled students more than speaks for itself: 2.5 million.

Python’s own getting-started guide

Links to many resources and code examples for everyone from the newbie to the experienced Python programmer.

Intel Edison Products Bluetooth User Guide

At 73 pages, this guide is not for the faint of heart! However, it is jam-packed with heaps of good information about Bluetooth hardware and software and Edison-specific knowledge.