+
+#define I2C_WRITE B00000000
+#define I2C_READ B00001000
+#define I2C_READ_CONTINUOUSLY B00010000
+#define I2C_STOP_READING B00011000
+#define I2C_READ_WRITE_MODE_MASK B00011000
+#define I2C_10BIT_ADDRESS_MODE_MASK B00100000
+#define MAX_QUERIES 8
+#define REGISTER_NOT_SPECIFIED -1
+
+// the minimum interval for sampling analog input
+#define MINIMUM_SAMPLING_INTERVAL 10
+
+
+/*==============================================================================
+ * GLOBAL VARIABLES
+ *============================================================================*/
+
+/* analog inputs */
+int analogInputsToReport = 0; // bitwise array to store pin reporting
+
+/* digital input ports */
+byte reportPINs[TOTAL_PORTS]; // 1 = report this port, 0 = silence
+byte previousPINs[TOTAL_PORTS]; // previous 8 bits sent
+
+/* pins configuration */
+byte pinConfig[TOTAL_PINS]; // configuration of every pin
+byte portConfigInputs[TOTAL_PORTS]; // each bit: 1 = pin in INPUT, 0 = anything else
+int pinState[TOTAL_PINS]; // any value that has been written
+
+/* timer variables */
+unsigned long currentMillis; // store the current value from millis()
+unsigned long previousMillis; // for comparison with currentMillis
+unsigned int samplingInterval = 19; // how often to run the main loop (in ms)
+
+/* i2c data */
+struct i2c_device_info {
+ byte addr;
+ int reg;
+ byte bytes;
+};
+
+/* for i2c read continuous more */
+i2c_device_info query[MAX_QUERIES];
+
+byte i2cRxData[32];
+boolean isI2CEnabled = false;
+signed char queryIndex = -1;
+// default delay time between i2c read request and Wire.requestFrom()
+unsigned int i2cReadDelayTime = 0;
+
+Servo servos[MAX_SERVOS];
+byte servoPinMap[TOTAL_PINS];
+byte detachedServos[MAX_SERVOS];
+byte detachedServoCount = 0;
+byte servoCount = 0;
+
+boolean isResetting = false;
+
+/* utility functions */
+void wireWrite(byte data)
+{
+#if ARDUINO >= 100
+ Wire.write((byte)data);
+#else
+ Wire.send(data);
+#endif
+}
+
+byte wireRead(void)
+{
+#if ARDUINO >= 100
+ return Wire.read();
+#else
+ return Wire.receive();
+#endif
+}
+
+/*==============================================================================
+ * FUNCTIONS
+ *============================================================================*/
+
+void attachServo(byte pin, int minPulse, int maxPulse)
+{
+ if (servoCount < MAX_SERVOS) {
+ // reuse indexes of detached servos until all have been reallocated
+ if (detachedServoCount > 0) {
+ servoPinMap[pin] = detachedServos[detachedServoCount - 1];
+ if (detachedServoCount > 0) detachedServoCount--;
+ } else {
+ servoPinMap[pin] = servoCount;
+ servoCount++;
+ }
+ if (minPulse > 0 && maxPulse > 0) {
+ servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
+ } else {
+ servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin));
+ }
+ } else {
+ Firmata.sendString("Max servos attached");
+ }
+}
+
+void detachServo(byte pin)
+{
+ servos[servoPinMap[pin]].detach();
+ // if we're detaching the last servo, decrement the count
+ // otherwise store the index of the detached servo
+ if (servoPinMap[pin] == servoCount && servoCount > 0) {
+ servoCount--;
+ } else if (servoCount > 0) {
+ // keep track of detached servos because we want to reuse their indexes
+ // before incrementing the count of attached servos
+ detachedServoCount++;
+ detachedServos[detachedServoCount - 1] = servoPinMap[pin];
+ }
+
+ servoPinMap[pin] = 255;
+}
+
+void readAndReportData(byte address, int theRegister, byte numBytes) {
+ // allow I2C requests that don't require a register read
+ // for example, some devices using an interrupt pin to signify new data available
+ // do not always require the register read so upon interrupt you call Wire.requestFrom()
+ if (theRegister != REGISTER_NOT_SPECIFIED) {
+ Wire.beginTransmission(address);
+ wireWrite((byte)theRegister);
+ Wire.endTransmission();
+ // do not set a value of 0
+ if (i2cReadDelayTime > 0) {
+ // delay is necessary for some devices such as WiiNunchuck
+ delayMicroseconds(i2cReadDelayTime);
+ }
+ } else {
+ theRegister = 0; // fill the register with a dummy value
+ }
+
+ Wire.requestFrom(address, numBytes); // all bytes are returned in requestFrom
+
+ // check to be sure correct number of bytes were returned by slave
+ if (numBytes < Wire.available()) {
+ Firmata.sendString("I2C: Too many bytes received");
+ } else if (numBytes > Wire.available()) {
+ Firmata.sendString("I2C: Too few bytes received");
+ }
+
+ i2cRxData[0] = address;
+ i2cRxData[1] = theRegister;
+
+ for (int i = 0; i < numBytes && Wire.available(); i++) {
+ i2cRxData[2 + i] = wireRead();
+ }
+
+ // send slave address, register and received bytes
+ Firmata.sendSysex(SYSEX_I2C_REPLY, numBytes + 2, i2cRxData);
+}
+
+void outputPort(byte portNumber, byte portValue, byte forceSend)
+{
+ // pins not configured as INPUT are cleared to zeros
+ portValue = portValue & portConfigInputs[portNumber];
+ // only send if the value is different than previously sent
+ if (forceSend || previousPINs[portNumber] != portValue) {
+ Firmata.sendDigitalPort(portNumber, portValue);
+ previousPINs[portNumber] = portValue;
+ }
+}
+
+/* -----------------------------------------------------------------------------
+ * check all the active digital inputs for change of state, then add any events
+ * to the Serial output queue using Serial.print() */
+void checkDigitalInputs(void)
+{
+ /* Using non-looping code allows constants to be given to readPort().
+ * The compiler will apply substantial optimizations if the inputs
+ * to readPort() are compile-time constants. */
+ if (TOTAL_PORTS > 0 && reportPINs[0]) outputPort(0, readPort(0, portConfigInputs[0]), false);
+ if (TOTAL_PORTS > 1 && reportPINs[1]) outputPort(1, readPort(1, portConfigInputs[1]), false);
+ if (TOTAL_PORTS > 2 && reportPINs[2]) outputPort(2, readPort(2, portConfigInputs[2]), false);
+ if (TOTAL_PORTS > 3 && reportPINs[3]) outputPort(3, readPort(3, portConfigInputs[3]), false);
+ if (TOTAL_PORTS > 4 && reportPINs[4]) outputPort(4, readPort(4, portConfigInputs[4]), false);
+ if (TOTAL_PORTS > 5 && reportPINs[5]) outputPort(5, readPort(5, portConfigInputs[5]), false);
+ if (TOTAL_PORTS > 6 && reportPINs[6]) outputPort(6, readPort(6, portConfigInputs[6]), false);
+ if (TOTAL_PORTS > 7 && reportPINs[7]) outputPort(7, readPort(7, portConfigInputs[7]), false);
+ if (TOTAL_PORTS > 8 && reportPINs[8]) outputPort(8, readPort(8, portConfigInputs[8]), false);
+ if (TOTAL_PORTS > 9 && reportPINs[9]) outputPort(9, readPort(9, portConfigInputs[9]), false);
+ if (TOTAL_PORTS > 10 && reportPINs[10]) outputPort(10, readPort(10, portConfigInputs[10]), false);
+ if (TOTAL_PORTS > 11 && reportPINs[11]) outputPort(11, readPort(11, portConfigInputs[11]), false);
+ if (TOTAL_PORTS > 12 && reportPINs[12]) outputPort(12, readPort(12, portConfigInputs[12]), false);
+ if (TOTAL_PORTS > 13 && reportPINs[13]) outputPort(13, readPort(13, portConfigInputs[13]), false);
+ if (TOTAL_PORTS > 14 && reportPINs[14]) outputPort(14, readPort(14, portConfigInputs[14]), false);
+ if (TOTAL_PORTS > 15 && reportPINs[15]) outputPort(15, readPort(15, portConfigInputs[15]), false);
+}
+
+// -----------------------------------------------------------------------------
+/* sets the pin mode to the correct state and sets the relevant bits in the
+ * two bit-arrays that track Digital I/O and PWM status
+ */
+void setPinModeCallback(byte pin, int mode)
+{
+ if (pinConfig[pin] == IGNORE)
+ return;
+
+ if (pinConfig[pin] == I2C && isI2CEnabled && mode != I2C) {
+ // disable i2c so pins can be used for other functions
+ // the following if statements should reconfigure the pins properly
+ disableI2CPins();
+ }
+ if (IS_PIN_DIGITAL(pin) && mode != SERVO) {
+ if (servoPinMap[pin] < MAX_SERVOS && servos[servoPinMap[pin]].attached()) {
+ detachServo(pin);
+ }
+ }
+ if (IS_PIN_ANALOG(pin)) {
+ reportAnalogCallback(PIN_TO_ANALOG(pin), mode == ANALOG ? 1 : 0); // turn on/off reporting
+ }
+ if (IS_PIN_DIGITAL(pin)) {
+ if (mode == INPUT) {
+ portConfigInputs[pin / 8] |= (1 << (pin & 7));
+ } else {
+ portConfigInputs[pin / 8] &= ~(1 << (pin & 7));
+ }
+ }
+ pinState[pin] = 0;
+ switch (mode) {
+ case ANALOG:
+ if (IS_PIN_ANALOG(pin)) {
+ if (IS_PIN_DIGITAL(pin)) {
+ pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
+ digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
+ }
+ pinConfig[pin] = ANALOG;
+ }
+ break;
+ case INPUT:
+ if (IS_PIN_DIGITAL(pin)) {
+ pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
+ digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
+ pinConfig[pin] = INPUT;
+ }
+ break;
+ case OUTPUT:
+ if (IS_PIN_DIGITAL(pin)) {
+ digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
+ pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
+ pinConfig[pin] = OUTPUT;
+ }
+ break;
+ case PWM:
+ if (IS_PIN_PWM(pin)) {
+ pinMode(PIN_TO_PWM(pin), OUTPUT);
+ analogWrite(PIN_TO_PWM(pin), 0);
+ pinConfig[pin] = PWM;
+ }
+ break;
+ case SERVO:
+ if (IS_PIN_DIGITAL(pin)) {
+ pinConfig[pin] = SERVO;
+ if (servoPinMap[pin] == 255 || !servos[servoPinMap[pin]].attached()) {
+ // pass -1 for min and max pulse values to use default values set
+ // by Servo library
+ attachServo(pin, -1, -1);
+ }
+ }
+ break;
+ case I2C:
+ if (IS_PIN_I2C(pin)) {
+ // mark the pin as i2c
+ // the user must call I2C_CONFIG to enable I2C for a device
+ pinConfig[pin] = I2C;
+ }
+ break;
+ default:
+ Firmata.sendString("Unknown pin mode"); // TODO: put error msgs in EEPROM
+ }
+ // TODO: save status to EEPROM here, if changed
+}
+
+void analogWriteCallback(byte pin, int value)
+{
+ if (pin < TOTAL_PINS) {
+ switch (pinConfig[pin]) {
+ case SERVO:
+ if (IS_PIN_DIGITAL(pin))
+ servos[servoPinMap[pin]].write(value);
+ pinState[pin] = value;
+ break;
+ case PWM:
+ if (IS_PIN_PWM(pin))
+ analogWrite(PIN_TO_PWM(pin), value);
+ pinState[pin] = value;
+ break;
+ }
+ }
+}
+
+void digitalWriteCallback(byte port, int value)
+{
+ byte pin, lastPin, mask = 1, pinWriteMask = 0;
+
+ if (port < TOTAL_PORTS) {
+ // create a mask of the pins on this port that are writable.
+ lastPin = port * 8 + 8;
+ if (lastPin > TOTAL_PINS) lastPin = TOTAL_PINS;
+ for (pin = port * 8; pin < lastPin; pin++) {
+ // do not disturb non-digital pins (eg, Rx & Tx)
+ if (IS_PIN_DIGITAL(pin)) {
+ // only write to OUTPUT and INPUT (enables pullup)
+ // do not touch pins in PWM, ANALOG, SERVO or other modes
+ if (pinConfig[pin] == OUTPUT || pinConfig[pin] == INPUT) {
+ pinWriteMask |= mask;
+ pinState[pin] = ((byte)value & mask) ? 1 : 0;
+ }
+ }
+ mask = mask << 1;
+ }
+ writePort(port, (byte)value, pinWriteMask);
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+/* sets bits in a bit array (int) to toggle the reporting of the analogIns
+ */
+//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
+//}
+void reportAnalogCallback(byte analogPin, int value)
+{
+ if (analogPin < TOTAL_ANALOG_PINS) {
+ if (value == 0) {
+ analogInputsToReport = analogInputsToReport & ~ (1 << analogPin);
+ } else {
+ analogInputsToReport = analogInputsToReport | (1 << analogPin);
+ // prevent during system reset or all analog pin values will be reported
+ // which may report noise for unconnected analog pins
+ if (!isResetting) {
+ // Send pin value immediately. This is helpful when connected via
+ // ethernet, wi-fi or bluetooth so pin states can be known upon
+ // reconnecting.
+ Firmata.sendAnalog(analogPin, analogRead(analogPin));
+ }
+ }
+ }
+ // TODO: save status to EEPROM here, if changed
+}
+
+void reportDigitalCallback(byte port, int value)
+{
+ if (port < TOTAL_PORTS) {
+ reportPINs[port] = (byte)value;
+ // Send port value immediately. This is helpful when connected via
+ // ethernet, wi-fi or bluetooth so pin states can be known upon
+ // reconnecting.
+ if (value) outputPort(port, readPort(port, portConfigInputs[port]), true);
+ }
+ // do not disable analog reporting on these 8 pins, to allow some
+ // pins used for digital, others analog. Instead, allow both types
+ // of reporting to be enabled, but check if the pin is configured
+ // as analog when sampling the analog inputs. Likewise, while
+ // scanning digital pins, portConfigInputs will mask off values from any
+ // pins configured as analog
+}
+
+/*==============================================================================
+ * SYSEX-BASED commands
+ *============================================================================*/
+
+void sysexCallback(byte command, byte argc, byte *argv)
+{
+ byte mode;
+ byte slaveAddress;
+ byte data;
+ int slaveRegister;
+ unsigned int delayTime;
+
+ switch (command) {
+ case I2C_REQUEST:
+ mode = argv[1] & I2C_READ_WRITE_MODE_MASK;
+ if (argv[1] & I2C_10BIT_ADDRESS_MODE_MASK) {
+ Firmata.sendString("10-bit addressing not supported");
+ return;
+ }
+ else {
+ slaveAddress = argv[0];
+ }
+
+ switch (mode) {
+ case I2C_WRITE:
+ Wire.beginTransmission(slaveAddress);
+ for (byte i = 2; i < argc; i += 2) {
+ data = argv[i] + (argv[i + 1] << 7);
+ wireWrite(data);
+ }
+ Wire.endTransmission();
+ delayMicroseconds(70);
+ break;
+ case I2C_READ:
+ if (argc == 6) {
+ // a slave register is specified
+ slaveRegister = argv[2] + (argv[3] << 7);
+ data = argv[4] + (argv[5] << 7); // bytes to read
+ }
+ else {
+ // a slave register is NOT specified
+ slaveRegister = REGISTER_NOT_SPECIFIED;
+ data = argv[2] + (argv[3] << 7); // bytes to read
+ }
+ readAndReportData(slaveAddress, (int)slaveRegister, data);
+ break;
+ case I2C_READ_CONTINUOUSLY:
+ if ((queryIndex + 1) >= MAX_QUERIES) {
+ // too many queries, just ignore
+ Firmata.sendString("too many queries");
+ break;
+ }
+ if (argc == 6) {
+ // a slave register is specified
+ slaveRegister = argv[2] + (argv[3] << 7);
+ data = argv[4] + (argv[5] << 7); // bytes to read
+ }
+ else {
+ // a slave register is NOT specified
+ slaveRegister = (int)REGISTER_NOT_SPECIFIED;
+ data = argv[2] + (argv[3] << 7); // bytes to read
+ }
+ queryIndex++;
+ query[queryIndex].addr = slaveAddress;
+ query[queryIndex].reg = slaveRegister;
+ query[queryIndex].bytes = data;
+ break;
+ case I2C_STOP_READING:
+ byte queryIndexToSkip;
+ // if read continuous mode is enabled for only 1 i2c device, disable
+ // read continuous reporting for that device
+ if (queryIndex <= 0) {
+ queryIndex = -1;
+ } else {
+ // if read continuous mode is enabled for multiple devices,
+ // determine which device to stop reading and remove it's data from
+ // the array, shifiting other array data to fill the space
+ for (byte i = 0; i < queryIndex + 1; i++) {
+ if (query[i].addr == slaveAddress) {
+ queryIndexToSkip = i;
+ break;
+ }
+ }
+
+ for (byte i = queryIndexToSkip; i < queryIndex + 1; i++) {
+ if (i < MAX_QUERIES) {
+ query[i].addr = query[i + 1].addr;
+ query[i].reg = query[i + 1].reg;
+ query[i].bytes = query[i + 1].bytes;
+ }
+ }
+ queryIndex--;
+ }
+ break;
+ default:
+ break;
+ }
+ break;
+ case I2C_CONFIG:
+ delayTime = (argv[0] + (argv[1] << 7));
+
+ if (delayTime > 0) {
+ i2cReadDelayTime = delayTime;
+ }
+
+ if (!isI2CEnabled) {
+ enableI2CPins();
+ }
+
+ break;
+ case SERVO_CONFIG:
+ if (argc > 4) {
+ // these vars are here for clarity, they'll optimized away by the compiler
+ byte pin = argv[0];
+ int minPulse = argv[1] + (argv[2] << 7);
+ int maxPulse = argv[3] + (argv[4] << 7);
+
+ if (IS_PIN_DIGITAL(pin)) {
+ if (servoPinMap[pin] < MAX_SERVOS && servos[servoPinMap[pin]].attached()) {
+ detachServo(pin);
+ }
+ attachServo(pin, minPulse, maxPulse);
+ setPinModeCallback(pin, SERVO);
+ }
+ }
+ break;
+ case SAMPLING_INTERVAL:
+ if (argc > 1) {
+ samplingInterval = argv[0] + (argv[1] << 7);
+ if (samplingInterval < MINIMUM_SAMPLING_INTERVAL) {
+ samplingInterval = MINIMUM_SAMPLING_INTERVAL;
+ }
+ } else {
+ //Firmata.sendString("Not enough data");
+ }
+ break;
+ case EXTENDED_ANALOG:
+ if (argc > 1) {
+ int val = argv[1];
+ if (argc > 2) val |= (argv[2] << 7);
+ if (argc > 3) val |= (argv[3] << 14);
+ analogWriteCallback(argv[0], val);
+ }
+ break;
+ case CAPABILITY_QUERY:
+ Firmata.write(START_SYSEX);
+ Firmata.write(CAPABILITY_RESPONSE);
+ for (byte pin = 0; pin < TOTAL_PINS; pin++) {
+ if (IS_PIN_DIGITAL(pin)) {
+ Firmata.write((byte)INPUT);
+ Firmata.write(1);
+ Firmata.write((byte)OUTPUT);
+ Firmata.write(1);
+ }
+ if (IS_PIN_ANALOG(pin)) {
+ Firmata.write(ANALOG);
+ Firmata.write(10); // 10 = 10-bit resolution
+ }
+ if (IS_PIN_PWM(pin)) {
+ Firmata.write(PWM);
+ Firmata.write(8); // 8 = 8-bit resolution
+ }
+ if (IS_PIN_DIGITAL(pin)) {
+ Firmata.write(SERVO);
+ Firmata.write(14);
+ }
+ if (IS_PIN_I2C(pin)) {
+ Firmata.write(I2C);
+ Firmata.write(1); // TODO: could assign a number to map to SCL or SDA
+ }
+ Firmata.write(127);
+ }
+ Firmata.write(END_SYSEX);
+ break;
+ case PIN_STATE_QUERY:
+ if (argc > 0) {
+ byte pin = argv[0];
+ Firmata.write(START_SYSEX);
+ Firmata.write(PIN_STATE_RESPONSE);
+ Firmata.write(pin);
+ if (pin < TOTAL_PINS) {
+ Firmata.write((byte)pinConfig[pin]);
+ Firmata.write((byte)pinState[pin] & 0x7F);
+ if (pinState[pin] & 0xFF80) Firmata.write((byte)(pinState[pin] >> 7) & 0x7F);
+ if (pinState[pin] & 0xC000) Firmata.write((byte)(pinState[pin] >> 14) & 0x7F);
+ }
+ Firmata.write(END_SYSEX);
+ }
+ break;
+ case ANALOG_MAPPING_QUERY:
+ Firmata.write(START_SYSEX);
+ Firmata.write(ANALOG_MAPPING_RESPONSE);
+ for (byte pin = 0; pin < TOTAL_PINS; pin++) {
+ Firmata.write(IS_PIN_ANALOG(pin) ? PIN_TO_ANALOG(pin) : 127);
+ }
+ Firmata.write(END_SYSEX);
+ break;
+ }
+}
+
+void enableI2CPins()
+{
+ byte i;
+ // is there a faster way to do this? would probaby require importing
+ // Arduino.h to get SCL and SDA pins
+ for (i = 0; i < TOTAL_PINS; i++) {
+ if (IS_PIN_I2C(i)) {
+ // mark pins as i2c so they are ignore in non i2c data requests
+ setPinModeCallback(i, I2C);
+ }
+ }
+
+ isI2CEnabled = true;
+
+ Wire.begin();
+}
+
+/* disable the i2c pins so they can be used for other functions */
+void disableI2CPins() {
+ isI2CEnabled = false;
+ // disable read continuous mode for all devices
+ queryIndex = -1;
+}
+
+/*==============================================================================
+ * SETUP()
+ *============================================================================*/
+
+void systemResetCallback()
+{
+ isResetting = true;
+
+ // initialize a defalt state
+ // TODO: option to load config from EEPROM instead of default
+
+ if (isI2CEnabled) {
+ disableI2CPins();
+ }
+
+ for (byte i = 0; i < TOTAL_PORTS; i++) {
+ reportPINs[i] = false; // by default, reporting off
+ portConfigInputs[i] = 0; // until activated
+ previousPINs[i] = 0;
+ }
+
+ for (byte i = 0; i < TOTAL_PINS; i++) {
+ // pins with analog capability default to analog input
+ // otherwise, pins default to digital output
+ if (IS_PIN_ANALOG(i)) {
+ // turns off pullup, configures everything
+ setPinModeCallback(i, ANALOG);
+ } else {
+ // sets the output to 0, configures portConfigInputs
+ setPinModeCallback(i, OUTPUT);
+ }
+
+ servoPinMap[i] = 255;
+ }
+ // by default, do not report any analog inputs
+ analogInputsToReport = 0;
+
+ detachedServoCount = 0;
+ servoCount = 0;
+
+ /* send digital inputs to set the initial state on the host computer,
+ * since once in the loop(), this firmware will only send on change */
+ /*
+ TODO: this can never execute, since no pins default to digital input
+ but it will be needed when/if we support EEPROM stored config
+ for (byte i=0; i < TOTAL_PORTS; i++) {
+ outputPort(i, readPort(i, portConfigInputs[i]), true);
+ }
+ */
+ isResetting = false;
+}
+
+void setup()
+{
+ Serial1.begin(57600); // Set the baud.
+ while (!Serial1) {
+ }
+ // Wait for U-boot to finish startup. Consume all bytes until we are done.
+ do {
+ while (Serial1.available() > 0) {
+ Serial1.read();
+ }
+ delay(1000);
+ }
+ while (Serial1.available() > 0);
+
+ Firmata.setFirmwareVersion(FIRMATA_MAJOR_VERSION, FIRMATA_MINOR_VERSION);
+
+ Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
+ Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
+ Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
+ Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
+ Firmata.attach(SET_PIN_MODE, setPinModeCallback);
+ Firmata.attach(START_SYSEX, sysexCallback);
+ Firmata.attach(SYSTEM_RESET, systemResetCallback);
+
+ Firmata.begin(Serial1);
+ systemResetCallback(); // reset to default config
+}
+
+/*==============================================================================
+ * LOOP()
+ *============================================================================*/
+void loop()
+{
+ byte pin, analogPin;
+
+ /* DIGITALREAD - as fast as possible, check for changes and output them to the
+ * FTDI buffer using Serial.print() */
+ checkDigitalInputs();
+
+ /* STREAMREAD - processing incoming messagse as soon as possible, while still
+ * checking digital inputs. */
+ while (Firmata.available())
+ Firmata.processInput();
+
+ // TODO - ensure that Stream buffer doesn't go over 60 bytes
+
+ currentMillis = millis();
+ if (currentMillis - previousMillis > samplingInterval) {
+ previousMillis += samplingInterval;
+ /* ANALOGREAD - do all analogReads() at the configured sampling interval */
+ for (pin = 0; pin < TOTAL_PINS; pin++) {
+ if (IS_PIN_ANALOG(pin) && pinConfig[pin] == ANALOG) {
+ analogPin = PIN_TO_ANALOG(pin);
+ if (analogInputsToReport & (1 << analogPin)) {
+ Firmata.sendAnalog(analogPin, analogRead(analogPin));
+ }
+ }
+ }
+ // report i2c data for all device with read continuous mode enabled
+ if (queryIndex > -1) {
+ for (byte i = 0; i < queryIndex + 1; i++) {
+ readAndReportData(query[i].addr, query[i].reg, query[i].bytes);
+ }
+ }
+ }
+}
diff --git a/libraries/Firmata/extras/readme.md b/libraries/Firmata/extras/readme.md
index 498a231b9de..d1556d690c1 100644
--- a/libraries/Firmata/extras/readme.md
+++ b/libraries/Firmata/extras/readme.md
@@ -1,6 +1,8 @@
#Firmata
-Firmata is a protocol for communicating with microcontrollers from software on a host computer. The [protocol](http://firmata.org/wiki/Protocol) can be implemented in firmware on any microcontroller architecture as well as software on any host computer software package. The arduino repository described here is a Firmata library for Arduino and Arduino-compatible devices. See the [firmata wiki](http://firmata.org/wiki/Main_Page) for additional informataion. If you would like to contribute to Firmata, please see the [Contributing](#contributing) section below.
+[](https://gitter.im/firmata/arduino?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Firmata is a protocol for communicating with microcontrollers from software on a host computer. The [protocol](https://github.com/firmata/protocol) can be implemented in firmware on any microcontroller architecture as well as software on any host computer software package. The arduino repository described here is a Firmata library for Arduino and Arduino-compatible devices. If you would like to contribute to Firmata, please see the [Contributing](#contributing) section below.
##Usage
@@ -18,29 +20,42 @@ Most of the time you will be interacting with arduino with a client library on t
* [https://github.com/firmata/pyduino]
* [https://github.com/lupeke/python-firmata]
* [https://github.com/tino/pyFirmata]
+ * [https://github.com/MrYsLab/PyMata]
* perl
* [https://github.com/ntruchsess/perl-firmata]
* [https://github.com/rcaputo/rx-firmata]
-* ruby
+* ruby
* [https://github.com/hardbap/firmata]
* [https://github.com/PlasticLizard/rufinol]
* [http://funnel.cc]
* clojure
* [https://github.com/nakkaya/clodiuno]
-* javascript
+ * [https://github.com/peterschwarz/clj-firmata]
+* javascript
* [https://github.com/jgautier/firmata]
* [http://breakoutjs.com]
* [https://github.com/rwldrn/johnny-five]
-* java
+* java
* [https://github.com/4ntoine/Firmata]
* [https://github.com/shigeodayo/Javarduino]
+ * [https://github.com/kurbatov/firmata4j]
* .NET
+ * [https://github.com/SolidSoils/Arduino]
* [http://www.imagitronics.org/projects/firmatanet/]
* Flash/AS3
* [http://funnel.cc]
* [http://code.google.com/p/as3glue/]
* PHP
* [https://bitbucket.org/ThomasWeinert/carica-firmata]
+ * [https://github.com/oasynnoum/phpmake_firmata]
+* Haskell
+ * [http://hackage.haskell.org/package/hArduino]
+* iOS
+ * [https://github.com/jacobrosenthal/iosfirmata]
+* Dart
+ * [https://github.com/nfrancois/firmata]
+* Max/MSP
+ * [http://www.maxuino.org/]
Note: The above libraries may support various versions of the Firmata protocol and therefore may not support all features of the latest Firmata spec nor all arduino and arduino-compatible boards. Refer to the respective projects for details.
@@ -50,22 +65,25 @@ Note: The above libraries may support various versions of the Firmata protocol a
If you discover a bug or would like to propose a new feature, please open a new [issue](https://github.com/firmata/arduino/issues?sort=created&state=open). Due to the limited memory of standard Arduino boards we cannot add every requested feature to StandardFirmata. Requests to add new features to StandardFirmata will be evaluated by the Firmata developers. However it is still possible to add new features to other Firmata implementations (Firmata is a protocol whereas StandardFirmata is just one of many possible implementations).
-To contribute, fork this respository and create a new topic branch for the bug, feature or other existing issue you are addressing. Submit the pull request against the *dev* branch.
+To contribute, fork this repository and create a new topic branch for the bug, feature or other existing issue you are addressing. Submit the pull request against the *master* branch.
If you would like to contribute but don't have a specific bugfix or new feature to contribute, you can take on an existing issue, see issues labeled "pull-request-encouraged". Add a comment to the issue to express your intent to begin work and/or to get any additional information about the issue.
-You must thorougly test your contributed code. In your pull request, describe tests performed to ensure that no existing code is broken and that any changes maintain backwards compatibility with the existing api. Test on multiple Arduino board variants if possible. We hope to enable some form of automated (or at least semi-automated) testing in the future, but for now any tests will need to be executed manually by the contributor and reviewsers.
+You must thoroughly test your contributed code. In your pull request, describe tests performed to ensure that no existing code is broken and that any changes maintain backwards compatibility with the existing api. Test on multiple Arduino board variants if possible. We hope to enable some form of automated (or at least semi-automated) testing in the future, but for now any tests will need to be executed manually by the contributor and reviewers.
-Maintain the existing code style:
+Use [Artistic Style](http://astyle.sourceforge.net/) (astyle) to format your code. Set the following rules for the astyle formatter:
-- Indentation is 2 spaces
-- Use spaces instead of tabs
-- Use camel case for both private and public properties and methods
-- Document functions (specific doc style is TBD... for now just be sure to document)
-- Insert first block bracket on line following the function definition:
+```
+style = ""
+indent = "spaces"
+indent-spaces = 2
+indent-classes = true
+indent-switches = true
+indent-cases = true
+indent-col1-comments = true
+pad-oper = true
+pad-header = true
+keep-one-line-statements = true
+```
-void someFunction()
-{
- // do something
-}
-
+If you happen to use Sublime Text, [this astyle plugin](https://github.com/timonwong/SublimeAStyleFormatter) is helpful. Set the above rules in the user settings file.
diff --git a/libraries/Firmata/extras/revisions.txt b/libraries/Firmata/extras/revisions.txt
new file mode 100644
index 00000000000..9a933d24781
--- /dev/null
+++ b/libraries/Firmata/extras/revisions.txt
@@ -0,0 +1,141 @@
+FIRMATA 2.4.3 - Apr 11, 2015
+
+[core library]
+* Added debug macros (utility/firmataDebug.h)
+* Added Norbert Truchsess' EthernetClientStream lib from the configurable branch
+
+[examples]
+* Added StandardFirmataEthernet to enable Firmata over Ethernet
+* Minor updates to StandardFirmata and StandardFirmataYun
+
+FIRMATA 2.4.2 - Mar 16, 2015
+
+[core library]
+* Add support for Teesy 3.1 (Olivier Louvignes)
+
+FIRMATA 2.4.1 - Feb 7, 2015
+
+[core library]
+* Fixed off-by-one bug in setFirmwareNameAndVersion (Brian Schmalz)
+
+[StandardFirmata]
+* Prevent analog values from being reported during system reset
+
+FIRMATA 2.4.0 - Dec 21, 2014
+
+Changes from 2.3.6 to 2.4 that may impact existing Firmata client implementations:
+
+* When sending a string from the client application to the board (STRING_DATA) a
+static buffer is now used for the incoming string in place of a dynamically allocated
+block of memory (see Firmata.cpp lines 181 - 205). In Firmata 2.3.6 and older,
+the dynamically allocated block was never freed, causing a memory leak. If your
+client library had freed this memory in the string callback method, that code
+will break in Firmata 2.4. If the string data needs to persist beyond the string
+callback, it should be copied within the string callback.
+
+* As of Firmata 2.4, when digital port reporting or analog pin reporting is enabled,
+the value of the port (digital) or pin (analog) is immediately sent back to the client
+application. This will likely not have a negative impact on existing client
+implementations, but may be unexpected. This feature was added to better support
+non-serial streams (such as Ethernet, Wi-Fi, Bluetooth, etc) that may lose
+connectivity and need a quick way to get the current state of the pins upon
+reestablishing a connection.
+
+[core library]
+* Changed sendValueAsTwo7bitBytes, startSysex and endSysex from private to
+ public methods.
+* Added Intel Galileo to Boards.h
+* Renamed FirmataSerial to FirmataStream
+* Updated to latest Arduino library format
+* writePort function in Boards.h now returns 1 (to suppress compiler warning)
+* Updated syntax highlighting (keywords.txt)
+* Fixed IS_PIN_SPI ifndef condition in boards.h
+* Added constants to Firmata.h to reserve configurable firmata features
+* Fixed issue where firmwareName was not reported correctly in Windows
+* Ensure incoming String via STRING_DATA command is null-terminated
+* Fixed memory leak when receiving String via STRING_DATA command
+ (note this change may break existing code if you were manually deallocating
+ the incoming string in your string callback function. See code for details)
+* Added ability for user to specify a filename when calling setFirmwareNameAndVersion
+* Increased input data buffer size from 32 to 64 bytes
+
+[StandardFirmata]
+* Updated I2C_READ_CONTINUOUSLY to work with or without slaveRegister (Rick Waldron)
+* Added Yun variant of StandardFirmata
+* When a digital port is enabled, its value is now immediately sent to the client
+* When an analog pin is enabled, its value is now immediately sent to the client
+* Changed the way servo pins are mapped to enable use of servos on
+ a wider range of pins, including analog pins.
+* Fixed management of unexpected sized I2C replies (Nahuel Greco)
+* Fixed a bug when removing a monitored device with I2C_STOP_Reading (Nahuel Greco)
+* Fixed conditional expression in I2C_STOP_READING case
+* Changed samplingInterval from type int to type unsigned int
+* Shortened error message strings to save a few bytes
+
+[examples]
+* Updated FirmataServo example to use new pin mapping technique
+* Removed makefiles from examples (because they were not being updated)
+* Updated all examples to set current firmware version
+
+FIRMATA 2.3.6 - Jun 18, 2013 (Version included with Arduino core libraries)
+
+[core library]
+* Fixed bug introduced in 2.3.5 that broke ability to use Ethernet.
+
+FIRMATA 2.3.5 - May 21, 2013
+
+[core library]
+* Added Arduino Due to Boards.h
+* Added Teensy 3.0 to Boards.h
+* Updated unit tests to use ArduinoUnit v2.0
+* Renamed pin13strobe to strobeBlinkPin
+* Removed blinkVersion method from begin method for non-serial streams
+* Fixed memory leak in setting firmware version (Matthew Murdoch)
+* Added unit tests for a few core functions (Matthew Murdoch)
+* Added IS_PIN_SPI macro to all board definitions in Board.h (Norbert Truchsess)
+
+FIRMATA 2.3.4 - Feb 11, 2013
+
+[core library]
+* Fixed Stream implementation so Firmata can be used with Streams other than
+ Serial (Norbert Truchsess)
+
+FIRMATA 2.3.3 - Oct 6, 2012
+
+[core library]
+* Added write method to expose FirmataSerial.write
+* Added Arduino Leonardo to Boards.h
+
+[StandardFirmata]
+* Changed all instances of Serial.write to Firmata.write
+* Fixed delayMicroseconds(0) bug in readAndReportData
+
+FIRMATA 2.3.0 - 2.3.2
+
+* Removed angle from servo config
+* Changed file extensions from .pde to .ino
+* Added MEGA2560 to Boards.h
+* Added I2C pins to Boards.h
+* Modified examples to be compatible with Arduino 0022 and 1.0 or greater
+* Removed I2CFirmata example
+* Changes to StandardFirmata
+ * Added I2C support
+ * Added system reset message to reset all pins to default config on sysex reset
+
+FIRMATA 2.2 (changes prior to Firmata 2.3.0 were not well documented)
+
+* changes undocumented
+
+FIRMATA 2.1
+
+* added support for changing the sampling interval
+* added Servo support
+
+FIRMATA 2.0
+
+* changed to 8-bit port-based digital messages to mirror ports from previous 14-bit ports modeled after the standard Arduino board.
+* switched order of version message so major version is reported first
+
+FIRMATA 1.0
+
+* switched to MIDI-compatible packet format (though the message interpretation differs)
diff --git a/libraries/Firmata/keywords.txt b/libraries/Firmata/keywords.txt
index ca4522c3d40..f384be18256 100644
--- a/libraries/Firmata/keywords.txt
+++ b/libraries/Firmata/keywords.txt
@@ -6,57 +6,66 @@
# Datatypes (KEYWORD1)
#######################################
-Firmata KEYWORD1 Firmata
-callbackFunction KEYWORD1
-systemResetCallbackFunction KEYWORD1
-stringCallbackFunction KEYWORD1
-sysexCallbackFunction KEYWORD1
+Firmata KEYWORD1
+callbackFunction KEYWORD1
+systemResetCallbackFunction KEYWORD1
+stringCallbackFunction KEYWORD1
+sysexCallbackFunction KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
-begin KEYWORD2
-begin KEYWORD2
-printVersion KEYWORD2
-blinkVersion KEYWORD2
-printFirmwareVersion KEYWORD2
-setFirmwareVersion KEYWORD2
-setFirmwareNameAndVersion KEYWORD2
-available KEYWORD2
-processInput KEYWORD2
-sendAnalog KEYWORD2
-sendDigital KEYWORD2
-sendDigitalPortPair KEYWORD2
-sendDigitalPort KEYWORD2
-sendString KEYWORD2
-sendString KEYWORD2
-sendSysex KEYWORD2
-attach KEYWORD2
-detach KEYWORD2
-flush KEYWORD2
+begin KEYWORD2
+printVersion KEYWORD2
+blinkVersion KEYWORD2
+printFirmwareVersion KEYWORD2
+setFirmwareVersion KEYWORD2
+setFirmwareNameAndVersion KEYWORD2
+available KEYWORD2
+processInput KEYWORD2
+sendAnalog KEYWORD2
+sendDigital KEYWORD2
+sendDigitalPort KEYWORD2
+sendString KEYWORD2
+sendSysex KEYWORD2
+attach KEYWORD2
+detach KEYWORD2
+write KEYWORD2
+sendValueAsTwo7bitBytes KEYWORD2
+startSysex KEYWORD2
+endSysex KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################
-MAX_DATA_BYTES LITERAL1
+MAX_DATA_BYTES LITERAL1
-DIGITAL_MESSAGE LITERAL1
-ANALOG_MESSAGE LITERAL1
-REPORT_ANALOG LITERAL1
-REPORT_DIGITAL LITERAL1
-REPORT_VERSION LITERAL1
-SET_PIN_MODE LITERAL1
-SYSTEM_RESET LITERAL1
+DIGITAL_MESSAGE LITERAL1
+ANALOG_MESSAGE LITERAL1
+REPORT_ANALOG LITERAL1
+REPORT_DIGITAL LITERAL1
+REPORT_VERSION LITERAL1
+SET_PIN_MODE LITERAL1
+SYSTEM_RESET LITERAL1
+START_SYSEX LITERAL1
+END_SYSEX LITERAL1
-START_SYSEX LITERAL1
-END_SYSEX LITERAL1
+ANALOG LITERAL1
+PWM LITERAL1
+SERVO LITERAL1
+SHIFT LITERAL1
+I2C LITERAL1
+ONEWIRE LITERAL1
+STEPPER LITERAL1
+ENCODER LITERAL1
+IGNORE LITERAL1
-PWM LITERAL1
-TOTAL_ANALOG_PINS LITERAL1
-TOTAL_DIGITAL_PINS LITERAL1
-TOTAL_PORTS LITERAL1
-ANALOG_PORT LITERAL1
+TOTAL_ANALOG_PINS LITERAL1
+TOTAL_DIGITAL_PINS LITERAL1
+TOTAL_PIN_MODES LITERAL1
+TOTAL_PORTS LITERAL1
+ANALOG_PORT LITERAL1
diff --git a/libraries/Firmata/library.properties b/libraries/Firmata/library.properties
index 4b508d57cc6..fd9eea05d9b 100644
--- a/libraries/Firmata/library.properties
+++ b/libraries/Firmata/library.properties
@@ -1,9 +1,9 @@
-name=Firmata
-version=2.3.8
-author=Firmata Developers
-maintainer=Firmata Developers
-sentence=Enables the communication with computer apps using a standard serial protocol. For all Arduino boards.
-paragraph=The Firmata library implements the Firmata protocol for communicating with software on the host computer. This allows you to write custom firmware without having to create your own protocol and objects for the programming environment that you are using.
-category=Device Control
-url=http://firmata.org
-architectures=*
+name=Firmata
+version=2.4.3
+author=Firmata Developers
+maintainer=https://github.com/firmata/arduino
+sentence=Enables the communication with computer apps using a standard serial protocol. For all Arduino boards.
+paragraph=The Firmata library implements the Firmata protocol for communicating with software on the host computer. This allows you to write custom firmware without having to create your own protocol and objects for the programming environment that you are using.
+category=Device Control
+url=https://github.com/firmata/arduino
+architectures=*
diff --git a/libraries/Firmata/src/Boards.h b/libraries/Firmata/src/Boards.h
index 67cae11a8fb..37a3da19a34 100644
--- a/libraries/Firmata/src/Boards.h
+++ b/libraries/Firmata/src/Boards.h
@@ -1,4 +1,14 @@
-/* Boards.h - Hardware Abstraction Layer for Firmata library */
+/*
+ Boards.h - Hardware Abstraction Layer for 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.
+*/
#ifndef Firmata_Boards_h
#define Firmata_Boards_h
@@ -6,7 +16,7 @@
#include
#if defined(ARDUINO) && ARDUINO >= 100
-#include "Arduino.h" // for digitalRead, digitalWrite, etc
+#include "Arduino.h" // for digitalRead, digitalWrite, etc
#else
#include "WProgram.h"
#endif
@@ -23,7 +33,7 @@
Firmata Hardware Abstraction Layer
Firmata is built on top of the hardware abstraction functions of Arduino,
-specifically digitalWrite, digitalRead, analogWrite, analogRead, and
+specifically digitalWrite, digitalRead, analogWrite, analogRead, and
pinMode. While these functions offer simple integer pin numbers, Firmata
needs more information than is provided by Arduino. This file provides
all other hardware specific details. To make Firmata support a new board,
@@ -163,7 +173,7 @@ writePort(port, value, bitmask): Write an 8 bit port.
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - FIRST_ANALOG_PIN)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
-#define PIN_TO_SERVO(p) (p)
+#define PIN_TO_SERVO(p) (p)
// old Arduinos
@@ -250,8 +260,8 @@ writePort(port, value, bitmask): Write an 8 bit port.
#define PIN_TO_SERVO(p) (p)
-// Teensy 3.0
-#elif defined(__MK20DX128__)
+// Teensy 3.0 and 3.1
+#elif defined(__MK20DX128__) || defined(__MK20DX256__)
#define TOTAL_ANALOG_PINS 14
#define TOTAL_PINS 38 // 24 digital + 10 analog-digital + 4 analog
#define VERSION_BLINK_PIN 13
@@ -263,7 +273,7 @@ writePort(port, value, bitmask): Write an 8 bit port.
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (((p)<=23)?(p)-14:(p)-24)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
-#define PIN_TO_SERVO(p) (p)
+#define PIN_TO_SERVO(p) (p)
// Teensy++ 1.0 and 2.0
@@ -297,7 +307,24 @@ writePort(port, value, bitmask): Write an 8 bit port.
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (p) - 18
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
-#define PIN_TO_SERVO(p) (p)
+#define PIN_TO_SERVO(p) (p)
+
+
+// Intel Galileo Board
+#elif defined(ARDUINO_LINUX)
+#define TOTAL_ANALOG_PINS 6
+#define TOTAL_PINS 20 // 14 digital + 6 analog
+#define VERSION_BLINK_PIN 13
+#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 19)
+#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 19)
+#define IS_PIN_PWM(p) digitalPinHasPWM(p)
+#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) - 2 < MAX_SERVOS)
+#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL)
+#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
+#define PIN_TO_DIGITAL(p) (p)
+#define PIN_TO_ANALOG(p) ((p) - 14)
+#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
+#define PIN_TO_SERVO(p) ((p) - 2)
// Sanguino
@@ -338,7 +365,7 @@ writePort(port, value, bitmask): Write an 8 bit port.
#endif
// as long this is not defined for all boards:
-#ifndef IS_PIN_SPI(p)
+#ifndef IS_PIN_SPI
#define IS_PIN_SPI(p) 0
#endif
@@ -350,21 +377,21 @@ static inline unsigned char readPort(byte, byte) __attribute__((always_inline, u
static inline unsigned char readPort(byte port, byte bitmask)
{
#if defined(ARDUINO_PINOUT_OPTIMIZE)
- if (port == 0) return (PIND & 0xFC) & bitmask; // ignore Rx/Tx 0/1
- if (port == 1) return ((PINB & 0x3F) | ((PINC & 0x03) << 6)) & bitmask;
- if (port == 2) return ((PINC & 0x3C) >> 2) & bitmask;
- return 0;
+ if (port == 0) return (PIND & 0xFC) & bitmask; // ignore Rx/Tx 0/1
+ if (port == 1) return ((PINB & 0x3F) | ((PINC & 0x03) << 6)) & bitmask;
+ if (port == 2) return ((PINC & 0x3C) >> 2) & bitmask;
+ return 0;
#else
- unsigned char out=0, pin=port*8;
- if (IS_PIN_DIGITAL(pin+0) && (bitmask & 0x01) && digitalRead(PIN_TO_DIGITAL(pin+0))) out |= 0x01;
- if (IS_PIN_DIGITAL(pin+1) && (bitmask & 0x02) && digitalRead(PIN_TO_DIGITAL(pin+1))) out |= 0x02;
- if (IS_PIN_DIGITAL(pin+2) && (bitmask & 0x04) && digitalRead(PIN_TO_DIGITAL(pin+2))) out |= 0x04;
- if (IS_PIN_DIGITAL(pin+3) && (bitmask & 0x08) && digitalRead(PIN_TO_DIGITAL(pin+3))) out |= 0x08;
- if (IS_PIN_DIGITAL(pin+4) && (bitmask & 0x10) && digitalRead(PIN_TO_DIGITAL(pin+4))) out |= 0x10;
- if (IS_PIN_DIGITAL(pin+5) && (bitmask & 0x20) && digitalRead(PIN_TO_DIGITAL(pin+5))) out |= 0x20;
- if (IS_PIN_DIGITAL(pin+6) && (bitmask & 0x40) && digitalRead(PIN_TO_DIGITAL(pin+6))) out |= 0x40;
- if (IS_PIN_DIGITAL(pin+7) && (bitmask & 0x80) && digitalRead(PIN_TO_DIGITAL(pin+7))) out |= 0x80;
- return out;
+ unsigned char out = 0, pin = port * 8;
+ if (IS_PIN_DIGITAL(pin + 0) && (bitmask & 0x01) && digitalRead(PIN_TO_DIGITAL(pin + 0))) out |= 0x01;
+ if (IS_PIN_DIGITAL(pin + 1) && (bitmask & 0x02) && digitalRead(PIN_TO_DIGITAL(pin + 1))) out |= 0x02;
+ if (IS_PIN_DIGITAL(pin + 2) && (bitmask & 0x04) && digitalRead(PIN_TO_DIGITAL(pin + 2))) out |= 0x04;
+ if (IS_PIN_DIGITAL(pin + 3) && (bitmask & 0x08) && digitalRead(PIN_TO_DIGITAL(pin + 3))) out |= 0x08;
+ if (IS_PIN_DIGITAL(pin + 4) && (bitmask & 0x10) && digitalRead(PIN_TO_DIGITAL(pin + 4))) out |= 0x10;
+ if (IS_PIN_DIGITAL(pin + 5) && (bitmask & 0x20) && digitalRead(PIN_TO_DIGITAL(pin + 5))) out |= 0x20;
+ if (IS_PIN_DIGITAL(pin + 6) && (bitmask & 0x40) && digitalRead(PIN_TO_DIGITAL(pin + 6))) out |= 0x40;
+ if (IS_PIN_DIGITAL(pin + 7) && (bitmask & 0x80) && digitalRead(PIN_TO_DIGITAL(pin + 7))) out |= 0x80;
+ return out;
#endif
}
@@ -376,40 +403,42 @@ static inline unsigned char writePort(byte, byte, byte) __attribute__((always_in
static inline unsigned char writePort(byte port, byte value, byte bitmask)
{
#if defined(ARDUINO_PINOUT_OPTIMIZE)
- if (port == 0) {
- bitmask = bitmask & 0xFC; // do not touch Tx & Rx pins
- byte valD = value & bitmask;
- byte maskD = ~bitmask;
- cli();
- PORTD = (PORTD & maskD) | valD;
- sei();
- } else if (port == 1) {
- byte valB = (value & bitmask) & 0x3F;
- byte valC = (value & bitmask) >> 6;
- byte maskB = ~(bitmask & 0x3F);
- byte maskC = ~((bitmask & 0xC0) >> 6);
- cli();
- PORTB = (PORTB & maskB) | valB;
- PORTC = (PORTC & maskC) | valC;
- sei();
- } else if (port == 2) {
- bitmask = bitmask & 0x0F;
- byte valC = (value & bitmask) << 2;
- byte maskC = ~(bitmask << 2);
- cli();
- PORTC = (PORTC & maskC) | valC;
- sei();
- }
+ if (port == 0) {
+ bitmask = bitmask & 0xFC; // do not touch Tx & Rx pins
+ byte valD = value & bitmask;
+ byte maskD = ~bitmask;
+ cli();
+ PORTD = (PORTD & maskD) | valD;
+ sei();
+ } else if (port == 1) {
+ byte valB = (value & bitmask) & 0x3F;
+ byte valC = (value & bitmask) >> 6;
+ byte maskB = ~(bitmask & 0x3F);
+ byte maskC = ~((bitmask & 0xC0) >> 6);
+ cli();
+ PORTB = (PORTB & maskB) | valB;
+ PORTC = (PORTC & maskC) | valC;
+ sei();
+ } else if (port == 2) {
+ bitmask = bitmask & 0x0F;
+ byte valC = (value & bitmask) << 2;
+ byte maskC = ~(bitmask << 2);
+ cli();
+ PORTC = (PORTC & maskC) | valC;
+ sei();
+ }
+ return 1;
#else
- byte pin=port*8;
- if ((bitmask & 0x01)) digitalWrite(PIN_TO_DIGITAL(pin+0), (value & 0x01));
- if ((bitmask & 0x02)) digitalWrite(PIN_TO_DIGITAL(pin+1), (value & 0x02));
- if ((bitmask & 0x04)) digitalWrite(PIN_TO_DIGITAL(pin+2), (value & 0x04));
- if ((bitmask & 0x08)) digitalWrite(PIN_TO_DIGITAL(pin+3), (value & 0x08));
- if ((bitmask & 0x10)) digitalWrite(PIN_TO_DIGITAL(pin+4), (value & 0x10));
- if ((bitmask & 0x20)) digitalWrite(PIN_TO_DIGITAL(pin+5), (value & 0x20));
- if ((bitmask & 0x40)) digitalWrite(PIN_TO_DIGITAL(pin+6), (value & 0x40));
- if ((bitmask & 0x80)) digitalWrite(PIN_TO_DIGITAL(pin+7), (value & 0x80));
+ byte pin = port * 8;
+ if ((bitmask & 0x01)) digitalWrite(PIN_TO_DIGITAL(pin + 0), (value & 0x01));
+ if ((bitmask & 0x02)) digitalWrite(PIN_TO_DIGITAL(pin + 1), (value & 0x02));
+ if ((bitmask & 0x04)) digitalWrite(PIN_TO_DIGITAL(pin + 2), (value & 0x04));
+ if ((bitmask & 0x08)) digitalWrite(PIN_TO_DIGITAL(pin + 3), (value & 0x08));
+ if ((bitmask & 0x10)) digitalWrite(PIN_TO_DIGITAL(pin + 4), (value & 0x10));
+ if ((bitmask & 0x20)) digitalWrite(PIN_TO_DIGITAL(pin + 5), (value & 0x20));
+ if ((bitmask & 0x40)) digitalWrite(PIN_TO_DIGITAL(pin + 6), (value & 0x40));
+ if ((bitmask & 0x80)) digitalWrite(PIN_TO_DIGITAL(pin + 7), (value & 0x80));
+ return 1;
#endif
}
diff --git a/libraries/Firmata/src/Firmata.cpp b/libraries/Firmata/src/Firmata.cpp
index 7dddfd46566..7ecead8c1a3 100644
--- a/libraries/Firmata/src/Firmata.cpp
+++ b/libraries/Firmata/src/Firmata.cpp
@@ -1,7 +1,7 @@
/*
- Firmata.cpp - Firmata library
- Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
-
+ Firmata.cpp - Firmata library v2.4.3 - 2015-4-11
+ 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
@@ -28,18 +28,18 @@ extern "C" {
void FirmataClass::sendValueAsTwo7bitBytes(int value)
{
- FirmataSerial->write(value & B01111111); // LSB
- FirmataSerial->write(value >> 7 & B01111111); // MSB
+ FirmataStream->write(value & B01111111); // LSB
+ FirmataStream->write(value >> 7 & B01111111); // MSB
}
void FirmataClass::startSysex(void)
{
- FirmataSerial->write(START_SYSEX);
+ FirmataStream->write(START_SYSEX);
}
void FirmataClass::endSysex(void)
{
- FirmataSerial->write(END_SYSEX);
+ FirmataStream->write(END_SYSEX);
}
//******************************************************************************
@@ -67,7 +67,7 @@ void FirmataClass::begin(void)
void FirmataClass::begin(long speed)
{
Serial.begin(speed);
- FirmataSerial = &Serial;
+ FirmataStream = &Serial;
blinkVersion();
printVersion();
printFirmwareVersion();
@@ -76,7 +76,7 @@ void FirmataClass::begin(long speed)
/* begin method for overriding default stream */
void FirmataClass::begin(Stream &s)
{
- FirmataSerial = &s;
+ FirmataStream = &s;
// do not call blinkVersion() here because some hardware such as the
// Ethernet shield use pin 13
printVersion();
@@ -84,16 +84,17 @@ void FirmataClass::begin(Stream &s)
}
// 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::printVersion(void)
+{
+ FirmataStream->write(REPORT_VERSION);
+ FirmataStream->write(FIRMATA_MAJOR_VERSION);
+ FirmataStream->write(FIRMATA_MINOR_VERSION);
}
void FirmataClass::blinkVersion(void)
{
// flash the pin with the protocol version
- pinMode(VERSION_BLINK_PIN,OUTPUT);
+ pinMode(VERSION_BLINK_PIN, OUTPUT);
strobeBlinkPin(FIRMATA_MAJOR_VERSION, 40, 210);
delay(250);
strobeBlinkPin(FIRMATA_MINOR_VERSION, 40, 210);
@@ -104,12 +105,12 @@ void FirmataClass::printFirmwareVersion(void)
{
byte i;
- if(firmwareVersionCount) { // make sure that the name has been set before reporting
+ 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; iwrite(REPORT_FIRMWARE);
+ FirmataStream->write(firmwareVersionVector[0]); // major version number
+ FirmataStream->write(firmwareVersionVector[1]); // minor version number
+ for (i = 2; i < firmwareVersionCount; ++i) {
sendValueAsTwo7bitBytes(firmwareVersionVector[i]);
}
endSysex();
@@ -118,87 +119,94 @@ void FirmataClass::printFirmwareVersion(void)
void FirmataClass::setFirmwareNameAndVersion(const char *name, byte major, byte minor)
{
- const char *filename;
- char *extension;
+ const char *firmwareName;
+ const 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;
+ firmwareName = strrchr(name, '/');
+
+ if (!firmwareName) {
+ // windows
+ firmwareName = strrchr(name, '\\');
+ }
+ if (!firmwareName) {
+ // user passed firmware name
+ firmwareName = name;
+ } else {
+ firmwareName ++;
+ }
+
+ if (!extension) {
+ firmwareVersionCount = strlen(firmwareName) + 2;
} else {
- firmwareVersionCount = strlen(name) + 2;
- filename = name;
+ firmwareVersionCount = extension - firmwareName + 2;
}
+ // in case anyone calls setFirmwareNameAndVersion more than once
free(firmwareVersionVector);
- firmwareVersionVector = (byte *) malloc(firmwareVersionCount);
+ firmwareVersionVector = (byte *) malloc(firmwareVersionCount + 1);
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);
+ strncpy((char *)firmwareVersionVector + 2, firmwareName, firmwareVersionCount - 2);
}
-// this method is only used for unit testing
-// void FirmataClass::unsetFirmwareVersion()
-// {
-// firmwareVersionCount = 0;
-// free(firmwareVersionVector);
-// firmwareVersionVector = 0;
-// }
-
//------------------------------------------------------------------------------
// Serial Receive Handling
int FirmataClass::available(void)
{
- return FirmataSerial->available();
+ return FirmataStream->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++;
+ switch (storedInputData[0]) { //first byte in buffer is command
+ case REPORT_FIRMWARE:
+ printFirmwareVersion();
+ break;
+ case STRING_DATA:
+ if (currentStringCallback) {
+ byte bufferLength = (sysexBytesRead - 1) / 2;
+ byte i = 1;
+ byte j = 0;
+ while (j < bufferLength) {
+ // The string length will only be at most half the size of the
+ // stored input buffer so we can decode the string within the buffer.
+ storedInputData[j] = storedInputData[i];
+ i++;
+ storedInputData[j] += (storedInputData[i] << 7);
+ i++;
+ j++;
+ }
+ // Make sure string is null terminated. This may be the case for data
+ // coming from client libraries in languages that don't null terminate
+ // strings.
+ if (storedInputData[j - 1] != '\0') {
+ storedInputData[j] = '\0';
+ }
+ (*currentStringCallback)((char *)&storedInputData[0]);
}
- (*currentStringCallback)(buffer);
- }
- break;
- default:
- if(currentSysexCallback)
- (*currentSysexCallback)(storedInputData[0], sysexBytesRead - 1, storedInputData + 1);
+ 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 inputData = FirmataStream->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
+ if (inputData == END_SYSEX) {
+ //stop sysex byte
parsingSysex = false;
//fire off handler function
processSysexMessage();
@@ -207,43 +215,43 @@ void FirmataClass::processInput(void)
storedInputData[sysexBytesRead] = inputData;
sysexBytesRead++;
}
- } else if( (waitForData > 0) && (inputData < 128) ) {
+ } 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;
+ 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) {
+ if (inputData < 0xF0) {
command = inputData & 0xF0;
multiByteChannel = inputData & 0x0F;
} else {
@@ -251,27 +259,27 @@ void FirmataClass::processInput(void)
// 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; // two data bytes needed
- executeMultiByteCommand = command;
- break;
- case START_SYSEX:
- parsingSysex = true;
- sysexBytesRead = 0;
- break;
- case SYSTEM_RESET:
- systemReset();
- break;
- case REPORT_VERSION:
- Firmata.printVersion();
- break;
+ 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;
}
}
}
@@ -280,15 +288,15 @@ void FirmataClass::processInput(void)
// Serial Send Handling
// send an analog message
-void FirmataClass::sendAnalog(byte pin, int value)
+void FirmataClass::sendAnalog(byte pin, int value)
{
// pin can only be 0-15, so chop higher bits
- FirmataSerial->write(ANALOG_MESSAGE | (pin & 0xF));
+ FirmataStream->write(ANALOG_MESSAGE | (pin & 0xF));
sendValueAsTwo7bitBytes(value);
}
// send a single digital pin in a digital message
-void FirmataClass::sendDigital(byte pin, int value)
+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
@@ -314,31 +322,31 @@ void FirmataClass::sendDigital(byte pin, int value)
// 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
+ FirmataStream->write(DIGITAL_MESSAGE | (portNumber & 0xF));
+ FirmataStream->write((byte)portData % 128); // Tx bits 0-6
+ FirmataStream->write(portData >> 7); // Tx bits 7-13
}
-void FirmataClass::sendSysex(byte command, byte bytec, byte* bytev)
+void FirmataClass::sendSysex(byte command, byte bytec, byte *bytev)
{
byte i;
startSysex();
- FirmataSerial->write(command);
- for(i=0; iwrite(command);
+ for (i = 0; i < bytec; i++) {
+ sendValueAsTwo7bitBytes(bytev[i]);
}
endSysex();
}
-void FirmataClass::sendString(byte command, const char* string)
+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)
+void FirmataClass::sendString(const char *string)
{
sendString(STRING_DATA, string);
}
@@ -346,7 +354,7 @@ void FirmataClass::sendString(const char* string)
// expose the write method
void FirmataClass::write(byte c)
{
- FirmataSerial->write(c);
+ FirmataStream->write(c);
}
@@ -355,26 +363,26 @@ void FirmataClass::write(byte c)
// 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;
+ 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;
+ switch (command) {
+ case SYSTEM_RESET: currentSystemResetCallback = newFunction; break;
}
}
void FirmataClass::attach(byte command, stringCallbackFunction newFunction)
{
- switch(command) {
- case STRING_DATA: currentStringCallback = newFunction; break;
+ switch (command) {
+ case STRING_DATA: currentStringCallback = newFunction; break;
}
}
@@ -385,12 +393,12 @@ void FirmataClass::attach(byte command, sysexCallbackFunction 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);
+ 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);
}
}
@@ -427,28 +435,26 @@ void FirmataClass::systemReset(void)
executeMultiByteCommand = 0; // execute this after getting multi-byte data
multiByteChannel = 0; // channel data for multiByteCommands
- for(i=0; i
+
+//#define SERIAL_DEBUG
+#include "firmataDebug.h"
+
+#define MILLIS_RECONNECT 5000
+
+EthernetClientStream::EthernetClientStream(Client &client, IPAddress localip, IPAddress ip, const char* host, uint16_t port)
+: ip(ip),
+ host(host),
+ port(port),
+ connected(false),
+ client(client),
+ localip(localip)
+{
+}
+
+int
+EthernetClientStream::available()
+{
+ return maintain() ? client.available() : 0;
+}
+
+int
+EthernetClientStream::read()
+{
+ return maintain() ? client.read() : -1;
+}
+
+int
+EthernetClientStream::peek()
+{
+ return maintain() ? client.peek() : -1;
+}
+
+void EthernetClientStream::flush()
+{
+ if (maintain())
+ client.flush();
+}
+
+size_t
+EthernetClientStream::write(uint8_t c)
+{
+ return maintain() ? client.write(c) : 0;
+}
+
+void
+EthernetClientStream::maintain(IPAddress localip)
+{
+ if (this->localip!=localip)
+ {
+ this->localip = localip;
+ if (connected)
+ stop();
+ }
+}
+
+void
+EthernetClientStream::stop()
+{
+ client.stop();
+ connected = false;
+ time_connect = millis();
+}
+
+bool
+EthernetClientStream::maintain()
+{
+ if (client && client.connected())
+ return true;
+
+ if (connected)
+ {
+ stop();
+ }
+ else if (millis()-time_connect >= MILLIS_RECONNECT)
+ {
+ connected = host ? client.connect(host,port) : client.connect(ip,port);
+ if (!connected) {
+ time_connect = millis();
+ DEBUG_PRINTLN("connection failed");
+ } else {
+ DEBUG_PRINTLN("connected");
+ }
+ }
+ return connected;
+}
diff --git a/libraries/Firmata/src/utility/EthernetClientStream.h b/libraries/Firmata/src/utility/EthernetClientStream.h
new file mode 100644
index 00000000000..c0d34e54e3b
--- /dev/null
+++ b/libraries/Firmata/src/utility/EthernetClientStream.h
@@ -0,0 +1,52 @@
+/*
+ EthernetClientStream.h
+ An Arduino-Stream that wraps an instance of Client reconnecting to
+ the remote-ip in a transparent way. A disconnected client may be
+ recognized by the returnvalues -1 from calls to peek or read and
+ a 0 from calls to write.
+
+ Copyright (C) 2013 Norbert Truchsess. 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.
+
+ formatted using the GNU C formatting and indenting
+ */
+
+#ifndef ETHERNETCLIENTSTREAM_H
+#define ETHERNETCLIENTSTREAM_H
+
+#include
+#include
+#include
+#include
+#include
+
+class EthernetClientStream : public Stream
+{
+public:
+ EthernetClientStream(Client &client, IPAddress localip, IPAddress ip, const char* host, uint16_t port);
+ int available();
+ int read();
+ int peek();
+ void flush();
+ size_t write(uint8_t);
+ void maintain(IPAddress localip);
+
+private:
+ IPAddress localip;
+ IPAddress ip;
+ const char* host;
+ uint16_t port;
+ Client &client;
+ bool connected;
+ uint32_t time_connect;
+ bool maintain();
+ void stop();
+};
+
+#endif
diff --git a/libraries/Firmata/src/utility/firmataDebug.h b/libraries/Firmata/src/utility/firmataDebug.h
new file mode 100644
index 00000000000..6e364b0c7b5
--- /dev/null
+++ b/libraries/Firmata/src/utility/firmataDebug.h
@@ -0,0 +1,14 @@
+#ifndef FIRMATA_DEBUG_H
+#define FIRMATA_DEBUG_H
+
+#ifdef SERIAL_DEBUG
+ #define DEBUG_BEGIN(baud) Serial.begin(baud); while(!Serial) {;}
+ #define DEBUG_PRINTLN(x) Serial.println (x)
+ #define DEBUG_PRINT(x) Serial.print (x)
+#else
+ #define DEBUG_BEGIN(baud)
+ #define DEBUG_PRINTLN(x)
+ #define DEBUG_PRINT(x)
+#endif
+
+#endif /* FIRMATA_DEBUG_H */
diff --git a/libraries/LiquidCrystal/examples/setCursor/setCursor.ino b/libraries/LiquidCrystal/examples/setCursor/setCursor.ino
index 4790b68b804..df75f7fe98c 100644
--- a/libraries/LiquidCrystal/examples/setCursor/setCursor.ino
+++ b/libraries/LiquidCrystal/examples/setCursor/setCursor.ino
@@ -7,7 +7,7 @@
can usually tell them by the 16-pin interface.
This sketch prints to all the positions of the LCD using the
- setCursor(0 method:
+ setCursor() method:
The circuit:
* LCD RS pin to digital pin 12
@@ -56,9 +56,9 @@ void loop() {
// loop from ASCII 'a' to ASCII 'z':
for (int thisLetter = 'a'; thisLetter <= 'z'; thisLetter++) {
// loop over the columns:
- for (int thisCol = 0; thisCol < numRows; thisCol++) {
+ for (int thisRow = 0; thisRow < numRows; thisRow++) {
// loop over the rows:
- for (int thisRow = 0; thisRow < numCols; thisRow++) {
+ for (int thisCol = 0; thisCol < numCols; thisCol++) {
// set the cursor position:
lcd.setCursor(thisCol, thisRow);
// print the letter: