Skill: Custom Breadboard/Molex Connectors

Disclosure: There are both affiliate and direct links to some of the tools and consumables used in this project at the bottom of the post.

We connect a lot of things to a lot of other different things. When prototyping, we use breadboards. A wire salad may look pretty, but it’s hard to debug and diagnose problems: let’s clean some of that mess up by creating some custom connectors to keep things a little bit neater.

(Okay, this is a contrived example, but when we start adding multiple components on a full-size breadboard, it all starts to make sense. Trust us.)

As part of our upcoming Maker’s End Inspiration Series of books we’re going to be doing a lot of prototyping on breadboards. Since many of the parts will be the same across projects, we thought it might be cool to have some pre-made jumpers for some of those parts. So we made some!

We’ll turn some pins, wires, pin holders, and heat-shrink tubing into a cable that’s exactly what we need: a double-ended three-pin jumper.

We’ll also need the usual suspects of tools:

  • Wire cutter
  • Wire stripper
  • Crimper
  • Pliers (maybe two)
Tools used
Tools

The operation will proceed much as you’d expect (but we made a video anyway, because we’re chatty, and sometimes it’s more inspiring to hear someone blab on instead of just looking at some pictures.

The pins themselves vary by manufacturer. These pins looked to be press-stamped, so instead of a “pin” it’s actually more of a U-shaped “channel”. This isn’t ideal: we’d prefer a higher-quality actual pin. They’re easier on the breadboard, stronger, and just all-round more pleasant to work with. But these aren’t awful, and they get the job done.

When you look at the non-pin end of the pin you’ll see some flared triangles: they grab on to the insulation and keep the wire from coming out. They often come too flared, though: we sometimes “pre-process” the pins so they’ll grab the insulation a little easier (makes the crimp go easier) and actually fit into the crimping tool.

Fixing flared pin by squeezing it
Fixing flared pin by squeezing it

Each pin is inserted (once it’s attached to a wire) into a “receiver” (the chunky part of jumper cables) that look roughly like this (we’ll get a better image).

pin receiver, what the pins are inserted into
Pin receivers

Let’s wire one up. We’ll also wire up a single-pin jumper in parallel in case you’d like to try your hand at a less-complex attempt first, before jumping into a complete jumper: basically a breadboard jumper wire instead of a set of wires.

Step One

Cut the wires to whatever length you want your jumper to be. Note that if you want to “bundle” up the cables (as we’ve done here with bits of heat-shrink tubing) you may want to make the “inside” wires a bit shorter, but it’s not that important.

Step Two

Strip the wires so they’ll make contact with the pins. Every pin has its own specification for how much wire to strip; these particular pins were about 1/4″ or so, but we mostly just eyeballed it.

After stripping the wires you’ll need to twist them together, tightly, especially if you’re working with one of the super-flexible “crazy” wires, otherwise it’ll be difficult to seat the wire in the pin correctly.

Step Three

Lay the wire in the pin. The large “wings” on the back of the pin grip the insulation, keeping the wire in the pin. The electrical contact is made further up the pin by the next, smaller “wings”.

The wire should be inserted into the “channel” near the end of the pin. This ensures good contact (and is where the precision stripping comes in to play). It’s often easier to strip a little bit extra and trim to fit.

Step Four

Crimp it! The channel side should be in the “receiver” of the crimping tool: it has bends in it that force the “wings” down into the insulation and over the wire. It’s basically a stapler, where the pin is the staple, and the wire is the paper.

Just squeeze the handles to crimp.

If you see what’s in the image below, try to remove the wire and pin from the tool–here the wire has crept out of the pin; this will lead to a bad crimp, and poor (if any) connection, and the wire is likely to pull out.

shows the wire falling out of the pin right before crimping
The wire is falling out 🙁

Revel in your handiwork. The black wire was a good crimp, the red wire got inserted a bit, and some insulation has gotten into the connection area. When this happens the connection may or may not be solid (in this case it was).

Step Six

Once you have pinned all your wires they can be inserted into the connector. The connectors (usually) have a little arrow showing which direction to insert the pins. Sometimes the pins stop where they’re supposed to, sometimes they don’t.

We usually start them by hand, possibly nudging with a pair of pliers, then often (usually) need to pull them the rest of the way through by gripping the receiver with pliers, gripping the pin with pliers (gently, especially these cheap ones), and pulling until we see the “channel” part of the pin in the little window.

If you’re making a simple jumper wire you might want to add some heat shrink tubing. It provides a little bit of strain relieve, provides a handle to grab on to, and just looks nicer. Here the size we chose is probably a little large.

For the connector block you can add some heat shrink tubing at strategic locations to help keep things neat.

completed jumper cable
A little heat shrink tubing keeps wires together

Lather, rinse, repeat. We made a half-dozen three-pin jumpers that we can use for NeoPixels or servos and several four-pin connectors for I2C devices. The four-pin I2C connectors only have a connector on one end (power, ground, SDA, SCL) while the other end are normal breadboard pins: this lets us hook up I2C devices all neatly on the component side, and hook up the Arduino side where we need to: on the component, already breadboard-ready, the pins are right next to each other. On the Arduino side the pins are separate.

Product Links

We’ve used all of the products below. The Hakko tools come highly recommended. The connector sets are adequate (and cheap) but we prefer higher-quality pins. For the price they’re okay. The affiliate links come first, followed by direct links, and are labeled appropriately.

Affiliate Links

Direct Links

Review and Build: Pimoroni Keybow, a blinky auxiliary keyboard

We love our keyboards, from mechanical to split to Apple Magic. We also love our shortcuts, and even with a zillion macro programs, we still sometimes “need” dedicated keys for our most-used apps and application shortcuts (here’s looking at you, every CAD program ever).

We’re purchased a multitude of commercial keyboard “extensions” over the years, from industrial-strength over-priced 16-key strips to products designed for video editing. We’ve put together several cobbled systems using touch screens and Arduinos and Raspberry Pis. They’ve all worked, to some extent (we’ll detail some touchscreen builds in an upcoming post since they’re quite similar to this product, and provide extra blinkage).

We were attracted to this product because it’s a mechanical solution, and its underlying platform has extra capabilities and versatility: this is a 12-key matrix with an RGB matrix under each key, powered by a Raspberry Pi Zero WH. This opens up a world of keyboard possibilities and hacks.

It’s (marginally) pricey at £49.98 (about $65USD plus post) so it won’t be saving you much money over commercial solutions, but the open platform and trivial hackability are attractive. That said, if you already have a keyboard that suits your needs, you might be better off hacking in the RPi yourself. But we love Pimoroni and throw money at them often, so yep.

What’s in the Box

PARTSES. There’s the Pi0, a PCB for the keys, the keys, the keycaps, two acrylic plates, rubber feet, and connection hardware.

You’ll need a micro-SD card, so be prepared. We were not, and had to wait.

But it can be a small one, they claim a 1G card is sufficient. We used 8G because we had them.

The problem with micro-SD cards? They’re micro, and we’re old.

The board includes an I2C breakout for adding peripherals (we’ll use this in an upcoming build) and runs a mini-Raspbian OS called Keybow OS to get things done. Interface customization is handled by Lua, an embeddable scripting language with great functionality.

The Build

This is not a tricky build: there’s no soldering, just press-fitting and screwing a few tiny screws and bolts that our fat fingers occasionally dropped: it wouldn’t hurt to have a few extra M2.5 parts on-hand just in case (we buy them by the mixed-case every now and then; we’ll throw up a post about keeping the shop stocked some day).

The assembly docs on the Pimoroni site do a great job of piecing it together; we’ll add a few details, but generally just follow their docs.

Prepare Baseplate

  • Remove protective sheets from acrylic parts (we hate this part; be careful on the thinner spacer piece).
  • Stick on little rubber feet. (Unless you’re going to mount it some other way, like in a 3D-printed stand–see below!)
  • The “Keybow” text should be on the lower-left, facing you, not backwards. This is the bottom of the device.

Attach Raspberry Pi Zero WH to Baseplate

  • Use two M2.5 screws and nuts on the front of Pi0 (the long edge with the USB ports) to attach to the thicker baseplate.
  • Attach it to the side without the rubber feet, e.g., the “inside”.
  • Don’t over-tighten the screws; acrylic loves to crack.

Attach Keybow PCB

  • Remove standoffs’ protective film on pCB ferrules
  • Mount standoffs on the PCB
  • Line up the Pi0’s GPIO pins with the header on the PCB.
  • Press to fit; support whichever side you’re pushing against.

Mount Switches

  • Push each switch through the “gold leaf” PCB, from the gold leaf side down. Make sure each key is seated evenly.
  • The “gap” on the underside of the keys (where the pins are, and where the plus-shaped plunger/switch is not) should be oriented to the top of the gold leaf PCB.

Mount Keycaps

  • Press each keycap onto the switch. They’re all the same, and symmetrical, so orientation doesn’t matter.
  • Support the bottom of the switch when you press: it’s a tight fit.

Mount the keys to the PCB

After the pins are all aligned just push it into the PCB, firmly and evenly.

The Software

The Keybow runs a tiny version of Linux based on Raspbian. To install it onto the SD card download the latest ZIP or TAR file from the Keybow OS GitHub Releases page. Un-archive it and copy the files from the sdcard directory to the root level of your SD card.

To restate: everything under the sdcard directory (highlighted in the image at right) should be at the top level of the SD card’s root directory.

The Default Layout

It’s a numeric keypad like on a PC keyboard, e.g., 7-8-9 are on the top row, and 0-.-[ENTER] are on the bottom row, when the USB cable is sticking out the right-hand side of the Keybow.

It also comes with some sample macros; we’ll discuss updating them, various ways to poke the RGB LEDs, and some more fun stuff. We’ll be using it horizontally, and will detail macros, customizations, and using the Pi0 in our next (and final?) Keybow post.

Smoke Test

  • Put the MicroSD card into the Raspberry Pi
  • Plug in a USB cable
  • You should see some blinky lights

Any Problems?

If we have any complaints it’d be around the USB cable location and cutout. We would have preferred the RPi be firing towards the back so the USB cable would have a straight shot out the rear. Barring that, a larger cutout for the USB plug itself to support right-angle connectors so the cable could run out the side might have been a better choice.

Additionally, we had to hunt around to find a Micro USB cable that would seat properly in the keyboard due to the small size of the cutout. The problem was at least partially solved when we broke the thinnest piece of the spacer acrylic by accident: you may want to break it on purpose.

Going Further

3d printed keybow stand
3D Printed Keybow Stand

Naturally we built a small box for it; the design is available on Thingiverse. The initial version for sizing is a bit tight, and keeps the entire build visible. We might do a version with taller walls with a slot for the USB cable. The rubber feet were stuck on the bottom of it so it wouldn’t slide. (It’s not hollow; hollow might be better to allow adding some weight.)

Instead of mounting it on its rubber feet you might prefer to drill out some holes, countersink the board-side’s holes, and screw it onto a platform (like at an angle). Or omit the rubber feet and 3d print a small angled platform with some spaces for the screw heads. Like we did.

Resources

Quick Look: Shop-Vac® Micro Wet-Dry: An Itty Bitty Vacuum

Disclosure: Post includes Amazon Affiliate and direct product links.

Continuing our trend of sucking, we picked up new under-desk vacuums and have to say–this is our current under-desk vacuum of choice, and includes a mounting plate that lets us stick it just about everywhere.

It’s not a full-power vacuum like our Rigid vac (which we’ll review, and was briefly mentioned in our Print: Vacuum Dust Collector for Wall Drilling post) but for our main desks (e.g., computers, some soldering, and an inappropriate amount of sanding), it’s pretty great.

It’s a one-gallon, 1HP, 1.25″ hose (but as noted below, it has a long taper, so some accessories might not fit without tweaking) and takes a filter bag if you’re not using it for wet stuff.

ShopVac Micro

It’s small, so very small. It ships with a bag installed–so while it’s totally a wet/dry vacuum, go ahead and remove that bag before resolving your Pepsi Syndrome with this little guy.

It ships with only flat and crevice tools, which is mostly-okay, although a few more tools would have been nice. We’ve also hooked it up to a number of micro-vacuum attachments with a 3d-printed adapter (yup, we’ll post about that as well) and sort-of works out-of-the-box with the afore-mentioned vacuum dust collector attachment–but the stock hose tapers from ~1.21″ to >1.25″ so it’s a bit floppy. We’ll have to modify the attachment to have a longer hose attachment area (or just cut the stock hose). It’s powerful enough to stick the DC attachment to the wall even with the non-fitting host diameter, so it’s more than sufficient for our desk vacuum needs.

(In fairness, when we’ve discussed this with other folks, they’re unsure why a desk needs a dedicated vacuum. IT’S OBVIOUS, OKAY????)

There’s also a convenient handle that folds on top–it’s not a nice flat surface like the Rigid (boo, we like things that stack) but it’s handy. The only thing we find lacking are mount points for the tools on the vacuum itself: there’s a bracket that (apparently?) is meant to mount on the wall next to the vacuum–we might repurpose it and stick it on to the vacuum itself, or just print something we can epoxy on the side so we don’t have to screw into the canister.

At ~$34 on Amazon we grabbed four, two of which are already mounted and in consistent use. It’s micro, it’s a vacuum, it’s really convenient. It became even more convenient with a quick remote switch so all we do is grab the hose and start sucking.

Product Links

Print: Vacuum Dust Collector for Wall Drilling

Rounded version of dust collector

Disclosures: This is one of our designs; the STL is available on Thingiverse. There’s also Amazon Affiliate and direct links to the Rigid “toolbox style” vacuum mentioned because it has quickly taken over our “Oh we always need a vacuum right here” needs: we have one under our main work desk and one under the pallet rack where our 3D printers and one of our CNC machines live.

We had to do a bunch of drilling into the wall in an area that was already populated with furniture. The solution? Spend hours designing and tweaking a 3D-printed dust collector. The design went through two major iterations: an angle-y one, and a roundier one.

Design Process

We do most of our print designs in Fusion 360. For the most part, a great app (but often crashes on coils) and for relatively simple stuff like this, perfectly adequate. The plethora of online resources for learning and using make it hard to beat for the pro-am maker.

More angled vacuum dust collection attachment
First, angled version

The original design (more angled version) worked great, but wouldn’t stick to the wall by itself. Why was the air path not an oval? Not sure–that’s just how it started out. Why was sticking to the wall by itself valuable? When working solo it’s actually convenient when drilling into wall studs; when just plowing through drywall you don’t need two hands on the drill anyway.

Rounded version of dust collector
More-rounded version; sticks to the wall!

We corrected most of the airflow problems by un-boxing the air path to the collection inlet and de-complicating some of the geometry where the main dust collection hole is.

One issue we ran in to (and why there’s such an aggressive taper) is that keeping the drill from bumping into the DC attachment we had to rotate one or the other or both. While it definitely has an impact on airflow, it also means we don’t have to get all wrist-twisty to complete even deep holes.

What’s Next?

We’ll put up some designs for other hose diameters (notably a 1 7/8″ one for our new Rigid “toolbox style” vacuum, which we’re loving!) and we’re likely going to further widen and smooth out the main airflow path into the hose so it’ll be even suckier.

We’ll also be doing quick reviews of both our Ryobi One+ (18V) tools and cute little Milwaukee M12 (12V) tools, which we’ve started using for almost all of our work: they’re perfectly adequate for most “utility” drilling, lighter, and smaller than the Ryobis.

Why did we start messing with the Milwaukee M12 series? We specifically wanted something small, light, and versatile–and they had an M12-powered inspection scope. That started the buying spree, and now we’ve duplicated many of our Ryobis with the smaller M12 form factor, and couldn’t be happier. But we’ll keep using both.

Resources

Quick Look: DFRobot Beetle BLE

Beetle BLE Front

Disclosure: This post contains affiliate and direct product links.

We have several projects that have low pin counts and require some form of connectivity. We found the DFRobot Beetle BLE to be a great fit for those projects (some of the builds will be documented; we’ll update this post as the build posts are updated).

A (tiny!) Arduino Uno-alike with on-board BLE, perfect for low pin count projects that require BLE connectivity.

Basic Features

It’s basically an Uno with a reduced pin count, so you get the expected functionality, just less of it:

  • ATmega328@16MHz
  • Digital: 4
  • Analog: 4
  • PWM: 2
  • UART: 1
  • I2C: 1
  • Micro USB: 1
  • ~ 29mm x 33mm

There are also dual ICSP interfaces (unpopulated), one for the 328P, and one for the CC2540 BLE chip.

The docs state it’ll take up to 8V (although we’ve only ever used USB or a reasonable 5V supply).

The I2C (SCL/SCA) and UART (TX/RX) pins are also broken out on the bottom of the board as pads: you’ll need to tweak your normal dev process if you plan on utilizing that functionality.

The Play Bluno app (iOS, Android) app allows interaction with the board, but any reasonable Arduino/BLE app should work.

Using The Beetle BLE

It shows up as an Uno–doesn’t get much easier than that! Under OS X the port shows up as a USB modem as you’d expect, with the additional “Arduino/Genuino Uno” tag. Since it’s an Uno, all default Uno sketches (that respect the Beetle BLE’s limited IO) should work right out of the box.

What is it not for?

  • IO-heavy projects
  • WiFi
  • Forget standard headers and breadboarding 🙁
  • Trivially mounting: it’s an odd shape (wearables, anyone?)
  • TODO 3D Printed Simple Mount

What’s Next?

We’re writing up a complete review with some tips for getting started and simple starter apps. We’re also using the board to power a tracked smart car chassis–both the chassis and build project will have their own posts.

Competition

There are a lot of similar boards these days, our favorites are products from the Adafruit Feather line:

Those are larger boards with a full complement of IO, and a wide variety of add-ons (“Feather Wings” in Adafruit-speak). For demanding projects they’re probably a better choice. (Quick and full reviews coming, naturally.) They’re also more expensive (by about $10-15), so if you don’t need the additional power for a specific project, the Beetle BLE is a great little board.

Reference Links

Product Links

What’s Coming?

We’re going to kick the blog off with a few microcontroller reviews followed by some quick projects powered by those boards, and a few tool reviews.

We have an awful lot of things in the pipeline that we’ll try to push out at soon as we can: some woodworking projects for the office and home, some craft projects, and some EBTKS (Everything But The Kitchen Sink) projects that combine pretty much everything we know how to do here (and a few things we’re still figuring out).

In the meantime, you can peruse our 3D designs at Thingiverse (with an unhealthy focus on pen holders, but there are workshop and electronics projects as well) and stay tuned: there’s tons to come.