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

I’ve often struggled with procrastination, and to-do applications have been lifesaving. I sometimes find myself needing a reminder to just focus on getting the most important task done before working on anything else. 

With that in mind, I created a simple photo frame to sit on my desk and remind me of my most important task of the day using e-paper and a Raspberry Pi. I wanted to use e-Paper specifically since it’s low-power and not as distracting as a standard display would be. If you’re the kind of person who likes a simple reminder of your most important tasks, here’s how to build it for yourself.

What You’ll Need For This Project

• Raspberry Pi 4, Raspberry Pi 3, or Raspberry Pi Zero with power adapter
• 8 GB (or larger) microSD card for Raspberry Pi
• 7.5” Black & White Waveshare E-Paper Display & Hat
• 5x7 Photo Frame
• A ToDoist account with Tasks in it
• Black construction paper

How to Build a To Do Reminder Frame with E-Paper and a Raspberry Pi

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/todo_reminder_frame.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.

cd ~/todo_reminder_frame/make install

4. Locate the VCC and Ground pins on the e-paper hat, connect them to Raspberry Pi BOARD pins 4 and 6 respectively.

5. Locate the DIN and CLK pins on the e-paper hat and connect them to Raspberry Pi BOARD pins 19 and 23 respectively.

6. Locate the CS and DC pins on the e-paper hat and connect them to Raspberry Pi BOARD pins 24 and 22 respectively.

7. Locate the RST and BUSY pins on the e-Paper hat, connect them to Raspberry Pi BOARD pins 11 and 18 respectively.

8. Using the included ribbon cable, connect your e-paper display hat to your e-paper display, if not already connected.

9. Enable the SPI interface by opening raspi-config and following through the menus.

sudo raspi-config> 3 - Interface Options> p4 - SPI> Enable> Finish

10. Restart your Raspberry Pi.

sudo reboot

11. Create a ToDoist account and add to-dos, if you haven’t already.

12. Visit your ToDoist integration settings and copy your API token at the bottom.

13. Export your API token to your environment.

nano ~/.bash_profile# Add the following line near the end of the fileexport TODOIST_PERSONAL_TOKEN=your_copied_token# Ctrl X, then Y, then enter to save and exit.

14. Re-source your environment and run a test. You should see some logs appear indicating the display is retrieving tasks.

source ~/.bash_profilecd ~/todo_reminder_framemake runINFO:root:Starting displayINFO:root:Starting 7.5 inch E-Paper ModuleINFO:root:Running displayINFO:root:Checking for updatesINFO:root:Getting latest taskINFO:root:Latest task has changedINFO:root:Updating display with latest taskINFO:root:Getting image bufferINFO:root:Writing image to paper

15. Check that your display is updating. It should flash and update with your most urgent task. If nothing is happening, and the logs look normal, you may have a pin out of place. For further troubleshooting, visit the manufacturing guide.

16. Remove the back from your 5x7 photo frame and tuck in the e-paper display.

17. Tuck in the e-paper display with a piece of black construction paper over the top to cover up the edges.

18. Close the back of the frame, allowing the ribbon cable to carefully wrap around.

19. Tuck the hat and the Pi behind the frame, or hot glue them into place behind the frame.

20. Run the application. It will periodically check for the latest highest priority task with the soonest deadline in your ToDoList application.

make run

A new Raspberry Pi OS based upon Debian 11 (Codenamed: Bullseye, following a Toy Story character naming convention) has been dropped and it has Raspberry Pi fans clamouring to install the latest OS on their favorite single board computer.

There are big changes for the latest Raspberry Pi OS, including a free speed boost for Raspberry Pi 4 / Compute Module 4 owners who have a certain SoC model, and a new compositing window manager which speeds up overall desktop performance.

Raspberry Pi OS “Bullseye” works with all models of Raspberry Pi, but the best performance is found using Raspberry Pi 4, Compute Module 4 and Pi 400. These models can benefit from the speed boost (except the Pi 400, where it is the default). If they have 2GB of RAM or greater, they can also use the new compositing window manager.

The ideal way to install the latest OS is to backup all your project and data files and then do a clean install using Raspberry Pi Imager to write to a microSD card, but it is possible to upgrade an old Debian 10 “Buster” based Raspberry Pi OS to Bullseye.There is a caveat, however, as it may not be the smoothest of upgrades. So before you take the plunge make sure that you have a backup of any important files and projects.

How to Upgrade to the Latest Raspberry Pi OS

1. Open a terminal and update the software repositories lists.

$ sudo apt update

2. Run a full upgrade of your installation.

$ sudo apt dist-upgrade -y

3. Update the Raspberry Pi firmware.

$ sudo rpi-update

4. Open the sources.list file ready for editing.

$ sudo nano /etc/apt/sources.list

5. Using the arrow keys, scroll down the file and locate the following line.

deb http://raspbian.raspberrypi.org/raspbian/ buster main contrib non-free rpi

6. Change the line from buster to bullseye and press CTRL + X, then press Y and Enter to save and exit.

deb http://raspbian.raspberrypi.org/raspbian/ bullseye main contrib non-free rpi

7. Update the Bullseye software repositories.

$ sudo apt update

8. Run another distribution upgrade to install the Bullseye software requirements.

$ sudo apt dist-upgrade

9. Clean up the installation files.

$ sudo apt autoclean

10. Reboot your Raspberry Pi for the change to take effect.

$ sudo reboot

You are now running the latest version of Raspberry Pi OS based upon “Bullseye”.

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!

If you're at all interested in gaming on PCs, you’ve probably come across Steam, Valve’s platform for distributing, updating and running games. Steam makes it possible to purchase a game, install it over the internet and then run it from the Steam interface. Ah, but that brings us back to the age-old Linux gaming conundrum of support, as not every PC game is designed to run on anything other than Microsoft Windows. 

That said, there are plenty of Steam games that will run on Linux, and quite often, a Windows Steam game can be convinced to run on Linux even though some ‘fettling’ by the user may be required. This approach is officially supported by Steam using a system called Proton. Getting all of these things running, and then possibly optimising the results, is what we’ll be looking at in this tutorial.

Steam itself is installed through a custom program called the Steam Installer. This makes sense, because Steam updates itself and the games you install with it, without relying on Linux’s own update systems. These days, the installer is in the official repositories of many Linux distributions such as Ubuntu and Fedora and their derivatives. As Steam is proprietary software you may have to enable a specific repository, such as ‘Multiverse’ for Ubuntu or ‘Nonfree’ on Fedora. 

To install Steam on Ubuntu open a terminal and type

$ sudo apt install steam-installer .

If you’re running a DEB-based distribution, but you can’t find the Steam installer in the official repositories:

1. Download the the installer directly from the Steam website

2. Open a terminal.

3. Install the downloaded file. 

$ sudo dpkg -i [name of archive]  as the super user.

The Steam application should now be available via your distros menu.

There is also another, unofficial, way of installing Steam that all Linux users might find interesting, and that is installation via the Flatpak system. This offers a few advantages of its own in terms of privacy and sandboxing, as Steam is a system unto itself once it’s on your system. Installation instructions can be found on the Flathub site.

Running Windows Games via Steam on Linux 

There are many great games that run via Steam on Linux, but what if you want to run a game that doesn’t offer a Linux version? In such cases, there is a good chance that it can be made to run using a system called Proton. 

An official part of Steam on Linux, Proton makes use of both Wine and DXVK, layers that translate Windows software and graphics calls into native Linux ones. However, there are some caveats. Firstly, compared with how the game runs natively on Windows, performance and stability might be an issue. Secondly, it does raise some ethical questions as, arguably, running the Windows version under Linux might reduce pressure on the developers to make a Linux native version of a game. 

Getting back to the first point, the best way to get answers about the viability of running a particular game is to search for it on the ProtonDB website to see what luck other Linux users had with it. The database itself is well organised and includes information about when the testing was carried out and what the specific hardware and software configuration used was. The level of success of running the game on Linux is rated from ‘Borked’ to ‘Platinum’. So, if you find a recent, highly-encouraging report about the game running well on a similar set-up to your own, the odds are good. In addition, ProtonDB reports contain information on tweaks you can use to make stubborn games run properly.

To run Windows versions of games on Linux:

1. Go to Steam > Settings > Steam Play.

2. To enable approved games select ‘Enable Steam Play for supported titles’. Or to enable all games, select ‘Enable Steam Play for other titles’. For the latter option check the game's ProtonDB entry for compatibility and issues. 

Troubleshooting and Tweaking Steam on Linux

If you look through ProtonDB, you’ll notice quite a lot of references to Winetricks. So what is it? Winetricks is a helper script that installs various Windows components that are needed by games. The script pulls through the component and makes it visible to the Wine subsystem, and it’s worth knowing about, even if you’re using Wine outside of Steam.

To install Winetricks:

1. Open a terminal and change directory to Downloads. 

$ cd "${HOME}/Downloads"

2.  Download Winetricks.

$ wget  https://raw.githubusercontent.com/Winetricks/winetricks/master/src/winetricks

3. Change the file permissions to set Winetricks as an executable file. 

