Using whatsapp for home automation - The parser

Last time we saw how to install Yowsup on our Raspberry Pi and use the python script yowsup-cli to send and receive messages.

Now it's time to use it for something useful.

With the new Yowsup 2 you cannot use yowsup-cli to send and receive the messages. This is both a good and a bad news. The bad part is that you need to create the classes as described in the author's site, or to modify the existing demos.
The good part is that we will have much more control over the whole system we are creating and everything will be integrated in the script, without the need to execute something external.

To make it easier for my readers, I created two files (modifying the original Yowsup demos) with the needed classes for sending and for receiving Whatsapp messages via Yowsup. You can download them here:

http://www.mascal.it/public/wasend.py
http://www.mascal.it/public/wareceive.py

To use Whatsapp for home automation we need to create a parser. There are many ways to create such task and some are smarter and more powerful than others. We will see just a simple one.

Before everything, let's put these functions to make things easier:

def credential():
    return "391122334455","whatsapp_password"

def Answer(risp):
    try:
        stack=YowsupSendStack(credential(), ["390000000000", risp])
        stack.start()
    return

The first function is used to return your RPi phone number and the password for Whatsapp, so there is no need to read the configuration file (just get the two strings from that file). The second function will send a text to the specified number using the Yowsup classes. Let's go on with the parser...

First of all an infinite loop that will contain our parser (note that at the top of the script there must be the header with the all the declarations that I will skip to concentrate only on the main parsing cycle):

while True:

Than let's check for a received message:

    try:
        stack=YowsupReceiveStack(credential())
        stack.start()
    except MessageReceived as rcvd:

The receiving class will execute and terminate after a few seconds if nothing has been received. In case of a message incoming, it raises a MessageReceived exception.
When this happens, we can just read the value of the exception that will contain what we are looking for. To make it easier to create the parser let's convert the whole string to lowercase:

        received=rcvd.value.lower()

Now let's check if the message has been received by our phone number and not from someone else:

        if received[:len("390000000000")]=="390000000000":
            received=received[len("390000000000"):]

If the number is correct I will strip it off from the string to have just the message. In case the number is not the right one we could append to a log file for inspection. At the end of this post there is a full listing of the script, with the logging statements.

Now we can start parsing the message. We can just search for specific text inside the message and act consequently. Let's start with a simple test that will answer "Hello" when receiving "Hello":

            if received[:5]=="hello": Answer("Hello!")

With this statements we are checking if the received message starts with "hello". Note that case is ignored because we converted everything to lowercase and also note that we could write whatever we like after "hello". We could have sent something like "hello my raspberry pi" and the message would have been correctly interpreted.

Ok, now let's try to do something a bit more useful. Shouldn't be nice if we could update our RPi with just a message? Just add this line after the "hello" test:

            elif received[:6]=="update":
                Answer("Updating...")
                os.system("sudo apt-get -y update")
                Answer("System updated!")

Here we check for the "update" text at the beginning of the received message. If found RPi answers with the text "Updating...", it performs an update without asking for confirmations and at the end it informs us that the update has been completed.

To keep the parser clean, it would be advisable to use functions. So before the main loop we could have something like

def UpdateFunc():
    Answer("Updating...")
    os.system("sudo apt-get -y update")
    Answer("System updated!")
    return

and the parser would become like this:

            elif received[:6]=="update": UpdateFunc()

What if we wish to execute something by different words? For example we could wish to make the RPi restart by sending "restart" or by sending "reboot". Actually that's quite easy:

            elif received[:7]=="restart" or received[:6]=="reboot": RestartFunc()

and we will have the following function declared:

def RestartFunc():
    Answer("Restarting the system...")
    os.system("sudo reboot")
    return

Now we try to manage a message where the expected word could not be at the beginning of the text. As an example we could ask fot the RPi internal temp with messages like these:

• Temperature?
• What is your temperature?
• Is your temperature too high?

and so on. To accomplish this task we can just check if the word "temperature" is inside the message with this test:

            elif "temperature" in received: TempFunc()

and the function would be:

def TempFunc():
    t=float(subprocess.check_output(["/opt/vc/bin/vcgencmd measure_temp | cut -c6-9"], shell=True)[:-1])
    ts=str(t)
    Answer("My temperature is "+ts+" °C")
    return

The word could be everywhere inside the message and the function will be executed anyway.

At the end of the parser there should be something to inform us about unrecognized statements, so we can put a statement like this:

            else: Answer("Sorry, I cannot understand what you are asking for...")

This ends the first part about using Whatsapp for home automation. We saw how to make a simple parser to recognize words (or small sentences) and execute some task according to these words. Actually there is still no real home automation, but we will see something more complex on next post.

Below You can see the Python script with all the above sections:

import os, subprocess, yowsup, logging
from wasend import YowsupSendStack
from wareceive import YowsupReceiveStack, MessageReceived

def credential():
    return "391122334455","whatsapp_password"

def Answer(risp):
    try:
        stack=YowsupSendStack(credential(), ["390000000000", risp])
        stack.start()
    except:
        pass
    return

def UpdateFunc():

    Answer("Updating...")

    os.system("sudo apt-get -y update")

    Answer("System updated!")

    return

def RestartFunc():

    Answer("Restarting the system...")

    os.system("sudo reboot")

    return

def TempFunc():

    t=float(subprocess.check_output(["/opt/vc/bin/vcgencmd measure_temp | cut -c6-9"], shell=True)[:-1])

    ts=str(t)

    Answer("My temperature is "+ts+" °C")

    return

while True:

    try:

        stack=YowsupReceiveStack(credential())
        stack.start()
    except MessageReceived as rcvd:

        received=rcvd.value.lower()

        if received[:len("390000000000")]=="390000000000":

            received=received[len("390000000000"):]

            if received[:5]=="hello": Answer("Hello!")

            elif received[:6]=="update": UpdateFunc()

            elif received[:7]=="restart" or received[:6]=="reboot": RestartFunc()

            elif "temperature" in received: TempFunc()

            else: Answer("Sorry, I cannot understand what you are asking for...")

        else: #message from wrong sender

            with open("/home/pi/whatsapp.log","a") as mf: mf.write("Wrong sender: "+received[:len("390000000000")]+"\n")