We're back with a new one - Sonos and Ikea have updated the Symfonisk for Gen2.  On the outside, not much has changed.  Same shell, same buttons, same speakers.

If you haven't seen the first article on why this thing is so cool, please head to that post right now.  So what's in the Gen2?

• Most important for this guide is that both the DAC, a TI PCM5102, and the amp, a TI TPA3116D2, are exactly the same.
• The NXP MCIMX6X2EVN10AC CPU is unchanged.
• The Maxim 78Q2133 is still around for ethernet with a slightly newer revision, but this time we get the ethernet port on a daughterboard.

There are some really noteworthy changes though:

• The memory has been doubled from the 256mb NANYA NT5CC128M16JR-EK to the 512mb NANYA NT5CC256M16ER-EK.
• The Atheros AR9582-AR1A PCIe daughterboard for wifi has been replaced with a Mediatek Mt7613DEN - a chip that, like the Atheros, doesn't have much public documentation.  But it supports 802.11ac - a nice upgrade and much more compact.
• New! - An Infineon CY8C4128LQI-BL543 chip and separate antenna for a powerful programmable Bluetooth and BLE ARM chip.  What's strange is this isn't enabled as far as I can tell but all the hardware is present.  Very strange to spend the money on the IC and leave it turned off.
• All of the power distribution has been offloaded to a daughterboard with only a clean 24vdc coming onto the main PCB.

Enough of the speeds and feeds, you're here to mod.  Fortunately this time around is actually a little easier (if you have steady hands) than the Gen1.

What do you need?

Following this guide takes about an hour and a half start to finish, taking your time along the way.  The last amp mod I did I timed at 43 minutes.  So not a ton of time to invest.

If you're a DIYer already, there's also not much to spend.  At an absolute minimum you need some binding posts, a Symfonisk Speaker and a ceiling speaker for each output location.  So for a two speaker setup, minimum cost is $320.  Thats 75% less expensive.

If you're totally new to DIY, and have to literally purchase every single tool, you're looking at about $600.  Still a 52% savings.

And if you want to follow this guide and make your own enclosure, throwing in the cost of a decent 3D printer and filament, is still 29% less expensive at about $900.

Follow along with the video guide

A video guide for Gen2 will be coming very soon.  In the mean time you can follow the Gen1 video guide here for the basics of disassembly

Modding the DAC (Digital to Analog Converter) and the Amp

The DAC, a TI PCM5102, is located on the bottom of the PCB.  We can check the pinout to see the work we'll need to do. The amplifier on the Symfonisk speaker is the TI TPA3116D2, a two speaker amplifier allowing 30 watts per channel in stereo mode, or 100 watts in a bridged mono mode.  If you want to see all the pinouts and details of the wiring scheme below, please see the Gen1 Article.

Just like on Gen1, we need a jumper across the Left and Right DAC outputs, to cut the traces of the Left +/- pins to the amp, and then to bridge the Left channel amp pins to ground.

Desolder the capacitors for Left +/- as shown.  It's much easier to do this by adding some additional solder first, then wicking it all away.  Apply light pressure with your soldering iron to one side to "lift" it out.  I needed to set my Hakko station to 400C to get enough heat to pull these caps loose.  DO NOT PRESS HARD or you will lift the pads below these caps, effectively destroying the board.

I recommend using Kapton tape both underneath the jumper wire, as well as to "mask" both sides of the amp when bridging pins 9/10/11 to avoid a solder blob disaster.

Double check you aren't bridging any pins - it is very easy to do if you aren't careful here.  Take your time.

Bridging the speaker output wires

Now the hard part is done.  The last step is handling the new output wiring.

Fortunately this is pretty easy too.  Most binding posts use the same terminal connector as the large connector on the Symfonisk.  So clip off the end of the small one, solder the red/black and white/blue ends together, and Bob's your uncle.

Red/Black is your new positive wire, and Blue/White is your new negative wire.  You could also directly wire new leads from the PCB, but there's really no purpose in doing so.  The output pads are already sized for this gauge wire, you aren't going to get much out of using heavier gauge, or combining into a single wire at the PCB given the very short run length.

Hook them up to some binding posts and connect your speakers.  Then turn everything on, grab an iPhone and run TruePlay tuning on the speaker.

Using a custom enclosure

Due to the completely new PCB layout, I've designed an updated custom enclosure for Gen 2.  You can download the design from my page on cults3d.

Dimensionally it's very close to the same size, but the layout for Gen2 is far more compact.  All cables exit the same downward facing direction and within the volume of the body, making cable routing and management in attics and ceilings much more manageable.  (Yes I have fixed the hangers the right way round in the downloads).  

If you don't have a 3d printer and would like to order this case directly, I am offering it directly through this site including the binding posts.

The BOM (Bill of Materials) for this project

Here's the list of everything you could possibly need to get this mod done.  You probably have most of it already.  The products below are either ones I personally own, or if I ever needed a replacement, what I would personally purchase.

Like so many in the homelabs community, I finally got ahold of the SC846 chassis and found it to be almost perfect - except for the loud stock fan wall.

There are many other options out there for 3d printed 120mm fan walls.  But they were all pretty janky, relying on friction fits or a bunch of extra parts and fasteners.

So I set out to create a drop in replacement, that leverages the same mounting points, the original screws, tight tolerances to maximize air pressure differential, and minimum airflow impedance for the fans.

This design can be printed on almost every mainstream FDM 3d printer - Enders, PRUSAs, et al.  You can grab the file to print yourself here for $1.70.

Update - 7/29/23:

I have revised this model with a new iteration that makes is possible to print on smaller printers (now requiring only 200x200mm footprint) as well as making it easier for me to pack and ship for custom orders.

Supermicro SC846 120mm Fan Shroud

3D Printable Fan Shroud for the popular Supermicro SC846 server chassis to use 120mm fans instead of the stock 80mm fans. Printed in two parts so it can be printed on most printers (large part dimensions are 242mm x 138mm, so it will print on PRUSA printers). Assembles using the original screws.…

Cults.

If you don't have a 3d printer, and really want this made for you, I'm offering this made-to-order for $30.  

Hopefully you've already modded your Ikea Symfonisk.  If not, check out that article first.

Now you want to put it in a snazzy new case.

First, head over to cults3d and download the files.  Yes, I'm asking a very small amount to try and recoup the hundreds of hours put into making it easy to print and documenting the whole process.

Now lets dive into the assembly process.

Step 1 - Mounting the Heatsink

While you shouldn't need to ream out any of the post holes, if you find them too tight to screw into ,use a 3/32in (3mm) drill bit.  Make sure to use the flat ended screws to mount the heatsink to the bottom case piece. Do not overtighten!  Turn until there is no jiggle between the heatsink and case.

Step 2 - Mount the Button PCB and Soft Buttons

The top two screw posts on this section are for the main PCB mounting.  While you shouldn't need to ream these out, test using a bevel ended screw (non-flat tip) and if needed, drill out with a 3/32in (3mm) drill bit.  

The 4 smaller screw posts do not need to be drilled out at all.

Insert the Soft buttons into the case.  Using the 3/32in drill bit, ream out the 4 holes on the Button PCB to ensure it smoothly fits on the 4 alignment posts. Then place the black assembly holder from the original Symfonisk on top of the button PCB and screw it into place.  Do not overtighten!  You just want a barely snug fit.

Step 3 - Snap lower case parts together

The pieces snap fit together, and should be a very tight fit by design.  The side without an inner lip should be oriented towards the button cutouts.

Step 4 - Mount the speaker posts

Grab your speaker binding posts, this case is designed to use the Conway 4mm Banana Plug Socket Binding Posts, but should work with any 4mm binding posts. Mount the terminals at an angle as shown, away from the main PCB.  Connect the speaker wires to the posts and them push them down flat into the case.  Be sure to use lock washers to hold everything tightly in place.  Blue/White is negative terminal, and Red/Black is Positive terminal.

Step 4 - Mount the Main PCB

The PCB Mounts by first sliding the power connector corner under the power connection boss in the case.  Push the PCB as far forward under this boss as you can and it will just clear the rear bosses for screwing in the top plate of the case.

Push the PCB down then push it away from the Button assembly to the back of the case.  It should line up with the Heatsink and case mounting posts with very little adjustment.  You should use the tapered screws for all 6 mounting points for the main PCB.  Again do not overtighten.

Step 5 - Mount the power connector

The power connector uses a friction fit with two screws.  It will be very tight.  If you printed with supports, make sure they are fully removed.  If you printed without supports, make sure there was no drooping.  I use a pair of slip-joint pliers with paper towels as cushion to force the connector into it's slot fully.

Then use a right-angle / offset screwdriver to put the two screws into place for the power connector.  They only need to be put in until snug, do not overtighten.

Plug in the power cable to the PCB. Press the cable down so it will comfortably rest within the space of the case when the back plate is put on.

Step 6 - Connect Button PCB Cable, Speaker Cable, and Mount Wifi Antennas

Connect the button PCB flex cable, pins down.  Connect the Speaker cable.

The mount the Wifi Antenna blocks as shown.  If you weren't able to save the original double-sided tape when removing them, apply double sided tape to the bottoms.

Step 7 - Put the back plate on and close the case

Like with the other parts, you shouldn't need to ream out these holes, but if you find them too tight, use a 9/64in (4mm) drill bit to ream the holes out for a better fit.  Use 4 of the large case screws from the Symfonisk speaker case plate, and optionally cover these 4 screws with 4 of the feet from either the bottom or side of the Symfonisk case.

Now you can mount your Amp to any wall, ceiling, or stud!

BOM (Bill of Materials)

Here's the list of everything you could possibly need to get this mod done.  You probably have most of it already.  The products below are either ones I personally own, or if I ever needed a replacement, what I would personally purchase.

Perhaps you've heard of Sonos.  I have been a fan for a long time, but the prices for their products have always been far out of my financial reach.

