Farnsworth Engineering

Intro

I first heard of these displays when I saw a snipped of Adrian Black using them on Adrian’s Digital Basement in 2021. For only $20 per CRT it seemed like the perfect dumb project for me. Fast forward 4 years and I’ve done nothing with them. In fact I’ve had a kid, conceived another, and changed jobs since I bought these things. Time to put them to use. All my design files and code are available on my github.

Scope

At first I wanted to have a simple display…then I thought on it for a while…then I got goaded into a full audio-visual-tactile experience. Now I had a few objectives:

• Composite video output
• Speaker for music
• Display on/off control
• Rotary encoder & button for volume/mute/power control
• LEDs (because they come with the encoder)
• USB -> Serial UART for console access without WiFi

Mechanical Design

I really wanted to mimic some of the wood and plastic designs from the late 80’s early 90’s. I also knew I wanted heat-set inserts for easy modifications/improvements.

Initial prints were solely there to fit-check the CRT as my calipers don’t open wide enough to get an accurate height of the unit. Once the CRT fit the bezels I designed I was good to design the rest of the base.

I’m pretty bad at enclosure design. But everything fit after a print or two….

With the existance of 0201 components and robots, I typically give my PCB a form factor before I place a single chip…or even put my design into schematic. The workflow goes as such:

1. Define large-scale components (encoders, speakers, buttons, ports, etc)
2. Import raspberry pi
3. Mechanically position large scale components
4. Check fit in the main assembly
5. Fillet, add mounting holes, make pretty
6. Export DXF
7. Import into KiCad user.comments layer
8. Layout board
9. Export PCB as step
10. Re-import into Solidworks (This step helps check the fit of other components like resistors or large inductors)

For my first rev of the PCB you can see a whole bunch of through-hole parts on the left side of the board. Initially I was going to go with a bulkhead-style USB C connector, however the part cost on that was like $30 and USB C connectors are sold for like $0.3 now. I digress.

To get the wood/plastic aesthetic, I used bambulab teak wood filament and matte black filament. In hindsight I probably would have used glossy black, but this was close enough.

Electrical Design

I decided to keep notes in powerpoint, because I can draw shapes and such. I think it was good diligence for a solo-design. Not sure if I would do it again in the future as it was quite tedious, but I had links and notes for every major component on the PCB. This is especially helpful when I needed example circuits and references.

I’m not sure why I had it in my head, but I did not want to give the CRT 12V boost power. I really wanted to USB PD to negotiate for the needed 12V.

In hindsight it’s quite goofy to ask a buck converter to also pass-through voltage which is what I was planning on. Also, the USB PD chip I was using did not work. After this revision of the board, I decided it would be best just to provider 12V from the rail that can be supplied universally from all USB ports (power not guaranteed!)

The new design was significantly more simple, but gives the user no protections if the port cannot supply the necessary 1A. Consider yourself warned.

For the schematic I followed as simple of a layout as I could. I think it’s a relatively new thing to add pictures into KiCad but I leveraged that to make a quick and dirty pinout of the Pi and confirm USB C connections.

Layout of the PCB in this case was quite simple. I chose the cheapest trace/spacing specs offered by JLC PCB and went to work.

I was presented with no difficulties, until I tried to fit a bunch of 0805 components on to the PCB. This is where I reached the decision to drop down to 0402s and go with an assembly service.

In principal I like to design my projects such that they can be easily reverse-engineered. This generally includes reference designators for all components in the silk screen, however I simply did not have the room on this board with the 0805s and really wanted to get the second revision out without focusing too much on silkscreen design.

One side thing I’m quite happy about was my poka yoke method of adding in the CRT connector (on the right side of the board). The connector can be installed either way and the CRT will still function as expected.

During extended testing I found out that I was overpowering the speaker and managed to burn one out. Luckily the I2S chip has short circuit protection and overtemp protection so the board was okay. I still need to figure out proper power settings for the speakers I bought.

Software

