As most people already know about me, I love making things with wood. I am a software engineer by profession and I love tinkering with hardware and wood as a hobby. As fun as it is to do my day to day job and spend time on my hobbies, to me it’s a whole lot more appealing whenever I get to combine hobbies and profession. So a few weeks ago, I had picked up a Raspberry Pi 4 for a smart home hub I wanted to build. One thing led to another and I ended up installing RetroPie in that Pi instead. From that point on, it was open season for ideas to flow through my head and, lo and behold, I ended up ordering a set of arcade game controllers and boards on Amazon.

Approximately 4 weeks later, I have a cool wooden case where I can play almost any retro game I want.

The Plan

While this blog post is NOT a tutorial on how to build this console, I think there’s still value in mentioning how I approached this build so someone else can take ideas and may choose to build on that idea themselves.

After receiving the controllers and making a poor man’s version of a proof of concept, I took out my notebook and sketched up a design based on small box I had made late last year. The original design of that box was inspired by Matt Kenney who is quite well known in the woodworking community.

There are many types of wood I could choose from to do this, but in the end, I went with Cherry sides and Walnut top and bottom because I liked how it looked and these species of hardwood are slightly lighter than something like Maple or White Oak – either of which also would’ve looked great to be honest. I didn’t want the box to show any of the end grains, which ruled out finger joints or dovetails or even butt joints. I went with something that’s relatively straight forward – mitered four sides and cut grooves to allow for the bottom and top boards to fit snugly together.

As far as where the circuitries go, I had to make a judgment call on whether to use the chamber at the bottom or the lid. In the end, given how I needed to have space for the joy stick handles, I decided to put the Raspberry Pi, LCD Panel Controller Board, Voltage regulator and the speakers on a special housing in the lid.

Internals

This gaming console is based on a Raspberry Pi 4B with 2GB RAM. I used a RetroPie image and followed instructions from here. For the LCD Panel, I used an old Lenovo monitor I had laying around in the house. Here’s the full list of items I used to make this. Most of these links are Amazon Affiliate links, so if you use these links to purchase any of the italicized items listed below, I will get a tiny percentage of that sale without any cost to you 🙂

• Cherry boards (dimensioned to about 1/2 inch thickness)
• Walnut Boards (dimensioned to about 1/2 inch thickness)
• Raspberry Pi 4B 2GB
• Arcade Console Controllers
• Crazy Horse Leather
• Brass Knurled Thumb Screws
• Brass Hinges
• Brass Lid Stays
• DIY Speaker/Volume Kit
• 1/2″ PET Expandable Braided Cable Sleeving
• 32GB Micro SD Memory Card
• Buck Voltage Converter
• Heat Sinks for Raspberry Pi
• Small Rubber Round Feet
• Lenovo LI2264d Monitor

ROMS

For downloading ROMs of desire, I shamelessly followed detailed instructions provided here. Nothing much to add here besides a word of advice. The only MAME game I was able to successfully play was Cadillacs and Dragons. Most MAME games have interdependencies on each other, so unless you acquire the full set of MAME games, chances are, most of them will not work.

Final Product

Two years ago, I’d worked on implementing a Physical Kanban board with a coworker that allowed users to maintain a physical board for kanban sprints and once an image is taken of the board and uploaded, our application would run image recognition (using Google Vision API) on the image and translate all the tasks written in post-it notes to tickets in Trello board on their respective board columns. These tickets could be worked on after the fact to have more details and a later instance of the image capture would retain all additional information or delete the ticket if the ticket is closed or removed from the physical board.

While the Physical Kanban project and the other projects I’d worked on during hackathons thus far were exclusively software applications, this year, I’d decided to go for a project that involved making my own hardware and the software to make it all work.

But I did not want to build something for the sake of just building. I actually had a real problem at hand and with the ideas of some close friends, found the right solution to my problem.

The Problem

At EAI Technologies, we keep track of our time through Harvest application and in the best of days and circumstances, it is a hard task for me to keep track of time with it. This is where a physical device to start and stop a timer, that would be integrated with Harvest API, would be so much easier for me to visually keep track of time spent in different projects. So as far as that problem goes, Tickery would be the perfect device to solve the problem.

The Solution

As with Physical Kanban project, human beings are more attentive to physical interaction than keeping up with software applications. So while the intangible world of software keeps us connected, it could easily be lost on us to keep up with mundane tasks such as time keeping. Enter Tickery. The goal of this device is to start and stop timer for various projects (mutually exclusively) as you see fit. This could be beneficial for developers such as myself or for project managers or even product people to keep track of their project hours for future analytics or just simply maintaining timesheets (if applicable to them).

