After writing this post on somone hacking QR codes, Hack A Day commenters came out in full force posting some really cool links about modifying QR codes to include a logo. I’ll fully admit I geeked out a little, but in the process I figured out some of the theory behind embedding logos in QR codes.

After getting my hands on the ISO 18004 specification for QR codes, I decided to try embedding the Hack A Day skull & wrenches inside a QR code. The tools I used were Photoshop, this QR code generator, and Microsoft Paint (I’ve never seen a program to edit individual pixels that has a better UI, so don’t laugh).

For this ‘how-to,’ I’m going to walk through the process of modifying a Version 6 QR code. The Version 6 QR code is 41 pixels square, and is a very good balance between the amount of data that can be presented and the physical size of the code itself. The graphic below shows what is absolutely required of a Version 6 QR code standard. In practice, what is actually necessary is a little different, but I’ll just go with the specs for now.

Black in this graphic will always be black, white pixels in this graphic will always be white, red is a “keep out zone,” and gray is “don’t care.” The alternating black and white band on the top and left side of the QR code is the ‘timing pattern.’ This is the little bit that divides everything on the QR code into columns and rows. The gray part of this graphic is separated into 172 8-pixel zones, as shown below:

If anyone wants to 4-color map theorem this, I’ll gladly update it.

Some of these zones are non-contiguous, so I drew black lines connecting the corresponding parts. Each of these 8-pixel parts translate into one byte of data in an alphanumeric QR code. Now, the million dollar question: why is knowing how the bytes are arranged in a QR code important? The answer is with a high level of error correction, about 30% of these bytes can be complete gibberish, and your phone will still be able to read the QR code. with 172 areas, that means about 51 of them can be altered in any way, shape or form.

So, how do we implement this? First, we start out with a crappily-drawn Hack A Day logo:

It’s important to include both positive and negative space when designing this logo. If there wasn’t a white border going around the logo, the random black and white pixels would be placed right against the logo. Of course, I’m sure someone will come up with a great design that ignores this technique, but I’ll just do it this way for now. After overlaying the Hack A Day logo on top of the color map of the QR code, we get this:

Then we physically count the number of 8 pixel cells that are obscured by the logo. Since we’re doing a Version 6 QR code, about 51 of these cells can be covered up. It looks like this graphic is okay, so we move onto the next step: putting a real QR code in this thing.

I used this site to generate all my QR codes for this post. It allows you to select the QR version number and the error correction level. After typing in “http://www.hackaday.com” as the code I want embedded, I ended up with this:

This little guy is going on our business cards.

That’s all well and good, but what if you want to put a logo in a QR code that a little bit larger than what would ‘normally’ be permitted? What if, for example, you wanted to tread into the timing area on the top and left side of a QR code? This is where design comes in. If a logo already has alternating black and white pixels, like the AT&T ‘Death Star’ for example, it’s fairly easy to have that logo overlap the timing pattern.

Yes, I used a Version 14 QR code for this, meaning it’s 73 pixels on a side. I did come up with smaller one, but it really doesn’t look as good.

Notice the blue bars. QR code interpreters don’t care if a pixel is white, black, red, orange, or maroon - only contrast matters. Since the blue in Big Blue is fairly dark, it registers as a dark pixel. This can be exploited by adding both visual contrast and getting rid of the 1-pixel border that is required of a 1-bit graphic.

If the Firefox logo had a white border, the logo would cover more than 30% of the QR code. Putting in a full color graphic – especially one that defines itself from a background with a dark edge like an icon – gets around the need for a white border all the way around a logo. I’m sure there are more clever ways of toying with the palette of a logo, but I’ll let that go for another time.

But wait, there’s more. I’m not limited to the resolution of the QR code – I can overlay stuff at a higher resolution than the QR. This observation led me to this:

Yes, it works.

I’m hoping this how-to was at least a little helpful in demonstrating how logos can be put into QR codes. If you’ve got a neat example of this, leave a note in the comments or send it in on the tip line.

This mini web server is slightly smaller than a business card. There are a lot of tiny one-board servers out there, but this is probably the smallest you can etch and solder at home. Unlike many embedded web servers, files are stored on a PC-readable SD card, not in a difficult-to-write EEPROM. Read on for the web server design, or catch up on PIC 24F basics in the previous article: Web server on a business card (part 1).

Concept overview

The goal of this project is to build a web server on a business card that serves web pages and files from a FAT formatted SD card. The server is based on a PIC 24F that connects to a TCP/IP network using the ENC28J60 ethernet MAC/PHY. Network layers and low-level services, such as DNS and DHCP, are handled by the Microchip TCP/IP stack. A FAT 12/16/32 formatted SD card contains web pages and files. A very simple HTTP server ties everything together by handling page requests on port 80, searching the SD card for requested, and serving them with the correct content type.

Hardware

(full size schematic .png)

Microcontroller (Microchip PIC 24FJ64GA002)

The brain of the server is a 16-bit PIC 24FJ64GA002 (IC1), a 28pin microcontroller available in several hobbyist friendly packages. Check out our PIC 24F introduction for more about working with this chip.

PIC 24Fs operate between 2 and 3.8volts, which is perfect because the ethernet chip (IC2) and SD card both run at 3.3volts. This chip has 8K of RAM, plenty for the TCP/IP stack and a few K for working with a full FAT file system. The 24FJ64 has two SPI modules, so the SD card and ethernet IC each get a dedicated data bus.

The PIC processor core operates at 2.5volts, and requires a 10uF capacitor (C2) for the on-chip voltage regulator. The datasheet specifies a tantalum capacitor, but we used a low-ESR electrolytic in a prototype without incident. Every power pin needs a 0.1uF decoupling capacitor (C4,5).

The internal 8MHz oscillator provides a 32MHz clock source with the 4x PLL multiplier enabled. We’re also using an external 32.768KHz crystal (Q1) with 2 x 27pF capacitors (C17,18) to enable the real time clock calendar.

Programming connections are brought to a header (SV1). We chose to use programming pin pair three (PGx3). The master clear and reset (MCLR) function is enabled with a 2K resistor (R1) from V+ to the MCLR pin. Optionally, add a button (S1) from MCLR to ground for a manual reset switch.

Ethernet connection (ENC28J60)

An ENC28J60 (IC2) handles the network physical connection (PHY) and MAC layer. The ENC28J60 needs a number of support parts beyond the typical 0.1uF decoupling capacitors (C6,7,9,10). A 25MHz crystal (Q2) and 2 x 27pf capacitors (C15,16) provide a clock signal. The internal core voltage regulator requires a 10uF tantalum capacitor (C1), but an electrolytic capacitor also worked fine. Two LEDs (LED1,2) with 330ohm resistors (R2,3) display link and data status.

A bias resistor (R12) is required; the value will depend on the ENC28J60 version you’re using. Current chips should be B5 (PDF) or B7 (PDF), and require a 2.32K 1% resistor.

The PHY I/O portion specifies 4 x 49.9ohm 1% resistors (R8-11), and a ferrite bead (L1).

The most difficult-to-find part for the ENC28J60 is the correct RJ-45 jack with integrated magnetics (RJ1). We used a J1006F21 PulseJack from Pulse Engineering. Be sure to check the pin configuration and connections if you use a different jack, they will probably be different than ours. A Cadsoft Eagle part library for the JP1006F21 is included in the project archive. This was a $4 part, but it’s gone up to $7. If you know of other jacks that work we’ll add them here.

microSD card

We used a microSD/transflash card in this design because SD cards waste a lot of board space under the holder. microSD cards are smaller versions of SD cards with the same data interface, and most come with an adapter for use in standard SD card readers. The card needs a holder (SD1) and a 0.1uF decoupling capacitor (C8).

If you want to use a full-size SD card, take a look at our version one prototype in the project archive. We used Alps SD card holder #SCDA1A0901. Unfortunately, this part is has been discontinued and we’ve yet to find a suitable replacement. Don’t try #SCDA5A0201, that’s for sure. If you have a favorite, we’ll add it here. Sparkfun has one, and a matching Cadsoft Eagle part library.

Power supply

An adjustable LM317 voltage regulator (IC3) is set to 3.3volts using a 390ohm (R6) and 240ohm (R7) resistor. We considered several 3.3volt regulators, but nothing was cheaper than a LM317 and two resistors. There’s a 0.1uF decoupling capacitor (C13,14) and a 10uF capacitor (C3,19) on both sides to help support the power hungry Ethernet transceiver. The LM317 will output 3.3volts from an input of 5 to 20volts+, but it gets really hot with greater than 9volts supply. The specified input capacitor is only rated 16volts, so consider an upgrade if you plan to use a supply greater than about 9volts.

For the first time ever, we incorporated a power jack (J1) into a design. A jack with a 2.1mm diameter internal pin seems to be the most common DC connector. We used a cheap through-hole DC power jack, like SparkFun #PRT-00119 or Mouser #163-7620-E. It mates with a plug like Mouser #1710-0721.

Circuit board

The PCB (full size placement .png) was designed in Cadsoft Eagle 5.0. Freeware versions are available for all major platforms. Renderings were done with Eagle3D, beta version. Schematic and board files are included in the project archive (ZIP).

We designed the project with large SOIC chips and 0805 surface mount (SMD) parts, but haters can rest assured that chips are available in a through-hole package. We prefer to use SMD parts because the resulting circuit boards are smaller, cheaper, and faster to produce. 0805 parts are dirt cheap, and easy to solder with a normal iron. Don’t expect this project to work on a breadboard, there’s probably too much capacitance for this circuit.

We took full advantage of the PIC’s programmable pin placement to get the simplest trace routings possible. Just four jumper wires are needed on an otherwise single-sided board.

The traces are large and clean, DIY toner transfer boards should be easy. We made our PCB using an inkjet printer transparency mask over an UV sensitive circuit board.

In addition to the final design, the project archive contains our v1 prototype design. The prototype uses a full size SD card (SCDA1A0901) and all electrolytic 10uF capacitors. We also put the RJ45 Ethernet jack on a daughterboard to better accommodate different pinouts.

Partslist

Firmware

Three firmware examples are included in the project archive [zip]. The examples compile with Microchip’s demonstration C30 compiler. Learn more about working with the PIC 24F in our previous article: Web server on a business card (part 1). MPLAB isn’t great about project portability, you may need to locate all the project files again if your path doesn’t match the ‘c:wsbc’ format that we used.

FAT12/16/32 disk library

Our first step was to get the FAT library reading from a SD card. FAT 12/16/32 are simple disk storage formats that work with PCs, MACs, digital cameras, music players, and other electronics. Here’s our favorite FAT tutorial/teardown (PDF).

Microchip’s FAT 12/16/32 library gives us simple functions for working with SD cards. The included demo application creates some files and directories to demonstrate each function. Here’s how we configured it to work on our custom hardware, you can find these changes by searching for the tag ‘HACKADAY’ in the code:

• HardwareProfile.h assigns actual PIC hardware to generic references in the code library. For the SD card this is an SPI interface, and pins for chip select and card detect. First, we deleted all the unused hardware profiles to make the code more manageable. Next, we configured the FAT library to communicate with the SD card using an SPI module (line 132). Finally, we defined the SPI pin assignments (line 152). Pin setup is shown in the table below.
  

  Pin	Port
  Chip select	B0
  SD card detect	A2
  SPI clock	B2
  SPI MOSI	B1
  SPI MISO	B3

• Demonstration.c. On line 48 we set a custom oscillator fuse configuration, as described in our PIC 24F introduction. This is also the logical place to configure pin assignments with peripheral pin select (line 63).
• FSConfig.h. This file enables various components of file system library, affecting the amount of memory and program space used. A read-only library is very small, a full write configuration is bigger. We didn’t have to make any changes for the demonstration, but this is an important file to note.

At first, the library failed to recognize our SD card. It only supports disks with a master boot record (MBR). Windows XP formats SD cards as a DOS disk: a single partition with no MBR. To verify this, open a Windows-formatted disk with a utility like HxD and inspect sector 0 of the physical disk. Byte 446 should be the location of the first MBR partition entry, but instead it’s the NTLDR executable code.

To format the disk in the ‘correct’ FAT format, use a digital camera’s format function or a utility like Panasonic’s SD card formatter. We also considered using a different FAT library that reads DOS disks, like DOSFS, or adding similar features to the Microchip firmware.

