Category Archives: Uncategorized

PlugPi, Now with 90% less fire hazard

I’m still waiting on the first print of the 3D printed base I drafted to come in to test fit before I work on the internal chassis model more, but in the mean time I put together a much safer version of the PlugPi with proper heat shrink tubing rather than hot glue and duct tape. A reddit comment pointed out that power creates heat and things like hot glue and duct tape get soft when heat is introduced. Please don’t use hot glue, but instead spring for the heat shrink tubing. I don’t want you to burn your house down.


WARNING: This project deals with hacking on mains AC power. Please proceed carefully.

I’ve wanted an inconspicuous wall wart style raspberry pi case / enclosure for the longest time, but there aren’t many options out there. I’ve seen the PiPlug developed by the dude that runs, but it wasn’t quite what I was looking for. After some research; though, I think I’ve hit on the just the right ingredients to easily build out very sleek and inconspicuous cases.

These are links to the components I landed on.







Here is one of the USB power supplies ripped apart next to an intact one. These things seem to be the best way to get cheap clean power in a small form factor. There are some other appealing options like the RAC05-05SK that are a bit cleaner and probably safer than cannibalizing a USB charger, but at 3x the price I decided I’d go this route.

As you can see the Raspberry Pi and this power adapter board sit nicely in this little project enclosure.

Soldering to the power adapter is quite easy. The pads for the mains AC were large, and soldering the cannibalized USB cable to the USB pads was easy enough. I secured all of these wires with hot glue as well.

Soldering to the poles inside the Polycase enclosure was tricky. I ruined the first one because I was hanging the soldering iron on the pole for too long and it melted the case causing it to become very unstable.

I then ripped off the little ground tab and hot glued the power adapter straight into the bottom of the enclosure. I would have used the 30mm heat shrink tubing to entirely wrap the power adapter entirely prior to securing it to the enclosure if I had actually thought about the size it for two second before impulsively hitting buy on Amazon and getting tubing that was 2x too large. I’ll have it for the next iterations of this project though.

Here I just used some duct tape to keep the power adapter seperated from the Raspberry Pi. The 30mm heat shrink tubing will replace this mess in the future.

And here you can see that the USB cable can simply plug into the Pi’s power port. The Pi has to sit in the enclosure at a slight angle, but it does sit in there will, and even with just a bit of wiggle room.

Finally here it is all buttoned up. Kind of boring, perfect.

Prior to enclosing everything it would probably be wise to configure the Pi for remote access as all the ports are occluded with this enclosure. This is my standard headless config that I use for a base on nearly all my headless Pi based projects.

-1: Flash Raspbian to SD card and sync
sudo dd if=~/Downloads/Raspbian_Image.img of=/dev/sdb bs=1M progress=status && sudo sync && sudo syn

-2: Remove and re-plug SD card if new partitions are not visible.

-3: Mount SD card.
sudo mkdir /mnt/piboot
sudo mkdir /mnt/piroot
sudo mount /dev/sdb1 /mnt/piboot
sudo mount /dev/sdb2 /mnt/piroot

-4: Enable SSH on boot.
sudo touch /mnt/piboot/ssh

-5: Set up interfaces file to enable WiFi roaming.
vim /mnt/piroot/etc/network/interfaces
# interfaces(5) file used by ifup(8) and ifdown(8)

# Please note that this file is written to be used with dhcpcd
# For static IP, consult /etc/dhcpcd.conf and ‘man dhcpcd.conf’

# Include files from /etc/network/interfaces.d:
source-directory /etc/network/interfaces.d

auto wlan0
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface WlanNetwork01 inet dhcp
iface WlanNetwork02 inet dhcp
iface WlanNetwork03 inet dhcp

-6: Set up WiFi APs with priorities.
vim /mnt/piroot/etc/wpa_supplicant/wpa_supplicant.conf
# proto should be: RSN (for WPA2) and WPA (for WPA1)
# key_mgmt should be: WPA-PSK or WPA-EAP (Pre-Shared or Enterprise)
# pairwise should be CCMP or TKIP (for WPA2 or WPA1)
# auth_alg should be OPEN for WPA1/WPA2 (less commonly used are SHARED and LEAP)

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev




-7: Create Re-Roam script to connect to preferred APs if they become available.
vim /mnt/piroot/etc/

CurrentNetwork=$(iwconfig 2>&1 | grep ESSID | cut -f2 -d”\””);

