The other day I set myself to figuring out what the best way to make a portfolio website for my artwork. I hope that this guide can be of use to any artists or designers looking for an easy way to build out a portfolio. If you can get WordPress installed and have access to an FTP account then all you really need is a little love and patience and all will be well.

Thinking about how I would go about making such a site, it seemed ideal that it would use one of the preexisting content management systems like Drupal or WordPress. For me, the main requirements I had were: (1) a portfolio page with a bunch of thumbnails, (2) sub-pages where contact and other static information could published, and (3) easy content updating.

One good candidate I came up with was Zenphoto, a sample site of which you can find here. In some ways this would make a very good solution because the diversity of gallery themes give a certain latitude in how the images are presented. However, from what I could smell, Zenphoto is really lagging other CMS systems in terms of development and a range of themes\plugins. I therefore decided to move on.

The solution I finally settled on was a combination of WordPress and the Yet Another Photoblog Plugin. You can see the site I made here. It uses the Monolit theme pretty much out of the box. For general reference I will outline the changes I made to it for anyone who wants to adapt it for a similar purpose. First thing is first: install WordPress, Yet Another Photo Blog and Monolit. Dreamhost, my host, has a very nice one-click install that drops a WordPress installation and mysql database right on top of your domain making the setup of WordPress a breeze.

• Go to the YAPB settings and under Automatic Image Insertion, unselect “Activate automatic image rendering in general” otherwise two copies of each picture will appear on each page.
• Create a few posts with images in them and assign them the same category. This will group them together on the Archive page that we will create next and then hack into a Portfolio page.
• Create a page using the Archive template.
• Also create however many additional pages you may want to have (About, Contact, et cetera)

Now for a small dose of PHP editing:

• In the folder that you uploaded the monolit theme there will be a subfolder called config and in it a file called config.php; find it and open it. I think you will have to use an FTP client for this step as it will not appear in the Theme Editor portion of your WordPress UI. The first section should have a list of definitions that look something like: “define(‘MONOLIT_SET_ABOUT_WP_TITLE’, ‘about’);”. In this example ‘about’ is referring to a page title as it would appear in WordPress. Copy this line over a few times and change it to suit your needs [eg. define('MONOLIT_SET_CONTACT_WP_TITLE', 'contact');]
• Change the “define(‘MONOLIT_SET_COPYRIGHT)” string to alter the footer text of each page.
• In the Menu Configuration section add a define line for each of the pages that you referenced in the first WordPress Page Titles section and set them to show (1). Also show the latest page (this is the index) and the archive page.
• Take note of the other settings you can change in the config file for your reference and to tweak things later.
• Open the functions.php file. You can do this within the WordPress theme editor. Find the menu function (“function monolit_get_menuitems”). As you can see here, these if statements are calling the config file we just edited and looking to see if the pages referenced there are turned on (1) or off (0). Duplicate the “if (MONOLIT_SET_SHOW_ABOUT == 1) :” section as many times as necessary and alter the copies to cover the new pages that you referenced in the config section.
• Look for “latest_photo_link = buildLink($latest_photo_url, MSG_MENUITEM_LATEST);” Here if you change “MSG_MENUITEM_LATEST” to something like “Portfolio” it will alter the menu text accordingly.
• After you made these changes go back and view the site. If you have not actually created the pages that you referenced in config.php and in functions.php make them now. The links on the top of the blog should now all work.
• Now go to the archives link that you enabled. The theme is set up to show you an archive portal when you do that which lets you enter a variety of archives based on different criteria (date, author, category, etc). This is why it was useful to keep all the posts we made earlier in the same category. When you click on that category you will be taken to a page with thumbnails of the images in your post that will be sized and arranged according to the settings in config.php . By taking note of the direct address to this category archive page we can rewrite this archive portal to take us directly there.
• Open archives.php and replace it with this code:

<?php
$URL=”http://www.ARCHIVEPAGE”;
header (“Location: $URL”);
?>

