Jake Walker

Revamping a 2DS XL

Jake Walker — Mon, 16 Mar 2026 18:13:23 GMT

Recently, I've found myself watching quite a few YouTube videos about various game console repairs and modding. One that stood out to me as a really awesome project was Zac Builds' video on building a "New New Nintendo 3DS". It's a good watch if you have time, and goes over a few mods like installing a bigger battery, Bluetooth audio and so on.

That along with other videos, spurred me on to buy a second hand New 2DS XL with the sole purpose of modding it. I thought it would make a great compact travel game console. I have a Switch 2 and Steam Deck which are both great, but they can both take up a little too much bag space sometimes when traveling.

Having had a DS Lite when I was younger, and an original 3DS in my late teen years, the DS family has quite a bit of nostalgia attached for me, and there's such a big library of games to explore. The nostalgia factor alone was a pretty good reason for me deciding to jump into this mini-project.

From doing a bit of research, I decided I'd install a new battery, swap the shell and install a USB C port.

Choosing a Model

Nintendo released quite a few 2DS & 3DS models over the console's lifetime, so there's quite a few to decide between. I was interested in some light emulation, and better performance, so I set my sights on either a New 2DS or New 3DS. The "new" versions both have slightly better CPUs than the original versions, and I also wanted an XL model for the larger screen.

Had I thought about this a couple of months earlier, I could have picked up a Japan "LL" model on my travels which would have been really cool. Although, from what I've read the system language can't be changed from Japanese, even with custom firmware, however games should still work in English.

In the end I went for a New 2DS XL. I was close to a New 3DS XL, but it was an extra £100 or so, and I wasn't that interested in the 3D features.

Custom Firmware

As soon as I got the 2DS, I software modded it with custom firmware. There's a fantastic guide already out there on 3ds.hacks.guide, so I won't repeat anything here - plus the instructions can differ depending on your OS version and console model. With Nintendo shutting down their 3DS servers a while back, soft modding is a no-brainer - it brings un-official online multiplayer servers, gives the ability to manage game saves, bypass region-locked games and most importantly homebrew for using emulators and things.

It only took about an hour or so to complete the process and the instructions are super clear and easy to follow.

A few notable things I've installed in the homebrew department are:

Fake-08 Emulator - This is an emulator for Pico-8, a "fantasy console" which never existed. It has a retro feel and "retro limitations" like a 128x128 display with 16 colours and a maximum game size of 32k, but it was made in 2015. There's some amazing free games for this and it has a thriving and creative community which I love. One of my favourite games on there is Celeste (yes, that Celeste if you've heard it before, but it was the prototype version, made before the full Steam/Switch version), I'm hoping to play the second version soon.
CTGP-7 - a modpack for Mario Kart 7 which adds tons of new tracks, characters and more.
TWiLight Menu++ - a launcher with support for original DS games and a bunch of emulators.
Pretendo Network - a project aiming to replace the now shut-down Nintendo online network, enabling online play for supported games.

2DS XL running Celeste Classic on Pico-8 Emulator

Shell Swap

The 2DS I picked up was definitely well-loved and came with a bit of a grimy shell and buttons, even after giving it a thorough deep clean, the case is a bit scratched up and there's just generally quite a bit of wear all over the shell and buttons. The console I picked up had a black & blue shell. In the photos below you can see a few scratches on the exterior of the shell, especially on the bottom.

I was able to find a new shell on AliExpress for £15 and in theory, it's a super easy way to give the console a new look and feel. I'd have loved to get a clear or atomic purple one, but unfortunately there aren't any mass produced ones in colours other than the original.

Once the new shell arrived, I got to work moving all the internals across. After doing the full swap which took multiple hours, I found out right at the end that the case didn't snap together properly and meant the display couldn't open fully. The bottom part of the shell is comprised of two parts - the top which houses the buttons and touch screen, and the bottom part which the top snaps into. On the third-party shell, this didn't quite meet up properly. After doing some further looking into this I found many people on Reddit mentioning that third-party shells are usually very hit-or-miss.

In hindsight, I would have never attempted the shell swap - it was a huge pain and I did nearly break both screens trying to remove them. It's really not worth it even with a really beaten up original shell - it's much better to stick with the original and perhaps apply some vinyl skins or something. The build quality of third-party replacements, at least for the 2DS XL, really isn't there like you'd find for Switch shells or other consoles.

On the bright side, after disassembling and reassembling the console two or three times, I'm really familiar with how everything fits together, and it would be no trouble to do repairs in the future.

Regardless, I'll briefly walk through how I did the shell swap as I think it's pretty cool to see the internals. This is not designed to be a guide though, and I'd recommend making use of the iFixit guides and YouTube videos as your primary reference if you're doing this yourself!

iFixit has some great guides, as usual, on the teardown process and common repairs which I roughly followed for disassembling the console. I believe they are made by the community, so there's a few details missing which I had to figure out for myself.

New Nintendo 2DS XL Repair Help: Learn How to Fix It Yourself.

Released on July 28th, 2017, The New Nintendo 2DS XL is a technologically-improved remodel of the 2DS handheld. It is the ninth and last redesign of the Nintendo DS line, The console is much larger than the original 2DS model and adds all the features of the updated ‘New 3DS’ line of systems, minus the ability to play games in 3D on the top screen.

iFixitReid Fleishman

To start off, I followed this guide for front button replacements which gets us to the point the motherboard is out of the console. The first step of this was gently prying around the gaps in the bottom shell and hinge to release the bottom of the shell. For context, the gap shown in the hinge here is the part of the replacement shell which didn't snap together properly.

With the back of the shell removed, I gently lifted the case and disconnected the ribbon connector for the back cameras and connectors for both speakers.

With the back part removed, we're down to the motherboard now. I removed the battery which was well stuck down and disconnected all of the ribbon cables. Important note: two of the connectors are friction-fit and trying to remove the locking tab like you would normally can damage them! There's more info on this in the iFixit guide.

With the motherboard removed, I can take off the plastic piece on the back of the bottom touchscreen. Following the iFixit guide for touchscreen replacement, I gently pried on the screen to remove it from the bottom case as it's stuck down with adhesive. However, in the process I managed to separate the digitizer from the screen. I later found out you can gently push the screen from the bottom to remove it from the shell which would have kept the digitizer and screen as one, so I'd recommend doing it that way. I reused the adhesive for the screen in the new shell, but it would have been sensible to replace it with some thin double-sided tape as the adhesive I removed got super tangled once I pulled it off the old shell. I honestly got a bit freaked out when I separated the digitizer from the screen and thought I might have broken it - but luckily didn't!

Below you can see the process of me first installing the digitizer, then the screen into the new shell.

The buttons were pretty easy to swap over, and I just used the new purple front buttons that came with the new shell.

Unfortunately from here it gets even harder! With the touch screen removed from the old shell, I had to separate the top and bottom by removing the small hinge mechanism. The tiny hinge mechanism is just under the red antenna wire you can see here. It's installed super tight and honestly took an unreasonable amount of force to get it out. The best technique I found to work in the end was from this YouTube video where you use a flat head screwdriver to lever it out.

With the top screen removed, I proceeded to take off the plastic piece from the back of the screen to reveal screws - taking these out and prying around the edge of the screen gets us to the point we have the back of the screen exposed. At this point I incorrectly pried around the edge of the screen and started peeling up the backlight. Again, not sure how I didn't end up breaking this screen! The screen is actually stuck to the front plastic "lens" piece, so we just need to take off this lens, keeping the screen attached. Below you can see the screen installed in the housing, and after just the screen on the lens.

With the top screen removed, it's just a case of doing the same steps in reverse to install it into the new shell. Then I could attach the two halves back together, and re-install the motherboard. I put the buttons from the new shell in here, and also swapped out the top of the joystick for a replacement as it was pretty worn. On the bottom piece of the shell, I installed the new trigger buttons and moved over the springs, retaining plastic pieces and cameras.

And with that, I reinstalled the battery, ribbon connectors and so on and I was ready to put the console back together.

Once I had it all back together, as mentioned earlier, I found it didn't snap together properly and was really gutted! To salvage the project, I swapped the bottom part of the shell back to the original as this was where the problem was. The top screen I left in the new shell as I was a bit traumatised by nearly breaking it and had slightly broken the original shell. I completely disassembled the bottom part again, and rebuilt it in the old shell, but keeping the new purple front buttons and triggers. In the end I have quite a cool looking black and purple console. I'm not a huge fan of the silver on the top screen, but with the original being blue, I felt the silver matched the aesthetic better.

Battery Swap

The new battery hadn't arrived in time for when I started on the shell swap, so I stuck with the old battery and installed the new one when it arrived, luckily not much disassembly is required for the install. It's the same size so fits in the same battery slot, but increases the capacity from 1,300 mAh to 2,000 mAh. That's ~1.5x larger so it should help a lot with battery life, plus with the console being at least a few years old, the old battery has probably lost some capacity from when it was new.

USB C Mod

My final mod for now, is swapping the charging port to a USB C connector. This is probably one of the best quality-of-life improvements as it means when travelling there's not an extra power adapter to carry round, and means you can charge the console from a power bank.

To begin, I removed the motherboard from the 2DS and applied some Kapton tape to the components around the connector, just to protect them from solder and heat. I used a bit of a cereal box as a soldering mat just to catch any solder bits and flux.

With the port taped off, I used a mixture of solder wick and a solder sucker to take off the old port. A hot air gun would have been a massive help here, but unfortunately I don't have one. I cleaned up the excess solder with more solder wick and cleaned off the area with isopropyl alcohol to remove the black bit shown below.

At this point, I double checked the connections to sanity check the part I bought and that I was putting it on the right way. I used a multimeter with one side on the game card port shield, and the other on each pad of the connector to see which pads were ground. I found the small arrow on the port points to the pin which carries voltage.

Next I applied some flux to the pads to help with the soldering and installed the port. I did some checking with the multimeter again to check for shorts, and I did find that the power and ground pins were shorted, although couldn't see just by looking, so I reflowed the joints which fixed the problem.

With the port installed, I had to do some modification to the battery bracket as the USB C port is wider than the original charging port. I shaved off the part of the bracket that sits around the charging port. You can see where I did this below with the original left bracket and new bracket on the right. I also had to gently sand down the port on the bottom shell just so the new port would fit properly.

With the new port being a lot thinner than the original, there's a bunch of gap round it vertically which is a bit of a shame. I've seen people install the port elsewhere on the board, like next to the SD card slot, or in place of the IR LED, but I thought I'd just go for the full swap.

I was able to design a small 3D printed cover for the port just to clean it up a little.

Here's a video of me plugging in the console for the first time with the USB C port. As with all builds, it's bad luck to put it back together before testing, hence the bottom shell being off.

Fin

With that, my mini-project on modding a 2DS XL is all wrapped up.

Having done a shell swap on my original Switch Joycons in the past, it makes for quite a fun project, but in this case it was a bit traumatic with the not so good quality replacement shell, and the difficulty of removing the screens and hinge. Supposedly the 2DS XL is one of the most difficult DS models to disassemble so I can't recommend doing a shell swap at all.

However, the USB C port is a pretty straightforward mod if you're comfortable with soldering.

I did also buy a Bluetooth audio module which I may install later on so that I can connect Bluetooth headphones for playing on the go. But for now, I've got a unique looking 2DS XL now which will make the perfect travel console for trips.

Automatic Post Notifications with n8n

Jake Walker — Sun, 31 Aug 2025 14:30:57 GMT

I'm an avid self-hoster and have had n8n setup for a while but not used it very much. That is until now...

This is a very quick post about how the automated notifications work on my blog with n8n. Probably quite niche, but hopefully useful for some!

I really like static sites, they're super fast and customisable while giving you the flexibility of using React or other frontend components without any JavaScript getting shipped to the user (unless you want it of course).

However, having had a static site in the past, the main way of authoring is with markdown files, which is fine but I never found a decent editor that I enjoy writing in. So I use Ghost for this website's backend, it's got a fantasic editing experience. I recently switched my website to use a static site Astro frontend which pulls posts from Ghost rather than using Ghost directly. I'm hoping the best of both worlds.

You can check out my site's source code here by the way.

Ghost Webhook

Ghost allow you to create a webhook (docs here) which can get triggered when something happens, in my case I'm only interested in when a post is published.

In n8n, I have a webhook receiver which is linked up to Ghost, so it triggers when a post is published. The payload contains some info about the post, such as the title and URL. Great!

Before I had Astro, it was easy enough to just use this trigger to create a Bluesky post.

Auto building

For my site, I host it with Cloudflare Workers which is like Cloudflare's serverless functions offering. I have a mostly a static site, however the contact form, for example, uses some server-side code. Cloudflare recommend using Workers over Pages (which is just static site hosting) now, even for completely static sites.

Cloudflare automatically build my site whenever I commit to the repo, but no commits are made when I publish, so the site doesn't update when I publish. Sadly Cloudflare doesn't give you a webhook like they do for Pages for triggering builds manually.

To resolve this, I setup a GitHub Actions workflow in my website repo (here) which is triggered with a workflow_dispatch event - essentially a manual trigger. Cloudflare build for me normally, so I don't want to trigger this build for every push although I'll probably combine them in the end for simplicity but that's a job for another day.

So once my n8n workflow receives the new blog post, it will now kick off the GitHub workflow:

Waiting for the build

The issue now is that the build can take a few minutes and I want to wait for the site to be live (or at least nearly live) before sending the notification. Luckily n8n has a cool "wait" node which can pause execution until a webhook has been received. This wait webhook is separate to the initial webhook and is unique for the execution.

When the workflow is dispatched, the wait webhook is passed in as an input to the workflow.

I have the wait node configured to only wait for up to an hour, which should be plenty of time, just in case the workflow fails and never calls back.

Sending the notification

Once the build completes, the Bluesky notification part is run. The "format post" node runs some JavaScript to create a JSON object to send to Bluesky as there's a bit of processing required to get it into the right format. This node can reach back to grab context from the initial webhook for all the post information.

The "create session" node makes a call to the Bluesky API to create a session using my auth token, then the final node creates a new post using the formatted post and the newly created session token.

There's some great docs from Bluesky on how to create posts programatically which I based my n8n stuff off. Here's the script that builds up the Bluesky post object:

function parseUrls(text) {
  const spans = [];
  // partial/naive URL regex based on: https://stackoverflow.com/a/3809435
  // tweaked to disallow some training punctuation
  const urlRegex = /[$|\W](https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*[-a-zA-Z0-9@%_\+~#//=])?)/g;

  let match;
  while ((match = urlRegex.exec(text)) !== null) {
    spans.push({
      start: match.index + match[0].indexOf(match[1]), // Adjust start based on full match
      end: match.index + match[0].indexOf(match[1]) + match[1].length, // Adjust end
      url: match[1],
    });
  }
  return spans;
}

function truncateToTwoSentences(text) {
  if (!text) {
    return ""; // Handle null or undefined input
  }

  const sentences = text.split(/[.?!]/).filter(s => s.trim() !== ""); // Split into sentences

  if (sentences.length <= 2) {
    return text.trim(); // Return original if fewer than 2 sentences, but trim whitespace
  }

  return sentences.slice(0, 2).join(". ") + "."; // Join the first two with ". " and add a final "."
}

// loop over all the webhook inputs (probably just one)
return $('Webhook').all().map((item) => {
  console.log(item);

  // replace the url
  const newUrl = item.json.body.post.current.url.replace("ghost.jakew.me", "jakew.me");
  
  const content = `I've just published a new blog post \"${item.json.body.post.current.title}\" - ${newUrl}`;

  // create the actual post object
  return {
    "json": {
      "post": {
        "$type": "app.bsky.feed.post",
        "text": content,
        "createdAt": new Date().toISOString(),
        "embed": {
          "$type": "app.bsky.embed.external",
          "external": {
            "uri": newUrl,
            "title": item.json.body.post.current.title,
            "description": truncateToTwoSentences(item.json.body.post.current.excerpt)
          }
        },
        "facets": parseUrls(content).map((u) => ({
          "index": {
            "byteStart": u["start"],
            "byteEnd": u["end"],
          },
          "features": [
            {
              "$type": "app.bsky.richtext.facet#link",
              "uri": u["url"],
            }
          ],
        }))
      }
    }
  }
});

Wrap Up

The final result is a post like this:

I've just published a new blog post "Light Up Festival Bucket Hat" - https://jakew.me/light-up-festival-bucket-hat/

[image or embed]
— Jake Walker (@jakew.me) 23 August 2025 at 23:49

Yes, this is a little overkill, but it turned out to be quite a cool little project to create with n8n! Maybe in the future I'll add Mastodon and other platforms.

I'd highly recommend having a play around with n8n, you can do some crazy complex workflows - I've seen one online where people have made fully automated AI slop posting machines.

Light Up Festival Bucket Hat

Jake Walker — Sat, 23 Aug 2025 21:00:00 GMT

I'm going to a festival next weekend and one project I always think about doing when I come back from one is a light up bucket hat. The idea is pretty simple, grab a bucket hat, attach an LED strip somehow and write some simple code to display different patterns.

I have thought about this project a little last minute, so I only have a day or so over the weekend to get it complete.

Gathering the parts

Luckily, I have a lot of the parts on hand, which is great for the short deadline I set myself.

For the lights, I'm going to use a strip of WS2812b LEDs which are individually addressable. You can also get a flexible matrix, or fairy light versions and they're pretty common these days on online maker shops or eBay. For the microcontroller, I have a really small Raspberry Pi Pico on hand which is nice and compact. The LED strip doesn't require any extra electronics so it can be directly wired to the microcontroller.

Ideally the LED strip would have some extra protection against things like drinks being thrown in the air, or just the potential bumps and stuff that might happen. The best option for this is probably a flexible rubber channel. I found a couple online, but they didn't have amazing reviews and I didn't have enough time to order it. It also looks as though it would double as a bit of a diffusion layer too. I won't link one here, as I don't want to potentially recommend something without trying it.

As for powering the project, to make it look really slick looking I'd put a rechargeable battery in the hat, however I'm not sure I trust a battery that I've modified right next to my head. So instead I'm going to have a cable going from the hat into a battery bank in my pocket.

With the right microcontroller, you could also make a cool web interface, or have it Bluetooth controlled, or even something more crazy like Meshtastic or crowd controlled. I stuck with just a button to control it so that I could use my tiny microcontroller on it's own.

Code

I decided to start with the code and basic electronics, just to make sure everything works before I assemble it.

I used a larger Raspberry Pi Pico board that I use a lot for testing things out. I also decided to add in a resistor to the data line of the LEDs just for extra safety - it helps protect the microcontroller from excessive current draw and can prevent reflections of the data signal.

I got a basic Arduino project setup in Visual Studio Code with PlatformIO - I prefer it so much over using the Arduino IDE these days! I put together a simple program with the FastLED library.

With this project running of battery power - hopefully for as long as possible - I was trying to put a bit of thought into my code power-efficient. There are simpler (and more power-efficient) ways of driving the LEDs, but FastLED does a lot of heavy lifting when it comes to making good looking lighting effects.

I started off with FastLEDs simple blink sketch, then edited it slightly to use all the LEDs available on my strip.

FastLED also have a bunch of other great sketches which have examples of lighting effects, and I also found this great blog post with a bunch of effects too which I used for inspiration:

Tweaking4All.com - Arduino - LEDStrip effects for NeoPixel and FastLED

In this article I’ll show you a several LED strip effects for NeoPixel and FastLED. The code works for both libraries and any strip they support (theoretically).

Tweaking4All.comHans

I also did a little bit of vibe coding to get a bunch more effects built in too.

Here's the final code I had with 8 different lighting effects, plus an "auto-cycle" mode which loops through all the effects. With just a single button, I had some code which detected long vs. short presses of the button. For certain effects, like the solid colour, it would change the colour when long pressed, and for other effects it would adjust the brightness. Short pressing the button would cycle to the next effect.

Assembling

Once I was happy with the code, I put the hat together.

I wanted to buy a cheap hat which was either black or white, but I wasn't able to find one locally which I was quite surprised at! My backup plan was a free branded bucket hat which I don't wear very often.

I started off by unpicking some of the stitches on one of the seams so I could poke the LED strip wires through to the inside.

With the wires poked through the hat, I soldered on my protective resistor to the green data line, then put some heat shrink tubing around it to stop it from shorting against the microcontroller. The power line is soldered to the 5v pad and ground to ground. The other end of the resistor can go to any pin.

Side note - this microcontroller - the Tiny 2040 is in fact very small, only about the size of a 50p coin or less! And has also has built-in Neopixel too

Finally I coated the microcontroller and it's wires in a healthy amount of hot glue to keep everything in place and protect against tugs on the wires.

Next up was sewing the hat. Luckily my mum (hi mum!) taught me to sew when I was younger, but it's been a couple of years since I have done so. I found some very cheap needles and transparent thread locally. The first parts weren't very neat, but I got into the swing of it pretty quickly.

First, I reinforced the hole I had made earlier to stop it from getting any bigger, then sewed the LED strip around the outside of the hat.

I should have probably chosen better needles, as I broke 3 of them just sewing this hat, but luckily there were plenty more. The transparent thread made it super difficult to see what I was doing, and I even considered swapping to black or white, but I powered through in the end.

For the finishing touches, I hot glued the cable very lightly at the hole to keep it in place, and sewed the microcontroller to the underside of the rim using the unused pads.

I wanted to do this project in such a way where I could reuse the parts for other projects in the future, and ideally get the hat back to normal too - so I tried to be neat and non-destructive with everything. Time will tell, but I think it should be easy enough to unpick the thread keeping the LED strip and microcontroller in place, and pick off the hot glue used everywhere.

Fin

Here's the finished product! The LEDs get very bright, so I did have to turn down the brightness when I was using it. I got a little bit of use from it, but I think it'll fit right into EMF Camp when I hopefully go next year.

Setting Up Lots of Raspberry Pis

Jake Walker — Wed, 02 Apr 2025 17:00:20 GMT

I help out with a STEM club aiming to teach Sixth Form students skills in Cyber Security and other up and coming tech that doesn't normally get taught in school. I actually used to be in the same club when I was younger so it's nice to go full circle and help out there!

As part of the club, we need some computers for the students to work on. We managed to find around ten Raspberry Pi 400 computers which we are going to trail for a few sessions. Unfortunately, they are underpowered when compared to a modern laptop but hopefully they'll work well enough for some simple web browsing, Linux command line and other stuff. In cases we want more power, we might look to use cloud alongside these Raspberry Pis.

Initial Tests

To start, I initially booted up one Pi 400 with it's existing SD card to get a feel for how web browsing would perform, as well as some other simple tasks. I've personally not used the Raspberry Pi OS Desktop for ages, and tend to just go for the Lite versions with no GUI. Unfortunately, web browsing was pretty sluggish with frequent freezes and slow load times.

To speed things up, I tried a 64-bit image which supposedly improves speed (especially for systems with >4GB RAM). Maybe the original image was 32-bit, or a fresh install did the job, but thankfully this improved web browsing to the point it would work for our purposes. I also experimented with a very small overclock to squeeze a little more speed out, going from 1.8 GHz to 2.0 GHz. After that, it now performs fine.

Setting them up

The default Raspberry Pi OS comes with an initial setup wizard, which is great if you're setting up 1, but means that I need to go through this wizard 10 times on each of the Pis. Doable, but I'd rather automate it a little more.

My next thought was to write a Rubber Ducky script for my Flipper Zero to automate going through the setup wizard and any other steps we want (e.g. making a non-sudo student account, installing additional software, etc...). It would be a little error prone as it's not able to get feedback from the OS, but it would have been a good solution.

Eventually, I decided to try and make my own image that we could use in the future for any stuff. I found a couple of tools that did this from HashiCorp Packer, ARM builder, to a purpose built tool called sdm. I tried the Packer builder but the image it made didn't end up booting. I'm sure it's something I had missed but I didn't have the time to troubleshoot, so I tried sdm instead.

sdm works really well and each option is configured using a command line argument. For example, creating a user just needs the argument --plugin user:"adduser=student|password=student|nosudo". You can also do some fancy things like copying files locally (e.g. config files) to specific places in the image.

To save what I had done, I made a very simple script to generate the image:

#!/bin/bash
if [[ $EUID -ne 0 ]]; then
        echo "This script must be run as root" 1>&2
        exit 1
fi

ADMIN_PASSWORD="password"

sdm --customize $1 \
        --plugin user:"deluser=pi" \
        --plugin user:"adduser=student|password=student|nosudo" \
        --plugin user:"adduser=admin|password=${ADMIN_PASSWORD}" \
        --plugin raspiconfig:"boot_behaviour=B4" \
        --plugin disables:piwiz \
        --plugin bootconfig:"arm_freq=2000|over_voltage=6" \
        --plugin wificonfig:"country=GB" \
        --plugin L10n:"keymap=gb|locale=en_GB.UTF-8|timezone=Europe/London" \
        --plugin network:"ssh=service" \
        --plugin copyfile:"from=authorized_keys|to=/home/admin/.ssh/|chown=admin:admin|chmod=600|runphase=postinstall|mkdirif" \
        --plugin copyfile:"from=lightdm.conf|to=/etc/lightdm/|chown=root:root|chmod=644|runphase=postinstall" \
        --plugin copyfile:"from=05-setup.sh|to=/etc/sdm/0piboot/|chown=root:root|chmod=744|runphase=postinstall" \
        --restart --bootscripts

generate.sh

The above command does the following (in order):

Delete's the default pi user (although I don't think it actually exists anymore, so this may be redundant).
Adds an admin and non-sudo student users.
Sets the boot behaviour to auto-login to the desktop (as opposed to going to the console, or just going to the desktop).
Disables the setup wizard (piwiz).
Applies the overclock to /boot/config.txt.
Sets the Wi-Fi region, keyboard, locale and timezone to the UK.
Enable SSH - for any bulk setting up later on (e.g. with Ansible).
Copy my SSH key to the relevant location so I can login over SSH without a password.
Copy the lightdm.conf file which is setup to automatically login the student user.
A custom script to set the hostname to a random value.

This image worked like a charm, helping save me from lots of setup, and it'll be a great base to build off in the future.

What's next?

If all goes well, my plan is to implement PiServer, a network boot server where each Pi is a thin-client. This means all the users and their data are in one central location. I think this will make it much easier to add new software, distribute files, etc... further down the line. At the moment each Pi would have to be configured individually for anything like that.

Making a DJ Macro Pad

Jake Walker — Fri, 28 Mar 2025 19:00:53 GMT

Recently, I've picked up a new hobby - DJing. I find it's a great way to enjoy music, and it's pretty fun to learn too.

I've got a great DJ controller, but I find it's missing a couple of buttons and knobs for extra functions - especially post effects which some other brands of controller do have. To fix that I've been wanting to make a small 'add-on' controller that has remappable buttons and knobs. I guess it's essentially a macro pad.

Design

For this project, I started out not really having much of a plan, but I knew I wanted to have a bunch of knobs (or potentiometers) to have analog control over effects, and a few buttons to turn effects on and off, or do other functions too. I decided that 6 potentiometers and 8 buttons would be plenty.

For the microcontroller, the brains behind the project, I went for a Seeed Studio XIAO RP2040. I liked the form factor of this from one of my previous projects and like the RP2040 in general. Although as you'll see below on the schematic, this microcontroller doesn't have many pins, but more on that later...

Then what is an electronics project without RGB lights? So I added WS2812 LEDs for each of the buttons which can show the status of each. These LEDs take in power and a single data line for controlling the colour. They daisy chain together, so you can have a big long line of LEDs that are individually addressable (i.e. you can change the colour of each individually), still with just one data line from the microcontroller. Pretty neat! I also added in a resistor for the power line, as it was suggested best practice on the datasheet, although it would still work fine without.

Back to the pins problem. I could have chosen a bigger microcontroller, but even with something a little bigger, I might have struggled for pins, with 14 being needed for all the inputs. After a bit of research, I found that using some multiplexers would help me out here. I'm glad I got to try them out because they're pretty cool. For the potentiometers, I used a CD4051B chip which uses 3 pins on the microcontroller to set an address. This address then sets which input is given to the microcontroller. So the 6 potentiometers are hooked up to the chip, and the chip only uses 4 pins on the microcontroller (although I could have had an extra 2).

For the buttons, I used a 74HC165 shift register which takes the button inputs (in parallel) and sends them to the microcontroller over serial. This takes up only 3 extra pins on the microcontroller for the 8 inputs. When I was looking into using the shift register, I found some conflicting advice on how to hook it up, so I added in some jumpers that I could connect or disconnect later on if the way I had wired it up didn't work. (But spoiler alert, it was fine in the end).

For good measure and future-proofing, I also added in a Grove connector, which will let me plug in I2C devices. The idea being if I needed even more inputs, I could add another board that plugs in.

Here's my final schematic for all of that. It's a bit messy!

I would normally test on a breadboard at this stage to make sure I have all the connections right, and it would have meant avoiding adding the jumpers. However, I didn't have a lot of the parts on hand, so I took a risk and designed the PCB.

Some casual Friday night PCB designing 😎. This is the most complicated I've made for while so this routing is pretty tricky
— Jake Walker (@jakew.me) 2025-02-21T20:22:41.250Z

It took me a good few hours to get everything routed, and it was certainly one of the more complex boards I've designed for a while. But I didn't help myself by wanting to put the resistors all in a row in the middle and the two chips either side.

After having tried it out, I would have spaced or positioned the potentiometers differently to give a bit more room as they're a little cramped. Although I've got some ideas for 3D printed parts that may help.

If you want to make your own, below is a list of the parts I used as well as a download of the KiCad project, but if you check out my previous post on designing PCBs, you could make your own which is definitely the more fun route!

KiCad Project Files

dj-boost.zip

163 KB

Parts List

Parts

8x WS2812 5050 SMD LEDs
1x 470Ω resistor
1x 100µF capacitor
1x CD4051BE Analog Multiplexer/Demultiplexer
1x 74HC165 Shift Register
6x potentiometers (RK0938N)
8x Cherry MX-style switches
8x 10k resistors
Seeed Studio XIAO RP2040 Microcontroller

Getting the PCB

PCBWay kindly offered their support for this project by providing their PCB prototyping services. As I talked about in my previous post, the ordering process with PCBWay is really quick and easy, and is as simple as using their plugin in KiCad, or uploading the exported files.

Shortly after ordering, one of their engineers sent me a message, asking for clarification on some of the drill holes for the potentiometers. I think the footprint I used for them may have been a bit ambiguous, but I was able to clarify that the large holes were not electrical connections to the engineer. It was great to have an engineer check out the design and it could have potentially saved me from an irritating problem.

After ordering, I think the manufacturing process took a few days and on the PCBWay website, I was able to check what stage of manufacturing that the board was in. I always end up choosing the most economical shipping when getting PCBs as I'm never in a rush. So after it was complete the finished boards arrived in just under two weeks.

The boards arrived in a nicely packaged box and were protected in some bubble wrap packaging. The boards are great quality, the solder mask and finish of the board is really nice feeling and they were a joy to solder on.

Soldering Up

While I was waiting for the boards to arrive, I ordered up all the parts I needed. I found it particularly difficult finding the multiplexer and shift register chips somewhere where I didn't have to buy in bulk and wasn't crazy expensive for small orders. And I did even have to switch out a few of the components before ordering the PCB for these reasons.

After the parts arrived, I got to soldering on my not very safe cardboard work surface.

I found it difficult to find a grove connector that was a reasonable price, plus I didn't really have a use for one yet, so I left that part off. Along with the smoothing capacitor, which I thought I would add later if I had any issues.

Testing

The potentiometers were a tight fit, so they made a decent enough electrical connection without having to solder them. For the switches I could short the two contacts on the board with tweezers to give them a test.

I wrote some very basic code to check everything was working okay before I soldered everything in. Luckily there was no issues. I used CircuitPython for the testing, as it's super easy to throw together some code, plus they have some great built-in libraries for this use case, specifically a keypad matrix library that worked with the shift register to read the button inputs easily.

import analogio
import board
import digitalio
import keypad
import neopixel

# setup pins for the potentiometer multiplexer
pots_a = digitalio.DigitalInOut(board.A3)
pots_a.direction = digitalio.Direction.OUTPUT
pots_b = digitalio.DigitalInOut(board.A2)
pots_b.direction = digitalio.Direction.OUTPUT
pots_c = digitalio.DigitalInOut(board.A1)
pots_c.direction = digitalio.Direction.OUTPUT
# this is an array of our three input pins for the multiplexer
pots_s = [pots_a, pots_b, pots_c]
# this is the pin for reading the multiplexer value
pots_z = analogio.AnalogIn(board.A0)

# fancy built-in library for reading the shift register button presses
k = keypad.ShiftRegisterKeys(
    clock=board.D9,
    data=board.D7,
    latch=board.D10,
    key_count=8,
    value_when_pressed=True,
)

# another fancy built-in library for controlling the LEDs
pixels = neopixel.NeoPixel(board.D6, 8)


# this function helps select a specific potentiometer by converting the `p` argument to binary that is sent to the pins
def select_pot_pin(p: int, pins: list[digitalio.DigitalInOut]):
    for i in range(len(pins)):
        pins[i].value = (p >> i) & 1


# example code for setting colours on the LEDs
for i in range(8):
    pixels[i] = (10, 10, 10)
pixels.show()


while True:
    # example code for reading the potentiometer values
    for i in range(8):
        select_pot_pin(i, pots_s)
        print(f"{pots_z.value:06}  ", end="")
    print()

    # example code for reading button events
    event = k.events.get()
    if event:
        print(event)
    
    sleep(0.25)

Software

Once I was happy everything was working, I wrote a bit of code to get it to work in my DJ software. Unfortunately, my software doesn't have any custom MIDI support, which is absolutely what I would try to use. That would be as simple as sending MIDI codes from the microcontroller using CircuitPython's usb_midi package.

I'm hoping to have a try with the MIDI approach in the future. However, for now, I had to go for a bit of a hacky approach using a Python program running on my computer. This uses pyautogui to adjust UI elements in the software using mouse and keyboard shortcuts. I did a quick proof-of-concept where I found the coordinates of the effect knob on screen, then the script will click and adjust the control up and down.

I used pyautogui.position() to get the current position of the mouse, then hovered over the knob I wanted to control, then noted the position.
Then it's as easy as using pyautogui.moveTo(x, y) to move the mouse cursor to that position on screen, then pyautogui.dragTo(x, y, button='left') to click and drag the control.
For the buttons, I could send keyboard shortcuts using pyautogui and map them to the buttons I wanted to in my DJ software.
The microcontroller had some basic code to send the input states (potentiometer readings and button presses) over USB serial to my computer where the local program listened then changed controls and performed keypresses as appropriate.

I'm hoping to work on this a little more over the coming weeks to get it to be more reliable, but as it is now, it works okay but is a little janky and can break easily, so I won't share where I've got to with the code, but will hopefully revisit this in another post.

I like the idea of trying out embedded Rust for the next iteration of the code. I really enjoy working with Rust and all the features I need are pretty well supported at this point.

Giving it a go

With the slightly janky code written up, it was time to give it a proper test. You can see a short demo video below. Unfortunately no music here, I don't want to get into any trouble!

The video isn't in perfect sync, but as you can see, the buttons are pretty responsive - immediately turning on and off the effects. However, the potentiometers need to actually move the mouse, which takes a little time. I also had to slow down the mouse movements because the software wasn't picking it up when it was any faster. Most of these effects I think I'd want to have pretty fast control over, so the potentiometers are definitely not as responsive as I would like, especially when turned from one extreme to the other. Luckily this is all just a software problem which can be iterated upon to make gradual improvements.

Wrapping Up

Although this has been my journey making a 'DJ'-type macropad, this could absolutely work for anything else, maybe a video editor with too many keyboard shortcuts or needing fine control over scrubbing over a timeline? Maybe add an ESP32 instead of an RP2040 and have it as an internet-connected home automation shortcut hub. You could even use the open-source project, deej, which lets you make a physical volume mixer, useful if you're into gaming. The possibilities are pretty endless and being able to create your own thing that fits your needs exactly is pretty awesome.

Let me know if you make anything cool based on this, I'd love to see it! And make sure to keep an eye out as there may be follow up posts to this project in the future.

How to create PCBs

Jake Walker — Sat, 08 Feb 2025 13:00:59 GMT

Over the past couple of years, I've had a couple of projects where I've designed and ordered PCBs. It's a great way to make more permanent electronics projects look and feel a lot less janky.

I've also come across a couple of open-source electronics projects where I had ordered PCBs from a project. For example, these drone timers (which I unfortunately am still yet to finish), and this drone controller screen adapter. It's super easy to download the design files from the project and upload them to a site and get them ordered - it's often a lot cheaper than finding them sold anywhere online (if they are at all).

I've also adventured into designing my own like a tiny DIY keyboard based on the ARTSEY.io layout.

For this post, I'll go over the basic principles I've learned for creating a PCB from scratch - from design, all the way to ordering. I like to use KiCad which is free and open-source, but there's lots of other great PCB design programs, both free and paid, even ones that work in your web browser. As far as I know, they all work pretty similarly, so these basics should transfer across.

The project I'll make here, is going to be a with a microcontroller, button and LED.

Building a schematic

First up, we need to build the circuit's schematic, this is a high-level overview of components and how they connect.

I'd actually usually start with a breadboard design before doing this, just to check it works in the real-world first, but you could also do this part after designing the schematic. It all depends how you like to work.

To get started, launch KiCad and create a new project. I've called mine simple here. You'll see it's automatically created files for the schematic (simple.kicad_sch), as well as the PCB (simple.kicad_pcb).

A new project created in KiCad

This post is just going to touch on the Schematic Editor and PCB Editor, but I'll give a super quick explanation for a couple of the other options:

Symbol Editor - this is for editing symbols or components for use in the Schematic Editor. There's lots of built-in parts, but if a part you want isn't in there, you can use this to import it from someone else who has designed the part online, or create your own part from scratch.
Footprint Editor - the same as above but for the PCB Editor instead. These footprints will likely be linked to symbols in the Symbol Editor.
Gerber Viewer - Gerbers are the exported design files that we'll eventually send off when ordering. You can view them using this tool.
Plugin and Content Manager - this lets you add extra components and plugins. For example, when I was designing my keyboard, I was able to find a component library for keyboard switches in here.

If you open up the Schematic Editor, you'll see a blank page with a lot of buttons around the outside.

First off we need to add components to the schematic. Use the 'Add Symbols' button on the right toolbar, which will bring up this window to select a symbol. A symbol is just a component in the schematic. For simplicity, I'll use a built-in one here, an Arduino Nano. The top right of the window shows the symbol as it will appear in the schematic, and the bottom right shows the footprint, which is as it will appear on the PCB. The dropdown in between the two previews lets you select a flavour of the footprint. For this Arduino Nano, there's just with mounting holes or without, but for more complicated components, you might need to select the size of component you're planning to use (e.g. size of a surface mount resistor or type of switch) - essentially make sure the footprint matches the real component you want to use.

After you press OK, click anywhere on the schematic to place the symbol. Now I'll add in a battery, button, LED and a resistor for the LED. The battery and button didn't have footprints for me, so I've left them blank and we'll sort them later. Here's where we're at:

I've moved all the components around so they are laid out better, then finally we'll add in a ground connection using the symbol underneath the one we just added. You could also add in a +5v connection if you wanted. I'm not sure if this is strictly necessary, but it makes the diagram slightly clearer and it may help out later on when we're putting a ground plane on our PCB (but more on that later...)

Now use the next icon down on the right to create some wires to connect all the components. Just click on one of the circles at the connection points on a component, then click one of the circles on another component.

Here's my final schematic:

That's pretty much all we need to do for the schematic, now just save it. You can also add labels to your diagram, using the label and global net label tools near the bottom on the right which can give your connections nicer names. There's not much going on here, but for more complex schematics it can help a lot with laying out things. It lets you have connections between multiple places on the schematic without drawing wires everywhere, just connect a global net label at each end.

Designing the PCB

So now we've got the schematic designed, we can move onto the PCB. Head back to the KiCad project window and open the PCB editor. This window also has a lot of buttons and things.

We can use this button at the top to import the components from the schematic. It'll give you a quick summary of what it's going to change (as you can also go back to the schematic and add more things later, then do this again to update the changes that have been made). Once done, you'll see the footprints added to the PCB.

For the few components that aren't shown, we can go back to the schematic editor and change the footprint to be used by double clicking on the symbol, then change the footprint by clicking the lines in the value box to bring up the footprint selector.

For anything missing, you might need to find something close, or find footprints others have designed online, or create your own. For the battery, I'll select a 2-pin header which will allow the circuit to be powered from an external 5v supply. Strangely, there is push button footprints available, they just weren't linked to the symbol earlier for some reason.

After making these symbol changes, redo the previous step again to import the new footprints. You'll notice some thin blue lines going between the components. This is how they should be connected together according to the schematic.

Now I would lay out the components to near the pins they are going to connect to. Once you're happy with the layout, click on the Edge.Cuts layer on the right side. As the name suggests, this is cuts that the manufacturer will make, so we want to put one around the edge of the board. If you're feeling extra fancy, you could add in rounded corners, mounting holes or other things. You might notice some of the components, for example, the LED already have holes where the legs go through the board.

Some of the layers have F & B prefixes, which means front and back. We'll use the F.Cu (front copper) and B.Cu (back copper) for traces between components and you can add printed text or images to the board using F.Silkscreen and B.Silkscreen (although remember to reverse text if using the back). Click on one of the copper layers then use the first blue line on the right toolbar to create a trace. You'll notice it'll helpfully highlight where it needs to go. Make sure to leave the ground connections for now, because we're going to make a ground plane to connect them all. Here I've used the back copper layer to run a trace along the back of the board because I've got two tracks that overlap. With more complex PCBs it can be a bit tricky to route everything around, but it's all part of the fun!

Now we'll use the copper zone tool which is the blue shape on the right that has a wire going into it. This creates a zone of copper on the board. We should add a ground zone on the board when we're done. This can help with any external interference on the circuit. Select either one of the copper layers in the window that appears, then select the GND net and draw a box around the board again. Finally, go to "Edit" then "Fill All Zones". You'll see the board now has copper everywhere, except where we've got the blue trace going through. And it connects up the ground pins on the components that need it.

Now I like to go to the 3D viewer (icon left of our schematic import tool) and give the board a check to make sure it looks okay and all the traces are connected up where they need to go.

There's also an automated checking tool named DRC which can help spot any issues with your board which I'd recommend using before ordering. But, I'm happy with this board, so lets go and order it!

Ordering the design

Once your happy with your PCB design, it's time to get it ordered. You can find a bunch of manufacturers online and can easily find one to get boards created and shipped for under £10, albeit they take a little while.

Regardless of where you choose to order, we need to export the PCB to gerber files. This is what the manufacturer uses to make your PCB. In the PCB editor, go to "File", then "Fabrication Outputs", then "Gerbers (.gbr)". The settings in here depend on your manufacturer so make sure to check their website for suggested settings. Once dialed in, click "Plot" to export, then "Generate Drill Files..." and do the same there. You should have a bunch of files generated now. If you choose to use PCBWay like me, they actually have a KiCad extension which allows you to upload your design to their site with one click, so there's no need to faff around with these Gerber settings.

You'll want to ZIP up the Gerber files now. I like to then take it to a couple of online Gerber viewers to double check the design again. For example, this one from PCBWay. It's a good idea to check on multiple viewers to make sure there's not an issue that arises with just one of them.

Once I'm happy that the design looks fine, I'll upload the design to the manufacturer. PCBWay have kindly given me some credit towards my next project, so I'm going over the process of ordering with them. There's also many other choices for manufacturers, both local and abroad, basically it depends on how fast you want your design and the quality you'd like.

On PCBWay, when going to order the board, you can use the 'Quick-order PCB' button to upload your files straight away, which will automatically calculate the size and show a preview at the top of the page. Underneath we've got a bunch of options to select. There should be similar options for other manufacturers too.

So first thing we'll do is upload our zipped up Gerber files. You should see a preview of the board after uploading, and it's another good chance to double check your design looks as it should. The site should automatically calculate the size of the board.

For the board type, there's a few choices. Unless you're doing lots of PCB assembly, you don't need a panel. You can see an example of a panel on the right of this screenshot, it's where boards come stuck together on a big board and you would separate them off after assembly.

For quantities, many manufacturers have a minimum order quantity of 5 boards. It might seem like a waste but it's always good to have a spare or two in case you mess up.

For layers, we're using 2, this is because we've got the front & back copper. You'll find anything higher will cost more money, but for most projects you should be able to get away with 2 layers. For more complex projects, you might want layers of copper sandwiched in the middle to give more space for routing.

For material, FR-4 is standard, with the others being used for special applications.
For the FR4-TG, this is the kind of quality for the board, particularly the temperature threshold of the board. The pre-selected one should be okay for most use cases.
For thickness, you might need to choose something else depending on your project. For example, if you're making a board that fits into a USB port it'll need to be 2mm. Otherwise, the normal 1.6mm thickness is great.
For minimum track/spacing and hole size, you'll need to double check your design. You can set constraints in KiCad for this by going to File > Board Setup > Design Rules > Constraints, after setting you can run a DRC check to check the spacing of everything.
For solder mask, you can choose whatever you like, this is the main colour of the board. Here I've gone for black, but strange colours can adjust the price of the board.
For silkscreen, again, you can choose whatever, but it may affect the price.
UV printing allows multi-colour prints on a board. I'm not going to cover that here, but it's a feature PCBWay has that I've not noticed at any other manufacturer.
For edge connector, this is if you have connection points on the edge of the board. Think like how a graphics card has the gold plated connector on the bottom edge of the board. Again, you'll only need to select this for specific applications.

For surface finish, there's a bunch of options. For the most part, HASL lead, and HASL lead free are the two standard ones. I like to choose lead free just so I feel a little better about all the solder fumes when assembling my board later on! ENIG offers a stronger finish while costing a little extra, and may of the others you probably won't need for normal use cases.
For via process, tenting vias is the standard, but as you can see this option for PCBWay is dictated by the Gerber files, so no need to make any changes to this. KiCad uses tented vias by default.
For finished copper, this is how much copper that is used on the outer sides of the board. A higher number is stronger, but for most cases, 1oz is fine.
At PCBWay, and other manufacturers, you can chose to remove or specify a location for the product number. This is just a code that identifies your order. Removing it completely costs a little extra, but you can move it to anywhere you like for free. I like to put it in one of the back corners of the board. Make sure you check with your manufacturer about how to specify the location. For example, for PCBWay I need to add the text 'WayWayWay' to my board.

Now you can head to the checkout to place your order. I'd recommend to double check the shipping method when you checkout. PCBWay, for example, offers a bunch of shipping methods that cater to different price points. I've chosen the Global Direct shipping which is the most cost effective.

After ordering, your design will most likely be checked by an engineer who will get in touch to clarify if there's any potential issues. Then it's just a matter of waiting!

Wrapping Up

Hopefully this quick crash course in PCB design has been useful and inspiring. I had always thought it was quite intimidating until I went to a talk on how someone designed conference PCB badges with some other PCB design software, and it's super cool to build something on your computer and eventually have a physical PCB! Keep an eye out for my next blog post where I'll be assembling my next project. Until next time...

Repairing Electronics with Dead Batteries on the Cheap

Jake Walker — Thu, 06 Jun 2024 17:32:17 GMT

I was recently testing out some software called Grocy which lets you keep track of food in your kitchen. I've previously had difficulty adding getting started for various reasons, and on Reddit, someone mentioned a barcode scanner made using Grocy easier and more satisfying.

I kept an eye out on eBay for a cheap wireless barcode scanner and eventually got lucky. Unfortunately, when it arrived and I tested it, it didn't work at all unless it was plugged in. I tried troubleshooting quickly by measuring the battery voltage and found it was at 0 volts. For reference the lowest a Lithium Polymer (LiPo) battery can go is 3.2 volts before potentially becoming damaged, so 0 volts is as bad as it gets and would need replacing. I contacted the seller and we worked out a partial refund, then I got to work replacing the battery.

This post is designed to talk about the process of replacing a battery in something quite generally so it should be applicable to anything with a dead rechargeable battery in.

⚠️

There's risks involved with working with batteries, make sure you do your homework and know what you're doing! For example, it's pretty dangerous to overcharge or short circuit a battery.

The first step was disassembling the barcode scanner to get to the battery itself.

I had to take the scanner apart completely to get to the battery. The board here on the right has all the electronics on, and the board on the left has the battery, a button and a connector for the charging dock.

Next, I removed the battery. The one here is an 18650 battery, which are super common in battery banks and other consumer electronics.

The blue plastic is just a cover, so removing it gets me access to the battery terminals as well as a battery protection circuit.

The battery protection circuit here is a really good salvage. I can simply attach this to a battery which doesn't have one to make it much safer. These little circuits make sure the battery doesn't get too much current, and doesn't get charged or discharged too much.

I removed the battery protection circuit and found a spare LiPo battery. It's worth pointing out the battery I'm using here is quite a lot smaller than the original at around a quarter of the capacity. That's okay for me as I'm not using this for short periods of time. If you're doing the same, you should check that the device your putting it into has an appropriate charging current. I managed to find this in the manual for the scanner, but you may need to crack out a multimeter.

As I mentioned earlier, 18650 batteries are super common, and in the past I've bought really cheap power banks (e.g. from Poundland) to harvest some. This probably gives the best results, but if I can re-use this smaller one it helps the environment at least 🌿.

Next, I soldered the battery onto the protection circuit.

Finally, I put the battery back into the scanner and reassembled the scanner. With some very janky electrical tape work to hide the exposed battery connections and to keep everything in place.

Finally, I reassembled everything and gave it a quick test. Now it works perfectly, and I saved a couple of quid by using stuff I already had.

This is a great example of repairing some broken electronics to keep it ticking still, and hopefully this serves as good inspiration for you!

Repurpose Your Old Laptop Into a Home Server

Jake Walker — Sat, 11 Nov 2023 17:26:03 GMT

I've got a really nice old laptop that I can't bare to sell, mainly because of the sticker collection on the back. There's no point it collecting dust though, so I've been using it as a home server.

Unfortunately the other day I managed to accidentally corrupt the drive on my home server. Luckily though, all the important stuff was on a second drive and it's a good opportunity to start again.

In this post I'm hoping to give you a bit of inspiration and go through the initial setup of mine, including a Plex media server with external drive and how to remotely access it from anywhere in the world.

These same steps can be used on anything else you have laying around. In fact, I used to have a Raspberry Pi server until I was having trouble transcoding videos with Plex (which is why I switched to my slightly more beefy old laptop).

Operating System

One of the important choices is choosing an operating system. This is mostly dictated by how much effort you want to put in and how much knowledge you have with Linux. Here are some popular options:

TrueNAS - although I've not tried it, this seems to be a great option with what looks like all the setup done through a web browser (after first installation). You can go with CORE or SCALE, the latter offering Docker container support (which I'm going to talk about a lot in this post).
Flatcar - again, I've never used this but it looks like a great option for running only container workloads.
Ubuntu/Fedora Server - the standard option is using one of these. They both have great support and Fedora Server has a lovely web dashboard.
Proxmox - if you want to run VM workloads this is an awesome option, you can separate any projects you may have into separate VMs.

