Anthony Nguyen

Control lights & home devices using voice commands

2017-08-05T00:00:00+00:00

Most of us have already been there. You had a long and productive day and now it is time to have a good rest. You go on a light switch hunt, because it inconveniently went on a night stroll again and *BAM!*, your pinky toe decided to remind you that its only reason of existence is to let you FEEL its existence. Next thing you know a war breaks out, every volcano on earth erupts at once and our planet flies straight to the center of the sun. All of this because a light switch didn’t do its job properly. We cannot waste another second - let us join forces in a rebellion against the source of all evil!

If you have the exact same thought in mind as me or fight for an even greater cause, you are at the right place. Controlling home devices using relay modules is fairly quickly built up. We only need a few hardware components which don’t take too long to assemble and the code to control our system is a handful of Python lines.

Warning: You will be working with mains electricity which can seriously injure you. Please use extreme caution and if you’re not absolutely certain, ask someone who is. Saving one or two questions isn’t worth endangering your life.

Overview

Figure 1: Setup overview

In the previous posts we have been implementing Google Assistant on a Raspberry Pi and use it to run shell commands using our voice. I will use that setup to switch different devices with voice commands but naturally you will be able to execute the Python script any way you want. This post only covers the hardware installation with the relay module up to the execution of the controlling script. If you want to know how to run the script with your voice, please refer to my previous guide.

For this project you need:

a Raspberry Pi or any other single-board computer with GPIOs containing a 5V pin
a 5V relay module. The module I use it similar to this one and I have seen boards with 1/2/4/8/16 channels.
Jumper wires (example). Depending on your single-board computer, you either need Female-Female or Male-Female wires.
Voltage tester

Step 1: Wiring relay module with Raspberry Pi

Note: In this post I will use the American terminology for the switches. Refer to this page for their alternate names.

The relay modules we use will typically contain a mechanical metal switch which is controlled by an electromagnetic coil. Upon feeding power through the coil, the switch is moved to its alternate position. For the ceiling lights, we can use this three-way switch (SPDT) to keep the manual switches intact when adding the voice control feature. But this will heavily depend on how your lights switches have been wired up. Some will have the lights and switched directly connected to the mains, while others have a separate circuit for the switches and thus safer system for the installer. Either way, you should disconnect the power source by shutting off the appropriate breaker or fuse in the fuse box. More on this later.

We will start off by connecting the relay module with the Raspberry Pi. Locate the set of pins that contains a GND, VCC and a IN# pin for every channel on your module. We connect the GND pin with a ground pin and the VCC with a 5V pin on the Raspberry Pi. Then connect a GPIO pin from the RasPi to the input pin of the channel you want to control. E.g. I used the GPIO2 pin to control the relay on channel 1, like so:

Figure 2: Wiring between relay module & Raspberry Pi (Source)

Step 2: Connect with target device

Next, we hook up the device we intend to control to the relay. Wiring with ceiling lamps is a bit tricky, so we will use a simple power strip for now. If you want to know how to connect your ceiling lights, refer to the appendix.

We will have to cut open the power strip wire, so ideally you want to use an old power strip which needs a “new haircut” anyway.
Cut the power strip cable into two parts. Depending on what type of cable you have, you will find three wires: Blue(Neutral), Brown(Live/Line/Hot), Green/Yellow(Earth/Ground). Remove approx. 1cm insulation from each of all six ends and twist the ends. Reconnect the Neutral and Earth wires with connector blocks and plug the Live wires into the relay block. It doesn’t really matter which sockets you use as long one wire goes into the middle socket:

Figure 3: Wiring power strip with relay module

Make sure no wires are exposed at the joints. Best put the relay module in a small box.
Once everything looks tidy and ready, plug the power strip into the wall socket and your target device into the power strip.

Step 3: Operate relay with Python script

Time to peck some keys. Logged into your trusty Raspberry Pi and install RPi.GPIO if you don’t have it yet:

sudo apt-get update && sudo apt-get install python-rpi.gpio

If you are running Python 3, use:

sudo apt-get update && sudo apt-get install python3-rpi.gpio

Create a file in a location of your choosing and name it something like relay_on.py (although we don’t really have an “on” and “off” state, it’s simply two different states whose function will depend on how and what you plugged into the relay blocks). This file should contain the following:

