Adventures in Bookbinding

The Question

Almost a year and a half ago, my good friend Stu reached out one morning with a question:

Could I, indeed! I had not too long before started teaching myself bookbinding techniques by watching DAS Bookbinding videos on YouTube, and had taken a few tentative steps myself, acquiring or making tools and supplies to do it.

Stu's project was certainly bigger, but I felt up for the task, and readily agreed. I ordered the book off eBay and some additional supplies I anticipated needing and set to work assessing the state of the book. It would prove to be eighteen months of learning, false starts, and procrastination before ultimately coming together just before attending the most recent Geek Flea in Stu's hometown.

Around this time, I discovered Four Key Book Arts, another YouTube channel and Dennis had recently posted a three-part series on restoring a book of very nearly the same vintage as Sea & Land. It was the perfect tutorial as I had to perform almost exactly the same repairs.

Assessing the cover

The book arrived, and I was immediately impressed by its bulk, despite its small stature. The front cover and spine were completely separated, and the back cover was hanging on literally by a few threads.

Removing the cover

A deft stroke with a razor blade and the back cover was off. I was reasonably certain by this point that the original cover wouldn't be, uh, recoverable. With the text block fully free, it was time to look at their overall condition.

Examining the signatures

The signatures all looked complete, and I could tell that they'd undergone a rounding process before that left a thick shoulder consistent with the thickness of the cover. But once they all came apart, they'd need to be re-flattened, or "knocked down".

Hidden treasures

Looking through the book itself, I came across an original note from some previous owner's sibling, as well as a few pressed flowers and plants.

Matching the endpapers

Given the title of the book, I decided to go with a gold and blue marbled paper. I felt it would match the period in looks and suit the theme well.

Building the lying press

The first side quest! In order to perform many of the actions I'd signed up for, I knew I needed at least a lying press. Basically a modified Moxon Vise, it would need to be beefy enough to handle an 800-page book and strong enough to apply the pressures needed for treating the text block as a solid unit. I was, at this point, tuned into a number of YouTube creators, and Darbin Orvar had a wonderful video detailing the creation of a book vise (lying press) and book plough.

Separating the signatures

With the press made, it was time to resume deconstructing the text block. I'd spread a mixture of methylcellulose on the spine to loosen the remaining glue and paper sediment, and to my surprise found staples holding the signatures together, rather than thread as I'd expected. While delicate, they all were more or less solid and bent easily with some tweezers and patience. I didn't understand the pattern of the staples, and ultimately it wouldn't matter as I'd decided I was going to sew the text block back together.

Knocking down the signatures

Before I could reassemble them (or even guard the folds), I needed to remove any curve at the spine edge of the signatures. This is a process called "knocking down", and it usually involves a very flat, very sturdy iron. You lay the spine edge on the iron and gently whack the signature with a broad, flat hammer. Just enough to remove the curve and leave the signature more or less flat. I could tell it would be most important with the first and last signatures.

Guarding the signatures

Since these signatures had been stapled and I saw no sign of tape or banding across the spine, I knew I'd be punching new holes in the signatures to accommodate them. That would require reinforcing, or "guarding" each signature with a small strip of thin but sturdy paper, just one per signature would be enough, so long as the inner-most sheet of the signature's fold was secure. These were brushed with a coat of methylcellulose and applied along the spine of each signature, then carefully folded over and set aside to dry.

Burnishing the endpapers

To elevate the endpapers a bit, I applied a light coating of beeswax and burnished it into the paper, giving it a glossy sheen, as well as a delightful smell. This would protect the endpaper and give it a little moisture protection. Usually you would use an agate burnisher, but since I didn't have one, I used the smooth face of the hammer I'd used for knocking down the signatures.

Marking the text block

With the signatures all dried and trimmed, I lined them up, double checking the order several times, and drew layout lines where the initial sewing holes would be as well as where the tapes would lie across the spine.

Punching the signatures

Second side quest! To more easily ensure common placement for the signature sewing holes, I built a signature cradle. A v-shaped trough with one reference edge. Place a signature folded open along the bottom, push the head (or tail, but be consistent) against the reference edge, and using a template, punch holes using an awl cleanly through the fold of the signature. The two wings of the cradle have a gap at the bottom a few millimeters wide to allow the awl to pass through the papers completely. When all the signatures were punched, I added a reference line across the spine to ensure correct ordering (I should have done it earlier).

