The software setup for my new HTPC started with a clean install of Ubuntu 9.10. This went without a hitch and it was time to install the various software packages that I use to get my system in working order.

Network Sharing

• Samba (located in the System -> Administration menu after installation)

In the Ubuntu repository this is called the system-config-samba package. This is a great GUI tool for setting up shares on a Windows network and allows me to view all the content on my HTPC on my Windows machines. Just input your Workgroup, what you want to share and who is allowed to view it. This tool makes this process much easier than editing configuration files. One thing that confused me at first was setting up user access; make sure to include the computer name of the user in the "Windows Username" field. For example "joe" didn't work, but "DESKTOP\joe" did.

Backup

• Scheduled Tasks (located in the System Tools menu after installation)

Called gnome-schedule in the repository this utility allows me to run a backup script at a particular time. This is basically a GUI frontend for CRON and therefore much easier for a Linux novice like myself. I run a RSYNC script every night at 2AM which synchronizes the hard drive containing my media archive with another hard drive. I have found this a better backup solution than having a RAID array because it doesn't rely on any controller hardware or software. If one of the drives fails I can just replace it and copy the files to the new one. If I want to put the hard drives in another machine I can just take them out and plug them in, no other configuration is necessary. I realize there are drawbacks to this system, but I prefer something that I understand and know how to fix as opposed to other solutions that I have tried that have failed and cannot be fixed (ie. the Drobo).

Media Playback

• VLC - media player
• Miro - RSS media aggregator/player
• XBMC - media center
• Boxee - media center based on XBMC but with web integration

This is the standard media grabbing and playback package I have been using for a while now. I use VLC whenever I'm in keyboard and mouse mode to play video and audio files. Miro isn't perfect, but it's better than any other media aggregator I have tried. XBMC is fantastic for local playback but it can't pull content from the web like Boxee, however, I prefer XBMC's simpler interface. Both XBMC and Boxee can be controlled via remote control. In the past Boxee was somewhat finicky when it came to your audio and video settings, but I have found the new Beta version much more stable.

 Bittorrent

• Deluge - my favorite torrent client, has the right balance of features and simplicity

Remote Control

• LIRC - configured this for my Windows Media Center remote and it integrated perfectly with XBMC & Boxee

Accessories

• GNOME Do - an awesome tool much like Quicksilver on the Mac, only for the GNOME desktop
• pyRenamer - a fantastic, simple tool for renaming lots of files quickly

This setup served me well on my Studio Hybrid HTPC and is performing equally well on my new machine. I frequently try different software packages, but these core programs are always present on my home theater box.

The following were my goals for my HTPC/media server build:

• Storage Expandability - plenty of internal 3.5" slots so I can reuse my current content storage drives and add more as needed in the future
• Adequate Onboard Video - although not as powerful as nVidia's or ATI's products, Intel's integrated graphics are fine for home theater use when paired with a decent CPU, they also use less power, and their Linux compatibility is generally better
• Low Power - this system will be on 24 hours a day so it needs to be as efficient as possible
• Quiet - this will sit next to my TV so it has to be as quiet as possible

Parts

• Antec Mini P180 Case (MicroATX Mini Tower)
• Antec Earthwatts Green 380W Power Supply
• Intel BOXDB43LD Motherboard (MicroATX, X4500 graphics, DVI, 6 SATA ports, 6 channel audio)
• Intel Celeron E3300 CPU (2.5 GHz, Dual Core)
• G.Skill DDR2 800 RAM (2GB)
• LG 22x DVD Burner
• Xigmatek HDT-SD964 CPU Cooler (with XIGMATEK ACK-I7363 mounting kit)