import RPi.GPIO as GPIO

# refer to pins by the "Broadcom SOC channel" number
GPIO.setmode(GPIO.BCM)
# set GPIO2 to output
GPIO.setup(2, GPIO.OUT)
# set to False to turn on relay
GPIO.output(2, False)

Run the script with python relay_on.py to test your setup.
Change the number in GPIO.setup() and GPIO.output() of both scripts if you selected a different pin to control the relay channel. If your device still wont turn on, try changing the boolean value in GPIO.output() to True. This will depend on which relay sockets you chose.

Note: In Python you can choose between GPIO numbering (GPIO.BCM) and physical numbering (GPIO.BOARD). The first option uses the labels as the computer sees them while the latter counts the pins across as you see them. If you use this script on different Raspberry Pi models, you might want to the physical numbering system, which didn’t change over the different models.

Create a second file named e.g. relay_off.py which contains:

import RPi.GPIO as GPIO

# refer to pins by the "Broadcom SOC channel" number
GPIO.setmode(GPIO.BCM)
# set PIN 2 to output
GPIO.setup(2, GPIO.OUT)
# set to False to turn off lamp
GPIO.output(2, True)
# clean exit by resetting all ports used
GPIO.cleanup()

Change the values accordingly based on which pin(s) and relay sockets you chose.

If you can run [shell commands with your voice], you can now tell your digital assistant to run the Python scripts after specific voice commands. Smooth!

Appendix: Ceiling lights circuit

First we need to determine what kind of circuit you have within your walls, except if you wired everything yourself - but then again you probably wouldn’t read this part if you did.
There are a lot of ways to setup a lighting system. I will list the most common systems I encountered and write how to add our custom switch to it. When dismantling the light switch from the wall, you should be able to determine which system is installed in your room.

Warning: Remember to turn off the appropriate breaker or fuse in the fuse box before tinkering with the light switches.

Two-way switch

Figure 4: Circuit with two-way switch

This is the simplest layout and unfortunately you wont be able to just add a custom switch while leaving the existing one operational (at least I wasn’t smart enough to come up with a solution). You either would have to replace the existing switch, which means if the voice switch fails, you wont be able to control the lights. Otherwise you could replace the two-way switch (SPST, single pole single throw) with a three-way switch (SPDT, single pole double throw) and run two wires between it and the relay block. The resulting circuit would look similar to the Figure 5 below, without SW2 & SW3 and e.g. SW4 replaced with the relay switch. The wire from the lamp would go into the relay’s middle socket while the two wires from the three-way switch in SW1 would go into the left & right socket.

Serial lighting circuit

Figure 5: Serial circuit

If you already have a circuit with multi-way switches in your room, we can reconstruct a four-way switch (DPDT, double pole double throw) with two relay blocks to get a component similar to SW2 and SW3. Plug each of the two wires coming from SW1 into the middle slots of separate relay blocks. The two wires from the next switch (e.g. SW2) go into the left and right slot of one relay channel. From the same slots you run two additional wires into the second relay channel but interchanged, i.e. left from the first into the right of the second and right of the first into the left of the second. As always, a picture is worth a thousand words:

Figure 6: Relay blocks in a serial lighting circuit

In the Python script, set both relays to the same boolean value at the same time to simulate a four-way switch.

Parallel lighting circuit with relay unit

Figure 7: Parallel circuit

Note: The voltage values in the upper circuit are just an example. It could even have a higher value if you are working on an unusual system. Check if it is VAC first. If your multimeter says 0V, then it is probably VDC. The other way round is also applicable.

This one is fairly simple to set up. Every time the upper circuit is closed, a relay unit switches its state and opens or closes the lower circuit.
We install one relay block in parallel to one of the switches. One wire from each connector on the switch go the middle and an arbitrary side socket of the relay block.
To toggle the lights, you close the circuit once and open it after a short delay. Example Python script:

import RPi.GPIO as GPIO
import time

# refer to pins by the "Broadcom SOC channel" number
GPIO.setmode(GPIO.BCM)
# set GPIO2 to output
GPIO.setup(2, GPIO.OUT)
# close circuit
GPIO.output(2, False)
# small delay, otherwise relay wont register value change
time.sleep(0.5)
# reopen circuit
GPIO.output(2, True)
# clean exit
GPIO.cleanup()

