[Nick Ames]’s Flexible Smartwatch project aims to create an Open Source smartwatch made out of a flexible, capacitive e-ink touchscreen that uses the whole surface of the band. This wraparound smartwatch displays information from the on-board pulse and blood oximetry sensor as well as the accelerometer and magnetometer, giving you a clear idea of how stressed you are about your upcoming meeting.
The display [Nick] went with is called an electrophoretic display (EPD). It’s 400×200-pixels at 115ppi with a 4″ diagonal, and can bend around a wrist. It can draw shapes in 16 shades of gray with a refresh time of under a second or B&W with a faster refresh.
The smartwatch described in [Nick]’s project would be 2.5mm thick — certainly thin enough to fit under a sleeve. We suspect that success of the form factor may hinge on [Nick]’s success in making it not look like a hospital wristband. Although this gives us the thought that a biofeedback-sensing smart wristband is probably the future of hospital stays.
E-ink displays are awesome. Humans spent centuries reading non-backlit devices, and frankly it’s a lot easier on the eyes. But have you looked into driving one of these critters yourself? It’s a nightmare. So chapeau! to [Julien] for his FPGA-based implementation that not only uses our favorite open-source FPGA toolchain, and serves as an open reference implementation for anyone else who’s interested.
Getting just black and white on an E-ink display is relatively easy — just hit the ink pixels with the same signal over and over until they give up. Greyscale is made by applying much more nuanced voltages because the pixels are somewhat state-dependent. If the desired endpoint is a 50% grey, for instance, you’d hit it with a different pulse train if the pixel were now white versus if it were now black. (Ever notice that your e-book screen periodically does a white-black flash? It’s resetting all the pixels to a known state.) And that’s not even taking into account the hassles with the various crazy voltages that E-ink displays require, which [Julien] wisely handed off to a dedicated chip.
In the end, the device has to make 20-50 passes through the screen for one user-visible refresh. [Julien] found that the usual microcontrollers just weren’t capable of the speed that he wanted, hence the FPGA and custom waveform tables. We’ve seen E-ink hacks before, and [Julien] is standing on the shoulders of giants, most notably those of [Petteri Aimonen] and [Sprite_tm]. [Julien]’s hack has the fastest updates we’ve ever seen.
We still can’t wait for the day that there is a general-purpose E-ink driver chip out there for pennies, because nearly every project we make with a backlit display would look better, and chew through the batteries slower, with E-ink. In the meantime, [Julien]’s FPGA implementation is pretty close, and it’s fully open.
Modern displays are fascinating little things. In particular, the E-Ink displays employed in modern E-books achieve mesmerising paper like contrast with excellent standby power consumption. Many of us at some point have had a go at experimenting with DIY displays, but been discouraged by the miniature scales involved. Driving them is hard enough, but building your own?
[MChel] has achieved some excellent success in building a simple E-Ink display. The account presented on this Russian electronics forum, graciously translated for us by Google Translate, outlines that the greatest barrier to pursing this in your home lab is creating the conductive layer that serve as electrodes for each pixel and depositing the thin layer of electrostatically charged ink pellets onto another transparent yet conductive film. [MChel] solution was to extract a small a portion of pre-deposited ink from a smashed and notoriously brittle E-ink display. Next, instead of attempting to build an ambitious and dense grid of electrodes, [MChel] etched a simple battery indicator on a PCB. The ink and the electrodes were then fused with some DIY graphite based conductive glue and sealed with some careful yet ingenuitive epoxy laying skills.
The result is a working battery indicator that consumes no power, whilst reporting any remaining power.
There is something increasingly defiant and laudable about home-brewing technologies, otherwise thought to be confined to multi-million dollar factories. We have already covered how you should go about making some conductive glass and using it in your homemade LCD.
[David] created a great looking e-ink WiFi display project that works a little like a network-connected picture frame with a few improvements over other similar projects. With the help of an ESP8266 it boots up, grabs an 800×600 image over the network, updates the screen, then goes back to sleep. Thanks to some reverse engineering, he was able to make his own firmware for the onboard controller to handle the low-level driving of the display. Since e-ink displays require no power to hold an image and the rest of the unit spends most of the time either asleep or off, power use is extremely low. [David] hopes to go months without needing to recharge the internal lithium-polymer battery.
We previously featured another WiFi-connected e-ink display project that was in fact also the inspiration for this version. [David] uses a 4.3″ 800×600 GDE043A e-ink display and wrote his own firmware for the STM32F103ZE ARM CortexM3 SoC used as a display controller, a process that required some reverse engineering but was aided by the manufacturer providing a closed-source driver for him to use. [David] writes that some reverse-engineering work for this display had already been done, but he had such a hard time getting a clear understanding from it that he reverse engineered the firmware anyway and used the documents mainly for validation and guidance.
As a result, [David] was able to make use of the low-level driver electronics already present on the board instead of having to make and interface his own. E-ink displays have some unusual driving requirements which include generating relatively high positive and negative voltages, and rapidly switching them when updating the display. Taking advantage of the board’s existing low-level driver electronics was a big benefit.
The ESP8266 rounds out the project by taking care of periodically booting things up, connecting to the wireless network and downloading an image, feeding the image data to the STM32 to update the display, then disconnecting power from all non-essential electronics and going back to sleep. We especially like how the unit automatically creates a WiFi access point to allow easy (re)configuring.
There’s one more nice touch. [David] goes the extra mile with server software (in the form of PHP scripts) to design screens for the display with data like weather forecasts, stock prices, and exchange rates. Check it out in the project’s github repository.
Tablet computers have come a long way, long way. It finally seems like they’ve found their niche in the market, and now maybe they can catch up to more traditional computers. The Microsoft Applied Sciences division came up with a cool prototype design for a new tablet, one with a secondary e-ink input display.
The tablet interface makes use of e-ink strip above the keyboard. While it might not seem like much, this frees up a bunch of screen real estate, allowing you to have various icons and shortcuts off screen. It makes a ton of sense for digital artists as they can draw on the screen, but also have their toolkit open right below them — almost like real painting/drawing.
One of the other great uses for something like this is a signature pad — with everything going digital, when is the last time you had to print, sign, and scan a document back to someone? They even developed a dedicated email app you can use solely on the e-ink screen, allowing you to maximize the use of your main screen for something like a video chat.
The demo is pretty cool, and we often wonder why there aren’t more phones with e-ink displays integrated into them — is this just the beginning?
Cellphones! Cellphone cases! Now that Radio Shack is kaput we need to pick up the slack!
A company named Oaxis has been making cell phone cases for a while now, and they’ve recently rolled out something rather interesting – a cell phone case with an e-ink screen. It’s an interesting idea and [Anton] did a teardown on two new releases. The first one just sends an image to an e-ink screen, and on paper, that’s all the second one does as well. There’s something special hidden under the hood, though: a low-end Android system. What an age to live in.
Something interesting happened when [Anton] was futzing with the battery for the e-ink iPhone case. Somehow, the device booted into recovery mode. Android recovery mode. Yes, iPhone cases now run Android.
Inside the e-ink iPhone case, [Anton] found a board with a Rockchip RK2818 SoC. This is the same chip that can be found in cheap Android cell phones. There’s only one button on the cell phone case, and connectivity is only provided by Bluetooth LE, but the possibilities for modding a cell phone case are extremely interesting.
The Kobo e-reader has been hacked for a while now. It’s pretty easy to enable telnet access by modifying some files. Once [Kevin] was able to telnet into the device and draw to the display, he created the Kobo Wifi Weather Forecast. This hack was inspired by the Kindle weather display that we discussed in the past, but this version runs entirely on the Kobo.
The weather report software is written in Python using the pygame library. After loading the software package onto a Kobo, a few commands are run over telnet to set up Python and run the display. Since Python and pygame run on the Kobo, it allows for direct access to the e-ink display.
There’s a lot of possibilities for a internet connected e-ink device running custom graphics code. It’s asking to be turned into any kind of display you can imagine. What ideas do you have for a custom e-ink display? Let us know in the comments.