I often see piano tutorial videos on YouTube where lights appear to illuminate the players’ hands right as they play the keys. Using the power of a MIDI, a Raspberry Pi, and some programmable LEDs, I wanted to see if I could turn my piano into something similar. If you dabble in technology as much as you do music - here’s how to build a LED strip for your piano that lights up as you play it. 

What You’ll Need For This Project

• Raspberry Pi 4 or Raspberry Pi 3, or Raspberry Pi Zero with power adapter and SD card
• Digital Piano with MIDI USB output and corresponding USB cable
• Programmable LED strip (1 meter or greater)
• Jumper cables

How to Turn a Raspberry Pi into a Piano LED Light Up Strip

Before you get started, get your Raspberry Pi set up. If you haven’t done this before, see our article on how to set up a Raspberry Pi for the first time or how to do a headless Raspberry Pi install (without the keyboard and screen). For this project, we recommend a headless Raspberry Pi install.

1. Install git. We’ll need it to download the code from GitHub.

sudo apt-get updatesudo apt-get -y install git

2. Clone the repository to your home directory. This will ensure we have all the code and audio files we need to run the project.

cd ~/git clone https://github.com/rydercalmdown/piano_key_illuminator.git

3. Run the “make install” command to install all project dependencies. This script will take care of installing lower level dependencies, as well as the Python libraries you need for the project to run. This should take about 10-15 minutes on a Raspberry Pi 4.

cd ~/piano_key_illuminator/make install

4. Unbox your LED strip and affix it to the piano with the sticky tape on the back. If it’s not long enough to cover the entire length of the keys, place it in the middle of the piano.

5. Attach the 5V and ground pins of your LED strip to your Raspberry Pi board pins 4 and 6 respectively.

6. Attach the data-in pin of your LED strip to your Raspberry Pi board pin 12.

7. Using a USB cable, attach the MIDI out of your piano to your Raspberry Pi (any USB port).

8. Turn the piano on and confirm it is listed with the following command. You should see the name of your instrument.

amidi -l

9. Set the self.lc.led_count variable in the src/app.py file to the number of LEDs on your strip (default 60).

nano src/app.py# self.lc.led_count = 60

10. Use the following command to start the application on the Raspberry Pi. If successful, the LEDs will flash a few times before the application starts. When a key is depressed, the corresponding LED will illuminate, and the console will show the ID of that key.

make run

INFO:root:41 - note_onINFO:root:41 - note_off

11. Press the lowest key on your piano covered by the LED strip, then the highest. Note the number/id of these keys in the console output and set the following variables in app.py:

INFO:root:30 - note_onINFO:root:30 - note_offINFO:root:101 - note_onINFO:root:101 - note_off

self.lc.highest_key = 101self.lc.lowest_key = 30

12. Run the program as before. With the adjusted settings, it will now approximate which LED to illuminate based on which key is pressed. This is done due to different LED strips having different spacing, or not having enough to cover the entire board.

make run

We miss the palmtop computer, one of the many varieties of sub-laptop rudely swallowed up by the rise to dominance of the smartphone and tablet. Hooray, then, for Canadian hacker Rune Kyndal, who has crammed a full Linux computer (a Raspberry Pi Zero W) and color screen into the shell of an HP-95LX PDA (Personal Digital Assistant). He’s called it the HPI95LX, obviously, and Hackaday reported on it

The 95LX, you’ll no doubt remember, was HP’s first attempt at a palmtop or PDA running MS-DOS, back in 1991. The NEC V20 CPU ran at 5.37MHz, up to 1MB of RAM was available, and the whole thing ran on two AA batteries, with a couple of coin cells to make sure the removable SRAM card (up to 32MB of storage) didn’t lose data. The screen could display two shades of gray across its 240 x 128px, 4.8 x 1.8 inch LCD matrix with no backlight. It ran MS-DOS 3.22 with a custom version of Lotus 1-2-3. HP produced nearly half a million 95LX units and over time released many iterations of successors.

While it might have been revolutionary for its time, those specs are slightly less impressive today. The Raspberry Pi Zero W isn’t exactly cutting-edge either, especially after the release of the Zero 2 W, but it is capable of running a full graphical desktop Linux, and its small form factor means it fits nicely within the shell of the 95LX. It's definitely one of the best Raspberry Pi projects we've seen.

The new screen is a backlit color LCD touchscreen (though that’s a work in progress) measuring 4.3 inches across and with a resolution of 800 x 480px. The mod adds ethernet, stereo speakers, a mic, some USB 2.0 ports, micro SD card slot, an HDMI, and of course the Pi Zero’s Micro USB for power. Fans of retro data transmission methods will be pleased to see that it keeps the 95LX’s RS232 and IR ports.

Rune reverse-engineered the original keyboard membrane, and wrote a custom Linux keyboard layout file to ensure all the keys work as intended. Inside, rather than use a custom PCB, the innards are made up from multiple pieces hot-glued together, which Rune says he would rectify if he did it again. There's plenty more information about the build at Rune’s hackaday.io page.

Halloween is upon us, and this year I'm building a series of smart Halloween decorations that are also Raspberry Pi projects.  So far, I’ve created a Raspberry Pi-powered zombie arm that slaps guests and a person-following creepy head.

However, one of my all time favourite decorations is a fog machine. The only unfortunate thing about them is that they're analog. Now, with a bit of hacking, we're going to be connecting a fog machine to a Raspberry Pi, and activating it with person detection. This way, we only use fog juice when there are people close by. Here's how to get started.

What You’ll Need For This Project

• Raspberry Pi 4
• A relay module compatible with the Raspberry Pi
• At least 6 jumper cables
• A soldering iron and solder
• A fog machine with a remote control (I picked mine up from walmart)
• Wyze Cam V2 / V3 or Raspberry Pi camera

How To Build a Smart Fog Machine with a Raspberry Pi

1. Set up your Raspberry Pi. If you don’t know how to do this, check out our story on how to set up your Raspberry Pi for the first time or how to set up a headless Raspberry Pi (without monitor or keyboard).

2. Install git as necessary, and clone the repository to your Raspberry Pi.

cd ~/sudo apt-get update && sudo apt-get -y install gitgit clone https://github.com/rydercalmdown/smart_fog_machine.git

3. Descend into the cloned repository and run the installation command to install all lower-level and python-based requirements for the project to work.

cd ~/smart_fog_machinemake install

4. Test your fog machine. Pressing the button once should cause the fog machine to turn on, pressing it again should cause it to turn off. Holding the button on my particular machine results in the same behavior as pressing it. 

5. Remove the screws from the back of your remote and open up the back panel.

6. Put the batteries in your remote if they are missing, and locate the solder points that are connected to the fog button.

7. Using a jumper cable, short the pins until you find the ones that cause the LED on the front of the remote to flash. In my case, that was the top right and bottom left pins when the remote  is on its back and the IR LED is pointed upwards. If your remote doesn’t have a status LED on the front, you can view the activity of the IR LED with the front-facing camera on your phone.

8. Once the pins are found that activate the LED, solder two jumper wires onto them.

9. Create a hole for the jumper wires to exit the back of the case. I used my soldering iron to burn a small divot in the side of my remote.

10. Close up your remote and test it. The status LED should blink upon push of the button, as well as shorting the two jumper wires coming out from the case. 

11. Connect the VCC pin of your relay to the BOARD pin #4 on your Raspberry Pi.

12. Connect the Ground pin to Raspberry Pi BOARD pin #6.

13. Connect the channel 4 pin of your relay to the Raspberry Pi BOARD pin #5. 

14. Connect the two jumper wires coming from the remote to the common, and normally open ports of channel 4 of your relay. On my relay, these are the leftmost ports. You should not see your LED flash at this time.

15. Flash the custom RTSP firmware to your Wyze camera using this tutorial. Installing RTSP support allows us to connect to the camera and grab frames directly with Python.

16. Get the RTSP URL value from your Wyze application, and edit the RTSP_URL variable in the Makefile to point the Raspberry Pi to your camera. You can find the RTSP URL in the “Advanced Settings” section of your Wyze application on your phone.

nano Makefile# Edit the file with your RTSP URL from your cameraRTSP_URL=rtsp://your_username:your_password@your_camera_ip/live

17. Test your system with the make run command. The LED should flash on your remote briefly as the system starts up and tests itself. It should also flash when a person is detected by the camera.

make run

18. Position the remote so it has a clear line of sight to your fog machine.

19. Plug in your fog machine, use the make run command, aim the camera at a person, and the fog machine in your desired direction, and enjoy!

make run

If you’re looking for more of a challenge, I’d recommend cloning the IR code with an IR receiver compatible with the Raspberry Pi, and retransmitting it with an IR LED. This was my original plan, but I unfortunately wasn’t able to get things functional on time - but there’s always next year! Happy Halloween!

Halloween is my favorite time of the year and what better way to spend it than creating animatronics with a Raspberry Pi to scare trick or treaters. This year I’m building a series of smart devices for my porch on Halloween. I’ve always wanted to build a zombie arm that jumps out as people walk by - and we’ll show you how to do it with a bit of pneumatics, a relay, and a Raspberry Pi. 

What You’ll Need For This Project

• Raspberry Pi
• Pneumatic Air Cylinder
• 4 Way 12 V pneumatic control valve
• Two push-to-connect fittings compatible with your air cylinder
• Two push-to-connect fittings compatible with your control valve
• 12 volt power supply
• A relay module compatible with the Raspberry Pi
• At least 4 jumper cables
• 2 wire nuts or WAGO connectors
• A few feet of extra wiring suitable for a 12v circuit
• Air compressor and hose (or another source of compressed air)
• 1 male quick-connect pneumatic adapter
• A roll of PTFE tape
• A tool box with some basic tools, a drill, a hot glue gun
• A Halloween zombie arm or skeleton arm (I picked mine up from the dollar store)
• Wyze Cam V2 / V3 or Raspberry Pi camera
• Polyethylene tubing

How To Build a Zombie Arm for Halloween with a Raspberry Pi

1. Set up your Raspberry Pi. If you don’t know how to do this, check out our story on how to set up your Raspberry Pi for the first time or how to set up a headless Raspberry Pi (without monitor or keyboard).

2. Install git as necessary, and clone the repository to your Raspberry Pi.

cd ~/sudo apt-get update && sudo apt-get -y install gitgit clone https://github.com/rydercalmdown/zombie_arm.git

3. Descend into the cloned repository and run the installation command to install all lower-level and python-based requirements for the project to work.

cd ~/zombie_armmake install

4. Attach your pneumatic control valve to a small piece of wood. This is entirely optional, but I like to have everything secure in one place. 

5. Attach your relay module to a small piece of wood. Once again, this is entirely optional.

6. Wire the negative end of your 12v power supply together with two small strands of wire using a wire nut or WAGO connector.

7. Attach the two negative wires coming from the wire nut / WAGO connector to the left-most ports of channels 4 and 3 or your relay.