TCP/IP stack

Microchip’s free TCP/IP stack performs the convoluted configuration and networking functions needed to run a web server. You can read all about the stack in various application notes and documentation. Wikipedia is our favorite TCP/IP learning resource; we wrote our first TCP/IP stack using only Wikipedia.

Microchip’s TCP/IP stack used to be messy and confusing. Now it’s just confusing. The last few versions of have improved considerably in code clarity and structure. Here’s what we did to to configure the base TCP/IP stack example for our hardware, you can find these changes by searching for the tag ‘HACKADAY’ in the code:

• HardwareProfile.h assigns actual PIC hardware resources to generic references in the code library. We added our custom oscillator configuration (line 68), and configured the server status LED to use the LED attached to PORTB7 (line 83).  We defined the SPI interface to the ENC28J60 as follows (line 116):
  

  Pin	Port
  Reset	B8
  Chip select	B9
  SPI clock	B10
  SPI MOSI	B11
  SPI MISO	B12
  Wake on lan	B13
  Interrupt	B14

• MainDemo.c. We eliminated a bunch of unused code, and added the peripheral pin select configuration code to the InitializeBoard() function (line 332).
• TCPIPConfig.h defines the TCPIP stack components included in a compile. We’ve enabled DNS, DHCP, the IP announcer, and the ping server (line 56):

#define STACK_USE_DNS            // Domain Name Service Client
#define STACK_USE_DHCP_CLIENT    // Get DNS automagically
#define STACK_USE_ANNOUNCE       // Microchip Ethernet Device Discoverer
#define STACK_USE_ICMP_SERVER    // Enable the PING server

After loading this firmware, we’re ready to connect the server to a network for the first time. During initialization, the TCP/IP stack negotiates with the network router for an IP address using DHCP. We need to know this address to communicate with the device. If the device had a screen we could display the IP address, but instead we use the MCHPDetect.exe utility from Microchip.

When the TCP/IP stack finishes initializing, it broadcasts an announcement packet to port 30303 of all locally connected computers. MCHPDetect extracts the IP address from these packets. A new announce packet is sent on every PIC reset.

It’s also possible to read the IP address directly from memory with a debugger. The address is stored in the AppConfig.MyIPAddr variable, the .byte form follows the standard x.x.x.x IP notation.

Once we have the IP address, we can ping the server and test its responsiveness.

If ping shows high latency or malformed packets, you can use Wireshark to inspect network traffic at the byte level. Unless you’re in Germany, because it might be criminal.

Building the custom HTTP server

The custom web server looks for requested files on the SD card, and sends them with the correct content type. We used the Microchip HTTP example server v1 (HTTP.c) as a base for our FAT file server (FATHTTP.c).

Microchip’s HTTP server used a simple file system called MPFS to index web pages on an EEPROM chip. We replaced calls to MPFS functions with calls to functions in the FAT library (see the HTTPProcess and Sendfile functions in FATHTTP.c). Our changes demonstrate the concept as simply as possible, without adding confusing pointers and other handy C obfuscations. The code leaves a ton of room for improvements, have at it. File writes are disabled in the default compilation, but there’s enough program space to enable them if you want to write to the SD card (see FSConfig.h).

It’s necessary to registered our custom FATHTTP server with the rest of the TCP/IP stack. We did a search and replace for the original HTTP server components, and added calls to our new FATHTTP server as needed. That turned out to be these places:

• TCPIPConfig.h. First we inserted some definitions that enable the FATHTTP server (line 70), and added a TCP socket for the FATHTTP server (line 248).
• TCPIP.h. Next, we added FATHTTP to the list of services that require the TCP/IP stack (line 170) and then included the necessary headers (line 351).
• StackTSK.c. We added the FATHTTP server initialization (line 138) and processing (line 340) functions to the list of TCP/IP stack tasks.
• Helpers.c. We also needed to include a few helper functions for working with URLs (line 259).

At long last, it’s time to put some files on an SD card and test this thing. Make sure your files follow the 8.3 file name format. The project archive contains a sample website with a test image and zip file.

After grabbing the server’s IP address with MCHPDetect, we pointed a browser at it. The IP address entered alone will redirect the browser to index.htm, whether or not it exists. Web pages and images stored on the SD card display in the browser, but unknown binary types trigger a download prompt.

Taking it further

We see a lot of potential projects using this tiny web platform.

• Add hooks in the FATHTTP.c source for special URLs that trigger events or configure pins.
• Build a remotely accessible data logger. Use the extra pins to read sensors and log data to the SD card. Logs are retrievable from a web browser, or directly from the FAT readable SD card.
• Get remote access to an ancient serial terminal or BBS, optionally log the console output. Use two external pins as a serial port, and forward commands from the Internet using Microchip’s Telnet server and Ethernet-to-serial bridge examples.
• Your suggestions?

Next time, we’ll use the mini server to make an Internet connected, electronic indoor graffiti wall. This will be an interactive project where everyone can contribute graffiti and animations on-line.

Schematic, board, and firmware files are included in the project archive (ZIP). Use the freeware version of Cadsoft Eagle to view the schematic and PCB. The firmware is written in C, and compiled with the Microchip demonstration C30 compiler.

We’ve been using Microsoft’s Media Center for a few years now and have grown to like it a lot. We’ve also noticed that more and more Apple computers have shown up on our home network and decided it was time to get everything working together smoothly. Follow along as we walk you through the hoops we jumped through to get everything cooperating.

To make things really easy, we could have ditched Media Center and used Macs all around. One thing that the Macs lacked was a complete 10’ interface for the television. Sure, you have Plex, Front Row, and EyeTV available; while each has their merits none of them were able to give a user a complete single TV viewing experience like Microsoft’s Media Center.

MCE, as it’s commonly referred to, can play back DVDs, music, videos, and broadcast TV all from one interface using a single remote. We wanted to build a home network that would centralize all our media, provide Time Machine backups for the Apple computers, and also act as a bittorrent client and print server.

We knew we could easily set up another Windows machine to act like a server, but Time Machine only supports writing to Mac formatted drives. There is information out there that shows how to get around this, but we didn’t want to risk our backups using unsupported methods. Running a NAS box was out as well for the same reason.

A 1TB Time Capsule could have been the answer to our problem since that would support Time Machine backups, and we could plug in a FAT32 formatted USB drive for the Windows computer. The issue here would be with the 4GB file size limitation, as most of the HD shows recorded are between 6-15GB. We would need a file system that would support larger file sizes like NTFS or HFS+.

We decided to base our server on a Mac running Leopard. All the drives would be Mac formatted to deal with the large file sizes and this would allow native Time Machine backups. As long as we enabled SMB support in Leopard, the Windows computers would be able to read and write to the Mac drives without any issues.

Since this would be a fully functioning computer we can configure it as a print server as well as a bittorrent client. Our list is rather simple and shows that it doesn’t take much to get a mixed computer network up and running.

Hardware

• Mac desktop
• Client computers running Leopard and Windows Media Center
• 4 hard drives
• USB printer

Software

• Tweak UI
• Tweak MCE
• Transmission
• Reader Notifier
• Microsoft Remote Desktop Client

Additional setup information

• Working home network
• Static IP assigned to the server and MCE computers
• Wired connection from the router to the server and MCE computers
• Media Center computers should be setup with the same admin login and password and have auto login enabled.
• DVD movies ripped using the VIDEO_TS structure

Since our server would mainly be used to host the network drives, we really didn’t need the latest and the greatest computer. Our digital media hub is a first generation 1.42 GHz PPC Mac mini complete with 1GB of Ram, an 80GB hard drive, bluetooth and AirPort Extreme.

We used 3 375GB Seagate drives that we had laying around, each in their own FireWire enclosure. We also picked up a 500GB Iomega FireWire drive on clearance to act as our Time Machine disk. The reason we went with FireWire over USB was a matter of processor load. Since USB required the CPU to dictate where the data went unlike FireWire’s peer to peer method we felt it was best to unload as much strain from the CPU as possible.

We also thought about using a Power Mac G4/G5 but liked the size of the Mac mini. Even with the 4 external drives, the whole thing fits nicely in our bookshelf. Whatever Mac you decide to use, just make sure it meets the minimum specifications to run Leopard.

After the initial OS install and updates, we started on formatting the drives one by one. Using Leopard’s Disk Utilities we formatted each external drive as GUID Partition, Mac OS Extended (Journaled)

Next each drive was given a logical name in the order they were installed under the mini: HDD001, HDD002, HDD003, and Time Machine.  HDD001 would serve as one of our DVD drives, as well as the drive used to keep our shared music, photos, and torrents, so we created the following folders: My DVDs, My Music, My Pictures, and Torrents. HDD002 would be only used for DVDs, so that drive only had one folder labeled My DVDs. That left HDD003 to serve as the drive for recording MCE shows, so a folder labeled RecordedTV was created. No folders were made on the Time Machine drive as each Mac connecting to it would be making their own folder when doing their backups.

We then proceeded to create the different user profiles that would be accessing the drives. To make it easier on ourselves we used the same admin login and passwords from the MCE computers, but instead of making them part of the Admin group we made them part of the Standard user group. Since we used the same login for each MCE computer we only had to make one user on the server. For the Mac computers we used individual login names and password that were in use on the computers themselves and gave them only sharing accounts.

From here we moved onto enabling file sharing setting, adding each of the 4 drives, and assigning the different users to each drives. The reason why we created different logins for the Mac accounts instead of using one generic one like the MCE account was to give different access to each user. Some only needed Time Machine access while others needed access to other drives. With the different accounts we were able to specify which accounts had access to which drives. Since we wanted to be able to map drives under Windows we enabled SMB support for the MCE user by clicking the Options button.

We also wanted to log into the computer remotely since this setup would be running without a monitor, keyboard or mouse connected directly to it. By enabling the Remote Management service we can now manage the computer via another mac or a computer running a VNC client, like on an iPhone.

Our Mac came with a built in WiFi card that we used as a secondary WiFi access point when guests come to visit. It’s an easy way to get them online without us having to give out the password to our main WiFi connection.

Under Internet Sharing we selected the Ethernet as the connection we wanted to share and Airport for the guest connection. Under the Airport options we gave it a different SSID than our main connection. Now when guest visit, we can remote into the server and enable the connection, when they leave we disable the service.

The last things we wanted our server to do was automate the download of torrents. This required the installation of Reader Notifier and Transmission. Reader Notifier works with Google Reader and will automatically download the torrent file based on our RSS subscription to our torrent directory. Transmission was then set to automatically monitor this directory for new torrent files, once Reader Notifier downloads the torrent, Transmission starts downloading.

If we wanted to add a new torrent feed we just have to add it to Google Reader. Because Transmission is set to monitor the torrent directory if anyone manually places a torrent file in that directory from any computer the download will start automatically as well.

Both 2005 and Vista versions of MCE do not support writing to a network attached drive. With a few changes in the registry, via TweakMCE, we corrected this and added a few enhancements along the way.

We started by locating the 3 media center services and stopping them for the time being. One at a time we double clicked each service and under the Log On tab changed the default setting to the “This account box” and entered in the admin name and password for the computer.

With the services still stopped we launched TweakMCE and navigated to TV > Storage Location For Recorded TV and replaced the current path with the UNC path to our new server (\\OSXServer\HDD003\RecordedTV). We did this as well to the Watched Folder For Recorded TV.

In order to take advantage of having our DVDs stored on the server we also enabled the My DVDs option under the DVD menu of TweakMCE.

After saving each of our changes and exiting out of TweakMCE, we proceed to map each of the network drives we would be using making sure to use the same user name and password and selecting the reconnect at log on option. This will ensure that the drives will always be reconnected in case of reboot.

We then rebooted the computer and once back, launched MCE. Under the Videos menu we added the new drives making sure to include the 2 My DVDs folders as MCE will use this information to populate the new My DVDs menu on the home screen. Adding the network paths to the My Music and My Pictures directory also allowed the MCE computers to have access to the same content.

Like the server, we wanted to manage these computers remotely so we enabled the Remote Desktop Service. Microsoft makes a free client for the Mac and XP MCE/Pro has the remote client built in. Except for the different codecs needed to playback the various files that we wanted no further configurations were needed.

