NKC Electronics Tutorials

The RGB LCD shield for Arduino 65K color KIT includes all the components to assemble a ready to use LCD shield for Arduino and compatible boards like Freeduino.

First the schematics:

The LCD module has a backlight made of 2 white LEDs that requiere approximate 9V with a max 19mA current to work.  As this voltage level is not available on the Arduino board, I used an ST232 RS232 driver to get 8V DC from the standard 5V Arduino power supply.  The backlight driver circuit is in a separate board (yellow) that will be inserted on top of the RGB LCD shield PCB.

The first step is to unpack the KIT.  It contains the following components:

1 x RGB LCD module

1 x RGB LCD shield PCB

1 x LCD module to PCB soldering adapter

1 x LM317T variable voltage regulator

2 x 10uF electrolytic capacitors

5 x 0.1uF ceramic capacitors

1 x 330 ohm resistor

1 x 430 ohm resistor

5 x 1Kohm resistors

5 x 1.3Kohm (1K3) resistors

1 x 40-pin male breakable header (you need to cut 2 8-pin sections, 2 6-pin sections and 1 1-pin section)

1 x 2×3 long leg female pin header

1 x DC step up PCB (yellow)

1 x ST232 RS232 driver IC

1 x 110 ohm resistor

1 x 6-pin female header

1 x 2×3 pin female header

Let’s start with the main RGB LCD shield PCB.  The LCD module needs to be soldered first.  Separate the LCD module and a small green thin PCB used to attach the LCD module to the main black PCB.

Apply some solder in one of the pins of the LCD module, you can choose either pin 1 or pin 10 (pin 1 is the one to the right of the picture).

Once the solder is applied, place the small thin PCB and align the 10 pads to the 10 pads on the LCD module.  Heat the pin that has the solder to attach the small thin PCB (the adapter).  Once you are satisfied how it is aligned (make sure the pads are correctly aligned, to avoid shorting the pins), solder the rest of the pads.

Now it is time to solder the LCD module to the main black PCB.  The process is the same, apply some solder in one of the pins (1 or 10) and align the LCD module with the adapter to the 10 pads on the black PCB.  Solder all the pads.  Be careful to not add excessive solder to create shorts in the pads.

The LCD part is done.  Let’s continue with the Power Supply (Voltage regulator).  This part of the circuit, takes 5V from Arduino and using the LM317 variable voltage regulator, generates 2.9V to supply the LCD module.  The components are: LM317T, 1 x 10uF electrolytic capacitor, 2 x 0.1uF ceramic capacitor, 1 x 430 ohm resistor and 1 x 330 ohm resistor.