The Antec Mini P180 has 5 internal hard drive bays, plenty of ventilation (120mm & 200mm fans) and sound reducing panels. While this case is much larger than either of my previous HTPCs, I was more than willing to sacrifice space for a better all-around system. The Intel BOXDB43LD motherboard has decent onboard graphics (an upgrade over the Studio Hybrid's X3100), plenty of SATA ports for storage expansion and a decent assortment of AV ports. The Celeron E3300 processor fits my requirements for a processor that is cheap, powerful enough, and uses relatively little electricity. In order to make this build as quiet as possible I decided to use a fanless CPU heatsink. This is possible because the thermal dissipation required by the Celeron E3300 (65W) is low, the heatsink I chose is fairly large, and it should get plenty of airflow from the two case fans even when they are run at their lowest setting.

Assembly

The build for this machine was fairly straightforward. The case has enough room to creatively route cables behind the motherboard to minimize air blockage. I mounted the DVD burner on the bottom because the top slot's depth is limited by the huge 200mm top fan. I also rotated the CPU's heatsink from its normal orientation to take advantage of the top fan's airflow.

In order to take advantage of the SPDIF connection on the motherboard I built myself a coaxial SPDIF bracket using an old PCI bracket, a female RCA jack, some single conductor shielded cable, and a 3 pin female header. All you have to do is wire the center of the RCA jack to the pin of the header that connects to the signal pin on the motherboard using the center conductor of the cable. Then connect the cable's shield to the outside of the RCA jack and the ground pin of the motherboard header.

Input Devices

I have used this control setup for a while now and it works very well for me:

• Apple Wireless Keyboard - great Bluetooth keyboard
• Microsoft Explorer Mini Mouse - the BlueTrack system is the only one I've found that works consistently well on surfaces around a living room (wood, fabric, etc.), it has great wireless range & battery life, and this mouse is just the right size (small but not too small)
• Logitech Harmony remote (set to emulate Windows Media Center remote) - I use the Harmony 610 which isn't the most advanced Harmony remote, but it also isn't ridiculously expensive

Performance

Superficially this machine performs about the same as the Studio Hybrid. I noticed slightly less CPU utilization when playing videos. This could be attributed to the improved graphics processor, although the X4500 does not support CPU offloading of video decoding other than MPEG2.

Here's a performance comparison between this build (bold) and my Studio Hybrid (in parenthesis):

• Boot Time - 0:55 (1:00)
• CD Rip to FLAC time - 2:16 (3:41)
• FLAC to MP3 Compression time - 1:16 (1:31)

Based on this info it seems that the Celeron E3300 is somewhat more powerful than the Core 2 Duo T5800 in the Studio Hybrid. Some of the performance difference could be attributable to the slower hard drive in the Studio Hybrid and the CD ripping performance was definitely affected by the much faster DVD drive in the HTPC.

 Here's the power usage I observed during some typical usage scenarios:

• Idle - 42W
• Play 720p Video - 51W
• Play 1080p Video - 55W
• FLAC to MP3 Compression - 64W
• Average over a week - 45W

Previously I determined that my Studio Hybrid used an average of 27W over the course of a week. This is 40% less than the 45W used by my new HTPC, however it doesn't take into account the two external hard drives I had attached to the Studio Hybrid that are now mounted internally. When you add in the 5W each for the two hard drives that means the Studio Hybrid used only 18% less power than my new HTPC. That's pretty good considering this new system is faster and uses desktop instead of laptop components.

I am very happy that all of my attempts to keep this machine as quiet as possible were very successful. In terms of absolute volume its probably about the same as the Studio Hybrid, however, the fans on this system are much lower pitched and therefore blend into the background noise of the room a lot more. Another advantage is that when under heavy load the fans won't spin up and make more noise like they did on the Studio Hybrid because the default cooling is more than enough for the low level of heat generated by this system.

• Check out the Software portion of my HTPC.

In order to turn the photos into video I used Picasa, which has a great movie creation feature. The movie creator has a timelapse mode that allows you to set how fast you want the frames to last. I went with 1/8 of a second per frame since it makes the video fairly smooth while not blowing through the frames too fast. If I wanted to I could have reduced my timing interval by a third and made a video at the normal 24 frames per second for smoother video.

All you need to create this effect is a lens with a wide enough aperature to create fairly shallow depth of field (the wider the better). I used my Canon 50mm F1.4 lens. For the sleeve I used some cardstock I had laying around, some tape, and a razor blade to cut out the tree shape. 

The photos below show the difference between a picture taken with the cardboard sleeve on and off. I used a Christmas tree in the background to create the small points of light necessary for this effect. Due to the relatively low light necessary for this type of photography a tripod may also be necessary, although these photos were taken hand-held.

For this build I used a 3"x2"x1" RadioShack project box, a 3.5mm stereo socket, and two momentary pushbuttons. In accordance with how my Canon Rebel XSi works, I wired the shutter trigger (red pushbutton) to the tip of the socket and the focus trigger (black pushbutton) to the middle contact. Then I wired the other side of both switches to the shield of the socket. I am a big fan of using a socket for a project such as this since I can now use a cable of any length or configuration as long as it has a 3.5mm plug on the end that plugs into the box. This is an incredibly simple build that works great and should come in very handy for all my remote triggering needs.

The steps are as follows:

• Open the base image as the Background for the composite image
• Dark Layer
  • Open the dark stock image
  • Copy & paste it into a new layer in the composite image
  • Rename the layer Dark
  • Desaturate the original dark stock image
  • Adjust the levels of the dark stock image
  • Create a layer mask for the Dark layer
  • Copy the desaturated dark stock image
  • Paste it into the Dark layer's mask and anchor
• Light Layer
  • Open the light stock image   
  • Copy & paste it into a new layer in the composite image
  • Rename the layer Light
  • Desaturate the original light stock image
  • Invert the colors of the desaturated light stock image
  • Adjust the levels of the light stock image
  • Create a layer mask for the Light layer
  • Copy the desaturated & inverted light stock image
  • Paste it into the Light layer's mask and anchor
• Save the finished composite image

Below from left to right are the base image and three HDR photos I made using this method. The photos further to the right push the dynamic range further than the ones to the left:

This is a fun technique to play around with. Some photos, if taken properly in the right conditions, can gain a whole new dimension when they get a little HDR boost.  

This turned out to be a much harder search than I anticipated due mainly to my utter disgust with all things iPod (overpriced hardware locked to bloated proprietary software is not my idea of a good value). Unfortunately, in the years since my last mp3 player purchase the market has inexplicably gotten worse for non iPod users. In my opinion the only way for non Apple media players to compete with the iPod is to offer comparable features with more flexibility at lower prices. Based on the majority of the devices available, however, Apple's competition seems content to either aim for the low end of the market or add too many features while eschewing platform flexibility.

My requirements for a mp3 player are very reasonable, but apparently too hard for most manufacturers:

1. Universal Mass Storage compatible - being able to drag and drop files from any computer whether it runs Windows or Linux is a must
2. Non-Proprietary Power/Data port - the ability to use any standard USB cable to load files and charge the device is just plain handy
3. At least 16GB of storage - not huge, but big enough
4. Decent battery life - enough to use the device at work for a few days between charges

The Sony NWZ-E345 is just about perfect for me; it meets all of my main requirements, produces solid audio and is small and light. The best part, however, is that it only costs $100 for the 16GB model.            

Pros:

• Interface - nothing special, but it's intuitive and does the job
• Screen - bright, clear text, good color
• Controls - well laid out, clicky, dedicated volume rocker is nice
• Battery - lasts about 30 hours
• Value - 44% less than an iPod Nano
• Linux and Windows compatible
• Data & Charging via standard mini-USB port

Cons:

• Interface is not customizable
• Plastic - scratches easily and is a fingerprint magnet
• Power Off - just goes into standby, making it too easy to accidentally turn on

I have had the unit for over a week now and overall I am very happy with it. In my opinion the Sony NWZ-E345 is the perfect middle-of-the-road media device, offering a good set of features and large enough capacity for a great price.

This is a very easy project to undertake. All that is required is to disassemble the hard drive (you will need some Torx screwdrivers) and solder two wires to the appropriate contacts on the hard drive's read head. These wires are then attached to the speaker outputs of your amplifier (I used my vacuum tube amplifier to drive the speakers).

After playing with the finished speakers I found that if I restricted the read head's movement by trapping the speaker wires between the two magnets at the base of the head's armature (as shown) the speakers would produce much cleaner audio. By restricting the read head's movement I prevent it from vibrating against the platters which can cause annoying scratching and rattling sounds. The downside of this is that you can no longer see the head's armature move with the music, which is a pretty cool effect. Regardless of how you construct your own set, hard drive speakers sound best with music that contains a lot of treble. Check out the video below to hear how my speakers sound playing some Bach.

Key features to keep from the original were:

• Camera interface isolation
• Timing range options
• Battery or AC adapter power options
• Camera connection flexibility
• Manual controls

Additional features that I wanted to add were the following:

• Power supply flexibility
• LCD readout
• Start/Stop the timing cycle

In order to maintain what worked best in the original design I simply copied it directly over to the new version. I used the same relay isolation for shutter triggering, as well as hard-wired pushbuttons for manual focus and shutter control. I also used the same 3.5mm jack to connect to the camera as the original. For power I decided to use a coaxial power jack as I had previously but this time I did not place a battery inside the enclosure. Instead, I made an adapter cable with an N style coaxial DC power plug on one end and a USB plug on the other end. With this cable I can power my new intervalometer from any 5V USB power source (PCs, wall adapters, MintyBoost, etc). In order to keep this build as simple and inexpensive as possible I decided to use the Arduino Pro and a basic LCD for a total cost of $36. The Arduino Pro is the same as a standard Arduino, except it uses all surface-mount components and has no USB interface. This keeps the cost down and reduces the board size. The LCD was simple to wire requiring only +5V, ground, 6 data lines and a dimmer potentiometer input. The final features were all implemented in the Arduino code. 

I ran into a few problems while developing the code for this project:

• How to adjust the timing interval value
• How to start & stop the timing cycle
• How to switch timing ranges

For adjusting the timing interval I had originally planned to use pushbuttons, however, after playing with the idea I decided against it. I found that it was much quicker and more user friendly to use a potentiometer as a virtual selector switch. In order to do this I used the map function, to divide up the potentiometer's analog input values into the specified number of steps.

Starting and stopping the timing cycle was not as easy as it first appeared because the simplest way to wait a specific amount of time between events is to use the delay function. The problem with this is that while the program is delaying for the set amount of time, no other commands are being run and inputs are not recognized. To get around this I used a technique I found on the Arduino website which blinks an LED without using the delay function. Instead it sets a preset interval and then checks how much time has past using the millis function until enough time has gone by to trigger the desired event. This allows the processor to keep scanning the code while the timing cycle is taking place. Now if I want to cancel the timing cycle I can do so without resetting the Arduino.

To switch timing ranges I used this clever piece of code that allows you to use one button for two functions. When the button is pressed the Arduino keeps track of how long it was pressed. For short presses it performs one function and for longer presses it does another. I used this method to implement both timing range switching as well as toggling between set mode and timing mode as shown in the video below.

After getting all of my code together I assembled my new intervalometer in a 6"X4"X2" project box from Radioshack. This is somewhat oversized for these purposes, but it's cheap and readily available. Overall I am very pleased with this project. The responsiveness of the interface is very good and it triggers my camera shutter perfectly. The two timing ranges I preset in the unit are 5-60 seconds in 5 second steps and 30 seconds to 10 minutes in 30 second steps. These should cover the most common intervals I will use, and I can change them at any time if I have to. This is by far the most complicated Arduino coding that I have done and it was a great learning experience. Check out the video below for a demonstration of the device.

My finished Arduino code is shown below, or you can download the sketch here. Note: the LCD requires the updated LiquidCrystal Library, checkout this tutorial if you are using version 0016 or earlier of the Arduino software.

#include <LiquidCrystal.h>                //library for LCD control
// LiquidCrystal display with:
// RS, EN, D4, D5, D6, D7
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);    //Set which LCD pins are used for data
//I-O setup
const int potentiometer = 0;              //Potentiometer analog input pin
const int mode = 2;                       //Mode button input pin
const int shutter = 3;                    //Shutter relay output pin
//Variables
long interval = 5000;                      //time between shutter presses
long previousMillis = 0;                   //previous millisecond value
int hold = 1000;                           //time shutter should be held open
int M = 0;                                 //Mode button state
int Mstate = 0;                            //previous Mode button state
int StartSet = 0;                          //Mode state
int pot;                                   //potentiometer reading
long range;                                //potentiometer position
int count = 0;                             //picture count
int ModeSW = 0;                           //Low-High set mode toggle
//Press & Hold variables
#define debounce 50                       // ms debounce period to prevent flickering when pressing or releasing the button
#define holdTime 2500                     // ms hold period: how long to wait for press+hold event
long btnDnTime;                           // time the button was pressed down
long btnUpTime;                           // time the button was released
boolean ignoreUp = false;                 // whether to ignore the button release because the click+hold was triggered