Setting up the Mac was rather quick since we would be connecting to another Mac for the drives. After launching Finder, we located the server to the left of the window. Selecting the server, we entered the shared user name we created on the server saving our login information to the keychain.

Enabling Time Machine to use a network drive is the same as selecting a locally connected drive. In the Time Machine preference screen select the Change Disk option to display all the connected drives. After selecting the drive labeled Time Machine we exited the screen, no hacks needed.

Unlike a Windows computer, OS X won’t automatically mount network drives on reboots. If we fail to mount the drives, Time Machine wouldn’t be able to perform it’s backups.. The easiest way we found was to create an Automator script at login to mount the drives.

Our first step was having Automator call out each drive we wanted to mount via IP. Once we had specified which drives we wanted, the next step was to have Automator connect to the server to mount the drives. Once we had verified that it was connecting to the correct drives, via the Run button, we saved it as an application and placed it in our applications folder. We then added this to the login items for each user we wanted to have access to the drives. Now on login, the script will automatically run and connect to the drives.

With our server now up and running, the MCE computers can now access the drives for movies, music, pictures, and share recorded shows. If our living room computer records an episode of Battlestar Galatica, all the MCE computers in the house can access it. Also, with MCE we now have access to all our DVDs anywhere in the house.

Because we chose to go with a Mac as a server, the Macs on our network can now back up wirelessly with Time Machine and share a printer as well.

If we had to do it over again, we would have gone with an Intel based mini as it comes with the Gigabit ethernet unlike the G4’s fast ethernet. In addition to that we should have gone with larger drives and tried Leopard’s built in software RAID. Other than that, we are please with our new home network.

After the overwhelming response to the Hackit we posted about automated hard drive destruction last fall, we finally decided to test out some thermite hard drive destruction ourselves. This has been done on The Screen Savers but they did not show up close results of the platters. So, aluminum and black iron oxide were procured through eBay, and until it arrived we watched some YouTube videos that showed a lot of fire and no real results. We decided to see what it would take to completely obliterate a drive.

With the amount of personal data stored on your computer, we all understand the importance of destroying the data that is stored on the platters of a hard drive before disposing of it. There are many ways to destroy a hard drive; software, physical disassembly, drills, hammers, magnets/electromagnets, and acid, but none are quite as outrageous and dangerous as thermite. That’s what we’re going to do here today. Follow along for pictures and videos of the results.

A couple different methods of containing the thermite above the hard drive were tried and we quickly found the best way is a clay flower pot with the drip tray for a lid. An Altoids tin was also tried, but it burned up to quickly. Molding a cement container was also attempted. Since thermite is extremely hard to ignite, sparklers that were left over from the 4th of July were used, and offered a very reliable method of ignition.

Our goal was to completely destroy the drive while it was still in the computer case. The theoretical application is to destroy the disk at a moments notice so it won’t fall into the wrong hands. After testing multiple methods, placing about 1 pound of thermite in a clay flower pot and lighting from the drain hole in the bottom yielded the best results. This could easily be placed in the 5.25″ bays above the drive.

A thermite reaction is a process in which the correct mixture of metallic fuels are combined with a metal oxidizer and ignited. Ignition itself requires extremely high temperatures, but once ignited, thermite supplies its own source of oxygen. It can potentially burn underwater when mixed properly. Thermite is usually used to weld railroad ties together.

The most common thermite is “black or blue iron oxide (Fe3O4), produced by oxidizing iron in an oxygen-rich environment under high heat” and Aluminum(Al). Red iron(III) oxide (Fe2O3), commonly known as rust, can also be used. There are many chemicals that can make thermite; the mixtures used to make thermite therefore vary, causing confusing and changing mixture ratios.

Since the oxidation of one substance involves the reduction of another, this type of reaction is often called redox reaction. In the following balanced reaction, 8Al + 3fe3O4 = 4Al2O3 + 9Fe + Heat. The element Al is oxidized, but Fe is reduced. This reaction is also called a displacement reaction because Al displaces Fe in the oxide. Because of the nature of this reaction, the correct ratio of substances is important to ensure the optimum amounts of fuel (aluminum) and oxygen (iron oxide) within the mixture. Thermite is very safe to handle because of the high ignition temperatures required, sparklers were used in this instance, however magnesium ribbon can also be used. We think an electric pyrogen igniter would be a far better choice for ignition, instead of unreliable methods.

There are two important aspects to ensure a successful reaction. Thorough/even mixing and smallest possible powder particle size. If thermite is not adequately mixed, it may be difficult to ignite or maintain the reaction. One problem when mixing thermite is the difference in weight between the aluminum and the iron oxide. This causes them to separate out rendering the thermite useless. The process used here with great success was five minutes in a rock tumbler. Powder particle size is measured with a measurement called mesh. Passing the powder through a mesh will determine the largest particle size, this reaction performs best with the smallest obtainable mesh size. The mesh size for aluminum was 1200 mesh and black iron oxide was 300 mesh.

The total enthalpy or heat content released is -3.677 kJoule per gram of Fe3O4/AL thermite. The ratio of Fe3O4 to aluminum powder by weight is about 3.22 to 1, according to the reaction’s stoichiometry. The reaction photographed was 200 grams of Aluminum and 644 grams of black iron oxide yielding 2368 kJoules of heat. This was more than was required to adequately destroy the hard drive, a smaller amount could have been used, and still destroyed the platters. It would have even been better controlled, or better yet contained within the computer case. What fun is that?

Using thermite to destroy a hard drive is a very violent and destructive process. Great care should be taken as the molten metal can splash and sputter for a long distance.

The reaction begins to sputter.

The thermite has just contacted the hard drive.

Things are really hot now!

Most of the reaction is completed.

The molten thermite, platters and most of the aluminum frame from the hard drive in the bottom of the case.

Above are the molten hard drive platters destroyed with 844 grams of thermite. It takes about this much thermite contained directly above the drive to get the job done, if it is not you will just get a superficial fire.

Over all the destruction of the drive and platters was accomplished in all cases in a matter of seconds. This is by far a guaranteed method of destroying data in a time of need. We’re pretty sure this will prevent most forensic data recovery methods.

Below is a video of Brainiac using thermite to burn cars and trying to stop the reaction with liquid nitrogen.

Here’s the directors cut of the thermite video which contains 4 extra minutes:

Finally, please do not try this.

The ThingamaKIT is an anthropomorphic analog synthesizer kit from Bleep Labs. Using “LEDacles”, photoresistors, knobs, and switches, it generates interesting high pitched vocalizations. Bleep Labs sent us a review unit and this article shares our experiences building and using the kit. We’ve also included a tutorial on making some hacks, modifications, and circuit bends to it. Skip to the end to see a video of our hacked kit in action.

Using the ThingamaKIT

While it may not be that useful for serious musical composition, the ThingamaKIT makes some nice bleeps and blips, even without modification.The LED to photoresistor input/feedback method is enjoyable to play with, by repointing the LEDacles and waving hands around the photoresistor. The ThingamaKIT is very easy to start using; just twiddle knobs, and it starts making its characteristic ridiculous sounds.

The ThingamaKIT is an simple but fun circuit, and schematics are provided. Three Schmitt trigger oscillators, like the ones used in the previous Hack a Day synth article are used to control the first LEDacle. Because they have different frequencies, the LEDacle blinks in an interesting manner. A Schmitt trigger and op amp generate a triangle wave for the other LEDacle, with controllable waveshape and speed. Another Schmitt trigger generates the modulating wave, with a frequency based on either Photocell 2 or a potentiometer. The main oscillator, the XR2206, has a pitch controlled by Photocell 1, except when the output from the modulation is high, then it switches to a different pitch.

Embedded above is Bleep Labs official demo video.

Building the ThingamaKIT

The instructions for building the ThingamaKIT are printed well and easy to follow. [Surachai]‘s build time lapse, shown above, gives a nice overview of the process. We had no problem finding components and soldering them to the board. Though troubleshooting instructions are provided in the manual, our device worked fine, and we did not need them.

If you are assembling the ThingamaKIT with the intent to hack it as shown in the rest of this article, there are a couple things you should do differently than shown in the instructions.

• Cut the 4” wires a little longer, closer to 6”. You’ll need the extra length when fitting components.
• Do not install the waveshape switch, unless you want to test the default ThingamaKIT unit without modifications.
• Do not proceed to the casing steps until you have made modifications.

Hacking the ThingamaKIT

Bleep Labs has designed the ThingamaKIT to be easily circuit bendable, and there are many fun hacks that can be done with this unit. A few are briefly presented in the extra information given with the kit. While playing around with it and assembling it, we also discovered several more. We’ll show you a few different hacks and circuit bends that you can do with an assembled ThingamaKIT.

Adding an audio input

Our favorite hack for the ThingamaKIT is to add an audio input. The ThingamaKIT will completely warp any audio input, crushing it to lo-fi fuzz and crunches. Here is its emotional rendition of The Police’s “Every Breath You Take”:

To do this, you’ll need a 3.5mm audio jack, like the kind used in the previous synthesizer how-to article and a SPDT (three way) switch. Solder a wire to the signal lug and a wire to the ground lug on the jack. Then, solder the signal wire (the blue wire) to the left hand pad of the .01 uF capacitor, which is outlined above in red. Our solder joints look like a warzone, but it all works. We swear.

There are two places the ground wire can be soldered, and each has a different sound; we installed a switch so that both could be used. Solder the ground wire to the center lug on the SPDT switch. Solder one of the outside lugs to the board’s ground, and another to the other pin of the .01 uF capacitor, as outlined in red above.

To use the audio input, flip the SPDT switch to either outside position, then patch some audio to the input. Music, drum machines, other synthesizers and more all work to make an interesting sound.

Adding a waveshaper knob

In its default configuration, the ThingamaKIT only has a switch to select between triangle and square wave main oscillators. By replacing this knob with a potentiometer, you can transition smoothly between the two waveforms. However, there will be a significant attenuation (decrease in volume) when the potentiometer is near its center, as both outputs will have increased impedance. This is not easily corrected, except with active amplification, or a dual potentiometer with two different tapers, which we have been unable to find.

To do this mod, you first need to remove the waveshape switch if you have already attached it. The easiest way to remove it is with a desoldering iron. Simply squeeze the bulb, place the hot iron over each pad (pads to remove are outlined in red on the image above), and release the bulb. Do this for each pad until all solder is removed, then remove the switch. Keep the switch, as it will be useful if you want to do the sine wave hack.

Next, solder three wires to a 10K potentiometer, such as the one pictured above. The red wire goes to the middle lug, and the other two go to either end on the board.

The waveshaper knob is complete, and you can now easily fade between square and triangle waves.

Adding a sine wave switch

While reading the datasheet (PDF) for the XR2206, the signal generator that the ThingamaKIT uses, we noticed a very easy way to change the triangle wave output into a sine wave, which has a softer sound.

If you are doing this with the waveshaper hack above, start by taking the old switch, and removing one lug from its side. Then bend the other two down slightly, as shown. This will allow the switch to fit where the old one did on the panel, without being in contact with the board. Solder two short wires to the remaining lugs. Then, stick a piece of electrical tape over the top of the pads on the board where the potentiometer is now wired, and put the switch there, using a bit of hot glue to hold it in place.

To one wire, solder a 220 ohm resistor inline; an extra is helpfully provided in the kit. Wrap the resistor in electrical tape to cover the exposed leads, then solder the two wire ends to pins 13 and 14 of the XR2206 as outlined in red above. The sine wave mod is complete!

Adding a spike wave switch

Another bend we found while poking around in the unit caused the main oscillator to create a “spike” waveform. It produces a nice lo-fi, glitchy sound. To add this bend, take any normal SPST (two way on-off switch) and solder a wire to each lug.

Then, connect it to pins 8 and 6 on the XR2206, as outlined in red. The spike wave mod is done.

Packaging it all up

To finish up our ThingamaKIT, we followed the instructions provided with the kit, but with a few modifications. A couple of extra holes had to be drilled for the new potentiometer (5/16”), the spike wave switch (5/16”), and the audio input (1/4”).

We had some difficulty getting all of the new components fitted into the case, but with some rearranging we managed. Be sure not to push the photoresistors up higher on the face then is shown on the drill jig, or you will have trouble fitting them around the LEDacles. The volume potentiometer was also mounted a little low, and we had to put the speaker toward the controls side rather then the LEDacle side of the case to fit it in.

