The Arduino site has a decent walkthrough, but I found some of the steps to be confusing or outdated. Hopefully, this will get you up and running quickly.

Overview

Most of this setup will have to happen once, then starting new projects is typically as easy as duplicating a simple, skeleton project. Getting the paths and configuration options correct for this initial project was the most confusing for me, but I haven’t needed to tinker with them again.

To begin, download Eclipse for C/C++ Developers, or install the C/C++ plugin for your existing Eclipse version (these instructions assume Eclipse 3.5 Galileo). To install an Eclipse plugin:

• Open Eclipse. Navigate to Help > Install New Software…

• Select CDT from the drop down menu. If CDT is not present, then click the add button and paste the link to the plugin update site in the Location field: http://download.eclipse.org/tools/cdt/releases/galileo
• Select Eclipse C/C++ Development Tools, then click “Next >” and “Finish” on the following screen. This may prompt you to restart Eclipse, however select No so we can install the next plugin.

• Return to the Install New Software dialog. Paste in the location for the AVR Plugin and select it and click Next to install. You may have to agree to license terms. http://avr-eclipse.sourceforge.net/updatesite/

• AVR tools. You should install tools appropriate for your platform:
  • Mac OS X: CrossPack (Note: I’m targeting this tutorial for an OS X system)
  • Linux: apt-get install avrdude binutils-avr gcc-avr avr-libc gdb-avr
  • Windows: WinAVR

Setup Eclipse

After the plugins have been installed they need to be configured. Specifically, the paths to the AVR Tools need to be verified.

• Open the Eclipse Preferences: Eclipse > Preferences. Twirl down the AVR category and select “Paths”. Verify that the paths have located the correct AVR toolkit (CrossPack-AVE on OS X). You can edit these fields as necessary.

• Select the AVRDude category. I’ve found that I need to add a Programmer configuration for each Arduino (or USB to Serial adapter) that I use. Please let me know if you can get a better solution working with wildcards.
  • Give this configuration a descriptive name. I’m using “Arduino Diecimila”.
  • Select “Arduino” as the Programmer Hardware
  • Enter the correct port for your Arduino. You can display this by plugging the Arduino into the computer, opening the Terminal then typing: /dev/tty.usbserial then hitting the Tab key. The remainder of the port name should appear.
  • Set the baud rate to 19200
  • Click OK. Then close the preferences.

Create an Arduino project

For the first project you’ll need to manually set up the configuration. I’d *highly* recommend making a basic blink sketch, then duplicate it for each new project. This is what the tutorial will set up. Alternatively, you can try importing this basic project, but may have to set up the paths for your system anyway. Eclipse Blink Sketch

• Go to File -> New -> C Project
• Select Empty Project under AVR Cross Target Application and name the project “Hello_Blink”.
• Click Finish.
• Select the “Hello_Blink” project in the Project Explorer panel, then navigate to Project > Properties menu.
• Twirl down the AVR category and select AVRDude.
  • Select your Arduino from the Programmer configuration menu
• Select Target Hardware at left.
  • Ensure that your Arduino is plugged into your computer via USB (and is powered on).
  • Click “Load from MCU”. This should query the Arduino for it’s type and detect it correctly.
    • If this doesn’t work, typically the Diecimila is an ATmega168 while the Duemilanove is an ATmega328

Each Ardiuno project needs to include the Ardunio core library. This file is compiled automatically by the Arduino IDE. While you could compile it yourself in Eclipse, the easiest way to get it is to build a simple sketch in the Arduino IDE, then copy the “core.a” file into your Eclipse project.

• Start the Arduino IDE
• Open the Blink sketch (File > Examples > Digital > Blink)
• Click the “Verify” button to compile the sketch
• Select Sketch > Show Sketch Folder
• Drag core.a into your Eclipse Hello_Blink project to copy it in.
• Right-click on core.a, select Rename and change it to “libcore.a”

Now we set up the correct building settings:

• Twirl down C/C++ Build and select Settings
• Select “Additional Tools in Toolchain”
• Check the following:
  • Generate HEX for Flash Memory
  • Print Size
  • AVRDude
• Uncheck Generate Extended Listing

• Select AVR Compiler
  • Change the command from avr-gcc to avr-g++
• Select AVR Compiler > Directories
  • Add an Include Path to the header files within the Arduino.app bundle (look at the screenshot)
  • You can right-click on Arduino.app and select Show Package Contents, then navigate to the Contents/Resources/Java/hardware/cores/arduino folder

• Select AVR Compiler > Debugging
  • Set “Generate Debugging info” to “No debugging info”
• Select AVR Compiler
  • Set the Optimization level to Size Optimizations

• Select AVR Assembler > Debugging
  • Set “Generate Debugging info” to “No debugging info”

• Select AVR C Linker > Libraries
  • Add a library named “core”
  • Add a library path. If libcore.a is in the Hello_Blink project folder, the path will be “${workspace_loc:/Hello_Blink}”

