An early test result, showing text and millseconds since power-on.

About a year ago, I bought a few 11 digit, 7 segment red LED displays from Active Surplus up on Queen Street in Toronto. (Excellent store.  If you’re into hacking stuff at all, it’s well worth the trip. Look for the monkey on Queen street to find their entrance.)

This past week, I wasn’t sure what to do at Interlock on Tuesday night, but I had recently re-found these displays, so I figured I would finally get them working.  I hit Radio Shack to get a Seeed Studio Arduino Shield ($10 with a mess of components, probably the best deal in all of Radio Shack.)

The display with a header soldered on, and the shield with its assorted parts.

I was all set to figure out how to reverse-engineer the pinout on the bottom of the display; I googled for the LED module, and found specs on those, and then on a whim, decided to check on the entire module board, a Rohm LU-3011, and found the jackpot, this post about figuring out the pinout.  It suddenly became very easy to do this project.

The two key things gleaned from that above post, which I have mirrored here, are this table of enables for each of the 11 digits:

and this image, showing the pin mappings of the segments:

Mapping of the segments to the pins on the header.

The basic way these displays work is that all of the 7 segments (plus one decimal point) are all tied together to the pins specified above.  Then the anodes for each of the displays are broken out to the pins in the table above.  So to draw a ’7′, you would set all of the segments to LOW, except for pins 11, 19, and 7 which you set HIGH.  Then to turn on a specific digit, let’s say digit 11 (rightmost), you set the digit enable pin 18 to be an output, and set it LOW.  Set all of the other digit enables to be inputs (tri-state, not low or high), and only position 11 will show a “7″.  You repeat this for all of the 11 digits in the display, and you can display 11 full digits from just those 19 pins.

In my code (available below) I start at digit 1, and work down to digit 11, enabling each one, in turn, showing its segments, waiting 1 millisecond, then disable that digit, move on to the next one.

I soldered a pin header on the display, and built up a shield to plug it into.

All of the digit enables wired up.  The top ones are a bit messy. Sorry about that.

I wired it up such that the digit enables and segments are wired directly to IO lines on my Arduino.  This used all of the IO lines, minus the D13 pin, which has an on-board LED.

The code that I wrote (available below) lets you do arbitrary digits per character, so that i can do (primitive) alphanumerics, or do animation patterns, etc.  I also store the decimal point as a separate character going in to the display code, so “3.141″ is five ascii characters going in, but a flag is set on the ’3′ position saying that this digit should also display its decimal point, so it only consumes four digits in the display.

just testing out all of the segments and digits

For now, it displays a nice clock and some animations on my desk, but I plan on changing it around a little in the near future.  I want to use the D13 line as one of the segment enables (probably decimal point) and move the segment enables off of the Serial Receive line.  That way i will be able to control it via serial to display patterns, animations or text content.  Since the hardware serial port is hardwired to 0 and 1, and I will be using the TX line for the LED displays, I’ll have to instead use the Software Serial, with only its Receive line mapped to an IO pin, and its Transmit line mapped to junk. I’ve done this before and it works well.

The code for this project is available in my Geodesic Sphere github repository.

This post is also available on my personal project blog thing.

Hello.  My name is Skip.  I’m an inventaholic.  I am compelled to invent things for reasons that I can not control.  I would like to welcome you to Inventaholics Anonymous.

Over the past 40 years, I have followed a path familiar to many people with my affliction by accumulating as many patents as I could.  But with the help of my new friends at INTERLOCK, I have overcome those tendencies, and I am proud to say that I have moved on to the sober world of hackers and makers.  A world  known as the Open-Source Hardware Movement.

First Patent: The Stepcounter

In many ways, being an inventor has scarred my life.   In the early 1970s I squandered all the funds I could beg or borrow (at least I didn’t steal), and I blew it all on my first patent.  The Stepcounter was a research device to measure the activity levels of laboratory animals.  My wife wanted to make the down payment on a house.  Thanks to my addiction, we rented for 25 years before we bought our first house.

Kenneth Brown, the author of a book called Inventors at Work asked my old friend, the late Bob Gundlach an important question during an interview: “Is it better to be an inventor working for a large corporation, or would you rather be working on your own?”  I can relate to Bob’s answer: “Being an inventor on your own is a good way to go broke! Being an inventor in a corporation is a very fortunate happenstance.”