Check out the demo video below to see our glorious leader in action.

Further hacks

To hack your ThingamaKIT further, Dr. Bleep has some recommendations in the manual: using the extra oscillators on the board to add effects, replacing the variable photocells with resistors and buttons to make a keyboard, making a patchbay, and getting complete control over LEDacle 1 with potentiometers.

That concludes our ThingamaKIT hacking. Have any of you built one? To see other custom ThingamaKITs, check out the Flickr group.

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.

To replace the old door strike with our new electric unit, we had to align it with the old one. Once it was set, we traced around the mounting plate with a pen and got to work. We grabbed a 3/8 inch bit and drilled out the width and depth of the hole to match the body of the strike. Then we cleaned up things a bit with a wood chisel until the hole was just big enough. The strike requires 12 volts to release, so we had to feed some wire to it. We dug up a fairly long drill bit and drilled through the wall and into the strike mounting hole.

The strike wiring is low voltage, so the wire doesn’t have to be anything special. We used some 18 gauge speaker wire – it’s cheap and we already had it in our parts bin. Pulling the wire is pretty easy. Just feed the wire through and grab the end with a pair of needle nose pliers. Since we had 50 feet of wire to work with, we pulled the wire over to our bench and did a quick soldering job to the strike leads. Once the connections were solid, we insulated them with electric tape. There’s no polarity to worry about, so just get things connected and ready to rock.

The strike has a thick mounting flange, so we had to remove some wood from the surface of the door frame. After some quality time with a hammer, flat headed screw driver, and a wood chisel, we managed to cut a decent mounting slot. Once the wiring was insulated, we pulled in the slack and mounted the strike with a pair of three inch screws.

We’ll be wall mounting the keypad, so we picked up an “old-work” two gang electrical box and a two gang blank wall plate. Mounting the box is pretty easy, but we’ll walk you through it.

To make the bezel, we laid out the buttons in CorelDraw and scaled up each button by a few percent. Once the size was correct, we rounded off the corners to match the buttons better.

After a few test fits made by cutting paper, we put the wall plate into our ever handy laser cutter. We realize that most of you don’t have one of these awesome machines – you can create your own with some careful drilling and dremel work (it might be easier to bribe the local sign shop with some beer). If you do have it laser cut, make sure you get a nylon wall plate and not a PVC plate. The fumes from burning PVC are toxic and air filters will not neutralize them.

When we test fit the new bezel, we found that the flex at the base of each button was impeded. It’s hard to see here, but the wall plate is only about 1/32 of an inch thick. Since it’s so thin, the buttons stick out too far.

To solve both problems, we created a sub-bezel. We used the same laser template, but expanded each hole a bit further. The 1/8 inch acrylic provided perfect depth for the buttons and the larger holes in the sub-bezel provide an area for the buttons to flex.

“Old-work” boxes are designed to be installed into existing drywall. You just have to cut a hole for the box and when the screws are tightened, these tabs will flip up to grip the inside of the wall.

Once the hole’s cut, just insert the box and check the fit. Don’t tighten the screws just yet – we’ll be pulling it back out for a quick mod. Since we’re mounting all the hardware on the other side of the wall, we drilled a hole into the workshop side to run the keypad wiring.

It just happens that Spark Fun’s PC Board is the same width as the 2 gang box. In order to fit the bezel flush, we need to trim back the edge of the box.

You can use your favorite tool, but we grabbed our rotary tool and a small drum sanding bit. Then we ground the edge of the box down to allow for approximately two times the thickness of the keypad PC board. (You might want to adjust this depending on your bezel design.)

The final fit is just about perfect. The edges of the drywall keep the board from shifting while the box supports the board from behind.

Now that the bezels are ready to go, mark your wiring so you can identify it post install. We used some colored electrical tape and noted the connections. Since we used Cat-5, you could easily use RJ-45 connectors to add some modularity. We didn’t need it, so we just pulled the wires through to the workshop side.

To finish up the key pad, we installed the PC board, the keypad, the acrylic sub-bezel, and finally the keypad. Everything actually floats under the keypad. The design has worked perfectly for the past few months – with one exception. One visitor pushed too hard and popped the PC board back into the wall box. If needed, you can add a support strut of some kind behind the PC board.

To create a permanent board for the keypad, we laid everything out in Eagle. Since we wanted to try out some interesting etching ideas, we used extra wide traces and expanded the pads to provide plenty of copper.

After making the keypad bezel, we wanted to try some new tricks with the laser cutter. We coated some copper clad PC Boards with spray paint and let it harden for a few days.

To We exported the design from eagle and sent it to the Epilog via CorelDraw. In order to remove all of the paint, we had to run the etching jo
b twice on the laser. Here, the laser is mid way through the second run.

Even after two jobs, a fine residue was still on the copper. Lightly scrubbing the board with acetone (nail polish remover) removed the left over residue. The traces remained intact and the copper was bared for the etching solution.

Radio Shack doesn’t bother to carry ferric chloride anymore, but we wanted local chemicals. We picked up some muriatic acid (hydrochloric acid), hydrogen peroxide, a cereal container air pump, bubble block, and some hose. The acid is readily available at the hardware store. We suggest finding the smaller container – it’s the perfect amount for a one time fill.

Etching the board is the usual show. The bubbles help agitate the solution around the copper and speed up the process.

The finished etch came out pretty decent, if slightly over-etched. Holding the board up to a light is an easy way to check for top/bottom layer alignment. The board was slightly over-etched, but after spending a couple of weeks mucking around with the process, we decided that it was time to get on with it already.

To drill the board, we used a #59 tungsten carbide drill bit. Instead of a drill press, we manually ran our CNC mini mill to drill the board. We only broke one bit and that was when we fat-fingered a direction key.

One more quick check and the board looks perfect. The milling machine made it easy to keep the holes in line for the build.

Finishing the build is pretty easy (the red wire going over the board was a quick design fix). We added jumpers for all of the Arduino connections and soldered the Cat-5 from the keypad directly to the new board. We won’t bore you with step by step soldering pics. If you prototyped the circuit, you should be intimately familiar with the thing by now. If you need some help soldering, be sure to check out our introduction to soldering.

The bezel’s built, the PC Board etched, the circuit soldered, and the keypad’s installed. The only thing left to do is enjoy the new keypad… or develop more code and teach it some new tricks.

We promised to explain the code a bit, so we’ll give you a quick walk through. The meffect keypad code (available here) was written to simplify the keypad routines for the project. The first several lines initialize the various variables we’ll need to make things work. We added comments regarding pin assignment to help simplify wiring and help people change things around as needed.

The code to drive the digital potentiometer comes directly from this tutorial.

The setup() function is run one time when the controller is powered on or reset. Variables are set and i/o pins are set to their initial states as needed.

The loop() function is the never ending loop where the controller will perform a few tasks. The main order of business is to read the button states for input. Second, the potentiometers are set and each LED is lit temporarily, based on the values in the matrix defined for each LED state. If no action is detected, then the values are set by an effect function. However, if an action is detected, the effect is halted and the button color is set based on the number of inputs keyed in. Next, the loop counts all the button presses that are detected. If the lock exceeds the defined number (in this case, 20) then the pad glows red, state is reset and it locks the user out for about 30 seconds. The final test is the actual lock code. If the keypad state matches the predefined code, then the pad glows green and the door lock is opened for about 5 to 10 seconds.

The code is pretty simple, but the framework is there to produce a more secure lock. The easiest way to up your security would be to create a rolling fade effect and possibly blip the LED color when a key press is detected. Probably the coolest feature of the lock is that you can program it to behave and lock in any way you want.

The basic design for the RGB keypad came from [JMG]‘s Arduino based Monome clone. He used an Arduino, and multiplexed RGB LEDs with some digital potentiometers to create a color mixing keypad. Since we couldn’t fit the complete 4×4 keypad into a standard 2 gang wall box, we chopped the design down to a 2×4 matrix. This cuts down significantly on the cost to build the keypad and makes the code that much easier to digest.

To build your own RGB keypad, you’ll need the following:

• An electric door strike (Smarthome.com)
• A locking door handle (Any hardware store)
• An Arduino or compatible clone (Sparkfun, adafruit and others)
• 1 TIP120 transistor
• 1 1N4001 diode
• 10 1N4148 diodes
• 4 2n2222 transistors
• 1 Monome style keypad (Sparkfun Electronics)
• 1 Keypad PC board (Sparkfun Electronics)
• 8 RGB LEDs (Sparkfun Electronics)
• 1 7805 voltage regulator
• 4 100 ohm resistors
• 2 150 ohm resistors
• 8 1 kohm resistors

To reliably lock and unlock the door, we ordered an electric door strike. We scored this one as an open box item from Smarthome.com. It’s a 12 Volt DC unit designed just for Schlage commercial door locks. The edge of the strike is slightly recessed from the mounting plate, so it might not work with certain locks. It features a thinner body than the non-recessed version, which will allow us to cut a smaller but deeper hole in the door frame. Without power, the strike stays locked, keeping the locking door shut. When 12 volts is applied to the coil, the strike releases, allowing the door to be pulled open. For the prototype build, you don’t have to purchase a strike just yet; you can use a LED and a resistor to indicate the door lock state for testing your code.

The keypad is actually built from two separate circuits that physically overlap. The input circuit is a simple keypad matrix. To read each button push, the Arduino brings one keypad input line high and checks the voltage of the four output lines in order. The diodes on the PC board prevent feedback across the rows and columns.

The RGB LEDs are lit via a completely separate set of circuits. Each row of like colored LEDs is brightness controlled by a digital potentiometer. The digital pot works just like a normal pot, but it’s digitally controlled by the Arduino. Meanwhile, each column of LEDs is activated by a separate transistor. By quickly changing the resistance and stepping through the columns, each LED will appear to be individually controlled.

The door strike circuit is pretty simple. Since it contains a coil, we’ll treat it like the coil of a stepper motor and use a TIP120 transistor to supply the power. When power is removed from a coil, the collapsing magnetic field creates a current within the coil. To keep the TIP120 from burning out, we’ll add a diode to handle the surge created by the field breakdown.

update: [Triffid] pointed out that the diode is better placed in parallel with the coil to handle the transient surge. He’s correct, but the circuit here has operated perfectly for several months, so you’ll be fine either way.

The traces for the buttons looked a bit challenging to etch at home, so we ordered this PC board that Sparkfun produces for their keypads. Sparkfun helpfully provides the layout for these keys in their eagle library, so you can make your own PCB if you prefer. For reliability, you’ll probably want to have it commercially produced. The board wasn’t really designed to break apart, but after a review of the traces and vias we decided that we could get away with trimming a couple of rows from the board.

We carefully split the board down the middle with a band saw. If you look closely, you can see where some of the vias were actually cut in half. (A paper cutter might work in a pinch) Don’t forget to put on a mask to keep the dust out of your lungs.

Cutting the button pad is much easier. The pads have pre-scored lines that just need a quick swipe of a sharp knife or scissors to separate them.

The new shorter PCB only needs a few parts: some 1N4148 diodes and the RGB LEDs. The silkscreen on the board indicates the direction and position of diodes and LEDs.

Once you solder on the 1n4148 diodes, cut them as close to the PC board as you can. Flat head cutters like these work extremely well. The keypad will sit on this side of the board and we want to make sure that it can sit as flat as possible.

Install the LEDs in the orientation indicated by the silk screen. Carefully push them down into the board until they’re inserted just like this. If you let them stick up too high, they’ll interfere with the keypad buttons being pushed.

Once you’ve soldered all the LEDs in place, clip them flush as well. Then you’ll need to add some cable to jumper from the keypad to the interface board we’ll build. We used some old CAT-5 wiring. Since each axis of the board has eight pins, it’s perfect for the application.

Each RGB LED has three LEDs inside the package. They share a common terminal and have a single separate lead coming out. Because they have different characteristics – that is brightness, current and voltage requirements, we spent some time testing out various combinations. We even murdered a couple of innocent $2 LEDs just for you. Hey, the other two colors are still usable…

After some experimentation, we managed to find the right combination to create some fairly white light. The requirements will vary between manufacturers, but for the Sparkfun LEDs we found that a pair of 100 ohm resistors and a single 150 ohm resistor blended the red, green and blue fairly well.