• After doing this, clicking on the Archives link should just direct you to the category archive that has been selected. If you want this page to be your index, you can direct WordPress to automatically load it under Settings–>Reading–>Static front page
• To remove dates from the posts, check out the date exclusion WordPress plugin
• To add a contact form, there does not seem to be too much of a better way to go than this PHP Contact Form WordPress plugin
• Of course you can edit the CSS to your heart’s content to alter the formatting. But this is a good quick and dirty to build a portfolio website.

As you can see, the basic prototype of the circuit could not be simpler: just the LED and a 220ohm resistor to throttle back that 5V the arduino so lovingly sends forth.

The timing sequence that was needed to control the Nikon shutter release came from Big Mike. If you go over to his site, you will see a detailed tutorial on how to build this remote using a ATTiny2313 using the AVR programmer. The code you will need for the Arduino is as follows:

int outPin = 8; // digital pin 8

void setup()
{
pinMode(outPin, OUTPUT); // sets the digital pin as output
}

void oscillationWrite(int pin, int time) { // this function will cause the LED to flicker at approximately 38KHz
for(int i = 0; i <= time/26; i++) {
digitalWrite(pin, HIGH);
delayMicroseconds(13);
digitalWrite(pin, LOW);
delayMicroseconds(13);
}
}

void loop()
{
oscillationWrite(outPin, 2000); // sets the pin on 2250us
delayMicroseconds(27830); // sets the pin off 27600us
oscillationWrite(outPin, 390); // sets the pin on 650us
delayMicroseconds(1580); // sets the pin off 1375us
oscillationWrite(outPin, 410); // sets the pin on 575us
delayMicroseconds(3580); // sets the pin off 3350us
oscillationWrite(outPin, 400); // sets the pin on 650us

delayMicroseconds(63200); //wait 63ms

oscillationWrite(outPin, 2000); // sets the pin on 2250us
delayMicroseconds(27830); // sets the pin off 27600us
oscillationWrite(outPin, 390); // sets the pin on 650us
delayMicroseconds(1580); // sets the pin off 1375us
oscillationWrite(outPin, 410); // sets the pin on 575us
delayMicroseconds(3580); // sets the pin off 3350us
oscillationWrite(outPin, 400); // sets the pin on 650us

delay(1000); // the sequence needs to loop twice and then cease

}

The only thing worth pointing out here is that we needed to create the oscillationWrite function because the protocol for most IR device requires the light to oscillate at a frequency of roughly 20KHz. We achieve this by causing the LED to go high 13us then low for 13us whenever we are sending light to the device. The common wisdom is that manufactuers implemented this so that the sun could not trigger any remote control functions.

So this simple IR code should work with every camera supported by ML-L1 and ML-L3 Nikon remote controls such as D40, D40X, D50, D60, D70, D70s, D80, Coolpix 8400 8800.

Beyond just building another remote for myself, I am wondering what else can be done with this easy access to my camera’s shutter function. A few ideas might be

• Write a small web applet to trigger the camera.

• Time lapse photography

• Connect to biometric data to snap pictures of subject at moments of great stress or alarm

• To make a device for capturing high speed events (eg place a microphone by a balloon and use the sound peak from that to trigger the shutter of the camera).

• Set up a light continuity sensor in a public place and photograph people as they walk through it.

UPDATE: After some more testing with the code above using the microsecondDelay function I was only able to get somewhat sporadic success in getting the shutter to trigger. Matt at CiboMahto, however, created a library for the Arduino platform that instructs the Atmega168 directly with assembly commands and seems to work like a charm for the shutter trigger. At this point the only technical problem I am still having is keeping the camera live after fifty or so frames are shot, one every thirty seconds, using the remote.

