Regular reader [Grenadier] wrote in to let us know about his newly published hacking hardware trading post called The Junkbox. Apparently when he’s not blowing up capacitors or building his own high voltage ones, he makes time to code up a website where you can buy, sell, and barter leftover components.

We have something like this right here at Hackaday. The dollar sign icon along the right column, just underneath the featured posts banner will take you to our classifieds section which at the time of writing had a whopping nine items posts. But these things to ebb and flow. Check in on the newly posted link from time to time to see that number grow.

Whether it’s over at The Junkbox or in our classifieds section, we think the biggest problem is finding what you need when you need it. This is nothing new. If you missed it before, we’ve embedded an older episode of the EEVblog after the break where [Dave Jones] tours Apex Surplus. It’s as if a hacker who has hoarding tendencies bought a store forty years ago and just kept piling more and more merchandise to the sky.

In response to last week’s post about parts scrounging with a heat gun, Hackaday forum member [BiOzZ] decided to try doing the same thing in his oven. It seems to work quite well, but we’re wondering if there should be any concerns over the lead content of the solder. Anyone care to chime in?

Spill-proof parts holder

Have you ever been in the midst of disassembling something and knocked over your container full of screws onto the floor? [Infrared] has a simple solution to the problem which also happens to keep a couple of plastic bottles out of the landfill.

Easy button stops abuse of the word awesome

Do you often repeat a word ad nauseam? Make author Matt Richardson does, and he hacked a Staples “Easy” button to help him break his addiction to the word “Awesome”.

Cheap Remote-controlled baseboard lighting

[Sean] scored a pair of LED deck lighting kits for a steal and decided to install them into his newly renovated kitchen. They are currently remote operated, but he plans on adding an X10 interface as well as PIR sensors for automatic triggering in the near future.

Yet another LCD recapping guide

