2/17/2026 - Dealing with LED Array Constraints

Spinetime is going to need an LED array to display the time. Here's me testing how one SMD LED would look line when it's shined to a paper:

Pretty good. That LED I tested was the top-view SMD LED that I took from my broken NodeMCU, though. I will use side-view LEDs for Spinetime. I kinda wish that the angle of SMD LEDs aren't so big though so that the time 'resolution' can be better. I'll probably be able to deal with that later by masking away some of the LED's closure.

I thought about other approaches as well but I can only come up with solutions that require moving parts—and I don't think they'll be as good as an LED array for long-term use.

LED Control Nightmare

The problem with using an LED array, is that I need to be able to decide which LED to turn on out of the dozens or so. This will be difficult to do manually (I'll need dozens of traces.. not great). To make my life easier, I thought about using NeoPixel LEDs that come with built-in controller for each of the lights. Their only side-view SMD LED is 4 mm wide though, not really ideal for my case because I want to pack as many LEDs as I can. I do think that a high-resolution linear clock is definitely necessary, though, so for now I'll just stick with using the side-view SMD LEDs for aesthetics and use the front-view LEDs for functionality. I'll need to add the front-view LEDs on both sides of the bookmark now, though. With a double-layer PCB, this approach should be possible.

2/18/2026 - Designing the Bookmark

LED Design Final Choices

I decided to use 24 SK6812 low power side-view SMD LEDs. Instead of having densely packed LED array, I'm thinking of having two LED bulbs on at once, and they can be of different brightness in order to simulate smooth progressing timeline light.

Designing the Bookmark

The bookmark consists of the LED array, sockets for cables to connect to the main controller unit, and a switch to turn on/off the LED array.

Here's the design of the PCB:

I also finished the mockup for the bookmark, which is now set as the cover image of the project. I'm quite satisfied with the look of it. However, I'm still unsure of whether soldering cables directly to the board (see the VIN, GND, and data soldering holes) is a good idea. I thought about using a JST connector earlier but in my opinion it just adds unnecessary thickness.

2/19/2026 - Deciding for Microcontroller

I've had a few microcontrollers for controlling my LED array in mind. They have to:

1. Have some way to do serial communication with (by having built-in hardware UART pin or digital pins for software serial). I decided that doing a serial communication would be a great long-term friendly way to configure Spinetime (setting the time, change the LED colors, etc.)
2. Have a suitable pin for controlling NoePixel LEDs
3. Has I2C pins (for the RTC).
4. Be compact.

I thought about using one of these:

• ATtiny85
• RP2040
• ATmega328p
• ATtiny1616

Decided to use ATtiny1616 for now. It's better than ATtiny85 but still .. well, tiny. RP2040 as it turns out is hard to use if I just use the chip alone. ATmega328p seems overkill for this project.

Page shown above: https://michael-crum.com/attiny1616/

2/22/2026 - Polish Bookmark PCB and Design Controller Circuit

Improving Bookmark PCB

Realized that I should've put the ground plane at the back instead and have the capacitors reach it directly from a somewhat short path.

I also added back reference designators to the the fabrication layer because I deleted all the reference designators from the silkscreen layer (for aesthetic purposes).

Power Use

After some research and fiddling, I decided to use these components together (as seen in previous blog posts) and here's the summary of their power usage:

The whole thing should consume just about 37 mA (worst case scenario). Seems quite tiny, until I realize that the bookmark needs to be powered for hours in a single day (because, well, this is an ambient clock). A 400 mAh battery pack can only power my circuit for 10 hours and 48 mins. That means maybe one or two charges every day—not ideal. So, I thought about using 1000 mAh battery pack. That'll give me 1d + 3h of usage, which is plenty of headroom when added with the fact that I won't use 20% of the battery's capacity to make its lifespan longer.

I found a fitting Rp36,900 (~$2.18) 503450 li-po battery pack over at Shopee that comes with a protection circuit. As its name suggests, it's 5 cm×3.4 cm big and 5 mm thick. Honestly, bigger than what I originally wanted. I'm now thinking of clipping the whole unit to my book's cover with a custom designed casing instead of putting it anywhere inside.

Designing the Controller Circuit

I made a relatively simple circuit to control the bookmark that uses a P-channel enhancement MOSFET to handle load sharing of the battery when being charged. The battery can be charged through a USB-C interface. A TP4056 is used as the charge controller. I set the charging current to about 550 mA to ensure long battery life.

To make my circuit less error-prone (my first time making an SMT board), I decided to expose the UPDI pin of my ATtiny1616 through simple header pins. Same goes for the serial communication pins:

Worries about SK8612 Soldering

I found that some people have had difficulties when fabbing boards with SK8612 LEDs, such as some assemblers at Makerfabs. However, it's not like I can just switch the LEDs again at this point. This'll probably be a side note later when I order a PCBA for the bookmark.

Resources Used/Gathered

• NeoPixel guide: https://learn.adafruit.com/adafruit-neopixel-uberguide/logic-level
• Another NeoPixel guide: https://www.digikey.com/en/maker/projects/adafruit-neopixel-berguide/970445a726c1438a9023c1e78c42e0bb
• how to flash attiny1616 https://michael-crum.com/attiny1616/
• change clock speed of attiny1616: https://www.avrfreaks.net/s/topic/a5C3l000000Ubn4EAC/t159058
• technical problems with sk6812: https://forums.adafruit.com/viewtopic.php?t=188940
• sk6812 hard to solder: https://www.makerfabs.com/blog/post/why-ws2812-sk6812-failures-after-smt-soldering
• order with moisture-sensitive devices recommendations: https://jlcpcb.com/help/article/moisture-sensitivity-level-msl-for-electronic-parts
• load sharing circuit: https://www.thanassis.space/loadsharing.html
• SMD resistor guide: https://www.allpcb.com/blog/pcb-assembly/smd-resistors-demystified-sizes-markings-and-practical-applications.html
• should LED strip's end be connected to anything?: https://www.reddit.com/r/AskElectronics/comments/1bnx4vv/addressable_led_data_out_connect_to_ground_yn/
• TP4056 breakout reference: https://github.com/alltheworld/tp4056/issues/3
• Setting internal reference voltage for attiny1616: https://forum.arduino.cc/t/how-to-measure-supply-voltage-in-attiny/1244260

Notes about Time Spent

Most of the 12 hours here consists of doing extensive research and reading through plenty of datasheets:

3/9/2026 - Design the Controller PCB

Re-Checking Controller's Schematic

Re-checked everything. Turns out, USB-C requires 5.1 KΩ pull-down from the CC pins. I initially removed the serial connection pins too because I figured compile-time configuration is much better, but now that I think about it, not having serial communication pins later will send me to debugging hell—so I added them back.

Routing the Controller PCB

The battery that I mentioned on the last post is now unavailable it seems like, so now I'm going with this one (the 1Ah one). It is 5.2 cm wide, 3.4 cm tall, and 5 mm thick. I designed the PCB around that: it has the same width as the battery. Having a somewhat square design when the battery and the PCB are placed in series, the controller unit's weight should be distributed evenly to avoid snapping or other unwanted issues.

So dense! I love it.

Note that this isn't the final design, however. Depending on how I'll design my casing later, I might need to add some extra mounting holes.

Small Tweaks for Bookmark

I now have the time start from 3 because sometimes I wake up at 3 AM :) I fixed one capacitor's form factor too (should have been the 1206 SMD package instead of the 0402 one). Also, I made the hour numbers bigger to make them more readable.