But even within a corporation you run into the Not Invented Here Syndrome.  If you offer a solution to improve a product that is outside of your assigned responsibilities, you will probably be rebuked with something like “No thanks. I’ve got my own ideas and I know what I’m doing.  Go work on your own assignment.”

vue-stand

I graduated from Xerox a few years ago and in 2010, my friend Ken and I invented a stand for iPads that we called the vue-stand.  It would hold your iPad at a comfortable eye-level.  As a human factors engineer I have spent decades designing easy-to-use products, and I thought that we were onto something.  After we spent thousands of dollars to do a pilot run at manufacturing and did a little test market, I couldn’t help remembering Bob’s words of wisdom.  People didn’t buy the vue for reasons we now understand.  We decided not to keep throwing money at trying to market a dead horse, so I bought out Ken’s interest in our company, and I continue selling off my inventory online without promotion.  That inventory will cut my losses, but it will not cover my investment.

Last summer something happened that changed my life:  A couple of guys from this Hackerspace called INTERLOCK Rochester gave a talk at AppleCIDER, a local Apple Computer Users Group.  They demonstrated a little desktop 3D printer that they had built themselves.  I was blown away.

I knew about Stereolithography and CAD (Computer-aided design).  Xerox engineers had made rapid prototypes using that technology for decades.  But specialist operated those machines, and they had talent and training that I didn’t have.  Furthermore, the machines cost more money than an individual could afford.

Now, people are building these little machines that can even build parts to replicate themselves.  And people are sharing their designs and discoveries for other people to build upon.  The source code for anything built on these little industrial robots can be shared online at a site called Thingiverse.com.

They call the shared technology RepRap for replicating rapid prototyping.  The designs are evolving unbelievably fast because people are sharing with each other!  What a sobering thought!

I don’t plan to get any more patents.  Now I have a reprap machine, and I have joined the people who share ideas in a Hackerspace.

I used to think of hackers as being the bad guys who stole identities and maliciously created computer viruses and things like that.  Now it has come to mean people who take an existing good idea and hack on it to make it better.

iPad on a HandleStand

For instance, I have hacked-up an iPad accessory that I call the HandleStand.  I took a protective iPad case that I bought on Amazon for $8 and hacked it.  I drilled two holes and attached a pair of hinged handles to it with screws.  The case I chose also allows me to attach a Keyboard that protects the front of my iPad.

The handles open up to make a stand that allows the iPad to tilt at any angle.  Great for making videos or calling people on FaceTime with the iPad camera that can be pointed in any direction.  By the way, it also holds the iPad at a comfortable eye level just like the vue-stand.  But it is better for all these reasons.

Where can you buy this HandleStand and how much does it cost?  Sorry, but you can’t buy one.  You can get the source code from Thingiverse however, and if you can get access to a 3D printer you can make your own!  You can even hack it to make a better one!

You don’t have a 3D printer?  Well come on over to INTERLOCK on any Tuesday or Thursday night and we will help you hack one up.

I must admit that getting these little printers to run is a bit tricky sometimes.  They are complex electronic devices that run on an open source micro-controller called Arduino.  The hardware and software are made from the contributions of many-many people, and instructions don’t necessarily keep up with the latest developments. A lot of things can go wrong, and Murphy’s law does apply.

But hackerspaces are springing up all around the world where people help each other with things like that.  So you should join the world of hardware hackers.  Free CAD software has gotten so easy to use now that even I could learn it.

Pretty soon most people will know how to design using CAD just like now most people can make Powerpoint presentations.  Perhaps it won’t be long before most people will have access to a 3D printer.  I built one from a kit for a little over $500.  Or you can get a MakerBot already assembled for $2000.

I no longer spend a lot of money trying to sell inventions, I give them away and save a lot of money.  My designs can no longer be stolen from me.  I’m publishing the source codes on Thingiverse and I am happy that people are downloading them for free.

People tell me that I’m missing an opportunity to make money on my inventions… I don’t care.  I’m an inventaholic.

If you have access to a 3D printer you can make this!   

