For a few months now, I’ve been toying with the idea of taking my experience in accelerometer-enabled nixie clock construction (see Mercury Retrograde) and leveraging it into the design of a high-quality kit. This meant jumping into the world of PCB design and manufacturing, which up until two months ago, was completely alien to me. So, to get started I designed a very simple numitron-based clock using IV-9 numitrons and had the board made using Sparkfun’s BatchPCB board service. Above is a photo of the final product.

BatchPCB has proven to be a wonderful and cost-effective service. I highly recommend it if you’re only prototyping one or two boards and don’t mind waiting a little longer for your order (the site quotes an average 3-4 week delivery time, but my first order arrived in 12 days).

I’ve already submitted a completely revised prototype board to BatchPCB that may be a candidate for the first clock kits. More details to follow, but suffice it to say that the clock kit will be as nice as I can manage for a first-time product. I’m spending as much time thinking about the case (milled aluminum, acrylic and hardwood) as I am about the circuit itself.

I have this peculiar fascination with obsolete display technologies like nixies and numitrons; they emanate a warm, inviting glow, they have a bit of heft, you can physically see how they work, and they’re nicely encased in glass. It’s little wonder, then, that my first “real” electronics project was a nixie clock. Nixies are fantastic eye candy, but they are also somewhat of a hassle to work with because they require a high-voltage power supply (180V) and something like the long-outdated TTL “power pig” 74141 to drive their respective cathodes. Recently, however, I got a hold of a bunch of Russian IV-9 “Numitrons” for additional, cheaper, clock projects — an easier-to-use display technology that doubles as a nice Nixie alternative. I use “Numitron” in quotes because the word Numitron is originally a trademarked name of RCA, the originator of Numitron technology (circa 1970), and what I have are cheap Russian knock-offs of the real thing. (Real RCA Numitrons currently cost about $10 a piece on eBay, whereas the IV-9 can be purchased in bulk for less than $1 per unit.)

If you’re at all familiar with common anode 7-segment LED displays, then working with like a Numitron shouldn’t prove too difficult. In fact, the procedure is pretty much the same — just substitute each individual LED in a 7-segment LED with a glowing filament (like an incandescent bulb) and you have a Numitron. And because they use a glowing filament, unlike LEDs, Numitrons do not require a current-limiting resistor on each cathode.

I read — somewhere — that the recommended max voltage for IV-9s is 4.2V. Standard Arduinos run at 5V, but a simple 1N4001 diode in series with the Numitron anode gives the exact 0.8V drop needed to achieve 4.2V.

In the video above I use an Allegro A6278 serial-parallel LED driver to drive each of the individual cathodes. Shift registers like these are a great way to conserve I/O pins on the Arduino (I always give out A6278s at my “Intro to Arduino” workshops) and they are not at all difficult to use, even for the beginner. This tutorial, which uses the popular 74HC595 will get you up and running with shift registers if you’ve never used them before. (Pay particular attention to the shiftOut() function provided in the code samples.) The A6278 works almost identically to the 74HC595, with the exception of an REXT pin on the A6278 that requires an external resistor for setting the desired current for the outputs. The beauty of this feature, however, is that for LED applications you need only 1 external resistor instead of the normal 7 (1 per cathode) you’d need with the 74HC595! A 900Ω resistor on the REXT pin, for instance, will give you a 20mA output on each output pin, exactly what you’d need for a red LED display.

IV-9s are readily available on eBay, so if this is a display technology that tickles your fancy, try picking up a few to hack around with on your next project.

The first-ever Gizmologi.st workshop — Intro to Arduino: Electronics for Artists, Tinkerers, Inventors and Hackers — will be taking place on August 8, 2009 at San Diego State University.

Photo by Todbot

Come join us on this all-day hacking session. This will be a great workshop for beginners to the DIY electronics world of microcontrollers, as well as for altruistic “old hands” looking to show off their skills and help the newcomers. If you’ve ever dreamed of building your own robot, UAV, home automation system, digital clock, synthesizer, portable gaming system, etc., but aren’t quite sure how to get started, then this is the workshop for you.