In my case, I'm going with Ubuntu Server. One of my limitations is having to use a Wi-Fi connection and Ubuntu/Fedora server has the best support for that (but do use Ethernet if you can, I have run into so many problems). TrueNAS was my second option, but it has to be installed on an entire drive and none of the storage on the install drive can be used for media & files (unless you want to deal with moving around partitions and things which makes it quite a bit of effort to get initially setup).

Install whichever OS as normal, there are plenty of great guides elsewhere on installing if you get stuck.

Once you've got it installed, I'd recommend setting up SSH (which I was able to do during setup on Ubuntu Server) so you can get access for the rest of the setup from another computer. You should also give it an ol' update.

You can ignore this part if using a desktop, but for a laptop it's important to disable the lid switch to prevent the system from sleeping or powering off when shut. To do that, edit /etc/systemd/logind.conf and edit the three lines shown below:

Setting up Docker

Docker makes it super easy to deploy and update any applications you might want to run. Getting started is easy and the following command sets up everything you need on any operating system:

curl -fsSL https://get.docker.com | sh

Once that's complete, you will want to give your current user permission to use Docker with the following command, then log out and back in for it to take effect. Also, we would like Docker compose for later.

sudo usermod -aG docker ${USER}
sudo apt install docker-compose -y

That's it, Docker is now installed and ready to go.

