IoT Pet Monitor!

Keep an eye (er, ear) on your beloved bbies while you are away! This project monitors the volume of sound in your home and if your pet gets too anxious and starts barking or making other loud noises, soothe their sad lil’ soul by turning on music or your own (pre-recorded) voice!

This tutorial will show how to build this project using a Raspberry Pi computer to monitor sound in your home (via the Cloud) to see if and when your pet is upset.

Along with the Pi (and speakers), we’ll use the SparkFun MEMS microphone breakout board to measure volume levels and trigger the audio player. Data is uploaded to the CloudMQTT service using the MQTT communication protocol.

Total Read Time: 8 min.

Total Build Time: 60 min. (less if you are experienced)

Suggested Reading

To build this project, you’ll need a fully configured, WiFi-connected Raspberry Pi 3 computer with ​Raspbian OS. It’s also helpful to know some ​Python programming as well as the following things: (1) how to use and control the Raspberry Pi GPIO pins; (2) MQTT communication; and (3) analog sensors. If any of this is unfamiliar, or if you’re just curious (be curious!), check out the tutorials below!

Raspberry Pi 3

  1. ​Raspberry Pi 3 Starter Kit Hookup Guide
  2. ​Raspberry Pi GPIO
  3. ​SPI Communication with the Raspberry Pi

MQTT Communication Protocol

MQTT (Message Query Telemetry Transport) is a popular IoT communication protocol. We’ll use the Paho Client Python library and an MQTT service called ​CloudMQTT. Here’s more about MQTT and how to use it:

  1. Exploring Communication Protocols for IoT
  2. Getting Started with CloudMQTT
  3. ​Overview of Eclipse Paho MQTT Python client library

MEMS Microphone Breakout Board

The MEMS microphone is an analog microphone, so we’ll need an Analog-to-Digital converter (“ADC”) to read in the analog signal with the Raspberry Pi digital GPIO pins.

  1. Getting started with the SparkFun MEMS Microphone Breakout Board
  2. ​MEMS Microphone Datasheet
  3. MCP3002 ADC Datasheet

 

Materials

Raspberry Pi 3 Model B

We’ll also need the following peripherals: ​Raspberry Pi 3 Case​SD Card (minimum 8 GB); ​Raspberry Pi 3 GPIO cable; ​MicroUSB power cable; HDMI cable and ​HDMI-compatible monitor; USB keyboard; USB mouse; speakers with 1/8″ headphone port.

​SparkFun MEMS Mic Breakout Board

​MCP3002 (Analog-to-Digital Converter)

​Breadboard & ​M-to-M Breadboard Jumper Wires

 

Configure the Raspberry Pi

Step 1: Check & Install Updates
Checking for and installing updates is always a good way to start. Run the following commands in the terminal window:

    sudo apt-get update
    sudo apt-get upgrade
    sudo reboot

Step 2: Set up SPI Interface for MEMS Microphone + MCP3002

To use the SPI (Serial Port Interface) to read in the MEMS Microphone via the MCP3002, we’ll need the Python Dev Package:

    sudo apt-get install python-dev

We’ll also need the SPI Interface (may want to create a subfolder to save this in):

    git clone git://github.com/doceme/py-spidev
    sudo python setup.py install

Here’s the SPI-Dev Documentation if you run into any issues.

Step 3: Playing Sounds with OMXPlayer

The OMXPlayer is an audio and video player pre-loaded on Raspbian OS. It works with most sound file types, including: .wav, .mp3, and .m4a. This is what we’ll use to play back sounds when Fido gets too loud. The Python library to control the OMXPlayer is included in Raspbian (woo!).

To test the OMXPlayer from the terminal, type the following:

    omxplayer /home/.../SongFilePath/SongFileName.mp3

If that doesn’t work, try forcing it over the local audio-out device:

    omxplayer -o local /home/.../SongFilePath/SongFileName.mp3

Step 4: Configure CloudMQTT Server

Now we set up an MQTT server! To do this using CloudMQTT, do the following:

  1. Set up a CloudMQTT account (the “Cute Cat” plan is free).
  2. Create a new MyCloud instance.
  3. In the Console, create a new ACL rule.
  4. You can monitor published messages in the “Websocket” UI.

 

Finally, install the MQTT Paho Client Python library:

    pip install paho-mqtt


Build it! Hardware

Here’s a pinout for the Raspberry Pi 3:

1. Insert MCP3002 pins into breadboard. Here’s a pinout for this board:

The MCP3002 uses 4 SPI pins for communication: Serial Clock (“SCL”), Master Input Slave Output (“MISO”), Master Output Slave Input (“MOSI”), and Chip Select (“CS”). These pins correspond to Raspberry Pi GPIO pin 11 (SCLK), GPIO pin 9 (MISO), GPIO Pin 10 (MOSI), and GPIO Pin 8 (CE0).