Solder first the LM317 voltage regulator.  Then you can solder the 0.1uF ceramic capacitors C2 and C3.  Orientation is not important for the ceramic capacitors.  Then solder the 10uF electrolytic capacitor, negative leg to the left, positive (long) to the right.  Next you need to solder R12 430 ohm resistor (you can follow the guide in http://www.bpesolutions.com/atechnical/ResistorQV.pdf to calculate the resistor colors).  430 ohms is yellow, orange, brown.  Then solder R13 330 ohm resistor (orange, orange, brown).  The power supply section is complete.

This is how the board looks now with the power supply section ready

Next solder the 10 resistors used to create the logic level converter from 5V to 2.9V.  We will be using 5 x 1K and 5 x 1.3K (or 1K3) resistors.  1K resistors are coded brown, black, red and 1.3K resistors are coded brown, orange, red.

This is how the board looks with the voltage dividers (10 resistors) soldered.

The next step is to solder the headers.  You need to break the 40-pin male header into 2 8-pin section, 2 6-pin section and 1 1-pin section (just grab 1 pin and twist it until it breaks).

Solder the pin headers.  The male headers are inserted from the bottom of the PCB to the top.  Once soldered, you need to plug this shield to the Arduino board, so you need the long side of the pin header going downwards.  The 2×3 female header is soldered backwards, also from the bottom of the PCB to the top, but long leg first.  You will also apply solder on the top side of the PCB.  Remember that the ICSP pin header on the Arduino board is male, while all the other headers are female.  The 6-pin headers are not easy to insert, as the holes are not aligned on purpose to make them fit better.  Push this headers all the way in.  You will notice slight bending of the pins, but it is ok.  It will make the shield fit tighter on the Arduino board.

It is easier to know how all the headers go if you look at the picture of the finished board.

The last pin you need to solder on the main black PCB is the 1-pin header.  It goes on the left pad of R11.  You can see R11 is empty.

Next step is to assemble the DC step up converter.  This little yellow board converts 5V from the Arduino board to approx 8V.  It is enough to drive the white LED backlight.

I was looking for a “true” step-up converter, but they are packaged in tiny tiny devices, almost impossible to solder.  So I realized that the ST232 with a couple of capacitors can generate 7-12V (even negative!), and they are cheaper than “true” step-up converters and needs less external components, so I tested this circuit and it worked just fine.  Added a 10uF capacitor to filter the 8V output.  This 8V goes to the Anode of the LCD backlight, but through a current limiting 110 ohm resistor.  This tiny board is very easy to assemble, just insert all the components (ST232 chip, 1 6-pin female header, 1 2×3 female header, 3 x 0.1uF ceramic caps, 1 x 10uF electrolytic cap, 110 ohm resistor).

And here is the board assembled.  This tiny board must be inserted in the RGB LCD shield board by using the ICSP header and one of the 6-pin female headers.  Remember the 1-pin header that you soldered on the left pin of R11?  OK, you need to align the 2nd pin from the left of this tiny board to the 1-pin header on the main board.  The 6-pin header, viewed from the top, has the following pinout: [GND] [8V] [GND] [GND] [5V] [GND].  [8V] pin must be inserted in the 1-pin header on the main board.  The GND comes from the ICSP header.

And this is how everything looks when the tiny board (step-up converter) is inserted, the board is plugged to USB and you upload the sample sketch to the Arduino board.

The sample code is self explanatory (You don’t need to mess with the setup code, just look for the piece of code that sends the characters to the screen, how the dots are turned on and off, etc.  I created 2 codes, one using digitalWrite() and another one using direct AVR I/O… I found the 2nd method to be almost 10 times faster, and drawing things on the screen, you can notice the difference in speed.

The sample codes are here:

Sample using digitalWrite()

Sample using direct AVR I/O

This is the assembly guide for the NKC Ethernet Shield for Arduino DIY KIT.

This shield is based on the WIZ812MJ module and shares the same W5100 TCP/IP chip with the official Arduino Ethernet Shield, making it 100% compatible. The current Arduino Ethernet Shield doesn’t work with the Arduino MEGA (a hack is possible, but some wiring is needed, as well as a small modification to the Ethernet library code). The NKC shield was designed to avoid this extra wiring and make it physically work with both the Arduino boards (and all its derivatives) and the Arduino MEGA board.

The KIT (purchase) comes with all the components, as shown in the next picture:

Start by opening the plastic poach and removing all the components on the table. Select the PCB, the 3.3V voltage regulator (TO-220 format) and the 2 x 100uF electrolytic capacitors.

Solder these components, make sure that the capacitors are correctly oriented, as they are polarized (long leg is positive, short leg negative. Also negative has a band on the capacitor body).

Next proceed with the LEDs, resistors and tactile switch. The switch is for resetting both the Arduino board and the Ethernet shield. The red LED is for LED13, the same LED13 that you have in your Arduino board is available on the Shield, as it indicates SPI activity. The 2 blue LEDs are for the Ethernet TX and RX activity indicators. The resistors are for limiting the current to these LEDs.

Now solder the 4 2×5 female sockets. Before applying solder, make sure they are correctly aligned.

It is time to solder the long legged pin headers: 2 x 8-pin, 2 x 6-pin and 1 x 2×3-pin (this one goes upside down!). There is also a 4-pin male header and a jumper or shunt.

The shield is ready. Plug the jumper in “Duemilanove” position (1-2). Insert the WIZ812MJ module as shown:

This is how it looks, mounted on a Freeduino board (Arduino diecimila, duemilanove, seeeduino, etc):

and the next step is to open the Arduino IDE, load some Ethernet library based sketch and enjoy your new Ethernet Shield.

If you have the Arduino MEGA board

This is how it looks:

You can keep the jumper in the Duemilanove setting.

1. Locate spi.h file (it is located under Arduino installation directory –> hardware –> libraries –> Ethernet –> utility)
2. Rename it as spi_orig.h
3. Download spiMEGA.h
4. Rename spiMEGA.h as spi.h
5. Delete all .o files from utility and Ethernet directories
6. Start the Arduino IDE
7. Load or program your Ethernet Library based shield
8. Compile –> upload sketch to the MEGA –> and Voila!!!
9. Enjoy your Arduino board connected to the NET

The jumper in MEGA position, together with the last pin (4) on the 4-pin male header, is when you cannot keep the SS signal (SPI) on Digital pin 10 and need to move it to the default position, which is digital pin 53 on the MEGA.

If this is the case, then download a different spi.h file named spiMEGAold.h, place the jumper in MEGA (2-3) position, and connect a wire from pin 4 on the Shield to digital pinn 53 on the MEGA:

The Arduino MEGA was announced officially on March 26th, 2009. The MEGA kept the odd pin header spacing to make it compatible with most Arduino shields. But unfortunately, some pins had to be moved and this movement made some shields that use SPI incompatible. One of the most popular shields, the Arduino Ethernet shield is one of the incompatible shields, as it relies on SPI for Arduino to Ethernet communication. The good news is that it is possible to make it work with the MEGA and here is the procedure:

Ingredients

• Arduino MEGA board
• Arduino Ethernet shield
• 4 x male2male jumper wires

ingredients

First the Hardware hack

The SPI signals SCK, MISO, MOSI and SS are located in pins 13, 12, 11 and 10 on the Arduino Diecimila/Duemilanove or compatible boards like freeduino and seeeduino.
These signals moved to pins 52, 50, 51 and 53 on the Arduino MEGA.
Signals SCK, MISO and MOSI are available in the ICSP 2×3 pin header also, but signal SS is missing from this header, and only available on pin 53.

As the Arduino Ethernet shield expects to get these signals from pins 13 to 10, we need to re-wire them to pins 50 to 53.

First, we need to disconnect pins 13 to 10 in the Arduino Ethernet Shield:

these4pins

Bend them slightly to the outside:

these4pinsside

And plug the Arduino Ethernet shield to the Arduino MEGA, so these 4 pins remains unplugged:

plug

Now, how are we going to get the SPI signals? From pins 50 to 53… following the next mapping:

MEGA pin 50 (MISO) to Arduino Ethernet Shield pin 12.
MEGA pin 51 (MOSI) to Arduino Ethernet Shield pin 11.
MEGA pin 52 (SCK) to Arduino Ethernet Shield pin 13.
MEGA pin 53 (SS) to Arduino Ethernet Shield pin 10.

wires1

wires2

wires3

Now the Hardware hack is complete, but there is one more change we need to do, as the original Ethernet Library included with the Arduino IDE has hardcoded the SPI signals. We need to change these hardcoded signals to match the new position in the Arduino MEGA.

Software Hack

Locate the file spi.h in the hardware/libraries/Ethernet/utility directory, under your Arduino 0015 installation.

Find and replace the following 5 lines:


#define SPI0_SS_BIT BIT2
...
#define SPI0_SCLK_BIT BIT5
...
#define SPI0_MOSI_BIT BIT3
...
#define SPI0_MISO_BIT BIT4
...
#define IINCHIP_CS_BIT BIT2


and replace them with this code:


#define SPI0_SS_BIT BIT0
...
#define SPI0_SCLK_BIT BIT1
...
#define SPI0_MOSI_BIT BIT2
...
#define SPI0_MISO_BIT BIT3
...
#define IINCHIP_CS_BIT BIT0


These 5 lines are in a non-consecutive order in the spi.h file.

After you save the edited spi.h file, remove all .o files in the utility and Ethernet directory.

Open the Arduino 0015 IDE (The Arduino MEGA requires Arduino 0015), and load your preferred Ethernet sketch or try this example that I use (You need to change the IP address to reflect the values in your network):

#include <Ethernet.h>

if (!client.connected()) {
Serial.println();
Serial.println(”disconnecting.”);
client.stop();
for(;;)
;
}
}

Compile and upload the sketch. Activate the Serial Monitor, set baud to 9600 and you should see the Google search result, in html format, like in the following screen capture:

ide

And the complete hack while getting information from Google:

working

This concludes the Arduino Ethernet Shield MEGA hack.

You can purchase the Arduino MEGA here and the Arduino Ethernet Shield here

April 14th, 2009 UPDATE
The previous hack requires moving 4 signals: SCK, MOSI, MISO and SS. As SS is used by AVR only when working SPI in SLAVE mode, I decided to try a new simpler hack, and move only 3 signals: SCK, MOSI and MISO, and use digital pin 10 as SS. This way, only 3 pins need to be bended: 13, 12 and 11.

At the beginning this seemed to be a simple modification to the original hack, but mysteriously it didn’t work. Assigning SPI0_SS_BIT and IINCHIP_CS_BIT to BIT4 (corresponding to digital pin 10 on the Arduino MEGA), the Arduino Ethernet shield couldn’t be initialized, so the sketch didn’t work (It never returned from Ethernet.begin()). After doing some research, I found that the SS pin is also used when setting AVR in SPI master mode, but only before setting bit 4 of register SPCR (Master mode) required this pin SS to be HIGH. So I tricked some more code to make it work (force SS HIGH before setting bit 4 in SPCR register to HIGH).

Hardware hack

Follow hardware hack instructions above, but only bend pins 13, 12 and 11. Wire the pins as instructed, except for the 4th wire from Arduino MEGA pin 53 to Ethernet Shield pin 10 (as this pin is not bended in this new hack).

Software hack

Forget all the changes suggested above, and follow this new changes:
Find and replace the following 6 lines:


#define SPI0_SS_BIT BIT2
...
#define SPI0_SCLK_BIT BIT5
...
#define SPI0_MOSI_BIT BIT3
...
#define SPI0_MISO_BIT BIT4
...
#define IINCHIP_CS_BIT BIT2
...
PORTB |= SPI0_SS_BIT; PORTB &= ~(SPI0_SCLK_BIT|SPI0_MOSI_BIT);\


and replace them with this code:


#define SPI0_SS_BIT BIT4
...
#define SPI0_SCLK_BIT BIT1
...
#define SPI0_MOSI_BIT BIT2
...
#define SPI0_MISO_BIT BIT3
...
#define IINCHIP_CS_BIT BIT4
...
PORTB |= SPI0_SS_BIT | BIT0; PORTB &= ~(SPI0_SCLK_BIT|SPI0_MOSI_BIT);\


By adding BIT0, we force pin SS to be HIGH when the SPCR register is set for AVR to behave like SPI master device.

I hope you find the new addition simpler to execute than the original hack.

Hi, I just saw the picture of the Arduino MEGA featured in hack-a-day

If there is an Arduino MEGA, then for sure you need a MEGAshield. Here are some pictures of the NKC MEGAShield:

Half Stackable MEGAShield = Monster MEGAShield (As called by ladyada)

I installed long legged 6-pin and 8-pin headers to make the Arduino MEGAshield stackable on the left half side (legacy Arduino side?). Here are some pictures:

Assembling the NKC Electronics XBee Shield V3.0 KIT

SCHEMATICS (click on images to enlarge)

The NKC Electronics XBee Shield V3.0 KIT is an enhanced version of the original Arduino XBee Shield. It is sold in a DIY kit format and it comes with all the components required to assemble a full XBee Shield that is pin-compatible with all Arduino format compliant boards (Arduino, Freeduino, Seeeduino, etc).
First, unpack the kit

and start with the PCB.

Let’s start with the power portion of the schematic using the following parts:

Next continue with the transistor, LEDs and other discrete components:

R1	10K resistor
R2	15K resistor
R3, R4	1K resistor
R5	330ohm resistor
RSSI	3mm LED
ASSOCIATE	3mm LED blue (transparent)
T1	BC547 transistor
reset	tactile switch

Solder the sockets and pin headers:

Next step: Insert the jumpers:

There are 4 jumpers. J1 and J2 are for upgrading the firmware on the XBee module. Leave open for normal operation (both J1 and J2 open).

Pay special attention to the alignment of the female headers. The 2×3 female socket must be placed with the female portion facing down. This board takes some signals from the ICSP connector, so this socket is mandatory.

And this is the final picture of the XBee Shield V3.0 assembled and ready to use. XBee module is not included in the kit and must be purchased separately.

http://www.nkcelectronics.com/

Assembling the Arduino^TM Diecimila Compatible Freeduino Serial v2.0 Board

SCHEMATICS (click on images to enlarge)

The Arduino diecimila compatible Freeduino serial board is a special version of the Arduino serial board designed by NKC Electronics. The board is diecimila compatible (autoreset) and includes the 13 digital pin LED for easy diagnostics and basic LED sketch execution. The v2.0 board uses a MAX232 compatible chip for interfacing with RS232. The older v1.0 board used two transistors, but had some reliability issues with auto-reset and sketch uploading.
First, unpack the kit

and start with the PCB.

Let’s start with the power portion of the schematic using the following parts:

Plug a wall plug voltage regulator (+7V to +12V). The LED lights up, indicating that the Power supply is working.
NOTE: This board is shields friendly as the 7805 voltage regulator is mounted horizontally.

Next continue with the soldering of the RS232 components:

Solder the rest of the components:

Now solder the headers and sockets:

Pay special attention to the alignment of the female headers.

And finally install the ATMEGA168/ATmega328P MCU and the MAX232 (or HIN232 / ICL232 / ICL3232) chips.

The board is ready to be used. Start the Arduino IDE and load the BLINK sketch from the examples directory. Verify that ATMEGA168 (or Duemilanove with ATmega328) is selected in Tools –> Microcontroller (MCU) and Arduino Diecimila in the Tools –> board option. Select the COM port number corresponding to the serial interface where the Freeduino serial board is connected to. Press the “Upload to I/O board” button in Arduino and the board should autoreset and complete the programming. If you selected correctly the BLINK sketch, the LED “13″ must start blinking once every 2 second (0.5Hz).

The board has space for an optional 3.3V regulator (78L33 TO-92 footprint) with it’s associated decoupling 0.1uF capacitor (C13).

http://www.nkcelectronics.com/arduino.html

Assembling the Arduino^TM Freeduino Motor Shield

SCHEMATICS (click on images to enlarge)

The Freeduino Arduino Motor Shield is the original Motor Shield V1.1 designed by David Cuartielles of the Arduino Team. This product is not certified nor endorsed by David or the Arduino Team.
First, unpack the kit

and start with the PCB. The PCB has some extra space for an encoder. It is optional to assemble the encoder section. The kit only includes the components to assemble the motor control section of the PCB.
Let’s start with the IC sockets using the following parts:

Then, we can solder the resistors and the LED.

The LED has two legs, one longer than the other. The longer leg is called ANODE (+) and the shorter is CATHODE (-). The LED goes in the PWR LED space. Insert the long leg into the left hole.

Then solder the 1K R7 resistor, and the four 100K (or 68K) R3 to R6 resistors.

We continue with the capacitors:

This is the board with all the components installed, before we solder the sockets.

NOTE: The C9 capacitor was installed backwards in the picture. Follow the marking on the PCB, which is positive down, negative up.

Solder the rest of the components: male sockets to plug the shield to the Freeduino / Arduino board, and the 4-pin female socket to plug the motors.  The 4-pin female socket was replaced by male pin header.

The motor shield, completely assembled and ready to use.

You can connect two DC motors. One goes on the first 2 socket holes (MOTOR B), from the top.

The second motor (MOTOR A)goes on the 2 bottom socket holes.

A simple Arduino code to test the shield:

// Motor Shield test
// by NKC Electronics
// Test Motor B

int dirbpin = 12; // Direction pin for motor B is Digital 12
int speedbpin = 9; // Speed pin for motor B is Digital 9 (PWM)
int speed = 200;
int dir = 0;

void setup()
{
pinMode(dirbpin, OUTPUT);
}

void loop()
{
digitalWrite(dirbpin, dir); // set direction
analogWrite(speedbpin, speed); // set speed (PWM)
dir = ((dir == 0) ? 1 : 0); // change direction
delay(10000); // 10 seconds
}

Motors can be any DC motor that can work up to the Vin voltage. Vin is the power supply voltage - 0.6V. If you are using a 12V transformer, then Vin is 11.4V. You can use a 12V motor. If you are using a 9V transformer, then Vin is 8.4V and you can use a DC motor rated at 9V.

The motor driver can support 3.6V to 36V motors (1A). But the shield is designed to take Vin from the Arduino / Freeduino power supply, before the 5V voltage regulator. You cannot supply Arduino / Freeduino with 36V without burning the voltage regulator.

If you need to use a motor rated < 7V or > 14V, you will need to modify the shield. Do not install the Vin pin header to the Arduino / Freeduino board (or install the Vin and GND pins upwards, to plug a connector from where you can supply this shield with a different voltage range than the Arduino / Freeduino board)… and install a socket and supply Vin in the Shield from a different regulated DC power source, using the same GND connection.http://www.nkcelectronics.com/arduino.html

Assembling the Arduino^TM Diecimila Compatible Freeduino Serial v1.0 Board

SCHEMATICS (click on images to enlarge)

The Arduino diecimila compatible Freeduino serial board is a special version of the Arduino serial board designed by NKC Electronics. The board is diecimila compatible (autoreset) and includes the 13 digital pin LED for easy diagnostics and basic LED sketch execution.
First, unpack the kit

and start with the PCB.

Let’s start with the power portion of the schematic using the following parts:

Plug a wall plug voltage regulator (+7V to +12V). The LED lights up, indicating that the Power supply is working.

NOTE: This board is not shield friendly, as the 7805 is too tall and there is no room to install it horizontally.

If you need to use shields with this board, mount the 7805 on the bottom side of the board following the next pictures:

The result is shown with the XBee shield, Motor controller shield and NKC Electronics protoshield.

Next continue with the soldering of the RS232 components:

Solder the rest of the capacitors and resistors:

Now solder the crystal, switch and the 13-pin LED:

Now solder the headers and sockets:

Pay special attention to the alignment of the female headers.

And finally install the ATMEGA168 MCU.

The board is ready to be used. Start Arduino0009 or Arduino0010 and load the BLINK sketch from the examples directory. Verify that ATMEGA168 is selected in Tools –> Microcontroller (MCU) and Arduino Diecimila in the Tools –> board option. Select the COM port number corresponding to the serial interface where the Freeduino serial board is connected to. Press the “Upload to I/O board” button in Arduino and the board should autoreset and complete the programming. If you selected correctly the BLINK sketch, the LED “13″ must start blinking once every 2 second (0.5Hz).

http://www.nkcelectronics.com/arduino.html

Assembling the Arduino^TM Compatible Freeduino Board

SCHEMATICS (click on images to enlarge)

The Arduino diecimila compatible Freeduino board is a special version of the USB diecimila board designed by the Freeduino team using all through-hole components (except FT232RL chip), for easy assembly. The board was designed by Bill Westfield of the Freeduino team.

The latest board is v1.22 which schematic is exactly the same as v1.19.1 and V1.20.  v1.22 assembles exactly the same as v1.19.1, except for the F1 PTC resettable fuse and it includes the mini USB B socket, already presoldered to the board.

First, unpack the kit

and start with the PCB. The Freeduino board comes with the FT232RL chip,  PTC fuse  and mini USB B socket pre-soldered (v1.22 only), eliminating the most difficult task in the assembly process of the Freeduino board.

First assemble the USB portion of the board.

Identify and separate the following components:

Solder the parts to the board, in any order. This completes the USB portion of the schematic.

Board v1.22 and V1.19.1: the F1 PTC resettable fuse is the blue or green rectangle marked LF050 and it is pre-soldered in the PCB.

Board V1.20: the F1 PTC resettable fuse is a through-hole component that looks very similar to a ceramic capacitor, but has markings like XF050. It must be soldered on F1.

This is how the PTC fuse for Board V1.20 looks like:

And it must be soldered in F1:

Plug the small shunt in SV1, shorting central pin and the top pin (USB). Install the FTDI drivers that are installed under the Arduino0009 or Arduino0010 directory. Connect the board to a Mac or PC. The LED in the board lights up and in windows you will hear a beep, indicating that windows identified an USB device. Unplug the USB connector from the board to continue soldering the rest of the components.

After testing the USB interface, you can continue soldering the rest of the components, in any order you like. I prefer to complete the power portion of the schematic using the following parts:

Move the shunt in SV1 to short the central pin and the bottom pin (EXT). This is the indication that the external power supply will be used, instead of USB. Plug a wall plug voltage regulator (+7V to +12V). The LED lights up, indicating that the Power supply is working.

The kit can include a ceramic oscillator (orange component with 3 legs) or a crystal plus 2 x 22pF ceramic capacitors (small round brown, marked 22).  Picture of the installed ceramic oscillator:

Picture of the installed crystal and 22pF ceramic capacitors:

Solder the rest of the components:

Now solder the headers and sockets:

Pay special attention to the alignment of the female headers.

And finally install the ATmega328 MCU (ATmega168 on older boards).

The board is ready to be used. Start Arduino and load the BLINK sketch from the examples directory. Verify that ATmega328 (ATmega168 in older boards) is selected in Tools –> Microcontroller (MCU). Select the COM port number corresponding to the USB serial interface. If the port number is high (not in the 1-10 range), then you need to change it using Device Manager (in windows) to use a lower number. Press the “Upload to I/O board” button in Arduino and the board should autoreset and complete the programming. If you selected correctly the BLINK sketch, the LED “L” must start blinking once every 2 second (0.5Hz).If you use the new Arduino0010, you don’t need to worry about the COM port number being higher than 10 in Windows environment. In previous releases, COM port number needed to be 10 or lower. With Arduino0010, I have tested COM port numbers up to 36 and it is recognized perfectly.

http://www.nkcelectronics.com/arduino.html

Assembling the Arduino^TM Diecimila Compatible USB Board v2.2

SCHEMATICS (right click –> view image)

The Arduino diecimila compatible USB 2.2 board is a special version of the USB diecimila board designed by NKC Electronics using all through-hole components (except FT232BL chip), for easy assembly.

First, unpack the kit

and start with the PCB. The Arduino Diecimila compatible USB board comes with the FT232BL chip pre-soldered, eliminating the most difficult task in the assembly process of the USB board.

Identify and separate the following components:

Solder the parts to the board, in any order. This completes the USB portion of the schematic. Plug the small shunt in SV1, shorting central pin and the top pin (USB). Install the FTDI drivers that are installed under the Arduino0009 or Arduino0010 directory. Connect the board to a Mac or PC. The LED in the board lights up and in windows you will hear a beep, indicating that windows identified an USB device. Unplug the USB connector from the board to continue soldering the rest of the components.

After testing the USB interface, you can continue soldering the rest of the components, in any order you like. I prefer to complete the power portion of the schematic using the following parts:

Move the shunt in SV1 to short the central pin and the bottom pin (EXT). This is the indication that the external power supply will be used, instead of USB. Plug a wall plug voltage regulator (+7V to +12V). The LED lights up, indicating that the Power supply is working.
If you are planning on using Arduino shields in the future, then I recommend you try to bend the voltage regulator a little bit to the back, so you can fit a shield on top of this board. It will not lay horizontal, it doesn’t fit. But it has some room to be bended a little to the back.

Now solder the rest of the components:

Pay special attention to the alignment of the female headers.

The board is ready to be used. Start Arduino0009 and load the BLINK sketch from the examples directory. Verify that ATMEGA168 is selected in Tools –> Microcontroller (MCU). Select the COM port number corresponding to the USB serial interface. If the port number is high (not in the 1-10 range), then you need to change it using Device Manager (in windows) to use a lower number. Press the “Upload to I/O board” button in Arduino and the board should autoreset and complete the programming. If you selected correctly the BLINK sketch, the LED “L” must start blinking once every 2 second (0.5Hz).

If you use the new Arduino0010, you don’t need to worry about the COM port number being higher than 10 in Windows environment. In previous releases, COM port number needed to be 10 or lower. With Arduino0010, I have tested COM port numbers up to 36 and it is recognized perfectly.

http://www.nkcelectronics.com/arduino.html