$ chmod +x winetricks

4. Using Winetricks, install CoreFonts, used by Windows applications via Wine.

$ ./winetricks corefonts

Things can get complicated if you want to apply Winetricks fixes to a specific Proton game, but not by much. Thankfully, there is a helper script called Protontricks for just this purpose.

1. Install Protontricks. Open a terminal and use the Python packaging tool “pip” to install. 

$ pip3 install prototricks

2. To apply Protontricks to a specific game, you need to discover the specific game ID of that game using Protontricks itself. For example typing protontricks -s fallout found Fallout and Fallout 4 installed on our Linux gaming machine. 

$ protontricks -s 

3.  Visit the ProtonDB entry for that game. For example, we looked at the entry for Cyberpunk 2077 which has a gold rating, but requires a few tweaks in order to work.

4. Use the Winetricks commands that match the requirements for your game. Typically the syntax is.

$ protontricks [game ID] [Winetricks command]

5. Start your freshly-patched game via Steam.

Special Options for Steam on Linux Games 

Some games may need special launch options to be added in order for them to run correctly. To do so:

1. Right click on the game name in your Steam Library and select General.

2. Type in the launch options from the ProtonDB entry. Typically these end with the string %command%.If there are multiple launch options, ensure that there is only one %command%

You may need to edit a game INI file.

1. Right click on the game name in your Steam Library, select Properties.

2. In the Local Files section click on Browse to locate the INI file.

This guide originally appeared in issue 281 of Linux Format magazine. 

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.

A friend of mine recently had a break in at his cabin up north. He wanted to know if I had any recommendations on technology that could let him keep an eye on things from far away. The only challenge is his cabin is relatively remote, and cell service or internet isn’t available in the area. With that in mind, I wanted to design a solution that would keep an eye on things using a Raspberry Pi, a bit of edge computing, and a satellite connection.

For this project I’m using the Swarm satellite constellation; it’s a low cost solution for providing satellite connectivity for internet-of-things devices in remote locations. Where one solution would be to livestream images from a camera using a high-bandwidth connection for off-site processing, this project does on-site processing (edge computing) instead sending only the results, letting us keep this project running for a long time at the low cost of $5 a month. Here’s how to build a remote cabin monitoring and alerting system with a Raspberry Pi, a camera, and the Swarm Eval Kit. 

What You’ll Need For This Project

• Raspberry Pi 4 or Raspberry Pi 3 with power adapter
• 8 GB (or larger) microSD card
• Raspberry Pi Camera
• Swarm Eval Kit & Data Plan
• An internet connection for the initial setup

How To Build A Remote Cabin Monitoring System with a Raspberry Pi

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 download all the necessary source code for person detection and communicating with the Swarm tile. 

cd ~/git clone https://github.com/rydercalmdown/remote_cabin_monitor.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. The machine learning library we’re using to detect people is packaged within one of the Python libraries, so it may take a few minutes to install.

cd ~/remote_cabin_monitor/make install

4. Connect your Raspberry Pi Camera to the Raspberry Pi and mount it in the desired location.

5. Test your Raspberry Pi Camera by taking a snapshot with the following command.

raspistill -o test.jpeg

6. Assemble and register your Swarm Eval Kit using the instructions in the quickstart guide. This will get it connected to the network for transmitting data. 

7. Turn on your Swarm Eval Kit system with the button on the side.

8. Set your Raspberry Pi Wi-Fi to the Swarm Evaluation Kit SSID. This will need to be done directly on the pi with an external monitor and keyboard. Any SSH connections to the pi will be dropped when the pi switches to the Swarm SSID.

The easiest way to do this is by using raspi-config (sudo raspi-config), navigating to System Options->WIreless LAN and then entering the Swarm Eval Kit’s SSID (you’ll have to find this on another device where it will be swarm-xxxx) and entering a default password of 12345678.

9. Run the application to test it. If the Raspberry Pi is connected to the Swarm Kit successfully, it will send a startup email over the network. Depending on your satellite availability it can take some time to arrive in your inbox; use this pass checker to determine when a satellite will be overhead.

cd ~/remote_cabin_monitormake run

10. Configure the application to run on boot by adding a line to the /etc/rc.local file.

sudo nano /etc/rc.local# Add the following line before the last line. /home/pi/remote_cabin_monitor/env/bin/activate && export EMAIL_FROM=youremail@example.com && export EMAIL_TO=youremail@example.com && /home/pi/remote_cabin_monitor/env/bin/python /home/pi/remote_cabin_monitor/src/app.py &

11. Place the Swarm Eval Kit in view of the sky, and mount the Raspberry Pi and camera in your desired location.

When running, the Raspberry Pi will continuously pull images from the camera and check them for the presence of a person. If a person is detected, the Pi will send a message to the Swarm Eval Kit, which will then communicate with a constellation of satellites via VHF. The satellites will relay the message to a downlink, and you’ll then receive an email indicating a person has been detected. The Pi will also send an email every 24 hours that no people have been detected in order to let you know it’s still working.

This type of system can also be modified to send more than just person-detection data. Leak detection, fire detection, and any kind of sensor that can communicate with a Raspberry Pi are all possible to send over the network.

I want to buy a smart doorbell, but the cost of them is a little outside of my budget. Instead, I’m using a Raspberry Pi, a speaker system, and a camera to build a smart doorbell system for a fraction of the cost.

In our last project, we created a doorbell system which rang when a person was at the door. This time we’ll expand on the code to allow the project to identify when people we know are at the door, and announce it accordingly. This will let us choose to either run to the door, or hide upstairs when our friends or inlaws drop by unexpectedly. 

What You’ll Need For This Project

• Raspberry Pi 4 or Raspberry Pi 3 with power adapter
• Desktop speakers or a megaphone with a 3.5mm input and 3.5mm cable
• Wyze Cam V2 (Wyze Cam V3 is not yet compatible)
• 2x8 GB (or larger) microSD cards, one for Raspberry Pi, another for the camera.
• Monitor with HDMI and power cables. (Optional)

How to Turn a Raspberry Pi into a Facial Recognition Doorbell System 

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/facial_recognition_doorbell.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 ~/facial_recognition_doorbell/make install

4. Set the 3.5mm audio output to be the default audio output in raspi-config. You do this by launching raspi-config (entering sudo raspi-config at the command prompt) and navigating to System Options -> Audio -> Headphones 1. The pi allows for audio to be outputted to either the 3.5mm analog output, or over the HDMI port. If you do not have a monitor attached, headphones may be the only option. 

sudo raspi-config# Navigate to System Options -> Audio -> Headphones 1

5. Plug your speakers into your Raspberry Pi using a 3.5mm cable. 

6. Test your speakers by playing the doorbell audio file. You should hear a doorbell sound from your speakers. In my case I’m using a megaphone, but feel free to use whatever speakers you have available. 

mpg321 /home/pi/facial_recognition_doorbell/src/audio/doorbell.mp3

7. Test text to speech on your pi by running the following command. You should hear the text spoken out loud through your speakers.

say ‘hello there’# Press Ctrl + C to exit if stuck

8. 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. You will need a Wyze V2 camera and a microSD card.

9. Get the RTSP URL value from your Wyze application, and edit the RTSP_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.

cd ~/facial_recognition_doorbell/nano Makefile# STREAM_URI=rtsp://your_username:your_password@camera_ip_address/live

10. Install your camera facing outwards from your front door. Keep in mind the Wyze V2 is not weather proof, so I’m keeping mine in a covered area. Ideally the camera should be mounted above the door pointing directly towards any person who would approach. This allows the facial recognition to work best. 

11. Download photos of known people and save them with their file names. Any .jpeg, .jpg or .png photo with someone’s face will work. There should be only one face per photo, and it’s not necessary to use more than one photo for each person. I have one for each one of my friends that comes by my house.

ryder.jpeg

12. Copy the photos of known people into the src/faces directory. 

mv ryder.jpeg /home/pi/facial_recognition_doorbell/src/faces/

13. Run the “make run” command on the pi to start the doorbell system. The system will first look for the detection of a person. When a person is detected, the doorbell will ring, and the system will start identifying any known faces from the faces directory. If a face is found, the system will announce the person at the door using text to speech. 

We now have a system that will ring whenever a person is at the door, and announce their name if we have their photo on file. 

I don’t have a doorbell, and while I could go out and buy a wireless one - I never pass up an opportunity to over-complicate something for the sake of learning to do something new. Today we’re dipping our toes into home security by building an automatic person-detecting doorbell system using a security camera and a Raspberry Pi.

While we’re using a doorbell sound effect in today’s project, this technology can be easily adapted to monitor other areas of your home, alerting you with a sound effect if someone’s in your garage, backyard, or anywhere else you can put a camera. 

Here’s how to use a Raspberry Pi, a security camera, and a bit of machine learning to detect if someone’s at your door and play a doorbell sound effect.

What You’ll Need For This Project 

• Raspberry Pi 4 or Raspberry Pi 3 with power adapter
• Desktop speakers or a megaphone with a 3.5mm input and 3.5mm cable
• Wyze Cam V2 (Wyze Cam V3 is not yet compatible)
• 2x8 GB (or larger) microSD cards, one for Raspberry Pi, another for the camera.
• Monitor with HDMI and power cables. (Optional)