This is an Open-Source design, and the STL files can be downloaded from Thingiverse:  http://www.thingiverse.com/thing:64811

*    *    *

The HandleStand is hacked from an inexpensive protective case by adding a pair of 3D printed handles.

As the name implies, the accessory provides both a handle and a stand function for the iPad, but it is also quite portable, and the handle can be folded out of the way.

The assembly also accommodates a shoulder strap, a magnetically attached “Smart Cover” or keyboard.

*    *    *

 The A-Frame stand gets the iPad screen up to a comfortable eye-level.  A recent study at Harvard concludes: “Head and neck posture during tablet computing can be improved by placing the tablet higher to avoid low gaze angles (i.e. on a table rather than on the lap) and through the use of a case that provides optimal viewing angles.”  http://iospress.metapress.com/content/x668002xv6211041/fulltext.pdf

 *    *    *

“But how can I print a handle big enough for an iPad on my little printer that has a 6″ x 6″ bed?” you ask.

Well the answer is: “solvent bonding”…  I use Oatey cleaner that is sold in hardware stores to be used on plastic plumbing pipes.

* * *

The trick is to design the device in pieces that are small enough to be printed, and they also must fit together precisely.  Then you print them in ABS plastic which can be bonded with solvent to form a solid piece of plastic!* (Please see the WARNING below!)

* * ** * *

I carry my HandleStand with me everywhere!

* * *

With the HandleStand, an iPad can be adjusted to any position about the horizontal or vertical axis, so it is great for FaceTime or shooting video.  

The iPad is protected when conveniently carried using the handles or when on a shoulder strap or when folded and stuffed into a backpack or briefcase.

* * *

Instructions

The iPad HandleStand is made up of parts that are small enough to be printed in 3 runs on a PrintrBot LC (which has a usable print area of 120mm x 130mm). The plastic parts are solvent bonded to create handles that are too large to fit on the printer bed.

The Hinge Set contains 2 brackets and 2 sets of A-Frame hinge members. The brackets are screwed onto a polycarbonate protective cover such as the Poetic Basic Smart Cover Slim-Fit Case.

Each bracket is also screwed to a pair of the A-Frame hinge members with o-rings providing the controlled friction for the hinges. Locknuts insure that the hinges stay adjusted and don’t come off.

The Hinge Set takes about 2hr to print on a Printrbot LC with ABS. Handles each contain 3 handle parts and a Microbeaner, and they take about 1hr 20min for each to print (for a total of about 5hr printing time). ABS is recommended because it allows the parts to be solvent bonded together. If PLA or other material is used, then superglue (cyanoacrylate) can be used to bond the parts.

* * *

A shoulder/neck strap that is made from printed “microbeaners” and Parachord can be attached.

* * *

Parts list:

-(1) Hinge Set (containing 2 brackets and 4 hinge members).

-(2) Handles (each containing parts for a 3-piece handle and a MicroBeaner for the shoulder strap).

-(1) Polycarbonate iPad case that snaps on at the corners such as amazon.com/PoeticBasic-Smart-Cover-Slim-Fit-Crystal/dp/B007JBN6NQ

-(2) Stainless steel 6-32 x ¾” oval phillips machine screw (attach hinges to brackets)

-(2) flat-head 6-32 x ⅜” machine screw (attach brackets to polycarbonate case)

-(4) 6-32 lock nuts with nylon inserts

-(4) #6 o-ring provide friction for hinges

-(4) #41 o-ring provide friction against a table

-(1) ⅛” parachord   5’  long

* * *

Tools:

-Drill with ⅛” bit and countersink bit

-Solvent to bond ABS such as Oatey cleaner (yellow label white can) made for ABS plumbing pipe (or use acetone or superglue)… See warning below!

-Use match or lighter to burn the cut ends of parachord

* * *

*WARNING:

-Use CAUTION during solvent bonding!

-Use eye protection.

-Work in well ventilated area!

-The solvent dissolves many things, and the wet plastic stains whatever it touches!

-Use latex NOT vinyl gloves!

-Use aluminum foil on work surface!

* * *

Notes:

-Use great care to go back and coat the whole part for a uniform glossy finish (especially if parts were sanded), but do one end and hang to dry (for a few minutes) before doing the other end!

