Merge branch 'master' of ssh://hygiene/srv/git/arduinisten

arduino-0018-linux/arduino

@@ -0,0 +1,22 @@
+#!/bin/sh
+ 
+APPDIR="$(dirname -- "${0}")"
+
+cd $APPDIR
+ 
+for LIB in \
+    java/lib/rt.jar \
+    java/lib/tools.jar \
+    lib/*.jar \
+    ;
+do
+    CLASSPATH="${CLASSPATH}:${APPDIR}/${LIB}"
+done
+export CLASSPATH
+
+LD_LIBRARY_PATH=`pwd`/lib:${LD_LIBRARY_PATH}
+export LD_LIBRARY_PATH
+
+export PATH="${APPDIR}/java/bin:${PATH}"
+
+java -Dswing.defaultlaf=com.sun.java.swing.plaf.gtk.GTKLookAndFeel processing.app.Base

arduino-0018-linux/examples/Analog/AnalogInOutSerial/AnalogInOutSerial.pde

@@ -0,0 +1,50 @@
+/*
+  Analog input, analog output, serial output
+ 
+ Reads an analog input pin, maps the result to a range from 0 to 255
+ and uses the result to set the pulsewidth modulation (PWM) of an output pin.
+ Also prints the results to the serial monitor.
+ 
+ The circuit:
+ * potentiometer connected to analog pin 0.
+   Center pin of the potentiometer goes to the analog pin.
+   side pins of the potentiometer go to +5V and ground
+ * LED connected from digital pin 9 to ground
+ 
+ created 29 Dec. 2008
+ by Tom Igoe
+ 
+ */
+
+// These constants won't change.  They're used to give names
+// to the pins used:
+const int analogInPin = 0;  // Analog input pin that the potentiometer is attached to
+const int analogOutPin = 9; // Analog output pin that the LED is attached to
+
+int sensorValue = 0;        // value read from the pot
+int outputValue = 0;        // value output to the PWM (analog out)
+
+void setup() {
+  // initialize serial communications at 9600 bps:
+  Serial.begin(9600); 
+}
+
+void loop() {
+  // read the analog in value:
+  sensorValue = analogRead(analogInPin);            
+  // map it to the range of the analog out:
+  outputValue = map(sensorValue, 0, 1023, 0, 255);  
+  // change the analog out value:
+  analogWrite(analogOutPin, outputValue);           
+
+  // print the results to the serial monitor:
+  Serial.print("sensor = " );                       
+  Serial.print(sensorValue);      
+  Serial.print("\t output = ");      
+  Serial.println(outputValue);   
+
+  // wait 10 milliseconds before the next loop
+  // for the analog-to-digital converter to settle
+  // after the last reading:
+  delay(10);                     
+}

arduino-0018-linux/examples/Analog/AnalogInSerial/AnalogInSerial.pde

@@ -0,0 +1,29 @@
+/*
+  Analog input, serial output
+ 
+ Reads an analog input pin, prints the results to the serial monitor.
+ 
+ The circuit:
+
+ * potentiometer connected to analog pin 0.
+   Center pin of the potentiometer goes to the analog pin.
+   side pins of the potentiometer go to +5V and ground
+ 
+ created over and over again
+ by Tom Igoe and everyone who's ever used Arduino
+ 
+ */
+ 
+ void setup() {
+  Serial.begin(9600); 
+ }
+ 
+ void loop() {
+  // read the analog input into a variable:
+   int analogValue = analogRead(0);
+   // print the result:
+   Serial.println(analogValue);
+   // wait 10 milliseconds for the analog-to-digital converter
+   // to settle after the last reading:
+   delay(10);
+ }

arduino-0018-linux/examples/Analog/AnalogInput/AnalogInput.pde

@@ -0,0 +1,48 @@
+/*
+  Analog Input
+ Demonstrates analog input by reading an analog sensor on analog pin 0 and
+ turning on and off a light emitting diode(LED)  connected to digital pin 13. 
+ The amount of time the LED will be on and off depends on
+ the value obtained by analogRead(). 
+ 
+ The circuit:
+ * Potentiometer attached to analog input 0
+ * center pin of the potentiometer to the analog pin
+ * one side pin (either one) to ground
+ * the other side pin to +5V
+ * LED anode (long leg) attached to digital output 13
+ * LED cathode (short leg) attached to ground
+ 
+ * Note: because most Arduinos have a built-in LED attached 
+ to pin 13 on the board, the LED is optional.
+ 
+ 
+ Created by David Cuartielles
+ Modified 16 Jun 2009
+ By Tom Igoe
+ 
+ http://arduino.cc/en/Tutorial/AnalogInput
+ 
+ */
+
+int sensorPin = 0;    // select the input pin for the potentiometer
+int ledPin = 13;      // select the pin for the LED
+int sensorValue = 0;  // variable to store the value coming from the sensor
+
+void setup() {
+  // declare the ledPin as an OUTPUT:
+  pinMode(ledPin, OUTPUT);  
+}
+
+void loop() {
+  // read the value from the sensor:
+  sensorValue = analogRead(sensorPin);    
+  // turn the ledPin on
+  digitalWrite(ledPin, HIGH);  
+  // stop the program for <sensorValue> milliseconds:
+  delay(sensorValue);          
+  // turn the ledPin off:        
+  digitalWrite(ledPin, LOW);   
+  // stop the program for for <sensorValue> milliseconds:
+  delay(sensorValue);                  
+}

arduino-0018-linux/examples/Analog/AnalogWriteMega/AnalogWriteMega.pde

@@ -0,0 +1,42 @@
+/*
+  Mega analogWrite() test
+ 	
+  This sketch fades LEDs up and down one at a time on digital pins 2 through 13.  
+  This sketch was written for the Arduino Mega, and will not work on previous boards.
+ 	
+  The circuit:
+  * LEDs attached from pins 2 through 13 to ground.
+
+  created 8 Feb 2009
+  by Tom Igoe
+ */
+// These constants won't change.  They're used to give names
+// to the pins used:
+const int lowestPin = 2;
+const int highestPin = 13;
+
+
+void setup() {
+  // set pins 2 through 13 as outputs:
+  for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++) { 
+    pinMode(thisPin, OUTPUT); 
+  }
+}
+
+void loop() {
+  // iterate over the pins:
+  for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++) { 
+    // fade the LED on thisPin from off to brightest:
+    for (int brightness = 0; brightness < 255; brightness++) {
+      analogWrite(thisPin, brightness);
+      delay(2);
+    } 
+    // fade the LED on thisPin from brithstest to off:
+    for (int brightness = 255; brightness >= 0; brightness--) {
+      analogWrite(thisPin, brightness);
+      delay(2);
+    } 
+    // pause between LEDs:
+    delay(100);
+  }
+}

arduino-0018-linux/examples/Analog/Calibration/Calibration.pde

@@ -0,0 +1,73 @@
+/*
+  Calibration
+ 
+ Demonstrates one techinque for calibrating sensor input.  The
+ sensor readings during the first five seconds of the sketch
+ execution define the minimum and maximum of expected values
+ attached to the sensor pin.
+ 
+ The sensor minumum and maximum initial values may seem backwards.
+ Initially, you set the minimum high and listen for anything 
+ lower, saving it as the new minumum. Likewise, you set the
+ maximum low and listen for anything higher as the new maximum.
+ 
+ The circuit:
+ * Analog sensor (potentiometer will do) attached to analog input 0
+ * LED attached from digital pin 9 to ground
+ 
+ created 29 Oct 2008
+ By David A Mellis
+ Modified 17 Jun 2009
+ By Tom Igoe
+ 
+ http://arduino.cc/en/Tutorial/Calibration
+ 
+ */
+
+// These constants won't change:
+const int sensorPin = 2;     // pin that the sensor is attached to
+const int ledPin = 9;        // pin that the LED is attached to
+
+// variables:
+int sensorValue = 0;         // the sensor value
+int sensorMin = 1023;  // minimum sensor value
+int sensorMax = 0;     // maximum sensor value
+
+
+void setup() {
+  // turn on LED to signal the start of the calibration period:
+  pinMode(13, OUTPUT);
+  digitalWrite(13, HIGH);
+
+  // calibrate during the first five seconds 
+  while (millis() < 5000) {
+    sensorValue = analogRead(sensorPin);
+
+    // record the maximum sensor value
+    if (sensorValue > sensorMax) {
+      sensorMax = sensorValue;
+    }
+
+    // record the minimum sensor value
+    if (sensorValue < sensorMin) {
+      sensorMin = sensorValue;
+    }
+  }
+
+  // signal the end of the calibration period
+  digitalWrite(13, LOW);
+}
+
+void loop() {
+  // read the sensor:
+  sensorValue = analogRead(sensorPin);
+
+  // apply the calibration to the sensor reading
+  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);
+
+  // in case the sensor value is outside the range seen during calibration
+  sensorValue = constrain(sensorValue, 0, 255);
+
+  // fade the LED using the calibrated value:
+  analogWrite(ledPin, sensorValue);
+}

arduino-0018-linux/examples/Analog/Fading/Fading.pde

@@ -0,0 +1,43 @@
+/*
+ Fading
+ 
+ This example shows how to fade an LED using the analogWrite() function.
+ 
+ The circuit:
+ * LED attached from digital pin 9 to ground.
+ 
+ Created 1 Nov 2008
+ By David A. Mellis
+ Modified 17 June 2009
+ By Tom Igoe
+ 
+ http://arduino.cc/en/Tutorial/Fading
+ 
+ */
+
+
+int ledPin = 9;    // LED connected to digital pin 9
+
+void setup()  { 
+  // nothing happens in setup 
+} 
+
+void loop()  { 
+  // fade in from min to max in increments of 5 points:
+  for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) { 
+    // sets the value (range from 0 to 255):
+    analogWrite(ledPin, fadeValue);         
+    // wait for 30 milliseconds to see the dimming effect    
+    delay(30);                            
+  } 
+
+  // fade out from max to min in increments of 5 points:
+  for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) { 
+    // sets the value (range from 0 to 255):
+    analogWrite(ledPin, fadeValue);         
+    // wait for 30 milliseconds to see the dimming effect    
+    delay(30);                            
+  } 
+}
+
+

arduino-0018-linux/examples/Analog/Smoothing/Smoothing.pde

@@ -0,0 +1,64 @@
+/*
+
+  Smoothing
+
+  Reads repeatedly from an analog input, calculating a running average
+  and printing it to the computer.  Keeps ten readings in an array and 
+  continually averages them.
+  
+  The circuit:
+    * Analog sensor (potentiometer will do) attached to analog input 0
+
+  Created 22 April 2007
+  By David A. Mellis  <dam@mellis.org>
+
+  http://www.arduino.cc/en/Tutorial/Smoothing
+
+
+*/
+
+
+// Define the number of samples to keep track of.  The higher the number,
+// the more the readings will be smoothed, but the slower the output will
+// respond to the input.  Using a constant rather than a normal variable lets
+// use this value to determine the size of the readings array.
+const int numReadings = 10;
+
+int readings[numReadings];      // the readings from the analog input
+int index = 0;                  // the index of the current reading
+int total = 0;                  // the running total
+int average = 0;                // the average
+
+int inputPin = 0;
+
+void setup()
+{
+  // initialize serial communication with computer:
+  Serial.begin(9600);                   
+  // initialize all the readings to 0: 
+  for (int thisReading = 0; thisReading < numReadings; thisReading++)
+    readings[thisReading] = 0;          
+}
+
+void loop() {
+  // subtract the last reading:
+  total= total - readings[index];         
+  // read from the sensor:  
+  readings[index] = analogRead(inputPin); 
+  // add the reading to the total:
+  total= total + readings[index];       
+  // advance to the next position in the array:  
+  index = index + 1;                    
+
+  // if we're at the end of the array...
+  if (index >= numReadings)              
+    // ...wrap around to the beginning: 
+    index = 0;                           
+
+  // calculate the average:
+  average = total / numReadings;         
+  // send it to the computer (as ASCII digits) 
+  Serial.println(average, DEC);               
+}
+
+

arduino-0018-linux/examples/ArduinoISP/ArduinoISP.pde

@@ -0,0 +1,480 @@
+// this sketch turns the Arduino into a AVRISP
+// using the following pins:
+// 10: slave reset
+// 11: MOSI
+// 12: MISO
+// 13: SCK
+
+// Put an LED (with resistor) on the following pins:
+// 9: Heartbeat - shows the programmer is running
+// 8: Error - Lights up if something goes wrong (use red if that makes sense)
+// 7: Programming - In communication with the slave
+//
+// October 2009 by David A. Mellis
+// - Added support for the read signature command
+// 
+// February 2009 by Randall Bohn
+// - Added support for writing to EEPROM (what took so long?)
+// Windows users should consider WinAVR's avrdude instead of the
+// avrdude included with Arduino software.
+//
+// January 2008 by Randall Bohn
+// - Thanks to Amplificar for helping me with the STK500 protocol
+// - The AVRISP/STK500 (mk I) protocol is used in the arduino bootloader
+// - The SPI functions herein were developed for the AVR910_ARD programmer 
+// - More information at http://code.google.com/p/mega-isp
+
+#define SCK 13
+#define MISO 12
+#define MOSI 11
+#define RESET 10
+
+#define LED_HB 9
+#define LED_ERR 8
+#define LED_PMODE 7
+
+#define HWVER 2
+#define SWMAJ 1
+#define SWMIN 18
+
+// STK Definitions
+#define STK_OK 0x10
+#define STK_FAILED 0x11
+#define STK_UNKNOWN 0x12
+#define STK_INSYNC 0x14
+#define STK_NOSYNC 0x15
+#define CRC_EOP 0x20 //ok it is a space...
+
+void pulse(int pin, int times);
+
+void setup() {
+  Serial.begin(19200);
+  pinMode(7, OUTPUT);
+  pulse(7, 2);
+  pinMode(8, OUTPUT);
+  pulse(8, 2);
+  pinMode(9, OUTPUT);
+  pulse(9, 2);
+}
+
+int error=0;
+int pmode=0;
+// address for reading and writing, set by 'U' command
+int here;
+uint8_t buff[256]; // global block storage
+
+#define beget16(addr) (*addr * 256 + *(addr+1) )
+typedef struct param {
+  uint8_t devicecode;
+  uint8_t revision;
+  uint8_t progtype;
+  uint8_t parmode;
+  uint8_t polling;
+  uint8_t selftimed;
+  uint8_t lockbytes;
+  uint8_t fusebytes;
+  int flashpoll;
+  int eeprompoll;
+  int pagesize;
+  int eepromsize;
+  int flashsize;
+} 
+parameter;
+
+parameter param;
+
+// this provides a heartbeat on pin 9, so you can tell the software is running.
+uint8_t hbval=128;
+int8_t hbdelta=8;
+void heartbeat() {
+  if (hbval > 192) hbdelta = -hbdelta;
+  if (hbval < 32) hbdelta = -hbdelta;
+  hbval += hbdelta;
+  analogWrite(LED_HB, hbval);
+  delay(40);
+}
+  
+
+void loop(void) {
+  // is pmode active?
+  if (pmode) digitalWrite(LED_PMODE, HIGH); 
+  else digitalWrite(LED_PMODE, LOW);
+  // is there an error?
+  if (error) digitalWrite(LED_ERR, HIGH); 
+  else digitalWrite(LED_ERR, LOW);
+  
+  // light the heartbeat LED
+  heartbeat();
+  if (Serial.available()) {
+    avrisp();
+  }
+}
+
+uint8_t getch() {
+  while(!Serial.available());
+  return Serial.read();
+}
+void readbytes(int n) {
+  for (int x = 0; x < n; x++) {
+    buff[x] = Serial.read();
+  }
+}
+
+#define PTIME 30
+void pulse(int pin, int times) {
+  do {
+    digitalWrite(pin, HIGH);
+    delay(PTIME);
+    digitalWrite(pin, LOW);
+    delay(PTIME);
+  } 
+  while (times--);
+}
+
+void spi_init() {
+  uint8_t x;
+  SPCR = 0x53;
+  x=SPSR;
+  x=SPDR;
+}
+
+void spi_wait() {
+  do {
+  } 
+  while (!(SPSR & (1 << SPIF)));
+}
+
+uint8_t spi_send(uint8_t b) {
+  uint8_t reply;
+  SPDR=b;
+  spi_wait();
+  reply = SPDR;
+  return reply;
+}
+
+uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
+  uint8_t n;
+  spi_send(a); 
+  n=spi_send(b);
+  //if (n != a) error = -1;
+  n=spi_send(c);
+  return spi_send(d);
+}
+
+void empty_reply() {
+  if (CRC_EOP == getch()) {
+    Serial.print((char)STK_INSYNC);
+    Serial.print((char)STK_OK);
+  } 
+  else {
+    Serial.print((char)STK_NOSYNC);
+  }
+}
+
+void breply(uint8_t b) {
+  if (CRC_EOP == getch()) {
+    Serial.print((char)STK_INSYNC);
+    Serial.print((char)b);
+    Serial.print((char)STK_OK);
+  } 
+  else {
+    Serial.print((char)STK_NOSYNC);
+  }
+}
+
+void get_version(uint8_t c) {
+  switch(c) {
+  case 0x80:
+    breply(HWVER);
+    break;
+  case 0x81:
+    breply(SWMAJ);
+    break;
+  case 0x82:
+    breply(SWMIN);
+    break;
+  case 0x93:
+    breply('S'); // serial programmer
+    break;
+  default:
+    breply(0);
+  }
+}
+
+void set_parameters() {
+  // call this after reading paramter packet into buff[]
+  param.devicecode = buff[0];
+  param.revision = buff[1];
+  param.progtype = buff[2];
+  param.parmode = buff[3];
+  param.polling = buff[4];
+  param.selftimed = buff[5];
+  param.lockbytes = buff[6];
+  param.fusebytes = buff[7];
+  param.flashpoll = buff[8]; 
+  // ignore buff[9] (= buff[8])
+  //getch(); // discard second value
+  
+  // WARNING: not sure about the byte order of the following
+  // following are 16 bits (big endian)
+  param.eeprompoll = beget16(&buff[10]);
+  param.pagesize = beget16(&buff[12]);
+  param.eepromsize = beget16(&buff[14]);
+
+  // 32 bits flashsize (big endian)
+  param.flashsize = buff[16] * 0x01000000
+    + buff[17] * 0x00010000
+    + buff[18] * 0x00000100
+    + buff[19];
+
+}
+
+void start_pmode() {
+  spi_init();
+  // following delays may not work on all targets...
+  pinMode(RESET, OUTPUT);
+  digitalWrite(RESET, HIGH);
+  pinMode(SCK, OUTPUT);
+  digitalWrite(SCK, LOW);
+  delay(50);
+  digitalWrite(RESET, LOW);
+  delay(50);
+  pinMode(MISO, INPUT);
+  pinMode(MOSI, OUTPUT);
+  spi_transaction(0xAC, 0x53, 0x00, 0x00);
+  pmode = 1;
+}
+
+void end_pmode() {
+  pinMode(MISO, INPUT);
+  pinMode(MOSI, INPUT);
+  pinMode(SCK, INPUT);
+  pinMode(RESET, INPUT);
+  pmode = 0;
+}
+
+void universal() {
+  int w;
+  uint8_t ch;
+
+  for (w = 0; w < 4; w++) {
+    buff[w] = getch();
+  }
+  ch = spi_transaction(buff[0], buff[1], buff[2], buff[3]);
+  breply(ch);
+}
+
+void flash(uint8_t hilo, int addr, uint8_t data) {
+  spi_transaction(0x40+8*hilo, 
+  addr>>8 & 0xFF, 
+  addr & 0xFF,
+  data);
+}
+void commit(int addr) {
+  spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0);
+}
+
+//#define _current_page(x) (here & 0xFFFFE0)
+int current_page(int addr) {
+  if (param.pagesize == 32) return here & 0xFFFFFFF0;
+  if (param.pagesize == 64) return here & 0xFFFFFFE0;
+  if (param.pagesize == 128) return here & 0xFFFFFFC0;
+  if (param.pagesize == 256) return here & 0xFFFFFF80;
+  return here;
+}
+uint8_t write_flash(int length) {
+  if (param.pagesize < 1) return STK_FAILED;
+  //if (param.pagesize != 64) return STK_FAILED;
+  int page = current_page(here);
+  int x = 0;
+  while (x < length) {
+    if (page != current_page(here)) {
+      commit(page);
+      page = current_page(here);
+    }
+    flash(LOW, here, buff[x++]);
+    flash(HIGH, here, buff[x++]);
+    here++;
+  }
+
+  commit(page);
+
+  return STK_OK;
+}
+
+uint8_t write_eeprom(int length) {
+  // here is a word address, so we use here*2
+  // this writes byte-by-byte,
+  // page writing may be faster (4 bytes at a time)
+  for (int x = 0; x < length; x++) {
+    spi_transaction(0xC0, 0x00, here*2+x, buff[x]);
+    delay(45);
+  } 
+  return STK_OK;
+}
+
+void program_page() {
+  char result = (char) STK_FAILED;
+  int length = 256 * getch() + getch();
+  if (length > 256) {
+      Serial.print((char) STK_FAILED);
+      return;
+  }
+  char memtype = getch();
+  for (int x = 0; x < length; x++) {
+    buff[x] = getch();
+  }
+  if (CRC_EOP == getch()) {
+    Serial.print((char) STK_INSYNC);
+    if (memtype == 'F') result = (char)write_flash(length);
+    if (memtype == 'E') result = (char)write_eeprom(length);
+    Serial.print(result);
+  } 
+  else {
+    Serial.print((char) STK_NOSYNC);
+  }
+}
+uint8_t flash_read(uint8_t hilo, int addr) {
+  return spi_transaction(0x20 + hilo * 8,
+    (addr >> 8) & 0xFF,
+    addr & 0xFF,
+    0);
+}
+
+char flash_read_page(int length) {
+  for (int x = 0; x < length; x+=2) {
+    uint8_t low = flash_read(LOW, here);
+    Serial.print((char) low);
+    uint8_t high = flash_read(HIGH, here);
+    Serial.print((char) high);
+    here++;
+  }
+  return STK_OK;
+}
+
+char eeprom_read_page(int length) {
+  // here again we have a word address
+  for (int x = 0; x < length; x++) {
+    uint8_t ee = spi_transaction(0xA0, 0x00, here*2+x, 0xFF);
+    Serial.print((char) ee);
+  }
+  return STK_OK;
+}
+
+void read_page() {
+  char result = (char)STK_FAILED;
+  int length = 256 * getch() + getch();
+  char memtype = getch();
+  if (CRC_EOP != getch()) {
+    Serial.print((char) STK_NOSYNC);
+    return;
+  }
+  Serial.print((char) STK_INSYNC);
+  if (memtype == 'F') result = flash_read_page(length);
+  if (memtype == 'E') result = eeprom_read_page(length);
+  Serial.print(result);
+  return;
+}
+
+void read_signature() {
+  if (CRC_EOP != getch()) {
+    Serial.print((char) STK_NOSYNC);
+    return;
+  }
+  Serial.print((char) STK_INSYNC);
+  uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00);
+  Serial.print((char) high);
+  uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);
+  Serial.print((char) middle);
+  uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);
+  Serial.print((char) low);
+  Serial.print((char) STK_OK);
+}
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+
+////////////////////////////////////
+////////////////////////////////////
+int avrisp() { 
+  uint8_t data, low, high;
+  uint8_t ch = getch();
+  switch (ch) {
+  case '0': // signon
+    empty_reply();
+    break;
+  case '1':
+    if (getch() == CRC_EOP) {
+      Serial.print((char) STK_INSYNC);
+      Serial.print("AVR ISP");
+      Serial.print((char) STK_OK);
+    }
+    break;
+  case 'A':
+    get_version(getch());
+    break;
+  case 'B':
+    readbytes(20);
+    set_parameters();
+    empty_reply();
+    break;
+  case 'E': // extended parameters - ignore for now
+    readbytes(5);
+    empty_reply();
+    break;
+
+  case 'P':
+    start_pmode();
+    empty_reply();
+    break;
+  case 'U':
+    here = getch() + 256 * getch();
+    empty_reply();
+    break;
+
+  case 0x60: //STK_PROG_FLASH
+    low = getch();
+    high = getch();
+    empty_reply();
+    break;
+  case 0x61: //STK_PROG_DATA
+    data = getch();
+    empty_reply();
+    break;
+
+  case 0x64: //STK_PROG_PAGE
+    program_page();
+    break;
+    
+  case 0x74: //STK_READ_PAGE
+    read_page();    
+    break;
+
+  case 'V':
+    universal();
+    break;
+  case 'Q':
+    error=0;
+    end_pmode();
+    empty_reply();
+    break;
+    
+  case 0x75: //STK_READ_SIGN
+    read_signature();
+    break;
+
+  // expecting a command, not CRC_EOP
+  // this is how we can get back in sync
+  case CRC_EOP:
+    Serial.print((char) STK_NOSYNC);
+    break;
+    
+  // anything else we will return STK_UNKNOWN
+  default:
+    if (CRC_EOP == getch()) 
+      Serial.print((char)STK_UNKNOWN);
+    else
+      Serial.print((char)STK_NOSYNC);
+  }
+}
+

arduino-0018-linux/examples/Communication/ASCIITable/ASCIITable.pde

@@ -0,0 +1,73 @@
+/*
+  ASCII table
+ 
+ Prints out byte values in all possible formats:  
+ * as raw binary values
+ * as ASCII-encoded decimal, hex, octal, and binary values
+ 
+ For more on ASCII, see http://www.asciitable.com and http://en.wikipedia.org/wiki/ASCII
+ 
+ The circuit:  No external hardware needed.
+ 
+ created 2006
+ by Nicholas Zambetti 
+ modified 18 Jan 2009
+ by Tom Igoe
+ 
+ <http://www.zambetti.com> 
+ */
+void setup() 
+{ 
+  Serial.begin(9600); 
+
+  // prints title with ending line break 
+  Serial.println("ASCII Table ~ Character Map"); 
+} 
+
+// first visible ASCIIcharacter '!' is number 33:
+int thisByte = 33; 
+// you can also write ASCII characters in single quotes.
+// for example. '!' is the same as 33, so you could also use this:
+//int thisByte = '!';  
+
+void loop() 
+{ 
+  // prints value unaltered, i.e. the raw binary version of the 
+  // byte. The serial monitor interprets all bytes as 
+  // ASCII, so 33, the first number,  will show up as '!' 
+  Serial.print(thisByte, BYTE);    
+
+  Serial.print(", dec: "); 
+  // prints value as string as an ASCII-encoded decimal (base 10).
+  // Decimal is the  default format for Serial.print() and Serial.println(),
+  // so no modifier is needed:
+  Serial.print(thisByte);      
+  // But you can declare the modifier for decimal if you want to.
+  //this also works if you uncomment it:
+
+  // Serial.print(thisByte, DEC);  
+
+
+  Serial.print(", hex: "); 
+  // prints value as string in hexadecimal (base 16):
+  Serial.print(thisByte, HEX);     
+
+  Serial.print(", oct: "); 
+  // prints value as string in octal (base 8);
+  Serial.print(thisByte, OCT);     
+
+  Serial.print(", bin: "); 
+  // prints value as string in binary (base 2) 
+  // also prints ending line break:
+  Serial.println(thisByte, BIN);   
+
+  // if printed last visible character '~' or 126, stop: 
+  if(thisByte == 126) {     // you could also use if (thisByte == '~') {
+    // This loop loops forever and does nothing
+    while(true) { 
+      continue; 
+    } 
+  } 
+  // go on to the next character
+  thisByte++;  
+} 

arduino-0018-linux/examples/Communication/Dimmer/Dimmer.pde

@@ -0,0 +1,360 @@
+/*
+  Dimmer
+ 
+ Demonstrates the sending data from the computer to the Arduino board,
+ in this case to control the brightness of an LED.  The data is sent
+ in individual bytes, each of which ranges from 0 to 255.  Arduino
+ reads these bytes and uses them to set the brightness of the LED.
+ 
+ The circuit:
+ LED attached from digital pin 9 to ground.
+ Serial connection to Processing, Max/MSP, or another serial application
+ 
+ created 2006
+ by David A. Mellis
+ modified 14 Apr 2009
+ by Tom Igoe and Scott Fitzgerald
+ 
+ http://www.arduino.cc/en/Tutorial/Dimmer
+ */
+
+const int ledPin = 9;      // the pin that the LED is attached to
+
+void setup()
+{
+  // initialize the serial communication:
+  Serial.begin(9600);
+  // initialize the ledPin as an output:
+  pinMode(ledPin, OUTPUT);
+}
+
+void loop() {
+  byte brightness;
+
+  // check if data has been sent from the computer:
+  if (Serial.available()) {
+    // read the most recent byte (which will be from 0 to 255):
+    brightness = Serial.read();
+    // set the brightness of the LED:
+    analogWrite(ledPin, brightness);
+  }
+}
+
+/* Processing code for this example
+ // Dimmer - sends bytes over a serial port
+ // by David A. Mellis
+ 
+ import processing.serial.*;
+ Serial port;
+ 
+ void setup() {
+ size(256, 150);
+ 
+ println("Available serial ports:");
+ println(Serial.list());
+ 
+ // Uses the first port in this list (number 0).  Change this to
+ // select the port corresponding to your Arduino board.  The last
+ // parameter (e.g. 9600) is the speed of the communication.  It
+ // has to correspond to the value passed to Serial.begin() in your
+ // Arduino sketch.
+ port = new Serial(this, Serial.list()[0], 9600);  
+ 
+ // If you know the name of the port used by the Arduino board, you
+ // can specify it directly like this.
+ //port = new Serial(this, "COM1", 9600);
+ }
+ 
+ void draw() {
+ // draw a gradient from black to white
+ for (int i = 0; i < 256; i++) {
+ stroke(i);
+ line(i, 0, i, 150);
+ }
+ 
+ // write the current X-position of the mouse to the serial port as
+ // a single byte
+ port.write(mouseX);
+ }
+ */
+
+/* Max/MSP v5 patch for this example
+ 
+ {
+ 	"boxes" : [ 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Dimmer\n\nThis patch sends a binary number from 0 to 255 out the serial port to an Arduino connected to the port.  It dims an LED attached to the Arduino.\n\ncreated 2006\nby David A. Mellis\nmodified 14 Apr 2009\nby Scott Fitzgerald and Tom Igoe",
+ 				"linecount" : 10,
+ 				"patching_rect" : [ 209.0, 55.0, 344.0, 144.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-32",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "change the slider to alter the brightness of the LED",
+ 				"linecount" : 3,
+ 				"patching_rect" : [ 90.0, 235.0, 117.0, 48.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-7",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "number",
+ 				"patching_rect" : [ 215.0, 385.0, 50.0, 19.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "int", "bang" ],
+ 				"id" : "obj-6",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "slider",
+ 				"patching_rect" : [ 215.0, 235.0, 20.0, 140.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "" ],
+ 				"bgcolor" : [ 0.94902, 0.94902, 0.94902, 0.0 ],
+ 				"id" : "obj-1",
+ 				"size" : 256.0,
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 0 1",
+ 				"patching_rect" : [ 342.0, 305.0, 62.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-30",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to close the serial port",
+ 				"patching_rect" : [ 390.0, 396.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-26",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to open the serial port",
+ 				"patching_rect" : [ 415.0, 370.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-27",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "close",
+ 				"patching_rect" : [ 342.0, 396.0, 39.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-21",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "port a",
+ 				"patching_rect" : [ 364.0, 370.0, 41.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-19",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click here to get a list of serial ports",
+ 				"patching_rect" : [ 435.0, 344.0, 207.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-2",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "toggle",
+ 				"patching_rect" : [ 342.0, 268.0, 15.0, 15.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-11",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "print",
+ 				"patching_rect" : [ 384.0, 344.0, 36.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-13",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "serial a 9600",
+ 				"patching_rect" : [ 259.0, 420.0, 84.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int", "" ],
+ 				"id" : "obj-14",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click to start",
+ 				"patching_rect" : [ 369.0, 268.0, 117.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-17",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "panel",
+ 				"patching_rect" : [ 215.0, 235.0, 21.0, 139.0 ],
+ 				"numoutlets" : 0,
+ 				"mode" : 1,
+ 				"grad1" : [ 1.0, 1.0, 1.0, 1.0 ],
+ 				"id" : "obj-8",
+ 				"grad2" : [ 0.509804, 0.509804, 0.509804, 1.0 ],
+ 				"numinlets" : 1,
+ 				"angle" : 270.0
+ 			}
+ 
+ 		}
+ ],
+ 	"lines" : [ 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-11", 0 ],
+ 				"destination" : [ "obj-30", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 351.0, 296.0, 351.5, 296.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 1 ],
+ 				"destination" : [ "obj-19", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 0 ],
+ 				"destination" : [ "obj-21", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-21", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 351.5, 416.5, 268.5, 416.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-19", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 373.5, 393.5, 268.5, 393.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-13", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 393.5, 365.5, 268.5, 365.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-1", 0 ],
+ 				"destination" : [ "obj-6", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-6", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 224.5, 411.5, 268.5, 411.5 ]
+ 			}
+ 
+ 		}
+ ]
+ }
+ */

arduino-0018-linux/examples/Communication/Graph/Graph.pde

@@ -0,0 +1,578 @@
+/*
+  Graph
+ 
+ A simple example of communication from the Arduino board to the computer:
+ the value of analog input 0 is sent out the serial port.  We call this "serial"
+ communication because the connection appears to both the Arduino and the
+ computer as a serial port, even though it may actually use
+ a USB cable. Bytes are sent one after another (serially) from the Arduino
+ to the computer.
+ 
+ You can use the Arduino serial monitor to view the sent data, or it can
+ be read by Processing, PD, Max/MSP, or any other program capable of reading 
+ data from a serial port.  The Processing code below graphs the data received 
+ so you can see the value of the analog input changing over time.
+ 
+ The circuit:
+ Any analog input sensor is attached to analog in pin 0.
+ 
+ http://www.arduino.cc/en/Tutorial/Graph
+ 
+ created 2006
+ by David A. Mellis
+ modified 14 Apr 2009
+ by Tom Igoe and Scott Fitzgerald
+ 
+ http://www.arduino.cc/en/Tutorial/Graph
+ */
+
+void setup() {
+  // initialize the serial communication:
+  Serial.begin(9600);
+}
+
+void loop() {
+  // send the value of analog input 0:
+  Serial.println(analogRead(0));
+  // wait a bit for the analog-to-digital converter 
+  // to stabilize after the last reading:
+  delay(10);
+}
+
+/* Processing code for this example
+ 
+ // Graphing sketch
+ 
+ 
+ // This program takes ASCII-encoded strings
+ // from the serial port at 9600 baud and graphs them. It expects values in the
+ // range 0 to 1023, followed by a newline, or newline and carriage return
+ 
+ // Created 20 Apr 2005
+ // Updated 18 Jan 2008
+ // by Tom Igoe
+ 
+ import processing.serial.*;
+ 
+ Serial myPort;        // The serial port
+ int xPos = 1;         // horizontal position of the graph
+ 
+ void setup () {
+ // set the window size:
+ size(400, 300);        
+ 
+ // List all the available serial ports
+ println(Serial.list());
+ // I know that the first port in the serial list on my mac
+ // is always my  Arduino, so I open Serial.list()[0].
+ // Open whatever port is the one you're using.
+ myPort = new Serial(this, Serial.list()[0], 9600);
+ // don't generate a serialEvent() unless you get a newline character:
+ myPort.bufferUntil('\n');
+ // set inital background:
+ background(0);
+ }
+ void draw () {
+ // everything happens in the serialEvent()
+ }
+ 
+ void serialEvent (Serial myPort) {
+ // get the ASCII string:
+ String inString = myPort.readStringUntil('\n');
+ 
+ if (inString != null) {
+ // trim off any whitespace:
+ inString = trim(inString);
+ // convert to an int and map to the screen height:
+ float inByte = float(inString); 
+ inByte = map(inByte, 0, 1023, 0, height);
+ 
+ // draw the line:
+ stroke(127,34,255);
+ line(xPos, height, xPos, height - inByte);
+ 
+ // at the edge of the screen, go back to the beginning:
+ if (xPos >= width) {
+ xPos = 0;
+ background(0); 
+ } 
+ else {
+ // increment the horizontal position:
+ xPos++;
+ }
+ }
+ }
+ 
+ */
+
+/* Max/MSP v5 patch for this example
+ {
+ 	"boxes" : [ 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Graph\n\nThis patch takes a string, containing ASCII formatted number from 0 to 1023, with a carriage return and linefeed at the end.  It converts the string to an integer and graphs it.\n\ncreated 2006\nby David A. Mellis\nmodified 14 Apr 2009\nby Scott Fitzgerald and Tom Igoe",
+ 				"linecount" : 10,
+ 				"patching_rect" : [ 479.0, 6.0, 344.0, 144.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-32",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 0 1",
+ 				"patching_rect" : [ 327.0, 80.0, 62.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-30",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to close the serial port",
+ 				"patching_rect" : [ 412.0, 231.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-26",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to open the serial port",
+ 				"patching_rect" : [ 412.0, 205.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-27",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "close",
+ 				"patching_rect" : [ 327.0, 231.0, 39.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-21",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "port a",
+ 				"patching_rect" : [ 349.0, 205.0, 41.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-19",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "multislider",
+ 				"candicane7" : [ 0.878431, 0.243137, 0.145098, 1.0 ],
+ 				"patching_rect" : [ 302.0, 450.0, 246.0, 167.0 ],
+ 				"contdata" : 1,
+ 				"numoutlets" : 2,
+ 				"peakcolor" : [ 0.498039, 0.498039, 0.498039, 1.0 ],
+ 				"slidercolor" : [ 0.066667, 0.058824, 0.776471, 1.0 ],
+ 				"candicane8" : [ 0.027451, 0.447059, 0.501961, 1.0 ],
+ 				"outlettype" : [ "", "" ],
+ 				"setminmax" : [ 0.0, 1023.0 ],
+ 				"settype" : 0,
+ 				"candicane6" : [ 0.733333, 0.035294, 0.788235, 1.0 ],
+ 				"setstyle" : 3,
+ 				"bgcolor" : [ 0.231373, 0.713726, 1.0, 1.0 ],
+ 				"id" : "obj-1",
+ 				"candicane4" : [ 0.439216, 0.619608, 0.070588, 1.0 ],
+ 				"candicane5" : [ 0.584314, 0.827451, 0.431373, 1.0 ],
+ 				"candicane2" : [ 0.145098, 0.203922, 0.356863, 1.0 ],
+ 				"candicane3" : [ 0.290196, 0.411765, 0.713726, 1.0 ],
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click here to get a list of serial ports",
+ 				"patching_rect" : [ 412.0, 179.0, 207.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-2",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Here's the number from Arduino's analog input",
+ 				"linecount" : 2,
+ 				"patching_rect" : [ 153.0, 409.0, 138.0, 34.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-3",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Convert ASCII to symbol",
+ 				"patching_rect" : [ 379.0, 378.0, 147.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-4",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Convert integer to ASCII",
+ 				"patching_rect" : [ 379.0, 355.0, 147.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-5",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "number",
+ 				"patching_rect" : [ 302.0, 414.0, 37.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int", "bang" ],
+ 				"bgcolor" : [ 0.866667, 0.866667, 0.866667, 1.0 ],
+ 				"id" : "obj-6",
+ 				"triscale" : 0.9,
+ 				"fontname" : "Arial",
+ 				"htextcolor" : [ 0.870588, 0.870588, 0.870588, 1.0 ],
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "fromsymbol",
+ 				"patching_rect" : [ 302.0, 378.0, 74.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-7",
+ 				"fontname" : "Arial",
+ 				"color" : [ 1.0, 0.890196, 0.090196, 1.0 ],
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "itoa",
+ 				"patching_rect" : [ 302.0, 355.0, 46.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-8",
+ 				"fontname" : "Arial",
+ 				"color" : [ 1.0, 0.890196, 0.090196, 1.0 ],
+ 				"numinlets" : 3
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "zl group 4",
+ 				"patching_rect" : [ 302.0, 332.0, 64.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "", "" ],
+ 				"id" : "obj-9",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 10 13",
+ 				"patching_rect" : [ 244.0, 281.0, 77.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-10",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "toggle",
+ 				"patching_rect" : [ 244.0, 43.0, 15.0, 15.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-11",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "qmetro 10",
+ 				"patching_rect" : [ 244.0, 80.0, 65.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang" ],
+ 				"id" : "obj-12",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "print",
+ 				"patching_rect" : [ 369.0, 179.0, 36.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-13",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "serial a 9600",
+ 				"patching_rect" : [ 244.0, 255.0, 84.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int", "" ],
+ 				"id" : "obj-14",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Read serial input buffer every 10 milliseconds",
+ 				"linecount" : 2,
+ 				"patching_rect" : [ 53.0, 72.0, 185.0, 34.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-15",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "If you get newline (ASCII 10), send the list. If you get return (ASCII 13) do nothing. Any other value, add to the list",
+ 				"linecount" : 3,
+ 				"patching_rect" : [ 332.0, 269.0, 320.0, 48.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-16",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click to open/close serial port and start/stop patch",
+ 				"linecount" : 2,
+ 				"patching_rect" : [ 271.0, 32.0, 199.0, 34.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-17",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ ],
+ 	"lines" : [ 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-6", 0 ],
+ 				"destination" : [ "obj-1", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-7", 0 ],
+ 				"destination" : [ "obj-6", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-8", 0 ],
+ 				"destination" : [ "obj-7", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-9", 0 ],
+ 				"destination" : [ "obj-8", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-10", 0 ],
+ 				"destination" : [ "obj-9", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 253.5, 308.0, 311.5, 308.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-10", 2 ],
+ 				"destination" : [ "obj-9", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 311.5, 320.0, 311.5, 320.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-14", 0 ],
+ 				"destination" : [ "obj-10", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-12", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-11", 0 ],
+ 				"destination" : [ "obj-12", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-13", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 378.5, 200.5, 253.5, 200.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-19", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 358.5, 228.5, 253.5, 228.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-21", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 336.5, 251.5, 253.5, 251.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 0 ],
+ 				"destination" : [ "obj-21", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 1 ],
+ 				"destination" : [ "obj-19", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-11", 0 ],
+ 				"destination" : [ "obj-30", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 253.0, 71.0, 336.5, 71.0 ]
+ 			}
+ 
+ 		}
+ ]
+ }
+ 
+ */

arduino-0018-linux/examples/Communication/MIDI/Midi.pde

@@ -0,0 +1,47 @@
+/*
+ MIDI note player
+ 
+ This sketch shows how to use the serial transmit pin (pin 1) to send MIDI note data.
+ If this circuit is connected to a MIDI synth, it will play 
+ the notes F#-0 (0x1E) to F#-5 (0x5A) in sequence.
+
+ 
+ The circuit:
+ * digital in 1 connected to MIDI jack pin 5
+ * MIDI jack pin 2 connected to ground
+ * MIDI jack pin 4 connected to +5V through 220-ohm resistor
+ Attach a MIDI cable to the jack, then to a MIDI synth, and play music.
+
+ created 13 Jun 2006
+ modified 2 Jul 2009
+ by Tom Igoe 
+ 
+ http://www.arduino.cc/en/Tutorial/MIDI
+ 
+ */
+
+void setup() {
+  //  Set MIDI baud rate:
+  Serial.begin(31250);
+}
+
+void loop() {
+  // play notes from F#-0 (0x1E) to F#-5 (0x5A):
+  for (intnote = 0x1E; note < 0x5A; note ++) {
+    //Note on channel 1 (0x90), some note value (note), middle velocity (0x45):
+    noteOn(0x90, note, 0x45);
+    delay(100);
+    //Note on channel 1 (0x90), some note value (note), silent velocity (0x00):
+    noteOn(0x90, note, 0x00);   
+    delay(100);
+  }
+}
+
+//  plays a MIDI note.  Doesn't check to see that
+//  cmd is greater than 127, or that data values are  less than 127:
+void noteOn(int cmd, int pitch, int velocity) {
+  Serial.print(cmd, BYTE);
+  Serial.print(pitch, BYTE);
+  Serial.print(velocity, BYTE);
+}
+

arduino-0018-linux/examples/Communication/MultiSerialMega/MultiSerialMega.pde

@@ -0,0 +1,31 @@
+/*
+  Mega multple serial test
+ 
+ Receives from the main serial port, sends to the others. 
+ Receives from serial port 1, sends to the main serial (Serial 0).
+ 
+ This example works only on the Arduino Mega
+ 
+ The circuit: 
+ * Any serial device attached to Serial port 1
+ * Serial monitor open on Serial port 0:
+ 
+ created 30 Dec. 2008
+ by Tom Igoe
+ 
+ */
+
+
+void setup() {
+  // initialize both serial ports:
+  Serial.begin(9600);
+  Serial1.begin(9600);
+}
+
+void loop() {
+  // read from port 1, send to port 0:
+  if (Serial1.available()) {
+    int inByte = Serial1.read();
+    Serial.print(inByte, BYTE); 
+  }
+}

arduino-0018-linux/examples/Communication/PhysicalPixel/PhysicalPixel.pde

@@ -0,0 +1,707 @@
+/*
+  Physical Pixel
+ 
+ An example of using the Arduino board to receive data from the 
+ computer.  In this case, the Arduino boards turns on an LED when
+ it receives the character 'H', and turns off the LED when it
+ receives the character 'L'.
+ 
+ The data can be sent from the Arduino serial monitor, or another
+ program like Processing (see code below), Flash (via a serial-net
+ proxy), PD, or Max/MSP.
+ 
+ The circuit:
+ * LED connected from digital pin 13 to ground
+ 
+ created 2006
+ by David A. Mellis
+ modified 14 Apr 2009
+ by Tom Igoe and Scott Fitzgerald
+ 
+ http://www.arduino.cc/en/Tutorial/PhysicalPixel
+ */
+
+const int ledPin = 13; // the pin that the LED is attached to
+int incomingByte;      // a variable to read incoming serial data into
+
+void setup() {
+  // initialize serial communication:
+  Serial.begin(9600);
+  // initialize the LED pin as an output:
+  pinMode(ledPin, OUTPUT);
+}
+
+void loop() {
+  // see if there's incoming serial data:
+  if (Serial.available() > 0) {
+    // read the oldest byte in the serial buffer:
+    incomingByte = Serial.read();
+    // if it's a capital H (ASCII 72), turn on the LED:
+    if (incomingByte == 'H') {
+      digitalWrite(ledPin, HIGH);
+    } 
+    // if it's an L (ASCII 76) turn off the LED:
+    if (incomingByte == 'L') {
+      digitalWrite(ledPin, LOW);
+    }
+  }
+}
+
+/* Processing code for this example
+ 
+ // mouseover serial 
+ 
+ // Demonstrates how to send data to the Arduino I/O board, in order to 
+ // turn ON a light if the mouse is over a square and turn it off 
+ // if the mouse is not. 
+ 
+ // created 2003-4
+ // based on examples by Casey Reas and Hernando Barragan
+ // modified 18 Jan 2009
+ // by Tom Igoe
+ 
+ 
+ import processing.serial.*; 
+ 
+ float boxX;
+ float boxY;
+ int boxSize = 20;
+ boolean mouseOverBox = false;
+ 
+ Serial port; 
+ 
+ void setup()  {
+ size(200, 200);
+ boxX = width/2.0;
+ boxY = height/2.0;
+ rectMode(RADIUS); 
+ 
+ // List all the available serial ports in the output pane. 
+ // You will need to choose the port that the Arduino board is 
+ // connected to from this list. The first port in the list is 
+ // port #0 and the third port in the list is port #2. 
+ println(Serial.list()); 
+ 
+ // Open the port that the Arduino board is connected to (in this case #0) 
+ // Make sure to open the port at the same speed Arduino is using (9600bps) 
+ port = new Serial(this, Serial.list()[0], 9600); 
+ 
+ }
+ 
+ void draw() 
+ { 
+ background(0);
+ 
+ // Test if the cursor is over the box 
+ if (mouseX > boxX-boxSize && mouseX < boxX+boxSize && 
+ mouseY > boxY-boxSize && mouseY < boxY+boxSize) {
+ mouseOverBox = true;  
+ // draw a line around the box and change its color:
+ stroke(255); 
+ fill(153);
+ // send an 'H' to indicate mouse is over square:
+ port.write('H');       
+ } 
+ else {
+ // return the box to it's inactive state:
+ stroke(153);
+ fill(153);
+ // send an 'L' to turn the LED off: 
+ port.write('L');      
+ mouseOverBox = false;
+ }
+ 
+ // Draw the box
+ rect(boxX, boxY, boxSize, boxSize);
+ }
+ 
+ 
+ */
+
+/*
+{
+ 	"boxes" : [ 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Physical Pixel\n\nThis patch sends an ASCII H or an ASCII L out the serial port to turn on an LED attached to an Arduino board. It can also send alternating H and L characters once every second to make the LED blink.\n\ncreated 2006\nby David A. Mellis\nmodified 14 Apr 2009\nby Scott Fitzgerald and Tom Igoe",
+ 				"linecount" : 11,
+ 				"patching_rect" : [ 14.0, 35.0, 354.0, 158.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-1",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click to blink every second",
+ 				"patching_rect" : [ 99.0, 251.0, 161.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-38",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "toggle",
+ 				"patching_rect" : [ 74.0, 251.0, 21.0, 21.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-39",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "p blink",
+ 				"patching_rect" : [ 74.0, 286.0, 45.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-37",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2,
+ 				"patcher" : 				{
+ 					"fileversion" : 1,
+ 					"rect" : [ 54.0, 94.0, 640.0, 480.0 ],
+ 					"bglocked" : 0,
+ 					"defrect" : [ 54.0, 94.0, 640.0, 480.0 ],
+ 					"openrect" : [ 0.0, 0.0, 0.0, 0.0 ],
+ 					"openinpresentation" : 0,
+ 					"default_fontsize" : 10.0,
+ 					"default_fontface" : 0,
+ 					"default_fontname" : "Verdana",
+ 					"gridonopen" : 0,
+ 					"gridsize" : [ 25.0, 25.0 ],
+ 					"gridsnaponopen" : 0,
+ 					"toolbarvisible" : 1,
+ 					"boxanimatetime" : 200,
+ 					"imprint" : 0,
+ 					"boxes" : [ 						{
+ 							"box" : 							{
+ 								"maxclass" : "newobj",
+ 								"text" : "* 1000",
+ 								"patching_rect" : [ 200.0, 150.0, 46.0, 19.0 ],
+ 								"numoutlets" : 1,
+ 								"fontsize" : 10.0,
+ 								"outlettype" : [ "int" ],
+ 								"id" : "obj-12",
+ 								"fontname" : "Verdana",
+ 								"numinlets" : 2
+ 							}
+ 
+ 						}
+ , 						{
+ 							"box" : 							{
+ 								"maxclass" : "inlet",
+ 								"patching_rect" : [ 200.0, 75.0, 25.0, 25.0 ],
+ 								"numoutlets" : 1,
+ 								"outlettype" : [ "" ],
+ 								"id" : "obj-11",
+ 								"numinlets" : 0,
+ 								"comment" : ""
+ 							}
+ 
+ 						}
+ , 						{
+ 							"box" : 							{
+ 								"maxclass" : "toggle",
+ 								"patching_rect" : [ 125.0, 250.0, 20.0, 20.0 ],
+ 								"numoutlets" : 1,
+ 								"outlettype" : [ "int" ],
+ 								"id" : "obj-10",
+ 								"numinlets" : 1
+ 							}
+ 
+ 						}
+ , 						{
+ 							"box" : 							{
+ 								"maxclass" : "newobj",
+ 								"text" : "metro 1000",
+ 								"patching_rect" : [ 115.0, 190.0, 69.0, 19.0 ],
+ 								"numoutlets" : 1,
+ 								"fontsize" : 10.0,
+ 								"outlettype" : [ "bang" ],
+ 								"id" : "obj-3",
+ 								"fontname" : "Verdana",
+ 								"numinlets" : 2
+ 							}
+ 
+ 						}
+ , 						{
+ 							"box" : 							{
+ 								"maxclass" : "outlet",
+ 								"patching_rect" : [ 125.0, 400.0, 25.0, 25.0 ],
+ 								"numoutlets" : 0,
+ 								"id" : "obj-2",
+ 								"numinlets" : 1,
+ 								"comment" : ""
+ 							}
+ 
+ 						}
+ , 						{
+ 							"box" : 							{
+ 								"maxclass" : "inlet",
+ 								"patching_rect" : [ 100.0, 25.0, 25.0, 25.0 ],
+ 								"numoutlets" : 1,
+ 								"outlettype" : [ "int" ],
+ 								"id" : "obj-1",
+ 								"numinlets" : 0,
+ 								"comment" : ""
+ 							}
+ 
+ 						}
+ ],
+ 					"lines" : [ 						{
+ 							"patchline" : 							{
+ 								"source" : [ "obj-12", 0 ],
+ 								"destination" : [ "obj-3", 1 ],
+ 								"hidden" : 0,
+ 								"midpoints" : [  ]
+ 							}
+ 
+ 						}
+ , 						{
+ 							"patchline" : 							{
+ 								"source" : [ "obj-11", 0 ],
+ 								"destination" : [ "obj-12", 0 ],
+ 								"hidden" : 0,
+ 								"midpoints" : [  ]
+ 							}
+ 
+ 						}
+ , 						{
+ 							"patchline" : 							{
+ 								"source" : [ "obj-1", 0 ],
+ 								"destination" : [ "obj-3", 0 ],
+ 								"hidden" : 0,
+ 								"midpoints" : [  ]
+ 							}
+ 
+ 						}
+ , 						{
+ 							"patchline" : 							{
+ 								"source" : [ "obj-10", 0 ],
+ 								"destination" : [ "obj-2", 0 ],
+ 								"hidden" : 0,
+ 								"midpoints" : [  ]
+ 							}
+ 
+ 						}
+ , 						{
+ 							"patchline" : 							{
+ 								"source" : [ "obj-3", 0 ],
+ 								"destination" : [ "obj-10", 0 ],
+ 								"hidden" : 0,
+ 								"midpoints" : [  ]
+ 							}
+ 
+ 						}
+ ]
+ 				}
+ ,
+ 				"saved_object_attributes" : 				{
+ 					"fontface" : 0,
+ 					"fontsize" : 10.0,
+ 					"default_fontface" : 0,
+ 					"default_fontname" : "Verdana",
+ 					"default_fontsize" : 10.0,
+ 					"fontname" : "Verdana",
+ 					"globalpatchername" : ""
+ 				}
+ 
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "convert to int",
+ 				"patching_rect" : [ 154.0, 386.0, 104.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-36",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "send L if 0, H if 1",
+ 				"patching_rect" : [ 154.0, 361.0, 104.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-35",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "is it on or off?",
+ 				"patching_rect" : [ 179.0, 336.0, 95.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-34",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "atoi",
+ 				"patching_rect" : [ 279.0, 386.0, 46.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "list" ],
+ 				"id" : "obj-33",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 3
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "H",
+ 				"patching_rect" : [ 329.0, 361.0, 32.5, 17.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-32",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "L",
+ 				"patching_rect" : [ 279.0, 361.0, 32.5, 17.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-31",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 0 1",
+ 				"patching_rect" : [ 279.0, 336.0, 62.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-25",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click to turn the LED on and off",
+ 				"linecount" : 2,
+ 				"patching_rect" : [ 130.0, 205.0, 143.0, 34.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-24",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "toggle",
+ 				"patching_rect" : [ 279.0, 211.0, 24.0, 24.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-23",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 0 1",
+ 				"patching_rect" : [ 381.0, 331.0, 62.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-30",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to close the serial port",
+ 				"patching_rect" : [ 429.0, 422.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-26",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to open the serial port",
+ 				"patching_rect" : [ 454.0, 396.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-27",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "close",
+ 				"patching_rect" : [ 381.0, 422.0, 39.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-21",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "port a",
+ 				"patching_rect" : [ 403.0, 396.0, 41.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-19",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click here to get a list of serial ports",
+ 				"patching_rect" : [ 474.0, 370.0, 207.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-2",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "toggle",
+ 				"patching_rect" : [ 381.0, 181.0, 21.0, 21.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-11",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "print",
+ 				"patching_rect" : [ 423.0, 370.0, 36.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-13",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "serial a 9600",
+ 				"patching_rect" : [ 279.0, 461.0, 84.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int", "" ],
+ 				"id" : "obj-14",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click to start",
+ 				"patching_rect" : [ 408.0, 181.0, 117.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-17",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ ],
+ 	"lines" : [ 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-39", 0 ],
+ 				"destination" : [ "obj-37", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-37", 0 ],
+ 				"destination" : [ "obj-25", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 83.5, 320.5, 288.5, 320.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-33", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-32", 0 ],
+ 				"destination" : [ "obj-33", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 338.5, 381.5, 288.5, 381.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-31", 0 ],
+ 				"destination" : [ "obj-33", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-25", 0 ],
+ 				"destination" : [ "obj-31", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-25", 1 ],
+ 				"destination" : [ "obj-32", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 310.0, 358.0, 338.5, 358.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-23", 0 ],
+ 				"destination" : [ "obj-25", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-13", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 432.5, 389.0, 367.0, 389.0, 367.0, 411.0, 288.5, 411.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-19", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 412.5, 417.0, 288.5, 417.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-21", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 390.5, 450.0, 288.5, 450.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 0 ],
+ 				"destination" : [ "obj-21", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 1 ],
+ 				"destination" : [ "obj-19", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-11", 0 ],
+ 				"destination" : [ "obj-30", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 390.5, 322.0, 390.5, 322.0 ]
+ 			}
+ 
+ 		}
+ ]
+ }
+ 
+ */

arduino-0018-linux/examples/Communication/VirtualColorMixer/VirtualColorMixer.pde

@@ -0,0 +1,697 @@
+/*
+  This example reads three analog sensors (potentiometers are easiest)
+ and sends their values serially. The Processing and Max/MSP programs at the bottom
+ take those three values and use them to change the background color of the screen.
+ 
+ The circuit:
+ * potentiometers attached to analog inputs 0, 1, and 2
+ 
+ http://www.arduino.cc/en/Tutorial/VirtualColorMixer
+ 
+ created 2 Dec 2006
+ by David A. Mellis
+ modified 14 Apr 2009 
+ by Tom Igoe and Scott Fitzgerald
+ 
+ */
+
+const int redPin = 0;		// sensor to control red color
+const int greenPin = 1;		// sensor to control green color
+const int bluePin = 2;		// sensor to control blue color
+
+void setup()
+{
+  Serial.begin(9600);
+}
+
+void loop()
+{
+  Serial.print(analogRead(redPin));
+  Serial.print(",");
+  Serial.print(analogRead(greenPin));
+  Serial.print(",");
+  Serial.println(analogRead(bluePin));
+}
+
+/* Processing code for this example
+ 
+ 
+ import processing.serial.*;
+ 
+ float redValue = 0;        // red value
+ float greenValue = 0;      // green value
+ float blueValue = 0;       // blue value
+ 
+ Serial myPort;
+ 
+ void setup() {
+ size(200, 200);
+ 
+ // List all the available serial ports
+ println(Serial.list());
+ // I know that the first port in the serial list on my mac
+ // is always my  Arduino, so I open Serial.list()[0].
+ // Open whatever port is the one you're using.
+ myPort = new Serial(this, Serial.list()[0], 9600);
+ // don't generate a serialEvent() unless you get a newline character:
+ myPort.bufferUntil('\n');
+ }
+ 
+ void draw() {
+ // set the background color with the color values:
+ background(redValue, greenValue, blueValue);
+ }
+ 
+ void serialEvent(Serial myPort) { 
+ // get the ASCII string:
+ String inString = myPort.readStringUntil('\n');
+ 
+ if (inString != null) {
+ // trim off any whitespace:
+ inString = trim(inString);
+ // split the string on the commas and convert the 
+ // resulting substrings into an integer array:
+ float[] colors = float(split(inString, ","));
+ // if the array has at least three elements, you know
+ // you got the whole thing.  Put the numbers in the
+ // color variables:
+ if (colors.length >=3) {
+ // map them to the range 0-255:
+ redValue = map(colors[0], 0, 1023, 0, 255);
+ greenValue = map(colors[1], 0, 1023, 0, 255);
+ blueValue = map(colors[2], 0, 1023, 0, 255);
+ }
+ }
+ }
+ */
+
+/* Max/MSP patch for this example
+ {
+ 	"boxes" : [ 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "/ 4",
+ 				"patching_rect" : [ 448.0, 502.0, 32.5, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-25",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "/ 4",
+ 				"patching_rect" : [ 398.0, 502.0, 32.5, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-24",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "/ 4",
+ 				"patching_rect" : [ 348.0, 502.0, 32.5, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-23",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Virtual color mixer\n\nThis patch takes a string, containing three comma-separated ASCII formatted numbers from 0 to 1023, with a carriage return and linefeed at the end.  It converts the string to three integers and uses them to set the background color.\n\n created 2 Dec 2006\n by David A. Mellis\nmodified 14 Apr 2009\nby Scott Fitzgerald and Tom Igoe",
+ 				"linecount" : 11,
+ 				"patching_rect" : [ 524.0, 51.0, 398.0, 158.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-32",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 0 1",
+ 				"patching_rect" : [ 372.0, 125.0, 62.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-30",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to close the serial port",
+ 				"patching_rect" : [ 457.0, 276.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-26",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "click here to open the serial port",
+ 				"patching_rect" : [ 457.0, 250.0, 206.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-27",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "close",
+ 				"patching_rect" : [ 372.0, 276.0, 39.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-21",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "port a",
+ 				"patching_rect" : [ 394.0, 250.0, 41.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-19",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click here to get a list of serial ports",
+ 				"patching_rect" : [ 457.0, 224.0, 207.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-2",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Convert ASCII to symbol",
+ 				"patching_rect" : [ 424.0, 423.0, 147.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-4",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Convert integer to ASCII",
+ 				"patching_rect" : [ 424.0, 400.0, 147.0, 20.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-5",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "fromsymbol",
+ 				"patching_rect" : [ 347.0, 423.0, 74.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-7",
+ 				"fontname" : "Arial",
+ 				"color" : [ 1.0, 0.890196, 0.090196, 1.0 ],
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "itoa",
+ 				"patching_rect" : [ 347.0, 400.0, 46.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-8",
+ 				"fontname" : "Arial",
+ 				"color" : [ 1.0, 0.890196, 0.090196, 1.0 ],
+ 				"numinlets" : 3
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "zl group",
+ 				"patching_rect" : [ 347.0, 377.0, 53.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "", "" ],
+ 				"id" : "obj-9",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "select 10 13",
+ 				"patching_rect" : [ 289.0, 326.0, 77.0, 20.0 ],
+ 				"numoutlets" : 3,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang", "bang", "" ],
+ 				"id" : "obj-10",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "toggle",
+ 				"patching_rect" : [ 289.0, 88.0, 15.0, 15.0 ],
+ 				"numoutlets" : 1,
+ 				"outlettype" : [ "int" ],
+ 				"id" : "obj-11",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "qmetro 10",
+ 				"patching_rect" : [ 289.0, 125.0, 65.0, 20.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "bang" ],
+ 				"id" : "obj-12",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "message",
+ 				"text" : "print",
+ 				"patching_rect" : [ 414.0, 224.0, 36.0, 18.0 ],
+ 				"numoutlets" : 1,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "" ],
+ 				"id" : "obj-13",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 2
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "serial a 9600",
+ 				"patching_rect" : [ 289.0, 300.0, 84.0, 20.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 12.0,
+ 				"outlettype" : [ "int", "" ],
+ 				"id" : "obj-14",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Read serial input buffer every 10 milliseconds",
+ 				"linecount" : 2,
+ 				"patching_rect" : [ 98.0, 117.0, 185.0, 34.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-15",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "If you get newline (ASCII 10), send the list. If you get return (ASCII 13) do nothing. Any other value, add to the list",
+ 				"linecount" : 3,
+ 				"patching_rect" : [ 377.0, 314.0, 320.0, 48.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-16",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Click to open/close serial port and start/stop patch",
+ 				"linecount" : 2,
+ 				"patching_rect" : [ 316.0, 77.0, 199.0, 34.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-17",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "bgcolor 0 0 0",
+ 				"patching_rect" : [ 348.0, 585.0, 169.0, 19.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 10.0,
+ 				"id" : "obj-6",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 4
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "newobj",
+ 				"text" : "unpack 0 0 0 0 0",
+ 				"patching_rect" : [ 347.0, 470.0, 119.0, 19.0 ],
+ 				"numoutlets" : 5,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "int", "int", "int", "int", "int" ],
+ 				"id" : "obj-20",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "number",
+ 				"patching_rect" : [ 448.0, 535.0, 50.0, 19.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "int", "bang" ],
+ 				"id" : "obj-18",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "number",
+ 				"patching_rect" : [ 398.0, 535.0, 50.0, 19.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "int", "bang" ],
+ 				"id" : "obj-1",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "number",
+ 				"patching_rect" : [ 348.0, 535.0, 50.0, 19.0 ],
+ 				"numoutlets" : 2,
+ 				"fontsize" : 10.0,
+ 				"outlettype" : [ "int", "bang" ],
+ 				"id" : "obj-22",
+ 				"fontname" : "Verdana",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ , 		{
+ 			"box" : 			{
+ 				"maxclass" : "comment",
+ 				"text" : "Here's the numbers from Arduino's analog input",
+ 				"linecount" : 3,
+ 				"patching_rect" : [ 198.0, 484.0, 138.0, 48.0 ],
+ 				"numoutlets" : 0,
+ 				"fontsize" : 12.0,
+ 				"id" : "obj-3",
+ 				"fontname" : "Arial",
+ 				"numinlets" : 1
+ 			}
+ 
+ 		}
+ ],
+ 	"lines" : [ 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-18", 0 ],
+ 				"destination" : [ "obj-6", 2 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-1", 0 ],
+ 				"destination" : [ "obj-6", 1 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-22", 0 ],
+ 				"destination" : [ "obj-6", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-25", 0 ],
+ 				"destination" : [ "obj-18", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-20", 4 ],
+ 				"destination" : [ "obj-25", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-20", 2 ],
+ 				"destination" : [ "obj-24", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-24", 0 ],
+ 				"destination" : [ "obj-1", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-23", 0 ],
+ 				"destination" : [ "obj-22", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-20", 0 ],
+ 				"destination" : [ "obj-23", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-8", 0 ],
+ 				"destination" : [ "obj-7", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-14", 0 ],
+ 				"destination" : [ "obj-10", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-12", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-11", 0 ],
+ 				"destination" : [ "obj-12", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-13", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 423.5, 245.5, 298.5, 245.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-19", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 403.5, 273.5, 298.5, 273.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-21", 0 ],
+ 				"destination" : [ "obj-14", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 381.5, 296.5, 298.5, 296.5 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 0 ],
+ 				"destination" : [ "obj-21", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-30", 1 ],
+ 				"destination" : [ "obj-19", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-11", 0 ],
+ 				"destination" : [ "obj-30", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 298.0, 116.0, 381.5, 116.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-7", 0 ],
+ 				"destination" : [ "obj-20", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-9", 0 ],
+ 				"destination" : [ "obj-8", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [  ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-10", 0 ],
+ 				"destination" : [ "obj-9", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 298.5, 353.0, 356.5, 353.0 ]
+ 			}
+ 
+ 		}
+ , 		{
+ 			"patchline" : 			{
+ 				"source" : [ "obj-10", 2 ],
+ 				"destination" : [ "obj-9", 0 ],
+ 				"hidden" : 0,
+ 				"midpoints" : [ 356.5, 365.0, 356.5, 365.0 ]
+ 			}
+ 
+ 		}
+ ]
+ }
+ 
+ */

arduino-0018-linux/examples/Control/Arrays/Arrays.pde

@@ -0,0 +1,55 @@
+/*
+  Arrays
+ 
+ Demonstrates the use of  an array to hold pin numbers
+ in order to iterate over the pins in a sequence. 
+ Lights multiple LEDs in sequence, then in reverse.
+ 
+ Unlike the For Loop tutorial, where the pins have to be
+ contiguous, here the pins can be in any random order.
+ 
+ The circuit:
+ * LEDs from pins 2 through 7 to ground
+ 
+ created 2006
+ by David A. Mellis
+ modified 5 Jul 2009
+ by Tom Igoe 
+ 
+ http://www.arduino.cc/en/Tutorial/Array
+ */
+
+int timer = 100;           // The higher the number, the slower the timing.
+int ledPins[] = { 
+  2, 7, 4, 6, 5, 3 };       // an array of pin numbers to which LEDs are attached
+int pinCount = 6;           // the number of pins (i.e. the length of the array)
+
+void setup() {
+  int thisPin;
+  // the array elements are numbered from 0 to (pinCount - 1).
+  // use a for loop to initialize each pin as an output:
+  for (int thisPin = 0; thisPin < pinCount; thisPin++)  {
+    pinMode(ledPins[thisPin], OUTPUT);      
+  }
+}
+
+void loop() {
+  // loop from the lowest pin to the highest:
+  for (int thisPin = 0; thisPin < pinCount; thisPin++) { 
+    // turn the pin on:
+    digitalWrite(ledPins[thisPin], HIGH);   
+    delay(timer);                  
+    // turn the pin off:
+    digitalWrite(ledPins[thisPin], LOW);    
+
+  }
+
+  // loop from the highest pin to the lowest:
+  for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) { 
+    // turn the pin on:
+    digitalWrite(ledPins[thisPin], HIGH);
+    delay(timer);
+    // turn the pin off:
+    digitalWrite(ledPins[thisPin], LOW);
+  }
+}

arduino-0018-linux/examples/Control/ForLoopIteration/ForLoopIteration.pde

@@ -0,0 +1,45 @@
+/*
+  For Loop Iteration
+ 
+ Demonstrates the use of a for() loop. 
+ Lights multiple LEDs in sequence, then in reverse.
+ 
+ The circuit:
+ * LEDs from pins 2 through 7 to ground
+ 
+ created 2006
+ by David A. Mellis
+ modified 5 Jul 2009
+ by Tom Igoe 
+ 
+ http://www.arduino.cc/en/Tutorial/ForLoop
+ */
+
+int timer = 100;           // The higher the number, the slower the timing.
+
+void setup() {
+  // use a for loop to initialize each pin as an output:
+  for (int thisPin = 2; thisPin < 8; thisPin++)  {
+    pinMode(thisPin, OUTPUT);      
+  }
+}
+
+void loop() {
+  // loop from the lowest pin to the highest:
+  for (int thisPin = 2; thisPin < 8; thisPin++) { 
+    // turn the pin on:
+    digitalWrite(thisPin, HIGH);   
+    delay(timer);                  
+    // turn the pin off:
+    digitalWrite(thisPin, LOW);    
+  }
+
+  // loop from the highest pin to the lowest:
+  for (int thisPin = 7; thisPin >= 2; thisPin--) { 
+    // turn the pin on:
+    digitalWrite(thisPin, HIGH);
+    delay(timer);
+    // turn the pin off:
+    digitalWrite(thisPin, LOW);
+  }
+}

arduino-0018-linux/examples/Control/IfStatementConditional/IfStatementConditional.pde

@@ -0,0 +1,53 @@
+/*
+  Conditionals - If statement
+ 
+ This example demonstrates the use of if() statements.
+ It reads the state of a potentiometer (an analog input) and turns on an LED
+ only if the LED goes above a certain threshold level. It prints the analog value
+ regardless of the level.
+ 
+ The circuit:
+ * potentiometer connected to analog pin 0.
+ Center pin of the potentiometer goes to the analog pin.
+ side pins of the potentiometer go to +5V and ground
+ * LED connected from digital pin 13 to ground
+ 
+ * Note: On most Arduino boards, there is already an LED on the board
+ connected to pin 13, so you don't need any extra components for this example.
+ 
+ created 17 Jan 2009
+ by Tom Igoe
+ 
+  http://arduino.cc/en/Tutorial/
+ 
+ */
+ 
+// These constants won't change:
+const int analogPin = 0;     // pin that the sensor is attached to
+const int ledPin = 13;       // pin that the LED is attached to
+const int threshold = 400;   // an arbitrary threshold level that's in the range of the analog input
+
+void setup() {
+  // initialize the LED pin as an output:
+  pinMode(ledPin, OUTPUT);
+  // initialize serial communications:
+  Serial.begin(9600);
+}
+
+void loop() {
+  // read the value of the potentiometer:
+  int analogValue = analogRead(analogPin);
+
+  // if the analog value is high enough, turn on the LED:
+  if (analogValue > threshold) {
+    digitalWrite(ledPin, HIGH);
+  } 
+  else {
+    digitalWrite(ledPin,LOW); 
+  }
+
+  // print the analog value:
+  Serial.println(analogValue, DEC);
+
+}
+

arduino-0018-linux/examples/Control/WhileStatementConditional/WhileStatementConditional.pde

@@ -0,0 +1,86 @@
+/*
+  Conditionals - while statement
+ 
+ This example demonstrates the use of  while() statements.
+ 
+ While the pushbutton is pressed, the sketch runs the calibration routine.
+ The  sensor readings during the while loop define the minimum and maximum 
+ of expected values from the photo resistor.
+ 
+ This is a variation on the calibrate example.
+ 
+ The circuit:
+ * photo resistor connected from +5V to analog in pin 0
+ * 10K resistor connected from ground to analog in pin 0
+ * LED connected from digital pin 9 to ground through 220 ohm resistor
+ * pushbutton attached from pin 2 to +5V
+ * 10K resistor attached from pin 2 to ground
+ 
+ created 17 Jan 2009
+ modified 25 Jun 2009
+ by Tom Igoe
+ 
+ http://arduino.cc/en/Tutorial/WhileLoop
+ 
+ */
+
+
+// These constants won't change:
+const int sensorPin = 2;     // pin that the sensor is attached to
+const int ledPin = 9;        // pin that the LED is attached to
+const int indicatorLedPin = 13;  // pin that the built-in LED is attached to
+const int buttonPin = 2;      // pin that the button is attached to
+
+
+// These variables will change:
+int sensorMin = 1023;  // minimum sensor value
+int sensorMax = 0;     // maximum sensor value
+int sensorValue = 0;         // the sensor value
+
+
+void setup() {
+  // set the LED pins as outputs and the switch pin as input:
+  pinMode(indicatorLedPin, OUTPUT);
+  pinMode (ledPin, OUTPUT);
+  pinMode (buttonPin, INPUT);
+}
+
+void loop() {
+  // while the button is pressed, take calibration readings:
+  while (digitalRead(buttonPin) == HIGH) {
+    calibrate(); 
+  }
+  // signal the end of the calibration period
+  digitalWrite(indicatorLedPin, LOW);  
+
+  // read the sensor:
+  sensorValue = analogRead(sensorPin);
+
+  // apply the calibration to the sensor reading
+  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);
+
+  // in case the sensor value is outside the range seen during calibration
+  sensorValue = constrain(sensorValue, 0, 255);
+
+  // fade the LED using the calibrated value:
+  analogWrite(ledPin, sensorValue);
+}
+
+void calibrate() {
+  // turn on the indicator LED to indicate that calibration is happening:
+  digitalWrite(indicatorLedPin, HIGH);
+  // read the sensor:
+  sensorValue = analogRead(sensorPin);
+
+  // record the maximum sensor value
+  if (sensorValue > sensorMax) {
+    sensorMax = sensorValue;
+  }
+
+  // record the minimum sensor value
+  if (sensorValue < sensorMin) {
+    sensorMin = sensorValue;
+  }
+}
+
+

arduino-0018-linux/examples/Control/switchCase/switchCase.pde

@@ -0,0 +1,59 @@
+/*
+  Switch statement
+ 
+ Demonstrates the use of a switch statement.  The switch
+ statement allows you to choose from among a set of discrete values
+ of a variable.  It's like a series of if statements.
+ 
+ To see this sketch in action, but the board and sensor in a well-lit
+ room, open the serial monitor, and and move your hand gradually
+ down over the sensor.
+ 
+ The circuit:
+ * photoresistor from analog in 0 to +5V
+ * 10K resistor from analog in 0 to ground
+ 
+ created 1 Jul 2009
+ by Tom Igoe 
+ 
+ http://www.arduino.cc/en/Tutorial/SwitchCase
+ */
+
+// these constants won't change:
+const int sensorMin = 0;      // sensor minimum, discovered through experiment
+const int sensorMax = 600;    // sensor maximum, discovered through experiment
+
+void setup() {
+  // initialize serial communication:
+  Serial.begin(9600);  
+}
+
+void loop() {
+  // read the sensor:
+  int sensorReading = analogRead(0);
+  // map the sensor range to a range of four options:
+  int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
+
+  // do something different depending on the 
+  // range value:
+  switch (range) {
+  case 0:    // your hand is on the sensor
+    Serial.println("dark");
+    break;
+  case 1:    // your hand is close to the sensor
+    Serial.println("dim");
+    break;
+  case 2:    // your hand is a few inches from the sensor
+    Serial.println("medium");
+    break;
+  case 3:    // your hand is nowhere near the sensor
+    Serial.println("bright");
+    break;
+  } 
+
+}
+
+
+
+
+

arduino-0018-linux/examples/Control/switchCase2/switchCase2.pde

@@ -0,0 +1,64 @@
+/*
+  Switch statement  with serial input
+ 
+ Demonstrates the use of a switch statement.  The switch
+ statement allows you to choose from among a set of discrete values
+ of a variable.  It's like a series of if statements.
+ 
+ To see this sketch in action, open the Serial monitor and send any character.
+ The characters a, b, c, d, and e, will turn on LEDs.  Any other character will turn
+ the LEDs off.
+ 
+ The circuit:
+ * 5 LEDs attached to digital pins 2 through 6 through 220-ohm resistors
+ 
+ created 1 Jul 2009
+ by Tom Igoe 
+ 
+ http://www.arduino.cc/en/Tutorial/SwitchCase2
+ */
+
+void setup() {
+  // initialize serial communication:
+  Serial.begin(9600); 
+   // initialize the LED pins:
+      for (int thisPin = 2; thisPin < 7; thisPin++) {
+        pinMode(thisPin, OUTPUT);
+      } 
+}
+
+void loop() {
+  // read the sensor:
+  if (Serial.available() > 0) {
+    int inByte = Serial.read();
+    // do something different depending on the character received.  
+    // The switch statement expects single number values for each case;
+    // in this exmaple, though, you're using single quotes to tell
+    // the controller to get the ASCII value for the character.  For 
+    // example 'a' = 97, 'b' = 98, and so forth:
+
+    switch (inByte) {
+    case 'a':    
+      digitalWrite(2, HIGH);
+      break;
+    case 'b':    
+      digitalWrite(3, HIGH);
+      break;
+    case 'c':    
+      digitalWrite(4, HIGH);
+      break;
+    case 'd':    
+      digitalWrite(5, HIGH);
+      break;
+    case 'e':    
+      digitalWrite(6, HIGH);
+      break;
+    default:
+      // turn all the LEDs off:
+      for (int thisPin = 2; thisPin < 7; thisPin++) {
+        digitalWrite(thisPin, LOW);
+      }
+    } 
+  }
+}
+

arduino-0018-linux/examples/Digital/Blink/Blink.pde

@@ -0,0 +1,40 @@
+/*
+  Blink
+ 
+ Turns on an LED on for one second, then off for one second, repeatedly.
+ 
+ The circuit:
+ * LED connected from digital pin 13 to ground.
+ 
+ * Note: On most Arduino boards, there is already an LED on the board
+ connected to pin 13, so you don't need any extra components for this example.
+ 
+ 
+ Created 1 June 2005
+ By David Cuartielles
+ 
+ http://arduino.cc/en/Tutorial/Blink
+ 
+ based on an orginal by H. Barragan for the Wiring i/o board
+ 
+ */
+
+int ledPin =  13;    // LED connected to digital pin 13
+
+// The setup() method runs once, when the sketch starts
+
+void setup()   {                
+  // initialize the digital pin as an output:
+  pinMode(ledPin, OUTPUT);     
+}
+
+// the loop() method runs over and over again,
+// as long as the Arduino has power
+
+void loop()                     
+{
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  delay(1000);                  // wait for a second
+}

arduino-0018-linux/examples/Digital/BlinkWithoutDelay/BlinkWithoutDelay.pde

@@ -0,0 +1,58 @@
+/* Blink without Delay
+ 
+ Turns on and off a light emitting diode(LED) connected to a digital  
+ pin, without using the delay() function.  This means that other code
+ can run at the same time without being interrupted by the LED code.
+ 
+  The circuit:
+ * LED attached from pin 13 to ground.
+ * Note: on most Arduinos, there is already an LED on the board
+ that's attached to pin 13, so no hardware is needed for this example.
+ 
+ 
+ created 2005
+ by David A. Mellis
+ modified 17 Jun 2009
+ by Tom Igoe
+ 
+ http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
+ */
+
+// constants won't change. Used here to 
+// set pin numbers:
+const int ledPin =  13;      // the number of the LED pin
+
+// Variables will change:
+int ledState = LOW;             // ledState used to set the LED
+long previousMillis = 0;        // will store last time LED was updated
+
+// the follow variables is a long because the time, measured in miliseconds,
+// will quickly become a bigger number than can be stored in an int.
+long interval = 1000;           // interval at which to blink (milliseconds)
+
+void setup() {
+  // set the digital pin as output:
+  pinMode(ledPin, OUTPUT);      
+}
+
+void loop()
+{
+  // here is where you'd put code that needs to be running all the time.
+
+  // check to see if it's time to blink the LED; that is, is the difference
+  // between the current time and last time we blinked the LED bigger than
+  // the interval at which we want to blink the LED.
+  if (millis() - previousMillis > interval) {
+    // save the last time you blinked the LED 
+    previousMillis = millis();   
+
+    // if the LED is off turn it on and vice-versa:
+    if (ledState == LOW)
+      ledState = HIGH;
+    else
+      ledState = LOW;
+      
+    // set the LED with the ledState of the variable:
+    digitalWrite(ledPin, ledState);
+  }
+}

arduino-0018-linux/examples/Digital/Button/Button.pde

@@ -0,0 +1,54 @@
+/*
+  Button
+ 
+ Turns on and off a light emitting diode(LED) connected to digital  
+ pin 13, when pressing a pushbutton attached to pin 7. 
+ 
+ 
+ The circuit:
+ * LED attached from pin 13 to ground 
+ * pushbutton attached to pin 2 from +5V
+ * 10K resistor attached to pin 2 from ground
+ 
+ * Note: on most Arduinos there is already an LED on the board
+ attached to pin 13.
+ 
+ 
+ created 2005
+ by DojoDave <http://www.0j0.org>
+ modified 17 Jun 2009
+ by Tom Igoe
+ 
+  http://www.arduino.cc/en/Tutorial/Button
+ */
+
+// constants won't change. They're used here to 
+// set pin numbers:
+const int buttonPin = 2;     // the number of the pushbutton pin
+const int ledPin =  13;      // the number of the LED pin
+
+// variables will change:
+int buttonState = 0;         // variable for reading the pushbutton status
+
+void setup() {
+  // initialize the LED pin as an output:
+  pinMode(ledPin, OUTPUT);      
+  // initialize the pushbutton pin as an input:
+  pinMode(buttonPin, INPUT);     
+}
+
+void loop(){
+  // read the state of the pushbutton value:
+  buttonState = digitalRead(buttonPin);
+
+  // check if the pushbutton is pressed.
+  // if it is, the buttonState is HIGH:
+  if (buttonState == HIGH) {     
+    // turn LED on:    
+    digitalWrite(ledPin, HIGH);  
+  } 
+  else {
+    // turn LED off:
+    digitalWrite(ledPin, LOW); 
+  }
+}

arduino-0018-linux/examples/Digital/Debounce/Debounce.pde

@@ -0,0 +1,74 @@
+/* 
+ Debounce
+ 
+ Each time the input pin goes from LOW to HIGH (e.g. because of a push-button
+ press), the output pin is toggled from LOW to HIGH or HIGH to LOW.  There's
+ a minimum delay between toggles to debounce the circuit (i.e. to ignore
+ noise).  
+ 
+ The circuit:
+ * LED attached from pin 13 to ground
+ * pushbutton attached from pin 2 to +5V
+ * 10K resistor attached from pin 2 to ground
+ 
+ * Note: On most Arduino boards, there is already an LED on the board
+ connected to pin 13, so you don't need any extra components for this example.
+ 
+ 
+ created 21 November 2006
+ by David A. Mellis
+ modified 3 Jul 2009
+ by Limor Fried
+ 
+ 
+ http://www.arduino.cc/en/Tutorial/Debounce
+ */
+
+// constants won't change. They're used here to 
+// set pin numbers:
+const int buttonPin = 2;     // the number of the pushbutton pin
+const int ledPin =  13;      // the number of the LED pin
+
+// Variables will change:
+int ledState = HIGH;         // the current state of the output pin
+int buttonState;             // the current reading from the input pin
+int lastButtonState = LOW;   // the previous reading from the input pin
+
+// the following variables are long's because the time, measured in miliseconds,
+// will quickly become a bigger number than can be stored in an int.
+long lastDebounceTime = 0;  // the last time the output pin was toggled
+long debounceDelay = 50;    // the debounce time; increase if the output flickers
+
+void setup() {
+  pinMode(buttonPin, INPUT);
+  pinMode(ledPin, OUTPUT);
+}
+
+void loop() {
+  // read the state of the switch into a local variable:
+  int reading = digitalRead(buttonPin);
+
+  // check to see if you just pressed the button 
+  // (i.e. the input went from LOW to HIGH),  and you've waited 
+  // long enough since the last press to ignore any noise:  
+
+  // If the switch changed, due to noise or pressing:
+  if (reading != lastButtonState) {
+    // reset the debouncing timer
+    lastDebounceTime = millis();
+  } 
+  
+  if ((millis() - lastDebounceTime) > debounceDelay) {
+    // whatever the reading is at, it's been there for longer
+    // than the debounce delay, so take it as the actual current state:
+    buttonState = reading;
+  }
+  
+  // set the LED using the state of the button:
+  digitalWrite(ledPin, buttonState);
+
+  // save the reading.  Next time through the loop,
+  // it'll be the lastButtonState:
+  lastButtonState = reading;
+}
+

arduino-0018-linux/examples/Digital/StateChangeDetection/StateChangeDetection.pde

@@ -0,0 +1,90 @@
+/*
+  State change detection (edge detection)
+ 	
+ Often, you don't need to know the state of a digital input all the time,
+ but you just need to know when the input changes from one state to another.
+ For example, you want to know when a button goes from OFF to ON.  This is called
+ state change detection, or edge detection.
+ 
+ This example shows how to detect when a button or button changes from off to on
+ and on to off.
+ 	
+ The circuit:
+ * pushbutton attached to pin 2 from +5V
+ * 10K resistor attached to pin 2 from ground
+ * LED attached from pin 13 to ground (or use the built-in LED on
+   most Arduino boards)
+ 
+ created  27 Sep 2005
+ modified 30 Dec 2009
+ by Tom Igoe
+ 	
+ http://arduino.cc/en/Tutorial/ButtonStateChange
+ 
+ */
+
+// this constant won't change:
+const int  buttonPin = 2;    // the pin that the pushbutton is attached to
+const int ledPin = 13;       // the pin that the LED is attached to
+
+// Variables will change:
+int buttonPushCounter = 0;   // counter for the number of button presses
+int buttonState = 0;         // current state of the button
+int lastButtonState = 0;     // previous state of the button
+
+void setup() {
+  // initialize the button pin as a input:
+  pinMode(buttonPin, INPUT);
+  // initialize the LED as an output:
+  pinMode(ledPin, OUTPUT);
+  // initialize serial communication:
+  Serial.begin(9600);
+}
+
+
+void loop() {
+  // read the pushbutton input pin:
+  buttonState = digitalRead(buttonPin);
+
+  // compare the buttonState to its previous state
+  if (buttonState != lastButtonState) {
+    // if the state has changed, increment the counter
+    if (buttonState == HIGH) {
+      // if the current state is HIGH then the button
+      // wend from off to on:
+      buttonPushCounter++;
+      Serial.println("on");
+      Serial.print("number of button pushes:  ");
+      Serial.println(buttonPushCounter, DEC);
+    } 
+    else {
+      // if the current state is LOW then the button
+      // wend from on to off:
+      Serial.println("off"); 
+    }
+
+    // save the current state as the last state, 
+    //for next time through the loop
+    lastButtonState = buttonState;
+  }
+  
+  // turns on the LED every four button pushes by 
+  // checking the modulo of the button push counter.
+  // the modulo function gives you the remainder of 
+  // the division of two numbers:
+  if (buttonPushCounter % 4 == 0) {
+    digitalWrite(ledPin, HIGH);
+  } else {
+   digitalWrite(ledPin, LOW);
+  }
+  
+}
+
+
+
+
+
+
+
+
+

arduino-0018-linux/examples/Digital/toneKeyboard/pitches.h

@@ -0,0 +1,95 @@
+/*************************************************
+ * Public Constants
+ *************************************************/
+
+#define NOTE_B0  31
+#define NOTE_C1  33
+#define NOTE_CS1 35
+#define NOTE_D1  37
+#define NOTE_DS1 39
+#define NOTE_E1  41
+#define NOTE_F1  44
+#define NOTE_FS1 46
+#define NOTE_G1  49
+#define NOTE_GS1 52
+#define NOTE_A1  55
+#define NOTE_AS1 58
+#define NOTE_B1  62
+#define NOTE_C2  65
+#define NOTE_CS2 69
+#define NOTE_D2  73
+#define NOTE_DS2 78
+#define NOTE_E2  82
+#define NOTE_F2  87
+#define NOTE_FS2 93
+#define NOTE_G2  98
+#define NOTE_GS2 104
+#define NOTE_A2  110
+#define NOTE_AS2 117
+#define NOTE_B2  123
+#define NOTE_C3  131
+#define NOTE_CS3 139
+#define NOTE_D3  147
+#define NOTE_DS3 156
+#define NOTE_E3  165
+#define NOTE_F3  175
+#define NOTE_FS3 185
+#define NOTE_G3  196
+#define NOTE_GS3 208
+#define NOTE_A3  220
+#define NOTE_AS3 233
+#define NOTE_B3  247
+#define NOTE_C4  262
+#define NOTE_CS4 277
+#define NOTE_D4  294
+#define NOTE_DS4 311
+#define NOTE_E4  330
+#define NOTE_F4  349
+#define NOTE_FS4 370
+#define NOTE_G4  392
+#define NOTE_GS4 415
+#define NOTE_A4  440
+#define NOTE_AS4 466
+#define NOTE_B4  494
+#define NOTE_C5  523
+#define NOTE_CS5 554
+#define NOTE_D5  587
+#define NOTE_DS5 622
+#define NOTE_E5  659
+#define NOTE_F5  698
+#define NOTE_FS5 740
+#define NOTE_G5  784
+#define NOTE_GS5 831
+#define NOTE_A5  880
+#define NOTE_AS5 932
+#define NOTE_B5  988
+#define NOTE_C6  1047
+#define NOTE_CS6 1109
+#define NOTE_D6  1175
+#define NOTE_DS6 1245
+#define NOTE_E6  1319
+#define NOTE_F6  1397
+#define NOTE_FS6 1480
+#define NOTE_G6  1568
+#define NOTE_GS6 1661
+#define NOTE_A6  1760
+#define NOTE_AS6 1865
+#define NOTE_B6  1976
+#define NOTE_C7  2093
+#define NOTE_CS7 2217
+#define NOTE_D7  2349
+#define NOTE_DS7 2489
+#define NOTE_E7  2637
+#define NOTE_F7  2794
+#define NOTE_FS7 2960
+#define NOTE_G7  3136
+#define NOTE_GS7 3322
+#define NOTE_A7  3520
+#define NOTE_AS7 3729
+#define NOTE_B7  3951
+#define NOTE_C8  4186
+#define NOTE_CS8 4435
+#define NOTE_D8  4699
+#define NOTE_DS8 4978
+
+

arduino-0018-linux/examples/Digital/toneKeyboard/toneKeyboard.pde

@@ -0,0 +1,49 @@
+/*
+  keyboard
+ 
+ Plays a pitch that changes based on a changing analog input
+ 
+ circuit:
+ * 3 force-sensing resistors from +5V to analog in 0 through 5
+ * 3 10K resistors from analog in 0 through 5 to ground
+ * 8-ohm speaker on digital pin 8
+ 
+ created 21 Jan 2010
+ by Tom Igoe 
+ 
+ http://arduino.cc/en/Tutorial/Tone3
+ 
+ */
+
+#include "pitches.h"
+
+const int threshold = 10;    // minimum reading of the sensors that generates a note
+
+// notes to play, corresponding to the 3 sensors:
+int notes[] = {
+  NOTE_A4, NOTE_B4,NOTE_C3 };
+
+void setup() {
+
+}
+
+void loop() {
+  for (int thisSensor = 0; thisSensor < 3; thisSensor++) {
+    // get a sensor reading:
+    int sensorReading = analogRead(thisSensor);
+
+    // if the sensor is pressed hard enough:
+    if (sensorReading > threshold) {
+      // play the note corresponding to this sensor:
+      tone(8, notes[thisSensor], 20);
+    } 
+  }
+  Serial.println();
+}
+
+
+
+
+
+
+

arduino-0018-linux/examples/Digital/toneMelody/pitches.h

@@ -0,0 +1,95 @@
+/*************************************************
+ * Public Constants
+ *************************************************/
+
+#define NOTE_B0  31
+#define NOTE_C1  33
+#define NOTE_CS1 35
+#define NOTE_D1  37
+#define NOTE_DS1 39
+#define NOTE_E1  41
+#define NOTE_F1  44
+#define NOTE_FS1 46
+#define NOTE_G1  49
+#define NOTE_GS1 52
+#define NOTE_A1  55
+#define NOTE_AS1 58
+#define NOTE_B1  62
+#define NOTE_C2  65
+#define NOTE_CS2 69
+#define NOTE_D2  73
+#define NOTE_DS2 78
+#define NOTE_E2  82
+#define NOTE_F2  87
+#define NOTE_FS2 93
+#define NOTE_G2  98
+#define NOTE_GS2 104
+#define NOTE_A2  110
+#define NOTE_AS2 117
+#define NOTE_B2  123
+#define NOTE_C3  131
+#define NOTE_CS3 139
+#define NOTE_D3  147
+#define NOTE_DS3 156
+#define NOTE_E3  165
+#define NOTE_F3  175
+#define NOTE_FS3 185
+#define NOTE_G3  196
+#define NOTE_GS3 208
+#define NOTE_A3  220
+#define NOTE_AS3 233
+#define NOTE_B3  247
+#define NOTE_C4  262
+#define NOTE_CS4 277
+#define NOTE_D4  294
+#define NOTE_DS4 311
+#define NOTE_E4  330
+#define NOTE_F4  349
+#define NOTE_FS4 370
+#define NOTE_G4  392
+#define NOTE_GS4 415
+#define NOTE_A4  440
+#define NOTE_AS4 466
+#define NOTE_B4  494
+#define NOTE_C5  523
+#define NOTE_CS5 554
+#define NOTE_D5  587
+#define NOTE_DS5 622
+#define NOTE_E5  659
+#define NOTE_F5  698
+#define NOTE_FS5 740
+#define NOTE_G5  784
+#define NOTE_GS5 831
+#define NOTE_A5  880
+#define NOTE_AS5 932
+#define NOTE_B5  988
+#define NOTE_C6  1047
+#define NOTE_CS6 1109
+#define NOTE_D6  1175
+#define NOTE_DS6 1245
+#define NOTE_E6  1319
+#define NOTE_F6  1397
+#define NOTE_FS6 1480
+#define NOTE_G6  1568
+#define NOTE_GS6 1661
+#define NOTE_A6  1760
+#define NOTE_AS6 1865
+#define NOTE_B6  1976
+#define NOTE_C7  2093
+#define NOTE_CS7 2217
+#define NOTE_D7  2349
+#define NOTE_DS7 2489
+#define NOTE_E7  2637
+#define NOTE_F7  2794
+#define NOTE_FS7 2960
+#define NOTE_G7  3136
+#define NOTE_GS7 3322
+#define NOTE_A7  3520
+#define NOTE_AS7 3729
+#define NOTE_B7  3951
+#define NOTE_C8  4186
+#define NOTE_CS8 4435
+#define NOTE_D8  4699
+#define NOTE_DS8 4978
+
+

arduino-0018-linux/examples/Digital/toneMelody/toneMelody.pde

@@ -0,0 +1,48 @@
+/*
+  Melody
+ 
+ Plays a melody 
+ 
+ circuit:
+ * 8-ohm speaker on digital pin 8
+ 
+ created 21 Jan 2010
+ by Tom Igoe 
+ 
+ http://arduino.cc/en/Tutorial/Tone
+ 
+ */
+ #include "pitches.h"
+
+// notes in the melody:
+int melody[] = {
+  NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};
+
+// note durations: 4 = quarter note, 8 = eighth note, etc.:
+int noteDurations[] = {
+  4, 8, 8, 4,4,4,4,4 };
+
+void setup() {
+  // iterate over the notes of the melody:
+  for (int thisNote = 0; thisNote < 8; thisNote++) {
+
+    // to calculate the note duration, take one second 
+    // divided by the note type.
+    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
+    int noteDuration = 1000/noteDurations[thisNote];
+    tone(8, melody[thisNote],noteDuration);
+
+    // to distinguish the notes, set a minimum time between them.
+    // the note's duration + 30% seems to work well:
+    int pauseBetweenNotes = noteDuration * 1.30;
+    delay(pauseBetweenNotes);
+  }
+}
+
+void loop() {
+  // no need to repeat the melody.
+}
+
+
+
+

arduino-0018-linux/examples/Digital/tonePitchFollower/tonePitchFollower.pde

@@ -0,0 +1,43 @@
+/*
+  Pitch follower
+ 
+ Plays a pitch that changes based on a changing analog input
+ 
+ circuit:
+ * 8-ohm speaker on digital pin 8
+ * photoresistor on analog 0 to 5V
+ * 4.7K resistor on analog 0 to ground
+ 
+ created 21 Jan 2010
+ by Tom Igoe 
+ 
+ http://arduino.cc/en/Tutorial/Tone2
+ 
+ */
+
+
+void setup() {
+  // initialize serial communications (for debugging only):
+  Serial.begin(9600);
+}
+
+void loop() {
+  // read the sensor:
+  int sensorReading = analogRead(0);
+  // print the sensor reading so you know its range
+  Serial.println(sensorReading);
+  // map the pitch to the range of the analog input.
+  // change the minimum and maximum input numbers below
+  // depending on the range your sensor's giving:
+  int thisPitch = map(sensorReading, 400, 1000, 100, 1000);
+
+  // play the pitch:
+  tone(8, thisPitch, 10);
+
+}
+
+
+
+
+
+

arduino-0018-linux/examples/Display/RowColumnScanning/RowColumnScanning.pde

@@ -0,0 +1,112 @@
+/*
+  Row-Column Scanning an 8x8 LED matrix with X-Y input
+ 
+ This example controls an 8x8 LED matrix using two analog inputs
+ 
+ created 27 May 2009
+ modified 29 Jun 2009
+ by Tom Igoe
+ 
+ This example works for the Lumex  LDM-24488NI Matrix. See 
+ http://sigma.octopart.com/140413/datasheet/Lumex-LDM-24488NI.pdf
+ for the pin connections
+ 
+ For other LED cathode column matrixes, you should only need to change 
+ the pin numbers in the row[] and column[] arrays
+ 
+ rows are the anodes
+ cols are the cathodes
+ ---------
+ 
+ Pin numbers:
+ Matrix:
+ * Digital pins 2 through 13,
+ * analog pins 2 through 5 used as digital 16 through 19
+ Potentiometers:
+ * center pins are attached to analog pins 0 and 1, respectively
+ * side pins attached to +5V and ground, respectively.
+ 
+ http://www.arduino.cc/en/Tutorial/RowColumnScanning
+ 
+ see also http://www.tigoe.net/pcomp/code/category/arduinowiring/514 for more
+ */
+
+
+// 2-dimensional array of row pin numbers:
+const int row[8] = {
+  2,7,19,5,13,18,12,16 };
+
+// 2-dimensional array of column pin numbers:
+const int col[8] = {
+  6,11,10,3,17,4,8,9  };
+
+// 2-dimensional array of pixels:
+int pixels[8][8];           
+
+// cursor position:
+int x = 5;
+int y = 5;
+
+void setup() {
+  Serial.begin(9600);
+  // initialize the I/O pins as outputs:
+
+  // iterate over the pins:
+  for (int thisPin = 0; thisPin < 8; thisPin++) {
+    // initialize the output pins:
+    pinMode(col[thisPin], OUTPUT); 
+    pinMode(row[thisPin], OUTPUT);  
+    // take the col pins (i.e. the cathodes) high to ensure that
+    // the LEDS are off: 
+    digitalWrite(col[thisPin], HIGH);    
+  }
+
+  // initialize the pixel matrix:
+  for (int x = 0; x < 8; x++) {
+    for (int y = 0; y < 8; y++) {
+      pixels[x][y] = HIGH;
+    }
+  }
+}
+
+void loop() {
+  // read input:
+  readSensors();
+
+  // draw the screen:
+  refreshScreen();
+}
+
+void readSensors() {
+  // turn off the last position:
+  pixels[x][y] = HIGH;
+  // read the sensors for X and Y values:
+  x = 7 - map(analogRead(0), 0, 1023, 0, 7);
+  y = map(analogRead(1), 0, 1023, 0, 7);
+  // set the new pixel position low so that the LED will turn on
+  // in the next screen refresh:
+  pixels[x][y] = LOW;
+
+}
+
+void refreshScreen() {
+  // iterate over the rows (anodes):
+  for (int thisRow = 0; thisRow < 8; thisRow++) {
+    // take the row pin (anode) high:
+    digitalWrite(row[thisRow], HIGH);
+    // iterate over the cols (cathodes):
+    for (int thisCol = 0; thisCol < 8; thisCol++) {
+      // get the state of the current pixel;
+      int thisPixel = pixels[thisRow][thisCol];
+      // when the row is HIGH and the col is LOW,
+      // the LED where they meet turns on:
+      digitalWrite(col[thisCol], thisPixel);
+      // turn the pixel off:
+      if (thisPixel == LOW) {
+        digitalWrite(col[thisCol], HIGH);
+      }
+    }
+    // take the row pin low to turn off the whole row:
+    digitalWrite(row[thisRow], LOW);
+  }
+}

arduino-0018-linux/examples/Display/barGraph/barGraph.pde

@@ -0,0 +1,58 @@
+/*
+  LED bar graph
+ 
+  Turns on a series of LEDs based on the value of an analog sensor.
+  This is a simple way to make a bar graph display. Though this graph
+  uses 10 LEDs, you can use any number by changing the LED count
+  and the pins in the array.
+  
+  This method can be used to control any series of digital outputs that
+  depends on an analog input.
+ 
+  The circuit:
+   * LEDs from pins 2 through 11 to ground
+ 
+ created 26 Jun 2009
+ by Tom Igoe 
+ 
+ http://www.arduino.cc/en/Tutorial/BarGraph
+ */
+
+
+// these constants won't change:
+const int analogPin = 0;    // the pin that the potentiometer is attached to
+const int ledCount = 10;    // the number of LEDs in the bar graph
+
+int ledPins[] = { 
+  2, 3, 4, 5, 6, 7,8,9,10,11 };   // an array of pin numbers to which LEDs are attached
+
+
+void setup() {
+  // loop over the pin array and set them all to output:
+  for (int thisLed = 0; thisLed < ledCount; thisLed++) {
+    pinMode(ledPins[thisLed], OUTPUT); 
+  }
+}
+
+void loop() {
+  // read the potentiometer:
+  int sensorReading = analogRead(analogPin);
+  // map the result to a range from 0 to the number of LEDs:
+  int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
+
+  // loop over the LED array:
+  for (int thisLed = 0; thisLed < ledCount; thisLed++) {
+    // if the array element's index is less than ledLevel,
+    // turn the pin for this element on:
+    if (thisLed < ledLevel) {
+      digitalWrite(ledPins[thisLed], HIGH);
+    } 
+    // turn off all pins higher than the ledLevel:
+    else {
+      digitalWrite(ledPins[thisLed], LOW); 
+    }
+  }
+}
+
+
+

arduino-0018-linux/examples/Sensors/ADXL3xx/ADXL3xx.pde

@@ -0,0 +1,62 @@
+
+/*
+ ADXL3xx
+ 
+ Reads an Analog Devices ADXL3xx accelerometer and communicates the
+ acceleration to the computer.  The pins used are designed to be easily
+ compatible with the breakout boards from Sparkfun, available from:
+ http://www.sparkfun.com/commerce/categories.php?c=80
+
+ http://www.arduino.cc/en/Tutorial/ADXL3xx
+
+ The circuit:
+ analog 0: accelerometer self test
+ analog 1: z-axis
+ analog 2: y-axis
+ analog 3: x-axis
+ analog 4: ground
+ analog 5: vcc
+ 
+ created 2 Jul 2008
+ by David A. Mellis
+ modified 26 Jun 2009
+ by Tom Igoe 
+
+*/
+
+// these constants describe the pins. They won't change:
+const int groundpin = 18;             // analog input pin 4 -- ground
+const int powerpin = 19;              // analog input pin 5 -- voltage
+const int xpin = 3;                   // x-axis of the accelerometer
+const int ypin = 2;                   // y-axis
+const int zpin = 1;                   // z-axis (only on 3-axis models)
+
+void setup()
+{
+  // initialize the serial communications:
+  Serial.begin(9600);
+  
+  // Provide ground and power by using the analog inputs as normal
+  // digital pins.  This makes it possible to directly connect the
+  // breakout board to the Arduino.  If you use the normal 5V and
+  // GND pins on the Arduino, you can remove these lines.
+  pinMode(groundpin, OUTPUT);
+  pinMode(powerpin, OUTPUT);
+  digitalWrite(groundpin, LOW); 
+  digitalWrite(powerpin, HIGH);
+}
+
+void loop()
+{
+  // print the sensor values:
+  Serial.print(analogRead(xpin));
+  // print a tab between values:
+  Serial.print("\t");
+  Serial.print(analogRead(ypin));
+  // print a tab between values:
+  Serial.print("\t");
+  Serial.print(analogRead(zpin));
+  Serial.println();
+  // delay before next reading:
+  delay(100);
+}

arduino-0018-linux/examples/Sensors/Knock/Knock.pde

@@ -0,0 +1,53 @@
+/* Knock Sensor
+  
+   This sketch reads a piezo element to detect a knocking sound. 
+   It reads an analog pin and compares the result to a set threshold. 
+   If the result is greater than the threshold, it writes
+   "knock" to the serial port, and toggles the LED on pin 13.
+  
+   The circuit:
+	* + connection of the piezo attached to analog in 0
+	* - connection of the piezo attached to ground
+	* 1-megohm resistor attached from analog in 0 to ground
+
+   http://www.arduino.cc/en/Tutorial/Knock
+   
+   created 25 Mar 2007
+   by David Cuartielles <http://www.0j0.org>
+   modified 30 Jun 2009
+   by Tom Igoe
+
+ */
+ 
+
+// these constants won't change:
+const int ledPin = 13;      // led connected to digital pin 13
+const int knockSensor = 0;  // the piezo is connected to analog pin 0
+const int threshold = 100;  // threshold value to decide when the detected sound is a knock or not
+
+
+// these variables will change:
+int sensorReading = 0;      // variable to store the value read from the sensor pin
+int ledState = LOW;         // variable used to store the last LED status, to toggle the light
+
+void setup() {
+ pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
+ Serial.begin(9600);       // use the serial port
+}
+
+void loop() {
+  // read the sensor and store it in the variable sensorReading:
+  sensorReading = analogRead(knockSensor);    
+  
+  // if the sensor reading is greater than the threshold:
+  if (sensorReading >= threshold) {
+    // toggle the status of the ledPin:
+    ledState = !ledState;   
+    // update the LED pin itself:        
+    digitalWrite(ledPin, ledState);
+    // send the string "Knock!" back to the computer, followed by newline
+    Serial.println("Knock!");         
+  }
+  delay(100);  // delay to avoid overloading the serial port buffer
+}
+

arduino-0018-linux/examples/Sensors/Memsic2125/Memsic2125.pde

@@ -0,0 +1,61 @@
+/*
+   Memsic2125
+   
+   Read the Memsic 2125 two-axis accelerometer.  Converts the
+   pulses output by the 2125 into milli-g's (1/1000 of earth's
+   gravity) and prints them over the serial connection to the
+   computer.
+   
+   The circuit:
+	* X output of accelerometer to digital pin 2
+	* Y output of accelerometer to digital pin 3
+	* +V of accelerometer to +5V
+	* GND of accelerometer to ground
+  
+   http://www.arduino.cc/en/Tutorial/Memsic2125
+   
+   created 6 Nov 2008
+   by David A. Mellis
+   modified 30 Jun 2009
+   by Tom Igoe
+
+ */
+
+// these constants won't change:
+const int xPin = 2;		// X output of the accelerometer
+const int yPin = 3;		// Y output of the accelerometer
+
+void setup() {
+  // initialize serial communications:
+  Serial.begin(9600);
+  // initialize the pins connected to the accelerometer
+  // as inputs:
+  pinMode(xPin, INPUT);
+  pinMode(yPin, INPUT);
+}
+
+void loop() {
+  // variables to read the pulse widths:
+  int pulseX, pulseY;
+  // variables to contain the resulting accelerations
+  int accelerationX, accelerationY;
+  
+  // read pulse from x- and y-axes:
+  pulseX = pulseIn(xPin,HIGH);  
+  pulseY = pulseIn(yPin,HIGH);
+  
+  // convert the pulse width into acceleration
+  // accelerationX and accelerationY are in milli-g's: 
+  // earth's gravity is 1000 milli-g's, or 1g.
+  accelerationX = ((pulseX / 10) - 500) * 8;
+  accelerationY = ((pulseY / 10) - 500) * 8;
+
+  // print the acceleration
+  Serial.print(accelerationX);
+  // print a tab character:
+  Serial.print("\t");
+  Serial.print(accelerationY);
+  Serial.println();
+
+  delay(100);
+}

arduino-0018-linux/examples/Sensors/Ping/Ping.pde

@@ -0,0 +1,82 @@
+/* Ping))) Sensor
+  
+   This sketch reads a PING))) ultrasonic rangefinder and returns the
+   distance to the closest object in range. To do this, it sends a pulse
+   to the sensor to initiate a reading, then listens for a pulse 
+   to return.  The length of the returning pulse is proportional to 
+   the distance of the object from the sensor.
+     
+   The circuit:
+	* +V connection of the PING))) attached to +5V
+	* GND connection of the PING))) attached to ground
+	* SIG connection of the PING))) attached to digital pin 7
+
+   http://www.arduino.cc/en/Tutorial/Ping
+   
+   created 3 Nov 2008
+   by David A. Mellis
+   modified 30 Jun 2009
+   by Tom Igoe
+
+ */
+
+// this constant won't change.  It's the pin number
+// of the sensor's output:
+const int pingPin = 7;
+
+void setup() {
+  // initialize serial communication:
+  Serial.begin(9600);
+}
+
+void loop()
+{
+  // establish variables for duration of the ping, 
+  // and the distance result in inches and centimeters:
+  long duration, inches, cm;
+
+  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
+  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
+  pinMode(pingPin, OUTPUT);
+  digitalWrite(pingPin, LOW);
+  delayMicroseconds(2);
+  digitalWrite(pingPin, HIGH);
+  delayMicroseconds(5);
+  digitalWrite(pingPin, LOW);
+
+  // The same pin is used to read the signal from the PING))): a HIGH
+  // pulse whose duration is the time (in microseconds) from the sending
+  // of the ping to the reception of its echo off of an object.
+  pinMode(pingPin, INPUT);
+  duration = pulseIn(pingPin, HIGH);
+
+  // convert the time into a distance
+  inches = microsecondsToInches(duration);
+  cm = microsecondsToCentimeters(duration);
+  
+  Serial.print(inches);
+  Serial.print("in, ");
+  Serial.print(cm);
+  Serial.print("cm");
+  Serial.println();
+  
+  delay(100);
+}
+
+long microsecondsToInches(long microseconds)
+{
+  // According to Parallax's datasheet for the PING))), there are
+  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
+  // second).  This gives the distance travelled by the ping, outbound
+  // and return, so we divide by 2 to get the distance of the obstacle.
+  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
+  return microseconds / 74 / 2;
+}
+
+long microsecondsToCentimeters(long microseconds)
+{
+  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
+  // The ping travels out and back, so to find the distance of the
+  // object we take half of the distance travelled.
+  return microseconds / 29 / 2;
+}

arduino-0018-linux/examples/Stubs/AnalogReadSerial/AnalogReadSerial.pde

@@ -0,0 +1,12 @@
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  int sensorValue = analogRead(0);
+  Serial.println(sensorValue, DEC);
+}
+
+
+

arduino-0018-linux/examples/Stubs/AnalogReadWrite/AnalogReadWrite.pde

@@ -0,0 +1,13 @@
+
+void setup() {
+  pinMode(6, OUTPUT);
+}
+
+void loop() {
+  int sensorValue = analogRead(2);
+  int ledFadeValue = map(sensorValue, 0, 1023, 0, 255);
+  analogWrite(6, ledFadeValue);  
+}
+
+
+

arduino-0018-linux/examples/Stubs/BareMinumum/BareMinumum.pde

@@ -0,0 +1,9 @@
+void setup() {
+  
+}
+
+void loop() {
+  
+}
+
+

arduino-0018-linux/examples/Stubs/DigitalReadSerial/DigitalReadSerial.pde

@@ -0,0 +1,13 @@
+
+void setup() {
+  Serial.begin(9600);
+  pinMode(2, INPUT);
+}
+
+void loop() {
+  int sensorValue = digitalRead(2);
+  Serial.println(sensorValue, DEC);
+}
+
+
+

arduino-0018-linux/examples/Stubs/DigitalReadWrite/DigitalReadWrite.pde

@@ -0,0 +1,12 @@
+
+void setup() {
+  pinMode(13, OUTPUT);
+}
+
+void loop() {
+  int switchValue = digitalRead(2);
+  digitalWrite(13, switchValue);  
+}
+
+
+

arduino-0018-linux/examples/Stubs/HelloWorld/HelloWorld.pde

@@ -0,0 +1,9 @@
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  Serial.println("Hello World!");
+}
+
+

arduino-0018-linux/hardware/arduino/boards.txt

@@ -0,0 +1,220 @@
+##############################################################
+
+atmega328.name=Arduino Duemilanove or Nano w/ ATmega328
+
+atmega328.upload.protocol=stk500
+atmega328.upload.maximum_size=30720
+atmega328.upload.speed=57600
+
+atmega328.bootloader.low_fuses=0xFF
+atmega328.bootloader.high_fuses=0xDA
+atmega328.bootloader.extended_fuses=0x05
+atmega328.bootloader.path=atmega
+atmega328.bootloader.file=ATmegaBOOT_168_atmega328.hex
+atmega328.bootloader.unlock_bits=0x3F
+atmega328.bootloader.lock_bits=0x0F
+
+atmega328.build.mcu=atmega328p
+atmega328.build.f_cpu=16000000L
+atmega328.build.core=arduino
+
+##############################################################
+
+diecimila.name=Arduino Diecimila, Duemilanove, or Nano w/ ATmega168
+
+diecimila.upload.protocol=stk500
+diecimila.upload.maximum_size=14336
+diecimila.upload.speed=19200
+
+diecimila.bootloader.low_fuses=0xff
+diecimila.bootloader.high_fuses=0xdd
+diecimila.bootloader.extended_fuses=0x00
+diecimila.bootloader.path=atmega
+diecimila.bootloader.file=ATmegaBOOT_168_diecimila.hex
+diecimila.bootloader.unlock_bits=0x3F
+diecimila.bootloader.lock_bits=0x0F
+
+diecimila.build.mcu=atmega168
+diecimila.build.f_cpu=16000000L
+diecimila.build.core=arduino
+
+##############################################################
+
+mega.name=Arduino Mega
+
+mega.upload.protocol=stk500
+mega.upload.maximum_size=126976
+mega.upload.speed=57600
+
+mega.bootloader.low_fuses=0xFF
+mega.bootloader.high_fuses=0xDA
+mega.bootloader.extended_fuses=0xF5
+mega.bootloader.path=atmega
+mega.bootloader.file=ATmegaBOOT_168_atmega1280.hex
+mega.bootloader.unlock_bits=0x3F
+mega.bootloader.lock_bits=0x0F
+
+mega.build.mcu=atmega1280
+mega.build.f_cpu=16000000L
+mega.build.core=arduino
+
+##############################################################
+
+mini.name=Arduino Mini
+
+mini.upload.protocol=stk500
+mini.upload.maximum_size=14336
+mini.upload.speed=19200
+
+mini.bootloader.low_fuses=0xff
+mini.bootloader.high_fuses=0xdd
+mini.bootloader.extended_fuses=0x00
+mini.bootloader.path=atmega
+mini.bootloader.file=ATmegaBOOT_168_ng.hex
+mini.bootloader.unlock_bits=0x3F
+mini.bootloader.lock_bits=0x0F
+
+mini.build.mcu=atmega168
+mini.build.f_cpu=16000000L
+mini.build.core=arduino
+
+##############################################################
+
+bt.name=Arduino BT
+
+bt.upload.protocol=stk500
+bt.upload.maximum_size=14336
+bt.upload.speed=19200
+bt.upload.disable_flushing=true
+
+bt.bootloader.low_fuses=0xff
+bt.bootloader.high_fuses=0xdd
+bt.bootloader.extended_fuses=0x00
+bt.bootloader.path=bt
+bt.bootloader.file=ATmegaBOOT_168.hex
+bt.bootloader.unlock_bits=0x3F
+bt.bootloader.lock_bits=0x0F
+
+bt.build.mcu=atmega168
+bt.build.f_cpu=16000000L
+bt.build.core=arduino
+
+##############################################################
+
+lilypad328.name=LilyPad Arduino w/ ATmega328
+
+lilypad328.upload.protocol=stk500
+lilypad328.upload.maximum_size=30720
+lilypad328.upload.speed=57600
+
+lilypad328.bootloader.low_fuses=0xFF
+lilypad328.bootloader.high_fuses=0xDA
+lilypad328.bootloader.extended_fuses=0x05
+lilypad328.bootloader.path=atmega
+lilypad328.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
+lilypad328.bootloader.unlock_bits=0x3F
+lilypad328.bootloader.lock_bits=0x0F
+
+lilypad328.build.mcu=atmega328p
+lilypad328.build.f_cpu=8000000L
+lilypad328.build.core=arduino
+
+##############################################################
+
+lilypad.name=LilyPad Arduino w/ ATmega168
+
+lilypad.upload.protocol=stk500
+lilypad.upload.maximum_size=14336
+lilypad.upload.speed=19200
+
+lilypad.bootloader.low_fuses=0xe2
+lilypad.bootloader.high_fuses=0xdd
+lilypad.bootloader.extended_fuses=0x00
+lilypad.bootloader.path=lilypad
+lilypad.bootloader.file=LilyPadBOOT_168.hex
+lilypad.bootloader.unlock_bits=0x3F
+lilypad.bootloader.lock_bits=0x0F
+
+lilypad.build.mcu=atmega168
+lilypad.build.f_cpu=8000000L
+lilypad.build.core=arduino
+
+##############################################################
+
+pro328.name=Arduino Pro or Pro Mini (3.3V, 8 MHz) w/ ATmega328
+
+pro328.upload.protocol=stk500
+pro328.upload.maximum_size=30720
+pro328.upload.speed=57600
+
+pro328.bootloader.low_fuses=0xFF
+pro328.bootloader.high_fuses=0xDA
+pro328.bootloader.extended_fuses=0x05
+pro328.bootloader.path=atmega
+pro328.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
+pro328.bootloader.unlock_bits=0x3F
+pro328.bootloader.lock_bits=0x0F
+
+pro328.build.mcu=atmega328p
+pro328.build.f_cpu=8000000L
+pro328.build.core=arduino
+
+##############################################################
+
+pro.name=Arduino Pro or Pro Mini (3.3V, 8 MHz) w/ ATmega168
+
+pro.upload.protocol=stk500
+pro.upload.maximum_size=14336
+pro.upload.speed=19200
+
+pro.bootloader.low_fuses=0xc6
+pro.bootloader.high_fuses=0xdd
+pro.bootloader.extended_fuses=0x00
+pro.bootloader.path=atmega
+pro.bootloader.file=ATmegaBOOT_168_pro_8MHz.hex
+pro.bootloader.unlock_bits=0x3F
+pro.bootloader.lock_bits=0x0F
+
+pro.build.mcu=atmega168
+pro.build.f_cpu=8000000L
+pro.build.core=arduino
+
+##############################################################
+
+atmega168.name=Arduino NG or older w/ ATmega168
+
+atmega168.upload.protocol=stk500
+atmega168.upload.maximum_size=14336
+atmega168.upload.speed=19200
+
+atmega168.bootloader.low_fuses=0xff
+atmega168.bootloader.high_fuses=0xdd
+atmega168.bootloader.extended_fuses=0x00
+atmega168.bootloader.path=atmega
+atmega168.bootloader.file=ATmegaBOOT_168_ng.hex
+atmega168.bootloader.unlock_bits=0x3F
+atmega168.bootloader.lock_bits=0x0F
+
+atmega168.build.mcu=atmega168
+atmega168.build.f_cpu=16000000L
+atmega168.build.core=arduino
+
+##############################################################
+
+atmega8.name=Arduino NG or older w/ ATmega8
+
+atmega8.upload.protocol=stk500
+atmega8.upload.maximum_size=7168
+atmega8.upload.speed=19200
+
+atmega8.bootloader.low_fuses=0xdf
+atmega8.bootloader.high_fuses=0xca
+atmega8.bootloader.path=atmega8
+atmega8.bootloader.file=ATmegaBOOT.hex
+atmega8.bootloader.unlock_bits=0x3F
+atmega8.bootloader.lock_bits=0x0F
+
+atmega8.build.mcu=atmega8
+atmega8.build.f_cpu=16000000L
+atmega8.build.core=arduino
+

arduino-0018-linux/hardware/arduino/bootloaders/atmega/ATmegaBOOT_168_atmega1280.hex

@@ -0,0 +1,245 @@
+:020000021000EC
+:10F000000C9472F80C9492F80C9492F80C9492F878
+:10F010000C9492F80C9492F80C9492F80C9492F848
+:10F020000C9492F80C9492F80C9492F80C9492F838
+:10F030000C9492F80C9492F80C9492F80C9492F828
+:10F040000C9492F80C9492F80C9492F80C9492F818
+:10F050000C9492F80C9492F80C9492F80C9492F808
+:10F060000C9492F80C9492F80C9492F80C9492F8F8
+:10F070000C9492F80C9492F80C9492F80C9492F8E8
+:10F080000C9492F80C9492F80C9492F80C9492F8D8
+:10F090000C9492F80C9492F80C9492F80C9492F8C8
+:10F0A0000C9492F80C9492F80C9492F80C9492F8B8
+:10F0B0000C9492F80C9492F80C9492F80C9492F8A8
+:10F0C0000C9492F80C9492F80C9492F80C9492F898
+:10F0D0000C9492F80C9492F80C9492F80C9492F888
+:10F0E0000C9492F811241FBECFEFD1E2DEBFCDBF4A
+:10F0F00012E0A0E0B2E0EEEDFEEF01E00BBF02C0D7
+:10F1000007900D92A833B107D9F71BBE13E0A8E30F
+:10F11000B2E001C01D92A334B107E1F70E9412FAD8
+:10F120000C946DFF0C9400F8982F959595959595F6
+:10F130009595905D8F708A301CF1282F295A809107
+:10F140003802813019F0823071F008958091C0004A
+:10F1500085FFFCCF9093C6008091C00085FFFCCF57
+:10F160002093C60008958091C80085FFFCCF90933E
+:10F17000CE008091C80085FFFCCF2093CE0008957B
+:10F18000282F205DDCCF982F80913802813019F034
+:10F19000823041F008958091C00085FFFCCF9093AC
+:10F1A000C60008958091C80085FFFCCF9093CE00E3
+:10F1B0000895EF92FF920F931F9380913802813050
+:10F1C00069F1823031F080E01F910F91FF90EF9054
+:10F1D0000895EE24FF2487018091C80087FD17C0A1
+:10F1E0000894E11CF11C011D111D81E4E81682E464
+:10F1F000F8068FE0080780E0180770F3E0913A0204
+:10F20000F0913B0209958091C80087FFE9CF80917A
+:10F21000CE001F910F91FF90EF900895EE24FF24F0
+:10F2200087018091C00087FD17C00894E11CF11C84
+:10F23000011D111D81E4E81682E4F8068FE008073D
+:10F2400080E0180770F3E0913A02F0913B020995D3
+:10F250008091C00087FFE9CF8091C6001F910F9178
+:10F26000FF90EF9008950E94D9F8982F809138026E
+:10F27000813049F0823091F091366CF490330CF08B
+:10F280009053892F08958091C00085FFFCCF909303
+:10F29000C60091369CF39755892F08958091C80038
+:10F2A00085FFFCCF9093CE00E7CF1F930E9433F9E8
+:10F2B000182F0E9433F91295107F810F1F91089526
+:10F2C000982F20913802992339F0213031F02230E3
+:10F2D00061F091509923C9F708958091C00087FF8C
+:10F2E000FCCF8091C6009150F5CF8091C80087FF78
+:10F2F000FCCF8091CE009150EDCF1F93182F0E942C
+:10F30000D9F8803249F0809139028F5F80933902B9
+:10F31000853091F11F910895809138028130B9F0C4
+:10F320008230C1F78091C80085FFFCCF84E18093D3
+:10F33000CE008091C80085FFFCCF1093CE00809155
+:10F34000C80085FFFCCF80E18093CE00E3CF8091A1
+:10F35000C00085FFFCCF84E18093C6008091C0008F
+:10F3600085FFFCCF1093C6008091C00085FFFCCFC5
+:10F3700080E18093C600CECFE0913A02F0913B024B
+:10F3800009951F9108950E94D9F8803241F080912B
+:10F3900039028F5F80933902853029F10895809179
+:10F3A0003802813089F08230C9F78091C80085FF2A
+:10F3B000FCCF84E18093CE008091C80085FFFCCF14
+:10F3C00080E18093CE0008958091C00085FFFCCF3E
+:10F3D00084E18093C6008091C00085FFFCCF80E16E
+:10F3E0008093C6000895E0913A02F0913B0209959E
+:10F3F000089540E951E08823A1F02F9A28EE33E0E8
+:10F40000FA013197F1F721503040D1F72F9828EECB
+:10F4100033E0FA013197F1F721503040D1F78150B4
+:10F4200061F708952F923F924F925F926F927F9271
+:10F430008F929F92AF92BF92CF92DF92EF92FF9204
+:10F440000F931F93CF93DF93000081E080933802E6
+:10F4500080E18093C4001092C5001092C00086E045
+:10F460008093C20088E18093C1006898709A279ABF
+:10F4700081E00E94F9F9E4E1EE2E7EE1D72E67E902
+:10F48000C62E53E0B52E40E1A42E9924939431E486
+:10F49000832E26E5722E92E5692E80E2582E09E42D
+:10F4A000402E13E5312EB0E52B2E0E94D9F8803383
+:10F4B000C9F1813309F452C0803409F4C8C08134E1
+:10F4C00009F4EAC0823489F1853409F4CAC0803570
+:10F4D00049F1823539F1813529F1853509F4ECC0DE
+:10F4E000863509F409C1843609F428C1843709F442
+:10F4F000ABC1853709F473C2863709F4D9C08132AC
+:10F5000009F4B7C2809139028F5F80933902853048
+:10F5100061F6E0913A02F0913B0209950E94D9F818
+:10F52000803339F60E94C3F9C0CF2091380293E1AD
+:10F5300005C0223061F09923A9F391502130C9F719
+:10F540008091C00087FFFCCF8091C600F4CF8091EE
+:10F55000C80087FFFCCF8091CE00EDCF0E94D9F884
+:10F56000803281F6809138028130D1F1823009F009
+:10F570009CCF8091C80085FFFCCFE092CE008091A7
+:10F58000C80085FFFCCF8092CE008091C80085FF27
+:10F59000FCCF7092CE008091C80085FFFCCF6092B6
+:10F5A000CE008091C80085FFFCCF5092CE008091A4
+:10F5B000C80085FFFCCF4092CE008091C80085FF37
+:10F5C000FCCF3092CE008091C80085FFFCCF209206
+:10F5D000CE008091C80085FFFCCFA092CE0065CF01
+:10F5E0008091C00085FFFCCFE092C6008091C000F2
+:10F5F00085FFFCCF8092C6008091C00085FFFCCFC4
+:10F600007092C6008091C00085FFFCCF6092C6005A
+:10F610008091C00085FFFCCF5092C6008091C00051
+:10F6200085FFFCCF4092C6008091C00085FFFCCFD3
+:10F630003092C6008091C00085FFFCCF2092C600AA
+:10F640008091C00085FFFCCFA092C6002ECF0E9403
+:10F65000D9F8863808F466CF0E94D9F80E94C3F919
+:10F6600024CF2091380294E0213041F0223069F01B
+:10F67000992309F457CF91502130C1F78091C000F0
+:10F6800087FFFCCF8091C600F3CF8091C80087FF31
+:10F69000FCCF8091CE00ECCF0E94D9F8803841F1A8
+:10F6A000813809F447C0823809F4CAC08839E1F0CA
+:10F6B00080E00E947DF9F9CE0E94D9F880933C0247
+:10F6C0000E94D9F880933D020E94C3F9EECE0E94B9
+:10F6D000D9F80E94D9F8182F0E94D9F8112309F4FB
+:10F6E0007EC2113009F40AC283E00E947DF9DDCEAA
+:10F6F00082E00E947DF9D9CE0E94D9F8803339F397
+:10F700002091380292E0213039F0223061F09923C3
+:10F7100079F291502130C9F78091C00087FFFCCF6A
+:10F720008091C600F4CF8091C80087FFFCCF809104
+:10F73000CE00EDCF81E00E947DF9B7CE0E94D9F8CE
+:10F7400080933F030E94D9F880933E038091420347
+:10F750008E7F809342030E94D9F8853409F4B3C1A7
+:10F7600080913E0390913F03892B89F000E010E0E7
+:10F770000E94D9F8F801E25CFD4F80830F5F1F4FB4
+:10F7800080913E0390913F030817190788F30E9468
+:10F79000D9F8803209F0B6CE8091420380FFB2C121
+:10F7A00040913C0250913D02440F551F50933D0241
+:10F7B00040933C0260913E0370913F0361157105D7
+:10F7C000F1F080E090E09A01280F391FFC01E25C23
+:10F7D000FD4FE081F999FECF1FBA32BD21BDE0BDDA
+:10F7E0000FB6F894FA9AF99A0FBE01968617970702
+:10F7F00050F3460F571F50933D0240933C028091B7
+:10F800003802813081F0823009F04FCE8091C800FB
+:10F8100085FFFCCFE092CE008091C80085FFFCCF31
+:10F82000A092CE0042CE8091C00085FFFCCFE09236
+:10F83000C6008091C00085FFFCCFA092C60035CEE7
+:10F8400080E10E947DF931CE0E94D9F880933F0378
+:10F850000E94D9F880933E0320913C0230913D02F2
+:10F8600037FD46C1809142038D7F80934203220F72
+:10F87000331F30933D0220933C020E94D9F8853417
+:10F8800009F430C1809142038E7F809342030E942D
+:10F89000D9F8803209F009CE60913802613009F45C
+:10F8A0006FC0623009F473C000913E0310913F03B2
+:10F8B0000115110509F440C080914203782F717041
+:10F8C000F82EF69481E0F82240913C0250913D02DE
+:10F8D00020E030E013C0FF2009F060C0FA019491ED
+:10F8E000613009F43BC0623009F441C0CA0101969D
+:10F8F0002F5F3F4FAC0120173107D0F4772359F326
+:10F90000F999FECF52BD41BDF89A90B56130F9F03A
+:10F91000623061F78091C80085FFFCCF9093CE00E4
+:10F92000CA0101962F5F3F4FAC012017310730F31A
+:10F9300090933D0280933C02613009F4CAC062306A
+:10F9400009F0B3CD8091C80085FFFCCF46CE8091F1
+:10F95000C00085FFFCCF9093C600C8CF8091C00047
+:10F9600085FDF9CF8091C00085FFF8CFF4CF80915D
+:10F97000C80085FDD3CF8091C80085FFF8CFCECFDA
+:10F980008091C00085FFFCCFE092C6008DCF8091B2
+:10F99000C80085FFFCCFE092CE0086CFCA01A0E070
+:10F9A000B0E080509040AF4FBF4FABBFFC0197918C
+:10F9B000613061F0623009F099CF8091C80085FD17
+:10F9C000ADCF8091C80085FFF8CFA8CF8091C0004F
+:10F9D00085FDC1CF8091C00085FFF8CFBCCF0E94CC
+:10F9E000D9F8803209F08ECD80913802813011F142
+:10F9F000823009F05ACD8091C80085FFFCCFE0929B
+:10FA0000CE008091C80085FFFCCFD092CE008091BF
+:10FA1000C80085FFFCCFC092CE008091C80085FF52
+:10FA2000FCCFB092CE008091C80085FFFCCFA092A1
+:10FA3000CE003BCD8091C00085FFFCCFE092C60098
+:10FA40008091C00085FFFCCFD092C6008091C0009D
+:10FA500085FFFCCFC092C6008091C00085FFFCCF1F
+:10FA6000B092C6008091C00085FFFCCFA092C60076
+:10FA70001CCD0E94D9F8813209F017CD0E94D9F827
+:10FA8000813209F012CD279A2F98109240032091CD
+:10FA90003802E1E491E00EC0223009F4A4C0909352
+:10FAA0004003E92FF0E0E050FE4FE0819F5FEE233E
+:10FAB00009F4A0C0213081F78091C00085FFFCCF00
+:10FAC000E093C600ECCF80914203816080934203B3
+:10FAD00047CE8091C00085FDB7CD8091C00085FFE5
+:10FAE000F8CFB2CD80914203816080934203CFCEA4
+:10FAF00080914203826080934203B9CE87E90E94DD
+:10FB00007DF9D3CC80913D028823880F880B892111
+:10FB1000809341038BBF80913C0290913D02880FFE
+:10FB2000991F90933D0280933C0280913E0380FF99
+:10FB300009C080913E0390913F03019690933F034B
+:10FB400080933E03F894F999FECF1127E0913C028F
+:10FB5000F0913D02CEE3D2E080913E0390913F03CD
+:10FB6000103091F40091570001700130D9F303E097
+:10FB700000935700E8950091570001700130D9F3C8
+:10FB800001E100935700E895099019900091570002
+:10FB900001700130D9F301E000935700E895139507
+:10FBA000103898F011270091570001700130D9F3F7
+:10FBB00005E000935700E89500915700017001306F
+:10FBC000D9F301E100935700E8953296029709F0C6
+:10FBD000C7CF103011F00296E5CF112410CE8EE180
+:10FBE0000E947DF962CC8091C80085FFFCCFE09334
+:10FBF000CE0055CF7AE0B72E6DE0A62E5AE3952EB3
+:10FC000040E2842E3DE3732E90E3692E81E3582E6B
+:10FC1000213009F442C0223009F45FC00E94D9F8B3
+:10FC2000982F20913802213089F1223009F44EC0FA
+:10FC3000943709F46BC0923709F405C1973709F47A
+:10FC40007BC0953799F0923609F4BDC09A3601F71A
+:10FC5000E0913A02F0913B02099520913802D8CF09
+:10FC60008091C00085FFFCCF9093C6000E94D9F818
+:10FC7000982F80913802813099F38230B9F78091C2
+:10FC8000C80085FFFCCF9093CE00F0CF8091C000DC
+:10FC900085FFFCCF9093C600CBCF8091C00085FF3D
+:10FCA000FCCFB092C6008091C00085FFFCCFA0922F
+:10FCB000C6008091C00085FFFCCF9092C600809165
+:10FCC000C00085FFFCCF8092C600A8CF8091C800FD
+:10FCD00085FFFCCF9093CE00ABCF8091C80085FF0D
+:10FCE000FCCFB092CE008091C80085FFFCCFA092DF
+:10FCF000CE008091C80085FFFCCF9092CE0080910D
+:10FD0000C80085FFFCCF8092CE0088CF1F9947C0E6
+:10FD10002F9A213051F0223009F07ACF8091C8001B
+:10FD200085FFFCCF6092CE0073CF8091C00085FF2D
+:10FD3000FCCF6092C6006CCF0E94D9F8982F8091BA
+:10FD400038028130F1F0823009F4ABC00E9455F9DD
+:10FD5000082F0E9455F9182F0E94D9F8982F8091EA
+:10FD600038028130A9F0823009F4A2C00E9455F90E
+:10FD7000D02ECC24F601E10FF11D808320913802B2
+:10FD800047CF8091C00085FFFCCF9093C600DECFA7
+:10FD90008091C00085FFFCCF9093C600E7CF2F98DD
+:10FDA000213051F0223009F033CF8091C80085FF17
+:10FDB000FCCF5092CE002CCF8091C00085FFFCCFAD
+:10FDC0005092C60025CF213041F1223081F080E8E9
+:10FDD00085BF109274001092750080E091E1FC01E3
+:10FDE000819180E091E13097D1F3CF01F8CF8091FC
+:10FDF000C80085FFFCCF82E68093CE008091C800CA
+:10FE000085FFFCCF85E78093CE008091C80085FFF9
+:10FE1000FCCF83E78093CE00DACF8091C00085FFCE
+:10FE2000FCCF82E68093C6008091C00085FFFCCFA6
+:10FE300085E78093C6008091C00085FFFCCF83E7F3
+:10FE40008093C600C4CF0E94D9F8982F80913802C1
+:10FE50008130C9F08230D1F10E9455F9182F0E94EB
+:10FE600055F9982F809138028130A1F0823039F114
+:10FE7000F12EEE24F701E90FF11D80810E9494F824
+:10FE800020913802C5CE8091C00085FFFCCF9093B1
+:10FE9000C600E2CF8091C00085FFFCCF7092C60003
+:10FEA000E7CF8091C80085FFFCCF9093CE004ECF66
+:10FEB0008091C80085FFFCCF9093CE0057CF8091F2
+:10FEC000C80085FFFCCF7092CE00D2CF8091C800D1
+:0EFED00085FFFCCF9093CE00BFCFF894FFCFFC
+:10FEDE0041546D656761424F4F54202F204172642B
+:10FEEE0075696E6F204D656761202D20284329208E
+:10FEFE0041726475696E6F204C4C43202D20303951
+:08FF0E00303933300A0D008088
+:040000031000F000F9
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega/ATmegaBOOT_168_atmega328.hex

@@ -0,0 +1,125 @@
+:107800000C94343C0C94513C0C94513C0C94513CE1
+:107810000C94513C0C94513C0C94513C0C94513CB4
+:107820000C94513C0C94513C0C94513C0C94513CA4
+:107830000C94513C0C94513C0C94513C0C94513C94
+:107840000C94513C0C94513C0C94513C0C94513C84
+:107850000C94513C0C94513C0C94513C0C94513C74
+:107860000C94513C0C94513C11241FBECFEFD8E036
+:10787000DEBFCDBF11E0A0E0B1E0ECE9FFE702C060
+:1078800005900D92A230B107D9F712E0A2E0B1E065
+:1078900001C01D92AD30B107E1F70E942D3D0C945F
+:1078A000CC3F0C94003C982F959595959595959582
+:1078B000905D8F708A307CF0282F295A8091C0000B
+:1078C00085FFFCCF9093C6008091C00085FFFCCF60
+:1078D0002093C6000895282F205DF0CF982F809127
+:1078E000C00085FFFCCF9093C6000895EF92FF92F1
+:1078F0000F931F93EE24FF2487018091C00087FD22
+:1079000017C00894E11CF11C011D111D81E4E8164B
+:1079100082E4F8068FE0080780E0180770F3E09132
+:107920000401F091050109958091C00087FFE9CF1E
+:107930008091C6001F910F91FF90EF9008950E94D3
+:10794000763C982F8091C00085FFFCCF9093C600B5
+:1079500091362CF490330CF09053892F089597555D
+:10796000892F08951F930E949F3C182F0E949F3CCF
+:107970001295107F810F1F9108951F93182F882350
+:1079800021F00E94763C1150E1F71F9108951F935A
+:10799000182F0E94763C803249F0809103018F5F5E
+:1079A000809303018530C1F01F9108958091C0003C
+:1079B00085FFFCCF84E18093C6008091C00085FFE5
+:1079C000FCCF1093C6008091C00085FFFCCF80E102
+:1079D0008093C6001F910895E0910401F091050184
+:1079E00009951F9108950E94763C803241F0809164
+:1079F00003018F5F80930301853081F008958091AA
+:107A0000C00085FFFCCF84E18093C6008091C00058
+:107A100085FFFCCF80E18093C6000895E0910401CA
+:107A2000F09105010995089540E951E08823A1F0FE
+:107A30002D9A28EE33E0FA013197F1F721503040CA
+:107A4000D1F72D9828EE33E0FA013197F1F7215064
+:107A50003040D1F7815061F708953F924F925F9285
+:107A60006F927F928F929F92AF92BF92CF92DF924E
+:107A7000EF92FF920F931F93CF93DF93000080E16B
+:107A80008093C4001092C50088E18093C10086E015
+:107A90008093C2005098589A259A81E00E94143D24
+:107AA00024E1F22E9EE1E92E85E9D82E0FE0C02ECA
+:107AB00010E1B12EAA24A394B1E49B2EA6E58A2E50
+:107AC000F2E57F2EE0E26E2E79E4572E63E5462E36
+:107AD00050E5352E0E94763C8033B1F18133B9F107
+:107AE000803409F46FC0813409F476C0823409F41B
+:107AF00085C0853409F488C0803531F1823521F1A3
+:107B0000813511F1853509F485C0863509F48DC0BC
+:107B1000843609F496C0843709F403C1853709F423
+:107B200072C1863709F466C0809103018F5F80932C
+:107B30000301853079F6E0910401F0910501099582
+:107B40000E94763C803351F60E94F33CC3CF0E94E2
+:107B5000763C803249F78091C00085FFFCCFF092DF
+:107B6000C6008091C00085FFFCCF9092C600809136
+:107B7000C00085FFFCCF8092C6008091C00085FFC9
+:107B8000FCCF7092C6008091C00085FFFCCF609250
+:107B9000C6008091C00085FFFCCF5092C600809146
+:107BA000C00085FFFCCF4092C6008091C00085FFD9
+:107BB000FCCF3092C6008091C00085FFFCCFB09210
+:107BC000C60088CF0E94763C863808F4BDCF0E945C
+:107BD000763C0E94F33C7ECF0E94763C803809F4CC
+:107BE0009CC0813809F40BC1823809F43CC1883942
+:107BF00009F48FC080E00E94C73C6CCF84E10E94F2
+:107C0000BD3C0E94F33C66CF85E00E94BD3C0E94D3
+:107C1000F33C60CF0E94763C809306010E94763C44
+:107C2000809307010E94F33C55CF0E94763C80333D
+:107C300009F41DC183E00E94BD3C80E00E94C73C66
+:107C400049CF0E94763C809309020E94763C809343
+:107C5000080280910C028E7F80930C020E94763C79
+:107C6000853409F415C18091080290910902892B8D
+:107C700089F000E010E00E94763CF801E85FFE4FDA
+:107C800080830F5F1F4F80910802909109020817AF
+:107C9000190788F30E94763C803209F045CF809125
+:107CA0000C0280FF01C16091060170910701660F0F
+:107CB000771F7093070160930601A0910802B091AD
+:107CC00009021097C9F0E8E0F1E09B01AD014E0F09
+:107CD0005F1FF999FECF32BD21BD819180BDFA9A17
+:107CE000F99A2F5F3F4FE417F50799F76A0F7B1F4B
+:107CF00070930701609306018091C00085FFFCCF5F
+:107D0000F092C6008091C00085FFFCCFB092C60003
+:107D1000E1CE83E00E94C73CDDCE82E00E94C73CFA
+:107D2000D9CE0E94763C809309020E94763C8093D3
+:107D300008028091060190910701880F991F909386
+:107D40000701809306010E94763C853409F4A6C0A1
+:107D500080910C028E7F80930C020E94763C8032D0
+:107D600009F0B8CE8091C00085FFFCCFF092C6002C
+:107D7000609108027091090261157105B9F140E046
+:107D800050E080910C02A82FA170B82FB27011C0E2
+:107D9000BB2309F45CC0E0910601F0910701319624
+:107DA000F0930701E09306014F5F5F4F46175707B7
+:107DB000E8F4AA2369F3F999FECF209106013091E6
+:107DC000070132BD21BDF89A90B58091C00085FFB2
+:107DD000FCCF9093C6002F5F3F4F30930701209355
+:107DE00006014F5F5F4F4617570718F38091C00099
+:107DF00085FDE5CE8091C00085FFF8CFE0CE81E023
+:107E00000E94C73C67CE0E94763C803209F08CCE3F
+:107E10008091C00085FFFCCFF092C6008091C00029
+:107E200085FFFCCFE092C6008091C00085FFFCCFAB
+:107E3000D092C6008091C00085FFFCCFC092C600E2
+:107E40008091C00085FFFCCFB092C60043CEE09188
+:107E50000601F091070194918091C00085FFFCCF4D
+:107E60009093C6009CCF80E10E94C73C33CE0E9415
+:107E7000763C0E94763C182F0E94763C112309F430
+:107E800083C0113009F484C08FE00E94C73C22CE29
+:107E900080910C02816080930C02E5CE80910C02EF
+:107EA000816080930C0259CF809107018823880F4D
+:107EB000880B8A2180930B02809106019091070123
+:107EC000880F991F90930701809306018091080203
+:107ED00080FF09C080910802909109020196909359
+:107EE000090280930802F894F999FECF1127E091D6
+:107EF0000601F0910701C8E0D1E08091080290915D
+:107F00000902103091F40091570001700130D9F34B
+:107F100003E000935700E89500915700017001308D
+:107F2000D9F301E100935700E89509901990009169
+:107F3000570001700130D9F301E000935700E89534
+:107F40001395103498F011270091570001700130FB
+:107F5000D9F305E000935700E895009157000170B0
+:107F60000130D9F301E100935700E895329602976A
+:107F700009F0C7CF103011F00296E5CF112480919F
+:107F8000C00085FFB9CEBCCE8EE10E94C73CA2CD19
+:0C7F900085E90E94C73C9ECDF894FFCF0D
+:027F9C00800063
+:040000030000780081
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega/ATmegaBOOT_168_atmega328_pro_8MHz.hex

@@ -0,0 +1,124 @@
+:107800000C94343C0C94513C0C94513C0C94513CE1
+:107810000C94513C0C94513C0C94513C0C94513CB4
+:107820000C94513C0C94513C0C94513C0C94513CA4
+:107830000C94513C0C94513C0C94513C0C94513C94
+:107840000C94513C0C94513C0C94513C0C94513C84
+:107850000C94513C0C94513C0C94513C0C94513C74
+:107860000C94513C0C94513C11241FBECFEFD8E036
+:10787000DEBFCDBF11E0A0E0B1E0EAE8FFE702C063
+:1078800005900D92A230B107D9F712E0A2E0B1E065
+:1078900001C01D92AD30B107E1F70E942D3D0C945F
+:1078A000C33F0C94003C982F95959595959595958B
+:1078B000905D8F708A307CF0282F295A8091C0000B
+:1078C00085FFFCCF9093C6008091C00085FFFCCF60
+:1078D0002093C6000895282F205DF0CF982F809127
+:1078E000C00085FFFCCF9093C6000895EF92FF92F1
+:1078F0000F931F93EE24FF2487018091C00087FD22
+:1079000017C00894E11CF11C011D111D81E2E8164D
+:1079100081EAF80687E0080780E0180770F3E09135
+:107920000401F091050109958091C00087FFE9CF1E
+:107930008091C6001F910F91FF90EF9008950E94D3
+:10794000763C982F8091C00085FFFCCF9093C600B5
+:1079500091362CF490330CF09053892F089597555D
+:10796000892F08951F930E949F3C182F0E949F3CCF
+:107970001295107F810F1F9108951F93182F882350
+:1079800021F00E94763C1150E1F71F9108951F935A
+:10799000182F0E94763C803249F0809103018F5F5E
+:1079A000809303018530C1F01F9108958091C0003C
+:1079B00085FFFCCF84E18093C6008091C00085FFE5
+:1079C000FCCF1093C6008091C00085FFFCCF80E102
+:1079D0008093C6001F910895E0910401F091050184
+:1079E00009951F9108950E94763C803241F0809164
+:1079F00003018F5F80930301853081F008958091AA
+:107A0000C00085FFFCCF84E18093C6008091C00058
+:107A100085FFFCCF80E18093C6000895E0910401CA
+:107A2000F09105010995089548EC50E08823A1F0F4
+:107A30002D9A28EE33E0FA013197F1F721503040CA
+:107A4000D1F72D9828EE33E0FA013197F1F7215064
+:107A50003040D1F7815061F708953F924F925F9285
+:107A60006F927F928F929F92AF92BF92CF92DF924E
+:107A7000EF92FF920F931F93CF93DF93000082E06A
+:107A80008093C00080E18093C4001092C50088E11B
+:107A90008093C10086E08093C2005098589A259A3E
+:107AA00081E00E94143D24E1F22E9EE1E92E85E959
+:107AB000D82E0FE0C02E10E1B12EAA24A394B1E479
+:107AC0009B2EA6E58A2EF2E57F2EE0E26E2E79E46B
+:107AD000572E63E5462E50E5352E0E94763C8033C6
+:107AE000B1F18133B9F1803409F46FC0813409F404
+:107AF00076C0823409F485C0853409F488C08035A5
+:107B000031F1823521F1813511F1853509F485C0D6
+:107B1000863509F48DC0843609F496C0843709F49B
+:107B200003C1853709F472C1863709F466C08091B4
+:107B300003018F5F80930301853079F6E0910401A2
+:107B4000F091050109950E94763C803351F60E9420
+:107B5000F33CC3CF0E94763C803249F78091C0004D
+:107B600085FFFCCFF092C6008091C00085FFFCCF5E
+:107B70009092C6008091C00085FFFCCF8092C60025
+:107B80008091C00085FFFCCF7092C6008091C0003C
+:107B900085FFFCCF6092C6008091C00085FFFCCFBE
+:107BA0005092C6008091C00085FFFCCF4092C60075
+:107BB0008091C00085FFFCCF3092C6008091C0004C
+:107BC00085FFFCCFB092C60088CF0E94763C8638F5
+:107BD00008F4BDCF0E94763C0E94F33C7ECF0E9409
+:107BE000763C803809F49CC0813809F40BC1823896
+:107BF00009F430C1883909F48FC080E00E94C73C85
+:107C00006CCF84E10E94BD3C0E94F33C66CF85E0CE
+:107C10000E94BD3C0E94F33C60CF0E94763C809362
+:107C200006010E94763C809307010E94F33C55CFE9
+:107C30000E94763C803309F411C183E00E94BD3C70
+:107C400080E00E94C73C49CF0E94763C80930902A5
+:107C50000E94763C8093080280910C028E7F809374
+:107C60000C020E94763C853409F409C18091080217
+:107C700090910902892B89F000E010E00E94763C87
+:107C8000F801E85FFE4F80830F5F1F4F809108026D
+:107C9000909109020817190788F30E94763C8032F8
+:107CA00009F045CF80910C0280FFF5C0609106017C
+:107CB00070910701660F771F7093070160930601AB
+:107CC000A0910802B09109021097C9F0E8E0F1E034
+:107CD0009B01AD014E0F5F1FF999FECF32BD21BD53
+:107CE000819180BDFA9AF99A2F5F3F4FE417F5070B
+:107CF00099F76A0F7B1F70930701609306018091CB
+:107D0000C00085FFFCCFF092C6008091C00085FFC7
+:107D1000FCCFB092C600E1CE83E00E94C73CDDCE2E
+:107D200082E00E94C73CD9CE0E94763C8093090233
+:107D30000E94763C80930802809106019091070191
+:107D4000880F991F90930701809306010E94763C4B
+:107D5000853409F49AC080910C028E7F80930C02C6
+:107D60000E94763C803209F0B8CE8091C00085FF39
+:107D7000FCCFF092C600A0910802B09109021097C2
+:107D8000C1F180910C02082F0170182F1695117007
+:107D9000E0910601F0910701AF014F5F5F4FBA011B
+:107DA00020E030E00023B1F4112339F49491809164
+:107DB000C00085FFFCCF9093C6002F5F3F4FCB01E3
+:107DC0000196FA012A173B0780F4BC014F5F5F4F11
+:107DD000002351F3F999FECFF2BDE1BDF89A90B5B9
+:107DE0008091C00085FFFCCFE6CF709307016093C0
+:107DF00006018091C00085FDE5CE8091C00085FF21
+:107E0000F8CFE0CE81E00E94C73C67CE0E94763C6E
+:107E1000803209F08CCE8091C00085FFFCCFF092BB
+:107E2000C6008091C00085FFFCCFE092C600809123
+:107E3000C00085FFFCCFD092C6008091C00085FFB6
+:107E4000FCCFC092C6008091C00085FFFCCFB092ED
+:107E5000C60043CE80E10E94C73C3FCE0E94763CE4
+:107E60000E94763C182F0E94763C112309F483C0AF
+:107E7000113009F484C08FE00E94C73C2ECE80915F
+:107E80000C02816080930C02F1CE80910C02816023
+:107E900080930C0265CF809107018823880F880B9F
+:107EA0008A2180930B028091060190910701880F2F
+:107EB000991F90930701809306018091080280FF2B
+:107EC00009C08091080290910902019690930902DD
+:107ED00080930802F894F999FECF1127E0910601EA
+:107EE000F0910701C8E0D1E0809108029091090269
+:107EF000103091F40091570001700130D9F303E084
+:107F000000935700E8950091570001700130D9F3B4
+:107F100001E100935700E8950990199000915700EE
+:107F200001700130D9F301E000935700E8951395F3
+:107F3000103498F011270091570001700130D9F3E7
+:107F400005E000935700E89500915700017001305B
+:107F5000D9F301E100935700E8953296029709F0B2
+:107F6000C7CF103011F00296E5CF11248091C000E8
+:107F700085FFC5CEC8CE8EE10E94C73CAECD85E957
+:0A7F80000E94C73CAACDF894FFCF81
+:027F8A00800075
+:040000030000780081
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega/ATmegaBOOT_168_diecimila.hex

@@ -0,0 +1,126 @@
+:103800000C94341C0C94511C0C94511C0C94511CA1
+:103810000C94511C0C94511C0C94511C0C94511C74
+:103820000C94511C0C94511C0C94511C0C94511C64
+:103830000C94511C0C94511C0C94511C0C94511C54
+:103840000C94511C0C94511C0C94511C0C94511C44
+:103850000C94511C0C94511C0C94511C0C94511C34
+:103860000C94511C0C94511C11241FBECFEFD4E0BA
+:10387000DEBFCDBF11E0A0E0B1E0E4EAFFE302C0AB
+:1038800005900D92A230B107D9F712E0A2E0B1E0A5
+:1038900001C01D92AD30B107E1F70E94361D0C94B6
+:1038A000D01F0C94001C982F9595959595959595FE
+:1038B000905D8F708A307CF0282F295A8091C0004B
+:1038C00085FFFCCF9093C6008091C00085FFFCCFA0
+:1038D0002093C6000895282F205DF0CF982F809167
+:1038E000C00085FFFCCF9093C6000895EF92FF9231
+:1038F0000F931F93EE24FF2487018091C00087FD62
+:1039000017C00894E11CF11C011D111D81E4E8168B
+:1039100082E4F8068FE0080780E0180770F3E09172
+:103920000401F091050109958091C00087FFE9CF5E
+:103930008091C6001F910F91FF90EF9008950E9413
+:10394000761C982F8091C00085FFFCCF9093C60015
+:1039500091362CF490330CF09053892F089597559D
+:10396000892F08951F930E949F1C182F0E949F1C4F
+:103970001295107F810F1F910895882351F0982F81
+:1039800091508091C00087FFFCCF8091C6009923A1
+:10399000B9F708951F93182F0E94761C803249F0C2
+:1039A000809103018F5F809303018530C1F01F91E7
+:1039B00008958091C00085FFFCCF84E18093C6000C
+:1039C0008091C00085FFFCCF1093C6008091C0009D
+:1039D00085FFFCCF80E18093C6001F910895E091A0
+:1039E0000401F091050109951F9108950E94761C2C
+:1039F000803241F0809103018F5F80930301853015
+:103A000081F008958091C00085FFFCCF84E1809310
+:103A1000C6008091C00085FFFCCF80E18093C60086
+:103A20000895E0910401F09105010995089510921F
+:103A30000A028823D1F090E040E951E02D9A28EE67
+:103A400033E0FA013197F1F721503040D1F72D984A
+:103A500028EE33E0FA013197F1F721503040D1F7E9
+:103A60009F5F981758F380930A0208953F924F92F0
+:103A70005F926F927F928F929F92AF92BF92CF92FE
+:103A8000DF92EF92FF920F931F93CF93DF9300008B
+:103A900083E38093C4001092C50088E18093C10045
+:103AA00086E08093C2005098589A259A81E00E943F
+:103AB000171D44E1F42E3EE1E32E24E9D22E96E0D8
+:103AC000C92E80E1B82EAA24A39401E4902E16E515
+:103AD000812EB2E57B2EA0E26A2EF9E45F2EE3E5AB
+:103AE0004E2E70E5372E0E94761C8033B1F1813363
+:103AF00009F441C0803409F479C0813409F48CC0E0
+:103B0000823471F1853409F47BC0803531F182351E
+:103B100021F1813511F1853509F48DC0863509F41F
+:103B20009DC0843609F4AEC0843709F41BC18537C3
+:103B300009F485C1863709F47AC0809103018F5F4B
+:103B400080930301853079F6E0910401F09105013D
+:103B500009950E94761C803351F60E94F61CC3CF53
+:103B600093E18091C00087FFFCCF8091C60099232C
+:103B7000A1F39150F6CF0E94761C8032F1F680912D
+:103B8000C00085FFFCCFF092C6008091C00085FF89
+:103B9000FCCF9092C6008091C00085FFFCCF809240
+:103BA000C6008091C00085FFFCCF7092C600809156
+:103BB000C00085FFFCCF6092C6008091C00085FFE9
+:103BC000FCCF5092C6008091C00085FFFCCF409290
+:103BD000C6008091C00085FFFCCF3092C600809166
+:103BE000C00085FFFCCFB092C6007DCF0E94761C3E
+:103BF000863808F4B2CF0E94761C0E94F61C73CF60
+:103C000094E08091C00087FFFCCF8091C60099238B
+:103C100009F4A3CF9150F5CF0E94761C8038D1F0E3
+:103C2000813861F1823809F499C0883979F080E0EF
+:103C30000E94CA1C58CF0E94761C809306010E94E5
+:103C4000761C809307010E94F61C4DCF83E00E94F2
+:103C5000CA1C49CF82E00E94CA1C45CF0E94761C34
+:103C6000803309F486C192E08091C00087FFFCCFC9
+:103C70008091C6009923D9F29150F6CF81E00E943D
+:103C8000CA1C31CF0E94761C809309020E94761CC8
+:103C90008093080280910C028E7F80930C020E9418
+:103CA000761C853429F480910C02816080930C028B
+:103CB0008091080290910902892B89F000E010E0C0
+:103CC0000E94761CF801E85FFE4F80830F5F1F4F54
+:103CD00080910802909109020817190788F30E9441
+:103CE000761C803209F029CF80910C0280FFD1C070
+:103CF0004091060150910701440F551F5093070151
+:103D000040930601A0910802B09109021097C9F0F2
+:103D1000E8E0F1E09A01BD016E0F7F1FF999FECF37
+:103D200032BD21BD819180BDFA9AF99A2F5F3F4F34
+:103D3000E617F70799F74A0F5B1F50930701409367
+:103D400006018091C00085FFFCCFF092C6008091F3
+:103D5000C00085FFFCCFB092C600C5CE80E10E94B6
+:103D6000CA1CC1CE0E94761C809309020E94761C58
+:103D7000809308028091060190910701880F991F96
+:103D800090930701809306010E94761C853409F404
+:103D90007AC080910C028E7F80930C020E94761C68
+:103DA000803209F0A0CE8091C00085FFFCCFF09258
+:103DB000C600A0910802B09109021097B9F1809154
+:103DC0000C02182F1170082F0270E0910601F0917B
+:103DD00007019F012F5F3F4FB90140E050E01123E1
+:103DE000B1F4002339F494918091C00085FFFCCF99
+:103DF0009093C6004F5F5F4FCB010196F9014A17C0
+:103E00005B0780F4BC012F5F3F4F112351F3F999F9
+:103E1000FECFF2BDE1BDF89A90B58091C00085FF5C
+:103E2000FCCFE6CF70930701609306018091C0003C
+:103E300085FDD9CE8091C00085FFF8CFD4CE0E94F9
+:103E4000761C803209F079CE8091C00085FFFCCFCE
+:103E5000F092C6008091C00085FFFCCFE092C600C2
+:103E60008091C00085FFFCCFD092C6008091C00039
+:103E700085FFFCCFC092C6008091C00085FFFCCFBB
+:103E8000B092C60030CE80910C02816080930C020B
+:103E900085CF809107018823880F880B8A21809322
+:103EA0000B028091060190910701880F991F909352
+:103EB0000701809306018091080280FF09C080916C
+:103EC00008029091090201969093090280930802DA
+:103ED000F894F999FECF1127E0910601F0910701BE
+:103EE000C8E0D1E08091080290910902103091F46D
+:103EF0000091570001700130D9F303E0009357009F
+:103F0000E8950091570001700130D9F301E1009369
+:103F10005700E89509901990009157000170013001
+:103F2000D9F301E000935700E8951395103498F009
+:103F300011270091570001700130D9F305E000937B
+:103F40005700E8950091570001700130D9F301E165
+:103F500000935700E8953296029709F0C7CF1030CA
+:103F600011F00296E5CF11248091C00085FFE9CEC3
+:103F7000ECCE0E94761C0E94761C182F0E94761CA4
+:103F8000112351F0113021F086E00E94CA1CABCD04
+:103F900084E90E94CA1CA7CD8EE10E94CA1CA3CD51
+:043FA000F894FFCFC3
+:023FA40080009B
+:0400000300003800C1
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega/ATmegaBOOT_168_ng.hex

@@ -0,0 +1,110 @@
+:103800000C94341C0C94511C0C94511C0C94511CA1
+:103810000C94511C0C94511C0C94511C0C94511C74
+:103820000C94511C0C94511C0C94511C0C94511C64
+:103830000C94511C0C94511C0C94511C0C94511C54
+:103840000C94511C0C94511C0C94511C0C94511C44
+:103850000C94511C0C94511C0C94511C0C94511C34
+:103860000C94511C0C94511C11241FBECFEFD4E0BA
+:10387000DEBFCDBF11E0A0E0B1E0E4EAFEE302C0AC
+:1038800005900D92A230B107D9F712E0A2E0B1E0A5
+:1038900001C01D92AD30B107E1F70E94ED1C0C9400
+:1038A000511F0C94001C482F10920A0280E08417CC
+:1038B000E0F4582F2D9A28EE33E080E991E001974B
+:1038C000F1F721503040C9F72D9828EE33E080E918
+:1038D00091E00197F1F721503040C9F7852F8F5FB4
+:1038E000582F841738F380930A020895EF92FF92BD
+:1038F0000F931F93EE24FF2487018091C00087FD62
+:1039000017C00894E11CF11C011D111D81E0E8168F
+:1039100082E1F8068AE7080780E0180770F3E09173
+:103920000201F091030109958091C00087FFE9CF62
+:103930008091C600992787FD90951F910F91FF9068
+:10394000EF900895982F8091C00085FFFCCF909351
+:10395000C60008950E94761C803271F080910401A7
+:103960008F5F80930401853009F00895E091020192
+:10397000F09103010995089584E10E94A21C80E161
+:103980000E94A21C0895CF93C82F0E94761C8032FB
+:1039900041F0809104018F5F80930401853081F4B0
+:1039A0000AC084E10E94A21C8C2F0E94A21C80E10C
+:1039B0000E94A21C05C0E0910201F091030109954B
+:1039C000CF910895CF93C82FC150CF3F21F00E94CF
+:1039D000761CC150E0F7CF910895CFEFD4E0DEBF61
+:1039E000CDBF000083E38093C4001092C50088E13E
+:1039F0008093C10086E08093C2005098589A259A1F
+:103A000083E00E94531C0E94761C8033B1F1813305
+:103A1000B9F1803409F455C0813409F45BC08234B3
+:103A200009F46DC0853409F470C0803531F18235F8
+:103A300021F1813511F1853509F46BC0863509F422
+:103A400073C0843609F47AC0843709F4CEC0853750
+:103A500009F429C1863709F44AC0809104018F5FB7
+:103A600080930401853079F6E0910201F091030121
+:103A700009950E94761C803351F60E94AA1CC3CF80
+:103A80000E94761CC82F803241F784E10E94A21C5C
+:103A900081E40E94A21C86E50E94A21C82E50E948D
+:103AA000A21C8C2F0E94A21C89E40E94A21C83E508
+:103AB0000E94A21C80E50E94A21C80E10E94A21C20
+:103AC000A2CF0E94761C8638C0F20E94761C0E940B
+:103AD000AA1C99CF0E94761C803809F486C18138CF
+:103AE00009F487C1823809F488C1883921F080E05F
+:103AF0000E94C31C88CF83E00E94C31C84CF84E152
+:103B00000E94E21C0E94AA1C7ECF85E00E94E21C5B
+:103B1000F9CF0E94761C809306010E94761C809348
+:103B200007010E94AA1C6FCF0E94761C803309F403
+:103B3000CAC083E00E94E21C80E0DACF0E94761CBB
+:103B4000809309020E94761C8093080280910C02E7
+:103B50008E7F80930C020E94761C853409F4C4C0C9
+:103B600000E010E0809108029091090218161906F1
+:103B700070F4C8E0D1E00E94761C89930F5F1F4F5C
+:103B8000809108029091090208171907A0F30E947A
+:103B9000761C803209F061CF80910C0280FFAEC0AC
+:103BA000E0910601F0910701EE0FFF1F00E010E029
+:103BB00020910802309109021216130680F4A8E041
+:103BC000B1E0F999FECFF2BDE1BD8D9180BDFA9AC9
+:103BD000F99A31960F5F1F4F0217130790F3F09376
+:103BE0000701E093060184E166CF0E94761C809372
+:103BF00009020E94761C8093080280910601909130
+:103C00000701880F991F90930701809306010E9476
+:103C1000761C853409F46EC080910C028E7F8093EF
+:103C20000C020E94761C803209F0EDCE84E10E94E5
+:103C3000A21C00E010E02091080230910902121647
+:103C4000130608F03ACFE0910601F0910701809148
+:103C50000C0280FF1FC0F999FECFF2BDE1BDF89ABA
+:103C600080B50E94A21CE0910601F09107013196F7
+:103C7000F0930701E09306012091080230910902B8
+:103C80000F5F1F4F0217130708F017CF80910C0228
+:103C900080FDE1CF869580FFB4C03196F093070197
+:103CA000E0930601EDCF0E94761C803209F0D5CE5C
+:103CB00084E10E94A21C8EE10E94A21C84E90E9461
+:103CC000A21C86E0F8CE0E94761C0E94761CC82FAB
+:103CD0000E94761CCC2309F47CC0C13009F47DC05D
+:103CE00086E00E94C31C8FCE80910C02816080937D
+:103CF0000C0236CF80910C02816091CF8091070138
+:103D000087FD6FC010920B02809106019091070110
+:103D1000880F991F909307018093060180910802F4
+:103D200080FF09C08091080290910902019690934A
+:103D3000090280930802F894F999FECF1127E091C7
+:103D40000601F0910701C8E0D1E08091080290914E
+:103D50000902103091F40091570001700130D9F33D
+:103D600003E000935700E89500915700017001307F
+:103D7000D9F301E100935700E8950990199000915B
+:103D8000570001700130D9F301E000935700E89526
+:103D90001395103498F011270091570001700130ED
+:103DA000D9F305E000935700E895009157000170A2
+:103DB0000130D9F301E100935700E895329602975C
+:103DC00009F0C7CF103011F00296E5CF112484E13D
+:103DD00072CE8EE10E94C31C16CE84E90E94C31CE1
+:103DE00012CE81E080930B028FCF82E00E94C31C31
+:103DF0000ACE81E00E94C31C06CE80E10E94C31C53
+:103E000002CE84910E94A21C2091080230910902E6
+:103E1000E0910601F091070140CFCF930E94761CFC
+:103E2000C82F0E94A21CC13614F0C75503C0C0336E
+:103E30000CF0C0538C2F992787FD9095CF91089552
+:103E40000F931F930E940D1F082F112707FD109538
+:103E500002951295107F1027007F10270E940D1FDA
+:103E6000800F992787FD90951F910F910895CF930B
+:103E7000C82F85958595859585958A3034F0895A22
+:103E8000CF70CA3034F0C95A05C0805DCF70CA30D7
+:103E9000D4F7C05D0E94A21C8C2F0E94A21CCF915F
+:043EA0000895FFCFB3
+:023EA40080009C
+:0400000300003800C1
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega/ATmegaBOOT_168_pro_8MHz.hex

@@ -0,0 +1,126 @@
+:103800000C94341C0C94511C0C94511C0C94511CA1
+:103810000C94511C0C94511C0C94511C0C94511C74
+:103820000C94511C0C94511C0C94511C0C94511C64
+:103830000C94511C0C94511C0C94511C0C94511C54
+:103840000C94511C0C94511C0C94511C0C94511C44
+:103850000C94511C0C94511C0C94511C0C94511C34
+:103860000C94511C0C94511C11241FBECFEFD4E0BA
+:10387000DEBFCDBF11E0A0E0B1E0EEEAFFE302C0A1
+:1038800005900D92A230B107D9F712E0A2E0B1E0A5
+:1038900001C01D92AD30B107E1F70E94331D0C94B9
+:1038A000D51F0C94001C982F9595959595959595F9
+:1038B000905D8F708A307CF0282F295A8091C0004B
+:1038C00085FFFCCF9093C6008091C00085FFFCCFA0
+:1038D0002093C6000895282F205DF0CF982F809167
+:1038E000C00085FFFCCF9093C6000895EF92FF9231
+:1038F0000F931F93EE24FF2487018091C00087FD62
+:1039000017C00894E11CF11C011D111D81E2E8168D
+:1039100081EAF80687E0080780E0180770F3E09175
+:103920000401F091050109958091C00087FFE9CF5E
+:103930008091C6001F910F91FF90EF9008950E9413
+:10394000761C982F8091C00085FFFCCF9093C60015
+:1039500091362CF490330CF09053892F089597559D
+:10396000892F08951F930E949F1C182F0E949F1C4F
+:103970001295107F810F1F9108951F93182F882390
+:1039800021F00E94761C1150E1F71F9108951F93BA
+:10399000182F0E94761C803249F0809103018F5FBE
+:1039A000809303018530C1F01F9108958091C0007C
+:1039B00085FFFCCF84E18093C6008091C00085FF25
+:1039C000FCCF1093C6008091C00085FFFCCF80E142
+:1039D0008093C6001F910895E0910401F0910501C4
+:1039E00009951F9108950E94761C803241F08091C4
+:1039F00003018F5F80930301853081F008958091EA
+:103A0000C00085FFFCCF84E18093C6008091C00098
+:103A100085FFFCCF80E18093C6000895E09104010A
+:103A2000F09105010995089510920A028823D1F0BA
+:103A300090E048EC50E02D9A28EE33E0FA013197FF
+:103A4000F1F721503040D1F72D9828EE33E0FA01FC
+:103A50003197F1F721503040D1F79F5F981758F315
+:103A600080930A0208953F924F925F926F927F92E5
+:103A70008F929F92AF92BF92CF92DF92EF92FF927E
+:103A80000F931F93CF93DF9394B714BE8091600080
+:103A90008861809360001092600091FF0CC289E100
+:103AA0008093C4001092C50088E18093C10086E035
+:103AB0008093C2005098589A259A81E00E94141D64
+:103AC00044E1F42E3EE1E32E24E9D22E96E0C92E05
+:103AD00080E1B82EAA24A39401E4902E16E5812E4D
+:103AE000B2E57B2EA0E26A2EF9E45F2EE3E54E2ECE
+:103AF00070E5372E0E94761C8033B9F18133C1F115
+:103B0000803409F470C0813409F477C0823409F438
+:103B100086C0853409F489C0803539F1823529F1B0
+:103B2000813509F4AFC1853509F485C0863509F4BE
+:103B30008DC0843609F435C1843709F4C1C0853796
+:103B400009F490C0863709F466C0809103018F5F45
+:103B500080930301853071F6E0910401F091050135
+:103B600009950E94761C803349F60E94F31CC2CF4F
+:103B70000E94761C803249F78091C00085FFFCCFFF
+:103B8000F092C6008091C00085FFFCCF9092C600E5
+:103B90008091C00085FFFCCF8092C6008091C0005C
+:103BA00085FFFCCF7092C6008091C00085FFFCCFDE
+:103BB0006092C6008091C00085FFFCCF5092C60085
+:103BC0008091C00085FFFCCF4092C6008091C0006C
+:103BD00085FFFCCF3092C6008091C00085FFFCCFEE
+:103BE000B092C60087CF0E94761C863808F4BDCFFD
+:103BF0000E94761C0E94F31C7DCF0E94761C8038A8
+:103C000009F45AC0813809F453C0823809F440C11C
+:103C1000883909F449C080E00E94C71C6BCF84E159
+:103C20000E94BD1C0E94F31C65CF85E00E94BD1C54
+:103C30000E94F31C5FCF0E94761C809306010E94B5
+:103C4000761C809307010E94F31C54CF0E94761CBF
+:103C5000803309F421C183E00E94BD1C80E00E94F2
+:103C6000C71C48CF0E94761C803209F06ECF80912D
+:103C7000C00085FFFCCFF092C6008091C00085FF98
+:103C8000FCCFE092C6008091C00085FFFCCFD092AF
+:103C9000C6008091C00085FFFCCFC092C600809115
+:103CA000C00085FFFCCF9CCF83E00E94C71C22CFC1
+:103CB00081E00E94C71C1ECF82E00E94C71C1ACF61
+:103CC0000E94761C809309020E94761C8093080251
+:103CD0008091060190910701880F991F9093070129
+:103CE000809306010E94761C853409F4C5C080913A
+:103CF0000C028E7F80930C020E94761C803209F0A9
+:103D0000F9CE8091C00085FFFCCFF092C600609193
+:103D10000802709109026115710591F140E050E0CF
+:103D200080910C02A82FA170B82FB27010C0BB23D5
+:103D300061F1E0910601F09107013196F0930701DE
+:103D4000E09306014F5F5F4F46175707C8F4AA2359
+:103D500071F3F999FECF209106013091070132BD30
+:103D600021BDF89A90B58091C00085FFFCCF90935B
+:103D7000C6002F5F3F4F3093070120930601E2CF2B
+:103D80008091C00085FFFCCF2BCFE0910601F09120
+:103D9000070194918091C00085FFFCCF9093C600ED
+:103DA000CCCF0E94761C809309020E94761C8093DF
+:103DB000080280910C028E7F80930C020E94761C78
+:103DC000853429F480910C02816080930C028091EB
+:103DD000080290910902892B89F000E010E00E940E
+:103DE000761CF801E85FFE4F80830F5F1F4F8091C4
+:103DF0000802909109020817190788F30E94761C9F
+:103E0000803209F0A2CE80910C0280FF62C0409106
+:103E1000060150910701440F551F5093070140932D
+:103E20000601609108027091090261157105C9F0DF
+:103E3000E8E0F1E09A01DB01AE0FBF1FF999FECF78
+:103E400032BD21BD819180BDFA9AF99A2F5F3F4F13
+:103E5000EA17FB0799F7460F571F50930701409346
+:103E600006018091C00085FFFCCFF092C6008091D2
+:103E7000C00085FFFCCFB4CE80910C02816080939E
+:103E80000C023ACF0E94F31C88E080936000FFCFC1
+:103E900080E10E94C71C2ECE0E94761C0E94761CD8
+:103EA000182F0E94761C112381F0113051F086E00A
+:103EB0000E94C71C1FCEE0910401F09105010995F5
+:103EC000EECD84E90E94C71C15CE8EE10E94C71C6E
+:103ED00011CE809107018823880F880B8A21809357
+:103EE0000B028091060190910701880F991F909312
+:103EF0000701809306018091080280FF09C080912C
+:103F00000802909109020196909309028093080299
+:103F1000F894F999FECF1127E0910601F09107017D
+:103F2000C8E0D1E08091080290910902103091F42C
+:103F30000091570001700130D9F303E0009357005E
+:103F4000E8950091570001700130D9F301E1009329
+:103F50005700E895099019900091570001700130C1
+:103F6000D9F301E000935700E8951395103498F0C9
+:103F700011270091570001700130D9F305E000933B
+:103F80005700E8950091570001700130D9F301E125
+:103F900000935700E8953296029709F0C7CF10308A
+:0E3FA00011F00296E5CF11245CCFF894FFCF0C
+:023FAE00800091
+:0400000300003800C1
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega/Makefile

@@ -0,0 +1,224 @@
+# Makefile for ATmegaBOOT
+# E.Lins, 18.7.2005
+# $Id$
+#
+# Instructions
+#
+# To make bootloader .hex file:
+# make diecimila
+# make lilypad
+# make ng
+# etc...
+#
+# To burn bootloader .hex file:
+# make diecimila_isp
+# make lilypad_isp
+# make ng_isp
+# etc...
+
+# program name should not be changed...
+PROGRAM    = ATmegaBOOT_168
+
+# enter the parameters for the avrdude isp tool
+ISPTOOL	   = stk500v2
+ISPPORT	   = usb
+ISPSPEED   = -b 115200
+
+MCU_TARGET = atmega168
+LDSECTION  = --section-start=.text=0x3800
+
+# the efuse should really be 0xf8; since, however, only the lower
+# three bits of that byte are used on the atmega168, avrdude gets
+# confused if you specify 1's for the higher bits, see:
+# http://tinker.it/now/2007/02/24/the-tale-of-avrdude-atmega168-and-extended-bits-fuses/
+#
+# similarly, the lock bits should be 0xff instead of 0x3f (to
+# unlock the bootloader section) and 0xcf instead of 0x0f (to
+# lock it), but since the high two bits of the lock byte are
+# unused, avrdude would get confused.
+
+ISPFUSES    = avrdude -c $(ISPTOOL) -p $(MCU_TARGET) -P $(ISPPORT) $(ISPSPEED) \
+-e -u -U lock:w:0x3f:m -U efuse:w:0x$(EFUSE):m -U hfuse:w:0x$(HFUSE):m -U lfuse:w:0x$(LFUSE):m
+ISPFLASH    = avrdude -c $(ISPTOOL) -p $(MCU_TARGET) -P $(ISPPORT) $(ISPSPEED) \
+-U flash:w:$(PROGRAM)_$(TARGET).hex -U lock:w:0x0f:m
+
+STK500 = "C:\Program Files\Atmel\AVR Tools\STK500\Stk500.exe"
+STK500-1 = $(STK500) -e -d$(MCU_TARGET) -pf -vf -if$(PROGRAM)_$(TARGET).hex \
+-lFF -LFF -f$(HFUSE)$(LFUSE) -EF8 -ms -q -cUSB -I200kHz -s -wt
+STK500-2 = $(STK500) -d$(MCU_TARGET) -ms -q -lCF -LCF -cUSB -I200kHz -s -wt
+
+
+OBJ        = $(PROGRAM).o
+OPTIMIZE   = -O2
+
+DEFS       = 
+LIBS       =
+
+CC         = avr-gcc
+
+# Override is only needed by avr-lib build system.
+
+override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) -DF_CPU=$(AVR_FREQ) $(DEFS)
+override LDFLAGS       = -Wl,$(LDSECTION)
+#override LDFLAGS       = -Wl,-Map,$(PROGRAM).map,$(LDSECTION)
+
+OBJCOPY        = avr-objcopy
+OBJDUMP        = avr-objdump
+
+all:
+
+lilypad: TARGET = lilypad
+lilypad: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>1' '-DNUM_LED_FLASHES=3'
+lilypad: AVR_FREQ = 8000000L
+lilypad: $(PROGRAM)_lilypad.hex
+
+lilypad_isp: lilypad
+lilypad_isp: TARGET = lilypad
+lilypad_isp: HFUSE = DD
+lilypad_isp: LFUSE = E2
+lilypad_isp: EFUSE = 00
+lilypad_isp: isp
+
+lilypad_resonator: TARGET = lilypad_resonator
+lilypad_resonator: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=3'
+lilypad_resonator: AVR_FREQ = 8000000L
+lilypad_resonator: $(PROGRAM)_lilypad_resonator.hex
+
+lilypad_resonator_isp: lilypad_resonator
+lilypad_resonator_isp: TARGET = lilypad_resonator
+lilypad_resonator_isp: HFUSE = DD
+lilypad_resonator_isp: LFUSE = C6
+lilypad_resonator_isp: EFUSE = 00
+lilypad_resonator_isp: isp
+
+pro8: TARGET = pro_8MHz
+pro8: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=1' '-DWATCHDOG_MODS'
+pro8: AVR_FREQ = 8000000L
+pro8: $(PROGRAM)_pro_8MHz.hex
+
+pro8_isp: pro8
+pro8_isp: TARGET = pro_8MHz
+pro8_isp: HFUSE = DD
+pro8_isp: LFUSE = C6
+pro8_isp: EFUSE = 00
+pro8_isp: isp
+
+pro16: TARGET = pro_16MHz
+pro16: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=1' '-DWATCHDOG_MODS'
+pro16: AVR_FREQ = 16000000L
+pro16: $(PROGRAM)_pro_16MHz.hex
+
+pro16_isp: pro16
+pro16_isp: TARGET = pro_16MHz
+pro16_isp: HFUSE = DD
+pro16_isp: LFUSE = C6
+pro16_isp: EFUSE = 00
+pro16_isp: isp
+
+pro20: TARGET = pro_20mhz
+pro20: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=1' '-DWATCHDOG_MODS'
+pro20: AVR_FREQ = 20000000L
+pro20: $(PROGRAM)_pro_20mhz.hex
+
+pro20_isp: pro20
+pro20_isp: TARGET = pro_20mhz
+pro20_isp: HFUSE = DD
+pro20_isp: LFUSE = C6
+pro20_isp: EFUSE = 00
+pro20_isp: isp
+
+diecimila: TARGET = diecimila
+diecimila: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=1'
+diecimila: AVR_FREQ = 16000000L 
+diecimila: $(PROGRAM)_diecimila.hex
+
+diecimila_isp: diecimila
+diecimila_isp: TARGET = diecimila
+diecimila_isp: HFUSE = DD
+diecimila_isp: LFUSE = FF
+diecimila_isp: EFUSE = 00
+diecimila_isp: isp
+
+ng: TARGET = ng
+ng: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>1' '-DNUM_LED_FLASHES=3'
+ng: AVR_FREQ = 16000000L
+ng: $(PROGRAM)_ng.hex
+
+ng_isp: ng
+ng_isp: TARGET = ng
+ng_isp: HFUSE = DD
+ng_isp: LFUSE = FF
+ng_isp: EFUSE = 00
+ng_isp: isp
+
+atmega328: TARGET = atmega328
+atmega328: MCU_TARGET = atmega328p
+atmega328: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=1' -DBAUD_RATE=57600
+atmega328: AVR_FREQ = 16000000L 
+atmega328: LDSECTION  = --section-start=.text=0x7800
+atmega328: $(PROGRAM)_atmega328.hex
+
+atmega328_isp: atmega328
+atmega328_isp: TARGET = atmega328
+atmega328_isp: MCU_TARGET = atmega328p
+atmega328_isp: HFUSE = DA
+atmega328_isp: LFUSE = FF
+atmega328_isp: EFUSE = 05
+atmega328_isp: isp
+
+atmega328_pro8: TARGET = atmega328_pro_8MHz
+atmega328_pro8: MCU_TARGET = atmega328p
+atmega328_pro8: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=1' -DBAUD_RATE=57600 -DDOUBLE_SPEED
+atmega328_pro8: AVR_FREQ = 8000000L 
+atmega328_pro8: LDSECTION  = --section-start=.text=0x7800
+atmega328_pro8: $(PROGRAM)_atmega328_pro_8MHz.hex
+
+atmega328_pro8_isp: atmega328_pro8
+atmega328_pro8_isp: TARGET = atmega328_pro_8MHz
+atmega328_pro8_isp: MCU_TARGET = atmega328p
+atmega328_pro8_isp: HFUSE = DA
+atmega328_pro8_isp: LFUSE = FF
+atmega328_pro8_isp: EFUSE = 05
+atmega328_pro8_isp: isp
+
+mega: TARGET = atmega1280
+mega: MCU_TARGET = atmega1280
+mega: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>4' '-DNUM_LED_FLASHES=0' -DBAUD_RATE=57600
+mega: AVR_FREQ = 16000000L 
+mega: LDSECTION  = --section-start=.text=0x1F000
+mega: $(PROGRAM)_atmega1280.hex
+
+mega_isp: mega
+mega_isp: TARGET = atmega1280
+mega_isp: MCU_TARGET = atmega1280
+mega_isp: HFUSE = DA
+mega_isp: LFUSE = FF
+mega_isp: EFUSE = F5
+mega_isp: isp
+
+isp: $(TARGET)
+	$(ISPFUSES)
+	$(ISPFLASH)
+
+isp-stk500: $(PROGRAM)_$(TARGET).hex
+	$(STK500-1)
+	$(STK500-2)
+
+%.elf: $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+clean:
+	rm -rf *.o *.elf *.lst *.map *.sym *.lss *.eep *.srec *.bin *.hex
+
+%.lst: %.elf
+	$(OBJDUMP) -h -S $< > $@
+
+%.hex: %.elf
+	$(OBJCOPY) -j .text -j .data -O ihex $< $@
+
+%.srec: %.elf
+	$(OBJCOPY) -j .text -j .data -O srec $< $@
+
+%.bin: %.elf
+	$(OBJCOPY) -j .text -j .data -O binary $< $@
+	

arduino-0018-linux/hardware/arduino/bootloaders/atmega8/ATmegaBOOT.c

@@ -0,0 +1,507 @@
+/**********************************************************/
+/* Serial Bootloader for Atmel mega8 AVR Controller       */
+/*                                                        */
+/* ATmegaBOOT.c                                           */
+/*                                                        */
+/* Copyright (c) 2003, Jason P. Kyle                      */
+/*                                                        */
+/* Hacked by DojoCorp - ZGZ - MMX - IVR                   */
+/* Hacked by David A. Mellis                              */
+/*                                                        */
+/* This program is free software; you can redistribute it */
+/* and/or modify it under the terms of the GNU General    */
+/* Public License as published by the Free Software       */
+/* Foundation; either version 2 of the License, or        */
+/* (at your option) any later version.                    */
+/*                                                        */
+/* This program is distributed in the hope that it will   */
+/* be useful, but WITHOUT ANY WARRANTY; without even the  */
+/* implied warranty of MERCHANTABILITY or FITNESS FOR A   */
+/* PARTICULAR PURPOSE.  See the GNU General Public        */
+/* License for more details.                              */
+/*                                                        */
+/* You should have received a copy of the GNU General     */
+/* Public License along with this program; if not, write  */
+/* to the Free Software Foundation, Inc.,                 */
+/* 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */
+/*                                                        */
+/* Licence can be viewed at                               */
+/* http://www.fsf.org/licenses/gpl.txt                    */
+/*                                                        */
+/* Target = Atmel AVR m8                                  */
+/**********************************************************/
+
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <avr/eeprom.h>
+#include <avr/interrupt.h>
+#include <avr/delay.h>
+
+//#define F_CPU			16000000
+
+/* We, Malmoitians, like slow interaction
+ * therefore the slow baud rate ;-)
+ */
+//#define BAUD_RATE		9600
+
+/* 6.000.000 is more or less 8 seconds at the
+ * speed configured here
+ */
+//#define MAX_TIME_COUNT	6000000
+#define MAX_TIME_COUNT (F_CPU>>1)
+///#define MAX_TIME_COUNT_MORATORY	1600000
+
+/* SW_MAJOR and MINOR needs to be updated from time to time to avoid warning message from AVR Studio */
+#define HW_VER	 0x02
+#define SW_MAJOR 0x01
+#define SW_MINOR 0x12
+
+// AVR-GCC compiler compatibility
+// avr-gcc compiler v3.1.x and older doesn't support outb() and inb()
+//      if necessary, convert outb and inb to outp and inp
+#ifndef outb
+	#define outb(sfr,val)  (_SFR_BYTE(sfr) = (val))
+#endif
+#ifndef inb
+	#define inb(sfr) _SFR_BYTE(sfr)
+#endif
+
+/* defines for future compatibility */
+#ifndef cbi
+	#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
+#endif
+#ifndef sbi
+	#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
+#endif
+
+/* Adjust to suit whatever pin your hardware uses to enter the bootloader */
+#define eeprom_rb(addr)   eeprom_read_byte ((uint8_t *)(addr))
+#define eeprom_rw(addr)   eeprom_read_word ((uint16_t *)(addr))
+#define eeprom_wb(addr, val)   eeprom_write_byte ((uint8_t *)(addr), (uint8_t)(val))
+
+/* Onboard LED is connected to pin PB5 */
+#define LED_DDR  DDRB
+#define LED_PORT PORTB
+#define LED_PIN  PINB
+#define LED      PINB5
+
+
+#define SIG1	0x1E	// Yep, Atmel is the only manufacturer of AVR micros.  Single source :(
+#define SIG2	0x93
+#define SIG3	0x07
+#define PAGE_SIZE	0x20U	//32 words
+
+
+void putch(char);
+char getch(void);
+void getNch(uint8_t);
+void byte_response(uint8_t);
+void nothing_response(void);
+
+union address_union {
+  uint16_t word;
+  uint8_t  byte[2];
+} address;
+
+union length_union {
+  uint16_t word;
+  uint8_t  byte[2];
+} length;
+
+struct flags_struct {
+  unsigned eeprom : 1;
+  unsigned rampz  : 1;
+} flags;
+
+uint8_t buff[256];
+//uint8_t address_high;
+
+uint8_t pagesz=0x80;
+
+uint8_t i;
+//uint8_t bootuart0=0,bootuart1=0;
+
+
+void (*app_start)(void) = 0x0000;
+
+int main(void)
+{
+  uint8_t ch,ch2;
+  uint16_t w;
+
+  //cbi(BL_DDR,BL);
+  //sbi(BL_PORT,BL);
+
+  asm volatile("nop\n\t");
+
+  /* check if flash is programmed already, if not start bootloader anyway */
+  //if(pgm_read_byte_near(0x0000) != 0xFF) {
+
+    /* check if bootloader pin is set low */
+    //if(bit_is_set(BL_PIN,BL)) app_start();
+  //}
+
+  /* initialize UART(s) depending on CPU defined */
+  /* m8 */
+  UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8; 	// set baud rate
+  UBRRL = (((F_CPU/BAUD_RATE)/16)-1);
+  UCSRB = (1<<RXEN)|(1<<TXEN);  // enable Rx & Tx
+  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // config USART; 8N1
+
+  //UBRRL = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
+  //UBRRH = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
+  //UCSRA = 0x00;
+  //UCSRC = 0x86;
+  //UCSRB = _BV(TXEN)|_BV(RXEN);
+
+
+  /* this was giving uisp problems, so I removed it; without it, the boot
+     works on with uisp and avrdude on the mac (at least). */
+  //putch('\0');
+
+  //uint32_t l;
+  //uint32_t time_count;
+  //time_count=0;
+
+  /* set LED pin as output */
+  sbi(LED_DDR,LED);
+	for (i = 0; i < 16; i++) {
+		outb(LED_PORT, inb(LED_PORT) ^ _BV(LED));
+		_delay_loop_2(0);
+	}
+	
+	//for (l=0; l<40000000; l++)
+		//outb(LED_PORT, inb(LED_PORT) ^= _BV(LED));
+
+  /* flash onboard LED three times to signal entering of bootloader */
+  //for(i=0; i<3; ++i) {
+    //for(l=0; l<40000000; ++l);
+    //sbi(LED_PORT,LED);
+    //for(l=0; l<40000000; ++l);
+    //cbi(LED_PORT,LED);
+  //}
+
+ /* see comment at previous call to putch() */
+ //putch('\0'); // this line is needed for the synchronization of the programmer
+
+  /* forever */
+  for (;;) {
+    //if((inb(UCSRA) & _BV(RXC))){
+    /* get character from UART */
+		ch = getch();
+		
+		/* A bunch of if...else if... gives smaller code than switch...case ! */
+	
+		/* Hello is anyone home ? */ 
+		if(ch=='0') {
+		  nothing_response();
+		}
+	
+		/* Request programmer ID */
+		/* Not using PROGMEM string due to boot block in m128 being beyond 64kB boundry  */
+		/* Would need to selectively manipulate RAMPZ, and it's only 9 characters anyway so who cares.  */
+		else if(ch=='1') {
+			if (getch() == ' ') {
+				putch(0x14);
+				putch('A');
+				putch('V');
+				putch('R');
+				putch(' ');
+				putch('I');
+				putch('S');
+				putch('P');
+				putch(0x10);
+		  }
+		}
+	
+		/* AVR ISP/STK500 board commands  DON'T CARE so default nothing_response */
+		else if(ch=='@') {
+		  ch2 = getch();
+		  if (ch2>0x85) getch();
+		  nothing_response();
+		}
+	
+		/* AVR ISP/STK500 board requests */
+		else if(ch=='A') {
+		  ch2 = getch();
+		  if(ch2==0x80) byte_response(HW_VER);		// Hardware version
+		  else if(ch2==0x81) byte_response(SW_MAJOR);	// Software major version
+		  else if(ch2==0x82) byte_response(SW_MINOR);	// Software minor version
+		  //else if(ch2==0x98) byte_response(0x03);		// Unknown but seems to be required by avr studio 3.56
+		  else byte_response(0x00);				// Covers various unnecessary responses we don't care about
+		}
+	
+		/* Device Parameters  DON'T CARE, DEVICE IS FIXED  */
+		else if(ch=='B') {
+		  getNch(20);
+		  nothing_response();
+		}
+	
+		/* Parallel programming stuff  DON'T CARE  */
+		else if(ch=='E') {
+		  getNch(5);
+		  nothing_response();
+		}
+	
+		/* Enter programming mode  */
+		else if(ch=='P') {
+		  nothing_response();
+		  // FIXME: modified only here by DojoCorp, Mumbai, India, 20050626
+		  //time_count=0; // exted the delay once entered prog.mode
+		}
+	
+		/* Leave programming mode  */
+		else if(ch=='Q') {
+		  nothing_response();
+		  //time_count=MAX_TIME_COUNT_MORATORY; 	// once the programming is done, 
+												// we should start the application
+												// but uisp has problems with this,
+												// therefore we just change the times
+												// and give the programmer 1 sec to react
+		}
+	
+		/* Erase device, don't care as we will erase one page at a time anyway.  */
+		else if(ch=='R') {
+		  nothing_response();
+		}
+	
+		/* Set address, little endian. EEPROM in bytes, FLASH in words  */
+		/* Perhaps extra address bytes may be added in future to support > 128kB FLASH.  */
+		/* This might explain why little endian was used here, big endian used everywhere else.  */
+		else if(ch=='U') {
+		  address.byte[0] = getch();
+		  address.byte[1] = getch();
+		  nothing_response();
+		}
+	
+		/* Universal SPI programming command, disabled.  Would be used for fuses and lock bits.  */
+		else if(ch=='V') {
+		  getNch(4);
+		  byte_response(0x00);
+		}
+	
+		/* Write memory, length is big endian and is in bytes  */
+		else if(ch=='d') {
+		  length.byte[1] = getch();
+		  length.byte[0] = getch();
+		  flags.eeprom = 0;
+		  if (getch() == 'E') flags.eeprom = 1;
+		  for (w=0;w<length.word;w++) {
+		    buff[w] = getch();	                        // Store data in buffer, can't keep up with serial data stream whilst programming pages
+		  }
+		  if (getch() == ' ') {
+				if (flags.eeprom) {		                //Write to EEPROM one byte at a time
+					for(w=0;w<length.word;w++) {
+						eeprom_wb(address.word,buff[w]);
+						address.word++;
+					}			
+				} else {					        //Write to FLASH one page at a time
+					//if (address.byte[1]>127) address_high = 0x01;	//Only possible with m128, m256 will need 3rd address byte. FIXME
+					//else address_high = 0x00;
+			
+					//address.word = address.word << 1;	        //address * 2 -> byte location
+					//if ((length.byte[0] & 0x01)) length.word++;	//Even up an odd number of bytes
+					cli();					//Disable interrupts, just to be sure
+					while(bit_is_set(EECR,EEWE));			//Wait for previous EEPROM writes to complete
+					asm volatile(
+							 "clr	r17		\n\t"	//page_word_count
+							 "lds	r30,address	\n\t"	//Address of FLASH location (in words)
+							 "lds	r31,address+1	\n\t"
+							 "lsl r30				\n\t"  //address * 2 -> byte location
+							 "rol r31				\n\t" 
+							 "ldi	r28,lo8(buff)	\n\t"	//Start of buffer array in RAM
+							 "ldi	r29,hi8(buff)	\n\t"
+							 "lds	r24,length	\n\t"	//Length of data to be written (in bytes)
+							 "lds	r25,length+1	\n\t"
+							 "sbrs r24,0		\n\t"  //Even up an odd number of bytes
+							 "rjmp length_loop		\n\t"
+							 "adiw r24,1		\n\t"
+							 "length_loop:		\n\t"	//Main loop, repeat for number of words in block							 							 
+							 "cpi	r17,0x00	\n\t"	//If page_word_count=0 then erase page
+							 "brne	no_page_erase	\n\t"						 
+							 "rcall  wait_spm		\n\t"
+//							 "wait_spm1:		\n\t"
+//							 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+//							 "andi	r16,1           \n\t"
+//							 "cpi	r16,1           \n\t"
+//							 "breq	wait_spm1       \n\t"
+							 "ldi	r16,0x03	\n\t"	//Erase page pointed to by Z
+							 "sts	%0,r16		\n\t"
+							 "spm			\n\t"							 
+							 "rcall  wait_spm		\n\t"
+//							 "wait_spm2:		\n\t"
+//							 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+//							 "andi	r16,1           \n\t"
+//							 "cpi	r16,1           \n\t"
+//							 "breq	wait_spm2       \n\t"									 
+							 "ldi	r16,0x11	\n\t"	//Re-enable RWW section
+							 "sts	%0,r16		\n\t"						 			 
+							 "spm			\n\t"
+							 "no_page_erase:		\n\t"							 
+							 "ld	r0,Y+		\n\t"	//Write 2 bytes into page buffer
+							 "ld	r1,Y+		\n\t"							 
+										 
+							 "rcall  wait_spm		\n\t"
+//							 "wait_spm3:		\n\t"
+//							 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+//							 "andi	r16,1           \n\t"
+//							 "cpi	r16,1           \n\t"
+//							 "breq	wait_spm3       \n\t"
+							 "ldi	r16,0x01	\n\t"	//Load r0,r1 into FLASH page buffer
+							 "sts	%0,r16		\n\t"
+							 "spm			\n\t"
+										 
+							 "inc	r17		\n\t"	//page_word_count++
+							 "cpi r17,%1	        \n\t"
+							 "brlo	same_page	\n\t"	//Still same page in FLASH
+							 "write_page:		\n\t"
+							 "clr	r17		\n\t"	//New page, write current one first
+							 "rcall  wait_spm		\n\t"
+//							 "wait_spm4:		\n\t"
+//							 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+//							 "andi	r16,1           \n\t"
+//							 "cpi	r16,1           \n\t"
+//							 "breq	wait_spm4       \n\t"
+							 "ldi	r16,0x05	\n\t"	//Write page pointed to by Z
+							 "sts	%0,r16		\n\t"
+							 "spm			\n\t"
+							 "rcall  wait_spm		\n\t"
+//							 "wait_spm5:		\n\t"
+//							 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+//							 "andi	r16,1           \n\t"
+//							 "cpi	r16,1           \n\t"
+//							 "breq	wait_spm5       \n\t"									 
+							 "ldi	r16,0x11	\n\t"	//Re-enable RWW section
+							 "sts	%0,r16		\n\t"						 			 
+							 "spm			\n\t"					 		 
+							 "same_page:		\n\t"							 
+							 "adiw	r30,2		\n\t"	//Next word in FLASH
+							 "sbiw	r24,2		\n\t"	//length-2
+							 "breq	final_write	\n\t"	//Finished
+							 "rjmp	length_loop	\n\t"
+							 
+							 "wait_spm:  \n\t"
+							 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+							 "andi	r16,1           \n\t"
+							 "cpi	r16,1           \n\t"
+							 "breq	wait_spm       \n\t"
+							 "ret			\n\t"
+							 
+							 "final_write:		\n\t"
+							 "cpi	r17,0		\n\t"
+							 "breq	block_done	\n\t"
+							 "adiw	r24,2		\n\t"	//length+2, fool above check on length after short page write
+							 "rjmp	write_page	\n\t"
+							 "block_done:		\n\t"
+							 "clr	__zero_reg__	\n\t"	//restore zero register
+							 : "=m" (SPMCR) : "M" (PAGE_SIZE) : "r0","r16","r17","r24","r25","r28","r29","r30","r31");
+			
+					/* Should really add a wait for RWW section to be enabled, don't actually need it since we never */
+					/* exit the bootloader without a power cycle anyhow */
+				}
+				putch(0x14);
+				putch(0x10);
+			}		
+		}
+	
+		/* Read memory block mode, length is big endian.  */
+		else if(ch=='t') {
+		  length.byte[1] = getch();
+		  length.byte[0] = getch();
+		  if (getch() == 'E') flags.eeprom = 1;
+		  else {
+				flags.eeprom = 0;
+				address.word = address.word << 1;	        // address * 2 -> byte location
+		  }
+		  if (getch() == ' ') {		                // Command terminator
+				putch(0x14);
+				for (w=0;w < length.word;w++) {		        // Can handle odd and even lengths okay
+					if (flags.eeprom) {	                        // Byte access EEPROM read
+						putch(eeprom_rb(address.word));
+						address.word++;
+					} else {	
+						if (!flags.rampz) putch(pgm_read_byte_near(address.word));
+						address.word++;
+					}
+				}
+				putch(0x10);
+		  }
+		}
+	
+		/* Get device signature bytes  */
+		else if(ch=='u') {
+		  if (getch() == ' ') {
+				putch(0x14);
+				putch(SIG1);
+				putch(SIG2);
+				putch(SIG3);
+				putch(0x10);
+		  }
+		}
+	
+		/* Read oscillator calibration byte */
+		else if(ch=='v') {
+		  byte_response(0x00);
+		}
+//    } else {
+//			time_count++;
+//			if (time_count>=MAX_TIME_COUNT) {
+//				app_start();
+//			}
+//		}
+	} /* end of forever loop */
+}
+
+void putch(char ch)
+{
+  /* m8 */
+  while (!(inb(UCSRA) & _BV(UDRE)));
+  outb(UDR,ch);
+}
+
+char getch(void)
+{
+  /* m8 */
+	uint32_t count = 0;
+  while(!(inb(UCSRA) & _BV(RXC))) {
+		/* HACKME:: here is a good place to count times*/
+		count++;
+		if (count > MAX_TIME_COUNT)
+			app_start();
+  }
+  return (inb(UDR));
+}
+
+void getNch(uint8_t count)
+{
+  uint8_t i;
+  for(i=0;i<count;i++) {
+    /* m8 */
+    //while(!(inb(UCSRA) & _BV(RXC)));
+    //inb(UDR);
+		getch(); // need to handle time out
+  }
+}
+
+void byte_response(uint8_t val)
+{
+  if (getch() == ' ') {
+    putch(0x14);
+    putch(val);
+    putch(0x10);
+  }
+}
+
+void nothing_response(void)
+{
+  if (getch() == ' ') {
+    putch(0x14);
+    putch(0x10);
+  }
+}
+
+/* end of file ATmegaBOOT.c */
+
+
+

arduino-0018-linux/hardware/arduino/bootloaders/atmega8/ATmegaBOOT.hex

@@ -0,0 +1,66 @@
+:101C000012C02BC02AC029C028C027C026C025C0AA
+:101C100024C023C022C021C020C01FC01EC01DC0C0
+:101C20001CC01BC01AC011241FBECFE5D4E0DEBF0C
+:101C3000CDBF10E0A0E6B0E0E8EEFFE102C0059005
+:101C40000D92A236B107D9F711E0A2E6B0E001C0CB
+:101C50001D92AA36B107E1F74FC0D2CFEF92FF92A3
+:101C60000F931F93EE24FF24870113C00894E11CF7
+:101C7000F11C011D111D81E0E81682E1F8068AE7DA
+:101C8000080780E0180728F0E0916200F0916300F7
+:101C900009955F9BEBCF8CB1992787FD90951F919C
+:101CA0000F91FF90EF9008955D9BFECF8CB9089542
+:101CB000D5DF803221F484E1F7DF80E1F5DF08959C
+:101CC0001F93182FCBDF803231F484E1EDDF812FB9
+:101CD000EBDF80E1E9DF1F9108951F93CF93DF933E
+:101CE000182FC0E0D0E002C0B9DF2196C117E0F3A1
+:101CF000DF91CF911F910895CFE5D4E0DEBFCDBF36
+:101D0000000010BC83E389B988E18AB986E880BD08
+:101D1000BD9A1092680130E2E0E0F0E02FE088B375
+:101D2000832788BBCF010197F1F7215027FFF7CF19
+:101D300020E12093680192DF803381F1813399F4AF
+:101D40008DDF8032C1F784E1AFDF81E4ADDF86E56E
+:101D5000ABDF82E5A9DF80E2A7DF89E4A5DF83E5C9
+:101D6000A3DF80E5C7C0803429F478DF8638B0F07F
+:101D700075DF14C0813471F471DF803811F482E0B2
+:101D80001DC1813811F481E019C1823809F015C1F3
+:101D900082E114C1823421F484E19FDF89DFCBCF5B
+:101DA000853411F485E0F9CF8035C1F38135B1F385
+:101DB0008235A1F3853539F451DF809364004EDF1D
+:101DC00080936500EBCF863519F484E086DFF5C09B
+:101DD000843609F093C042DF809367013FDF809330
+:101DE0006601809169018E7F8093690137DF8534B8
+:101DF00029F480916901816080936901C0E0D0E09D
+:101E000006E610E005C02ADFF80181938F012196D4
+:101E10008091660190916701C817D907A0F31EDF72
+:101E2000803209F088CF8091690180FF1FC020E0D7
+:101E300030E0E6E6F0E012C0A0916400B0916500E9
+:101E40008191082EC5D08091640090916500019623
+:101E500090936500809364002F5F3F4F80916601EF
+:101E6000909167012817390738F343C0F894E19936
+:101E7000FECF1127E0916400F0916500EE0FFF1F87
+:101E8000C6E6D0E0809166019091670180FF01C0B5
+:101E90000196103051F422D003E000935700E895EA
+:101EA0001DD001E100935700E8950990199016D0D4
+:101EB00001E000935700E8951395103258F0112770
+:101EC0000DD005E000935700E89508D001E100939C
+:101ED0005700E8953296029739F0DBCF0091570012
+:101EE00001700130D9F30895103011F00296E7CF58
+:101EF000112484E1D9DE80E1D7DE1DCF843709F0DB
+:101F00004BC0ACDE80936701A9DE80936601A6DE3C
+:101F100090916901853421F49160909369010DC01D
+:101F20009E7F909369018091640090916500880F75
+:101F3000991F909365008093640090DE803209F0D1
+:101F4000FACE84E1B1DEC0E0D0E01EC0809169012C
+:101F500080FF07C0A0916400B091650031D0802D52
+:101F600008C081FD07C0E0916400F0916500E49134
+:101F70008E2F9ADE80916400909165000196909377
+:101F800065008093640021968091660190916701BD
+:101F9000C817D907D8F2AFCF853761F45FDE80323A
+:101FA00009F0C9CE84E180DE8EE17EDE83E97CDE4D
+:101FB00087E0A0CF863709F0BECE80E081DEBBCEC1
+:101FC000E199FECFBFBBAEBBE09A11960DB208956A
+:101FD000E199FECFBFBBAEBB0DBA11960FB6F89418
+:081FE000E29AE19A0FBE089598
+:021FE800800077
+:0400000300001C00DD
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/atmega8/Makefile

@@ -0,0 +1,88 @@
+# Makefile for ATmegaBOOT
+# E.Lins, 2004-10-14
+
+# program name should not be changed...
+PROGRAM    = ATmegaBOOT
+
+PRODUCT=atmega8
+
+# enter the parameters for the UISP isp tool
+ISPPARAMS  = -dprog=stk500 -dserial=$(SERIAL) -dspeed=115200
+
+
+#DIRAVR = /usr/local/avr
+DIRAVRBIN = $(DIRAVR)/bin
+DIRAVRUTILS = $(DIRAVR)/utils/bin
+DIRINC = $(DIRAVR)/include
+DIRLIB = $(DIRAVR)/avr/lib
+
+
+MCU_TARGET = atmega8
+LDSECTION  = --section-start=.text=0x1c00
+FUSE_L     = 0xdf
+FUSE_H     = 0xca
+ISPFUSES   = $(DIRAVRBIN)/uisp -dpart=ATmega8 $(ISPPARAMS) --wr_fuse_l=$(FUSE_L) --wr_fuse_h=$(FUSE_H)
+ISPFLASH   = $(DIRAVRBIN)/uisp -dpart=ATmega8 $(ISPPARAMS) --erase --upload if=$(PROGRAM).hex -v
+
+
+OBJ        = $(PROGRAM).o
+OPTIMIZE   = -Os
+
+DEFS       = -DF_CPU=16000000 -DBAUD_RATE=19200
+LIBS       =
+
+CC         = $(DIRAVRBIN)/avr-gcc
+
+
+# Override is only needed by avr-lib build system.
+
+override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) -D$(PRODUCT) $(DEFS) -I$(DIRINC)
+override LDFLAGS       = -Wl,-Map,$(PROGRAM).map,$(LDSECTION)
+
+OBJCOPY        = $(DIRAVRBIN)/avr-objcopy
+OBJDUMP        = $(DIRAVRBIN)/avr-objdump
+SIZE           = $(DIRAVRBIN)/avr-size
+
+all: $(PROGRAM).elf lst text asm size
+
+isp: $(PROGRAM).hex
+	$(ISPFUSES)
+	$(ISPFLASH)
+
+$(PROGRAM).elf: $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+clean:
+	rm -rf *.s
+	rm -rf *.o *.elf
+	rm -rf *.lst *.map
+
+asm: $(PROGRAM).s
+
+%.s: %.c
+	$(CC) -S $(CFLAGS) -g1 $^
+
+lst:  $(PROGRAM).lst
+
+%.lst: %.elf
+	$(OBJDUMP) -h -S $< > $@
+
+size: $(PROGRAM).hex
+	$(SIZE) $^
+
+# Rules for building the .text rom images
+
+text: hex bin srec
+
+hex:  $(PROGRAM).hex
+bin:  $(PROGRAM).bin
+srec: $(PROGRAM).srec
+
+%.hex: %.elf
+	$(OBJCOPY) -j .text -j .data -O ihex $< $@
+
+%.srec: %.elf
+	$(OBJCOPY) -j .text -j .data -O srec $< $@
+
+%.bin: %.elf
+	$(OBJCOPY) -j .text -j .data -O binary $< $@

arduino-0018-linux/hardware/arduino/bootloaders/bt/ATmegaBOOT_168.hex

@@ -0,0 +1,121 @@
+:103800000C94341C0C944F1C0C944F1C0C944F1CA7
+:103810000C944F1C0C944F1C0C944F1C0C944F1C7C
+:103820000C944F1C0C944F1C0C944F1C0C944F1C6C
+:103830000C944F1C0C944F1C0C944F1C0C944F1C5C
+:103840000C944F1C0C944F1C0C944F1C0C944F1C4C
+:103850000C944F1C0C944F1C0C944F1C0C944F1C3C
+:103860000C944F1C0C944F1C11241FBECFEFD4E0BE
+:10387000DEBFCDBF11E0A0E0B1E0E0E6FFE302C0B3
+:1038800005900D92A230B107D9F712E0A2E0B1E0A5
+:1038900001C01D92AC30B107E1F70C94D61C0C941A
+:1038A000001C882309F483E01092090290E0981725
+:1038B000F0F4692F2D9A2FEF37E448EE51E02253B0
+:1038C00030404040504057FFFACF2D982FEF33ED56
+:1038D00040E350E0225330404040504057FFFACF81
+:1038E000962F9F5F692F981728F3909309020895E8
+:1038F000982F8091C00085FFFCCF9093C60008955B
+:10390000EF92FF920F931F93EE24FF248701809183
+:10391000C00087FD17C00894E11CF11C011D111D9A
+:1039200081E0E81682E1F8068AE7080780E01807D8
+:1039300070F3E0910201F091030109958091C000BC
+:1039400087FFE9CF8091C600992787FD90951F9149
+:103950000F91FF90EF9008950E94801C803209F033
+:10396000089584E10E94781C80E10E94781C0895EB
+:10397000CF93C82F0E94801C803249F484E10E94BA
+:10398000781C8C2F0E94781C80E10E94781CCF91BB
+:103990000895282F90E007C08091C0008823E4F7A5
+:1039A0008091C6009F5F9217B8F30895CFEFD4E0DF
+:1039B000DEBFCDBF000056985E9A1092C50088E029
+:1039C0008093C40088E18093C10086E08093C200A8
+:1039D000259A579A5F9A109209022FE080E090E0B2
+:1039E0000197F1F7215027FFF9CF20E12093090239
+:1039F0005F9883E00E94511C83E50E94781C85E457
+:103A00000E94781C84E50E94781C80E20E94781C49
+:103A100082E40E94781C84E50E94781C80E20E9467
+:103A2000781C80E50E94781C81E40E94781C87E461
+:103A30000E94781C85E40E94781C8DE40E94781C0A
+:103A40008FE40E94781C84E40E94781C85E40E9424
+:103A5000781C80E20E94781C83E30E94781C80E23C
+:103A60000E94781C82E30E94781C80E30E94781CEC
+:103A700080E30E94781C80E30E94781C80E20E9410
+:103A8000781C81E30E94781C8DE00E94781C83E5FD
+:103A90000E94781C85E40E94781C84E50E94781CB2
+:103AA00080E20E94781C82E40E94781C84E50E94D7
+:103AB000781C80E20E94781C82E50E94781C8FE4CA
+:103AC0000E94781C8CE40E94781C85E40E94781C7B
+:103AD00080E20E94781C80E30E94781C80E20E94B1
+:103AE000781C86E60E94781C80E20E94781C87E39E
+:103AF0000E94781C84E60E94781C80E30E94781C57
+:103B000080E30E94781C8DE00E94781C0E94801C3B
+:103B1000803361F1813369F1803409F449C0813423
+:103B200009F44FC0823409F45DC0853409F460C0E3
+:103B30008035E1F08135D1F08235C1F0853509F469
+:103B40005BC0863509F463C0843609F465C08437E8
+:103B500009F4B9C0853709F414C18637B9F680E095
+:103B60000E94B81C0E94801C8033A1F60E94AC1CED
+:103B7000CDCF0E94801CC82F803241F684E10E9484
+:103B8000781C81E40E94781C86E50E94781C82E5FE
+:103B90000E94781C8C2F0E94781C89E40E94781C5B
+:103BA00083E50E94781C80E50E94781C80E1ACCF00
+:103BB0000E94801C8638D0F20E94801C0E94AC1C9F
+:103BC000A5CF0E94801C803809F4EDC0813809F42B
+:103BD000EEC0823809F4EFC0883909F683E00E940C
+:103BE000B81CC0CF84E10E94C91C0E94AC1C8ECFBF
+:103BF00085E00E94C91CF9CF0E94801C80930501BA
+:103C00000E94801C809306010E94AC1C7FCF84E040
+:103C10000E94C91C80E0A4CF0E94801C80930802EF
+:103C20000E94801C8093070280910B028E7F8093FC
+:103C30000B020E94801C853409F4C1C000E010E032
+:103C400080910702909108021816190670F4C7E0D7
+:103C5000D1E00E94801C89930F5F1F4F8091070263
+:103C60009091080208171907A0F30E94801C803267
+:103C700009F04CCF80910B0280FFADC000E010E056
+:103C8000209107023091080212161306C0F4E09149
+:103C90000501F0910601A7E0B1E0F999FECFF2BD70
+:103CA000E1BD8D9180BDFA9AF99A31960F5F1F4F51
+:103CB0000217130790F3F0930601E093050184E1E6
+:103CC0000E94781C73CF0E94801C809308020E947F
+:103CD000801C809307020E94801C853409F475C003
+:103CE00080910B028E7F80930B0280910501909151
+:103CF0000601880F991F90930601809305010E9489
+:103D0000801C803209F002CF84E10E94781C00E020
+:103D100010E020910702309108021216130608F0F5
+:103D200045CFE0910501F091060180910B0280FFE3
+:103D30001FC0F999FECFF2BDE1BDF89A80B50E948F
+:103D4000781CE0910501F09106013196F09306018F
+:103D5000E093050120910702309108020F5F1F4F89
+:103D60000217130708F022CF80910B0280FDE1CFEC
+:103D7000869580FF9BC03196F0930601E093050184
+:103D8000EDCF0E94801C803209F0C0CE84E10E94F9
+:103D9000781C8EE10E94781C84E90E94781C86E0E1
+:103DA0000E94781C03CF82E00E94B81CDBCE81E029
+:103DB0000E94B81CD7CE8FE00E94B81CD3CE809151
+:103DC0000B02816080930B0239CF80910B028160DE
+:103DD00080930B0294CF8091060187FD73C01092EF
+:103DE0000A028091050190910601880F991F909316
+:103DF0000601809305018091070280FF09C0809130
+:103E0000070290910802019690930802809307029E
+:103E1000F894F999FECF1127E0910501F091060180
+:103E2000C7E0D1E08091070290910802103091F430
+:103E30000091570001700130D9F303E0009357005F
+:103E4000E8950091570001700130D9F301E100932A
+:103E50005700E895099019900091570001700130C2
+:103E6000D9F301E000935700E8951395103498F0CA
+:103E700011270091570001700130D9F305E000933C
+:103E80005700E8950091570001700130D9F301E126
+:103E900000935700E8953296029709F0C7CF10308B
+:103EA00011F00296E5CF112484E10ACF84910E949B
+:103EB000781C2091070230910802E0910501F091F1
+:103EC000060159CF81E080930A028BCF1F93CF93D5
+:103ED0000E94801CC82F0E94781C0E94801C182FF2
+:103EE0000E94781CC1362CF0C75511363CF017558E
+:103EF00008C0C033D4F3C0531136CCF710330CF0E4
+:103F00001053C295C07FC10F8C2F992787FD9095C4
+:103F1000CF911F910895CF93282F992787FD9095D2
+:103F2000807F9070959587959595879595958795C0
+:103F3000959587958A303CF0895AC22FCF70CA3048
+:103F40003CF0C95A06C0805DC22FCF70CA30CCF792
+:103F5000C05D0E94781C8C2F0E94781CCF91089520
+:023F60008000DF
+:0400000300003800C1
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/lilypad/LilyPadBOOT_168.hex

@@ -0,0 +1,117 @@
+:103800000C94341C0C944F1C0C944F1C0C944F1CA7
+:103810000C944F1C0C944F1C0C944F1C0C944F1C7C
+:103820000C944F1C0C944F1C0C944F1C0C944F1C6C
+:103830000C944F1C0C944F1C0C944F1C0C944F1C5C
+:103840000C944F1C0C944F1C0C944F1C0C944F1C4C
+:103850000C944F1C0C944F1C0C944F1C0C944F1C3C
+:103860000C944F1C0C944F1C11241FBECFEFD4E0BE
+:10387000DEBFCDBF11E0A0E0B1E0E8E1FFE302C0B0
+:1038800005900D92A230B107D9F712E0A2E0B1E0A5
+:1038900001C01D92AD30B107E1F70C94311D0C94BD
+:1038A000001CCF93DF93CDB7DEB724970FB6F89403
+:1038B000DEBF0FBECDBF382F882309F433E010924E
+:1038C0000A02332309F44BC020E02D9A19821A8290
+:1038D0001B821C8289819A81AB81BC8180549F416B
+:1038E000A040B040A0F489819A81AB81BC8101964F
+:1038F000A11DB11D89839A83AB83BC8389819A8181
+:10390000AB81BC8180549F41A040B04060F32D98B2
+:1039100019821A821B821C8289819A81AB81BC81A7
+:1039200080549F41A040B040A0F489819A81AB812E
+:10393000BC810196A11DB11D89839A83AB83BC8391
+:1039400089819A81AB81BC8180549F41A040B04065
+:1039500060F32F5F231708F4B8CF20930A02249650
+:103960000FB6F894DEBF0FBECDBFDF91CF910895A3
+:10397000EF92FF920F931F93EE24FF248701809113
+:10398000C00087FD17C00894E11CF11C011D111D2A
+:1039900081E0E81689E0F8068DE3080780E0180763
+:1039A00070F3E0910201F091030109958091C0004C
+:1039B00087FFE9CF8091C600992787FD90951F91D9
+:1039C0000F91FF90EF900895982F8091C00085FF90
+:1039D000FCCF9093C60008950E94B81C803271F00D
+:1039E000809104018F5F80930401853009F0089570
+:1039F000E0910201F09103010995089584E10E948C
+:103A0000E41C80E10E94E41C08951F93182F0E947B
+:103A1000B81C803269F0809104018F5F80930401AB
+:103A2000853079F4E0910201F0910301099509C014
+:103A300084E10E94E41C812F0E94E41C80E10E942A
+:103A4000E41C1F910895282F882351F090E0809165
+:103A5000C00087FFFCCF8091C6009F5F2917B9F790
+:103A60000895CFEFD4E0DEBFCDBF000089E18093A1
+:103A7000C4001092C50088E18093C10086E0809365
+:103A8000C2005098589A259A83E00E94511C0E94C7
+:103A9000B81C8033B1F18133B9F1803409F454C0DA
+:103AA000813409F45AC0823409F469C0853409F4B8
+:103AB0006CC0803531F1813521F1823511F18535C8
+:103AC00009F4B2C0863509F4BAC0843609F463C07B
+:103AD000843709F4BBC0853709F40EC1863709F471
+:103AE0004AC0809104018F5F80930401853079F68C
+:103AF000E0910201F091030109950E94B81C803306
+:103B000051F60E94EC1CC3CF0E94B81C803249F7CA
+:103B100084E10E94E41C81E40E94E41C86E50E948A
+:103B2000E41C82E50E94E41C80E20E94E41C89E41B
+:103B30000E94E41C83E50E94E41C80E50E94E41CD2
+:103B400080E10E94E41CA3CF0E94B81C8638C8F212
+:103B50000E94B81C0E94EC1C9ACF0E94B81C8038AE
+:103B600009F4F7C0813809F4F8C0823809F4F9C0C3
+:103B7000883909F4BDC080E00E94051D88CF84E12A
+:103B80000E94231D0E94EC1C82CF85E00E94231D11
+:103B90000E94EC1C7CCF0E94B81C809309020E94FA
+:103BA000B81C8093080280910C028E7F80930C02D7
+:103BB0000E94B81C853409F4C6C080910802909117
+:103BC0000902892B09F0ADC00E94B81C803209F0AF
+:103BD00088CF80910C0280FFC8C08091080290912C
+:103BE00009020097D1F02091060130910701E8E029
+:103BF000F1E0AC014E0F5F1FF999FECF32BD21BD40
+:103C0000819180BDFA9AF99A2F5F3F4F4E175F0757
+:103C100099F7309307012093060184E10E94E41C88
+:103C200080E10E94E41C33CF0E94B81C80930601FF
+:103C30000E94B81C809307010E94EC1C28CF84E0EE
+:103C40000E94231D80E00E94051D21CF0E94B81C08
+:103C5000809309020E94B81C809308020E94B81C3D
+:103C6000853409F4F4C080910C028E7F80930C029D
+:103C70008091060190910701880F991F9093070189
+:103C8000809306010E94B81C803209F000CF84E1C5
+:103C90000E94E41C2091080230910902211531058F
+:103CA00019F1C0E0D0E0E0910601F09107018091A8
+:103CB0000C0280FFC4C0F999FECFF2BDE1BDF89AB5
+:103CC00080B50E94E41CE0910601F0910701319655
+:103CD000F0930701E0930601209108023091090258
+:103CE0002196C217D30718F380E10E94E41CCFCEBF
+:103CF00083E00E94051DCBCE0E94B81C803209F0E3
+:103D0000F0CE84E10E94E41C8EE10E94E41C84E970
+:103D10000E94E41C86E00E94E41C80E10E94E41CF6
+:103D2000B6CEC0E0D0E008E011E00E94B81CF80177
+:103D300081938F0121968091080290910902C81702
+:103D4000D90798F341CF80910C02816080930C02D7
+:103D500034CF82E00E94051D9ACE81E00E94051DAD
+:103D600096CE80E10E94051D92CE8091070187FDCD
+:103D700080C010920B028091060190910701880F7C
+:103D8000991F90930701809306018091080280FF9C
+:103D900009C080910802909109020196909309024E
+:103DA00080930802F894F999FECF1127E09106015B
+:103DB000F0910701C8E0D1E08091080290910902DA
+:103DC000103091F40091570001700130D9F303E0F5
+:103DD00000935700E8950091570001700130D9F326
+:103DE00001E100935700E895099019900091570060
+:103DF00001700130D9F301E000935700E895139565
+:103E0000103498F011270091570001700130D9F358
+:103E100005E000935700E8950091570001700130CC
+:103E2000D9F301E100935700E8953296029709F023
+:103E3000C7CF103011F00296E5CF1124EECE81FFEE
+:103E40000CC03196F0930701E093060149CF8091B1
+:103E50000C02816080930C0215CF84910E94E41CB7
+:103E60002091080230910902E0910601F0910701CA
+:103E7000E8CF81E080930B027ECF0F931F930E94C7
+:103E8000B81C182F0E94E41C0E94B81C082F0E9426
+:103E9000E41C11362CF0175501363CF0075508C0CC
+:103EA0001033D4F310530136CCF700330CF0005329
+:103EB0001295107F100F812F992787FD90951F91E4
+:103EC0000F9108951F93282F992787FD9095807F44
+:103ED00090709595879595958795959587959595E6
+:103EE00087958A304CF0982F995A822F8F708A309C
+:103EF0004CF0182F195A08C0982F905D822F8F70A0
+:103F00008A30BCF7182F105D892F0E94E41C812F86
+:083F10000E94E41C1F910895BA
+:023F1800800027
+:0400000300003800C1
+:00000001FF

arduino-0018-linux/hardware/arduino/bootloaders/lilypad/src/ATmegaBOOT.c

@@ -0,0 +1,979 @@
+/**********************************************************/
+/* Serial Bootloader for Atmel megaAVR Controllers        */
+/*                                                        */
+/* tested with ATmega8, ATmega128 and ATmega168           */
+/* should work with other mega's, see code for details    */
+/*                                                        */
+/* ATmegaBOOT.c                                           */
+/*                                                        */
+/* 20070626: hacked for Arduino Diecimila (which auto-    */
+/*           resets when a USB connection is made to it)  */
+/*           by D. Mellis                                 */
+/* 20060802: hacked for Arduino by D. Cuartielles         */
+/*           based on a previous hack by D. Mellis        */
+/*           and D. Cuartielles                           */
+/*                                                        */
+/* Monitor and debug functions were added to the original */
+/* code by Dr. Erik Lins, chip45.com. (See below)         */
+/*                                                        */
+/* Thanks to Karl Pitrich for fixing a bootloader pin     */
+/* problem and more informative LED blinking!             */
+/*                                                        */
+/* For the latest version see:                            */
+/* http://www.chip45.com/                                 */
+/*                                                        */
+/* ------------------------------------------------------ */
+/*                                                        */
+/* based on stk500boot.c                                  */
+/* Copyright (c) 2003, Jason P. Kyle                      */
+/* All rights reserved.                                   */
+/* see avr1.org for original file and information         */
+/*                                                        */
+/* This program is free software; you can redistribute it */
+/* and/or modify it under the terms of the GNU General    */
+/* Public License as published by the Free Software       */
+/* Foundation; either version 2 of the License, or        */
+/* (at your option) any later version.                    */
+/*                                                        */
+/* This program is distributed in the hope that it will   */
+/* be useful, but WITHOUT ANY WARRANTY; without even the  */
+/* implied warranty of MERCHANTABILITY or FITNESS FOR A   */
+/* PARTICULAR PURPOSE.  See the GNU General Public        */
+/* License for more details.                              */
+/*                                                        */
+/* You should have received a copy of the GNU General     */
+/* Public License along with this program; if not, write  */
+/* to the Free Software Foundation, Inc.,                 */
+/* 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */
+/*                                                        */
+/* Licence can be viewed at                               */
+/* http://www.fsf.org/licenses/gpl.txt                    */
+/*                                                        */
+/* Target = Atmel AVR m128,m64,m32,m16,m8,m162,m163,m169, */
+/* m8515,m8535. ATmega161 has a very small boot block so  */
+/* isn't supported.                                       */
+/*                                                        */
+/* Tested with m168                                       */
+/**********************************************************/
+
+/* $Id$ */
+
+
+/* some includes */
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <avr/interrupt.h>
+#include <avr/wdt.h>
+
+
+/* the current avr-libc eeprom functions do not support the ATmega168 */
+/* own eeprom write/read functions are used instead */
+#ifndef __AVR_ATmega168__
+#include <avr/eeprom.h>
+#endif
+
+/* Use the F_CPU defined in Makefile */
+
+/* 20060803: hacked by DojoCorp */
+/* 20070626: hacked by David A. Mellis to decrease waiting time for auto-reset */
+/* set the waiting time for the bootloader */
+/* get this from the Makefile instead */
+/* #define MAX_TIME_COUNT (F_CPU>>4) */
+
+/* 20070707: hacked by David A. Mellis - after this many errors give up and launch application */
+#define MAX_ERROR_COUNT 5
+
+/* set the UART baud rate */
+/* 20060803: hacked by DojoCorp */
+//#define BAUD_RATE   115200
+#define BAUD_RATE   19200
+
+
+/* SW_MAJOR and MINOR needs to be updated from time to time to avoid warning message from AVR Studio */
+/* never allow AVR Studio to do an update !!!! */
+#define HW_VER	 0x02
+#define SW_MAJOR 0x01
+#define SW_MINOR 0x10
+
+
+/* Adjust to suit whatever pin your hardware uses to enter the bootloader */
+/* ATmega128 has two UARTS so two pins are used to enter bootloader and select UART */
+/* BL0... means UART0, BL1... means UART1 */
+#ifdef __AVR_ATmega128__
+#define BL_DDR  DDRF
+#define BL_PORT PORTF
+#define BL_PIN  PINF
+#define BL0     PINF7
+#define BL1     PINF6
+#else
+/* other ATmegas have only one UART, so only one pin is defined to enter bootloader */
+#define BL_DDR  DDRD
+#define BL_PORT PORTD
+#define BL_PIN  PIND
+#define BL      PIND6
+#endif
+
+
+/* onboard LED is used to indicate, that the bootloader was entered (3x flashing) */
+/* if monitor functions are included, LED goes on after monitor was entered */
+#ifdef __AVR_ATmega128__
+/* Onboard LED is connected to pin PB7 (e.g. Crumb128, PROBOmega128, Savvy128) */
+#define LED_DDR  DDRB
+#define LED_PORT PORTB
+#define LED_PIN  PINB
+#define LED      PINB7
+#else
+/* Onboard LED is connected to pin PB2 (e.g. Crumb8, Crumb168) */
+#define LED_DDR  DDRB
+#define LED_PORT PORTB
+#define LED_PIN  PINB
+/* 20060803: hacked by DojoCorp, LED pin is B5 in Arduino */
+/* #define LED      PINB2 */
+#define LED      PINB5
+#endif
+
+
+/* monitor functions will only be compiled when using ATmega128, due to bootblock size constraints */
+#ifdef __AVR_ATmega128__
+#define MONITOR
+#endif
+
+
+/* define various device id's */
+/* manufacturer byte is always the same */
+#define SIG1	0x1E	// Yep, Atmel is the only manufacturer of AVR micros.  Single source :(
+
+#if defined __AVR_ATmega128__
+#define SIG2	0x97
+#define SIG3	0x02
+#define PAGE_SIZE	0x80U	//128 words
+
+#elif defined __AVR_ATmega64__
+#define SIG2	0x96
+#define SIG3	0x02
+#define PAGE_SIZE	0x80U	//128 words
+
+#elif defined __AVR_ATmega32__
+#define SIG2	0x95
+#define SIG3	0x02
+#define PAGE_SIZE	0x40U	//64 words
+
+#elif defined __AVR_ATmega16__
+#define SIG2	0x94
+#define SIG3	0x03
+#define PAGE_SIZE	0x40U	//64 words
+
+#elif defined __AVR_ATmega8__
+#define SIG2	0x93
+#define SIG3	0x07
+#define PAGE_SIZE	0x20U	//32 words
+
+#elif defined __AVR_ATmega88__
+#define SIG2	0x93
+#define SIG3	0x0a
+#define PAGE_SIZE	0x20U	//32 words
+
+#elif defined __AVR_ATmega168__
+#define SIG2	0x94
+#define SIG3	0x06
+#define PAGE_SIZE	0x40U	//64 words
+
+#elif defined __AVR_ATmega162__
+#define SIG2	0x94
+#define SIG3	0x04
+#define PAGE_SIZE	0x40U	//64 words
+
+#elif defined __AVR_ATmega163__
+#define SIG2	0x94
+#define SIG3	0x02
+#define PAGE_SIZE	0x40U	//64 words
+
+#elif defined __AVR_ATmega169__
+#define SIG2	0x94
+#define SIG3	0x05
+#define PAGE_SIZE	0x40U	//64 words
+
+#elif defined __AVR_ATmega8515__
+#define SIG2	0x93
+#define SIG3	0x06
+#define PAGE_SIZE	0x20U	//32 words
+
+#elif defined __AVR_ATmega8535__
+#define SIG2	0x93
+#define SIG3	0x08
+#define PAGE_SIZE	0x20U	//32 words
+#endif
+
+
+/* function prototypes */
+void putch(char);
+char getch(void);
+void getNch(uint8_t);
+void byte_response(uint8_t);
+void nothing_response(void);
+char gethex(void);
+void puthex(char);
+void flash_led(uint8_t);
+
+/* some variables */
+union address_union {
+    uint16_t word;
+    uint8_t  byte[2];
+} address;
+
+union length_union {
+    uint16_t word;
+    uint8_t  byte[2];
+} length;
+
+struct flags_struct {
+    unsigned eeprom : 1;
+    unsigned rampz  : 1;
+} flags;
+
+uint8_t buff[256];
+uint8_t address_high;
+
+uint8_t pagesz=0x80;
+
+uint8_t i;
+uint8_t bootuart = 0;
+
+uint8_t error_count = 0;
+
+void (*app_start)(void) = 0x0000;
+
+
+/* main program starts here */
+int main(void)
+{
+    uint8_t ch,ch2;
+    uint16_t w;
+
+    asm volatile("nop\n\t");
+
+    /* set pin direction for bootloader pin and enable pullup */
+    /* for ATmega128, two pins need to be initialized */
+#ifdef __AVR_ATmega128__
+    BL_DDR &= ~_BV(BL0);
+    BL_DDR &= ~_BV(BL1);
+    BL_PORT |= _BV(BL0);
+    BL_PORT |= _BV(BL1);
+#else
+    /* We run the bootloader regardless of the state of this pin.  Thus, don't
+    put it in a different state than the other pins.  --DAM, 070709
+    BL_DDR &= ~_BV(BL);
+    BL_PORT |= _BV(BL);
+    */
+#endif
+
+
+#ifdef __AVR_ATmega128__
+    /* check which UART should be used for booting */
+    if(bit_is_clear(BL_PIN, BL0)) {
+      bootuart = 1;
+    }
+    else if(bit_is_clear(BL_PIN, BL1)) {
+      bootuart = 2;
+    }
+#endif
+
+    /* check if flash is programmed already, if not start bootloader anyway */
+    if(pgm_read_byte_near(0x0000) != 0xFF) {
+
+#ifdef __AVR_ATmega128__
+	/* no UART was selected, start application */
+	if(!bootuart) {
+          app_start();
+	}
+#else
+	/* check if bootloader pin is set low */
+	/* we don't start this part neither for the m8, nor m168 */
+	//if(bit_is_set(BL_PIN, BL)) {
+    //      app_start();
+    //    }
+#endif
+    }
+
+#ifdef __AVR_ATmega128__    
+    /* no bootuart was selected, default to uart 0 */
+    if(!bootuart) {
+      bootuart = 1;
+    }
+#endif
+
+
+    /* initialize UART(s) depending on CPU defined */
+#ifdef __AVR_ATmega128__
+    if(bootuart == 1) {
+	UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
+	UBRR0H = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
+	UCSR0A = 0x00;
+	UCSR0C = 0x06;
+	UCSR0B = _BV(TXEN0)|_BV(RXEN0);
+    }
+    if(bootuart == 2) {
+	UBRR1L = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
+	UBRR1H = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
+	UCSR1A = 0x00;
+	UCSR1C = 0x06;
+	UCSR1B = _BV(TXEN1)|_BV(RXEN1);
+    }
+#elif defined __AVR_ATmega163__
+    UBRR = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
+    UBRRHI = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
+    UCSRA = 0x00;
+    UCSRB = _BV(TXEN)|_BV(RXEN);	
+#elif defined __AVR_ATmega168__
+    UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
+    UBRR0H = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
+    UCSR0B = (1<<RXEN0) | (1<<TXEN0);
+    UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
+
+    /* Enable internal pull-up resistor on pin D0 (RX), in order
+    to supress line noise that prevents the bootloader from
+    timing out (DAM: 20070509) */
+    DDRD &= ~_BV(PIND0);
+    PORTD |= _BV(PIND0);
+#elif defined __AVR_ATmega8__
+  /* m8 */
+  UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8; 	// set baud rate
+  UBRRL = (((F_CPU/BAUD_RATE)/16)-1);
+  UCSRB = (1<<RXEN)|(1<<TXEN);  // enable Rx & Tx
+  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // config USART; 8N1
+#else
+    /* m16,m32,m169,m8515,m8535 */
+    UBRRL = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
+    UBRRH = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
+    UCSRA = 0x00;
+    UCSRC = 0x06;
+    UCSRB = _BV(TXEN)|_BV(RXEN);
+#endif
+
+    /* set LED pin as output */
+    LED_DDR |= _BV(LED);
+
+
+    /* flash onboard LED to signal entering of bootloader */
+#ifdef __AVR_ATmega128__
+    // 4x for UART0, 5x for UART1
+    flash_led(NUM_LED_FLASHES + bootuart);
+#else
+    flash_led(NUM_LED_FLASHES);
+#endif
+    
+    /* 20050803: by DojoCorp, this is one of the parts provoking the
+                 system to stop listening, cancelled from the original */
+    //putch('\0');
+
+
+    /* forever loop */
+    for (;;) {
+
+	/* get character from UART */
+	ch = getch();
+
+	/* A bunch of if...else if... gives smaller code than switch...case ! */
+
+	/* Hello is anyone home ? */ 
+	if(ch=='0') {
+	    nothing_response();
+	}
+
+
+	/* Request programmer ID */
+	/* Not using PROGMEM string due to boot block in m128 being beyond 64kB boundry  */
+	/* Would need to selectively manipulate RAMPZ, and it's only 9 characters anyway so who cares.  */
+	else if(ch=='1') {
+	    if (getch() == ' ') {
+		putch(0x14);
+		putch('A');
+		putch('V');
+		putch('R');
+		putch(' ');
+		putch('I');
+		putch('S');
+		putch('P');
+		putch(0x10);
+	    } else {
+		if (++error_count == MAX_ERROR_COUNT)
+		    app_start();
+	    }
+	}
+
+
+	/* AVR ISP/STK500 board commands  DON'T CARE so default nothing_response */
+	else if(ch=='@') {
+	    ch2 = getch();
+	    if (ch2>0x85) getch();
+	    nothing_response();
+	}
+
+
+	/* AVR ISP/STK500 board requests */
+	else if(ch=='A') {
+	    ch2 = getch();
+	    if(ch2==0x80) byte_response(HW_VER);		// Hardware version
+	    else if(ch2==0x81) byte_response(SW_MAJOR);	// Software major version
+	    else if(ch2==0x82) byte_response(SW_MINOR);	// Software minor version
+	    else if(ch2==0x98) byte_response(0x03);		// Unknown but seems to be required by avr studio 3.56
+	    else byte_response(0x00);				// Covers various unnecessary responses we don't care about
+	}
+
+
+	/* Device Parameters  DON'T CARE, DEVICE IS FIXED  */
+	else if(ch=='B') {
+	    getNch(20);
+	    nothing_response();
+	}
+
+
+	/* Parallel programming stuff  DON'T CARE  */
+	else if(ch=='E') {
+	    getNch(5);
+	    nothing_response();
+	}
+
+
+	/* Enter programming mode  */
+	else if(ch=='P') {
+	    nothing_response();
+	}
+
+
+	/* Leave programming mode  */
+	else if(ch=='Q') {
+	    nothing_response();
+	}
+
+
+	/* Erase device, don't care as we will erase one page at a time anyway.  */
+	else if(ch=='R') {
+	    nothing_response();
+	}
+
+
+	/* Set address, little endian. EEPROM in bytes, FLASH in words  */
+	/* Perhaps extra address bytes may be added in future to support > 128kB FLASH.  */
+	/* This might explain why little endian was used here, big endian used everywhere else.  */
+	else if(ch=='U') {
+	    address.byte[0] = getch();
+	    address.byte[1] = getch();
+	    nothing_response();
+	}
+
+
+	/* Universal SPI programming command, disabled.  Would be used for fuses and lock bits.  */
+	else if(ch=='V') {
+	    getNch(4);
+	    byte_response(0x00);
+	}
+
+
+	/* Write memory, length is big endian and is in bytes  */
+	else if(ch=='d') {
+	    length.byte[1] = getch();
+	    length.byte[0] = getch();
+	    flags.eeprom = 0;
+	    if (getch() == 'E') flags.eeprom = 1;
+	    for (w=0;w<length.word;w++) {
+		buff[w] = getch();	                        // Store data in buffer, can't keep up with serial data stream whilst programming pages
+	    }
+	    if (getch() == ' ') {
+		if (flags.eeprom) {		                //Write to EEPROM one byte at a time
+		    for(w=0;w<length.word;w++) {
+#ifdef __AVR_ATmega168__
+			while(EECR & (1<<EEPE));
+			EEAR = (uint16_t)(void *)address.word;
+			EEDR = buff[w];
+			EECR |= (1<<EEMPE);
+			EECR |= (1<<EEPE);
+#else
+			eeprom_write_byte((void *)address.word,buff[w]);
+#endif
+			address.word++;
+		    }			
+		}
+		else {					        //Write to FLASH one page at a time
+		    if (address.byte[1]>127) address_high = 0x01;	//Only possible with m128, m256 will need 3rd address byte. FIXME
+		    else address_high = 0x00;
+#ifdef __AVR_ATmega128__
+		    RAMPZ = address_high;
+#endif
+		    address.word = address.word << 1;	        //address * 2 -> byte location
+		    /* if ((length.byte[0] & 0x01) == 0x01) length.word++;	//Even up an odd number of bytes */
+		    if ((length.byte[0] & 0x01)) length.word++;	//Even up an odd number of bytes
+		    cli();					//Disable interrupts, just to be sure
+			// HACKME: EEPE used to be EEWE
+		    while(bit_is_set(EECR,EEPE));			//Wait for previous EEPROM writes to complete
+		    asm volatile(
+				 "clr	r17		\n\t"	//page_word_count
+				 "lds	r30,address	\n\t"	//Address of FLASH location (in bytes)
+				 "lds	r31,address+1	\n\t"
+				 "ldi	r28,lo8(buff)	\n\t"	//Start of buffer array in RAM
+				 "ldi	r29,hi8(buff)	\n\t"
+				 "lds	r24,length	\n\t"	//Length of data to be written (in bytes)
+				 "lds	r25,length+1	\n\t"
+				 "length_loop:		\n\t"	//Main loop, repeat for number of words in block							 							 
+				 "cpi	r17,0x00	\n\t"	//If page_word_count=0 then erase page
+				 "brne	no_page_erase	\n\t"						 
+				 "wait_spm1:		\n\t"
+				 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+				 "andi	r16,1           \n\t"
+				 "cpi	r16,1           \n\t"
+				 "breq	wait_spm1       \n\t"
+				 "ldi	r16,0x03	\n\t"	//Erase page pointed to by Z
+				 "sts	%0,r16		\n\t"
+				 "spm			\n\t"							 
+#ifdef __AVR_ATmega163__
+				 ".word 0xFFFF		\n\t"
+				 "nop			\n\t"
+#endif
+				 "wait_spm2:		\n\t"
+				 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+				 "andi	r16,1           \n\t"
+				 "cpi	r16,1           \n\t"
+				 "breq	wait_spm2       \n\t"									 
+
+				 "ldi	r16,0x11	\n\t"	//Re-enable RWW section
+				 "sts	%0,r16		\n\t"						 			 
+				 "spm			\n\t"
+#ifdef __AVR_ATmega163__
+				 ".word 0xFFFF		\n\t"
+				 "nop			\n\t"
+#endif
+				 "no_page_erase:		\n\t"							 
+				 "ld	r0,Y+		\n\t"	//Write 2 bytes into page buffer
+				 "ld	r1,Y+		\n\t"							 
+							 
+				 "wait_spm3:		\n\t"
+				 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+				 "andi	r16,1           \n\t"
+				 "cpi	r16,1           \n\t"
+				 "breq	wait_spm3       \n\t"
+				 "ldi	r16,0x01	\n\t"	//Load r0,r1 into FLASH page buffer
+				 "sts	%0,r16		\n\t"
+				 "spm			\n\t"
+							 
+				 "inc	r17		\n\t"	//page_word_count++
+				 "cpi r17,%1	        \n\t"
+				 "brlo	same_page	\n\t"	//Still same page in FLASH
+				 "write_page:		\n\t"
+				 "clr	r17		\n\t"	//New page, write current one first
+				 "wait_spm4:		\n\t"
+				 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+				 "andi	r16,1           \n\t"
+				 "cpi	r16,1           \n\t"
+				 "breq	wait_spm4       \n\t"
+#ifdef __AVR_ATmega163__
+				 "andi	r30,0x80	\n\t"	// m163 requires Z6:Z1 to be zero during page write
+#endif							 							 
+				 "ldi	r16,0x05	\n\t"	//Write page pointed to by Z
+				 "sts	%0,r16		\n\t"
+				 "spm			\n\t"
+#ifdef __AVR_ATmega163__
+				 ".word 0xFFFF		\n\t"
+				 "nop			\n\t"
+				 "ori	r30,0x7E	\n\t"	// recover Z6:Z1 state after page write (had to be zero during write)
+#endif
+				 "wait_spm5:		\n\t"
+				 "lds	r16,%0		\n\t"	//Wait for previous spm to complete
+				 "andi	r16,1           \n\t"
+				 "cpi	r16,1           \n\t"
+				 "breq	wait_spm5       \n\t"									 
+				 "ldi	r16,0x11	\n\t"	//Re-enable RWW section
+				 "sts	%0,r16		\n\t"						 			 
+				 "spm			\n\t"					 		 
+#ifdef __AVR_ATmega163__
+				 ".word 0xFFFF		\n\t"
+				 "nop			\n\t"
+#endif
+				 "same_page:		\n\t"							 
+				 "adiw	r30,2		\n\t"	//Next word in FLASH
+				 "sbiw	r24,2		\n\t"	//length-2
+				 "breq	final_write	\n\t"	//Finished
+				 "rjmp	length_loop	\n\t"
+				 "final_write:		\n\t"
+				 "cpi	r17,0		\n\t"
+				 "breq	block_done	\n\t"
+				 "adiw	r24,2		\n\t"	//length+2, fool above check on length after short page write
+				 "rjmp	write_page	\n\t"
+				 "block_done:		\n\t"
+				 "clr	__zero_reg__	\n\t"	//restore zero register
+#if defined __AVR_ATmega168__
+				 : "=m" (SPMCSR) : "M" (PAGE_SIZE) : "r0","r16","r17","r24","r25","r28","r29","r30","r31"
+#else
+				 : "=m" (SPMCR) : "M" (PAGE_SIZE) : "r0","r16","r17","r24","r25","r28","r29","r30","r31"
+#endif
+				 );
+		    /* Should really add a wait for RWW section to be enabled, don't actually need it since we never */
+		    /* exit the bootloader without a power cycle anyhow */
+		}
+		putch(0x14);
+		putch(0x10);
+	    } else {
+		if (++error_count == MAX_ERROR_COUNT)
+		    app_start();
+	    }		
+	}
+    
+
+        /* Read memory block mode, length is big endian.  */
+        else if(ch=='t') {
+	    length.byte[1] = getch();
+	    length.byte[0] = getch();
+#if defined __AVR_ATmega128__
+	    if (address.word>0x7FFF) flags.rampz = 1;		// No go with m256, FIXME
+	    else flags.rampz = 0;
+#endif
+	    if (getch() == 'E') flags.eeprom = 1;
+	    else {
+		flags.eeprom = 0;
+		address.word = address.word << 1;	        // address * 2 -> byte location
+	    }
+	    if (getch() == ' ') {		                // Command terminator
+		putch(0x14);
+		for (w=0;w < length.word;w++) {		        // Can handle odd and even lengths okay
+		    if (flags.eeprom) {	                        // Byte access EEPROM read
+#ifdef __AVR_ATmega168__
+			while(EECR & (1<<EEPE));
+			EEAR = (uint16_t)(void *)address.word;
+			EECR |= (1<<EERE);
+			putch(EEDR);
+#else
+			putch(eeprom_read_byte((void *)address.word));
+#endif
+			address.word++;
+		    }
+		    else {
+
+			if (!flags.rampz) putch(pgm_read_byte_near(address.word));
+#if defined __AVR_ATmega128__
+			else putch(pgm_read_byte_far(address.word + 0x10000));
+			// Hmmmm, yuck  FIXME when m256 arrvies
+#endif
+			address.word++;
+		    }
+		}
+		putch(0x10);
+	    }
+	}
+
+
+        /* Get device signature bytes  */
+        else if(ch=='u') {
+	    if (getch() == ' ') {
+		putch(0x14);
+		putch(SIG1);
+		putch(SIG2);
+		putch(SIG3);
+		putch(0x10);
+	    } else {
+		if (++error_count == MAX_ERROR_COUNT)
+		    app_start();
+	    }
+	}
+
+
+        /* Read oscillator calibration byte */
+        else if(ch=='v') {
+	    byte_response(0x00);
+	}
+
+
+#ifdef MONITOR
+
+	/* here come the extended monitor commands by Erik Lins */
+
+	/* check for three times exclamation mark pressed */
+	else if(ch=='!') {
+	    ch = getch();
+	    if(ch=='!') {
+		ch = getch();
+		if(ch=='!') {
+
+#ifdef __AVR_ATmega128__
+		    uint16_t extaddr;
+#endif
+		    uint8_t addrl, addrh;
+
+#ifdef CRUMB128
+		    PGM_P welcome = {"ATmegaBOOT / Crumb128 - (C) J.P.Kyle, E.Lins - 050815\n\r"};
+#elif defined PROBOMEGA128
+		    PGM_P welcome = {"ATmegaBOOT / PROBOmega128 - (C) J.P.Kyle, E.Lins - 050815\n\r"};
+#elif defined SAVVY128
+		    PGM_P welcome = {"ATmegaBOOT / Savvy128 - (C) J.P.Kyle, E.Lins - 050815\n\r"};
+#endif
+
+		    /* turn on LED */
+		    LED_DDR |= _BV(LED);
+		    LED_PORT &= ~_BV(LED);
+
+		    /* print a welcome message and command overview */
+		    for(i=0; welcome[i] != '\0'; ++i) {
+			putch(welcome[i]);
+		    }
+
+		    /* test for valid commands */
+		    for(;;) {
+			putch('\n');
+			putch('\r');
+			putch(':');
+			putch(' ');
+
+			ch = getch();
+			putch(ch);
+
+			/* toggle LED */
+			if(ch == 't') {
+			    if(bit_is_set(LED_PIN,LED)) {
+				LED_PORT &= ~_BV(LED);
+				putch('1');
+			    } else {
+				LED_PORT |= _BV(LED);
+				putch('0');
+			    }
+
+			} 
+
+			/* read byte from address */
+			else if(ch == 'r') {
+			    ch = getch(); putch(ch);
+			    addrh = gethex();
+			    addrl = gethex();
+			    putch('=');
+			    ch = *(uint8_t *)((addrh << 8) + addrl);
+			    puthex(ch);
+			}
+
+			/* write a byte to address  */
+			else if(ch == 'w') {
+			    ch = getch(); putch(ch);
+			    addrh = gethex();
+			    addrl = gethex();
+			    ch = getch(); putch(ch);
+			    ch = gethex();
+			    *(uint8_t *)((addrh << 8) + addrl) = ch;
+
+			}
+
+			/* read from uart and echo back */
+			else if(ch == 'u') {
+			    for(;;) {
+				putch(getch());
+			    }
+			}
+#ifdef __AVR_ATmega128__
+			/* external bus loop  */
+			else if(ch == 'b') {
+			    putch('b');
+			    putch('u');
+			    putch('s');
+			    MCUCR = 0x80;
+			    XMCRA = 0;
+			    XMCRB = 0;
+			    extaddr = 0x1100;
+			    for(;;) {
+				ch = *(volatile uint8_t *)extaddr;
+				if(++extaddr == 0) {
+				    extaddr = 0x1100;
+				}
+			    }
+			}
+#endif
+
+			else if(ch == 'j') {
+			    app_start();
+			}
+
+		    }
+		    /* end of monitor functions */
+
+		}
+	    }
+	}
+	/* end of monitor */
+#endif
+	else if (++error_count == MAX_ERROR_COUNT) {
+	    app_start();
+	}
+    }
+    /* end of forever loop */
+
+}
+
+
+char gethex(void) {
+    char ah,al;
+
+    ah = getch(); putch(ah);
+    al = getch(); putch(al);
+    if(ah >= 'a') {
+	ah = ah - 'a' + 0x0a;
+    } else if(ah >= '0') {
+	ah -= '0';
+    }
+    if(al >= 'a') {
+	al = al - 'a' + 0x0a;
+    } else if(al >= '0') {
+	al -= '0';
+    }
+    return (ah << 4) + al;
+}
+
+
+void puthex(char ch) {
+    char ah,al;
+
+    ah = (ch & 0xf0) >> 4;
+    if(ah >= 0x0a) {
+	ah = ah - 0x0a + 'a';
+    } else {
+	ah += '0';
+    }
+    al = (ch & 0x0f);
+    if(al >= 0x0a) {
+	al = al - 0x0a + 'a';
+    } else {
+	al += '0';
+    }
+    putch(ah);
+    putch(al);
+}
+
+
+void putch(char ch)
+{
+#ifdef __AVR_ATmega128__
+    if(bootuart == 1) {
+	while (!(UCSR0A & _BV(UDRE0)));
+	UDR0 = ch;
+    }
+    else if (bootuart == 2) {
+	while (!(UCSR1A & _BV(UDRE1)));
+	UDR1 = ch;
+    }
+#elif defined __AVR_ATmega168__
+    while (!(UCSR0A & _BV(UDRE0)));
+    UDR0 = ch;
+#else
+    /* m8,16,32,169,8515,8535,163 */
+    while (!(UCSRA & _BV(UDRE)));
+    UDR = ch;
+#endif
+}
+
+
+char getch(void)
+{
+#ifdef __AVR_ATmega128__
+    if(bootuart == 1) {
+	while(!(UCSR0A & _BV(RXC0)));
+	return UDR0;
+    }
+    else if(bootuart == 2) {
+	while(!(UCSR1A & _BV(RXC1)));
+	return UDR1;
+    }
+    return 0;
+#elif defined __AVR_ATmega168__
+    uint32_t count = 0;
+    while(!(UCSR0A & _BV(RXC0))){
+    	/* 20060803 DojoCorp:: Addon coming from the previous Bootloader*/               
+    	/* HACKME:: here is a good place to count times*/
+    	count++;
+    	if (count > MAX_TIME_COUNT)
+    		app_start();
+     }
+    return UDR0;
+#else
+    /* m8,16,32,169,8515,8535,163 */
+    uint32_t count = 0;
+    while(!(UCSRA & _BV(RXC))){
+    	/* 20060803 DojoCorp:: Addon coming from the previous Bootloader*/               
+    	/* HACKME:: here is a good place to count times*/
+    	count++;
+    	if (count > MAX_TIME_COUNT)
+    		app_start();
+     }
+    return UDR;
+#endif
+}
+
+
+void getNch(uint8_t count)
+{
+    uint8_t i;
+    for(i=0;i<count;i++) {
+#ifdef __AVR_ATmega128__
+	if(bootuart == 1) {
+	    while(!(UCSR0A & _BV(RXC0)));
+	    UDR0;
+	} 
+	else if(bootuart == 2) {
+	    while(!(UCSR1A & _BV(RXC1)));
+	    UDR1;
+	}
+#elif defined __AVR_ATmega168__
+	while(!(UCSR0A & _BV(RXC0)));
+	UDR0;
+#else
+	/* m8,16,32,169,8515,8535,163 */
+   	/* 20060803 DojoCorp:: Addon coming from the previous Bootloader*/               
+	//while(!(UCSRA & _BV(RXC)));
+	//UDR;
+    uint8_t i;
+    for(i=0;i<count;i++) {
+    	getch(); // need to handle time out
+    }
+#endif		
+    }
+}
+
+
+void byte_response(uint8_t val)
+{
+    if (getch() == ' ') {
+	putch(0x14);
+	putch(val);
+	putch(0x10);
+    } else {
+	if (++error_count == MAX_ERROR_COUNT)
+	    app_start();
+    }
+}
+
+
+void nothing_response(void)
+{
+    if (getch() == ' ') {
+	putch(0x14);
+	putch(0x10);
+    } else {
+	if (++error_count == MAX_ERROR_COUNT)
+	    app_start();
+    }
+}
+
+void flash_led(uint8_t count)
+{
+    /* flash onboard LED three times to signal entering of bootloader */
+	/* l needs to be volatile or the delay loops below might get
+	optimized away if compiling with optimizations (DAM). */
+    volatile uint32_t l;
+
+    if (count == 0) {
+      count = 3;
+    }
+    
+    for (i = 0; i < count; ++i) {
+	LED_PORT |= _BV(LED);
+	for(l = 0; l < (F_CPU / 1000); ++l);
+	LED_PORT &= ~_BV(LED);
+	for(l = 0; l < (F_CPU / 1000); ++l);
+    }
+}
+
+
+/* end of file ATmegaBOOT.c */

arduino-0018-linux/hardware/arduino/bootloaders/lilypad/src/Makefile

@@ -0,0 +1,84 @@
+# Makefile for ATmegaBOOT
+# E.Lins, 18.7.2005
+# $Id$
+
+# Instructions
+#
+# To build the bootloader for the LilyPad:
+# make lily
+
+
+# program name should not be changed...
+PROGRAM    = ATmegaBOOT_168
+
+# enter the target CPU frequency
+AVR_FREQ   = 8000000L
+
+# enter the parameters for the avrdude isp tool
+ISPTOOL	   = stk500v2
+ISPPORT	   = usb
+ISPSPEED   = -b 115200
+
+MCU_TARGET = atmega168
+LDSECTION  = --section-start=.text=0x3800
+
+# the efuse should really be 0xf8; since, however, only the lower
+# three bits of that byte are used on the atmega168, avrdude gets
+# confused if you specify 1's for the higher bits, see:
+# http://tinker.it/now/2007/02/24/the-tale-of-avrdude-atmega168-and-extended-bits-fuses/
+#
+# similarly, the lock bits should be 0xff instead of 0x3f (to
+# unlock the bootloader section) and 0xcf instead of 0x0f (to
+# lock it), but since the high two bits of the lock byte are
+# unused, avrdude would get confused.
+ISPFUSES    = avrdude -c $(ISPTOOL) -p m168 -P $(ISPPORT) $(ISPSPEED) -e -u -U lock:w:0x3f:m -U efuse:w:0x00:m -U hfuse:w:0xdd:m -U lfuse:w:0xff:m
+ISPFLASH    = avrdude -c $(ISPTOOL) -p m168 -P $(ISPPORT) $(ISPSPEED) -U flash:w:$(PROGRAM)_$(TARGET).hex -U lock:w:0x0f:m
+
+
+OBJ        = $(PROGRAM).o
+OPTIMIZE   = -O2
+
+DEFS       = 
+LIBS       =
+
+CC         = avr-gcc
+
+
+# Override is only needed by avr-lib build system.
+
+override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) -DF_CPU=$(AVR_FREQ) $(DEFS)
+override LDFLAGS       = -Wl,$(LDSECTION)
+#override LDFLAGS       = -Wl,-Map,$(PROGRAM).map,$(LDSECTION)
+
+OBJCOPY        = avr-objcopy
+OBJDUMP        = avr-objdump
+
+all:
+
+lily: CFLAGS += '-DMAX_TIME_COUNT=F_CPU>>1' '-DNUM_LED_FLASHES=3'
+lily: $(PROGRAM).hex
+
+$(PROGRAM).hex: $(PROGRAM).elf
+	$(OBJCOPY) -j .text -j .data -O ihex $< $@
+	
+$(PROGRAM).elf: $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
+	
+$(OBJ): 
+	avr-gcc $(CFLAGS) $(LDFLAGS) -c -g -O2 -Wall -mmcu=atmega168 ATmegaBOOT.c -o ATmegaBOOT_168.o
+
+%.lst: %.elf
+	$(OBJDUMP) -h -S $< > $@
+
+%.srec: %.elf
+	$(OBJCOPY) -j .text -j .data -O srec $< $@
+
+%.bin: %.elf
+	$(OBJCOPY) -j .text -j .data -O binary $< $@
+
+clean:
+	rm -rf *.o *.elf *.lst *.map *.sym *.lss *.eep *.srec *.bin *.hex
+	
+install:
+	avrdude -p m168 -c stk500v2 -P /dev/cu.USA19H1b1P1.1 -e -u -U lock:w:0x3f:m -U efuse:w:0x00:m -U hfuse:w:0xdd:m -U lfuse:w:0xe2:m 
+	avrdude -p m168 -c stk500v2 -P /dev/cu.USA19H1b1P1.1 -e -u -U flash:w:ATmegaBOOT_168.hex  -U lock:w:0x0f:m

arduino-0018-linux/hardware/arduino/cores/arduino/HardwareSerial.cpp

@@ -0,0 +1,226 @@
+/*
+  HardwareSerial.cpp - Hardware serial library for Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+  
+  Modified 23 November 2006 by David A. Mellis
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include "wiring.h"
+#include "wiring_private.h"
+
+#include "HardwareSerial.h"
+
+// Define constants and variables for buffering incoming serial data.  We're
+// using a ring buffer (I think), in which rx_buffer_head is the index of the
+// location to which to write the next incoming character and rx_buffer_tail
+// is the index of the location from which to read.
+#define RX_BUFFER_SIZE 128
+
+struct ring_buffer {
+  unsigned char buffer[RX_BUFFER_SIZE];
+  int head;
+  int tail;
+};
+
+ring_buffer rx_buffer = { { 0 }, 0, 0 };
+
+#if defined(__AVR_ATmega1280__)
+ring_buffer rx_buffer1 = { { 0 }, 0, 0 };
+ring_buffer rx_buffer2 = { { 0 }, 0, 0 };
+ring_buffer rx_buffer3 = { { 0 }, 0, 0 };
+#endif
+
+inline void store_char(unsigned char c, ring_buffer *rx_buffer)
+{
+  int i = (rx_buffer->head + 1) % RX_BUFFER_SIZE;
+
+  // if we should be storing the received character into the location
+  // just before the tail (meaning that the head would advance to the
+  // current location of the tail), we're about to overflow the buffer
+  // and so we don't write the character or advance the head.
+  if (i != rx_buffer->tail) {
+    rx_buffer->buffer[rx_buffer->head] = c;
+    rx_buffer->head = i;
+  }
+}
+
+#if defined(__AVR_ATmega1280__)
+
+SIGNAL(SIG_USART0_RECV)
+{
+  unsigned char c = UDR0;
+  store_char(c, &rx_buffer);
+}
+
+SIGNAL(SIG_USART1_RECV)
+{
+  unsigned char c = UDR1;
+  store_char(c, &rx_buffer1);
+}
+
+SIGNAL(SIG_USART2_RECV)
+{
+  unsigned char c = UDR2;
+  store_char(c, &rx_buffer2);
+}
+
+SIGNAL(SIG_USART3_RECV)
+{
+  unsigned char c = UDR3;
+  store_char(c, &rx_buffer3);
+}
+
+#else
+
+#if defined(__AVR_ATmega8__)
+SIGNAL(SIG_UART_RECV)
+#else
+SIGNAL(USART_RX_vect)
+#endif
+{
+#if defined(__AVR_ATmega8__)
+  unsigned char c = UDR;
+#else
+  unsigned char c = UDR0;
+#endif
+  store_char(c, &rx_buffer);
+}
+
+#endif
+
+// Constructors ////////////////////////////////////////////////////////////////
+
+HardwareSerial::HardwareSerial(ring_buffer *rx_buffer,
+  volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
+  volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
+  volatile uint8_t *udr,
+  uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udre, uint8_t u2x)
+{
+  _rx_buffer = rx_buffer;
+  _ubrrh = ubrrh;
+  _ubrrl = ubrrl;
+  _ucsra = ucsra;
+  _ucsrb = ucsrb;
+  _udr = udr;
+  _rxen = rxen;
+  _txen = txen;
+  _rxcie = rxcie;
+  _udre = udre;
+  _u2x = u2x;
+}
+
+// Public Methods //////////////////////////////////////////////////////////////
+
+void HardwareSerial::begin(long baud)
+{
+  uint16_t baud_setting;
+  bool use_u2x;
+
+  // U2X mode is needed for baud rates higher than (CPU Hz / 16)
+  if (baud > F_CPU / 16) {
+    use_u2x = true;
+  } else {
+    // figure out if U2X mode would allow for a better connection
+    
+    // calculate the percent difference between the baud-rate specified and
+    // the real baud rate for both U2X and non-U2X mode (0-255 error percent)
+    uint8_t nonu2x_baud_error = abs((int)(255-((F_CPU/(16*(((F_CPU/8/baud-1)/2)+1))*255)/baud)));
+    uint8_t u2x_baud_error = abs((int)(255-((F_CPU/(8*(((F_CPU/4/baud-1)/2)+1))*255)/baud)));
+    
+    // prefer non-U2X mode because it handles clock skew better
+    use_u2x = (nonu2x_baud_error > u2x_baud_error);
+  }
+  
+  if (use_u2x) {
+    *_ucsra = 1 << _u2x;
+    baud_setting = (F_CPU / 4 / baud - 1) / 2;
+  } else {
+    *_ucsra = 0;
+    baud_setting = (F_CPU / 8 / baud - 1) / 2;
+  }
+
+  // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
+  *_ubrrh = baud_setting >> 8;
+  *_ubrrl = baud_setting;
+
+  sbi(*_ucsrb, _rxen);
+  sbi(*_ucsrb, _txen);
+  sbi(*_ucsrb, _rxcie);
+}
+
+void HardwareSerial::end()
+{
+  cbi(*_ucsrb, _rxen);
+  cbi(*_ucsrb, _txen);
+  cbi(*_ucsrb, _rxcie);  
+}
+
+uint8_t HardwareSerial::available(void)
+{
+  return (RX_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % RX_BUFFER_SIZE;
+}
+
+int HardwareSerial::read(void)
+{
+  // if the head isn't ahead of the tail, we don't have any characters
+  if (_rx_buffer->head == _rx_buffer->tail) {
+    return -1;
+  } else {
+    unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
+    _rx_buffer->tail = (_rx_buffer->tail + 1) % RX_BUFFER_SIZE;
+    return c;
+  }
+}
+
+void HardwareSerial::flush()
+{
+  // don't reverse this or there may be problems if the RX interrupt
+  // occurs after reading the value of rx_buffer_head but before writing
+  // the value to rx_buffer_tail; the previous value of rx_buffer_head
+  // may be written to rx_buffer_tail, making it appear as if the buffer
+  // don't reverse this or there may be problems if the RX interrupt
+  // occurs after reading the value of rx_buffer_head but before writing
+  // the value to rx_buffer_tail; the previous value of rx_buffer_head
+  // may be written to rx_buffer_tail, making it appear as if the buffer
+  // were full, not empty.
+  _rx_buffer->head = _rx_buffer->tail;
+}
+
+void HardwareSerial::write(uint8_t c)
+{
+  while (!((*_ucsra) & (1 << _udre)))
+    ;
+
+  *_udr = c;
+}
+
+// Preinstantiate Objects //////////////////////////////////////////////////////
+
+#if defined(__AVR_ATmega8__)
+HardwareSerial Serial(&rx_buffer, &UBRRH, &UBRRL, &UCSRA, &UCSRB, &UDR, RXEN, TXEN, RXCIE, UDRE, U2X);
+#else
+HardwareSerial Serial(&rx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UDR0, RXEN0, TXEN0, RXCIE0, UDRE0, U2X0);
+#endif
+
+#if defined(__AVR_ATmega1280__)
+HardwareSerial Serial1(&rx_buffer1, &UBRR1H, &UBRR1L, &UCSR1A, &UCSR1B, &UDR1, RXEN1, TXEN1, RXCIE1, UDRE1, U2X1);
+HardwareSerial Serial2(&rx_buffer2, &UBRR2H, &UBRR2L, &UCSR2A, &UCSR2B, &UDR2, RXEN2, TXEN2, RXCIE2, UDRE2, U2X2);
+HardwareSerial Serial3(&rx_buffer3, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UDR3, RXEN3, TXEN3, RXCIE3, UDRE3, U2X3);
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/HardwareSerial.h

@@ -0,0 +1,66 @@
+/*
+  HardwareSerial.h - Hardware serial library for Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef HardwareSerial_h
+#define HardwareSerial_h
+
+#include <inttypes.h>
+
+#include "Print.h"
+
+struct ring_buffer;
+
+class HardwareSerial : public Print
+{
+  private:
+    ring_buffer *_rx_buffer;
+    volatile uint8_t *_ubrrh;
+    volatile uint8_t *_ubrrl;
+    volatile uint8_t *_ucsra;
+    volatile uint8_t *_ucsrb;
+    volatile uint8_t *_udr;
+    uint8_t _rxen;
+    uint8_t _txen;
+    uint8_t _rxcie;
+    uint8_t _udre;
+    uint8_t _u2x;
+  public:
+    HardwareSerial(ring_buffer *rx_buffer,
+      volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
+      volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
+      volatile uint8_t *udr,
+      uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udre, uint8_t u2x);
+    void begin(long);
+    void end();
+    uint8_t available(void);
+    int read(void);
+    void flush(void);
+    virtual void write(uint8_t);
+    using Print::write; // pull in write(str) and write(buf, size) from Print
+};
+
+extern HardwareSerial Serial;
+
+#if defined(__AVR_ATmega1280__)
+extern HardwareSerial Serial1;
+extern HardwareSerial Serial2;
+extern HardwareSerial Serial3;
+#endif
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/Print.cpp

@@ -0,0 +1,206 @@
+/*
+ Print.cpp - Base class that provides print() and println()
+ Copyright (c) 2008 David A. Mellis.  All right reserved.
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+ 
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ 
+ Modified 23 November 2006 by David A. Mellis
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include "wiring.h"
+
+#include "Print.h"
+
+// Public Methods //////////////////////////////////////////////////////////////
+
+/* default implementation: may be overridden */
+void Print::write(const char *str)
+{
+  while (*str)
+    write(*str++);
+}
+
+/* default implementation: may be overridden */
+void Print::write(const uint8_t *buffer, size_t size)
+{
+  while (size--)
+    write(*buffer++);
+}
+
+void Print::print(const char str[])
+{
+  write(str);
+}
+
+void Print::print(char c, int base)
+{
+  print((long) c, base);
+}
+
+void Print::print(unsigned char b, int base)
+{
+  print((unsigned long) b, base);
+}
+
+void Print::print(int n, int base)
+{
+  print((long) n, base);
+}
+
+void Print::print(unsigned int n, int base)
+{
+  print((unsigned long) n, base);
+}
+
+void Print::print(long n, int base)
+{
+  if (base == 0) {
+    write(n);
+  } else if (base == 10) {
+    if (n < 0) {
+      print('-');
+      n = -n;
+    }
+    printNumber(n, 10);
+  } else {
+    printNumber(n, base);
+  }
+}
+
+void Print::print(unsigned long n, int base)
+{
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+void Print::print(double n, int digits)
+{
+  printFloat(n, digits);
+}
+
+void Print::println(void)
+{
+  print('\r');
+  print('\n');  
+}
+
+void Print::println(const char c[])
+{
+  print(c);
+  println();
+}
+
+void Print::println(char c, int base)
+{
+  print(c, base);
+  println();
+}
+
+void Print::println(unsigned char b, int base)
+{
+  print(b, base);
+  println();
+}
+
+void Print::println(int n, int base)
+{
+  print(n, base);
+  println();
+}
+
+void Print::println(unsigned int n, int base)
+{
+  print(n, base);
+  println();
+}
+
+void Print::println(long n, int base)
+{
+  print(n, base);
+  println();
+}
+
+void Print::println(unsigned long n, int base)
+{
+  print(n, base);
+  println();
+}
+
+void Print::println(double n, int digits)
+{
+  print(n, digits);
+  println();
+}
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+void Print::printNumber(unsigned long n, uint8_t base)
+{
+  unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars. 
+  unsigned long i = 0;
+
+  if (n == 0) {
+    print('0');
+    return;
+  } 
+
+  while (n > 0) {
+    buf[i++] = n % base;
+    n /= base;
+  }
+
+  for (; i > 0; i--)
+    print((char) (buf[i - 1] < 10 ?
+      '0' + buf[i - 1] :
+      'A' + buf[i - 1] - 10));
+}
+
+void Print::printFloat(double number, uint8_t digits) 
+{ 
+  // Handle negative numbers
+  if (number < 0.0)
+  {
+     print('-');
+     number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  for (uint8_t i=0; i<digits; ++i)
+    rounding /= 10.0;
+  
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits > 0)
+    print("."); 
+
+  // Extract digits from the remainder one at a time
+  while (digits-- > 0)
+  {
+    remainder *= 10.0;
+    int toPrint = int(remainder);
+    print(toPrint);
+    remainder -= toPrint; 
+  } 
+}

arduino-0018-linux/hardware/arduino/cores/arduino/Print.h

@@ -0,0 +1,62 @@
+/*
+  Print.h - Base class that provides print() and println()
+  Copyright (c) 2008 David A. Mellis.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef Print_h
+#define Print_h
+
+#include <inttypes.h>
+#include <stdio.h> // for size_t
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+#define BYTE 0
+
+class Print
+{
+  private:
+    void printNumber(unsigned long, uint8_t);
+    void printFloat(double, uint8_t);
+  public:
+    virtual void write(uint8_t) = 0;
+    virtual void write(const char *str);
+    virtual void write(const uint8_t *buffer, size_t size);
+
+    void print(const char[]);
+    void print(char, int = BYTE);
+    void print(unsigned char, int = BYTE);
+    void print(int, int = DEC);
+    void print(unsigned int, int = DEC);
+    void print(long, int = DEC);
+    void print(unsigned long, int = DEC);
+    void print(double, int = 2);
+
+    void println(const char[]);
+    void println(char, int = BYTE);
+    void println(unsigned char, int = BYTE);
+    void println(int, int = DEC);
+    void println(unsigned int, int = DEC);
+    void println(long, int = DEC);
+    void println(unsigned long, int = DEC);
+    void println(double, int = 2);
+    void println(void);
+};
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/Tone.cpp

@@ -0,0 +1,515 @@
+/* Tone.cpp
+
+  A Tone Generator Library
+
+  Written by Brett Hagman
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Version Modified By Date     Comments
+------- ----------- -------- --------
+0001    B Hagman    09/08/02 Initial coding
+0002    B Hagman    09/08/18 Multiple pins
+0003    B Hagman    09/08/18 Moved initialization from constructor to begin()
+0004    B Hagman    09/09/26 Fixed problems with ATmega8
+0005    B Hagman    09/11/23 Scanned prescalars for best fit on 8 bit timers
+                    09/11/25 Changed pin toggle method to XOR
+                    09/11/25 Fixed timer0 from being excluded
+0006    D Mellis    09/12/29 Replaced objects with functions
+
+*************************************************/
+
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <wiring.h>
+#include <pins_arduino.h>
+
+#if defined(__AVR_ATmega8__)
+#define TCCR2A TCCR2
+#define TCCR2B TCCR2
+#define COM2A1 COM21
+#define COM2A0 COM20
+#define OCR2A OCR2
+#define TIMSK2 TIMSK
+#define OCIE2A OCIE2
+#define TIMER2_COMPA_vect TIMER2_COMP_vect
+#define TIMSK1 TIMSK
+#endif
+
+// timerx_toggle_count:
+//  > 0 - duration specified
+//  = 0 - stopped
+//  < 0 - infinitely (until stop() method called, or new play() called)
+
+#if !defined(__AVR_ATmega8__)
+volatile long timer0_toggle_count;
+volatile uint8_t *timer0_pin_port;
+volatile uint8_t timer0_pin_mask;
+#endif
+
+volatile long timer1_toggle_count;
+volatile uint8_t *timer1_pin_port;
+volatile uint8_t timer1_pin_mask;
+volatile long timer2_toggle_count;
+volatile uint8_t *timer2_pin_port;
+volatile uint8_t timer2_pin_mask;
+
+#if defined(__AVR_ATmega1280__)
+volatile long timer3_toggle_count;
+volatile uint8_t *timer3_pin_port;
+volatile uint8_t timer3_pin_mask;
+volatile long timer4_toggle_count;
+volatile uint8_t *timer4_pin_port;
+volatile uint8_t timer4_pin_mask;
+volatile long timer5_toggle_count;
+volatile uint8_t *timer5_pin_port;
+volatile uint8_t timer5_pin_mask;
+#endif
+
+
+#if defined(__AVR_ATmega1280__)
+
+#define AVAILABLE_TONE_PINS 1
+
+const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 3, 4, 5, 1, 0 */ };
+static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255, 255, 255, 255 */ };
+
+#elif defined(__AVR_ATmega8__)
+
+#define AVAILABLE_TONE_PINS 1
+
+const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1 */ };
+static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255 */ };
+
+#else
+
+#define AVAILABLE_TONE_PINS 1
+
+// Leave timer 0 to last.
+const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1, 0 */ };
+static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255 */ };
+
+#endif
+
+
+
+static int8_t toneBegin(uint8_t _pin)
+{
+  int8_t _timer = -1;
+
+  // if we're already using the pin, the timer should be configured.  
+  for (int i = 0; i < AVAILABLE_TONE_PINS; i++) {
+    if (tone_pins[i] == _pin) {
+      return pgm_read_byte(tone_pin_to_timer_PGM + i);
+    }
+  }
+  
+  // search for an unused timer.
+  for (int i = 0; i < AVAILABLE_TONE_PINS; i++) {
+    if (tone_pins[i] == 255) {
+      tone_pins[i] = _pin;
+      _timer = pgm_read_byte(tone_pin_to_timer_PGM + i);
+      break;
+    }
+  }
+  
+  if (_timer != -1)
+  {
+    // Set timer specific stuff
+    // All timers in CTC mode
+    // 8 bit timers will require changing prescalar values,
+    // whereas 16 bit timers are set to either ck/1 or ck/64 prescalar
+    switch (_timer)
+    {
+#if !defined(__AVR_ATmega8__)
+      case 0:
+        // 8 bit timer
+        TCCR0A = 0;
+        TCCR0B = 0;
+        bitWrite(TCCR0A, WGM01, 1);
+        bitWrite(TCCR0B, CS00, 1);
+        timer0_pin_port = portOutputRegister(digitalPinToPort(_pin));
+        timer0_pin_mask = digitalPinToBitMask(_pin);
+        break;
+#endif
+
+      case 1:
+        // 16 bit timer
+        TCCR1A = 0;
+        TCCR1B = 0;
+        bitWrite(TCCR1B, WGM12, 1);
+        bitWrite(TCCR1B, CS10, 1);
+        timer1_pin_port = portOutputRegister(digitalPinToPort(_pin));
+        timer1_pin_mask = digitalPinToBitMask(_pin);
+        break;
+      case 2:
+        // 8 bit timer
+        TCCR2A = 0;
+        TCCR2B = 0;
+        bitWrite(TCCR2A, WGM21, 1);
+        bitWrite(TCCR2B, CS20, 1);
+        timer2_pin_port = portOutputRegister(digitalPinToPort(_pin));
+        timer2_pin_mask = digitalPinToBitMask(_pin);
+        break;
+
+#if defined(__AVR_ATmega1280__)
+      case 3:
+        // 16 bit timer
+        TCCR3A = 0;
+        TCCR3B = 0;
+        bitWrite(TCCR3B, WGM32, 1);
+        bitWrite(TCCR3B, CS30, 1);
+        timer3_pin_port = portOutputRegister(digitalPinToPort(_pin));
+        timer3_pin_mask = digitalPinToBitMask(_pin);
+        break;
+      case 4:
+        // 16 bit timer
+        TCCR4A = 0;
+        TCCR4B = 0;
+        bitWrite(TCCR4B, WGM42, 1);
+        bitWrite(TCCR4B, CS40, 1);
+        timer4_pin_port = portOutputRegister(digitalPinToPort(_pin));
+        timer4_pin_mask = digitalPinToBitMask(_pin);
+        break;
+      case 5:
+        // 16 bit timer
+        TCCR5A = 0;
+        TCCR5B = 0;
+        bitWrite(TCCR5B, WGM52, 1);
+        bitWrite(TCCR5B, CS50, 1);
+        timer5_pin_port = portOutputRegister(digitalPinToPort(_pin));
+        timer5_pin_mask = digitalPinToBitMask(_pin);
+        break;
+#endif
+    }
+  }
+
+  return _timer;
+}
+
+
+
+// frequency (in hertz) and duration (in milliseconds).
+
+void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
+{
+  uint8_t prescalarbits = 0b001;
+  long toggle_count = 0;
+  uint32_t ocr = 0;
+  int8_t _timer;
+
+  _timer = toneBegin(_pin);
+
+  if (_timer >= 0)
+  {
+    // Set the pinMode as OUTPUT
+    pinMode(_pin, OUTPUT);
+    
+    // if we are using an 8 bit timer, scan through prescalars to find the best fit
+    if (_timer == 0 || _timer == 2)
+    {
+      ocr = F_CPU / frequency / 2 - 1;
+      prescalarbits = 0b001;  // ck/1: same for both timers
+      if (ocr > 255)
+      {
+        ocr = F_CPU / frequency / 2 / 8 - 1;
+        prescalarbits = 0b010;  // ck/8: same for both timers
+
+        if (_timer == 2 && ocr > 255)
+        {
+          ocr = F_CPU / frequency / 2 / 32 - 1;
+          prescalarbits = 0b011;
+        }
+
+        if (ocr > 255)
+        {
+          ocr = F_CPU / frequency / 2 / 64 - 1;
+          prescalarbits = _timer == 0 ? 0b011 : 0b100;
+
+          if (_timer == 2 && ocr > 255)
+          {
+            ocr = F_CPU / frequency / 2 / 128 - 1;
+            prescalarbits = 0b101;
+          }
+
+          if (ocr > 255)
+          {
+            ocr = F_CPU / frequency / 2 / 256 - 1;
+            prescalarbits = _timer == 0 ? 0b100 : 0b110;
+            if (ocr > 255)
+            {
+              // can't do any better than /1024
+              ocr = F_CPU / frequency / 2 / 1024 - 1;
+              prescalarbits = _timer == 0 ? 0b101 : 0b111;
+            }
+          }
+        }
+      }
+
+#if !defined(__AVR_ATmega8__)
+      if (_timer == 0)
+        TCCR0B = prescalarbits;
+      else
+#endif
+        TCCR2B = prescalarbits;
+    }
+    else
+    {
+      // two choices for the 16 bit timers: ck/1 or ck/64
+      ocr = F_CPU / frequency / 2 - 1;
+
+      prescalarbits = 0b001;
+      if (ocr > 0xffff)
+      {
+        ocr = F_CPU / frequency / 2 / 64 - 1;
+        prescalarbits = 0b011;
+      }
+
+      if (_timer == 1)
+        TCCR1B = (TCCR1B & 0b11111000) | prescalarbits;
+#if defined(__AVR_ATmega1280__)
+      else if (_timer == 3)
+        TCCR3B = (TCCR3B & 0b11111000) | prescalarbits;
+      else if (_timer == 4)
+        TCCR4B = (TCCR4B & 0b11111000) | prescalarbits;
+      else if (_timer == 5)
+        TCCR5B = (TCCR5B & 0b11111000) | prescalarbits;
+#endif
+
+    }
+    
+
+    // Calculate the toggle count
+    if (duration > 0)
+    {
+      toggle_count = 2 * frequency * duration / 1000;
+    }
+    else
+    {
+      toggle_count = -1;
+    }
+
+    // Set the OCR for the given timer,
+    // set the toggle count,
+    // then turn on the interrupts
+    switch (_timer)
+    {
+
+#if !defined(__AVR_ATmega8__)
+      case 0:
+        OCR0A = ocr;
+        timer0_toggle_count = toggle_count;
+        bitWrite(TIMSK0, OCIE0A, 1);
+        break;
+#endif
+
+      case 1:
+        OCR1A = ocr;
+        timer1_toggle_count = toggle_count;
+        bitWrite(TIMSK1, OCIE1A, 1);
+        break;
+      case 2:
+        OCR2A = ocr;
+        timer2_toggle_count = toggle_count;
+        bitWrite(TIMSK2, OCIE2A, 1);
+        break;
+
+#if defined(__AVR_ATmega1280__)
+      case 3:
+        OCR3A = ocr;
+        timer3_toggle_count = toggle_count;
+        bitWrite(TIMSK3, OCIE3A, 1);
+        break;
+      case 4:
+        OCR4A = ocr;
+        timer4_toggle_count = toggle_count;
+        bitWrite(TIMSK4, OCIE4A, 1);
+        break;
+      case 5:
+        OCR5A = ocr;
+        timer5_toggle_count = toggle_count;
+        bitWrite(TIMSK5, OCIE5A, 1);
+        break;
+#endif
+
+    }
+  }
+}
+
+
+void noTone(uint8_t _pin)
+{
+  int8_t _timer = -1;
+  
+  for (int i = 0; i < AVAILABLE_TONE_PINS; i++) {
+    if (tone_pins[i] == _pin) {
+      _timer = pgm_read_byte(tone_pin_to_timer_PGM + i);
+      tone_pins[i] = 255;
+    }
+  }
+  
+  switch (_timer)
+  {
+#if defined(__AVR_ATmega8__)
+    case 1:
+      bitWrite(TIMSK1, OCIE1A, 0);
+      break;
+    case 2:
+      bitWrite(TIMSK2, OCIE2A, 0);
+      break;
+
+#else
+    case 0:
+      TIMSK0 = 0;
+      break;
+    case 1:
+      TIMSK1 = 0;
+      break;
+    case 2:
+      TIMSK2 = 0;
+      break;
+#endif
+
+#if defined(__AVR_ATmega1280__)
+    case 3:
+      TIMSK3 = 0;
+      break;
+    case 4:
+      TIMSK4 = 0;
+      break;
+    case 5:
+      TIMSK5 = 0;
+      break;
+#endif
+  }
+
+  digitalWrite(_pin, 0);
+}
+
+#if 0
+#if !defined(__AVR_ATmega8__)
+ISR(TIMER0_COMPA_vect)
+{
+  if (timer0_toggle_count != 0)
+  {
+    // toggle the pin
+    *timer0_pin_port ^= timer0_pin_mask;
+
+    if (timer0_toggle_count > 0)
+      timer0_toggle_count--;
+  }
+  else
+  {
+    TIMSK0 = 0;   // disable the interrupt
+    *timer0_pin_port &= ~(timer0_pin_mask);  // keep pin low after stop
+  }
+}
+#endif
+
+
+ISR(TIMER1_COMPA_vect)
+{
+  if (timer1_toggle_count != 0)
+  {
+    // toggle the pin
+    *timer1_pin_port ^= timer1_pin_mask;
+
+    if (timer1_toggle_count > 0)
+      timer1_toggle_count--;
+  }
+  else
+  {
+    TIMSK1 = 0;   // disable the interrupt
+    *timer1_pin_port &= ~(timer1_pin_mask);  // keep pin low after stop
+  }
+}
+#endif
+
+
+ISR(TIMER2_COMPA_vect)
+{
+
+  if (timer2_toggle_count != 0)
+  {
+    // toggle the pin
+    *timer2_pin_port ^= timer2_pin_mask;
+
+    if (timer2_toggle_count > 0)
+      timer2_toggle_count--;
+  }
+  else
+  {
+    TIMSK2 = 0;   // disable the interrupt
+    *timer2_pin_port &= ~(timer2_pin_mask);  // keep pin low after stop
+  }
+}
+
+
+
+//#if defined(__AVR_ATmega1280__)
+#if 0
+
+ISR(TIMER3_COMPA_vect)
+{
+  if (timer3_toggle_count != 0)
+  {
+    // toggle the pin
+    *timer3_pin_port ^= timer3_pin_mask;
+
+    if (timer3_toggle_count > 0)
+      timer3_toggle_count--;
+  }
+  else
+  {
+    TIMSK3 = 0;   // disable the interrupt
+    *timer3_pin_port &= ~(timer3_pin_mask);  // keep pin low after stop
+  }
+}
+
+ISR(TIMER4_COMPA_vect)
+{
+  if (timer4_toggle_count != 0)
+  {
+    // toggle the pin
+    *timer4_pin_port ^= timer4_pin_mask;
+
+    if (timer4_toggle_count > 0)
+      timer4_toggle_count--;
+  }
+  else
+  {
+    TIMSK4 = 0;   // disable the interrupt
+    *timer4_pin_port &= ~(timer4_pin_mask);  // keep pin low after stop
+  }
+}
+
+ISR(TIMER5_COMPA_vect)
+{
+  if (timer5_toggle_count != 0)
+  {
+    // toggle the pin
+    *timer5_pin_port ^= timer5_pin_mask;
+
+    if (timer5_toggle_count > 0)
+      timer5_toggle_count--;
+  }
+  else
+  {
+    TIMSK5 = 0;   // disable the interrupt
+    *timer5_pin_port &= ~(timer5_pin_mask);  // keep pin low after stop
+  }
+}
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/WConstants.h

@@ -0,0 +1 @@
+#include "wiring.h"

arduino-0018-linux/hardware/arduino/cores/arduino/WInterrupts.c

@@ -0,0 +1,215 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Wiring project - http://wiring.uniandes.edu.co
+
+  Copyright (c) 2004-05 Hernando Barragan
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+  
+  Modified 24 November 2006 by David A. Mellis
+*/
+
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <stdio.h>
+
+#include "WConstants.h"
+#include "wiring_private.h"
+
+volatile static voidFuncPtr intFunc[EXTERNAL_NUM_INTERRUPTS];
+// volatile static voidFuncPtr twiIntFunc;
+
+#if defined(__AVR_ATmega8__)
+#define EICRA MCUCR
+#define EIMSK GICR
+#endif
+
+void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) {
+  if(interruptNum < EXTERNAL_NUM_INTERRUPTS) {
+    intFunc[interruptNum] = userFunc;
+    
+    // Configure the interrupt mode (trigger on low input, any change, rising
+    // edge, or falling edge).  The mode constants were chosen to correspond
+    // to the configuration bits in the hardware register, so we simply shift
+    // the mode into place.
+      
+    // Enable the interrupt.
+      
+    switch (interruptNum) {
+#if defined(__AVR_ATmega1280__)
+    case 2:
+      EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
+      EIMSK |= (1 << INT0);
+      break;
+    case 3:
+      EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
+      EIMSK |= (1 << INT1);
+      break;
+    case 4:
+      EICRA = (EICRA & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20);
+      EIMSK |= (1 << INT2);
+      break;
+    case 5:
+      EICRA = (EICRA & ~((1 << ISC30) | (1 << ISC31))) | (mode << ISC30);
+      EIMSK |= (1 << INT3);
+      break;
+    case 0:
+      EICRB = (EICRB & ~((1 << ISC40) | (1 << ISC41))) | (mode << ISC40);
+      EIMSK |= (1 << INT4);
+      break;
+    case 1:
+      EICRB = (EICRB & ~((1 << ISC50) | (1 << ISC51))) | (mode << ISC50);
+      EIMSK |= (1 << INT5);
+      break;
+    case 6:
+      EICRB = (EICRB & ~((1 << ISC60) | (1 << ISC61))) | (mode << ISC60);
+      EIMSK |= (1 << INT6);
+      break;
+    case 7:
+      EICRB = (EICRB & ~((1 << ISC70) | (1 << ISC71))) | (mode << ISC70);
+      EIMSK |= (1 << INT7);
+      break;
+#else
+    case 0:
+      EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
+      EIMSK |= (1 << INT0);
+      break;
+    case 1:
+      EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
+      EIMSK |= (1 << INT1);
+      break;
+#endif
+    }
+  }
+}
+
+void detachInterrupt(uint8_t interruptNum) {
+  if(interruptNum < EXTERNAL_NUM_INTERRUPTS) {
+    // Disable the interrupt.  (We can't assume that interruptNum is equal
+    // to the number of the EIMSK bit to clear, as this isn't true on the 
+    // ATmega8.  There, INT0 is 6 and INT1 is 7.)
+    switch (interruptNum) {
+#if defined(__AVR_ATmega1280__)
+    case 2:
+      EIMSK &= ~(1 << INT0);
+      break;
+    case 3:
+      EIMSK &= ~(1 << INT1);
+      break;
+    case 4:
+      EIMSK &= ~(1 << INT2);
+      break;
+    case 5:
+      EIMSK &= ~(1 << INT3);
+      break;
+    case 0:
+      EIMSK &= ~(1 << INT4);
+      break;
+    case 1:
+      EIMSK &= ~(1 << INT5);
+      break;
+    case 6:
+      EIMSK &= ~(1 << INT6);
+      break;
+    case 7:
+      EIMSK &= ~(1 << INT7);
+      break;
+#else
+    case 0:
+      EIMSK &= ~(1 << INT0);
+      break;
+    case 1:
+      EIMSK &= ~(1 << INT1);
+      break;
+#endif
+    }
+      
+    intFunc[interruptNum] = 0;
+  }
+}
+
+/*
+void attachInterruptTwi(void (*userFunc)(void) ) {
+  twiIntFunc = userFunc;
+}
+*/
+
+#if defined(__AVR_ATmega1280__)
+
+SIGNAL(INT0_vect) {
+  if(intFunc[EXTERNAL_INT_2])
+    intFunc[EXTERNAL_INT_2]();
+}
+
+SIGNAL(INT1_vect) {
+  if(intFunc[EXTERNAL_INT_3])
+    intFunc[EXTERNAL_INT_3]();
+}
+
+SIGNAL(INT2_vect) {
+  if(intFunc[EXTERNAL_INT_4])
+    intFunc[EXTERNAL_INT_4]();
+}
+
+SIGNAL(INT3_vect) {
+  if(intFunc[EXTERNAL_INT_5])
+    intFunc[EXTERNAL_INT_5]();
+}
+
+SIGNAL(INT4_vect) {
+  if(intFunc[EXTERNAL_INT_0])
+    intFunc[EXTERNAL_INT_0]();
+}
+
+SIGNAL(INT5_vect) {
+  if(intFunc[EXTERNAL_INT_1])
+    intFunc[EXTERNAL_INT_1]();
+}
+
+SIGNAL(INT6_vect) {
+  if(intFunc[EXTERNAL_INT_6])
+    intFunc[EXTERNAL_INT_6]();
+}
+
+SIGNAL(INT7_vect) {
+  if(intFunc[EXTERNAL_INT_7])
+    intFunc[EXTERNAL_INT_7]();
+}
+
+#else
+
+SIGNAL(INT0_vect) {
+  if(intFunc[EXTERNAL_INT_0])
+    intFunc[EXTERNAL_INT_0]();
+}
+
+SIGNAL(INT1_vect) {
+  if(intFunc[EXTERNAL_INT_1])
+    intFunc[EXTERNAL_INT_1]();
+}
+
+#endif
+
+/*
+SIGNAL(SIG_2WIRE_SERIAL) {
+  if(twiIntFunc)
+    twiIntFunc();
+}
+*/
+

arduino-0018-linux/hardware/arduino/cores/arduino/WMath.cpp

@@ -0,0 +1,60 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Wiring project - http://wiring.org.co
+  Copyright (c) 2004-06 Hernando Barragan
+  Modified 13 August 2006, David A. Mellis for Arduino - http://www.arduino.cc/
+  
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+  
+  $Id$
+*/
+
+extern "C" {
+  #include "stdlib.h"
+}
+
+void randomSeed(unsigned int seed)
+{
+  if (seed != 0) {
+    srandom(seed);
+  }
+}
+
+long random(long howbig)
+{
+  if (howbig == 0) {
+    return 0;
+  }
+  return random() % howbig;
+}
+
+long random(long howsmall, long howbig)
+{
+  if (howsmall >= howbig) {
+    return howsmall;
+  }
+  long diff = howbig - howsmall;
+  return random(diff) + howsmall;
+}
+
+long map(long x, long in_min, long in_max, long out_min, long out_max)
+{
+  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+unsigned int makeWord(unsigned int w) { return w; }
+unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8) | l; }

arduino-0018-linux/hardware/arduino/cores/arduino/WProgram.h

@@ -0,0 +1,32 @@
+#ifndef WProgram_h
+#define WProgram_h
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <avr/interrupt.h>
+
+#include "wiring.h"
+
+#ifdef __cplusplus
+#include "HardwareSerial.h"
+
+uint16_t makeWord(uint16_t w);
+uint16_t makeWord(byte h, byte l);
+
+#define word(...) makeWord(__VA_ARGS__)
+
+unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
+
+void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);
+void noTone(uint8_t _pin);
+
+// WMath prototypes
+long random(long);
+long random(long, long);
+void randomSeed(unsigned int);
+long map(long, long, long, long, long);
+#endif
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/binary.h

@@ -0,0 +1,515 @@
+#ifndef Binary_h
+#define Binary_h
+
+#define B0 0
+#define B00 0
+#define B000 0
+#define B0000 0
+#define B00000 0
+#define B000000 0
+#define B0000000 0
+#define B00000000 0
+#define B1 1
+#define B01 1
+#define B001 1
+#define B0001 1
+#define B00001 1
+#define B000001 1
+#define B0000001 1
+#define B00000001 1
+#define B10 2
+#define B010 2
+#define B0010 2
+#define B00010 2
+#define B000010 2
+#define B0000010 2
+#define B00000010 2
+#define B11 3
+#define B011 3
+#define B0011 3
+#define B00011 3
+#define B000011 3
+#define B0000011 3
+#define B00000011 3
+#define B100 4
+#define B0100 4
+#define B00100 4
+#define B000100 4
+#define B0000100 4
+#define B00000100 4
+#define B101 5
+#define B0101 5
+#define B00101 5
+#define B000101 5
+#define B0000101 5
+#define B00000101 5
+#define B110 6
+#define B0110 6
+#define B00110 6
+#define B000110 6
+#define B0000110 6
+#define B00000110 6
+#define B111 7
+#define B0111 7
+#define B00111 7
+#define B000111 7
+#define B0000111 7
+#define B00000111 7
+#define B1000 8
+#define B01000 8
+#define B001000 8
+#define B0001000 8
+#define B00001000 8
+#define B1001 9
+#define B01001 9
+#define B001001 9
+#define B0001001 9
+#define B00001001 9
+#define B1010 10
+#define B01010 10
+#define B001010 10
+#define B0001010 10
+#define B00001010 10
+#define B1011 11
+#define B01011 11
+#define B001011 11
+#define B0001011 11
+#define B00001011 11
+#define B1100 12
+#define B01100 12
+#define B001100 12
+#define B0001100 12
+#define B00001100 12
+#define B1101 13
+#define B01101 13
+#define B001101 13
+#define B0001101 13
+#define B00001101 13
+#define B1110 14
+#define B01110 14
+#define B001110 14
+#define B0001110 14
+#define B00001110 14
+#define B1111 15
+#define B01111 15
+#define B001111 15
+#define B0001111 15
+#define B00001111 15
+#define B10000 16
+#define B010000 16
+#define B0010000 16
+#define B00010000 16
+#define B10001 17
+#define B010001 17
+#define B0010001 17
+#define B00010001 17
+#define B10010 18
+#define B010010 18
+#define B0010010 18
+#define B00010010 18
+#define B10011 19
+#define B010011 19
+#define B0010011 19
+#define B00010011 19
+#define B10100 20
+#define B010100 20
+#define B0010100 20
+#define B00010100 20
+#define B10101 21
+#define B010101 21
+#define B0010101 21
+#define B00010101 21
+#define B10110 22
+#define B010110 22
+#define B0010110 22
+#define B00010110 22
+#define B10111 23
+#define B010111 23
+#define B0010111 23
+#define B00010111 23
+#define B11000 24
+#define B011000 24
+#define B0011000 24
+#define B00011000 24
+#define B11001 25
+#define B011001 25
+#define B0011001 25
+#define B00011001 25
+#define B11010 26
+#define B011010 26
+#define B0011010 26
+#define B00011010 26
+#define B11011 27
+#define B011011 27
+#define B0011011 27
+#define B00011011 27
+#define B11100 28
+#define B011100 28
+#define B0011100 28
+#define B00011100 28
+#define B11101 29
+#define B011101 29
+#define B0011101 29
+#define B00011101 29
+#define B11110 30
+#define B011110 30
+#define B0011110 30
+#define B00011110 30
+#define B11111 31
+#define B011111 31
+#define B0011111 31
+#define B00011111 31
+#define B100000 32
+#define B0100000 32
+#define B00100000 32
+#define B100001 33
+#define B0100001 33
+#define B00100001 33
+#define B100010 34
+#define B0100010 34
+#define B00100010 34
+#define B100011 35
+#define B0100011 35
+#define B00100011 35
+#define B100100 36
+#define B0100100 36
+#define B00100100 36
+#define B100101 37
+#define B0100101 37
+#define B00100101 37
+#define B100110 38
+#define B0100110 38
+#define B00100110 38
+#define B100111 39
+#define B0100111 39
+#define B00100111 39
+#define B101000 40
+#define B0101000 40
+#define B00101000 40
+#define B101001 41
+#define B0101001 41
+#define B00101001 41
+#define B101010 42
+#define B0101010 42
+#define B00101010 42
+#define B101011 43
+#define B0101011 43
+#define B00101011 43
+#define B101100 44
+#define B0101100 44
+#define B00101100 44
+#define B101101 45
+#define B0101101 45
+#define B00101101 45
+#define B101110 46
+#define B0101110 46
+#define B00101110 46
+#define B101111 47
+#define B0101111 47
+#define B00101111 47
+#define B110000 48
+#define B0110000 48
+#define B00110000 48
+#define B110001 49
+#define B0110001 49
+#define B00110001 49
+#define B110010 50
+#define B0110010 50
+#define B00110010 50
+#define B110011 51
+#define B0110011 51
+#define B00110011 51
+#define B110100 52
+#define B0110100 52
+#define B00110100 52
+#define B110101 53
+#define B0110101 53
+#define B00110101 53
+#define B110110 54
+#define B0110110 54
+#define B00110110 54
+#define B110111 55
+#define B0110111 55
+#define B00110111 55
+#define B111000 56
+#define B0111000 56
+#define B00111000 56
+#define B111001 57
+#define B0111001 57
+#define B00111001 57
+#define B111010 58
+#define B0111010 58
+#define B00111010 58
+#define B111011 59
+#define B0111011 59
+#define B00111011 59
+#define B111100 60
+#define B0111100 60
+#define B00111100 60
+#define B111101 61
+#define B0111101 61
+#define B00111101 61
+#define B111110 62
+#define B0111110 62
+#define B00111110 62
+#define B111111 63
+#define B0111111 63
+#define B00111111 63
+#define B1000000 64
+#define B01000000 64
+#define B1000001 65
+#define B01000001 65
+#define B1000010 66
+#define B01000010 66
+#define B1000011 67
+#define B01000011 67
+#define B1000100 68
+#define B01000100 68
+#define B1000101 69
+#define B01000101 69
+#define B1000110 70
+#define B01000110 70
+#define B1000111 71
+#define B01000111 71
+#define B1001000 72
+#define B01001000 72
+#define B1001001 73
+#define B01001001 73
+#define B1001010 74
+#define B01001010 74
+#define B1001011 75
+#define B01001011 75
+#define B1001100 76
+#define B01001100 76
+#define B1001101 77
+#define B01001101 77
+#define B1001110 78
+#define B01001110 78
+#define B1001111 79
+#define B01001111 79
+#define B1010000 80
+#define B01010000 80
+#define B1010001 81
+#define B01010001 81
+#define B1010010 82
+#define B01010010 82
+#define B1010011 83
+#define B01010011 83
+#define B1010100 84
+#define B01010100 84
+#define B1010101 85
+#define B01010101 85
+#define B1010110 86
+#define B01010110 86
+#define B1010111 87
+#define B01010111 87
+#define B1011000 88
+#define B01011000 88
+#define B1011001 89
+#define B01011001 89
+#define B1011010 90
+#define B01011010 90
+#define B1011011 91
+#define B01011011 91
+#define B1011100 92
+#define B01011100 92
+#define B1011101 93
+#define B01011101 93
+#define B1011110 94
+#define B01011110 94
+#define B1011111 95
+#define B01011111 95
+#define B1100000 96
+#define B01100000 96
+#define B1100001 97
+#define B01100001 97
+#define B1100010 98
+#define B01100010 98
+#define B1100011 99
+#define B01100011 99
+#define B1100100 100
+#define B01100100 100
+#define B1100101 101
+#define B01100101 101
+#define B1100110 102
+#define B01100110 102
+#define B1100111 103
+#define B01100111 103
+#define B1101000 104
+#define B01101000 104
+#define B1101001 105
+#define B01101001 105
+#define B1101010 106
+#define B01101010 106
+#define B1101011 107
+#define B01101011 107
+#define B1101100 108
+#define B01101100 108
+#define B1101101 109
+#define B01101101 109
+#define B1101110 110
+#define B01101110 110
+#define B1101111 111
+#define B01101111 111
+#define B1110000 112
+#define B01110000 112
+#define B1110001 113
+#define B01110001 113
+#define B1110010 114
+#define B01110010 114
+#define B1110011 115
+#define B01110011 115
+#define B1110100 116
+#define B01110100 116
+#define B1110101 117
+#define B01110101 117
+#define B1110110 118
+#define B01110110 118
+#define B1110111 119
+#define B01110111 119
+#define B1111000 120
+#define B01111000 120
+#define B1111001 121
+#define B01111001 121
+#define B1111010 122
+#define B01111010 122
+#define B1111011 123
+#define B01111011 123
+#define B1111100 124
+#define B01111100 124
+#define B1111101 125
+#define B01111101 125
+#define B1111110 126
+#define B01111110 126
+#define B1111111 127
+#define B01111111 127
+#define B10000000 128
+#define B10000001 129
+#define B10000010 130
+#define B10000011 131
+#define B10000100 132
+#define B10000101 133
+#define B10000110 134
+#define B10000111 135
+#define B10001000 136
+#define B10001001 137
+#define B10001010 138
+#define B10001011 139
+#define B10001100 140
+#define B10001101 141
+#define B10001110 142
+#define B10001111 143
+#define B10010000 144
+#define B10010001 145
+#define B10010010 146
+#define B10010011 147
+#define B10010100 148
+#define B10010101 149
+#define B10010110 150
+#define B10010111 151
+#define B10011000 152
+#define B10011001 153
+#define B10011010 154
+#define B10011011 155
+#define B10011100 156
+#define B10011101 157
+#define B10011110 158
+#define B10011111 159
+#define B10100000 160
+#define B10100001 161
+#define B10100010 162
+#define B10100011 163
+#define B10100100 164
+#define B10100101 165
+#define B10100110 166
+#define B10100111 167
+#define B10101000 168
+#define B10101001 169
+#define B10101010 170
+#define B10101011 171
+#define B10101100 172
+#define B10101101 173
+#define B10101110 174
+#define B10101111 175
+#define B10110000 176
+#define B10110001 177
+#define B10110010 178
+#define B10110011 179
+#define B10110100 180
+#define B10110101 181
+#define B10110110 182
+#define B10110111 183
+#define B10111000 184
+#define B10111001 185
+#define B10111010 186
+#define B10111011 187
+#define B10111100 188
+#define B10111101 189
+#define B10111110 190
+#define B10111111 191
+#define B11000000 192
+#define B11000001 193
+#define B11000010 194
+#define B11000011 195
+#define B11000100 196
+#define B11000101 197
+#define B11000110 198
+#define B11000111 199
+#define B11001000 200
+#define B11001001 201
+#define B11001010 202
+#define B11001011 203
+#define B11001100 204
+#define B11001101 205
+#define B11001110 206
+#define B11001111 207
+#define B11010000 208
+#define B11010001 209
+#define B11010010 210
+#define B11010011 211
+#define B11010100 212
+#define B11010101 213
+#define B11010110 214
+#define B11010111 215
+#define B11011000 216
+#define B11011001 217
+#define B11011010 218
+#define B11011011 219
+#define B11011100 220
+#define B11011101 221
+#define B11011110 222
+#define B11011111 223
+#define B11100000 224
+#define B11100001 225
+#define B11100010 226
+#define B11100011 227
+#define B11100100 228
+#define B11100101 229
+#define B11100110 230
+#define B11100111 231
+#define B11101000 232
+#define B11101001 233
+#define B11101010 234
+#define B11101011 235
+#define B11101100 236
+#define B11101101 237
+#define B11101110 238
+#define B11101111 239
+#define B11110000 240
+#define B11110001 241
+#define B11110010 242
+#define B11110011 243
+#define B11110100 244
+#define B11110101 245
+#define B11110110 246
+#define B11110111 247
+#define B11111000 248
+#define B11111001 249
+#define B11111010 250
+#define B11111011 251
+#define B11111100 252
+#define B11111101 253
+#define B11111110 254
+#define B11111111 255
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/main.cpp

@@ -0,0 +1,14 @@
+#include <WProgram.h>
+
+int main(void)
+{
+	init();
+
+	setup();
+    
+	for (;;)
+		loop();
+        
+	return 0;
+}
+

arduino-0018-linux/hardware/arduino/cores/arduino/pins_arduino.c

@@ -0,0 +1,469 @@
+/*
+  pins_arduino.c - pin definitions for the Arduino board
+  Part of Arduino / Wiring Lite
+
+  Copyright (c) 2005 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: pins_arduino.c 804 2009-12-18 16:05:52Z dmellis $
+*/
+
+#include <avr/io.h>
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+// On the Arduino board, digital pins are also used
+// for the analog output (software PWM).  Analog input
+// pins are a separate set.
+
+// ATMEL ATMEGA8 & 168 / ARDUINO
+//
+//                  +-\/-+
+//            PC6  1|    |28  PC5 (AI 5)
+//      (D 0) PD0  2|    |27  PC4 (AI 4)
+//      (D 1) PD1  3|    |26  PC3 (AI 3)
+//      (D 2) PD2  4|    |25  PC2 (AI 2)
+// PWM+ (D 3) PD3  5|    |24  PC1 (AI 1)
+//      (D 4) PD4  6|    |23  PC0 (AI 0)
+//            VCC  7|    |22  GND
+//            GND  8|    |21  AREF
+//            PB6  9|    |20  AVCC
+//            PB7 10|    |19  PB5 (D 13)
+// PWM+ (D 5) PD5 11|    |18  PB4 (D 12)
+// PWM+ (D 6) PD6 12|    |17  PB3 (D 11) PWM
+//      (D 7) PD7 13|    |16  PB2 (D 10) PWM
+//      (D 8) PB0 14|    |15  PB1 (D 9) PWM
+//                  +----+
+//
+// (PWM+ indicates the additional PWM pins on the ATmega168.)
+
+// ATMEL ATMEGA1280 / ARDUINO
+//
+// 0-7 PE0-PE7   works
+// 8-13 PB0-PB5  works
+// 14-21 PA0-PA7 works 
+// 22-29 PH0-PH7 works
+// 30-35 PG5-PG0 works
+// 36-43 PC7-PC0 works
+// 44-51 PJ7-PJ0 works
+// 52-59 PL7-PL0 works
+// 60-67 PD7-PD0 works
+// A0-A7 PF0-PF7
+// A8-A15 PK0-PK7
+
+#define PA 1
+#define PB 2
+#define PC 3
+#define PD 4
+#define PE 5
+#define PF 6
+#define PG 7
+#define PH 8
+#define PJ 10
+#define PK 11
+#define PL 12
+
+#define REPEAT8(x) x, x, x, x, x, x, x, x
+#define BV0TO7 _BV(0), _BV(1), _BV(2), _BV(3), _BV(4), _BV(5), _BV(6), _BV(7)
+#define BV7TO0 _BV(7), _BV(6), _BV(5), _BV(4), _BV(3), _BV(2), _BV(1), _BV(0)
+
+
+#if defined(__AVR_ATmega1280__)
+const uint16_t PROGMEM port_to_mode_PGM[] = {
+	NOT_A_PORT,
+	&DDRA,
+	&DDRB,
+	&DDRC,
+	&DDRD,
+	&DDRE,
+	&DDRF,
+	&DDRG,
+	&DDRH,
+	NOT_A_PORT,
+	&DDRJ,
+	&DDRK,
+	&DDRL,
+};
+
+const uint16_t PROGMEM port_to_output_PGM[] = {
+	NOT_A_PORT,
+	&PORTA,
+	&PORTB,
+	&PORTC,
+	&PORTD,
+	&PORTE,
+	&PORTF,
+	&PORTG,
+	&PORTH,
+	NOT_A_PORT,
+	&PORTJ,
+	&PORTK,
+	&PORTL,
+};
+
+const uint16_t PROGMEM port_to_input_PGM[] = {
+	NOT_A_PIN,
+	&PINA,
+	&PINB,
+	&PINC,
+	&PIND,
+	&PINE,
+	&PINF,
+	&PING,
+	&PINH,
+	NOT_A_PIN,
+	&PINJ,
+	&PINK,
+	&PINL,
+};
+
+const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
+	// PORTLIST		
+	// -------------------------------------------		
+	PE	, // PE 0 ** 0 ** USART0_RX	
+	PE	, // PE 1 ** 1 ** USART0_TX	
+	PE	, // PE 4 ** 2 ** PWM2	
+	PE	, // PE 5 ** 3 ** PWM3	
+	PG	, // PG 5 ** 4 ** PWM4	
+	PE	, // PE 3 ** 5 ** PWM5	
+	PH	, // PH 3 ** 6 ** PWM6	
+	PH	, // PH 4 ** 7 ** PWM7	
+	PH	, // PH 5 ** 8 ** PWM8	
+	PH	, // PH 6 ** 9 ** PWM9	
+	PB	, // PB 4 ** 10 ** PWM10	
+	PB	, // PB 5 ** 11 ** PWM11	
+	PB	, // PB 6 ** 12 ** PWM12	
+	PB	, // PB 7 ** 13 ** PWM13	
+	PJ	, // PJ 1 ** 14 ** USART3_TX	
+	PJ	, // PJ 0 ** 15 ** USART3_RX	
+	PH	, // PH 1 ** 16 ** USART2_TX	
+	PH	, // PH 0 ** 17 ** USART2_RX	
+	PD	, // PD 3 ** 18 ** USART1_TX	
+	PD	, // PD 2 ** 19 ** USART1_RX	
+	PD	, // PD 1 ** 20 ** I2C_SDA	
+	PD	, // PD 0 ** 21 ** I2C_SCL	
+	PA	, // PA 0 ** 22 ** D22	
+	PA	, // PA 1 ** 23 ** D23	
+	PA	, // PA 2 ** 24 ** D24	
+	PA	, // PA 3 ** 25 ** D25	
+	PA	, // PA 4 ** 26 ** D26	
+	PA	, // PA 5 ** 27 ** D27	
+	PA	, // PA 6 ** 28 ** D28	
+	PA	, // PA 7 ** 29 ** D29	
+	PC	, // PC 7 ** 30 ** D30	
+	PC	, // PC 6 ** 31 ** D31	
+	PC	, // PC 5 ** 32 ** D32	
+	PC	, // PC 4 ** 33 ** D33	
+	PC	, // PC 3 ** 34 ** D34	
+	PC	, // PC 2 ** 35 ** D35	
+	PC	, // PC 1 ** 36 ** D36	
+	PC	, // PC 0 ** 37 ** D37	
+	PD	, // PD 7 ** 38 ** D38	
+	PG	, // PG 2 ** 39 ** D39	
+	PG	, // PG 1 ** 40 ** D40	
+	PG	, // PG 0 ** 41 ** D41	
+	PL	, // PL 7 ** 42 ** D42	
+	PL	, // PL 6 ** 43 ** D43	
+	PL	, // PL 5 ** 44 ** D44	
+	PL	, // PL 4 ** 45 ** D45	
+	PL	, // PL 3 ** 46 ** D46	
+	PL	, // PL 2 ** 47 ** D47	
+	PL	, // PL 1 ** 48 ** D48	
+	PL	, // PL 0 ** 49 ** D49	
+	PB	, // PB 3 ** 50 ** SPI_MISO	
+	PB	, // PB 2 ** 51 ** SPI_MOSI	
+	PB	, // PB 1 ** 52 ** SPI_SCK	
+	PB	, // PB 0 ** 53 ** SPI_SS	
+	PF	, // PF 0 ** 54 ** A0	
+	PF	, // PF 1 ** 55 ** A1	
+	PF	, // PF 2 ** 56 ** A2	
+	PF	, // PF 3 ** 57 ** A3	
+	PF	, // PF 4 ** 58 ** A4	
+	PF	, // PF 5 ** 59 ** A5	
+	PF	, // PF 6 ** 60 ** A6	
+	PF	, // PF 7 ** 61 ** A7	
+	PK	, // PK 0 ** 62 ** A8	
+	PK	, // PK 1 ** 63 ** A9	
+	PK	, // PK 2 ** 64 ** A10	
+	PK	, // PK 3 ** 65 ** A11	
+	PK	, // PK 4 ** 66 ** A12	
+	PK	, // PK 5 ** 67 ** A13	
+	PK	, // PK 6 ** 68 ** A14	
+	PK	, // PK 7 ** 69 ** A15	
+};
+
+const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
+	// PIN IN PORT		
+	// -------------------------------------------		
+	_BV( 0 )	, // PE 0 ** 0 ** USART0_RX	
+	_BV( 1 )	, // PE 1 ** 1 ** USART0_TX	
+	_BV( 4 )	, // PE 4 ** 2 ** PWM2	
+	_BV( 5 )	, // PE 5 ** 3 ** PWM3	
+	_BV( 5 )	, // PG 5 ** 4 ** PWM4	
+	_BV( 3 )	, // PE 3 ** 5 ** PWM5	
+	_BV( 3 )	, // PH 3 ** 6 ** PWM6	
+	_BV( 4 )	, // PH 4 ** 7 ** PWM7	
+	_BV( 5 )	, // PH 5 ** 8 ** PWM8	
+	_BV( 6 )	, // PH 6 ** 9 ** PWM9	
+	_BV( 4 )	, // PB 4 ** 10 ** PWM10	
+	_BV( 5 )	, // PB 5 ** 11 ** PWM11	
+	_BV( 6 )	, // PB 6 ** 12 ** PWM12	
+	_BV( 7 )	, // PB 7 ** 13 ** PWM13	
+	_BV( 1 )	, // PJ 1 ** 14 ** USART3_TX	
+	_BV( 0 )	, // PJ 0 ** 15 ** USART3_RX	
+	_BV( 1 )	, // PH 1 ** 16 ** USART2_TX	
+	_BV( 0 )	, // PH 0 ** 17 ** USART2_RX	
+	_BV( 3 )	, // PD 3 ** 18 ** USART1_TX	
+	_BV( 2 )	, // PD 2 ** 19 ** USART1_RX	
+	_BV( 1 )	, // PD 1 ** 20 ** I2C_SDA	
+	_BV( 0 )	, // PD 0 ** 21 ** I2C_SCL	
+	_BV( 0 )	, // PA 0 ** 22 ** D22	
+	_BV( 1 )	, // PA 1 ** 23 ** D23	
+	_BV( 2 )	, // PA 2 ** 24 ** D24	
+	_BV( 3 )	, // PA 3 ** 25 ** D25	
+	_BV( 4 )	, // PA 4 ** 26 ** D26	
+	_BV( 5 )	, // PA 5 ** 27 ** D27	
+	_BV( 6 )	, // PA 6 ** 28 ** D28	
+	_BV( 7 )	, // PA 7 ** 29 ** D29	
+	_BV( 7 )	, // PC 7 ** 30 ** D30	
+	_BV( 6 )	, // PC 6 ** 31 ** D31	
+	_BV( 5 )	, // PC 5 ** 32 ** D32	
+	_BV( 4 )	, // PC 4 ** 33 ** D33	
+	_BV( 3 )	, // PC 3 ** 34 ** D34	
+	_BV( 2 )	, // PC 2 ** 35 ** D35	
+	_BV( 1 )	, // PC 1 ** 36 ** D36	
+	_BV( 0 )	, // PC 0 ** 37 ** D37	
+	_BV( 7 )	, // PD 7 ** 38 ** D38	
+	_BV( 2 )	, // PG 2 ** 39 ** D39	
+	_BV( 1 )	, // PG 1 ** 40 ** D40	
+	_BV( 0 )	, // PG 0 ** 41 ** D41	
+	_BV( 7 )	, // PL 7 ** 42 ** D42	
+	_BV( 6 )	, // PL 6 ** 43 ** D43	
+	_BV( 5 )	, // PL 5 ** 44 ** D44	
+	_BV( 4 )	, // PL 4 ** 45 ** D45	
+	_BV( 3 )	, // PL 3 ** 46 ** D46	
+	_BV( 2 )	, // PL 2 ** 47 ** D47	
+	_BV( 1 )	, // PL 1 ** 48 ** D48	
+	_BV( 0 )	, // PL 0 ** 49 ** D49	
+	_BV( 3 )	, // PB 3 ** 50 ** SPI_MISO	
+	_BV( 2 )	, // PB 2 ** 51 ** SPI_MOSI	
+	_BV( 1 )	, // PB 1 ** 52 ** SPI_SCK	
+	_BV( 0 )	, // PB 0 ** 53 ** SPI_SS	
+	_BV( 0 )	, // PF 0 ** 54 ** A0	
+	_BV( 1 )	, // PF 1 ** 55 ** A1	
+	_BV( 2 )	, // PF 2 ** 56 ** A2	
+	_BV( 3 )	, // PF 3 ** 57 ** A3	
+	_BV( 4 )	, // PF 4 ** 58 ** A4	
+	_BV( 5 )	, // PF 5 ** 59 ** A5	
+	_BV( 6 )	, // PF 6 ** 60 ** A6	
+	_BV( 7 )	, // PF 7 ** 61 ** A7	
+	_BV( 0 )	, // PK 0 ** 62 ** A8	
+	_BV( 1 )	, // PK 1 ** 63 ** A9	
+	_BV( 2 )	, // PK 2 ** 64 ** A10	
+	_BV( 3 )	, // PK 3 ** 65 ** A11	
+	_BV( 4 )	, // PK 4 ** 66 ** A12	
+	_BV( 5 )	, // PK 5 ** 67 ** A13	
+	_BV( 6 )	, // PK 6 ** 68 ** A14	
+	_BV( 7 )	, // PK 7 ** 69 ** A15	
+};
+
+const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
+	// TIMERS		
+	// -------------------------------------------		
+	NOT_ON_TIMER	, // PE 0 ** 0 ** USART0_RX	
+	NOT_ON_TIMER	, // PE 1 ** 1 ** USART0_TX	
+	TIMER3B	, // PE 4 ** 2 ** PWM2	
+	TIMER3C	, // PE 5 ** 3 ** PWM3	
+	TIMER0B	, // PG 5 ** 4 ** PWM4	
+	TIMER3A	, // PE 3 ** 5 ** PWM5	
+	TIMER4A	, // PH 3 ** 6 ** PWM6	
+	TIMER4B	, // PH 4 ** 7 ** PWM7	
+	TIMER4C	, // PH 5 ** 8 ** PWM8	
+	TIMER2B	, // PH 6 ** 9 ** PWM9	
+	TIMER2A	, // PB 4 ** 10 ** PWM10	
+	TIMER1A	, // PB 5 ** 11 ** PWM11	
+	TIMER1B	, // PB 6 ** 12 ** PWM12	
+	TIMER0A	, // PB 7 ** 13 ** PWM13	
+	NOT_ON_TIMER	, // PJ 1 ** 14 ** USART3_TX	
+	NOT_ON_TIMER	, // PJ 0 ** 15 ** USART3_RX	
+	NOT_ON_TIMER	, // PH 1 ** 16 ** USART2_TX	
+	NOT_ON_TIMER	, // PH 0 ** 17 ** USART2_RX	
+	NOT_ON_TIMER	, // PD 3 ** 18 ** USART1_TX	
+	NOT_ON_TIMER	, // PD 2 ** 19 ** USART1_RX	
+	NOT_ON_TIMER	, // PD 1 ** 20 ** I2C_SDA	
+	NOT_ON_TIMER	, // PD 0 ** 21 ** I2C_SCL	
+	NOT_ON_TIMER	, // PA 0 ** 22 ** D22	
+	NOT_ON_TIMER	, // PA 1 ** 23 ** D23	
+	NOT_ON_TIMER	, // PA 2 ** 24 ** D24	
+	NOT_ON_TIMER	, // PA 3 ** 25 ** D25	
+	NOT_ON_TIMER	, // PA 4 ** 26 ** D26	
+	NOT_ON_TIMER	, // PA 5 ** 27 ** D27	
+	NOT_ON_TIMER	, // PA 6 ** 28 ** D28	
+	NOT_ON_TIMER	, // PA 7 ** 29 ** D29	
+	NOT_ON_TIMER	, // PC 7 ** 30 ** D30	
+	NOT_ON_TIMER	, // PC 6 ** 31 ** D31	
+	NOT_ON_TIMER	, // PC 5 ** 32 ** D32	
+	NOT_ON_TIMER	, // PC 4 ** 33 ** D33	
+	NOT_ON_TIMER	, // PC 3 ** 34 ** D34	
+	NOT_ON_TIMER	, // PC 2 ** 35 ** D35	
+	NOT_ON_TIMER	, // PC 1 ** 36 ** D36	
+	NOT_ON_TIMER	, // PC 0 ** 37 ** D37	
+	NOT_ON_TIMER	, // PD 7 ** 38 ** D38	
+	NOT_ON_TIMER	, // PG 2 ** 39 ** D39	
+	NOT_ON_TIMER	, // PG 1 ** 40 ** D40	
+	NOT_ON_TIMER	, // PG 0 ** 41 ** D41	
+	NOT_ON_TIMER	, // PL 7 ** 42 ** D42	
+	NOT_ON_TIMER	, // PL 6 ** 43 ** D43	
+	TIMER5C	, // PL 5 ** 44 ** D44	
+	TIMER5B	, // PL 4 ** 45 ** D45	
+	TIMER5A	, // PL 3 ** 46 ** D46	
+	NOT_ON_TIMER	, // PL 2 ** 47 ** D47	
+	NOT_ON_TIMER	, // PL 1 ** 48 ** D48	
+	NOT_ON_TIMER	, // PL 0 ** 49 ** D49	
+	NOT_ON_TIMER	, // PB 3 ** 50 ** SPI_MISO	
+	NOT_ON_TIMER	, // PB 2 ** 51 ** SPI_MOSI	
+	NOT_ON_TIMER	, // PB 1 ** 52 ** SPI_SCK	
+	NOT_ON_TIMER	, // PB 0 ** 53 ** SPI_SS	
+	NOT_ON_TIMER	, // PF 0 ** 54 ** A0	
+	NOT_ON_TIMER	, // PF 1 ** 55 ** A1	
+	NOT_ON_TIMER	, // PF 2 ** 56 ** A2	
+	NOT_ON_TIMER	, // PF 3 ** 57 ** A3	
+	NOT_ON_TIMER	, // PF 4 ** 58 ** A4	
+	NOT_ON_TIMER	, // PF 5 ** 59 ** A5	
+	NOT_ON_TIMER	, // PF 6 ** 60 ** A6	
+	NOT_ON_TIMER	, // PF 7 ** 61 ** A7	
+	NOT_ON_TIMER	, // PK 0 ** 62 ** A8	
+	NOT_ON_TIMER	, // PK 1 ** 63 ** A9	
+	NOT_ON_TIMER	, // PK 2 ** 64 ** A10	
+	NOT_ON_TIMER	, // PK 3 ** 65 ** A11	
+	NOT_ON_TIMER	, // PK 4 ** 66 ** A12	
+	NOT_ON_TIMER	, // PK 5 ** 67 ** A13	
+	NOT_ON_TIMER	, // PK 6 ** 68 ** A14	
+	NOT_ON_TIMER	, // PK 7 ** 69 ** A15	
+};
+#else
+// these arrays map port names (e.g. port B) to the
+// appropriate addresses for various functions (e.g. reading
+// and writing)
+const uint16_t PROGMEM port_to_mode_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	&DDRB,
+	&DDRC,
+	&DDRD,
+};
+
+const uint16_t PROGMEM port_to_output_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	&PORTB,
+	&PORTC,
+	&PORTD,
+};
+
+const uint16_t PROGMEM port_to_input_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	&PINB,
+	&PINC,
+	&PIND,
+};
+
+const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
+	PD, /* 0 */
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PB, /* 8 */
+	PB,
+	PB,
+	PB,
+	PB,
+	PB,
+	PC, /* 14 */
+	PC,
+	PC,
+	PC,
+	PC,
+	PC,
+};
+
+const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
+	_BV(0), /* 0, port D */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+	_BV(6),
+	_BV(7),
+	_BV(0), /* 8, port B */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+	_BV(0), /* 14, port C */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+};
+
+const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
+	NOT_ON_TIMER, /* 0 - port D */
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	// on the ATmega168, digital pin 3 has hardware pwm
+#if defined(__AVR_ATmega8__)
+	NOT_ON_TIMER,
+#else
+	TIMER2B,
+#endif
+	NOT_ON_TIMER,
+	// on the ATmega168, digital pins 5 and 6 have hardware pwm
+#if defined(__AVR_ATmega8__)
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+#else
+	TIMER0B,
+	TIMER0A,
+#endif
+	NOT_ON_TIMER,
+	NOT_ON_TIMER, /* 8 - port B */
+	TIMER1A,
+	TIMER1B,
+#if defined(__AVR_ATmega8__)
+	TIMER2,
+#else
+	TIMER2A,
+#endif
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER, /* 14 - port C */
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+};
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/pins_arduino.h

@@ -0,0 +1,76 @@
+/*
+  pins_arduino.h - Pin definition functions for Arduino
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2007 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.h 249 2007-02-03 16:52:51Z mellis $
+*/
+
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <avr/pgmspace.h>
+
+#define NOT_A_PIN 0
+#define NOT_A_PORT 0
+
+#define NOT_ON_TIMER 0
+#define TIMER0A 1
+#define TIMER0B 2
+#define TIMER1A 3
+#define TIMER1B 4
+#define TIMER2  5
+#define TIMER2A 6
+#define TIMER2B 7
+
+#define TIMER3A 8
+#define TIMER3B 9
+#define TIMER3C 10
+#define TIMER4A 11
+#define TIMER4B 12
+#define TIMER4C 13
+#define TIMER5A 14
+#define TIMER5B 15
+#define TIMER5C 16
+
+// On the ATmega1280, the addresses of some of the port registers are
+// greater than 255, so we can't store them in uint8_t's.
+extern const uint16_t PROGMEM port_to_mode_PGM[];
+extern const uint16_t PROGMEM port_to_input_PGM[];
+extern const uint16_t PROGMEM port_to_output_PGM[];
+
+extern const uint8_t PROGMEM digital_pin_to_port_PGM[];
+// extern const uint8_t PROGMEM digital_pin_to_bit_PGM[];
+extern const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[];
+extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
+
+// Get the bit location within the hardware port of the given virtual pin.
+// This comes from the pins_*.c file for the active board configuration.
+// 
+// These perform slightly better as macros compared to inline functions
+//
+#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) )
+#define digitalPinToBitMask(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM + (P) ) )
+#define digitalPinToTimer(P) ( pgm_read_byte( digital_pin_to_timer_PGM + (P) ) )
+#define analogInPinToBit(P) (P)
+#define portOutputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) )
+#define portInputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_input_PGM + (P))) )
+#define portModeRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_mode_PGM + (P))) )
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/wiring.c

@@ -0,0 +1,238 @@
+/*
+  wiring.c - Partial implementation of the Wiring API for the ATmega8.
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.c 808 2009-12-18 17:44:08Z dmellis $
+*/
+
+#include "wiring_private.h"
+
+// the prescaler is set so that timer0 ticks every 64 clock cycles, and the
+// the overflow handler is called every 256 ticks.
+#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
+
+// the whole number of milliseconds per timer0 overflow
+#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
+
+// the fractional number of milliseconds per timer0 overflow. we shift right
+// by three to fit these numbers into a byte. (for the clock speeds we care
+// about - 8 and 16 MHz - this doesn't lose precision.)
+#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
+#define FRACT_MAX (1000 >> 3)
+
+volatile unsigned long timer0_overflow_count = 0;
+volatile unsigned long timer0_millis = 0;
+static unsigned char timer0_fract = 0;
+
+SIGNAL(TIMER0_OVF_vect)
+{
+	// copy these to local variables so they can be stored in registers
+	// (volatile variables must be read from memory on every access)
+	unsigned long m = timer0_millis;
+	unsigned char f = timer0_fract;
+
+	m += MILLIS_INC;
+	f += FRACT_INC;
+	if (f >= FRACT_MAX) {
+		f -= FRACT_MAX;
+		m += 1;
+	}
+
+	timer0_fract = f;
+	timer0_millis = m;
+	timer0_overflow_count++;
+}
+
+unsigned long millis()
+{
+	unsigned long m;
+	uint8_t oldSREG = SREG;
+
+	// disable interrupts while we read timer0_millis or we might get an
+	// inconsistent value (e.g. in the middle of a write to timer0_millis)
+	cli();
+	m = timer0_millis;
+	SREG = oldSREG;
+
+	return m;
+}
+
+unsigned long micros() {
+	unsigned long m;
+	uint8_t oldSREG = SREG, t;
+	
+	cli();
+	m = timer0_overflow_count;
+	t = TCNT0;
+  
+#ifdef TIFR0
+	if ((TIFR0 & _BV(TOV0)) && (t < 255))
+		m++;
+#else
+	if ((TIFR & _BV(TOV0)) && (t < 255))
+		m++;
+#endif
+
+	SREG = oldSREG;
+	
+	return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
+}
+
+void delay(unsigned long ms)
+{
+	unsigned long start = millis();
+	
+	while (millis() - start <= ms)
+		;
+}
+
+/* Delay for the given number of microseconds.  Assumes a 8 or 16 MHz clock. */
+void delayMicroseconds(unsigned int us)
+{
+	// calling avrlib's delay_us() function with low values (e.g. 1 or
+	// 2 microseconds) gives delays longer than desired.
+	//delay_us(us);
+
+#if F_CPU >= 16000000L
+	// for the 16 MHz clock on most Arduino boards
+
+	// for a one-microsecond delay, simply return.  the overhead
+	// of the function call yields a delay of approximately 1 1/8 us.
+	if (--us == 0)
+		return;
+
+	// the following loop takes a quarter of a microsecond (4 cycles)
+	// per iteration, so execute it four times for each microsecond of
+	// delay requested.
+	us <<= 2;
+
+	// account for the time taken in the preceeding commands.
+	us -= 2;
+#else
+	// for the 8 MHz internal clock on the ATmega168
+
+	// for a one- or two-microsecond delay, simply return.  the overhead of
+	// the function calls takes more than two microseconds.  can't just
+	// subtract two, since us is unsigned; we'd overflow.
+	if (--us == 0)
+		return;
+	if (--us == 0)
+		return;
+
+	// the following loop takes half of a microsecond (4 cycles)
+	// per iteration, so execute it twice for each microsecond of
+	// delay requested.
+	us <<= 1;
+    
+	// partially compensate for the time taken by the preceeding commands.
+	// we can't subtract any more than this or we'd overflow w/ small delays.
+	us--;
+#endif
+
+	// busy wait
+	__asm__ __volatile__ (
+		"1: sbiw %0,1" "\n\t" // 2 cycles
+		"brne 1b" : "=w" (us) : "0" (us) // 2 cycles
+	);
+}
+
+void init()
+{
+	// this needs to be called before setup() or some functions won't
+	// work there
+	sei();
+	
+	// on the ATmega168, timer 0 is also used for fast hardware pwm
+	// (using phase-correct PWM would mean that timer 0 overflowed half as often
+	// resulting in different millis() behavior on the ATmega8 and ATmega168)
+#if !defined(__AVR_ATmega8__)
+	sbi(TCCR0A, WGM01);
+	sbi(TCCR0A, WGM00);
+#endif  
+	// set timer 0 prescale factor to 64
+#if defined(__AVR_ATmega8__)
+	sbi(TCCR0, CS01);
+	sbi(TCCR0, CS00);
+#else
+	sbi(TCCR0B, CS01);
+	sbi(TCCR0B, CS00);
+#endif
+	// enable timer 0 overflow interrupt
+#if defined(__AVR_ATmega8__)
+	sbi(TIMSK, TOIE0);
+#else
+	sbi(TIMSK0, TOIE0);
+#endif
+
+	// timers 1 and 2 are used for phase-correct hardware pwm
+	// this is better for motors as it ensures an even waveform
+	// note, however, that fast pwm mode can achieve a frequency of up
+	// 8 MHz (with a 16 MHz clock) at 50% duty cycle
+
+	// set timer 1 prescale factor to 64
+	sbi(TCCR1B, CS11);
+	sbi(TCCR1B, CS10);
+	// put timer 1 in 8-bit phase correct pwm mode
+	sbi(TCCR1A, WGM10);
+
+	// set timer 2 prescale factor to 64
+#if defined(__AVR_ATmega8__)
+	sbi(TCCR2, CS22);
+#else
+	sbi(TCCR2B, CS22);
+#endif
+	// configure timer 2 for phase correct pwm (8-bit)
+#if defined(__AVR_ATmega8__)
+	sbi(TCCR2, WGM20);
+#else
+	sbi(TCCR2A, WGM20);
+#endif
+
+#if defined(__AVR_ATmega1280__)
+	// set timer 3, 4, 5 prescale factor to 64
+	sbi(TCCR3B, CS31);	sbi(TCCR3B, CS30);
+	sbi(TCCR4B, CS41);	sbi(TCCR4B, CS40);
+	sbi(TCCR5B, CS51);	sbi(TCCR5B, CS50);
+	// put timer 3, 4, 5 in 8-bit phase correct pwm mode
+	sbi(TCCR3A, WGM30);
+	sbi(TCCR4A, WGM40);
+	sbi(TCCR5A, WGM50);
+#endif
+
+	// set a2d prescale factor to 128
+	// 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
+	// XXX: this will not work properly for other clock speeds, and
+	// this code should use F_CPU to determine the prescale factor.
+	sbi(ADCSRA, ADPS2);
+	sbi(ADCSRA, ADPS1);
+	sbi(ADCSRA, ADPS0);
+
+	// enable a2d conversions
+	sbi(ADCSRA, ADEN);
+
+	// the bootloader connects pins 0 and 1 to the USART; disconnect them
+	// here so they can be used as normal digital i/o; they will be
+	// reconnected in Serial.begin()
+#if defined(__AVR_ATmega8__)
+	UCSRB = 0;
+#else
+	UCSR0B = 0;
+#endif
+}

arduino-0018-linux/hardware/arduino/cores/arduino/wiring.h

@@ -0,0 +1,133 @@
+/*
+  wiring.h - Partial implementation of the Wiring API for the ATmega8.
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.h 804 2009-12-18 16:05:52Z dmellis $
+*/
+
+#ifndef Wiring_h
+#define Wiring_h
+
+#include <avr/io.h>
+#include "binary.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#define HIGH 0x1
+#define LOW  0x0
+
+#define INPUT 0x0
+#define OUTPUT 0x1
+
+#define true 0x1
+#define false 0x0
+
+#define PI 3.1415926535897932384626433832795
+#define HALF_PI 1.5707963267948966192313216916398
+#define TWO_PI 6.283185307179586476925286766559
+#define DEG_TO_RAD 0.017453292519943295769236907684886
+#define RAD_TO_DEG 57.295779513082320876798154814105
+
+#define SERIAL  0x0
+#define DISPLAY 0x1
+
+#define LSBFIRST 0
+#define MSBFIRST 1
+
+#define CHANGE 1
+#define FALLING 2
+#define RISING 3
+
+#define INTERNAL 3
+#define DEFAULT 1
+#define EXTERNAL 0
+
+// undefine stdlib's abs if encountered
+#ifdef abs
+#undef abs
+#endif
+
+#define min(a,b) ((a)<(b)?(a):(b))
+#define max(a,b) ((a)>(b)?(a):(b))
+#define abs(x) ((x)>0?(x):-(x))
+#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt)))
+#define round(x)     ((x)>=0?(long)((x)+0.5):(long)((x)-0.5))
+#define radians(deg) ((deg)*DEG_TO_RAD)
+#define degrees(rad) ((rad)*RAD_TO_DEG)
+#define sq(x) ((x)*(x))
+
+#define interrupts() sei()
+#define noInterrupts() cli()
+
+#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
+#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
+#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
+
+#define lowByte(w) ((uint8_t) ((w) & 0xff))
+#define highByte(w) ((uint8_t) ((w) >> 8))
+
+#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
+#define bitSet(value, bit) ((value) |= (1UL << (bit)))
+#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
+#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
+
+typedef unsigned int word;
+
+#define bit(b) (1UL << (b))
+
+typedef uint8_t boolean;
+typedef uint8_t byte;
+
+void init(void);
+
+void pinMode(uint8_t, uint8_t);
+void digitalWrite(uint8_t, uint8_t);
+int digitalRead(uint8_t);
+int analogRead(uint8_t);
+void analogReference(uint8_t mode);
+void analogWrite(uint8_t, int);
+
+void beginSerial(long);
+void serialWrite(unsigned char);
+int serialAvailable(void);
+int serialRead(void);
+void serialFlush(void);
+
+unsigned long millis(void);
+unsigned long micros(void);
+void delay(unsigned long);
+void delayMicroseconds(unsigned int us);
+unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);
+
+void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, byte val);
+
+void attachInterrupt(uint8_t, void (*)(void), int mode);
+void detachInterrupt(uint8_t);
+
+void setup(void);
+void loop(void);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/wiring_analog.c

@@ -0,0 +1,179 @@
+/*
+  wiring_analog.c - analog input and output
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
+*/
+
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+uint8_t analog_reference = DEFAULT;
+
+void analogReference(uint8_t mode)
+{
+	// can't actually set the register here because the default setting
+	// will connect AVCC and the AREF pin, which would cause a short if
+	// there's something connected to AREF.
+	analog_reference = mode;
+}
+
+int analogRead(uint8_t pin)
+{
+	uint8_t low, high;
+
+	// set the analog reference (high two bits of ADMUX) and select the
+	// channel (low 4 bits).  this also sets ADLAR (left-adjust result)
+	// to 0 (the default).
+	ADMUX = (analog_reference << 6) | (pin & 0x07);
+  
+#if defined(__AVR_ATmega1280__)
+	// the MUX5 bit of ADCSRB selects whether we're reading from channels
+	// 0 to 7 (MUX5 low) or 8 to 15 (MUX5 high).
+	ADCSRB = (ADCSRB & ~(1 << MUX5)) | (((pin >> 3) & 0x01) << MUX5);
+#endif
+
+	// without a delay, we seem to read from the wrong channel
+	//delay(1);
+
+	// start the conversion
+	sbi(ADCSRA, ADSC);
+
+	// ADSC is cleared when the conversion finishes
+	while (bit_is_set(ADCSRA, ADSC));
+
+	// we have to read ADCL first; doing so locks both ADCL
+	// and ADCH until ADCH is read.  reading ADCL second would
+	// cause the results of each conversion to be discarded,
+	// as ADCL and ADCH would be locked when it completed.
+	low = ADCL;
+	high = ADCH;
+
+	// combine the two bytes
+	return (high << 8) | low;
+}
+
+// Right now, PWM output only works on the pins with
+// hardware support.  These are defined in the appropriate
+// pins_*.c file.  For the rest of the pins, we default
+// to digital output.
+void analogWrite(uint8_t pin, int val)
+{
+	// We need to make sure the PWM output is enabled for those pins
+	// that support it, as we turn it off when digitally reading or
+	// writing with them.  Also, make sure the pin is in output mode
+	// for consistenty with Wiring, which doesn't require a pinMode
+	// call for the analog output pins.
+	pinMode(pin, OUTPUT);
+	
+	if (digitalPinToTimer(pin) == TIMER1A) {
+		// connect pwm to pin on timer 1, channel A
+		sbi(TCCR1A, COM1A1);
+		// set pwm duty
+		OCR1A = val;
+	} else if (digitalPinToTimer(pin) == TIMER1B) {
+		// connect pwm to pin on timer 1, channel B
+		sbi(TCCR1A, COM1B1);
+		// set pwm duty
+		OCR1B = val;
+#if defined(__AVR_ATmega8__)
+	} else if (digitalPinToTimer(pin) == TIMER2) {
+		// connect pwm to pin on timer 2, channel B
+		sbi(TCCR2, COM21);
+		// set pwm duty
+		OCR2 = val;
+#else
+	} else if (digitalPinToTimer(pin) == TIMER0A) {
+		if (val == 0) {
+			digitalWrite(pin, LOW);
+		} else {
+			// connect pwm to pin on timer 0, channel A
+			sbi(TCCR0A, COM0A1);
+			// set pwm duty
+			OCR0A = val;      
+		}
+	} else if (digitalPinToTimer(pin) == TIMER0B) {
+		if (val == 0) {
+			digitalWrite(pin, LOW);
+		} else {
+			// connect pwm to pin on timer 0, channel B
+			sbi(TCCR0A, COM0B1);
+			// set pwm duty
+			OCR0B = val;
+		}
+	} else if (digitalPinToTimer(pin) == TIMER2A) {
+		// connect pwm to pin on timer 2, channel A
+		sbi(TCCR2A, COM2A1);
+		// set pwm duty
+		OCR2A = val;	
+	} else if (digitalPinToTimer(pin) == TIMER2B) {
+		// connect pwm to pin on timer 2, channel B
+		sbi(TCCR2A, COM2B1);
+		// set pwm duty
+		OCR2B = val;
+#endif
+#if defined(__AVR_ATmega1280__)
+	// XXX: need to handle other timers here
+	} else if (digitalPinToTimer(pin) == TIMER3A) {
+		// connect pwm to pin on timer 3, channel A
+		sbi(TCCR3A, COM3A1);
+		// set pwm duty
+		OCR3A = val;
+	} else if (digitalPinToTimer(pin) == TIMER3B) {
+		// connect pwm to pin on timer 3, channel B
+		sbi(TCCR3A, COM3B1);
+		// set pwm duty
+		OCR3B = val;
+	} else if (digitalPinToTimer(pin) == TIMER3C) {
+		// connect pwm to pin on timer 3, channel C
+		sbi(TCCR3A, COM3C1);
+		// set pwm duty
+		OCR3C = val;
+	} else if (digitalPinToTimer(pin) == TIMER4A) {
+		// connect pwm to pin on timer 4, channel A
+		sbi(TCCR4A, COM4A1);
+		// set pwm duty
+		OCR4A = val;
+	} else if (digitalPinToTimer(pin) == TIMER4B) {
+		// connect pwm to pin on timer 4, channel B
+		sbi(TCCR4A, COM4B1);
+		// set pwm duty
+		OCR4B = val;
+	} else if (digitalPinToTimer(pin) == TIMER4C) {
+		// connect pwm to pin on timer 4, channel C
+		sbi(TCCR4A, COM4C1);
+		// set pwm duty
+		OCR4C = val;
+	} else if (digitalPinToTimer(pin) == TIMER5A) {
+		// connect pwm to pin on timer 5, channel A
+		sbi(TCCR5A, COM5A1);
+		// set pwm duty
+		OCR5A = val;
+	} else if (digitalPinToTimer(pin) == TIMER5B) {
+		// connect pwm to pin on timer 5, channel B
+		sbi(TCCR5A, COM5B1);
+		// set pwm duty
+		OCR5B = val;
+#endif
+	} else if (val < 128)
+		digitalWrite(pin, LOW);
+	else
+		digitalWrite(pin, HIGH);
+}

arduino-0018-linux/hardware/arduino/cores/arduino/wiring_digital.c

@@ -0,0 +1,111 @@
+/*
+  wiring_digital.c - digital input and output functions
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
+*/
+
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+void pinMode(uint8_t pin, uint8_t mode)
+{
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+	volatile uint8_t *reg;
+
+	if (port == NOT_A_PIN) return;
+
+	// JWS: can I let the optimizer do this?
+	reg = portModeRegister(port);
+
+	if (mode == INPUT) *reg &= ~bit;
+	else *reg |= bit;
+}
+
+// Forcing this inline keeps the callers from having to push their own stuff
+// on the stack. It is a good performance win and only takes 1 more byte per
+// user than calling. (It will take more bytes on the 168.)
+//
+// But shouldn't this be moved into pinMode? Seems silly to check and do on
+// each digitalread or write.
+//
+static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
+static inline void turnOffPWM(uint8_t timer)
+{
+	if (timer == TIMER1A) cbi(TCCR1A, COM1A1);
+	if (timer == TIMER1B) cbi(TCCR1A, COM1B1);
+
+#if defined(__AVR_ATmega8__)
+	if (timer == TIMER2) cbi(TCCR2, COM21);
+#else
+	if (timer == TIMER0A) cbi(TCCR0A, COM0A1);
+	if (timer == TIMER0B) cbi(TCCR0A, COM0B1);
+	if (timer == TIMER2A) cbi(TCCR2A, COM2A1);
+	if (timer == TIMER2B) cbi(TCCR2A, COM2B1);
+#endif
+
+#if defined(__AVR_ATmega1280__)
+	if (timer == TIMER3A) cbi(TCCR3A, COM3A1);
+	if (timer == TIMER3B) cbi(TCCR3A, COM3B1);
+	if (timer == TIMER3C) cbi(TCCR3A, COM3C1);
+	if (timer == TIMER4A) cbi(TCCR4A, COM4A1);
+	if (timer == TIMER4B) cbi(TCCR4A, COM4B1);
+	if (timer == TIMER4C) cbi(TCCR4A, COM4C1);
+	if (timer == TIMER5A) cbi(TCCR5A, COM5A1);
+	if (timer == TIMER5B) cbi(TCCR5A, COM5B1);
+	if (timer == TIMER5C) cbi(TCCR5A, COM5C1);
+#endif
+}
+
+void digitalWrite(uint8_t pin, uint8_t val)
+{
+	uint8_t timer = digitalPinToTimer(pin);
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+	volatile uint8_t *out;
+
+	if (port == NOT_A_PIN) return;
+
+	// If the pin that support PWM output, we need to turn it off
+	// before doing a digital write.
+	if (timer != NOT_ON_TIMER) turnOffPWM(timer);
+
+	out = portOutputRegister(port);
+
+	if (val == LOW) *out &= ~bit;
+	else *out |= bit;
+}
+
+int digitalRead(uint8_t pin)
+{
+	uint8_t timer = digitalPinToTimer(pin);
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+
+	if (port == NOT_A_PIN) return LOW;
+
+	// If the pin that support PWM output, we need to turn it off
+	// before getting a digital reading.
+	if (timer != NOT_ON_TIMER) turnOffPWM(timer);
+
+	if (*portInputRegister(port) & bit) return HIGH;
+	return LOW;
+}

arduino-0018-linux/hardware/arduino/cores/arduino/wiring_private.h

@@ -0,0 +1,68 @@
+/*
+  wiring_private.h - Internal header file.
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.h 239 2007-01-12 17:58:39Z mellis $
+*/
+
+#ifndef WiringPrivate_h
+#define WiringPrivate_h
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/delay.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "wiring.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#ifndef cbi
+#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
+#endif
+#ifndef sbi
+#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
+#endif
+
+#define EXTERNAL_INT_0 0
+#define EXTERNAL_INT_1 1
+#define EXTERNAL_INT_2 2
+#define EXTERNAL_INT_3 3
+#define EXTERNAL_INT_4 4
+#define EXTERNAL_INT_5 5
+#define EXTERNAL_INT_6 6
+#define EXTERNAL_INT_7 7
+
+#if defined(__AVR_ATmega1280__)
+#define EXTERNAL_NUM_INTERRUPTS 8
+#else
+#define EXTERNAL_NUM_INTERRUPTS 2
+#endif
+
+typedef void (*voidFuncPtr)(void);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

arduino-0018-linux/hardware/arduino/cores/arduino/wiring_pulse.c

@@ -0,0 +1,66 @@
+/*
+  wiring_pulse.c - pulseIn() function
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
+*/
+
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH
+ * or LOW, the type of pulse to measure.  Works on pulses from 2-3 microseconds
+ * to 3 minutes in length, but must be called at least a few dozen microseconds
+ * before the start of the pulse. */
+unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout)
+{
+	// cache the port and bit of the pin in order to speed up the
+	// pulse width measuring loop and achieve finer resolution.  calling
+	// digitalRead() instead yields much coarser resolution.
+	uint8_t bit = digitalPinToBitMask(pin);
+	uint8_t port = digitalPinToPort(pin);
+	uint8_t stateMask = (state ? bit : 0);
+	unsigned long width = 0; // keep initialization out of time critical area
+	
+	// convert the timeout from microseconds to a number of times through
+	// the initial loop; it takes 16 clock cycles per iteration.
+	unsigned long numloops = 0;
+	unsigned long maxloops = microsecondsToClockCycles(timeout) / 16;
+	
+	// wait for any previous pulse to end
+	while ((*portInputRegister(port) & bit) == stateMask)
+		if (numloops++ == maxloops)
+			return 0;
+	
+	// wait for the pulse to start
+	while ((*portInputRegister(port) & bit) != stateMask)
+		if (numloops++ == maxloops)
+			return 0;
+	
+	// wait for the pulse to stop
+	while ((*portInputRegister(port) & bit) == stateMask)
+		width++;
+
+	// convert the reading to microseconds. The loop has been determined
+	// to be 10 clock cycles long and have about 16 clocks between the edge
+	// and the start of the loop. There will be some error introduced by
+	// the interrupt handlers.
+	return clockCyclesToMicroseconds(width * 10 + 16); 
+}

arduino-0018-linux/hardware/arduino/cores/arduino/wiring_shift.c

@@ -0,0 +1,40 @@
+/*
+  wiring_shift.c - shiftOut() function
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2005-2006 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+
+  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
+*/
+
+#include "wiring_private.h"
+
+void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, byte val)
+{
+	int i;
+
+	for (i = 0; i < 8; i++)  {
+		if (bitOrder == LSBFIRST)
+			digitalWrite(dataPin, !!(val & (1 << i)));
+		else	
+			digitalWrite(dataPin, !!(val & (1 << (7 - i))));
+			
+		digitalWrite(clockPin, HIGH);
+		digitalWrite(clockPin, LOW);		
+	}
+}

arduino-0018-linux/hardware/arduino/programmers.txt

@@ -0,0 +1,20 @@
+avrisp.name=AVR ISP
+avrisp.communication=serial
+avrisp.protocol=stk500v1
+
+avrispmkii.name=AVRISP mkII
+avrispmkii.communication=usb
+avrispmkii.protocol=stk500v2
+
+usbtinyisp.name=USBtinyISP
+usbtinyisp.protocol=usbtiny
+
+parallel.name=Parallel Programmer
+parallel.protocol=dapa
+parallel.force=true
+# parallel.delay=200
+
+arduinoisp.name=Arduino as ISP
+arduinoisp.communication=serial
+arduinoisp.protocol=stk500v1
+arduinoisp.speed=19200

arduino-0018-linux/lib/keywords.txt

@@ -0,0 +1,173 @@
+# LITERAL1 specifies constants
+
+HIGH	LITERAL1	Constants
+LOW	LITERAL1	Constants
+INPUT	LITERAL1	Constants
+OUTPUT	LITERAL1	Constants
+DEC	LITERAL1	Serial_Print
+BIN	LITERAL1	Serial_Print
+HEX	LITERAL1	Serial_Print
+OCT	LITERAL1	Serial_Print
+BYTE	LITERAL1	Serial_Print
+PI	LITERAL1
+HALF_PI	LITERAL1
+TWO_PI	LITERAL1
+LSBFIRST	LITERAL1	ShiftOut
+MSBFIRST	LITERAL1	ShiftOut
+CHANGE	LITERAL1	AttachInterrupt
+FALLING	LITERAL1	AttachInterrupt
+RISING	LITERAL1	AttachInterrupt
+DEFAULT	LITERAL1	AnalogReference
+EXTERNAL	LITERAL1	AnalogReference
+INTERAL	LITERAL1	AnalogReference
+
+# KEYWORD1 specifies datatypes and C/C++ keywords
+
+boolean	KEYWORD1	BooleanVariables
+break	KEYWORD1	Break
+byte	KEYWORD1	Byte
+case	KEYWORD1	SwitchCase
+char	KEYWORD1	Char
+class	KEYWORD1
+continue	KEYWORD1	Continue
+default	KEYWORD1	SwitchCase	
+do	KEYWORD1	DoWhile
+double	KEYWORD1	Double
+else	KEYWORD1	Else
+false	KEYWORD1	Constants
+float	KEYWORD1	Float
+for	KEYWORD1	For
+if	KEYWORD1	If
+int	KEYWORD1	Int
+long	KEYWORD1	Long
+new	KEYWORD1	
+null	KEYWORD1	
+private	KEYWORD1
+protected	KEYWORD1	
+public	KEYWORD1	
+return	KEYWORD1	Return	
+short	KEYWORD1
+signed	KEYWORD1
+static	KEYWORD1	Static	
+switch	KEYWORD1	SwitchCase
+this	KEYWORD1	
+throw	KEYWORD1	
+try	KEYWORD1	
+true	KEYWORD1	
+unsigned	KEYWORD1
+void	KEYWORD1	Void
+while	KEYWORD1	While
+word	KEYWORD1	Word
+
+# operators aren't highlighted, but may have documentation
+
++=		IncrementCompound
++		Arithmetic
+[]		arrayaccess
+=		assign
+&		BitwiseAnd
+|		BitwiseAnd
+,		
+//		Comments
+?:		
+{}		Braces
+--		Increment
+/		Arithmetic
+/*		Comments
+.		dot
+==		
+<		greaterthan
+<=		greaterthanorequalto
+++		Increment
+!=		inequality
+<<		Bitshift
+<		lessthan
+<=		lessthanorequalto
+&&		Boolean
+!		Boolean
+||		Boolean
+-		Arithmetic
+%		Modulo
+*		Arithmetic
+()		parentheses
+>>		Bitshift
+;		SemiColon
+-=		IncrementCompound
+
+# these are datatypes, but we've also defined functions to cast to them
+
+boolean	KEYWORD2	boolean_
+byte	KEYWORD2	byte_
+char	KEYWORD2	char_
+float	KEYWORD2	float_
+int	KEYWORD2	int_
+long	KEYWORD2	long_
+word	KEYWORD2	word_
+
+# KEYWORD2 specifies methods and functions
+
+abs	KEYWORD2	Abs
+acos	KEYWORD2	ACos
+asin	KEYWORD2	ASin
+atan	KEYWORD2	ATan
+atan2	KEYWORD2	ATan2
+ceil	KEYWORD2	Ceil
+constrain	KEYWORD2	Constrain
+cos	KEYWORD2	Cos
+degrees	KEYWORD2
+exp	KEYWORD2	Exp
+floor	KEYWORD2	Floor
+log	KEYWORD2	Log
+map	KEYWORD2	Map
+max	KEYWORD2	Max
+min	KEYWORD2	Min
+radians	KEYWORD2
+random	KEYWORD2	Random
+randomSeed	KEYWORD2	RandomSeed
+round	KEYWORD2
+sin	KEYWORD2	Sin
+sq	KEYWORD2	Sq
+sqrt	KEYWORD2	Sqrt
+tan	KEYWORD2	Tan
+
+bitRead	KEYWORD2	BitRead
+bitWrite	KEYWORD2	BitWrite
+bitSet	KEYWORD2	BitSet
+bitClear	KEYWORD2	BitClear
+bit	KEYWORD2	Bit
+highByte	KEYWORD2	HighByte
+lowByte	KEYWORD2	LowByte
+
+analogReference	KEYWORD2	AnalogReference
+analogRead	KEYWORD2	AnalogRead
+analogWrite	KEYWORD2	AnalogWrite
+attachInterrupt	KEYWORD2	AttachInterrupt
+detachInterrupt	KEYWORD2	DetachInterrupt
+delay	KEYWORD2	Delay
+delayMicroseconds	KEYWORD2	DelayMicroseconds
+digitalWrite	KEYWORD2	DigitalWrite
+digitalRead	KEYWORD2	DigitalRead
+interrupts	KEYWORD2
+millis	KEYWORD2	Millis
+micros	KEYWORD2	Micros
+noInterrupts	KEYWORD2	NoInterrupts
+noTone	KEYWORD2	NoTone
+pinMode	KEYWORD2	PinMode
+pulseIn	KEYWORD2	PulseIn
+shiftOut	KEYWORD2	ShiftOut
+tone	KEYWORD2	Tone
+
+Serial	KEYWORD3	Serial
+Serial1	KEYWORD3	Serial
+Serial2	KEYWORD3	Serial
+Serial3	KEYWORD3	Serial
+begin	KEYWORD2	Serial_Begin
+end	KEYWORD2	Serial_End
+read	KEYWORD2	Serial_Read
+print	KEYWORD2	Serial_Print
+println	KEYWORD2	Serial_Println
+available	KEYWORD2	Serial_Available
+flush	KEYWORD2	Serial_Flush
+
+setup	KEYWORD3	Setup
+loop	KEYWORD3	Loop

arduino-0018-linux/lib/preferences.txt

@@ -0,0 +1,227 @@
+# !!!!!!!! UNLIKE PREVIOUS VERSIONS OF PROCESSING !!!!!!!!!!
+# DO NOT MODIFY THIS FILE, OR DELETE SETTINGS FROM THIS FILE
+
+# These are the default preferences. If you want to modify 
+# them directly, use the per-user local version of the file:
+
+# Documents and Settings -> [username] -> Application Data -> 
+#    Processing -> preferences.txt (on Windows XP)
+
+# Users -> [username] -> AppData -> Roaming -> 
+#    Processing -> preferences.txt (on Windows Vista)
+
+# ~/Library -> Processing -> preferences.txt (on Mac OS X)
+
+# ~/.processing -> preferences.txt (on Linux)
+
+# The exact location of your preferences file can be found at
+# the bottom of the Preferences window inside Processing.
+
+# Because AppData and Application Data may be considered 
+# hidden or system folders on Windows, you'll have to ensure
+# that they're visible in order to get at preferences.txt
+
+# You'll have problems running Processing if you incorrectly 
+# modify lines in this file.
+
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+# DEFAULT PATHS FOR SKETCHBOOK AND SETTINGS
+
+# relative paths will be relative to processing.exe or procesing.app.
+# absolute paths may also be used.
+
+# note that this path should use forward slashes (like unix)
+# instead of \ on windows or : on macos or whatever else
+
+# If you don't want users to have their sketchbook default to 
+# "My Documents/Processing" on Windows and "Documents/Processing" on OS X, 
+# set this to another path that will be used by default. 
+# Note that this path must exist already otherwise it won't see
+# the sketchbook folder, and will instead assume the sketchbook
+# has gone missing, and that it should instead use the default.
+#sketchbook.path=
+
+# if you don't want settings to go into "application data" on windows
+# and "library" on macosx, set this to the alternate location.
+#settings.path=data
+
+# temporary build path, normally this goes into the default
+# "temp" folder for that platform (as defined by java)
+# but this can be used to set a specific file in case of problems
+#build.path=build
+
+# By default, no sketches currently open
+last.sketch.count=0
+
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+# by default, check the processing server for any updates
+# (please avoid disabling, this also helps us know basic numbers 
+# on how many people are using Processing)
+update.check = true
+
+# on windows, automatically associate .pde files with processing.exe
+platform.auto_file_type_associations = true
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+# default size for the main window
+default.window.width = 500
+default.window.height = 600
+
+# font size for editor
+editor.font=Monospaced,plain,12
+# Monaco is nicer on Mac OS X, so use that explicitly
+editor.font.macosx = Monaco,plain,10
+
+# anti-aliased text, turned off by default
+editor.antialias=false
+
+# color to be used for background when 'external editor' enabled
+editor.external=false
+
+# caret blinking
+editor.caret.blink=true
+
+# area that's not in use by the text (replaced with tildes)
+editor.invalid=false
+
+console			 = true
+console.output.file      = stdout.txt
+console.error.file       = stderr.txt
+console.lines            = 4
+
+# set to false to disable automatically clearing the console
+# each time 'run' is hit
+console.auto_clear = true
+
+# set the maximum number of lines remembered by the console
+# the default is 500, lengthen at your own peril
+console.length = 500
+
+# convert tabs to spaces? how many spaces?
+editor.tabs.expand = true
+editor.tabs.size   = 2
+
+# automatically indent each line
+editor.indent = true
+
+# size of divider between editing area and the console
+editor.divider.size = 0
+# the larger divider on windows is ugly with the little arrows
+# this makes it large enough to see (mouse changes) and use, 
+# but keeps it from being annoyingly obtrusive
+editor.divider.size.windows = 2
+
+# any additional java options when running externally
+# (for applets that are run external to the environment...
+# those with a code folder, or using any libraries)
+# if you hose this and can't run things, it's your own durn fault 
+run.options = 
+
+# settings for the -XmsNNNm and -XmxNNNm command line option
+run.options.memory = false
+run.options.memory.initial = 64
+run.options.memory.maximum = 256
+
+# example of increasing the memory size for applets run externally
+#run.options = -Xms128m -Xmx1024m
+
+# index of the default display to use for present mode
+# (this setting not yet completely implemented)
+run.display = 1
+
+# set internally
+#run.window.bgcolor=
+
+# set to false to open a new untitled window when closing the last window
+# (otherwise, the environment will quit)
+# default to the relative norm for the different platforms, 
+# but the setting can be changed in the prefs dialog anyway
+#sketchbook.closing_last_window_quits = true
+#sketchbook.closing_last_window_quits.macosx = false
+
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+#history.recording = true
+
+# for advanced users, enable option to export a library
+#export.library = false
+
+# which platforms to export by default
+export.application.platform.windows = true
+export.application.platform.macosx = true
+export.application.platform.linux = true
+
+# whether or not to export as full screen (present) mode
+export.application.fullscreen = false
+
+# whether to show the stop button when exporting to application
+export.application.stop = true
+
+# false will place all exported files into a single .jar
+export.applet.separate_jar_files = false
+
+# set to false to no longer delete applet or application folders before export
+export.delete_target_folder = true
+
+# may be useful when attempting to debug the preprocessor
+preproc.save_build_files=false
+
+# allows various preprocessor features to be toggled 
+# in case they are causing problems
+
+# preprocessor: pde.g
+preproc.color_datatype = true
+preproc.web_colors = true
+preproc.enhanced_casting = true
+
+# preprocessor: PdeEmitter.java
+preproc.substitute_floats = true
+#preproc.substitute_image = false
+#preproc.substitute_font = false
+
+# auto-convert non-ascii chars to unicode escape sequences
+preproc.substitute_unicode = true
+
+# PdePreproc.java
+# writes out the parse tree as parseTree.xml, which can be usefully
+# viewed in (at least) Mozilla or IE.  useful when debugging the preprocessor.
+preproc.output_parse_tree = false
+
+# imports to use by default (changed for 0149, some imports removed)
+preproc.imports = java.applet,java.awt,java.awt.image,java.awt.event,java.io,java.net,java.text,java.util,java.util.zip,java.util.regex
+
+# set the browser to be used on linux
+browser.linux = mozilla
+
+# set to the program to be used for launching apps on linux
+#launcher.linux = gnome-open
+
+# FULL SCREEN (PRESENT MODE)
+run.present.bgcolor = #666666
+run.present.stop.color = #cccccc
+# starting in release 0159, don't use full screen exclusive anymore
+run.present.exclusive = false
+# use this by default to hide the menu bar and dock on osx
+run.present.exclusive.macosx = true
+
+# ARDUINO PREFERENCES
+board = atmega328
+target = arduino
+
+upload.using = bootloader
+
+serial.port=COM1
+serial.databits=8
+serial.stopbits=1
+serial.parity=N
+serial.debug_rate=9600