The txtr beagle was designed to be a stripped-down and simplified eReader⁰.

As far as I can tell, it never shipped. There were a few review units sent out but I can't find any evidence of consumers getting their hands on one. Also, that £8 price was the subsidised price when purchased with a mobile contract. Their website ceased working long ago.

But it got me intrigued. Moore's law is supposed to drive down the cost of electronics. So where are all the dirt-cheap eReaders?

The cheapest Kindle for sale on Amazon UK right now is about £100. Back in 2012, it was about £70. Taking inflation into account, that price has stayed static. Brands like Kobo are also in the £100 to £150 range.

About the cheapest retail eReader is the PocketBook Lux 4 for £85 or the (terribly reviewed) Woxter Scriba for £70.

AliExpress has loads of second-hand and obsolete models at cheap-ish prices. But a surprising dearth of new eReaders.

Going wholesale, Alibaba has a range of models, some of which clock in at around £30.

But, of course, that's before shipping and tax. They won't come with any manufacturer's warranty and don't expect any software updates. Also, good luck getting accessories!

So what's stopping new eReaders being released at a cheap(er) price? I think it comes down to four main things.

Reading is a niche hobby

Around 40% of UK adults didn't read a single book last year. That survey combines reading books and listening to audiobooks. Of the 60% who do read/listen, about 14% primarily listen. Of those that read, around 60% do so on paper books.

If reading is niche, reading electronically is a tiny niche! This is somewhat of a chicken-and-egg argument. If an eReader were the same cost as a mass-market paperback, I'm sure many more paper-book readers would become converts.

The whole point of an eInk reader is that it is a distraction-free environment. Yeah, you could scroll TikTok on one, but it isn't a pleasant experience. An eReader is designed for one thing only, unlike a phone or tablet. Do enough people want to carry yet-another-bloody-device just for reading?

eInk is expensive

The company which makes eInk hold several patents on the process. They're not a patent troll; they're building a business and selling mega-hectares of the stuff. Understandably, they have an interest in keeping prices high. They don't want to cannibalise their own market.

A basic 6 inch screen with wiring costs around £20 wholesale - that's from Alibaba, so doesn't include tax and shipping. That's before you've added any electronics or a operating system.

Speaking of which…

Android is a bottleneck

The promise of the Android Open Source Project was a free Operating System for anyone to use. The reality has been a little different. Most people want to be able to use basic Android functionality - like download operating system updates or reading apps. But Google doesn't allow that for eInk devices.

As I understand it, Google requires Android devices to have colour screens and, so I've read, won't certify eInk eReaders for newer versions of Android.

So manufacturers have to source parts which have drivers for older versions of Android. Or they have to develop their own OSes.

Books are fungible

Back when Apple sold iPods, they knew that the majority of purchasers would buy MP3s direct from Apple. The perfect symbiotic relationship! But the walled-gardens cracked and now people can buy their music from anywhere.

Amazon keeps this model for its eBooks. Unless you're prepared to get technical, you can only read Amazon books on your Amazon Kindle paid for with your Amazon wallet.

Games consoles are often sold at a loss because the manufacturer knows they'll make it up in game sales and subscriptions.

A low-price manufacturer is unlikely to also run a book store and wouldn't be able to cross-subsidise their hardware with content sales.

Alternatives

Some people have tried building open source eReaders but they're either abandoned, not suitable for production, or ridiculously expensive.

Buying second hand is relatively cheap - often under £50. But eInk screens can be brittle, and older ones may have scratches or cracks which are effectively unrepairable.

How cheap is cheap?

I'd love a £8 eReader. Something I could throw in a pocket and not worry about damaging. An eReader which was the same price as a hardback book - around £20 - would be amazing.

But I don't think we'll get there soon. The monopoly on screen technologies sets a retail floor of around £30, before the rest of the hardware is taken into account. Niche hardware is viable - but only with decent OS support. Other than Kobo and Amazon, no book retailer wants to stray outside their core competency to develop and subsidise hardware.

So I guess it's buy second-hand, or wait for the patents to expire.

Here's a quick video and then a walk-through of its features.

You can also view SmartDisplayer's official video.

The Badge

It is a single block of plastic. There are no seams, screws, or rough edges. The ePaper appear right on the surface of the badge, there's no recessing or anything to indicate that this is a high-tech gadget. It uses their "cold lamination" technology which creates an impeccable matt finish.

The display area is 56.4mm x 84.6mm - which is pretty close to the size of a standard credit card - for a resolution of 180PPI.

The eInk

This uses E-Ink Spectra 6 technology. With only 6 colours to play about with there's a lot of dithering needed to make a picture look presentable. Those 6 colours are:

• #000 Black
• #F00 Red
• #0F0 Green
• #00F Blue
• #FF0 Yellow
• #FFF White

I used a standard Monitor Calibration Image, dithered it using the supplied software, and flashed it to the card. I then scanned in the card so you can see exactly how faithful the image reproduction is.

On the left, the eInk. On the right, the original image.

That's pretty bloody good!

Using Bruce Lindbloom's RGB Reference image is also a good way to test a range of colours.

Not bad for red, green, blue, yellow, white, black, eh?

It's hard to find a good test-card with a variety of skin-tones (there's a creepy Getty one with naked women), so I used the Murideo Portrait Reference Photograph. The original:

On eInk:

And here's another one:

The Card Writer

For Linux nerds, the USB writer showed up as: 1fc9:0102 NXP Semiconductors IT-102MU Reader.

There's almost no information about it other than a brief discussion on an OpenBSD mailing list, and a mention on the CCID database. Apparently it will work as on ChromeOS. It makes a hideous beeping sound when the card is inserted.

Once the card is inserted, two LEDs light up.

The green one quickly vanishes, but the blue one pulses until the card is removed from the reader.

Bus 005 Device 084: ID 1fc9:0102 NXP Semiconductors IT-102MU Reader
Device Descriptor:
  bLength                18
  bDescriptorType         1
  bcdUSB               2.00
  bDeviceClass            0 
  bDeviceSubClass         0 
  bDeviceProtocol         0 
  bMaxPacketSize0        64
  idVendor           0x1fc9 NXP Semiconductors
  idProduct          0x0102 
  bcdDevice            1.12
  iManufacturer           1 InfoThink
  iProduct                2 IT-102MU Reader
  iSerial                 3 1.00
  bNumConfigurations      1
  Configuration Descriptor:
    bLength                 9
    bDescriptorType         2
    wTotalLength       0x005d
    bNumInterfaces          1
    bConfigurationValue     1
    iConfiguration          0 
    bmAttributes         0x80
      (Bus Powered)
    MaxPower              500mA
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        0
      bAlternateSetting       0
      bNumEndpoints           3
      bInterfaceClass        11 Chip/SmartCard
      bInterfaceSubClass      0 
      bInterfaceProtocol      0 
      iInterface              0 
      ChipCard Interface Descriptor:
        bLength                54
        bDescriptorType        33
        bcdCCID              1.10  (Warning: Only accurate for version 1.0)
        nMaxSlotIndex           0
        bVoltageSupport         7  5.0V 3.0V 1.8V 
        dwProtocols             3  T=0 T=1
        dwDefaultClock       3685
        dwMaxiumumClock     14320
        bNumClockSupported      0
        dwDataRate           9909 bps
        dwMaxDataRate      848000 bps
        bNumDataRatesSupp.      0
        dwMaxIFSD             254
        dwSyncProtocols  00000000 
        dwMechanical     00000000 
        dwFeatures       000404BE
          Auto configuration based on ATR
          Auto activation on insert
          Auto voltage selection
          Auto clock change
          Auto baud rate change
          Auto PPS made by CCID
          Auto IFSD exchange
          Short and extended APDU level exchange
        dwMaxCCIDMsgLen       271
        bClassGetResponse    echo
        bClassEnvelope       echo
        wlcdLayout           none
        bPINSupport             0 
        bMaxCCIDBusySlots       1
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x81  EP 1 IN
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               0
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x01  EP 1 OUT
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               0
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x82  EP 2 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0040  1x 64 bytes
        bInterval               4