How to Turn a Raspberry Pi into a Person-Detecting Doorbell

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/person_detecting_doorbell.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. The machine learning library we’re using to detect people is packaged within one of the Python libraries, so it may take a few minutes to install.

cd ~/person_detecting_doorbell/make install

4. Set the 3.5mm audio output to be the default audio output in raspi-config. You do this by launching raspi-config (entering sudo raspi-config at the command prompt) and navigating to System Options -> Audio -> Headphones 1. The pi allows for audio to be outputted to either the 3.5mm analog output, or over the HDMI port. If you do not have a monitor attached, Headphones may be the only option.

sudo raspi-config# Navigate to System Options -> Audio -> Headphones 1

5. Plug your speakers into your Raspberry Pi using a 3.5mm cable. 

6. Test your speakers by playing the doorbell audio file. You should hear a doorbell sound from your speakers. In my case I’m using a megaphone, but feel free to use whatever speakers you have available.

mpg321 /home/pi/person_detecting_doorbell/src/audio/doorbell.mp3

7.  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. You will need a Wyze V2 camera and a microSD card.

8. Get the RTSP URL value from your Wyze application, and edit the RTSP_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.

cd ~/person_detecting_doorbell/nano Makefile# STREAM_URI=rtsp://your_username:your_passport@camera_ip_address/live

9. Install your camera facing your front door. You can place it anywhere you like, but I have mine mounted outside. Keep in mind the Wyze V2 is not weather proof, so I’m keeping mine in a covered area. 

10. Run the “make run” command on the pi to start the doorbell system. When a person is detected in the frame, the doorbell will ring continuously with a 5 second delay in between rings until the person leaves the frame. 

You can adjust the delay between rings in app.py, and modify the doorbell sound effect by replacing the .mp3 file within the repository. Now all that’s left to do is wait for people to arrive.

Pro tip: use a sound effect of barking dogs instead of a doorbell to make this more of a security system than a doorbell.

There are many options out there for content creators when it comes to teleprompters, but most affordable ones involve an app on your phone that can be clunky or extra hardware that may not work well with your camera setup. However, you can build your own Raspberry Pi-powered teleprompter,  using some Python code, basic electronic components and 3D printed parts. 

What You’ll Need: Raspberry Pi Teleprompter

• Raspberry Pi 4B
• 3 tactile momentary buttons
• sliding switch
• Adafruit Perma-Proto HAT
• Adafruit TFP401 HDMI/DVI Decoder to 40-pin TTL Breakout Without Touch
• 5" 40-pin 800x480 TFT Display without Touchscreen
• HDMI to Micro-HDMI cable
• Black PLA Filament
• Wire and Soldering Iron

Software Setup of Raspberry Pi Teleprompter: Install Dependencies and Scripts

The Python code requires a few dependencies. You'll need to install two libraries: Tkinter and pynput, along with Adafruit’s Blinka layer.

1.  Install Tkinter using the apt-get command in the terminal. Tkinter is a Python library for creating basic graphical user interfaces and here it's being used to create the teleprompter application portion of the project.  

sudo apt-get install python-tk

2. Install Pynput using pip3. Pynput is a keyboard and mouse simulator Python library. For this project, it's being used to simulate mouse scrolling for the text box created with Tkinter.

pip3 install pynput

3. Install Blinka,, an Adafruit CircuitPython compatibility layer for single-board computers running Linux. Blinka also lets you run CircuitPython libraries alongside Python libraries. The basic setup just involves entering these three commands:

sudo pip3 install --upgrade adafruit-python-shellwget https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/raspi-blinka.pysudo python3 raspi-blinka.py

If you have issues, see Adafruit’s Blinka install guide.

4. Download all three .py files from my github page and place them in  your /home/pi directory. 

Python Scripts for Raspberry Pi Teleprompter

The software for the teleprompter involves two Python scripts (you downloaded above) plus one Bash script. The first Python is the actual teleprompter app written with Tkinter. The code creates a scrollable text box where you can display your scripts. There is also a button on the side of the app. When you click it, you can open text files to load into the text box. If you need to make any edits to your script while it is open in the app, you can type directly into the text box.

The second Python script is for controlling the teleprompter app with external digital inputs. In this program, we're using the pynput library and Blinka, to simulate mouse scrolling inputs and the buttons. It can be thought of as the control interface for the Tkinter script.

When the switch is engaged, pynput will begin scrolling allowing your teleprompter to run. Two buttons are also available to increase or decrease the speed for the scrolling. Finally, one additional button is available to toggle between having the teleprompter app be full screen or windowed on the Pi.

We can use a bash script to run the two Python scripts concurrently. The Bash script is launched from the terminal using “sudo ./tele.sh”. 

Wiring  the Raspberry Pi Teleprompter

To interface with the buttons to control the teleprompter on the Raspberry Pi, we're using an Adafruit Perma-Proto HAT. It is a breadboard-style blank board that lets you easily solder circuits for use with the Pi. It has power, ground and GPIO pins broken out and labeled. 

The Fritzing circuit diagram will show you how to wire up the three buttons and the sliding switch. The two buttons on the upper left of the Perma-Proto HAT control the speed of the teleprompter and the one button on the right switches between fullscreen and windowed mode.

The switch controls whether the teleprompter is running or not. Additionally, the HDMI decoder board can receive ground and 5V power from the Perma-Proto HAT. Otherwise, it needs to be powered through USB.

3D Printing the Raspberry Pi Teleprompter

There are three 3D printed parts you need to create the body of the teleprompter. The .STL files can be downloaded from my GitHub page. The two larger parts snap fit together to make the main portion of the teleprompter. One side has a tripod mount and a cutout for a DSLR lens to fit into. The other side has mounts and cutouts for the reflective acrylic, screen and Raspberry Pi. 

It's important to print the part, or paint it after, in black. It needs to be dark so that you can see the reflection of the screen in the acrylic. 

The third 3D printed part is a PCB mount for the HDMI decoder board that is used with the 5-inch HDMI monitor that carries the video signal from the Raspberry Pi.

Assembling the Raspberry Pi Teleprompter 

After you’ve 3D printed your parts, it’s time to put them together.

1. Attach two M2.5 standoffs with two M2.5 nuts in the front mounting holes of the front 3D printed part for the Raspberry Pi. 

2.  Attach the PCB mount for the HDMI decoder PCB with four M3 nuts and screws at the bottom of the 3D printed part. 

3. Use two M2.5 standoffs to attach the Raspberry Pi  to the mounted M2.5 standoffs. The Pi is going to be mounted to the front of the teleprompter for easy access.

4. Place the Perma-Proto HAT on the Raspberry Pi's GPIO header and secure it to the M2.5 standoffs with two M2.5 screws.

5. Insert the 5" screen into the 3D printed part and carefully run its flexible connector through the bottom of the case. Be careful because the connector can easily become damaged. Then insert the connector into the slot on the HDMI decoder board.

6. Mount the HDMI decoder board with 4 M3 screws onto the 3D printed PCB carrier.

7. Run an HDMI cable between the Raspberry Pi and the HDMI decoder board. You can use any cable, but a modular, ribbon cable can keep the build compact. However, much like the screen's connector they can be fragile so handle with care.

And that concludes the hardware assembly for the teleprompter!

8. Cut a piece of acrylic approximately 109 mm by 127 mm. Do this using a safety knife or other cutting tool that is recommended for acrylic. Then slide the acrylic into the slots on the 3D printed part.  

Display Setup of Raspberry Pi Teleprompter

The final step is to invert the Raspberry Pi's display so that it is mirrored on the screen and is reflected properly in the acrylic. To do this, you'll edit the /boot/config.txt file a bit. We’ll list the changes below but  you can also see them in my sample config.txt file.

1. Open /boot/config.txt for editing.

sudo nano /boot/config.txt

2. Disable the FKMS graphics driver by putting a # sign (for comment out) in front of any line that has dtoverlay=vc4-kms-v3d on it.  Normally this isn't recommended, but legacy graphics gives you more control over flipping and inverting the display. 

3. Force an 800 x 480 resolution by making sure the “force a specific HDMI mode” section looks like what you see below. The resolution of the screen is also forced to 800x480, because since the HDMI decoder does not have scaling.

# uncomment to force a specific HDMI mode (this will force VGA)hdmi_group=2hdmi_mode=1hdmi_mode=87hdmi_cvt 800 480 60 6 0 0 0

4. Add the line display_rotate=0x20000 to the bottom of config.txt in order to invert the display.

display_rotate=0x20000

5. Save and reboot your Pi.

After rebooting, your Pi's display will be mirrored but appear correctly in the acrylic, making it ready to be a teleprompter.

Using the Raspberry Pi Teleprompter

There are a few different workflows that you can use with your Raspberry Pi teleprompter. You can use VNC or SSH to access the Pi remotely to load your video scripts and run your code or you can still use a wireless keyboard and mouse to use the teleprompter's display as a monitor for the Pi. 

