Every once in a while, the Hack a Day tip line gets a submission that is cool, but screams to be built in a few hours, possibly while consuming adult beverages. When [Shay] and [Ben] sent in their Manifold Clock Kickstarter, I knew what I had to do. To make a long story short, there’s a manifold clock hanging on my wall right now. Check out my manifold clock how-to guide after the break.

As designed by [Shay] and [Ben] at Studio Ve, the Manifold Clock tells time in three dimensions and is based on the log z Riemann surface. Here’s the video the guys put up on their Kickstarter campaign:

As you can see, it’s not a terribly complicated build. There are three basic components for this build. First, the clock drive: these can be had for about $5 from any arts and crafts store. Secondly, the clock hands: not many clock drives come with a six-inch long minute hand, but I can make something work. Lastly, the webbing that goes between the hands. The official version of the Manifold Clock uses Tyvek for its tear resistance, but I came up with something just as cool.

To create the long clock hands, I repurposed the clock hands that came with the clock drive. By cutting of the largest part of the hour and minute hand, I was left with a small sliver of brass that can be attached to the hub of the clock. I bought a few pieces of brass tubing while I was in the hobby shop, as well. The hands of the clock were extended by soldering on brass tubing with 0.1″ or 2.5mm OD brass tubing:

Pardon the terrible picture. If anyone would like to donate a macro lens for a D40, I would graciously accept.

After cutting the clock hands to length, everything’s gravy. Now onto building the webbing that goes in between the clock hands.

The next two paragraphs are rather boring. Fair warning.

If you’d like to create your own manifold, just fire up your favorite CAD package and get to work. For my manifold, I first drew a circle with the same radius as the minute hand, and two more for the hour hand and center. I used a circle with a diameter of half and inch for the center – just enough to clear the hub of the clock drive. Inscribe a 12-gon in the hour hand’s circle, and draw the hour hand. I drew mine at 5 o’ clock, although this is just a rough guesstimate from watching the video for the Manifold Clock

The next step may be a little difficult if you don’t know your drawing package very well, but luckily it can be done very easily with a compass and straight-edge construction. I’ll let you Euclid that one out for yourself. Bisect the hour and minute hands, then draw a circle with a radius that is the average of the minute and hour hands. Draw an arc from the tip of the minute hand through the intersection of the bisection and circle you just drew, ending at the tip of the hour hand. Erase a few lines,  put some tabs on for gluing, and you’re done.

To save everyone from having to replicate my work, I’ve created a PDF file of the template for my clock’s membrane. This template is sized for a minute hand that is 5.5 inches long and an hour hand that is 3 inches long. Do with it what you will.

The Manifold Clock uses a piece of Tyvek for the web between the hour and minute hands. Tyvek can be had for free if you care enough to drive around to a new development and dumpster-dive for a piece of housewrap, but I wanted to make my clock a little classier. My webbing is made out of mylar (from an “emergency camping blanket” or alternatively a mylar balloon) with a layer of Kapton tape stuck to one side. The Kapton tape was originally purchased for the heated bed and hot end of my RepRap, but once I realized the gold foil on the Apollo LEM were a lamination of mylar and Kapton, I had to try this out. The result is a fairly tear-resistant film in a wonderful silver and gold:

Oh yeah, you also have to bend the minute hand higher than the hour hand.

After cutting my gold and silver film according to the template, the only thing left to do is assemble the clock. Wrap the tabs on the web around the hands of the clock, making sure the hands can rotate freely around the foil. Assemble the hands onto the clock mechanism according to the directions and mount it in some sort of enclosure. I used a fifty-cent round clock face:

So far the clock has been up on my wall for 38 hours and it’s still keeping the right time. I’m going to call this a success. Here’s a time-lapse of the clock in action:

The expenses for this build were a clock mechanism for $5.99, a small brass tube for $2.99, and an unfinished clock face for $0.50, totaling $9.49. Of course I haven’t figured in the cost of the mylar, Kapton, solder, paint, and soldering iron, but you get the point.

Sadly my clock doesn’t have a second hand and doesn’t tick very loudly so a Vetinari Clock is out of the question. If anyone is brave enough to build a Manifold Clock with a second hand, send it in. We’ll put it up.

As winter is officially upon us, we’re pretty sure that the last thing most of you are thinking about is mowing your lawn. We would argue that it’s actually the ideal time to do so – that is, if you are interested in automating the process a bit.

[Robert Smith] has spent a lot of time thinking about his lawn, wanting a way to sit back and relax while doing his weekly trimming. He set off for the workshop to build an R/C electric lawnmower, and thoroughly documented the process in order to help you do the same.

On his web site, you will find a series of videos detailing every bit of the solar charged R/C lawnmower’s construction, taking you through the planning phases all the way to completion. [Robert] has provided just about anything you could possibly need including parts lists, schematics, code, and more.

If the short introductory video below has you interested, be sure to swing by his site for everything you need to build one of your own.

[Emily Daniels] has been teaching interactive electronics workshops geared towards children for some time now, recently holding a session that demonstrated how batteries work in a pretty novel fashion.

She wanted to keep things safe and simple due to the class size, so she didn’t want to rely on using soldering irons for the demonstration. Instead, she showed the children how batteries function by building simple voltaic cells with paper flowers, salt water, and LEDs. The paper flowers’ absorbency was used to act as a salt bridge between the wire pairs that adorned each petal. After salt water was applied to each of the flower’s petals, the center-mounted LED came to life, much to the amazement of her class.

The concept is quite simple, and the LED flowers are pretty easy to build, as you can see in her Instructables tutorial.

We think it’s a great way to demonstrate these sorts of simple concepts to kids, and hope to see more like it.

[via Adafruit blog]

The number one and number two things asked after presentation of our DIYDTG were…
“How does it hold up in the wash?”
and…
“How did you change out the inks?”
While we’ve explained the first several times (regular ink washes out, DTG ink gets a little lighter but survives) we can hopefully answer the second with a tutorial.

To change out or refill the Epson cartridges we used was relatively simple. You’ll need a few supplies.
-Old/used (or new, but you would be wasting ink) Epson cartridge
-DTG ink (we recommend DTGinks.com)
-SSC utility (this lets your trick the printer into thinking it has a fresh cartridge)
-Windex (ammonia base won’t rust the print head)
-Plastic syringe
-Flat head screw driver
-Hot glue
-Electrical tape
-Small cup
-Rags (ink gets everywhere)
-Resolve or other stain remover (to clean up said ink everywhere)
-Time (a lot of it)
-(Optional) sponge from other printers
-(Optional) latex gloves
-Original head waste collection piece from printer.

The bottom item on the list is a small funnel and squeegee that were originally located just below the head when it is at ‘home’ position within your printer. Its job was to suck ink out of the head, cleaning it and priming it at the same time.

Fair warning, your fingers will be black/stained without gloves.

You’ll want to first take the flat head screwdriver and crack open the cartridge’s top. Make sure it stays intact, we will be reusing it and glueing it back on. From there, pull out the old sponge that resides in the cartridge.

Pour some Windex in a cup and place in the cartridge and top. You can either soak the original sponge as well in the cup, or cut a new sponge. We don’t recommend kitchen sponges (too many large holes), but we found several clean sponges in old printer’s ‘ink recycle receptacle’ – for lack of a better term.

Let it soak (we recommend overnight).

I’ll take this moment to explain how to prime your head. You’ll want to make sure you put in some cartridge: ink, DTG ink, Windex, or other. Just don’t try to prime your head with air/no cartridge!

Take your syringe, and push it onto the hose that is connected to the waste collection piece.

You’ll position it below the head’s nozzles (seen in the picture below as dots), push it against the head with one hand. Using your other hand, pull out the syringe (creating a vacuum). You should get a nice thick stream of whatever cartridge you put in. If not, wiggle around the waste collection piece until a seal is formed. We pull out on average about 1ml of liquid to prime.

(Optional) If you think your printer has a lot of clogged heads, you can take out the cartridge from the cup. Place it in your printer head, and fill it with Windex. Prime as explained above. Your heads should be clean and clear.

