(Quick & Easy) Micro:Bit Magic 8 Ball Costume

90s kids unite! And build this super fun, easy, and interactive costume!

Ask a (yes/no) question, shake the Micro:Bit, and it displays a fortune (obviously accurate) to your deepest most pressing questions, like what is life, how do we solve climate change, and why are pineapples so difficult to cut open. Except you’ll do a better job with phrasing your questions as yes/no 🙂

Anyway….

Here we go!

Read Time: 7 min.

Build Time: < 30 min.

Project Cost: $15 – $20

Materials

  • Micro:Bit 
  • 2xAAA Battery Case
  • 2 AAA Batteries (plus some extras if you plan to wear the costume for more than 3 hours)

… Seriously, that’s it!

Oh, and to make it all aesthetically pleasing and on point:

  • Cardboard (like a 4″ x 4″ square)
  • Blue Paint

Step 1: Program the Micro:Bit!

Step 1: Go to www.MakeCode.org and open a new Micro:Bit project.

Step 2: Write a program to display randomly generated messages of your choosing!

Need more info? Here’s a more detailed overview 🙂

Go to Variables and create a unique variable for each message you want to send (e.g. msg1msg2, …msg42, etc).

Go to Inputs and drag out the On shake block. In On shake, add “set item to” from Variables, then go to the Math blocks and connect the “pick random 0 to..Change the random number range (i.e. the 2nd number) to reflect the total number of messages you are showing (e.g. if you have 5 messages, the random number range is 0 to 4 because there are 5 possible numbers: 0, 1, 2, 3, 4).