8. Attach a few inches of wire to each terminal of your pneumatic control valve; each end should have a positive and negative wire coming from it.

9. Attach the positive ends of both wires coming from the pneumatic control valve together with the positive end of the 12v power supply. You can use wire nuts or a WAGO connector to do this.

10. Attach the negative ends of the wires coming from the pneumatic control valve to the middle port of channels 4 and 3 of the relay. 

11. Wire the 12v and ground pins from your relay to GPIO pins 4 and 6 on the Raspberry Pi.

12. Wire channels 4 and 3 from the relay to GPIO pins 8 and 10 on the Pi. 

13. Attach 3 quick connect adapters to the ports on your pneumatic control valve, and 2 to the ports on your pneumatic cylinder.

14. Attach two polyethylene tubes from your pneumatic control valve to each end of your pneumatic cylinder. 

15. Attach a source of compressed air to the input of your pneumatic control valve.

16. Test your system by using the manual push valves on the pneumatic control valve; the cylinder should actuate.

17. Drill a hole in your halloween zombie arm and hot glue it to the end of the cylinder. 

18. Set up the Wyze camera or Raspberry Pi camera. For this project you can substitute a simple motion sensor, but I wanted to make use of person recognition to trigger the hand, so I’m using a Wyze Cam V2 (V3 also works) to handle the detection.

19. Flash the custom RTSP firmware to your Wyze camera using this tutorial. Installing RTSP support allows us to connect to the camera and grab frames directly with Python.

20. Get the RTSP URL value from your Wyze application, and edit the RTSP_URL variable in the Makefile to point the Raspberry Pi to your camera. You can find the RTSP URL in the “Advanced Settings” section of your Wyze application on your phone.

nano Makefile# Edit the file with your RTSP URL from your cameraRTSP_URL=rtsp://your_username:your_password@your_camera_ip/live

21. Plug in your 12 volt power supply. 

22. Test the system by running the make run command. It should boot up and move the arm as a test to start, then only activate the arm when a person is detected. If your movements are backwards, reverse the two hoses going to the cylinder.

make run

23. Mount your system in a place where it can scare friends and family.

The majority of these components are not waterproof, so mount them in a way that they’ll stay dry. In addition, a pneumatic cylinder can be a dangerous component depending on how much pressure it’s given. To stay safe, set your regulator to the smallest amount of pressure required to move the arm, and make sure the arm has plenty of room away from people. Happy Halloween!

From time to time, I like to let the internet control things in my home. Sometimes it’s letting a live stream turn on and off a light and  others it's driving a RC car around my living room. When building these projects, I normally use a Raspberry Pi to listen for web traffic and perform an event when someone visits the site.

I could give people my IP address and port forward my router to my Raspberry Pi, but I’d rather keep my IP private and my network as secure as possible. We can get the best of both worlds with a SSH tunnel, nginx, and a virtual machine in the cloud. All this creates a reverse proxy, where visitors hit a public IP address that’s not your home network’s and get directed to the Pi that’s on your LAN.

If you’re looking to build something interactive with your Pi while still keeping things as secure as possible, here’s how to do it.

What You’ll Need For This Project 

• Raspberry Pi 4 or Raspberry Pi 3 with power adapter
• 8 GB (or larger) microSD card with Raspberry Pi OS. See our list of best microSD cards for Raspberry Pi. 
• A Google Cloud Platform account and the gcloud command line tool or another cloud provider you’re familiar with. Note that the incoming traffic will cost some money which, in our case, is $5 a month.

How To Host a Public Website on Your Home Raspberry Pi

Before you get started, make sure that you have your Raspberry Pi OS set up. If you haven’t done this before, see our article on how to set up a Raspberry Pi for the first time or how to do a headless Raspberry Pi install (without the keyboard and screen).

1. Install git, which will allow us to clone this project’s code.

sudo apt-get update && sudo apt-get install -y git

2. Clone the repository with example code. This code takes care of communication with the sensor, and sets up a simple server for monitoring on your home network. 

cd ~/git clone https://github.com/rydercalmdown/pi_home_reverse_proxy.git

3. Run the installation command after descending into the repository. This will install all necessary SSH components as well as nginx, a simple server we’ll use as an example.

cd pi_home_reverse_proxymake install-pi

4. Create a SSH public/private keypair. The private key will remain on the Raspberry Pi, and will be used in conjunction with the public key to connect to our cloud virtual machine. 

ssh-keygen# press enter to accept all default settings

5. Copy the SSH public key for later. We’ll need this when setting up our virtual machine in the cloud.

/home/pi/.ssh/id_rsa.pub# Copy the results

6. Visit your Google Cloud Console and navigate to the VM Instances page.

7. Click “Create Instance” to create a new virtual machine.

8. Choose a memorable name for your instance. I’m calling mine “home-reverse-proxy”.

9. Choose your desired region and zone. This doesn’t matter as much, but it’s good to pick something close to you for low latency. 

10. Under machine configuration, choose “N1” for the series, and f1-micro for the machine type. This will give us the lowest monthly cost, around $5 USD per month. 

11. Scroll down to the “Boot Disk'' section and click the change button. Set the Operating system to Ubuntu, and the version to “Ubuntu 20.04 LTS”, leave everything else the same and cick Select.

12.  Scroll down to “Firewall” and check both “Allow HTTP traffic” and “Allow HTTPS traffic”.

13. Scroll down to the bottom of the instance and click “Create”.

14. Once the machine is running, click the dropdown next to SSH to get the SSH command. I recommend using the “View gcloud command”. Paste that command into your terminal to SSH on to your cloud virtual machine. 

15. Once connected to your virtual machine, install nginx with the following commands.

sudo apt-get updatesudo apt-get install -y nginx

16. Check to see if nginx is running by running the following command. You can also visit the External IP in your browser listed next to your virtual machine in the Google Cloud console. When visiting, you should see a nginx welcome page.

sudo service nginx status# Ctrl + C then enter to exit# It should show “active (running)” in green if all is well

17. Update the default configuration with a custom reverse-proxy config. This tells nginx to forward all traffic it receives to a port on your machine. 

cd /etc/nginx/sites-enabledsudo rm defaultsudo touch defaultsudo nano default# copy in the code below

This code rate limits the number of requests to 5 per second to not overwhelm the pi during interactive projects. If you’d like to accept more, simply increase the number, or remove any lines that start with limit_req from the file for no limits.