-The solvent can also be used to heal delaminated parts, but BE CAREFUL!

-Countersink the holes drilled in the Poetic case so that the screw heads will not touch the iPad.

-A large rubber band can be added to keep the the Ultrathin Keyboard or Smart Cover closed while the assembly is being carried around.

Enjoy the HandleStand! 

One of the things I was unsure of was the control linkages, and how the articulation points can be made.  It needs to have a few points of articulation to match the birds in the Enchanted Tiki Room:

• Perch rotation – 270 degrees, spins the bird around (not shown)
• Lean – +20, -20 degrees, to lean forward and backward at the point where the legs connect
• Head yaw – +45, -45 degrees back and forth
• Head tilt – +15, -15 degrees up and down
• Beak – 30 degrees, could be all open or all closed (shown in the diagram as 15 degrees)

I was thinking that after I constructed the foam version, I could figure things out from there, but after seeing this post on Hack-A-Day with a “HOG Drive”, I realized I could leverage off of this design for the head linkages.

I chatted with Skip at Interlock, and by the end of this last Tuesday evening, I had two 3-D printed versions of this, using ABS, rather than the PLA material I am more familiar with. (Here’s the Thingiverse link for the design.) Since I wasn’t going to be mounting a motor, we (and by “we” I mean “he”) replaced the motor space with a flat plate with a mounting screw hole.  He also replaced the back control arm with just a peg, since the bridge-like shape wouldn’t hold up properly on his printer.

The first print (on the left) has a failed control peg on the center disk.  It was adding material onto printed material that didn’t cool yet, so it just kinda globbed up.  This was improved by Skip by adding a second post, seen in the second version on the right.  He also added some material around the screw holes in the frame, to improve durability.

After printing and having this in my hand, I’m realizing that it won’t quite work for me, although it does give me an excellent starting point.  The center disk is too small to mount the head on.  It’s only about 1 1/2 inches in diameter. I think I’d want something about 2-3″ in diameter, with plenty of mounting points and space for securing the head ,as well as space for wiring for the beak servo (or linear motor, or solenoid, or whatever).  It really showed me the design considerations for actually constructing something, not to mention it really emphasized that whatever design I can think of, I can print… which is pretty futuristically awesome.

But the important thing is that I know have ideas to build on for the final version.  I’ll still be constructing a foam core model, and I’ll be using this above design as a kick-off point.

(This post is cross-posted to my personal project blog as well.)

One of the things that I’ve had to do for my re-purposing of the DB15 Stepper Motor controllers is to be able to reliably reprogram them.  The early versions of the programmer consisted of just a wire harness with a DB-15 connector on one end, and leads that plugged into the headers on a standard Arduino board. It eventually progressed into an octopus-like wire harness that used another DB15 as the “host” Arduino.  This worked well, but is cumbersome.  In this post, I’ll highlight the basic circuit used, and the procedure for using it, specifically for this controller board, but the techniques are applicable to other ATmega based micros as well.

The reason for doing all of this work.  About 30 or so DB-15 widgets which can be repurposed as Arduino-compatible microcontroller boards.  They don’t have all of the IO that a stock Arduino board has, but if your device only needs 6 IO (one of which is analog input), with a potential for another analog input, and 4 more digital outputs with a little work, they’re an excellent free resource at Interlock!

The ICSP (In-Circuit Serial Programmer) is basically a device that takes in a firmware image from a host computer, and uses SPI-based communications with a target device to shove that firmware image into place.  For general Arduino use, you can shove the Arduino serial bootloader into place. This is about 1k (for the optimized bootloader aka “Optiboot”) of program space that sits on your micro, next to any sketch that you download to it.  When the Arduino powers up or gets reset, this small bit of code will check for a new sketch to download.  If it sees something, it will accept it, shove it into program memory and then run it.  If it doesn’t, it simply skips over and runs whatever sketch has already been downloaded there.

The ICSP allows you to program in that bootloader.  You can also use it to program in your sketch, if you need to reclaim that 1kbyte of space.  I’ll get into that later on.

Okay.  Let’s get into the hardware for a moment.

Host Connection.