Plans Ahead

In my next sessions I'll design the casing for my controller unit, and perhaps also one for the bookmark unit.

3/10/2026 - Creating Right-Angle JST Connectors

I need right-angle JST housings, but I only have the vertical ones. So, I decided to... make my own right-angle JSTs.

I tried soldering a 1x3 JST housing directly to a right-angle male header, but it looks terrible:

So then, I decided to take off the headers' black thing and realized that the ends are too long. I spent a while trying to cut the end away with a pair of scissors (I do not have a proper cutter), and end up with something that looks better:

It fits too:

Except, there was some short circuit going on. Technically, it was just some ghost bridges that might be caused by residual flux. But it annoyed me so I reflowed some of the solder joints again.

If you noticed the crap amount of solder I put there, well.. it was hard, okay? Sticking individual 1 mm thick pins to a JST..

3/19/2026 - Designing the Casing (for the Controller Unit)

I made the casing design(s) for my circuit:

Yep, there are two parts. I'll explain in this post.

Are those Clips on your Casing?

Yes, to clip to your book, duh. Where else do you want to put it?

Why are there two clips?

You see, I thought I can make a pretty small and thin casing. However, I was stuck with 12 mm of thickness, and some 60x78 mm^2 area. Yikes. This means I can't trivially clip the unit to the back of a book's cover because then it would cause the book to wobble when being written on. Naturally, you'd want a second clip located at the bottom to counter this unstable position. Sure, now the cover is gonna be slightly raised, but this is way better than having to write on a book that literally rocks back and forth.