What You’ll Learn

We’ll cover as much as possible from the list below:

• Arduino basics: Getting up and running, basic Arduino programming, blinking an LED
• Beginning digital circuits: Using shift registers to control 7-segment LED displays and multiple LEDs simultaneously
• Sensor basics: Reading and acting on digital and analog sensors, including buttons, photocells, thermistors and maybe some more sophisticated sensors like ultrasonic range finders or heartrate monitors
• Communicating with PCs: Fundamentals of Arduino serial communication
• Controlling motors: Using relays to control motors and/or solenoids

Date/Time/Location/Cost

• Date: Saturday, August 8, 2009
• Time: 10AM to 5PM (or longer as desired/necessary)
• Location: SDSU Engineering Building, Room 300A
• Cost: $60.00 materials fee. (Includes Arduino Duemilanove, wiring, sensors, resistors, motors, LEDs, etc. that you get to keep. If you have your own Arduino, bring it for a $25 fee reduction.) Please bring cash or checks payable to “Sean Voisen.” This is a non-profit event. The cost is for the materials only.
• Parking: SDSU has a $1.00/hour parking fee. You may wish to take the trolley or bus to avoid paying for parking.

What to Bring

• A laptop running Windows, Mac OS X or Linux
• An A-B USB cable (the kind you usually find on a USB printer)
• A positive, can-do attitude

RSVP

Space is limited to 20 participants. Register by July 24, 2009.

NOTE: Registration for this event is now closed.

While working on a pigeon-based aerial photography solution as part of PigeonBlog for Beatriz da Costa, I wrote a library in C++ that allows the Arduino to communicate with the C328R camera over UART using the camera’s built-in communications protocol. Here’s a sample picture to prove that it works:

Sample C328R picture

The camera can take pictures in a variety of color depths (2- to 8-bit grayscale, 12- to 16-bit color, JPEG) and resolutions (80×64 to 640×480) with serial communication up to 115,200 baud. It’s fairly versatile and not terribly expensive (~$50) given the fact that it does a lot of work for you (i.e. on-board JPEG compression).

The rest of this post assumes that you have the camera and an Arduino Duemilanove (or similar) in hand. If you don’t, I suggest that you get them. You’re also going to need some type of external storage for the pictures, because the Arduino doesn’t provide any sufficient storage on-board. The sample code that follows assumes a 256KB Atmel SPI serial EEPROM or similar SPI EEPROM.

How to Use the Camera

Using the C328R camera involves a fairly straightforward issuance of commands. After power on, you essentially just have to synchronize with the camera, tell it what size and color-depth you want your pictures to be, and optionally set the byte size of the data packets it will send back to you (default 64 bytes), light frequency to use, etc. It looks something like this, assuming you want a JPEG photo:

1. Power on camera.
2. Issue “sync” command.
3. Issue “initial” command (tell the camera the desired color-depth, resolution, etc.).
4. Wait about 2 seconds for the camera to settle.
5. Issue “snapshot” command. This will tell the camera to take a snapshot and store it in its internal memory.
6. Issue “getPicture” command. The camera will then begin sending the JPEG image over serial in a series of data packets (default 64 bytes).
7. Take each data packet and store its image data sequentially in the EEPROM, until all image data has been retrieved. (A 640×480 JPEG can be upwards of 20KB. At 64 bytes a packet, this would be 320 individual data packets per photo.)

All of these commands are issued over a proprietary serial communications protocol. The C328R Arduino library takes care of all of this behind the scenes, and reduces the complexity to nothing more than a series of function calls.

Download the Library

You can download the camera library here. Standard Arduino library installation instructions apply.

Making the Connections

The camera should be powered at 3.3V, with the TX (yellow wire) connected to the RX pin on the Arduino, and the RX (green wire) connected to the TX pin on the Arduino. The wiring that comes with the camera is thin and stranded, so you may want to solder on some headers for a more robust electrical connection, especially if you plan on using a breadboard.

