Ugh.

But, on the other hand, you can reprogram it in C++. So swings and roundabouts...

Anyway, this is the code you need to stick into your watch face to have it perform an NTP sync at, for example, 5am:

if ( minute == 0 ) {
  if ( hour == 5 ) {
    if (connectWiFi()) {
      syncNTP();
      WiFi.mode(WIFI_OFF);
      btStop();
    }
  }
}

You will need to have first configured your WiFi. You will also need to set your NTP server and preferred timezone in settings.h:

#define NTP_SERVER "pool.ntp.org"
#define GMT_OFFSET_SEC 3600 * +1 // GMT is 0, BST is +1

Now every morning you will start with a freshly sync'd watch - with minimal impact on the battery life.

In truth, Discord is no harder to sign up to than Slack, Matrix, Gitter, IRC, or whatever. And of course Open Source projects will follow the maxim of "go where your audience are". There's no point posting everything to MySpace when everyone's already on Facebook.

Do I care that Discord isn't open source? Well, kinda. But I can open it in Firefox and it works just fine.

Discord is perfect for ephemeral communications.

But it is not a fucking substitute for documentation!

I'm currently getting started, and increasingly frustrated, with the Watchy development platform. They've effectively said "here's a barebones guide to setting it up - anything else, ask on Discord" - and it fucking sucks.

There's no API documentation - I have to scroll through a million messages to find anything.

I can't use search, because people don't know how to thread. So I can see questions but not replies.

When I do find replies, it's hard to know how relevant they are. A typical Discord chat looks like:

• Alice: What's the command to go fullscreen?
• Bob: Anyone know how I irrevocably format my disk without confirmation?
• Carol: Oh, yeah, it's easy. Just pass the -f flag.

Errrr...

And then you get the people who get snippy with newbie for asking a question which is frequently seen! So infuriating.

I'm not necessarily advocating for the Four-Document Model - which has some critics - but I just don't understand why wouldn't at least collate all of the common questions and put the answers in one place.

Look, writing a FAQ is probably not the right way to approach comprehensive documentation. But if you can't even be bothered to do that, perhaps you shouldn't be releasing a product in the first place?

/rant

It would declare the time as "Nearly tea-time" or "A little after elevenses" or "Quite late" or "Gosh, that's early".

But I can find no evidence that it ever existed and am beginning to wonder if I dreamt it.

So I built it⁰.

First thing's first - there are a lot of existing fuzzy clocks. But they mostly say things like "afternoon" or "nearly 3 o'clock". There's even a Hobbit Time for Watchy. However, I wanted something a bit more vague and human than those.

Here's an example of what I mean:

    if (hour >= 5 && hour < 7) {
        printf("Blimey! That's early.\n");
    } else if (hour >= 7 && hour < 11) {
        printf("Good morning! Rise and shine!\n");
    } else if (hour >= 11 && hour < 13) {
        printf("Goodness me! Elevenses!\n");
    } else if (hour >= 13 && hour < 17) {
        printf("Afternoon tea time! Care for a cuppa?\n");
    } else if (hour >= 17 && hour < 20) {
        printf("Evening is upon us. Time to unwind.\n");
    } else if (hour >= 20 && hour < 23) {
        printf("Nighttime adventures await! Off we go!\n");
    } else {
        printf("Bedtime beckons. Rest well, my friend.\n");
    }

And here they are rewritten as Shakespearean-style timestamps:

   if (hour >= 5 && hour < 7) {
        printf("Good morrow! 'Tis the break of day.\n");
    } else if (hour >= 7 && hour < 11) {
        printf("Hail, fair morn! Arise and be joyful.\n");
    } else if (hour >= 11 && hour < 13) {
        printf("Goodness me! 'Tis the hour of elevenses!\n");
    } else if (hour >= 13 && hour < 17) {
        printf("Afternoon doth approach! Wouldst thou like some tea?\n");
    } else if (hour >= 17 && hour < 20) {
        printf("Evening doth draw nigh. 'Tis time to unwind.\n");
    } else if (hour >= 20 && hour < 23) {
        printf("Nightfall is upon us. Adventure beckons!\n");
    } else {
        printf("Bedtime doth approach. Rest well, good sir/madam.\n");
    }

And here we come to a central problem with any fuzzy system - repetitiveness. How to make it say something new every time it is called? I guess there are three main approaches:

1. An exhaustive list of every possible saying.
2. A computable way of saying "[Gosh|Blimey|Wow] it's [almost|nearly|just gone] [morning|lunchtime|snooze o'clock]"
3. Use an LLM every time to generate something new.

I had some success with 1. I got the AI to spit out dozens of responses.

But they either need manually fitting into appropriate timeslots, or a bit more prompt-work to get the LLM to spit them out in the right order. Even with a few hundred, it's likely to get repetitive quickly. And, on an embedded system, are liable to take up a lot of memory.

Option 2 also has similar drawbacks. Even with a large amount of stock phrases, the structure and permutations will start to become noticeable. It's possible to reduce that with an enhanced semantic structure - but it becomes quite complex to automate.

Finally Option 3. Ah... It is computationally expensive (not to mention financially prohibitive) to call a network API every time we want to know the time. And on a battery-powered system, every time the WiFi has to wake is a dent in the longevity of the device.

My ultimate goal is to have this as a fuzzy-watchface for the Watchy eInk device.

At the moment, my plan is to use a mixture of 2 and 3.

If you've done something like this before, please let me know 😊

But - fuck me! - the documentation is atrocious! Well, that's a lie. There is no documentation. It has the "Chat to us on Discord" anti-pattern that infects so many otherwise great projects.

So I'm left to figure out how to make the Watchy's haptics work.

The example watchfaces have a file called settings.h which contains .vibrateOClock = true. Set that and you'll get a little buzz on the hour, every hour.

But how do you make it buzz when you've hit your step-count goal? Or when the time is 13:37? Or whenever you want?

There's no documentation. And searching the code for "vibrate" or "vibe" or "vibration" yielded nothing. But I accidentally typo'd my search and entered "vib" - and that did the trick.

In config.h there's this line: #define VIB_MOTOR_PIN 13.

So, pin 13 is wired in to the vibration motor. We can add that line to our own config file. But how do we turn the buzzer on and off?

With a bit of help from Discord, it became clear:

pinMode(VIB_MOTOR_PIN, OUTPUT);     // Set vibration motor pin as an output.
digitalWrite(VIB_MOTOR_PIN, true);  // Enable vibration motor
delay(150);                         // Vibe for 150 ms.
digitalWrite(VIB_MOTOR_PIN, false); // Disable vibration motor.
delay(500);                         // Wait half a second
digitalWrite(VIB_MOTOR_PIN, true);  // Enable vibration motor
delay(250);                         // Vibe for quarter of a second
digitalWrite(VIB_MOTOR_PIN, false); // Stop vibrating

That's the same as the HTML5 Vibrate API - you can't control the intensity, but you can program your own vibration patterns.

I just don't understand why hardware vendors are so crap at writing documentation. Don't they like people using their products?

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!

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.