Then Ikea started selling the Symfonisk Bookshelf Speaker for $99.00.  I bought three.  I love them.  Brilliant sound, beautiful design, simple interface.  Ikea even sells wall mount hardware for them.  After living with them for a few months, I realized that in my bedroom and bathroom, I wanted SONOS, but I didn't want a bookshelf speaker taking up the space.  Like any other nerdy home owner, I wanted some cool in ceiling speakers instead.

So imagine my shock and awe when I went to order two in-ceiling Sonos speakers and almost choked at seeing the price - $1248 for two speakers and a Sonos Amp.

Surely there must be a better (cheaper) way.  Fortunately there were several amazing folks who paved the way for this solution.  First for me is Mr. Todd Parker whose YouTube Videos on various Symfonisk Hacks were instrumental.

Next was this amazing article explaining the Mono Bridge mode on the TPA3116 Amp (the same amp in the Symfonisk speaker).

This laid all the technical groundwork to prove that the Symfonisk speaker should work as a general purpose mono speaker amp.  But how well does it work, how much money do you really save, and is it really worth the hassle?  In a word, absolutely.

How much value is there?

Following this guide takes about two hours start to finish, taking your time along the way.  The last amp mod I did I timed at 43 minutes.  So not a ton of time to invest.

If you're a DIYer already, there's also not much to spend.  At an absolute minimum you need some binding posts, a Symfonisk Speaker and a ceiling speaker for each output location.  So for a two speaker setup, minimum cost is $320.  Thats 75% less expensive.

If you're totally new to DIY, and have to literally purchase every single tool, you're looking at about $600.  Still a 52% savings.

And if you want to follow this guide and make your own enclosure, throwing in the cost of a decent 3D printer and filament, is still 29% less expensive at about $900.

Follow along with the video guide

My video guide goes through in depth the full process and disassembly of the Symfonisk itself.  This article will focus on the details, pinouts, process, and alternatives.

Modding the DAC (Digital to Analog Converter)

The DAC, a TI PCM5102, is located on the top of the PCB.  We can check the pinout to see the work we'll need to do.

Basically, in order to use the amp's bridge mode, we need to create a two channel crossover to recombine the separate audio channels into a mono channel.  Even though this is a stereo DAC, Sonos uses it as a bi-amp mono DAC.  The audio input (pin14) is separated from the CPU into frequency bands to match the two speakers in the Symfonisk.  This work has already been done for us by yondermogul at Instructables.  

In a nutshell, we need a jumper across these two pads next to the capacitors.  If you're really into hi-fi, and really good at tiny SMD component soldering, you could probably get a little better performance from the cross-over by swapping the 4.6Ohm resistor for some 10k's.  But it really isn't necessary because we can still use TruePlay tuning to fix up everything after installation.

These are the two basic options for bridging.  On the left is using a very small piece of bare jumper wire.  There are no exposed traces between these pads, so you don't need a shielded wire to make the connection.

On the right is using a piece of 24ga or 28ga silicon wire.  I highly recommend this method. It is much easier, faster, and cleaner.  Also easier to remove if you ever want to reverse the process.

Modding the Amp

The amplifier on the Symfonisk speaker is the TI TPA3116D2, a two speaker amplifier allowing 30 watts per channel in stereo mode, or 100 watts in a bridged mono mode.

The amp is located on the bottom of the PCB and is the reason for the huge heatsink on the Symfonisk.

Fortunately, thanks to the combination of a great article and great documentation, this is a pretty straightforward process as well.

Basically, we need to only use the right inputs, bridge the left inputs to ground, and combine the outputs into right channel for positive, left channel for negative.

Once again there are two approaches to this.

On the left is the preferred method.  Desolder the left channel inputs, pins 10 and 11, from their pads, lift them with a utility knife, push them onto pin 9 (ground), and drop a little solder on the trio.  This approach is easy to reverse to put the amp (and the whole Symfonisk speaker) back into its original state.

On the right is the "easy" way.  Use a utility knife to cut the traces as shown, then drop a solder blob across the three pins.  This takes a minute or less, but it means you can't ever use the Symfonisk as anything other than a mono amp after this.

Bridging the speaker output wires

Now the hard part is done.  The last step is handling the new output wiring.

Fortunately this is pretty easy too.  Most binding posts use the same terminal connector as the large connector on the Symfonisk.  So clip off the end of the small one, solder the red/black and white/blue ends together, and Bob's your uncle.

Red/Black is your new positive wire, and Blue/White is your new negative wire.  You could also directly wire new leads from the PCB, but there's really no purpose in doing so.  The output pads are already sized for this gauge wire, you aren't going to get much out of using heavier gauge, or combining into a single wire at the PCB given the very short run length.

Hook them up to some binding posts and connect your speakers.  Then turn everything on, grab an iPhone and run TruePlay tuning on the speaker.

Using a custom enclosure

Since we aren't using the speakers anymore, it doesn't make a ton of sense to use such a large enclosure for an amp.  It definitely saves money to do so, but if you want to go the last mile and put this project in a fit for purpose case, check out the companion guide for the 3d printed Sonos Amp enclosure here.  As you can see it's less than half the size and is designed to be mounted to a stud nearby your in-ceiling speaker.

The BOM (Bill of Materials) for this project

Here's the list of everything you could possibly need to get this mod done.  You probably have most of it already.  The products below are either ones I personally own, or if I ever needed a replacement, what I would personally purchase.

One of the last big challenges in building a prototype AR headset was in producing the custom earpieces required in an extremely tight timeframe. We needed to deliver 100 headsets to users to begin a field trial.  We had 3 weeks to get them produced, assembled and shipped.

It started with a 3D Print.  Ideally I'd have used an SLS or SLA printer at Microsoft, but with such short notice all of the machine time was booked for several weeks.

So on to the home FDM printer.  Since the parts are very small, I went with the highest detail possible, 50 micron layers.

I printed a pair and then spent the next 8 hours sanding, priming, painting and finishing these.  They would become my master.

The next step was making molds.

Normally with short runs, I make a single mold with multiple sets per cast.  Especially with small parts like this, mixing batches of thermoset plastics gets tricky below a certain volume.  When you're mixing in milliliters, the losses from stirring and scraping can really add up.

In the example above, we calculated the volume of the parts using area calculations (Rhino3D in this case) times the depth, then added 20% for losses and spillage.  This ensures you have enough resin to fill the mold, without waste and give repeatable results for color/addons mixed in.

In this case though, I did some back of napkin math and knew I didn't have the time to create multiple master copies.  So instead I made multiple molds from my single printed originals.

The process started as normal - I used foam board and hot glue to build up mold boxes.  This works really well for molds that are only a few inches in size.  Using plasticine modeling clay, I built up a base on the bottom board.  This is a two part mold, so I did my best to get the parting line along the middle of the ear piece arms.  Then I hot glued on the sides of the mold box and filled in more clay to the halway point of the box.  I added mold keys to make registration for the two parts easier, and purposefully kept the halves with some surface movement to increase surface area.

Time for sprues.  I used Bamboo Skewers for this, they are easy to cut and provided a controllable contact area to the parts.  I clipped the points of the skewers to the width of the area they contacted, and experimented with different numbers and orientations for the sprues.

The image above shows one of the earlier sprue configurations. Highlighted in red is where I relocated the inflow sprue for later molds to more evenly distribute the plastic.  I had issues with air bubbles in the left wing of the loop (closest to the red mark) before moving the sprue orientation.

The sprues are also aligned halfway into the clay, to ensure they can be removed from the two part mold easily.

Finally, I sprayed mold release over the clay, part, box, and sprues.  This is absolutely critical.  I sprayed two light coats, then used a small paintbrush to make sure it covered all areas and especially corners, and then sprayed one more light coat.  Better a little too much than too little.

Next step was mixing the silicone.  I used Smooth-On Mold Star 30, a good multi-purpose two part silicone.  Again some basic math there - measured the interior of my mold box, divided the volume by two and added 20% for margins.  With molds this small, precision is pretty important.

You should always degass silicone, preferably with a vacuum chamber (I have a kit from Best Value Vacs that they no longer sell).  A single stage pump will save you a lot of cash, but at the expense of speed and lower vaccum pressure.

Next up was the pour - slowly, starting at the lowest point of the part itself, filling up and out.  Filled to the top of the mold box.  I made sure to place the mold on a level surface, to keep the surfaces square with one another.

After the mold had cured, it was time for part 2 - making the 2nd part of the mold. I pulled out the bottom of the box (using an exacto knife) and pulled out the plasticine clay and original parts.  Cleaned the mold release from the original part, then inserted it int to the silicone mold.  I reused the sides of the mold box and sprayed mold release over the silicone and original part following the same process - coat, brush, coat.

Mixed a 2nd batch of silicone, degassed, and poured.

The last part of the process was casting.  I chose Smooth Cast 327 for this project for several reasons - it has a relatively high shore strength, but because it's still a urethane resin, it will flex under strain, rather than snapping.  It also works well with pigments and had the best balance of pot life (20min) and cure time (4hrs) for my equipment.  

I added and mixed the pigment (So-Strong Black) to part B as instructed, and mixed the resin parts 1:1 by volume using glass eye droppers.  Even with these small volumes, I still degassed the resin before pouring.

Finally, using plastic syringes, I pulled all of the resin into one syringe.  I put a second syringe into the top sprue opening and then injected the resin into the lower sprue opening.  I "pumped" the syringes back and forth, adjusting the vertical position so the injecting syringe was always horizontal and receiving syringe always vertical.  This let me get out any tiny air bubbles in the mold.

Because the inner tip of the syringe is silicone, I was able to reuse the syringes for many castings.  I used a small screwdriver bit to clear the syringes after the resin cured.

It took the better part of two days, but using this process I produced 100 pairs of ear pieces that were assembled and shipped on time.

Lessons learned

If I had to make these parts again today, I would 100% use an SLA printer instead.  The price of SLA printers has come down so far and the availability of tailored resins has made this kind of casting all but obsolete.

That said, I learned a lot along the way.

• Unfortunately in our rush we forgot to add indents to the assembly so the earpieces would snap-fit onto the headsets.  This meant we had to epoxy the earpiece into place.  It turns out there aren't many adhesives that like to stick to both ABS and Urethane plastics.  If we could have a redo, I would have put in a separable snap fit.
• Mixing pigment requires a LOT LESS pigment than you'd imagine.  A little goes an incredibly long way.
• You can cut sprues into your silicone mold after the curing the silicone.  I had to do this for my first mold, as I forgot to add them initially.  It worked, but only just.  Don't do this if you can avoid it. Put your sprues in ahead of time.
• Don't forget your mold release.  Triple check it.  Follow the directions for whatever release you use.  Don't skip steps, especially the brushing step.  I ruined a mold pouring the 2nd part this way and it took me an hour to get the original part back out without damaging it.  Having a part in the middle of a solid block of silicone is a guaranteed bad day.
• Plan ahead.  Unless you're extremely fortunate to have a Tap Plastics or other specialty plastics supplier locally, you will have to mail order everything and because they are chemicals, they will all be shipped via ground/freight.  So getting materials overnighted isn't usually an option.  Buy at least double the volume you think you need.

A few years ago I had the good fortune to work on an amazing project at work - Microsoft Soundscape.  My team at Microsoft joined the effort and delivered a truly awesome experience over the 8 months of work we put in.

You can see some of my work on the software side of this project here.  This post is about the other half of the work we did.

The hardware to make this experience work consisted of 3 components -

• iPhone
• Stereo headphones with integrated IMU
• A remote control

This project was created in Spring 2016, predating IMU integration into any commercial headphones and assistant integration into headphones.  Additionally, wake-word capability wasn't available on custom devices from any vendor (at least not without NDAs).

The project started as a Windows Phone application, but one of my first contributions to the project was to move development to iPhone and iOS (visually impaired smart phone platform preference 2014 86% iOS
2017 80% iOS.

So all that was left to do was to integrate an IMU into a pair of headphones and make a basic remote control that could be paired via bluetooth to the iPhone.  Easy right?

Designing and building an AR audio headset

The first headset - Aftershokz + Sensor Tag

After a significant amount of ethnographic research with Guide Dogs members, we had a very clear set of minimum viable criteria to a headset.

• It must appear like a standard commercial set of headphones.  Users did not want to wear or carry any device that appeared as a medical or special assistance device.
• It must not obscure environmental sound.  Blind users literally depend on their heightened hearing to get envrionmental cues for wayfinding and danger avoidance.

In addition to user requirements, we had several more:

• Must pair as a standard bluetooth device to iOS
• Device management (pairing, charging, storage) can be handled by the end-user, no IT specialists or care assistants.

When I joined the project, the team had been using the Aftershokz Sports M3 and attaching a TI CC2560 SensorTag to the back.

This worked in meeting the above requirements initially.  However a few problems in the user experience popped up that made us switch directions.

First was the SensorTag.  It has incredible battery life, close to a year on a button cell battery (and TI advertises this heavily).  What they neglect to mention is that this battery life claim is with the IMU turned off.  When you enable the IMU with a reasonable sampling frequency necessary for accurate positional audio (10hz minimum), the battery life plummets to a few hours.

This meant we had to provide instructions to blind users on opening the enclosure, removing and replacing a button cell battery up to twice a day.  Total non-starter for a real world experience.

Second was the Aftershokz. On the positive side, they delivered really exceptional sound quality for the time, and didn't obscure envrionmental sounds.  However, it turns out that bone conduction doesn't work too well with positional audio - not that it doesn't work, but accuracy and precision suffer in comparison to traditional headsets (over or in ear).  And more importantly to our users, BCTs (Bone Conduction Transducers) have a LOT of sound leakage.  Whatever you hear, so does everyone within arm's length.  This loss of privacy would also make others aware of a user's special use of the device, breaking their desire to blend in.  Last, the headset was wired and has a breakout box with a battery and switch, that a user would need to charge regularly.

I actually created instructions for this variant of the headset and remote, both visual and audio -

So, we needed something a little better.

Take 2 - Custom Bluetooth headset

For a lot of reasons, I can't go into the specifics of the board we built.  But we can talk about the industrial design.  Here are the final visual instructions for this solution.

First, we started with a commodity shell (most commonly referred to as the BS19C).  We only used the casing, but this was a crucially important decision - we didn't need tooling to prototype solutions.  These headsets are available worldwide, from hundreds of vendors, for almost no cost.

This gave us enough room to get all the electronics in, have a single rechargeable battery, a familiar form factor to wear and not appear as specialized equipment.

We were fortunate to have an awesome industrial designer - Oscar Salandin - to iterate on the earpiece design, landing on one that worked well in testing and was easy to position with good accuracy.  He did an amazing job producing dozens of options, that my colleague Michael Platt tested for efficacy and audio quality.

While I toiled away manufacturing the ear pieces, my colleagues worked around the clock a few miles away soldering PCBs, mounting and assembling units.

For more on the process of manufacturing these tiny ear pieces, see the article here.

We got the headsets working well, and they shipped on time for field trials to begin.  The last piece of the hardware puzzle was the packaging, but I'll have to cover that in another article in the future.

This summer I ended up in the middle of the desert with about a hundred thousand other people. I was fortunate to join a camp filled with an amazing group of people. My contribution was to provide parking for the nearly 150 bicycles expected to show up throughout the week.

Originally I planned to spend a week on the project, but it turned into almost 4 months of research, iterations, and experiments. The criteria for a great bike rack at the burn (in my humble opinion) should be:

• Inexpensive to build
• Fast and extremely simple to setup and take down
• Little to no construction waste
• Use as little storage space as possible
• Accommodate as many bikes sizes/styles as possible
• Require no specialty tools to construct
• Use only universally available materials
• Robust and reusable for at least several years

That's a pretty big wish-list, but what's the fun if there's no challenge?

TLDR:

1. Burning Man Designs

2. Looking outside of the Burning Man community

3. Designing a better solution

4. The final result

5. Link to Thingiverse files

Burning Man Designs

Of course, rule #1 as a designer and engineer is "don't reinvent the wheel" so I set off to find an existing design to build. Burning Man is such a nexus of incredible creativity and expression I thought I'd have trouble narrowing down to pick a design. Instead, I was shocked by how little innovation has spread for this staple building product.

Part of this is for good reason. The rack used overwhelmingly at burning man, the conduit cage, has a lot going for it.

The conduit cage

First and foremost, the instructions are posted as part of the theme camp guide from the official site requiring little to no investigation. But the design does have a lot going for it:

• It mimics the most common commercial metal bike racks used in cities. People instantly recognize what it is and how to use it properly.
• All the materials are available at any building supply store.
• It is extremely cost-effective fitting 18 bikes per rack at a cost of ~$45.
• Requires no specialty tools to build and is relatively easy to transport and assemble on site, as well as to break down when leaving.

But it also has some downsides. It takes a lot of labor to build - typically a couple of hours per rack. It glue and screws and multiple types of wood. It doesn't pack away very well. And it's a bit, well, ugly.

Playatech Bike Jack

The Playtech bike jack is in some ways a big improvement.

• Its designed to be cut from a single sheet of plywood and work without fasteners or glue.
• Because of the material, storage and transport are much easier and more efficient.
• It looks pretty cool :)

But all is not perfect here either. It costs 3x more than the conduit cage, it has about 1/2 the efficiency, there are a lot of pieces to put it together, and it can put undue stress on the spokes of bike wheels - otherwise known as "rim twister" or "spoke stretcher" (read "the ugly" here). These racks are almost never found commercially because of the damage they can do to the wheels.

The Pole rack

By far the easiest to build and the cheapest, this style of rack comes from triathlons.

It requires each rider to lift the seat over the cross-bar to secure the bike to work. If your bike has anything obstructing this, it can be pretty difficult. I figured that between the heat, alcohol and other substances at the burn, not many folks would even understand how to use it, much less be willing to put forth the effort. (footnote, I was correct. Only a few camps used them and almost no one properly stored their bikes on this style of rack).

Also, burner bikes tend to be heavy, and be carrying other items, making the lift a lot more work and making it easy to overload the rack. (Per The Triathlon Bike Rack you can only load 6 mountain/hybrid/cruiser bikes on a 104" short span, and after lights, bins, playa dust and ornaments, that would be closer to 4 burner bikes. Less than 1/4 the density of other common racks.

Circular Racks

A completely different take, with pretty good instructions on Instructables has a lot going for it as well.

Simple to make and assemble, very robust and it offers a lot of density. The price is hard to beat as well. Wire spools can be found in abundance, usually for free, bringing the cost per rack to about $10 for 2x4's and dowels.

But it doesn't pack or disassemble easily and it can be challenging to use a circular layout for parking over a hundred bikes in an orderly manner.

Found object racks

There are lots of smaller camps who make pretty ingenious racks from scrap goods - Futon frames, Shipping palettes, PVC pipe and more.

These are perfect for small camps, but unfortunately not really a viable design for larger camps that need an easy to assemble and transport solution. If you can't locate the materials for free, the cost to make more can get big in a hurry.

Looking outside of the Burning Man community

I found literally hundreds of incredible designs for bike racks in the wild. However while many were absolutely beautiful and most very functional, there was very little I could adapt to meet the criteria I set out for myself. Most commercial offerings are made of metal, typical tube or square stock steel. They are also nearly always designed to be permanently installed in a location. This tends to mean they are heavy and extremely space intensive to transport.

I did find a bunch of interesting ideas, particularly when searching for wooden bike racks

I really liked the simplicity of this one

But then I found the inspiration for my own design. A pretty awesome company out of Australia - Bikerax, makes a line of fold-flat, plywood bike racks that are beautiful, well designed, and very robust.

Simple to assemble and very tough. Their design doesn't make the most efficient use of material, but I could immediately see the opportunities to improve upon it. So I used the BikeRax as my starting point.

Designing a better solution

I learned a few lessons researching existing racks.

• Three points of contact with the tires.
• Avoid resting on the spokes of the wheels.
• Enough space to hold the tire in place, but not too much so that the wheel doesn't stay straight.
• Enough space between each bike for the handlebars.

I also learned about bike tires and wheels. There are 4 "common" diameters - 29", 26.5", 26" and 24". 29" wheels are most common for road bikes, with 26" being the standard for most mountain bikes, hybrids and cruisers. 24" is most common in BMX and kids bikes.

There's also the consideration for tire width. Most road bikes have a 1-1.25" wide tread, with mountain and hybrids commonly having 2.5-3" treads. "Fat bikes" range from 3.8-5.5" in width.

Based on looking at a lot of photos of parked bikes from burning man, the vast majority of people are using bikes with 26" wheels and 2.5-3" tires. Even so, I wanted to support as many bikes as I could.

This is my first set of explorations on different ways to hold bikes. Obvious inspiration came from BikeRax and their 30 degree angled slots. I found that by making the taller piece vertical, I could mirror the rack, enabling bikes to park on both sides similar to the common conduit rack. This doubled the density with little additional material. As you can see in the image above, this design also fits 24-29" wheels well.

But I also needed to consider tire width and handlebar width for spacing of the bikes. I found that most bikes have handlebars between 16 and 19" wide. So I wanted to ensure that there would be enough space for riders to park next to each other. But I needed to balance this with two other needs: part nesting and tire width. You can see the dilemma in the design:

From my data, it looked like these bikes represented about 5% of the bikes at the burn, so one spot per rack should be plenty to accommodate these riders.

You can see the challenge though. The wider I make the space between each wheel, the less efficient use of the material. If I make the wheel gaps wider, it will be harder to park a bike without it wanting to tip and rack the wheel. I opted to add a slot for a single "fat" tire per rack. This is complicated even more when you nest the parts:

Nesting the parts serves two purposes: reducing waste material and making the racks extremely space efficient for storage.

The next piece of the puzzle is the cross-section. It needs to be sturdy but still maximize space on a 4x8 foot sheet of plywood. I went through dozens of iterations on these, finally settling on a partially nested design:

With this design, a single sheet of 3/4" plywood will park 22 bikes at a cost of ~$32 for Pine plywood.

This design and layout also have less than 4% board waste, and including cut waste is still 85% efficient. It is intended to be cut on a CNC Router but can also be cut out by hand with a standard jigsaw. We ended up cutting out most of our racks on site with a jigsaw and it worked really well. It takes one person with an electric jigsaw about 45 minutes per board to cut out and assembly two racks.

The final result

After months of work, and with the aid of a recently purchased PrintrBot Crawlbot I was finally ready to go. We cut two on the CNC and another 6 with jigsaws.

Even better, none were damaged at all, and we were able to break them down for storage in less than 10 minutes:

(You'll note we got a little creative with 2x4's having run out of material on site, but they worked almost as well!)

In my time at Burning Man, I felt like I took so much and gave back so little. I hope providing this to the community will be the start of a lot of giving to come :)

You can find the plans free of charge under a Creative Commons license here on Thingiverse. I've provided plans for a number of different configurations depending on your needs. Feel free to use them, remix, improve and share. If you are so inclined, I do accept donations the "Tip Designer" button on Thingiverse :)

When Microsoft released spectator view last month, I was pretty darn excited. I was fortunate enough to get into the Wave 1 HoloLens release and have been happily building and consulting on mixed reality for nearly a year now. Mixed Reality is pretty incredible, but sharing the experiences you build with others is, in a word, challenging.

First, the good stuff.

Spectator View is open-sourced (MIT License) on github. If you have developed anything for HoloLens, adding the functionality to your existing app is actually very straightforward. It’s basically a derivative of the mixed reality capture that has been available since launch.
What’s new is the ability to use a standard camera for video and composite mixed reality onto the video stream in real-time. It’s all still a bit finicky, but getting the code up and running only take a couple of hours at most.

What happened with the hardware?

While the software is well laid out, the hardware and build instructions are a complete mess. 14 bolts in 3 different metric sizes (I love metric, but all camera equipment uses 1/4”-20 or 3/8”-16 screws). 8 individual parts. And they recommend to have it machined out of aluminum. And you have to partially disassemble your $3,000 HoloLens.
Then, after all that craziness, the “alternate” setup is a clamp with some padding. Who would trust their HoloLens to a janky clamp and foam?
I printed out their rig to try it. Then set off to improve on it for everyone else like myself who doesn’t want to drop a thousand dollars at a machine shop.

Three Solutions

http://www.thingiverse.com/thing:2196586
All three of the brackets are 3D Printable on most consumer 3D Printers. With a build volume of just under 200mm95mm75mm, and two of the three are designed to print without any supports.
The center mount point is positioned at the HoloLens’ center of gravity at a height offset that should fit nearly every DSLR camera on the market today.
You will only need to remove the nose-piece before installing any of the mounts. You will need to drill each screw hole out to size after printing. I did this to enable you to use M5 machine screws if desired, or drill out to use 1/4”-20 screws. I used a #3 drill bit with very good results, but you should measure twice and drill once.
I highly recommend using either PETG or ABS as your print material. My mounts are all printed with Hatchbox PETG @ 250c on a e3dv6 hotend with .2mm layer heights. I used 50% infill and 3 perimeter layers with 8 layers top and bottom. This will produce an extremely rigid part.

I created an Amazon wishlist for all of the mounting hardware I found really useful. Check it out here: https://www.amazon.com/gp/registry/wishlist/2CVA3M6A6YEED/ref=cm_wl_list_o_3?

Mount 1: Light and simple

The first mount option is for folks who want the absolute least weight. It has a single hot shoe screw mount. You will need to purchase a set of Velcro cable ties, a Tripod Screw hot shoe adapter and one 1/4”-20 nut. You will need to print this mount with supports. Print, insert into the cutouts on each arm of the HoloLens and use 4 cable ties through the cutouts to secure the arms to the mount securely. Ream the tripod mount hole with a drill bit. Press fit the nut in the cut-out (you may need to use a pair of pliers or a clamp to get the nut securely pressed into place) and then secure with the tripod screw hot shoe adapter.

Mount 2: Simple and flexible

The second mount option uses the same Velcro ties, but has a more traditional mounting plate configuration. It provides 1/4"-20 holes spaced 9mm on center alternating with 3/8”-16 holes. The tripod drop mount still provides a standard 1/4"-20 center hole with countersink for a nut. The drop mount area also features additional 1/4"-20 holes for more secure mounting to camera cage rigs as well as ARRI 3/8”-16 mounts with pogo pins for alignment.
This mount is useful if you want to mount other gear to the bracket, especially if you’re mounting to a camera cage. I use the internal volume to mount my Tascam audio recorder and wireless mic receiver.
You can optionally use the top mount plate with this mount for a super-secure and rigid rig. The top plate slots into the risers snugly. Secure the top to base with two 1/4" bolts through any of the internal holes in the cheese grid.

Mount 3: Heavyweight

This mount provides the most flexibility for professional operators. It moves the drop mount to a separate printable adapter and just provides the base plate with cheese grid. Similarly to mount 2, you can secure with Velcro straps or use the top mount place with 1/4” bolts.
This mount is useful if it is being installed as part of a larger camera rig system or larger cage.

I hope this helps you create even better mixed reality experiences, and happy coding!

I had the privilege to join the Guide Dogs UK / Cities Unlocked project earlier to help push it through the next phase of development. Our team built, productized and integrated a collection of truly amazing services to turn the idea into reality.

From a user experience perspective, the turn-by-turn navigation functionality is by far the most complex. We went through a number of evolutionary and revolutionary steps during the past 6 months that this article will walk through. We learned a lot through the process and I believe we are still just scratching the surface of what's possible with auditory displays in real world products.

Current State of the Art

Turn-by-turn navigation is a relatively mature technology area, with a large pool of hardware and software solutions. There are a few common traits to most, if not all commercial offerings:

1. A visual 2D/3D map with compass-based directional alignment.
   
2. Visual/Voice search with visual list results to find intended destination.
   
3. Live route guidance using a combination of skeuomorphic visuals: accurately scaled roadway maps and pictographs of lane position and direction of travel.
   
4. Voice guidance that is a direct translation of the visual guidance.
5. Nearly total reliance on roadway data^[1] as the vector source for routing, regardless of transport mode: car, bus, bike, walking.

There are a few notable interactions that are pretty unique.

• Google maps (iOS) has haptic feedback for turn indications - Three vibrations for left, two vibrations for right. This is really useful for walking directions, you can almost leave your phone in your pocket.
• Apple Maps (Apple Watch) uses haptic feedback as well but 12 pulses for a right turn and three double pulses for a left turn.

Within the visually impaired community, two apps stand out from the rest:

• Blindsquare which leverages FourSquare and OpenStreetMaps for POI (Point-of-interest) data, and has smooth handoff to Apple or Google maps for turn-by-turn direction.
• SeeingEyeGPS is a fully baked navigation and POI explorer. It can also leverage FourSquare as a data source but handles it's own turn by turn directions.

Both apps rely on the phone's compass to find orientation and spoken language for relative direction. This is usually manifested by either clock-orientation (12 o'clock being straight ahead, and 6 o'clock being directly behind) or through cardinal orientation (north, south, east or west in addition to the user's current direction).

Cities unlocked introduces a new capability: highly accurate 3D spatial audio.

Lack of precision with spoken language

We struggled from the very beginning on finding a spoken language lexicon that could be both precise and brief. English is especially poor for this pursuit when it comes to wayfinding.