The Software

It is Windows-only software, and it is bare-bones. You can load an image, select if you want it dithered or not, and then download it to the badge. That's it. No image editing; it just resizes everything to 400x600. There's no badge design software or QR generator. And, to be honest, I think that's fine. You're better off designing your badges in dedicated software.

Unsurprisingly, the app wouldn't run under WINE in Linux. I used Oracle's VirtualBox. Note, the included software requires you to install Microsoft's .Net Windows Desktop Runtime 6 and the latest Microsoft Visual C++ Redistributable Version.

VirtualBox initially refused to see the USB peripheral. I had to unplug the reader, create a USB filter using 1fc9:0102, start the VM, and only then plug in the USB reader. Then it worked. Bit of a faff!

Pricing

I've got good news and bad news!

First, the bad. SmartDisplayer Technology Co are B2B sellers. They'll sell you a single badge for US$70 + shipping. If you're buying more than a thousand, the price drops to $65. The NFC reader is $120.

In terms of badge pricing, I think that's pretty fair. If you want to buy a demokit of just the screen, that'll cost you US$99 direct from eInk. So $70 full assembled is a bargain.

The good news? They'll shortly be bringing out a USB-C badge which doesn't require the NFC reader. The badge itself will be slightly smaller (and a little thicker). That should make it easier to update the badge on the fly - but possibly not as convenient if you're programming hundreds of them.

If you're buying in bulk, they will also do custom printing on the badge, and can replace the plastic with wood.

For more information, or to place an order, contact SmartDisplayer.

Verdict

If you want a fun lanyard which is easy to change, and can reproduce a decent range of colours, this is excellent. Ideally it would be easy to flash with a phone, but the supplied software is adequate.

The USB writer is a little bit clunky, but it holds the badge in place while data and power are transmitted.

I'm astonished by just how flat this badge is. SmartDisplayer cold-lamination process is incredible. The image is on the badge, not under it.

It looks stunning - a real premium product and the price reflects that.

As a personal gadget, I think it is great. But for other uses, I'm not so sure. Are you really going to be handing out $65 lanyards to all of your event attendees? Perhaps at a very expensive conference! But even then, you might want to take a deposit.

Anyone with a suitable reader can reflash a badge; there's no way to lock these. So they're not ideal for security.

If you attend lots of conferences, and are perpetually annoyed by ugly conference badges which misspell your name or don't have a personal QR code, these are a great (albeit pricey) gadget.

Thanks to SmartDisplayer for the review unit. Next time you see me at an event - please snap a photo of my badge!

After some back-and-forth with the manufacturer, they agreed to send me their Android SDK and documentation. Sadly, the PDF they sent me was riddled with errors and the software library is also a bit dodgy. So, with the help of Edward Toroshchyn and a hefty amount of automated boiler-plate, I managed to get it working.

The full code is open source, but here's a quick walk-through of the important bits.

First, the AAR library needs to be imported into the project. Place it in app/libs and then include it in the Gradle build file:

dependencies {
    implementation(files("libs/badge_nfc_api-release.aar"))
}

The key to getting it working is in the Android permissions. It needs Bluetooth, NFC, and location. So the manifest has to contain:

<uses-permission android:name="android.permission.BLUETOOTH"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
<uses-permission android:name="android.permission.BLUETOOTH_SCAN"/>
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
<uses-permission android:name="android.permission.NFC"/>
<uses-permission android:name="android.permission.NFC_TRANSACTION_EVENT"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>

The following imports are needed from the Android Archive library:

import cn.manytag.badge_nfc_api.manager.BadgeWriteManager
import cn.manytag.badge_nfc_api.manager.OnNFCReaderCallback
import cn.manytag.badge_nfc_api.manager.OnBluetoothCallBack
import cn.manytag.badge_nfc_api.manager.OnSendImageCallback

The library needs to be initialised with:

val state = BadgeWriteManager.getInstance().init(this)

When the phone reads the NFC tag, it gets a bunch of information:

BadgeWriteManager.getInstance().setOnNFCReaderCallback(object : OnNFCReaderCallback {
    override fun onReaderMessage(i: Int, tag: Tag) {
        if (i == 0) {
            BadgeWriteManager.getInstance().readNFC(tag)
        }
    }

    //  Get the data from the badge
    override fun onReaderType(tag: Tag, isodep: IsoDep, i: Int, type: String, size: String, color: String) {
        if (i == 0) {
            nfcData = """
                NFC Tag Detected!!!
                Tag: $tag
                IsoDep: $isodep
                Type: $type
                Size: $size
                Color: $color
            """.trimIndent()
            colorFromNFC = color
            tagObject = tag
            isoDepObject = isodep
            badgeType = type
            badgeSize = size
        }
    }
})

The color is most important right now. It says whether the badge is black and white, or black and white and red, or black and white and red and yellow.

After picking an image from the filesystem, it needs to be dithered into the correct colour format:

processedBitmap = originalBitmap?.let { bitmap ->
    colorFromNFC?.let { color ->
        BadgeWriteManager.getInstance().processImage(bitmap, color)
    }
}

Finally, the processed image needs to be converted to bytes and then sent to the badge via Bluetooth:

if (processedBitmap != null && badgeType != null && badgeSize != null && colorFromNFC != null) {
    val imgData = BadgeWriteManager.getInstance().getImageData(processedBitmap!!, colorFromNFC!!)

    BadgeWriteManager.getInstance().sentImageResource(
        tagObject!!, isoDepObject!!, imgData, badgeType!!, badgeSize!!, colorFromNFC!!
    )
}

I realise this is a bit "draw the rest of the owl" but that should be enough to get you started on building an app which can communicate with these badges.

The app I've built isn't the prettiest in the world but at least it works. It scans a badge, gets its info, picks an image, dithers it, then sends it to the badge.

You can play with the code on CodeBerg.

I wondered if there was a retail version I could hack around with. I found the HSN371. It is a colour eInk screen with a lanyard hole. The picture quality is amazing given the technology, the update speed is acceptable, and the supplied app is crap.

Let's take a look!

Picture Quality

Colour eInk isn't designed to be as vibrant as an OLED display. But that's not why you get something like this. It uses no power to display the image, and will happily keep an image on screen indefinitely. The resolution is 240x416 which works out to about a PPI of 130. With only four colours (black, white, red, and yellow) you aren't going to get the Full HD Mona Lisa on there. But it is relatively easy to craft an image which looks good enough.

Here's the default image:

That looks pretty good from a distance! Here's a close-up of the left shoulder so you can see the dithering at work.

There are various dithering algorithms you can use to change the picture quality.

Update Speed

I used the Android app to flash a new image onto it. It takes a few seconds to transmit the image via BlueTooth. But, as you can see, it takes about 30 seconds of blinking before it is fully drawn.

Power

There are cheaper versions available which are NFC only. They don't require a dedicated battery and are powered by the NFC radio of your phone.

This ones uses BlueTooth to communicate. While still low power, it does mean it requires a chunky CR3032 battery to be installed. The battery cover twists off, but doesn't have the most ergonomic action.