Sewing the text block

Third side quest! I ended up building, but not using (at least for this project), a sewing frame. I found it easier ultimately to elevate the text block and manually align and adjust the signatures. I chose a relatively thick thread and applied a very thin layer of beeswax to help it smoothly travel through the holes in the signatures. I knew that a properly sewn text block should be able to withstand 20-25% swell on the spine side, but this thread ended up being too thick when applied to each signature, and clocked in at 30% swell. So I put the project aside for a while to consider alternate approaches.

Undoing the text block

I had to completely undo the entire text block and carefully remove all the stitching to ensure the holes weren't torn or made too loose.

Resewing the text block

I watched DAS's video on two-on sewing several times to make sure I understood the process. Basically, it's a technique that allows for less swell at the expense of a slightly less secure text block by attaching multiple signatures on each run up or down the spine. In my case, with fifty signatures, I chose an alternating pattern of two-on and three-on binding. I figured once the spine was glued, under mull, and bound, it would still prove to be secure. In the end, it was a success, and brought the swell at the spine down to 18%! Much easier and fully within optimal range.

Gluing the spine

The text block was back together and strong and secure, despite the change in sewing technique, and it was time to strengthen and reinforce it with glue. It was important to avoid the tapes so the back could be properly rounded later.

Rounding the text block

In order to round the text block, you would normally have shouldering irons that would catch the force of the blows applied to the signatures and help fold them over, forming the shoulder. I didn't have shouldering irons, so I made some. Two lengths of steel plate, pre-drilled, were screwed to some rabbets I routered out of a pair of plywood boards. In the end, I went pretty easy on the text block as I was afraid to put too much stress on the spine.

Strengthening the spine, pt 1

Now it was time for the first round of spine strengthening. A layer of glue, then mull laid down on it, then sandwiched with more glue, impregnated the mull and tapes with glue, forming a solid layer from head to tail.

Sewing the bands

The first time I bound a book, I made decorative head and tail bands, but they weren't very structural. For this book, I felt it needed as much support and reinforcement as I could give it. Plus, sewn head and tail bands would be more period appropriate and be an opportunity to again show off some theming. I chose blue and green threads (sea and land) and firmed up some paper cord with PVA glue to act as the core of the bands. I identified the centers of the signatures, and started the wrapping process. If you've ever made friendship bracelets as a kid, you'd probably recognize the process. Every so often, the whole structure would get sewn into the book via the fold in the signature with the thread coming out the back of the spine. Ideally, it's done underneath the first sewn line of knots across the spine, further strengthening the structure. Like many parts of this project, I would have benefitted from starting with the side least likely to be seen regularly, but I didn't. Head first, literally and figuratively.

Strengthening the spine, pt 2

Next came a spine stiffener, and piece of cardstock glued and smoothed down, followed by the hollow, a structural piece that would allow the spine's cloth to fold open without creasing on itself.

Making the tabs

The two waste sheets on the front and back of the book were now folded down in thirds, and sandwiched with glue, binding the remaining mull and tape within it. About this time, I also managed to pick up an antique nipping press locally. Having steady pressure, equally applied would be pretty crucial throughout the remainder of the process.

Assembling the boards

I had determined that the cover boards would be 4mm thick, but made by laminating two 2mm boards, leaving the last third unglued along the edge of the spine. That gap would eventually take the tabs I'd just made and fully secure the covers to the spine. At this point, it's a book!

Creating the deboss cards

Since I was not reusing the original covers, but I wanted to pay homage to its design, I traced the title lettering in Affinity Designer and turned it into an SVG, which I could scale and place and make full cover size. I cut it out with a Cricut at the studio and glued the cardstock to the cover boards and set them to dry in the press.

Clothing the book

The book was structured, but still vulnerable. Gluing down book cloth and putting it in the press allowed the cloth to be debossed into the stencil I cut out. I was in a bit of a rush, and the blotter paper I used outside the book met up with some glue coming through the book cloth, and left little fuzzy bits.