Installing Plex on Docker

One of my main reasons for running a home server is for Plex. This allows you to dump all your music, movies, photos and TV shows onto a hard drive and be able to watch them easily on your TV, phone, laptop and whatever else.

A very cool additional feature of Plex is that you can set up a TV tuner and record TV shows to watch later.

Mounting an External Drive

Although not necessary, I have all my media on an external drive, this is just so I have more storage on the main drive for Docker images and other stuff.

First up, run lsblk -f to find the drive that looks correct and note down it's UUID. In my case, the drive I'm using is 1TB, so sdb1 is the one that I want.

Should you want to reformat the drive, run sudo mkfs -t ext4 /dev/sdXX (editing to the correct device). Then check with the lsblk -f command to make sure the UUID hasn't changed.

Next up, create a folder to mount the drive into (this can be anywhere you like): sudo mkdir -p /media/data. Then run sudo nano /etc/fstab to edit the config for the permanent drive mounts. Create a new line at the bottom with the following content (remembering to replace your drive's UUID):

UUID=XXXX /media/data ext4 defaults 0 1

For any additional drives, create separate folders for mounting and add more lines to this file. Here is mine below as an example.

Save and exit by pressing Control-X then Y. Finally, run sudo mount -a for the changes to take affect, mounting the drive you added. You can run lsblk to check the mount point of the drive is expected.

Installing Plex

To install Plex, I'll use a Docker compose file. A compose file is a bit like a recipe for creating one or more Docker containers, as well as networks and volumes. This makes it super easy to configure and upgrade in the future rather than remembering long commands.

To get started, make a new folder anywhere called plex or something similar with mkdir plex. This folder will contain the Docker compose file and any folders that we want on this drive. Then open the folder with cd plex and run nano docker-compose.yml to create the compose file.

Then copy the following content into the file:

version: "3.4"
services:
  plex:
    container_name: plex
    image: lscr.io/linuxserver/plex:latest
    restart: unless-stopped
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - VERSION=docker
    volumes:
      - /media/data/tv:/tv
      - /media/data/movies:/movies
      - /media/data/music:/music
    devices:
      - /dev/dri:/dev/dri

Note: remove the devices section if you receive errors later on - this is for using Intel hardware acceleration. If you have an NVIDIA GPU see here to get it working with Plex. Also with devices and volumes, the left side is the host and right side is the container.

Then, run docker-compose up -d to start Plex. It will take a few moments to download the image and it will launch Plex.

Other useful commands

Logs: docker-compose logs --follow --tail 10 - get the last 10 lines of container logs and any future lines. Press Control-C to exit.
Stop: docker-compose down - stop the container.
Update: docker-compose pull && docker-compose up -d - pull the latest container image and recreate the container with the new image.

Once running, give it a few moments to warm up, then go to the IP address of your server with port 32400. Make sure to add /web to the path if you get an XML response. You will be taken to a page where you can sign in, then you will get a setup wizard like this:

Remote Access

For remote access, I like to use Tailscale. It creates a peer-to-peer, private WireGuard VPN and has great apps for any computer or mobile device for connecting remotely. It's free for up to 20 devices and it's much better than opening ports on your router. To get started, sign up on their website then run the following comamnd to install Tailscale.

curl -fsSL https://tailscale.com/install.sh | sh

Once complete, run sudo tailscale up and log in with your account. Once logged in, you can go back to your terminal and run ip a to see a new tailscale0 device has been added with an IP address starting with 100. Your new device will also show up in the Tailscale dashboard:

You'll notice my server has 'expiry disabled' this means that I won't have to reauthenticate on the server every now and again. To do this, click on the dropdown at the end of the server and select 'disable key expiry'.

Fin

That's it, a simple home server setup with Plex installed as an example. If you want any other apps, there's a list of suggestions below, the process for setting them up with Docker will be similar to the above with Plex.

Having a home server makes a great way to share files between your own devices or family, it also gives you more control over your data, especially when you opt to self-host an application yourself rather than going to an online app run by a company.

Other services to setup

Home Assistant - Smart Home
NextCloud - File Storage (similar to OneDrive, Google Drive or iCloud)
WireGuard VPN
See awesome-selfhosted for more apps sorted into categories

An Introduction to Serverless Functions with Cloudflare Workers

Jake Walker — Tue, 11 Jan 2022 20:00:00 GMT

One of my new favorite services is Cloudflare Workers. It's a platform for running serverless code with quite nice developer experience. In this post, I'd share what I like so much and how you can get started.

Firstly, what is serverless? Serverless is a way of deploying code to the cloud where you do not manage the infrastructure, it is all managed by your chosen provider. With serverless, you only pay for the time that your code is executed which makes it great for applications that get low traffic or only get used certain times. Instances of your code are created and destroyed on demand which your code can 'infinitely scale'.

Sounds great right? Let's have a deeper look. If you're not too interested in the details, skip down to the code.

Serverless Benefits vs. Other Methods

To put that into context, let's talk about some of the ways you might deploy some code that you have written.

One of the obvious options is to rent a virtual machine or dedicated server from a hosting company. This gives you a lot of control, you get to install any operating system that you want and fine tune the power you need (like wanting more CPU over RAM). The provider of the machine is maintaining the actual hardware, networking, cooling and other things. The downside for virtual machines, are that you need to constantly maintain this machine, updating the OS, deploying new code, etc...

Another option might be to use something like Heroku or AWS Elastic Beanstalk where you just upload your code to the platform, and it gets provisioned onto machines by the provider. This gives you less control over the hardware that your code is running on, usually just the environment (i.e. the version of runtime your code runs and dependencies, not the operating system). The provider is responsible for the physical hardware as well as the operating system. Most providers offer Continuous Deployment which will automatically deploy any new versions of code.

The last option might be serverless, using something like Cloudflare Workers or AWS Lambda. Similarly to the last option, you only upload your code to the platform and the provider sorts out the servers and running of the code. You usually get even less control over serverless, where the provider might only allow certain runtimes or no choice at all. You are usually limited on the size of your code too, 50MB on AWS Lambda, and 1MB on Cloudflare Workers. However, the big benefit of serverless is that you only pay for the time your code is running, this makes it great for applications that have light traffic or traffic at only certain times in the day. With some providers, you get 'infinite' scaling, so more and more instances of your code will be created as necessary to saturate the incoming requests. There are other pros and cons depending on the provider, but those are some of the major ones.

Why Cloudflare Workers?

Cloudflare released Workers back in September 2017 (with public access in March 2018), which is relatively new compared to AWS who have been offering their serverless Lambda functions since November 2014.

Runs Globally

Cloudflare run Workers at their existing edge locations, which are data centers which are placed close to end users so they can offer fast, snappy responses. By comparison, if you used AWS Lambda, your function would be limited to a single region, if someone from the other side of the world made a request, they'd get a slow response. Cloudflare would give great performance anywhere in the world.

I should point out, AWS offers a product called Lambda@Edge, which runs at edge locations, but I can't find much information on them. If you're interested Cloudflare has some good articles comparing like this one.

Fast Startups

Cloudflare Workers have extremely fast startup times, usually milliseconds after a request, where other providers have seconds or minutes. This is very important for user experience, especially since 10 seconds is the limit for people keeping attention on the ongoing interaction.

"After 1 second, users get impatient and notice that they're waiting for a slow computer to respond. The longer the wait, the more this impatience grows; after about 10 seconds, the average attention span is maxed out. At that point, the user's mind starts wandering and doesn't retain enough information in short-term memory to easily resume the interaction once the computer finally loads the next screen."

- Jakob Nielsen (source)

Other providers, like AWS Lambda, tend to use lightweight containers for running code, these provide a secure environment for running untrusted code. Once a request comes in, a container is started and takes a few seconds to boot up (this is called a slow start). Any subsequent requests will use the existing container running the code so a response is sent back quickly. Once there are no requests for a while, the container is destroyed. In summary, any new requests often need to wait for a container to start, but any subsequent requests are much faster.

Cloudflare achieves super fast startup times because they run code in 'Isolates', which are a way of running lots of JavaScript functions independently while using a single runtime. They always have the runtime ready which means there are almost zero startup times. A downside of this approach is that you can only run JavaScript code on Cloudflare Workers, however you can compile other code into WebAssembly so that it can run in a Worker (WebAssembly unfortunately has lower performance than running native code).

Affordable Pricing & Generous Free Tier

Cloudflare gives 100,000 requests for free each day, with any extra requests being charged at $0.15 per million requests (with a minimum of $5/month). AWS, for comparison, gives you 1 million requests each month, but charges $0.20 per million for anything over ($0.60 per million for Lambda@Edge).

Prices as of 4th Jan 2022 in the UK West (Ireland) region for AWS. I am ignoring execution time pricing here as there's more considerations than just price for it. Cloudflare bundles them into their price up to a certain amount and have only one option for memory (128MB). AWS charges execution time for each request.

Summary

Cloudflare Workers has great performance around the world, have affordable pricing and a great free tier. This all makes Workers a great offering in the serverless space, but there's still advantages for going elsewhere.

Writing your first function

To get started, you will need Node.js installed on your machine and a new folder for your project.

I'm going to be using Yarn which is package manager for Node.js which I like to use.

Installing Wrangler CLI

First, you will need to install the Wrangler CLI. This is a tool which Cloudflare has made for deploying code to Cloudflare Workers as well as working with some other Cloudflare services. After installing the CLI, you will need to login to your Cloudflare account.

yarn global add @cloudflare/wrangler
wrangler login

If you get an error saying Wrangler is not found, you may need to add the Yarn bin directory to your path. Get the path of the Yarn bin with yarn global bin. For more information see here.

Creating a new project

Next up, you will need to make a new Yarn project.

yarn init --yes

Now create a file called wrangler.toml, this is the configuration file that tells Wrangler what to do with this project.

name = "hello-world"
type = "webpack"

account_id = ""
workers_dev = true

compatibility_date = "2022-01-11"

type can be javascript or webpack. Webpack means you can use Node.js packages in your project. The compatibility_date is the set of features that are enabled for your project.

Then, create a file called main.js with this code. This simply listens for new requests and responds with 'Hello World!'.

addEventListener('fetch', (event) => {
  event.respondWith(new Response("Hello World!"));
});

At this stage, you can run wrangler dev and open http://127.0.0.1:8787 to see your message.

Great, you've just written your first Cloudflare Worker!

Using npm packages

As with most Node.js projects, you will probably want to make use of some npm packages. As an example, I'll show using a package which will return an inspirational quote.

First, install the package.

yarn add inspirational-quotes

Then, use it in your code like normal. In this case, we import the package at the top of the file and return the output of one of the functions.

const quotes = require('inspirational-quotes');

addEventListener('fetch', (event) => {
  const quote = quotes.getRandomQuote();
  event.respondWith(new Response(quote));
});

Running the development server again, the response is now an inspirational quote!

Publishing

Finally, we can publish this project. Cloudflare gives you a free workers.dev domain which you can publish your Workers to, however you can also publish to another domain that you manage on Cloudflare.

Simply, choose a subdomain and then publish. You only need to run the subdomain command once.

wrangler subdomain <name>
wrangler publish

You will then be given the URL of your published Worker! Notice the start of the domain is the name value in your wrangler.toml which in this case is hello-world.

That's it, you have just written and published your first Cloudflare Worker and perhaps your first serverless code!

I hope this post was useful and inspired you to check out Cloudflare Workers. I'm going to continue this adventure with my next post on Cloudflare Workers KV, a way of storing persistent data in a Cloudflare Worker.

Starship

Jake Walker — Tue, 28 Dec 2021 16:23:00 GMT

Starship is a cool little open-source project, which gives you a nice customizable prompt for your shell.

What is a prompt?

A prompt is the text at the start of your shell/terminal that tells you that you need to type a command. Usually it's something boring like this (the pi@raspberrypi:~ $):

Installing Starship

Linux

Simply run this one-liner, to install Starship.

sh -c "$(curl -fsSL https://starship.rs/install.sh)"

You then need to add the init script to your shell config. This is usually bash, but on some distros could be zsh or something else.

# For bash
echo 'eval "$(starship init bash)"' >> ~/.bashrc
source ~/.bashrc

# For zsh
echo 'eval "$(starship init zsh)"' >> ~/.zshrc
source ~/.bashrc

Windows (PowerShell)

On Windows, the easiest way to install Starship is using Chocolatey, a package manager for Windows. Although, if you prefer to not install that, there are other ways listed here.

# Install Chocolatey
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# Install Starship
choco install starship -y

# Get the location of your PowerShell profile
echo $PROFILE
# e.g. /Users/jakew/.config/powershell/Microsoft.PowerShell_profile.ps1

# Create the directory
New-Item -ItemType Directory /Users/jakew/.config/powershell/

# Add the init script to the profile
echo "Invoke-Expression (&starship init powershell)" >> $PROFILE

# Reload the profile
& $PROFILE

MacOS

Simply install Starship with brew on MacOS. Then add the init script to your zsh config.

brew install starship
echo 'eval "$(starship init zsh)"' >> ~/.zshrc
source ~/.zshrc

Customize!

Now already after installing, your prompt should look a lot more interesting than before. I'm not a huge fan of all the extra stuff though, like the Python version when in a Python project, I could just run python --version if I needed.

You can edit ~/.config/starship.toml to configure how Starship looks. You can see the options available here, but this is my go to configuration which is very minimal:

add_newline = false
format = """$username\
$hostname\
$directory\
$character
"""

[character]
success_symbol = "[➜](bold green)"
error_symbol = "[➜](bold red)"

[username]
format = "[$user]($style)"

[hostname]
format = ":[$hostname]($style) "

The format variable sets the order of what is displayed. In this case, I have the username, hostname, directory and then character. The character I have set so that it is usually green, but goes red when the last command failed. The username and hostname only show when SSHing in.

Even though I could do this by changing my shell's prompt variable, I like Starship because there is a lot more control over things and does some things better. For example, you can see the path here changes where it is relative to once I enter my Git repository, whereas the default prompt might only show 2 directories higher:

I find if I have no GUI whatsoever (e.g. on a headless Raspberry Pi), it's useful to turn on some of the other bits, like Git, memory usage, time or perhaps sudo.

Thanks for reading, hopefully this very short blog post helped you make your shell feel more at home.

Using Zigbee devices with Home Assistant

Jake Walker — Sun, 15 Aug 2021 14:30:00 GMT

A few years ago, I had cheap 'smart' light bulbs in my room which were controlled with a remote control. To make them smarter, I decided to make an internet-connected Arduino relay the commands for turning the lights on and off, and changing the colour. I think I then hooked them up to Home Assistant so that I could control them through my Alexa or phone.

Eventually I moved away from those light bulbs, as they were so cheap that I ended up not being able to see some things when it was dark. For various reasons, I went for IKEA's Trådfri ecosystem, rather than the more expensive (at the time), Phillips Hue. These days there's lots more good quality choices, but I'm still very happy with my IKEA lights.

After a recent trip to IKEA, I bought some new Trådfri gadgets, like a plug and a motion sensor. I thought the motion sensor would be good for turning the lights off if I'm not in the room. But I didn't do any research before buying it, so I wasn't sure how it would work. After getting home and setting it up, it turned out that the motion sensor turned the lights on if there was movement, and off if there was no movement. That's alright for most use cases, but I wanted it in my bedroom, and I don't really want it turning the lights on and off while I was sleeping, so my motion sensor has been sitting doing nothing for a few months.

Z-Wave and Zigbee

Earlier this week, I was inspired by a video by Linus Tech Tips where he was showing his idea for smartening up his home with Home Assistant. He is using Z-Wave light switches around his house so he can control ordinary lights from a phone or voice assistant. The light switches also have motion sensors inside them, so they can detect if nobody is in the room, and turn off the lights.

Z-Wave is a standard for smart home devices, which creates a mesh network, meaning each device will relay messages to devices that are further away from the gateway. Z-Wave check every device to ensure that it has a good standard of security and quality.

There is also a similar standard called Zigbee. Zigbee do not check every device which makes it a more open standard. Zigbee devices are much cheaper than a similar Z-Wave one. IKEA Trådfri devices are actually using Zigbee under-the-hood, so theoretically, you can actually buy any Zigbee gateway and pair a Trådfri gadget to it.

After a quick Google search to make sure that it was possible, I thought that it would be a great idea to use my Trådfri motion sensor directly with a Zigbee gateway, so I could get more control over what it does.

The Dongle

Buying a Zigbee dongle with Home Assistant seemed like the best way to move forward.

After a search on Amazon, I found this cheap dongle which had the word 'Home Assistant' in the title, so surely it should work with Home Assistant right? That's what I thought, so I bought the dongle, and a cheap temperature and humidity sensor to bring my order up to the free shipping limit.

Unfortunately, I missed the sentence in the description of the dongle's product page which said "After flashing the firmware [...] it can work with Zigbee2mqtt". I eventually found out that I would need to flash it after plugging it into my computer and not seeing anything come up (I was expecting a serial port), which means that it would need flashing before it would work.

If you end up buying a dongle, I would recommend buying a pre-flashed one and a slightly more powerful one, as I later found out mine can't handle networks over 50 devices. That shouldn't be a problem, but it's nice to be future-proof.

Flashing the Dongle

As I found out, my dongle needed flashing with firmware that would let it work with Home Assistant. You can follow the instructions from the Zigbee2MQTT project here. Even though I'm not using that project, the instructions are still valid.

After looking at the instructions, I saw that I would need to buy a debugger and special cable to flash the dongle. I didn't fancy buying those for a one-time job, so I tried looking at the more janky alternative flashing methods. I went down the Raspberry Pi route, so I wouldn't have to install anything on my laptop.

Brief Flashing Instructions with a Raspberry Pi

These instructions are shortened from the Zigbee2MQTT website, make sure to check them out if you would like more detail.

Below is the pinout of the dongle from the product page. You do not need to connect pin 2 (Vdd) if you plug the dongle into USB.

The debug pins on the dongle are very tightly packed together, so to be able to fit crocodile clips on them without shorting out, I needed to bend the pins to the side. Only 4 of the 10 pins need to be connected, so they don't need to all be bent. I was quite worried I would snap the pins, so be careful if you take this approach.

Here is my dongle connected to the Raspberry Pi with crocodile clips. The wires are stuck down to stop them from moving around accidentally and shorting.

After connecting up the dongle, and nothing blowing up, I moved onto actually flashing it with the instructions below.

# Install dependencies
sudo apt update
sudo apt install wiringpi git -y

# Download flashing scripts
git clone https://github.com/jmichault/flash_cc2531.git
cd flash_cc2531

# Checking the chip ID
./cc_chipid  # Should return b524, if not your wiring could be wrong

# Download the firmware
wget https://github.com/Koenkk/Z-Stack-firmware/raw/master/coordinator/Z-Stack_Home_1.2/bin/default/CC2531_DEFAULT_20201127.zip
unzip CC2531_DEFAULT_20201127.zip

# Flash the dongle
./cc_erase
./cc_write CC2531ZNP-Prod.hex

After about 3 minutes, the dongle will have flashed successfully. The dongle should now create a serial port when plugged into a computer.

This picture shows the output of dmesg on Linux, which lets you see that the CC2531 dongle has been detected and assigned serial port /dev/ttyACM0.

Setting up Home Assistant

Now the dongle is good to go, it's time to setup Home Assistant. I'm going to walk through setting up Home Assistant inside a Docker container because I find it a little bit easier. I'm using an old laptop as a server, but I'd recommend a Raspberry Pi if you're not running much else.

Firstly, you will need to install Docker and Docker Compose:

# Install Docker
curl -fsSL https://get.docker.com | sh

# Install Docker Compose
sudo apt update
sudo apt install docker-compose -y

# Add yourself to the docker group
sudo usermod -aG docker $USER

Now Docker is installed, we'll make a new folder for storing the Docker Compose file (which is like a recipe for creating Docker containers).

# create a new folder in your home folder
mkdir ~/homeassistant
cd ~/homeassistant

# open docker-compose.yml for editing
nano docker-compose.yml

Inside the docker-compose.yml file, put the following. Notice that under devices, /dev/ttyACM0 is being passed into the container, this is so Home Assistant can use the dongle. You may need to change the device that is being passed in, you can check by looking at the output of dmesg as shown in the previous section. Also, this container uses network_mode: host which essentially means no network isolation is in place, this is important so that Home Assistant can more easily advertise itself to other things on your network (e.g. for the HomeKit integration).

version: '3.4'
services:
    homeassistant:
        container_name: homeassistant
        restart: unless-stopped
        image: ghcr.io/linuxserver/homeassistant
        network_mode: host
        environment:
            - PUID=1000
            - GUID=1000
            - TZ=Europe/London
        devices:
            - "/dev/ttyACM0:/dev/ttyACM0"
        volumes:
            - "./config:/config"

Save the file, then start up the container:

docker-compose up -d

After starting up the container, go to port 8123 to see the Home Assistant dashboard and follow the instructions to get set up.

Setting up Zigbee in Home Assistant

Once into Home Assistant, head to 'Configuration' on the sidebar, then 'Integrations'. In the bottom right, click 'Add Integration' and search for 'Zigbee'. You should see 'Zigbee Home Automation' come up.

You should be prompted to select the serial port. You should see the device that was passed in from the Docker Compose file, and the chipset of the dongle, which in my case is CC2531.

If you don't get prompted to add a device, you can click on the devices link underneath Zigbee Home Automation on the Integrations page, then 'Add Device' in the bottom right. You will then be asked to put your device into pairing mode. You will need to follow your specific devices instructions for that.

Temperature and Humidity Sensor

I first tried to setup my temperature and humidity sensor. I bought this because I know that it works with Zigbee, and should help me troubleshoot whether my Trådfri device isn't working or whether the Home Assistant or Zigbee dongle isn't working.

Following the instructions for it, I put into pairing mode, and a red light began to flash.

Almost instantly, the device was detected in Home Assistant. It takes just under a minute for it to be fully 'interviewed', where the device is asked what information it can give.

The temperature and humidity are now shown on the Overview page.

Trådfri Motion Sensor

Now for the main event, the motion sensor that has been sitting on my desk for months.

The motion sensor can be put into pairing mode by pressing the link button on the back 4 times. This process is similar for other Trådfri devices with buttons, otherwise for things like light bulbs without buttons, they need to be reset. It's worth Googling if your not sure, there's lots of documentation out there for connecting these Trådfri devices to a Zigbee gateway.

The motion sensor shows a red light, to indicate it is in pairing mode, just like the temperature sensor.

The motion sensor also gets instantly picked up by Home Assistant, and after the quick interview process, shows up in the Overview tab.

Next Steps

Inside Home Assistant, the temperature and humidity sensor has 3 separate 'entities', one for the temperature reading, one for the humidity reading and one with the battery level. The motion sensor has 2 'entities', one indicating whether there is motion or not, and the other with the battery level.

The motion sensor now gives me a lot more control, I can setup automations within Home Assistant which can use the motion sensor to do things. For example, I could make it so that if the light is on, and no motion has been detected for 5 minutes, the light turns off. That way, if I'm sleeping, the light won't turn on when it detects motion. I haven't gotten around to setting up automations yet, because I'm having some issues (more on that below), although I expect I will do a blog post if I learn anything cool about them.

In the future, I might also switch over all of my IKEA lights over to use Home Assistant, depending on how well the reliability holds up.

I hope this post has inspired you to look into home automation and smart devices. I'd love to know if you do anything cool!

Using the Elecrow 5" TFT display with Balena

Jake Walker — Tue, 01 Jun 2021 18:30:00 GMT

Balena is a really cool cloud platform for managing your IoT projects. Essentially, you can write some code, and Balena will manage your devices, keeping track of versions and automatically updating your devices.

There are a few Balena projects that make use of displays, there's lots of documentation for the official Raspberry Pi display, but for other displays it's a little hard to find the right things to change. This post should help you quickly get your Elecrow 5" TFT display working with Balena with touch support.

Under your device, go to 'Device Configuration'.

Set 'Define DT overlays' to "ads7846,cs=1,penirq=25,penirq_pull=2,speed=50000,keep_vref_on=0,swapxy=0,pmax=255,xohms=150,xmin=200,xmax=3900,ymin=200,ymax=3900"
Set 'Define a custom CVT mode for the HDMI' to 800 480 60 6 0 0 0
Set 'Force the HDMI hotplug signal' to on
Set 'Define the HDMI output group' to 2
Set 'Define the HDMI output format' to 87
Set 'Define the rotation or flip of the display' to 0

Underneath in the 'Custom Configuration Variables' section, add the following:

Name	Value
`BALENA_HOST_CONFIG_hdmi_drive`	`1`
`BALENA_HOST_CONFIG_max_usb_current`	`1`

And that's it, wait for the changes to propogate to your device (which includes a restart) and enjoy!

Create a WireGuard VPN in 10 minutes with Docker

Jake Walker — Mon, 19 Oct 2020 20:16:00 GMT

I'm a big fan of Docker, it really easily lets you set up applications without much effort and keeps everything organised on my server. I already run an OpenVPN server for the few times that I find myself on public Wi-Fi these days and I've been wanting to replace it with WireGuard which seems like a better solution.

It intends to be considerably more performant than OpenVPN. [...] It might be regarded as the most secure, easiest to use, and simplest VPN solution in the industry.

I've heard more and more good things about WireGuard, so I thought it would be finally a good time to switch over this weekend.

I set up WireGuard on my existing Linux cloud server, but this could also be replicated on a Raspberry Pi at home if you don't want to splash cash on a cloud server.

Installing Docker

These Docker installation instructions will only work on Linux machines, if you are working on Windows or macOS go to the Docker website for instructions on downloading Docker Desktop.

This two-liner installs Docker on most major Linux distributions.

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

After installing Docker, you will need to add your user to the docker group to allow you to run Docker commands without using sudo or logging in as a root user.

sudo usermod -aG docker <username>

You will most likely need to sign out and in again (or restart your SSH session) in order to be able to run Docker commands.

Setting up WireGuard

Now that Docker has been installed, we can move on to setting up the VPN itself. For this, it is best to have a domain pointing to your machine that you can use for VPN purposes. If you do not have one, use auto instead of a domain in the command below.

You will also need to know how many devices that you will have that will use the VPN at the same time. In my case, I have a laptop, tablet and phone that could be using the VPN at the same time. From these devices, you will need to make a comma separated list of device names (e.g. laptop,tablet,phone) these can be named anything you'd like.

Now run the command below. Make sure to put your domain in for SERVERURL= and your list of devices for PEERS=.

docker run -d \
  --name wireguard \
  --cap-add=NET_ADMIN \
  --cap-add=SYS_MODULE \
  -e PUID=1000 -e PGID=1000 \
  -e TZ=Europe/London \
  -e SERVERURL=wireguard.yourdomain.com \
  -e PEERS=laptop,tablet,phone \
  -e PEERDNS=auto \
  -p 51820:51820/udp \
  -v wireguard_config:/config \
  -v /lib/modules:/lib/modules \
  --sysctl="net.ipv4.conf.all.src_valid_mark=1" \
  --restart=unless-stopped \
  linuxserver/wireguard

Here's what all of that means:

--name wireguard - This names the container which makes it easier for using in commands later (rather than using the container's ID).
--cap-add=NET_ADMIN --cap-add=SYS_MODULE - This gives the container extra permissions on the host system. Specifically, it is allowed to modify network interfaces and install kernel modules respectively (more on that below).
-e ... - Each of the -e arguments sets an environment variable inside the container, these are used to configure the application that is running inside the container.
-p 51820:51820/udp - This listens for traffic on UDP port 51820 (left of the colon) on the host and passes it through to the container on port 51820 (right of the colon). If something else was using that port, you could change the one on the left of the colon to something else (for WireGuard, you'd also have to set -e SERVERPORT= to reflect the new port too)
-v wireguard_config:/config - This mounts the /config folder in the container to a Docker volume called wireguard_config (this could also be changed to a folder on the host, for example /home/jakew/wireguard). This particular volume would be stored at /var/lib/docker/volumes/wireguard_config/_data.
-v /lib/modules:/lib/modules - This is the same as before, but we are just mounting the folder /lib/modules to the same place on the host (more on that below).
--sysctl="net.ipv4.conf.all.src_valid_mark=1" - This sets a kernel parameter.
--restart=unless-stopped - This makes sure that the container starts again on crashes and host restarts (unless it is manually stopped in which case it will not be started again when the host reboots).
linuxserver/wireguard - This is the image that is being used. This is the name of the image which will be downloaded from Docker Hub which is a repository of Docker images.

Pressing enter will pull (download) the image and start the container in the background. You will get a long string of characters which is the container's ID. The VPN will initially take a little while to start up.

Why the SYS_MODULE and /lib/modules?

The reason that the VPN takes a little while to start up for the first time and the reason that we give the container permission to install kernel modules and mount the /lib/modules folder is because WireGuard is actually run inside the Linux kernel. This is why it has such great performance and security.

Getting client configurations

WireGuard will generate a configuration for each peer that we defined earlier on. These configurations contain connection information like the IP/domain of the VPN server and certificates for authentication.

The easiest way to get the client configuration onto your device is to scan the generated QR codes when the container starts. These are only shown on the first run, so if you missed them you'll need to get the files instead. We can look at them by using the following command and simply scanning the QR code with your phone or tablet.

docker logs wireguard

It's best to also save the configurations to your local machine so that you have them for future use. To use these, simply open the .conf file onto your device and open it in the WireGuard app. This command will copy the configurations to your home directory.

sudo cp /var/lib/docker/volumes/wireguard_config/_data/peer*/*.conf ~

Now set up a device with a configuration and make sure that it works correctly. If it connects it will most likely be working properly, but it might be worth checking your IP address to make sure that it matches what you would expect (e.g. the IP address of your cloud server).

Setting up automatic updates

Although the VPN is now working, it may be worth setting up automatic updates to make sure you have the best security. There is a tool called watchtower that is run inside a Docker container that checks all of your other Docker containers for updates and will automatically download the update and restart the container seamlessly.

docker run -d \
           --name watchtower \
           -v /var/run/docker.sock:/var/run/docker.sock \
           containrrr/watchtower wireguard

If you have more containers that you would like to keep updated, it would be worth checking out the watchtower documentation to make sure that you have it set up properly for how you would expect. I have mine set up by adding a label to each container that I would like to have updates on and leaving critical containers to be updated manually. You can also configure other useful things like notifications when containers get updated.

Wrap Up

Maybe the ease of setting up this VPN has shown you how cool Docker can be. I have become a big fan of it over the last couple of years that I've been experimenting with it.

I haven't had much time to test out WireGuard yet except quickly at home, but I can notice that it's slightly more snappy than OpenVPN when browsing websites. The app is much more simple though and much more easy to use with just one tap to turn on the VPN after set up.

Setting up a Raspberry Pi Zero W without a Display, Keyboard and Mouse

Jake Walker — Thu, 16 Apr 2020 12:53:27 GMT

I often find myself setting up a Raspberry Pi and I always forget the right way to set it up headlessly (without anything plugged in but power) so I thought I'd write a quick post about how I end up setting them up.

Although, I'm referring to a Pi Zero W for this post, these same instructions can be applied to any Raspberry Pi with a built-in Wi-Fi adapter or a compatible USB Wi-Fi adapter.

Choosing an SD Card

Unlike most other things, it's quite important to have a good quality SD card for your Raspberry Pi. I have a small collection of ones that work fine in Raspberry Pis but if you're looking for a new one it's good to look out for:

Class. SD cards are given a class which summarises what kind of speeds you should expect to get from the SD card. Most places online recommend a class of 10 or higher. The SD card that I have below is class 10 (which you can see by the 10 in the small circle).
Size. SD cards also come in a variety of sizes. 8GB is the recommended minimum for Raspbian but you could possibly fit it all on a smaller SD card.

Flashing the SD card

The next step is to install the operating system onto the SD card. For this step you'll need a separate computer.

Raspberry Pi have recently released a new tool called 'Raspberry Pi Imager' that simplifies the process of flashing SD cards with the operating system.

Firstly, you'll need to download the Raspberry Pi Imager for your specific operating system, you can find all of the links at the top of the Raspberry Pi Downloads Page.

After you've downloaded the imager, install and launch it:

The next step is then to select which operating system you would like. There are many different official varieties. Most of the time you'll just want ordinary Raspbian which is the first item in the list.

As I'm walking through a headless setup, I'd recommend using Raspbian Lite which has no desktop (just a command line). You can find this by clicking 'Raspbian (other)' and then selecting 'Raspbian Lite'.

The next step is to connect the SD card that you want to flash. There might be only one device to choose from, but if not make sure that you are selecting one with a similar size to your SD card (it might not be exactly the same, mine shows up as 7GB in the list even though it is 8GB).

Finally, after selecting the operating system and SD card, you can hit the write button and wait.

It could take a couple of minutes to download the image and flash it depending on your internet speed.

Setting up headless

At this point, you could stop and plug in the SD card to your Raspberry Pi with a screen, keyboard and mouse and use it as usual. Or, you could add a couple of files to the SD card to make the Raspberry Pi connect to your Wi-Fi network and start SSH (which both would normally require you to configure manually).

The Raspberry Pi Imager automatically ejects the SD card after it has been flashed so you might need to unplug and plug back in your SD card in order to see the files stored on it.

Enabling SSH

Open up the 'boot' drive that shows up and in Windows you can hold down Shift while right-clicking to bring up a menu with the option 'Open PowerShell window here':

On Windows, you can then type the command echo $null >> ssh to create a blank file called 'ssh'. On Linux and MacOS, you can use the command touch ssh in order to create the same blank file.

Creating a blank file called 'ssh' tells Raspbian to enable SSH.

Wi-Fi

The next step is to enable Wi-Fi on the Pi. This can be done by creating a new file called 'wpa_supplicant.conf'.

Make a new blank file in your text editor of choice, ensuring that line endings are set to 'LF', then copy the text below into the file:

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

network={
    ssid="network"
    psk="password"
}

Replace 'network' with your Wi-Fi network's name and 'password' with your Wi-Fi network's password. Then save the file as 'wpa_supplicant.conf' to the root of the SD card.

After doing both of those steps, you should now have 2 new files in the root of the SD card like so:

Booting Up

Now you're good to pop the SD card into the Raspberry Pi and connect power.

Then you can use an app like Fing to scan your Wi-Fi network for a Raspberry Pi. Looking at the app, I found that my Pi's IP address is 192.168.1.125.

Connecting via SSH

To connect via SSH, you'll first need an SSH client. Termius is a great cross-platform client, and is one that I use most of the time.

To connect with Termius, click the 'New Host' button at the top and type in the IP address in the 'Address' box.

Then scroll down to the SSH configuration section and type in the username and password. By default the username is 'pi' and the password is 'raspberry' (you should probably change these when you get logged in).

Finally, double-click on the new host that you've created and wait for it to connect.

And bam, we're in. Now you can use your Raspberry Pi from anywhere in Wi-Fi range and without plugging anything in but power.

Running WannaCry in a Virtual Machine

Jake Walker — Fri, 28 Feb 2020 16:30:00 GMT

I'm part of a club in my Sixth Form called CADS which among other things, involves learning about soft skills and cyber skills and applying those in the real world. Next week, we are attending an event where we are trying to spread awareness about Cyber Security and to achieve that we have decided to do a couple of demonstrations.

I am in charge of setting up a demonstration about WannaCry which is a ransomware attack that targets Windows computers using an exploit called EternalBlue. It's the one that was prominent in the news during 2017 when it hit the UK's NHS and took down a lot of their computer network. You can read up some more about WannaCry on the Wikipedia page.

Research

There are samples of malware (like WannaCry) available online to allow security researchers to reverse engineer them to find out how they work, how they can stop them and to add them to their anti-virus databases. During my research, theZoo on GitHub seemed to be a great place for finding these malware samples.

It is important to setup a safe environment for running the WannaCry sample. After doing some research from multiple sources, I found that the best way to run the sample of malware would be within a virtual machine with no internet connection and some extra settings to ensure that it is isolated from the host machine. I was also planning to use snapshots of the virtual machine so that it could easily be reset to a working version of Windows after it has been infected with the ransomware.

Unpatched Windows XP and Windows 7 machines are vulnerable to WannaCry so I would need to use one of those operating systems. In the end I decided to go for Windows 7 because it's slightly newer and WannaCry works better on Windows 7 according to the Wikipedia page. I found an Windows 7 disc which was older than 2016 so it wouldn't be patched against the EternalBlue exploit.

Setup

Now that I had completed my research, I was ready to create a virtual machine for running WannaCry safely.

Setting up the Virtual Machine

I am using VMware Workstation 15 Pro for creating the virtual machine, but VirtualBox would also work fine and can also create snapshots of virtual machines.

I started off by creating a new Typical Virtual Machine:

Then although I had in ISO file to use, I picked 'I will install the operating system' later so that VMware didn't use it's Easy Install feature which skips through the installation wizard.

Next up, I picked the version of Windows that I was using:

And gave it a name

Then I created the virtual hard drive. The recommended size is 60 GB, but I decided to go for half of that as I wouldn't be doing anything other than copying some files into the VM and running WannaCry.

Then I needed to give the VM slightly more processor, RAM and setup the ISO to be in the virtual machine's CD drive by clicking 'Customize Hardware...':

In the Memory tab, I increased the memory from 1024 MB to 2048 MB:

In the Processors tab, I increased the number of processors from 1 to 2:

Then I removed the Network Adapter by selecting it and hitting the remove button at the bottom of the menu.

Then on the 'CD/DVD (SATA)' tab, I selected the 'Use ISO image file' and opened the ISO image that I had for Windows 7:

Finally, I checked over the new VM's settings and hit Finish:

Setting up Windows

After creating the virtual machine, it was time to setup and install Windows 7. The ISO image was already mounted to the VM from the previous steps, so it is ready to boot.

Then I just went through the setup wizard as on a normal computer.

I created a new user called 'CADS' and gave it a suitable name:

I clicked next when it asked for a product key as it doesn't matter that this VM isn't activated. Then I selected 'Use recommended settings' and set my time zone, date and time. Then I was greeted with the Windows 7 desktop. At this point, it's a good idea to make sure that the virtual machine does not have an internet connection.

From my earlier research, it is recommended that you don't install VMware tools, so if you are prompted by VMware to add them, it's best to ignore the message.

One of the downsides of not installing VMware tools is that the screen is tiny. As I'm doing a demonstration I can't really use it with a tiny screen resolution. I fixed this by going into the settings and changing the screen resolution and also turning on screen stretching in VMware so that it would scale the screen to the size of the window.

I then customised Windows 7 a bit by adding a wallpaper, user avatar and adding some random files to the desktop, documents and pictures folders which would demonstrate the files getting encrypted. I copied all of the things I'd need on the virtual machine to a USB drive plugged into my host machine.

I then attached the USB drive to the virtual machine and copied all of the files off to their relevant places:

Malware Sample

Now that the virtual machine is setup, it's time to download the malware sample and copy it into the virtual machine.

To download the sample, I went to theZoo on GitHub on my host machine and went into malwares → Binaries → Ransomware.WannaCry and then downloaded the Ransomware.WannaCry.zip file.

After downloading, Windows Defender should immediately detect that you have just downloaded malware and quarantine it.

We need to allow the malware to be on our host computer. The malware is safe as long as it is inside the ZIP file. To do this, open up Windows Defender and find where the threat has been blocked and hit the allow button:

Now that it is allowed, we can copy it onto the USB drive like with the other files (you might need to disconnect it from the virtual machine for it to show up on the host machine). Then connect the USB drive back to the virtual machine and copy the newly downloaded file onto the desktop (or another convenient folder).

Now disconnect the USB drive from the virtual machine. It's best not to unzip the malware until it is about to be used.

Snapshot

It's a good idea to take a snapshot of the virtual machine at this point. A snapshot is a 'copy' of the virtual machine at it's current state with all of it's files and settings. Doing this will allow us to restore a snapshot after we have executed the malware.

Give the snapshot a suitable name and then hit 'Take Snapshot'. At the bottom of VMware, there will be a percentage of the progress of the snapshot (e.g. 'Saving state... 42%'). Ensure that you wait until this message has disappeared before continuing. It's also best to not use the virtual machine whilst it is saving a snapshot.

Final Checks

Now that the virtual machine is loaded with the malware and we have a snapshot of before the malware is executed, it is worth shutting down the virtual machine and checking the settings. Shut down the virtual machine by shutting down Windows 7 as normal.

Go into the menu for editing the virtual machine's settings in VMware and double check the following:

There is no network adapter. If there is one, make sure that it has been removed.
There is no CD/DVD drive or printer. Although this isn't important to remove, it's best to remove all of the ways that the malware could escape the virtual machine.
In the 'Guest Isolation' tab, uncheck 'Enable drag and drop' and 'Enable copy and paste'.

Then hit 'Save'.

The demonstration

Boot the virtual machine back up and double click on the Ransomware.WannaCry.zip file on the Desktop and unzip the EXE that is contained inside. The password for unzipping is on the GitHub download page.

Then simply double click on the EXE to start WannaCry and watch the carnage.

Then to reset the virtual machine, click the restore snapshot button at the top of the window and wait for a couple of seconds.

Improvements

For the final demonstration at the event, I am planning on having a host-only network between two virtual machines so that I can show the malware spreading through a network of computers.

Wrapping Up

Hopefully this has been a small introduction on how to safely run malware on your own computer using a virtual machine. From here, you can do some analysis on the running malware using tools like Wireshark to check network activity, Volatility to look inside memory or Regshot for comparing the registry before and after executing the malware.

Thanks for reading :)

Drone - Continuous Integration with Containers

Jake Walker — Sat, 23 Nov 2019 20:24:29 GMT

In the past month, I have been playing around with Drone which is probably my new favourite CI tool! In this article, I'm going to talk about why I like it so much and how you can use it to test your own code.

Lots of code projects will have tests (which are small functions that test a section of the project to check that it is working as intended). It would be very time consuming for maintainers of a project to keep running these tests after contributors have changed it, so this job can be automated using continuous integration. CI tools can detect when code has been changed, run all of the tests, alerting the project maintainers if there are any problems.

As I mentioned before, Drone is one of these tools that automatically runs tests. However, there are many other tools like this available, such as Jenkins, Travis CI and the new GitHub Actions. Lots of these have their advantages and some are more specialized for specific use cases, so if you don't feel like Drone is for you, maybe do some research!

Why Drone?

Unlike the majority of CI tools, Drone uses containers to run it's tests. This is a huge benefit because once the test is run, everything that was changed in the container is gone, so there are no changes to the host's operating system.

I also like Drone because of how simple it is to get up and running as well as how easy it is to setup a testing pipeline (as we'll see later in this post).

The last point I like about Drone is that you host it all yourself. Travis CI and GitHub Actions are hosted which means that the company manages the infrastructure, not you. This does have it's advantages with excellent uptime and an 'it just works' experience. However, once you need to start needing building closed source projects or have large or lots of projects, you start running into problems with pricing. As with Drone you're always in control of your own infrastructure, you can always scale up when you need to build more simultaneous projects and you will probably be paying less than buying a hosted CI.

Setting up Drone

Drone is run inside Docker which there are only a couple of commands to get it up and running. I'll be showing how you install it on a fresh Ubuntu server, but these commands should work on most major Linux distributions and even on a VM or spare computer.

Specifically, I'm using a CX11 instance from Hetzner Cloud running Ubuntu Server 18.04. On the server where I run my main instance of Drone, I also run other applications with no problems.

You'll need a server with a public IP address, there are no minimum requirements to run Drone, but I'd recommend at least 1 GB of RAM and 1 CPU core. At idle, both the server and runner use about 15MB RAM and little CPU, so extremely lightweight.

Installing Docker

The quickest and easiest way to install Docker is using their installer script. This script works on most major Linux distros (even Raspbian). Make sure you run this as root!

curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

If you have any ordinary user accounts that you'd like to be able to use Docker, you can use this command to give them permission to do so:

sudo usermod -aG docker username

Installing Drone

Next up, installing Drone itself. Drone is installed differently depending on which provider you use for your source code (at the moment GitHub, GitLab, Gitea, Gogs, Bitbucket Cloud, Bitbucket Server are supported). I'm going to be setting up a GitHub instance, but if you want to setup something else take a look at the relevant installation instructions here.

Create a OAuth Application on GitHub. For the application name, put something like 'Jake's Drone', for homepage URL, put the URL of where you will be hosting your Drone instance whether it's an IP address or domain name (e.g. http://drone.example.com/ or http://10.20.30.40) and finally for the Authorization URL put the domain of your drone instance plus /login at the end (e.g. http://drone.example.com/login or http://10.20.30.40/login). After that, take a note of the client ID and client secret that you get.

Here's the information for my instance when creating the OAuth application:

And here's the client ID and secret that we get:
Now we need a secret code will be used for encrypting communications between the runner (which we'll get onto later) and the server. Run this command to get a suitable key:
```
openssl rand -hex 16
```
And now we need to download Drone through Docker, we need to use the command:
```
docker pull drone/drone:1
```

Finally, we are going to start up the Drone server through Docker with this command. Make sure to substitute all of the placeholders in angle brackets <>:

docker run --volume /var/lib/drone:/data --env DRONE_AGENTS_ENABLED=true --env DRONE_GITHUB_SERVER=https://github.com --env DRONE_GITHUB_CLIENT_ID=<GITHUB_CLIENT_ID> --env DRONE_GITHUB_CLIENT_SECRET=<GITHUB_CLIENT_SECRET> --env DRONE_RPC_SECRET=<SECRET_KEY> --env DRONE_SERVER_HOST=<YOUR_DOMAIN_OR_IP> --env DRONE_SERVER_PROTO=http --env DRONE_USER_CREATE=username:<YOUR_GITHUB_USERNAME>,admin:true --env DRONE_USER_FILTER=<YOUR_GITHUB_USERNAME> --publish=80:80 --publish 443:443 --restart=always --detach=true --name drone drone/drone:1

That's a long command right! Here's a breakdown of what the different parameters are doing:

Parameter explanations

--volume /var/lib/drone:/data tells Docker to permanently store the folder /data in the container to /var/lib/drone on the host. If this wasn't set, whenever the container is restarted, data might be lost and we'd have to setup Drone again.
--env ... tells Docker to set an environment variable inside of the container. It's a way of giving the application inside the container some basic configuration.

DRONE_AGENTS_ENABLED=true sets that we want the server to communicate with the agents/runners that we'll setup later.
DRONE_GITHUB_SERVER=https://github.com tells Drone which GitHub we are talking to (this would change if you were hosting your own GitHub Enterprise instance, but for most people we just want to be talking to the normal GitHub)
DRONE_GITHUB_CLIENT_ID=... is used for handling authentication with GitHub, allowing users to login with their GitHub credentials to Drone.
DRONE_GITHUB_CLIENT_SECRET=... same as above.
DRONE_RPC_SECRET=... is a secret key that is used for the server when communicating to the runners and vice-versa.
DRONE_SERVER_HOST=... is the place where the Drone instance is being hosted.
DRONE_SERVER_PROTO=http tells Drone whether we are using HTTP or HTTPS. It makes sure that all of the links that it uses are either HTTP or HTTPS.
DRONE_USER_CREATE=username:...,admin=true will make sure that our GitHub account is an adminstrator of the Drone instance. It will allow you to use the Drone CLI with your account to do things with the server.
DRONE_USER_FILTER=... only let's this list of users to make accounts, if you want to add more you can separate the list with commas (e.g. bob,jeff,alex)

--publish=80:80 tells Docker that any traffic coming in or out of port 80 on the host should be forwarded to port 80 inside the container.
--publish=443:443 is the same as above but for port 443 which is HTTPS.
--restart=always makes sure that the container is kept running all the time. If this wasn't set and the server was rebooted, the Drone server would not automatically start, additionally, if the Drone server crashes it will be restarted automatically.
--detach=true makes this container run in the background.
--name drone gives this container a name, useful for running any commands on the container (e.g. docker logs drone will get the logs of the container).
drone/drone:1 tells Docker which image that should be used for this container.

OK, now you've got a hopefully working Drone server! Open up your favourite web browser and head over your your server's IP address.

You'll be redirected to a GitHub authorization page:

And then you'll get a list of your repositories after a couple of seconds:

You can click the 'Activate' button by any of your repositories to let Drone build them automatically, but nothing will happen without a runner.

Creating a Drone Runner

To make the Drone instance functional, we need a runner. This is a small application that runs all of the tests that we define in our project. We'll be setting up a Docker runner which runs the tests inside Docker containers (you can also get a Kubernetes Runner, Exec Runner (runs commands inside a shell on a host), SSH Runner (runs commands on a remote host) and Digital Ocean Runner (runs tests inside a fresh Digital Ocean server)). There are reasons why you might want to use a different type of runner, so you might want to research which one might be best for you and your project, however the Docker runner will work best for the majority of projects if you are just building on Linux. You can read the installation instructions for all of the different runner types here.

For Windows builds, an Exec runner is the best to use as Docker is a bit janky on Windows.

These instructions are for installing the Docker runner on Linux. It does not need to be run on the same server as the Drone server, but I will be doing that.

Download the runner image through Docker:

docker pull drone/drone-runner-docker:1

Run the runner:

docker run -d -v /var/run/docker.sock:/var/run/docker.sock -e DRONE_RPC_PROTO=http -e DRONE_RPC_HOST=<YOUR_DRONE_INSTANCE_DOMAIN_OR_IP> -e DRONE_RPC_SECRET=<SECRET_KEY_FROM_INSTALLING_DRONE_SERVER> -e DRONE_RUNNER_CAPACITY=2 -e DRONE_RUNNER_NAME=${HOSTNAME} -p 3000:3000 --restart always --name runner drone/drone-runner-docker:1

The parameters have the same meanings as when we installed the Drone server. DRONE_RUNNER_CAPACITY tells the server how many things can be built at once, unless you will be building lots of projects at the same time 2 is a good value to go for.

Now we are ready to build something!

Using Drone

To demonstrate how Drone works, I'm going to walk through how to setup a project to test. You should be able to follow along with this demonstration as all of my code is available here, I'll link to the specific version of the repository that I'm at throughout this section.

The Test Subject

I don't want to go much into coding with this blog post, but I'll be testing a simple Python application:

sum.py

def sum(a, b):
    return a +b

print(sum(4,6))

So in this example, I'm using the Python library flake8 to test that my code is conforming to a set of nice styles. I've purposely formatted my code badly so that the tests will not pass.

To use this code on my own computer, I'll need to:

Install the Python libraries that I'm using: python -m pip install -r requirements.txt
Run flake8 to check for errors: flake8

With the code above, I'm getting 3 errors from flake8 on my computer:

➜ flake8
./sum.py:2:15: E225 missing whitespace around operator
./sum.py:4:1: E305 expected 2 blank lines after class or function definition, found 1
./sum.py:4:12: E231 missing whitespace after ','

OK, now that I've got something to test, I'm going to commit my code to GitHub. Take a look at my commit here.

Activating the Repository

Now let's head over to Drone and activate that repository:

After clicking Activate, you'll get the settings of your repository:

Here you can set:

Project Webhooks where you can configure to disable checking for pull requests or forks of your repo.
Project Settings where you can set:
- Protected - let's you sign your build configuration and don't run it unless it is signed. Read more here.
- Trusted - let's your Docker containers run in privileged mode, which allows them to have unlimited access to the host.
Timeout - the time for one build before Drone goes "Welp, this isn't going to finish. Might as well stop".
Configuration - the name of the file to look for instruction in (we'll come onto this later).
Secrets - variables that can be used in your test which you don't want people to see (e.g. passwords).
Cron Jobs - running tests on a regular schedule (e.g. hourly, daily, weekly, monthly)
Badges - little status icons that you can add onto your repository.

You might have noticed under the 'Activity Feed' tab that nothing has happened since we have added this repository. That's because we actually haven't told Drone what to do with all of this code. Let's make a configuration file to do so.

Creating a Pipeline

Back in our code we'll make this simple config file with all of the instructions that we need. I'm not going to go over every single option you can put in this config file so you can have a look at the extra awesome things you can do here.

.drone.yml

---
kind: pipeline
type: docker
name: default

steps:
  - name: lint
    image: python:3.7-alpine
    commands:
      - python -m pip install -r requirements.txt
      - flake8

This file is pretty small right? Here's what everything means:

kind: pipeline - I'm not totally sure what else this would be, but this tells Drone that we are defining a new pipeline.
type: docker - This tells Drone to run this pipeline on a Docker runner.
name: default - This is the name of the pipeline, this can be anything really.
steps: - This is the list of instructions that are executed in order to test the code.
- name: lint - The hyphen at the start indicates a new 'step' block. Also in this line we are defining the name of this step, this can also be anything.
image: python:3.7-alpine - This is the Docker image that is going to be used for building this code. This particular image python:3.7-alpine has Python pre-installed.
commands: is a list of commands that should be executed in this step
python -m pip install -r requirements.txt this runs that exact command inside the container which installs all of the extra packages that we need for the program to run (this would be specific to your project)
flake8 is the command that tests our code.

So how does Drone know that the test failed? Every command on Linux has an exit code which can be any number. If the command finishes successfully the command sends an exit code of 0, otherwise it might give an exit code of 1. Any code which isn't 0 indicates the command didn't run successfully, and hence Drone can tell whether the test fails. Any commands that fail in the commands section of the config will stop the test and mark it as a failure.

After committing this config file, Drone will actually start running the test. If you look at Drone now you'll be able to see the test running:

And when we click on the test above, we can see the separate steps (along the sidebar) that this build contains and whether they have failed or passed. The yellow cog shows that the lint step is in progress:

Oh no! Our test has failed:

If you take a look closer, we are getting the same output as I got when I ran the test command on my computer.

OK now that we know that our test fails properly, let's fix the code. After committing the changes, we can see that Drone starts another build and it passes!

Wrapping Up

So hopefully I've been able to show you how Drone is so awesome and how to use it. Even if you don't have a server to host your own instance of Drone, you can still use their free, hosted one here, or alternatively you could use a similar CI tool which is free and hosted (such as GitHub Actions (which also uses containers, but different config files) and Travis CI).

If you need any help setting up your own instance or making config files or anything like that, don't hesitate to ask me for help! Thanks for reading :)

Getting a ST7735 TFT Display to work with a Raspberry Pi

Jake Walker — Fri, 19 Jan 2018 18:37:00 GMT

I recently bought a cheap TFT display for a project I was doing and after a bit of research I decided upon a 1.8" 128x160 ST7735 Display from Karen's eShop on eBay, it's very affordable and looked great for my project. On the product page, the seller has got some really great, detailed instructions for getting the screen to work on an Arduino, however, I couldn't find anywhere online for getting this screen to work on a Raspberry Pi. This post will quickly save you the trial and error of getting a ST7735 working with a Raspberry Pi.

Wiring

Firstly, the display needs to be wired correctly to the Raspberry Pi. This site will come in handy for finding which pins are where.

Screen Pin	Raspberry Pi Pin
GND	Ground (pins 6, 9, 14, 20, 25, 30, 34 or 39)
VCC	5v Power (pins 2 or 4)
SCL	GPIO 11 (pin 23)
SDA	GPIO 10 (pin 19)
RES	GPIO 25 (pin 22)
DC	GPIO 24 (pin 18)
CS	GPIO 8 (pin 24)
BL	Not connected

When powering on your Raspberry Pi, the screen will show white by default. You will need to use Python to now display images, more on that below.

Software

I found a library for the screens using the ST7735 chip on GitHub. The instructions and examples on GitHub will work fine, but this is for a different size of the screen, the instructions and example code here will work from the 128x160 display from Karen's eShop.

Firstly, you need to enable SPI on your Raspberry Pi. You can do this by using the Raspberry Pi configuration tool:

sudo raspi-config

Once in the configuration, select '3 - Interface Options', then 'P4 - SPI', select 'Yes'

Now, you'll need to install the dependencies and the ST7735 library itself:

sudo python3 -m pip install RPi.GPIO spidev Pillow numpy
sudo python3 -m pip install st7735

Example Code

Here is some example code that I used to print out 'Hello World!' to my display, modified from one of the examples in the GitHub repository.

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont

import ST7735

disp = ST7735.ST7735(port=0, cs=0, dc=24, backlight=None, rst=25, width=128, height=160, rotation=0, invert=False)

WIDTH = disp.width
HEIGHT = disp.height

img = Image.new('RGB', (WIDTH, HEIGHT))
draw = ImageDraw.Draw(img)

# Load default font.
font = ImageFont.load_default()

# Write some text
draw.text((5, 5), "Hello World!", font=font, fill=(255, 255, 255))

# Write buffer to display hardware, must be called to make things visible on the
# display!
disp.display(img)

Introduction to Electron Apps

Jake Walker — Sun, 24 Jul 2016 09:21:00 GMT

Yesterday, I was downloading Visual Studio and then I thought to myself: What if I could write desktop apps with Node.JS, HTML and CSS?. After a bit of Googling around I found something called Electron.

Electron is made by GitHub and it's Atom editor uses it. Essentially it is an iframe in a window. But of coarse nothing is as simple as that. It also manages the processes.

This tutorial was written for Windows but I'm sure it's not too hard to replicate on Linux (or other)

Installing Node.JS

First your going to want to Download Node.JS. Download the one on the right.

Then once you've installed, go to a command line WIN-R then type cmd. Then type

node -v

and you should get something back like

v6.2.0

And also you might want to get Git here for Windows (Linux, Mac).

Writing an App

Firstly, navigate to where ever you want your app to live:

mkdir "My Electron Apps"
cd "My Electron Apps"

Clone the quick start repository:

git clone https://github.com/electron/electron-quick-start

Navigate to the folder where it cloned to:

cd electron-quick-start

Install the node packages: (This may take a while)

npm install

Start the application:

npm start

and you should see this:

Now let's dive into the code and make some changes. I am using Atom to edit these files.

Opening index.html shows the HTML shown in the main screen and it looks like it has Node inline.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Hello World!</title>
  </head>
  <body>
    <h1>Hello World!</h1>
    <!-- All of the Node.js APIs are available in this renderer process. -->
    We are using node <script>document.write(process.versions.node)</script>,
    Chromium <script>document.write(process.versions.chrome)</script>,
    and Electron <script>document.write(process.versions.electron)</script>.
  </body>

  <script>
    // You can also require other files to run in this process
    require('./renderer.js')
  </script>
</html>

OK, now let's try and add a library and see if it works. Go back to the command line and type:

npm install request --save

--save make the package manager save the library to the dependencies so if someone else wanted to use your app it would automagically install for them.

After it's installed, you can now include it into the project. Go to index.html then at the bottom there is a <script> tag that looks like this:

<script>
  // You can also require other files to run in this process
  require('./renderer.js')
</script>

Add var request = require('request') to include the request library.
Add request('http://random.cat/meow', function (error, response, body) { }) to fetch the cat image.
Then inside the request function add if (!error && response.statusCode == 200) { } which will check that there are no errors like the site being down.
Then inside the if statement add var jsonObj = JSON.parse(body) which will parse the output from the website and make it easy to extract the image URL.
Then underneath the last line add var image = document.getElementById('myImage') which will search the file for an element with the id of 'myImage'.
Then, again underneath the last line add image.setAttribute("src", jsonObj.file) which will set the image URL of the image tag to the image of the cat.

All that code should look like this:

<script>
  // You can also require other files to run in this process
  require('./renderer.js')
  var request = require('request')

  request('http://random.cat/meow', function (error, response, body) {
    if (!error && response.statusCode == 200) {
      var jsonObj = JSON.parse(body)
      var image = document.getElementById('myImage')
      image.setAttribute("src", jsonObj.file)
    }
  })
</script>

Make sure to add the img tag to the HTML like so:

<h1>Hello World!</h1>
<!-- All of the Node.js APIs are available in this renderer process. -->
<img id="myImage">
We are using node <script>document.write(process.versions.node)</script>,
Chromium <script>document.write(process.versions.chrome)</script>,
and Electron <script>document.write(process.versions.electron)</script>.

the whole index.html should look like this:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Hello World!</title>
  </head>
  <body>
    <h1>Hello World!</h1>
    <!-- All of the Node.js APIs are available in this renderer process. -->
    <img id="myImage">
    We are using node <script>document.write(process.versions.node)</script>,
    Chromium <script>document.write(process.versions.chrome)</script>,
    and Electron <script>document.write(process.versions.electron)</script>.
  </body>

  <script>
    // You can also require other files to run in this process
    require('./renderer.js')
    var request = require('request')

    request('http://random.cat/meow', function (error, response, body) {
      if (!error && response.statusCode == 200) {
        var jsonObj = JSON.parse(body)
        var image = document.getElementById('myImage')
        image.setAttribute("src", jsonObj.file)
      }
    })

  </script>
</html>

Run it again by doing:

npm start

and it works!

I think the JavaScript we put in could have gone into renderer.js but I didn't get it to work.

Now for awesome some new Node.JS apps huh?

Pi Zero Impressions

Jake Walker — Mon, 29 Feb 2016 17:54:00 GMT

I brought a Raspberry Pi Zero on Friday because it was really hyped up and it was also very cheap. I brought mine from The Pi Hut, I got the Zero + Essentials Kit variation (which costed £10.25 at the time of purchase).

First Impressions

My first impression of the Pi Zero was that it was extremely small. The only place I had seen it is in magazines which made it look bigger. When I first booted it up it took a while making me think it was going to be quite slow but once it was booted up it seemed quite snappy (in bash/command line mode).

Setup

I first plugged in the HDMI adapter then a (powered) HDMI to VGA adapter as my monitor is VGA.
Next, I plugged in my OTG cable then plugged that into a powered USB Hub which I had my keyboard, mouse and Wi-Fi dongle connected.
Then, I inserted my microSD card which I had put Raspbian on (I used the lite version (which has no desktop GUI) as I like to run my Pi's headless and its more fun to learn bash :))
I plugged in the power then waited for it to boot up for the first time.
I typed in pi for the username and raspberry for the password.
I then expanded the filesystem to use the whole of my SD card by typing sudo raspi-config then selecting 'Expand Filesystem'.
I then finished by rebooting the Pi.
I then set up the Wi-Fi by: (using this article)
Scanning for networks using sudo iwlist wlan0 scan but as I already knew my Wi-Fi SSID and Password it was unnecessary. The ESSID part is the SSID you need for later
Opening the configuration file by typing sudo nano /etc/wpa_supplicant/wpa_supplicant.conf. Then going to the bottom of the file and adding:

network={
    ssid="ssid of your network"
    psk="password of your network"
}

Next, I updated the apt packages by typing sudo apt-get update. You could also do sudo apt-get upgrade if your image is a bit old.
As I had no desktop, I decided to install Lynx. A web browser that can be used in the command line. You can install it by typing sudo apt-get install lynx. Then opening it by typing lynx.

Overall the Raspberry Pi Zero is great for the £5 price tag but can set you back a little more for the adapters. It is very small so can be used for projects when a traditional Pi is too big.

Installing a Custom ROM onto the 5th Generation Kindle Fire

Jake Walker — Sun, 27 Dec 2015 17:36:55 GMT

After playing with my Kindle for a few weeks, I thought how much bloatware was installed and how locked down the device was. I then decided to install a custom ROM.

Prep

Fastboot and ADB. You may already have this installed but it is very simple to install from scratch. Use this guide written by Lifehacker http://goo.gl/SLpJXX.
ROM Image. You will need to get this from https://goo.gl/UMaqln. Put this (don’t unzip it) onto an SD card in your Kindle.
TWRP (Recovery) Image. You will need to get this from https://goo.gl/AfVCun.
Google Apps (gapps). You will need to download a version from the list here https://goo.gl/6AKGhp. It is recommended that you download the mini version (I downloaded Slim_mini_gapps.BETA.5.1.build.0.x-20151215.zip, however, it will be most likely outdated so make sure you get the latest. Put this (don’t unzip it) onto an SD card in your Kindle.

Booting into Recovery

Once you have downloaded and installed Fastboot and ADB, you will need to plug the Kindle Fire into your Desktop/Laptop and fire up a command prompt.
Navigate to where you have saved the TWRP Image using cd (for Windows) and ls (for Linux).
Turn off the kindle and press down volume button and the power button until there is a little message on the screen saying Fastboot Mode (not Recovery Mode) OR type in the shell adb shell reboot bootloader.
Type in the shell fastboot boot TWRP_Fire_2.8.7.0_adb.img

Installing the ROM

Now you should be in recovery. There should be some buttons on the screen.

Press the Wipe button and swipe the arrow across to initiate the wipe (make sure you wipe dalvik cache, data, cache and system).
Go back to the main menu and press Install and find the ROM Image. Flash it and when successful go back to the Main Menu and flash Google Apps.
Reboot (to System)

You should boot up and find a setup menu. I have found some apps won’t install from the Google Play Store (I found Inbox (by Gmail) and Amazon Shopping don’t work), however, if you sideload these apps they work fine.

Hacking the 5th Generation Kindle Fire

Jake Walker — Sun, 04 Oct 2015 21:05:00 GMT

On Black Friday I bought a Kindle Fire (5th Gen) for £35. I decided to hack it. My main aim was to install Google Play, change the launcher and remove the bloatware, however, to achieve this I also needed to root the device.

Prerequisites: ADB and Fastboot (guide: http://goo.gl/SLpJXX), Drivers (http://goo.gl/sqJgpL)

1. Google Apps (no root required)

Source: http://goo.gl/btPy9W

Install ES File Explorer from Amazon’s App Store for free on the Kindle Fire.
Open Settings > Security > Unknown Sources and check it or turn it on.
Download the Google Core APK .zip archive here: https://goo.gl/ansjr1 to the device and find it in ES File Explorer under the internal SD card in the Downloads folder
Install each of the below in order by tapping on the particular file name in ES File Explorer.
com.android.vending-5.9.12-80391200-minAPI9.apk
com.google.android.gms-6.6.03_(1681564-036)-6603036-minAPI9.apk
GoogleLoginService.apk
GoogleServicesFramework.apk
Reboot the Kindle Fire
Open Settings > Device Options and repeatedly tap the Serial Number until it says something like “No need you are already a developer”.
Open Settings > Device Options > Developer Options and check or turn the option saying Enable ADB
Plug the device into the computer you have ADB and Fastboot installed on.
Open a prompt and type adb devices. If nothing show up in the list something is wrong with your drivers. If everything is correct you should get a code with numbers and letters then ‘device’ after.
Type adb shell pm grant com.google.android.gms android.permission.INTERACT_ACROSS_USERS. There will be no text returned after running this
Check if Google Play works by finding it in the apps list. If it immediately closes after opening it follow step 12 if not you’re done!
Reinstall ‘com.android.vending-5.9.12-80391200-minAPI9.apk’ in ES File Explorer.

2. Rooting

Source: http://goo.gl/FQhGl0

Enable ADB on the Device (see section 1, steps 6 and 7)
Download the .zip archive of all the tools used for rooting from here: http://goo.gl/wvUMgI.
Unzip the file and plug in the Kindle Fire to your PC.
Windows: Double click root.bat and follow instructions. Linux: Open a terminal and navigate to the place you unzipped the archive and type sh root.sh and wait for the script to complete. The Kindle Fire will restart multiple times, don’t worry this is normal. The Kindle Fire may say Installing Firmware, this is also normal and just means it it is optimising apps.
You should be rooted you can try this by installing a Root Checker app from the Google Play Store.

3. Remove Bloat (root required)

Source: http://goo.gl/ud7HWU

Install an app called “System App Remover (ROOT)” from the Google Play Store.
Remove any app in the list below by opening the app and checking the apps and tapping remove at the bottom of the app.
com.amazon.webapp | Bookstore
com.amazon.zico | Documents | 2.0_205111610
com.amazon.mp3 | Amazon music
com.android.music |Music | 10.0.51-D-20151009-NA-7
com.amazon.kindle.ottercom.amazon.kindle | Kindle Reader
com.audible.application.kindle | Audible
com.amazon.tahoe | FreeTime | 1.5.345.26-FreeTimeForTabletGen6_201365610
com.amazon.kindle.otter.oobe | Device Setup | 1.0.171.0_3337310
com.amazon.client.metrics | Amazon Metrics Service Application | 1.0.175.0_9610
com.amazon.device.backup | Amazon Backup and Restore | 5.0.410.0_5107610
com.amazon.platform | Amazon platform | 1.0.9.2_1009710
com.amazon.photos | photos FOS | 20115210 (Needed to change the wallpaper)
com.nuance.edr.androidservice.service
com.amazon.whisperlink.core.android | Whisperlinkplay Daemon | 2.0.100021.00
com.amazon.camera | Camera | 1.0.088.0_1002120310
com.amazon.csapp | Help App
com.amazon.legalsettings | Legal Settings App
com.amazon.venezia | Amazon App Store
com.amazon.h2settingsfortablet | Profiles & Family Library App
com.amazon.weather | Weather App
com.goodreads.kindle | Goodreads | 1.6.1+1060100710
com.android.calendar | Calendar App
com.amazon.kindle.kso | Special Offers / Ads (lockscreen ads)
com.android.email | Email App
com.amazon.kindle.personal_video | Video App
com.amazon.avod | Video App
com.amazon.contacts | Contacts App
com.amazon.windowshop | Amazon Windowshop (Amazon Shopping App)
com.amazon.cloud9 | Silk Browser App
com.amazon.ags.app | Amazon Game Circle App
com.amazon.kindle.otter.settings | Amazon Registration Service
Restart the Device.

4. Changing Launcher (requires root)

Make sure you have another launcher before continuing.
Open ES File Explorer and open the side menu and open the Tools part then turn on the Root Explorer option
Navigate to the root of the device and open the system folder then the priv-app folder [ /system/priv-app/ ]
Copy the folder called com.amazon.firelauncher to the SD card of the device and then go back to the priv-app folder and delete the folder you just copied. You should then end up with no folder called com.amazon.firelauncher in the priv-app folder and a folder called com.amazon.firelauncher in the SD card.
Restart the device.

Thanks for reading. I hope this helped you enhance your £50 Kindle Fire. I found some more articles at: http://goo.gl/cITO3g including the articles below.

Remove Lock Screen Ads (no root required): http://goo.gl/xlxQrp

In the future I hope to install CyanogenMod when a stable release comes out.

Arduino Weather Logger

Jake Walker — Fri, 10 Apr 2015 19:57:00 GMT

Introduction

This was originally a way to test out an app I found called ‘Blynk’ which I first tested on the Raspberry Pi. I then decided to try and get it working with an Arduino and a cheap Wi-Fi module then I plugged in my BMP180 and a light sensor and successfully got it working. I then decided to remove the components I was testing it with and turn it into a data logging weather station.

Wiring

View on Fritzing

Code

Virtual Pin 1 is Temperature (degC), Virtual Pin 2 is Pressure (Pa).

/**************************************************************
 * Blynk is a platform with iOS and Android apps to control
 * Arduino, Raspberry Pi and the likes over the Internet.
 * You can easily build graphic interfaces for all your
 * projects by simply dragging and dropping widgets.
 *
 *   Downloads, docs, tutorials: http://www.blynk.cc
 *   Blynk community:            http://community.blynk.cc
 *   Social networks:            http://www.fb.com/blynkapp
 *                               http://twitter.com/blynk_app
 *
 * Blynk library is licensed under MIT license
 * This example code is in public domain.
 *
 **************************************************************
 *
 * This example shows how to use ESP8266 Shield via Hardware Serial
 * (on Mega, Leonardo, Micro...) to connect your project to Blynk.
 *
 * Note: Ensure a stable serial connection to ESP8266!
 *       Firmware version 1.0.0 (AT v0.22) or later is needed.
 *       You can change ESP baud rate. Connect to AT console and call:
 *           AT+UART_DEF=115200,8,1,0,0
 *
 * Change WiFi ssid, pass, and Blynk auth token to run :)
 * Feel free to apply it to any other example. It's simple!
 *
 **************************************************************/
//#define BLYNK_DEBUG
#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <ESP8266_HardSer.h>
#include <BlynkSimpleShieldEsp8266_HardSer.h>

#include <Wire.h>
#include <Adafruit_BMP085.h>

// Set ESP8266 Serial object
#define EspSerial Serial

ESP8266 wifi(EspSerial);
Adafruit_BMP085 bmp;

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "__BLYNK-API-KEY__";

void setup()
{
  // Set console baud rate
  //Serial.begin(9600);
  //delay(10);
  // Set ESP8266 baud rate
  EspSerial.begin(115200);
  delay(10);

  Blynk.begin(auth, wifi, "__SSID__", "__PASSWORD__");
  bmp.begin();
}

void loop()
{
  Blynk.run();
  Blynk.virtualWrite(1, bmp.readTemperature());//temp
  Blynk.virtualWrite(2, bmp.readPressure());//Pressure
}

In the Future

In the future I am planning to put it actually outside (and provide a thumbnail) and possibly improve code or switch to another platform.

Raspberry Pi PVR

Jake Walker — Sun, 26 Oct 2014 20:59:00 GMT

In this project I used a Raspberry Pi (I used a model B) with OpenELEC on the SD card, a USB TV Receiver and a cheap Indoor Ariel to create a PVR.

These instructions were done on Windows.

This is what I did: I burnt OpenELEC on the SD card. I got the OpenELEC disk image build from here and I followed the instructions to install from here. Once I was done I plugged in a monitor, keyboard and mouse into the Pi and booted it up. Once I was on the Main Menu I went to the Add-on Menu in Settings and got two add-ons: TVheadend (which I found under Get Add-ons > services) and TVheadend HTSP Client (which I found under Disabled Add-ons > PVR Clients). Once I had done that I went into the TVheadend configuration interface on my laptop which was at: http://[Pi IP]:9981. Then I went to the Configuration > TV Adapters menu. Then I selected the drop-down menu and selected my TV receiver and then I clicked the ‘Add DVB Network by Location’ button. I selected where my closest TV repeater was and clicked the 'Add DVB network’ button at the bottom of the menu. At the side there is some text. Under the 'Muxes awaiting initial scan:’ heading there is a number and I waited for it to go to 0. It took a couple of minutes. After it had finished I clicked the 'Map DVB services to channels’ button and opened the console at the bottom. After it looked like it was finished I configured the frontend. On OpenELEC I went to Settings > Live TV and checked the 'Live TV Enabled’ option.

I have added a hard drive to record to. It has a USB connection to the raspberry Pi. I have had lots of power issues but got there in the end. Also I have brought the MPEG2 codec to decode the video. I have to wait for a reply from the raspberry Pi team...