The second clip (green) has extra pockets there. They're to put anti-slip rubber strips. I thought that it'd be cool for the extra clip to double as anti-slip clip.

My Experience with FreeCAD

WHEW... 13 hours. For a casing? That doesn't make sense, does it? Oh well, look, this is the first time ever that I used FreeCAD (or any CAD software for that matter). And, you know, FreeCAD has a terrifying user interface. But it's really powerful—I love it now that I know how to use it (Thanks, MangoJelly!). This is also the first time I dipped my toes into simple compliant mechanisms (cantilever!), so figuring that part out took some while. Really exciting new stuff.

Anyway, the first problem I encountered with FreeCAD was my inability to create sketches on a surface. Huh? Turns out, I wasn't selecting the correct body.

Then, figuring out how to move features of a body. Turns out, instead of editing the location of the features (like pads, pockets, etc.), you move the sketch. Alright, makes sense..

Later, after some while of more FreeCAD, I figured I'd modify the sketch of a pocket from like 10 part design operation entries ago. And then, TNP (topological naming problem) hit me like a truck—it broke my entire model! And for some reason, I didn't have a backup file. I ended up having to redo a lot of my progress.. sucks. Learning from that, I now have backups for every milestone of the file. And thankfully, I tamed the TNP monsters and didn't encounter any of those again (well I did but they weren't as horrible as the earlier one).

The rest of my FreeCAD experience is pretty much just:

Ohh this feature exists, I don't have to do it manually. Cool.

I discovered a heckin' ton of useful features in FreeCAD, like fillet, chamfer, thickness, surface features (mirror, linear pattern, etc.), construction lines in sketch mode, transparent mode, symmetry in sketch mode, and more. The list goes on. FreeCAD cool.

3/29/2026 - Writing the Firmware

Whew, last step of it all! I finally wrote the firmware for SpineTime. Hopefully it'll work just fine.

idk what pic to attach here.. how about my IDE?

The code is at: https://github.com/DaringCuteSeal/spinetime-fw

The code is pretty simple. All it does is wake up every 10 minutes (by the interrupt signal generated from the DS3231 RTC) and set the LED to the correct colors. It's my first time coding an MCU by directly manipulating its registers though, because for some reason I can't find a user-friendly code to make the ATtiny1616 sleep and also to set its brown-out detector to the sampled mode. Turns out, bare metal programming isn't too bad (reading the datasheet and other long form documentations is pretty boring, though).

Oh and yeah, no run-time configuration. Everything is compile time and can be configured by the cfg.h file. We do it the suckless™ way.

Besides merely coding, I also edited the PCB of the controller unit a bit. I made the battery power circuit directly connected to the RTC without a switch. I'd love to have two switches, one for the RTC and the other for the MCU & LEDs, but I'm already too far ahead to edit the board's dimension (it's already really crammed and a switch is somewhat big).

I also added test pads of the VIN rail that can be used to measure the current usage of both the ATTiny and the LEDs, because I'm damn sure I'll have horrible current draw initially.