In theory, you should only need to replace the battery every year - but it'll depend on how often you update the design.

Personally, I'd have preferred it to be a sealed unit with a USB-C charging socket.

Cost

They were about £16 / US$20 each after tax and payment fees. That seems pretty reasonable to me. In bulk, they might be cheap enough to hand out as conference swag.

They didn't come with batteries. Annoyingly, the CR3032 are a bit of an unusual size. So budget a couple of quid extra per badge.

I had a voucher for free shipping from AliBaba. I couldn't find anywhere in Europe stocking them.

Buying Experience

I purchased direct from Alibaba and it wasn't great. The manufacturer initially refused to supply the promised NFC readers but, after a bit of back and forth, agreed to send one.

It took over 3 weeks to arrive. I also had to chase them to get a link for the app and computer software. They were pretty responsive over WhatsApp given the time-zone difference.

Security

The only meaningful security seems to be proximity. In order to flash a new image onto the badge, you need to launch an app on your phone, then touch the badge to your device's NFC antenna. Once the app has seen the badge, it transmits the image via BlueTooth.

As far as I can tell, the BLE radio doesn't start until the app has exchanged something over NFC. I don't know whether the NFC message contains a password or whether it just contains a BlueTooth ID. There's no sound or vibration on the badge, so the only way you'll know it has changed is by looking at it.

If you take the battery out, the NFC and BlueTooth won't work - but the image will still be displayed on screen.

Android App

Just crap. It isn't available on any app stores - so you need to get a copy from the vendor. There's no way to automatically update it. Looking inside, it appears to target an ancient version of Android and hasn't been updated recently. It frequently crashes and is only partly translated. It didn't work on GrapheneOS.

I found an old phone to run it on. The app, when it does work, is pretty basic.

You can build your own template with text, images, QR codes, and barcodes.

There are a bunch of built in templates you can send.

You can give it any image and it'll convert it to the right format.

And it gives instructions on how to pair the badge to the app

For those of you looking for more information, it calls itself cn.manytag.work_card_write

Windows App

There's a more fully-featured Windows app which works with a USB NFC writer. I was able to launch it on PlayOnLinux, but it couldn't see the USB device and quickly crashed. So I installed a VM of Windows 10, loaded the drivers I'd been sent for the NFC dongle, and was delighted that it worked!

Like the Android app, it is basic and ugly.

This comes with even more templates which can be dithered to taste.

Templates can be saved in JSON format. They look something like this:

{
  "ColorType": "6",
  "Model": "3.7",
  "Size": "0, 0, 240, 416",
  "BgColor": {
    "Color": "White",
    "Name": "White"
  },
  "TemplateList": [
    {
      "$type": "ESL_Badge.BarcodeTemplate, ESL_Badge",
      "BarcodeType": 16,
      "BarcodeText": "12345678",
      "BgColor": {
        "Color": "White",
        "Name": "White"
      },
      "ForeColor": {
        "Color": "Black",
        "Name": "Black"
      },
      "Zindex": 0,
      "Bounds": "187, 150, 100, 30",
      "RelaVarKey": null
    },
    {
      "$type": "ESL_Badge.ImageNewTemplate, ESL_Badge",
      "BackColor": {
        "Color": "White",
        "Name": "White"
      },
      "Image": "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABz...==",
      "DitheringType": "None",
      "OriginalImage": "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCA...QmCC",
      "Zindex": 1,
      "Bounds": "55, 125, 50, 50",
      "RelaVarKey": null
    },
    {
      "$type": "ESL_Badge.LableTemplate, ESL_Badge",
      "Font": "Arial, 12px",
      "BgColor": {
        "Color": "White",
        "Name": "White"
      },
      "ForeColor": {
        "Color": "Black",
        "Name": "Black"
      },
      "Text": "Text",
      "TextAlign": 0,
      "Zindex": 2,
      "Bounds": "68, 49, 100, 30",
      "RelaVarKey": null
    },
    {
      "$type": "ESL_Badge.QrCodeTemplate, ESL_Badge",
      "QrCodeText": "12345678",
      "BgColor": {
        "Color": "White",
        "Name": "White"
      },
      "ForeColor": {
        "Color": "Black",
        "Name": "Black"
      },
      "model": 1,
      "Zindex": 3,
      "Bounds": "94, 233, 70, 70",
      "RelaVarKey": null
    }
  ]
}

The Windows app only works with the supplied NFC transmitter - not with BlueTooth. Load up the template, drop the badge on the puck, hit send, done!

NFC Transmitter

It shows itself as 10c4:ea60 "Silicon Labs CP210x UART Bridge" - it isn't detected as an NFC device in Linux. I think the Windows app just sends raw serial commands to it.

It's micro-USB (bleugh!) and has some flashing LEDs.

Linux Use

Nope! I'm happy to share the Android app and Windows app with anyone who reckons they can decompile them. The manufacturer offered to sell me the official SDK for US$600!

I did a USB capture in Wireshark. It looks like the image is transmitted unencrypted - but I'm not skilled enough to decipher all the commands it sends the USB device. If you are - please let me know!

Background

I purchased from MRB Retail.

It seems to originate with Highlight ESL

I think the ultimate manufacturer is HangZhou Ontime IT Co., LTD but, as with lots of of companies, the ownership is a little confusing.

Verdict

This is a reasonably large, four-colour ePaper badge, and it works! Go along to any (geeky) event and always have a name-badge with your personal branding, cool images, QR code, whatever else you want. Whip your phone out and update it in a jiffy.

After shipping, taxes, and batteries, they're about £19 each. More expensive than paper, sure, but a lot more fun.

There's no backlight or side-light, so it won't be as distracting as wearing other digital screens or flashing LEDs.

It's made of cheap white plastic and doesn't have the most premium feel to it. There is a screen-protector pre-applied to prevent any scratches.

If you can find an Android phone it works on, or are prepared to run Windows and use a dongle, it's a surprisingly good bit of kit!

Badges!

Some badges what I made. Graphic Design Is My Passion!

And, yes, you can run DOOM on it!

(Obviously not - but you can send screenshots. I guess you could play at 2 frames per minute?)

Official Demo Video

Background

After installing solar panels, a smart electricity meter, and a solar battery - the next obvious step was a smart energy tariff.

Octopus (join and we both get £50) have an "Agile" tariff. Unlike a normal tariff - with a set price for electricity - this tariff fluctuates every 30 minutes. Prices depend on wholesale costs which means they can go negative. That's right, you can get paid to soak up excess power.

Of course, they can also spike considerably. Unlike the failed Texas experiment, here the maximum price is capped at £1/kWh.

Every day at about 1600, the next day's prices are published on Octopus's website. And they're also made available via a simple REST API.

So, it's relatively simple to generate a line graph and display it on the eInk screen.

Code

(You can treat this code as MIT Licenced if that makes you happy.)

Calling the API for the half-houly prices is:

$url = "https://{$API_KEY}:@api.octopus.energy/v1/products/" .
       "AGILE-FLEX-22-11-25/electricity-tariffs/E-1R-AGILE-FLEX-22-11-25-C/standard-unit-rates/";

Your API_KEY is unique - and you'll need to check which tariff you're on.

The data is retrieved as JSON and converted:

$content = file_get_contents($url);
$data = json_decode($content);

The JSON is full of entries like this:

"results": [
{
  "value_exc_vat": 13.6,
  "value_inc_vat": 14.28,
  "valid_from": "2023-11-01T22:30:00Z",
  "valid_to": "2023-11-01T23:00:00Z",
  "payment_method": null
},
{
  "value_exc_vat": 18.4,
  "value_inc_vat": 19.32,
  "valid_from": "2023-11-01T22:00:00Z",
  "valid_to": "2023-11-01T22:30:00Z",
  "payment_method": null
},

They're newest first, so need to be reversed:

$tariffs = array_reverse( $data->results );

Then it's a case of looping through them and grabbing today's data:

$userTimeZone = new DateTimeZone('Europe/London');
$now = new DateTime('now', $userTimeZone);

$nowPosition = 0;
$datay = array();
$datax = array();

foreach ( $tariffs as $tariff ) {
    $dateStringFrom = $tariff->valid_from;
    $dateStringTo   = $tariff->valid_to;
    $dateTimeFrom = new DateTime($dateStringFrom, new DateTimeZone('UTC'));
    $dateTimeTo   = new DateTime($dateStringTo,   new DateTimeZone('UTC'));

    if ($now >= $dateTimeFrom && $now <= $dateTimeTo) {
        $costNow = $roundedInteger = (int)round( $tariff->value_inc_vat );
        $hour   = intval( $dateTimeFrom->format('G') ); //  No leading 0
        $minute = intval( $dateTimeFrom->format('i') );
        $offset = ($minute == 0) ? 0 : (($minute == 30) ? 1 : null);
        $nowPosition = (2 * $hour) + $offset + 0.5;
        $until = $dateTimeTo->format('H:i');
    }

    if ($dateTimeFrom->format('Y-m-d') == $now->format('Y-m-d')) {

        $datax[] = $dateTimeFrom->format("H:i");
        $cost = $roundedInteger = (int)round( $tariff->value_inc_vat );
        $datay[] = $cost;
    }   
}

Drawing the graph uses the venerable JPGraph:

$path = 'jpgraph/';
set_include_path(get_include_path() . PATH_SEPARATOR . $path);
require_once ('jpgraph/jpgraph.php');
require_once ('jpgraph/jpgraph_line.php');
require_once ('jpgraph/jpgraph_plotline.php');

// Size of graph
$width  = 600;
$height = 600;

// Setup the graph
$graph = new Graph($width,$height);
$graph->SetScale("intlin");
$graph->SetMargin(35,0,45,20); // L R T B

$graph->SetUserFont('dejavu/DejaVuSansMono.ttf');
$graph->title->SetFont(FF_USERFONT,FS_NORMAL,25);

$graph->SetBox(false);

$graph->title->Set( $now->format('l') . "'s Electricity Prices\n" . $costNow . "p / kWh until {$until}" );
$graph->title->SetColor('#000');

$graph->ygrid->Show(true);
$graph->xgrid->Show(true);

$graph->xaxis->SetTickLabels( $datax );

$graph->xaxis->SetColor('#000');
$graph->yaxis->SetColor('#000');

$graph->xaxis->SetFont(FF_USERFONT, FS_NORMAL, 10);
$graph->yaxis->SetFont(FF_USERFONT, FS_NORMAL, 14); 

// Just let the maximum be autoscaled
$graph->yaxis->scale->SetAutoMin(0); 

// Only show up until 23:00
$graph->xaxis->scale->SetAutoMax(46);

$graph->xaxis->SetTextLabelInterval(2); 
$graph->SetTickDensity(TICKD_DENSE, TICKD_DENSE);  

// Create the line plot
$p1 = new LinePlot($datay);
$graph->Add($p1);
$p1->SetStepStyle();
$p1->SetColor('#000');

//                 Direction, position,     colour@alpha, width
$l1 = new PlotLine(VERTICAL,  $nowPosition, 'black@.8',   13);
// Add vertical highlight line to the plot
$graph->AddLine($l1);

// Output line
$graph->Stroke();

Next steps

I dunno? Add some details about carbon emissions? Battery stats? Let me know what you think in the comments.

HOWTO

This uses Luca Dentella's TOTP-Arduino library.

You will need a pre-shared secret which is then converted into a Hex array. Use the OTP Tool for Arduino TOTP Library to get the Hex array, Base32 Encoded Key, and a QR Code to scan into your normal TOTP generator.

Add the Hex array into the code below.

To check that it is functioning correctly, either scan the QR code from the OTP Tool above, or use the Base32 Encoded Key with an online TOTP generator.

Here's how the code interfaces with the Watchy:

#include <Watchy.h> //include the Watchy library
#include "settings.h"
#include "sha1.h"
#include "TOTP.h"

class MyFirstWatchFace : public Watchy{ //inherit and extend Watchy class
    public:
        MyFirstWatchFace(const watchySettings& s) : Watchy(s) {}
        void drawWatchFace(){

          ...

          RTC.read(currentTime);
          time_t epoch = makeTime(currentTime) - 3600; // BST offset


          // The shared secret - convert at https://www.lucadentella.it/OTP/
          uint8_t hmacKey[] = {}; // e.g. {0x4d, 0x79, 0x4c, 0x65, 0x67, 0x6f, 0x44, 0x6f, 0x6f, 0x72};
          int hmacKeyLength = sizeof(hmacKey) / sizeof(hmacKey[0]);

          TOTP totp = TOTP(hmacKey, hmacKeyLength);
          char* epochCode = totp.getCode( epoch );

          display.print(  "TOTP Code Twitter: ");
          display.println( epochCode );

          ...

You can grab the full code from GitLab.

I'm not very good at C++ - so please let me know what terrible mistakes I've made.

Is this a good idea?

Well... Yes and no.

TOTP is a strong-ish form of Multi-Factor Authentication. It helps prevent attacks where someone already knows your username and password. Having a convenient way to get your TOTP codes may make you more likely to use them. It also prevents you from getting locked out of your accounts if your phone dies or is stolen.

Convenient security is good security.

But... Having them on your wrist for everyone to see? I've deliberately made the font as small as I can so it is only readable up close. However, if someone is shoulder-surfing your details, they may well see your wrist. The watch isn't encrypted - so even if you hid the codes behind a button press, anyone who steals your watch will have your codes. If they steal your phone, they need to get through your PIN / biometrics.

Who are your adversaries? If you are trying to evade state-level actors, thieves specifically targeting you for your crypto-holdings, or an untrustworthy spouse - this probably isn't a great idea. If you don't use 2FA because you don't keep your phone with you - this will probably increase your security posture.

Ultimately, all security measures are a trade-off between convenience and control.

A typical watch face looks like this:

My new watch face is far superior and looks like this:

That's using the GNU Unifont - which works brilliantly on tiny devices.

HOWTO

• Download the GNU Unifont
• Download and compile HarfBuzz
• Run the HarfBuzz Font Subsetter
• ./hb-subset unifont-15.0.06.ttf abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\!\"\£\$\%\^\&\*\(\)\-\_\=\+\@\~\'\#\,\.\/\?\:\;\<\>\\\| -o latin.ttf
• Convert the output to AdaFruit's GFX format using truetype2gfx (set the Font Size to 5 points for about the smallest you can reasonably go. But Font Size of 8 is a better compromise between size and readability.)
• Follow the tutorial to create a new watch face
  • NOTE If you put the font file in the same director as the .ino file, you need to include it using #include "latin5pt7b.h"
• Compile and upload to your watchy via USB.

Nice!

Next Steps

I dunno. Make it bounce around? Print a Shakespearean sonnet? Give me some suggestions!

I've since updated the display to show me three different sets of transport information.

At a glance, I can see the next bus, whether there are delays on the Elizabeth Line, and if my regular trains are running.

Here's how all three APIs work.

Bus

The bus is the easiest one of all. Transport for London (TfL) have a set of free APIs. No registration required! You will need to know the ID of your local bus stop. Visit the TfL bus search page and search for your local stop. Click the stop on the map.

You'll be taken to a URl like https://tfl.gov.uk/bus/stop/490000173RF/oxford-circus-stn-margaret-street - that will show you the Bus Stop ID (technically the NaPTAN ID). In this case 490000173RF.

You can then call this API: https://api.tfl.gov.uk/StopPoint/490000173RF/arrivals - which will return JSON like this:

[{
    "$type": "Tfl.Api.Presentation.Entities.Prediction, Tfl.Api.Presentation.Entities",
    "id": "-119695796",
    "operationType": 1,
    "vehicleId": "LTZ1049",
    "naptanId": "490000173RF",
    "stationName": "Oxford Circus Stn  / Margaret Street",
    "lineId": "12",
    "lineName": "12",
    "platformName": "RF",
    "direction": "outbound",
    "bearing": "152",
    "destinationNaptanId": "",
    "destinationName": "Dulwich Library",
    "timestamp": "2023-06-29T10:40:18.3147535Z",
    "timeToStation": 1470,
    "currentLocation": "",
    "towards": "Trafalgar Square Or Green Park",
    "expectedArrival": "2023-06-29T11:04:48Z",
    "timeToLive": "2023-06-29T11:05:18Z",
    "modeName": "bus",
    "timing": {
        "$type": "Tfl.Api.Presentation.Entities.PredictionTiming, Tfl.Api.Presentation.Entities",
        "countdownServerAdjustment": "-00:00:02.7011995",
        "source": "2023-06-29T07:28:52.918Z",
        "insert": "2023-06-29T10:40:01.313Z",
        "read": "2023-06-29T10:39:58.591Z",
        "sent": "2023-06-29T10:40:18Z",
        "received": "0001-01-01T00:00:00Z"
    }
}, {
    "$type": "Tfl.Api.Presentation.Entities.Prediction, Tfl.Api.Presentation.Entities",
    "id": "-1460579610",
    "operationType": 1,
    "vehicleId": "LTZ1447",
    "naptanId": "490000173RF",
    "stationName": "Oxford Circus Stn  / Margaret Street",
    "lineId": "12",
    "lineName": "12",

Hopefully the entity names are self-explanatory. If you need a specific route, you will need to filter on the lineId's value.

Personally, I use timeToStation to see how long until the bus arrives. If it's less than a couple of minutes, I don't display it.

CrossRail

Again, I am overjoyed that TfL have a free API which lets you check the status of various tube lines.

The Elizabeth Line's status can be found at https://api.tfl.gov.uk/Line/elizabeth/status - can you guess the URl for the other lines 😉?

And, again, we get back some fairly self-explanatory JSON:

[{
    "$type": "Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities",
    "id": "elizabeth",
    "name": "Elizabeth line",
    "modeName": "elizabeth-line",
    "disruptions": [],
    "created": "2023-06-27T12:37:57.107Z",
    "modified": "2023-06-27T12:37:57.107Z",
    "lineStatuses": [{
        "$type": "Tfl.Api.Presentation.Entities.LineStatus, Tfl.Api.Presentation.Entities",
        "id": 0,
        "lineId": "elizabeth",
        "statusSeverity": 9,
        "statusSeverityDescription": "Minor Delays",
        "reason": "Minor delays between Stratford and Shenfield due to a an earlier signal failure at Tottenham Court Road. GOOD SERVICE on the rest of the line. ",
        "created": "0001-01-01T00:00:00",
        "validityPeriods": [{
            "$type": "Tfl.Api.Presentation.Entities.ValidityPeriod, Tfl.Api.Presentation.Entities",
            "fromDate": "2023-06-29T10:30:50Z",
            "toDate": "2023-06-30T00:29:00Z",
            "isNow": true
        }],
        "disruption": {
            "$type": "Tfl.Api.Presentation.Entities.Disruption, Tfl.Api.Presentation.Entities",
            "category": "RealTime",
            "categoryDescription": "RealTime",
            "description": "Minor delays between Stratford and Shenfield due to a an earlier signal failure at Tottenham Court Road. GOOD SERVICE on the rest of the line. ",
            "affectedRoutes": [],
            "affectedStops": [],
            "closureText": "minorDelays"
        }
    }],
    "routeSections": [],
    "serviceTypes": [{
        "$type": "Tfl.Api.Presentation.Entities.LineServiceTypeInfo, Tfl.Api.Presentation.Entities",
        "name": "Regular",
        "uri": "/Line/Route?ids=Elizabeth line&serviceTypes=Regular"
    }],
    "crowding": {
        "$type": "Tfl.Api.Presentation.Entities.Crowding, Tfl.Api.Presentation.Entities"
    }
}]

You can grab the text out of there for easy display.

Train Times

This is the only pain-in-the-arse service. It uses National Rail's Live Departure Boards Web Service (LDBWS). This is an XML SOAP API which requires credentials.

Register for an API token at National Rail's site.

Find the three letter CRS code for your departure and arrival station on the National Rail website.

I use the GetDepBoardWithDetailsHeader() API call. For example: GetDepBoardWithDetails(20, "WWA", "LBG", "to") gets the next 20 trains from Woolwich Arsenal to London Bridge.

There are OpenLDBWS libraries available in most major programming languages. Don't bother writing your own!

There's more discussion online about how to test and use OpenLDBWS.

Once you've got a response, you can filter it for the specific trains you're interested in.

Putting it all together

Well, that's up to you Sparky! Personally, I have a hodge-podge of PHP building it into a format suitable for my ancient eInk screen. You can do what you like!

The Watchy is the opposite in every single conceivable way.

It is an Arduino powered, open source, eInk display, with no data guzzling tendancies. And is only £60 including delivery. It's gorgeous to look at without being distracting, has a massive battery life, and allows for a bunch of tinkering.

But...

Ah... Let's get it out of the way. This is not a consumer product. It is fiddly to assemble, has very little protection for its delicate components, and to change the timezone you have to recompile the firmware!

Oh, and it uses USB-Micro rather than USB-C 😡

The watch ships in kit form and is not overly satisfying to build. The buttons are especially fiddly to fit, the instructions assume you know how to open a ribbon connector, and there's warnings about how fragile everything is. Took me about 20 minutes all in - and that was mostly aligning the buttons.

But, once built, it does look great. Here are my first impressions:

It is an fun device to play with. But the whole thing is built on a set of (very reasonable) compromises.

The eInk screen is a delight to look at and helps keep the battery lasting for ages. There's no backlight - but that also makes it less of a flashy distraction.

The eInk screen is fragile. Yet, bizarrely, the watch comes with zero protection. There is no plastic shield to keep it from getting bumped or scratched. I appreciate that might cause glare or get dust trapped in it - but I don't think the deep bezel is going to protect that screen.

Similarly, there's no water ingress protection. I wasn't expecting a diver's watch with rubber gaskets - but I'd be nervous about wearing this in the rain. You can 3D print your own case, or buy a different one - but that adds to the cost.

There's no speaker - again, less distracting than other watches. The vibration motor is sufficiently powerful to discreetly alert you to anything important.

There's no touchscreen - again, saves on power and protects the screen. But the buttons are hard, loud, and just don't feel nice. Luckily WiFi can be set up by connecting to the device's own SSID. I was dreading the thought of having to enter details using those buttons!

It won't monitor your heart rate, sweatiness, or blood pressure - nor will it try to sell those data to perverts on the Internet. It does have a step-counter which uses an accelerometer to keep track of your movement.

It can't pair to your headphones for listening to music - but you can use BLE for firmware updates and WiFi for NTP.

You can reprogram it! But there's only 3,673,264 bytes to play with, so you can't squeeze to much in there. Oh, and the instructions are the usual half-finished & untested set of scattered files beloved by hackers.

There's no weird proprietary connectors needed to charge it. But it uses USB-Micro. So you'll have to dig out one of those old cables that you kept when the world moved over to USB-C.

Do you see what I mean? It isn't quite as spartan as the Casio F-91W, but it is missing some things you may find essential in a modern watch.

I'm conflicted. I love everything eInk. I like devices which are fully under my control. I don't want to wear something expensive and distracting on my wrist. I want to change the watchface to match my mood.

But... I don't want to wear something fragile. If I go abroad, I don't want to lug a laptop with me just to change timezone. I'm not sure I want to learn yet another programming paradigm. And, if I'm recharging something, I want it to use the same connector as every other gadget I've bought in the last few years.

I enjoy tinkering. But the instruction on the website are incomplete and hard to follow. I've sent a pull request to fix some of the errors I found. Eventually, after some confusion, I was able to download a face, edit the settings, and flash it.

I'm going to spend a few weeks playing with it. The Watchy is crammed full of possibilities. But it remains to be seen if I can fulfil them.

This time, I'm taking a different Nook, and turning it into a magic gallery. Here's what it looks like in action:

Terence Eden is on Mastodon

@edent

Upcycled an old eReader into an art frame.
Displays a new black & white piece of art from Flickr every few minutes.
Full write-up this weekend, but pretty straightforward to do. pic.x.com/ttvrbhz3ee

---

Video

With the front light off:

With the front light on:

How it works

Every few minutes, it finds a black and white artistic image from Flickr and displays it. Simple!

Inspiration

Ambient home cinema by Tom Whitwell

Build

I've previously replaced the battery on an eInk Nook, so I know how easy they are to disassemble. But for this I wanted to keep the plastic frame on, so that I'd be able to attach a more æsthetically pleasing wooden picture frame.

Finding a picture frame of the right size was a little tricky. The physical dimension of the unit are ~170mm x ~140mm. But the screen is only ~125mm x ~93mm .

I used eFrame - they have a really handy website for custom sized frames and inserts. I ordered a mount for an 135mm x 103mm picture (they cut them slightly smaller but I didn't want any overhang) with 20mm top and bottom borders, and 35mm left and right borders. That gave me enough space to fit the Nook. But, as long as the aperture lets you see the eInk, and masks off the plastic frame, you should be OK.

I was also able to buy a frame without a glass front. As this is my first attempt, I went for simple and cheap wood - rather than something more ornate and artistic. Total cost including shipping was £25.

Attaching the frame

It is useful to be able to get to the main "N" button - and there needs to be a gap for the charging cable. I thought about cutting out a little bit of the frame but, in the end, it was easier to attach the Nook to the frame using velcro and blu-tak. Because of the weight of the Nook, I used some sturdy hooks for the wall mount.

Power

There wasn't enough room in the frame for a normal USB cable, so I used a right-angled micro-USB cable. With the page refreshing every 5 minutes between 0600-2300, it got about 3 days of battery life - less if it used the Glow-Light. So a permanent wired connection seemed sensible.

Background

On the surface this seems quite simple - get a bunch of images and display them. But there are some limitations.

The original Nook Simple Touch is, bless it, an old and slow device. I want to do the minimum amount of processing on it as possible. The screen resolution is only 600x800. I don't want to convert colour artwork to black and white - that will just look messy. I also want the image size to roughly match the screen - so things aren't shrunk down.

So, I want a list of art which meets the following criteria:

• Intended for monochrome display⁰
• Roughly 4:3 aspect ratio
• Proper art¹ by real artists²

I started by looking at the Open Data produced by various museums and art galleries. Unfortunately, none of them indicated whether an artwork was greyscale. So, I turned to Flickr!

Using the Flickr API

Sadly, the Flickr API has been neglected for the best part of a decade. So the documentation is grossly out of date.

Two of the undocumented Search API calls are styles and orientation. I use them to search for black and white images in landscape orientation. You can discover more by using the Flickr search website and opening the "Advanced" panel.

The rest of the API call is quite standard. A keyword to search for ("art") - or whatever you want. Sorted by "interestingness" - although popularity is also a good metric. With safe_search turned off - no prudes in our house. And an image size no wider that 800px - because serving a correctly scaled image means less work for the eReader.

The Code

It is almost embarrassing in its simplicity. It uses Sam Wilson's PHP library for Flickr. It grabs 100 images, and then picks a random one to serve. It is resized to fit in a bounding box of 800x600 and repaginated to centre the image. The image is rotated it 90 degrees and served over HTTP with an appropriate caching policy. Nothing else. Here it is³.

require_once 'vendor/autoload.php';
$flickr = new \Samwilson\PhpFlickr\PhpFlickr("123465789");

$search_terms = ["art", "artistic", "painting", "drawing"];
$search_rand = array_rand($search_terms, 1);

$sort_terms = ["date-posted-asc", "date-posted-desc", "date-taken-asc", "date-taken-desc", "interestingness-desc", "interestingness-asc", "relevance"];
$sort_rand = array_rand($sort_terms, 1);

$s = $flickr->photos()->search(["text"        => $search_terms[$search_rand],
                                "per_page"    => "100",
                                "styles"      => "blackandwhite",
                                "orientation" => "landscape",
                                "sort"        => $sort_terms[$sort_rand],
                                "safe_search" =>"3"
                               ]);

$number_of_photos = count($s["photo"]);

$random_photo = random_int(0, $number_of_photos - 1);

$p = $s["photo"][$random_photo];

$farm   = $p["farm"];
$server = $p["server"];
$id     = $p["id"];
$secret = $p["secret"];
$title  = $p["title"];

$image_url = "https://live.staticflickr.com/{$server}/{$id}_{$secret}_c.jpg";

$image = imagecreatefromjpeg( $image_url );

$cropped = imagecropauto( $image, IMG_CROP_DEFAULT );
if ( $cropped !== false ) { 
   imagedestroy($image);  
   $image = $cropped;
}

$x = imagesx( $image );
$y = imagesy( $image );

$width_ratio  = $x / 800;
$height_ratio = $y / 600;

// Scale
if ( $height_ratio >= $width_ratio ) {
   $new_height = ( 600 / $y ) * $x;
   $scaled = imagescale( $image, $new_height, 600 );
} else {
   $scaled = imagescale( $image, 800, -1 );
}

$x = imagesx( $scaled );
$y = imagesy( $scaled );


// Make a background canvas
$canvas = imagecreatetruecolor( 800, 600 );
$black  = imagecolorallocate( $canvas, 0, 0, 0 );
imagefilledrectangle( $canvas, 0, 0, 800, 600, $black );

$dst_x = ( ( 800 - $x ) / 2 );
$dst_y = ( ( 600 - $y ) / 2 );

imagecopy( $canvas, $scaled, $dst_x, $dst_y, 0, 0, $x, $y );

$rotated = imagerotate( $canvas, 90, 0 );

header('Content-type: image/jpeg');
header("Expires: on, 01 Jan 1970 00:00:00 GMT");
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
header("Cache-Control: no-store, no-cache, must-revalidate");
header("Cache-Control: post-check=0, pre-check=0", false);
header("Pragma: no-cache");

imagejpeg( $rotated );

// Tidy Up
imagedestroy( $image );
imagedestroy( $scaled );
imagedestroy( $rotated );

Displaying

As I mentioned in my previous post about displaying web pages on the Nook - the browser is slow, old, and can't handle https connections.

So I used ElectricSign which is an old Android app. Give it a URL and it will display the contents on screen. It can be set to periodically refresh.

I've had it running for months on a different screen and it hasn't crashed.

That's it!

TODO

• Buy more cheap, 2nd hand eInk screens on eBay. Preferably larger and with higher DPI.
• Get some fancy frames.
• Start a pirate art museum.
• Monetise it by tracking how long people stare at a particular artwork.
• BitCoin?⁴

Thanks for reading

If you've enjoyed this blog post, you can buy me something from my wishlist or sponsor my GitHub. Find out more way to support this blog.

KOReader is the best eReader software I've found. It works beautifully on eInk screens, Android, and Linux. Just a gorgeous - and infinitely customisable - experience.

There's one thing I don't like - to move forward a page, you have to click the right of the screen and, to move back, the left. That's fine if you're holding the book in your right hand. But sometimes I behave in a sinister fashion and hold it in my left. I want to tap the bottom of the screen to move forward, and the top to move back a page.

My previous eReader had an easy-settings menu like this:

KOReader doesn't have anything like that - yet - so here's how to set it up manually.

1. In the book selection screen (not when reading a book) tap the top of the screen to bring up the menu bar, then press 🛠️ for Tools
   
2. At the bottom of the menu, scroll across to page 2
   
3. Select "More Tools"
   
4. Select "Advanced Settings"
   
5. Read the big scary warning message and press "OK"
   
6. Scroll along until you find "DTAP_ZONE_BACKWARD". Tap on it, and edit the values to read h=0.5 w=1 x=0 y=0
   
7. For "DTAP_ZONE_FORWARD", set the values to h=0.5 w=1 x=0 y=0.5"
   
8. Press the "X" in the top right corner, and restart KOReader.

Done!

Adapted from this GitHub issue. I've also added these instructions to the KOReader Wiki

I've boosted the contrast of those images. It's the sort of thing the human eye can detect under decent light, but cameras struggle with. At night, it isn't noticeable. But in daylight, the yellowing discolouration is pretty obvious.

To be clear, those photos are taken with the LEDs off. This is not caused by uneven light distribution.

If I'm charitable, it's a bit like the way paper books weather with age.

A few other people on MobileRead forum have noticed similar problems with their Boyue devices.

Because I'm lazy, I leave the reading light on all the time. Perhaps the heat from the LEDs has cooked the eInk. Or perhaps the glass is getting damaged. There's no screen protector on there which has decayed.

I bought the device from a Hong Kong seller on eBay with a UK warehouse. I've enquired about a warranty replacement as it is less than a year old, but I'm not hopeful.

The device is still readable. And you expect electronics to wear with age. But the yellowing is annoying. It is less apparent if I turn the edge lighting on, and set the colour temperature to warm.

Perhaps we'll see liquid cooled eReaders soon?

If you've experienced this - or know how to reverse it - please let me know.

End Result

An eInk screen which displays the trains I can catch from my local station.

It shows the next few available trains, and whether they're delayed. It also shows how long until the next local bus to the train station.

Updating the Nook

Before doing anything, manually update the Nook's firmware. You can download the latest version from Barnes and Nobel

Copy the .zip file to the root directory of your Nook via USB. Unplug the Nook and turn it off. After a few minutes, it should detect the file and perform the update.

Sadly, it's only Android 2.1 - and the TLS implementation is artificially restricted. More on that later!

It's worth deregistering your Nook and then resetting it. You have to press a few buttons to use the Nook without a B&N Account.

Rooting the Nook

Download Nook Manager (or compile it yourself from the open source code).

Unzip the file. It should just contain NookManager.img. Write the disk image to a microSD card. Follow the instructions on XDA Developers to root the device.

Changing the Launcher

I used ReLaunchX which is an eInk optimised Android launcher. Download the latest Android version from F-Droid.

With the Nook connected to your computer by USB, run:

adb install com.gacode.relaunchx_200105000.apk

That will install the launcher. When you hit the Nook's home button, you will be able to select it as the default launcher.

Electric Sign

Running a modern web browser on the Nook is close to impossible. So I recommend using Electric Sign. It's an open source Android app which periodically calls a URl, turns it into an image, and then uses it as the Nook's screensaver.

You can download the latest version from APKpure.

Again, install it using:

adb install Electric\ Sign_v1.0.3_apkpure.com.apk

Launch it from ReLaunchX and follow the setup screen. I set it to reload every 5 minutes from 7AM until 9pm.

TLS Woes!

Here's where life gets complicated. The World Wide Web is changing to become more secure. Sadly, this means older browsers simply cannot access modern web servers. Even though B&N have updated the Nook to use TLS 1.3 - it only works with their own servers. Trying to access modern https:// sites just won't work.

So, you will need to point Electric Sign to an unencrypted website.

Train API

UK trains have an open API, the snappily named Live Departure Boards Web Service (LDBWS). You need to register for an API key, which is pretty much instant.

There's a great PHP library for OpenLDBWS. You can also find libraries in most popular programming languages.

I created a quick little page which displays the trains that either my wife or I can catch to get to our jobs. When we're sat eating breakfast, we can see if our regular train is delayed.

Bus

I have an Alexa skill to tell me the bus times - but listening is much slower than reading. So I also added bus times.

You can also see that I've only included trains we can actually catch. There's no point showing a train leaving in 5 minutes if it takes 10 minutes to walk to the station. The train API shows the departure time of delayed trains, so the code takes that into account.

Physical Install

I used a double-sided 3M sticky pad and plonked it on the wall. No fancy hooks, screws, or magnets. Just glue.

It's conveniently close to an electrical socket. But having a trailing wire looks messy. So we'll only plug it in when it needs a top up. I replaced the Nook battery a few years ago so it should last several days without a recharge.

Code

All the code - plus backups of the binaries - are available on GitLab.

What next?

I don't really care about the weather or the news, and there's limited screen space. But if you have any suggestions for what it could display, do let me know.

Hope you found that useful!

Terence Eden is on Mastodon

@edent

Replying to @edentI declare this project complete!
We now have a passive display showing us bus & train times.
Blog post coming up this weekend. pic.x.com/m2emF5rq3e

---

OK! OK! That's not the main reason. It has pretty good support from the manufacturer and a vibrant community around it. Masses of memory, warm lighting, and oodles of space. And, I think, pretty hackable.

Quick video

Specifications

• Android 6.0 - with a promise to update it to Android 8.0
• Touchscreen with Wacom stylus
• 1.5GHz CPU
• 2GB RAM
• 32GB storage plus a microSD slot
• 7.8 inch E-ink Carta HD (300 PPI) screen
• Dual colour front lights
• USB-C for charging, data transfer, and headphones
• WiFi and Bluetooth
• Speakers and microphone
• 3200 mAh battery

Essentially it's an Android tablet with an eInk screen. The Wacom stylus can be used for handwriting and note-taking.

The reading experience

Amazing! The screen is goregous. You have precise control over the thickness of the fonts, line spacing, word spacing, and more. Pinch to zoom works perfectly. You can even side-load your own fonts. You can also read in landscape mode with two columns. I find that particularly useful.

Links within books work, as do footnotes and endnotes. The keyboard is pretty quick for searching. You can change how bright the light is - and flip between warm and cool lighting.

It also does Text-To-Speech, so a little robot can read books out via the stereo speakers. It'll also play MP3s. No headphone jack - but it supports Bluetooth and USB-C.

There are some glitches in the default reading experience - especially when it comes to punctuation.

Formats supported

A sample of ePub, .mobi, PDF, and .txt files all worked well.

It shows up as an MTP device when connected to a computer via USB. Or you can send files via Bluetooth. It also has a built in webserver, so you can send via WiFi.

ePub 3

I tried the default reader using some of the sample ePub 3 documents. It coped with Arabic (right to left), Japanese with Ruby, and inline images.

Weirdly, it didn't like linebreaks in running text - collapsing them so there was no spaces between words.

It didn't support embedded fonts in eBooks. But, that's ok, you can add your own!

Fonts

Create a directory called /fonts/ on the device. Paste in either TTF or OTF fonts. They magically appear in the reading app!

No support for WOFF / WOFF2 fonts in the default reader.

Apps

There are a few built in apps - the standard Android browser is included. There's an app store and the ability to side-load. There are a bunch of reading apps if you don't like the default one.

Yup, you can install the Amazon Kindle app if you really want to!

(Screenshots are in colour, but the screen is black and white.)

Note taking

I don't like handwriting - but the Wacom stylus is easy to use. You can draw on the screen, annotate PDFs, and erase your scribblings.

Quirks

It doesn't come with a case, nor a screen protector. I'm in two minds about this. It has a glass screen, so should be fairly rugged. I don't plan on using the Wacom stylus, so I doubt that'll scratch it. But seeing as any blemish interferes with your reading experience, some protection is a must. I purchased a £20 case for it.

Start-up time is slow. This is an Android tablet, so doesn't have quite the same energy efficiency as other readers. From off to reading takes about 45 seconds. You can set it to never switch off, but you'll need to charge it a little more often.

The UI isn't brilliantly translated into English. You'll understand it, but the grammar and spacing are quirky. You can also see a few HTML entities in the the UI. So, not perfect quality. But usable.

There are also some untranslated /UI elements.

The UI takes a little getting used to. Some options are hidden away in menus, others behind icons. Most things you'll only have to set once, but it can be a challenge finding everything.

The first time I rebooted, it reverted to Chinese, but it was pretty simple to set it back.

Cost and Verdict

I paid £190 from eBay - plus £20 for a case. I reckon that's a bargain! There are cheaper eReaders out there - but this is the only one I found with USB-C. It doesn't tie you in to the Amazon Kindle monoculture.

As an Android table, it's basically fine. Good enough for occasional web browsing, and some specifically optimised apps.

And as a book reader? Close to perfect! Text is crisp and clear, page turns are instant. Lots of options to fiddle with to get your books just right.

Taking apart the nook is incredibly simple, pop off the power button, use a Torx 5 screwdriver to undo the single screw, and then spludger your way around the edges. This is what I found in mine...

VERY BAD!

A replacement nook battery is less than a tenner from Amazon. It is developed by Cameron Sino who seem to specialise in making replacement batteries for all sorts of gadgets.

Fitting the battery was a little tricky, here's how it went...

There's a small port on the motherboard into which the battery cable is attached.

The cable only fits in one way - with the red wire at the bottom. This is the position which the battery will take when the nook is reassembled.

The battery came charged, so I was able to verify that everything worked as expected. Now's a good time to test charging it.

Once done, unplug the battery and prepare to reassemble!

The back case of the nook has a recessed area for the battery. There's just one tiny problem...

Yup! The battery doesn't fit!

Luckily, the casing for the battery is rather pliable and, with some gentle force, it's just about possible to squeeze it in.

A little bit of tape to secure it into place and we're good to go!

The cable on the battery is long enough to plug in while the back is detached.

Reassembling is somewhat tricky. You have to slide on the bottom, then re-clip everything, and slide up. Be careful not to apply too much pressure - it's really easy to damage the screen that way.

When all the plastic casings are done, it's a simple case of screwing in the T5.

And - that's it! A fairly easy device to replace parts on - no soldering, easy clips, one screw. Why can't all electronics be like this?

Replacement batteries for the nook and glolight are on Amazon for under £10.

I had planned to use a salvaged eInk screen - but the Nook STR (or NSTR from now on) is only £29 due to a massive price drop. The Glow version is a mere £69 - so I bought that and have set my old NSTR to work as a "Family Display Screen".

The idea is that this will stay by the front door, show today's weather, mine and my wife's calendar, as well as other useful bits of information.

Step 1 - Rooting

It's now dead easy to root the NSTR using NookManager.

• Download NookManager from XDA.
• Unzip the file - there should be a disk image in there; "NookManager.img"
• You'll need to use a micro SD card to create a bootable disk. In Linux it's as simple as

  dd if=NookManager.img of=/dev/sdb1 bs=1M

  Windows and Mac users, will have to find tools to help them.
• Turn off your NSTR (hold down the power button on the back, then confirm on screen).
• Stick the micro SD card into the NSTR.
• Turn on the NSTR and follow the on-screen instructions.

And that's pretty much it!

There are, effectively, two options for how to proceed.

1. Point the default browser at a web page and use meta-refresh / JavaScript to update it every so often.
2. Automatically push an image to the NSTR to be used as its default screensaver

I've (mostly) grown out of the habit of tearing down things which are currently useful, and tend to wait until they reach their natural end before poking them with sharpened metal.

In late 2009, I purchased the Elonex E511EB from Waterstones. My review of it on this blog was incredibly popular - with over 250 comments!

As much as I loved the 511EB, it is well past its useful lifespan. I've since got a nook and my wife has a Kindle. The Elonex still works, but it's a little slow and clunky. So - time to break out those screwdrivers and see if I can reuse the eInk screen for something else.

After unscrewing the back and cracking off the case, this is what I found (click the images to embiggen them).

The board, made by Hanvon, runs Windows CE, and appears to be cobbled together from the most random of parts. Here's a close up of it

This really is a Frankenstein's monster of a device. Despite having no wireless capabilities, there's space for an antenna! The ribbon connector clip doesn't attach to anything.

In fact, of the three ribbon connectors present, only the one on the left is connected to anything! I assume the large empty space is for a WiFi / 3G modem to be coupled to the antenna and the smaller ribbon latch. Perhaps the one on the right is for a touchscreen digitizer?

To the left of the board is a random switch. It doesn't appear to be connected to anything else. It's not even accessible when the device is assembled.

The speakers are fairly cheap and don't hide anything of importance.

For the chip nerds among you, this is what's driving the engine:

The CPU is the Ingenic JZ4740. Interestingly, this chip is perfectly suited to running Linux. Which makes Hanvon's decision to run Windows CE all the more bizarre.

The eInk controller is the Epson D135211B2. According to this Chinese hacker's website, that's the same version of controller used to work the Kindle's eInk screen.

Connecting the eInk screen to the board is this component from Ichia.

The board itself has very tiny torx screws holding it in place. Once removed, they reveal:

Nothing of consequence.

What To Do With The Screen?

So, I have an 800*600 eInk screen, in reasonable condition, just begging to be put to good use.

Some clever people, like Matthew Petroff, have turned their Kindles into amazing displays - but that relies on the Kindle having a network connection. As does the amazing Kindleberry project which links the Kindle to a Raspberry Pi.

The 511EB is dumb. Dumb as a box of rocks. There's no networking, so that's out. The system is capable of displaying PNGs, but that would require mounting the internal memory, uploading, unmounting, rebooting, and automatically opening an image. Not feasible.

So, what I want to see is if it's possible to control the eInk screen directly from something like the Raspberry Pi.

The screen connector is the ED050SC3(LF) It's the same screen used for lots of 5 inch PVI displays.

Now, all I need to do is find some (simple) way to drive the screen. Any bright ideas, people?