Showing the basic construction for the Arduino-ICSP Host.

The circuit to wire up is pretty easy.  On the host, there are three status LEDs that the packed-in “ArduinoISP” uses.  Heartbeat shows you it’s alive, Programming shows you when it’s programming a target device, and Error tells you when something went wrong — which is also displayed on the host computer.

These three output should be wired through a 220 ohm resistor, to a LED, and tied to ground.

One other thing that may be necessary is to disable the reset circuit on the host Arduino.  This is necessary because when the computer connects to the host Arduino-programmer, that micro will reset, and then quickly hop into the “check for new firmware over serial for itself” routine, as explained above.  This may often cause failures with the host computer connecting and communicating with the programmer properly.  If you disable the reset circuit here, it will never fall into this state, and will remain perfectly stable.  The easiest way to disable it, if you’re building it up from scratch, is to disconnect the DTR/Serial based reset trigger completely, leaving the 10k pullup resistor tied to the arduino’s reset line.  However, if you’re using a pre-constructed Arduino as the host, you can simply tie the reset line to +5v through a 120 ohm resistor.

Connecting the host to the target is also easy.  The target device should be hooked up as a basic arduino — power, crystal clock, etc. Be sure that even if they’re on separate power supplies, that they at least have their grounds tied together.  For ease of use, just power the target from the host completely. Past that, simply connect up pins 11, 12, 13 from the host to the target device.  This will put both on the same SPI bus.  This is how the data will get sent to the target device.  Basically, this maps out as SPI-MISO, SPI-MOSI, and SPI-CLOCK.  The only other connection you need to do is to hook up pin 10 from the host computer through to the RESET line of the target.

Step 1: hook up power, ground, serial IO, and reset circuitry.

The reset circuit is a 10k pullup resistor to +5v, and a .1uF cap to the reset line.

Next up will be putting a jumper to disable the reset line as explained above.

(Note: this picture is from a different build but shows the same first step)

The DB15 as seen here has pin 1 on the right.  The pins are basically: 1) TX,  2) RX, 4) RESET, then +5 and ground on the bottom pins.

The Red LED is the power indicator.  The resistor and cap for the reset circuit are visible, as is the jumper for disabling reset on the ICSP widget.

Above you can see the version of this board that I fabbed up for Interlock.  It has the FTDI header for connecting to the host computer, and used a pre-programmed DB-15 widget with the ICSP firmware on it.  I know this sounds like a chicken-and-egg thing, but once you program your first device using a standard Arduino as the host, it makes sense to program one of these, and use it to replace that board  instead. (especially when you have ~100 of them to spare. hehe)

The blue/white/red/white lines from the ICSP widget are equivalent to pins 10,11,12,13 on a standard host Arduino, and those go right into the cable down to the target device. Since pins 9, 8, and 7 were not all able to be broken out to the LEDs, I had to tweak the sketch a little.  8 is the LED on the ICSP widget itself, which is Yellow.  The Yellow and Green LEDs on the board (along with their current limiting resistors) are wired up to Analog 2 and Digital 3 (pwm), and these ports are changed accordingly.  8 remains as the error LED, 3 became the green Heartbeat light, and A2 became the new yellow program light.

Ready to roll, with a target device plugged in!

Note the extra prototyping area.  This can be for a ZIF socket in the future for other devices, etc.

The full circuit diagram for the D15-hosted programmer, connected to a D15 target.

(The wire colors are the same as the above for reference.)

Once this is all wired up, we can get some firmware down onto that thing.  In our case, we have a device that isn’t directly supported by the Arduino IDE, so we need to configure that first.

Two things need to be installed. First is the board definition, second is the optiboot hex file. Both of these content files can be grabbed from my Geodesic Sphere repository.  Full instructions are also there as for specific directories on Windows and Mac for doing this installation. The “readme” there shows the text block to drop into your “Boards.txt” file, and where to find that file.  You will also need to drop the optiboot.hex file into the “optiboot” folder as well.  Once these two steps are done, you can start up the Arduino IDE and you’re ready to program.  Let’s also assume that we’ve already externally kickstarted this, and the “Arduino ISP” sketch is already on the host device, and is running properly.