if (( $(echo $CurrentNetwork | egrep -c “$PriorityNets”) == 0 )); then
if (( $(iw wlan0 scan | egrep -c “$PriorityNets”) == 1 )); then
service networking restart;

-8: Set up crontab to run the Re-Roam script every minute.
vim /mnt/piroot/etc/crontab

m h dom mon dow user command
0 * * * * root run-parts /etc/cron.hourly
10 0 * * * root run-parts /etc/cron.daily
20 0 * * 1 root run-parts /etc/cron.weekly
30 0 1 * * root run-parts /etc/cron.monthly
* * * * root /home/pi/

-9: Unmount SD card.
sudo umount /mnt/piboot
sudo umount /mnt/piroo

-10: Plug SD card into Pi, power it on, SSH to it, and continue configuration as desired.

I’m working on a 3d printable chassis for all this as well to keep things cleaner, easier, and a bit safer. Its nowhere near done yet, but here are the files in case anyone better with CAD than I wants to take a crack at working on it.

Raspberry Pi 3 WiFi FPV Drone Bridge

I recently got a cheap WiFi FPV drone. Specifically the Visuo XS809HW. I can’t legally use it past line of site in the U.S., but I thought it’d be cool to take a shot at boosting the WiFi range. Initially I installed an external antenna which on its own will probably take the little thing out of my line of site, but I really wanted to take it a step further.

There are a couple cheap WiFi repeaters that can be used with pretty good results and I did buy one of them, but I really wanted to get it repeating from my 1000mw alfa with a nice 9dbi antenna to really be able to drive it out. On top of that I wanted to be able to easily take pcaps of the traffic so I can maybe work on reversing the protocols to get FPV and control native on the Pi.

Well I got it working with mixed results, but be warned, what follows isn’t exactly kosher networking. It’s not something I’d advise implementing on a real network, or for that matter, on a drone you’re not willing to see crash and burn.

The control latency is pretty good, but the FPV is pretty lossy with a full 1-2 second lag. In the future I’m likely to try a DDWRT repeater, and I’m considering working an angle to get my rtl8187 supported on LineageOS on my Pi via a custom kernel build or chrooted nix so I can run the XSW UFO app natively with the high power card and high gain antenna. Thats for a later day though, so lets begin with what we’ve got now.

Everything beginning with “pi#” is to be run on the Pi’s shell. Boxes following “CONFIG:” are inside a config file.

Starting with a fresh install of Raspbian Stretch lite install all updates and the requisite softwares. I use vim so if you like another editor then use that. Unless it’s emacs then you can just go suck an egg. 😛 If you’re not a nix nerd then you should probably use the nano editor instead of vim.

pi# sudo apt update && sudo apt full-upgrade
pi# sudo apt install vim dnsmasq hostapd parprouted avahi-daemon

Generate network interface names based on their mac addresses. This way even if one wireless card is brought up before the other during boot the config files wont need to be changed because the cards swapped the wlan0 and wlan1 names.

pi# sudo rm /etc/systemd/network/
pi# sudo vim /etc/systemd/network/


NamePolicy=kernel database onboard slot path mac

Reboot the Pi.

pi# sudo reboot

After the device reboots ensure both of your WiFi devices are plugged in and run.

pi# ifconfig

You should see something similar to the following picture. The device names beginning with wlx are what you want to take note of. These are the names with which we will be addressing the WiFi cards in the following config files. If you’re unsure which card is which then just unplug one of them and run ifconfig again. The one that is still plugged in shows up. For the rest of this tutorial I will refer to the wired NIC as enx0 the card connecting to the drone as wlx0 and the card broadcasting the local network as wlx1, but you will need to use your device names.

Edit your /etc/network/interfaces file to reflect the following. I just delete everything in there and use the following config. If your drone broadcasts a secured network then see this link and make changes as appropriate. Adafruit WiFi Connection

pi# sudo vim /etc/network/interfaces


auto lo
iface lo inet loopback

auto enx0
iface enx0 inet dhcp

auto wlx0
allow-hotplug wlx0
iface wlx0 inet dhcp
    wireless-essid Your-Drones-essid-Here
    post-up parprouted wlx1 wlx0
    post-up ip addr add $(/sbin/ip addr show wlx0 | perl -wne 'm|^\s+inet (.*)/| && print $1')/32 dev wlx1
    post-down pkill -9 parprouted
    post-down sudo ip addr flush dev wlx0
    post-down sudo ip addr flush dev wlx1