This concludes the relay module implementation with single board computers. Have fun tinkering and always stay safe! I would love to hear about what you put together. See you next time!

Run shell commands and boot your computer with your voice

2017-08-02T00:00:00+00:00

Combining Google Assistant, IFTTT and Home Assistant provides us access to a powerful tool: Voice-activated shell commands. No more getting up from the couch and physically control devices. Calories have rights too and we should stop burning them. Let’s go!

IFTTT stands for “If This Then That” and is a web-based service which enables a large variety of applications to communicate with each other. Conveniently for us, it supports both Google Assistant and Home Assistant - an open-source platform which you can as a server on your computer (at the time of writing it supports Linux, Windows, OS X, FreeBSD) and is able to monitor and control your home automation devices. But the main feature of interest for us in this post is the ability to run shell commands.

The implementation of the Home Assistant wasn’t quite intuitive, so I will provide a clear step-by-step guide to the best of my writing skills. If you are running a Debian-based OS like I do (Raspbian), this guide should be a perfect fit for you. I haven’t tried this setup on other OSs but it should work on everything that can run Python 3. Alright, enough with the introduction, our homes are eagerly waiting to be made alive!

Overview

Needed for this project:

Computer which runs the Google Assistant and can run Home Assistant, e.g. Raspberry Pi 3 running Raspbian Jessie. Additionally, internet access and peripherals to record and play audio
(Optional) A computer that supports Wake-on-LAN for booting from the network

The second computer is for me to demonstrate the functionality of the shell command feature. But also since its base unit is cramped somewhere under my desk guarded by a cable clutter and a potential army of spiders, I might as well have a small upgrade in quality of living. Naturally you can use any other shell command such as touch ~/test.txt to test the functionality.

Step 0: Prerequisites

You first need a device running Google Assistant. Google provides a great guide on how to install it. You can take a look at this post for more details - I guarantee it wont bite!

Step 1: Install Home Assistant

Similar to the Google Assistant installation, I will install the Home Assistant in a Python virtual environment again so it wont mess with any existing Python installments. If you prefer a different installation method, check out this page.

[IMAGE: screenshot of Home Assistant installation in Terminal]

As usual, we start by getting all packages up-to-date from the command line:

$ sudo apt-get update && sudo apt-get upgrade

Install & update Python 3, pip and the virtualenv tool afterwards:

$ sudo apt-get install python-pip python3-dev
$ sudo pip install --upgrade virtualenv

The Home Assistant server will be constantly connected to the internet, so it is a good idea to create a separate user for it to limit its permissions. This part could introduce complications to the implementation, but security is a value worth fighting for!
Add a system user and a group to your system:

$ sudo adduser --system homeassistant
$ sudo addgroup homeassistant

We will need a directory to store for the virtual environment and the server files and you can choose whichever location you prefer. As an example I will use the directory suggested in the documentation. Afterwards we need to grant our new user full access to the directory:

$ sudo mkdir /srv/homeassistant
$ sudo chown homeassistant:homeassistant /srv/homeassistant

Once this is done, we will switch to the homeassistant user and create a virtual environment in which the Home Assistant is installed:

$ sudo su -s /bin/bash homeassistant # -s option specifies a shell in which we will operate. By default, system users don't have a shell.
$ virtualenv -p python3 /srv/homeassistant # create virtual environment
$ source /srv/homeassistant/bin/activate # change into virt. env.
(homeassistant)$ pip3 install --upgrade homeassistant

Now you can start Home Assistant while in the virtual environment with

$ hass

If you are outside of the environment, run these lines which can be saved in a bash script:

$ sudo su -s /bin/bash homeassistant << EOF
$ source /srv/homeassistant/bin/activate
$ hass

Or alternatively simply run:

$ sudo -u homeassistant -H /srv/homeassistant/bin/hass

To see if the Home Assistant server is running, launch http://<Rasperry-Pi-IP>:8123 on another computer in your web browser or http://localhost:8123 if your Raspberry Pi has a GUI and a web browser.

Figure 1: Home Assistant, up and ready

