Merge branch 'ide-1.5.x' into dev-ide-1.5.x-discovery

Conflicts:
	app/src/processing/app/Preferences.java
	app/src/processing/app/debug/Uploader.java

1 files changed, 0 insertions, 444 deletions

diff --git a/libraries/Firmata/Firmata.cpp b/libraries/Firmata/Firmata.cpp
deleted file mode 100644
index 36f8ed1..0000000
--- a/libraries/Firmata/Firmata.cpp
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
-  Firmata.cpp - Firmata library
-  Copyright (C) 2006-2008 Hans-Christoph Steiner.  All rights 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.
-
-  See file LICENSE.txt for further informations on licensing terms.
-*/
-
-//******************************************************************************
-//* Includes
-//******************************************************************************
-
-#include "Firmata.h"
-#include "HardwareSerial.h"
-
-extern "C" {
-#include <string.h>
-#include <stdlib.h>
-}
-
-//******************************************************************************
-//* Support Functions
-//******************************************************************************
-
-void FirmataClass::sendValueAsTwo7bitBytes(int value)
-{
-  FirmataSerial.write(value & B01111111); // LSB
-  FirmataSerial.write(value >> 7 & B01111111); // MSB
-}
-
-void FirmataClass::startSysex(void)
-{
-  FirmataSerial.write(START_SYSEX);
-}
-
-void FirmataClass::endSysex(void)
-{
-  FirmataSerial.write(END_SYSEX);
-}
-
-//******************************************************************************
-//* Constructors
-//******************************************************************************
-
-FirmataClass::FirmataClass(Stream &s) : FirmataSerial(s)
-{
-  firmwareVersionCount = 0;
-  systemReset();
-}
-
-//******************************************************************************
-//* Public Methods
-//******************************************************************************
-
-/* begin method for overriding default serial bitrate */
-void FirmataClass::begin(void)
-{
-  begin(57600);
-}
-
-/* begin method for overriding default serial bitrate */
-void FirmataClass::begin(long speed)
-{
-  Serial.begin(speed);
-  FirmataSerial = Serial;
-  blinkVersion();
-  printVersion();
-  printFirmwareVersion();
-}
-
-void FirmataClass::begin(Stream &s)
-{
-  FirmataSerial = s;
-  systemReset();
-  printVersion();
-  printFirmwareVersion();
-}
-
-// output the protocol version message to the serial port
-void FirmataClass::printVersion(void) {
-  FirmataSerial.write(REPORT_VERSION);
-  FirmataSerial.write(FIRMATA_MAJOR_VERSION);
-  FirmataSerial.write(FIRMATA_MINOR_VERSION);
-}
-
-void FirmataClass::blinkVersion(void)
-{
-  // flash the pin with the protocol version
-  pinMode(VERSION_BLINK_PIN,OUTPUT);
-  pin13strobe(FIRMATA_MAJOR_VERSION, 40, 210);
-  delay(250);
-  pin13strobe(FIRMATA_MINOR_VERSION, 40, 210);
-  delay(125);
-}
-
-void FirmataClass::printFirmwareVersion(void)
-{
-  byte i;
-
-  if(firmwareVersionCount) { // make sure that the name has been set before reporting
-    startSysex();
-    FirmataSerial.write(REPORT_FIRMWARE);
-    FirmataSerial.write(firmwareVersionVector[0]); // major version number
-    FirmataSerial.write(firmwareVersionVector[1]); // minor version number
-    for(i=2; i<firmwareVersionCount; ++i) {
-      sendValueAsTwo7bitBytes(firmwareVersionVector[i]);
-    }
-    endSysex();
-  }
-}
-
-void FirmataClass::setFirmwareNameAndVersion(const char *name, byte major, byte minor)
-{
-  const char *filename;
-  char *extension;
-
-  // parse out ".cpp" and "applet/" that comes from using __FILE__
-  extension = strstr(name, ".cpp");
-  filename = strrchr(name, '/') + 1; //points to slash, +1 gets to start of filename
-  // add two bytes for version numbers
-  if(extension && filename) {
-    firmwareVersionCount = extension - filename + 2;
-  } else {
-    firmwareVersionCount = strlen(name) + 2;
-    filename = name;
-  }
-  firmwareVersionVector = (byte *) malloc(firmwareVersionCount);
-  firmwareVersionVector[firmwareVersionCount] = 0;
-  firmwareVersionVector[0] = major;
-  firmwareVersionVector[1] = minor;
-  strncpy((char*)firmwareVersionVector + 2, filename, firmwareVersionCount - 2);
-  // alas, no snprintf on Arduino
-  //    snprintf(firmwareVersionVector, MAX_DATA_BYTES, "%c%c%s", 
-  //             (char)major, (char)minor, firmwareVersionVector);
-}
-
-//------------------------------------------------------------------------------
-// Serial Receive Handling
-
-int FirmataClass::available(void)
-{
-  return FirmataSerial.available();
-}
-
-
-void FirmataClass::processSysexMessage(void)
-{
-  switch(storedInputData[0]) { //first byte in buffer is command
-  case REPORT_FIRMWARE:
-    printFirmwareVersion();
-    break;
-  case STRING_DATA:
-    if(currentStringCallback) {
-      byte bufferLength = (sysexBytesRead - 1) / 2;
-      char *buffer = (char*)malloc(bufferLength * sizeof(char));
-      byte i = 1;
-      byte j = 0;
-      while(j < bufferLength) {
-        buffer[j] = (char)storedInputData[i];
-        i++;
-        buffer[j] += (char)(storedInputData[i] << 7);
-        i++;
-        j++;
-      }
-      (*currentStringCallback)(buffer);
-    }
-    break;
-  default:
-    if(currentSysexCallback)
-      (*currentSysexCallback)(storedInputData[0], sysexBytesRead - 1, storedInputData + 1);
-  }
-}
-
-void FirmataClass::processInput(void)
-{
-  int inputData = FirmataSerial.read(); // this is 'int' to handle -1 when no data
-  int command;
-    
-  // TODO make sure it handles -1 properly
-
-  if (parsingSysex) {
-    if(inputData == END_SYSEX) {
-      //stop sysex byte      
-      parsingSysex = false;
-      //fire off handler function
-      processSysexMessage();
-    } else {
-      //normal data byte - add to buffer
-      storedInputData[sysexBytesRead] = inputData;
-      sysexBytesRead++;
-    }
-  } else if( (waitForData > 0) && (inputData < 128) ) {  
-    waitForData--;
-    storedInputData[waitForData] = inputData;
-    if( (waitForData==0) && executeMultiByteCommand ) { // got the whole message
-      switch(executeMultiByteCommand) {
-      case ANALOG_MESSAGE:
-        if(currentAnalogCallback) {
-          (*currentAnalogCallback)(multiByteChannel,
-                                   (storedInputData[0] << 7)
-                                   + storedInputData[1]);
-        }
-        break;
-      case DIGITAL_MESSAGE:
-        if(currentDigitalCallback) {
-          (*currentDigitalCallback)(multiByteChannel,
-                                    (storedInputData[0] << 7)
-                                    + storedInputData[1]);
-        }
-        break;
-      case SET_PIN_MODE:
-        if(currentPinModeCallback)
-          (*currentPinModeCallback)(storedInputData[1], storedInputData[0]);
-        break;
-      case REPORT_ANALOG:
-        if(currentReportAnalogCallback)
-          (*currentReportAnalogCallback)(multiByteChannel,storedInputData[0]);
-        break;
-      case REPORT_DIGITAL:
-        if(currentReportDigitalCallback)
-          (*currentReportDigitalCallback)(multiByteChannel,storedInputData[0]);
-        break;
-      }
-      executeMultiByteCommand = 0;
-    }	
-  } else {
-    // remove channel info from command byte if less than 0xF0
-    if(inputData < 0xF0) {
-      command = inputData & 0xF0;
-      multiByteChannel = inputData & 0x0F;
-    } else {
-      command = inputData;
-      // commands in the 0xF* range don't use channel data
-    }
-    switch (command) {
-    case ANALOG_MESSAGE:
-    case DIGITAL_MESSAGE:
-    case SET_PIN_MODE:
-      waitForData = 2; // two data bytes needed
-      executeMultiByteCommand = command;
-      break;
-    case REPORT_ANALOG:
-    case REPORT_DIGITAL:
-      waitForData = 1; // one data byte needed
-      executeMultiByteCommand = command;
-      break;
-    case START_SYSEX:
-      parsingSysex = true;
-      sysexBytesRead = 0;
-      break;
-    case SYSTEM_RESET:
-      systemReset();
-      break;
-    case REPORT_VERSION:
-      Firmata.printVersion();
-      break;
-    }
-  }
-}
-
-//------------------------------------------------------------------------------
-// Serial Send Handling
-
-// send an analog message
-void FirmataClass::sendAnalog(byte pin, int value) 
-{
-  // pin can only be 0-15, so chop higher bits
-  FirmataSerial.write(ANALOG_MESSAGE | (pin & 0xF));
-  sendValueAsTwo7bitBytes(value);
-}
-
-// send a single digital pin in a digital message
-void FirmataClass::sendDigital(byte pin, int value) 
-{
-  /* TODO add single pin digital messages to the protocol, this needs to
-   * track the last digital data sent so that it can be sure to change just
-   * one bit in the packet.  This is complicated by the fact that the
-   * numbering of the pins will probably differ on Arduino, Wiring, and
-   * other boards.  The DIGITAL_MESSAGE sends 14 bits at a time, but it is
-   * probably easier to send 8 bit ports for any board with more than 14
-   * digital pins.
-   */
-
-  // TODO: the digital message should not be sent on the serial port every
-  // time sendDigital() is called.  Instead, it should add it to an int
-  // which will be sent on a schedule.  If a pin changes more than once
-  // before the digital message is sent on the serial port, it should send a
-  // digital message for each change.
-
-  //    if(value == 0)
-  //        sendDigitalPortPair();
-}
-
-
-// send 14-bits in a single digital message (protocol v1)
-// send an 8-bit port in a single digital message (protocol v2)
-void FirmataClass::sendDigitalPort(byte portNumber, int portData)
-{
-  FirmataSerial.write(DIGITAL_MESSAGE | (portNumber & 0xF));
-  FirmataSerial.write((byte)portData % 128); // Tx bits 0-6
-  FirmataSerial.write(portData >> 7);  // Tx bits 7-13
-}
-
-
-void FirmataClass::sendSysex(byte command, byte bytec, byte* bytev) 
-{
-  byte i;
-  startSysex();
-  FirmataSerial.write(command);
-  for(i=0; i<bytec; i++) {
-    sendValueAsTwo7bitBytes(bytev[i]);        
-  }
-  endSysex();
-}
-
-void FirmataClass::sendString(byte command, const char* string) 
-{
-  sendSysex(command, strlen(string), (byte *)string);
-}
-
-
-// send a string as the protocol string type
-void FirmataClass::sendString(const char* string) 
-{
-  sendString(STRING_DATA, string);
-}
-
-
-// Internal Actions/////////////////////////////////////////////////////////////
-
-// generic callbacks
-void FirmataClass::attach(byte command, callbackFunction newFunction)
-{
-  switch(command) {
-  case ANALOG_MESSAGE: currentAnalogCallback = newFunction; break;
-  case DIGITAL_MESSAGE: currentDigitalCallback = newFunction; break;
-  case REPORT_ANALOG: currentReportAnalogCallback = newFunction; break;
-  case REPORT_DIGITAL: currentReportDigitalCallback = newFunction; break;
-  case SET_PIN_MODE: currentPinModeCallback = newFunction; break;
-  }
-}
-
-void FirmataClass::attach(byte command, systemResetCallbackFunction newFunction)
-{
-  switch(command) {
-  case SYSTEM_RESET: currentSystemResetCallback = newFunction; break;
-  }
-}
-
-void FirmataClass::attach(byte command, stringCallbackFunction newFunction)
-{
-  switch(command) {
-  case STRING_DATA: currentStringCallback = newFunction; break;
-  }
-}
-
-void FirmataClass::attach(byte command, sysexCallbackFunction newFunction)
-{
-  currentSysexCallback = newFunction;
-}
-
-void FirmataClass::detach(byte command)
-{
-  switch(command) {
-  case SYSTEM_RESET: currentSystemResetCallback = NULL; break;
-  case STRING_DATA: currentStringCallback = NULL; break;
-  case START_SYSEX: currentSysexCallback = NULL; break;
-  default:
-    attach(command, (callbackFunction)NULL);
-  }
-}
-
-// sysex callbacks
-/*
- * this is too complicated for analogReceive, but maybe for Sysex?
- void FirmataClass::attachSysex(sysexFunction newFunction)
- {
- byte i;
- byte tmpCount = analogReceiveFunctionCount;
- analogReceiveFunction* tmpArray = analogReceiveFunctionArray;
- analogReceiveFunctionCount++;
- analogReceiveFunctionArray = (analogReceiveFunction*) calloc(analogReceiveFunctionCount, sizeof(analogReceiveFunction));
- for(i = 0; i < tmpCount; i++) {
- analogReceiveFunctionArray[i] = tmpArray[i];
- }
- analogReceiveFunctionArray[tmpCount] = newFunction;
- free(tmpArray);
- }
-*/
-
-//******************************************************************************
-//* Private Methods
-//******************************************************************************
-
-
-
-// resets the system state upon a SYSTEM_RESET message from the host software
-void FirmataClass::systemReset(void)
-{
-  byte i;
-
-  waitForData = 0; // this flag says the next serial input will be data
-  executeMultiByteCommand = 0; // execute this after getting multi-byte data
-  multiByteChannel = 0; // channel data for multiByteCommands
-
-
-  for(i=0; i<MAX_DATA_BYTES; i++) {
-    storedInputData[i] = 0;
-  }
-
-  parsingSysex = false;
-  sysexBytesRead = 0;
-
-  if(currentSystemResetCallback)
-    (*currentSystemResetCallback)();
-
-  //flush(); //TODO uncomment when Firmata is a subclass of HardwareSerial
-}
-
-
-
-// =============================================================================
-// used for flashing the pin for the version number
-void FirmataClass::pin13strobe(int count, int onInterval, int offInterval) 
-{
-  byte i;
-  pinMode(VERSION_BLINK_PIN, OUTPUT);
-  for(i=0; i<count; i++) {
-    delay(offInterval);
-    digitalWrite(VERSION_BLINK_PIN, HIGH);
-    delay(onInterval);
-    digitalWrite(VERSION_BLINK_PIN, LOW);
-  }
-}
-
-
-// make one instance for the user to use
-FirmataClass Firmata(Serial);
-
-