The SPI EEPROM, assuming you’re using an Atmel SPI EEPROM or another SPI EEPROM with the same pin layout, should be connected per the instructions found here.

An LED, with appropriate resistor, should be connected to pin 8. This will be used as an indicator LED to let you know when the Arduino is done writing the picture to the EEPROM.

Sample Code and Application

The following sample code operates in two parts: The first part captures a picture with the camera, stores it on an external EEPROM at address 0, then powers off the camera. The second part sends the JPEG image data from the EEPROM to the computer over USB, allowing a simple program written in Processing to read the data and save it to disk for viewing.

IMPORTANT NOTE: This sample code is designed primarily for testing and debugging purposes. Because the Arduino has only one hardware serial port, and the camera and computer (via USB) are both connected to that port, we use the indicator LED to notify us when the Arduino is done saving the data to the EEPROM and has powered off the camera. This way we know that any subsequent data being sent over serial is picture data that should be captured on the computer and saved to disk. By default, the code gives us 5 seconds to MANUALLY tell the Processing sketch to begin listening for and saving the serial data. You do this simply by pressing any key on the keyboard when the Processing sketch is running. After it is done reading the data, press any key again to write it to disk.

First up, the Arduino code. You will need to have the SPI library already installed. Save this as a sketch and upload it to your Arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

#include "CameraC328R.h"
#include "Spi.h"
 
#define LED_PIN 8
#define PAGE_SIZE 64
#define BAUD 38400
 
// EEPROM Opcodes
#define WREN 6
#define WRDI 4
#define RDSR 5
#define WRSR 1
#define READ 3
#define WRITE 2
 
// Buffer for EEPROM data
byte pageBuffer[PAGE_SIZE];
 
CameraC328R camera;
 
static uint16_t pictureSizeCount = 0;
static uint16_t pageBufferIndex = 0;
static uint16_t currentAddress = 0;
bool dirtyBuffer = false;
 
/**
 * Reads one byte from the EEPROM at the given address.
 */
byte readByte( uint16_t address )
{
  byte data;
 
  digitalWrite( SS_PIN, LOW );
  Spi.transfer( READ );
  Spi.transfer( (byte)(address >> 8) );
  Spi.transfer( (byte)(address) );
  data = Spi.transfer( 0xFF );
  digitalWrite( SS_PIN, HIGH );
  return data;
}
 
/**
 * Writes the data in the buffer to the EEPROM at the page
 * starting at the given address.
 */
void writeBuffer( uint16_t address, uint16_t bufferSize )
{
  // Write enable
  digitalWrite( SS_PIN, LOW );
  Spi.transfer( WREN );
  digitalWrite( SS_PIN, HIGH );
 
  delay( 10 );
 
  // Begin write
  digitalWrite( SS_PIN, LOW );
  Spi.transfer( WRITE );
 
  // Send the address
  Spi.transfer( (byte)(address>>8) ); // MSB
  Spi.transfer( (byte)(address) ); // LSB
 
  // Send the data
  for( uint16_t i = 0; i < bufferSize; i++ )
  {
    Spi.transfer( pageBuffer[i] );
  }
 
  digitalWrite( SS_PIN, HIGH );
}
 
/**
 * Fills the page buffer for the EEPROM with data.
 */
void fillPageBuffer( byte* data, uint16_t dataSize )
{
  for( uint16_t i = 0; i < dataSize; i++ )
  {
    pageBuffer[pageBufferIndex] = data[i];
    dirtyBuffer = true;
    pageBufferIndex++;
 
    if( pageBufferIndex == PAGE_SIZE && dirtyBuffer )
    {
      pageBufferIndex = 0;
      writeBuffer( currentAddress, PAGE_SIZE );
      currentAddress += PAGE_SIZE;
      dirtyBuffer = false;
      delay( 50 );
    }
  }
}
 
/**
 * Sends a picture to the computer.
 */