I started off with a project in visual studio. This allows me to prototype code much faster than a remote session on the pi. I also used relative directory positioning such that my code could be run on either system. For some reason I could not do remote development on my PI Zero W through VS Code. I was able to do this for a previous project, but that feature does not seem to be available anymore? Luckily, until I got PCBs in hand, I could write a majority of the code as system-agnostic besides GPIO stuffs. For GPIO development I turned to old-trusty WinSCP. Save the file in VSCode, drag and drop it on the pi, run it from the pi over SSH. Rinse and repeat.

I’m pretty proud of how clever I was with the GUI. Instead of re-inventing the WeatherStar4000+ from scratch, I just copied it graphically, and added in dynamic elements only.

99% of this code was written with ChatGPT. As such, I wanted to make it as atomic as possible to avoid the bogging down that comes with excessively long sections of code. In my infinite free time I’ll come in and optimize things a bit

Side Bar: I had no idea that the WeatherStar4000+ Emulator existed. Knowing what I know now, I probably would have used that and just played the video from a webpage instead of re-inventing this from scratch.

The GPIO handling works well enough, but it would be nice to figure out how to get it to be more responsive. Right now I’ve got some really janky software PWM for the LED color control and weird debouncing going on. I probably should have written it as C code so it’s a bit less bloated.

I don’t play with VENVs in python so all libraries are imported as root “–break-system-packages”. Not the best thing to do, but this is dedicated hardware running a dedicated service. So, hell with it.

Another thing to note is the shapefiles come from NaturalEarth. The shapefiles are too large to host on Github so you’ll need to manually download them and add them to the “shapefiles” folder.

It’s been a while since I touched the code on this, but the get_radar.py script took forever to make, and I’m super proud I was able to get png weather data and accurately place it on a latitude-and-longitude grid, with boarders, then animate it. If anyone has any leads for free radar I would appreciate it. I was using NOAAs GOES satellite data, but it didn’t fit the aesthetic, and it also didn’t give good local data.

Closing Thoughts

It’s pretty, it’s goofy, it makes music, and gives me the weather for my friends and family.

Don’t turn up the volume too loud or you’ll melt the speaker (apparently).

I’m glad I got to get back out and do some small scale engineering again, even if it was for a hobby project. My current job has been more nut-and-bolt/simulation oriented and I missed the inconsequential nature of small hardware development.

I’m currently working on a youtube video version of this post for those audio-visual oriented. I’ll update this post when it’s published.

Acknowledgements

I’d like to thank the TWCClassics group for their Star JR font. Open weather map for the weather data. I would also like to thank Natural Earth data for their boundary shapefiles. This made the radar map much easier to implement. Tristan and Remington did a great job reviewing my PCB and caught some issues with R1 before I sent it out, so they earned a spot on my silkscreen.

I’ve been fawning over the reMarkable 2 tablet for a while as I’ve always had fidelity issues with lab books, note books, and note pads. Upon receipt of this fine (hackable!!!!) device. I decided to make it my Christmas mission to allow the reMarkable to have custom backgrounds that cycle. With a little help from chatGPT I’ve written a service (reMarkable doesn’t have crontab installed), timer, and installer that does all the heavy lifting.

Step 1: SSH Into Your Remarkable 2 and Download Backgrounds + Installer

Go to Settings->General->Help->Copyrights and Licenses. Clicking this will bring up a whole bunch of text. Mainly, the ip address and password are at the bottom of this first page (no scrolling necessary). It should look something like this

using the information above you would ssh in using the following command:

ssh [email protected]

It’ll prompt for the password (blacked out above) and you’ll type that in and hit enter. After login you’ll be greeted with this:

Next create a “backgrounds” directory in your current directory with the following command and navigate into that directory.

mkdir backgrounds
cd backgrounds

From there, you’ll use wget to download my installer and a few backgrounds.

After the file is downloaded, unzip the archive.

wget https://github.com/Radacon/reMarkable_Background_Shuffler/raw/main/BG_Shuffler_Release_2023.tar.xz

