Its a really simple application, you start it up, you click “take image”, you re-position the scene, you click “take image” and so on until you are happy with your animation and you click “save” to store it as an animated gif.

You can find the source code at gist.github.com/martinohanlon.

Install

1. Connect a camera module
2. Enable the camera (Menu > Preferences > Raspberry Pi Configuration, Interfaces, Camera)
3. Open a terminal (Menu > Accessories > Terminal), install the modules and download the code:

sudo pip3 install guizero
sudo pip3 install imageio
wget -O guizero_stopmotion.py https://gist.githubusercontent.com/martinohanlon/52a7557a91d9e5b353a278447fbacc34/raw/guizero_stopmotion.py

1. Run the program:

python3 guizero_stopmotion.py

A couple of “interesting” things about this project The gui was created using guizero which is a super simple to use library for creating GUI’s, definitely have a look.

Most of the work was finding a way to create animated gifs in Python and working with images in memory rather than stored on disk

When the image is captured from the camera it isn’t stored to a file, it is stored in a numpy array, this means each frame is only stored in memory making it faster:

# create the camera
camera = PiCamera(resolution="640x480")
camera_output = PiRGBArray(camera)
...
# capture the image
camera.capture(camera_output, "rgb")
# append the camera image to the list as a numpy array
animation.images.append(camera_output.array)

The python module imageio is used to create the gif by passing the frames as a list, but again rather than being written to disk each time it is created as an in memory BytesIO stream:

gif_output = BytesIO()
imageio.mimsave(gif_output, animation.images, format="gif")

When the animated gif is displayed in guizero the BytesIO stream has to be open into a PIL Image.

animation.image = Image.open(gif_output)

At @Raspberry_Pi ‘s MakerDay I hacked a lucky cat so it only waves when it’s sunny. pic.twitter.com/JUED5nYadt

— Martin O’Hanlon (@martinohanlon) June 9, 2018

It did this by pulling the weather data from Open Weather Map using the Python module pyowm.

1.Sign up for a free API key in Open Weather Map.

2. Install the pyown Python module, open a Terminal or Command Prompt and run:

Windows

pip install pyown

Raspberry Pi / Linux

sudo pip3 install pyown

MacOS

pip3 install pyown

3. Create a Python program using the following code, inserting your API key:

import pyowm

owm = pyowm.OWM('put api key here')

observation = owm.weather_at_place('Cambridge,GB')
w = observation.get_weather()

clouds = w.get_clouds()
wind = w.get_wind()
humidity = w.get_humidity()
temp = w.get_temperature('celsius')