The color combination was hard on the eyes until we put the keypad over the LED to double check our findings. In real life, you can see some blending lines from the offset of each LED, but it still looks great.

The circuit has plenty of components, but it’s pretty easy to build. We’ll break everything up by section to keep things easy. You can download the all of the schematics, Eagle project files, and code for the Arduino here.

The digital pot has six outputs. Each of these will power a row of red, green or blue LEDs, via a color matching resistor. The digital potentiometer wiring comes directly from this how-to. You can read it if you need more information, or use our quick version:

• Connect AD5206 pins 3, 6, 10, 13, 16, 21 and 24 to 5v.
• Connect pins 1, 4, 9, 12, 15, 18, 19, and 22 to ground.
• Connect pot pin 5 to Arduino pin 10
• Connect pot pin 7 to Arduino pin 11
• Connect pot pin 8 to Arduino pin 13

Grab four 100 ohm resistors and two 150 ohm resistors. Place them in the breadboard in a row with each end in a separate bus. (Across the center of the board is easiest) Connect the six LED leads from the keypad to one end of each resistor – reds get the 150′s and blue and green into the 100′s. Here’s the connection order we used.

• RED3 to a 150 ohm resistor to pot pin 14
• GREEN3 to a 100 ohm resistor to pot pin 11
• BLUE3 to a 100 ohm resistor to pot pin 2
• RED4 to a 150 ohm resistor to pot pin 23
• GREEN4 to a 100 ohm resistor to pot pin 20
• BLUE4 to a 100 ohm resistor to pot pin 17

To ground the LED busses, we’ll be using four 2N2222 transistors. The Arduino will trigger each transistor individually through a 1Kohm resistor. The collector of each transistor connects to a ground line from the keypad. The emitter of each transistor is connected to the ground. The four transistor select lines connect to Arduino pins 0, 1, 2, and 3. Yes, they’re marked Analog in, but it doesn’t matter.

The keypad switch matrix is connected in four columns and two rows. Each of the four columns gets a pull-down resistor. We used 1Kohm resistors for R11, R12, R13, and R14; one lead connects to the columns and the other is grounded.

Arduino pins 2 and 3 should connect to the two ungrounded lines, which are marked SWITCH3 and SWITCH4 on the PC board (5 and 6 on the schematic).

Arduino pins 6, 7, 8, and 9 should connect to the four output lines marked SWT-GND1, SWT-GND2, SWT-GND3, and SWT-GND4 (1-4 on the schematic).

The final version of the board takes a 12VDC input to drive the door lock. We added a 7805 to drop the 12V down to 5V for the Arduino. You don’t need it for the prototype version unless you want to test the striker. The Arduino has an on-board regulator, but 7805′s are cheap and it helps reduce the load on the Arduino’s built in regulator. For code development, we just connected an LED with a resistor to the output line that will control the door lock.

With everything wired in the prototyping board, it’s time to test things out. With any luck, you’ll soon be rewarded by the pulsing, glowing sight of several RGB LEDs under your tender digits.

Programming the Arduino is a snap. Just download the software for your OS here. Now follow the Getting Started guide to get the Arduino software talking to the Arduino board. Once you’ve enjoyed the blinking LED demo, come back here and get your keypad rolling.

Once you’ve set up and tested your Arduino, it’s time to test out your prototype. Download the button_test code from here. Paste it into a new sketch and upload it to the Arduino. Click the serial console button and you should start seeing dots accumulating in the window. If you press a button on the pad, the Arduino should print a message to the console and toggle the lock output state.

Once your buttons are tested, you’ll probably want to try out your LEDs. Grab the RGB_light_fade routine from the same page and upload it to your Arduino. You should get treated to a nice little light show. This is our favorite demo because it really shows off the color mixing capabilities of the digital potentiometer.

With your LEDs and buttons working, you can grab the row_entry_pad_meffect lock code from the same place and upload it. Now the keypad should start flashing blue buttons while it’s idle. On key presses, the keys will change colors. By entering the correct color code, the pad will flash green and unlock the door for 10 seconds. If you go over the limit counter, it will flash red for 30 seconds.

Next time we’ll show you how to make the permanent version of the keypad, walk through the code for the Arduino, make the PC board, cut a custom wall plate, and install the lock strike.

This hack shows how to make a dumb terminal out of a keyboard, LCD screen, and an 8-bit microcontroller. From time to time, a portable dumb terminal can be handy for when you have to rescue a headless server that’s acting up or if you are building a minicomputer out of a WRT, or if you just want to learn how to run a keyboard and LCD screen with a microcontroller. This super simple serial terminal will use RS-232 to control a headless linux system. Additionally, you might want to check into some of the command line interface programs that allow web browsing, AIM and IRC chatting and more directly from the terminal, but nothing beats being able to track your pizzas with this device.

The Linux system in question here will be Linux Mint. It’s a young distro based on Ubuntu that’s gaining a lot of attention lately, though the principles can be used for other Linux distros.

The Hardware:
For this How-To we’ll be using an ATMEGA128 running at 16MHz. Since this device will be communicating through RS-232, we’re going to need a level shifter. RS-232 uses 12 volt signals which will fry our 5V microcontroller. To fix this problem, we’re going to use a MAX233 chip.

This is the schematic of the level shifter circuit.

This is an example layout.

I’m using the ET-AVR stamp module with the stamp board for this project. This dev board is cheap and has the essentials built in. I’ll be using the on board power supply and the MAX232 RS-232 level converter.

The LCD chosen for this project is a very common 4×20 character LCD. These LCDs are really easy to control with a microcontroller(PDF), and even without one(PDF). The HD44780 chip allows for several bit widths for parallel programming, as well as commands, and even custom characters. This LCD has nice software library, which makes it even easier to use.

A more attractive choice would have been to go with a graphical LCD, which are also supported by our library, however, we only had the character LCD on hand.

A common AT keyboard will be used for character input, again these aren’t hard to find, you probably have an extra one laying around somewhere .

If you don’t want to buy the ET-AVR, you can build the circuit for this hack yourself. (Click for larger pic).

A full parts list of above circuit: :

If you would like to use the ET-AVR or some other dev board, you can use this parts list:

The Software:
We used WinAVR with AVRlib installed. AVRlib is a set of libraries that can run servos, set up A/D conversions, etc. It can do pretty much anything else you need it to do. To install WinAVR, get the newest version here and follow the directions on the installer. We generally don’t follow the directions here for installing AVRlib and place it into the include folder of WinAVR installation found at C:/WinAVR/avr/include/AVRlib. This way your included headers are easier to see and find.

eg. #include <AVRlib/servo.h>

Once this is done, you can open up Programmer’s Notepad and begin coding. We’ve already written the code for this project (with room left over for some adventurous readers to modify).

The Keyboard Protocol:
Keyboards use a simple serial communication setup. There are only 2 lines, the DATA and the CLOCK. Generally, nothing is happening on these lines (both the CLOCK and DATA lines are high) until you hit a key. Once a key is pressed, the DATA line goes low. Shortly thereafter, the CLOCK falls. The clock will go for a total of 11 cycles. As this happens, data must be read form the DATA line on the falling edge of the clock. The data is sent from the keyboard in reverse (least significant bit first) with a parity and a stop bit.

The overall data package is:

The Start bit, Parity bit, and Stop bits are going to be ignored in this simple hack.

After the keyboard sends a key’s scancode, it also sends a 0xF0 when the key has been released.

Looking at an example, it is easier to understand. Imagine the ‘m’ key has been hit on the keyboard. The data line goes low to make a start bit, then the scancode is sent with the LSB first, then the parity (odd parity) and a stop bit. Since the scancode for ‘m’ is 0x3A, we should get that value in the data portion of the package. Again, the keyboard sends data LSB first, so since we are expecting 0x3A (binary 00111010) we will actually get the reverse of that (binary 010111100). Just remember to read the data bits from right to left to make it easier to see the scancode. After the data, we’ll receive a 1 in the parity bit to make the package odd parity, then the stop bit. After the scan code has been sent, the keyboard will send another scancode when the button has been released. This release code is always 0xF0 and can be ignored, and it gets handled in the code.

So when ‘m’ is hit, the keyboard sends :

A more advanced explanation on how this works can be found elsewhere.

We must only read the data line as the clock falls to make sure we get good data. We attempted to do this using an external interrupt on the ATMEGA128 and AVRlib’s external interrupts routines. This proved more complicated than it needed to be. We then remembered that not too long ago Sparkfun had posted about some kind of keyboard widget on their site that used an AVR. The code for their keyboard reading routine was really simple and didn’t use external interrupts at all. We modified the “getkey” routine from the one [Nathan] at Sparkfun wrote for their key-counter widget.

Once the scancodes have been read, they must be converted into something useful. As far as we could tell, keyboard scancodes have no mathematical relation to ASCII code so we set up two ASCII lists. Each list is actually an array of ASCII characters. One list has all the values for shifted characters, and another list has the values for unshifted characters. We looked up the ASCII value for each scancode and placed them in the array in order. This allows for a simple way to return the ASCII value of a given scancode.

When you hit the ‘h’ key for instance, the program catches the scancode 0×33 and goes to the 0×33 rd value in that array, which happens to be 0×68, the ASCII value of ‘h’. The resulting ASCII character is sent to the LCD and to the UART, both being controlled by AVRlib to make them easier to deal with.

There are a lot of 0s used as placeholders in the arrays. This is because AVRlib automatically loads the LCD’s CG RAM address 0×00 (the ASCII code for NULL) with a character. Basically, if those codes are send to the LCD, it will just look like garbled mess. We used ’0′ so we could tell what was going in if that were the case.

Extended keys are not currently supported. The Function keys (F1-F12) have been given normal functions used in Linux, but not supported by the rest of the program. For example, pressing F1 sends the same command as “Ctrl+X” in Linux. See the code for the other function keys. Not all the keys are used (purposely) so if you want to add custom functions to the terminal, there’s plenty of space to.

The UART:
The ATMEGA128 has two UART ports. Using the first one (UART0) characters can be sent from the AVR to the terminal, and vice versa. The UART is initialized and set to 9600 baud, 8-bits, no parity, one stop bit. Make sure to set the terminal program to the same settings. We’ll modify Linux later to make sure the settings match.

With AVRlib, using the UART is a breeze. Simply initialize it, give it a baud rate, and you can start sending and receiving data.

Fiddling with Linux:
You’ll either need a monitor and keyboard on the Linux machine, or SSH into the machine and set this up.

There are several good guides on the internet for setting up a Linux machine to use a serial console. However, Linux Mint is based off of Ubuntu, which is a bit different than most OSs when it comes to setting up serial access at boot. This guide explains the basics, but we’ll need to tweak that a little to make it work for us.

First you need to find out if you even have a serial port on your machine. Look at the back and try to find a DB9 connector.

Now you will need to figure out what that serial port is referenced on your machine. Open a terminal window on the machine and enter the following command:

======================================
$ dmesg | grep tty
======================================

The output will be something like this:
======================================
[ 35.742036] serial8250: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A
[ 35.742435] 00:08: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A
======================================
This shows that we have 1 serial port on this particular machine. And it is called “ttyS0″.

Now we must set up a way of logging into the serial console. This is handled by the getty process. This process will open the tty port you specify and send a login prompt.

To set this up, we need to create a file in /etc/event.d called ttyS0. Open up your favorite text editor and type in the following:

======================================
start on runlevel 2
start on runlevel 3
start on runlevel 4
start on runlevel 5

stop on runlevel 0
stop on runlevel 1
stop on runlevel 6

respawn
exec /sbin/getty -L 115200 ttyS0 vt102
======================================

Now save this file as /etc/event.d/ttyS0.

Now, that’s fine for the regular users on the machine, but to do things as root, there will have to be a pass in the /etc/securetty file. Go to /etc and use a text editor to open the securetty file. (That’s “securetty”, not “security” ).In this file, type “ttyS0″. This allows that port to have root access. Save the file and close the editor.
Now the final step is to have the console available when the machine boots. To do this, we must modify the grub bootloader. You have to go to /boot/grub and edit the menu.lst file. First go there and make a clean copy of the menu.lst file:

======================================
cp /boot/grub/menu.lst /boot/grub/menu_orig.lst
======================================

Now open menu.lst in a text editor and type the following

======================================
serial --unit=0 --speed=9600 --word=8 --parity=no --stop=1
terminal --timeout=10 serial console
======================================

