Tuesday, June 19, 2012

Arduino control RGB LEDs

Arduino control RGB LEDs

Arduino compatible Board from ETT model ET-BASE-AVR-EASY328 more info

RGB LEDs model SPNovaLED NMRTB-USD-AAB+ADE+Y2Z1-1 ( Dominant Semiconductors)

RGB LED spec
Featuring a staggering brilliance and significant flux output, the SPNovaLED™ showcases the latest technological advent in this range. With its extremely high level of brightness and the ultra low high profile, which is only 1.5 mm are highly suitable for both conventional lighting and specialized application such as automotive signal lights, traffic lights, channel lights, tube lights and garden lights among others.

> Super high brightness surface mount LED.
> High flux output.
> 125° viewing angle.
> Compact package outline (LxWxH) of 6.0 x 6.0 x 1.5mm.
> Ultra low height profile - 1.5 mm.
> Designed for high current drive; typically 250 mA.
> Low junction-to-solder point thermal resistance; RTH js = 50 K/W.
> Qualified according to JEDEC moisture sensitivity Level 2.
> Compatible to IR reflow soldering.
> Environmental friendly; RoHS compliance.

> Signage: full colour display video notice board, signage, special effect lighting.
> Lighting: architecture lighting, general lighting, garden light, channel light.

Download RGB LEDs Datasheet

Arduino code

 This example shows how to fade an LED using the analogWrite() function.
#define REDPIN 9             // LED connected to digital pin 9
#define GREENPIN 10    // LED connected to digital pin 10
#define BLUEPIN 11        // LED connected to digital pin 11

#define FADESPEED 5