Almost done! Add an “If – Then” from Loops. In the first if, set the condition to: item = 0, then display the first message (“show string” block w/ the variable name for your first message (e.g. msg1)). Recommended to repeat the message at least once ’cause scrolling letters can be hard to read! Repeat the if statement condition for each random number and message, and viola, c’est fini! You can test the code in the simulation on the left side of the screen by clicking the Play button and then Shake (:

When you’re ready, download the code, plug in your Micro:Bit, and then drag the (.hex) file onto the Micro:Bit drive. The code is loaded when the power lights are done flashing!

Step 2: Optional Triangle Cover

Step 1: Make a cardboard triangle & paint it blue!

For most accurate imitation, go for an equilateral triangle (geometry for the win, woot woot!).

Step 2: Cut a 1 in. x 1 in. (2.5 cm x 2.5 cm) hole in the center for Micro:Bit LEDs.

Step 3: Attach Micro:Bit on back of triangle w/ glue or tape.

If using hot glue, avoid the battery and USB connector.

Step 4: Wear it & Share it, pretty bby!

Attach the Micro:Bit (& cardboard combo) to yourself or your clothes! You can use velcro, tape, or hot glue (although probably avoid using this one on your actual skin..) Or make straps w/ string, twine, fabric, etc!

Put on your favorite black outfit & you’re done! Quick & awesome & comfy Halloween costume for the winnnn 😀

Feel free to ask any questions in the comments section. If you build this or a variation, please share your creations, I’d love to see what you make!!

Make a Minecraft Gesture Controller!

Move your body to play Minecraft! What!! Yes. Check the video for a demo 🙂

This tutorial will show you how to make your very own gesture game controller for Minecraft (or your other fav. computer game). Move your hand(s) to walk/run/jump, look around, and attack* all the things!

Let’s get started! Grab yourself a Circuit Playground Expresssnag my program code, and get shakin’ to play Minecraft in (srsly) the most fun way ever! 😀

Read time: 20 min

Build Time: ~ 2 hours

Cost: ~$30

*It is a biiiiit tricky to attack moving things (like monsters), so be careful in survival mode! Or use this to challenge your skills 🙂

Materials

Tools

  • Sewing Needle
  • Scissors
  • and a lil’ patience.. 🙂

 

Build the Glove Controller!

You can make the gesture controller without the glove, but the glove controller makes it easier to play, keeps the CPX in the same orientation (very important), and means you can use your fingers as added controls!

1. Cut rectangles of conductive fabric for the finger pads (~ 0.5 in. x 1 in.).

2. Use regular thread to sew the conductive fabric pads onto each of the glove fingers.

Suggested to use a highlighter or other pen to avoid sewing the two sides of the glove together (learn from my mistakes bbies).

3. Attach CPX to the glove with velcro squares.

4. Use an alligator clip or insulated wire to connect the CPX ground (“GND”) to the thumb pad.

5. Stitch conductive thread from the CPX capacitive touch pads (A1, A2, A3 & A4) to each of the four fingers.

6. If you have a multimeter, check continuity between the CPX pins and the conductive thread pads.

Plan out your controller!

 

First! What do we need to do to control Minecraft (or another awesome game)?

This is a super helpful & fun lesson in Design Thinking, but you can skip this if you want to just use my controls. You can always come back here later if you want to make changes later 😀

1. Determine (crucial) game controls.

Note: Start simple! Figure out the most important controls for the game and start there. You can always add more later.

Here are the controls that I wanted to use while playing Minecraft.. in creative mode 🙂 (you can use the same ones or customize your own controller!):

Movement:

  • Walk forward: W key
  • Run: Ctrl + W
  • Jump: Space bar
  • Look Left & Right: Mouse rotate
  • Walk backward: S key

Actions:

  • Attack: Mouse Left Click
  • Place Block/Push/Open: Mouse Right Click
  • Inventory: E key
  • Escape: ESC key

2. Decide how you want to use gestures and/or the finger pads to trigger these controls. Recommended to sketch out your plan.

Here is my design thought process:

I’ve always wanted to feel like I was actually *in* a game, so I went the “cheap VR” route and used gestures to control basic movements. For walking, I went the “let’s move my arms like I’m walking” route, which easily transitioned into running and jumping by increasing the speed of motion.

To make it easy to place a block or exchange items, I decided to use an “awkward handshake” motion.

Turning was a bit of a challenge, but my goal was to be able to look around by moving my hands in the direction I wanted to look.

Attack became the pointer finger pad, inventory the middle finger pad (which I ended up removing), Escape the ring finger pad, and the pinky finger pad to let me to walk backwards.

Again, you can keep these same controls or design your own 😀

Let’s get programming: Set up the CPX!

1. If you’re using Windows, download the Adafruit Windows Drivers here.

2. Download & save the latest CPX Circuit Python UF2 file.

3. Plug in the CPX with a USB cable (make sure it has data transfer capabilities).

4. Double-click the reset button on the CPX.

The LEDs should turn green. If they are red, it means something is wrong with data transfer to the CPX — check the USB cable, try another USB port on your computer, or try the trusty “unplug and plug back in” method.

5. On your computer, you will see a new disk drive called “CPLAYBOOT”.

6. Drag the CPX Circuit Python UF2 file onto the disk drive.

7. The “CPLAYBOOT” drive will disappear and be replaced with “CIRCUITPY”.

 

Add all the libraries!

Libraries let us access all sorts of special functions for the CPX without having to do a ton of programming.. hooray for open-source! This install will download most of the standard Circuit Python libraries* so peruse them at your leisure to learn about more cool things you can do!

1. Download and save the Adafruit Circuit Python Library Bundle Release from here.

2. Unzip the folder, open the first folder, and copy the “lib” folder onto the “CIRCUITPY” drive.

*It is unlikely that you’ll run out of space since the CPX comes with at least 2MB of Flash storage. But, if you do end up needing more space, you can revisit the libraries and remove the ones you don’t need. If you mess ’em up, just copy and paste the lib folder again.

 

Writing the Controller Code

The CPX has an on-board compiler, which means you can program it in (pretty much) any language you want! I opted for MicroPython, a version of Python for microcontrollers, ’cause Python is awesome.

Read this step if you want to understand how the program works (definitely suggested) or if you want to modify the code.

Here’s the GitHub repository that has the full code.Download it, drag it to your CPX, and rename the file “Code.py” (here’s the raw code if you want to just copy & paste).

1. To do the things I mentioned in the last step in MicroPython, we need the following libraries:

  • LIS3DH accelerometer

    • This allows us to use motion to trigger various things.
  • Human Interface Device (“HID”) keyboard

    • This library allows us to control the keyboard!
  • HID mouse

    • This library means we can control the mouse!
  • CPX capacitive touch
    • This library lets us use the capacitive touch feature on the CPX, hooray!
  • A couple of other libraries to make our lives easier: timebusio, and board.

2. Configure and initialize the libraries.

Assign variables for the keyboard, mouse, and accelerometer objects. Select a range for the accelerometer.

3. Write short functions for each of the controls.

The motion controls can be tricky. Do some initial testing with the accelerometer by printing the values in a serial monitor (in the source code, go to the __main__ function and uncomment the two debugging lines). This will help you to determine thresholds for walking, running and jumping, looking left and right, and placing objects.

The touch pad triggers are much easier as you are only looking for a capacitive trigger (True/False).

Remember to release all of the keyboard and mouse keys at the end of each function!

Debugging: Seeing what’s up the CPX program

If you’re familiar with Arduino, you’re probably familiar with the Serial Monitor. The CPX has the same feature with a slightly different access point depending on what program you are using.

If you are using Mu it’s super easy: the serial console is built in and will automatically detect your board, yay!.

If you are using Idle or another program, follow these steps:

1. Download PuTTY* here.

2. Go to Windows Device Manager and check the serial port number for the CPX (e.g. COM18) — see Photo below.

If there are multiple serial ports listed, unplug the CPX and plug it back in to see which one disappears then reappears.

3. Open PuTTY and select “Serial”.

4. Enter the serial port number (e.g. COM18) under “Serial line” and the baud rate of 115200 under “Speed”.

5. Click Connect! 

*PuTTY is a free and open-source SSH and telnet connection program.

 

Test & Improve

Load the program onto the CPX by dragging and dropping the python file onto the CIRCUITPY drive, then rename the file as “Code.py”

Like pretty much every project, this one will likely be a little wonky when you first get it running. If the touch pads are acting strange, reset the CPX (this recalibrates the capacitive input pins).

Test 1:

– Open up the serial monitor with PuTTY and run the program (CTRL + D)

– Test each of the movement controls (you’ll see the mouse moving on the screen and make sure the program doesn’t crash as well as the touch pads (which should display relevant text on the serial monitor).

Test 2:

Deploy in Minecraft creative mode! Test the movement and action controls to see if anything breaks or doesn’t work as expected (plz keep in mind that this is a prototype)

Update the program based on your testing. Remember, it’s OK if it’s not perfect, there’s always time to make it better!

 

Have all the fun!!

You’re ready to run through Minecraft!! Just be wary of monsters, it might be a bit tricky to protect yourself..

Supplementing your gesture controller with a keyboard is a good idea if you want play for reals 🙂

Please like and/or leave a comment if you enjoyed the tutorial! And of course, let me know if you have any comments or questions!
Happy Building!

<3, jenfoxbot

Turn your Pi into a (local) Cloud Server!

Save and access docs and photos and music on your own local Pi Cloud* server! The best part: you can use it if, or when, the Internet goes down (or if you’re in a remote spot & want access to Wikipedia). Oh hey, and if your friend gets one and they live close (*ahem*80ft*ahem*), you can share stuff with them and make your own personal chat line!

That gets me thinking.. if enough folks built Pi Cloud servers, we could crowdsource the Internet! That would be an 11/10 on a scale of greatness. With the new models of the Raspberry Pi computer, it’s possible and not even expensive! (What! Tell me more!)

This tutorial will show you how to set up a short-range (~ 80 ft) WiFi Access Point and a personal web server (‘bringin it back to HTML bbies). You can set this up as a (closed) local network only (i.e. your own personal “cloud” backup device), or broadcast it to the rest of the world! (..if you do this be sure you know network security.)

That said, assuming you have a basic knowledge of the Pi, here’s the breakdown:

Read Time: ~ 40 min

Build Time: ~ 60 min (less if you are experienced w/ Linux)

Cost: ~ $35 (for the Pi 3)

If you are interested in using this to crowdsource a people’s Internet, share it w/ your friends & family & everyone you know (or build it for them!). If you build this project please mark that you’ve built it so we can get a sense of how many folks have the infrastructure we need to actually make a full-fledged people’s Internet. Lastly, follow me to stay updated (I am reaching out to some folks to try to get this to be a real thing, please feel free to contact me if you can help and/or take this on, it is open-source!).

 

New to Linux & Terminal Programming?

We’ll need to be able to access our Pi remotely (e.g. via SSH). If you’re like “wtf is that”, check out this introductory tutorial for a more thorough overview on how to set up the Raspberry Pi 3 and some quick Linux terminal programming.

This approach to the Pi Access Point* and web server** uses the Jessie Lite OS. If you follow this tutorial line-by-line, you will need this specific version of Linux.

Lastly, this tutorial is built off of the Adafruit Digital Free Library tutorial, so check that tutorial if you run into any issues (or leave a comment and myself or another helpful folk will attempt to answer your question 🙂 )

(Also, this might feel a bit long, so I’ve included various cute puppy photos throughout to keep you motivated :D)

*An Access Point is hardware device that allows a WiFi device (e.g. smartphone) to connect to a wired network (e.g. router).

**A web server is a computer that delivers a web page. When you go to your favorite websites, you type in “www.wikipedia.org” which takes you to the IP address for the web server and displays public information.

Warning: it is recommended to run your Pi as a local network only (i.e. do not connect the Pi to the broader World Wide Web) as the WPA2 password protocol may not be secure.

Materials

– Computer with Ethernet port & SD Card slot

– Raspberry Pi 3

– SD Card (8GB or larger, esp. if you want to use it for storage)

– MicroUSB to USB power cord

– Ethernet Cable

– RecommendedRaspberry Pi Case

Software Programs

1. PuTTY allows us to remotely log in to the Raspberry Pi using the Pi’s IP address, username, and password.

Download here: ​http://www.putty.org/

2. Etcher formats and writes the Raspbian (or other) Operating System (“OS”) to an SD card.

Download here:​ https://etcher.io/

3WinSCP allows for easy file transfer between your computer and the Raspberry Pi.

Download here (click on Installation Package): ​https://winscp.net/eng/download.php

4. Windows computers will need Bonjour print services for Windows (from Apple) to use the “raspberrypi.local” IP address.

Download here: ​https://support.apple.com/kb/dl999?locale=en_US

 

Quickstart

If you’ve worked with the Pi before and are comfortable w/ the Linux terminal and such, here’s a quick overview of this process:

1. Load Jessie Lite onto an SD card (8GB or more) and insert into the Pi.

Download the Jessie Lite OS here.

2. Remotely log in (e.g. SSH) and enter credentials.

3. Here’s a Github repository with all of the commands to turn your Pi into a web server 😀

Go through the Setup file and input the commands (in order). This process will install HostAPD (authentication), DHCP (IP management), iptables (firewall), and Apache (web server software).

4. Create a public web page or keep your files/data private/w/ friends & family.

A sample HTML web page adapted from the Adafruit Digital Free Library tutorial is included in the Github repository (ServerWebsiteHTML-Raw). You can also use the larger zip file to build off of 🙂

Warning: it is recommended to run your Pi as a local network only (i.e. do not connect the Pi to the broader World Wide Web) as the WPA2 password protocol may not be secure.

 

Set up the Raspberry Pi

1. Flash the SD card with Jessie Lite (​download Jessie Lite here). Enable SSH by adding a file named “SSH” in the SD card file contents (no extensions — remove the .txt if any added automatically). Insert into the Pi.

2. Plug in the Ethernet cable between your computer and the Pi, then plug the Pi power cable.

3. Create a network bridge between your computer and the Pi.

Go to Settings -> Network & Internet -> Change Adapter Settings. Select the Ethernet connection (should show an unknown connection or something similar). Hold the “CTRL” key, and then select the WiFi connection. Right click and choose “Bridge Connections.”

3. Open PuTTY, type “raspberrypi.local” for the hostname, and log into your Pi, woo!

If you are logging in for the first time, use the default username: pi and password: raspberry . Change your password using the command passwd .

4. Check that the Pi is connected to the Internet and update it.

Run this command to check if the Pi can connect to Google (it will print 5 lines saying it if received information from google.com):

ping -c 5 google.com

Run this command to update the Pi:

 sudo apt-get update
 sudo apt-get upgrade

Install Apache

Apache is our web server software! (It allows us to easily host information and files accessible via a web browser like Chrome, Firefox, Explorer, etc.).

Let’s install the Apache software and then change permissions to edit the HTML folder. Type and enter the following commands (in order):

sudo apt-get install apache2 -y
cd /var/www
sudo chown pi:pi /var/www/html
cd

Install Server Software!

1. Install HostAPD and DHCP software.

HostAPD is used to authenticate information sent and received from connected devices, and DHCP is a protocol used to provide quick, automatic, and central management for the distribution of IP addresses within a network.

To install both at once, type the following command and then press “y” to continue:

sudo apt-get install hostapd isc-dhcp-server

2. Install iptables for a firewall. (yayy for security!)

Run this command and type “y” (yes) to both of the config screens that pop up:

sudo apt-get install iptables-persistent

Edit the DHCP Configuration File

Let’s set up the DHCP communication protocol so we can send and receive information (pretty important if you’re thinking of building a connected network)! Go to the DHCP configuration file by typing the following:

sudo nano /etc/dhcp/dhcpd.conf

1. Add a comment (“#”) in front of the following lines (so it looks like the file in Photo 1):

option domain-name “example.org”;

option domain-name-servers ns1.example.org, ns2.example.org;

2. Remove the comment (“#”‘) from the “authoritative” line (Photo 1 also helpful here):

#If this DHCP server is the official DHCP server for the local network, the authoritative directive should be uncommented.

#authoritative;

3. Add this code to the very end of the file:

subnet 192.168.42.0 netmask 255.255.255.0 {    
    range 192.168.42.10 192.168.42.50;     
    option broadcast-address 192.168.42.255;
    option routers 192.168.42.1;
    default-lease-time 600;
    max-lease-time 7200;
    option domain-name “local”;
    option domain-name-servers 8.8.8.8, 8.8.4.4;
}

What is this doing?! To (very briefly) summarize, it sets up a range of IP addresses to assign to connected devices (from 192.168.42.10 to 192.168.42.50), just like your home router! It also tells the Pi how to communicate to other devices (its broadcast address, 192.168.42.255, and its own IP address, 192.168.42.1). It assigns an amount of time (in sec) to share this connection (lease time), and sets up domain name servers (like looking up a phone number in a directory).

4. Save and exit by pressing “Ctrl – X” and then “y” (and then the enter key).

Edit the Default DHCP Server File

Let’s edit the DHCP server file so that we can assign it to broadcast via WiFi! Go to the DHCP default server file by typing the following:

sudo nano /etc/default/isc-dhcp-server

1. Scroll down to the line that says INTERFACES=”” and change it to broadcast via wlan0 (that’s a zero, not an O):

INTERFACES=”wlan0”

2. Save and exit by pressing “Ctrl – X” and then “y” (you’ve probably figured this out key combo by now so I’ll stop mentioning it 🙂 ).

 

Set Up a Static IP Address

1. Let’s give our Pi a static (unchanging) IP address so that we can always find it, yay! Temporarily disable the wireless interface network:

sudo ifdown wlan0

2. Use the nano text editor program to edit the network interfaces file (which you probably figured out by reading the command (: )

sudo nano /etc/network/interfaces

3. Edit the file so that it looks exactly like the following, then exit & save (also check out the photo below):

auto lo
iface lo inet loopback
iface eth0 inet dhcp
allow-hotplug wlan0
iface wlan0 inet static
    address 192.168.42.1
    netmask 255.255.255.0
#iface wlan0 inet manual
#wpa-roam /etc/wpa-supplicant/wpa_supplicant.conf
#iface default inet dhcp

4. Assign a static IP:

sudo ifconfig wlan0 192.168.42.1

Configure the Access Point Details

1. Create a new configuration file named “hostapd”:

sudo nano /etc/hostapd/hostapd.conf

2. Write the following (exactly as-is) in this new configuration file (then exit & save) (see photo below):

interface=wlan0
ssid=HelloWorld #Name of your RPi WiFi connection
country_code=US #Unless you are elsewhere!
hw_mode=g
channel=6
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2 #This is the password protocol
wpa_passphrase=raspberry #Change the password!
wpa_key_mgmt=WPA-PSK
wpa_pairwise=CCMP
wpa_group_rekey=86400
ieee80211n=1
wme_enabled=1

3. Tell the HostAPD protocol where to find this new file.

Edit the default HostAPD file:

sudo nano /etc/default/hostapd

Find the line that says #DAEMON_CONF=””. Remove the comment and edit it so that it looks like this (see photo below):

DAEMON_CONF=”/etc/hostapd/hostapd.conf”

Edit the HostAPD initialization file:

sudo nano /etc/init.d/hostapd

Find the line that says DAEMON_CONF=. Edit it so that it to point to your new configuration file! Like this (Photo 3):

DAEMON_CONF=/etc/hostapd/hostapd.conf

Configure Network Address Translation (“NAT”)

This step allows for multiple clients (like all your friends!) to connect to the Pi’s WiFi at once (play all the games!!). It is a bit technical, so I’m gonna gloss over the deets (also not terribly familiar with this part), but it will get you through the process.

Note: you only need the iptables shenanigans if you want to connect your local access point to the greater World Wide Web.

1. First, we need to start IP forwarding every time the Pi turns on. Enter the following command to edit the sysctl* configuration file:

sudo nano /etc/sysctl.conf

— Scroll to the bottom and type this code on a new line, then exit & save:

net.ipv4.ip_forward=1

*btw that is an L in sysctl, not a 1, which I have messed up soooo many times -.-

2. Activate IP forwarding by typing:

sudo sh -c “echo 1 > /proc/sys/net/ipv4/ip_forward”

3. Create network translation between the Ethernet port eth0 and the WiFI port wlan0 by typing the following commands (w/ – signs and caps and such):

sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT
sudo iptables -A FORWARD -i wlan0 -o eth0 -j ACCEPT

4. To ensure network translation happens when we reboot the Pi, run this:

sudo sh -c “iptables-save > /etc/iptables/rules.v4”

Test that Access Point!

1. Run hostapd with our configuration file manually with this command:

sudo /usr/sbin/hostapd /etc/hostapd/hostapd.conf

2. Check the WiFi list on your computer or smartphone and find your new access point SSID! If you didn’t change anything, it will be named “HelloWorld” with a password of “Raspberry”.

If you connect successfully, you will get some text on the Raspberry Pi screen. We won’t see much yet, but we are very close!

3. Cancel the test by typing “Ctrl+C” in the Raspberry Pi console.

You can check the status of the host AP server and the DHCP server with the following commands:

sudo service hostapd status
sudo service isc-dhcp-server status

 

Set up a Daemon!

A daemon is a program that starts automatically every time the Pi is powered on and runs in the background (not quite like the “His Dark Materials” series..).

1. Start the hostapd and dhcp programs:

sudo service hostapd start
sudo service isc-dhcp-server start

2. Run these next two commands to enable hostapd and dhcp to start automatically when the Pi turns on:

sudo update-rc.d hostapd enable 
sudo update-rc.d isc-dhcp-server enable

Almost there! Create an HTML Web Server!

1. Write an HTML page to host on your web server! Or download one I adapted from the Adafruit Digital Free Library 🙂

Here’s the zip file, and here’s the GitHub repository. Save and unzip the file.

2. Open WinSCP and enter the hostname: raspberrypi.local

3. Log in to the Pi (type the username and password).

4. On the Pi side of the screen (right side), go to the home directory.

Click the folder with the up arrow on it two times.

5.Go to the /var/www/html file.

Double-click on the folder labeled “var”, then the “www” folder”, and finally the “html” folder.

6. Delete the existing index.html file (or if you want to write your own you can just open and edit it).

7. Copy the web server files into the Pi html folder.

On the left side of the screen (your computer), go to the folder where you saved the files. Highlight and drag the contents (two folders and a file named “index.html”) into the Pi html folder. That’s it!

8. Open a browser and type “raspberrypi.local” in the navigation bar at the top. If it worked, you will see the web server page, what what!

Edit the HTML Pt. 1

Change up the HTML file to share the info and documents that you want!

1. Open the index.html file on the Pi.

2. Edit the headers and descriptors in the index.html file.

— Change the title of your web server by editing the text between the title parts:

<title> jenfoxbot's Local Web Server!</title><br>

— Change the heading of the webserver by editing the text between the h2 and center parts (line 51):

<h2> <center> 
jenfoxbot webserver
</center> </h2>

— Optional: Change the description of the webpage (line 55):

<pre><div><center>
<p>Depending on the position of the moon & stars*, 
this hotspot may or may not provide an Internet connection.</p>
<p> If there IS an Internet connection, check out <a href="http://www.foxbotindustries.com" style="font-size: 12.15px;">jenfoxbot's website</a> 
and learn about the other cool stuff she does! </p>
<p><i style="font-size: 12.15px;">*And by position of the moon & stars we mean the current whims of the builder, jenfoxbot :) </p> </i>
</center></div>

3. Optional: Delete existing documents, images, and videos and add your own!

Store PDFs in the “issues” folder and photos in the “images” folder. You can also create other folders to store different files.

Edit the HTML Pt. 2

1. Add your own documents!

— Decide what you want to include on your server and download PDFs of those docs. Also download images for each of the documents so you’ll have something fun to click on 😀

— Using WinSCP, add your documents to the appropriate folders.

— Edit the index.html or other appropriate html file (e.g. if you want to add or change a book in the helpful info page, edit the “helpfulinfo.html” file).  Display your documents and images by changing the file names and extensions and update the descriptions.

2. For folks new to code, you can add more documents by copying and pasting the existing code and changing the file names and extensions!

Here’s a helpful overview on HTML from the Khan Academy!

OMG Finally! We’re Done 🙂

Unplug the Ethernet cable, connect to your wireless access point, and then type in the IP address in the address bar of your favorite browser (192.168.42.1 if you followed this tutorial exactly).

If everything is working, you’ll see your web page (like the screenshots of mine above and below). Woohoo you just created a wireless access point!! (If it didn’t work, run through the setup again and double check that all the terminal code is exactly as shown, including spaces and such).

Explore your very own local Cloud website and decide how you want to use it from here!

What’s Next?

One option is to use it as a local wireless storage device. Plug in the Pi, connect to the WiFi access point you set up (this one is named “HelloWorld”), and store or withdraw files from it. You can access these files even if you are disconnected from the Internet. So you could save your favorite movie and still watch it when the power goes out 🙂 (er, assuming you have a charged laptop).

Add more documents (e.g. you can use it as backup storage), play around with the HTML code to make your site all fancy, and have fun!

Another option is to configure this as a public-facing web page and assign it a domain name so other people can access the files. This is particularly helpful if you are going somewhere without WiFi or cable Internet — you can take Wikipedia with you! (but maybe donate to them if you do that ’cause they are awesome). If you are comfortable with code, you can set this up to be an automatic backup server, a local wireless game server for you and your friends, etc. Get creative!

If you go this route, be sure you know a bit about network security as the WPA2 password protocol has recently been compromised (sad panda..).

Finally, as mentioned in the intro, you can use this Cloud server to kickstart a people’s Internet! Have a build day with your friends to create a bunch of Cloud servers so that you all can “talk” to each other! This approach isn’t necessarily the *best* (aka most efficient/effective) way to build a public Internet, but it’s a great starting point. Plus, the better we understand how these technologies work, the better we use them to solve serious problems and advocate for ourselves and our communities. 🙂

Micro:Bit Puppet “Text Message” System

Intro

Nearly all of our wireless communication is done using radio waves*, including phone calls, text messages, and WiFi. With its built-in radio transmitters and receivers, the Micro:Bit microcontroller makes it super easy to build all sorts of projects with radio communication.

This particular project is a simple & quick way to send text messages between two Micro:Bit** microcontrollers – the sender writes a (short) message that is transmitted via radio to the receiving Micro:Bit, which shakes a lil’ puppet using a servo motor, and then displays the message on the Micro:Bit LED screen. Each Micro:Bit can be both a sender and receiver.

It’s sort of like a two-person Twitter.. if the tweet notified you via dancing cardboard robot puppet!

*Radio waves are long-wavelength light waves. Check out the electromagnetic spectrum here!

**A huge THANK YOU to Adafruit for donating the Micro:Bit microcontrollers used in this project for educational purposes! yayy thank you for supporting this educational endeavor!! 😀

Materials & Tools

Electronics

Puppet (or other Message Alert System) Materials

Tools

  • Hot Glue Gun
  • Scissors and/or utility knife (e.g. exacto knife)
  • Pencil
  • Ruler or other straightedge

Build the Incoming Message Alert Puppet!

Step 1: Build a cardboard puppet like the one shown in the photo or create your own! Use the paper fasteners to make joints.

Step 2: Build a mounting system to attach the puppet to the servo with skewers and cardboard.

I used a magnet to attach the puppet to the servo mounting system because magnets are awesome, but you can also use glue, tape, velcro, or a variety of other adhesives!

Step 3: Build a stand for the puppet.

  • On an approx. 6 in. x 12 in. cardboard sheet, measure, mark, and cut a hole for the servo body so that the arms of the servo rest against the front of the cardboard sheet.
  • Cut two triangles out of cardboard and glue them on the back of the stand so that the stand, well, stands upright!
  • Cut a hole for the Micro:Bit wires to thread through and add two pushpins on the front to hold the Micro:Bit.

 

 

 

 

 

 

 

Code the Two Micro:Bits!

To start, choose one Micro:Bit to be the sender and the other Micro:Bit to be the receiver. Once both are working as expected, add in the code for both roles.

Use the Make Code Micro:Bit website to program each Micro:Bit. As this is intended as a beginner project, the whole system can be built using the block-based programming language, although adaptations are encouraged and appreciated!

If there is more than one pair of Micro:Bits in the room (i.e. in a classroom setting), remember to set different radio group numbers for each pair.

The sender sends a (short) text based on user inputs over radio, like the example above. Pretty simple!

The receiver moves the servo when an incoming text is received, then scrolls the message text on the LED screen, like in the example below.

Press the reset button to stop sending/receiving the incoming message.

 

Connect the Servo!

Connect the servo red wire to the Micro:Bit 3V power pin, the servo black wire to Micro:Bit ground pin, and the servo white (or yellow) wire to the Micro:Bit input pin P0.

Send all the Messages!

Program both Micro:Bits to be both a sender and a receiver so you can communicate back and forth. Then switch power from the laptop to the battery pack and test out your wireless communication system! When the sender sends a message, the puppet will notify you to check the LED screen so that you can see the incoming message.

How far of a range can you get? Test it out!

There are tons of other extensions to this introductory project, here are some possibilities:

  • Add more message options by adding more inputs or changing how those inputs are read;
  • Instead of a table-top alert system, build a wearable alert system;
  • Send voice messages and/or other sounds.

Happy building!

Anti-Facial Recognition Wearable No. 1

Every time we leave our homes, we are photographed and videotaped in public and private spaces. Facial recognition software identifies our unique facial features and can be used to tag us in photos that are taken with or without our consent. This tutorial is about exerting our right to control our personal privacy. It is our choice and our right to decide if we want to be identified by cameras that photograph us in public and private spaces.

There are many approaches to anti-facial recognition makeup/wearables. This is my first approach based on some background research, chatting with fashion-minded friends, and my own personal artistic and electronic interests.

The purpose of this project is to make it more normal (& fun!) to wear privacy enhancing fashion so that if/when it is needed, folks who are using it for legitimate protection are not targets.

Follow along or use this as inspiration for your own anti-facial recognition wearables! If you design your own, pleasepleaseplease share it in the comments so other folks can learn from and be inspired by you!

Difficulty: Easy

Build Time: 1 – 2 hours (+2 hours for glove controller)

Cost: < $15

Quick Overview of Facial Recognition Software

Computer Vision, or “CV” for short, is a software method that breaks down images into a series of black and white pixels, and then attempts to extract meaning from patterns in the pixels. Since human faces have the same characteristics (two eyes, nose, mouth, & chin), these characteristics can be broken down into patterns that a software program can look for.

For example, pupillary distance, or the distance between the pupils of each eye, varies from about 54 to 68 mm for adults – a CV program would look for black pixels separated by that distance range and log those as one layer. There are tons of patterns that a CV program can search for and locate, then go back and analyze the layers together to ensure they match up. All of these values are stored as variables that can be used for comparison with other images.

The more images a CV program analyzes, the better it gets. By comparing CV-found patterns to patterns in existing photos tagged on social media, CV programs may also tag an individual regardless of where that photo was obtained. CV programs are incredibly accurate, can select a face from multiple angles and backgrounds, and can identify a person’s emotions.

Check out CV Dazzle to learn more about anti-facial recognition makeup and other styles!

 

Materials & Tools

Materials

Optional glove controller:

Tools

  • Liquid Latex
  • Scissors
  • Wire Strippers
  • Soldering Iron (recommended for glove controller)
  • Hot glue gun (or other fabric-safe glue)

 

Step 1: Attaching the Flowers

Use the flowers to cover up distinguishing facial features. Eyes, eyebrows, and nose bridge are three primary regions of the face that are used by facial recognition software to identify and tag a face.

1. Cut flower stems off (unless you want ’em on for aesthetic purposes).

2. Pour a small amount of liquid latex into a container.

3. Figure out where you want to put the flower, then dab the base of the flower into the liquid latex. Let it dry for a few seconds, until it feels sticky and less liquid.

Be sparring with this stuff, it can be kinda painful to peel off, especially after 30 flowers.

4. Attach the flower to your skin. BUT FOR REAL THOUGH avoid your hair!! It is a huuuge pain (literally) to get out.

5. Repeat 2 & 3 until your face is adequately covered.

You can check your progress using a Snapchat or Instagram filter: If the filter can’t find your face or looks wonky (like sunglasses on your forehead instead of your eyes) then you’re all set!

 

Step 2: Adding LEDs!

To add freestanding LEDs, grab a coin cell, and push the two LED legs over the coin cell battery sides (longer LED leg on the positive battery side). Dip one side in the liquid latex, let dry for a few seconds, and then smoosh onto your skin just like with the flowers (again, avoiding precious and sensitive hair).

If you’re using the glove controller (see next step), run the LED wires up your arm to behind your ear, holding them in place with rubber bands or hair bands. Arrange how you want the LEDs to point, then pin the wires in place with bobby pins. That should be sufficient to hold them, if not add some liquid latex to the ends of the LEDs.

The LED + coin cell combo should last ~ 12 hrs.

 

Step 3 (Optional): Make a Glove Controller

This is a good option if you want to save battery life or to be able to turn on/off the LEDs. The thumb is the battery case, with conductive thread on the top as the positive connection. The fingers are the positive connections for the LEDs.

This takes ~ 2 – 3 hours to build.

1. Attach wires to the LED(s).

Measure out two (2) wires per LED to span from your head, down your neck, and to your wrist. Add 3″ to this measurement to allow for movement. Cut wires and strip both ends.

Mark the positive side of the LED with a pen, then twist one end of each wire around the LED leads. Solder the LED leads to the wire. Use a red wire, or mark the positive wire with a pen.

If available, use heat shrink tube to make a poke-less connection. Or just coat it in epoxy or hot glue or some other liquid adhesive.

Repeat for each LED you want to add to the glove.

2. Using conductive thread, make the negative side of the circuit: a negative connection for the coin cell and a “ground bar” for the LEDs.

Put on the glove, and mark where the center of the battery will go. Sew about 10 layers of conductive thread over your mark — this is the ground connection for the coin cell battery.

With the thread still attached, sew down to the base of the glove and stitch back and forth until there are a few layers of conductive thread in a line — this is the negative connection for the LED connections.

3. Make a coin cell battery case on the thumb of the glove.

Cut out 1 square of regular fabric, and 1 square of conductive fabric.

Cut a small hole in the regular fabric and then stitch the conductive fabric square over the hole (with regular thread). Run over this a few times since the conductive fabric tends to fray.

Using normal thread, sew 3 of the 4 sides of the regular fabric over the negative connection for the battery, so that it makes a lil’ pouch for the coin cell. (You might want to sew down the 4th side a bit to hold in the battery, or use a safety pin).

4. Attach the positive side of one LED to a glove finger and make a conductive pad.

Sew the positive LED wire onto the glove (regular thread)

Still using regular thread, sew a square of conductive fabric over the stripped end of the wire.

5. Attach the negative side of the LED to the glove ground pad.

Wrap the stripped end of the wire to the conductive thread ground pad and/or use conductive thread to secure it.

6. Repeat 4 & 5 for all LEDs.. or until you run out of fingers.

7. Epoxy or use fabric glue to adhere all of the connections.

 

Step 5: Test & Deploy!

Test your privacy enhancing getup by opening Snapchat or another filter app and check that it can’t identify that there is a face in the image. At the very least, if it does identify a face, be sure that the filter it adds is hilariously broken.

If you want to get real serious, you can download the OpenCV library and test it against your wearable — this is my long-term goal, but for now I’m happy with sticking flowers and LEDs on my face for V1.0.

Stay tuned for more of these anti-facial recognition wearables and please share your awesome creations!

Renewable Energy Technology: What is it and How to Use it!

Now more than ever, folks like you and me have to step up and take a stand to protect and preserve our environment (and, quite honestly, our species). One great way to do that is to incorporate renewable energy technology into projects that use electricity.

Even if the environmental aspect isn’t enough to get you on board, you should still use renewable energy tech because the simple truth is that eventually we will run out of coal and natural gas. Besides, renewable energy tech is cleaner and more cost-effective in the long term, AND it means that you rely less on external sources for electricity — super handy in case there’s a severe storm or a solar flare that temporarily knocks out your local power grid.

First of all, what is renewable energy technology? Basically, it encompasses any technology that generates (electrical) energy from effectively renewable sources. For example, from our perspective, the sun is essentially an infinite power source since it will be around long after we are gone and produces more energy than we could possibly hope to consume in our lifetime.

Coal and natural gas are NOT renewable because they are finite, meaning that there is only so much of it available for us to use. Once we’ve used it up, we’re pretty much sh** out of luck, as the saying goes.

Now that I’ve convinced you it’s a good idea to use renewable energy technology, what are your options and how do you actually go about incorporating them into your projects?? Well my friend, read on to find out! This is by no means an exhaustive list, but it does cover the most common and easily accessible types of renewable energy tech.

Also, this guide assumes you have a basic knowledge of electronics, so please ask if there is a term or concept that you’re unsure about and I’ll be happy to expand or provide you with more thorough resources. Happy building!!

Photovoltaic Panels (aka Solar Panels)

Solar panels are awesome! I put these first because they are one of the most common and, in my opinion, the easiest to incorporate into all kinds of different electronic projects.

How Solar Panels Work

Solar panels convert incident radiation (aka sunlight) into usable electrical energy via the photoelectric effect. Basically, a photon (light carrier particle) knocks into an electron and transfers its energy to the electron. By making solar panels out of special materials called semi-conductors, one with extra electrons and one with missing electrons (aka “holes”), the free electrons are attracted towards the positively charged material (and repelled by the negatively charged material). When an external load is connected across the solar panel, it creates an effective current.

Since the current output depends on the amount of sunlight hitting the panel, the highest power output occurs when the panel is in full, direct sunlight (and is free of dust and debris).

How to Use a Solar Panel

  1. First, solar panels output Direct Current (“DC”), which is ideal for computer/microcontroller projects. For household applications, you’ll need an inverter to convert the DC voltage into AC.
  2. Second, since we’ll only get energy generation during the day, we’ll (most likely) need to use a rechargeable battery to store the energy for use at all hours of the day and night. Calculate the battery capacity that you’ll need by multiplying the electric current consumption of your project by the number of hours it will be on and consuming power without any external charge. For example, if my project consumes 0.20 mA of current and I want it to be able to provide power all night (~ 12 hours), I’ll need a battery with a minimum capacity of: 0.20mA * 12 hours = 0.0024 Ah (2.4 mAh). Also, the battery voltage needs to be lower than the solar panel voltage for current to flow from the panel into the battery.
  3. Third, use a diode for trickle charging or a charge controller for higher power applications to protect the solar panel from backwards current flow.
  4. Finally, to choose the right sized panel, figure out how much power your project consumes (P = I * V) and pick a panel within a reasonable range. For example, the power consumption of a 5V, 0.50mA microcontroller is 0.0025 W, so a panel between 1W and ~ 7W would be more than sufficient. For larger power panels, be sure you have sufficient circuit protection to avoid blowing out your microcontroller or other electronic device(s).

For more information, here is a helpful guide.

Wind & Water Turbines

Wind and water turbines use pretty much the same mechanism to generate electrical energy, so I lumped ’em together. Of course, depending on what medium you’re using, you’ll want a different turbine size and shape.

How Turbines Work

Turbines are a mechanical device that rotate when an external fluid passes through the blades of the turbine, whether it’s water or wind (whoa what air is a fluid?! yes, yes it is :D). The turbine is connected to a drive shaft that spins an electric generator to produce electrical energy. 

How to Use Turbines

  1. Turbines are location dependent, so first you’ll want to figure out if it’s feasible: Do you have a stream, waterfall, or other moving water source nearby? Does the location of your project get steady wind?
  2. Turbines also output DC current, so you’ll need an inverter for household appliances.
  3. As with solar panels, you will likely want a rechargeable battery to store the power for use anytime during the day or night, regardless of weather conditions. Calculate your needed battery capacity using the same method as for solar panels.
  4. Use a diode for low-power projects and a charge controller for larger projects to protect the energy generator from backwards current flow.
  5. Determine the power output for your turbine by calculating the power consumption of your project in the same way that’s outlined for the solar panel.

There are tons of DIY wind turbine projects on the interwebs, including on Instructables! Find one that fits your project needs and try building your own!! 😀

Here’s a link to more information on wind turbines!

 

Thermoelectric Generator

Thermoelectric generators (“TEGs”) are super cool, but generally have a very low power output. That said, they are not weather dependent, don’t have any moving parts (aka are essentially maintenance free), and are very reliable. Thermoelectric generators can be super handy for small projects like charging smartphones or powering LEDs.

How Thermoelectric Generators Work

Ok, so these things are somewhat complicated — basically, special materials with high electrical conductivity and low thermal conductivity can generate an electric current when there is a temperature gradient (aka a temperature difference between one side and the other). So if you heat one side of the thermoelectric generator and cool the other side, a current will flow. It also works the other way around — if you apply a current to the generator leads, it will cause one side to heat up and the other side to cool down.

A super simple thermoelectric generator is shown in the photo above: a junction of two different metals (copper and iron) is heated to produce a current output between one end of the copper wire and the head of the nail. It’s too little current to be of much practical use, but it’s a great educational project!

How to Use Thermoelectric Generators

  1. Another DC electrical energy generator! Get at those inverters for AC power applications.
  2. Since these are super low power, I’d suggest a rechargeable battery just like with solar panels and turbines, and maybe even an amplifier like a transistor.
  3. Since these will likely stay low power, you shouldn’t need a diode to protect the TEG, but be sure to have adequate circuit protection for your particular electronic load.
  4. You can purchase TEGs that have specific power outputs, typically for camping purposes, or you can rig up your own using peltier junctions. Consider connecting a few in series to get a higher energy output.

Here’s a great overview on how TEGs work, check it out and be inspired!

 

Other Types of Renewable (& Clean) Energy Technology

Ok, so that’s it! We’ve covered 3 of the primary renewable (and clean) energy technologies! There are TONS more out there but they are either 1) super involved, 2) super expensive or 3) both. Here are two of the more common ones to give you a sense of what is possible in the wonderful world of renewable energy technology!

Geothermal Power Plants

Geothermal power plants use hot water deep in the earth to run a steam turbine. This requires ridiculously deep wells (~ 1km) to pump up the hot water, run it through a heat exchanger (or directly through a steam turbine if you’re lucky enough to be close to a water source that hot), and then push the water back into the earth or let it seep back down naturally.

These are super cool because there are no negative consequences of energy generation — no pollution is generated (only steam!), no water is lost, and it the water will heat back up naturally over time.

Nuclear Power Plants

These are a bit controversial due to the radioactive waste byproducts of nuclear fission, but nuclear power plants do in fact generate renewable, clean energy. As long as the waste is properly stored and there are safeguards in place to prevent meltdowns, nuclear power plants are relatively safe and well understood.

Currently, nuclear power plants use the process of fission, which involves breaking up an unstable atom (e.g. uranium) to get out high energy electromagnetic radiation (aka light). That energy is usually converted into heat and used to run a steam turbine.

Ideally, we’ll figure out fusion somewhere in the near future, which is the process of fusing two simple atoms together (usually two isotopes of hydrogen). Nuclear fusion generates electromagnetic energy and inert particles like helium. This is what stars do! Except they are much, much more efficient as they are insanely hot and high pressure.

Fusion does NOT produce any radioactive waste, so it would be a perfect solution to our energy crisis. Now to just figure out how to get a net positive energy output….

For more info on fusion, check out this awesome article by the folks at Industrial Quick Search Directory.

Go Forth & Build!

Now you know what renewable energy technology is and, generally speaking, how to incorporate it into your personal projects. It’s also a great way to charge your gadgets while out and about, make your projects portable, and have a backup power source in the event of a power outage.

Please feel free to ask any and all questions! My goal with this is to empower you to feel confident in using some sort of renewable energy tech in your everyday life, whether you purchase it or build your own.

Remember, it’s ok (and encouraged) to start small and simple! Use a solar panel to power a small motor, use a wind turbine on your bike helmet to power a bike light, or use a thermoelectric generator to light up some LEDs while camping!

If this tutorial inspires you, I’d love to see any projects you made, share ’em in the comments below!!

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!

Make a Light-Up Holiday Card!

Light-up cards incorporate two of the best worlds of making (electronics and crafts) with the added bonus of making somebody smile. Heck yes!

Here’s my approach to light-up cards and my favorite recent discoveries: pop-ups and cotton balls.

Read time: ~ 5 min.

Build time: ~ 30 min -1 hr (mostly crafting the card)

Cost: < $5

 

Materials!

Gather up the following materials:

  • One or more LEDs!
  • Copper tape (~ 20″)
  • One coin cell
  • One paper clip
  • One pushpin
  • Colored paper
  • & any other craft materials your creative heart desires!

 

Build the Circuit!

 

 

1. Cut out a pocket for the coin cell.

 

 

 

2. Add copper tape to cardstock!

Stick 2″ of copper tape just above the battery pocket, so that the bottom of the battery rests on top of it. This is the negative (-) side of the circuit.

Stick another 2″ piece of copper tape on the underside of the pocket, so that it touches the top of the battery. This is the positive (+) side of the circuit.

 

3. Add a switch!

Cut a small line at the end of the copper tape, push paper fastener through the slit and hook the paperclip under the paper fastener (it might also help to add copper tape to the end of the paperclip). This makes an “on/off” switch!

 

 

4. Connect the LED!

The longer LED leg connects to the positive side of the circuit. The shorter leg connects to the negative side of the circuit. Be sure that these two sides of the circuit do not cross, or it “shorts” the LED and drains the battery.

 

 

Design & Make the Card!

1. Plan out where the light is going to go!

This is super crucial if you want the light to be in a specific spot, like the top of a tree, as a nose, etc. It’s helpful to make a super simple drawing of what you want before you try, or at least have extra materials on-hand for second (or possibly third) versions. Check all the things before you glue stuff down.

2. Craft the card!

Since it’s the December holiday season, I’m making a bunch of holidays cards for friends, woo! I like incorporating re-used (or upcycled) materials, so for this card I cut out the cover of an old calendar and folded the edges under to make it 3D (oooohhh now we’re gettin’ fancy!).

Another fun option are pop-ups! Cut out thin strips (~ 1/2 inch) and fold them accordion-style, then use ’em to prop up your cutouts and drawings!

3. Add in the LED!

You can either hide the circuit under the cover, or inside the card. For this card, the circuit slips under the cut-out, and the LED, covered by a lot of cotton balls, sticks out the top to light up the clouds!

 

 

Final Touches & Beyond!

Close the switch to the LED and stand in awe at your awesome creation! Write a heart-felt note on the inside and give it to your favorite family member/friend/coworker/neighbor/etc!!

There are tons of other ways to make the LED circuit! The photo to the left shows a method using magnets (ohhhh magnets!). What other ways can you come up with to make the circuit? Post your creations in the comments below!! 😀

Make a Sneaky Wearable ‘State Change Switch’!

 

Secretly change settings for your wearable outfits or use this button as a secret prank trigger! Here’s a quick & easy tutorial on how to build and program a “state change switch.” AKA a button that cycles through different settings. It’s super easy and has tons of practical applications!

Read Time: ~ 5 min
Build Time: ~ 30 min
Cost: Super cheap (>$5)

Materials!

materials1-sm

— Glove (just one.. but you should probably wear two to avoid giving away the secret)

— Three (3) stranded wire segments (24/26 gauge), approx. 3 ft

Wires should be long enough to reach from your palm to wherever you want to hide the electronics. I hid mine in a belt pouch, but you could also opt for a pocket, backpack, etc.

— One (1) 10kOhm resistor

— One (1) pushbutton (aka momentary switch)

— One (1) 1″ x 1″ piece of thin wood

Those free wood swatches at hardware stores are perfect!

— Microcontroller

I used the SparkFun EL Sequencer b/c I was using this switch to select different settings for my Hallowen EL Wire costume. Check out the tutorial to learn how to build your own version of this costume, or you can use this state change switch with any ol’ microcontroller for your own awesome project!

 

Build it!

schematic_bb

buttonbase1-sm

1. Drill holes in a small piece of wood for the button feet.

resistor1-sm

2. Solder a wire to one of the button legs, and a resistor to the other button leg on the same side. Solder a black wire to the resistor.

3. On the other side of the button, solder a wire to the leg across from the resistor.

4. Test electrical connections, then coat all solder joints in hot glue.

buttonbase-bottom2-sm

5. Connect the black wire to the microcontroller ground, and the wire on the same side to the microcontroller voltage output (Vcc).

6. Connect the wire on the other side to a microcontroller digital (or analog) input pin (see schematic above), and then onward to programming!

buttonbase-solder-sm

 

Program it!

code-screenshot

Most folks that program state change switches use the modular, or mod, operator* to tell different settings apart. It’s not perfect, but for how little code is involved it’s a good way to cycle through different settings and get back to our original state.

Here’s a quick sketch that will allow you switch between three different settings by pushing the button. As is, it’s written to switch between three different digital output settings. In other words, if you have a motor connected to your microcontroller, the button will switch the motor from constantly on, to pulsing (i.e. repeatedly on/off), to constantly off, then back to constantly on.

*The mod operator (usually “%”) divides the number by the value after the operator and gives you the remainder. For example, if you see: 10%2, it means 10 / 2 = 5, which equals 0, since there is no remainder. Another example is 10%3, which equals 1, since 10 / 3 = 3.33, and 0.33 is one out of three. Here’s more info on this or feel free to leave a comment if you have any questions!

 

Finish & Test!

Connect the button wire leads to your microcontroller inputs, run the full program and test to see that it works as expected. If it’s all good, put the glove on and push the state change switch and watch as your costume/insertotherawesomeprojecthere changes through different settings!

Now go forth and show off your project around town!

IoT Industrial Scale!

finalscale2-v2

 

What does a baby elephant weigh?* How much impact force does a jump have?? How can you tell if a rain barrel is full without looking inside??? Answer all these questions and more by building your very own Internet of Things (“IoT”) industrial scale using the SparkFun OpenScale board!

This project is intended for folks with a lil’ bit of background using Arduino or other microcontrollers. But, whether this is your first or 137th project, check out the links in the Suggested Reading section below (and throughout the tutorial) or leave a comment if you have any questions!

Read time: ~ 15 min.

Build time: Approx. 2 – 3 hours

*To weigh a baby elephant, you might need to be a zookeeper or otherwise have an elephant friend.. but you could always weigh Fido and/or kitty!

For all you visual learners, check out a video of the project below:

 

Materials!


To follow along and build your own scale, all the parts used are listed below.

Electronics

To make the system wireless:

All these parts can be found in the wish list here.

Scale and Casing

  • Terminal blocks (5)
  • Three (3) M3 screws per load cell (total of 12)
  • One (1) project case (to protect the electronics)
  • One (1) base board, and one (1) top board (for the scale platform)
    • My base board was ~ 16″ x 16″ and my top board was ~ 12″ x 14″.
    • Both boards should be sturdy and not flex or dent.
  • Wood slats to frame the sides of the top board to hold it in place.
  • Four (4) feet for base

 

But wait! There’s some background reading..


First of all, how do we measure weight??
Strain gauges!

Also called load sensors, strain gauges measure electrical resistance changes in response (and proportional) to, well, strain! Strain is how much an object deforms under an applied force, or pressure (force per area). Check out this super awesome tutorial for more info on how strain gauges work.

Usually what you’ll find in a bathroom scale is a load cell, which combines four strain gauges in a wheatstone bridge. This project uses four disc compression load cells rated at 200 kg.

Here’s some additional background material to learn more about the components and tools used in this project:

  1. Serial Terminal Basics
  2. OpenScale Applications and Hookup Guide
  3. Getting Started with Load Cells
  4. Photon Development Guide

As usual, don’t forget to read the Datasheet for the Load Cells and any other components you with to use in your project.

Build the Electronics! Pt. 1


industrialscale-schematicv2

Connect the Load Cells!

Load cells have four signal wires:

  • Red: Excitation+ (E+) or VCC
  • Black: Excitation- (E-) or ground
  • White: Output+ (O+), Signal+ (S+)+ or Amplifier+ (A+)
  • Green (or blue): Output- (O-), Signal- (S-), or Amplifier (A-)

They also have bare (or yellow) grounding wires to block outside (electromagnetic) noise.

Connect all five load cell wires in parallel to the OpenScale terminal blocks with the corresponding labels. You might need to switch the green and white load cell wires – check this by adding weight to the load cells. If the weight is decreasing, switch the wire orientation.

The OpenScale terminal blocks are a bit cramped with four load cells, so I used the terminal blocks pictured above. If you have a case for the electronics, remember to put the connectors INSIDE the case before connecting them to the load cells (not speaking from experience or anything..).

 

Build the Electronics! Pt. 2


Connect the OpenScale to a data logger!

In addition to printing, reading, and gathering data from the Arduino serial monitor (see “Reading Load Cells!”), we can add a Photon microcontroller to connect to WiFi and upload the measurements to the Internet!

Connect the OpenScale “Serial Out” ground (“GND”) port to the Photon GND, and the OpenScale “TX” port to the Photon “RX” port. If your data logger needs power, connect the OpenScale 5V port to the data logger Vin port. That’s it!

 

Build the Base & Case!


1. Plan out, measure, and mark location of load cells.

Load cells should be at least 1″ in from the top platform board sides and installed equidistant and on the same plane (aka same height) with each other.

Each load cell needs three M3 type screws, which requires fairly precise measurements. I opted for a quick & easy solution: make a plastic stencil that marks the load cell outline and the location of the screw holes. The plastic I used was cut from a discarded strawberry container (yay, free and upcycled!).

2. Drill holes for load cell screws and attach load cells to base board.

3. Attach feet to base.

4. Secure the scale platform.

Place platform on top of the load cells. Attach wood slats to sides of base with wood glue and/or screws to secure the platform in place laterally, but not vertically. AKA, be sure that there is no resistance to the board pushing downward.

Add brackets on opposite sides for a more secure hold.

5. Place electronics into project box container (or tupperware) and drill holes for cables.

6. Admire your handiwork!

 

Connect the OpenScale!


One of the awesome features of the OpenScale program is that it outputs data to the Arduino IDE serial monitor (9600bps). All we need to do is plug in our OpenScale via USB, select the appropriate board (Arduino Uno) and port, and you can read the load cell data directly from the Arduino Serial Monitor. More info on how to do this here.

Enter ‘x’ to bring up the OpenScale settings menu. Entering ‘x’ again leaves the menu and the OpenScale will start printing data!

arduinoserialmonitor-fullmenu2_labeled

We also need to remove the serial trigger from the OpenScale. Do this by going to the menu, inputting ’t’, and turning the serial trigger to OFF.

You can change various other settings on the OpenScale using the serial monitor, including units (lbs/kg), print rate, decimal places, etc. You can adjust, or peruse, the entire OpenScale program by downloading it from GitHub!

Note: If you are connected to another microcontroller, the OpenScale does not send data when in the menu mode.

 

Tare & Calibrate the OpenScale


Tare!

We’ll need to tare the OpenScale each time it is powered up. To tare the scale, remove all weights from the scale and open the OpenScale settings menu. Input ‘1’ in the OpenScale menu, wait for it to finish taring, then exit the menu and check that the output is close to zero (+/- 5 lbs). If the reading is still off, taring again should fix the problem – if not, check that the load cell grounding wires are properly connected to ground.

Calibrate!

We also need to calibrate the OpenScale to get accurate measurements. It’s also recommended to re-calibrate the system every few weeks (or days) to avoid creep (slow change in reading over time).

To calibrate the scale:

  1. Remove all weights (except the platform).
  2. Open the OpenScale menu and select ‘2’ to open the calibration setting.
  3. Place a (known) weight on the scale and adjust the calibration factor using ‘+’ and ‘-’ until the scale reads out the calibration weight within a reasonable margin in error.*

Also, the load cell output varies with temperature (‘cause heat causes expansion), so we need to keep the system at a constant temperature (or use different calibration factors at different temperatures.

*My experimental uncertainty was about +/- 5 lbs.

 

Program the Photon!


Write a program for the Photon that will read in the serial output data from the OpenScale and push it to the IoT platform of your choice. Or you can use/modify my code 🙂

Here’s the GitHub repository for the IoT scale.

This program reads data from the OpenScale and pushes it to ThingSpeak (also prints it to the Photon serial monitor). ThingSpeak is super easy (and free!) to set up, the only downside is that it only allows data to be posted every 15s.

What you need to do to make the program work for your setup:

programcode-whattochange_labeled

  1. Include your WiFi SSID (network name) and your WiFi password in lines 53 & 54, and lines 69 & 70.
  2. Set up a ThingSpeak channel!  thingspeak-channelsetup
    1. Name the channel and write a brief description.
    2. Include at least one field name. If you want to push more data, like temperature or a timestamp, include those corresponding fields.
    3. Save the channel!
  3. Copy the “Channel ID” number and the “Write API Key” and input them into lines 84 & 85.thingspeak-apikeys_labeled

Read through the comments in the program code for more information on how the program works.

 

Test & Refine!


Prototype complete! Have your favorite human or animal stand (or awkwardly lay..) on the scale to check that it works as expected.

Check thoroughly to see if there is anything that needs to be fixed, secured, and/or improved. During my build process I noticed that a lot of the wood I was using to test would get dented by the load cells, resulting in inaccurate readings.

 

Lessons Learned & Next Steps!


My initial goal for this IoT scale was to gather data on the forces due to jumping (specifically in parkour). Alas, the OpenScale is intended for constant loads and the fastest print rate is 505 ms, which is too slow to get accurate readings on impact force.

Fortunately, we can still use the scale to gather general data and use this design as a foundation for future versions. Some quick and well-timed preliminary testing by a professional jumper (~165 lbs) resulted in the readings plotted below:

data-jumptest3

It shows a single jump, where the landing corresponds to the highest reading (~ 230 lbs), and the point just before that (~ 135 lbs) is when his feet were in the air. (The weight decrease + little blip after the the peak is when he was stepping off the scale.)

In addition to an updated program to print data faster, I’ll need waaay more data and a consistent, controlled procedure to determine any kind of reasonable relationship between impact force, jump height, and weight. Also, the top platform was a bit dented after these tests, so I’ll need a sturdier wood, or metal, scale platform.

Overall, this was a cool proof-of-concept and an informative preliminary test! Plus, there are tons of other practical uses for this simple Internet-connected scale!

 

Education Extension & Beyond!


Beyond being a great hands-on project for computer science, engineering, and electronics courses, this is a handy experimentation tool for physics classrooms! Use it to illustrate the difference between weight and mass, demonstrate how acceleration relates to force, or use the on-board temperature sensor to estimate the mathematical relationship between thermal expansion and load cell output.

Other Applications:

  • Use the system to measure the weight of a rain barrel and notify you when it is full.
  • Make a bathroom scale that keeps track of your weight (or your animal’s weight).
  • Monitor the weight of your Halloween candy to be sure that no one is sneaking some from under your nose.

Happy Building!