Make the following connections with MCP3002 pins:

  • ​Connect Pin 1 to Raspberry Pi GPIO Pin 8 (CE0)
  • Connect Pin 2 to the analog output of the MEMS Microphone breakout board
  • Connect Pin 4 to GND
  • Connect Pin 5 to Raspberry Pi GPIO Pin 10 (MOSI)
  • Connect Pin 6 to Raspberry Pi GPIO pin 9 (MISO)
  • Connect Pin 7 to Raspberry Pi GPIO Pin 11 (SCLK)
  • Connect Pin 8 to Raspberry Pi 3.3V out

2. Solder wires to the MEMS Microphone breakout board. Connect to MCP3002 and Raspberry Pi.

  • ​Connect Vcc to Raspberry Pi 3.3V.
  • Connect GND to Raspberry Pi GND
  • Connect AUD to MCP3002 Pin 2

3. Plug in all the cables for the Raspberry Pi and turn everything on.

 

Build it! Software

Our goal with the Bark Back is twofold: trigger a playback sound when the dog barks, and send the data to a server where we can check it.

Here’s the ​open-source Python program for this project. Feel free to (and please do) adjust and modify the code

To get the program up and running, you need to fill in two things:

songList: Write in the file path and file name for each of the songs you want to play.

creds: Input your CloudMQTT information in this dictionary.

Step 1: Read in the SparkFun MEMS Microphone breakout board.

Read in the ADC value (between 0 and 1023) from the MEMS Microphone breakout board (via the MCP3002) using the SPI library and calculate the signal peak-to-peak amplitude.

Map the signal peak-to-peak amplitude to a Volume Unit. The current code maps the ADC range between 0 and 700 (based on quick experimentation) to a Volume Unit between 0 and 10. To adjust the sensitivity of the microphone, adjust the ADC input range.

For a thorough overview of the MEMS mic, ​check out this tutorial.

Step 2: Trigger audio player.

First we’ll need songs to play! You can quickly record sounds in GarageBand (or on your smartphone) and send ’em to the Raspberry Pi. In Python, use the subprocess library to call the omxplayer.

In the code, input the file path of the songs you want to play back in the *songList* variable (line 26). The current volume threshold is set to 7 in the main function.

Step 3: Send data to CloudMQTT Server

Use the ​Paho Client Python library to communicate with the CloudMQTT servers. To broadly summarize: Set up a Client server; define communication protocols; connect with our credentials (aka creds); and subscribe and publish our data. Most of this is done in the main function (lines 129 – 149, and lines 169 – 174).

To check on received data, go to the “Websocket UI” tab in the CloudMQTT console.

 

Test & Install & Enjoy!

Run the BarkBack.py program in Terminal or in the Python IDE (you can also use SSH to run the program after you’ve already left).

Check that you are getting volume levels in your Websocket UI tab.

Test the system by triggering the mic (clap, yell, bark, etc.) to be sure that the speakers play through all of the sounds.

Once everything is up and running, it’s recommended to solder the components to a PCB (Printed Circuit Board) if you intend to install the system for more than just a few days.

 

Project Extensions

1. Add in an RPi camera module to include video.
2. We’re already connected to the IoT, so why not throw in some more sensors! For example, you could monitor hazardous gases (perhaps methane?).
4. Prefer a reward over barking back? Create an automatic treat dispenser to reward your pet for being quiet for a few hours. Here’s a candy-dispensing tutorial for inspiration and to help get you started.
5. Share your findings and adaptations in the comments below!

Happy building!

Interactive Survey Game!

A survey questionnaire come to life! Use (nearly) any object to gather helpful data through an interactive, engaging, and fun multiple-choice survey.

This project uses the Makey Makey microcontroller in combination with a Raspberry Pi computer to read in participants’ survey choices and save the results in a text file.

Planning & Design!

This general design is easily customized to fit a different theme. The only crucial design requirement is to use materials that conduct electricity for the survey pieces, or wrap non-conductive materials in aluminum foil.

Suggestions:
Prototype, prototype, prototype! Build different versions and test them on family, friends, co-workers, or (ideally) your target audience. Observe how folks interact with your survey, then use that to make it better! And always remember to keep it simple 🙂

Materials

Makey Makey Kit
– Computer: Raspberry Pi

– One (1) ground piece, five (5) survey response pieces, one (1) submit piece, and two (2) yes/no pieces*

22 Gauge (stranded) Wire — five (5) 10 – 16″ strips and three (3) 6″ pieces (ends stripped)

– Container:

— Wood Box (12.5″ x 12.5″)
— Plexliglass.(“12 x 12”)
— Three (3) 2″ x 2″ wood panels

* Specific materials used in this design are detailed with the corresponding procedure, although customization is encouraged!

Tools

Safety goggles, woo!
Multimeter
— Optional: Soldering iron, solder& desoldering wick
— Ruler (or calipers)
Drill w/ both drill and driver bits
Flat wood file (to prevent splinters!)
Hot glue gun
— Epoxy (permanent)
– Pliers

Reprogram the Makey Makey

To reprogram the Makey Makey, you’ll need to have the Arduino IDE with Makey Makey drivers installed. Here’s a thorough tutorial on how to do this.


