Here’s a video of the fully functioning chess board in action.
Here’s a video of the fully functioning chess board in action.
Information is pretty scarce on getting these up and running, so I hope this quick guide might help to clarify the process for others.
First, you want to expand the filesystem. Launch raspi-config:
Go to Advanced -> Expand filesystem
Now you’ll need a copy of the driver. Download it here.
cd Downloads && tar xvf LCD-show-*.tar.gz cd LCD-show/ chmod +x LCD35-show ./LCD35-show
This installs the driver and also makes the LCD screen the default choice.
This means your HDMI screen will not display your desktop any longer on boot.
To make HDMI the default choice again, cd to your LCD-show folder and run the following:
Naturally you can run the following again to switch back to the screen.
This is a very brief guide to putting QMK on your GH60 Satan, in a linux environment. There are many ways to do this, but this way works for me. It’s a very similar process for Mac.
There are two parts to this:
First grab the source from GitHub:
git clone https://github.com/kairyu/tkg-toolkit
Now go to the linux folder and make the setup.sh and reflash.sh files executable:
cd tkg-toolkit/linux && ./setup.sh
The setup script will now prompt you to configure various parameters.
For a Satan GH60, you want:
Now tkg-toolkit is setup.
First, go ahead and download QMK:
git clone https://github.com/qmk/qmk_firmware.git
I’m not going to cover editing your keymap.c or other QMK files as that’s beyond the scope of this tutorial, but for now we’ll assume that you’ve edited and saved all the relevant files within your keyboard’s keymap directory.
Now we get to build that sweet, sweet hex file!
Make sure you’re in the same directory as your keymap.c file for this next command:
If your code checks out, you should see lots of green messages :)))
Now we have to run tkg-toolkit to flash the board with our freshly built hex file. First, go to the directory where the ./reflash.sh script resides:
Time to flash! We need to provide tkg with the path to the hex file that you just built. For some reason, qmk places the hex file in it’s root directory by default, instead of the specific keyboard directory.
tkg-toolkit will give you a brief Y/n prompt, then you can press the button on the bottom of your Satan and let the magic happen. Now enjoy your newly flashed keyboard!
To automate the flashing process, I made a small bash script which I placed in /bin (so it can be called from any directory). To do the same, place the following in /bin/flash, and simply type flash to do just that. Obviously you’ll need to replace “ben” with the name of your keymap.
#! /bin/bash cd ~/qmk_firmware/keyboards/satan/keymaps/ben sudo make cd ~/tkg-toolkit/linux echo "Y" | ./reflash.sh ~/qmk_firmware/satan_ben.hex
Hope this tutorial was helpful in some way. Feel free to drop any questions my way.
This is something I’ve wanted to do for a while but never got round to. I was initially going to design my own PCB, but sadly A level exams are a thing, and I just wanted a quick project.
Switches and LEDs fitted to plate and soldered to PCB
The keycaps are a custom set I designed and MaxKeyboards sent over from the US. The case is CNC’ed aluminium that’s been anodized. It cost a bit more than a plastic case but I’m glad I paid the extra as it adds a nice weight.
I tried inverting the spacebar and liked it so much that the Alts got the same treatment.
I flashed it with the QMK firmware, and modifying the layouts and layers is an ongoing thing. Holding spacebar is my main alternate layer, which gives me arrows, media keys and PgUp/Dn on the home row. I’m also playing around with some mouse functionality when Caps is held.
Recently I was given an old iPod dock for parts. Since I had some spare 3″ speaker drivers lying about, I decided to salvage the circuitry from the dock and make a portable speaker.
First, I had to make an enclosure. I used some scrap oak floorboards that I found in our shed, along with some pine for the front face.
I routed a step into the top of the sides, and joined them with a simple mitre. Then I cut and chamfered the speaker holes from the front face.
Next, I salvaged the amplifier PCB. It was the only part I needed from the iPod dock since the speaker drivers were cheap and very tinny. I added a bluetooth module, a battery management board, boost converter and a pair of Li-ion 18650s in parallel before testing the electronics.
Everything worked great, apart from the fact that I wanted to use a latching switch for power and a potentiometer to control the volume. This was a problem since the amplifier’s only controls were 3 momentary push buttons for power, volume up and volume down. Since the power button would only work when it was pushed and released, I had to come up with a way to simulate that happening, whilst using a latching power switch. In the end I used a relay, resistor and capacitor to create a circuit which simulated pressing the power button for half a second, then releasing it, then holding down the volume up button. This allowed me to control the volume of the amplifier by using a potentiometer at line level on the input.
When first turned on, the relay closes the power switch until the capacitor charges up. When it is charged, the power switch is opened and the volume up switch is closed. When the power is switched off, the capacitor discharges through a bleed resistor.
The electronics assembly inside are rather messy, and use copious amounts of hot glue, but it does the job.
The back has switchable inputs between a standard 3.5mm jack and a bluetooth module. There’s also a micro USB charging jack.
Overall, I’m fairly pleased with how it turned out. The woodwork is pretty scrappy and could definitely be better, but it sounds pretty good 🙂
My latest project is building a small, fast, 250-class quadcopter. Since it’s designed to be light and agile, keeping weight down is an essential part of the build. A lot of the total weight (~1/4) of the quad comes from the battery, so choosing the right size is a major decision.
I decided to model the flight time that different batteries would provide, based on their
Since the current drawn by the motors would be directly determined by the weight of the quad, I needed to find how much current my motors would pull for a given amount of thrust.
Of course, this is not a linear relationship, so I used a thrust table for the motors I am using to plot some points in GeoGebra, then created a quadratic function to fit them.
Next, I made a spreadsheet which takes a weight and capacity of a given battery, and calculated the flight time. It is available to view here.
The gist is:
I will be interested to compare the predicted times with my actual flight times once I’ve finished the build.
I spent a while researching in late 2015, got some parts for Christmas, and have been building since. As you can see from the costings graph above, my main expense was the RC transmitter, as I decided to go for one that supports telemetry. For a flight controller, the Arducopter project appealed to me as it uses completely open source software and hardware, so I can customise/hack any part of it I like. I chose an S500 frame as it’s suitable for aerial photography but not too large, and it comes with a PDB (Power Distribution Board), which makes cable management a lot easier.
It had its maiden flight today, and now that it’s working in its most basic form I’m looking forward to adding a camera, and having a fiddle with the source code 🙂
Lately I used an Arduino Leonardo’s native USB communications to make a control panel for my computer.
It can open applications; cut, copy and paste text; switch and close windows; run a demo; as well as turn off the computer.