This first line tells grub that you want ttyS0 to be used (–unit=0) with a baud rate of 9600 (–speed=9600) using 8n1 (–word =8–parity=no –stop=1)

The second line says to display the terminal on both the serial console as well as the screen, if there is one.

If you want to watch the boot messages on the serial console, you can add the following line to the end of the “kernel” line in this file:

======================================
console=ttyS0,9600n8 console=tty0
======================================

Save this file.

Now you should have access to the serial console when you boot, but the default shell is bash. This is bad because bash sends a lot of extra characters when it executes commands. On many terminals, these characters are stripped from displaying, however, it is hard to do that on an LCD, and with only 80 characters, we don’t have much room to spare on our screen. We need to use something a little simpler.

[Fabienne] suggested using sh as the shell to get rid of bash’s weird characters. This worked during tests, so we made it the default shell on the machine. This allows it to automatically load during the boot, making it much easier to use with the device we’ve just made.To do this, simply open a terminal window and type:

======================================
chsh
======================================

This will ask you for your password. Once you enter it, you will see a screen like this:

======================================
Changing the login shell for <username>
Enter the new value, or press ENTER for the default.
Login shell [/bin/bash]
======================================

At this point you need to type the following:

======================================
/bin/sh
======================================

Hitting ENTER again will save this new setting.

Now you are ready to connect the device and see it in action!

Connecting the device:
You can play with this on a windows machine, but its real power is with a Linux machine. If you have a Windows machine, you can now communicate to the device through hyperterminal or some other terminal program. Just plug in a serial cable to the DB9 plug and set the terminal to 8n1 as mentioned above. Typing on the keyboard will display on the terminal and on the LCD.

To use it with the Linux machine, plug in the DB9 to the serial port on the computer, and turn the machine on. The first that that should happen is that the system will ask you to “Press any key to continue”. Hit anything on the keyboard to begin loading the OS. After pressing the key, you should see all the boot information scrolling on the screen. Once this stops, hit “enter”. This will bring up the logon screen (remember setting up the getty?).

Type your login name, and hit enter, then your password. As with most Linux systems, typing in the password field will NOT print to the screen. Go ahead and get an “ls” of your home directory. Notice that the screen isn’t large enough to show all the files and folders. We’ve written in a simple single screen buffer that will show the previous 4 lines displayed on the screen. So this kind of emulates a “Page Up” function.

Now you have the code, and the hardware lists, lets see what you can do with it.

As anyone who has lusted over the technical specifications for Canon’s new Digital Rebel XSi knows, the capabilities of the average point and shoot camera are severely limited. Using the CHDK firmware hack, the features of Canon point and shoot cameras can be significantly expanded, allowing for ultra-high speed photography, very long exposures, time lapse photography, and RAW capture. This How-To provides a guide to our experiences using the CHDK firmware, and shows just how easy it is to get more out of a point and shoot than ever thought possible.

Installing CHDK

The first step is to install the CHDK software. Our friends at Lifehacker recently ran an article covering exactly that, so we won’t bother repeating the instructions. Be sure to install the Allbest build, it has all of the nice features.

After installing, you’ll want to have the firmware autoload when you boot up your camera. To do so, open up the main CHDK menu by pressing your ALT button, then the MENU button. Scroll down to “Debug parameters”, then click on “Make card bootable…” After it is done, turn off your camera, remove the SD card, and toggle the write protect switch. When this switch is toggled, the camera will automatically boot into CHDK (you’ll still be writing to it).

Taking long exposures

Long exposure photography is appreciated for its soft, sometimes surreal images of (usually) night scenes. Many point and shoot cameras only allow exposures of 15 seconds, but with CHDK, you can take photos at up to 64 seconds.

Navigate to CHDK’s main menu and find Extra Photo Operations. In Extra Photo Operations, change the Override Shutter Speed value to the shutter speed you wish to shoot at, such as 64 seconds. Scroll down and change the Value Factor from OFF to 1.

Though the camera will not indicate the modified shutter speed, the changes will take place. Just take a picture as you normally would. Be sure to have your camera set to manual mode. Taking photos of moving things works best for long exposures: try subjects like the ocean, windy trees, and traffic. Additionally, using neutral density filters, you can even take long exposures in the day time!

Taking ultra-fast exposures

Just as you can override the shutter speed for long exposures, you can take ultra-fast exposures as well, at up to 1/100,000 of a second with some cameras. Flash will sync at up to 1/60,000 of a second, and you’ll need flash with such short exposures. We were unsure how useful or easy this would be to use, but the results surprised us: in just a few minutes we were able to capture nice looking water droplets, without a hint of motion blur.

Navigate to CHDK’s main menu and find Extra Photo Operations. In Extra Photo Operations, change the Override Shutter Speed value to the shutter speed you wish to shoot at, such as 1/16,000 of a second. Scroll down and change the Value Factor from OFF to 1. Be sure to have your camera set to manual mode.

Note that the minimum shutter speed is restricted by the aperture value you have selected in the camera’s manual settings. The wide end (lower numbers), can usually only shoot at down to 1/8000 of a second, while the narrower end (higher numbers) can shoot for the full range.

Prefocus before taking the picture, either by using manual focus mode, or by holding the shutter button halfway down. Though the camera will not indicate the modified shutter speed, it will use the short shutter speed. There are many different things that can be done with high speed photography: capture water droplets, capture explosions, or even capture a bullet leaving a gun. All of these are possible with CHDK.

Running scripts

The real power in CHDK comes from running user made scripts. The first script we will look at is an intervalometer, which allows you to take many photos over a period of time. We used it to easily create a time-lapse video.

Copy and paste this script into a new document, and save as ult_intrvl.bas to your computer. Then, plug in your camera’s SD card, and copy ult_intrvl.bas to /CHDK/SCRIPTS/.

To use the intervalometer, navigate to the main CHDK menu, find “Scripting parameters”, and click “Load script from file”. Find ult_intrvl.bas, and press set. Then, scroll down and adjust the script parameters: the delay until the first shot is taken, the number of shots you wish to take, the interval between each shot, and whether or not you want it to take an “endless” number of photos. Then, exit the menu, but leave your camera in ALT mode, and press the shutter button to start the script.

The video above was created by taking approximately 700 shots at 15 second intervals over 2 hours and 45 minutes. Just set your camera on a tripod or another steady surface, and start the intervalometer. Using QuickTime Pro, go to File>Open Image Sequence to convert the hundreds of separate images into a movie. For space and processing considerations, we recommend setting your camera to a low-resolution mode before starting the intervalometer.

Exposure bracketing

Exposure bracketing allows you to take many pictures at slightly different exposures nearly simultaneously. You can use this to correct errors in the camera’s autoexposure, or merge exposures for HDR photography. Many higher end Canon PowerShot’s have exposure bracketing built in, but for those that don’t, CHDK has the answer.

Like with the intervalometer script, simply copy and paste this script into a new text file. Name it bracketing.bas, and place it in the /CHDK/SCRIPTS/ folder of your SD card.

Then navigate to the main CHDK menu, find “Scripting parameters”, and click “Load script from file”. Find bracketing.bas, and press set. Then, scroll down and adjust the script parameters. The step size is the difference between each image taken, in 1/3 EV steps, the correction is the EV of the middle image taken. The only slightly tricky part here is that first parameter is the (number of images – 1)/2. This means that if you want three pictures, it must be 1, five is 2, seven is 3, and so on. To run the script, exit the menu, leave the camera in alt mode, and press the shutter button.

With these different exposures, you can create HDR tone-mapped images, that show very bright and very dark regions exposed properly. For example, taking the seven different images of the lighthouse above into an HDR program such as Photomatix, optimizing settings for realism, produces this result:

You can also use HDR to produce more dramatic photos, such as this train. It is all in how you process the images.

There is a lot that can be done with HDR, from extremely vibrant photos, to the scarily surreal, such as this one below from Till Krech.

..

For more information on HDR photography, Stuck In Customs has an excellent tutorial.

Taking RAW photos

RAW photos can be extremely useful to digital photographer. They enable you to extract more information from bright highlights in an image, and RAW gives the you complete control over white balance. For example, in the above photo the JPG had an incorrect white balance, which was easily corrected using the RAW image. While DSLRs offer 12 bits of data in RAWs, most point and shoot cameras can only provide 10, meaning that even with CHDK, you won’t be able to extract as much information from highlights as you could with a DSLR. Still, RAWs are very useful for having precise white balance control.

In the Raw Parameters menu, enable “Save RAW”, and adjust the other parameters as shown. Now, you can take photos as normal, and a RAW will be automatically saved with your JPG. The RAW file will take quite a bit a more space than the standard JPG, so your camera will not be able to correctly display remaining space on the SD card.

Processing RAW photos

To process your RAW photos, you’ll need to convert them to the Digital Negative format, DNG. The DNG4PS-2 software can do this for these cameras: A610, A620, A630, A640, A710 IS, S2 IS, S3 IS, A700, G7, A560, A570 IS, IXUS 700, IXUS 70, IXUS 800, A720 IS, S5 IS, IXUS 950, A650 IS, A460, SD800 IS, A530, A540. You can also process the files using UFRaw or dcraw, though that is much more difficult.

Open DNG4PS-2, then go to settings. Adjust the model settings based on how many megapixels your camera is. Next, press OK, and find the path to RAW files option. This is not the location of the file that you wish to convert, but the folder that contains the files. When you have selected the correct folder, press “Convert”.

The DNGs will be in a folder marked with today’s date, and from there, you can process them in Lightroom, Aperture, Photoshop, or whichever RAW processing software you prefer.

Adding a battery meter

Tired of have the low battery warning sneak up on you? CHDK can add a battery meter to your camera, though the configuration depends on what type of camera you have.

To enable it, go to OSD parameters in the main menu, then to Battery. Edit the parameters so that they are as they appear above, if you have a camera with 4 AA rechargeable batteries. Cameras with 2 AA rechargeable batteries should be about half of that. For other power sources, experiment to find the best value.

Writing your own scripts

CHDK uses a very simple BASIC-like language called UBASIC. It has all of the features that one would expect from any language, but there are many camera specific features.

Input/output

Each script begins with a special header, that provides information and control to the user.

@title Intervalometer

In this header, the title of the script is declared, as are two user adjustable parameters. The syntax is simple: @title declares a title, @param par declares the name and label of a parameter, and @default [par] declares the default value of a parameter. Scripts can only receive input through the header, at the beginning of their execution.

To output information to the user, the print command is used: print "Num shots: ", a will print the number of shots, as inputted in the script header. Note the use of the comma to seperate text from variables. The print command is limited to 25 characters of text. To clear what has been printed, use the cls command.

Standard program flow

let a = 2

next x

:display

rem print even numbers

if x % a = 0 then print x

return

This block of code demonstrates many of the logic features of the UBASIC language. To assign values to variables, use the let command. You can also see a for loop and a subroutine. Note the use of the rem command to insert comments, and the single line if statement. UBASIC supports most standard mathematical comparisons, including +, -, *, /, %, <, >, =, <=, >=, <> (not equal to), &, |, ^ (xor).

Camera control

The meat of UBASIC is in its many commands for controlling the camera:

shoot

Takes a photo

click/press/release "button"

Clicks (press and release), presses, or releases on the cameras buttons. The following are available: up, down, left, right, set, shoot_half (depresses the shutter halfway), shoot_full, zoom_in, zoom_out, menu, display, print, erase, iso, flash, mf (manual focus), macro, video, timer.

wait_click timeout

Waits for a button to be pressed, then continues. The timeout value is optional.

is_key x "button"

Immediately follows a wait_click command. If the last button pressed is "button", then the variable x is set with the value of 1. If wait_click timed out, then "no_key" is used as the button name.

set_tv val

Sets the shutter speed to val. Note that val is not “1/1000″ or something similar, but rather an integer value. Each increase in the integer value corresponds to a 1/3 EV increase. The absolute mapping between integer values and shutter speeds varies between cameras, but tables are available here. This, and all following commands must be used with the camera in manual mode.

set_tv_rel val

Sets the shutter speed relative to the current shutter speed. Example: set_tv_rel 0-1 increases the shutter speed by 1/3 EV.

get_tv target

Sets target equal to the current shutter speed.

set_av val, set_av_rel val, get_av target