It starts with a finicky backlight, or perhaps a high-pitched whine from the back of your display – by now, we’re sure that everyone knows the symptoms of an LCD panel that’s just about to die. [Eric's] Syncmaster recently quit on him, so he pried it open and got busy recapping. It’s running again, and he wanted to share his repair process in case others out there own the same display.

This digital display is made from several analog clocks with thick hands. Together they make something of a 7-segment display, which can be used to display the time. It reminds us of the “Shared Time” installation we covered previously. [Thanks Drum365 via Anonimiss Files]

Quickly desolder lots of parts

[Rhys Goodwin] is grabbing parts from junk PCBs but he’s not using a rework station. Instead it’s a hot-air gun and a brisk tap on the bench to send the parts flying. Well, at least he’s not using a blow-torch like [Ben Heck] does.

Binary Hero

This bank of 8 toggle switches is the controller for Binary Hero, a geeky take on Guitar Hero. When you see a decimal number come down the screen set your toggle to the binary equivalent in time or the game will be over before you know it. [Thanks Fabien]

Quick fan POV

[GMG] took a small persistence of vision board and slapped onto an oscillating fan blade. Along with a couple of magnets on the safety cage this display is a persistence of vision hack you can pull off in an hour or two.

Speed up laser etching

[James] figured out a way to cut down on the time it takes to etch multiple copies of one item with a laser cutter. It doesn’t run the laser faster, but orients the pieces in a way that means less movement of the head while the laser is not on. Read through his article and see if this method can help you out when doing some CNC work.

If you’re thinking of working with carbon fiber this guide should be a big help. The example is aimed at the automotive crowd but the principles transfer quite easily. Carbon fiber parts are constructed in a similar manner as fiberglass parts. A mold is covered in a release agent, the fibers are put in place and covered in epoxy. With fiberglass the fibers are often sprayed on but carbon fiber components use woven mats of the material to build up multiple layers. Vacuum bags are used to hold the layers together, removing air and impregnating the fibers with the epoxy. This guide even outlines the construction of a vacuum pump needed for that step.

The benefits of carbon fiber are many, including strength and weight reduction. This makes it a great material for adding parts to weight-sensitive hacks such as quadcopters. But the mesh also has an interesting look which is why it shows up in custom electronics cases. The one real drawback is that when this material fails it is a catastrophic failure, tending to crumble across the entire structure rather than limiting damage to a small area. That means that a rough landing might be the end of your new parts.

[Thanks MS3FGX]

[Mike Rankin] built a small CNC machine using some PC parts. He repurposed two optical drives and a floppy drive to create the plotter seen drawing the Hackaday logo above. The X and Y axes use the stepper motor controlled read heads from two optical drives. The Z axis is built using the read head hardware from a floppy drive. A 3-axis controller module from eBay drives the little machine, keeping the cost quite low at around $45.

As you can see in the video after the break it does a great job as a plotter. [Mike] doesn’t think there’s enough power in the hardware to be used as a mill. We’d still like to try adding a flexible shaft rotary tool and see if this could mill some rudimentary PCBs, but maybe you need to shell out just a little bit more for that functionality. It might also be possible to use an etchant resist marker instead of toner transfer or photo-resist.

This is the kind of footage that makes our mouths water here at Hackaday. [Akiba] of Freaklabs has been kind enough to take us all on a video tour of Akihabara Station, a treasure trove for electronics hackers located in the Chiyoda ward of Tokyo. The highlight includes surplus stores, specialty electronics shops, and enough silicon to bring an engineer to tears. Rather than waste time reading about it, follow the link and check out the videos in stunning 720p.

Hackers in other parts of the world, what kind of stores and marketplaces do you have like this? Send us your pictures and videos of local marketplaces that cater to your hacking needs so we can show them off.

[Doug Paradis] took a good look inside the Air Wick Freshmatic Compact i-Motion and then stole all the parts for other projects. We’ve looked at adding a manual spray button or making air fresheners Internet enabled before. Those models didn’t have parts that were all that interesting, but this one has a passive infrared motion sensor. You’ll also gain three switches, a PNP transistor, and an LED.

Price seems to be all over the map for this model, but [Doug] says you can find it for $8 or less. After showing how to make a tool to bypass the triangular security screws, he explains how to access the PIR sensor. But if you want to be all you can be with the hardware, he details the modifications needed to patch into the analog and digital circuitry on the rest of the board too.

[Jeff] set up version control for Eagle libraries and projects. He mentions that Eagle has become the standard for open source hardware projects and he’s absolutely right. We use it for our projects, and we’ve grown to expect that the posts we feature have Eagle files available in most cases.

But Eagle falls short in its library management. There is some amazing work from SparkFun to support a usable parts library, but who hasn’t added parts themselves? [Jeff] setup libraries using github so that changes and additions to the libraries can benefit all and cut the amount of time spent making custom footprints for new components and packages.

Nixie tubes make for fun projects but the fun can’t start until you get your hands on the hardware. Well, [Dieter's] got you covered with his one-stop repository on Nixie tubes and where to get them. We know that Woz’s watch isn’t currently available because of a lack of tiny tubes an obsolete accelerometer. Ladyada’s Ice Tube Clock depends on a rare 8-digit VFD tube. But you can get around parts obsolescence by adapting these designs for an available replacement. So when you take on the Dekatron Timer or a Bottled Nixie Clock you’ll know where to turn for the goods.

Update: Our mistake about Woz’s watch.  It wasn’t a tube shortage that put it out of production.

[Thanks Aaron]

Quick: which pins are used for I2C on an ATmega168 microcontroller?

If you’re a true alpha geek you probably already know the answer. For the rest of us, ChipDB is the greatest thing since the resistor color code cheat sheet. It’s an online database of component pinouts: common Atmel microcontrollers, the peripheral ICs sold by SparkFun, and most of the 4000, 7400 and LMxxx series parts.

The streamlined interface, reminiscent of Google, returns just the essential information much quicker than rummaging through PDF datasheets (which can also be downloaded there if you need them). And the output, being based on simple text and CSS, renders quite well on any device, even a dinky smartphone screen.

Site developer [Matt Sarnoff] summarizes and calls upon the hacking community to help expand the database:

“The goal of my site isn’t to be some comprehensive database like Octopart; just a quick reference for the chips most commonly used by hobbyists. However, entries still have to be copied in manually. If anyone’s interested in adding their favorite chips, they can request a free account and use the (very primitive at this point) part editor. Submissions are currently moderated, since this is an alpha-stage project.”

For months we’ve used our Bus Pirate universal serial interface tool to demonstrate electronics parts, so it’s only appropriate that the Bus Pirate get it’s own parts post. We recently had a Bus Pirate preorder, and today we received the pre-production Bus Pirate prototype from Seeed Studio. This prototype was mailed just a few days before preorder 1 started to ship, so those packages should start arriving any day.

Follow along as we unbox the prototype Bus Pirate, and connect it to a debugger to determine the PIC24FJ64GA002-I/SO revision that shipped with this board. Use this post to share your own Bus Pirate unboxing experience. Pictures and discussion after the break.

Most Bus Pirates will ship in a padded envelope (JPG), but ours came in a box with some PCBs for future projects and an AVR programmer.

Inside the box, the Bus Pirate is protected by a static dissipative bag. The Bus Pirate pin headers are stuck in foam to protect the packaging.

We ran a battery of functionality tests that covered USB, the user terminal, protocol libraries, power supplies, and pullup resistors. Everything passed our tests.

Next, we used a Microchip ICD2 debugger/programmer to make a backup of the firmware prior to doing a test upgrade/downgrade with the bootloader.

Connecting to MPLAB ICD 2
…Connected
Setting Vdd source to target
Target Device PIC24FJ64GA002 found, revision = Rev 0×3042
…Reading ICD Product ID
Running ICD Self Test
…Passed
MPLAB ICD 2 ready for next operation

All of our previous Bus Pirate version were built using Rev 0×3003 (A3) of the PIC 24FJ64GA002. Version A3 has a few issues, known as errata (PDF), one of which is a flaky hardware I2C module. These chips aren’t ‘defective’, they just have a few quirks like any complicated integrated circuit. The Bus Pirate firmware works around these issues using software techniques. Most desktop computer processors go through a similar stepping process.

Our Bus Pirate appears to have a B4 revision PIC (0×3042) that corrects some, but not all, of the errata from A3. This is no guarantee that every Bus Pirate will have a B4 PIC, preorder 1 and 2 are both sourced from multiple international vendors. Additionally, there’s no immediate benefit from having a B4 chip, someone will have to write software that takes advantage of the hardware. The next firmware update will print the PIC revision in the user terminal, check the nightly compiles if you’re anxious.

There is a revision B5 mentioned in the PIC errata. Some of these might find their way into preorder 2 boards.

Now that you’ve got your Bus Pirate, what do you do with it? We’ve got a bunch of part demonstrations to get you started.

Please leave a comment about your unboxing experience, and the devices you plan to interface.

Futaba makes vacuum florescent character displays that can be used as a drop-in replacement for common character LCDs. VFDs have a wider viewing angle, and generally look cooler.

Futaba’s character displays can be interfaced using the standard 8-bit or 4-bit parallel LCD interface, or a simple two-wire protocol. The protocol type is set by resistors on the back of the display, so it’s not particularly easy to change without a hot-air rework station. Today we’ll demonstrate a serially-interfaced VFD using the Bus Pirate.

Futuba VFD character LCD replacement (NA204SD02, $7.00). Datasheet (PDF).

We used our Bus Pirate universal serial interface to demonstrate the Futaba VFD, but the interface operations will be the same for any microcontroller implementation. The connections we made between the VFD and the Bus Pirate are shown in the table above.

We setup the Bus Pirate for raw2wire mode (menu M, 7) with open drain outputs (HiZ). The open drain outputs let us interface the 5volt VFD from the 3.3volt Bus Pirate using the on-board pull-up resistors (menu P, 2). Finally, we enabled the on-board power supply (capital ‘W’).

The VFD’s strobe pin is connected to the Bus Pirate CS pin.  The auxiliary pin doesn’t have it’s own pull-up resistor but CS does. CS is otherwise unused in raw2wire mode, so we reassigned the auxiliary commands to the CS pin (menu C,2).

Interfacing

The two-wire interface uses a straight-forward 16bit (2byte)  protocol (datasheet page 20). The LCD control bits (R/W, RS) go in the first byte, and eight data bits go in the second. All transactions start with strobe low and end with strobe high. Read operations are similar to writes, except the R/W bit is set and the second byte is read.

The Futaba VFD accepts all the standard HD44780 LCD commands (datasheet page 27), see these tables for a detailed description of each command. After a reset (power-up), the VFD expects the first command to be the function set command.

RAW2WIRE>@ <–start with strobe high
AUX HIGH IMP, READ: 1 <– aux pin (CS) is now input, pull-up resistor holds strobe high
RAW2WIRE>a 0b11111000 0b00111000 @ <–command
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×38 <–instruction byte (function set)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Function set configures the data interface length (bit 4), display lines (bit 3), and brightness/luminescence (bits 1,0).  Before we start we set the strobe pin high (@) in case it’s currently low. Then, we start the transaction by taking the strobe pin low (a), and send the first byte with the R/W and register select (RS) settings.

The second byte is the command. We set the data interface length to 8bits (bit 4 = 1), but in serial mode this is probably ignored. Our display has multiple lines (bit 3 = 1), and we set brightness to full (bits 1,0 = 0). The sequence concludes when the strobe pin returns high (@).

RAW2WIRE>a 0b11111000 0b00001111 @
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0x0F <–instruction byte (display on/off control)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

The display ON/OFF command enables the display (bit 3), toggles the cursor (bit 1), and blinks the cursor (bit 0). We enabled the display (bit 3 = 1) with a blinking cursor (bit 1,0 = 1) so it’s obvious that the display is working.

RAW2WIRE>a 0b11111000 0b10000000 @
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×80 <–instruction byte (DDRAM address set)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Before writing characters to the display we need to position the cursor by sending the DDRAM address set command (0b10000000) summed with the desired cursor position. We set the cursor to the first character on line 1.

The second character on line 1 is located at 0×01. To set this address we’d send 0b10000001 (0b10000000 +0b00000001).

Character display memory isn’t linear, the first line starts at 0×00, the second line starts on position 0×40, the third at 0×14, and the last line begins with position 0×54. Most displays have a similar configuration, here’s some tables for determining the layout of different character displays.

RAW2WIRE>a 0b11111010 0×48 0×61 0×63 0x6b 0×20 0×61 0×20 0×44 0×61 0×79 @
AUX LOW <–strobe low
WRITE: 0xFA <–start byte (R/W=0, RS=1)
WRITE: 0×48 <–ASCII letter ‘H’
…
WRITE: 0×79 <–ASCII letter ‘y’
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Finally, we can enter some characters at the position set with the previous command. Characters are entered as their ASCII equivalent values. We displayed “Hack a Day” with proper capitalization.

Multiple characters can be entered at once, but because the memory space isn’t contiguous it’s necessary to manually position the cursor at the beginning of each new line. After writing the last position of line 1, the cursor will advance to the first character of line 3. Use another position command, 0b10010100, to set the cursor to the beginning of line 2 (0b10000000 + 0×14 = 0b10010100).

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Hack a Day review disclosure: We bought the serial VFD demonstrated here on eBay, Futaba also sent us a sample with a parallel interface that we’ll demo later (shown here).

[Eric] sent in this very informative writup on how to use Photo interrupters. These things can be used for many things, he lists pellet dispensing and limit switches. He found one in his junk box and realized he knew very little about it. After some exploring and research, he’s here to educate the rest of us. There’s a good breakdown of the circuit itself which is pretty simple as well as a test circuit and some sample code.

Ferrite beads (L1 in the photo) filter high frequency power supply noise by converting it into a tiny amount of heat. Power supply noise can cause various problems for many parts, especially in analog audio and display circuits.

Ferrite beads are simple, but choosing one can be confusing because they’re not commonly used by hobbyists. Most designs will still work if you omit the ferrite bead(s), but beads are so cheap there’s no reason to sacrifice the added reliability they provide. We describe how we pick ferrite beads for our projects after the break.

A ferrite bead is rated for current, impedance, and resistance; see this Mouser listing for an example. Unless a datasheet or circuit requests specific bead characteristics, we choose a bead rated for sufficient current, and ignore the impedance and resistance values.

If the bead is for a power supply, we determine the maximum possible current the circuit will use and find a bead rated for double that amount. Last week we calculated the the Bus Pirate’s worst-case current consumption as 525ma, so we looked at beads rated for at least 1000ma. We used this one, which is rated for 1500ma and costs 10 cents.

Sometimes a ferrite bead is used to filter the power supply for one specific part of a circuit. We used a dedicated bead to filter the LCD bias voltage on the DIY digital picture frame, and with the ENC28J60′s ethernet transceiver on the web server on a business card. These parts only consume a few milliamps, so we used a smaller 200ma ferrite bead ($0.11).

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Microchip’s 25AA/25LC EEPROMs are data storage chips with a simple 3-wire interface. The 25AA/LC is an SPI version of the common 24AA/LC I2C EEPROM.  It comes in capacities of 128bytes to 128kilobytes. We looked at the smallest, the 128byte 25AA010A.

There are Bus Pirate demonstrations for most types of serial EEPROMs. Check out our previous 1-wire (DS2431) and I2C (24LC1025) EEPROM posts.

Continue below to see our test circuit and a demonstration of the 25AA010 EEPROM. We used the Bus Pirate to play with this chip from our PC.  For a limited time you can get your own Bus Pirate, fully assembled and shipped worldwide, for only $30.

25AA010A SPI EEPROM memory, 128bytes (Octopart search, $0.70). Datasheet (PDF).

The schematic above shows a simple test circuit that should work with any 25AA/25LC SPI EEPROM. It’s a good idea to use a 0.1uF decoupling capacitor (C1) on the power pin in a real circuit, but we didn’t use one for our demonstration. We also connected the write protect (WP) and hold (HOLD) pins to the supply voltage (V+) to disable these features.

We used our Bus Pirate universal serial interface to demonstrate this chip, but the command sequences will be the same for any setup. We connected the Bus Pirate to the 25AA010 as shown in the table above. We setup the Bus Pirate for SPI mode (M, 5) with normal outputs, and enabled the on-board power supply (capital ‘W’).

25AA parts work from 1.8volts to 5.5volts, 25LC parts have a 2.5volt minimum. We used a 3.3volt supply to power the chip, and interfaced it using the Bus Pirate’s normal 3.3volt pin outputs.

You could also power the chip from the Bus Pirate’s 5volt supply. Interface the chip at 5volts by choosing open drain pin type (HiZ) during the mode configuration, then hold the bus high with pull-up resistors connected to 5volts.

Interfacing

Page 7 of the datasheet has a complete list of interface commands. This demonstration shows the minimum operations needed to write and retrieve data.

SPI>[0b110] <–Bus Pirate command syntax
CS ENABLED <– Chip select enabled (0 volts)
WRITE: 0×06 <–Write enable command
CS DISABLED <– Chip select disabled (V+)
SPI>

A valid write enable command is required before data can be saved to the EEPROM. Enable the chip select signal to wake the chip ([), send the write enable command (0b110 binary, or 0x06 in hexadecimal), and then disable chip select (]).

SPI>[0b10 0 1 2 3 4 5] <– Bus Pirate command syntax
CS ENABLED <– Chip select enabled (0volts)
WRITE: 0×02 <– Write data command
WRITE: 0×00 <– Write address (*sometimes 2 bytes)
WRITE: 0×01 <– Data to write (5 bytes)
WRITE: 0×02
WRITE: 0×03
WRITE: 0×04
WRITE: 0×05
CS DISABLED <– Chip select disabled (V+)
SPI>

Store data in the EEPROM by sending the write command (0×02), the address to start writing (0×00), and the bytes to write (the values 1 to 5).

Up to 16 bytes can be written in a single operation. All writes must be on the same page of memory, see datasheet page 6 for details. EEPROMs larger than 256 bytes use 16 bit (2 byte) addresses.

SPI>[0b11 0 r:5] <– Bus Pirate command syntax
CS ENABLED <– Chip select enabled (0volts)
WRITE: 0×03 <–Read data command
WRITE: 0×00 <–Read address (*sometimes 2 bytes)
BULK READ 0×05 BYTES:
0×01 0×02 0×03 0×04 0×05 <– The data we wrote earlier
CS DISABLED <– Chip select disabled (V+)
SPI>

Read back the values to verify the write operation. Send the read command (0×03) and the address to start reading at (0×00), then read 5 bytes from the chip (r:5). The output should match the values we wrote earlier.

*EEPROMs larger than 256 bytes use 16 bit (2 byte) addresses. Enter a two byte address such as “0 0″ if you’re using one of these EEPROMs.

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.