You can close the server for now with the shortcut Ctrl + C.After we adjust the Home Assistant configurations, we should specify what shell command to run and then copy-paste a few lines to setup IFTTT with the rest, which should be smooth sailing. Arr!

Step 2: Home Assistant setup and shell command services

The link to the IFTTT service demands that our Home Assistant server is exposed to the outside world. As such we need to tend to the server security for a bit.

Open the configuration.yaml file found in ~/.homeassistant of in homeassistant’s home directory. By default the full path is /home/homeassistant/.homeassistant/.

$ cd /home/homeassistant/.homeassistant/ # run as user homeassistant
$ nano configuration.yaml

Add a password for the Home Assistant web interface in the following entry:

http:
  api_password: <your-ingenious-password>

Note: Make sure to include keep the indent of two spaces which are crucial for the YAML language and add them if you want to add new configuration variables.

Note: Unfortunately this wont be enough to secure our server. The connection to it is unencrypted and we have to make web requests which target an URL that contains our password in plaintext.
Additionally, since our Internet Service Provider will change our external IP in random intervals, we will have a difficult time keeping our setup running without adjusting the configurations every now and then. But luckily we can set up encrypted communication by using HTTPS and dynamic DNS service. The latter will assign a static URL to your external IP address and whenever it changes, your device will tell the DDNS service to assign the URL to your new IP address.
For the sake of briefness I will leave this part out for this guide and will at a later point write on how I set up these components. We will focus on getting the system up and running for now. Meanwhile here is a great guide on how to use DuckDNS and Let’s Encrypt to solve the dynamic IP issue and implement encryption: I’m a fancy guide.

Add this line at the end for the shell command service:

shell_command: !include shell_commands.yaml

This will read the configuration for shell commands from a file called shell_commands.yaml. It is good practice to split up the configuration file into multiple files for readability and manageability.

In the same directory as configuration.yaml we create and edit a new file:

$ nano shell_commands.yaml

Then add a shell command of your choice using the format <command-name>: <shell-command>.

test_cmd: touch /home/homeassistant/.homeassistant/test.txt

Save and reboot your Home Assistant server.
Log into the web interface with the password you wrote into configuration.yaml. In the sidebar on the left under Developer Tools, click the left-most button which reads “Services”.

Figure 2: Services menu of Home Assistant web interface

After choosing shell_command in Domain you should be able to see and select your custom shell command, e.g. test_cmd. Test the shell command by clicking CALL SERVICE down below and check if the shell command was executed.

Figure 3: File test.txt sucessfully created by shell command test_cmd

Note: If Home Assistant did not properly execute the shell command, check if homeassistant has the ownership of all necessary files.
[IMAGE: screenshot of ls -lh in /home/homeassistant/.homeassistant/]

Too many notes: If you want to boot your computer using a shell command, there are a lot of online guides on how to set up Wake-on-LAN. I am using the wakeonlan package for example. I could write a quick guide on this too on demand, although in the end the exact details depend on your OS, network adapter and motherboard.

Almost there! Now that we got the shell command service running, we only need to link IFTTT with Home Assistant & Google Assistant and finally create an IFTTT applet to run the whole setup.

Step 3: Link the Good, the Bad and the Ugly

Head over to the IFTTT web page and create an account.
Click on the My Applets tab and create a New Applet.

Figure 4: Create a new applet in IFTTT
Click on this

Figure 5: It wasn't obvious enough..
Search and connect with “Google Assistant” (grant permission to the Google account you use with Google Assistant)
Choose the trigger “Say a simple phrase”
Write a custom voice command phrase and a response phrase for the Assistant

Figure 6: Words can hurt
Click on that. Search, select, connect to “Webhooks” and click on “Make a web request”.
In URL, type:
http://<Raspberry-Pi-IP>:8123/api/services/shell_command/<command_name>?api_password=<your-password>,
e.g. http://192.168.1.101:8123/api/services/shell_command/test_cmd?api_password=PASSWORD
Choose POST for Method, application/json for Content type and click on “Create action”. Click on “Finish” to complete the Applet.

In the final part we need to enter the API key from IFTTT into the configuration.yaml file of our Home Assistant server.

Still on the IFTTT webpage, navigate to “My Applets” > “Services” > “Webhooks” > “Settings”.
Copy the letter-number-jumble at the end of the URL