Here’s where it gets confusing.  What? You’re not already confused?  HERE WE GO!

Fire up the Arduino IDE, and let’s set it for the D15 device.  From the “Tools” menu, select “Serial Port” and select your FTDI interface’s serial port name.  Next, from the “Tools” menu, select “ATmega168 at 7372800Hz (D15)” from the “Board” menu.  This will tell the IDE what our target device is.  Now, from the “Tools” menu, select “Arduino as ISP” from the “Programmer” menu. This is all one-time configuration stuff.  Now, you can plug in a target D15 widget to the end of the cable seen above, and then select “Burn Bootloader” from the “Tools” menu.  A bunch of lights should flash, and you’ll end up with the Arduino bootloader on the target widget!

On the above setup, it’s wired such that you can also use it to test the target.  Disconnect the FTDI cable, disconnect the ICSP widget, and move the newly programmed device into the DB15 connector on the board.  Adjust the jumper so that “RESET” is enabled.  Now plug the DB15 cable back in.  This is now the equivalent to using the DB15 as a barebones Arduino.  Load up the D15_Test sketch included in the github repository mentioned above.  Click the “upload” arrow button, wait a moment, and the LED on the target widget should be blinking.  That’s it!

One alternate way you can use this is to program your Arduino code onto the target widget without installing the bootloader.  These widgets use an ATMega 168, which has very constrained space, so this might be preferred for larger programs.

Hook it back up in the programmer configuration, with the ICSP widget on the board, the target on the cable, and the jumper set to disable RESET.

From the Arduino IDE, instead of just clicking the “upload” arrow button, hold down the [SHIFT] key, and the text will change from “upload” to “upload using programmer”.  It may take a moment longer, but the end result is that you will see the LED blinking on the target widget.

You can use this to program other Arduino-like devices too (ATMega, ATTiny, etc).  You will just need to breakout the 6 lines (MOSI, MISO, CLOCK, RESET, +5v, GROUND) to whatever pin header configuration or socket is necessary.  Then you can just select the target device from the menu as appropriate (ATmega 168, 328, 5v, 3.3v, etc) and then select “Burn Bootloader” from the menus as above, and it will put the appropriate serial bootloader onto the device for you.

Last month, I read in the local paper of the formation of the Rochester Brainery, opening early next month in the Village Gate, across the Goodman Street railyard from us here at Interlock and our neighbors at the Hungerford.

We’ll always owe a debt to Dave at Coworking Rochester for helping us get started by offering space and moral support during some of our bigger early organizational meetings, before we settled on a space of our own to rent. Still, it’s interesting to see people coming together in another coworking space in town, Smokestack Coworking, High Falls area.

Here’s hoping they both thrive and complement each other.

Last month we received a visitor from Ithaca, José, who traveled up with a couple of friends maybe to join what he thought at the time was the closest hackerspace to him. I had a great time talking with him, so it was a little bittersweet to tell him Ithaca Generator has recently gotten off to what looks like a good start and might just meet his needs without the long drive.

I wasn’t able to make it to their open house back in December. But, I
did visit with some family over the holidays who were able to go and got to see the party favors they made at the open house. Fun. Look like good things are in store for the hands-on, DIY hacker and maker community in Ithaca.

We’ve also been having a friend, Joe, make the trip from Niagara Falls every so often to visit, which has had us asking how things are going at Buffalo Lab. Figured we’ve give them a shout out while we’re at it.

[placehold for eventual Rochester Makerspace logo]

Last, but hopefully not least, the most recent big news is a much-anticipated step for the group calling themselves Rochester Makerspace. They’ve rented a space a little north of downtown, on St. Paul Street. Just Tuesday they had a get-together with pizza at the new location.

Though the planning for this new space has been careful and deliberate, ongoing since at least this last summer, they now are moving towards ambitious goals to grow fast. I continue eagerly to await the opening of another maker-friendly space in Rochester, expected some time in March.

My name is MacGyvrBot.  I’m an open-source 3D Printer hacked-up from a Printrbot LC kit by Skip (Printrbot LC | printrbot).  I hang out at the INTERLOCK space a lot, but I’m portable and I often follow Skip around to help at Tango Product Design.