//Initialize I-O
void setup() {                    
  pinMode(shutter, OUTPUT);             
  pinMode(mode, INPUT);
  lcd.begin(16, 2);                        //set LCD for 16 columns & 2 rows of display
}

void loop(){
  M = digitalRead(mode);                   //read Mode button state     
  //Test for button pressed and store the down time
  if (M == HIGH && Mstate == LOW && (millis() - btnUpTime) > long(debounce))
  {
    btnDnTime = millis();
  }
  //Test for button release and store the up time
  if (M == LOW && Mstate == HIGH && (millis() - btnDnTime) > long(debounce))
  {
    if (ignoreUp == false) ModeSW = !ModeSW;      //test if Low-High set mode should be toggled
    else ignoreUp = false;
    btnUpTime = millis();
  }
  //Test for button held down for longer than the hold time
  if (M == HIGH && (millis() - btnDnTime) > long(holdTime))
  {
    StartSet = !StartSet;                  //toggle Set mode to Timing mode or vice versa
    ignoreUp = true;
    btnDnTime = millis();
  }
  Mstate = M;
  //Test for Set Mode
  if(StartSet == LOW){           
    lcd.home();                             //set cursor to LCD column 1, row 1
    lcd.print("Set Mode   ");               //display "Set Mode" on LCD                   
    count = 0;                              //reset picture count
    if(ModeSW == LOW) LowRange();           //test Low-High set mode
    else HighRange();
  }
  //Test for Timing Mode
  else{
    lcd.home();                             //set cursor to LCD column 1, row 1
    lcd.print("Timing Mode");               //display "Timing Mode" on LCD
    Shutter();                              //call Shutter triggering function
    lcd.setCursor(0, 1);                    //set cursor to LCD column 1, row 2
    lcd.print(count);                       //display picture count number on LCD
    lcd.print(" Pictures   ");              //display "Pictures" on LCD
  }
}