Once your sponge has soaked (or you cut a new one), simply drop ink/DTG ink onto the end of the sponge that will be pushed into the cartridge first. We used about 10ml, do NOT fill your sponge completely.

Stuff the soaked end first into the cartridge, pushing it down to the bottom, but make sure you don’t push too far, the top of the sponge has to touch the lid (why that’s important in a moment).

You’ll notice that by squashing down the sponge into the cartridge, the extra previously unfilled area of the sponge gets soaked.

Push on your lid, and hot glue around the edge, it must be air tight (but not so much so you can’t ever get the lid off again, we assume you’ll want to refill again). And place a small amount in any holes except the main center one.

By having the lid done this way (with the sponge and glue) you’re creating an air tight seal that only lets out the correct amount of ink. If you cleaned out your head before with Windex (that optional stage), with no sponge and no lid as instructed, you may have noticed just how easily without this seal that fluid will just fall out of the head, you don’t want that.

(Pictured below, ink dribbling out)

Wrap a tight piece of electrical tape over the cartridge, covering and sealing the bottom hole completely. Only once around is needed, too many and the plastic spike may not be able to pierce the tape.

Place the cartridge into the head, from here on out, until the cartridge is completely empty, do NOT remove it from the head. Prime your head. At this point if you put too much ink into the sponge you’ll see it fall out of the head (as mentioned above). Don’t worry, just leave it. Place a rag underneath and wait (once again, overnight is prefered). By morning you should be able to wipe away all the excess, prime it, and no ink will ‘just fall out’.

We also added a small piece of rag to act as a squeegee to help clean the head when it returned to home position.

You’re done! Do a lot of test printing, you’ll find that some of the first prints will be messy (it took us 10 full prints before we got it to be constant darkness).

For those unaware, the little acronym above stands for Do-It-Yourself-Direct-To-Garment printing. In layman’s terms, printing your own shirts and designs. Commercial DTGs can cost anywhere from $5,000 to $10,000 which for the hobbyist who only wants a few shirts is ridiculous. So you would think this field of technology would be hacked to no end, but we’ve actually only seen one other fully finished and working DIYDTG. So we took it upon ourselves to build a DIYDTG as cheaply and as successfully as possible.

We would like to take this moment to thank [makemygraphix] for his original designs, as ours is heavily based off his. And Tshirt Forums, for their valuable input.

For your own DIYDTG you’ll need a few parts, (we honestly just used what we had lying around)
-3/4 inch particle board/plywood/MDF
-1/2 inch particle board/plywood/MDF
-1/4 inch plywood
-1 and 1/2inch wood screws
-24inch ball bearing drawer track
-scrap aluminum (1/16″ thick)
-Epson printer (more on this below)

The printer you choose is the most absolutely crucial part of this hack. We took apart an HP DeskJet 3845, Canon iP1500, Brother MFC420CN, Epson Stylus Photo 820 and an Epson Stylus c40. Why so many? We literally purchased every printer the local thrift store had (at $6 a printer, it’s not that bad actually), that way the reader wouldn’t have to. Our findings were thus; the HP and the Canon both had rotary encoders on the paper feed shaft and ended up being a total peta to try to align and get working, both not recommended. The Brother was an all-in-one that would not function unless every part was connected, making it too large and bulky for our needs. Both Epsons used stepper motors, were very easy to take apart, and only had one easy to manage paper sensor. Go with Epson! (We ended up using the C40 because it had the 3 ink CYM system instead of the 5 CYMLCLM system the 820 did).

As for the ink you will be using in your printer, we found DTGinks.com to be a good resource.

For software for your Epson, we found the default drivers worked well enough. There is RIP software out there, but we couldn’t find any that supported the c40. We will recommend the SSC Utility program though. Allowing you to quickly and easily lie to the printer about how much, what kind, and replaced ink cartridges (for Epson only).

For tools we recommend the following
-measuring tape
-square
-pen/chalk line
-table saw
-circular saw
-jigsaw
-Dremel
-drill press/drill (and an assortment of bits)
-sand paper/file

We started off by taking apart the printers. Every printer is different, so we can’t give you details but its relatively simple process. By the end you’ll only need the head and its carriage, the paper feed motor and its shaft, and the power supply.

You’ll need to cut the wood as follows, (it should be noted, these are slightly different then what we actually used)
For the 3/4 inch,
1 x 26inch by 11 and 1/2 inches.
1 x 26inch by 10 inches.

For the 1/2 inch,
2 x 26inch by 5inch,
2 x 26 inch by 1 and 3/4 inches.

First clamp the two 26″x5″ boards together. Now 6″ from the end and 2″ and 3/8″ from the bottom drill a 5/8″ hole through both boards at the same time. This is where your paper feed shaft will go.

Here is a tricky part, the metal track. We mounted the outer part 3/4″ from the top on one of the 26″x5″(doesn’t matter which you choose) pieces and made the stop/back/end of the track flush with the end of the board (this isn’t very high priority) . And the inner part of the track goes 1″ and 1/8″ from the top on one of the 26″x1 and 3/4″ pieces.

Normally we do recommend that you use metal “L” brackets to attach corners of wood, but as long as you pre-drill a hole slightly smaller than your screws, you’ll be fine (we also counter sunk most of our screws, but that’s optional). Attach the two 26″x1 and 3/4″ to the  26″x10″. Do the same with the two 26″x5″ and the 26″x11 and 1/2″ pieces.

All that was a little tricky, so here is a picture to help out. For those wondering, the top tray rolls “towards” you in this image.

And a shot without the top tray, as you can see our shaft wasn’t long enough, so a simple 2″x3″ piece was put in place. Make sure the shaft spins freely and without binding, with and without the top tray in.

The next interesting part is mounting the drive motor. It needs to be snug against the gear of the shaft, yet not too tight to make it grind against the wood. It also needs to have a way of preventing the shaft from “popping out”. We solved both problems relatively simply.

Take your assembly, remove the top shelf, and prop it on its side. Position your motor where it will be mounted on top/inside the 26″x5″ piece. Drop in the shaft, get everything aligned and draw a circle around the motors base. Using a straight edge and tangent lines you can approximate the center of your circle.

Use a large hole saw cut it out (it doesn’t have to be perfect). Sand/file it so the motor easily fits in without bending any pins. We pop riveted a 1″x3″ piece of aluminum to the motor to make mounting a little easier.

Drop in your shaft and make sure everything lines up. Finally, to prevent the shaft from slipping in, we used the washers and C clamp from the extra printer parts (you didn’t throw away, right?) on the other 26″x5″ piece. And to avoid the shaft from slipping out we took a 1″x10″ piece of aluminum, bent it in a “_n_” shape, drilled a hole for the shaft, and used a cut up spring from the extra printer parts. A picture is worth 1000 words,

Bare with me, we’re almost done!

You’ll need to modify the printer carriage now, simply cut off the slot that paper used to come through,

You’ll want to mount it on-top of the two 26″x5″ pieces about 6″ back. We were lucky and found two of the previous mounting screw holes on the carriage fit perfectly, however other printers you might need to bend or make your own. (This picture taken before we made our nifty “_n_” bracket).

Now we made our platen, this is the thing your shirt goes on. It’s really up to you how its made, and we’re not even totally happy with our design, so play around and find what works best. Ours is 24″x9 and 1/2″ piece of 1/4″ plywood mounted to the top of two 20″x2 and 7/8″ pieces of 1/2″ plywood. The height measurement completely depends on the height of your head. For those wondering, we never got an answer for how far the shirt should actually be from the head, but we’ve found about 1/8″ works well enough. (The “legs” you see on our platen were later taken off.)

Mount your power supply and solder it, alongside your motor, to the driver board.

Now there is one part we’ve neglected to mention until now. And that is the paper feed sensor (remember that one sensor we mentioned earlier?). Well it’s because we spent 3 days trying to get that sucker to work with our platen. We tried everything, different timings and positions of the platen, even programming an MCU to try to trick the printer into thinking the platen was paper. In the end, we just broke it off.