Skip creates most of my gcode  instructions on Slic3r – G-code generator for 3D printers from stl files created on  Tinkercad – Mind to design in minutes.  I often publish my designs on Thingiverse – Digital Designs for Physical Objects.

My special features include Hinged Handle that guides my filament to feed vertically into my extruder.  This minimizes perturbations on my x-axis and doubles as an alarm by slamming down if my Filament gets snarled from the supply spooled on a Rack made from a hacked-up Power Tower | printrbot.  I can carry my MacBook around in Brackets on my starboard side. MacBook Brackets by MacGyvrBot – Thingiverse

My power cord and my usb connector along with a power connector for the MacBook can be stored in a Zipper Pouch below the filament rack.  I also have a handy Z-stop Adjustment Z-Stop Adjuster for Printrbot LC by MacGyvrBot – Thingiverse that lets Skip tweak the thickness of my first layer if the printed perimeter doesn’t look perfect.

On my starboard bow there is 70mm Muffin Fan (scrounged from Skip’s junk pile)  with an Air-flow Adjuster and Shroud custom made for the fan 70mm Fan Shroud by MacGyvrBot – Thingiverse.  I made a similar fan for my RepRap Mendle friend from an 80mm fan 80mm Fan Shroud by MacGyvrBot – Thingiverse.  The adjustment allows Skip to conveniently adjust my bed-cooling during a print job.  The maximum airflow marginally allows my heated bed to maintain the 80 degrees C required to stick onto ABS while it allows tall single features to quickly cool layer by layer. The fan can be adjusted back to make sure the first layers stick properly.

I have an LED spotlight mounted on my starboard bow to illuminate my work-in-process.

Skip’s iPad can hang on my port side during our travels.  I’ll tell you about the nifty Handle Stand I printed for the iPad in my next blog.



As seen in a previous post, I have a Tron Mini/Cabaret arcade machine.  I used to have a Tron full-sized (FS) machine, but sold it many years ago.  One thing that the FS had over the mini was lots of extra lighting.

It had artwork beyond the monitor lit with a regular light, it had a blacklight above the control panel to make the traces glow, and make the joystick glow.  There’s also a second blacklight below the control panel to backlight the bottom portion as well.  All of these lights are always lit, making the machine extra awesome.  On the mini, there is glow artwork, but no light to illuminate them.  Ever since the late 90s, I’ve had a plan to change this, so I bought a pack of UV LEDs, but they’ve sat dormant in my parts bin until now!

One thing that I’d like to bring to this, is to go an extra step, and bring some ideas over from the “Environmental Discs Of Tron” (EDOT) machine.  On the EDOT, you walk inside of it… one of the few, if not the only, games where you can do this.  Around the monitor and control panel are lights, similar to the FS Tron. However, on EDOT, they’re controlled by the game.  They will flash and such when certain game events happen. I can make this happen with Tron, using an interface to the game, and a ROM hack.

Above all, the modifications made must be reversible without any damage to the machine.  I do not want to inflict any permanent damage or changes to the cabinet.  I will simply add lighting, make a ROM hack to control the lights, and mount an additional board inside the cabinet.

To start with, I need a secondary micro to control the lights. I’ll use one of my stepper motor controller/Arduino devices. I made the FTDI programming and power interface seen above in about 30 minutes on the piece of strip board at Interlock this past Tuesday.  You can see the resistor/capacitor pair to handle the programmer’s reset, power, and TX/RX lines, and a red power indicator LED for the heck of it.

After a bit more work, I had the 3 LED driver chips wired up, with their 8 outputs, along with the 5 pin header which I’ll be using to interface it with the arcade machine.  The pinout there is two bits of input, 5v power input, and ground.  I’ll add in SPI-like (clock+data) communications from the TRON game.  I figure that the first version will just send down a packet stating the lighting effect, but in the future I can use this to send down high scores as well, which can be sent out via serial to a host PC and post them on the net or something like that.

At first it didn’t power on properly, and the LED driver chips got VERY hot.  Then I remembered that the circuit diagram I was referring to while soldering this up was incorrect and had power and ground reversed to the chip.  I also had + and – wired backwards for the LEDs as well. I forgot that these driver chips sink current, rather than sourcing it.  After a little bit of emergency soldering, all of that got worked out.