void setup()  {
  pinMode(REDPIN, OUTPUT);

void loop()  {
   int r, g, b;
  for (r = 0; r < 120; r++) {     // fade from blue to violet
    analogWrite(REDPIN, r);
  for (b = 120; b > 0; b--) {      // fade from violet to red
    analogWrite(BLUEPIN, b);
  for (g = 0; g < 120; g++) {   // fade from red to yellow
    analogWrite(GREENPIN, g);
  for (r = 120; r > 0; r--) {        // fade from yellow to green
    analogWrite(REDPIN, r);
  for (b = 0; b < 120; b++) {    // fade from green to teal
    analogWrite(BLUEPIN, b);
  for (g = 120; g > 0; g--) {      // fade from teal to blue
    analogWrite(GREENPIN, g);

Friday, June 8, 2012

Android ADK - ETT Mega2560

Android ADK - ETT Mega2560 Microcontroller Board

Product Description
The ETT Mega 2560 ADK Board is based on the ATmega2560, which is fully compatible with Google's ADK and it includes all the basics you need to start building your own Android accessories. It has a USB host interface to connect with Android based phones, based on the MAX3421 IC and has number of facilities for communicating with a computer, another Arduino, or other microcontrollers. It is designed in a way that allows it to be reset by software running on a connected computer. Each of the 50 digital pins on the ADK can be used as an input or output.
ETT Mega 2560 ADK Board supports Android devices v1.5 using MicroBridge and v2.3.4 and above with Google Open Accessories API (ADK).

  • Supports Android v2.3.4 with Android Open Accessories development Kit (ADK)
  • Supports Android v1.5 with Android Debug Bridge (ADB) using MicroBridge
  • Arduino Mega 2560 compatible (256K Flash MCU)
  • Clock speed of 16 MHz
  • Operating voltage: 5V
  • Input Voltage (recommended): 7V to 12V (Power Jack 2.55mm)
  • Digital I/O pins: 54
  • 16 Analog inputs
  • 14 PWM outputs
  • 4 Hardware serial ports (UART)
  • 1 Hardware TWI (I2C)
  • 1 Hardware SPI (up to 8Mbps)
  • On board MAX3421 USB host
  • On board FT232RL USB slave

Because Arduino that is the development project on AVR MCU as Open Source has been published, it is popular and widespread shortly. For Software, it has been continued developing; and nowadays (September, 2011) Program Arduino has been improved to be version “arduino-0022”. For Hardware, it has been continued improving as same as Software. In the past,
it only supports in developing program with small Chip MCU 28PIN such as ATMEGA8/ATMEGA88/ATMEGA168/ATMEGA328; and nowadays it can support in developing program with larger Chip MCU 100PIN such as ATMEGA1280/ATMEGA2560, respectively. Recently, it has developed capabilities of Arduino on AVR to connect with USB Host devices, so Arduino can be modified to connect with various types of USB Device such as USB HID Keyboard or USB HID Mouse. Moreover, it is more interesting because this Arduino can be modified to interface with smart phones that use Operating System of Android. This Operating System is Open Source from Google, a large web browser of the world, called Android Phone. In this case, user can communicate and command Board Arduino through Android Phone well. This is a step of developing Arduino on AVR that makes this Arduino more interesting and outstanding.

Now, ETT has developed Chip AVR MCU No.ATMEGA2560 and MAX3421 to make Board Arduino called “ET-MEGA2560-ADK”; it has USB Host that supports the connection between USB Device and
Android Phone. It has designed I/O Pins, including size according to the standard of Board “Arduino Mega”; moreover, it adds USB Host and improves some restrictions better. So, it is more convenient for user to use this device.

Specifications of Board ET-MEGA2560-ADK
  • Use ATMEGA2560 as MCU on Board; RUN by 16 MHz Frequency from Crystal Oscillator
  • Has 256 Kbyte(4 KByte is reserved for Bootloader)/ 8 Kbyte SRAM/ 4 KByte EEPROM
  • 100% Support for developing program by C++ Language of Arduino according to Arduino MEGA
  • Use USB Bridge No.FT232RL from FTDI and Over Current Protection to communicate and download Code from computer into board without using any external Programmer Device
  • Use On Board USB Host(MAX3421) to interface with USB Device or Android ADK device
  • Support ADK (Android Open Accessories development Kit) to develop program; it uses Google Open Accessories API with Android device that has been installed Android Operating Systems V2.3.4 or higher.
  • Support Android Debug Bridge (ADB) to develop program; it uses Library of Microbridge with Android device that has been installed Android Operating Systems V1.5 or higher.
  • Has 54Pin Digital I/O as follows;
  • 16 Pin Analog Input (10BIT 16-CH ADC)
  • 14 PWM outputs
  • 4 UART(Hardware Serial Port) as TTL Logic
  • 1 Hardware TWI (I2C)
  • 1 Hardware SPI (up to 8Mbps)
  • Size of PCB Board and position of Pin Connectors accord with Arduino MEGA, so it can be used with all Board Shields that are made to support Board Arduino Mega. This PCB Board size is 5.3cm. x 10.2cm.
  • Support External Supply that is both 7-12V AC and DC. It uses 1A Switching Regulate (LM2575-5V) to reduce heat when using very high current. It can use Power Supply from Port USB if using current is not higher than 500mA. In this case, there is circuit to choose Power Supply automatically; it disables Power Supply from USB automatically when it is connected with external Power Supply.
More info
What is Android ADK? 

Beginning Android ADK with Arduino eBook. ( Free Download )

Tuesday, June 5, 2012

Arduino ADK Microcontroller Board

Arduino ADK Micro controller Board


    The Arduino ADK based on the Mega 2560 is a microcontroller board based on the ATmega2560 (datasheet). It has a USB host interface to connect with Android based phones, based on the MAX3421e IC. It has 54 digital input/output pins (of which 14 can be used as PWM outputs), 16 analog inputs, 4 UARTs (hardware serial ports), a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, and a reset button.
Similar to the Mega 2560 and Uno, it features an ATmega16U2 (ATmega8U2 in the revision 1 and revision 2 boards) programmed as a USB-to-serial converter.
For information on using the board with the Android OS, see Google's ADK documentation.
Schematic, Reference Design & Pin Mapping
EAGLE files: Arduino_ADK-Mega_2560-Rev3-reference-design.zip
Schematic: Arduino ADK_Mega_2560-schematic.pdf
Pin Mapping: PinMap2560 page
Microcontroller ATmega2560
Operating Voltage 5V
Input Voltage (recommended) 9V
Input Voltage (limits) 6-18V
Digital I/O Pins 54 (of which 14 provide PWM output)
Analog Input Pins 16
DC Current per I/O Pin 40 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 256 KB of which 8 KB used by bootloader
Clock Speed 16 MHz

      The Arduino ADK can be powered via the USB connection or with an external power supply. The power source is selected automatically. External (non-USB) power can come either from an AC-to-DC adapter (wall-wart) or battery. The adapter can be connected by plugging a 2.1mm center-positive plug into the board's power jack. Leads from a battery can be inserted in the Gnd and Vin pin headers of the POWER connector.
NB: Because the ADK is a USB Host, the phone will attempt to draw power from it when it needs to charge. When the ADK is powered over USB, 500mA total is available for the phone and board.The external power regulator can supply up to 1500mA. 750mA is available for the phone and ADK board. An additional 750mA is allocated for any actuators and sensors attached to the board. A power supply must be capable of providing 1.5A to use this much current.
The board can operate on an external supply of 5.5 to 16 volts. If supplied with less than 7V, however, the 5V pin may supply less than five volts and the board may be unstable. If using more than 12V, the voltage regulator may overheat and damage the board. The recommended range is 7 to 12 volts.

The power pins are as follows:

VIN. The input voltage to the Arduino board when it's using an external power source (as opposed to 5 volts from the USB connection or other regulated power source). You can supply voltage through this pin, or, if supplying voltage via the power jack, access it through this pin.
5V. The regulated power supply used to power the microcontroller and other components on the board. This can come either from VIN via an on-board regulator, or be supplied by USB or another regulated 5V supply.
3V3. A 3.3 volt supply generated by the on-board regulator. Maximum current draw is 50 mA.
GND. Ground pins.

The ADK has 256 KB of flash memory for storing code (of which 8 KB is used for the bootloader), 8 KB of SRAM and 4 KB of EEPROM (which can be read and written with the EEPROM library).

Input and Output
Each of the 50 digital pins on the ADK can be used as an input or output, using pinMode(), digitalWrite(), and digitalRead() functions. They operate at 5 volts. Each pin can provide or receive a maximum of 40 mA and has an internal pull-up resistor (disconnected by default) of 20-50 kOhms. In addition, some pins have specialized functions:
Serial: 0 (RX) and 1 (TX); Serial 1: 19 (RX) and 18 (TX); Serial 2: 17 (RX) and 16 (TX); Serial 3: 15 (RX) and 14 (TX). Used to receive (RX) and transmit (TX) TTL serial data. Pins 0 and 1 are also connected to the corresponding pins of the ATmega16U2 (ATmega8U2 in the revision 1 and revision 2 boards) USB-to-TTL Serial chip.
External Interrupts: 2 (interrupt 0), 3 (interrupt 1), 18 (interrupt 5), 19 (interrupt 4), 20 (interrupt 3), and 21 (interrupt 2). These pins can be configured to trigger an interrupt on a low value, a rising or falling edge, or a change in value. See the attachInterrupt() function for details.
PWM: 0 to 13. Provide 8-bit PWM output with the analogWrite() function.
SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). These pins support SPI communication using the SPI library. The SPI pins are also broken out on the ICSP header, which is physically compatible with the Uno, Duemilanove and Diecimila.
USB Host: MAX3421E. The MAX3421E comunicate with Arduino with the SPI bus. So it uses the following pins:
Digital: 7 (RST), 50 (MISO), 51 (MOSI), 52 (SCK).
NB:Please do not use Digital pin 7 as input or output because is used in the comunication with MAX3421E
Non broken out on headers: PJ3 (GP_MAX), PJ6 (INT_MAX), PH7 (SS).
LED: 13. There is a built-in LED connected to digital pin 13. When the pin is HIGH value, the LED is on, when the pin is LOW, it's off.
TWI: 20 (SDA) and 21 (SCL). Support TWI communication using the Wire library. Note that these pins are not in the same location as the TWI pins on the Duemilanove or Diecimila.
The ADK has 16 analog inputs, each of which provide 10 bits of resolution (i.e. 1024 different values). By default they measure from ground to 5 volts, though is it possible to change the upper end of their range using the AREF pin and analogReference() function.
There are a couple of other pins on the board:
AREF. Reference voltage for the analog inputs. Used with analogReference().
Reset. Bring this line LOW to reset the microcontroller. Typically used to add a reset button to shields which block the one on the board.

More info
What is Android ADK? 

Beginning Android ADK with Arduino eBook. ( Free Download )

Monday, June 4, 2012

Android ADK Microcontroller Board

Android ADK Micro-controller Board

The Accessory Development Kit (ADK) is basically a micro-controller development board that adheres to the simple Open Accessory Standard Protocol created by Google as a reference implementation. Although that could be any board fulfilling the specification to be ADK compatible, most boards are based on the Arduino design, which is an open hardware platform created in 2005. Those boards are USB-enabled micro-controller boards based on the Arduino Mega2560 and the implementation of the Circuits@Home USB Host Shield. However, there are other board designs known to be ADK compatible, such as PIC-based boards or even plain USB host chip boards such as the VNCII by FTDI. Google decided to build its reference kit upon the Arduino Mega2560 design and provided the software and hardware resources as open source. This was a clever move because the Arduino community has grown tremendously over the last years, enabling designers, hobbyists, and average Joes to easily make their ideas come to life. With the ever-growing communities of both factions of Android and Arduino enthusiasts, the ADK had a pretty good start.

To communicate with the hardware boards, an Android-enabled device needs to fulfill certain criteria. With Android Honeycomb version 3.1 and backported version 2.3.4, the necessary software APIs were introduced. However, the devices also have to ship with a suitable USB driver. This driver enables general USB functionality but, in particular, it enables the so-called accessory mode. The accessory mode allows an Android device that has no USB host capabilities to communicate with external hardware, which in turn acts as the USB host part.
The specification of the Open Accessory Standard stipulates that the USB host has to provide power for the USB bus and can enumerate connected devices. The external device has to provide 500mA at 5V for charging purposes of the Android device according to the USB 2.0 specification.

The ADK also provides firmware for the development board which comes in the form of a set of source code files, libraries, and a demokit sketch, which is the Arduino term for a project or source code file. The firmware cares about the enumeration of the USB bus and finding a connected device that is accessory modecompatible.
Google also provides an example app for the Android device that easily accesses and demonstrates the capabilities of the reference board and its sensors and actuators. If you are working with a derivative board that doesnt have the same variety of sensors, you still can work with the example app, but you might want to strip the code down to only the basic part of the communication.
When you set up an ADK hardware project you are building a so-called Android accessory. Your hardware project is an accessory for the Android device such as, for example, a keyboard would be for a PC, with the difference being that your accessory provides the power for the whole system. Accessories need to support the already mentioned power supply for the device and they must adhere to the Android accessory protocol. The protocol dictates that the accessory follows four basic steps to establish a communication to the Android device:

1. The accessory is in wait state and tries to detect any connected devices.
2. The accessory checks for accessory mode support of the device.
3. The accessory tries to set the device in accessory mode if it is necessary.
4. If the device supports the Android accessory protocol, the accessory establishes the communication.
If you want to learn more about the ADK and the Open Accessory Standard have a look at the Android developer pages at http://developer.android.com/guide/topics/usb/adk.html.

The Google ADK Board
The Google ADK is the reference kit presented at the Google IO in May 2011 and it was the first board adhering to the Open Accessory Standard. The kit comes with the ADK base board and a demo shield, as shown in Picture.
The Arduino ADK Board
The Arduino ADK  is an ADK-compatible base board from the makers of the Arduino series themselves. It is also based on the ATmega2560 and only differs slightly from the Google reference board.

The Seeeduino ADK Board
The Seeeduino ADK board (Figure 1-5), also derived from the ATmega board, looks quite similar to the standard Arduino ADK board but, at second glance, it has some nice extra features

The IOIO Board
The IOIO (pronounced yo-yo) board is a PIC micro-controllerbased development board developed by Sparkfun Electronics before the announcement of the Open Accessory Standard.

More ADK Possibilities
After you have seen the most common boards with ADK support out there, youll probably wonder if thats all there is. Although the Open Accessory Standard is only about a year old, the number of boards already available is incredible, with many still to come in this young but rapidly evolving field of open source hardware. There are still plenty of other possibilities for developing with the Open Accessory Standard. Some represent pure DIY (do-it-yourself) approaches, while others are extensions for boards that have been in use since before the ADK came out.
One early approach was to port the ADK to the common Arduino Uno or Duemilanove. The only thing you needed was an additional USB host shield to connect the Android device to. I was one of those early DIY hackers who went in that direction. At the time, it was the only affordable alternative to the original Google reference board. Nowadays, I wouldnt recommend it; there are already perfect all-inone boards that dont need additional shields, hacking, or stripping of code. If you still want to use your regular Arduino there are a lot of shops carrying USB host shields you can use:

Which Board Should You Use?
Now that you have read about the variety of boards supporting the Open Accessory Standard that are already out there you might wonder which board is the right one for your own project. This is always a hard question, for which there is no single answer. You should plan your project thoroughly ahead of time to analyze which board fits best.
If you are a beginner in the world of hardware development and ADK, you should stick to the boards that are most commonly used out in the wild. As of this writing, that would be the Google ADK board, which was given out to hundreds of developers attending the Google IO 2011. If you are not one of the lucky ones to have received one of these boards and your budget is pretty tightwhich is usually the caseconsider the standard Arduino ADK board. Both of these boards are used in most hacker and maker projects I have seen so far and they have a huge community built around them to help you if you are in need.

Table gives you an overview of the boards under discussion.

Comparison of the Most Common ADK-Enabled Boards

ADK Boards
Google ADK
Arduino ADK
Seeeduino ADK
Sparkfun IOIO


CPU clock speed
16 MHz
16 MHz
16 MHz
32 MHz
Flash memory
256 Kbytes
256 Kbytes
256 Kbytes
256 Kbytes
8 Kbytes
8 Kbytes
8 Kbytes
96 Kbytes
Digital IO pins
54 (14 PWM)
54 (14 PWM)
54 (14 PWM)
 48 (28 PWM)

Analog input pins
Input voltage
voltage 5.5V - 16V
voltage 5.5V - 16V
voltage 5.5V - 16V
5V - 15V
DC power
USB A-type
USB micro B-type

DC power
USB A-type
USB B-type

DC power
USB A-type
USB micro B-type

USB A-type

More info
What is Android ADK? 

Beginning Android ADK with Arduino eBook. ( Free Download )