auto wlx1
allow-hotplug wlx1
iface wlx1 inet manual

Set some iptables rules to set up NAT and allow multicast and broadcast forwarding. If someone who knows iptables a bit better can double check this I’d be grateful.

pi# sudo vim /etc/iptables.ipv4.nat


-A FORWARD -m pkttype --pkt-type multicast -j ACCEPT
-A FORWARD -m pkttype --pkt-type broadcast -j ACCEPT
-A FORWARD -i wlx1 -o wlx0 -j ACCEPT
-A FORWARD -i wlx0 -o wlx1 -j ACCEPT

Set up the dnsmasq.conf for the dhcp server. This bit is not exactly kosher. We’re starting a second dhcp server on the same subnet. This makes me cringe, but its listening on a different interface, there should never be more than a couple hosts on this machine at any time, and the ip range is well away from where the drone’s ip lease range starts. If someone out there can get dhcp-helper working reliably then that would be a much better solution.

pi# sudo vim /etc/dnsmasq.conf



Edit rc.local so we start dnsmasq on boot and load in our iptables rules. Add the following lines just above the line “exit 0”

pi# sudo vim /etc/rc.local


iptables-restore < /etc/iptables.ipv4.nat
service dnsmasq start

Now we will enable ipv4 forwarding. Go into the sysctl.conf file, find and uncomment or add the following line to the file.

pi# sudo vim /etc/sysctl.conf



Next we will set up hostapd to manage the local repeated WiFi access point. I’m boring, but you can change the values below to make your access point something more fun.

pi# sudo vim /etc/hostapd/hostapd.conf



Now we need to make sure that this hostapd file is actually getting loaded when hostapd starts. Modify the following /defaults/ file to match this.

pi# sudo vim /etc/defaults/hostapd



Now we’re going to set up the avahi daemon. We need to enable mDNS relaying here. Do so by uncommenting the following line and ensuring it mirrors this.

pi# sudo vim /etc/avahi/avahi-daemon.conf



Next make sure you’re in your /home/ and create a little script to reconnect your Pi to your drone whenever you inevitably change the battery. Then make it executable.

pi# cd ~
pi# vim ~/


#!/usr/bin/env bash
sudo ifdown wlx0
sleep 2
sudo ifup wlx0
pi# sudo chmod +x

Finally disable unwanted services, enable the services you want to run at boot, reboot everything, and cross your fingers. I find that some times things fall over, but if I’ve got the drone on to hand out an I.P. to wlx0 then the Pi boots fine.

pi# sudo systemctl disable dhcpcd.service
pi# sudo systemctl enable hostapd.service
pi# sudo systemctl enable dnsmasq.service
pi# sudo reboot

Finally I want to shout out to the resources I used to piece this together.
Surfer Tim on the RasPi forums
This guide
The Debian Wiki
This Adafruit Tutorial

Questions, Comments, Suggestions? Let me know. I’m open to all of it.

Cloud At Cost Remote Desktop

Recently I purchased a rather large Cloud At Cost service plan. It was like $240 for 8 CPUs, 8g memory, and an 80g HDD.

That’s pretty great even though the machine crashes and burns wayyy more often than it should. Well I do dig that it’s still somewhat powerful and I don’t much care that it dies weekly as I only use it for hacking on till I break it anyway, but I don’t like having to entirely rebuild my machine every time CaC borks it up.

To be a bit lazy there I hacked up a little script that helps me take their out of box Ubuntu 14 server and get it up as a remote desktop with some of my preferred tools. This could probably be used on any Ubuntu 14.04 server with minimal hackage.

It’s a bit vulgar, but we’re all adults here and it was hard to pass on this joke.

Some notes to be aware of.

  1. You need to have the ‘expect’ package installed. I think everything else is default.
  2. It’s not fire and forget yet. Keep an eye on it, you will be prompted for user input for grub and iptables.
  3. It does not handle errors. I’m too lazy to implement that in a non vital script.
  4. If your latency is bananas then you probably need to up the sleep time inside the expects. Sometimes CaC is stupid slow.
  5. Edit the line around ~118 if you want to add or remove packages.
  6. The firewall is set up with ports for ssh, http, https, and NoMachine.
  7. If you want to update the NoMachine.deb file go ahead and download the latest .deb package and just rename it correctly.
  8. Bro is the coolest IDS ever so we installed that slice of awesome.
  9. Your new passwords will be output to ‘CAC_{$CACIP}.txt’