tar –xvzf BG_Shuffler_Release_2023.tar.xz –C /home/root/backgrounds

After unzipping is complete double check to make sure all files are inside of your backgrounds folder as such (use the ls command).

Next, get the installer ready to execute and run the installer.

chmod +x install.sh
./install.sh

It should output something like this once its installed

Thank goodness systemd-tmpfiles-clean.timer was already running as a service. It served as a bit of a guide for some of the nuances of getting this working. Either way, the script is designed to run once per hour. This shouldn’t effect battery life much, as the remarkable never really goes into “sleep”.

Step 2: Mod Away

The changebg.timer can be edited with

nano /var/systemd/system/changebg.timer

Currently the timer is set to change the background every hour but you can uncomment a line to change the background every minute or once per day.

I also included 18 sample images (that I took) that you can use outright or replace with your own. Keep in mind the images you use must be SEQUENTIALLY numbered from suspend_opt00.png-suspend_optxx.png for the randomizer script to work.

reMarkable automatically places owner’s information OVER the image. I would recommend adding your name/contact information manually to each image to avoid a black text on black background issue where nobody would be able to see your name/contact info. You can also remove a chunk of the images and replace them with white but I think that’s hideous. Keep in mind you should disable that feature in settings->security->personal information to keep redundant info from showing up.

I would also recommend turning off automatic updates for the remarkable. Keep in mind each time the device is updates your backgrounds will disappear and you will need to repeat these steps again! I don’t know of any locations that are safe from the update process just yet.

The github repo is here: https://github.com/Radacon/reMarkable_Background_Shuffler/tree/main

Merry Christmas!

UPDATES

I was told on reddit that all files in the /home/ directory are preserved during a firmware update. If you have automatic updates enabled, your background will change back to its default. All you need to do when that happens is to re-run the install script as it is preserved in your /home/root/backgrounds directory.

It’s also not important to have the images in sequential order. They do need to have the same name “suspend_optxx.png” though.

My wife got a new car! Excellent, it has all the bells and whistles, on-star, android auto, those dumb key fobs that let you unlock your car/drive without removing them from your pocket, and the option to pay $15/month to remote start the thing from your phone (there’s a few other features).

In an effort to get back at “The Man” and upgrade my 2013 Silverado, I decided to make my own remote-start app.

The premise is simple, I want to be able to lock, unlock, and start my vehicles remotely. I also want to be able to schedule a remote-start. Where we live, the vehicles are ALWAYS parked outside. Winter’s aren’t as harsh as when I used to live up north, but it’s nice to a) have a warm vehicle to scrape the snow off, and b) have a warmed-up vehicle to reduce wear-and-tear when the fluids are thicker than molasses.

I wrote the CSS and HTML from scratch (with the help of a few websites noted later in this article). This project was a good exercise in learning AJAX. From an EE point of view, it’s surprisingly easy.

Required Components

1. One or More remote-start capable vehicles.
2. Sacrificial key-fobs
   1. What the hell is up with the cost of new key fobs? $150 for an extra for my wife’s car!
   2. If you buy a new set, you’ll probably have to take them to a dealer to get them programmed.
3. An ESP8266. I am using a Wemos D1 Pro knockoff from AliExpress
   1. In hindsight, just buy a legit Wemos D1 from Amazon or whatever.
4. Soldering Iron.
5. Solder.
6. A 3D printer.
7. Some bits of wire.

Warnings and Limitations

Common sense ain’t all that common, so I feel like I have to warn you (the reader/maker/builder/user) not to try this yourself. Why? Let’s say you park your vehicle inside a garage. Let’s also say you have an auto-start scheduled for 5AM. You’re sleeping in your bedroom above the garage, your car starts, you don’t notice, and suddenly you’re in the obituaries as “That dumbass who accidentally killed himeslf/others.” “But…”, you may tell yourself, “I’m not dumb enough to do that!”. Well, consider that this code implements 7 different libraries and uses features I have not thoroughly tested or verified as good. Also, consider that my code, as it’s written, allows over-the-air updates from anyone on your local network. Even if you don’t die as a result of someone hacking this, you’ve just left your vehicle more venerable to theft.