Tickery (Final Product)

The general plan for the device was to be a polyhedron shape where flipping on each side would trigger a timer to start. There would be neutral position which would trigger all timers to stop. I also wanted a display on the top that, when flipped to one of the sides, would display the name of the project/task that it started tracking. The orientation of the display needed to based on which side it was flipped on and the color of the screen should reflect the color each side is marked with. I wanted a case that would fit all the hardware – and went against my usual tendency to make something out of wood. I opted for transparency (literally) such that it would showcase the inner parts of the device – and the Container Store had just the thing staring back at me from one of the shelve racks – an acrylic Baseball display cube. With a little bit of drilling, this became the perfect case for the job.

Hardware

For this project, I’d decided to go with a Raspberry Pi Zero W that has builtin Wifi and Bluetooth support and a Raspberry Pi Sense HAT that comes with bunch of sensors, joystick, and an 8×8 LED Matrix display. Sense hat has extensive libraries and jam packed hardware features that I could take advantage of and even expand functionalities on in the future if I wanted to (like triggering e-emergency alerts for fire emergency, and so on). I’m using the joystick (although not made accessible from outside the case) to show which project the timer is active for and to do a safe shutdown of the pi if needed so that I don’t end up corrupting the SD card with having to pull the plug on the pi every time I need to turn off the device (or having to SSH in to the box and turning it off that way first).

Powering the device

To power the Pi and the Sense Hat, I used a 1200mAh 3.7v Lipo battery. The pi and the Sense Hat actually needs 5v input, so I used a voltage regulator that takes in 3.7v and delivers a constant 5V output and also does a clean shutdown of the Pi if the voltage falls below a certain threshold. This is where the Pimoroni Zero Lipo circuit shim came in to play. The only thing I do not like about the Zero Lipo, however is that you actually need a separate circuit to charge the Lipo battery. For that purpose, I used Adafruit’s Micro USB Lipo battery charger, a small device that is capable of accepting 5V input and charge the 3.7v Lipo battery while delivering the same 3.7v out for consumption at the same time as charging the battery.

So along with the capability to charge the Pi over micro USB, I also wanted to power the device wirelessly using a Qi charger. This was made possible with Adafruit’s Wireless Qi Receiver which I am pretty excited about. The Qi receiver delivers 5V output at 500mA and paired with the Lipo Zero, battery and charger, the Pi is capable of running on its own completely wireless for a long time.

Components Used

• computer Raspberry Pi Zero W ($5)
• battery_charging_full Adafruit Wireless Qi Receiver ($15)
• battery_charging_full Pimoroni Zero Lipo ($12)
• sd_card 4GB SD Card ($3)
• screen_rotation Raspberry Pi Sense Hat ($30)
• battery_charging_full 1200mAh 3.7v Lipo Battery ($10)
• crop_square Baseball Display Cube ($4)
• battery_charging_full Adafruit Micro USB Lipo Charger ($7)

Features

• wifi WiFi
• bluetooth Bluetooth
• battery_charging_full Wireless Qi Charging
• screen_rotation 9 DOF IMU Sensor
• battery_full 7h Battery life
• tv 8×8 LED Display

Software

At the heart of the device is a python script that I run that pulls in the project mappings for each side of the tickery device that constantly monitors the Sense HAT’s IMU sensors to sense the orientation of the device. This python script can be found at my GitHub here.

As for the Restful services to keep track of the project mapping for each side of the Tickery device, I’d created a simple Spring Boot based application that uses elasticsearch as the data storage. I’ve used a docker container to run the elasticsearch instance, but you could easily use a hosted service or even a local instance if you so desire. You can follow my tutorial on a similar project from here Spring Boot Starter App with Elasticsearch.

The UI I built was a very basic Angular app that allowed me to map each of the four sides to one of the project assignments I have in Harvest. Details on using Harvest API can be found here. For this, I needed a personal access token from Harvest, which could be created here.

Additional Features

One of the features that I was able to implement last minute was a proximity based start/stop trigger for currently active timer. For this feature I have the bluetooth address of my phone being searched for over bluetooth while at least one timer is active. If this feature is turned on, then the active timer would be stopped if, let’s say, I walk out to grab lunch and would resume the active timer if I’m back to my desk. This reduces the complexity of having to worry about leaving behind the device when I’m going leaving for home or just the work premises in general. This feature can be turned off as one wishes, but for me, this is a perfect feature that I see forgetful self leveraging quite heavily :). If I’m working from home and I leave the device on an active side, I can simply turn off the feature through the web portal.

Future Features