print("{}, {}, {}, {}".format(clouds, wind, humidity, temp)

Note - it can take up to 60 minutes for your API key to be activated.

There is a lot more information which can be pulled back - have a look at the weather module documentation for more details.

This seemed like a really big miss, shortcuts are the usual way for people (and certainly beginners to launch applications).

So I set to creating a really simple way of creating shortcuts for Python applications.

Enter shortcut, a X platform (Windows, MacOS, Linux, Raspberry Pi) Python module for automatically creating shortcuts.

Its really simple to install and use:

pip3 install shortcut
shortcut name_of_app

It will find the location of the app and create desktop and menu shortcuts for it.

There is also a Python API which can be used to do the same:

from shortcut import ShortCutter
s = ShortCutter()
s.create_desktop_shortcut("python")
s.create_menu_shortcut("python")

You will find documentation at shortcut.readthedocs.io and code at github.com/martinohanlon/shortcut.

sudo apt-get install samba

Modify the Samba config file to add a share called pihome which points to the /home/pi directory:

sudo nano /etc/samba/smb.conf

Scroll to the bottom and add the following:

protocol = SMB2

[pihome]
   comment= Pi Home
   path=/home/pi
   browseable=Yes
   writeable=Yes
   only guest=no
   create mask=0644
   directory mask=0755
   public=no

Setup a samba password for the Pi user:

sudo smbpasswd -a pi

Restart the samba service:

sudo service smbd restart

You should now be able to connect to your Pi using the address:

//ip_address_of_pi/pihome

It is most definitely a starting point rather than a finished solution, but someone might find it useful.

Setup (assuming you are using a Raspberry Pi / Linux computer, although it will work on Windows as well).

1. Generate a security token for the slack group you want to stream.

2. Create an environment variable SLACK_API_TOKEN and put your security token in it.

Edit /etc/profile adding the export to the bottom:

sudo nano /etc/profile
export SLACK_API_TOKEN=[my super long token]

1. Install slackclient and colorama using pip:

sudo pip3 install colorama
sudo pip3 install slackclient

1. Download the slack_stream.py from gist:

wget https://gist.githubusercontent.com/martinohanlon/477b6ea4c3bdc679ddff92dfc3bff4a7/raw/8ec39d08a9501b25d381ac3b008e9cf7be92377a/slack_streamer.py

1. Run it:

python3 slack_streamer.py

It uses a 2 way RFCOMM communication - you can send messages to and from 2 devices, 1 being the server which waits for connections, 1 being the client which makes a connection.

Install the library

sudo apt-get install python3-dbus
sudo pip3 install bluedot

Pairing

The 2 devices you which want to communicate between will need to be paired, the Blue Dot documentation describes how to pair 2 raspberry pi’s which might be useful.

Simple Client / Server Example

Lets create a simple example, a server which waits for connections and when it receives data it echo’s it back to the client.

Create a new Python program and save it as btserver.py:

from bluedot.btcomm import BluetoothServer
from signal import pause

def data_received(data):
    print(data)
    s.send(data)

s = BluetoothServer(data_received)
pause()

Create a 2nd program and save it as btclient.py:

from bluedot.btcomm import BluetoothClient
from signal import pause

def data_received(data):
    print(data)

c = BluetoothClient("nameofyourserver", data_received)
c.send("helloworld")

pause()

Run the server and then run the client, the client should connect and “Hello World” will be sent to the server and displayed on the screen, the server will then send the same “Hello World” message back to the client, which will print it to the screen.

Adapter

There is also a useful API for accessing the Bluetooth adapter allowing you to get its current status, power it on/off, make it discoverable or find the devices its paired with.

from bluedot.btcomm import BluetoothAdapter

a = BluetoothAdapter()

print("Powered = {}".format(a.powered))
print(a.paired_devices)
a.allow_pairing()

Documentation

There is comprehensive documentation for the btcomm library, which describes the API and how to use it.

Turning the display is relatively easy but making the touch work is more difficult - there was a set of instructions on the Raspberry Pi forum, but a recent update to Jessie meant they no longer worked, so I pulled this set of instructions together:

Install xinput:

sudo apt-get install xinput

Rotate the display by editing config.txt:

sudo nano /boot/config.txt

.. add this to the buttom of the file:

display_rotate=1

Use Ctrl X, Yes to Save Create a script to rotate the touchscreen:

nano /home/pi/touch_rotate.sh

.. add the following command

xinput --set-prop 'FT5406 memory based driver' 'Coordinate Transformation Matrix'  0 1 0 -1 0 1 0 0 1

Make the script executable:

chmod +x touch_rotate.sh

Make the script run when the GUI starts by editing autostart:

sudo nano ~/.config/lxsession/LXDE-pi/autostart

.. add this to the bottom to run your script

@/home/pi/touch_rotate.sh

Reboot:

sudo reboot

I created Blue Dot after being asked many times at Picademy “how can I get rid of all these wires?”.

Blue dot is an android app (client) and really easy to use Python library which allows you to wirelessly control your Python projects, whether that is a light switch, remote camera, robot or anything else you can think of!

See the getting started guide for more info on ‘getting started’, or follow the tutorial below.

Installation & Use These instructions assume your Raspberry Pi is running the latest version of Raspbian with Pixel.

You will need a Raspberry Pi with built-in Bluetooth (such as the Pi 3 or Pi Zero W) or a Raspberry Pi and a USB Bluetooth dongle.

Get the app Download and install the Blue Dot app from the google play store.

If you are wondering why there is no iOS app? Its because iOS doesn’t support Bluetooth serial comms; you can only really talk to ‘standard devices’ (cars, speakers, fitness trackers, etc).

Python library Open a terminal (Menu > Accessories > Terminal) and type:

sudo apt-get install python3-dbus
sudo pip3 install bluedot

Or if you need to use Python 2 (please dont tho!):

sudo apt-get install python-dbus
sudo pip install bluedot

Pairing In order to communicate over Bluetooth securely you need to pair your phone to your Raspberry Pi.

On your Android phone:

1. Open Settings
2. Select Bluetooth
3. This will make your phone Discoverable

Using your Raspberry Pi

1. Click the bluetooth icon on the taskbar
2. Turn on Bluetooth (if its off)
3. Click Make Discoverable
4. Click Add Device
5. Your phone will appear in the list, select it and click Pair
6. Enter a PIN code

On your Android phone

1. Enter the same PIN code when prompted
2. Click Ok

Code The simplest way to use the Blue Dot is as a button:

1. Open Python 3 (Menu > Programming > Python 3)
2. Create a new file (File > New File)

3. The following code, will start up the Blue Dot, and wait for it to be pressed:

   from bluedot import BlueDot
   bd = BlueDot()
   bd.wait_for_press()
   print("You pressed the blue dot!")
   

4. Save your program (File > Save) as mydot.py
5. Run your program (Run > Run Module)
6. Open the Blue Dot app
7. Connect to your Raspberry Pi
8. Press the Blue Dot

As well as waiting for something to happen you can also call functions when the button is pressed, released or the position its pressed moves.

from bluedot import BlueDot
from signal import pause

def say_hello():
    print("Hello World")

def say_goodbye():
    print("goodbye")

bd = BlueDot()
bd.when_pressed = say_hello
bd.when_released = say_goodbye

pause()

By using the position of where the button is pressed you can use the Blue Dot like a joystick:

from bluedot import BlueDot
from signal import pause

def dpad(pos):
    if pos.top:
        print("up")
    elif pos.bottom:
        print("down")
    elif pos.left:
        print("left")
    elif pos.right:
        print("right")
    elif pos.middle:
        print("fire")

bd = BlueDot()
bd.when_pressed = dpad

pause()

Add to this gpiozero’s Robot functions, you can create a Bluetooth controlled robot with very little code.

from bluedot import BlueDot
from gpiozero import Robot
from signal import pause

bd = BlueDot()
robot = Robot(left=(lfpin, lbpin), right=(rfpin, rbpin))

def move(pos):
    if pos.top:
        robot.forward()
    elif pos.bottom:
        robot.backward()
    elif pos.left:
        robot.left()
    elif pos.right:
        robot.right()

def stop():
    robot.stop()

bd.when_pressed = move
bd.when_moved = move
bd.when_released = stop

pause()

Check out the Blue Dot documentation for more information and ideas - you really can do a lot with a simple circle :)

This builds on the code I created for driving single 7 segment displays.

Hopefully the PR will get added into a gpiozero release soon, but until then add this code to your project and use the following to drive your display.

#setup the pins

#these are the pins the LED are connected too
# (in the order A, B, C, D, E, F, G, decimal point)
LED_PINS = (7, 22, 25, 17, 8, 27, 4, 24)
#these are the pins the digits are connected too
DIGIT_PINS = (23, 18, 15, 14)

#create the multi seven segment display
# use active_high=True when digit pins are cathode (ground)
multi_sev = MultiSevenSegmentDisplay(LED_PINS, DIGIT_PINS,
                                     active_high=True)

#display your message
multi_sev.display("LEDS")

#turn off the display using
multi_sev.off()

The display function works by plexing the display, turning the LEDs on one at a time, so quickly it tricks the eye into thinking the display is showing 1 message.