I’ve since cleaned up the wiring a bit, adding some insulation.

I decided to wire up the LEDs such that the current limiting resistor was wired up with the LEDs, rather than on the main board.  I’m glad I did this, as the resistance I picked (220 ohms) was way too high.

Enhanced image. It sadly doesn’t look quite this intense in person.

Experimenting with how it will look to have LEDs inside of the joystick to illuminate it.

 The output from these LEDs was much dimmer than I was hoping for. I will be experimenting with lower-valued resistors, as well as possibly doubling-up LEDs for lighting the various artwork elements.  I also need to figure out how to mount the LEDs without damaging the machine at all.

Next up is the ROM hack to talk with this!

I’m in the process of constructing/setting up my office in the house, and for lighting, I have decided that I want to use xmas light-style lighting.  Many years ago, I used to light my room with multicolored incandescent lights. I loved the warm indirect glow, and smooth light without a single light source.  This time, I’m going to take it a step further.

While there’s nothing about this project yet that is really innovative over what others have done, it is the first step to getting the office lighting done.  The real fun will come into play once I’m able to hang this up, and start programming effects, and tying those effects in to physical or time-based events.

A couple years back I picked up a strand of addressable LED lights, similar to this one, available at adafruit.com.  I got a strand of 50 lights, blew out one of them while being stupid, and used a few of them in Jasper’s Toy Box (posts to come about that eventually), so I’m left with 42 lights.  A nice number.

In any event, the plan is to hang them up around the upper perimeter of the room, and it will give a nice comfortable glow to illuminate the room.  I can also extend it by doing lighting effects with the color.  For example, in the evening I can have all of them dim blue, and randomly twinkle one to white, to simulate a star in the sky.  I could also tie them in to an automation system to glow a particular corner of the room red or yellow when i have email from a specific person.  I could also adjust their color based on the content of my monitor, or the light outisde, etc.

The basic design for the control circuitry is that there will be an Arduino-based AVR micro (actually one of the D-15 servo controllers I’ve appropriated), which is perfect, since the strands only need two lines to control them.  The host computer will send down codes to address the LEDs (set all to color X, set led Y to color X, etc) and this will pass on the content to the strand, and twiddle the data lines and all of that fun stuff.  I had considered putting more “smarts” into the micro, but the amount of space in there would severely limit the kind of content I could “display”, so I decided to put all of the grunt work back on the host computer.

To power it, I needed to get a 5 volt power supply. I snagged a power brick from an old external drive case, as well as a standard PC power connector, from a failed power supply, and spliced the two of them together.

Copious, yet appropriate amounts of heat shrink tubing and splicing some wires yielded a nice power supply.

Next, I built an interface board to tie it all together.  The ports on the board are (left to right) – 6 pin FTDI interface for serial IO, 2 pin jumper (power the D15 from the power supply rather than FTDI source), 3 pin power, 4 pin light strand connector.  You can also see in this picture, the process of crimping the terminals for the molex connector on the LED strand’s wires.

I kept the layout and pinout of the FTDI the same as I used for my serial node experiment.  This will help me plug that connector in correctly.  I still need to add visual cues (colored sharpie markings) to help me align the pins correctly.  The power connector has GND on pins 1 and 3, and +5V on pin 2.  Keeping it symmetrical will help me always plug it in correctly, reducing the chance that I will blow it all up.  The 4 pin connector is the same pinout as the wiring of the LEDs.  GND, Data, Clock, +5.

The jumper on the board (dis)connects the power header from the D15 and FTDI portion.  If I make standalone firmware for it, I can power everything from the power supply, if need be. The tiny green LED on the board just lights when the D15 has power.  A nice indicator in case everything else is not functioning.

The protocol I used for this is very simple.  There’s a command character sent through serial, then the data for that command.  If the firmware is expecting a command character but gets something it doesn’t understand, it just keeps checking the serial input for a command it knows.  The protocol is as follows:

Five bytes.  It sets the specified LED (0..42 in this case) with the specified RGB value (0..255 each).  Note that this is not an ascii string, it is data.  So no matter what, it is 5 bytes to change a single pixel.