That’s it. If you like it then enjoy, and if you’ve got ideas then please let me know.

Flash LibreBoot to Lenovo X200

I did this write up like a year or so ago, but I want to post it up here in case it disappears; though, I think that’s a long shot. I don’t have the very original write up I did and I’m too lazy to dig through github to get  my original, so I need to give some credit to the others that edited the page as I didn’t do literally everything you’ll read.

Copyright © 2014, 2015 Lawrence Wu
Copyright © 2015 snuffeluffegus <>
Copyright © 2015 Kevin Keijzer <>
Copyright © 2016 Leah Rowe

Also I’d like to tip my hat to the LibreBoot folks, they’re doing great work!



  • An x86, x86_64, or arm7l (for changing the libreboot.rom image mac address)
  • Raspberry Pi and peripherals
  • Relevant SOIC clip
  • 6 female – female jumpers
  • Internet connection
  • Screw drivers

Follow the ThinkPad X200: Initial installation guide to disassemble the laptop, and access the BIOS rom chip.

Note: x86# refers to commands to be run on the x86 computer, and pi# refers to commands to be run on the pi. A good practice is to make a work directory to keep your libreboot stuff inside.

x86# mkdir ~/work

If you’re running Raspian, you can do sudo raspi-config, enable SPI under Advanced and then spidev will be enabled. Simple, eh?

Download Libreboot from their releases page. For your safety, verify the GPG signature as well.

x86# gpg --keyserver --recv-keys 0x656F212E

x86# for signature in $(ls *.sig); do gpg --verify $signature; done

Install dependencies:

pi# sudo apt-get update && sudo apt-get install libftdi1 libftdi-dev libusb-dev libpci-dev subversion libusb-1.0-0-dev pciutils, zlib, libusb, build-essential

Download and build flashrom.

pi# svn co svn:// ~/flashrom

pi# cd ~/flashrom

pi# make

pi# sudo make install

On your x86 box change the libreboot.rom mac address

x86# cd ~/work/libreboot_bin/

Change the mac address on the libreboot images to match yours.

x86# ./ich9macchange XX:XX:XX:XX:XX:XX

Move the libreboot.rom image over to your pi

x86# scp ~/work/libreboot_bin/<path_to_your_bin> pi@your.pi.address:~/flashrom/libreboot.rom

Shutdown your pi, write down your rom chip model, and wire up the clip

pi# sudo shutdown now -hP

Chip model name

Pinout. You may want to download the image so you can zoom in on the text.

Pin # SPI Pin Name Raspberry Pi Pin #
1 not used not used
2 3.3V 1
3 not used not used
4 not used not used
5 not used not used
6 not used not used
7 CS# 24
8 S0/SIO1 21
9 not used not used
10 GND 25
11 not used not used
12 not used not used
13 not used not used
14 not used not used
15 S1/SIO0 19
16 SCLK 23

Note: The raspberry pi 3.3V rail should be sufficient to power the chip during flashing, so no external power supply should be required; however, at the time of writing that has only been tested and confirmed for one chip, the MX25L6405D.

Macronix Spec sheet so you can adjust your pinout for 8 pin 4Mb chips as necessary

At this point connect your SOIC clip to the rom chip before powering on your PI.

Power on your Pi, and run the following. Ensure you swap out “your_chip_name” with the proper name/model of your chip. Check that it can be read successfully. If you cannot read the chip and receive an error similar to “no EEPROM Detected” or “0x0 Chip detected” then you may want to try powering off your PI, and switching the two pins which are connected to the IO ports. I.E. Connect pins (clip)8 to (pi)19 and pins (clip)15 to (pi)21

pi# cd ~/flashrom

pi# ./flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=512 --chip <your_chip_name> -r romread1.rom

pi# ./flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=512 --chip <your_chip_name> -r romread2.rom

pi# ./flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=512 --chip <your_chip_name> -r romread3.rom

pi# sha512sum romread*.rom

If they are identical sha512 hashes then you can generally assume that it’s safe to flash your rom.

pi# ./flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=512 --chip <your_chip_name> -w libreboot.rom

It may fail a couple times, but keep at it and when you get the message Verifying flash... Verified or Warning: Chip content is identical to the requested image then you’re done.

Shut down your pi, put your box back together, and install a libre OS for great good!