Attaching endpapers

The last step was attaching the endpapers, fully connecting and making secure the cover to the text block. A mixture of PVA glue and methylcellulose gives a bit more working time and allows the endpapers to be smoothed against the cover boards. The cover boards had bowed slightly as the cloth compressed, and gluing the endpapers inside would counter that bend and the tension would pull them back flat.

Assembling the shadowbox

The back cover had no decoration or ornamentation, but the front cover and spine still retained some of their former beauty. In addition, the personal note and pressed flowers found in the book all made for a nice memento of the book's former life. I mounted them all in a shadow box, which would accompany the book and get presented to Stu.

Ready for presentation

I drove up the morning of Geek Flea with the book still in the nipping press, where it had sat overnight, receiving as much pressure as I could muster and as much time as I could give it. When I finally pulled it out the press, it was as much a surprise to me as it was to Stu, and I couldn't have been more pleased with how well it all turned out.

The next step for me is to try and recreate the original cover artwork as a dust jacket so Stu will have something other than a grey spine to look at on his shelf.

Elegance, distilled: the 60% Apple Extended Keyboard II

Have I mentioned that I love mechanical keyboards? I have? Well, I’ve just finished up another little project, and I’m typing on it right now. It’s considerably smaller than the Nimitz, but just as satisfyingly clicky.

The Hook

I don’t remember exactly what prompted me to visit this picture, but I was utterly captivated when I saw it. You’ll recall, I have several spares. I have switches, keycaps, and solder. All I need is a custom PCB and a GH60 case. Help me, Hasu. I ordered one set of the PCB and plates. I still have two spare keyboards, having built a second Teensy adapter so I could leave one keyboard at work and one at my studio. This keyboard is so much smaller, I can actually fit it in my bag and tote it along with me, and I have future plans to make it a truly on-the-go tool.

Desoldering switches

The Apple Extended Keyboard II disassembles pretty easily. There’s only one screw, and a minimal amount of prying to get the case open. A keycap puller gets the switches clear for removal. Luckily, the only keycap that had problems on this keyboard was the help key. Who needs that, with Geek Hack and Deskthority available? Slow and steady gets the switches desoldered. Several of them had the pins bent down, presumably to make a better connection. Patience and needle nosed pliers won out in the end, though. Cleared out and bent straight, I had 60 little switches ready to be redeployed.

Cleaning keycaps

Once I had those keycaps off, it was obvious they were filthy. Threw them in a big, quart-sized Mason jar with some dish washing liquid and warm water, screwed the lid on, and put them through the gentle cycle. If your keyboard’s keycaps are removable, do yourself a favor and clean them once in a while. Your fingertips will thank you. The spacebar keycap is made of ADP rather than PBT, so it yellows over time, just like the case. I could apply retr0bright, but I think I’ll just let it be for the time being.

Folding and soldering diodes

When you order the Alps64 board from Hasu, it requires some assembly. He includes a strip of diodes that need to be soldered to the board. I suppose he does this because the board also includes SMT pads if you are crazy and want to surface mount your own diodes. I opted to fold (using the included little tool!) each and every one, and aligning them properly (line side goes to the square pad), solder them all in place. For future reference: use flux and more solder than you think. I’m pretty sure I’ve got decent connections (I’m typing this on the keyboard now), but it seemed pretty clear to me that the solder is really only on one side of the PCB. It’s not that big a deal, but if I were to do it again, I’d be a bit more generous with the solder and make that connection as solid as possible.

Soldering switches

The diodes live on the underside of the PCB, hidden from view, so you need to do them first. Once attached, the switches will sandwich the top plate down and obscure the top of the PCB. So, you’ll also want to ensure that the leads are clipped as close as comfortably possible. At this point in the project, I was actually running low on solder, so I placed the switches, and soldered the four corners plus the space bar. After acquiring more, it was a simple job to apply flux to the leads and solder them one row at a time. I tested as I went: hook up the keyboard, launch TextEdit, and press switches, when you see characters appearing, you’ve got a good, solid connection. Once I had everything done, I noticed a few switches weren’t registering. I tested the PCB by bridging the switch pads with the accompanying diodes with tweezers and seeing characters typed in TextEdit, so I deduced the switches must be bad. Luckily, going from a 104-key keyboard to a 60-key means you have a reserve supply. I desoldered three more switches and tested each before fixing them in place.

