Introduction: Communicator Watch
Teeny tiny communication devices that you can pin to your chest, strap to your arm, or pop into your ear have long been a sci-fi trope. While wrist-worn "two-way radios" have mostly either been toys or the result of movie magic, we've finally reached the point where it's possible to actually build wearable technology that functions how people have envisioned for decades. Thanks to the amazing open-source hardware community, the technology to build advanced, connected devices is cheaper and easier than ever before! In this Instructable, I'll show you how I designed and built my very own communicator watch that not only keeps the time, but allows me to make and receive phone calls from my wrist!
Step 1: Reference Design
Although there are many instances of similar devices, here are the main sources from which I drew inspiration when designing the watch:
The Venture Bros.
Every mad science family needs a way to stay in touch, right? If you're part of the Venture crew, then you receive a fairly stylish and compact wristwatch communicator. The user interface for my watch is largely drawn from the Venture Bros.-style device.
Several years back, I built a big, clunky, handheld PipBoy. I still love the series and constantly draw from the depth of retro-futuristic detail the designers put into the series. The 3000 series in particular had a strong bearing on the color scheme of the watch.
Star Trek TOS
Far more futuristic than my own device, Capt. Kirk himself briefly wore a wrist communicator. The shape of the case and screen selection is drawn from this device.
Exceedingly quaint by modern consumer electronic standards, transistor radios were bleeding edge when they first became available in the 50s. I spent many hours browsing digital archives of old advertisements and auction listings to get a better feel for their design and styling.
Step 2: Parts and Materials
(2x) momentary pushbutton
(Optional) I2C current sensor
28 AWG wire
30 AWG wire
12"x12" 20 gauge aluminum sheet
(25x) M2x6 screw
(25x) M2x6 "thin" nut
Olive Montanna Gold spray paint
(4x) 3D printed case pieces (depends on the service)
Step 3: Case Design
I designed the case using Fusion 360, which is my go-to CAD software (it's free for students and hobbyists!). I made many of the design decisions based on issues that I had with the Apple II Watch, which were mostly strength related. The case itself is made out of 3D printed "ABS-Like" Objet resin reinforced with 20 gauge aluminum plates, fastened to the sides with stainless steel M2.5 screws, which pair with internal, captive nuts. I split the case into four main 3D printed components: a body, face plate, control plate, and rear cap.
The body is the largest component by far and is the most complicated. One of main issues I wanted to resolve from the Apple II Watch was the the internal mounting for components. In the Communicator Watch, the main body has recesses and protrusions for snugly holding the various electronic components. On the underside, the body has two pairs of connectors for the watch band spring pins.
The face serves as a mounting point for the main screen and provides a grill to protect the speaker. The face also has a spot for a rounded rectangular logo plate. The ridges at the top provide no structural purpose, but visually they help balance out the visual layout of the face, since the screen is quite small and I wanted to have it centered.
The control plate frames the buttons for the user interface and proves a mounting point for the rotary encoder, microphone, and power switch.
The rear plate simply caps the FONA module (the cellular component). I originally considered adding a little expansion port here to add more sensors etc., but decided to keep the design to a minimum. The non-body plates can all be independently removed, so it's still an option in the future!
Step 4: Electrical Design
The Teensy 3.1 is my go to board for microcontroller projects. They're fast (72 MHz+), inexpensive (~$20), and (by embedded standards) have oodles of memory (256K ROM, 64K SRAM). The 3.1 has a built-in RTC which makes time keeping a breeze. The only needed accessories are a 32.768 KHz crystal and a 3V battery backup to keep time.
I chose to design the interface around two momentary push buttons and a rotary encoder (with built-in switch) and a single slide SPDT switch. The slide switch directly controls power from the LiPo battery. Although I could have easily designed around just the encoder for the UI, scrolling and confirming for every single interaction takes time and can become tedious, plus I wanted to have the red and blue buttons a la the Venture Bros style communicators.
The heart of the system is a SIMCOM-800 chip, which mounted on Adafruit's FONA breakout board. Short from designing my own PCB, the FONA is one of the most compact GSM breakout boards available, which is good for keeping things slim. The FONA is basically an all-in-one cellphone module, requiring only the minimum connections of a battery, speaker, microphone, and a host controller. I opted to attach a wee vibration motor as well for additional notification goodness.
I chose to use a 1.27" 128x96 pixel OLED screen as the main display. I went with this module for many reasons: 128x96 is a 4:3 aspect ratio, which is a classic design, it draws minimal current, has razor sharp contrast, includes a microSD card slot on the back.
The system is powered by a 2000mAh LiPo battery, which is extraordinarily large for a wearable device (most are in the sub 500mAh range), but since this is essentially a cell phone, I wanted to have a realistic battery life of at least 8 hours. The battery is connected directly to the FONA module and the rest of the system is powered via a 5V step-up regulator that boosts the 3.7V source from the module's VBAT pin. The power switch is located at the front edge of the control plate.
Step 5: Watch Metal Side Plates
The side plates survived to the final design, but the main metal logo plate did not. I cut the pieces from .020" thick aluminum. I've attached the vector files for the layout above. I'm lucky enough to have access to a water-jet for quick 2D metal cutting, but the design is fairly simple, with bold rounded curves that would make it none too difficult to cut out with a band saw and a drill press. After the plates were cut, I washed, dried, and sanded them with course sand paper to give them a brushed look. I initially considered sanding them to a pristine finish, but I was very satisfied with the wear pattern of the course grit paper. The profiles for the plates are attached above.
Step 6: Wood Veneer Logo
In lieu of the original aluminum top plate, I found some scrap walnut veneer that matched very well with the olive paint-job. I quickly added a Brush Script "Communicator" logo and cut out a few pieces with a laser-cutter. I initially tested filling the etching with light paint, however it bled into the grain on the larger text. Having spent a considerable amount of time fiddling with the logo plate design, I ultimately chose a simple, un-engraved piece of veneer as the inlay and epoxied it in place.
Step 7: 3D Print the Case and Knob
The communicator watch consists of four individual 3D prints. I've attached the STL files above. I made mine on an Object Connex 500, which has fairly high resolution and support material for overhangs. I also originally designed a custom knob (the black cylindrical bit) for the encoder, but later opted for a premade aluminum one (it is still included in the STL archive though). Wall thicknesses and features are (mostly) 2.5 millimeter minimum and there are a minimum of right angles as well, so it should stand up to being printed in a variety of materials. The .STL files are attached above. (There is a file for a knob that I designed, but didn't end up using.)
Step 8: Painting
The raw 3D printed parts need to be lightly sanded before they'll take paint well. I used a course grit paper (< 500) and carefully went around attempting to scour as many of the outside surfaces as I could. After the sanding, I gave each of the pieces a coat of primer and let them dry. The next day I returned and finished the pieces with a healthy coat of olive paint for the drab American military aesthetic.
Step 9: Modify Teensy
The Teensy is normally bus-powered, but we'll need to modify it slightly to be powered externally. You'll need an box cutter or other reasonably sharp, strong, and small implement to carefully scrape away the thin trace between the VIN pin and VUSB pin. With the Teensy securely mounted, now is also a good time time to solder the tiny crystal to the underside of the board, as well as the CR1220 holder to the VBAT and GND pins.
Step 10: Soldering
Soldering the main circuit is definitely the most complicated aspect of this build. The A2W had excessively thick gauge wires, so this time around I opted to use much smaller wires. I originally planned to mostly use 30 AWG for the signal wires in the system, but it proved too fiddly (at least for my hands) so I bumped everything up to 28 AWG to connect the components together. I also went great lengths to avoid too much heat-shrink tubing, there's just not much allowance in the case to have thickened cables of wire. I only needed to solder in a unusual way for the OLED screen. I designed it to be flush to the underside of the 3D faceplate, so instead of soldering the wires through the normal pads, I simply tinned the holes and soldered the wires onto the underside of the PCB to keep the screen side perfectly flat.
Step 11: Insert Nuts
There are 20 total nuts that need to be inserted into their respective slots in the various case slots. They're quite hard to hold (at least with my large hands), so I used fine tweezers to place the nuts and tuck them down. You should paint before inserting them, as they fall out quite easily when inverted.
Step 12: Attach Strap
The spring pins pop into place on the underside of the main body plate. The strap attaches by sliding under spring pins and back through its stainless loop. Easy.
Step 13: Final Case Assembly
With the electronics soldered together, it's time to put everything in place. Each component with the exception of the battery pack has a dedicated attachment point. The nubs on the bottom of the switches mate with the holes on the front side of the body piece and so on. The encoder has a nut that secures it to the control plate. A bit of five minute epoxy secures the teensy towards the base of the watch for some added strain relief. The wires for the components are only ever so slightly longer than they need to be, so they need to be nudged in place while the caps come on.
Step 14: UI Design Making Graphics
For the most part, I used the built-in functions from the Adafruit GFX library for creating the UI graphics. I wanted to use more detailed symbols for the logo, signal strength, and battery charge so I created my own aliased, black and white symbols in photoshop. I could have added a micro SD card for graphics, but I wanted to create a monochrome UI and an SD card would have added to the overall power draw.
I used a free bit of software called LCD Assistant to convert the bitmaps into C-style hex arrays which could be used by the bitmap drawing function. If you'd like to create your own simple symbols it's quite easy as the software simply takes a bitmap and pops out a header file with the arrays. If your images are small and not to complex, I would visually scan the array for any errors. For a handful of images, LCD Assistant would occasionally insert a random bit into the top row of the image.
Here's a quick example use from Sparkfun on using the software as well.
Step 15: SIM Card Activation
Step 16: UI Design "Lock" Screen
The next few steps detail the design and operation of the watch. If you'd like to skip ahead to code, jump to step 20.
On startup, the watch does a very brief boot sequence. First, the UI color, sound, vibration, and time settings are read from EEPROM, then the OLED displays a small splash screen shows the logo while the the Teensy communicates with the FONA module. Once communication is established, the watch plays a small success chime and enters the lock screen.
The lock screen serves as the main "watch face" and displays the day of the week, time, and date (minus the year). Pressing in the encoder button serves as an enter button and will change the screen to different mode selection.
Step 17: UI Design CLK Menu
While in mode selection state, the encoder knob allows the user to cycle though the three modes. In all states outside of the lock screen, a small header will display the battery charge, time, and cellular signal strength. The "<" and ">" symbols show that the user has a scrolling option (left or right or up or down depending on context) and the "[" and "]" symbols denote that a setting has been previously confirmed. Pressing the red button at anytime resets the scroll counter position to zero. Pressing the blue button at anytime returns the user to the previous menu state. For example, in mode selection state, blue returns the user to the lock screen. Only pressing the encoder button will confirm and save a setting.
The first selectable mode is related to time functions. The user can set the watch to be 12 or 24 hour time, set the hour, minute, month, day, and year. Setting any time function automatically sets seconds (not visible in any UI) to zero. Although the year is not displayed outside of the clock settings mode, it is necessary for internally calculating the current day of the week.
Step 18: UI Design COM Menu
The second mode allows the user to actually dial out. Numbers and symbols can be selected by scrolling and confirmed with a press of the encoder. I was concerned this would be quite slow at first, but it's actually quite easy and even more comfortable and fast to dial out while the watch is worn than to palm the device.
The watch asynchronously checks for incoming calls every second. If an incoming call occurs, the watch will leave whatever mode is currently active, (if enabled) ring and vibrate, and display the incoming call number (INCOMING CALL FROM ### - ####). In this context, the red button will cancel the incoming call. If the user decides to answer (by pressing the encoder button), then the screen will say "ON CALL WITH #######." While on call, scrolling will automatically adjust the volume.
Step 19: UI Design SYS Menu
The third and final mode shows system information and allows a few settings to be changed. This screen shows the actual battery percentage (the symbol only represents 20% chunks) and the signal strength. The user can scroll to select the notification behavior of incoming calls, the default volume percentage, and the current UI color. Scrolling through the UI colors is the only time two colors will be shown at once. If a new UI is chosen, the screen will immediately update, as well as save this to EEPROM for restoring the settings.
Step 20: Programming
The watch runs a single Arduino style sketch that I compiled and ran with IDE 1.6.5 and Teensyduino 1.2.4. I've attached the necessary libraries and code. I extended the FONA software to include a few extra functions that report the status of the GSM module and setting the ringtone, so if you already have the FONA library, you'll need to replace it with the one attached for everything to compile.
Step 21: FAQ
How much did this cost to make?
$250 total +$9 monthly
What is it made out of?
3D-printed Objet "ABS-like" resin, aluminum, walnut, stainless steel, leather
What are the tech specs?
72 MHz ARM processor with 256K ROM 64K RAM
1.27" OLED 128 x 96 pixel screen with 16-bit color
7.4 watt-hour battery (2000 mAh single cell Lithium-Ion Polymer)
Weight: 7.4 oz (210 g)
Dimensions: 3" (75 mm) W x 2" (51 mm) H and .65" (16.8 mm) thick
What does it do?
Dial and receive cell phone calls. Set and retrieve the time and date.
Are you selling these?
No, but you can make your own :)
How long did this take you to make?
Six weeks of design and prototyping. Approximately three days of actual assembly.