//Low Set Mode function
long LowRange(){
  long seconds;                             //shutter timing interval in seconds
  pot = analogRead(potentiometer);          //read potentiometer value
  range = map(pot, 0, 1023, 12, 1);         //divide potentiometer range into 5 second steps
  interval = 5000 * range;                  //convert steps into 60 second range in milliseconds
  seconds = interval/1000;                  //convert milliseconds to seconds
  lcd.setCursor(0, 1);                      //set cursor to LCD column 1, row 2
  lcd.print(seconds);                       //display shutter timing interval in seconds on LCD
  lcd.print(" seconds    ");                //display "seconds" on LCD
  return interval;                          //return shutter timing interval value to loop
}

//High Set Mode function
long HighRange(){
  float minutes;                            //shutter timing interval in minutes
  pot = analogRead(potentiometer);          //read potentiomenter value
  range = map(pot, 0, 1023, 20, 1);         //divide pot range into 30 second steps
  interval = 30000 * range;                 //convert steps into 10 minute range in milliseconds
  minutes = interval/60000;                 //convert milliseconds into minutes 
  lcd.setCursor(0, 1);                      //set cursor to LCD column 1, row 2
  lcd.print(minutes);                      //display shutter timing interval in minutes on LCD
  lcd.print(" minutes ");                  //display "minutes on LCD
  return interval;                          //return shutter timing interval value to loop
}