Installing the PCB and plate

At this point, all the switches were working with the default onboard keymapping, so I attached the PCB to the case with screws and tested and retested and retested (a lot of testing). I set all the stabilizers back in, and attached the largest keycaps first, starting with the space bar.

Installing keycaps

The keycaps are simple enough to install by themselves: just place over the switch and push down with moderate force until it clicks. With no particular order to follow, it was kind of fun trying to match muscle memory with where keys went. When I wasn’t sure, I just looked at my Macbook Pro for confirmation. Muscles remember, but they don’t talk.

Test drive

I found the default key layout a little wanting. Luckily, the onboard chipset is completely programmable, and Hasu provides an online configurator to specify just exactly how your keyboard should act.

Configuring and flashing the firmware

I used Hasu’s TMK Keymap Editor to set up a few layers on my keyboard. It supports up to 7, but I haven’t explored more than the three I have so far:

In the default layer, most everything is normal, with the exception of the two control keys in the bottom row.

The left control key activates Layer 1, but only when held, making it a modifier to enable arrow keys, function keys, and media keys.

Press the right control key, however, and the entire keyboard switches into mouse mode. I’ve mapped the vim keys for left, down, up, and right to the corresponding mouse events, left, down, up, and right, and I’ve reused the standard WASD keys for scrolling behavior. Space bar becomes mouse button 1, and the right Command key becomes mouse button 2. I now have a fully capable (if slow, and currently frustration-inducing) mouse mode.

In use

So far, after a day of use, it’s becoming a bit more familiar, and a whole lot more intuitive. As a heavy vim user, I still get caught up in using the Esc key on layers 1 or 2. I’ve swapped it to be Esc on Layer 0, but it turns out I also make heavy use of the backtick and tilde! In the meanwhile, I’m quite enjoying the aestheic nature of my new keyboard, and the challenge involved in mastering yet another set of fingertip-driven conventions. With a pleasing click and a solid build, I’ll give it another 100 years.

Future Plans

There are a couple ideas I’m already exploring in my head:

• Bluetooth! There’s a writeup of adding a BT controller and battery inside the case. There should be enough room to make that happen, and there are a few other keyboard enthusiasts at work planning on just such a project for theirs.
• 3D printing a new case that doesn’t leave the top plate and switches so exposed.

Self Control

In response to my recent keyboard posts, Alpha Chen posed a really good question:

@zacbir Re: http://t.co/AmXWBktHHe Why not remap caps lock to control directly in the firmware instead of doing it in OS X?

— Alpha Chen (@kejadlen) January 18, 2015

The answer to which is: *headslap* Of course!

I’ve modified my firmware again to map the key to LCTL, and now the keyboard converter will always send Control when that key is pressed, regardless of OS settings. In fact, it’ll send Control regardless of OS.

Thanks for the dose of obvious, Alpha Chen!

Current keymap file:

#include "keymap_common.h"


const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP_EXT_ANSI(
    ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12,           FN0, SLCK,PAUS,                   PWR,
    GRV, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,     INS, HOME,PGUP,    NLCK,PEQL,PSLS,PAST,
    TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS,     DEL, END, PGDN,    P7,  P8,  P9,  PMNS,
    LCTL,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
    LSFT,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,          RSFT,          UP,           P1,  P2,  P3,
    LCTL,LALT,LGUI,          SPC,                               RALT,RCTL,     LEFT,DOWN,RGHT,    P0,       PDOT,PENT
    ),

    KEYMAP_EXT_ANSI(
    ESC, F1,  F2,  F3,  F4,  F5,  F6, MPRV,MPLY,MNXT,MUTE, VOLD,VOLU,          FN0, SLCK,PAUS,                   PWR,
    GRV, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,     INS, HOME,PGUP,    NLCK,PEQL,PSLS,PAST,
    TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS,     DEL, END, PGDN,    P7,  P8,  P9,  PMNS,
    LCTL,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
    LSFT,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,          RSFT,          UP,           P1,  P2,  P3,
    LCTL,LALT,LGUI,          SPC,                               RALT,RCTL,     LEFT,DOWN,RGHT,    P0,       PDOT,PENT
    ),
};