Going further, you may choose to have the bash script run every time you start up (see how to run a script at Raspberry Pi boot). However you choose to use it, you will have a compact and open source teleprompter option to use during your videos or presentations.

Hardware failure and a careless user feeling adventurous with powerful utilities such as  dd  and fdisk can lead to data loss in Linux. Not only that, sometimes spring cleaning a partition or directory can also lead to accidentally deleting some useful files. Should that happen, there’s no reason to despair. With the PhotoRec utility, you can easily recover a variety of files, be it documents, images, music,  archives and so on. 

Developed by CGSecurity and released under the GPL, PhotoRec is distributed as a companion utility of Testdisk, which can be used to recover and restore partitions. You can use either of these tools to recover files, but each has a job that it’s best suited for. Testdisk is best suited for recovering lost partitions. Whether this is on account of you overwriting or deleting a partition, or a partition becoming unreadable for any reason, Testdisk can help you restore the partition, or at the very least, recover data from it. But if all you’re interested in is recovering deleted files from a partition, hard disk or even a USB drive, you can use PhotoRec. Although initially designed to only recover image files (hence the name), PhotoRec can be used to recover just about any manner of file. 

Even better, PhotoRec works by ignoring the underlying filesystem on the specified partition, disk or USB drive. Instead, it focuses on the unique signatures left by the different file types to identify them. This is why PhotoRec can work with FAT, NTFS, ext3, ext4 and other partition types.

In contrast, Testdisk only supports a limited number of filesystems. The greatest drawback of PhotoRec – if any tool that can seemingly pull deleted files out of the digital ether can have a drawback – is that it doesn’t retain the original filenames. This means that recovered files all sport a gibberish alpha-numeric name. If this is a deal-breaker for you, consider using Testdisk first to recover your lost files. 

To Install Testdisk open a terminal window and first update the software repositories before installing testdisk. We’re using an Ubuntu machine for our installation.

$ sudo apt install testdisk

If you are using a Fedora or other RPM based distro, use dnf instead.

$ sudo dnf install testdisk

Get Recoverin’ 

Before you start using PhotoRec, it’s important to understand how a filesystem handles deleted files. When you delete a file, it isn’t immediately zapped into oblivion. Instead, the file system merely marks the file as deleted and assigns the space the file occupied as available for use. This means that until that space is taken up by another file, the original file is still there and can be retrieved using specialised data recovery tools.  

It’s for this reason why you should ideally stop using the system as soon as you realise that you’ve deleted an important file, because you’ll minimise the risk of its space being occupied. Although both PhotoRec  and Testdisk can recover files from deleted and then overwritten partitions, it decreases the chances of recovering all the files.

1. Using the file manager, create a directory where you wish to store the files recovered by PhotoRec. This directory should not be on the same partition or device from which you are attempting to recover files.

2. Open the terminal and fire up PhotoRec with sudo powers.

$ sudo photorec

You’ll be presented with the welcome screen that lists all the partitions as well as connected disks and devices.

3. Using the up and down arrow keys select the drive that you wish to recover, then use the left and right keys to select Proceed and press Enter. You can help speed things up by restricting the recovery to search for specific file types, such as pdf, jpg or mp3.

After selecting the device or partition from which you wish to recover deleted files, use the right/left arrow keys to select the File Opt button and press Enter. If your selected device comprises several partitions, PhotoRec will display all the partitions and enable you to choose the partition that was home to the deleted file. 

4. Select the filesystem type used on the drive that you wish to recover. If the drive had typical Linux partitions, select ext2/ext3. For anything else, choose the Other option.

5. Using the up and down arrow keys, select whether to search and recover files from the free space of the drive, or from the entire drive. 

6. Select the destination for the recovered files. Pressing Enter will open directories. When ready press C to set the destination and start the recovery process 

Making Sense of Recovered Files 

Depending on the size of the partition or device, PhotoRec can take quite a while to perform the complete search for files. PhotoRec creates several directories such as recup_dir.1 or recup_dir.2 within the specified destination directory for recovered files. You’ll find all the recovered files within these directories, but PhotoRec makes no attempt at sorting the different files based on their name or file formats.

You can, however, resort to some quick CLI-fu to organise the recovered files.

1. Create directories for different file formats, such as mp3 or jpg. 

2. Use the  mv  command to move files of a specific format to the relevant directory. For example here we move all of the jpeg images into the images directory.