//Shutter triggering function
int Shutter(){
  //Test that timing interval has passed
  if((millis() - previousMillis) > interval){       
    previousMillis = millis();                      //save the last time shutter was triggered
    digitalWrite(shutter, HIGH);                    //trigger shutter relay coil
    delay(hold);                                    //wait preset shutter hold time
    digitalWrite(shutter, LOW);                    //release shutter relay coil
    ++count;                                      //increment picture count
    return count;                                   //return picture count value to loop
  }
  else return count;
}

Each panel produces 4.5 - 5 Volts at around 50mA 35mA. Since I had several of them I decided to build myself a modular solar panel system for additional flexibility. To build a more portable setup I wired two panels in parallel and glued them with silicone cement to a piece of 1/8" plexiglass to provide some support. The panel can then be velcroed to the Altoids tin and plugged into the charger board. This arrangement should be more or less equivalent to the single panel used in the original project. The second setup I made uses six panels in parallel to produce around 300mA 200mA, which should charge the battery much faster than the more portable version, while being somewhat bulkier.

The only other modification I made involved putting a piece of velcro on the battery to secure it to the charger board. Without this I found that the battery could easily rattle around in the Altoids tin. I haven't had a chance to charge this unit with either solar panel yet (I'll update when I do), since by the time I finished this it was already dark, but it does charge and operate properly using the charger board's mini-USB plug. Overall a fun and very useful project.