By accident.

And it worked (no really!) It takes a little timing on our part but by hand to trigger the sensor, but we’ve never had a misprint like we did with the platen. (Pictured below, one of our “tape” attempts at triggering the paper feed sensor, this one worked about 1 out of 50 times).

Powered on,

Send a print job, hand trigger the paper feed sensor, and we have a print!

Here is just a short video if it in action, most notably you can see us hand triggering the paper feed sensor. The orange was a test print, as you can see if your platen isn’t 100% flat and level relative to the head, you’ll get some smudging and general print errors. The white shirt was a perfect (well, test) print that we did a little earlier.

(Yes, we know the video was blocked earlier. We have re-uploaded it, thank you for your patience; it should work now.)

*Disclaimer, using tools without proper ear and eye protection can result in a visit to the hospital. And HaD is in no way responsible for any damages. Be smart, be safe.*

Complex programmable logic devices (CPLDs) contain the building blocks for hundreds of 7400-serries logic ICs. Complete circuits can be designed on a PC and then uploaded to a CPLD for instant implementation. A microcontroller connected to a CPLD is like a microcontroller paired with a reprogrammable circuit board and a fully stocked electronics store.

At first we weren’t sure of the wide appeal and application of CPLDs in hobbyist projects, but we’ve been convinced. A custom logic device can eliminate days of reading datasheets, finding the ideal logic IC combination, and then waiting for chips to arrive. Circuit boards are simpler with CPLDs because a single chip with programmable pin placement can replace 100s of individual logic ICs. Circuit mistakes can be corrected by uploading a new design, rather than etching and stuffing a new circuit board. CPLDs are fast, with reaction times starting at 100MHz. Despite their extreme versatility, CPLDs are a mature technology with chips starting at $1.

We’ve got a home-etchable, self programming development board to get you started. Don’t worry, this board has a serial port interface for working with the CPLD, and doesn’t require a separate (usually parallel port) JTAG programmer.

Intro to CPLDs

When to use a CPLD

Consider using a CPLD when a design calls for more than one 7400 series logic ICs. A CPLD will be cheaper, faster, and can be programmed with your ideal pin-out configuration for simpler PCBs.

Use a CPLD in tricky designs that might require several iterations. It’s easier to design a new circuit in software and upload it to the CPLD than it is to design, etch, and stuff a new circuit board.

For maximum speed and instant response, choose a CPLD. The difference in speed is amazing; CPLDs start at a 100MHz, while microcontrollers respond to interrupts at a few MHz. CPLD designs form circuits that react to external stimulus, reactions occur almost instantaneously. A microcontroller executes code to react to events, even interrupt routines have comparatively high latency.

CPLD vs FPGA

FPGAs are better known than CPLDs, but they share many characteristics. This analogy isn’t perfect, but we like it: where FPGAs are a reprogrammable processor core, a CPLD is a reprogrammable circuit board or breadboard. FPGAs replace microcontrollers, memory, and other components. CPLDs absorb logic ICs, and work well with a microcontroller.

Manufacturers

Altera and Xilinx, the biggest CPLD manufacturers, are better known for their FPGAs. Lattice Semiconductor is another large CPLD manufacturer with less community following. Atmel makes pin-compatible versions of old industry-standard CPLDs.

If you plan to work at 5volts, your options are limited. Xilinx XC9500 CPLDs are still available as new old stock, but cost four times more than newer 3.3volt equivalents. Atmel’s ATF1502 series works at 5volts, but they don’t offer a free development environment.

At 3.3volts there’s more options, but new CPLDs increasingly have a core that runs at 2.5volts, 1.8volts, or lower. The Altera MAXII and the Xilinx XC9500XL series are probably the most popular 3.3volt CPLDs. Xilinx also makes the CoolrunnerII CPLD, but it only comes in a TQFP package and requires a separate 1.8volt supply for the core.

Packages

Most manufacturers offer one or two CPLDs in a hobbyist friendly PLCC 44 package, though this is starting to disappear. PLCC is an SOIC-sized surface mount chip with pins on all four sides. PLCC44 sockets are commonly available in through-hole and SMD versions. Unfortunately, newer CPLD families are starting to eliminate the PLCC package and offer only 44 pin and larger TQFP chips, such as Xilinx’s CoolrunnerII.

Development environments

Most manufacturers offer a free development environment that supports design entry using simple schematics, as well as Verilog or VHDL. Many won’t support the latest FPGAs in the free version, but we only need the CPLD parts anyway. Altera has Quartus, Xilinx has ISE, and Lattice has ispLever. Atmel has ProChip Designer for the ATF15xx series, but they only offer a 6month trial license — which they wouldn’t actually give us.

Programmers

The development board we present doesn’t need a separate JTAG programmer because the PIC microcontroller already programs the CPLD.  If you want an external programmer, the cheapest are the parallel port programmers: Parallel Cable III for Xilinx and BytleBlaster for Altera. Inexpensive clones, and schematics, are available at SparkFun.  The OpenOCD is a generic USB JTAG programmer that will work with many CPLDs, FPGAs, and ARMs.

Our choice

We eventually settled on the Xilinx XC9500XL series because it had a cheap development kit we could use to test our JTAG programmer prior to implementing an entire design.