This is one of those dumb projects that I just HAD to do. There is precedent here: Who the hell pays $15/month to remote start their car? Not me.

Okay now the limitations:

1. The Wemos D1 Mini hardware can support up to 3 key fobs (lock, unlock, and start connected). My code only has provisions for 2 users.
2. The webpage is COMPLETELY unsecured. Literally anyone on your network with an IP address (hell, mDNS hostname: http://cars.local) can connect and start/unlock your vehicles.
3. The code is a complete bodge-job but I have to say I’m proud that I wrote the CSS by myself.
4. This doesn’t give your car superpowers, it’s just hooking an arduino up to your key-fob. As a result you cannot:
   1. Start your vehicle from your phone when you’re at work (away from your wifi network)
   2. Schedule a remote start time while your vehicle is away from the base station

Hardware

Key fobs always interested me because they’re these tiny coin-cell powered devices with an absolutely minimal number of components, they have a range of 100’s of feet, and they last for months/years! It’s the type of EE I can get behind. Now it’s our turn to reverse engineer them. What gets me are these devices are ALWAYS powered on. Sipping micro/nano amps from the coin cell when waiting for a button press.

The microcontroller in the remotes is pretty obscure. I was unable to find a datasheet on the elusive chip, but I was able to make some educated guesses with a multimeter

1. The microcontroller is always powered on
2. All 4 inputs are pull-up
3. It’ll probably handle 3.3V

The GPIO pins are initialized high (3.3V) as the microcontroller is looking for a “low” (0V) signal for a button press. When you want to press a button, toggle the GPIO pin low. Easy! We do this hookup twice, once for each remote.

Code

I’ll keep this section short as I have the code on Github.

The code needs to do 5 things:

1. Host a website
2. Toggle some GPIO
3. Keep time
4. Hold a schedule
5. OTA Firmware Updates

Hosting a website, toggling GPIO, keeping time, and OTA firmware updates are very common things people want a microcontroller to do. The base code is available as libraries which I import.

Scheduling turned out the be the most difficult part of this project. There’s a library called alarms which is complete trash for the ESP8266 as you need to use alarm_delay instead of regular delays. This causes the ESP to crash frequently.

I still haven’t quite figured out the bug yet. But I need to publish this blog post before winter hits. I’ll publish an update to this post when I figure out why time keeps slipping away for starts >24 hours in the future.

The code is available on my github here.

Webcode

Most of the web design I do is derived from html5up.net. It’s a great resource for getting simple webpages going for people you care about. Well, I wanted a proper course in web design as I’ve been using templates for years and have never formally taken a web design course. I started with the basics of CSS and built little widgets as I went along. I use brackets.io for code editing and live previews of changes I make. It’s very handy and keeps me from uploading useless code to the ESP.

One of the more handy things I was able to learn was the use of AJAX. Which let’s parts of my webpage be refreshed on command. Kind of like a data stream. There’s a great tutorial here for implementing this.

Once a website was created, I was able to flash all of the page data and resources onto the ESP8266 via this handy tutorial.

Mechanical Design

I really didn’t go all-out on this design. I really needed a box that could be mounted to a wall and hide my hideous wiring job. It serves that purpose. Again, the files are available on my github if you feel like following in my steps.

Conclusion

This was a really fun project involving my new favorite microcontroller. I was able to make something useful and web-based. There are still some bugs in the code I am trying to stomp out, but things are working well enough for me to get some use out of this system on my smart phone. Again, I wouldn’t recommend this if there’s ANY chance you’ll be parking in your garage or if you care about your vehicle getting broken into. Code like this should not be responsible for safety or security and there’s a good chance you’ll forget about this device a few months after building it.

I love the idea of being able to get the status and history of temperatures and humidity around my house. You can use the data to infer certain things like when a shower is being taken, a door/window being left open, or when you’re heating a room you don’t need to. I can use this data to re-balance my forced-air system as well.

Please understand that I do not recommend the use of unencrypted wireless devices in any way, shape, or form for control systems. There are major safety vulnerabilities that can crop up from otherwise, well-written code. The data generated from these devices is used to help me make an informed decision about my environmental control. The data is not tied into a control loop at all.

The units that are available on the market are typically bluetooth and require an app to read the data. WiFi units send the data off to “the cloud” and likely log everything, but can be accessed by a phone/browser.

So what’s a good compromise between designing my own hardware and giving all of my information away to China? Enter Aaron Christophel!

I saw a post on Hackaday about Aaron Christophel modifying the firmware of $2 Xiaomi thermometers from Aliexpress. So I went ahead and bought 16 of them to scatter around the house.

The problem Aaron is trying to address is the fact that these thermometers obfuscate temperature and humidity data contained within their broadcast information. There is a way to pull this data out if you know the token and bind key (something the app does). But Aaron’s firmware takes out the need for bind keys and tokens and instead lets the thermometers broadcast the data as plain text so to speak. No app, and a simple python script can read the data.

Aaron wrote a really nice bootloader that uses google chrome and your computer’s bluetooth radio to flash new firmware on to the units. It’s a little slow taking about 1 minute to connect, activate, and re-flash the unit’s firmware.

Step 1: Preparation

Out of the 16 units I purchased, I only ended up deciding on locations for 13 units. Deciding on a location is the first step. Next you’ll transfer all of the locations to an excel spreadsheet as a column. Next door to the locations column you’ll put the mac address column. This will help you form an array later for matching up broadcast mac addresses with the rooms the devices are in.

Step 2: Re-Flashing Firmware

I’m condensing Aaron’s instructions here, but a full how-to exists on the project’s github page. First, download the ATC_Thermometer.bin file. This is the new compiled firmware that Aaron wrote. Okay now is when you use Aaron’s web-browser DFU tool. Select the .bin firmware file, connect to the thermometer, activate the thermometer, and then start flashing.

Keep an eye on the progress bar, and when it gets up around 90% watch the bottom right two digits on the thermometer. They will flash the last 3 bytes of the mac address in hex. Write these six characters down as you’ll need to pull the battery and put it back in to get it to display the mac again. If you have lot’s of devices it’s important to have the mac address written on the unit.

Before writing the address on the unit however, connect to the device via bluetooth and change the appropriate settings that make you happy. For example, I set my devices to display Fahrenheit, and to show the battery in the LCD. We do this step first to double check the mac address because the number 6 displays as the letter b and that can introduce problems if you read and wrote the address incorrectly.

Once you’re sure you’ve got the correct mac address for the correct device, go ahead and scribble down the address on the bottom of the unit. I chose the bottom because I could still read the address once they’re adhered to the wall. Add this mac address to your spreadsheet and now you have a relationship established between the room and the mac address.

Step 3: Parsing and Aggregating Broadcast Information

Tom Nardi has a good writeup exploring the software side of this project, including some example code to get you started reading data off of the sensors. I’ll post the full code below as I had to make several modifications to filter out redundant information his code would be saving. My script also saves the data to an array of verified sensors and then writes that to a file. This is important because the py-bluetooth-utils runs until keyboard interrupt, and the devices will all update their broadcast information out of sync. This isn’t 100% the best way to do this, but python really isn’t good at running continuously if your script is super bloated.

I wrote a script that runs on startup and simply writes all values broadcast by the thermometer to a 2Dx1 array and then writes that information to a file. This has been running stable for over a month now on a raspberry pi zero w.

Step 4: Publishing MQTT Information

If all you want to do is log this data to a CSV file then you’re pretty much done here, except for generating a CSV file. But if you’d like to get the information into a web service, I’d recommend using mqtt since it’s a fairly lightweight protocol and Home Assistant plays nice with mqtt. I wrote a second script which reads the output file written to by the BLE listener, and parses it into MQTT topics with data. A chronjob runs this second python script which publishes data once per minute (which is the refresh rate of the sensor).

Step 5: Receiving and plotting the sensor data in Home Assistant

If you just want the data aggregated in a place that you have control over and can plot then Home Assistant is a pretty good option. There’s also plugins available for HASS such as GRAFANA if you want more graphing options. I’m not going to go into Home Assistant setup but will outline how to install and configure the Mosquito MQTT Plugin and add the published data as a “sensor”

Step 6: Viewing and acting on Data

Since these sensors are not part of a control loop, we’ll use the information to make manual adjustments.

As you can see here,

My Movie Room (upstairs bedroom) temperature is about 6 degrees hotter than the rest of the house. While this doesn’t look so odd at first glance, I’ll say that the movie room is heated with electric baseboard heating. This means we’re spending more money heating a rarely-used room above what we consider a comfortable winter temperature. Clearly a point of cost savings.

Another thing you can do is determine if a room has proper ventilation. Below is a historical line graph of the relative humidity of the master bathroom.

See those spikes? Those indicate a shower was taken. The current relative humidity outside is 40%, so seeing the spikes return to “baseline” in a timely manner, indicates good air flow. Since our master bathroom doesn’t have a vent fan, this is an important variable to monitor to combat mold growth. From the looks of this, we don’t need to install a vent fan.

These sensors are marketed to last about a year on one coin cell. I’m sure their battery life could be extended by changing the broadcast interval in the firmware, however, planned sensor maintenance can be carried out as the sensors are broadcasting their battery level!

We can even determine a failure based on current time and the Last RX Time variable. If it’s last reported battery level was 50% and the last RX time was 2 days ago, the unit is probably dead or the scanning computer can’t pick it up anymore.

Closing Comments

So why all this hassle? Why not just use the xiaomi app and not hack the sensors? You’ve seen that this data can be used to infer more than just the temperature of a house. A company can gather some serious data about your behaviors all the way down to your showering habits, yikes!

Update: 2-21-21

I’ve started using Grafana and InfluxDB to store and graph my information. It works much better than the built-in graphing in Home Assistant.

I’m what you might call a casual mechanical engineer. By trade, I’m an electrical engineer, but there’s something cathartic about designing parts in solidworks. I started off in high school and didn’t think much of it, but as I went through college I contracted out my skills to model up jewelry for clients. This jewelry was then 3D printed and cast into final products. Don’t worry, I actually was dumb enough to drop several thousand dollars on a “personal” copy of solidworks.

It was an enjoyable experience for both myself and my clients as we could hang out, drink scotch, and work through what exactly they were looking for. Eventually a design came up where they needed variations on a theme so to speak. Small changes in the design, but the overall concept was the same. Learning about design tables saved me so much time as a result. A guy can alter variables in an excel spreadsheet and solidworks will build derived configurations with these new variables.

Fast forward 5 years and I’m designing a part that helps me position my chopsaw back clamp at specific angles.

Getting my inspiration from machinist’s angle blocks I designed a part that fits in the track the front clamp rides on and butts up to the back clamp.

Okay here’s the thing. I have the solidworks part reliably re-building from 0 degrees to 45 degrees. This means I can feasibly make any angle I’d like without throwing any weird solidworks errors. I don’t want to manually enter the angle I want, and then revise the text for all of the infinity of angles that exist between 0 and 45 degrees. I also want to generate a pallet of blocks that step from 0 to 45 degrees in increments of 5 degrees. I ALSO want the text on the side of the block to update with the angle the block was set to so I don’t have to go in to every derived configuration and update the text.

Here’s how we do this (keep in mind I’m running SW14, so your mileage may vary).

1. Make your part how you want it, and rename your “primary value” of your smart dimensions that you want to change to something meaningful eg: “set_angle@Sketch3”
2. File->Insert->Tables->Design Table…
3. You should now be prompted with a list of primary values from your part. This is why you took the time to rename your primary value. Select “set_angle@Sketch3” and excel will automatically populate a new column with that name at the top and the value of that directly below.
4. You can make as many new configurations as you’d like by adding another row. You will have to name them by entering the name in the column where “Defult” resides. I’d recommend something meaningful.
5. This should successfully generate x number of spin-off parts with the values of smart dimensions changed appropriately.
6. To get sketch text to update as a variable go to file->properties…->configuration specific
7. Make a new property named “text”, type: text, value: 69420
8. Go to your extruded cut or boss and edit the sketch text as so: $PRP:”text”
9. Go back to your design table by right clicking on it and edit it. It should prompt you asking if you want to add the “text” property you just made.
10. Now your angles and text values reside as variables in an excel table!

Use this to create as many variations as you want of your model. These derived configurations can then be loaded into an assembly with ease. This makes palleting up parts for 3D printing easy.

I inserted a sketch of my build plate are into my assembly as a guide for how many I can fit on to the build plate at once. From here you can generate an STL from the assembly as one part to save you hassle from having to get things stacked up in Cura or whatever.

File->save as->.stl for the type->Options…->Check “Save all components of an assembly in a single file”

Import this STL into cura and now you have a pallet of different models you can print!

Here’s an angle block in the saw. Works like a charm!

Now don’t go expecting to get decimal-place-precision out of your chopsaw. But these guides work way better than the scale on the saw itself and can give you reproducible cuts if you need to adjust every time you cut.

Sources:

https://centralinnovation.com/technical-resources/learn/add-sketch-text-to-design-table/

Post In Progress!

Starting this blog post so I’m forced to follow through on my hare-brained idea.

Okay so picture this: You have a license to a brand-spanking-new copy of Solidworks 2014 sitting on your desktop computer. You live in the mountainous South West, it’s summer, and the idea of air conditioning never caught on in your town so you try to keep all of your electronic equipment off at all times unless it’s in use.

Finally! Relief! You find yourself a cool dark place to set up shop for the day and open your laptop so you can remote into your desktop back at home and do some designing on Solidworks! But wait. Your computer isn’t on, and home is a half hour away! Oh no! I wish there was some way to leverage this internet-of-bullshit to my advantage.

Well say hello to WoWLAN! Wake on Wireless LAN. This is the greatest idea that will never catch on. And unfortunately for me, it’s not available on my PC. Well, it is, but only from hibernate mode and windblows10 likes to wake up my PC from hibernation periodically so that option is OUT. Time for some hardware.

Step 1: Raspberry Pi

I’m purchasing a raspberry pi zero w for this project because they’re small and have wireless built in. Unfortunately they’re the slowest of the Pi’s so Raspbian isn’t going to work. Go ahead and install dietPi. It’s worked great for me and has low overhead.

Step 2: Software

Sudo apt-get install python3 and paho-mqtt on your Pi and download MQTT Dash on your smartphone. From here you can write a python script that connects to the MQTT test broker and you can start sending and receiving messages and debugging any issues that come along the way. I am leaving my code unpublished at the moment because it isn’t robust enough to deploy. But it’s in my best interest to fix it so it’ll be released eventually.

Step 3: More Hardware

It’s kind of a dick move to use a public MQTT broker (also insecure) to handle your web traffic so get a piece of hardware that is web-facing that you can install Mosquitto MQTT on. This can be a webserver you have or, in my case, an AWS instance. You get a free year of the t2.micro after that the t2.nano should run around $50/year and work just fine. If I ever figure out how to field Mosquitto on my lightsail instance it’ll save me from paying double for AWS services. I’ll update that here.

Be sure to use DuckDNS and your domain to adapt to your dynamic IP address. Also don’t forget to start Mosquitto MQTT on boot.

Step 4: Even more hardware

I started out with the idea of using a solid state relay to emulate a button press. Here’s my schematic:

And here’s my PCB.

Here’s My Bill of Materials:

Step 5: Integration

Build up your PCB, solder it on to the raspberry pi and install it on your PC.

Hey, you’re done!

Good Luck!

-Conrad