1. Plug Makey Makey into computer and open the Arduino IDE.

2. Open (or copy) Makey Makey source code:
Here’s the GitHub page for the Makey Makey.
Here’s a direct link to download the full program. This is a .zip file, so be sure to extract all the files.

3. Reprogram the “click” key into an “enter” key.
For a thorough overview of how to do this, check out this tutorial.

4. Change the following keys:
These two keys are mapped in the survey program, but can be left as-is or you can choose to switch other keys (e.g. the arrow keys). Just be sure to change the mapping in the program.

A. Change the “g” into an “n”.
B. Change “space” key into “y”.

Build the Survey Response Pieces!

Specific materials used in this design:

– Two (2) wood blocks, two (2) golf balls, and one (1) jar lid.
– Aluminum foil
Unistrut 1/2″ Channel Nut with Spring
– Ten (10) 1/2″ washers
– Plexiglass [or wood] (12″ x 12″)

Procedure:

1. Wrap each of the survey response pieces at least 2 – 3 times with foil, hot gluing each layer.

2. For unistrut spring pieces, hot glue (or epoxy) the top of the spring to the bottom of each survey response piece — be sure that the metal of the spring is touching the foil of the survey piece.

3. Attach the survey pieces to plexiglass.

Determine location of survey response pieces and mark with tape. Drill a hole at each point.

Place a washer on either side of the hold and screw bolt into unistrut spring about 3 turns.

4. Connect a wire to each of the unistrut spring pieces.

Wrap wire around base of bolt (between washer and plexiglass). Hand tighten the bolt to secure wire without squishing it

Build the Ground Piece!

Specific materials used in this design:
– Styrofoam ball
– Metal pipe
– Flange stand for pipe
– Aluminum foil
– Twelve (12) washers
– 4 wood screws
– Wood panel (2″ x 2″)

Procedure

1. Build a stand for the styrofoam ball — use conductive materials or wrap pieces in foil.

2. Wrap styrofoam ball in aluminum foil, leaving a “tail” of foil. Place ball on stand and push the foil tail against the inside of  Hot glue pieces together.

3. Cover the exposed end of the ground wire (24″) to the inside, or bottom, of base and adhere with tape or epoxy.

5. Add a layer of two (2) washers under base to avoid squishing the wire, then connect base to wood pane via screws or epoxy.

Build the Enter Key!

Specific materials used in this design:

– Clothespin
– Wood panel (2″ x 2″)
– One (1) wood screw + one (1) washer

The screw should be about 1/4″ longer than the wood thickness.

– Aluminum foil

Procedure:

1. Wrap one of the handles of the clothespin in foil.

2. Remove clothespin spring clamp, align other side of the clothespin on wood panel, and drill in a screw and washer.

Foil on the other side of the clothespin should make contact with the washer + screw when closed.

3. Reconnect spring clamp and other side (may need pliers). Epoxy bottom of clothespin to wood panel.

4. Use alligator clip or wrap wire around screw and secure with hot glue.

Make the Yes and No Keys! 

Specific materials used in this design:
– Two (2) plastic container lids
– Two (2) wood panels (2″ x 2″)
– Two (2) wood screws and washers

Each screw should be about 1/4″ longer than the wood thickness.

– Aluminum foil


Procedure

1. Cut circle out of container lids. Wrap in foil.

2. Align lids on wood panels and drill in a wood screw with washer on top — be sure the screw slightly pokes through the back of the wood panel.

3. Use alligator clip or wrap wire around screw and secure with hot glue. 

Connect Pieces to Makey Makey

1. Connect ground piece lead to Makey Makey ground pads.

2. Connect survey game pieces to the first five (5) Makey Makey back header pins on the left: “w”, “a”, “s”, “f”, and “d”.

3. Connect the no button to the last (6th) back header pin, “g”

4. Connect the yes button to the “space” pads.

5. Connect the submit piece to the “click” pads.



Load the Survey Program!

Using a Raspberry Pi computer means that all of the electronics can fit into the game box! Write up a program in Python to cycle through a series of survey questions and five possible choices that map to the survey response pieces.

Here’s my code:
GitHub page!
Python program only.

Final Touches & Case!

This case is designed to withstand high traffic, experimentation, and children — and to be easily (and cheaply) fixable and adjustable. Use this design or customize your own!

Materials:
12.5″ x 12.5″ wood box
1″ x 10 ” wood panel

Procedure:
1. Epoxy wood panel onto front of box.

2. Drill the submit, yes, and no keys into the wood panel.


Recommended to put the “submit” button on the far right (switched this after further testing and feedback).

 

3. Drill hole large enough to fit an HDMI port in the back panel of the box.

I used two 3/8″ bits and filed down the hole until the HDMI port fit.

4. Label the survey game pieces and the submit, yes, and no keys.

Test, & Install!

Connect the Raspberry Pi to a monitor, keyboard, and the Makey Makey. Test the program and double check all the keys. Once everything is up and running, remove the keyboard (and mouse if connected).

Load the python program, stand back, and let passersby have a blast participating in a survey!