Figure 7: IFTTT API key
Head over to the configuration.yaml file of Home Assistant and append a new entry:
```
 ifttt:
   key: <your-API-KEY>
```

At long last, boot up your Google Assistant and say the magic words to run your shell command.

This has been quite a ride! From here on out the possibilities are endless. One of the many ways to impress your friends (and enemies?) is controlling your home devices’ electricity with your voice. Join me when we use relay modules and a couple wires to toggle ceiling lights, wall outlets and more!

Custom audio response for Google Assistant

2017-07-30T00:00:00+00:00

Our custom Google Assistant trigger opened up many possibilities for starting a conversation with the Assistant. But without any display on the headless Raspberry Pi, it is hard to know whether the trigger has been registered and when we can start making our voice request.
In this post we will provide the Google Assistant with a custom audio response. This can be anything from a beep tone, a spoken “Listening”, “Yes Sir” to “Sorry buddy, not today!”.

The problem with playing an arbitrary audio file while using Google’s gRPC API as in the previous post, is that it blocks our audio output device so that other applications aren’t able to access it while the streaming runs. One more or less inelegant solution would be to tap into this audio stream and push the frames of our custom audio response. Afterwards we release it for the Assistant to use as usual.

Requirements

You can find the necessary files in this Git repository: link. It also contains scripts from the Bluetooth remote implementation which we will use as an example script to implement our custom response.

Step 1: Extract frames from audio file

I will use the default beep sound from the Google Assistant on Google Home or Android devices, uploaded in the Git repo as beep-response.wav. We can handle WAVE files in Python using the wave module. Add import wave to the script to use it.

Note: When selecting a custom audio file, keep in mind that it has to have a sample rate of 16kHz. The stream used by the Assistant is configured sample at this rate.

The file is first converted into a wave_read object from which we can extract the frames for later use:

# load audio response file as a wave_read object
wavep = wave.open('beep-response.wav', 'rb')
# number of frames in audio response file
num_frames = wavep.getnframes()
# get frames from wav file
resp_samples = wavep.readframes(num_frames)

The sequence of frames contained in resp_samples can be written directly onto the conversation_stream object in the sample script.

Step 2: Play audio file

Before forwarding the frames we need to activate the audio stream which is a private member of the conversation_stream object, meaning we can’t activate it directly. And here comes the inelegant part: the audio stream can be activated using the start_recording() function. We will hold the input channel with stop_recording(), start the output channel with start_playback() and are then able to write our frames onto the stream. Finally the stream is inactivated and released for the Assistant to use.

stream = conversation_stream

# [...]

# announce listening phase with audio response
stream.start_recording() # activate audio stream
stream.start_playback()
stream.stop_recording()
stream.write(resp_frames) # write response frames to output stream
stream.stop_playback() # inactivate audio stream

Add the lines before assistant.converse() is executed to get a response whenever the Assistant is about to recording your query.
You can find my implementation in the file pushtotalk_resp.py.
Whenever you trigger a request you should now hear your custom response first, before the Assistant starts recording with the announcement “Recording audio request”.

If you have a better way of playing a custom response, I would love to know! Happy hacking and hopefully I will see you next time when we integrate IFTTT and Home Assistant to the system to run shell commands via Google Assistant.

Start Google Assistant via Bluetooth Remote

2017-07-28T00:00:00+00:00

After successfully running the Google Assistant on the Raspberry Pi, we proceed with initiating a voice command with a Bluetooth remote. The motive behind this is that even though starting a query with a hotword is a great feature, we might not want the Assistant to always listen - especially if you tend to paranoia like I do. We could instead physically start a conversation and preferably from any part of the house.
One quite cheap solution that I found is using Bluetooth remote buttons that cost less than two bucks online and with Bluetooth LE the electricity bill will be happy too. Additionally it is easy to carry around, e.g. with your key ring. Four birds with one stone? So many birds!

Overview

Figure 1: Setup overview

Pretty much the same setup as the previous part.

Hardware:

Bluetooth remote controller (example)
Raspberry Pi 3 Model B running Raspbian Jessie
Speakers with 3.5mm jack
Microphone with 3.5mm jack
3.5mm to USB audio adapter to plug the mic into the Raspberry Pi
Notebook running OSX 10.11