The Sense Hat has a bunch of sensors that I did not take advantage of for the hackathon project, but it is totally feasible to take advantage of the temperature and humidity sensor to trigger fire alarm if temperature sensor picks up an alarmingly high temperature calling. This could conceivably be done using SingleWire API or Ring API for instance. I haven’t done much research on this area but something I look forward to doing in the future.

On our first anniversary, my wife gifted me a Fitbit Versa smart watch and I’d been playing around with Fitbit Studio. While the Fitbit app gallery is far from mature, to my pleasant surprise, I’ve found the Fitbit developer studio very intuitive and easy to work with. Their SDK is also fairly well documented with some basic code examples (albeit not comprehensive by any means) to get anyone up and running to build their first app or clock face.

One of the first app I wanted to install on my versa was an app to control my smart home devices. I use Wink Hub to control a few of such devices and to my dismay, there wasn’t any wink app that let me control individual devices. There is an unoffical Wink Scenes app that only lets you control predefined wink Scenes but nothing that lets you control individual devices. Enter Fitbit SDK and Wink API. I’ve already played around with Wink API, so there was no learning curve there. Fitbit SDK was also pretty straight forward and after spending a few hours playing around in Fitbit Studio, I had my app up and running.

Fitbit does a good job at explaining their app architecture here, but the gist is that Fitbit apps are broken down in four main sections.

• app is the application folder containing JavaScript logic which executes on the Fitbit Device giving access to device sensor APIs.
• companion is the folder that contains JavaScript logic that executes on the mobile phones giving app access to internet, GPS location and such.
• settings is the folder containing JSX files that’s configurable by user.
• common is the folder containing shared code usable by other folders.
• resources contains all the static assets and SVG files that drives the GUI in the device.

Currently using OAuth, user can sign in to their Wink account through the Fitbit App and use this app to control all smart bulbs. Once the user is logged in, user is taken to the list of smart bulbs they have.

If there are no smart bulbs to control, a message is shown to notify the user that there are no devices to control using the app and suggested user to add smart devices before using this app.

If, however, there are smart bulbs, they would be listed in alphabetical order in a scrollable list and there is a refresh button on the right top corner to fetch the latest states. This UI only shows if the device is ON (blue color) or OFF (grayed out). In addition there is a refresh button on the right top corner of the screen allowing user to fetch the latest device updates, should the states of such devices be changed outside of this app.

Once user clicks on a device, they are given the option to change brightness. The slider at the top of the screen allows user to drag and move the slider bar allowing users to change the brightness of the bulb. Initial position of the slider bar represents the last reading of the bulb (regardless of state of device power). Changing brightness will turn bulb on regardless of its original state. The user is also given the option to turn the device ON / OFF depending on initial state and the option to leave the page. If the brightness had already been altered before hitting cancel, change in state will be persisted.

And that sums up my first Fitbit app. I don’t have any immediate plans to publish this app to the Fitbit App Gallery. Will be doing a few more improvements before considering to submit to the app gallery. But meanwhile, source code can be made available upon request :).

Future Improvements

• Currently the app only lists wink smart bulbs. This can be extended to show any devices and sensors that can be represented with on/off values and/or range values.
• Future improvements could also include more icons for various device types and represent on/off state from the listing screen.
• Currently the app does not warn about lack of internet access permission. This could be improved to show appropriate messages.
• Long names are currently truncated with ellipsis. This can be improved to show a text marquee instead only for the long names.

Update (03/21/2019)

I’ve submitted the app to Fitbit App Gallery. While in pending review state, you can download and use the app from this private link https://gam.fitbit.com/gallery/app/08553b35-8751-46b7-94f0-6b7387a36ffd

Update (03/30/2019)

The app has been accepted by Fitbit and is now available to users through Fitbit App Gallery

This weekend, my roommate and I put a Raspberry Pi Zero W in Lego 42000 Grand Prix Racer. Sadly, we had to remove the signature piston engine to fit an actual Lego motor, but the outcome was quite satisfactory.

Items used:

• Lego 42000
• Power Functions 8293
• Raspberry Pi Zero W
• Jackery Bar Pocket-sized 6000mAh Ultra Compact Portable Charger
• Adafruit DC & Stepper Motor HAT for Raspberry Pi – Mini Kit
• Miscellaneous lego pieces to fit motor to steering wheel
• 30RPM Geared DC Motor
• 8Bitdo NES30 Bluetooth Controller

http://solarsystem.nasa.gov/kids/index.cfm?Filename=papermodels

On a related note, if you’re interested in building a paper model (or other types) of Hubble space telescope, you will find  this following link useful:

http://hubblesite.org/the_telescope/hand-held_hubble/