void transferPicture( uint16_t startAddress, uint16_t size )
{
  uint16_t endAddress = startAddress + size;
 
  for( uint16_t i = startAddress; i < endAddress; i++ )
  {
    Serial.print( readByte( i ), BYTE );
  }
}
 
/**
 * This callback is called EVERY time a JPEG data packet is received.
 */
void getJPEGPicture_callback( uint16_t pictureSize, uint16_t packageSize, uint16_t packageCount, byte* package )
{
  // packageSize is the size of the picture part of the package
  pictureSizeCount += packageSize;
 
  // package contains everything in the package
  fillPageBuffer( package, packageSize );
 
  if( pictureSizeCount == pictureSize )
  {
    // Is there still stuff in the buffer?
    if( dirtyBuffer )
    {
      writeBuffer( currentAddress, pageBufferIndex );
    }
 
    camera.powerOff();
    digitalWrite( LED_PIN, HIGH ); // DONE!
    Serial.flush();
    delay( 5000 ); // Give us 5 seconds to hit a key ...
    transferPicture( 0, pictureSize );
  }
}
 
void setup()
{
  Serial.begin( BAUD );
  digitalWrite( SS_PIN, HIGH ); // disable device
  pinMode( LED_PIN, OUTPUT );
 
  if( !camera.sync() )
  {
    Serial.println( "Sync failed." );
    return;
  }
 
  if( !camera.initial( CameraC328R::CT_JPEG, CameraC328R::PR_160x120, CameraC328R::JR_640x480 ) )
  {
    Serial.println( "Initial failed." );
    return;
  }
 
  if( !camera.setPackageSize( 64 ) )
  {
    Serial.println( "Package size failed." );
    return;
  }
 
  if( !camera.setLightFrequency( CameraC328R::FT_50Hz ) )
  {
    Serial.println( "Light frequency failed." );
    return;
  }
 
  // Let camera settle, per manual
  delay(2000);
 
  if( !camera.snapshot( CameraC328R::ST_COMPRESSED, 0 ) )
  {
    Serial.println( "Snapshot failed." );
    return;
  }
 
  if( !camera.getJPEGPicture( CameraC328R::PT_JPEG, PROCESS_DELAY, &getJPEGPicture_callback ) )
  {
    Serial.println( "Get JPEG failed." );
    return;
  }
}
 
void loop()
{
}

Next up, the Processing code. This code doubles as a serial monitor, so you can run it as soon as you plug in the Arduino to USB, and ignore the built-in Arduino serial monitor. Again, note that you must hit a key within 5 seconds of the LED lighting up, and again once data is done reading to save it to disk. By default, it will be saved as a file called “photo.jpg” in the same folder as your Processing sketch.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import processing.serial.*;
 
Serial myPort;
String filename = "photo.jpg";
byte[] photo = {};
Boolean readData = false;
 
void setup()
{
  println( Serial.list() );
  myPort = new Serial( this, Serial.list()[0], 38400 );
}
 
void draw()
{
  byte[] buffer = new byte[64];
  if( readData )
  {
    while( myPort.available() > 0 )
    {
      int readBytes = myPort.readBytes( buffer );
      print( "Read " );
      print( readBytes );
      println( " bytes ..." );
      for( int i = 0; i < readBytes; i++ )
      {
        photo = append( photo, buffer[i] );
      }
    }
  }
  else
  {
    while( myPort.available() > 0 )
    {
      print( "COM Data: " );
      println( myPort.readString() );
    }
  }
}
 
void keyPressed()
{
  if( photo.length > 0 ) {
    readData = false;
    print( "Writing to disk " );
    print( photo.length );
    println( " bytes ..." );
    saveBytes( filename, photo );
    println( "DONE!" );
  }
  else {
    readData = true;
    myPort.clear();
    println( "Waiting for data ..." );
  }
}

That should be enough to get started. The sample code above does not cover using the camera for RAW image capture, which is considerably faster and more useful as a solution for video (5 frames per second), but the library includes this functionality.

Feel free to post questions, comments or ideas below.