Software:

a couple of scripts I wrote/modified and uploaded on Github (link)

Step 1: Connect Bluetooth remote

To link our remote we can use the bluetoothctl command in the Terminal. The Bluetooth module should already be installed in the latest release of Raspbian, but if it is not, you can install using sudo apt-get install pi-bluetooth.
We can start scanning for the remote as follows:

$ bluetoothctl
[bluetooth]# agent on
[bluetooth]# default-agent
[bluetooth]# scan on

Figure 2: Scan for Bluetooth devices ... successful!

Note: You might need to run sudo bluetoothctl, depending on your user rights.

Note: If the Bluetooth module can’t find anything, try restarting the Bluetooth daemon: sudo systemctl restart bluetooth. Or if it wasn’t running in the first place, use sudo systemctl start bluetooth to start it and sudo systemctl enable bluetooth to run it automatically at boot time.

The device should show up as AB Shutter 3 or similar. Let us take a closer look:

Figure 3: Bluetooth remote details

It is registered as a keyboard. We should keep this in mind if we later want to control the Google Assistant with it. Time to connect to it:

[bluetooth]# pair <device MAC address>
[bluetooth]# trust <device MAC address>
[bluetooth]# connect <device MAC address>

Figure 4: Successful link with AB Shutter 3

Note: You can use tab completion and don’t need to type in the full address. Use pair and trust for it to automatically reconnect in the future and connect to complete the connection.

Step 2: Test Bluetooth remote input

Now we can test whether the device is properly connected and we can use it like a keyboard. I put together a short Python script which uses the evdev package. Thanks to Jon Burgess for providing the base code!
Switch to the virtual environment which we created while installing the Google Assistant. source <path-to-environment>/env/bin/activate
I have mine in the home directory, so I typed source ~/env/bin/activate. In the environment, we install the evdev package using sudo pip install evdev.

Once that is done, the Python script is fired up: python3 Test_BT_trigger.py

Note: Make sure that the variable TRIGGER_DEVICE in the script contains the exact name of your device in case yours is named differently.

Comments to script: We basically load a list of input devices connect to our system and look for our trigger device by its advertised name. Once found, the device is grabbed/blocked so that other applications wont be able to use it simultaneously and then iteratively check for key events from it which we print out.

Figure 5: Testing output of AB Shutter 3

Apparently the keys simulate the “Enter” key and the “Volume Up” key. But that wont be a problem, as the grab() function prevents it from messing with other programs.

Before we continue, there are a couple of issues we should take note of: The device has to already be connected when starting the script, otherwise it will just quit after checking the device list once. Furthermore, when the connected device moves out of range or is turned off, the function read_loop() returns an IOError with “No such device”, which also quits the program. We will fix this when we combine it with the Google Assistant. Almost there!

Step 3: Triggering a Google Assistant query with the remote

Google provides us with a nice example to trigger requests pressing any key. Clone these files and run sudo apt-get install portaudio19-dev libffi-dev libssl-dev and pip install --upgrade -r requirements.txt to make sure you have all the necessary dependencies.

After that, run python3 pushtotalk.py from the files you just copied and press any button to test the sample.

Figure 6: Testing pushtotalk.py

Note: The SoundDeviceStream warning occurs when recorded frames are lost between reading iterations according to the sounddevice documentation. These can be ignored if they only occur when starting the program, as was in my case. If they turn out to be a problem, try increasing the iteration and block size and see if it helps, e.g. python3 pushtotalk.py --audio-iter-size=4000 --audio_block_size=8000. I got less frame losses after this but I couldn’t eliminate them completely.

Once this is done, we can modify the script to exclusively listen to our Bluetooth remote. The main part of interest in the script is in line 314:

...
while True:
    if wait_for_user_trigger:
        click.pause(info='Press Enter to send a new request...')
    continue_conversation = assistant.converse()
...

Instead of waiting for any arbitrary key, this is where the read_loop() function from the evdev package should run. If we receive a trigger event from the remote, e.g. the “Enter” key, the program continues by starting a conversation with the Assistant.

I split our previous Python script into two functions:

get_BT_device_list() which will return the Bluetooth device if it was found, else None
wait_for_BT_trigger(device) the device from the previous function is listens to the keycode 115 (which is the “Enter” key). We execute this in a “try-except” block to handle the IOError, so the program doesn’t exit once the device disconnects.

The first function is called once every 5 seconds to check if the device is connected. Once it is, we will start polling for the trigger key and start a conversation whenever it is pressed.
I uploaded the code as pushtotalk_BT.py into the Git repo. You will also need BT_trigger.py for to handle the Bluetooth remote.

Figure 7: She replied "Sorry, I don't understand"...

This concludes the Bluetooth remote feature implementation. I hope you didn’t mind the amount of detail.
See you in the next posts where I will add a custom audio response whenever a request is initiated and then combine the Google Assistant with IFTTT and Home Assistant to run shell commands using your voice!

Build a home assistant for less than 40 $

2017-07-24T00:00:00+00:00

With the Google Assistant SDK being released, speech-based home projects received a powerful new component in its arsenal and with this I thought it’s about time for me to jump on the home assistant hype train!
The Google Assistant will be implemented on a Raspberry Pi, which makes it a potentially more powerful and much cheaper system than the Google Home device and along with fun and joy we will hopefully learn a thing or two.

This project contains a variety of features among which are:

Google Assistant running on a Raspberry Pi (covered in this post)
Use a bluetooth remote to initiate request to Google Assistant (link)
Execute shell commands with Google Assistant + IFTTT + Home Assistant with voice commands (link)
Control home devices and ceiling lights with voice commands (link)

If you want to use this post as a guide or inspiration for your own projects, I am going to assume that you are already somewhat familiar with Linux systems and the Raspberry Pi, although I will try to mention all important details on what I did. Alright, let’s get right to it!

Overview

Figure 1: More cables than components

A quick overview on what components I used for this setup:

Raspberry Pi 3 Model B running Raspbian Jessie
Speakers with 3.5mm jack
Microphone with 3.5mm jack
3.5mm to USB audio adapter to plug the mic into the Raspberry Pi
Notebook running OSX 10.11
at least one finger

Step 1: Preparation & SSH connection

To start off, we first need to install the Google Assistant on a Raspberry Pi which will be the main focus of this post. Google provides a great guide for the installation, I started off here.
Conveniently, I already have a Raspberry Pi 3 Model B with Raspbian Jessie installed which I use for my home surveillance system. I will access my headless Raspberry Pi via SSH, so except for the power supply no additional wiring will be necessary for now, when using the WiFi connection - gotta save the cable clutter for later!
With the option to comfortably control the Raspberry Pi from my notebook, I connect to it via SSH in Terminal.

Step 2: Audio configuration

The audio input and output can be set by editing the file ~/.asoundrc. With the commands arecord -l and aplay -l, we can find the card/device numbers of the desired input and output devices respectively:

Figure 2: List of input and output devices

Choosing my USB dongle as input and the 3.5mm jack as output, my .asoundrc file is changed accordingly:

Figure 3: Content of .asoundrc

$ speaker-test -t wav # test output
$ arecord --duration=5 -f S16_LE --rate=16k ~/test.wav # test input
$ aplay ~/test.wav # check recording

All good? Onwards!

Step 3: Create Google Developer Project & configure Google account

This step is fairly straight-forward: follow this
We need to create a Google Developer Project, grant the Raspberry Pi access to the Google Assistant API by downloading a client secret JSON file. Since I downloaded the JSON file on my notebook, I have to transfer the file on my Raspberry Pi via SFTP (e.g. using FileZilla) or alternatively by simply executing in the Terminal:

$ scp <path to file>/client_secret_<client-id>.json pi@<raspberry-pi-ip-address>:/home/pi/

After enabling all necessary activity controls, we arrive at the final step.

Step 4: Install Google Assistant SDK and run demo

Again, the guide is quite thorough in the last step. If the Assistant responds to the voice command Hey Google or Ok Google, we are ready to proceed to the next exciting part: Start a conversation with a bluetooth remote

If you later want to come back and test the Assistant, execute on the Raspberry Pi:

$ source ~/env/bin/activate
$ google-assistant-demo

Figure 4: Google Assistant Demo

Feel free to post questions/comments/suggestions and let me know if you run into any trouble!