All GPS-based apps struggle with the same complexity, though for driving and sighted users, much of this can be masked by cognitive error correction based on visual landmarks.

If an app is telling you to turn right in 30ft, but the real turn is in 15ft due to GPS interference or LTE congestion, a sighted user can resolve the conflict quickly - the intersection will be in a slightly different place and they can quickly error-correct. For a visually impaired user, this can mean the difference between turning onto a path vs. the middle of a busy road.

Furthermore, when on a route that requires a long, straight segment, it can be very easy to question whether or not you're still on track. Has the app stopped? Have I overshot? We introduced a positive reinforcement feature called navigation sense to solve this problem.

We found ourselves over indexing on completeness and precision more and more.

"Turn left at the corner of Market St. and Pine St. in 152ft, then continue on Pine St. heading North."

But in practice, users had a hard time processing all of the details. The app was bombarding users with continual updates on GPS signal strength changes, waypoints, turns, location information and safety information. On some routes, the spoken audio would stack up with messages incoming faster than they could be spoken to the user.

Part of the solution to this problem came with technical improvements to both the application and services.

• Implementing configurable speech prosody (speed) in our text to speech engine to allow users to have more audio density.
• Kalman filtering allowed us to be much more resilient to GPS degradation, reducing the occurrence of verbal warnings dramatically.
• Client-side and service caching reduced command latency from several seconds to sub 250ms, increasing the reliability of location specific announcements.
• Improvements to the precision of the spatial audio engine eliminated the need for cardinal or clock-based directional verbiage.
• Adding huge amounts of GPS data for footpaths, building features and obstacles to OpenStreetMaps improved routing reliability and reduced noise from road vs. walkway deviations.

After months and months of improvements, the app "noise" was reduced dramatically. One of our most common commands, "What's around me?", responds with the 4 nearest points of interest in each direction around you. At the beginning of our work, it averaged almost 17 seconds to complete the spoken response. With technical improvements, we were able to reduce this to 12 seconds (30% better) at 1x prosody, down to 4 seconds (83% better) at 3x prosody.

The app was now usable. User feedback supported this, but we still had issues. There was still continual feedback that the app felt too verbose in some ways and too limited in others. We'd finally reach the point of diminishing returns with spoken language. It was time to look for other auditory means to convey information.

Non-verbal audio information

There is a wide base of academic research into auditory displays and methods that I was extremely fortunate to turn to our quest for improving the user experience. Alarms, earcons, auditory icons, audification, sonification, and soundscapes form the lexicon of non-verbal audio cues that one can harness in auditory displays.

(Source)

We ruled out alarms and spearcons early on, the former being far too startling and the latter still suffering from language shortcomings. Auditory icons were also ruled out as many of the concepts we have in the app are abstract, without good natural sound correlations.

So earcons and audification became the tools of choice for our experimentation.

Poor supplements to speech

We experimented with earcons to differentiate different types of POIs: landmarks, shops, hazards, etc. We call these the senses: location sense, information sense and safety sense. They were used as a supplement to the spoken name of the POI. Surprisingly, even with a small set of well-produced sounds, we found users didn't remember them and didn't find them valuable.

Similarly, we used this for navigation sense as an addition to speech directions during turn-by-turn navigation. But unlike the other senses, navigation sense was unique. It isn't directly paired to a verbal instruction, but rather a mode that can be toggled on and off by the user independently of spoken instructions.

This caused us some pain and complexity in the user interface, but also presented an opportunity. Since this sense was already decoupled from speech, how could we manipulate the relationship with speech and how would it affect user's ability to navigate safely, confidently and efficiently?

Experiment 1: Automatic activation

The first experiment was looking for ways to reduce the cognitive load for the user by automatically triggering navigation sense at known useful times: beginning a new journey, rerouting, and at turns. We knew users overwhelmingly triggered nav sense after these states, and indeed we found almost instantly that this was a much-improved experience. Navigation sense added more primary information (exact absolute direction) to spoken directions (relative instructions). My colleague Phong Cao Thai did an incredible job implementing this.

Experiment 2: Parallel playback

Until this point, we purposefully designed our audio engine to be single-channel to avoid cocktail party^[2] overload, especially for critical safety information. We designed an interrupt-driven audio queue with command priorities for point of insertion. But once again, navigation sense didn't need to be played alone - it didn't interfere with speech or the other earcons.

So Andrei Ermilov extended our audio engine with an experimental second channel to enable nav sense to play in parallel. Once again, we immediately saw the positive impact on user experience: users could easily parse the very binary directional audio cue in parallel with spoken commands with little effort, thanks to the way our brain processes different kinds of sounds in different ways^[3].

Experiment 3: "Always on"

Naturally, after enabling parallel playback and seeing the success of automatic activation, we pushed even further. What if we trigger nav sense after every change in our state machine? This turned out to be a step backward. The earcon we used wasn't designed to be played continuously. While we watched user safety and efficiency improve, we'd hit the noise threshold. It was just too intrusive and became an annoyance, even with the added benefits.

Why had we hit a point of diminishing returns? Would a new earcon help alleviate this problem?

Supplementing positional audio

We learned a number of lessons along the way with our "clip-clop" navigation sense sounds. Similar to the "Six principles of visual context" from Stephen Few, there seems to be a similar set of contextual traits that you can use for auditory displays.

• We knew that binary on/off sounds were just too finicky.
• We knew that constant bombardment of a repeating earcon became quickly annoying to users, outweighing the value.
• We knew that it would be possible to convey more information density through sound than speech if done well.
• Technically we could now play multiple streams at once, creating the need to be mindful of cocktail party effects.^[2:1]

With a bit more research I ran across several interesting possibilities.
Using the concepts of dopplar effects to convey distance from target as seen here: http://sonification.de/handbook/index.php/chapters/chapter5/#S5.4

To keep things simple, and based on some prior research into error rates, I kept the number of initial steps to 5. The idea being to allow for quite a bit of deviation from target with subtle changes to the sound, but having enough steps to provide the illusion of a cascade of sound.

And the concept of relating size to sound through using volume, intensity and composition as seen here:
http://sonification.de/handbook/index.php/chapters/chapter5/#S5.3

I used this idea to form the idea of the cascade. Being that each sound layers on top of the previous to create a continuous compoisition for the user.

At this point I needed help from a professional audio designer. I reached out to my colleague Matthew Bennett, who has been almost secretly creating incredible audio experiences for Microsoft's biggest platforms.

Breaking conventions and moving forward

With a few weeks of iterations, Matthew landed on our first hit - a cascading, multi-step set of navigation sense sounds. We broke one major convention with this experiment: the closer to target, the less intense the sound. There was a lot of pushback to this design, but we were given the freedom and flexibility to try it! We got the sounds integrated into the app and you can hear the initial results:

It was a surprise to say the least. Even the designers were a bit taken with how well this worked even in it's first prototype integration.

So we upped the ante and re-enabled "always on":

It worked! User feedback was pretty immediate - the sounds were effective without being annoying, and communicated position and action for the user. While far from done, the cascading composition approach seems to be the winning entry.

Where to go from here and lessons learned

The new navigation sense exposed a slew of new bugs and limitations in the application that now need to be addressed:

• How "always on" is always-on? Should it ever be interrupted?
• How far can we push removing spoken language with the new navigation sense before it too reaches dimishing returns?
• Is 5 the right number of steps? Would a parametric compositional approach produce even better results than static samples?
• How can we integrate beat matching / sample alignment into the spatial audio engine?

(Updated 12/24/2020 - Links to Microsoft Developer Blog)

Footnotes

Now that we have our little printer set up and updated, it’s time to get on to the next step. This article will walk you through how to tune the configuration of the printer’s firmware and getting started with our first slicing program, Cura.

No added costs this time around, everything we are going to do uses free software!

Tuning – learning to speak gcode

No matter which 3D printer you start with, they all speak one common dialect, gcode (with a few notable exceptions). Before you get too worried by the name, let me put you at ease: gcode is probably the most simple interface language that’s ever existed.

There are a few forks of gcode, think of these like dialects to a spoken language. The most common is Marlin/Sprinter. Fortunately for us, this is the flavor of gcode that the Select Mini uses.

Also in our favor is that gcode has been around for a very long time and is extremely well documented, largely thanks to the reprap project. If you’re interested in going beyond the basics in this article, have a look at the gcode reference on the reprap wiki.

We are only going to focus on tuning one aspect of the select mini, because it is notoriously poorly configured in the firmware. The hotend is probably the most important mechanical piece of the printer, and out of the box it can vary in temperature by 5-7 degrees Celsius when in use. For comparison, a well tuned hotend should only vary .1-.3 degrees Celsius when set to a steady temperature.

How the hotend works

FDM printers (forced deposition of material) basically work like very precise hot glue guns. They heat up plastic filament until it melts and then is forced through a tiny nozzle and deposited on to a flat surface one layer at a time.

In order to make this process fast, reliable and repeatable we need to ensure that the temperature of the material coming out of the nozzle can be very accurately measured and controlled.

This is done In the firmware by using two pieces of hardware – the heater cartridge and the thermistor. Both are incredibly simple elements. The heater cartridge does just that, converts electricity into heat. It does this very quickly and with a lot of energy. Typical heater cartridges are 30 or 40 watts, enough to heat our hotend by hundreds of degrees in a minute or so.

Herein lies the problem, we have no way to measure how electrical input affects temperature. There are a nearly infinite number of variables that can affect this relationship – changing room temperature, type of material being extruded, distance from the bed, speed of the axes, cooling fans, extrusion speed and many, many more.

The thermistor helps to solve this problem. It is literally a tiny thermometer. But unlike traditional thermometers that used a liquid like mercury to measure temperature differences, a thermistor uses electrical resistance. The hotter the thermistor gets, the less resistance it has to the flow of electricity. We can use this property to measure the temperature of the hotend very accurately.