With the same syntax as shutter speed commands, these adjust aperture settings.

set_zoom val, set_zoom_rel val, get_zoom target

Just like set_tv/set_tv_rel commands. In set_zoom_rel, val is +/- the relative change. Zoom values range from 0 to 8 or 14 for A-series cameras, and 0 to 128 for S-series cameras.

set_zoom_speed x

S-series only. Sets the zoom speed, at x% of maximum speed. x may vary between 5 and 100.

set_focus x, get_focus target

x/target is distance in millimeters.

set iso x, get iso target

x/target is one of the following values: 0 (Auto ISO), 1 (50/80), 2 (100), 3 (200), 4 (400), 5 (800), -1 (High ISO).

Where to go from here

Try checking out the CHDK wiki, for more features then are even printed here. Finally, take photos! The most important thing that you can do to improve your photography skills is to take lots of photos.

We covered many of [Jason Rollette]‘s personal projects in the past and are happy to welcome him as our newest Hack-A-Day contributor.

The electronics industry has shifted to lead free compliance, but most hobbyists haven’t even considered the personal impact of using lead. Today’s How-To will cover what it takes to switch from tin/lead solder to completely lead free. Our previous posts Introduction to soldering and the follow-up still apply to lead free. You may have never considered switching to lead free before, but we hope to help you make an informed decision.

The reason we are even talking about this is because of the Restriction of Hazardous Substances directive. RoHS was adopted in February 2003 by the European Union; all electronics sold there must comply. The substances restricted are: lead, mercury, cadmium, chromium VI also known as hexavalent chromium plating, and pbb, pbde flame retardants used in plastics. We will focus on lead. Solder joints must contain less than 0.1% lead to be compliant. RoHS is not currently required in the US, but California RoHS, effective September 2003, had a compliance deadline of January 2007.

Although the electronics industry has been directly targeted it only accounts for a small percentage of the lead used in manufacturing. The battery industry consumes nearly 80% of manufactured lead. Tire wheel weights also account for a larger percentage.

There are some good reasons for the hobbyist to convert to lead free solder, both personal safety and environmental. Lead poisoning can occur when lead enters the body through inhalation, ingestion or dermal contact such as direct contact to mouth, nose, eyes, and skin lesions. Even if you keep using tin/lead solder, wash your hands before and after you do anything. Most poisoning cases are from lead building up over time. The main environmental issue is lead leaching into drinking water or watersheds when disposed of improperly.

There are many different varieties of lead free solder. Two alloys seem be the most popular: SAC305 contains 96.5% tin, 3% silver, and 0.5% copper and melts at ~217C, SN100 contains 99.3% tin, 0.6% copper, and some nickel and silver and melts at ~228C. Choose whatever alloy and brand you feel is appropriate for you. Compare those alloys to traditional 63% tin and 37% lead melts that melts at ~183C. The higher melting point is part of what makes lead free harder to work with. We use SAC305 with a “no clean” flux core.

In addition to picking an alloy, you also need to decide on the diameter. We recommend for through hole .032″,.020″ and .015″ for SMT. Choosing the right diameter solder is very important to success. A finished joint viewed from the side should look like a little Hershey’s kiss, not an inflated balloon. The correct diameter solder makes this much easier to control.

A high wattage soldering iron with temperature adjustment is the best choice for precision work. Get a soldering iron with several sizes of replaceable tips for different soldering applications. Having a good iron makes soldering with lead free easier because of the higher melting point. It also helps to keep the dwell time as short as possible reducing damage to components caused by excessive heat.

Choosing the correct size tip for the job is perhaps the most important part for a new person learning to solder. Lead-free is less forgiving and the right tip will go a long way in preventing defects.

Using a tip that is too small will take longer, abuse the tip, and will not efficiently transfer heat to the joint. A small tip will seem too cold or too slow.

Using a tip that is too large will damage the circuit board, over heat and damage the parts, and burn off the flux too soon causing a bad joint.

Use tips that are designed for lead-free. Tips designed for lead free will have the longest life. The iron temperature should be set to 700-800F. Do not use pressure to compensate for lack of wetting and heat transfer; this will cause damage to the circuit board. Heat transfer is optimized by providing the best contact area.

Differences from tin/lead soldering

Tin/lead solder should not be mixed with lead free solder because it decreases the strength of the joint. Lead free parts can be used with tin/lead solder. You should try ordering all parts, ICs, resistors, caps, proto boards, etc. lead free even if you are not using lead free solder yet. This will ease the conversion for you in the future. Consumables such as flux and tip cleaner should be certified for lead free soldering. Flux will need to withstand higher temperatures and longer dwell times, and some tip cleaners have tin/lead solder in them that could contaminate the lead free solder joints.

Not all fluxes are capable of sustaining high soldering temperatures. Flux charring, called “black tip syndrome”, occurs when thermally incapable fluxes turn the tip black and make re-tinning nearly impossible. Heat transfer is severely reduced when this happens. Buying compatible flux is key.

As we’ve said many times: you’ll need to set your solder iron slightly higher temperature than you are used to. You will also notice that slightly longer dwell times are needed because of higher melting points. Wetting or spread is also a little slower when compared to tin/lead. The resulting lead free solder joints will appear slightly grainy and dull compared to shiny tin/lead.

The iron must be kept clean and fully coated with the solder alloy, otherwise at the higher temps oxidation can occur. Solder tips will need to be cleaned and tinned more frequently. Use a wet sponge for cleaning and keep your tip tinned by adding a small amount of solder. In general, all tips will have a reduced life when using lead free alloys.

Lead free solder is more prone to solder bridges (shorts). Tin whisker growth is also possible with high tin alloys, but is poorly understood.

The temperatures required make lead free soldering a different experience, but not out of reach. If you can solder with tin/lead solder, you can solder lead free. If you are having problems soldering, maybe some of the tips here will help. Remember, soldering takes practice; solder, desolder, resolder some old circuit boards from computers or consumer electronics before attempting a project. Otherwise you can’t expect a perfect outcome. Knowledge, practice and experience will provide the consistency required for excellent hand soldering results. Please share any experiences you have working lead free.

Old computer mice are being abandoned in droves. They’re tossed out because of dirt, obsolescence, or for being entirely too beige. Anyone who has a computer usually has more than one mouse and you can get them for pennies, if not free just for asking. Fortunately for the discriminating (read: cheap) hacker, these little widgets are chock-full of project parts. Today’s How-To will dissect a computer mouse, extract the useful parts, and give some ideas about how to use them.

Here we have a standard PS2 mouse; a USB mouse will look pretty much the same. We’ll talk about optical mice later on.

Lets open it up. First, take out the mouse ball. Then there will be one or more screws on the bottom side that need to come out. Screws are sometimes hidden under the rubber pads.

The first thing to notice is the cable connector. Most mice have a very convenient plug for the cable, instead of soldering it onto the board. That’s the first usable part: a 4 (or 6) conductor cable with a nice plug on one end. The socket can be removed from the PCB and used in other projects.

With the cord out of the way, we can start pulling out parts. First thing that pops off is the mouse wheel. Yes, it’s just a big rubber wheel. If you’re annoyed by the mouse wheel’s clicking noise, you can silence it. There are at least two micro-switches and usually a third one under the mouse wheel which can be used for bump sensors or buttons.

Next thing to take out are the two plastic slotted discs. They’re the encoder wheels. They turn whenever the mouse moves and interrupt an IR beam, producing pulses. It used to be that precision encoder wheels were pretty expensive, but not anymore. Every single (non-optical) mouse comes with a pair built in.

On either side of the encoder wheel are some little boxes. One side is an IR emitter, and the other side is a pair of IR detectors. Sometimes the emitters and detectors will be one complete unit. A pair of detectors is used because with 2 detectors slightly offset, it generates quadrature encoding, so that mouse knows the direction of rotation.

These IR emitters and detectors are fairly modular pieces when it comes to hacking and can be removed with some careful desoldering. It is a good idea to use a multimeter to see what kind of voltage is going to them before removing them. They are probably TTL parts, because mice are powered by 5v, but sometimes they are an even lower voltage. The emitter/detector pair by itself can be interfaced directly. Those parts alone can be used for a proximity sensor or for a line following robot.

Add an encoder wheel and this sensor setup has lots of uses. From a tachometer, to a wind speed indicator, to sensing a robot’s speed, this will do it. The quadrature output (with some decoding) can be used to measure distance, direction, and speed.

One tricky thing about using the encoder with the IR sensor is getting the emitter to line up with the detector(s). No problem: instead of desoldering the parts from the PCB, use a rotary tool to cut off the little piece of PCB that has the sensors on it (already lined up). Wires can then be soldered to the pins/traces on the other side. If holding the encoder wheel in place is a problem, a hunk of the mouse casing can be used with it. Be sure to leave enough PCB to keep it stable on the mouse casing.

This is a picture of an encoder wheel with quadrature from a PS2 mouse on a small robot. Rather than make custom parts, the mouse is carved up and the whole assembly is fitted to the motor axis.

What’s left to salvage on the mouse? The sensors for the mouse wheel. Depending on the model, the mouse wheel movement may be sensed with switches or a low resolution encoder, suitable for measuring slow rotation.

The final bit is the mouse controller chip. At first thought it seems pretty useless: it’s a single purpose part made specifically to run a computer mouse and nothing else. However, if your controller chip isn’t an anonymous blob, the datasheet could be very enlightening. Octopart can help find datasheets based on the chip’s part number. This (PDF) is a typical datasheet for a mouse controller.

This specific part does a number of useful things:

• decodes the quadrature input from the encoders
• keeps a running count of the number of encoder pulses in a set of registers
• filters out jitter
• debounces the micro-switches and keeps track of their state
• packetizes the information and sends it up the cord.

For a PS2 mouse, getting at these features is not too difficult. The PS2 protocol is pretty friendly, even for microcontrollers. Here’s an example of interfacing a microcontroller with a mouse. For USB mice, check the controller’s datasheet to see if it can do both PS2 and USB; with older mice there’s a decent chance it does. While pure USB is not very easy to talk to with a microcontroller, it’s really easy to hook to a PC (with the right software).

We promised a look at optical mice. Optical mice do not have any rotary encoders. There are still some switches and a low-res encoder for the mouse wheel. What an optical mouse has in it is a mini-camera, lights, and lenses. The light is probably a fairly standard LED, although they tend to be bright, and the lenses are purpose built. However, it is possible to interface directly to the mini-camera or use it as a really poor scanner.

We hope this How-To has sparked some ideas and that your obsolete mouse won’t seem as useless anymore.

This week’s How-To comes from our newest contributor: Logan Williams.

This simple guide will show you how to build a digital synthesizer that generates and manipulates square waves. Your synthesizer will have one oscillator, which produces a variable pitch controlled by a potentiometer, as well as an LFO which modulates that pitch at a variable frequency. The part count for this project is quite low, and it can be built for under $20.

Finding the Parts

The first step in building this digital synthesizer is to procure the parts that you will need. Most of these can be bought at RadioShack, but RadioShack’s prices are often much more expensive than ordering online. All of the parts for this project can be purchased at Jameco, Digi-Key, or Mouser. We’ve provided Jameco part numbers below. If you don’t mind waiting, this is the best way to order parts.

Not Pictured

Tools

Note: The potentiometers and audio jack must be either taped or soldered to 22 AWG solid core wire. Soldering is highly recommended, as it produces a more secure connection.

Creating an oscillator

Before we can begin with the digital synthesizer, we must generate the correct voltage. Most of you will be familiar with using a 7805 5V voltage regulator. It is very simple; connect the +9V from the battery to the left hand pin, ground the middle pin, and the right hand is +5V.

The most basic circuit in any synthesizer is the oscillator. A square wave oscillator constantly alternates between two voltages, in this case +5V and 0V. We have a logic inverter to create this, which operates quite simply; if it is given +5V in (a logic 1), it give
s 0V out
(a logic 0) and if it is given a logic 0, it gives a logic 1 as output. When the input and output are connected together, it will oscillate rapidly between those two values: a 0 goes in, comes out as a 1, goes in, comes out as a 0, and so on.

The problem is that it oscillates much too fast. A resistor capacitor (RC) delay circuit can be added to slow it down. This forces the output current to charge the capacitor before it can pass through to the input. The resulting brief delay slows the oscillations to audible frequencies.