The DO-CPLD-DK from Digilent includes a XC9572XL, a CoolrunnerII, and parallel port programmer. Nu Horizons has some old non-ROHS models for $40, but due to sloppy variable type handling in their credit card processing scripts, we couldn’t complete an order online. We tried to do it over the phone but they refused to take such a small order on the phone, even during a website malfunction. In the end, it was cheaper to pay full price at Digikey (#122-1512-ND) after including New Horizon’s exorbitant shipping charges. We wouldn’t normally mention this, but with only two places to buy the board it’s probably worth noting our experience.

CPLD development board

Click here for a full size schematic image (PNG). The circuit and PCB are designed using the freeware version of Cadsoft Eagle. All the files for this project are included in the project archive linked at the end of the article.

Circuit

A PIC 24FJ64GA002 microcontroller (IC1) provides the user and programming interface to the CPLD. We use this $4 PIC in a lot of projects because the peripheral pin select feature makes board routing really easy. Check out our introduction to the PIC24F for more details. The PIC needs to communicate with a PC serial port, so we added an inexpensive MAX3232 RS232 transceiver. The serial interface should work with a USB->serial adapter.

Our choice of CPLD (IC3), a Xilinx XC9572XL (PDF), is connected between the PIC and several other components. We can create an endless variety of circuitry between the PIC and other chips using the reprogrammable logic inside the CPLD. The PIC will program the CPLD with code sent from a PC serial port, but we still brought the JTAG pins to a header for easy external debugging.

A DS1085 digital programmable oscillator (IC4) generates clock frequencies between 8KHz and 133MHz, at 10KHz increments. This is very similar to the DS1077 we covered earlier, but it has even steps between all frequencies. The DS1085 requires a 5volt supply (VR2). The I2C interface also runs at 5volts, so we connected it to 5volt tolerant PIC pins. It’s possible to use the 3.3volt 66MHz 1085L instead, and remove the 5volt supply.

We used a cheap 3.3volt SOT223 voltage regulator (VR1) to power most of the circuit.  The 5volt supply (VR2) can be excluded if you use a slower 1085L 3.3volt oscillator.

CPLDs are commonly used as a memory controller, so we included 32K of SRAM (IC5) on the development board. A 3.3volt latch with 5volt tolerant inputs interface the memory inputs to a wide range of external voltages (IC6). The latch inputs are held low with a 1Mohm resistor network (RN1). We’ll discuss this section extensively in an upcoming article.

PCB

The board is a quasi one-sided design. We made several compromises so we could prototype this highly experimental PCB ourselves. We present the board ‘as is’ for other die-hards that might want to etch this board at home. If you send the PCB to a board house, try to correct these issues prior to producing a ‘real’ double-sided board.

One power pin of the CPLD is missing a decoupling capacitor entirely; there was no way to put a capacitor in that area. One CPLD decoupling capacitor, and the SRAM decoupling capacitor, are through-hole parts. Using these through-hole parts eliminated a few jumper wires.

The jumper wires on the back of the board are optimized for single-sided production, rather than good design practices. We faked a double-sided board by soldering the power bus on the back. A real double-sided board design should route the power bus to avoid crossing signal paths, and include the missing decoupling capacitors.

We used an surface mount PLCC chip socket, but a through-hole version is definitely a better idea. We though the SMD version would be easy to solder, but it turned out to be a nightmare. We really wanted the CPLD to be on the front of the board for the coolest possible presentation. A proper two-sided board with plated through-holes can have a through-hole socket on the front, but this wasn’t possible with our 1-sided prototype board.

Parts list

Click here for a full size placement diagram (PNG).

Firmware

The firmware is written in C using the free demonstration version of the PIC C30 compiler. Learn all about working with this PIC in our introduction to the PIC 24F series. The firmware is included in the project archive at the end of the article.

We wanted a super easy way to interact with the hardware on the board without endless compile-program-test cycles. We made a custom version of the Bus Pirate firmware that  provides a simple ASCII terminal interface to the DS1085 clock chip (I2C), the CPLD programing interface (JTAG), and a 3 wire (SPI) interface to the CPLD. Check out the Bus Pirate tutorial for background on the simple syntax used with the firmware.

The original Bus Pirate firmware handles several protocols that share the same pins. For the CPLD version, we changed the pin assignments to fit the connections on the development board. We also removed unused modules and options.

CPLD blinky LED examples

We prepared several designs in Xilinx’s ISE development environment. The schematics, pin placement files, and compiled designs (XSVF) are included in the project archive linked at the end of the article.  A full explanation of ISE is beyond the scope of this article; we found the help files sufficiently useful to make these examples.

The first design simply lights the LED connected to pin 8 of the CPLD.

Prepare the XSVF file

XSVF is a compressed JTAG programming format, as described by Xilinx in this application note (PDF). XSVF isn’t limited to programming Xilinx devices, and can be prepared for any chip that provides a common BSDL JTAG definition file.

Open the iMPACT programming tool from the ISE Design Suite project panel under Configure target device->iMPACT.

• Choose the option to create a boundary scan file,  and set the type to XSVF.
• Give the XSVF output a file name and then add a compiled CPLD image (ex1.jed) when prompted to add a device.
• You should see a JTAG chain that contains a single device.

Click on the device and choose program; iMPACT will record the programming sequences to an XSVF file.

With XSVF file in hand, it’s time to open up a terminal and program the CPLD. We like Tera Term and Hercules on Windows. You must enable XON/XOFF flow control in the client to use the JTAG interface. The default PC side setting for the development board terminal is 115200bps, 8N1.

HiZ>m <–select mode
1. HiZ
2. I2C
3. JTAG
4. RAW3WIRE
MODE>3 <–JTAG
900 MODE SET
602 JTAG READY
JTAG>(2) <–probe JTAG chain macro
xxx JTAG INIT CHAIN
xxx JTAGSM: RESET
xxx JTAGSM: RESET->IDLE
xxx JTAGSM: IDLE->Instruction Register (DELAYED ONE BIT FOR TMS)
xxx JTAGSM: IR->IDLE
xxx JTAGSM: IDLE->Data Register
xxx JTAGSM: DR->IDLE
xxx JTAGSM: RESET
xxx JTAGSM: RESET->IDLE
xxx JTAGSM: IDLE->Data Register
xxx JTAG CHAIN REPORT:
0×01 DEVICE(S)
#0×01 : 0xC9 0×02 0×06 0x9A <–XC9572XL responds
xxx JTAGSM: DR->IDLE
JTAG>

In the terminal we enter the mode menu (m), and choose JTAG (3). Macro 2 probes the JTAG chain, in our case this is just the CPLD.  The chain report tells us that the chip is connected and responding. Read more about the JTAG interface.

Now we can run the XSVF programmer, macro (3), and upload the XSVF file from the terminal in binary mode. The first example just lights the LED on pin 8. If the LED lights, we can verify that programming was successful. If your LED doesn’t light, don’t despair; sometimes the JTAG programmer sticks and a reset macro (1) will get the chip going.

LED at full brightness.

74LS32/4071 OR gate, blink at half rate (/2)

A major component of the CPLD development board is the 1085(L) frequency synthesizer connected to pin 7 of the CPLD. The next example uses a logic OR gate, like a 74LS32 or 4071 IC, to blink the LED whenever the clock signal is high. At even the slowest clock rate the blinking will be too fast to see, but we should get a nice PWM dimming effect compared to the first example.

JTAG>m <–select mode
1. HiZ
2. I2C
3. JTAG
4. RAW3WIRE
MODE>2 <–I2C interface to DS1085
900 MODE SET
202 I2C READY
I2C>(1) <–address search macro
xxx Searching 7bit I2C address space.
Found devices at:
0xB0 0xB1 <–found the DS1085 address
I2C>

Program the CPLD as before, and then switch to I2C mode to access the DS1085 clock. We could look up the device address in the datasheet, but we save a few seconds by running the address search macro; the report tells us the chip answers to 0xb0 (write) and 0xb1 (read).

I2C>{0xb0 0×02 0b00011111 0b10000000}<–max prescaler
210 I2C START CONDITION
220 I2C WRITE: 0xB0 GOT ACK: YES
220 I2C WRITE: 0×02 GOT ACK: YES
220 I2C WRITE: 0x1F GOT ACK: YES
220 I2C WRITE: 0×80 GOT ACK: YES
240 I2C STOP CONDITION
I2C>{0xb0 1 0b11111111 0b11000000}<–max divider
210 I2C START CONDITION
220 I2C WRITE: 0xB0 GOT ACK: YES
220 I2C WRITE: 0×01 GOT ACK: YES
220 I2C WRITE: 0xFF GOT ACK: YES
220 I2C WRITE: 0xC0 GOT ACK: YES
240 I2C STOP CONDITION
I2C>

The DS1085 is almost exactly like the DS1077 we covered earlier, but has a DAC controlled oscillator for even steps between all frequencies. We programmed the clock to the slowest frequency using the commands shown above. The LED is dimmed by the pulse-width modulation effect of the clock signal.

LED at half brightness.

74F269 16bit synchronous counter, blink slowly (/65535)

We just programmed the CPLD with a logic OR gate similar to a 74LS32. Now, we’re going to reprogram the chip with a 16bit counter like two cascaded 74F269s.  At $1.15 each, two 74F269 Ics are more expensive than the XC9572XL CPLD. A 16bit counter rolls over once per 65535 ticks, so a LED attached to the last bit will toggle once every 65535/2 ticks.

Now we can see the cool part of CPLDs. The CPLD is like a programmable breadboard; we just popped out the 74LS32 and put in a 74F269, without buying parts, reading datasheets, etching, wiring, etc. A microcontroller connected to a CPLD can reconfigure its own circuit board to fix errors, add features, or re-purpose it for entirely different applications.

We upload the new design as before, but now the clock is divided by 65535 and the LED toggles about once per second.

Taking it further
Next time we’ll look at discrete 7400-series logic chips, and implement a ton of them in the CPLD to make a high-speed bus sniffer and logic analyzer.

Download: bitclone.v1.zip

Now that we listen to MP3s, and watch XVIDs or x264s, a computer is the entertainment center in at least one room of most homes. Unless you have a special HTPC, though, you’re probably stuck using the keyboard to pause, change the volume, and fast-forward through annoying Mythbusters recaps. PC remote control receivers range from ancient serial port designs (who has one?) to USB devices not supported by popular software. In this how-to we design a USB infrared receiver that imitates a common protocol supported by software for Windows, Linux, and Mac. We’ve got a full guide to the protocol plus schematics and a parts list.

Design overview

Remote controls transmit data on an modulated infrared beam. An infrared receiver IC separates the modulated beam into a clean stream of 0s and 1s. The data stream is decoded by a microcontroller and sent to a computer over a USB connection. Software processes the codes and triggers actions on the computer.

Background

Computer infrared receivers

The oldest PC infrared receiver design uses a receiver IC to toggle a serial port pin, usually DCD. This design probably originated on Usenet, and it’s still the most popular on the web: Engadget, Instructables, etc. These aren’t true serial devices because they don’t send data to the PC. Instead, a computer program times pulses on the serial port and demodulates the signal. This is a super simple design, but it depends on direct interrupt access and timing precision that’s no longer available in Windows. Linux or Mac users can try this receiver, if you still have a serial port. We couldn’t get this type of receiver to work with the serial port on a modern Windows XP PC, and don’t expect the precise timing to transfer through a USB->serial converter.

Some more advanced infrared receivers are true serial port devices that measure or decoding infrared signals before sending data to the computer. The UIR/IRMan and UIR2 incorporate a classic PIC 16F84, but don’t provide firmware and/or source code. These devices should work on a modern computer, through a USB->serial converter if necessary. The USBTINY and USBIRBOY are native USB devices, but lack wide support.

Receiver software

Regardless of receiver type, the computer needs a program to listen for incoming remote commands and convert them to actions on the computer. Linux and Mac users have LIRC, which supports a bunch of different receiver types. Windows users are a bit less fortunate. WinLIRC is an abandoned Windows port of LIRC for simple interrupt-based serial port receivers; WinLIRC was last developed in 2003. Girder was originally a freeware PC automation utility, but has become expensive bloatware with a 30 day trial. Fortunately, the last freeware version of Girder (3.2.9b) is still available for download.

Working with IR remote protocols

Decoding IR signals

Remote controls encode commands in the spacing or timing of a 38KHz carrier pulse, [San Bergmans] has an explanation of the principals involved. An infrared receiver IC separates the data stream from the carrier. Our job is to decode the data stream with a microcontroller. There are dozens of remote control protocols, but Phillips’ RC5 is widespread and commonly used by hobbyists.

RC5 is stream of 14 equal length bits of exactly 1.778ms per bit time. A pulse during the first half of the bit time represents 0, a pulse in the second half represents 1. This scheme is called Manchester coding.

We used a logic analyzer to examine the output of a Happauge WinTV remote control, a known RC5 remote. The diagram shows two presses of the 1 button, and two presses of the 2 button; note that the output is inversed and the Manchester coding is backwards from the above description.

The first two bit times are start bits, followed by a toggle bit. The toggle bit inverses each time a button is pressed so the receiver can tell the difference between a hold and a repeated press. The next 5 bits are the address (0b11110=0x1E), followed by the command (0b000001=0×01, 0b000010=0×02). A backwards compatible extension to RC5 uses the second start bit as command bit 7.

Representing remote codes to the computer

Looking at previous designs, we saw three general methods of communicating remote commands to a computer:

• Protocol specific receivers decode one protocol, and send actual decoded commands to the PC
• A more general type of receiver measures the timing and spacing of each pulse and sends the full waveform to the PC for analysis.
• Some receivers create a unique hash for a signal, but don’t actually include enough data to fully recreate the waveform.

While our preference is towards the general hash method, our only remote uses RC5 and it was more interesting to build an RC5 specific decoder. We describe modifications for a more general version in the firmware section.

Computer interface protocol

We didn’t want to write our own receiver software or driver, so we looked for an existing, well established communication protocol to imitate. The UIR/IRMAN/IRA/CTInfra/Hollywood+ type receiver is supported by Girder and LIRC, and uses a simple serial protocol with handshake:

• The device is initialized by the DTS and DTR pins of the serial port. We don’t have these and don’t care.
• The computer sends “IR”, with an optional delay. The device replies “OK”. We’ll just send “OK” on every “R”
• Remote control codes are sent as a unique six byte hash. We’ll decode an RC5 signal and send the actual values, but a generic hash could be used instead.

This protocol is for a serial port device, but our USB receiver will appear as a virtual serial port and the program won’t know the difference.

Hardware

Click here for a full size schematic (png). Our receiver is based on a USB enabled PIC 18F2455 microcontroller, the smaller, cheaper version of the 18F2550. The 18F family is programmable with the hobbyist favorite JDM-style programmers if a diode is used to drop VPP to a safe level. The PIC gets one decoupling capacitor (C1), and a diode (D1) and resistor(R1) on the ICSP programming header. We exposed the serial port on a pin header for debugging or a mixed USB/serial port version using a MAX RS232 transceiver IC.

The USB peripheral requires a 20MHz external clock (Q1, C5,6), and a .220uF capacitor. We faked the capacitor using 2 x .1uF decoupling capacitors (C2,3). A 3mm LED (LED1) and a 330ohm current limiting resistor (R2) show USB connection status.

We used a TSOP-1738 infrared receiver IC which calls for a 4.7uF decoupling capacitor (C4). If you can’t find this particular IC, any receiver listed here should work. The TSOP-1738 output is the inverse of the received signal, it pulls to ground when a pulse is detected, so a pull-up resistor (R3) holds the pin high when no signal is present. Check if you use a different receiver, you may need to use a pull-down resistor and reverse the Manchester decoding routine in the firmware.

The circuit draws power from the USB bus, so we don’t need an additional power supply.

Parts list

Click here for a full size placement diagram (png). The PCB design is 100% through-hole and single sided. The schematic and PCB were made with Cadsoft Eagle, freeware versions are available for most platforms. All the files are included in the project archive (zip).

Firmware

The firmware is written in C using Microchip’s free demonstration C18 compiler. Firmware and source are included in the project archive (zip).

We used version 2.3 of Microchip’s USB stack to create a USB serial port using the default drivers already available on most systems. The USB stack has simple functions to enumerate the USB device and transfer data between device and host. It only took a few pin changes to get the CDC demonstration working on our custom hardware.

Our implementation of the UIR/IRMAN/IRA/CTInfra/Hollywood+ protocol simply responds to the letter ‘R’ with ‘OK’. This should satisfy the handshake requirements of any implementation of this protocol.

We chose to specifically decode RC5 (and RC5x) because it’s a widely used protocol, and the only type of remote we have to work with. Most of the decoding is done in the interrupt handler:

• The first signal change triggers an interrupt that starts a 889us (one-half bit period) timer.
• On each timer interrupt, one-half of a Manchester coded bit is sampled.
• Every other interrupt the measurements are compared, and the bit value is calculated to be 0, 1, or an error. Errors reset the decoding routing.
• At the end of each transmission the address and command bytes are decoded, and sent to the host with 4 buffer bytes(0). We discard the toggle bit because it would confuse the PC software into thinking every other press was a unique code. We append the second start bit to the command bit for RC5x compliance; this just adds 0×40 to non RC5x remote codes.

A more general version can be made by removing the Manchester coding step (3), and sending 48 sample bits (all 6 bytes) to the computer.

Installing the USB infrared receiver

Most operating systems already have drivers that support a virtual serial port device like the receiver. Windows XP has the required drivers, but needs help from an .inf file to properly associate them with our device.

Windows will show the new hardware dialog the first time you plug in the receiver. Choose to use a custom driver and point it to the .inf file included in the project archive (zip). This links the device to a driver already included in Windows, and adds the receiver as a COM port. You can check the COM port number in the control panel.

Mac and Linux users can use the receiver with LIRC, but Windows users will be faced with the choice of the old, freeware Girder, or the new, 30-day trial shareware version. We used the freeware version of Girder, but hope you guys can suggest a great, open source alternative that we overlooked.

Regardless of the computer-side control software you use, configure it for a UIR/IRMAN/IRA/CTInfra/Hollywood+ style receiver, and enter the COM port or serial address assigned to it. Our receiver is also compatible with any protocol options like ‘Fast UIR Init’ and ‘Skip UIR Init Check’, which shorten or eliminate the “IR”->”OK” handshake. Now test the receiver and add a remote according to the documentation for your software.

Manual terminal interface and debugging

If you have a problem with the receiver, or you’re just curious, try to interface it from a serial terminal. We really like the serial terminal on Hercules. Set the correct COM port, but the speed and configuration settings are ignored by the USB serial port driver.

A capital ‘R’ will prompt the receiver to reply ‘OK’. RC5 codes are returned as raw bytes, so be sure to set your terminal to show HEX values rather than interpret it as ASCII text. The first byte is the RC5 address byte (0x1E), followed by the command byte (0×41), and then four buffer 0s to comply with the UIR/IRman protocol. The image shows the handshake, and the output of a short press on the 1,2, and 3 buttons.

A free utility called Portmon logs COM port activity for review. This is helpful for spying on existing receiver protocols, and debugging the interaction of our custom hardware and closed/proprietary software. The image shows Girder sending the initialization string ‘IR’ (0×49,0×52), and the receiver reply ‘OK’ (0x4F,0x4B).

Taking it further

Our RC5x compliant receiver follows a widely used interface protocol. There’s a ton of possibilities for additional features in an open source infrared receiver:

• Support all remotes through a generic hash generator, like the original UIR/IRman hardware.
• Add additional remote protocol decoders, like RC6.
• Support multiple, configurable interface protocols.
• Implement the serial port I/O.
• Store configuration options in EEPROM, including protocol, interface mode, timing options, serial port, etc.

For years, Microchip PIC microcontrollers dominated; PIC16F84 hacks and projects are everywhere. The 8-bit 16F and 18F lines are supported by several coding environments and easy-to-build serial port programmers. Microchip’s 16-bit PIC24F is cheaper, faster, and easier to work with, but largely absent from hacks and projects.

We recently used a Microchip PIC24F microcontroller in a mini web server project, but didn’t find many introductory references to link to. In this article we’ll cover some PIC 24F basics: support circuitry and programming options. We’ll also talk about our favorite features, and how we figured them out. Our next article will outline a web server on a business card based on the PIC 24F.

The basic circuit

This is the basic support circuit (full size .png) for a PIC 24FJ64GA002. Some helpful documents are the code examples, application notes, individual datasheets, and 24F family manual.

Main system power supply

Peripherals and pins on the 24F PICs operate between 2.0 and 3.8volts. This is a big advantage over older PICs because the 24F can directly interface modern 3.3volt components like SD memory cards. Some 16F and 18F PICs will run at 3.3volts, but usually at drastically reduced speeds. As always, put a 0.1uF capacitor between each power pin and ground to decouple the chip from the power supply (C1, C2).

Core power supply

The processor core requires a separate 2.5volt supply. A built-in 2.5volt regulator can be enabled by connecting the DISVREG pin to ground, and placing a 10uF capacitor between the Vcap/VDDCORE pin and ground (C3). We’ve not experienced any problems using a 10uF low ESR electrolytic capacitor, but in the future we’ll use a tantalum capacitor as specified in the datasheet.

Speed and crystal

PIC 24Fs have a max clock speed of 32MHz, and complete one operation every 2 clock cycles for a top speed of 16 million instructions per second (MIPS). Most 24Fs have an internal 8MHz oscillator, but you can also use an external crystal for a more precise timebase. An internal phase lock loop (PLL) can multiply any clock signal by four.

We used a common option: 8MHz internal oscillator multiplied by four (32MHz), with full IO functions on the external oscillator pins. The clock mode is set with CONFIG2. Use these settings to run a PIC 24F at 32MHz using the internal oscillator and PLL:

// Internal FRC OSC with 4x PLL @ 32MHz
//from p24FJ64GA002.h:
//FNOSC_FRCPLL - internal oscillator
//OSCIOFNC_ON  - enable the oscillator pins as IO
//POSCMOD_NONE - Primary (external) oscillator disabled

_CONFIG2(FNOSC_FRCPLL & OSCIOFNC_ON &POSCMOD_NONE)

Programming connections

Microchip’s standard 5 wire in circuit serial programming (ICSP) connection is used to program the 24F. ICSP consists of a clock line (PGC), bi-directional data line (PGD), master clear and reset (MCLR), and connections to power (V+) and ground (GND).

The MCLR function resets the chip when voltage levels are too low to operate. Enable it with a 2000 (2K) ohm resistor (R12) from the system power supply to the MCLR pin. Optionally, add a button (S1) from MCLR to ground for a manual reset switch. The programmer also connects to the MCLR pin to reset the PIC and control programming modes.

PIC 24Fs have several sets of programming pins labeled PGDx and PGCx. Choose the set most convenient for your design. One catch: you can’t use the clock pin of one set and the data pin of another, you have to use the same pair.

The primary pin pair used for debugging is programmed in CONFIG1 with the ICS_PGX option. This only effects debugging; programming is still possible from any pin pair.

_CONFIG1( ICS_PGx3)

Coding and Programming

Unfortunately, the 24F can’t be programmed with the hobbyist-favorite serial port programmers. These are usually 5volt programmers that place 13volts on the MCLR pin. 24F PICs are rated for 3.8volts maximum on the MCLR and programming pins, old serial port programmers will destroy them.

The ICD2 is Microchip’s cheapest programmer for the full 24F line. An education discount is available if you have a .edu email. There are numerous clones too, most notable is the Olimex PIC-ICD2 clone, also sold by Sparkfun. We’ve never used it, but it’s supposed to be an exact clone. You can also try your hand at building a DIY ICD2 clone, we’ve had luck with the PiCS Rev B in the past. You’ll probably need to build an adapter to use a homebrew ICD2 with a PIC 24F.

MPLAB is a free development environment for coding, compiling, and debugging all PIC microcontrollers. We like to program in C, so we downloaded the free, evaluation/student edition of the Microchip C30 compiler that integrates into MPLAB. HI-TECH’s C compiler is a fairly popular alternative if you’re not thrilled about MPLAB.

Microchip’s low-voltage 18FxxJ line, such as the Ethernet enabled 18F97J60, can only be programmed a few hundred times. That’s fine for production, but really unfriendly to a developer. We’re exceedingly happy to note that the 24F can be programmed at least 10,000 times.

New features and improvements

We made a list of the things we liked best about the PIC 24F after using it in a project. Not all of them are new, sometimes little improvements make designs much simpler.

8-bit vs 16-bit

C programmers won’t notice many differences between 8-bit and 16-bit architectures. Native 16-bit math operations will save you a few cycles if you do 16-bit integer math. Memory and registers are 16-bits long, meaning the default 16-bit variable type counts to 65,536, rather than 255.

Peripheral pin select

Peripheral pin select (PPS) is our favorite feature on the PIC 24F. The digital peripherals SPI, UARTs, timers, etc can be connected to almost any pin on the chip.

PCB designs get really creative because the pin arrangement on a microcontroller rarely matches that on the peripheral you’re interfacing. Compare these two designs. The design on the left uses looping, winding traces to connect a SD card without jumper wires. On the right, we used PPS to assign pins in a way that lined up perfectly with the SD card. We spent caffeine fueled nights routing the board on the left, but only hours on the other. We’ll find it difficult to ever work with a PIC 16F or 18F again because of the complete and total awesomeness of PPS.

Input and output pins are assigned differently: pins are assigned to inputs, outputs are assigned to pins. A peripheral input, such as the “serial data input” (SDI) signal of an SPI interface, is set by putting a pin number in its register. In the C30 compiler, SDI of SPI1 and SPI2 are assigned like this:

// Inputs
//SDI1 B12/23/RP12
//SDI2 B1/5/RP1

RPINR20bits.SDI1R = 12;            //SDI1 = PORTB12

RPINR22bits.SDI2R = 1;            //SDI2 = PORTB1

Output functions are handled in the opposite way. A group of registers represent the programmable pins (RPORx). Peripheral outputs are assigned to each pin. Assign the SPI “serial data output” and “clock output” lines like this:

// Outputs
//SDO1 B11/22/RP11   //CLK1 B10/21/RD10

RPOR5bits.RP10R = SCK1OUT_IO;     //RP10 = SCK1

RPOR5bits.RP11R = SDO1_IO;        //RP11 = SDO1

//SDO2 B3/7/RP3       //CLK2 B2/6/RP2

RPOR1bits.RP2R = SCK2OUT_IO;     //RP2 = SCK2

RPOR1bits.RP3R = SDO2_IO;        //RP3 = SDO2

Check the device datasheet and the IO with PPS datasheet (PDF) for a complete list of peripheral (RPINRxx) and pin (RPORx) registers.

Individually configurable pull-up/pull-down resistors

Pull-up and pull-down resistors hold inputs at a known level when there’s no other signal. Illustrated below on the left (S1), a pull-up resistor (R1) normally holds the signal high (1). A button press pulls the signal to ground (0). Without a pull-up resistor, the value on the microcontroller pin will fluctuate wildly (state undefined) until a button press pulls it to ground (0).

Internal pull-up resistors make it easier to route a button on a circuit board. An internal resistor holds the signal high until the button pulls it low, saving a resistor and power supply trace (S2). PIC 16Fs and 18Fs sometimes have an all-or-nothing pull-up on 8 pins, but the 24F adds individually configurable pull-up resistors. See the IO datasheet (PDF).

CRC hardware module

Cyclic redundancy check (CRC) values are used to verify the integrity of data. Your PC calculated CRCs for the TCP packets that carried this page over the web. The 24F has a hardware CRC module that does tedious CRC calculation without processor involvement. Check out the datasheet (PDF) and example code (ZIP).

Real time clock and calender

Microchip added a hardware real time clock and calendar module (RTCC) to every 24F. It’s always been easy to add an interrupt-based clock to a microcontroller, but this module takes care of everything without timing concerns.

The RTCC module requires a 32.768khz watch crystal (Q1) to be connected to the SOSCx pin pair. Don’t forget 2 suitable capacitors for your crystal, we used 27pF (C1,C2). There’s a datasheet for the RTCC module (PDF), and example code (ZIP).

Package sizes

Microchip continues their tradition of offering products in a range of package sizes. Low pin count parts are available in through-hole (DIP) and several surface mount sizes. As with all manufacturers, though, the largest, coolest, chips are only produced in surface mount packages. Microchip is a fan of 64, 80, and 100 pin thin quad flat packs (TQFP), a square chip with an equal number of pins on all sides. TQFP isn’t terribly difficult to solder, but the circuit boards can be a pain to make at home.

Conclusion

The past was dominated by 8-bit PIC 16F and 18F-based microcontroller projects. 16-bit PICs, however, have been largely neglected. If you’re already considering a PIC for your next project, check out the 24F series. The peripheral pin select feature alone is worth the switch — it simplifies circuit boards, reduces routing time, and saves board space. We were able to fit an entire PIC 24F web server on a business card using a home-etched PCB. Our next article will introduce this simple server prototype.

The project archive (ZIP) contains the base schematic for the PIC24FJ64GA002, and a custom 28pin part we added to an existing PIC 24F part library. Both are for use with Cadsoft Eagle, a freeware version is available for most popular platforms.

We’ll begin by building the solder fume hood. Yes, we said “hood”, not just “extractor”. While there have been some nice fume extractors hacked together, this system integrates all of your soldering tools into and around the fume hood.

The purpose of a fume hood is to draw solder fumes away from the person soldering. Besides the health risks, these fumes are really annoying as they follow that pesky law of the universe: “No matter where you happen to be sitting, solder fumes will float directly towards your face.”

To start, let’s gather materials:

Once all the materials are gathered, we can begin cutting the plastic of the Rubbermaid container. To cut this material, use a plastic scoring tool. When you make your cuts, make sure to repeatedly score the line you want to cut until the blade goes all the way through the plastic. Do not try to score it and snap it like acrylic. This material has a bad tendency to crack in places you didn’t intend. If your plastic cracks, all is not lost. Since the plastic is soft, you can weld the cracks back together by touching it with the tip of a high temperature hot glue gun.

First, we need to cut a hole for the fan in the top of the hood. Take off the cover of the fan and use it to make a hole slightly smaller than the inside diameter of the fan cover in the top center of the hood. The fan is actually going to hang from the top of the hood and pull the fumes out of the hood when turned on.

Once the big hole is made, drill smaller holes for the screws used to hold the fan together. With the nuts on the outside, screw the fan assembly to the top of the hood.

To reattach the top cover of the fan, use some scrap solid core wire or twist-ties to connect the spars on the top cover to the spars on the bottom fan assembly. We used only three twist ties as this is plenty to keep the fan cover in place.

Now we are ready to mount the light. Mark a good place to attach the light in the back top of the hood. It is likely that the mounting screws that came with the lamp are too long. Additionally, the lamp might get too hot. To prevent the lamp from melting the plastic, we cut about five half-inch spacers out of some of the plastic cut off earlier. To make life easier, pre-drill holes in the center of each of the spacers. Use a couple of the spacers on the inside to lower the lamp away from the top of the hood, and then use a few on the outside to cover the sharp points of the protruding screws. Alternatively, encapsulating the screw points on the outside of the hood with hot glue works just as well.

Next, cut the main window of the fume hood. Ours goes all the way across the front and is about 7 inches high. It’s a good idea to start with a smaller hole and expand it to see what feel comfortable for you to use. Make sure it is easy to reach the top back wall of the hood. This is where the controls will go later.

At this point, you can use zip ties to attach the active carbon filter to the top of the fan.

Plug the fan and the light into a powerstrip. Make sure the fan and the light are turned on so you can turn the entire hood on and off from the strip. Plug in the soldering iron and you are ready to go. The adjustable base of the fan is used here to hold the excess wire from the soldering iron; keeping it out of the way.

A slightly more advanced option for the front is to cut another smaller window (about 6.5 by 13.5 inches) just above the first one and add a piece of acrylic. This greatly improves visibility. Make sure to cut the acrylic about a half inch larger than the window to give yourself a surface to glue. Attach the acrylic on the inside of the fume hood with hot glue.

To improve your soldering iron set-up, you can get a professional soldering station. But why spend $50 on a temperature controlled soldering station when you can build your own for cheaper! Afrotechmods has a rough guide to building a great adjustable temperature soldering station.

To install this soldering station into the fume hood, simply cut a hole in the back of the hood large enough to stuff the dimmer and the socket through it from the front side and small enough to make sure the mounting holes still have some plastic to mount to. The box will be attached to the back of the hood, but the faceplate needs to be on the inside.

You’ll notice that there is a different knob on the dimmer switch. We used a scrap knob with a flat bottom (comes complete with cool numbers) on the dimmer switch instead of the stock knob.

Regardless of what soldering station you use, if it doesn’t have auto turn off (which is good for fire prevention), put a grounded AC appliance timer inline with the iron. These timers allow you to automatically turn on or off any AC appliance at any time you want within a 24 hour period, but don’t rely on it to keep your iron turned off, as it will turn it back one every 24 hours. It’s better than nothing and is a cheap option, as they run between 5 and 10 bucks at local hardware and super stores. The one we use has increments of about 15 minutes. Setting it for 30-45 minutes works well.

For some reason, the designers of these timers want to take up all the plug space they can by placing the plug practically in the center on the back of the timer. Luckily, the scrap dimmer knob we found has a low profile, and allows the timer to plug in with little interference to the dimmer. A better option is to get an aquarium timer. These are designed with a better form factor and generally only cover one socket.

Many cheap soldering irons come with a sponge to clean the tip. If you think about it, it’s not really the best idea to use a sponge to clean your soldering iron; it works, but it also cools down the tip of the iron every time you clean it. If you are doing delicate work and clean your tip once every couple of soldering points, this can lead to cold solder joints and bad connections.

Professionals use a flux covered wire mesh to clean the tip. This method draws off the solder and uses flux to clean the tip. Every now and then, you just kind of stab the mesh with your iron a couple of times to clean it off. The problem is that this method costs around $10.

Instead of buying some job specific wire mesh, just use a copper coated scourer to clean your soldering iron tip. Usually used for cleaning pots and pans, these little guys can be picked up at your local grocery store for $1 or so a pack. The copper mesh isn’t coated with flux, but the copper itself will draw the excess solder from the tip of the iron. Do not get the steel scourers, as they are only good for cleaning dishes.

A great addition to our ti
p cleaner is the use of a simple $1 “locker organizer” picked up from the dollar aisle of the local super store. Just shove the scourer into the organizer to keep it from sticking to the iron. The magnet on the bottom will also weigh it down enough to keep it on the table when you make spastic stabs at the scourer in frenzied hacking sessions.

Surface mount soldering is becoming more common amongstl hackers and hobbyists. This work is notorious for being one of the most tedious and annoying practices known to man. Of course, having the right tools for the job helps. The cheapest surface mount rework stations cost upwards of $100. In the past, our own [Will O'Brien] showed how to make your own surface mount reflow iron.

A reflow iron or pen isn’t the only tool you need for surface mount soldering. Sometimes you’ll need a hot plate or oven.

For smaller jobs we’ve found that using a candle warmer can be useful. We got ours for $5 from a super store. The plate might not get completely hot enough to melt the solder by itself, but it does help a lot when you use a soldering iron or a reflow iron by decreasing the time and effort it takes to warm the joints. The sweet spot on these warmers is usually directly in the middle of the black steel plate.

Simply place a PCB in the center of the candle warmer and allow it to raise the temp of the solder joints. Use a reflow pen or soldering iron to heat the particular joint you want the rest of the way. It will take a lot less time to melt the solder this way. This is especially useful when placing surface mount parts, but can also be useful when taking them off of a PCB.

Placing all of these components together inside the fume hood, the Hacker’s Soldering Station is complete. With this project we set out to make a simple, cheap solder fume hood complete with a time and temperature soldering station. We ended up with a great soldering station and fume extractor set up. In fact, this has now replaced one of the WLC100 soldering stations we usually use.

Many people use protoboard and point-to-point wire everything, but needing multiple copies of the same circuit is the reason that forces many away from using protoboard. After making your first circuit board, you might not point-to-point wire anything again!

For your first circuit board, one goal is to keep the circuit single sided so you can etch using single sided copper clad. This will allow you to gain some experience before moving on to double-sided. If you need topside traces, simply run a few jumper wires on the top. There are many complete circuit layouts you could try like the Hack a Day design challenge winner.

Here is a list of materials you will need to produce a single-sided board. With the exception of the copper clad and PCB drills, everything on this list is easily obtained at your local store.

Materials: Muratic acid, common household hydrogen peroxide, safety goggles, good quality magazine pages (cut to 8×11), laser printer, single sided 1 ounce copper clad, a plastic container the board will fit in, soft plastic brush, clothes iron, lacquer thinner, rubber gloves, paper towel, tin snips, drill or rotary tool, PCB drill bits, Scotch Brite scrubbing pad, good ventilation, 5-gallon plastic pail full of water.

Now, here is how you do it:

Print the bottom side layer on a piece of paper from a high quality magazine. Use one actual page from the magazine, the thicker and shinier the magazine paper the better, but do not use the cover. You must use a laser printer, not an inkjet. If your printer uses ink cartridges and not toner cartridges, it will not work. If you do not have a laser printer, you can work around this by printing to white paper and using a photocopier set to the darkest setting to copy the layout to the magazine paper. If the paper jams in the printer, you are not using a thick-enough magazine page. Again, do not use the magazine covers, as they do not work.

Magazine pages are used because they work well, and they are cheap! The reason they work is because the paper is very glossy and the toner does not adhere well to the glossy pages. The printing used on the magazine page is ink and it does not come off, but toner does. Toner is actually a plastic polymer, and different toners may yield varied results. In our experience, a genuine HP toner cartridge was used with great success; an Office Max brand yielded poor results. The sole purpose of the toner is the protect the copper below it from etching away, you only want the uncovered areas to etch.

Next, wash your hands to remove any oils. Keep handling to a minimum once the pages are printed and do not touch the laser printing with your fingers; this could get oils on the printing. Keep pages as flat as possible.

Very carefully, remove the copper clad from the packaging. Do not touch the copper surface for the same reason as above. You can cut the copper clad to size using a tin snip if needed. Use the Scotch Brite scrubbing pad to gently buff the surface (Scotch Brite is a popular brand of of plastic scrubbing pad meant to emulate steel wool). Do not use steel wool because it will embed steel into the copper. Clean off the residual dust with a slightly damp paper towel.

Find a hard, very flat, sturdy, heat resistant surface. Empty the water out of the clothes iron and set the iron on the hottest setting. Allow the iron to get hot.

This is both side of a piece of copper clad. Place the blank side facing down and copper side facing up. Align printing/paper onto copper clad board with the printing facing the copper. Do not allow it to move.

Firmly press the iron onto the back of the magazine paper, sandwiching it between the copper clad and the iron. Pressing hard without moving the iron, hold the iron perfectly still for one full minute. Do not move the iron at all during this minute, and push hard, really hard!

Then, for four more minutes, slowly move the iron around making sure to put a lot of pressure on the paper, but not allowing the paper to slide on the copper. When done, let the board fully cool before you move it at all. This will allow the toner to adhere to the copper and prevent you from being burned.

Put the board in cold water and let soak for five minutes. After five minutes, try to peel the wet paper from the board leaving only the toner/print from your laser printer. Only the toner should be left adhering to the copper. If the paper does not come off easily, let it soak in the water for a while longer. If necessary, rub with your finger to remove any paper, leaving only the toner. It’s ok if there are a few excess paper fibers stuck to the toner.

If you find not every trace adhered to the copper clad or it is misaligned, use lacquer thinner and paper towel to clean the toner from the copper board and start over. If the traces look good then move on. Inspect the traces carefully, however, because what you see now will be your finished product.

In a well-ventilated area with a fan, add 2-cups hydrogen peroxide to a plastic container. Gently pour in 1-cup Muriatic acid, to create the etching solution. Always wear goggles, gloves, and do not inhale the fumes. Do not use any metal containers, measuring cups, stainless steel sinks, or tools with this mixture as this mixture will aggressively etch metal. Acid safety, think “triple A”, for Always Add the Acid, it’s whatever is in the container that will end up splashing. This etching solution, while made with common chemicals, should command respect. It is dangerous to yourself and surroundings, treat it with respect. Ferric Chloride is another common etching solution, it is not a safer solution to use, both are equally dangerous.

Put the board copper side up in the plastic container filled with etching solution. Use a soft plastic brush to gently wipe the board. You will notice the copper begin to dissolve. It takes about 3-4 minutes to get all the exposed copper dissolved. You just have to watch to make sure it is gone in all areas between the traces. Do not leave the board in the etching mix for too long as the traces will dissolve under the toner that is protecting them.

Use lacquer thinner (paint thinner and acetone do not work well) and a paper towel to remove any toner left on top of the copper traces.

Tinning prevents the copper from oxidizing, which can make it hard to solder to in the future. If you choose, you can tin all the traces with solder and a soldering iron now. This actually makes drilling much easier because it helps to center the drill bit. Make sure to clean off excess flux if you do this. You could use Tinit to chemically plate the copper. Here is a different tutorial describing its use.

Drill all the holes for the through-hole parts using the correct size PCB drill bit and rotary tool. Drill large mounting holes with a normal drill. PCB drill bits are carbide and made to drill through fiber glass that would quickly dull standard bits. There are a few very common sizes of bits and these are often sold in packs. We use .0260″ for IC holes and .0310″ for resistors and caps.

Print out the top side silkscreen layer on magazine paper and iron this onto the top side, using the same processes as above. Again, run under water and peel off the paper. Now you have the component ID’s on the top side.

Here is a different video using essentially the same method:

You can make really nice PCBs of your own circuit design using this simple method, and we look forward to seeing your future projects using this method coming in on the tip line. Look for more How-Tos like this one in the How-To category.

I was just checking for this final piece this morning – but props to [Tony] for noticing it first.