Wise Clock 3 with Duino644

Let's start with a bit of "history".
Duino644 was designed to match with (plug into) the now-discontinued 2416 mono-color LED display from Sure Electronics.
Wise Clock 3 board was designed to plug into the 3216 bi-color LED display from Sure.
Both boards have a similar schematic, based on ATmega644, and they share similar features: RTC (DS3231) on I2C, SD card, piezo buzzer, 3 user buttons.

There are a few differences between the 2 boards:

• Duino644 has IR receiver, connected on D2, whereas Wise Clock 3 has the Plus button on D2 and no IR receiver;
• Wise Clock 3 has D11 connected to pin 2 (CLK) of the 3216 display; on Duino644, since the 2416 display does not require an input on pin 2, D11 is not connected.

Our goal is to adapt the "old" Duino644 board to the 3216 bi-color LED display and run the Wise Clock 3 software on it. This is easily achieved by doing the following hardware hacks:
1. connect the processor's pin 17 to pin 2 of the display's connector (red wire in the photo);
2. solder a bridge between processor's pins 3 and 4 (also visible in the photo);
3. cut out the IR receiver.

Now upload the Wise Clock 3 sketch (download latest version from here).
Plug the Duino644 board into the 5mm display, as shown in the photo above, then power it with the USB miniB cable. Surprisingly, the ensemble looks pretty functional and practical as it is: the buttons are accessible at the top (albeit a bit deep), the board is flush with the display, and the power (USB) socket is on the right side.
The enclosure could be a similar pair of plexiglass plates as used in Wise Clock 3. This bigger Wise Clock 3 would be more suitable to be hang on a wall (rather than sit on a desk).

Note that the Duino644 I tested uses DS3231. A version with DS1307 should work the same (except it will show 0 as the current temperature, I think).

As always, feedback is appreciated.

"Finished" Wise Clock 2 with Duino644

By "finished" I am only referring to the enclosure, not to the evolving (hopefully) software. Once released to the open source community, the software should be, in theory, never "finished", like a piece of art :)

Here is a photo of a simple (and cost-effective), yet elegant, enclosure, consisting in two laser-cut sheets of 1/8" plexiglass separated by plastic spacers.

And here it is in more details, in a video.

Wise Clock 2 - New software release

Before talking about the new software release, I must point out a few corrections/edits I made in earlier posts:

• added photos to "Assembling Duino644", also clearing out a confusion about the orientation of the infrared receiver;
• corrected the (blindly copied from sanguino.cc) pin diagram in "Duino644 - Use it";
• added photo to "Testing Duino644 - RTC and EEPROM".

The new software release can be downloaded from here. Most of the items on a previous "to do" list have been addressed. Following are the items I managed to do so far:

• included Tone library (written by B. Hagman) to generate alarm sounds;
• implemented functionality for the three buttons (Menu, Set, Plus);
• removed the branching for ATmega328 (#ifdef _ATMEGA328P_), since many of the features won't fit in its RAM anyway;
• ability to set up the date the same way as the time, through the file time.txt on the SD card;
• display notification when the SD card is not inserted (or, to be more accurate, file quotes.txt is not found);
• implemented sleep mode (more work is required for waking up from sleep mode with the remote control);
• scrolling speed adjustable through 1-button (Plus) pushes;
• dimming adjustable through 1-button (Set) pushes;
• select to display the date or not;
• ability to set the alarm time;
• enable/disable alarm.

(Details and explanations to follow.)

Duino644 - a few more explanations

I get suggestions and ideas from many people these days. Thank you, I honestly appreciate it. This will only make the "product" better. As a result, I made a few corrections to the "Assembling Duino644" post and I added a couple of more posts (included this one). There are more photos coming (thanks Mike B.), software updates, and board fixes.

"MatrixType" 2-pin header

A few words about the "MatrixType" 2-pin header, found between the EEPROM and PORT_C header. With the jumper on, pin D11/PD3 is pulled down (that is, connected to the ground). When the jumper is not present, pin D11/PD3 is pulled up by the 10K resistor. By reading the state of this pins, the sketch can adapt to display on either the 16x24 or the 8x32 LED matrix display from Sure Electronics. The software support is almost trivial. The hardware is not. Plugging the active (SV1) connector directly into the 8x32 LED display makes for an awkward beast (since the dimensions of the 2 boards are so different). But it can work with a 16-wire ribbon cable.

Note: As of today, the software support for the "MatrixType" is not yet tested.

ICSP6 6-pin header

This is the standard connector used for programming the microcontroller chip with the AVR programmer. As in Arduino Diecimila, one rarely needs to use it for burning a program, since the bootloader (already burned on the chip) allows for easy upload of a sketch from the IDE.

6-pin inline, right-angled header

This header is used for connecting with the FTDI cable, or with the equivalent FTDI basic breakout from Sparkfun. This is the only way to upload a sketch from Arduino IDE to the Duino644 board. Keep in mind that the USB miniB connector is only used to provide power (5V), unlike the USB connector on most of the Arduino-type boards (which have the FTDI chip on board).

The next batch of PCBs will include a few corrections in the silkscreen: the 16MHz crystal is marked "XTAL" and the places for DS1307 and 24LC256 are clearly marked. Also, the 3 buttons are visibly named on the back of the board, useful if the enclosure has a transparent back panel.

As mentioned in an earlier post, the USB power connector can be either miniB or B type. If you have a preference for either one when you buy the kit, please let me know and I will accommodate it.

Next post will be about software. A quick "to do" list includes:

• functionality for the 3 buttons (menu, scrolling speed, dimming, set clock/alarm etc);
• IR functions for remote control;
• extend time displayed to include year/month/day;
• include the alarm/melody functions (plus 2 sound-intensities through the speaker);
• sleep (power down) mode;
• alarm functionality (set/sound/trigger/enable/disable);
• support for "matrix type".

Edit: As of Jan/10, all (except the last) of the above "to do" items have been implemented and are currently implemented in the latest software release.

Duino644 - Use it

The best tutorials I have seen are, by far, those from adafruit.com. With the effort I can spend, I will never be able to write anything better than those instructionals. So, as the saying goes, "if you can't beat them, join them", I will try to mimic. (One item on my "to do" list is the building of a project site, with a "normal" navigation: projects listed on the left column, description on the wider right column. Hopefully, all these postings will eventually become project chapters. And, of course, one chapter will be named "Use it".)

As we already know by now, Duino644 can be used independently of the LED display from Sure Electronics (this is one of the reasons I re-named the board Duino644 from the original Wise4Sure), more like an Arduino (or, I should say Sanguino) is. For this purpose, all 4 "ports" are exposed through 4 headers (8-pin connectors). On the board, these ports are named PORT_A, PORT_B, PORT_C and PORT_D, and they are highlighted in the picture below.

Since Duino644 is compatible with (or "piggybacking on") Sanguino, here is the pin mapping used when programmed Arduino-style (that is, using digitalWrite/digitalRead rather than accessing the ports directly):

                  +---\/---+
(D 0) PB0  1|        |40  PA0 (AI 0 / D31)
(D 1) PB1  2|        |39  PA1 (AI 1 / D30)
INT2 (D 2) PB2  3|        |38  PA2 (AI 2 / D29)
PWM (D 3) PB3  4|        |37  PA3 (AI 3 / D28)
PWM (D 4) PB4  5|        |36  PA4 (AI 4 / D27)
MOSI (D 5) PB5  6|        |35  PA5 (AI 5 / D26)
MISO (D 6) PB6  7|   A    |34  PA6 (AI 6 / D25)
SCK (D 7) PB7  8|   T    |33  PA7 (AI 7 / D24)
RST  9|   M    |32  AREF
VCC 10|   E    |31  GND
GND 11|   G    |30  AVCC
XTAL2 12|   A    |29  PC7 (D 23)
XTAL1 13|        |28  PC6 (D 22)
RX0 (D 8)  PD0 14|   6    |27  PC5 (D 21) TDI
TX0 (D 9)  PD1 15|   4    |26  PC4 (D 20) TDO
INT0(D 10) PD2 16|   4    |25  PC3 (D 19) TMS
INT1(D 11) PD3 17|        |24  PC2 (D 18) TCK
PWM (D 12) PD4 18|        |23  PC1 (D 17) SDA
PWM (D 13) PD5 19|        |22  PC0 (D 16) SCL
PWM (D 14) PD6 20|        |21  PD7 (D 15) PWM
+--------+

(to be continued)

References:

• Sanguino.cc
• ATmega644 datasheet

Testing Duino644 - "Wise Clock 2" main sketch

Updated Feb 18/2010

The latest version of the "Wise Clock 2" code library can be downloaded here. This was tested and confirmed working in Arduino 17 (on Windows) with the sanguino libraries.

The library includes functions/classes from the following:

• DS1307;
• a modified version of the SDuFAT library;
• font3.h, the definition of the character set;
• Tone library;
• HT1632 library (for the Sure Electronics LED display), written by westfw. (HT1632 functions are included directly in Wise4Sure.pde sketch.)

Note: If you already have DS1307.zip installed, you may get an error saying that DS1307 is defined in multiple places (it is already included in WiseClock2.zip). If that is the case, delete the DS1307 folder from hardware/libraries.

Now bring on your 16x24 LED display from Sure Electronics to see Wise Clock 2 in action.

Plug the display into the Duino644 board (or vice versa :). Make sure that the display has the CS1 in the "ON" position and the other three switches are set to "OFF".

Note: The LED display board has a pair of 2-pin screw terminals on the back (face opposite to LED matrices). They may impede the Dunio644 to plug into the display board. Even if that is not the case (it did not happen to me so far), it is a good idea to extract those screw terminals, which can be useful somewhere else. The picture above shows the LED display board with the screw terminals removed.

Next, copy the two text files, time.txt and quotes.txt onto the SD card, after you made sure the card is formatted as FAT16. For information on how to check the formatting, follow this article on adafruit website.

Open the file time.txt in a text editor and modify the line containing the time. This will be the time used for setting the RTC, and it happens when the clock is powered with the time.txt file on the SD card. (After the time was set, the file is "deleted". See more information here.)

Now, after uploading the sketch to Duino644 board, the text from the file quotes.txt should be scrolling on the top half of the display, and the time should be displayed on the bottom half, as shown in this video.

Congratulations! It is now the time (pun intended :) to design a nice enclosure and to show it off to friends and family.

Related posts:

• Duino644 revision 1.1 kit
• Duino644 software updates

Testing Duino644 - RTC and EEPROM

With the Duino644 kit assembled, we can now start testing it.
First, plug the USB cable in the USB miniB onboard connector and make sure the blue LED is lighting.
Alternatively, plug in the FTDI connector (or "FTDI basic breakout"), making sure that the USB (power-only) cable is unplugged. Unlike Wiseduino board, Duino644 is powered by the 5V FTDI pin. Blue LED should be on.

Before uploading any sketch to Duino644, we need to install the Sanguino libraries. (Remember that Duino644 is compatible with Sanguino.) At the end of the integration we will see Sanguino listed in the Tools/Board menu of the Arduino IDE. This is the board that must be selected when working with Duino644.

Before proceeding further, we need to modify boards.txt file, specifically the "Sanguino" section, to look like this:

sanguino.name=Sanguino

sanguino.upload.protocol=stk500

sanguino.upload.maximum_size=63488

sanguino.upload.speed=38400

sanguino.bootloader.low_fuses=0xFF

sanguino.bootloader.high_fuses=0xDC

sanguino.bootloader.extended_fuses=0xFD

sanguino.bootloader.path=atmega644

#sanguino.bootloader.path=atmega644p

sanguino.bootloader.file=ATmegaBOOT_644.hex

#sanguino.bootloader.file=ATmegaBOOT_644P.hex

sanguino.bootloader.unlock_bits=0x3F

sanguino.bootloader.lock_bits=0x0F

sanguino.build.mcu=atmega644

#sanguino.build.mcu=atmega644p

sanguino.build.f_cpu=16000000L

sanguino.build.core=sanguino

sanguino.verbose=false

This is because Duino644 comes with ATmega644 instead of Sanguino's ATmega644P. The difference between the two processors is a second UART in ATmega644P.

(Note: Future revisions may ship with ATmega644P, although the extra functionality is not required nor used in Wise Clock 2.)

Using the FTDI cable, upload the first sketch, the one that sets the real time clock.
(Note: This is just for testing the RTC, since the clock itself can be set using the method described here).

If you feel adventurous you can start directly with the main sketch. It should work, unless you skipped a step or two (forgot to insert the DS1307 chip in the socket, for example) .

Download this file and unzip it in the hardware/libraries folder of your Arduino IDE.

It contains rtc.pde sketch and DS1307 class (header and cpp files).

To set the clock, un-comment the portion of the code in setup(), upload the sketch and run it once. To avoid setting up the same time at every reset and power-up, modify the sketch by commenting out the setup() portion, then upload it again. Now, the board will just send back the time from RTC on serial port.

Testing the EEPROM is done similarly with Wise Clock and detailed here.

(Note: The Wise Clock 2 functionality does not use the EEPROM so far. In the "glass dome" Wise Clock, the quotations were stored in EEPROM, there was no SD card.)

If everything works fine so far, let's take the big jump and load the sketch for Wise Clock 2, which reads the SD card and displays the content of quotes.txt file onto the LED display.

So, next step is the last, and most important, one: uploading the main sketch.

Other "uzes" for Duino644

As mentioned in an earlier post, Duino644 can form the base for an implementation of the Uzebox project. A "uzebox shield" would be plugged in the Duino644 board, much as shields are used with Arduinos. The picture below shows my current effort in trying to get the "uzebox" working. Soldering is done, testing/debugging is next.

A few changes (from the Wise Clock setup) are required:

• ATmega644 has a different firmware burnt in (not the Arduino/Sanguino bootloader);
• the microcontroller, nominal frequency of 20MHz, is overclocked at 28.63636 MHz.

Many components on the main board are not necessary (RTC, battery, EEPROM etc). Instead of the LED display (2x8 female header) connectors, the four extension (8 pin female header) connectors are used.

I will post the results of this experiment later. I also plan to design a "uzebox shield" PCB.

On the same note (other uses), it was pointed out by fellow Arduino enthusiast BroHogan, of X10 fame, that the Duino644 is also compatible with his Nex10 board (I am grateful for the link on his page), so it can be used as the base for my next X10 project (following his instructions, obviously).

I will keep you posted on the Nex10 project as well, hopefully I will find the time to do it.

Duino644 software updates

I was close to giving up on SDuFAT library in favour of FAT16, but my one last attempt worked. I was trying to implement a feature suggested by fellow Arduino blogger BroHogan, to set up the clock using a file on the SD card. Since real time clock is set up quite rarely, this idea makes perfect sense.

Here is how it works:

• the user creates/copies the file "time.txt", which contains the time, formatted as HH:MM:SS, onto the SD card;
• after reset, if "time.txt" is found, the clock is set with the given (in the file) time;
• "time.txt" file is deleted, so the next reset won't find the file anymore;

It is always easier said than done.

Firstly, SDuFAT requires the file to have some characteristics, the most important being to contain a pseudo-EOF (0x03) character.

Secondly, the deletion of the file is not physical, the file does not disappear from the SD card, but it is rather modified so that its first character is the pseudo-EOF (0x03). The "deleted" file can be opened and its content read. The code decides that the file is "deleted" by checking the first character. How smart is that?

setRtcFromSDCard() shown below is the function that gets called in setup().

void setRtcFromSDcard()
{
numSectors = (int) SD.getSectors("time.txt");
if (numSectors == 0)
{
// try again;
delay(500);
numSectors = SD.getSectors("time.txt");
}

if (numSectors == 0)
{
#ifdef _DEBUG_
Serial.println("File time.txt not found.");
#endif

return;
}

// open file time.txt and read its content;
sectorContent = SD.readBytes("time.txt", 0);

// search for the time in the sector buffer;
boolean isTimeFound = false;
for (int i = 0; i<512; i++)
{
if (sectorContent[i] == 0x03)  // EOF
break;

for (int j=0; j<8; j++)
{
timeBuffer[j] = sectorContent[i+j];
}
if (timeBuffer[2] == ':' && timeBuffer[5] == ':')
{
// found the time;
isTimeFound = true;
break;
}
}

if (!isTimeFound)
{
#ifdef _DEBUG_
Serial.println("Could not find time (HH:MM:SS) in file time.txt");
#endif
return;
}

#ifdef _DEBUG_
Serial.print("Time from file is: ");
Serial.println(timeBuffer);
#endif

int hh = 10*(timeBuffer[0]-48) + (timeBuffer[1]-48);
int mm = 10*(timeBuffer[3]-48) + (timeBuffer[4]-48);
int ss = 10*(timeBuffer[6]-48) + (timeBuffer[7]-48);

#ifdef _DEBUG_
Serial.print("RTC time to be set to: ");
Serial.print(hh);
Serial.print(":");
Serial.print(mm);
Serial.print(":");
Serial.println(ss);
#endif

if (hh < 24 && mm < 60 && ss < 60)
{
setTime(hh, mm, ss);
SD.del("time.txt");
}
}

The other software change I made was also the contribution of BroHogan, who wrote (see reply #147) a few functions that perform "fast writes" to the LED display from Sure Electronics. Basically, the calls to digitalWrite() in ht1632_writebits() function have been replaced with calls to fWriteA(). This allows control over the speed of scrolling, ranging from fast to slow, rather than from slow to slower.

New Duino644 kit (revision 1.1)

Thanks for ordering Duino644 kits.

At the moment, all of the "original", revision 1.0 (first batch of) PCBs are gone. In the meantime, I designed an improved version, by adding a few more components, to bring it closer to its intended functionality as the backbone of the Wise Clock:

• 3 right angle push buttons (for setting up time, snooze, dimming etc);
• piezo buzzer, for the alarm;
• bright blue LED, as a background (and power indicator) light;
• a bit bigger PCB.

This is the schematic for revision 1.1 of Duino644 (download Eagle file here):

and this is the board (download Eagle file here):

To my estimation, I should receive the new PCBs by Oct 20.

Once the new boards are in, I will have to re-price the Duino644 kit to cover the cost of the extra components, essentially increasing it by US$4, to a total of US$58 (free regular shipping to North America) and US$62 (free shipping outside North America) respectively.

The orders placed until then, at the old prices, will be filled with the new design. Consider this as a "promotion" campaign and take advantage of the "reduced" price.

See also:

• Buy Duino644 kit
• Finished Wise Clock with Duino644
• Assembling Duino644 kit

Buy Duino644 kit

Updated Sep 30, 2011 - DISCONTINUED
This kit is no longer offered. It was replaced by the Wise Clock 3 kit.


Updated Jan 27, 2011

A redesigned (revision 2.1) Duino644 is back in stock. Read more about it here.

Note: Although I added a few more components and I made the board a bit larger, I decided to keep the price unchanged. I hope this is appreciated :)

Also, the picture below won't accurately reflect the actual component set. Missing are the 4 right-angle push buttons (one is replacing the reset button), the micro-speaker and the high brightness blue LED.

I have a few Duino644 kits for sale, on hand and ready to ship. After they are gone, any order will be fulfilled in about 4 weeks time.
Duino644 kits are US$54, with free regular shipping to North America.

For only US$10 more, buy the 2416 LED matrix display from Sure Electronics (ebay), and you can have a nice gadget on your desk to impress your friends an colleagues.

The Duino644 kit includes the following parts:

• PCB;
• ATmega644 / 20MHz, with bootloader;
• either 16 MHz resonator or crystal 16 MHz (plus 2 capacitors 22pF);
• 40-pin socket for ATmega644;
• SD card socket (SD card is not included);
• DS1307 real time clock, either in DIP or SOIC package;
• 24LC256 EEPROM, either in DIP or SOIC package;
• 3V coin battery (CR1220 equivalent);
• battery holder for CR1220;
• crystal 32,768 Hz;
• 2 x 16-pin (2x8) female headers;
• 3 x capacitor 100nF;
• 78L33 regulator (3V3);
• 10 x resistor 10K;
• 3 x resistor 4.7K;
• micro push button (reset);
• micro slide switch (power);
• 6-pin angled male header (FTDI);
• either USB miniB SMD connector or USB type B connector;
• infrared receiver;
• 40-pin female connector;
• either molex 2-pin angled power connector or JST jack.

Assembling instructions are published here.

Related posts:

• Introducing Duino644

Introducing Duino644

Updated Sep 30, 2011 - DISCONTINUED
This kit is no longer available. A very similar kit is the Wise Clock 3.

A simple name from a simple mind: think Arduino clone powered by ATmega644.

Compatible with Arduino software environment (thanks to the Sanguino board, from which it was inspired), Duino644 offers more capabilities than a regular, ATmega328-based Arduino, in the same price range.

Duino644 was originally designed to be used in an advanced new version of Wise Clock. It features the same combo RTC + EEPROM as Wiseduino, and also an SD card socket and connectors for the 24x16 LED matrix display from Sure Electronics.

Duino644 can also be used as a general-purpose Sanguino-compatible board, having all ports (input/ouput pins) exposed and available for use.

Here are some of Duino644 features:

• PDIP (40 pin) ATmega644 on socket, running at 16 MHz;
• compatible with Arduino software environment through the addition of Sanguino libraries;
• directly pluggable into the 2416 LED display from Sure Electronics;
• semi-pluggable (just one of the two connectors) into the 0832 LED matrix display from Sure Electronics; display type (2416 or 0832) is selectable through jumper;
• compatible with uzebox game console (requires a different crystal and the "uzebox shield" (under development));
• relatively easy to solder, with mostly through hole components;
• on board socket for either SD card or microSD card;
• on board RTC (DS1307) in either PDIP or SOIC package;
• on board EEPROM (24LC256) in either PDIP or SOIC package;
• 6-pin FTDI connector with automatic reset capability;
• powered, with regulated 5V only, through either standard 2-pin power connector (MLX-WF02R from molex or JST jack from seeedstudio) or USB (type B or miniB connector);
• power on/off micro switch, easily accessible on the side;
• available interrupt output pin from RTC;
• on board backup battery (CR1220), allowing RTC to keep time even when Duino644 is not powered;
• infrared receiver for remote control;
• all 4 ports made available through extension headers, spaced at 0.1" multiples, for use with prototype boards;
• ISCP6 connector for AVR programming.

Schematic (download Eagle file)

Board (download Eagle file)

A few Duino644 PCBs are shown in the photo below.

And this is an assembled Duino644, which is the base for Wise4Sure. With the current software, it works exactly like in this video.

Assembling instructions can be found here.



Duino644 by FlorinC is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.


References:

• Sanguino
• Arduino vs Sanguino vs Arduino Mega

Related posts:

• Wise Clock 2 with ATmega644
• The original Wise4Sure
• When 2K is not enough

Assembling Duino644

This the schematic (download Eagle file) for Duino644 revision 1.1 (Oct/09)

and the board (download Eagle file):

If you bought the Duino644 kit, you received the following components:

• PCB with the SD card socket soldered on it;
• ATmega644 microcontroller and its 40-pin socket;
• DS1307 real time controller, in either 8-pin DIP (with a socket) or SOIC (surface mounted) package;
• 24LC256 EEPROM, in either 8-pin DIP (with a socket) or SOIC (surface mounted) package;
• CR1220 (or equivalent) coin battery;
• coin battery holder;
• either a 16MHz crystal and 2 capacitors 22pF, or a 16MHz resonator;
• crystal 32,768Hz for RTC;
• 4 right angled push buttons;
• micro-speaker;
• high intensity blue LED (SMD, 1206 package);
• USB miniB-type connector;
• JSP 2-pin jack;
• JST 2-pin power connector (with red-black cables soldered);
• 2 female headers 2x8 pins;
• 40-pin female header;
• L78L33 voltage regulator (3V3);
• infrared receiver IC;
• 6-pin right angled male header (FTDI connector);
• 3 decoupling 100nF capacitor;
• 2x3 pin male header (ICSP connector);
• 10 resistor 10K;
• 3 resistor 4K7;
• resistor 75R.

As with the other kits, soldering the components is not for absolut beginners: this should not be the first kit you assemble. The challenge comes from the few SMD components. Although these are the biggest SMD (surface mounted) packages you will find (SOIC for ICs, 1206 for LED, and the USB miniB), you would still need, depending on your experience, tweezers, de-soldering braid, flux pen.

So here is how we should proceed with the assembling.

1. Solder the USB miniB connector first. Place the connector with its bumps in its holes, so it fits in its place. Then solder the 4 outside extremities to the pads, so it becomes solidly attached to the board. Now solder the 5 pins, with disregard to the bridges that may occur. The next step should be to remove those bridges with the braid.

2. Solder the 75 ohm resistor in its place (R14). This is the current limiting resistor for the LED.

Note: The kit has 3 color-coded resistor values: 10K (brown, black, orange, gold), 4K7 (yellow, purple, black, brown, brown) and 75 ohm (purple, green, black, gold, brown). To simplify identification for those who don't want to consult the color-code chart, use the following photo.

3. Next, solder the SMD LED. The cathode of the LED is marked (green dot, visible through magnifying glass). The cathode is marked on the PCB as well, with 3 dots. Melt some solder on the cathode pad; place the LED's cathode over that pad and solder it; then solder the anode.

4. Time to check that the board gets power from USB, by plugging in the USB cable. The LED should become bright blue. We have ignition!

5. Perform this step if you have the SMD (surface mounted) version of the RTC and/or EEPROM. For best results, moist their pads with a flux pen before you solder them. Avoid using the "de-soldering braid" to remove the eventual bridges, since these are temperature sensitive, unlike the USB connector soldered earlier. (Pay attention to the orientation of these chips: the dots marking pin 1 must be closer to the bottom of the PCB.)

6. Solder the 4K7 resistors (yellow, purple, black, brown, brown), R5, R6 and R7. Then continue with the remaining resistors, all 10K.

7. Solder the IC sockets, for ATmega644, RTC and EEPROM (if the last two were provided). Pay attention to their orientation, so that their notches match the notch in the silkscreen (this is not vital, but it will help later to correctly place the ICs).

8. Solder the two crystals (16MHz and 32768Hz), then the capacitors (C1 and C2 are 22pF, the rest are 100nF). The 16MHz (bigger) crystal goes in the three-hole spot (center is not used) close to the pins 11-13 of the microcontroller. Latest PCB version has this spot marked "XTAL".

9. Solder the battery holder. (I personally cut the 3 bumps underneath, so it gets closer to the board.). Then solder the ISCP (optional) and FTDI connectors.

10. Solder the 4 right-angle push buttons, the micro-speaker and the JSP (power) jack. Continue with soldering the 2 LED display connectors (2x8 female headers).

11. Solder the 3V3 regulator after placing it to match the silkscreen.

12. Insert the ATmega644 chip in its socket, then the RTC and the EEPROM (if you have the DIP version). Pay attention to their orientation, by matching the notches on the IC with the notches in the socket (if they were placed correctly in step 7 :) Also, remember to bend their pins just a tiny bit, on a hard surface (e.g. desk) to make them parallel, as so nicely documented in many of ladyada's instructionals (including this one).

13. Optionally, solder the infrared receiver. (This part should be visible to the remote control. Therefore, its final place will be dictated by the enclosure. Depending on that, it may be necessary for the infrared receiver to be "extended" with some wires.)

Pay attention to its orientation: when inserted, the bump should be facing inwards, toward the board. To be visible by the remote control, the IR receiver should also stick out from behind the LED display, so it would need to be bent 90 degrees, as shown in the photo below.

It has been suggested (thanks Mowcius) that a 3-pin female header can be soldered in place of the IR receiver. This will act as a socket, eliminating the risk of soldering the part wrongly, as it happened in a few instances. More, it will allow for the cables to be unplugged when the device need to be dis-assembled (assuming that the IR receiver is fixed to the enclosure).

At this point, Duino644 is assembled and ready for testing (continue here).

It should look pretty close to the one below (which is missing a few non-essential parts).