limit_req_zone $binary_remote_addr zone=basic:10m rate=5r/s;server {  listen 80;  location / {    limit_req zone=basic;    proxy_pass  http://0.0.0.0:5000;  }}

18. Restart the nginx service and visit the external IP of the virtual machine again. You should be presented with a “502 Bad Gateway” page if all goes correctly. 

sudo service nginx restart

19. Using the following command, create a user for the pi to SSH into on the virtual machine.

sudo useradd -m -p raspberry -s /bin/bash piconnect

20. Create the SSH directory and authorized key files, and copy in the public key you copied from your Raspberry Pi. 

sudo mkdir /home/piconnect/.ssh/sudo touch /home/piconnect/.ssh/authorized_keyssudo nano /home/piconnect/.ssh/authorized_keys# copy in the public key you copied from your raspberry pi

21. Back on the Raspberry Pi, edit the establish_remote_connection.sh file to include your remote server’s IP address. 

cd ~/pi_home_reverse_proxysudo nano scripts/establish_remote_connection.sh# change REMOTE_HOST=your_remote_ip_address to the external IP you got from the Google Cloud Platform console

22. Run the make connect command to establish the SSH connection between your Raspberry Pi and your virtual server.

make connect

23. Visit your virtual machine’s IP address to see the content running on the Raspberry Pi served remotely and not on your home IP address. 

And there you have it! You are serving content from your Raspberry Pi from a Google Cloud IP address, via an SSH tunnel. I only use this setup from time to time, but for a more permanent setup, I'd recommend connecting a domain and securing it with LetsEncrypt on the virtual machine side.

Halloween is coming, and what better way to celebrate the season than by using machine learning and a Raspberry Pi to accomplish something spooky! This year I’ve built a mannequin head that uses person detection and a simple servo motor to detect when a person is walking by and turn the head to follow them. I’m using a simple styrofoam mannequin head with some coloured in eyes from the dollar store, but you’re welcome to dress it up to fit your house’s theme or use a completely different kind of head or object. As long as you can use a servo to rotate it, the result is the same.

This project won’t require any machine learning training, and is more or less plug and play just in time for the season. Here’s how to build it.

What You’ll Need For This Project 

• Raspberry Pi 4 or Raspberry Pi 3 with power adapter and MicroSD card
• Mannequin Head (styrofoam or something equally light weight works best)
• 5V Micro-Servo motor compatible with a Raspberry Pi
• Hot Glue Gun
• Misc. Blocks of Wood or Cardboard
• Wyze Cam V2 (Wyze Cam V3 is not yet compatible) or Raspberry Pi Camera

How To Build A Person-Following Halloween Mannequin Head for Halloween 

Before you get started, get your Raspberry Pi set up. If you haven’t done this before, see our article on how to set up a Raspberry Pi for the first time or how to do a headless Raspberry Pi install (without the keyboard and screen). For this project, we recommend a headless Raspberry Pi install.

1. Install git. We’ll need it to download the code from GitHub. 

sudo apt-get updatesudo apt-get -y install git

2. Clone the repository to your home directory. This will ensure we have all the code and audio files we need to run the project. 

cd ~/git clone https://github.com/rydercalmdown/halloween_mannequin_head.git

3. Run the “make install” command to install all project dependencies. This script will take care of installing lower level dependencies, as well as the Python libraries you need for the project to run. This should take about 10-15 minutes on a Raspberry Pi 4 as it needs some time to install machine learning libraries and models. 

cd ~/halloween_mannequin_head/make install

4. Choose your camera; if you’re using a Wyze V2 camera, skip to step 6. If you’re using a Raspberry Pi camera, move to step 5. Both will work, but the advantage of the Wyze camera is the ability to mount it in a different place away from your Pi (and mannequin head).

5. Connect your Raspberry Pi camera directly to the Raspberry Pi and test it with the following command. Do not set the STREAM_URI environment variable, it will by default use the Pi camera. Skip to step 8.

sudo raspistill -o test.jpeg

6. Flash the RTSP custom firmware to your Wyze Camera using these instructions. This will allow us to access the stream from the camera wirelessly with the Raspberry Pi. This will only work with a Wyze V2 camera.

7. Get the RTSP URL value from your Wyze application, and edit the STREAM_URI variable in the Makefile to point the Raspberry Pi to your camera. You can find the RTSP URL in the “Advanced Settings” section of your Wyze application on your phone. 

nano Makefile# Only edit this if you’re using a RTSP camera; leave blank if you’re using a Pi cameraSTREAM_URI=rtsp://username:password@camera_ip_address/live

8. Hot glue your servo motor to a base piece of wood, or directly to the place you intend on mounting the mannequin head. I drilled out a small piece of wood to use as my base and fit the motor inside. 

9. Hot glue the servo bracket with the motor to the base of the mannequin head. I used a small piece of wood to reinforce the connection, but depending on yours you might not need one. Make sure the bracket can still connect to the motor.

10. Using jumper cables attach the 5V and ground pins of the servo motor to Raspberry Pi pins #4 and #6 respectively.

11. Using a jumper cable, attach the data pin of the servo motor to board pin #3 on the Raspberry Pi. This pin allows control of the servo motor by the Pi directly.

12. Using the bracket, connect the mannequin head so it sits on top of the servo motor and mount the device and camera in your desired location.

13. Use the make run command to test the system. Step into frame of the camera and move left to right to have the servo turn. 

14. Adjust the mannequin head on the servo by lifting it and recentering it to calibrate it to follow you properly.

15. Buy your trick or treat candy and get it ready for halloween.

I’m a big fan of the Stranger Things series and I can’t wait for the next season. If you haven’t seen the show, in season 1 two characters communicate across different dimensions using Christmas lights with letters written underneath them. 

I built a replica of this a year ago, but with the upcoming release of season 4, it’s time to build a bigger and better version. These lights can be hung up on your wall, and can let friends, family, and even strangers communicate with you.

What You’ll Need For This Project 

• Raspberry Pi 4 or Raspberry Pi 3 
• USB power adapter for Raspberry Pi
• 8 GB (or larger) microSD card with Raspberry Pi OS. See our list of best microSD cards for Raspberry Pi. 
• Two strands of 12v WS2811 LEDs (one strand will work, but two looks better for letter spacing)
• A 12 volt power supply (any standard 12v power supply will work)
• Jumper cables
• Wire strippers
• Solder or wire nuts
• A black and white printer and paper
• Scissors
• Push pins

How to build the Stranger Things Christmas Lights with Raspberry Pi 

Before you get started, make sure that you have your Raspberry Pi OS set up. If you haven’t done this before, see our article on how to set up a Raspberry Pi for the first time or how to do a headless Raspberry Pi install (without the keyboard and screen).

1. Install git, which will allow us to clone the code from github.com

sudo apt-get update && sudo apt-get install -y git

2. Clone the repository and descend into the directory created.

git clone https://github.com/rydercalmdown/stranger_things_lights.gitcd stranger_things_lights

3. Run the installation command to install all necessary base and python components.

make install-pi

4. Connect both WS2811 strands together using their attached connectors. You can use 1 strand, but I’ve found two look better for letter spacing.

5. Connect GPIO pin 18 on the pi to the data pin of the WS2811 strand.

6. Wire the 12v of the WS2811 strand to the positive end of a 12 volt power supply. I used wire nuts to attach mine together. 

7. Wire the ground of the WS2811 strand to the negative end of the 12 volt power supply, and also a jumper cable with a female end. 

8. Connect that jumper cable to a ground pin on the Raspberry Pi. 

9. Pin the WS2811 strands up on a wall using push pins (or another method you prefer). 

10. Print out each letter of the alphabet from a text editor to your desired size.

11. Cut out and attach the letters under LEDs of your choice. 

12. Back on the Raspberry Pi, open the worker/app.py file with a text editor of your choice. 

# in the stranger_things_lights directorynano worker/app.py

13. Edit the mapping dictionary so your pins match the letters. Pins are zero-indexed, so the very first pin on your strand will be 0, and the very last will be 99 (if you have only 1 strand it will be 49). If you have the letter “A” under the last LED, assign it 99 (49 for only 1 strand of LEDs). 

14. Start the server component. It will start running on port 5000 in the background. I originally designed the server to be run separately for security, since I allow public messages from the internet, but if you’re using it for yourself you can run both on the pi.

make run-server

15. Start your worker component to receive messages from the server.

make run-worker

16. Plug in your 12v power supply. This is separate from the Raspberry Pi’s USB power supply.

17. Visit your Pi’s IP address and port from anywhere on the network. In my network, I put this in my browser:

http://10.0.0.15:8000/

18. Submit a message to the server. You should see it shortly appear letter by letter on the lights after a brief display of flashing lights to get your attention. 

You have the option of exposing this service to the internet so friends and family can send messages. Keep in mind that any time you open ports on your router or firewall there is an inherent risk - so it’s recommended you do this only temporarily.

Depending on your router or modem-router combo, you might have an option to port forward. If that’s the case, you can forward port 80 on your router to the Raspberry Pi’s IP address, and port 8000. This means that any browser that types in your home IP address (http://10.0.0.0/ as an example) will be forwarded to the running server on your Pi, where they can submit messages.

For more advanced users, you could also consider setting up a cloud-based reverse proxy with TLS termination, but to share with friends and family, the above should be sufficient.

Looking for something with atmosphere and function? Check out this beautiful Raspberry Pi-powered lamp, known as Canari by maker Guillaume Slizewicz. Not only does it feature a unique, brassy design, but it also shows real-time changes to local air quality by changing the light pattern of its bulbs.

According to Slizewicz, the name comes from the stories of coal miners releasing canaries into mines in order to test the air quality. In the same spirit, the Canari lamp will notably flash when air quality is higher than usual.

It doesn't take much to control the lamp. Slizewicz used a Raspberry Pi Zero W in the final build, as the project requires internet access in order to retrieve real-time air quality data.

The Canari lamp also uses an Adafruit 16-channel PWM Servo Bonnet to address the individual bulb,  which are constructed using LEDs, glass globes and propped on top of brass tubes. Some of the best Raspberry Pi projects use 3D-printed assets, so it's not surprising to see this one use a custom 3D-printed base.

The code for this project is open-source and available for anyone to use and explore at GitLab. Interested parties can also read more about the project through Slizewicz's website.

Keeping fit can be fun. What if, instead of running around a park we made a game where you have to hit as many balls as you can to score points? The catch is that you only have 30 seconds to get the highest score! Sounds easy, hand me the joypad! No! To control the game we have to use our body and a webcam that will look for our hands, feet, head and react when we hit a ball. In a twist, we can only start the game shouting “GO” and then the countdown starts! 

For This Project You Will Need

• Raspberry Pi 4 or 400 (or a Windows / Apple computer)
• The latest Raspberry Pi OS
• A USB webcam

Starting the Game 

1. Power up your Raspberry Pi 4 / 400 and connect your USB webcam. We are using a USB webcam instead of the official Raspberry Pi camera as we need the built in microphone. 

2. Go to Preferences >> Recommended Software to install Scratch 3. Scratch 3 is found in the Programming category, place a tick in the box and click Apply to install. 

3. Open Scratch 3, found in the main menu under Programming. On first start Scratch may take a little while to open. We’re going to assume that you have an understanding of how to code with Scratch. 

4. Click on the blue folder icon in the bottom left of the screen to load the Extensions menu. Select Video Sensing to add a palette of new blocks that will be used to create our interface.

5. Delete the cat sprite. In the bottom right of the screen click on the Cat sprite and then click on the trash can icon to delete the cat. 

6. Click on the cat logo and select “Choose a sprite”. From the selection choose a basketball.  

7. From the Events blocks, drag the “When Green Flag Clicked.” From Looks drag both “show” and “say hello for 2 seconds.” This will create the trigger to start the game and force our sprite to appear. Change the text inside “say” to “Say GO to start”. 

8. on Variables, then “Make a Variable.” Call the variable “score” and make it available for all sprites. 

9. From Variables drag the “Set score to 0” and place it under the previous blocks. You may need to use the drop down menu to select the correct variable name. 

10. From Control drag a “forever” loop and connect it to the previous blocks of code. 

11. From Control, drag “if..then” and place it inside the loop. This is a conditional test, a question. To form the question we need  to go to Operators and drag “ __ > __” and place it inside the hexagon shaped blank of “if..then”.

In the second blank type 50, and in the first drag “loudness” from the Sensing blocks. Loudness uses the microphone to detect noise, and the noise level is given a value of 0 to 100. If we shout “GO” then it should be over 50 and trigger the game to start. But this number may need tweaking for your home. 

12. Drag “broadcast,” found in Events inside the “if..then” section and use the dropdown to create a new message called “balls.” 

13. Drag “say hello for 2 seconds” and “hide” from Looks and place them inside the “if..then” section. Change the say block to read “GO!”. So when the player shouts “GO” the basketball will disappear and the game will start. The code for this sprite should look like this. 

Adding More Sprites 

Right now we have created a means to start the game, but we do not yet have a game. For that we need to add sprites with which we can interact with.

1. Create a new sprite using the “Choose a sprite” button in the bottom right of the screen. Select a baseball. 

2. From Events, drag two “When I receive balls” blocks. This broadcast is triggered when the player shouts “GO!”. 

3. From Motion drag “if on edge bounce” and “set rotation style” and connect them under one of the blocks. Set the rotation to “all around”. 

4. From Control drag “forever” and place it under the previous blocks. 

5. Inside forever drag “glide 1 secs to random position,” found in the Motion blocks. Your code should now look like this. 

When this sprite receives the message “balls” it will set the sprite to bounce off walls and to reflect at realistic angles off the borders of the screen. Lastly the ball will glide around the screen, similar to a ball travelling in air. 

Our attention now turns to the remaining “When I receive balls” block which will use our webcam to detect if there is movement on a sprite, indicating we are trying to hit the ball.

1. From Control place a forever loop under the second “When I receive balls” block and then add “if..then” so that it is nested inside the forever loop. 

2. From Operators drag “ __ > __” and place it inside the hexagon shaped blank of “if..then”. In the second blank type 80 and in the first blank drag “video motion on sprite” from the Video Sensing blocks. This will use the camera to see if we are waving / punching on a sprite and it will check to see how fast we are waving. In reality this block checks for movement and assigns a value, so you may need to tweak 80 to match your goals. 

3. Inside the if block we need to drop a “change score by” block from Variables. The score should change by 10 points if the baseball is hit. Your code should now look like this. 

Duplicating Sprites

Rather than repeat the process of creating a new sprite we can duplicate a sprite and edit. 

1. Right click on the baseball sprite and select Duplicate. We now have two identical balls in the game.

2. Change the “glide 1 secs” to 0.5 seconds to make the ball move faster.

3. Select costumes and click on the “Choose a costume” button in the bottom left of the screen. Select the tennis ball. Back in the Costume editor, click on the tennis ball on the left side of the screen to make it the default. Click on Code when done. 

Adding a Countdown Timer

Right now our game will run forever, or until we get tired. We need to add a timer in order for players to have a goal. How many points can they score in 30 seconds? The countdown timer is set for 30 seconds and the code for it is contained inside the Stage, the place where our game plays.

1. Click on the Stage icon, found in the bottom right of the screen. 

2. Drag “When I receive balls” from Events, this will trigger our code to run at the same time as the sprites move. 

3. Create a new variable, called timer, and then drag “set timer to 0” and place it under the block. Set the value to 30. 

4. From control drag “repeat 10” and place it under the previous. Change 10 to 30. This will force the loop to repeat 30 times, effectively our countdown timer. 

5. Inside the loop, drag a “change timer by 0” from Variables. Set the value to -1. From Control, drag a “wait 1 seconds” block. So now this loop will timer from 30 seconds to 0, the time for our game. 

6. From Control drag “Stop All” and place it outside of the Repeat 30 loop. When the timer reaches zero, the loop ends and the final block, “stop all” is triggered and stops all sprites and running code.

The game is now complete, but you can also add a new backdrop to the stage using the “Choose a Backdrop” button found in the bottom right of the screen. This changes the look of the stage, but we can still see the live video preview, of us playing the game overlaid on top.

To start the game click on the Green Flag, place yourself in the view of the camera and then shout “GO!” to start the game. Good luck!

The article originally appeared in Linux Format magazine. 

We've seen  makers develop some pretty cool Raspberry Pi Pico displays, but this is the first POV Pico display we've seen! POV stands for persistence of vision and refers to a technology that works by flashing LEDs on a rotating string. Through careful timings, the lights can flash in a way that creates an image. 

A maker who goes by Home Made Garbage developed this project, which relies on a Raspberry Pi Pico to control a spinning strip of Adafruit DotStar LEDs. The Pico is in charge of controlling both the LED output and rate at which the strip is spun.

The best Raspberry Pi projects are ones you can customize. Not only can users display a static image, they can also play animated sequences using GIFs.

To keep things in motion without worrying about wires, the Pico receives power from a wireless charging module. One half is mounted to the motor while the other is embedded in the LED arm, supplying juice to the LEDs and Pico.

Home Made Garbage developed a custom script for the project derived from this work on Github. Visit the official Home Made Garbage blog for an in-depth look at the project, and maybe even recreate it yourself!

Working from home gives you more opportunities to spend time with your family - pets included. My office is upstairs and occasionally my dog wants to go outside. I could put a bell on the door that she could ring, but why waste the opportunity to build an over-engineered solution.

This project uses a field of machine learning known as object detection. Fortunately if you’re not familiar with machine learning, it’s a relatively easy project to get started with. We’ll be using a pre-trained model, meaning we won’t need a graphics card, sample data, or hours of time to train a model - just the things listed below.

What You’ll Need For This Project 

• Raspberry Pi 4 or Raspberry Pi 3 with power adapter
• 8 GB (or larger) microSD card with Raspberry Pi OS. See our list of best microSD cards for Raspberry Pi. 
• Raspberry Pi Camera and cable for doing the object detection
• Raspberry Pi Wide Angle Camera Lens, or a zoom lens depending on how far away your camera will be placed.
• Desktop Speakers or megaphone with 3.5mm input jack
• Monitor & Keyboard (optional) with HDMI and power cables

How to detect when your pet wants to go outside with a Raspberry Pi 

1. Set up your Raspberry Pi. If you don’t know how to do this, check out our story on how to set up your Raspberry Pi for the first time or how to set up a headless Raspberry Pi (without monitor or keyboard). 

2. Connect your raspberry pi camera to your pi.

3. Enable your camera with raspi-config. You do this by entering sudo raspi-config from the command line and then navigating to Interface Options > P1 Camera. 

4. Reboot.

5. Test your camera’s focus using the following command. The image can be viewed if you have a monitor connected to your desktop. If you’re using a headless version of raspbian, you’ll need to use scp to move the image to a computer where you can view it. 

raspistill -o /home/pi/focus.jpg

6. Install git. We need git to download code and scripts from a remote repository. Run the following command to install it:

sudo apt-get update && sudo apt-get -y install git

7. Clone the pet detector repository to your home directory. This contains custom code that will take care of the detection for us.

cd ~/git clone https://github.com/rydercalmdown/pet_detector

8. Install the requirements for the repository. The install script will install low-level dependencies, set up a virtual environment, and install python dependencies within it.

cd ~/pet_detectormake install

9. Download the pre-trained machine learning models. We’re using the YOLOv3 model trained on the COCO dataset. This model is able to recognize a variety of household objects - dogs and cats included.

cd ~/pet_detectormake download-model

10. Connect speakers to your raspberry pi. We’ll use the speakers to play a sound effect you can hear whenever your pet steps into the frame. I’m using a megaphone but desktop speakers should work just fine. Test your speakers with the following command:

say “this is a test”

11. Edit your /etc/rc.local file so this script runs on boot. Open /etc/rc.local by entering the sudo nano /etc/rc.local command and then adding the following line to the bottom of the file:

source /home/pi/pet_detector/env/bin/activate && cd /home/pi/pet_detector/src && python app.py &

12. Set up your camera so it faces the door. My pets wait by the door when they want to be let outside - so we work on the assumption that if they step into frame, they want to go outside.

13. Let your pets go outside. When your cat or dog steps into the frame, the model will detect it, and play a text to speech message letting you know they want to go outside.

Building your own smart home is easier than ever with a Raspberry Pi. Even companies like MicroNova have recognized the potential of our favorite single-board computer (SBC) by using one inside its home sound system, called AmpliPi.

The crowdfunded AmpliPi box is capable of streaming from four separate sources. Users can interact with it using a web-based interface and output audio to a maximum of 36 stereo output zones.

The system is built on top of the Raspberry Pi Compute Module 3 and can interface with the likes of Spotify, AirPlay and Pandora. Users can configure speaker zones and playlists using the AmpliPi REST API created by MicroNova.

MicroNova's web app lets users manage audio sources using a series of tabs. It includes settings to adjust groups and zones to make sure music plays in the intended room. 

Explore the AmpliPi GitHub for more in-depth information about how the system works.

If Raspberry Pi projects get you excited, check out our list of Best Raspberry Pi Projects for more fun creations from the maker community.

Just when you think retro gaming couldn't get more pixelated, maker Neythen Treloar comes forward with this awesome Raspberry Pi-powered LED matrix retro gaming project.

The project shared this week shows off a way to play games on an LED panel using a handheld controller. Treloar tested the system with both a Nintendo Switch Pro controller and PlayStation 4 controller. Be advised, however, that this project is still in its Alpha phase, so updates are expected.

Treloar tested the creation on a Raspberry Pi 4, which proved to be the most reliable performance-wise. The system was also tested on a Pi Zero, which ran some games better than others but lacked overall in performance when compared to the Pi 4. 

In terms of the housing, everything is entirely 3D printed. Treloar shared the model files on Thingiverse.

The maker also developed a companion app, called the Retro Matrix Companion. This application allows you to interface with the RGB LEDs using an iPad. You can "paint" the LEDs in real-time over a local network. You can find the source files for the Retro Matrix Companion project on GitHub.

If you want to recreate this project yourself, check out the official Retro Matrix GitHub page. Be sure to follow Treloar on Reddit for more projects and future updates. 

We’ve all been there. You’re in the bathroom conducting some “business,” when you realize there’s no toilet paper left. You can tell your family or housemates to keep a careful eye on the stack of spare rolls in the corner, but you know that people forget, raising the possibility that you’ll be left without a square to spare. Fortunately, there’s a way to prevent toilet paper outages using a Raspberry Pi that alerts you when you have no spares left in the bathroom.

In this article, we’ll show you how to build a smart toilet paper holder that uses a Raspberry Pi Zero W and an ultrasonic sensor that measures the level of toilet paper in your holder and sends you an email if it has been empty for over 30 minutes. You can customize the email to specify the bathroom and suggest plans of action.

How does the Raspberry Pi Toilet Paper Reminder work? 

The ultrasonic sensor checks the level of toilet paper every 30 minutes. If 2 checks go by and the holder is empty, your Raspberry Pi will send you an email requesting that you refill the holder or purchase more toilet paper. 

The Pi will continue to send emails every hour every hour until the holder is refilled. Each email will state when the toilet paper holder was first empty and how many reminders it has sent. Once the holder is refilled, everything resets and the Raspberry Pi will stop sending reminder emails. The code also provides a “Do Not Disturb” option to refrain from sending emails at night; default is set to 10 pm to 8 am, and is also customizable.

What You’ll Need:

• Raspberry Pi Zero W with pre-soldered GPIO headers or you can solder them yourself. We could have used any model but the Raspberry Pi Zero W is small and low-power.
• Power supply/Keyboard/Mouse/Monitor/HDMI Cable (for your Raspberry Pi)
• Ultrasonic Sensor HC-SR04
• Small Breadboard
• Set of jumper wires (M-to-F, M-to-M, and F-to-F)
• 2 resistors (330 ohm & 470 ohm)
• 5” x 5” cardboard
• Small Magnets
• Super glue
• Raspberry Pi case
• Ultrasonic sensor housing
• Toilet paper holder

Part 1: Hardware Assembly of Toilet Paper Reminder 

In this step, we will attach the Raspberry Pi, ultrasonic sensor, and small breadboard to the top of the toilet paper holder (where the toilet paper roll would normally be placed). The ultrasonic sensor should face downward, perpendicular to the toilet paper rolls below; the Pi and breadboard should sit evenly on top. We will wire the components together in this section. At the end of this step, you should be ready to power up your Pi.

1. Insert your microSD card formatted with the Raspberry Pi OS into your Raspberry Pi.

2. Superglue 2 small magnets to the back of the housing for the ultrasonic sensor.

3. Connect 4 female-to-male wires to each prong of the ultrasonic sensor. Insert the ultrasonic sensor into the housing.

4. Attach the ultrasonic sensor with housing to the toilet paper holder so that it faces the top toilet paper roll directly.

5. Wind the 4 wires from the ultrasonic sensor through the toilet paper holder and insert into the breadboard in sequential order.

6. Attach the breadboard and Raspberry Pi to the top of the toilet paper holder. The Pi should be encased so that the board doesn’t directly contact the metal holder and create a short. We glued 2 small magnets to the enclosure to hold the Raspberry Pi in place. The breadboard should be pre-equipped with an adhesive backing that sticks to the holder.

7. Connect  the VCC pin of the ultrasonic sensor to pin 2 of your Raspberry Pi for 5V power.

8. Connect TRIG to GPIO 18 of your Raspberry Pi.

9. Connect ECHO to a 330 ohm resistor.

10. Connect the other end of the resistor to GPIO 24 of your Raspberry Pi.

11. Connect a 470 ohm resistor from the 330 ohm resistor to the GND rail.

12. Connect GNC pin from the sensor to the GND rail. 

13. Cut out a circle from cardboard the same width as your roll of toilet paper (approximately 5 inches in diameter). You’ll use this in the next step. Alternatively, you can 3D print this STL file.

Part 2: Ultrasonic Sensor for Toilet Paper Reminder 

In this section we will set up the ultrasonic sensor on the Raspberry Pi toilet paper reminder, in order to measure the distance from the holder’s base to determine if it’s empty. Note: The ultrasonic sensor works by sending out an inaudible sound and determines the distance from when the sound wave is returned. Toilet paper absorbs ultrasonic sounds and thus, we will use cardboard from the previous step to determine the distance for email triggering.

1. Boot your Raspberry Pi. If you don’t already have a microSD card see our article on how to set up a Raspberry Pi for the first time or how to do a headless Raspberry Pi install.

2. Boot your Raspberry Pi.

3. Open a Terminal. You can do that by pressing CTRL + T.

4. Clone this repository:

git clone https://github.com/carolinedunn/TP_Reminder

5. Navigate to the TP_Reminder folder in your file manager.

6. Open ultrasonic.py in Geany or Thonny.

7. Run ultrasonic.py by clicking the paper airplane icon in Geany or PLAY button in Thonny.

8. Move rolls of toilet paper into and out of the holder, keeping the circular cut-out on top. You should see the distance change as you add and/or replace rolls of toilet paper.

9. Remove all toilet paper from the holder and leave the circular cut-out at the bottom of the holder.

10. Note the distance reading on your screen. Note this distance (write it down if necessary) for Step 4.

11. Press Ctrl-C to exit the program.

With our toilet paper holder, Full TP Holder reads ~1 in and Empty TP Holder reads > 18 in. Your results may vary and you may also decide to use the measurement number for when one roll is left so you are alerted with a single roll, rather than when the holder is empty. 

Part 3: Email Automation of Toilet Paper Reminder 

In this step, we will set up an automated email service and send ourselves test emails from the Raspberry Pi toilet paper reminder. This step requires a mail service account. I have selected Mailgun for its simplicity; you are welcome to modify the code with the email service of your choice. Mailgun requires a valid credit card to create an account. For this project, I used the default sandbox domain in Mailgun.

1. Navigate to mailgun.com in your browser.

2. Create and/or Login to your Mailgun account. Navigate to your sandbox domain and click API and then Python to reveal your API credentials. 

3. Open send-email-test.py in Thonny or Geany from your file manager, in the TP_Reminder directory.

4. On line 9, "https://api.mailgun.net/v3/YOUR_DOMAIN_NAME/messages" replace “YOUR_DOMAIN_NAME” with the correct one

5. On line 10, replace "YOUR_API_KEY" with your API key from Mailgun.

6. On line 12, add your email address from your Mailgun account. 

7. Run the code send-email-test.py. If you receive a status code 200 and “Message: Queued” message, check your email. 

When you complete this step successfully, you should receive the following email. This email may be delivered to your Spam folder. 

If you wish to email a different email address other than the email address you used to set up your Mailgun account, you can enter it in Mailgun under Authorized Recipients. Don’t forget to verify your additional email address in your inbox. 

Part 4: Toilet Paper Level Notifications

In this part, we will combine the distance noted from the ultrasonic sensor in Part 2 with the email sending exercise from Part 3, and set our Raspberry Pi to run the Python code on boot.

1. Open TPLevel.py in Thonny or Geany from your file manager, in the TP_Reminder directory.

2. Enter your credentials on line 18, 19, and 21 as you did in Part 3.

3. Set your emptyDist (line 9) to your measurement from Part 2 minus 2 inches. For example, if your empty toilet paper distance from Part 2 was 19, then set emptyDist = 17. The code checks if the current distance is greater than emptyDist. If you want more advanced warning, use the distance with one roll left.

4. Run TPLevel.py and you should see 1 distance reading appear. Notice that one distance is printed on the screen and then nothing happens? That’s right, the code only checks the distance every 30 minutes and only sends an email if the holder is empty after 2 consecutive checks. If you leave the code running (and your holder is empty), you should receive an email after 30 minutes. Press Ctrl-X  to stop the code. 

5. To speed things up for testing purposes, comment out line 10 (by adding a # to the beginning of the line) and uncomment line 11 (by removing the # before intervalTime). This will check the level every 5 seconds. Run your updated code.

6. Test various scenarios of toilet paper levels with your 5” cardboard. Note if you are working on this project between the hours of 10 pm and 8 am, the default code is set to NOT send emails during those hours. You may need to adjust “endHour = 22” or “startHour = 8” on lines 12 and 13. 22 represents 24-hour military time a.k.a. 10 pm. 

Test Scenarios:

a. Full toilet paper holder for 10 seconds. No email.

b. Remove some toilet paper, but leave 1 roll. No email (unless you changed set the level at one roll distance) 

c. Remove all toilet paper and put your cardboard at the bottom. After two checks that are five seconds apart, you should receive your first email. After another 10 seconds, you should receive your second email. To stop the emails, go to the next scenario. 

d. Add 2 rolls of toilet paper with the cardboard on top. Wait 10 seconds. Emails should stop. 

e. Remove toilet paper. Emails should start over.

7. Adjust the position of your ultrasonic sensor to most accurately measure the toilet paper level. There will be some “jitter” which may produce a few inaccurate measurements, but this should settle down. For example, if the sensor is too close to the sides of the holder, distance readings will reflect the sides and not the toilet paper level.

8. Press Ctrl-X to stop the code.

9. At this point, you can update the code to suit your specific needs. For example, you could update the subject or body of the email in lines 22 and 23.

10. Adjust the interval time back to 30 minutes by undoing your work from Step 5 in this section. Comment out line 11 and uncomment line 10.

11. Save your work.

Next, we’ll want to set TPLevel.py to run on boot.

12. Open /home/pi/.bashrc for editing in the terminal.

sudo nano /home/pi/.bashrc

13. Enter the following text at the bottom of .bashrc and save it (by hitting CTRL + X).

 python /home/pi/TP_Reminder/TPLevel.py 

a. Press Ctrl-X to exit and Y to save.

b. Reboot your Pi.

Once your Pi reboots, it should automatically run TPLevel.py python script every time.

If you look back fondly on rocking out to cassettes in your boombox, you're going to love this DIY project by Martin Mander! It uses a Raspberry Pi to control a tiny scrolling Pimoroni LED screen housed inside a clear cassette tape, turning your boombox's cassette window into a bonafide show. 

The idea came from the trend of clear shell electronics from the ‘80s and ‘90s, which were designed to show off the internal hardware and components. Mander decided to use a Raspberry Pi Zero to control the LED display. The maker opted for the Pi Zero because it's the only edition small enough to fit inside a cassette.

The Pi Zero receives input from an application called If This, Then That (IFTTT), used for programming between compatible apps for Internet of Things (IoT) projects. The Raspberry Pi receives data from IFTT via an Adafruit.IO feed. That data is then processed with a Python script. After, the notification message is displayed across the 11 x 7-inch scrolling LED display. The cassette even vibrates to alert you of new notifications. 

This whole operation is wireless and receives power from a 150mAh LiPo battery. When the battery runs low, it can be recharged via microUSB using an Adafruit Micro Lipo. 

This project is the perfect blend of retro and future tech. If you want to review the build details or recreate it yourself, visit the full project breakdown shared by Mander on Hackster. And be sure to check back here on Tom's Hardware regularly for more cool Raspberry Pi news and projects.

Your garden needs love and attention to flourish. So why not automate that love with the help of a Raspberry Pi? Maker Richard Sears did just that with an invention aptly dubbed GardenPi. It's a fully automated hydroponic/aquaponic control system made to help control and monitor your garden with ease. 

We can't go forward without recognizing how much work Sears invested into this project. It has tools to control sprinkler valves, sensors to detect water levels from his fish aquariums and an application to help manage water flow between his fish and garden plots.

Sears and his family keep aquariums. Up until now, they had to carry buckets of water from the aquariums to the garden by hand. The new GardenPi system takes filtered water from the aquariums and puts it into a reservoir tank. Ultrasonic sensors detect the water levels in the tank, and then GardenPi automatically pumps the water from the tank into the garden when it's time.

The project relies on a 4GB Raspberry Pi 4 model, but Sears insisted that older editions should work just as well. Although, the Pi 4 provides a bit of a buffer with the expanded RAM. 

Sears also fitted his Pi 4 with a touchscreen interface and custom bezel.

If you want to explore the details of this project, check out the full write-up from Sears on Hackster. You can also follow him on Reddit for future updates.

Due to the global pandemic, I’ve seen both useful and funny COVID-19 hacks everywhere. I thought I would make my own COVID life hack with a hand washing timer that is motion triggered and plays a 20-second music clip. Why 20 seconds? Health officials are recommending that we wash our hands often and for at least 20 seconds each time. When I reach for my soap, I trigger this hand washing timer to play a music clip and the display will countdown for 20-seconds.

This is a four part tutorial. In Part 1, you’ll learn how to connect your Raspberry Pi to an external speaker and play music clips via VLC through a Python script. Part 2 is all about adding a 16X2 LCD screen and adjusting contrast. In Part 3, we add the ultrasonic sensor and learn how to measure distance. In Part 4, we pull it all together by triggering the music and the countdown display with the ultrasonic sensor.

What You’ll Need to Build a Hand Washing Timer 

• Raspberry Pi 3B or newer (3B+,3A+, or 4)
• Power supply/Keyboard/Mouse/Monitor/HDMI Cable (for your Raspberry Pi)
• Ultrasonic Sensor
• 16x2 LCD screen with I2C backpack
• Small screwdriver to adjust contrast of the LCD screen
• 3.5mm male-to-male audio cable
• Portable speaker with 3.5mm Aux Audio Jack
• Breadboard
• Set of jumper wires (M-to-F, M-to-M, and F-to-F)
• 2 resistors (330 ohm & 470 ohm)

Optional: 3D print a case for your hand washing timer

This design also requires 4 - M2.5 screws and corresponding nuts to attach the LCD screen + 4 short M2.5 screws to attach the Raspberry Pi to the base.

Part 1: Playing Music on Raspberry Pi Hand Washing Timer 

Connect your speaker to the Raspberry Pi’s 3.5mm jack. If it charges via USB, you can power it from one of the Pi’s ports.

1. Boot your Raspberry Pi. If you don’t already have a microSD card see our article on how to set up a Raspberry Pi for the first time or how to do a headless Raspberry Pi install.

2. Right click on the speaker icon to select ‘Analog’ input. You’ll find it in the upper right corner of the screen. After setting ‘Analog’ input, left click the same speaker icon to set the volume to the middle (or your desired level).  

4. Open a Terminal

5. Install VLC for Python by entering 

sudo pip install python-vlc

6. Clone this repository

git clone https://github.com/carolinedunn/Handwashing_Timer_Display

7. Navigate to the directory you just created

cd Handwashing_Timer_Display

8. Test your setup by entering in the Terminal

python test_music.py

If music plays, then go to the next step, if not then go back and troubleshoot. 

Note: Music should play (20 second clips) followed by a 5 second pause between each song.

Bonus: You can replace the music with your own music by replacing the music files but please keep the naming convention of 1.mp3, 2.mp3, etc. so that you don’t have to rewrite the code. I used Audacity to cut the music down to 20 second clips. The music included in this tutorial is royalty free music.

You’ll need Shutdown your Raspberry Pi and unplug the power for the next part.

Part 2: LCD display for Raspberry Pi Hand Washing Timer 

From the I2C backpack on the LCD screen (using 4 female-to-female jumper wires):

1. Connect GND to a ground pin on the Raspberry Pi.

2. Connect VCC to 5V (pin 2) on the Raspberry Pi.

3. Connect the SDA to pin 3 on the Raspberry Pi.

4. Connect the SCL to pin 5 on the Raspberry Pi. 

5. Boot your Raspberry Pi

6. Open the Raspberry Pi Configuration tool from the Preferences menu in the Raspbery Pi OS GUI. 

7. Enable ‘I2C’ on the Interfaces tab. 

8. Open lcd_disp.py from the Handwashing_Timer_Display folder in Geany. The easiest way is to use file manager to navigate to the folder, right click on the file and select Geany as your editor. y. 

9. Run lcd_disp.py by clicking the paper airplane icon in Geany.

You should now see text across the LCD screen.

10. Adjust the contrast dial on the back of the screen using a screw driver, until you’re comfortable with the output. 

Shutdown your Raspberry Pi and unplug the power for the next step. 

Part 3: Ultrasonic Sensor on Raspberry Pi Hand Washing  

1. Attach a female to male jumper wire to each lead from the ultrasonic sensor.

2. Insert the male-end of the jumper wires to the breadboard in sequential order.

3. Connect  the VCC pin of the ultrasonic sensor to pin 4 of your Raspberry Pi for 5V power.

4. Connect TRIG to GPIO 18 of your raspberry pi.

5. Connect ECHO to a 330 ohm resistor.

6. Connect the other end of the resistor to GPIO 24 of your raspberry pi.

7. Connect a 470 ohm resistor from the 330 ohm resistor to the GND rail.

8. Connect GNC pin from the sensor to the GND rail. 

Side Note: For testing, I found it was easiest to insert the 4 pins of the ultrasonic sensor directly into the breadboard and connect from there. In practice (actual hand washing), adding 4 female-to-male jumper wires between the ultrasonic sensor and the breadboard allowed me to be able to position the sensor for optimal usage.

9. Boot your Raspberry Pi 

10. Open ultrasonic.py for editing using Geany.

11. Run ultrasonic.py by clicking the paper airplane icon in Geany.

As you hold your hand over the ultrasonic sensor, the distance between the sensor and your hand should be measured and shown in the terminal.

12. Press Ctrl-C to exit the program. 

Part 4: Pull It All Together 

1. Measure / estimate the distance between your hand and the ultrasonic sensor to determine the distance you wish to set to trigger the sensor.

2. Open ultrasonic_display.py for editing in Geany

3. Adjust the dist_trig on line 51 to the distance you determined (in inches) to trigger the sensor. Default is 7 inches.

4. Save your changes.

5. Run ultrasonic_display.py

6. Wave your hand over the ultrasonic sensor until you reach the distance you set to trigger the hand washing timer. Once you have moved your hand closer than the distance that you set on line 51, the music should start playing and the display should count down.

After the song ends, the display should read: 

“Great Job! 

All Clean”

The display should pause for at least 5 seconds before going back into “Ready for Motion” status. This prevents the hand washing timer from triggering too often.

When the hand washing sensor has reset, you should see “Ready for Motion” on the display.

7. Click the stop icon to stop the hand washing timer.

8. Set ultrasonic_display.py to run every time you boot your Raspberry Pi if you want it to work every time you power the computer on.  We have instructions here on how to set a script to boot on Raspberry Pi.

Side Note: Parts 2 & 3 all seemed to work with both default Python apps in Raspberry Pi OS (Thonny and Geany). The python code test_music.py and ultrasonic_display.py did not work with Thonny as Thonny could not invoke VLC to play music files. Please use Geany or run in a terminal command > python ultrasonic_display.py 

Optional: When you get your project working you can 3D print a case to enclose your hand washing timer. https://www.thingiverse.com/thing:4559022 

Setup your hand washing Timer to run on Boot 

This step sets up your Raspberry Pi to always run the ultrasonic_display.py script to run on boot.

1. Open a Terminal

2. Enter sudo nano /home/pi/.bashrc

3. Enter the following text at the bottom of .bashrc

python /home/pi/Handwashing_Timer_Display/ultrasonic_display.py

4. Hit Ctrl-X to exit and Y to save.

5. Reboot your Pi. Reboot your Pi. 

Once your Pi reboots, it should automatically run ultrasonic_display.py python script every time.

Enjoy your 20-second hand washing timer!

This Raspberry Pi project wobbles, but it definitely won't fall down. Created by Harry from Raspibotics, this balancing robot was inspired by the Handle robot from Boston Dynamics. It uses a Raspberry Pi as the main board to detect its current orientation and maintain balance.

Harry's balance bot stands out with the addition of two legs complete with custom wheels. This allows for height adjustment to help with stability when tipped towards a given side.

The wheels use two 38mm Nema 17 stepper motors, while each leg uses an MG996R Servo. These components allow for the control necessary to maintain balance.

An Arduino Uno handles all of the PID calculations in real-time. In addition to the Raspberry Pi, Harry used a Picon Zero HAT. This add-on PCB has the form factor of a Pi Zero, helping to keep the overall project build smaller.

If you want to recreate this project yourself, check out the project breakdown on the Raspibotics website. Harry shares everything you need to get started. Be sure to follow Raspibotics for future Pi projects.

You could really bring some fun into your summer with this automated Bubble Bot. It does exactly what it sounds like: delivers a continuous supply of bubbles for its owner. The cool thing is that this robot was made by a Reddit user known as LiquidPsycho and is controlled entirely by a Raspberry Pi.

Bubble Bot, like many Raspberry Pi projects, had a few iterations before reaching the final version shared on Reddit earlier this week. According to LiquidPsycho, one big (and hilarious to picture) problem was a rowdy servo that kept throwing bubble solution everywhere. The maker was able to fix the issue in the final code.

This DIY robot uses a Raspberry Pi Zero and works by dipping a bubble wand into bubble solution with a servo motor. A fan is used to blow the bubbles. You can see it in action on Reddit.

LiquidPsycho provided a complete list of hardware used in the project. It uses a servo, motor and relay board, as well as a 5V 2.1A power bank. If you use the same hardware, you will need a separate lithium-ion battery to power the motor because the power bank isn't strong enough to run everything used in the setup. You may want to consider power alternatives if you plan on building this robot yourself.

You can check out the robot's source code on Github, as well as a detailed list of hardware needed to construct your own Pi-powered bubble bot. Be sure to follow LiquidPsycho on Reddit for more cool Raspberry Pi projects.

The Raspberry Pi may be a great platform for learning, but one major thing it can’t do out of the box is use analog electronic components. That leaves everything from analog joysticks to potentiometers off limits by default, but fortunately adding an expensive chip solves the problem. The MCP3008 ADC (Analog to Digital Converter) is used to connect analog electronics to the Raspberry Pi’s 40 GPIO pins, enabling you to use all kinds of additional components. 

To show you how to take advantage of analog-to-digital conversion and how to make a fun light show, we’ve created a project that will read three potentiometers and use these dials to control the color of an Adafruit NeoPixel. Here’s how to create a colorful Raspberry Pi light show using analog input.

What You Need to Make a light show with your Raspberry Pi:

• Raspberry Pi. Any model can be used
• Raspberry Pi OS on an 8GB+ micro SD card
• MCP3008 Analog to Digital (A/D) converter used to read analog signals and convert them for the Pi to understand
• Adafruit NeoPixels WS2812B LEDs. We used a 12 pixel LED ring from Adafruit
• Soldering equipment. This is only required to solder jumper wires to the NeoPixels.
• A 400 point of larger breadboard. Used to build the circuit
• 3x 10k potentiometers. These are the dials used as inputs
• 6x Male to female jumper wires
• 13x Male to male jumper wires

How to Create a Rasperry Pi Light Show with Analog Inputs 

1. Insert the MCP3008 into the breadboard so that the pins straddle the central cut out. The notch on the chip should face the short end of the breadboard. The 16 pins of the MCP3008 start with 1 in the bottom left corner, then we count along to 8 in the bottom right. Pin 9 is in the top right corner and finally pin 16 in the top left. 

2. Connect the MCP3008 to the Raspberry Pi GPIO using the female to male jumper wires. First female to male wires to connect the 3.3V and GND pins to the + and - rails of the breadboard. Then use male-to-male wires to connect the rails to the MCP3008 pins for power and GND. 

3. Connect the MCP3008 to the Raspberry Pi using female to male jumper wires. 

4. Insert the potentiometers and connect them to the MCP3008 using male to male jumper wires. 

5. Solder three wires to the Adafruit NeoPixels. PWR, GND and In. PWR connects to the + rail on the breadboard, GND to the - rail. “IN” is connected to GPIO 18 on the Raspberry Pi. 

6. Edit the /boot/config.txt file. 

sudo nano /boot/config.txt

7. Add this line to the bottom of the file. It will enable the GPIO to talk to the NeoPixels but it will disable audio output via the headphone jack. Press CTRL + X, Y and Enter to exit when done. Reboot the Pi for the changes to take effect. 

hdmi_force_hotplug=1

8. Install the Python 3 modules for NeoPixels.

sudo pip3 install rpi_ws281x adafruit-circuitpython-neopixel

9.  Open the Thonny IDE, found in the Programming menu.

10. Add the following lines to import modules that enable the code to work with NeoPixels, pause the code, and use the MCP3008 board. 

import boardimport neopixelfrom time import sleepfrom gpiozero import MCP3008

11. Create three variables r,g,b which will store the raw values output by the MCP3008.

r = MCP3008(channel=0)g = MCP3008(channel=1)b = MCP3008(channel=2)

12. Create an object called pixels. This will enable the Python code to work with the NeoPixels.  To this object we pass the GPIO pin which is being used, D18, and the number of NeoPixels in the chain / ring, 16. 

pixels = neopixel.NeoPixel(board.D18, 16)

13. Create a while True: loop which will continuously run the code.

while True:

14. Create three variables, red, green and blue which will store the returned value from the potentiometer. This value is between 0.0 and 1.0 and to convert it into something the NeoPixels can understand we multiply the value by 255. 

        red = round(r.value * 255)green= round(g.value * 255)blue = round(b.value * 255)

15. Print the returned values to the Python shell. 

print(red,green,blue)

16. Create a for loop which will update all 16 pixels in the ring to show the current color mix.

        for i in range(16):    pixels[i] = (red, green, blue)

17. Add a 0.1 second pause to the code.

sleep(0.1)

18. Save the code as analog-inputs.py.

19. Run the code using sudo in a terminal.

sudo python3 analog-inputs.py

20. Turn the potentiometers to control the color of the NeoPixels. 

Complete Code Listing 

Here is all of the code used in this project. 

import boardimport neopixelfrom time import sleepfrom gpiozero import MCP3008r = MCP3008(channel=0)g = MCP3008(channel=1)b = MCP3008(channel=2)pixels = neopixel.NeoPixel(board.D18, 16)while True:    red = round(r.value * 255)    green= round(g.value * 255)    blue = round(b.value * 255)    print(red,green,blue)    for i in range(16):        pixels[i] = (red, green, blue)    sleep(0.1)

MORE: Raspberry Pi Tutorials

MORE: Best Raspberry Pi HATs

MORE: Best microSD Cards for Raspberry Pi

Want to play fetch but don't have a pet? Vlad from The Wonderful World of Vlad YouTube channel has got you covered with his new DIY robot shared recently. The bot uses a Raspberry Pi, an Arduino and OpenCV and can go retrieve a ball placed near it. 

This robot served as the maker's final project for an engineering class. It operates with a series of sensors on a custom track designed by Vlad. The robot can navigate to all four corners of its track and use its sensors to locate a ball to retrieve. There's also a little bar mounted to the back of the bot that scoops the ball safely under the machine for transport.

Vlad used a Raspberry Pi Zero, as its small form factor makes it easier integrate. He also tagged in the Arduino ATMEGA338P board to interface with all of the on-board sensors.

The robot has a mounted battery, making the unit completely wireless. It uses both a Pi Cam and a distance sensor to help determine the ball location. An LCD screen provides a readout of useful data, such as voltage information for the battery or real-time alerts and notifications.

If you want to see this robot in action and learn more about its creation, check out The Wonderful World of Vlad on YouTube and keep an eye out for future maker projects.

Keeping up to date with the latest news is tough and sometimes we need a little help. RSS feeds provide a great way to quickly digest lots of news quickly. Sure you could visit an RSS feed or have an RSS reader on your computer, but what if you could have a simple, dedicated device that only shows the headlines?

Here’s a Raspberry Pi project that will use Python code to read an RSS feed, the Tom’s Hardware feed for example, and display the top five headlines on an LCD screen.

To build this project you will need:

• Any model of Raspberry Pi with Raspberry Pi OS and GPIO Pins
• An I2C LCD screen such as this one
• 4 x Female to female jumper wires

1. Install Python libraries to use LCD screens and work with RSS feeds by entering the following commands:

sudo pip3 install rpi-lcd feedparser

2. Enable the I2C interface via Preferences >> Raspberry Pi Configuration

3. Connect the I2C LCD screen as per the diagram. 

4. Launch Thonny. You can find it on the start menu under Programming.

5. In a new file import libraries of Python code to use the LCD screen, control the pace of the project, read the RSS feed and finally manipulate text into chunks. 

from rpi_lcd import LCDfrom time import sleepimport feedparserimport textwrap

6. Create an object, called “tom” which will store the RSS feed data from Tom’s Hardware. 

tom = feedparser.parse("https://www.tomshardware.com/uk/feeds/all")

7. Create a connection to the LCD and then pause the code for 1 second. 

lcd = LCD()sleep(1)

8. Use a for loop to repeat code five times. If you want more than 5 headlines, change the (5) to a higher number. 

for i in range(5):

9. Print the entries from the Tom’s Hardware RSS feed. The value of i is incremented each time the for loop goes round, to a maximum of five. 

          print(tom['entries'][i]['title'])

10. Create an object called split and use that to save 16 character chunks of the RSS feed. The chunk size is set by the 16 character screen size of the LCD. 

split = textwrap.wrap(text, 16)

11. Create an object called split and use that to save 16 character chunks of the RSS feed. The chunk size is set by the 16 character screen size of the LCD.

split = textwrap.wrap(text, 16)

12. Print “Tom’s Hardware” (or the name of your news source) to the first line of the LCD screen. 

lcd.text("Tom's Hardware", 1)

13. Create another for loop to print the contents of the split object to the LCD screen.

        for i in range(len(split)):    lcd.text(split[i], 2)    sleep(0.5)

14. Add a one second pause before clearing the LCD screen.

     sleep(1)lcd.clear()

15. Save the code as TomsRSSFeed.py 

16. Check your code against our complete code listing. 

from rpi_lcd import LCDfrom time import sleepimport feedparserimport textwraptom = feedparser.parse("https://www.tomshardware.com/uk/feeds/all")lcd = LCD()sleep(5)for i in range(5):print(tom['entries'][i]['title'])text = tom['entries'][i]['title']split = textwrap.wrap(text, 16)lcd.text("Tom's Hardware", 1)for i in range(len(split)):    lcd.text(split[i], 2)    sleep(0.5)sleep(1)lcd.clear()

17. Click on Run to start the code. 

Sometimes tinkerers tap a Raspberry Pi to fix a problem in their life. Other times, they grab the single-board computer just to see how far they can push it. This project shared by Ryan from The Garage Journal is a little different. The DIY display looks like a retro TV but doesn't have any sound. Set to loop the maker's favorite old movies, it's simply a piece of art. 

The retro TV display relies on a Raspberry Pi 4 for all of its primary functions. Ryan designed it to play his favorite classic flicks on repeat while displayed on a shelf. 

And if you do want to get some more functionality out of this vintage-looking display, you can. It's fitted with USB speakers for adding sound output.

Ryan made the retro-style housing entirely from scratch. The switch panel on the front makes use of some really interesting vintage hardware, including a couple of toggle switches protected by switch guards that supposedly came from Apollo 16.

The final unit stands on a curvy mount that allows the display to swivel. The power indicator light works as an indicator that tells you when the Pi 4 is powered on.

According to the post, the maker encountered a small overheating issue (not uncommon with the Pi 4), but he easily overcame this by adding a fan. 

If you want to see more of Ryan's work, check out the official Garage Journal website and YouTube channel for more original content.

There’s nothing quite like the power of real, first-person video. If you’re at home playing with your children or pets, wearing a body camera lets you save those special memories, without sticking your face in your phone. And, if you’re attending a protest and want to capture malfeasance on anyone’s part, it also fits the bill.

While you could go out of your way to buy a dedicated body camera, it’s easy enough to build one using a Raspberry Pi Zero W and a few inexpensive parts. Note that, if you are going to a protest, you’ll want to make your setup as unobtrusive and non-threatening as possible. If you have wires and duct tape hanging out of your jacket, people could get the wrong impression. The photos in this article show our best take on how to make the setup look like the body camera that it is, but you may be able to make it more compact and less scary looking.

This project will record your daily life at the push of a button. It will be constantly recording in two minute chunks, and when triggered it will save the video to disk, before uploading for safe keeping to a private Dropbox folder. So, even if your camera breaks or is confiscated, your video will be available in the cloud. From Dropbox, you can edit and share your videos as necessary.

What You’ll Need to Build a Raspberry Pi Body Camera

• A Raspberry Pi Zero W 
• A microSD Card with Raspberry Pi OS on it
• Raspberry Pi Zero official case
• Raspberry Pi Camera Module. Note that Pi Zeros use a narrower camera cable than other Pis.
• Female to female jumper wires
• A USB power bank
• Soldering iron or Pimoroni Hammerhead to attach GPIO pins to Pi Zero W
• One momentary push button
• A mobile hotspot or phone that goes into hotspot mode
• Double sided tape and sticky tape

Hardware Setup of Raspberry Pi Body Cam 

1. Attach two wires to GPIO 16 and GND on the Raspberry Pi Zero W. You can either solder the wires on or attach GPIO pins to the Pi Zero W, either by soldering them on or using a Pimoroni Hammer Header. Pre-soldered Raspberry Pi Zero Ws, known as the Zero WH, are also available for sale. 

 Using 2x female to female jumper wires and a 2 pin push button connect GPIO16 and GND to the button. 

2. Use a little tape or heat shrink tubing to tidy up the connection. Wrap the tape so that the button and the wires are secure.

3. Insert the camera module to the Raspberry Pi Zero W Camera slot using the adapter. Ensure that the cable is inserted correctly and locked into place. If using the official Raspberry Pi Zero W case, feed the ribbon cable through the slot on the underside of the case.
 

Software Setup of Raspberry Pi Body Camera 

 4. Boot your Raspberry Pi Zero W with peripherals connected. If you don’t already have a microSD card see our article on how to set up a Raspberry Pi for the first time.

5. Turn on your mobile hotspot, or set your cell phone to act as an access point. Make a note of the access point name and the password.

6. Connect your Raspberry Pi to the hotspot via Wi-Fi.

7. Enable the camera module in Raspberry Pi OS. You can do that, by going to Preferences >> Raspberry Pi Configuration, clicking on the Interfaces tab and ensuring that.the Camera interface is enabled. Reboot the Pi for this to take effect.

8. Install the Dropbox library for Python 3 by entering the following at the command prompt.

sudo pip3 install dropbox

9. Navigate to Dropbox Developers www.dropbox.com/developers in your browser and Click on Create Apps to sign in. If you don’t already have a Dropbox account, register for one (2GB Basic Plan is free) and then return to this page.

10. Select the Dropbox API and App Folder access. Then name the app, which creates a folder to store the video files and click Create App. 

A new screen appears.

11. Click Generate under Generated access token then copy this token into a spare text document for later reference.

Coding a Python Script for Raspberry Pi Body Camera 

12. Open the Geany IDE, found in the Raspberry Pi Programming menu.

13. Enter the code as described below. The first line of Python is the location of the Python3 interpreter, this is needed to make the code executable from the terminal. 

#!/usr/bin/python3

14. Import the following libraries to add support for basic IO, a push button, the camera,  date / time and Dropbox. 

import iofrom gpiozero import Buttonimport picamerafrom datetime import datetimeimport dropbox

15. Paste the Dropbox token into the code, and then assign it to a variable called “token”. Then a connection to Dropbox is made using the token for authentication. 

token = "DROPBOX TOKEN HERE"dbx = dropbox.Dropbox(token)

16. Create an object, “trigger” that will be used to link the button connected to GPIO 16 to the code. 

trigger = Button(16)

17. Create a connection to the Raspberry Pi Camera, then set the resolution to 720p.

camera = picamera.PiCamera()camera.resolution = (1280, 720)

18. Create a recording stream. A stream is used to create a circular buffer that will record events before the button is pressed. Here the camera is instructed to record 2 minutes before activation. The stream is recorded to an h264 file. 

stream = picamera.PiCameraCircularIO(camera, seconds=120)camera.start_recording(stream, format='h264')

19. Add a try statement which will attempt to run the code indented within it, in this case it will start with a loop to constantly run the code within. 

try:while True:

20. Create a delay, forcing the camera to wait for one second each time the loop iterates. 

camera.wait_recording(1)

21. Create an if condition for the trigger and set the current date and time, used later as a timestamp. When the user presses the button, this if condition will start the process of capturing video. 

                if trigger.is_pressed:        now = datetime.now()

22. Print a message to the terminal to show that the recorder has been triggered and set the recording time to 120 seconds.

                print("ACTION")        camera.wait_recording(120)

23. Add this code to save the video stream to a file, which uses the timestamp as the filename, and appends the file format to create a valid file. Another message is printed to advise the user. 

                stream.copy_to(str(now)+'.h264')        print("Stream saved to disk...will upload to Dropbox")

24. Add this code to enable the script to open the freshly created video file in read only mode and upload it to Dropbox, overwriting any files that share the same name. A message is printed to the Terminal when this is complete. 

with open(str(now)+'.h264',"rb") as data:            dbx.files_upload(data.read(),'/'+str(now)+'.h264',mute=True, mode=dropbox.files.WriteMode.overwrite)        print("File uploaded to Dropbox")

25. Create these last two lines of code to stop the camera recording when the user stops the code from running. 

finally:camera.stop_recording()

26. Save the script as video-recorder.py and then close Geany. 

This Raspberry Pi project is ready for takeoff -- or at least it's ready to plan your drone's next takeoff. We recently spotted this fascinating creation from Sky Horse Tech that uses a Raspberry Pi as the mainboard and shows weather and current FAA advisories on a 32-inch display.

This is extremely useful for anyone planning to fly a drone, as laws and regulations vary across the U.S. and can impact when it's okay to fly. It's important to be mindful of any restrictions or compromising weather conditions before you take off.

The team built a custom housing for the kiosk made from wood. They connected a Raspberry Pi 3 B  to an LED screen with 720p resolution. The Pi runs a few applications on top of Raspberry Pi OS, formerly known as Raspbian. It uses three separate API, one for weather information and two for FAA advisories called AirMap and MapBox.

The kiosk is pre-programmed to shut off at night,. This not only saves power but makes sense, considering you can't fly unmanned aircraft systems (or UAS) at night. The team added a few different networks to the Pi so it could be easily transported and set up at different locations.

If you're interested in recreating this drone kiosk for yourself, check out the Sky Horse tech website. The team created a really comprehensive guide to help get you started, including blueprints for the kiosk cabinet. 

Raspberry Pi projects meant for kids are always a plus, as they get young minds excited about STEM. This DIY jukebox, created by a user known as Milkris on Reddit, was made for his two young daughters. It lets his kids jam out by using a Raspberry Pi as the main board of a radio-frequency identification (RFID) jukebox. 

The maker made the jukebox's case by hand with wood. It also features 3D printed designs on the outside. The end result is a finished box with a library of content available for exploring. 

This DIY radio is controlled with custom cards fitted with RFID chips. The kids can select a card with an artist, scan it on the radio and use the buttons to interact with the associated tracks. You can find a full step by step album of progress pictures on Imgur.

You can make RFID cards for any kind of audio file, including audiobooks. The buttons on Milkris' DIY jukebox appear to be arcade buttons with 3D-printed toppers. They also control the overall volume of the device.

If you'd like to see more, be sure to follow Milkris on Reddit. There's a thread for this Raspberry Pi jukebox project with a little Q&A about the process.

Raspberry Pi projects are more about what you can do with a Pi, not what you should do. Earlier this week, Shane with the Game Dev Academy YouTube channel pushed the Raspberry Pi to its limits by using it for 3D modeling with Blender. 

Don't get too excited. A Raspberry Pi is far from being the ideal 3D modeling computer. You'd still be much better off running Blender on a more capable desktop PC. But this developer has shown that Blender on Pi as at least possible. 

This project was inspired out of necessity (like most Pi projects). Shane said he was working on a new tutorial when his graphics card failed. Instead of rushing out and buying a new graphics card, he looked to see if a Pi could get the job done.

Blender doesn't require much in the way of hardware. Shane decided to use version 2.79, which requires 4GB of RAM and a dual-core CPU with a clock speed of at least 2 GHz. However, it's recommended that you use 16GB of RAM and a quad-core CPU. Shane chose to use a 2GB Raspberry Pi 4, which features a 1.5-GHz processor with four cores. 

Setting up Blender on Raspberry Pi 

Getting Blender to run on the Raspberry Pi looked easy enough, based on what the Game Dev Academy's video showed us. 

You'll need a Raspberry Pi with Raspbian installed. Shane searched for Blender in the Add / Remove Software window to get the Blender 2.79 package. 

Once installed, Blender launched, and Shane demonstrated its capabilities with a time-lapse video. The biggest drawback came with rendering, which took much longer to complete on a Raspberry Pi than a desktop. 

 If you want to see more of Shane's work, check out Game Dev Academy on YouTube for more projects and 3D modeling tutorials. 

This Raspberry Pi project is seriously delicious. Harrison McIntyre is using his time in lockdown to create a Pi-powered candy launcher that shoots M&Ms at his mouth from across the room.

McIntyre's creation has a Raspberry Pi receives voice commands by using an Amazon Echo Dot. When triggered, it uses a camera to detect a face and determine how far away it us before launching candy toward the face. 

McIntyre had to work out the logistics of how to accurately project candy along the best trajectory. He opted to use regular M&Ms because of their consistent shape and size. The launching device can swivel and tilt up or down.

Other similar projects use a spring-loaded mechanism for launching; however, McIntyre opted for a flywheel design. This proved to be an excellent move, providing better control over velocity without the reload time that comes with using a spring. With everything together, McIntyre could control the angle, velocity and direction of each launch.

This project was built using a Raspberry Pi 3, but other editions should work just as well. 

There's a lot that goes into this project, from setting up a number of servo motors to 3D printing the chassis for the launcher. 

You can check out a complete breakdown of this project on YouTube:

If you enjoyed this project, be sure to check out Harrison McIntyre's YouTube channel for more projects and future updates on this one. 

If you want to check Twitter, this Raspberry Pi-based bot is one way to do it. This project tracks specific hashtags in real-time, with LEDs lighting up when someone tweets the hashtag. The project comes from a Reddit user known as MrEdews.

Handy for social media fanatics, the project relies on an application called Tweepy to monitor Twitter for certain hashtags. Tweepy is a Python library designed to access Twitter's API. This makes it possible to read and respond to specific hashtags right as they're used.

Tweepy can handle sifting through tweets with multiple hashtags. MrEdews programmed his setup to keep checking until it found one of three hashtags: #quarantine, #corona and #covid19. He assigned a specific color LED to each hashtag. When the Raspberry Pi detects one of the hashtags, it illuminates the corresponding LED.

This is a fun Raspberry Pi project that should work with any model of the Raspberry Pi. If you'd like to see more, follow MrEdews on Reddit for a video demonstration of the Twitter bot and more cool Pi projects.

You don't ever want to find yourself without a computer.T hat's why one maker, known as Blackie810 on Reddit, designed this handy Raspberry Pi-based emergency recovery tool. Everything you need is housed inside a protective Pelican case.

According to Blackie810, this emergency Pi rig is perfect in the event of an EMP attack or network outage. It can help with recovery or, using some features to stream media to local devices, even entertainment. 

In addition to some applications, it also has quite a bit of data stored that can be seriously useful in an emergency situation. The project can provide offline access to maps—perfect for an off-the-grid getaway—or even encyclopedia services like Wikipedia. 

It doesn't take much hardware to build one of these yourself. It uses a Raspberry Pi 4, but older models will work too. The creator used a 7-inch touch screen display and a 256GB microSD card for storage. Everything was housed inside a waterproof Pelican case and supported using a 3D printed frame.

When the system first boots, it loads a boot menu, where the operator can choose an instance of Debian, Kali or ParrotSec to load. This is just the OS list chosen by Blackie810 though; the device can support many different Linux distros and even Android.

Blackie810 has a few upgrades, including a permanent keyboard solution and batteries for mobility, planned for the future. 

Until then, you can follow Blackie810 on Reddit for more updates and future Raspberry Pi projects.

If you're looking for a fun, music-based Raspberry Pi project, check out this Pi-powered granular synth called noLoop. Created by industrial designer Niles Fromm, it's built on top of a Raspberry Pi and features a handmade case with a screen for visual output.

The Raspberry Pi in the noLoop uses the Python programming language and Pure Data, which is synth software used to create custom sounds that can be controlled either digitally or physically (via hardware input). The visual display features a user interface designed with PyGame, a Python module set originally for writing video games. With this display, you get real-time visual feedback of the current audio output.

The synth offers four individual granulated audio samples, and you can filter, randomize and chop each sample using the switches. Fromm opted to use a series of knobs to adjust things like volume, pan and metronome values. There are a few master knobs to adjust things universally, like volume.

If you want to recreate this project yourself, you're in luck. Fromm provided everything you need to set up Pure Data with his custom patch files on GitHub. You can see what goes into the creation process and maybe even improvise for your own custom design.

There are a few updates planned for noLoop. Fromm has expressed serious interest in SuperCollider, a programming language for real-time audio synthesis, and hopes to integrate new features with it. In the meantime, you can check out his website for more work and future projects.

There are a number of different apps that let you monitor how your PC's components are doing, but this one brings in the DIY fun of Raspberry Pi. Created by Debayan Sutradhar, a young developer with a serious knack for Pi projects, this resource monitor lets you check things like CPU temperature and RAM usage.

The Pi-powered system monitor also lets you check fan speed and even GPU performance. Sutradhar used a Raspberry Pi 3 B, but the project can run on other Pi models, like the Pi Zero, as well. The maker also had the UI displayed on a 7-inch (17.78cm) screen.

Sutradhar created the UI with JavaFX, and the UI pulls data from a Windows-based hardware monitoring tool. The PC app has a few settings that can be changed, like how frequently the information is updated on the Pi display. Overall, the setup has very little impact on performance, using just 30MB of RAM after three hours of running.

This project is still a work in progress and Sutradhar promised on Reddit to provide us with more updates. You can download the server and client applications on Github. The PC app is Windows-based, but Sutradhar also expressed interest in adding macOS and Linux support. In the meantime, check out some of his other projects and follow him on Twitter.

RGB lighting has made a name for itself in the computing space, especially when it comes to gaming. But what if you could bring the trend from your gaming den to the living room? With this project shared on Reddit this week by a maker known as Moe7863, you can bring RGB to your TV with a Raspberry Pi. 

The setup relies on a Raspberry Pi 4 to control 116 individually addressable LEDs. It also uses a USB camera to detect the current image and assign a color for each LED based on its location along the edge of the screen.

It doesn't take much hardware to recreate the project. In addition to the Pi 4, you'll need an Arduino Uno R3, LED strip, USB camera and a power supply. You don't even need an expensive LED strip, Moe7863 had no trouble using a generic LED strip from Amazon.

Moe7863 mounted the USB camera to the wall across the room. It required a 10m (32.8 feet) USB extension cable to reach the Raspberry Pi. There is a slight 50-100ms delay, as input information has to travel from the camera, through the Pi and to the Arduino before reaching the LED strip.

This is still a work in progress with plans for improvement. If you'd like to check this project and more of Moe7863's work, you can follow him on Reddit. 

This might not be the first ambient lighting project for the Raspberry Pi, but we appreciate Moe7863 for bringing it to the Pi 4 and showing that you don't need expensive hardware to build awesome projects at home.