$ mv ~/miracles-happen/recup_dir.*/*.jpg ~/miracle-happens/images/ 

This tutorial first appeared in an issue of Linux Format magazine. 

A key matrix for determining the vitality of a Linux distro, or the hardware that it runs on, is system performance. Depending on your purpose, you can choose from a variety of dedicated tools to monitor the different components such as CPU frequency, temperature and memory utilisation. But if you favour the CLI, like us, you’ll rather enjoy working with S-TUI.

With S-TUI, which is an acronym for Stress-Terminal UI, you can simultaneously monitor CPU temperature, frequency, power and utilisation. The utility presents all the information graphically and can even be used to  export the data into CSV files. Better still, you can configure S-TUI to automatically launch scripts when the values of any of the components being monitored breaches the defined threshold values. When coupled with stress, another command-line utility, S-TUI can also be used to stress-test your system.

Installing S-TUI 

Although S-TUI isn’t available in the software repositories of most popular desktop distributions, installing the tool is fairly straightforward, and the project’s GitHub page describes various installation techniques. For our install we shall use Ubuntu 21.04. 

1.  In the terminal, Update the available software repositories and install the Python 3 packaging tool. 

$ sudo apt update$ sudo apt install python3-pip

2. Install S-TUI using pip3.

$ sudo pip install s-tui

3.  Run S-TUI.

$ s-tui

Unlike many other command-line utilities, S-TUI requires no configuration and you can begin using it immediately after installation. 

Using S-TUI 

At the top of the sidebar on the left are the details about your CPU. Our Lenovo test machine was correctly identified as running an Intel Core i3-5005U CPU @ 2.00GHz processor. This is because S-TUI utilises various other native tools and utilities to gather the relevant information. For instance, the same information and far more details can be ascertained from running the cat /proc/cpuinfo command.

When you first launch S-TUI, it displays all four parameters – Frequency, Utilization,Temperature and Power – and refreshes the data for each every two seconds. 

To change the refresh rate from two seconds to 0.1, change the value of Refresh[s]:2.0 on the sidebar to 0.1, note that this will put extra strain on your Pi.

Use the up and down arrow keys to navigate the sidebar, but S-TUI also supports the use of H and J  to scroll, much like you would in Vim. S-TUI will also work with mouse input.

Using S-TUI to Stress Test Your Machine 

By default, S-TUI is configured to only monitor your system. To push our machine to its limits we installed “stress” a stress testing terminal tool. Stress works with all types of CPUs, we use it to stress test Raspberry Pis as part of the stressberry Python benchmarking tool.

1. To install stress, open a terminal and enter the following. 

$ sudo apt install stress

2. Open S-TUI.

$ s-tui

3. Using the arrow keys, navigate to Stress and press the spacebar. Alternatively you can also use the mouse to select. You will see the CPU graphs rapidly update, showing the current processor temperature, frequency and utilization. The stress test will run indefinitely. 

4. Turn off the stress test by navigating to Monitor and pressing the spacebar, or by clicking with your mouse.

5. To set a time limited stress test, navigate / click on Stress Options and change the Time out to your desired time (in seconds). Set the Sqrt() worker count to match the number of cores for your CPU. Click Save when done. 

6. Click on / navigate to Stress and press spacebar to run the timed test. Here we set the duration to be 30 seconds, and left the worker count at 4. 

Saving Your Test Results 

The collected data is lost as soon as you exit S-TUI, because the tool doesn’t save it by default.

To automatically save the collected information to a timestamped CSV file when you exit S-TUI, invoke the command as so.

$ s-tui -c

To specify your own file name, invoke the command with a “--csv-file” provide a filename.

$ s-tui --csv-file .csv

If you prefer your data in a JSON format, then we can output the data in JSON format, but only the current status, not a running log.

$ s-tui -j

These days, everyone gets packages delivered on a regular basis and, if you don’t notice a drop off right away, a “porch pirate” could steal your stuff. According to C + R research, 43 percent of Americans had at least one package stolen in 2020. 

To solve this problem, I built a Raspberry-Pi powered system that uses a camera and machine learning to determine if a package has been stolen from your door. When it detects the problem, it can either sound an alarm, turn on your sprinklers to wet the offenders or even shoot flour at the thieves. Tom’s Hardware covered my project in a previous news article, but today I’m going to show you how to do it yourself.

If you’ve never worked with machine learning before, this should be an easy enough project to get your feet wet. We’ll be using a type of computer vision called image classification to determine if there is, or is not a package at your front door. To train it, we’ll be using a tool called Google Cloud AutoML which takes away a lot of the complexity behind training a machine learning model.

What You’ll Need For This Project 

• Raspberry Pi 4 with Internet connectivity and a memory card of at least 16GB
• Raspberry Pi Power Supply
• 12 volt power supply
• A relay module compatible with the Raspberry Pi
• At least 5 jumper cables
• 12 volt sprinkler valve
• A few feet of extra wiring suitable for a 12v circuit
• A Google Cloud Account for Google Cloud AutoML (this will cost approximately $10-15)
• A 12 volt siren
• A Wyze V2 camera (with memory card) or other RTSP compatible camera

Initial Setup 

To get started, we’ll need to set up a few things to gather data for our machine learning model. 

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. Plug in your pi, Install base dependencies, and clone the repository to your Raspberry Pi.

cd ~/sudo apt-get update && sudo apt-get -y install git python3-pip && python3 -m pip install virtualenvgit clone https://github.com/rydercalmdown/package_theft_preventor.git

3. Descend into the training directory and set up a virtual environment.

cd package_theft_preventor/trainingpython3 -m virtualenv -p python3 env

4. Activate your virtual environment and install python requirements.

source env/bin/activatepip install -r requirements.txt

5. Set up your RTSP camera and point it at your front door. If you’re using a Wyze Cam V2, flash the custom RTSP firmware (instructions available here).  

6. Get the RTSP url from your camera’s settings and set it as the stream url in the training/Makefile file.

nano Makefile# update stream_url with your stream URLRTSP_URL=rtsp://username:password@10.0.0.1/live

7. Run the code to test image collection. You should start to see images appear in the data directory.

make no-package-images

8. Use the code to collect images of your front door at various points throughout the day. The code takes a photo every 10 seconds which should account for various lighting and weather conditions. You will want approximately 1000 photos without a package to get started. 

# take photos of your door without packagesmake no-package-images

9. Once you’ve gathered enough images without packages, we’ll need to start taking images with various packages. Use a variety of different sized boxes and envelopes, in different positions and orientations around your door. When you have a good number of photos of various packages, and an equal number of your door without packages at various points throughout the day, you’re ready to start training. 

make package-images

10. Go through the training/data directory and delete any photos that may not have turned out, or may not be good for training.

11. Create a Google Cloud Storage bucket to store your images in. You will need a Google Cloud account, and the gcloud command line tool installed on your local machine. You will also need a Google Cloud project if this is your first time using Google Cloud. 

# gsutil is installed with gcloudgsutil mb gs://your_bucket_name_here -p your-project-name-here -l us-central1

12. Set your bucket name as GCS_BASE in the training/Makefile file.

nano Makefile# edit GCS_BASE=gs://your_bucket_name_here

13. Run the make generate-csv command to generate the CSV required for training.

make generate-csv

14. Upload the generated CSV to your new bucket.

gsutil cp training_data.csv gs://your_bucket_name_here

15. Upload your images to your new bucket. 

gsutil cp -r data gs://your_bucket_name_here/data

16. Navigate to the Google Cloud AutoML Vision Dashboard in the Google Cloud Console. Click “Get Started” with AutoML Vision.

17. Click “New Data Set” and choose a name for this data set. Select “Single-Label Classification” as the model objective, and click “Create Dataset”.

18. Choose “Select a CSV file on Cloud Storage”, and provide the Google Cloud storage path to your uploaded CSV file in the box below, then click continue. 

gs://your_bucket_name_here/training_data.csv

19. Google Cloud will return you to the import screen. After about 10 minutes you’ll be automatically taken to the “Images” section of your data set. Verify all your images are uploaded and properly labeled as package or no_package.

20. In the “Train” tab, click “Train New Model” and choose a name. Then choose “Edge” so the model can be downloaded from Google Cloud once complete. Then click Continue.

21. Click “Faster Predictions” for model optimization, since we’ll be running on a Raspberry Pi with limited computational power. Then Click Continue. 

22. Accept the default recommendation for the node hour budget, but please note you will be charged for the hours these machines are training your model. At the time of writing this, the approximate cost is $3.15 USD per node hour, so this model should cost a little over $12 to train.

23. Click the start training button. You will get an email when your training is complete.

24. When training is complete, navigate to the “Test & Use” tab and download the model as a TF Lite file. As a destination, choose the bucket you saved your training data in, and download it with the following command. It will download a dict.txt, and model.tflite and a tflite_metadata.json file. You now have a machine learning model trained to identify whether there is or is not a package at your door.

gsutil cp -r gs://your_bucket_name_here/model-export/ ./

Setting Up The Raspberry Pi Package Alarm System 

1. Navigate to the root of the repository and run the installation command to install all lower-level and python-based requirements for the project to work.

cd ~/package_theft_preventormake install

2. Copy your downloaded model files from your computer to your Raspberry Pi and use them to replace the existing files in the src/models directory.

# From your desktop machinemv training/model-export/dict.txt /home/pi/package_theft_preventor/src/models/dict.txtmv training/model-export/tflite_metadata.json /home/pi/package_theft_preventor/src/models/tflite_metadata.jsonmv training/model-export/model.tflite /home/pi/package_theft_preventor/src/models/model.tflite

3. Set the STREAM_URL in the Makefile to the RTSP stream URL of the camera pointing towards your door. This will be the same URL as the one you used to train your model.

nano Makefile# Edit STREAM_URL=rtsp://username:password@camera_host/endpoint

4. Connect the VCC and ground pins of your relay board to your Raspberry Pi, using board pins 4 (VCC) and 6 (ground) respectively.

5. Connect the data pins on the relay to the following Raspberry Pi BCM pins. You can modify the order, just keep track of which channel each pin is connected to for later wiring.

Relay Pin 1 = Raspberry Pi BCM Pin 27 (Sprinkler Pin)Relay Pin 2 = Raspberry Pi BCM Pin 17 (Siren Pin)Relay Pin 3 = Raspberry Pi BCM Pin 22 (Air Solenoid Pin)

Note: For my project I used a combination of a 12v siren, a 12v sprinkler controller, and a 12v air solenoid to trigger a variety of alarms. For the purposes of this tutorial we’ll be connecting only a siren - and I don’t recommend connecting anything other than that for real life use. If you’re connecting other modules, follow the same three steps as below.

6. Wire the positive end of your 12 volt power supply into the common port of relay channel 2.

7. Connect your 12v siren to the normally open port of relay channel 2. 

8. Connect the other end of the siren directly to the 12v power supply ground.

9. If you’re connecting a sprinkler, wire in your 12v sprinkler controller in the exact steps above using Relay channel 1, connecting the common port of relay channel 1 to the positive end of the power supply, one end of the sprinkler controller to the relay, and the other end of the sprinkler controller to ground. The code controls the sprinkler and the siren independently. 

10. If connecting a sprinkler, connect the supply end to a pressurized water source and turn on the tap. Connect the other end to a hose leading to a sprinkler. 

11. Connect your 12v power supply to a power source.

12. Add a photo of your face to the src/faces directory as a .jpg file (optional). This enables the system to periodically check to see if you are in the area, and disarm the system accordingly.

13. Start the system and test it. You will see a variety of log statements indicating the current state the system is in: 

make run# Starting stream - The system is connecting to the camera# System watching - The system is classifying images of your porch as package/no_package right now# System Armed - A package has been definitively detected, if it is removed the alarm will go off# Activating Alarm - The package has been removed, activating the alarm

14. Invite your friends to steal packages from you to test out your new theft alarm. Mine had a great time doing it.

Once you’re satisfied, your Raspberry Pi package theft detection system should work. However, we’d advise caution as, if it doesn’t work perfectly, you could end up alerting  

Video editors are incredibly powerful and vastly complex applications which can be used to edit your amateur videos into professional looking masterpieces, complete with a background score, but only if you have the patience to master the interface. Sometimes all you need is a quick cut of unwanted parts from a video, or to merge some clips together. Feature-rich video editors would be overkill for those tasks. Instead, you can use VidCutter, a minimalist video editor that uses Ffmpeg to perform surgery on your video files.

Released under the GPLv3 license, VidCutter follows the old Unix philosophy of doing one thing well. Unlike more complex applications such as DaVinci Resolve, Adobe Premiere etc., VidCutter is designed to only cut video files, or join them together, albeit without any special effects. This makes VidCutter ideal for home users, or even amateur broadcasters who only needs a few tweaks to their video before publishing.

How To Install Vidcutter 

Vidcutter is primarily a Linux video editor, and in this tutorial we shall install the Snap package version on our Ubuntu 20.04 system. There are installation candidates for other versions of Linux, along with versions for Windows and macOS.

1. Open a terminal and install Vidcutter using the snap package manager.

$ sudo snap install vidcutter

2. Press the Super (Windows) key and type “vidcutter” and press Enter to launch the application. This can also be done via the Terminal.

Install Vidcutter Using Apt Package Manager

If you would prefer to install Vidcutter via the Apt package manager, then there is a Personal Package Archive (PPA) for Ubuntu users.

1. In a terminal, add the PPA to your list of repositories. Press Enter when prompted to enable this.

$ sudo add-apt-repository ppa:ozmartian

2. Update your software repositories.

$ sudo apt update

3. Install Vidcutter.

sudo apt install vidcutter

4. Press the Super (Windows) key and type “vidcutter” and press Enter to launch the application. This can also be done via the Terminal. 

How To Use Vidcutter 

Vidcutter’s interface is fairly straightforward and customisable. We can switch between a light or dark theme, toggle between text-only buttons, or buttons with text beneath them. The latter option makes sense, especially for novice users, even though Vidcutter is quite intuitive to use.

To start working on a video file,

1. Click on the open media button, and then select the file you wish to use.
2. Click the Start Clip button to identify the start point of the portion you wish to keep.
3. While the video is playing, click the End Clip button to identify its end.
4. Repeat this process to edit the video into sections until you are happy with the edit.
5. Click on Save Media to save your edited clip.

Unlike other video editing tools, VidCutter doesn’t offer extensive export options. Instead, you have a tool that supports a variety of formats, such as AVI, MP4, MPEG 1/2, WMV, MP3, MOV, 3GP, FLV etc., and automatically retains the format of the parent clip when saving shortened clips. 

Removing Audio From Clips 

Sometimes we need to remove the audio from a video, for example when we wish to add narration or background music. Vidcutter can easily remove audio from clips with just a few clicks. 

1. Load a video into Vidcutter.
2. Right click on the clip and select Media Streams.
3. Click on the checkbox under Audio in the Media Streams dialog to remove the audio.

The Vidcutter developers are constantly working to improve VidCutter. And while Vidcutter will never compare to a full video editor, it is a useful tool to make quick edits via a simple user interface. 

I’ve been more concerned about the quality of air in my house recently. I’ll soon be paying for a service to clean the furnace and duct work, and I wanted a way to determine if there’s been any measurable impact or change. Fortunately, using a SDS011 sensor, a Raspberry Pi and a bit of software, I can create a simple home air quality monitor. 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. 
• SDS011 sensor
• A small block of wood for mounting the pi and sensor (optional)
• Hot glue for mounting the pi and sensor (optional)

How to Make a Raspberry Pi Home Air Quality Monitor 

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 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_air_quality_monitor.git

3. Run the installation command after descending into the repository. This will take care of installing all base dependencies, like Docker and Docker Compose to make this project run. 

cd pi_air_quality_monitormake install

4. Run the build command to build the docker images. This may take a bit of time depending on your Raspberry Pi. 

make build

5. Connect the SDS011 sensor to the USB adapter it comes with using the provided jumper cable. 

6. Connect the SDS011 USB adapter to your Raspberry Pi. You may see a flashing red light, but if not, don’t worry. 

7. Mount the SDS011 sensor and your Raspberry Pi to a small block of wood. This step is optional, you can also use a case, but I like the open air look of the system. If mounting the sensor inside a component, make sure the air inlet port is connected to the outside of the case. 

8. Run the server to start taking measurements. 

make run

9. Navigate to your Pi’s IP address on port 8000 to view the web server, and a small graph of recent measurements of air quality. You’ll see a graph. 

The sensor in this Raspberry Pi Project measures two metrics: PM2.5 and PM10. PM stands for particulate matter and the number after is the amount of micrometers, 2.5 or 10. Particles of PM2.5 are particularly bad for your health if they contain toxic substances.

This server shows running measurements for the last 30 minutes, but could be easily adapted to do more. I’ll be comparing my values from now until after my HVAC system is cleaned, and hopefully I’ll see a measurable difference. After that, I’ll be putting this in a water proof box to measure air quality outside, to give me an idea of how it varies over time.

With SpaceX’s Starlink being made available in my area, I became curious about just how many satellites were overhead at any given time. Fortunately, the US Space Command tracks and makes available data for tracking the live positions of objects in orbit. We can download this data, and use a Raspberry Pi and some speakers to announce when a particular satellite is making an overhead pass. You can also get an SMS message sent to your phone in addition to the audio. 

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. 
• Desktop speakers with a 3.5mm audio input

How to make a Raspberry Pi Satellite Tracker 

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/pi_satellite_announcer.gitcd pi_satellite_announcer

3. Run the installation command. It will take care of installing a virtual environment, any necessary low level dependencies, and the python requirements.

make install

4. Visit space-track.org and create a new account. This will let us download two-line element (TLE) data tracked by  the US Space Command. The code will update data from this website once per day, and store it locally to minimize stress on their servers.

5. Once registered, return to your raspberry pi and edit your environment.sh file - replace the template values with your space-track username and password. 

nano environment.sh# Your spacetrack credentials# export SPACETRACK_USERNAME=youremail@example.com# export SPACETRACK_PASSWORD=your_spacetrack_password

6. Retrieve your home latitude and longitude values from Google maps by right clicking on the map and selecting the first option.

7. Copy your latitude and longitude values into environment.sh, and set your desired radius in kilometers. For example, a radius of 20 kilometers would only report satellites overhead if their position on the ground is less than 20 kilometers away from you - they could be at any altitude. 

8. Plug in speakers to the 3.5mm audio port on your raspberry pi, and test that you can hear them with the following command. I’m using a megaphone, but any speakers with a 3.5mm audio input will work.  You may need to increase the volume with the alsamixer command. If you run into trouble, try configuring your audio in the raspi-config menu. 

# Test speakersespeak -a 200 "this is a test" --stdout | aplay# Adjust volumealsamixer

 9. Set up a twilio account. We’ll use this to send a text message when a satellite appears overhead. If you don’t wish to use twilio, you can edit app.py and set the ‘use_twilio’ variable to False.

10. Follow the setup instructions for a twilio account. Detailed instructions can be found on Twilio’s site here. You will need to create a phone number, and get your account credentials to perform the send actions.

11. Once you have your credentials and phone number, Add them to the environment.sh file.

nano environment.sh# Twilio credentialsexport TWILIO_ACCOUNT_SID=your_account_idexport TWILIO_AUTH_TOKEN=your_account_token# the number you purchased with twilioexport TWILIO_NUMBER_FROM=+10000000000# your phone numberexport TWILIO_NUMBER_TO=10000000000

12. Run the code with the following command. It will connect to space-track, download the latest TLE data, and immediately start reporting satellites over the latitude, longitude, and radius provided in the environment.sh file.

make run

13. Play around with the code. Right now it only announces satellites that are not considered debris, but this can be adjusted easily. You can also filter down by constellation, or only announce satellites with names that are interesting to you, like the international space station (ZARYA). 

After you’ve gone through the process of building Chia Coin plots on a PC (see how to farm Chia Coin), there’s no need to waste the electricity and tie up expensive computer hardware keeping those plots connected to the Internet. Instead, it’s best to take an external drive or drive(s) with the plots on them and hook them up to a Raspberry Pi where they can stay online, without gulping down too much juice.

In this tutorial, we will create a custom Raspberry Pi Chia farming device powered by the latest Ubuntu 64-bit release for the Raspberry Pi. The unit is designed to be hidden away, farming Chia Coin silently while we go about our lives. As such we chose to house the Raspberry Pi 4 inside of a passively cooled case. Our choice this time was the Akasa Gem Pro which has great cooling for the SoC, PMIC and PCIe chip and a rather tasteful, if unusual design. 

For This Project You Will Need 

• Raspberry Pi 4 4GB
• Raspberry pi case, perhaps one of the best Raspberry Pi cases, with cooling
• An external USB storage drive or SSD / HDD with USB 3.0 caddy.
• 16GB Micro SD card or larger
• Raspberry Pi Imager tool
• Accessories to use your Raspberry Pi 4

Installing Chia On Raspberry Pi 4 

1. Install Ubuntu 21.04 to a 16GB micro SD card using the official Raspberry Pi Imager tool. You can also try a headless installation.

2. Connect your keyboard, mouse, screen and Ethernet cable. If you did a headless install, you can skip the keyboard / mouse / screen. Boot your Raspberry Pi 4 and complete the Ubuntu 21.04 installation process. Reboot the Raspberry Pi for all the changes to take effect.

3. Open a terminal and update the software repositories, then upgrade the system software.

$ sudo apt update$ sudo apt upgrade -y

4. Install the openssh server to enable remote monitoring via an SSH session. After installation this will automatically start the SSH server as a background service. 

$ sudo apt install openssh-server

5. Install and start Byobu, a terminal multiplexer that will enable us to log out of the Pi and leave our Chia farm running.

$ sudo apt install byobu$ byobu

6. Make a note of your Raspberry Pi’s IP address and hostname.

$ hostname -I

7. Install the Git version control software and a number of essential dependencies to build the Chia application.

$ sudo apt install git$ sudo apt-get install -y build-essential python3-dev

8. Clone the Chia git repository containing the latest version.

$ git clone https://github.com/Chia-Network/chia-blockchain.git -b latest

9. Change directory to chia-blockchain and run the installer.

cd chia-blockchainsh install.sh

10.  Activate the Chia virtual environment and create a new Chia config. 

$ . ./activate$ chia init

11. Connect your USB 3.0 hard drive containing your Chia plot to the blue USB 3.0 ports on the Raspberry Pi 4. The drive will mount to a directory inside of /media/.

12. In the terminal change directory to your USB drive. Our test drive is at /media/les/Chia/

$ cd /media/YOUR USERNAME/DRIVE NAME

13. Add the plot from your USB drive to the Chia config using the 24 word key, created when the plot was created. Enter the command and then type the 24 words with a space between each word. 

$ chia keys add

14. Start farming the plot; this will also start services for your wallet. This command will only show that the process has started.

$ chia start farmer

15. Use this command to see the process of syncing our machine to the network and to confirm that farming has begun. The command will update every two seconds. This command can be stopped by pressing CTRL + C.

$ watch 'chia show -s -c'

16. Press F6 to detach from the current Byobu session. This releases us from the running session but it keeps the previous command to view our farming progress running in the background. Should you wish to go back to that Byobu session type this command.

$ byobu

It will take some time for the Pi to sync with the Chia network but it will still continue to farm as it syncs. Right now if you wish, you can unplug the monitor, keyboard, mouse. Leaving just the power, network and USB 3.0 drive connected. Your Pi will happily farm Chia quietly in the corner of the room. But to access the Pi we now need to use SSH, a secure shell terminal and for that we need to instal a client on our computer. 

Should you ever need to manually start the Chia farmer, for example after a reboot, start byobu and repeat steps 14 to 16.  

How To Remotely Access Your Raspberry Pi Chia Coin Farm 

1. Install PuTTY on your PC. PuTTY is used to make remote serial connections, SSH, with our Raspberry Pi 4.

2. Open PuTTY and in the Host Name or IP Address field enter the hostname or IP address of your Raspberry Pi 4. Click Open. 

3. Enter your username and password to remotely login to the Raspberry Pi 4. 

4. Open the Byobu session to see the current progress. 

$ byobu

Auto Mount USB Drive on Boot 

Should we need to power off our P, or there is power loss, we need the drive to automatically be ready to farm Chia with little interaction. It is best to connect your keyboard, mouse and screen for this part of the project but it can also be done remotely using an SSH connection.

1. With the USB drive connected, open a terminal and list all the attached devices. Our device is sda1 which is connected to the mountpoint /media/les/Chia. Make a note of your mountpoint, we will need this later. 

$ lsblk

2. Run this command to identify the UUID of your drive. Copy the text which starts UUID=. For example our UUID was UUID="b0984018-3d5e-4e53-89d9-6c1f371dbdee

blkid /dev/YOUR DRIVE

3. Open the filesystem configuration file, fstab with sudo.

$ sudo nano /etc/fstab

4. Add this line to the end of the file. Add your UUID after the =, and leave a space before entering the mountpoint. Here is how our drive is configured.

UUID=b0984018-3d5e-4e53-89d9-6c1f371dbdee /media/les/Chia/ auto nosuid,nodev,nofail,x-gvfs-show 0 0

5. Press CTRL+ X then Y and Enter to save.

6. Reboot the Raspberry Pi.

$ sudo reboot

If you’re like me, you spend a little too much time on a few websites, particularly social media sites. Try as you might to avoid them, you find yourself unconsciously typing in Facebook, Reddit, or something else into your search bar. There are a ton of browser extensions, desktop apps, and router rules you can configure to help, but I wanted something more physical.

This project uses light switches and an at-home DNS server running on a Raspberry Pi Zero to turn on or off access to specific websites. If I want access to a site I have blocked, I need to physically get up and turn off the switch -- something that’s slightly more difficult than turning off a browser extension.

What You’ll Need To Make A Website Off Switch

• Raspberry Pi Zero W, SD Card, and Power Supply
• Two single-pole light switches
• A PVC double-gang switch box
• A plastic 2-toggle switch plate
• Four male-female jumper wires
• Phillips and flathead screwdrivers

How to Build a Website Off Switch With a Raspberry Pi

1. Set up your Raspberry Pi Zero W and connect to it remotely. If you don’t know how, see our tutorial on how to set up a headless Raspberry Pi.

2. Update and Install git if not already installed.

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

3. Clone the code from this repository. It will handle the management of the dnsmasq tool, which will be our new DNS server.

git clone https://github.com/rydercalmdown/internet_kill_switch

4. Run the installation command from within the newly cloned directory. This will take care of installing all base dependencies, installing the dnsmasq tool, and ensuring it’s running.

cd internet_kill_switchmake install

5. Ensure dnsmasq is running by entering the following command. To exit, use Ctrl + C. You should see status “Running” in green.

sudo systemctl status dnsmasq# Use Ctrl + C to exit

6. Try running the software to ensure everything works accordingly. You should see a few log messages with no errors. Exit the software with Ctrl + C.

make run# Use Ctrl + C to exit

7. Wire the male end of each jumper cable to the switches. You should be able to tuck the pin under the screw and tighten it until it’s snug. These switches are designed for high AC voltage, but will work just the same for our project.

8. Attach the female end of the jumper cables to the Raspberry Pi. Pin order doesn’t matter, as long as one end of the switch goes to a GPIO pin, and the other goes to a ground pin. The default code expects GPIO (BCM) pins 18 and 24, though this is configurable.

9. Tuck the raspberry pi into the PVC double-gang switch box, and affix it to the back with hot glue.

10. Run the power cable through the switch box inlet, and connect it to the Raspberry Pi.

11. Attach both switches to the switch box using the screws they came with.

12. Place the switch plate on top of the switches, and attach it with the screws it came with.

13. Label which switch belongs to which site. Keep track of which switch is attached to which pin.

14. Open the src/toggle_switches.py file for editing.

cd src/nano toggle_switches.py

15. Modify toggle_switches.py to list the websites you want to block for each switch. You can add or remove switches by modifying the SWITCHES list, and adding new objects of the class SwitchConfig. The accepted parameters are the BCM pin number, followed by a list of sites to block.

# Example: The switch connected to BCM pin 18 blocks social media, and the switch connected to BCM pin 24 blocks video websitesSWITCHES = [   SwitchConfig(18, ['facebook.com', 'instagram.com']),   SwitchConfig(24, ['netflix.com', 'youtube.com', 'vimeo.com']),]

16. Run the application to test it, and make note of the IP address it prints out when starting - that’s the IP address of your Pi.

cd ~/internet_kill_switchmake run# IP Address is 10.0.0.25

17. Configure your DNS servers on your computer with that IP address. I'm configuring mine in System Preferences > Network of my MacBook, but you can also configure it at the router level.

18. Test the switches on the machine that now uses your Pi as a DNS server - in my case, my MacBook. With the switches in the off position, you should be able to access websites freely. Once you flip the switches to the on position, after a short delay, you should receive a network error when trying to visit that website.

19. To confirm, use the following command on your computer, substituting google.com with the site you’ve chosen to block:

# When the switch is offdig +short google.com172.217.164.238# When the switch is ondig +short google.com127.0.0.1

20. Edit your /etc/rc.local file to include the following line, so this software runs when your Pi reboots.

sudo nano /etc/rc.local# Add this line before the very last linecd /home/pi/internet_kill_switch/src && sudo ../env/bin/python app.py &

21. Mount your switches. If you would like to put this switchbox on the wall, you’ll have to find a place to mount it that’s close to an outlet so you can power the Pi. Alternatively, you can just leave the switchbox on a table or shelf somewhere.

Enjoy, and if ever you’re not able to load websites, try removing the Pi’s IP address from your DNS servers - there’s likely a problem.

As important as it is to keep your disks clear of duplicate files, finding copies of files is a tiresome job and most people don’t want to do it. This isn’t a problem if all you have are tiny text files that take up a few kilobytes each. But media files, especially raw images and HD videos can eat a lot of disk space, leaving you with less room for new data and apps. 

Thankfully, the Fdupes command-line utility provides a faster and more efficient way of identifying duplicate files than just manually combing through your folders. Released under the MIT License, this nifty tool can be used to find duplicate files in the specified directories. The tool works by comparing the MD5 signature of the files, followed by a byte-to-byte comparison to ensure that all copies are identified.

In addition to tracking down duplicates, you can also use Fdupes to delete duplicate files, replace deleted files with links to the original, etc.

How to Install Fdupes for Linux 

You’ll find Fdupes in the software repositories of most desktop distributions such as Ubuntu, Fedora, Arch, etc. The following instructions work on Ubuntu, Debian and other Linux flavors that are based on them (ex: Mint and Raspberry Pi OS).

1. Update the list of repositories by entering this command in a terminal window.

$ sudo apt update

2. Install the dependencies and npm package manager.

sudo apt install fdupes

You can similarly install Fdupes on Fedora, or other rpm based distributions with the ///BEGIN CODE///sudo dnf install fdupes///END CODE/// command.

How to Find Duplicate Files in Linux with Fdupes 

Despite performing a seemingly straightforward task, Fdupes boasts of a vast number of useful features. As the utility can also be used to delete duplicate files, we would advise you to spend some time with the man page to familiarise yourself with the different command options. At a minimum, Fdupes expect the path to a directory to perform a search for duplicates.

$ fdupes 

• To identify duplicate files in a given directory:

Refer the directory to fdupes

$ fdupes ~/Documents

• To recursively search through all sub-directories in the specified directory and identify all the duplicate files.

$ fdupes -r ~/Documents

Both the above commands only list the duplicate files onto the screen, without deleting them. You must use the -d command option if you want Fdupes to also delete the duplicate files it identifies. But even then, Fdupes will ask to confirm which of the identified files you wish to retain. You can choose to keep a single file, or provide a comma separated list of the ones you wish to retain, or alternatively to keep all.

Here we've opted to retain two files. Also, if your specified directory has multiple copies of different files, each group of copies of a single file is referred to as a set.

This is only a basic introduction to Fdupes. There’s still more that you can do such as ignore hidden files or follow symbolic links, etc.

More Linux Tutorials:

• Kill Linux Processes the Easy Way with Fkill
• How To Manipulate PDF Files in Linux With PDFtk
• How to Send Files to Trash from the Linux Command Line
• How to Get Persistent SSH Connections in Linux Using Eternal Terminal

While Linux distributions don’t suffer the ignominy of a blue screen of death, running processes (aka programs)  do become unresponsive sometimes. If you run a web browser, media player, ebook reader, etc. on your Linux distribution, each of these is a different process, with a unique process ID and, traditionally, you need to issue a couple of different commands to find this ID and stop it. 

Released under the MIT License, fkill is a cross-platform utility that can be used to interactively kill processes with ease. With fkill, we can scroll through a list of running processes and kill any of them by pressing the Enter key. We can also search through the processes by typing the name of commands / processes  into the terminal and the output will be filtered to show any matching entries. This is a world away from how commands such as top are used to list processes via grep and a separate command is then used to kill the process using its PID.

Fkill is not available in Linux distributions out of the box. It’s also not available in the software repositories of most Linux distributions. However, its only dependency is the Node.js runtime environment, which you can easily install from the software repository on your distribution. You’ll also need the npm package manager, which too can be installed using the package management tool on your distribution.

How to Install Fkill in Linux

The following instructions work in Ubuntu or Debian and probably several other flavors as well.

1. Open a terminal window and update the list of repositories. 

$ sudo apt update

2. Install Node.js and Npm Package Manager. 

sudo apt install nodejs npm

3. Install fkill.

npm install --global fkill-cli

How to Use Fkill to Kill Tasks in Linux 

Terminating a program with fkill is as easy as typing it at the command prompt, with no command line arguments required. Here are three main ways to use it.

1. Type fkill and navigate the menu. If you just launch fkill, you’ll be shown a scrolling list of all current processes. Select the process you want to kill and hit Enter. 

You can use the arrows to navigate through the list or start typing the name of the process you are looking for (ex: “fire” for firefox) and you’ll see a list of matching processes appear.  

2. Enter fkill [process name]. For example, you’d type fkill firefox to kill firefox. 

3. Enter fkill [process ID]. If you know the process ID, you can kill it directly. 

Unlike alternative commands such as kill, which supports sending many different signals to the process, Fkill can only be used to kill the process so it works just like kill -9. 

Update 6/9/2020 09:07 PT: We would like to quote that the source of this story was OMG Ubuntu.

Original Article:

On the surface the Raspberry Pi 4 8GB may not have been a revolutionary release, but it has finally brought the power of a low cost 64 bit desktop computer to homes around the world. From day one the Raspberry Pi has used a Linux based operating system, initially a rather limited release of Debian, called Raspbian which has evolved over the years to become Raspberry Pi OS. But there are times when a more refined desktop experience would benefit the user.

For over 15 years Ubuntu have provided a Linux distribution that offers a more friendly and forgiving means to delve into the Linux ecosystem.

On a recent Ubuntu Podcast, Martin Wimpress, Director of Engineering at Canonical the company which publishes Ubuntu, hinted that “maybe we’re working on Ubuntu desktop for the Raspberry Pi”. Martin Wimpress was brought in to work on the main Ubuntu release based on his work in the Ubuntu MATE community.

There is a high chance that this will be ready for Ubuntu 20.10 due for release in October 2020. 

Ubuntu has been an official option since the Raspberry Pi 2 was released, but official support was limited to running servers or installing Ubuntu Core, an IoT platform based on Ubuntu Server. There are community and unofficial projects to enable installation of Ubuntu on to the Raspberry Pi 4. These projects typically use an Ubuntu Server image as a base from which to install a desktop environment using the APT package manager or via Desktopify, which is a tool also developed by Martin Wimpress.

Could Ubuntu replace Raspberry Pi OS as the default operating system? Unlikely given that Raspberry Pi OS is an in-house project which has early access to the latest Raspberry Pi hardware. Instead what Ubuntu could bring is a more refined desktop experience for those that wish to use the Raspberry Pi as a desktop computer or for business use as a thin client.

Early Alpha and Beta testing images of Ubuntu 20.10 for the Raspberry Pi will be available in the coming months, but if you cannot wait then you can always try Desktopify.

We have reached out for confirmation of this news and will update this post accordingly.

The Debian Security Advisory posted a vulnerability in Debian that gives root access to unauthorized users. The team first announced the bug on October 14th. A patch is already in place to fix the problem. The bug is present in Raspbian—Pi users will also need the update.

The issue lies within the sudo program. The security log explains, "when configured to allow a user to run commands as an arbitrary user via the ALL keyword in a Runas specification, allows to run commands as root by specifying the user ID -1 or 4294967295. This could allow a user with sufficient sudo privileges to run commands as root even if the Runas specification explicitly disallows root access.”

Pi users can check the current OS version using the following command in a terminal on the Pi.

apt show sudo

If you're running Buster, you need patch level 1.8.27-1+deb10u1. If you're Pi is still running Stretch, the patch level you need is 1.8.19p1-2.1+deb9u1.

To update your Pi to the latest patch, use this command:

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

Despite the severity of unauthorized root access, security experts, like Yanick Fratantonio insist the bug is overhyped. Exploiting the vulnerability would require very specific circumstances that most users won't encounter.

It's still good practice to keep your OS up to date. You may not have to hurry, but you should still update your Pi or any Linux machine you've got running Debian. You can check the status of the sudo bug on the security tracking page.

Following the recent CCleaner malware incident, Avast (the new owner of CCleaner) and Cisco’s Talos Intelligence security research group have continued to analyze the attack. The two found that the malware was more sophisticated than originally thought and was targeting large companies to steal their intellectual property.

Advanced Persistent Threat

Avast concluded that the malware was in fact a type of attack called an advanced persistent threat (APT), which is a sophisticated attack usually launched by nation states. The APT that infected CCleaner was supposed to deliver a second-stage payload only to select victims.

Of the 2.27 million users who installed the infected CCleaner version, Avast believes that only a few hundred were also infected by the second-stage payload. Avast had previously said that it believes the second stage payload was never deployed, but the company has now walked back that statement.

Large Companies Targeted

The antivirus maker stated that the APT targeted large technology and telecommunications companies from Japan, Taiwan, UK, Germany, and the U.S. via a watering hole attack, which is an attack that targets popular websites or tools used by millions, only to infect a few targets that may also use those same tools. The name is taken from the real world where some predators wait for an opportunity to pick their prey from the animals that come to drink water at a watering hole.

Avast didn’t want to say who were the targets of this attack, but Cisco revealed a list of targets the attackers were attempting to hack. Besides Cisco itself, the list includes Intel, HTC, Samsung, Sony, VMware, Microsoft, Vodafone, Epson, Linksys, MSI, Akamai, and a few others.

Complex Obfuscated Code

According to Avast, the second-stage payload contains complex and obfuscated code and includes two DLL components. The first component comes with anti-debugging and anti-emulation mechanisms, and its purpose seems to be finding another command and control (C2) server.

The C2 server’s address could be modified in the future, which means that it may not be enough that law enforcement shut down the original C2 servers. The attackers may be able to regain control of the infected machines and continue to control them remotely through a new another server.

The second part of the second-stage payload is responsible for persistence on the operating system, and they seem to be piggybacking on other vendors’ applications to avoid detection and maintain persistence. The 32-bit version of the code embeds itself into a Winzip package, whereas the 64-bit one uses a Symantec dll. Most of the malicious code is delivered from the registry. Avast noted that all of these techniques demonstrate a high level of sophistication from the attacker.

Attribution

Attribution is difficult for cyber attacks, as sophisticated attackers can often make it look as if someone else did it by re-using other attackers’ code or hacking styles. They may effectively hide behind reused IP addresses by launching their attacks from computers they hack in a given country. This is also why Avast is reluctant to say for sure who the attackers were right now, but it promised to continue to work with law enforcement to find out who was responsible.

However, Cisco and Kaspersky were both able to confirm that the malware uses code that overlaps with malware code used by “Group 72,” also called “Deep Panda,” “Axiom,” and “Shell Crew.” Group 72 is believed to be a cyber espionage group funded by the Chinese government, and it’s also believed to be responsible for stealing 80 million U.S. social security numbers from health insurance company Anthem.

Avast initially suggested that it should be enough to update to the clean version of CCleaner, but Cisco recommended that it would be safer to restore from backups and reimage the systems. Avast also recommends updating to CCleaner 5.35, as the company has now also revoked the Symantec certificate it was using to sign the infected 5.33 version as well as the cleaned-up 5.34 version.