[Matt at CiboMahto writes:] The most straightforward approach to this would be to take apart an existing remote and fire its button with a microcontroller. However, that didn’t sound like much of a challenge, so instead the goal became to train the micro to output the signals itself. A quick search fished out a well-documented solution by one San Bergmans. The routine is written in assembly to generate an accurate signal. I chose the Arduino as my platform, and figured out that it is pretty straightforward to include assembly inside of a C++ file. So, I ported San’s code to the Atmega168 that my Arduino is based on, and it appears to work quite swimmingly. The routine is wrapped up in a library, so using it is as simple as adding the library to your project and calling the Snap() function. There are a couple of caveats to this code,though: it (currently) only works on pin 12, and will only support the default clock frequency (16MHz?). Code after the break.

To use these, place them in a folder named NikonRemote, which should be located in the hardware/libraries/ section of your Arduino installation. Then, restart (or just start) the Arduino program, add the library to the project, and create the object in your sketch:

NikonRemote remote(12);

Whenever you want to trigger the camera, just do this:

remote.Snap();

Oh, and don’t forget to attach an IR LED to pin 12, with some sort of current-limiting resistor. Tip: You can test if the IR LED is in the correct orientation by powering it up and looking at it with a digital that has a live preview.

NikonRemote.h:

#ifndef NikonRemote_h
#define NikonRemote_h

#include "WConstants.h"

class NikonRemote {
  public:
    NikonRemote(unsigned int port);

    void Snap();

  private:
    unsigned int _port;
};
#endif

NikonRemote.cpp:

//
// NikonRemote
//
// This is an evil Arduino library that uses inline assembly to generate an IR
// signal capable of triggering a Nikon SLR camera.
//
// By Matt Mets, October, 2008.
//
// Adapted from San Bergman's 'ML-L1 / ML-L3 IR remote control replacement'
// http://www.sbprojects.com/projects/nikon/index.htm
//
// Note: At time of writing, it isn't clear what license it can be used under.
//       I will contact the author about this.
// Note: This is an incomplete implementation.  It requires the output LED to
//       be on pin 12.

#include "NikonRemote.h"

NikonRemote::NikonRemote(unsigned int port)
{
  pinMode(port, OUTPUT);
  _port = port;
}

void NikonRemote::Snap()
{
// Definitions:
// r16: port ON value
// r17: port OFF value
// r18: burst delay counter
// r19: burst counter
// r20: end delay counter
// r21: port mask

// 0x03: Port B input register
// 0x05: Port B output register

  asm volatile (

"\n\t cli"              // Disable interrupts

"\n\t push r16"         // Save context
"\n\t push r17"
"\n\t push r18"
"\n\t push r19"
"\n\t push r20"
"\n\t push r21"

"\n\t in   r16, 0x03"   // Calculate on and off port values
"\n\t ori  r16, 0x10"
"\n\t in   r17, 0x03"

"\n\t rjmp COMMAND"     // Jump to the command routine

"\nNEXTPULSE:"
"\n\t ldi r18, 68"      // Count to 9 for one low pulse
"\nSENDBURST:"          // Low period delay loop
"\n\t dec r18"
"\n\t brne SENDBURST"
"\n\t nop"
"\n\t out 0x05, r21"    // Set the output to mask
"\n\t ldi r18, 68"      // Count to 9 for one high pulse
"\nBURSTLOOP:"

"\n\t dec r18"
"\n\t brne BURSTLOOP"
"\n\t out 0x05, r17"    // Set the output low
"\n\t dec r19"          // Determine if another burst should be performed.
"\n\t brne NEXTPULSE"
"\n\t ret"

"\nCOMMAND:"

// 2000us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 76"      // count = 76
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"

// 28ms off
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 64"      // count = 64
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"

// 400us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 15"      // count = 15
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"

// 1580us off
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 60"      // count = 60
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"

// 400us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 15"      // count = 15
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"

// 3580us off
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 136"     // count = 136
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"

// 400us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 15"      // count = 15
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"

"\n\t pop  r21"         // Restore Context
"\n\t pop  r20"
"\n\t pop  r19"
"\n\t pop  r18"
"\n\t pop  r17"
"\n\t pop  r16"

"\n\t sei"              // Enable interrupts
"\n\t"
  );
}

Link