Add a new main.c source file

This file will contain your typical Arduino sketch code. There are additional bits of code that are typically added automatically by the Arduino IDE which need to be explicitly written in Eclipse. Feel free to copy the below code.

• Go to File > New… > C Source File. Name this file main.c
• Paste in the following for a basic blink sketch:

#include "WProgram.h"

// prototypes
void blink(int n, int d);

// variables
int ledPin = 13; // LED connected to digital pin 13

void setup(){
Serial.begin(9600);	// opens serial port, sets data rate to 9600 bps
pinMode(ledPin, OUTPUT);      // sets the digital pin as output
Serial.println("------------------");
Serial.println("   hello world");
Serial.println("------------------");
}

void loop(){

  blink(3, 50); // blink led (n times, ms interval)
  delay(1000); // wait 1 sec
}

void blink(int n, int d){
  for (int i=0; i<n; i++) {
    digitalWrite(ledPin, HIGH);
    delay(d/2);
    digitalWrite(ledPin, LOW);
    delay(d/2);
  }
}

int main(void)
{
init();

setup();

for (;;)
loop();

return 0;
}

Building

When you’re ready to build and upload to the Arduino, click the Hammer icon. This should compile your program and then run avrdude, which uploads to the Arduino.

New projects

Duplicating a project in Eclipse is as simple as selecting the source project in the Project Explorer panel, copying it (Edit > Copy) then paste. Eclipse will prompt you for a new name , then will create a new, duplicate project in the workspace.

If you keep the blink sketch intact, you should be able to duplicate it each time and avoid the above setup.

Follow up

You should be all set to work on Arduino projects in Eclipse. Note that Eclipse uses various “perspectives” for different modes and programming languages. Typically, you’ll be working in the C/C++ perspective while working on Arduino code. If you’d like to switch back to the Java perspective for working with Processing, select it from the perspectives at the upper right of the main window, or Navigate to Window > Open Perspective > Other…

I made a few (simple in hindsight) changes to the project which has worked well for me so far.

Bill of Materials

• Xcode – provided with the Apple Developer Tools
• Arduino IDE – needed for the core libraries for programming the Arduino
• AVR programming tools. Easiest solution is to install the AVRMacPack.
  • You can alternatively install avr-gcc, avr-libc, avrdude and libusb via MacPorts or Fink.
• Project Template for Arduino on Xcode.
  • For reference: Original source of the ArduinoXcode project template.

Set-up

1. Install Xcode. Typically at /Developer
2. Install Arduino. Typically at /Applications/arduino-x.xx
   Update: Arduino 017+ on OS X is now provided as an application bundle. See below.
3. Install AVRMacPack. The tools are located at /usr/local/AVRMacPack
4. Uncompress the ArduinoOnXcode project template. Move it to /Developer/Library/Xcode/Project Templates/Other/
5. Open the Makefile in the ArduinoOnXcode folder. Edit the ARDUINO and AVRDUDE_DIR lines to reflect your system. The default values should work “as is” with this tutorial. Note: for Arduino 017+ change the ARDUINO path to:
   /Applications/Arduino.app/Contents/Resources/Java/hardware/cores/arduino

Use

Create a new project in Xcode and select Other>ArduinoOnXcode. You’ll be prompted for a save location for the new project. Select a location and name and click “Save”.

The code for your sketch is written in “main.cpp”. Any custom functions you write will need to be either prototyped at the top of the file where indicated, or will have to be declared before they are used in setup() or loop(). A prototype just indicates the return value and any arguments a function requires. The blink function returns nothing (void) and expects two integer arguments, which is prototyped as: void blink(int n, int d); Again, look at the example code in the template for guidance.

Compiling/Uploading to Arduino

Connect the Arduino via USB. Change the Active Target to “Upload”. The select Build>Clean All Targets. This will compile the code and upload it to the Arduino. The template contains a simple blink sketch to confirm that the process worked.

Serial Terminal

I recall a neat trick to enable easy access to opening a serial terminal through Xcode, but can’t find it now. In the meantime you can use the Terminal.app to open a serial connection to the Arduino:

1. Open /Applications/Utilities/Terminal.app
2. The the command prompt in the new terminal window type (without the quote marks),
   • “screen /dev/tty.usbserial”
   • Hit the Tab key. The rest of the serial port’s name should appear. If it doesn’t, verify that the Arduino is plugged in via serial and is powered on.
   • For example, the command for my Arduino looks like: “screen /dev/tty.usbserial-A4001Jdl”
3. Press return to execute the screen command. The Arduino will reset and should open the serial port.
4. You can type to send characters, but there is no local echo (ie. you won’t see the typed characters)
5. To exit and close the serial port
   • Press Control-A then ‘k’ to “kill” the window. This just stops the screen program and returns to the command prompt.

Of course, you could use ZTerm instead…
Good luck!