But there’s still a bit more to complicate matters. The heater cartridge and the thermistor both get mounted to a heater block. The heater block also has a threaded hole where the nozzle Is screwed on and filament flows through it. Because these elements are all a small distance from one another, there is always going to be a small delay and variance between the heat added, the measurement of that heat by the thermistor, and the actual temperature of the filament at the nozzle.

PID Tuning

In order to calculate the temperature of the filament from these elements (heater cartridge, thermistor, heater block and nozzle) we use a PID function.

PID stands for Proportional – Integral – Derivative. (shout out to CoolNamesAllTaken for correcting me on this!). Wikipedia has a really well documented article if you want to understand the math behind it. It made my eyes glaze over, so in this article we are just going to move on set the values for our printer so that it will be able to heat up quickly and still maintain a consistent temperature.

We are able to do this thanks to the incredible work of Michael O’Brien on hackaday. He has done all the hard math and electrical engineering experimentation to find the ideal settings for our little printer. Even if it’s over your head (it was certain way above mine), have a read through his articles and be glad that engineers like him exist in our world.

https://hackaday.io/project/12696-monoprice-select-mini-electro-mechanical-upgrades

In order to set these properties, we need to be able to talk to the firmware of our printer. I’m going to be using one of the original products to do this – Pronterface.

Head over to pronterface website, and download the latest version for your operating system. http://koti.kapsi.fi/~kliment/printrun/

If you have Windows 10, all you need to do is to plug the USB cable included with your printer into both the printer and a USB port on your computer. It should be automatically recognized as a generic 3D serial printer. This may also be the case for Windows 7 and MacOS, but please drop me a note if not.

Once connected, open pronterface.

If this is your only connected serial device, it should register as COM3. But worst case, simply go through each com port until the connection succeeds. Use the default connection speed of 115200.

With the connection established, it’s time to enter the world of gcode.

Intro to gcode

G-code is the common name for the ubiquitous numerical control programming language. For more about it’s history, have a read through the great reference on Wikipedia: https://en.wikipedia.org/wiki/G-code

For 3D printers, g-code does two things.

1. Control motors – these are the commands that G-code is named for. They all start with a G prefix, the most common being G1, the move command.

2. Control peripherals – heaters, wifi, thermistors, and everything else. These are the M commands.

In a fully implemented firmware, every setting and operation of a gcode-based printer should be addressable through gcode. In reality this is not always the case, but fortunately for us the Select Mini printer does a pretty good job with its implementation.

We are only going to be doing a couple of specific things in gcode to get the printer up and running. But for reference, have a read through the gcode guide to see everything you can do with gcode!
http://reprap.org/wiki/G-code

PID Settings

Setting the PID values for the hotend is actually pretty straightforward.
From the console on the right-hand side of Pronterface, enter the following command:
M301 P36.00 I0.012 D72.00 C0.12 L2

Press send (or press the enter key). You’ll see an OK response with the values.
Then enter:
M500

This command saves the values, you’ll see a response:
echo:Settings Stored

Next enter:
M304 P106.56 I0.024 D96.81

This will set the PID values for the heated bed. Save these values with:
M500

You can verify the settings have been persisted by entering:
M503

This will read out all the saved settings, including the PID parameters we just entered for the hotend and the bed. Finally, just to ensure the settings were saved, power off the printer and turn it back on. Reconnect with pronterface and run M503 once again, then verify the M301 and M304 settings from the output.

Slicing with Cura

There are many different applications that we can use to take 3d models and slice them into the gcode language that the Select Mini uses to print. Cura, Slic3r, Repetierhost and Simplify3D are all good choices with a large community of support.
For the beginner, Cura is by far the best option. It has a robust GUI, a low learning curve, and quite a bit of customization.

If you find yourself really loving the world of 3D printing, Simplify3D is by far the most advanced slicer on the market with a pricetag to match. But it’s worth every penny if you print a lot of models or want to get into more advanced prints.

Download Cura from https://ultimaker.com/en/products/cura-software

After installing Cura, choose to add a new Custom Printer. Give it a name, I like “Select Mini”, and then move on to the Machine Settings screen.

Set the X, Y, and Z each to 120mm and be sure to check the box for Heated Bed.
Make sure the GCode Flavor is set to RepRap (Marlin/Sprinter).
Make sure the Nozzle Size is set to 0.4

Next up, we need to update the Start and End gcode scripts:

For the starting gcode:

G21 ;metric values
G90 ;absolute positioning
M82 ;set extruder to absolute mode
M107 ;start with the fan off
G28 X0 Y0 ;move X/Y to min endstops
G28 Z0 ;move Z to min endstops
G1 Z15.0 F9000 ;move the platform down 15mm
G92 E0 ;zero the extruded length
G1 F200 E3 ;extrude 3mm of feed stock
G92 E0 ;zero the extruded length again
G1 F9000
;Put printing message on LCD screen
M117 Printing...

For the end gcode:

M104 S0 ; turn off extruder
M140 S0 ; turn off bed
G91 ; relative positioning
G1 E-1 F300 ;retract the filament a bit before lifting the nozzle to release some pressure
G1 Z+0.5 E-5 X-20 Y-20 F9000 ;move z up a bit and retract filament even more
G4 P300000 ; wait 5 minutes before turning off the fan
M106 S1 ; turn off fan
G28 X0 Y0 ; move X/Y to min endstops so the head is out of the way
M84 ; disable motor
G90; absolute positioning

With that bit done, we can finish printer setup and move on to our first print.

Initial Settings for a PLA print

Now let’s configure our settings for PLA.

First is the layer height. The defaults for almost every printer are going to be .1mm for fine detail prints and .2mm for general prints. In other words, multiples of .05mm.
But the select mini is different. Because of the pitch of the threading on the lead screw, we need to set the layer height to a multiple of .04375.
For high quality prints, selecting .0875 or .13125 will get you accurate z-height with accurate material deposition.
For normal prints, .175 or .21875 are the layer heights you’ll want to go with. The full list of layer heights that will work well with the Select Mini are below:

.04375
.0875
.13125
.175
.21875
.2625
.30625

I wouldn’t recommend going below .04375 as the printer can’t step less than this amount. Don’t try going above .30625 because the hotend can’t handle pushing much more than that amount of material while holding a consistent temperature.

Wall thickness should always be set to a multiple of the nozzle size, so .4, .8 or 1.2. In other slicers this is called “perimeters”. It’s setting how thick to make the walls of the parts before starting infill. The thinner the walls, the less material used. But below 1.3 (or 3 perimeters) you will often find mechanical strength to be significantly reduced.

Infill density is almost completely dependent on the use of the part. For cosmetic parts, 12-20% is fine. For mechanically durable parts, 50% is a good place to start. 85% infill is equivalent to a solid part. Going above that will quite often result in undesirable effects without any increase in strength.

Print temperature for PLA should be between 195-210c. You’ll need to calibrate this temperate yourself based on the specific PLA filament you have. 200c is usually a great place to start.
Build plate temperature should be 60c.

**Diameter **should be defaulted to 1.75mm. However you should buy a pair of calipers and measure your actual filament diameter between prints to adjust accordingly. Most filaments will have a common variance of .05-.1mm and this can make a visible difference to print quality.

Print speed should be set between 30 and 70 mm/s. 30 for high quality prints. The higher the speed, the lower the quality will be. Beyond about 70 mm/s, it’s likely to get skips and enough backlash to cause issues in your prints. I stick to 50 mm/s.

Enable support for parts that need it, and always leave the skirt enabled to ensure the filament gets primed and any ooze gets cleared before starting the main print.

With all that set, we can save our generated gcode and take it over to the printer.

CAUTION - THIS IS ONLY FOR V1 Printers, and only necessary for firmware revisions older than 22.41. Do not attempt to upgrade firmware on V2 printers.

After you've gotten your brand new Select Mini out of the box, the next big step is updating the firmware. These printers came out originally with very unpolished firmware that had some serious issues.

Reading the SD card

If your Mini doesn't show at least version 22.41 on startup, you should update the firmware before proceeding any further.