To build the oscillator, assemble the schematic below on a breadboard.

When done, the oscillator should look something like this:

Connect one side of the audio jack to 0V and the other side to the output, and it will sound like this:

Controlling the oscillator

We can make things more interesting by allowing the user to change the frequency. We replace the constant resistor R1 with a potentiometer, such as the 100K R2. This is a simple change to do, and is reflected in this altered schematic.

Now the oscillator sounds like this:

Much more interesting. Try playing an actual song, if you dare.

Duty cycle adjustment

We can add some basic timbre control to make the oscillator more interesting. The duty cycle of a square wave is how long it spends at logic 1 vs. at logic 0. For example, a wave that spends 1 ms at +5V and 1ms at 0V per cycle would have a 50% duty cycle. 1.5 ms at +5V and 0.5 ms at 0V would be a 75% duty cycle. To adjust the wave’s duty cycle, we can add another potentiometer and diode to the circuit. When the input is high and the output is low, current will be able to flow through both potentiometers, decreasing the amount of time it takes to charge the capacitor, and increasing the duty cycle.

It should sound like this when completed:

Creating an LFO

A low-frequency oscillator (LFO) is an oscillator that oscillates very slowly, from 1 to 100 cycles per second. We will use an LFO to alternate the pitch of our oscillator between two different frequencies. This can be used for siren like sound effects, timbre control, or musical sequences.

The circuit to control the LFO is slightly more complex than the ones we have used before. Because it uses a capacitor with 10x the capacitance, and a potentiometer with 10x the resistance, the oscillations are 100x slower than our first oscillator. The LFO connects to the gate of the IRF 510 MOSFET transistor. When the output of the LFO is +5V, the transistor connects its source and drain pins. With these pins connected, current can flow through the second potentiometer, increasing the pitch. When the LFO returns to 0V, the potentiometer is disconnected, and the pitch drops back to its original level.

There are quite a number of sounds that can be produced with the LFO, such as this:

and this:

Conclusion

You have now made your own simple digital synthesizer. Keep experimenting with different control methods. The frequency is adjusted with just resistance, so almost anything can be used for an input. Try a photocell, or a flex sensor. Try combining the LFO and the duty cycle adjustment. Try using it to actually make music! We’d love to see what you come up with.

If you want to keep your money, I’d avoid RadioShack as much as possible. When you’re stuck because you can’t find a freaking 10kohm resistor, it’s fine, but the markup on their low quality parts is insane-their clearance prices aren’t too bad. As much as people bag on RadioShack, just remember that nobody else bothers to sell electronic parts in the middle of nowhere.

Shipping can eat your project budget quicker than anything else. It’s the reason that I’m sometimes willing to pay $1 for $.05 in resistors at RadioShack. When I’m buying parts, I try to buy from a single supplier if possible to maximize my parts budget.

Stocking up on parts in bulk can help make projects extra affordable later on. Buying a quantity of resistors, capacitors, PNP and NPN transistors and a decent supply of linear voltage regulators will save you a fair amount of money later on. I love it when I can build a $30 project for the cost of a proto-board and an odd capacitor.

Just about every electronics component manufacturer will provide free samples on request. That’s right – free. It’s usually just a matter of creating an account on the manufacturers web site and selecting the components you need. As a rule, I don’t mention when I’ve sampled parts for a project. Seriously, they’ll get a little suspicious if 100 people suddenly sample the exact same parts. Samples aren’t limited to semiconductor companies. [ladyada] has a nice list of sample providers, including enclosures and connectors.

Digi-Key carries just about every part you can think of. These guys prefer to sell large quantities, but they’re happy to take small orders. Orders are shipped out fast, but they’ll tack on an extra $5 fee if your order is under $25. Even if you’re not ordering, they usually have data sheets linked for every part they carry online. If you’re wiling to jump through the hoops, you can even create a parts order that’s linkable from your website – it can make it much easier to share a project with others, but I usually find that a few part numbers get deprecated as time goes by. Oh, and they’ll send you a massive parts catalog that’s handy for parts hunting and brain storming.

Mouser Electronics is one of my favorite suppliers these days. They have reasonable shipping options and are fast with UPS ground orders showing up at my house within two days. Their inventory isn’t always the best, but substitution parts are usually easy to find because the online catalog links to web enabled PDF pages from their print catalog. It makes cross-referencing very easy. Like Digi-Key, they’ll send you a massive parts catalog to shove under your monitor.

Futurlec is a great place to get incredibly cheap parts, but you won’t be seeing your order for about a month (ok, so my last order showed up after three weeks). I suggest stocking up on connector headers and resistors. I haven’t had to make a late night resistor run in a couple of years thanks to these guys.

Sparkfun electronics is like a candy shop for Hack-A-Day readers. They carry higher end parts like GPS units, GMRS modules and micro controller programmers. Pricing varies a bit, but I can always find something interesting there. If you prefer professionally made PC Boards, they even put together an inexpensive PC Board service.

ebay is one of my favorite places to shop for parts. It’s a great place to buy brand new $150 stepper motors for $20 or hunt down funky, hackable hardware. People certainly try to sell single components, but it’s usually not worth the effort.

Salvaging parts is the absolute cheapest method for parts shopping. Thanks to custom ICs and SMD parts, newer electronics don’t normally have much in the way of salvage value. On the other hand, older hardware is a great source for parts. My current favorite salvage source is the dot matrix printer. They’re easy to take apart, have nice power supplies, and they’re loaded with quality heat sinks, wiring, connectors, hardened steel rods, and stepper motors. The bigger the dot matrix printer, the bigger the stepper motor. If you can score a few of the same model, you’ll end up with a few matched sets. People hate throwing them away, so they’re easy to get for free.

Lack of availability can be a problem, but obsolete parts are another way to keep costs down. Originally, the UCN5804B stepper driver I used for the cutting board CNC machine cost about $16 each. Now that they’re deprecated, they can be had for about $5 each.

Grab bags are another good way to save money. They’re usually full of loose parts that’ll have to be identified, but they’re cheap. The guys over at uchobby put together a nice how-to on sorting them.

Thanks to the movement from mail order to internet suppliers, the parts company scene is huge. There are loads of production part and surplus companies around. Here’s a quick list of shops that’ll probably be useful if you’re looking for parts.

Digi-Key electronics
Mouser electronics
Futurlec
Sparkfun electronics
eBay
All Electronics
BG Micro
American Science & Surplus
Goldmine Electronics
MPJA Online
MCM Electronics
Parts Express

Got a favorite shop? Drop the link in the comments and I’ll add it to the list.

Having the right tools and workspace are key to successful soldering. The actual technique is pretty simple. We will cover all the basic tools you need, the key to good soldering, and how to undo your mistakes or harvest components from old hardware.

The first thing you’ll need is a decent soldering iron. Weller makes a decent product, but RadioShack’s are dirt cheap if you’re in a hurry. My favorite iron was a temperature controlled Tenma with LED temp display (sadly lost from a crappy storage unit along with my oscilloscope).

Most soldering stations come with a sponge; they get lost and they tend to hold onto bits of solder. I actually prefer to use a paper towel instead. Either way, wet it down and give it a squeeze so it’s not sopping wet. If it dries out, it’ll burn when you wipe your iron on it.

Buying the right kind of solder is just as important. It comes in various thicknesses, metal alloys, and core types. I won’t get very deep into the alloys. Generally, you want 60/40 (60% tin, 40% lead). Most modern electronics are lead free, but for hobby work lead is fine. Just wash your hands when you’re done! The solder produced for plumbing work is usually very thick (left hand side) and has a solid metal core (or worse: acid core). For electronics work, you’ll definitely need rosin core. The rosin acts as flux for the solder, allowing it to flow onto and attach to the metal. You can certainly use liquid flux/rosin, but it’s usually not easy to find locally. For thickness, I always buy the thinnest rosin core I can find. To sum up: you want thin, rosin core, 60/40 solder.

Not all iron tips are created equal. For fine work, I always reach for my 15 watt Weller pencil iron. It has the smallest tip I could find, and I ground an even finer point on the tip with my rotary tool. The bigger iron is an inexpensive RadioShack station that I keep in my office to handle favors for coworkers.

Every so often, the tip of a soldering iron needs a little maintenance. If the end of the iron isn’t tinned, as in bright and shiny when you wipe it down, you’ll have a hard time getting solder to melt. Think of this stuff as a sort of pumice stone for your iron. Heat the iron up and rub the tip in the cleaner. The cleaner will melt a bit and your soldering iron should work better than ever.

Securely holding the work piece is important, but your hands will be busy with the iron and solder. My current favorite tool is this Panavise Jr. which runs about $25. Props to Ladyada for unknowingly turning me onto Panavise products. If you need something cheaper, you can score a set of helping hands – it’s set of alligator clips connected to a weighted base. They work great and I still use them for smaller soldering projects.

Some projects require extra fine attention to detail. A giant magnifying glass lamp comes in handy when visually inspecting for shorts and dealing with surface mount problems (I inherited this one one from my grandmother). You’ll be fine without one, but they’re great when you need to work on really small components or when your eyes are getting tired.

For one-off projects, prototyping boards from RadioShack are handy. They’re cheap, easy to get, and making a connection is as simple as bridging your solder across the copper pads.

Before investing your time soldering parts together, it’s a good idea to prototype your circuit. Breadboards like these are great for preventing frustration later on. When I tried to buy my first one, I was about 10 years old. Nobody knew what the hell I was talking about and the local RadioShack apparently didn’t keep them in stock. People at RadioShack kept trying to sell me kitchen cutting boards. After about a year of wondering if [Forrest Mims] was insane, I finally visited another RadioShack that actually had them.

Don’t bake your bits. Passive components like resistors or small ceramic capacitors don’t usually suffer any problems from being heated up, but you should still pay attention to how long you’ve been cooking them with your soldering iron. If you’re having problems getting a solder joint just right, let the parts rest for a few minutes so they have a chance to cool off between soldering rounds.

Integrated circuits like this logic chip are usually far more sensitive to heat and static than passive components. Sockets are cheap insurance against blowing a chip.

RadioShack sells the small red handled clip as a heat sink. It’s okay, but a generic hemostat like the one above works and holds on even better. They’re also great for saving your finger tips from burns by holding wires in place while you solder them.

To successfully solder a component, don’t melt the solder on the iron. Put the iron against the copper on the board (solder pad) and the component you want to attach. Give the iron a moment to heat up both of them. Then melt the solder on the component and, if needed the copper pad.

Do not melt the solder on the tip of the iron. Sometimes it’s necessary to melt a small amount on the iron to facilitate heat transfer, but to achieve a good connection, you want the solder to melt and flow onto the component leads.

Heat up the component with the iron just before applying solder!

Once the joint is good, the soldering iron can be used to remove small amou
nts of excess solder from the joint.

Wipe the solder and burn rosin off by pulling the tip across your wet sponge or paper towel.

The joint should be good if the solder flowed onto both the copper pad and the wire lead of the component.

Now you’ll need to trim down the excess wire lead of the component. If you use diagonal cutters, the piece you cut off will probably fly through the air. These flat cutters are my favorite: the metal wire stays still and the resulting edge isn’t nearly as sharp.

Nobody’s perfect. Sometimes we need to remove a bad component or undo a mistake. Desoldering braid works sort of like a sponge for excess solder.

To desolder something, just place the braid over the target and apply your soldering iron over the top. The heat should transfer through the braid and the melted solder will flow onto the the copper like oil though a wick. For larger amounts of solder, I normally pull out my bigger iron. For small amounts, even the pencil iron does the trick.

For larger desoldering jobs, like recovering components, a desoldering iron works wonders. The hotter the better, so let it warm up for a while before using it.

Compress the bulb with your thumb before you touch the board with the iron.

Once it’s in position, give it a moment the heat the solder and release the bulb. The bulb with suck up the solder through the hollow tip. Larger components might take a few hits, but smaller ones usually only take a single pull.

We’ve covered all the basics: the tools, soldering and desoldering. If you’re looking for a good starter project, I highly suggest taking a shot at making your own headphone amplifier. I built this one from RadioShack parts (I had some high end opamps in my parts bin). It’s a rewarding, low cost project. If you want an even more illustrated guide, check out these basic videos from NASA or even this collection of videos from Solder.net.