const uint16_t PROGMEM fn_actions[] = {
    [0] = ACTION_LAYER_MOMENTARY(1),
};

In Media Res

I realized that in my first post about my new keyboard, I didn’t really explain the process to build the firmware for the Teensy 2.0 microcontroller. Since then, I’ve modified my keymap to swap caps lock with control, and now I’ve added back in most of the media key functionality. I’ll show you how to do that now, and explain the compilation process.

Getting the Tools

There are two tools required for compiling and installing the firmware to the Teensy. The first is CrossPack by Objective Development. The tools are installed into /usr/local/CrossPack-AVR/bin/, so you’ll want to add that directory to your $PATH environment variable, either permanently or during compilation. The examples below will use the latter.

To install the resulting firmware code onto the Teensy, you’ll need the Teensy Loader application.

Both these tools predate the signing requirements to get past OS X’s quarantine, so you’ll need to open them via context menu in the Finder.

Getting the Code

You’ll need a copy of hasu’s tmk_keyboard project:

$ git clone git@github.com:tmk/tmk_keyboard.git

Modifying the Keymap

We’ll start with the keymap_ansi.c file and modify it. The ANSI layout makes a very sensible default for the stock keyboard, since it uses the locking caps lock.

#include "keymap_common.h"


const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP_EXT_ANSI(
    ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12,           PSCR,SLCK,PAUS,                   PWR,
    GRV, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,     INS, HOME,PGUP,    NLCK,PEQL,PSLS,PAST,
    TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS,     DEL, END, PGDN,    P7,  P8,  P9,  PMNS,
    LCAP,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
    LSFT,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,          RSFT,          UP,           P1,  P2,  P3,
    LCTL,LALT,LGUI,          SPC,                               RALT,RCTL,     LEFT,DOWN,RGHT,    P0,       PDOT,PENT
    ),
};

const uint16_t PROGMEM fn_actions[] = {
};

$ cd tmk_keyboard/converter/adb_usb/
$ cp keymap_ansi.c keymap_zbir.c

To create media keys, we’ll need to add another keyboard layer to our keymap. We can duplicate the base layer, and change one key’s code to be FN0. In my case, I’ve chosen the Print Screen key. I’ve designated its action to be ACTION_LAYER_MOMENTARY to switch to layer 1, which has the media keys assigned to F7 through F12.

#include "keymap_common.h"


const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KEYMAP_EXT_ANSI(
    ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12,           FN0, SLCK,PAUS,                   PWR,
    GRV, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,     INS, HOME,PGUP,    NLCK,PEQL,PSLS,PAST,
    TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS,     DEL, END, PGDN,    P7,  P8,  P9,  PMNS,
    CAPS,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
    LSFT,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,          RSFT,          UP,           P1,  P2,  P3,
    LCTL,LALT,LGUI,          SPC,                               RALT,RCTL,     LEFT,DOWN,RGHT,    P0,       PDOT,PENT
    ),

    KEYMAP_EXT_ANSI(
    ESC, F1,  F2,  F3,  F4,  F5,  F6, MPRV,MPLY,MNXT,MUTE, VOLD,VOLU,          FN0, SLCK,PAUS,                   PWR,
    GRV, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,     INS, HOME,PGUP,    NLCK,PEQL,PSLS,PAST,
    TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS,     DEL, END, PGDN,    P7,  P8,  P9,  PMNS,
    CAPS,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
    LSFT,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,          RSFT,          UP,           P1,  P2,  P3,
    LCTL,LALT,LGUI,          SPC,                               RALT,RCTL,     LEFT,DOWN,RGHT,    P0,       PDOT,PENT
    ),
};

const uint16_t PROGMEM fn_actions[] = {
    [0] = ACTION_LAYER_MOMENTARY(1),
};

Compiling the Firmware

By default, with nothing specified, the Makefile will compile keymap_ansi.c. You can specify a KEYMAP parameter to make to choose an alternate. It matches the part of the filename like this: keymap_{KEYMAP}.c. Remember to include the CrossPack AVR location in your $PATH:

$ set PATH /usr/local/CrossPack-AVR/bin $PATH; make KEYMAP=zbir

This will create a number of output files, but we’re interested in adb_usb_lufa.hex, as that’s the file format Teensy Loader will install.

Installing the Firmware

Launch the Teensy app. It’s just one little window. Isn’t it cute? Four little buttons along the top. Press the reset button on the Teensy itself to start the conversation. Click the first button to locate your .hex file. Click the second to erase the Teensy and install the new firmware. Click the third button to reboot the Teensy. Don’t bother with Automatic Mode.

You’re done! If you use a layout like mine, pressing Print Screen and F8 will play/pause iTunes. And since it’s part of the firmware, it works and sends the same commands no matter what computer you plug the keyboard into (or if you use a virtual KV like Teleport, no matter which computer is receiving the keyboard and mouse events).

Getting Control over Caps Lock

So, one of the first things I wanted to do with my newly resurrected Apple Extended Keyboard II was to return to the “proper” behavior with respect to the horribly misplaced Caps Lock key.

As a developer, I make extensive use of OS X’s built-in text editing features, many of which have origins in UNIX. I use a lot of Control key shortcuts: Control-A to go to the beginning of a line, Control-E to go to the end, Control-N to advance to the next line, Control-P to go to the previous line, and so on… I don’t know the whole history of keyboard hardware development, but I’m sure there was some reason why Caps Lock got the placement it did, wrong as it was. Personally, I find using Control works much better situated next to the ‘A’ key.

Normally, OS X makes it very easy to change the behavior of the Caps Lock key (as we’ll see below). However, Apple’s mechanical keyboards use locking Alps key switches, which behave as a key-down-key-up with each press, rather than as a momentary key-down like other modifier keys. This means the OS can’t simply treat it as it does a non-locking switch (like on Apple’s new keyboards). These locking switches are easily modifiable though, as I’ll explain.

There are three parts to upgrading your Caps Lock to Control: One mechanical, one in the firmware of the adapter, and one in the OS.

[Edit 2015-01-19]: Actually, you don’t even need to fiddle with the OS. You can just change the firmware

Mechanical

1. You’ll need to remove the keycap of the Caps Lock key. I have a wire keycap puller, but if you exhibit a bit of care, you can gently pry the keycaps off.
2. You’ll need to gently remove the inner sleeve of the key switch. Watch this video to see the process in action. This is the housing where you’ll be able to remove the locking pin. If you accidentally pry out the entire switch, like I did, the best that will happen is you’ll break the soldering connection on the board, like I did, and have to clean it up, and re-solder, or you’ll damage the switch, possibly irrevocably. I was not too thrilled about prying out the entire switch, but I managed to reseat it, and get it cleanly soldered again.
3. With the inner housing removed, use tweezers to remove the small, plastic locking pin. Now you have a regular switch. Gently replace the housing in the switch, and replace the keycap. I saved the pin because reasons.

Firmware

All you need to change in Hasu’s tmk code is the keymap code for the Caps Lock key in keymap_ansi.c:

--- a/converter/adb_usb/keymap_ansi.c
+++ b/converter/adb_usb/keymap_ansi.c
@@ -6,7 +6,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     ESC, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12,           PSCR,SLCK,PAUS,                   PWR,
     GRV, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, BSPC,     INS, HOME,PGUP,    NLCK,PEQL,PSLS,PAST,
     TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS,     DEL, END, PGDN,    P7,  P8,  P9,  PMNS,
-    LCAP,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
+    CAPS,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,     ENT,                         P4,  P5,  P6,  PPLS,
     LSFT,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,          RSFT,          UP,           P1,  P2,  P3,
     LCTL,LALT,LGUI,          SPC,                               RALT,RCTL,     LEFT,DOWN,RGHT,    P0,       PDOT,PENT
     ),

Apply this change, recompile, reinstall the firmware, and reboot your Teensy.

Operating System

Open your Keyboard preference pane, select the “ADB keyboard converter” keyboard, and set Caps Lock to “^ Control”.

Now you have a Control key where it belongs.