This means you need some way to read the MicroSD card on your PC or Mac. Some laptops have SD card slots built in - many Macbooks do (as long as you don't have the newest models, damn you Apple!). If so, all you need is a super-cheap MicroSD to SD adapter (along with another 32gb card): SanDisk 32GB Ultra microSDHC UHS-I (Newegg.com)

But, more likely you won't have a reader on your laptop or desktop. Fortunately this is a great excuse to buy one. You'd be amazed how often these come in handy, for digital photography, video, GoPros and even just routine file transfers. I highly recommend the Kingston FCR-HS4 - $17.98 (Amazon.com)

In addition to enabling Wifi connectivity (though I don't recommend using it at the moment), the newer firmware versions fix a number of bugs, improve stability and temperature accuracy and open the printer up to a number of possible improvements later.

So lets get started! Watch the video on youtube and follow along with the article below.

The easy way (motion controller)

If everything worked the way it was supposed to, technology wouldn't be nearly as fun right? The easy way to update the firmware is as follows:

1. The firmware is actually in two parts: The motion controller and the UI controller.
   Head on over to the semi-official Google Drive folder and grab the latest firmware revisions for each: https://drive.google.com/drive/folders/0BxyFI3iDaicLemUwcHZkbGtRbkU
   As of mid-November 2016, I recommend motion_v28 and UI_v42. There may be some rough edges to motion_v29, so best to avoid it for now.

2. Unzip each firmware zip file and place the .bin file for each firmware on the root of the SD card that came with your printer.

3. Put the SD card back in the printer, turn it on, navigate to the print screen and select update.bin with the dial. You will see the screen say "updating" for 10-15 seconds and then the new firmware revision will be displayed on screen.

For even more exact instructions, check the step-by-step process here:
http://mpselectmini.com/motion_controller as well as the short video at the bottom of the page.

However, if, like me, you seem to make electronics do crazy things without even touching them, this process may not work.

In my case, the screen would flash momentarily and put me right back on the list of the SD card contents. After nearly an hour of frustration it was time to move on to the brute-force method (aka the "Recovery Method")

The viking way (motion controller)

Perhaps surprisingly, this is only a tiny amount more work.

1. After step 2 of the easy way, grab any file that is at least 1 megabyte in size, copy it to the root of the SD card, then rename it to "fcupdate.flg". Make sure you have file extensions visible in Windows!

2. Put the SD card back in the printer.

3. Turn on the printer and watch it update successfully. Revel in your abilities.

4. Take the SD card out of the printer and delete fcupdate.flg from the SD card.

Halfway done! Next up is the UI controller. It's a little trickier, but a lot less likely to go wonky.

Updating the UI controller

1. Grab the UI controller firmware from https://drive.google.com/drive/folders/0BxyFI3iDaicLemUwcHZkbGtRbkU
   As of mid-November 2016, I recommend UI_v42.

2. Unzip the firmware zip file and place the lcd.bin on the root of the SD card.

3. Turn the printer off, disconnect the USB cable, and put the SD card back in the printer.

4. Move the X-axis all the way to the left (towards the tower assembly) until the endstop clicks in. Move the Y-axis all the way back until the endstop clicks in.

5. Push down the dial button on the front of the printer.

6. Applying light pressure to both X and Y axes to ensure the endstops stay clicked in, and while still holding down the dial button, turn on the printer.
   The hotend fan will spin on after a few seconds, once this happens you can release the dial button (but continue to keep both X and Y axis endstops pressed).
   After about a minute the LCD will turn on (it will be black during the update).

7. Turn off the printer.

8. Delete lcd.bin from the SD card. Put the SD card back in the printer.

9. Turn the printer back on and pat yourself on the back for successfully updating the firmware!

Again for a nice short video of the procedure, check out Matthew Upp's wiki here: http://mpselectmini.com/ui_controller

With the firmware all sorted, next on the list is tuning the electronics inside the Mini. Fortunately thanks to the amazing community, this is a really fast and painless process. Click on over to Part 3: Slicer and Settings (Coming soon) to keep on trucking!

A couple of months ago I got another deal alert for a cheap 3D Printer, the Monoprice Select Mini, on sale for $175, from a still ridiculously low $199 regular price. Normally I wouldn't have given it a second thought^[1]. This time however, a pretty thorough review from Brian Benchoff at Hackaday made me take a second look.

After buying one myself, I was convinced - This thing is a lot of machine for very little money. A couple of weeks later, with my dad's birthday approaching I ordered one for him. My dad has always been a techie, but he'd never touched a 3D printer before. After a few phone calls I remembered the months of pain and incredibly steep learning curve I went through when I took the dive into 3D printing. I told him I would make him a guide, so here it is (part 1):

Buying the printer

This may seem like the easy part, right? Turns out you can't just buy a 3D printer and start printing.

You do need the printer first though. Unfortunately the previous deals from Jet.com - $167^[2] have dried up, so the best place to get it is direct from Monoprice - $199.

But you also need a pretty standard set of tools and supplies that very few people ever mention. You may already own most of this stuff, but here's the complete list:

Check this Amazon Wishlist for everything here and more that you may need for 3D Printing!

1. ScotchBlue painters tape - 2"x60yd - $11 or 3"x60yd - $12
2. Flush cut shears - $10
3. Retractable utility knife - $4.50 (Cheaper at Harbor Freight) - Plus Blades - 50pk - $5.98
4. Cleaning filament spool - $12.75
5. Aqua Net extra super hold hair spray - $8.54 (Find this cheaper at your local grocery store or beauty supply)
6. 3M 100 grit flexible sandpaper rool - $12.97
   (optional 3M 150 grit flexible sandpaper roll - $12.97)
   (optional 3M 220 grit flexible sandpaper roll - $12.97)
7. Isopropyl Alcohol - $2
8. Paper towels - $6
9. Machinist screwdriver+socket set - $14.95
10. Needle nose pliers - $5.46
11. Digital Calipers $18.50

Total supplies cost about $120 if you're literally starting from scratch. Don't cheap out on the tape, filament, sandpaper or hair spray. Yes, you need this stuff.

Finding material

To print with a 3D printer, you're gonna need some plastic! Stay away from cheap filament. Bad filament causes bad problems. Anything under $20/kg is giong to be very suspect. There's also an incredible number of different types of filaments^[3], along with specialty brands and trade names. But we are going to start very simple:

Get a roll or two of Hatchbox PLA 1.75mm filament from Amazon - $22.99. It's good quality for about the lowest price you are going to find.

If you know you're going to be making mechanical parts, also get a roll or two of Matterhackers PRO Series ABS 1.75mm filament - $42. While a bit more expensive, printing with ABS is already a much more complex task.

Unboxing and inital setup

Unboxing is a pretty straightforward affair. The two things to pay attention to:

1. Don't throw away any of the packaging
2. Keep both external and internal cardboard boxes intact.

The reason for this is that there's a decent chance you will have to RMA (aka return/exchange) the printer at some point. The power supply going out seems to be the most common issue, but there are others. Don't fret, your chances are very good that nothing bad will happen, but better to be prepared! Monoprice will honor returns, but they do no provide any spare parts.

So what's in the box?

• Monoprice Select Mini 3D Printer
• Filament Spool Holder
• Power Supply Brick
• AC Power Cord
• Micro USB Cable
• SD Card
• Hex Wrench
• Spudger Tool
• Sample PLA (toss this in the garbage)
• Newer units (factory firmware 20.xx+) seem to include an extra extruder bearing arm, your mileage may vary.

With the printer out of the box, just one piece of tape holds the hot end securely to the X axis gantry. Do a thorough look around the unit checking the X and Y axes for tape and packing materials just to be sure. You can also remove the LCD screen cover, or just leave it in place since it isn't a touch screen.

All the tape off? Don't connect the USB cable or insert the SD card yet. Plug the Power Supply into the wall, then into the socket on the back of the printer. Next, flip the switch to power it on.

The boot up screen will display the firmware revision for the motion controller and LCD screen

Most printers will show 18.37, with 22.39 being the latest available firmware.

If your printer shows 22.39 on startup, then you're one step ahead! You can continue on to Part 3: Slicer and Settings (coming soon!)

If not, we need to flash some firmware. Head onward to Part 2: Flashing the Firmware

Huge shoutout to Matthew Upp, the guy who has pretty much single-handedly built an amazing community for the Mini Select printer on Facebook. Check out his website + wiki here: http://mpselectmini.com/
Get involved by joining the Facebook Community Group here:
https://www.facebook.com/groups/1717306548519045
And if you feel like going deep down the rabbit hole, have a read through the comprehensive google doc here:
https://docs.google.com/document/d/1HJaLIcUD4oiIUYu6In7Bxf7WxAOiT3n48RvOe5pvSHk/edit

Footnotes

The Intel Edison platform is a great piece of hardware for wearables and other mobile computing projects. Intel manages two open source repositories, MRAA and UPM to enable multi-language interfaces to hundreds of different sensors, shields, motors, servos, input devices and displays.

However, the Edison is also still a very new platform and most of this support is coming from the open source community. As a result, many devices have very minimal support and very little documentation. In my case, the Sparkfun OLED Block for Intel Edison happened to be one of these devices. Sparkfun provided an extremely barebones sample, only in C++. The UPM module similarly provided little functionality and an even more barebones sample. Fortunately, we can remedy this situation!

Setting up the environment

UPM is an open-source project and all the development tools needed to build and extend the Edison are already on the device.
This was such a foreign concept to me, I spent an entire day trying to create my own development environment to replicate the Edison. I failed miserably at this. It was only after a good night's sleep that I thought to myself "I wonder if I can compile UPM on the Edison itself?".

The first thing to do is to make sure the YOCTO Linux has the most recent package manifest. The firmware, OS and packages that come preinstalled can vary significantly depending on the manufacturing date. You can follow my blog post on out-of-box configuration for the Edison that walks through this process. It will walk through how to connect to your Edison, update the firmware and the various options to get an SSH terminal session open.

From an SSH terminal, run these commands:

echo "src intel-iotdk http://iotdk.intel.com/repos/1.1/intelgalactic" > /etc/opkg/intel-iotdk.conf

(This pulls the latest package manifest from Intel's server and saves it to the correct conf file)

opkg update

(Updates the opkg manifest using the downloaded conf file)

opkg upgrade

(upgrades any installed packages to the latest available version)

opkg install git

(installs the git client on the Edison)

cd ~/
git clone https://github.com/intel-iot-devkit/upm.git

(changes to the home directory on the Edison, then clones the UPM repository to the device)

cd upm
mkdir build
cd build
cmake .. -i

The -i option on cmake runs interactive mode which will walk you through the advanced options. The only option that needs to be changed is to set the install path option from the default (/usr/local/) to:

/usr/

Which will allow you to quickly make and refresh the app to see changes.

Building the library

You can see the code I contributed here:
https://github.com/intel-iot-devkit/upm/commit/14a3924fb29bbf2e5517636699f8726ec7013b81

Because I was tweaking low-level SPI bus routines, I routinely caused the Edison to completely lockup, forcing hard power cycles. So I started on the hunt to speed things up. Here's what I found:

Partial build/deploy

One trick I only discovered by accident is how to isolate the module you're working on when running the build and deploy. There's some unclear language about this in the UPM build guide that didn't quite work for me in practice.

Normally you'd just go into your source root folder and run

 make install

If you're working on a specific module, you can just build the module's directory with.

 cd src/lcd
 make install

Leveraging this shortcut cut my compile times from about a minute down to a few seconds.

Using remote filesystem mounting

It took real time after every restart to bring back up vim, open my files and get back to the place I left off. Fortunately I found another open-source project called win-sshfs https://github.com/dimov-cz/win-sshfs. It lets you easily map any scp/sftp accessible filesystem as a drive on Windows! One tiny issue was that it was, at the time, broken in Windows 8/10. So I fixed it and now have easy filesystem mounting on Windows. I used Visual Studio Code as my editor, and gained the added benefit of doing all my git actions from Windows, rather than needing to suffer through CPU intensive syncs and merges on the Edison directly.

Using remote mounting made my dev cycle much faster, but there's still one trick left.

Watchman for total automation

The final trick in the magic hat is Watchman: https://github.com/facebook/watchman, an awesome little utility from Facebook. It sits on the Edison and everytime I save a file, auto runs the build and run script I want. In my case, simply killing node if it's already running, then running a make install from my module directory and restarting the node example app.

Using these three speedups, my total time to test a change went from 3-5 minutes down to about 15 seconds.

Improving the OLED Support

The biggest known issue with the Edison in regards to the OLED screen is the poor quality SPI bus. Pushing more than a 16bits of data per message
and/or setting the bus frequency over 10000000 result in the board completely hard locking.

So I had to use a bunch of tricks to batch writes into bytes and batch updates to the screen over the SPI bus. With the current refresh rate being about 2 frames per second, there was a lot of room for improvement!

https://github.com/intel-iot-devkit/upm/blob/master/src/lcd/eboled.hpp
https://github.com/intel-iot-devkit/upm/blob/master/src/lcd/eboled.cxx

Changing the addressing mode.

The Sparkfun OLED unit is a modified SSD1306 OLED display from Solomon Systech. Fortunately I was able to find the full technical data documentation for the display and driver.

I found that the display defaults to using Page Addressing Mode

The issue with this is that you have to manually set the page and column start/end pointers every time you want to write to the screen! It's 8 extra calls , plus the latency induced for page switches.

Instead I opted for Horizontal Addressing Mode:

 setAddressingMode(HORIZONTAL);

 //Set Page Address range, required for horizontal addressing mode.
 command(CMD_SETPAGEADDRESS); // triple-byte cmd
 command(0x00); //Initial page address
 command(0x05); //Final page address

 //Set Column Address range, required for horizontal addressing mode.
 command(CMD_SETCOLUMNADDRESS); // triple-byte cmd
 command(0x20); // this display has a horizontal offset of 20 columns
 command(0x5f); // 64 columns wide - 0 based 63 offset

Both Horizontal and Vertical addressing modes simplify the calls. They both map each column to a single virtual array to be written. No more interim page sets or column sets. Only specify the total range for pages and columns! This change got me from 2fps to 5fps!

No more single bit writing - bytes and buffers

The rest of the speed comes from the writing strategy. Originally, each pixel was being blitted directly to the display. That's 4 calls per pixel - set page, set column low/high and set bit.

Instead, I opted to store an entire screen buffer in memory. I'd planned to actually use double-buffering, but found that with the ceiling of the SPI bus frequency, it didn't provide any performance increase over the single buffer.

 static uint16_t screenBuffer[BUFFER_SIZE];

By storing the entire screen memory in a byte array and then writing to the screen in words (16bit chunks), I was able to hit the absolute limits of the SPI bus.

 mraa::Result EBOLED::refresh()
 {
   mraa::Result error = mraa::SUCCESS;;

   m_gpioCD.write(1);            // data mode
   for(int i=0; i<BUFFER_SIZE; i++)
   {
     error = data(screenBuffer[i]);
     if(error != mraa::SUCCESS)
       return error;
   }

   return error;
 }

 mraa::Result EBOLED::data(uint16_t data)
 {
   m_spi.writeWord(data);
   return mraa::SUCCESS;
 }

The devil in the details (columns not rows!)

Here's where I hit a roadblock for several days. No matter what I tried, I just couldn't get the display to look correct. Everything was off, but in a consistent pattern. After stepping away for a day, I came back to immediately see the problem. I'd assumed that when using Horizontal addressing, I would be addressing pixels by row position, not column!

Once I realize this, it was just a matter of lots of bit shifting and math to get things aligned. With a 64x48 display, there are 6 pages, with each containing 64 columns. Each column of course contains 8 rows.

Now this would all be simple to manage if I was writing BYTES (uint8) to the display. But to maximize throughput, I'm writing WORDS (uint16). This means each word in my buffer array actually contains two columns. So a little extra math needed to handle the extra wrinkle:

 void EBOLED::drawPixel(int8_t x, int8_t y, uint8_t color)
 {
   if(x<0 || x>=OLED_WIDTH || y<0 || y>=OLED_HEIGHT)
     return;

   /* Screenbuffer is uint16 array, but pages are 8bit high so each buffer
    * index is two columns.  This means the index is based on x/2 and
    * OLED_WIDTH/2 = VERT_COLUMNS.
    *
    * Then to set the appropriate bit, we need to shift based on the y
    * offset in relation to the page and then adjust for high/low based
    * on the x position.
   */

   switch(color)
   {
     case COLOR_XOR:
       screenBuffer[(x/2) + ((y/8) * VERT_COLUMNS)] ^= (1<<(y%8+(x%2 * 8)));
       return;
     case COLOR_WHITE:
       screenBuffer[(x/2) + ((y/8) * VERT_COLUMNS)] |= (1<<(y%8+(x%2 * 8)));
       return;
     case COLOR_BLACK:
       screenBuffer[(x/2) + ((y/8) * VERT_COLUMNS)] &= ~(1<<(y%8+(x%2 * 8)));
       return;
   }
 }

Once the pixel blitting was working, it was time to start adding useful features. I leaned heavily on the awesome Adafruit GFX Library and implemented enough functions to enable the project we were working on (to great a menuing GUI for the Edison!).

Lines, rectangles, circles, triangles, rounded corners, screen fill/blank, multi-size fonts, string writing, virtual cursor positioning, and filled rectangles, circles, triangles and corners.

Of course to verify that everything worked, I had to make a sweet demo for the examples to replace the barebones one that preceeded it.

https://github.com/intel-iot-devkit/upm/blob/master/examples/javascript/eboled.js

Wrapping things up

With everything sorted, we could finally put together a non-hacky GUI system for the display.

In the end I was able to get the display to push ~28fps. The only big improvement space left would be implementing differential buffer swapping, as most of the time there's very little change from frame to frame and so doing full buffer swaps is overkill. I think this would get the common case up to 50+fps, but it would require quite a bit more logic to implement in a way that is passive for Edison developers.

Hopefully one of these days I'll get around to cleaning up the GUI system and releasing it on a repo of its own. For now, here's a demo of it in action:

Last week I was participating in a Hackfest, working with the Intel Edison and using a bunch of Sparkfun Blocks to create a prototype.

A big reason for choosing the Edison and Sparkfun blocks was trying to make a standalone wearable device. It took us a couple of days, but Jason Fox and I got things sorted (more on that soon).

Once we had a working device small enough to put on a wrist, I got to work on the case. Fortunately, a user on Thingiverse had recently made a simple watch case for the Edison (thanks Einse!) which saved me a lot of time. Even better, Einse provided the source files in addition to the STL. So I imported the files into Rhinoceros 5 and set to work on an enclosure.

This was the first design. Simple as I could Manage, simply extending the watch case, making some notches and a cutout for the LED. With only one day left in the hackfest I just had to throw it on the printer and go.

The first print

Everything looked good in Rhino, so I just hit print. With a little Dremel action and some squinting, it looked pretty good! But the buttons didn't work at all, the Dpad didn't fit, the top cover printed with a single layer, the cutout in the back for wiring was too thin and didn't print at all, the case was too tight, there was no way to get the LED in without cutting, and I forgot to put in holes for the charging port and on/off switch!

But for the event, it worked and proved the concept:

More fun before #TECHintersection - Prototyping a new wearable with the #IntelEdison and @JasonGFox #IoT pic.twitter.com/27ca2whJL1

— dseven (@dseven) August 7, 2015

Fixing the problems

Even though I had a working model, there were a ton of problems with it. I could have just thrown the files up on the web as-is, but that wouldn't have helped people who don't have expensive modeling software, don't already own the Edison, and might not have 3d printers that print just like mine.

Even though I used calipers to measure everything multiple times, I still got almost every dimension wrong! There is a big difference between what you measure, model and print. FDM (Fused Deposition Modeling) printers need quite a bit of tolerance to account for differences in materials, temperatures, hotends, and software slicers.

The only way I have found to get a model that prints reliably is to make a change to the model, slice it, print it and measure it. So that's what I did.

After 4 more iterations, I finally arrived at a design that prints reliably, looks pretty good, and fits well. No glue required, everything snap fits together, and it needed minimal cleanup.

You can download and print it yourself from my page on Thingiverse: http://www.thingiverse.com/thing:967668

Lessons learned

1. Snap-fit parts need 0.2mm - 0.3mm of tolerance, or about 1/2 the width of your tip (mine being .4mm). Not many people do snap-fit 3d printed parts because they can be so finicky, but it's not much more work and really results in much easier use when you're working with prototypes.

2. Don't get too complicated. I dropped the square button overlays when I realized they weren't adding anything useful and were causing me to make too many other compromises. Same thing for a power-button overlay that was simply too small and fragile to print easily.

3. Measure, model, print, repeat. I saved a ton of time by making parts close, printing them and then looking at the differences. A number of final changes were .2-.4mm, almost impossible to have accounted for in one try. Plastic is relatively cheap, and working with such small parts, a print only takes an hour!

4. Prep the files before you post them. Simple things like making sure your STL is in the right units, each piece is flipped in the correct print direction, and each piece is separated into its own file will save other people a ton of time.

5. Prep your source files too! This may be contentious, but I always post the source models too. It's nearly impossible to modify, extend or update STL files. Prepping the original models to clean up junk and saving them in a couple of accessible formats will help others down the road.

Make yourself one

Head over to Thingiverse, download it, and print one for yourself!
http://www.thingiverse.com/thing:967668