simas/arduino
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
simisimis
2018-08-08 08:33:26 +02:00
commit ada8fdbdf9
368 changed files with 65878 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
libraries/FirmataWithDeviceFeature/examples/ConfigurableFirmata/ConfigurableFirmata.ino Normal file
View File

@@ -0,0 +1,430 @@
/*
Firmata is a generic protocol for communicating with microcontrollers
from software on a host computer. It is intended to work with
any host computer software package.
To download a host software package, please clink on the following link
to open the download page in your default browser.
https://github.com/firmata/ConfigurableFirmata#firmata-client-libraries
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2014 Nicolas Panel. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: January 23rd, 2016
*/
/*
README
This is an example use of ConfigurableFirmata. The easiest way to create a configuration is to
use http://firmatabuilder.com and select the communication transport and the firmata features
to include and an Arduino sketch (.ino) file will be generated and downloaded automatically.
To manually configure a sketch, copy this file and follow the instructions in the
ETHERNET CONFIGURATION OPTION (if you want to use Ethernet instead of Serial/USB) and
FIRMATA FEATURE CONFIGURATION sections in this file.
*/
#include "ConfigurableFirmata.h"
/*==============================================================================
* ETHERNET CONFIGURATION OPTION
*
* By default Firmata uses the Serial-port (over USB) of the Arduino. ConfigurableFirmata may also
* comunicate over ethernet using tcp/ip. To configure this sketch to use Ethernet instead of
* Serial, uncomment the approprate includes for your particular hardware. See STEPS 1 - 5 below.
* If you want to use Serial (over USB) then skip ahead to the FIRMATA FEATURE CONFIGURATION
* section further down in this file.
*
* If you enable Ethernet, you will need a Firmata client library with a network transport that can
* act as a server in order to establish a connection between ConfigurableFirmataEthernet and the
* Firmata host application (your application).
*
* To use ConfigurableFirmata with Ethernet you will need to have one of the following
* boards or shields:
*
* - Arduino Ethernet shield (or clone)
* - Arduino Ethernet board (or clone)
* - Arduino Yun
*
* If you are using an Arduino Ethernet shield you cannot use the following pins on
* the following boards. Firmata will ignore any requests to use these pins:
*
* - Arduino Uno or other ATMega328 boards: (D4, D10, D11, D12, D13)
* - Arduino Mega: (D4, D10, D50, D51, D52, D53)
* - Arduino Leonardo: (D4, D10)
* - Arduino Due: (D4, D10)
* - Arduino Zero: (D4, D10)
*
* If you are using an ArduinoEthernet board, the following pins cannot be used (same as Uno):
* - D4, D10, D11, D12, D13
*============================================================================*/
// STEP 1 [REQUIRED]
// Uncomment / comment the appropriate set of includes for your hardware (OPTION A, B or C)
/*
* OPTION A: Configure for Arduino Ethernet board or Arduino Ethernet shield (or clone)
*
* To configure ConfigurableFirmata to use the an Arduino Ethernet Shield or Arduino Ethernet
* Board (both use the same WIZ5100-based Ethernet controller), uncomment the SPI and Ethernet
* includes below.
*/
//#include <SPI.h>
//#include <Ethernet.h>
/*
* OPTION B: Configure for a board or shield using an ENC28J60-based Ethernet controller,
* uncomment out the UIPEthernet include below.
*
* The UIPEthernet-library can be downloaded
* from: https://github.com/ntruchsess/arduino_uip
*/
//#include <UIPEthernet.h>
/*
* OPTION C: Configure for Arduino Yun
*
* The Ethernet port on the Arduino Yun board can be used with Firmata in this configuration.
* To execute StandardFirmataEthernet on Yun uncomment the Bridge and YunClient includes below.
*
* NOTE: in order to compile for the Yun you will also need to comment out some of the includes
* and declarations in the FIRMATA FEATURE CONFIGURATION section later in this file. Including all
* features exceeds the RAM and Flash memory of the Yun. Comment out anything you don't need.
*
* On Yun there's no need to configure local_ip and mac address as this is automatically
* configured on the linux-side of Yun.
*
* Establishing a connection with the Yun may take several seconds.
*/
//#include <Bridge.h>
//#include <YunClient.h>
#if defined ethernet_h || defined UIPETHERNET_H || defined _YUN_CLIENT_H_
#define NETWORK_FIRMATA
// STEP 2 [REQUIRED for all boards and shields]
// replace with IP of the server you want to connect to, comment out if using 'remote_host'
#define remote_ip IPAddress(192, 168, 0, 1)
// OR replace with hostname of server you want to connect to, comment out if using 'remote_ip'
// #define remote_host "server.local"
// STEP 3 [REQUIRED unless using Arduino Yun]
// Replace with the port that your server is listening on
#define remote_port 3030
// STEP 4 [REQUIRED unless using Arduino Yun OR if not using DHCP]
// Replace with your board or Ethernet shield's IP address
// Comment out if you want to use DHCP
#define local_ip IPAddress(192, 168, 0, 6)
// STEP 5 [REQUIRED unless using Arduino Yun]
// replace with Ethernet shield mac. Must be unique for your network
const byte mac[] = {0x90, 0xA2, 0xDA, 0x0D, 0x07, 0x02};
#endif
/*==============================================================================
* FIRMATA FEATURE CONFIGURATION
*
* Comment out the include and declaration for any features that you do not need
* below.
*
* WARNING: Including all of the following features (especially if also using
* Ethernet) may exceed the Flash and/or RAM of lower memory boards such as the
* Arduino Uno or Leonardo.
*============================================================================*/
#include <DigitalInputFirmata.h>
DigitalInputFirmata digitalInput;
#include <DigitalOutputFirmata.h>
DigitalOutputFirmata digitalOutput;
#include <AnalogInputFirmata.h>
AnalogInputFirmata analogInput;
#include <AnalogOutputFirmata.h>
AnalogOutputFirmata analogOutput;
#include <Servo.h>
#include <ServoFirmata.h>
ServoFirmata servo;
// ServoFirmata depends on AnalogOutputFirmata
#if defined ServoFirmata_h && ! defined AnalogOutputFirmata_h
#error AnalogOutputFirmata must be included to use ServoFirmata
#endif
#include <Wire.h>
#include <I2CFirmata.h>
I2CFirmata i2c;
#include <OneWireFirmata.h>
OneWireFirmata oneWire;
#include <StepperFirmata.h>
StepperFirmata stepper;
#include <SerialFirmata.h>
SerialFirmata serial;
#include <FirmataExt.h>
FirmataExt firmataExt;
#include <FirmataScheduler.h>
FirmataScheduler scheduler;
// To add Encoder support you must first install the FirmataEncoder and Encoder libraries:
// https://github.com/firmata/FirmataEncoder
// https://www.pjrc.com/teensy/td_libs_Encoder.html
// #include <Encoder.h>
// #include <FirmataEncoder.h>
// FirmataEncoder encoder;
/*===================================================================================
* END FEATURE CONFIGURATION - you should not need to change anything below this line
*==================================================================================*/
// dependencies. Do not comment out the following lines
#if defined AnalogOutputFirmata_h || defined ServoFirmata_h
#include <AnalogWrite.h>
#endif
#if defined AnalogInputFirmata_h || defined I2CFirmata_h || defined FirmataEncoder_h
#include <FirmataReporting.h>
FirmataReporting reporting;
#endif
// dependencies for Network Firmata. Do not comment out.
#ifdef NETWORK_FIRMATA
#if defined remote_ip && defined remote_host
#error "cannot define both remote_ip and remote_host at the same time!"
#endif
#include <EthernetClientStream.h>
#ifdef _YUN_CLIENT_H_
YunClient client;
#else
EthernetClient client;
#endif
#if defined remote_ip && !defined remote_host
#ifdef local_ip
EthernetClientStream stream(client, local_ip, remote_ip, NULL, remote_port);
#else
EthernetClientStream stream(client, IPAddress(0, 0, 0, 0), remote_ip, NULL, remote_port);
#endif
#endif
#if !defined remote_ip && defined remote_host
#ifdef local_ip
EthernetClientStream stream(client, local_ip, IPAddress(0, 0, 0, 0), remote_host, remote_port);
#else
EthernetClientStream stream(client, IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0), remote_host, remote_port);
#endif
#endif
#endif
/*==============================================================================
* FUNCTIONS
*============================================================================*/
void systemResetCallback()
{
// initialize a default state
// pins with analog capability default to analog input
// otherwise, pins default to digital output
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_ANALOG(i)) {
#ifdef AnalogInputFirmata_h
// turns off pull-up, configures everything
Firmata.setPinMode(i, PIN_MODE_ANALOG);
#endif
} else if (IS_PIN_DIGITAL(i)) {
#ifdef DigitalOutputFirmata_h
// sets the output to 0, configures portConfigInputs
Firmata.setPinMode(i, OUTPUT);
#endif
}
}
#ifdef FirmataExt_h
firmataExt.reset();
#endif
}
/*==============================================================================
* SETUP()
*============================================================================*/
void setup()
{
/*
* ETHERNET SETUP
*/
#ifdef NETWORK_FIRMATA
#ifdef _YUN_CLIENT_H_
Bridge.begin();
#else
#ifdef local_ip
Ethernet.begin((uint8_t *)mac, local_ip); //start Ethernet
#else
Ethernet.begin((uint8_t *)mac); //start Ethernet using dhcp
#endif
#endif
delay(1000);
#endif
/*
* FIRMATA SETUP
*/
Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
#ifdef FirmataExt_h
#ifdef DigitalInputFirmata_h
firmataExt.addFeature(digitalInput);
#endif
#ifdef DigitalOutputFirmata_h
firmataExt.addFeature(digitalOutput);
#endif
#ifdef AnalogInputFirmata_h
firmataExt.addFeature(analogInput);
#endif
#ifdef AnalogOutputFirmata_h
firmataExt.addFeature(analogOutput);
#endif
#ifdef ServoFirmata_h
firmataExt.addFeature(servo);
#endif
#ifdef I2CFirmata_h
firmataExt.addFeature(i2c);
#endif
#ifdef OneWireFirmata_h
firmataExt.addFeature(oneWire);
#endif
#ifdef StepperFirmata_h
firmataExt.addFeature(stepper);
#endif
#ifdef SerialFirmata_h
firmataExt.addFeature(serial);
#endif
#ifdef FirmataReporting_h
firmataExt.addFeature(reporting);
#endif
#ifdef FirmataScheduler_h
firmataExt.addFeature(scheduler);
#endif
#ifdef FirmataEncoder_h
firmataExt.addFeature(encoder);
#endif
#endif
/* systemResetCallback is declared here (in ConfigurableFirmata.ino) */
Firmata.attach(SYSTEM_RESET, systemResetCallback);
// Network Firmata communicates with Ethernet-shields over SPI. Therefor all
// SPI-pins must be set to PIN_MODE_IGNORE. Otherwise Firmata would break SPI-communication.
// add Pin 10 and configure pin 53 as output if using a MEGA with Ethernetshield.
// No need to ignore pin 10 on MEGA with ENC28J60, as here pin 53 should be connected to SS:
#ifdef NETWORK_FIRMATA
#ifndef _YUN_CLIENT_H_
// ignore SPI and pin 4 that is SS for SD-Card on Ethernet-shield
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_SPI(i)
|| 4 == i // SD Card on Ethernet shield uses pin 4 for SS
|| 10 == i // Ethernet-shield uses pin 10 for SS
) {
Firmata.setPinMode(i, PIN_MODE_IGNORE);
}
}
// pinMode(PIN_TO_DIGITAL(53), OUTPUT); configure hardware-SS as output on MEGA
pinMode(PIN_TO_DIGITAL(4), OUTPUT); // switch off SD-card bypassing Firmata
digitalWrite(PIN_TO_DIGITAL(4), HIGH); // SS is active low;
#endif
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
pinMode(PIN_TO_DIGITAL(53), OUTPUT); // configure hardware SS as output on MEGA
#endif
// start up Network Firmata:
Firmata.begin(stream);
#else
// Uncomment to save a couple of seconds by disabling the startup blink sequence.
// Firmata.disableBlinkVersion();
// start up the default Firmata using Serial interface:
Firmata.begin(57600);
#endif
systemResetCallback(); // reset to default config
}
/*==============================================================================
* LOOP()
*============================================================================*/
void loop()
{
#ifdef DigitalInputFirmata_h
/* DIGITALREAD - as fast as possible, check for changes and output them to the
* stream buffer using Firmata.write() */
digitalInput.report();
#endif
/* STREAMREAD - processing incoming message as soon as possible, while still
* checking digital inputs. */
while (Firmata.available()) {
Firmata.processInput();
#ifdef FirmataScheduler_h
if (!Firmata.isParsingMessage()) {
goto runtasks;
}
}
if (!Firmata.isParsingMessage()) {
runtasks: scheduler.runTasks();
#endif
}
/* SEND STREAM WRITE BUFFER - TO DO: make sure that the stream buffer doesn't go over
* 60 bytes. use a timer to sending an event character every 4 ms to
* trigger the buffer to dump. */
#ifdef FirmataReporting_h
if (reporting.elapsed()) {
#ifdef AnalogInputFirmata_h
/* ANALOGREAD - do all analogReads() at the configured sampling interval */
analogInput.report();
#endif
#ifdef I2CFirmata_h
// report i2c data for all device with read continuous mode enabled
i2c.report();
#endif
#ifdef FirmataEncoder_h
// report encoders positions if reporting enabled.
encoder.report();
#endif
}
#endif
#ifdef StepperFirmata_h
stepper.update();
#endif
#ifdef SerialFirmata_h
serial.update();
#endif
#if defined NETWORK_FIRMATA && !defined local_ip &&!defined _YUN_CLIENT_H_
// only necessary when using DHCP, ensures local IP is updated appropriately if it changes
if (Ethernet.maintain()) {
stream.maintain(Ethernet.localIP());
}
#endif
}

445
libraries/FirmataWithDeviceFeature/examples/ConfigurableFirmataDeviceDriver/ConfigurableFirmataDeviceDriver.ino Normal file
View File

@@ -0,0 +1,445 @@
/*
Firmata is a generic protocol for communicating with microcontrollers
from software on a host computer. It is intended to work with
any host computer software package.
To download a host software package, please clink on the following link
to open the download page in your default browser.
https://github.com/firmata/ConfigurableFirmata#firmata-client-libraries
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2014 Nicolas Panel. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: January 23rd, 2016
This ConfigurableFirmataDeviceDriver.ino has been edited to include the
DeviceFirmata feature. None of the other features are installed.
Doug Johnson, June 2016
*/
/*
README
This is an example use of ConfigurableFirmata. The easiest way to create a configuration is to
use http://firmatabuilder.com and select the communication transport and the firmata features
to include and an Arduino sketch (.ino) file will be generated and downloaded automatically.
To manually configure a sketch, copy this file and follow the instructions in the
ETHERNET CONFIGURATION OPTION (if you want to use Ethernet instead of Serial/USB) and
FIRMATA FEATURE CONFIGURATION sections in this file.
*/
#include <ConfigurableFirmata.h>
/*==============================================================================
* ETHERNET CONFIGURATION OPTION
*
* By default Firmata uses the Serial-port (over USB) of the Arduino. ConfigurableFirmata may also
* comunicate over ethernet using tcp/ip. To configure this sketch to use Ethernet instead of
* Serial, uncomment the approprate includes for your particular hardware. See STEPS 1 - 5 below.
* If you want to use Serial (over USB) then skip ahead to the FIRMATA FEATURE CONFIGURATION
* section further down in this file.
*
* If you enable Ethernet, you will need a Firmata client library with a network transport that can
* act as a server in order to establish a connection between ConfigurableFirmataEthernet and the
* Firmata host application (your application).
*
* To use ConfigurableFirmata with Ethernet you will need to have one of the following
* boards or shields:
*
* - Arduino Ethernet shield (or clone)
* - Arduino Ethernet board (or clone)
* - Arduino Yun
*
* If you are using an Arduino Ethernet shield you cannot use the following pins on
* the following boards. Firmata will ignore any requests to use these pins:
*
* - Arduino Uno or other ATMega328 boards: (D4, D10, D11, D12, D13)
* - Arduino Mega: (D4, D10, D50, D51, D52, D53)
* - Arduino Leonardo: (D4, D10)
* - Arduino Due: (D4, D10)
* - Arduino Zero: (D4, D10)
*
* If you are using an ArduinoEthernet board, the following pins cannot be used (same as Uno):
* - D4, D10, D11, D12, D13
*============================================================================*/
// STEP 1 [REQUIRED]
// Uncomment / comment the appropriate set of includes for your hardware (OPTION A, B or C)
/*
* OPTION A: Configure for Arduino Ethernet board or Arduino Ethernet shield (or clone)
*
* To configure ConfigurableFirmata to use the an Arduino Ethernet Shield or Arduino Ethernet
* Board (both use the same WIZ5100-based Ethernet controller), uncomment the SPI and Ethernet
* includes below.
*/
//#include <SPI.h>
//#include <Ethernet.h>
/*
* OPTION B: Configure for a board or shield using an ENC28J60-based Ethernet controller,
* uncomment out the UIPEthernet include below.
*
* The UIPEthernet-library can be downloaded
* from: https://github.com/ntruchsess/arduino_uip
*/
//#include <UIPEthernet.h>
/*
* OPTION C: Configure for Arduino Yun
*
* The Ethernet port on the Arduino Yun board can be used with Firmata in this configuration.
* To execute StandardFirmataEthernet on Yun uncomment the Bridge and YunClient includes below.
*
* NOTE: in order to compile for the Yun you will also need to comment out some of the includes
* and declarations in the FIRMATA FEATURE CONFIGURATION section later in this file. Including all
* features exceeds the RAM and Flash memory of the Yun. Comment out anything you don't need.
*
* On Yun there's no need to configure local_ip and mac address as this is automatically
* configured on the linux-side of Yun.
*
* Establishing a connection with the Yun may take several seconds.
*/
//#include <Bridge.h>
//#include <YunClient.h>
#if defined ethernet_h || defined UIPETHERNET_H || defined _YUN_CLIENT_H_
#define NETWORK_FIRMATA
// STEP 2 [REQUIRED for all boards and shields]
// replace with IP of the server you want to connect to, comment out if using 'remote_host'
#define remote_ip IPAddress(192, 168, 0, 1)
// OR replace with hostname of server you want to connect to, comment out if using 'remote_ip'
// #define remote_host "server.local"
// STEP 3 [REQUIRED unless using Arduino Yun]
// Replace with the port that your server is listening on
#define remote_port 3030
// STEP 4 [REQUIRED unless using Arduino Yun OR if not using DHCP]
// Replace with your board or Ethernet shield's IP address
// Comment out if you want to use DHCP
#define local_ip IPAddress(192, 168, 0, 6)
// STEP 5 [REQUIRED unless using Arduino Yun]
// replace with Ethernet shield mac. Must be unique for your network
const byte mac[] = {0x90, 0xA2, 0xDA, 0x0D, 0x07, 0x02};
#endif
/*==============================================================================
* FIRMATA FEATURE CONFIGURATION
*
* Comment out the include and declaration for any features that you do not need
* below.
*
* WARNING: Including all of the following features (especially if also using
* Ethernet) may exceed the Flash and/or RAM of lower memory boards such as the
* Arduino Uno or Leonardo.
*============================================================================*/
//#include <DigitalInputFirmata.h>
//DigitalInputFirmata digitalInput;
//#include <DigitalOutputFirmata.h>
//DigitalOutputFirmata digitalOutput;
//#include <AnalogInputFirmata.h>
//AnalogInputFirmata analogInput;
//#include <AnalogOutputFirmata.h>
//AnalogOutputFirmata analogOutput;
//#include <Servo.h>
//#include <ServoFirmata.h>
//ServoFirmata servo;
//// ServoFirmata depends on AnalogOutputFirmata
//#if defined ServoFirmata_h && ! defined AnalogOutputFirmata_h
//#error AnalogOutputFirmata must be included to use ServoFirmata
//#endif
//
//#include <Wire.h>
//#include <I2CFirmata.h>
//I2CFirmata i2c;
//#include <OneWireFirmata.h>
//OneWireFirmata oneWire;
//#include <StepperFirmata.h>
//StepperFirmata stepper;
//#include <SerialFirmata.h>
//SerialFirmata serial;
#include <FirmataExt.h>
FirmataExt firmataExt;
//#include <FirmataScheduler.h>
//FirmataScheduler scheduler;
// To add Encoder support you must first install the FirmataEncoder and Encoder libraries:
// https://github.com/firmata/FirmataEncoder
// https://www.pjrc.com/teensy/td_libs_Encoder.html
// #include <Encoder.h>
// #include <FirmataEncoder.h>
// FirmataEncoder encoder;
#include "SelectedDeviceDrivers.h"
#include <DeviceFirmata.h>
DeviceFirmata deviceMgr;
/*===================================================================================
* END FEATURE CONFIGURATION - you should not need to change anything below this line
*==================================================================================*/
// dependencies. Do not comment out the following lines
#if defined AnalogOutputFirmata_h || defined ServoFirmata_h
#include <AnalogWrite.h>
#endif
#if defined AnalogInputFirmata_h || defined I2CFirmata_h || defined FirmataEncoder_h
#include <FirmataReporting.h>
FirmataReporting reporting;
#endif
// dependencies for Network Firmata. Do not comment out.
#ifdef NETWORK_FIRMATA
#if defined remote_ip && defined remote_host
#error "cannot define both remote_ip and remote_host at the same time!"
#endif
#include <EthernetClientStream.h>
#ifdef _YUN_CLIENT_H_
YunClient client;
#else
EthernetClient client;
#endif
#if defined remote_ip && !defined remote_host
#ifdef local_ip
EthernetClientStream stream(client, local_ip, remote_ip, NULL, remote_port);
#else
EthernetClientStream stream(client, IPAddress(0, 0, 0, 0), remote_ip, NULL, remote_port);
#endif
#endif
#if !defined remote_ip && defined remote_host
#ifdef local_ip
EthernetClientStream stream(client, local_ip, IPAddress(0, 0, 0, 0), remote_host, remote_port);
#else
EthernetClientStream stream(client, IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0), remote_host, remote_port);
#endif
#endif
#endif
/*==============================================================================
* FUNCTIONS
*============================================================================*/
void systemResetCallback()
{
// initialize a default state
// pins with analog capability default to analog input
// otherwise, pins default to digital output
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_ANALOG(i)) {
#ifdef AnalogInputFirmata_h
// turns off pull-up, configures everything
Firmata.setPinMode(i, PIN_MODE_ANALOG);
#endif
} else if (IS_PIN_DIGITAL(i)) {
#ifdef DigitalOutputFirmata_h
// sets the output to 0, configures portConfigInputs
Firmata.setPinMode(i, OUTPUT);
#endif
}
}
#ifdef FirmataExt_h
firmataExt.reset();
#endif
}
/*==============================================================================
* SETUP()
*============================================================================*/
void setup()
{
/*
* ETHERNET SETUP
*/
#ifdef NETWORK_FIRMATA
#ifdef _YUN_CLIENT_H_
Bridge.begin();
#else
#ifdef local_ip
Ethernet.begin((uint8_t *)mac, local_ip); //start Ethernet
#else
Ethernet.begin((uint8_t *)mac); //start Ethernet using dhcp
#endif
#endif
delay(1000);
#endif
/*
* FIRMATA SETUP
*/
Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
#ifdef FirmataExt_h
#ifdef DigitalInputFirmata_h
firmataExt.addFeature(digitalInput);
#endif
#ifdef DigitalOutputFirmata_h
firmataExt.addFeature(digitalOutput);
#endif
#ifdef AnalogInputFirmata_h
firmataExt.addFeature(analogInput);
#endif
#ifdef AnalogOutputFirmata_h
firmataExt.addFeature(analogOutput);
#endif
#ifdef ServoFirmata_h
firmataExt.addFeature(servo);
#endif
#ifdef I2CFirmata_h
firmataExt.addFeature(i2c);
#endif
#ifdef OneWireFirmata_h
firmataExt.addFeature(oneWire);
#endif
#ifdef StepperFirmata_h
firmataExt.addFeature(stepper);
#endif
#ifdef SerialFirmata_h
firmataExt.addFeature(serial);
#endif
#ifdef FirmataReporting_h
firmataExt.addFeature(reporting);
#endif
#ifdef FirmataScheduler_h
firmataExt.addFeature(scheduler);
#endif
#ifdef FirmataEncoder_h
firmataExt.addFeature(encoder);
#endif
#ifdef DeviceFirmata_h
firmataExt.addFeature(deviceMgr);
#endif
#endif
/* systemResetCallback is declared here (in ConfigurableFirmata.ino) */
Firmata.attach(SYSTEM_RESET, systemResetCallback);
// Network Firmata communicates with Ethernet-shields over SPI. Therefor all
// SPI-pins must be set to PIN_MODE_IGNORE. Otherwise Firmata would break SPI-communication.
// add Pin 10 and configure pin 53 as output if using a MEGA with Ethernetshield.
// No need to ignore pin 10 on MEGA with ENC28J60, as here pin 53 should be connected to SS:
#ifdef NETWORK_FIRMATA
#ifndef _YUN_CLIENT_H_
// ignore SPI and pin 4 that is SS for SD-Card on Ethernet-shield
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_SPI(i)
|| 4 == i // SD Card on Ethernet shield uses pin 4 for SS
|| 10 == i // Ethernet-shield uses pin 10 for SS
) {
Firmata.setPinMode(i, PIN_MODE_IGNORE);
}
}
// pinMode(PIN_TO_DIGITAL(53), OUTPUT); configure hardware-SS as output on MEGA
pinMode(PIN_TO_DIGITAL(4), OUTPUT); // switch off SD-card bypassing Firmata
digitalWrite(PIN_TO_DIGITAL(4), HIGH); // SS is active low;
#endif
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
pinMode(PIN_TO_DIGITAL(53), OUTPUT); // configure hardware SS as output on MEGA
#endif
// start up Network Firmata:
Firmata.begin(stream);
#else
// Uncomment to save a couple of seconds by disabling the startup blink sequence.
// Firmata.disableBlinkVersion();
// start up the default Firmata using Serial interface:
Firmata.begin(57600);
#endif
systemResetCallback(); // reset to default config
}
/*==============================================================================
* LOOP()
*============================================================================*/
void loop()
{
#ifdef DigitalInputFirmata_h
/* DIGITALREAD - as fast as possible, check for changes and output them to the
* stream buffer using Firmata.write() */
digitalInput.report();
#endif
/* STREAMREAD - processing incoming message as soon as possible, while still
* checking digital inputs. */
while (Firmata.available()) {
Firmata.processInput();
#ifdef FirmataScheduler_h
if (!Firmata.isParsingMessage()) {
goto runtasks;
}
}
if (!Firmata.isParsingMessage()) {
runtasks: scheduler.runTasks();
#endif
}
/* SEND STREAM WRITE BUFFER - TO DO: make sure that the stream buffer doesn't go over
* 60 bytes. use a timer to sending an event character every 4 ms to
* trigger the buffer to dump. */
#ifdef FirmataReporting_h
if (reporting.elapsed()) {
#ifdef AnalogInputFirmata_h
/* ANALOGREAD - do all analogReads() at the configured sampling interval */
analogInput.report();
#endif
#ifdef I2CFirmata_h
// report i2c data for all device with read continuous mode enabled
i2c.report();
#endif
#ifdef FirmataEncoder_h
// report encoders positions if reporting enabled.
encoder.report();
#endif
}
#endif
#ifdef StepperFirmata_h
stepper.update();
#endif
#ifdef SerialFirmata_h
serial.update();
#endif
#ifdef DeviceFirmata_h
deviceMgr.update();
#endif
#if defined NETWORK_FIRMATA && !defined local_ip &&!defined _YUN_CLIENT_H_
// only necessary when using DHCP, ensures local IP is updated appropriately if it changes
if (Ethernet.maintain()) {
stream.maintain(Ethernet.localIP());
}
#endif
}

22
libraries/FirmataWithDeviceFeature/examples/ConfigurableFirmataDeviceDriver/SelectedDeviceDrivers.h Normal file
View File

@@ -0,0 +1,22 @@
#include <LuniLib.h>
// Device Drivers
//#include <DDMeta/DDMeta.h>
#include <DDHello/DDHello.h>
//#include <DDMCP9808/DDMCP9808.h>
//#include <DDServo/DDServo.h>
//#include <DDSensor/DDSensor.h>
//#include <DDStepper/DDStepper.h>
DeviceDriver *selectedDevices[] = {
// new DDMeta("Meta",1),
new DDHello("Hello",1),
// new DDMCP9808("MCP9808",1,0x18),
// new DDServo("Servo",2),
// new DDSensor("Chan",16),
// new DDStepper("Stepper",6),
0};

609
libraries/FirmataWithDeviceFeature/examples/ConfigurableFirmataWiFi/ConfigurableFirmataWiFi.ino Normal file
View File

@@ -0,0 +1,609 @@
/*
Firmata is a generic protocol for communicating with microcontrollers
from software on a host computer. It is intended to work with
any host computer software package.
To download a host software package, please clink on the following link
to open the download page in your default browser.
https://github.com/firmata/ConfigurableFirmata#firmata-client-libraries
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2014 Nicolas Panel. All rights reserved.
Copyright (C) 2015-2016 Jesse Frush. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: January 23rd, 2016
*/
/*
README
This is an example use of ConfigurableFirmata with WiFi. The easiest way to create a
configuration is use http://firmatabuilder.com and select the communication transport and the
firmata features to include and an Arduino sketch (.ino) file will be generated and downloaded
automatically.
To manually configure a sketch, follow the instructions in this file.
ConfigurableFirmataWiFi is a WiFi server application. You will need a Firmata client library with
a network transport in order to establish a connection with ConfigurableFirmataWiFi.
To use ConfigurableFirmataWiFi you will need to have one of the following
boards or shields:
- Arduino WiFi Shield (or clone)
- Arduino WiFi Shield 101
- Arduino MKR1000 board (built-in WiFi 101)
- Adafruit HUZZAH CC3000 WiFi Shield (support coming soon)
Follow the instructions in the WIFI CONFIGURATION section below to configure your particular
hardware.
Dependencies:
- WiFi Shield 101 requires version 0.7.0 or higher of the WiFi101 library (available in Arduino
1.6.8 or higher, or update the library via the Arduino Library Manager or clone from source:
https://github.com/arduino-libraries/WiFi101)
In order to use the WiFi Shield 101 with Firmata you will need a board with at least
35k of Flash memory. This means you cannot use the WiFi Shield 101 with an Arduino Uno
or any other ATmega328p-based microcontroller or with an Arduino Leonardo or other
ATmega32u4-based microcontroller. Some boards that will work are:
- Arduino Zero
- Arduino Due
- Arduino 101
- Arduino Mega
NOTE: If you are using an Arduino WiFi (legacy) shield you cannot use the following pins on
the following boards. Firmata will ignore any requests to use these pins:
- Arduino Uno or other ATMega328 boards: (D4, D7, D10, D11, D12, D13)
- Arduino Mega: (D4, D7, D10, D50, D51, D52, D53)
- Arduino Due, Zero or Leonardo: (D4, D7, D10)
If you are using an Arduino WiFi 101 shield you cannot use the following pins on the following
boards:
- Arduino Due or Zero: (D5, D7, D10)
- Arduino Mega: (D5, D7, D10, D50, D52, D53)
*/
#include "ConfigurableFirmata.h"
/*
* Uncomment the #define SERIAL_DEBUG line below to receive serial output messages relating to your
* connection that may help in the event of connection issues. If defined, some boards may not begin
* executing this sketch until the Serial console is opened.
*/
//#define SERIAL_DEBUG
#include "utility/firmataDebug.h"
#define WIFI_MAX_CONN_ATTEMPTS 3
/*==============================================================================
* WIFI CONFIGURATION
*
* You must configure your particular hardware. Follow the steps below.
*
* Currently ConfigurableFirmataWiFi is configured as a server. An option to
* configure as a client may be added in the future.
*============================================================================*/
// STEP 1 [REQUIRED]
// Uncomment / comment the appropriate set of includes for your hardware (OPTION A, B or C)
// Option A is enabled by default.
/*
* OPTION A: Configure for Arduino WiFi shield
*
* This will configure ConfigurableFirmataWiFi to use the original WiFi library (deprecated)
* provided with the Arduino IDE. It is supported by the Arduino WiFi shield (a discontinued
* product) and is compatible with 802.11 B/G networks.
*
* To configure ConfigurableFirmataWiFi to use the Arduino WiFi shield
* leave the #define below uncommented.
*/
#define ARDUINO_WIFI_SHIELD
//do not modify these next 4 lines
#ifdef ARDUINO_WIFI_SHIELD
#include "utility/WiFiStream.h"
WiFiStream stream;
#endif
/*
* OPTION B: Configure for WiFi 101
*
* This will configure ConfigurableFirmataWiFi to use the WiFi101 library, which works with the
* Arduino WiFi101 shield and devices that have the WiFi101 chip built in (such as the MKR1000). It
* is compatible with 802.11 B/G/N networks.
*
* To enable, uncomment the #define WIFI_101 below and verify the #define values under
* options A and C are commented out.
*
* IMPORTANT: You must have the WiFI 101 library installed. To easily install this library, open
* the library manager via: Arduino IDE Menus: Sketch > Include Library > Manage Libraries >
* filter search for "WiFi101" > Select the result and click 'install'
*/
//#define WIFI_101
//do not modify these next 4 lines
#ifdef WIFI_101
#include "utility/WiFi101Stream.h"
WiFi101Stream stream;
#endif
/*
* OPTION C: Configure for HUZZAH
*
* HUZZAH is not yet supported, this will be added in a later revision to ConfigurableFirmataWiFi
*/
//------------------------------
// TODO
//------------------------------
//#define HUZZAH_WIFI
// STEP 2 [REQUIRED for all boards and shields]
// replace this with your wireless network SSID
char ssid[] = "your_network_name";
// STEP 3 [OPTIONAL for all boards and shields]
// If you want to use a static IP (v4) address, uncomment the line below. You can also change the IP.
// If this line is commented out, the WiFi shield will attempt to get an IP from the DHCP server
// #define STATIC_IP_ADDRESS 192,168,1,113
// STEP 4 [REQUIRED for all boards and shields]
// define your port number here, you will need this to open a TCP connection to your Arduino
#define SERVER_PORT 3030
// STEP 5 [REQUIRED for all boards and shields]
// determine your network security type (OPTION A, B, or C). Option A is the most common, and the default.
/*
* OPTION A: WPA / WPA2
*
* WPA is the most common network security type. A passphrase is required to connect to this type.
*
* To enable, leave #define WIFI_WPA_SECURITY uncommented below, set your wpa_passphrase value
* appropriately, and do not uncomment the #define values under options B and C
*/
#define WIFI_WPA_SECURITY
#ifdef WIFI_WPA_SECURITY
char wpa_passphrase[] = "your_wpa_passphrase";
#endif //WIFI_WPA_SECURITY
/*
* OPTION B: WEP
*
* WEP is a less common (and regarded as less safe) security type. A WEP key and its associated
* index are required to connect to this type.
*
* To enable, Uncomment the #define below, set your wep_index and wep_key values appropriately, and
* verify the #define values under options A and C are commented out.
*/
//#define WIFI_WEP_SECURITY
#ifdef WIFI_WEP_SECURITY
//The wep_index below is a zero-indexed value.
//Valid indices are [0-3], even if your router/gateway numbers your keys [1-4].
byte wep_index = 0;
char wep_key[] = "your_wep_key";
#endif //WIFI_WEP_SECURITY
/*
* OPTION C: Open network (no security)
*
* Open networks have no security, can be connected to by any device that knows the ssid, and are
* unsafe.
*
* To enable, uncomment #define WIFI_NO_SECURITY below and verify the #define values
* under options A and B are commented out.
*/
//#define WIFI_NO_SECURITY
/*==============================================================================
* CONFIGURATION ERROR CHECK (don't change anything here)
*============================================================================*/
#if ((defined(ARDUINO_WIFI_SHIELD) && (defined(WIFI_101) || defined(HUZZAH_WIFI))) || (defined(WIFI_101) && defined(HUZZAH_WIFI)))
#error "you may not define more than one wifi device type in wifiConfig.h."
#endif //WIFI device type check
#if !(defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101) || defined(HUZZAH_WIFI))
#error "you must define a wifi device type in wifiConfig.h."
#endif
#if ((defined(WIFI_NO_SECURITY) && (defined(WIFI_WEP_SECURITY) || defined(WIFI_WPA_SECURITY))) || (defined(WIFI_WEP_SECURITY) && defined(WIFI_WPA_SECURITY)))
#error "you may not define more than one security type at the same time in wifiConfig.h."
#endif //WIFI_* security define check
#if !(defined(WIFI_NO_SECURITY) || defined(WIFI_WEP_SECURITY) || defined(WIFI_WPA_SECURITY))
#error "you must define a wifi security type in wifiConfig.h."
#endif //WIFI_* security define check
/*==============================================================================
* PIN IGNORE MACROS (don't change anything here)
*============================================================================*/
// ignore SPI pins, pin 5 (reset WiFi101 shield), pin 7 (WiFi handshake) and pin 10 (WiFi SS)
// also don't ignore SS pin if it's not pin 10
// TODO - need to differentiate between Arduino WiFi1 101 Shield and Arduino MKR1000
#define IS_IGNORE_WIFI101_SHIELD(p) ((p) == 10 || (IS_PIN_SPI(p) && (p) != SS) || (p) == 5 || (p) == 7)
// ignore SPI pins, pin 4 (SS for SD-Card on WiFi-shield), pin 7 (WiFi handshake) and pin 10 (WiFi SS)
#define IS_IGNORE_WIFI_SHIELD(p) ((IS_PIN_SPI(p) || (p) == 4) || (p) == 7 || (p) == 10)
/*==============================================================================
* FIRMATA FEATURE CONFIGURATION
*
* Comment out the include and declaration for any features that you do not need
* below.
*
* WARNING: Including all of the following features (especially if also using
* Ethernet) may exceed the Flash and/or RAM of lower memory boards such as the
* Arduino Uno or Leonardo.
*============================================================================*/
#include <DigitalInputFirmata.h>
DigitalInputFirmata digitalInput;
#include <DigitalOutputFirmata.h>
DigitalOutputFirmata digitalOutput;
#include <AnalogInputFirmata.h>
AnalogInputFirmata analogInput;
#include <AnalogOutputFirmata.h>
AnalogOutputFirmata analogOutput;
#include <Servo.h>
#include <ServoFirmata.h>
ServoFirmata servo;
// ServoFirmata depends on AnalogOutputFirmata
#if defined ServoFirmata_h && ! defined AnalogOutputFirmata_h
#error AnalogOutputFirmata must be included to use ServoFirmata
#endif
#include <Wire.h>
#include <I2CFirmata.h>
I2CFirmata i2c;
#include <OneWireFirmata.h>
OneWireFirmata oneWire;
#include <StepperFirmata.h>
StepperFirmata stepper;
#include <SerialFirmata.h>
SerialFirmata serial;
#include <FirmataExt.h>
FirmataExt firmataExt;
#include <FirmataScheduler.h>
FirmataScheduler scheduler;
// To add Encoder support you must first install the FirmataEncoder and Encoder libraries:
// https://github.com/firmata/FirmataEncoder
// https://www.pjrc.com/teensy/td_libs_Encoder.html
// #include <Encoder.h>
// #include <FirmataEncoder.h>
// FirmataEncoder encoder;
/*===================================================================================
* END FEATURE CONFIGURATION - you should not need to change anything below this line
*==================================================================================*/
// dependencies. Do not comment out the following lines
#if defined AnalogOutputFirmata_h || defined ServoFirmata_h
#include <AnalogWrite.h>
#endif
#if defined AnalogInputFirmata_h || defined I2CFirmata_h || defined FirmataEncoder_h
#include <FirmataReporting.h>
FirmataReporting reporting;
#endif
#ifdef STATIC_IP_ADDRESS
IPAddress local_ip(STATIC_IP_ADDRESS);
#endif
int wifiConnectionAttemptCounter = 0;
int wifiStatus = WL_IDLE_STATUS;
/*==============================================================================
* FUNCTIONS
*============================================================================*/
void systemResetCallback()
{
// initialize a default state
// pins with analog capability default to analog input
// otherwise, pins default to digital output
for (byte i = 0; i < TOTAL_PINS; i++) {
if (IS_PIN_ANALOG(i)) {
#ifdef AnalogInputFirmata_h
// turns off pull-up, configures everything
Firmata.setPinMode(i, PIN_MODE_ANALOG);
#endif
} else if (IS_PIN_DIGITAL(i)) {
#ifdef DigitalOutputFirmata_h
// sets the output to 0, configures portConfigInputs
Firmata.setPinMode(i, OUTPUT);
#endif
}
}
#ifdef FirmataExt_h
firmataExt.reset();
#endif
}
void printWifiStatus() {
#if defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
if ( WiFi.status() != WL_CONNECTED )
{
DEBUG_PRINT( "WiFi connection failed. Status value: " );
DEBUG_PRINTLN( WiFi.status() );
}
else
#endif //defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
{
// print the SSID of the network you're attached to:
DEBUG_PRINT( "SSID: " );
#if defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
DEBUG_PRINTLN( WiFi.SSID() );
#endif //defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
// print your WiFi shield's IP address:
DEBUG_PRINT( "IP Address: " );
#if defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
IPAddress ip = WiFi.localIP();
DEBUG_PRINTLN( ip );
#endif //defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
// print the received signal strength:
DEBUG_PRINT( "signal strength (RSSI): " );
#if defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
long rssi = WiFi.RSSI();
DEBUG_PRINT( rssi );
#endif //defined(ARDUINO_WIFI_SHIELD) || defined(WIFI_101)
DEBUG_PRINTLN( " dBm" );
}
}
/*==============================================================================
* SETUP()
*============================================================================*/
void setup()
{
/*
* WIFI SETUP
*/
DEBUG_BEGIN(9600);
/*
* This statement will clarify how a connection is being made
*/
DEBUG_PRINT( "ConfigurableFirmataWiFi will attempt a WiFi connection " );
#if defined(WIFI_101)
DEBUG_PRINTLN( "using the WiFi 101 library." );
#elif defined(ARDUINO_WIFI_SHIELD)
DEBUG_PRINTLN( "using the legacy WiFi library." );
#elif defined(HUZZAH_WIFI)
DEBUG_PRINTLN( "using the HUZZAH WiFi library." );
//else should never happen here as error-checking in wifiConfig.h will catch this
#endif //defined(WIFI_101)
/*
* Configure WiFi IP Address
*/
#ifdef STATIC_IP_ADDRESS
DEBUG_PRINT( "Using static IP: " );
DEBUG_PRINTLN( local_ip );
//you can also provide a static IP in the begin() functions, but this simplifies
//ifdef logic in this sketch due to support for all different encryption types.
stream.config( local_ip );
#else
DEBUG_PRINTLN( "IP will be requested from DHCP ..." );
#endif
/*
* Configure WiFi security
*/
#if defined(WIFI_WEP_SECURITY)
while (wifiStatus != WL_CONNECTED) {
DEBUG_PRINT( "Attempting to connect to WEP SSID: " );
DEBUG_PRINTLN(ssid);
wifiStatus = stream.begin( ssid, wep_index, wep_key, SERVER_PORT );
delay(5000); // TODO - determine minimum delay
if (++wifiConnectionAttemptCounter > WIFI_MAX_CONN_ATTEMPTS) break;
}
#elif defined(WIFI_WPA_SECURITY)
while (wifiStatus != WL_CONNECTED) {
DEBUG_PRINT( "Attempting to connect to WPA SSID: " );
DEBUG_PRINTLN(ssid);
wifiStatus = stream.begin(ssid, wpa_passphrase, SERVER_PORT);
delay(5000); // TODO - determine minimum delay
if (++wifiConnectionAttemptCounter > WIFI_MAX_CONN_ATTEMPTS) break;
}
#else //OPEN network
while (wifiStatus != WL_CONNECTED) {
DEBUG_PRINTLN( "Attempting to connect to open SSID: " );
DEBUG_PRINTLN(ssid);
wifiStatus = stream.begin(ssid, SERVER_PORT);
delay(5000); // TODO - determine minimum delay
if (++wifiConnectionAttemptCounter > WIFI_MAX_CONN_ATTEMPTS) break;
}
#endif //defined(WIFI_WEP_SECURITY)
DEBUG_PRINTLN( "WiFi setup done" );
printWifiStatus();
/*
* FIRMATA SETUP
*/
Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
#ifdef FirmataExt_h
#ifdef DigitalInputFirmata_h
firmataExt.addFeature(digitalInput);
#endif
#ifdef DigitalOutputFirmata_h
firmataExt.addFeature(digitalOutput);
#endif
#ifdef AnalogInputFirmata_h
firmataExt.addFeature(analogInput);
#endif
#ifdef AnalogOutputFirmata_h
firmataExt.addFeature(analogOutput);
#endif
#ifdef ServoFirmata_h
firmataExt.addFeature(servo);
#endif
#ifdef I2CFirmata_h
firmataExt.addFeature(i2c);
#endif
#ifdef OneWireFirmata_h
firmataExt.addFeature(oneWire);
#endif
#ifdef StepperFirmata_h
firmataExt.addFeature(stepper);
#endif
#ifdef SerialFirmata_h
firmataExt.addFeature(serial);
#endif
#ifdef FirmataReporting_h
firmataExt.addFeature(reporting);
#endif
#ifdef FirmataScheduler_h
firmataExt.addFeature(scheduler);
#endif
#ifdef FirmataEncoder_h
firmataExt.addFeature(encoder);
#endif
#endif
/* systemResetCallback is declared here (in ConfigurableFirmata.ino) */
Firmata.attach(SYSTEM_RESET, systemResetCallback);
// ConfigurableFirmataWiFi communicates with WiFi shields over SPI. Therefore all
// SPI pins must be set to IGNORE. Otherwise Firmata would break SPI communication.
// Additional pins may also need to be ignored depending on the particular board or
// shield in use.
for (byte i = 0; i < TOTAL_PINS; i++) {
#if defined(ARDUINO_WIFI_SHIELD)
if (IS_IGNORE_WIFI_SHIELD(i)
#if defined(__AVR_ATmega32U4__)
|| 24 == i // On Leonardo, pin 24 maps to D4 and pin 28 maps to D10
|| 28 == i
#endif //defined(__AVR_ATmega32U4__)
) {
#elif defined (WIFI_101)
if (IS_IGNORE_WIFI101_SHIELD(i)) {
#elif defined (HUZZAH_WIFI)
// TODO
if (false) {
#else
if (false) {
#endif
Firmata.setPinMode(i, PIN_MODE_IGNORE);
}
}
//Set up controls for the Arduino WiFi Shield SS for the SD Card
#ifdef ARDUINO_WIFI_SHIELD
// Arduino WiFi, Arduino WiFi Shield and Arduino Yun all have SD SS wired to D4
pinMode(PIN_TO_DIGITAL(4), OUTPUT); // switch off SD card bypassing Firmata
digitalWrite(PIN_TO_DIGITAL(4), HIGH); // SS is active low;
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
pinMode(PIN_TO_DIGITAL(53), OUTPUT); // configure hardware SS as output on MEGA
#endif //defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#endif //ARDUINO_WIFI_SHIELD
// start up Network Firmata:
Firmata.begin(stream);
systemResetCallback(); // reset to default config
}
/*==============================================================================
* LOOP()
*============================================================================*/
void loop()
{
#ifdef DigitalInputFirmata_h
/* DIGITALREAD - as fast as possible, check for changes and output them to the
* stream buffer using Firmata.write() */
digitalInput.report();
#endif
/* STREAMREAD - processing incoming message as soon as possible, while still
* checking digital inputs. */
while (Firmata.available()) {
Firmata.processInput();
#ifdef FirmataScheduler_h
if (!Firmata.isParsingMessage()) {
goto runtasks;
}
}
if (!Firmata.isParsingMessage()) {
runtasks: scheduler.runTasks();
#endif
}
// TODO - ensure that Stream buffer doesn't go over 60 bytes
#ifdef FirmataReporting_h
if (reporting.elapsed()) {
#ifdef AnalogInputFirmata_h
/* ANALOGREAD - do all analogReads() at the configured sampling interval */
analogInput.report();
#endif
#ifdef I2CFirmata_h
// report i2c data for all device with read continuous mode enabled
i2c.report();
#endif
#ifdef FirmataEncoder_h
// report encoders positions if reporting enabled.
encoder.report();
#endif
}
#endif
#ifdef StepperFirmata_h
stepper.update();
#endif
#ifdef SerialFirmata_h
serial.update();
#endif
// keep the WiFi connection live. Attempts to reconnect automatically if disconnected.
stream.maintain();
}

458
libraries/FirmataWithDeviceFeature/extras/LICENSE.txt Normal file
View File

@@ -0,0 +1,458 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

48
libraries/FirmataWithDeviceFeature/extras/v0.9-release-notes.md Normal file
View File

@@ -0,0 +1,48 @@
##FirmataWithDeviceFeature
###A fork of Configurable Firmata with the addition of the DeviceFirmata feature, enabling the use of device driver modules as defined by LuniLib.
####Summary
ConfigurableFirmata is a Firmata implementation that splits the various capabilities of Firmata into separate
classes that can be included or excluded when an Arduino program is compiled and linked in order to tailor the
code to the needs of the application and (hopefully) save memory. This FirmataWithDeviceFeature is a fork of
ConfigurableFirmata and includes an additional feature that recognizes and manages DEVICE\_QUERY and DEVICE\_RESPONSE
Sysex messages.
The stable release repositories for the LuniLib related packages are available on github.com from user finson-release.
####Release v0.9, July 2016
This library is one of several concurrent v0.9 releases.
- The Arduino library LuniLib (Arduino Device Driver framework and a few example drivers)
- FirmataWithDeviceFeature, a fork of ConfigurableFirmata that includes the DeviceFirmata pull request
- LuniJS (Javascript NodeJS client package)
Changes to FirmataWithDeviceFeature for v0.9 include:
1. Minor changes to facilitate use of the Arduino library manager: version number, library.properties
2. Additions and updates to the documentation: release notes.
Dependencies
- LuniLib by Doug Johnson at https://github.com/finson-release/luni
- base64 by Adam Rudd at https://github.com/adamvr/arduino-base64
####Release v0.8, May 2016
First release for beta testing.
This library is part of several concurrent v0.8 releases:
- This Arduino library LuniLib
- Update to Configurable Firmata (Arduino Firmata host connection to remote clients)
- LuniJS (Javascript NodeJS client package)
- LuniFive (Javascript Johnny-Five client controller examples) [Update. No, didn't happen, see LuniJS for a Johnny-Five example.]
There are initially three ways to use this library.
1. Standalone LuniLib. All code is on the Arduino and there is no external control of the various device drivers. There are examples included in the library. Only the LuniLib itself is needed for this configuration.
2. NodeJS and LuniLib. The device driver library (and a device driver or two), along with an updated Configurable Firmata are on the Arduino, and NodeJS is running on a client. Required packages are Arduino LuniLib, updated Configurable Firmata, and lunijs, an addon to firmata.js.
3. Johnny-Five and LuniLib.The device driver library (and a device driver or two), along with an updated Configurable Firmata are on the Arduino, and Johnny-Five is running on a client. All four packages listed above are needed in this configuration.

96
libraries/FirmataWithDeviceFeature/keywords.txt Normal file
View File

@@ -0,0 +1,96 @@
#######################################
# Syntax Coloring Map For Firmata
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
Firmata KEYWORD1 Firmata
callbackFunction KEYWORD1 callbackFunction
systemResetCallbackFunction KEYWORD1 systemResetCallbackFunction
stringCallbackFunction KEYWORD1 stringCallbackFunction
sysexCallbackFunction KEYWORD1 sysexCallbackFunction
#######################################
# Methods and Functions (KEYWORD2)
#######################################
begin KEYWORD2
printVersion KEYWORD2
blinkVersion KEYWORD2
printFirmwareVersion KEYWORD2
setFirmwareVersion KEYWORD2
setFirmwareNameAndVersion KEYWORD2
available KEYWORD2
processInput KEYWORD2
isParsingMessage KEYWORD2
parse KEYWORD2
sendAnalog KEYWORD2
sendDigital KEYWORD2
sendDigitalPort KEYWORD2
sendString KEYWORD2
sendSysex KEYWORD2
attach KEYWORD2
detach KEYWORD2
write KEYWORD2
sendValueAsTwo7bitBytes KEYWORD2
startSysex KEYWORD2
endSysex KEYWORD2
attachDelayTask KEYWORD2
delayTask KEYWORD2
getPinMode KEYWORD2
setPinMode KEYWORD2
getPinState KEYWORD2
setPinState KEYWORD2
writePort KEYWORD2
readPort KEYWORD2
disableBlinkVersion KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################
FIRMATA_PROTOCOL_MAJOR_VERSION LITERAL1
FIRMATA_PROTOCOL_MINOR_VERSION LITERAL1
FIRMATA_PROTOCOL_BUGFIX_VERSION LITERAL1
FIRMATA_FIRMWARE_MAJOR_VERSION LITERAL1
FIRMATA_FIRMWARE_MINOR_VERSION LITERAL1
FIRMATA_FIRMWARE_BUGFIX_VERSION LITERAL1
MAX_DATA_BYTES LITERAL1
DIGITAL_MESSAGE LITERAL1
ANALOG_MESSAGE LITERAL1
REPORT_ANALOG LITERAL1
REPORT_DIGITAL LITERAL1
REPORT_VERSION LITERAL1
SET_PIN_MODE LITERAL1
SET_DIGITAL_PIN_VALUE LITERAL1
SYSTEM_RESET LITERAL1
START_SYSEX LITERAL1
END_SYSEX LITERAL1
REPORT_FIRMWARE LITERAL1
STRING_DATA LITERAL1
PIN_MODE_ANALOG LITERAL1
PIN_MODE_PWM LITERAL1
PIN_MODE_SERVO LITERAL1
PIN_MODE_SHIFT LITERAL1
PIN_MODE_I2C LITERAL1
PIN_MODE_ONEWIRE LITERAL1
PIN_MODE_STEPPER LITERAL1
PIN_MODE_ENCODER LITERAL1
PIN_MODE_SERIAL LITERAL1
PIN_MODE_PULLUP LITERAL1
PIN_MODE_IGNORE LITERAL1
TOTAL_PINS LITERAL1
TOTAL_ANALOG_PINS LITERAL1
TOTAL_DIGITAL_PINS LITERAL1
TOTAL_PIN_MODES LITERAL1
TOTAL_PORTS LITERAL1
ANALOG_PORT LITERAL1
MAX_SERVOS LITERAL1

9
libraries/FirmataWithDeviceFeature/library.properties Normal file
View File

@@ -0,0 +1,9 @@
name=FirmataWithDeviceFeature
version=2.9.4
author=Firmata Developers, Doug Johnson
maintainer=Doug Johnson <strix@whidbey.com>
sentence=This library implements the Firmata protocol as a set of plugins that can be used to create applications to remotely interface with an Arduino board.
paragraph=FirmataWithDeviceFeature is a fork of ConfigurableFirmata 2.8.2 that adds a feature to support DeviceDrivers on the Arduino.
category=Device Control
url=https://github.com/finson-release/FirmataWithDeviceFeature
architectures=*

74
libraries/FirmataWithDeviceFeature/readme.md Normal file
View File

@@ -0,0 +1,74 @@
#ConfigurableFirmata
[![Join the chat at https://gitter.im/firmata/ConfigurableFirmata](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/firmata/ConfigurableFirmata?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.
##Installation
- **If you are using Arduino IDE version 1.6.4 or higher** go to `Sketch > Include Library > Manage Libraries` and then search for "ConfigurableFirmata" and click on `Install` after tapping on the ConfigurableFirmata item in the filtered results. You can also use this same method to update ConfigurableFirmata in the future.
- **If you are using an older version of the Arduino IDE**, download or clone ConfigurableFirmata to your Arduino sketchbook library folder. This is typically `/Documents/Arduino/libraries/` on Mac or Linux or `\My Documents\Arduino\libraries\` on Windows.
##Usage
ConfigurableFirmata is a version of Firmata that breaks features such as Digital Input, Digital Output, Analog Input, Analog Output, I2C, etc into [individual classes](https://github.com/firmata/ConfigurableFirmata/tree/master/src) making it easier to mix and match standard features with custom features.
The easiest way to use ConfigurableFirmata is with [firmatabuilder](http://firmatabuilder.com) which is a simple web application that generates an Arduino sketch based on a selection of Firmata features. Download the generated sketch, compile and upload it to your board.
Another way to use ConfigurableFirmata is by adding or removing various include statements in the [ConfigurableFirmata.ino](https://github.com/firmata/ConfigurableFirmata/blob/master/examples/ConfigurableFirmata/ConfigurableFirmata.ino) example file.
##Firmata Wrapper Libraries
You can use the ConfigurableFirmata architecture to wrap 3rd party libraries to include
functionality not included in the base ConfigurableFirmata.ino example. See [FirmataEncoder](https://github.com/firmata/FirmataEncoder) for an example of a Firmata wrapper. To include a Firmata wrapper your
ino file, you must install both the sketch and the 3rd party library into your `/Arduino/libraries/`
directory (where all 3rd party libraries are installed).
When creating a new Firmata wrapper library, you generally should not include the 3rd party
library it wraps. For example, the Encoder library that FirmataEncoder wraps is not included with
the FirmataEncoder library.
If you create a wrapper library, prepend the name with 'Firmata'. Hence 'FirmataEncoder' in the
referenced example. This will keep the wrapper libraries together in the user's Arduino libraries
directory.
A Firmata wrapper template library will be published soon along with instructions for creating
a wrapper library.
##Firmata Client Libraries
Only a few Firmata client libraries currently support ConfigurableFirmata:
* javascript
* [https://github.com/jgautier/firmata]
* [https://github.com/rwldrn/johnny-five]
* [http://breakoutjs.com]
* perl
* [https://github.com/ntruchsess/perl-firmata]
*Additional Firmata client libraries may work as well. If you're a client library developer and have verified that you library works with ConfigurableFirmata, please [open an issue](https://github.com/firmata/ConfigurableFirmata/issues) with a request to add the link.*
<a name="contributing" />
##Contributing
If you discover a bug or would like to propose a new feature, please open a new [issue](https://github.com/firmata/ConfigurableFirmata/issues?sort=created&state=open).
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.
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.
Use [Artistic Style](http://astyle.sourceforge.net/) (astyle) to format your code. Set the following rules for the astyle formatter:
```
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
```
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.

32
libraries/FirmataWithDeviceFeature/src-features/AnalogFirmata.cpp Normal file
View File

@@ -0,0 +1,32 @@
/*
AnalogFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
*/
#include <ConfigurableFirmata.h>
#include "AnalogFirmata.h"
boolean handleAnalogFirmataSysex(byte command, byte argc, byte* argv)
{
if (command == 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);
return true;
}
return false;
}

24
libraries/FirmataWithDeviceFeature/src-features/AnalogFirmata.h Normal file
View File

@@ -0,0 +1,24 @@
/*
AnalogFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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 AnalogFirmata_h
#define AnalogFirmata_h
#include <ConfigurableFirmata.h>
boolean handleAnalogFirmataSysex(byte command, byte argc, byte* argv);
#endif

109
libraries/FirmataWithDeviceFeature/src-features/AnalogInputFirmata.cpp Normal file
View File

@@ -0,0 +1,109 @@
/*
AnalogFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: November 22nd, 2015
*/
#include <ConfigurableFirmata.h>
#include "AnalogFirmata.h"
#include "AnalogInputFirmata.h"
AnalogInputFirmata *AnalogInputFirmataInstance;
void reportAnalogInputCallback(byte analogPin, int value)
{
AnalogInputFirmataInstance->reportAnalog(analogPin, value);
}
AnalogInputFirmata::AnalogInputFirmata()
{
AnalogInputFirmataInstance = this;
analogInputsToReport = 0;
Firmata.attach(REPORT_ANALOG, reportAnalogInputCallback);
}
// -----------------------------------------------------------------------------
/* sets bits in a bit array (int) to toggle the reporting of the analogIns
*/
//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
//}
void AnalogInputFirmata::reportAnalog(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 (!Firmata.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
}
boolean AnalogInputFirmata::handlePinMode(byte pin, int mode)
{
if (IS_PIN_ANALOG(pin)) {
if (mode == PIN_MODE_ANALOG) {
reportAnalog(PIN_TO_ANALOG(pin), 1); // turn on reporting
if (IS_PIN_DIGITAL(pin)) {
pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
}
return true;
} else {
reportAnalog(PIN_TO_ANALOG(pin), 0); // turn off reporting
}
}
return false;
}
void AnalogInputFirmata::handleCapability(byte pin)
{
if (IS_PIN_ANALOG(pin)) {
Firmata.write(PIN_MODE_ANALOG);
Firmata.write(10); // 10 = 10-bit resolution
}
}
boolean AnalogInputFirmata::handleSysex(byte command, byte argc, byte* argv)
{
return handleAnalogFirmataSysex(command, argc, argv);
}
void AnalogInputFirmata::reset()
{
// by default, do not report any analog inputs
analogInputsToReport = 0;
}
void AnalogInputFirmata::report()
{
byte pin, analogPin;
/* ANALOGREAD - do all analogReads() at the configured sampling interval */
for (pin = 0; pin < TOTAL_PINS; pin++) {
if (IS_PIN_ANALOG(pin) && Firmata.getPinMode(pin) == PIN_MODE_ANALOG) {
analogPin = PIN_TO_ANALOG(pin);
if (analogInputsToReport & (1 << analogPin)) {
Firmata.sendAnalog(analogPin, analogRead(analogPin));
}
}
}
}

42
libraries/FirmataWithDeviceFeature/src-features/AnalogInputFirmata.h Normal file
View File

@@ -0,0 +1,42 @@
/*
AnalogFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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 AnalogInputFirmata_h
#define AnalogInputFirmata_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#include "FirmataReporting.h"
void reportAnalogInputCallback(byte analogPin, int value);
class AnalogInputFirmata: public FirmataFeature
{
public:
AnalogInputFirmata();
void reportAnalog(byte analogPin, int value);
void handleCapability(byte pin);
boolean handlePinMode(byte pin, int mode);
boolean handleSysex(byte command, byte argc, byte* argv);
void reset();
void report();
private:
/* analog inputs */
int analogInputsToReport; // bitwise array to store pin reporting
};
#endif

65
libraries/FirmataWithDeviceFeature/src-features/AnalogOutputFirmata.cpp Normal file
View File

@@ -0,0 +1,65 @@
/*
AnalogFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: November 22nd, 2015
*/
#include <ConfigurableFirmata.h>
#include "AnalogFirmata.h"
#include "AnalogOutputFirmata.h"
AnalogOutputFirmata::AnalogOutputFirmata()
{
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
}
void AnalogOutputFirmata::reset()
{
}
boolean AnalogOutputFirmata::handlePinMode(byte pin, int mode)
{
if (mode == PIN_MODE_PWM && IS_PIN_PWM(pin)) {
pinMode(PIN_TO_PWM(pin), OUTPUT);
analogWrite(PIN_TO_PWM(pin), 0);
return true;
}
return false;
}
void AnalogOutputFirmata::handleCapability(byte pin)
{
if (IS_PIN_PWM(pin)) {
Firmata.write(PIN_MODE_PWM);
Firmata.write(8); // 8 = 8-bit resolution
}
}
boolean AnalogOutputFirmata::handleSysex(byte command, byte argc, byte* argv)
{
if (command == 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);
return true;
}
return false;
} else {
return handleAnalogFirmataSysex(command, argc, argv);
}
}

38
libraries/FirmataWithDeviceFeature/src-features/AnalogOutputFirmata.h Normal file
View File

@@ -0,0 +1,38 @@
/*
AnalogFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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 AnalogOutputFirmata_h
#define AnalogOutputFirmata_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
// analogWriteCallback is defined in AnalogWrite.h but must also be declared here in order
// for AnalogOutputFirmata to compile
void analogWriteCallback(byte pin, int value);
class AnalogOutputFirmata: public FirmataFeature
{
public:
AnalogOutputFirmata();
void handleCapability(byte pin);
boolean handlePinMode(byte pin, int mode);
boolean handleSysex(byte command, byte argc, byte* argv);
void reset();
private:
};
#endif

51
libraries/FirmataWithDeviceFeature/src-features/AnalogWrite.h Normal file
View File

@@ -0,0 +1,51 @@
/*
AnalogWrite.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: November 15th, 2015
*/
#ifndef AnalogWrite_h
#define AnalogWrite_h
#include <ConfigurableFirmata.h>
#if defined AnalogOutputFirmata_h || defined ServoFirmata_h
void analogWriteCallback(byte pin, int value)
{
if (pin < TOTAL_PINS) {
switch (Firmata.getPinMode(pin)) {
#ifdef ServoFirmata_h
case PIN_MODE_SERVO:
if (IS_PIN_SERVO(pin)) {
servoAnalogWrite(pin, value);
Firmata.setPinState(pin, value);
}
break;
#endif
#ifdef AnalogOutputFirmata_h
case PIN_MODE_PWM:
if (IS_PIN_PWM(pin)) {
analogWrite(PIN_TO_PWM(pin), value);
Firmata.setPinState(pin, value);
}
break;
#endif
}
}
}
#endif
#endif

127
libraries/FirmataWithDeviceFeature/src-features/DigitalInputFirmata.cpp Normal file
View File

@@ -0,0 +1,127 @@
/*
DigitalInputFirmata.cpp - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: November 15th, 2015
*/
#include <ConfigurableFirmata.h>
#include "DigitalInputFirmata.h"
DigitalInputFirmata *DigitalInputFirmataInstance;
void reportDigitalInputCallback(byte port, int value)
{
DigitalInputFirmataInstance->reportDigital(port, value);
}
DigitalInputFirmata::DigitalInputFirmata()
{
DigitalInputFirmataInstance = this;
Firmata.attach(REPORT_DIGITAL, reportDigitalInputCallback);
}
boolean DigitalInputFirmata::handleSysex(byte command, byte argc, byte* argv)
{
return false;
}
void DigitalInputFirmata::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 DigitalInputFirmata::report(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);
}
void DigitalInputFirmata::reportDigital(byte port, int value)
{
if (port < TOTAL_PORTS) {
reportPINs[port] = (byte)value;
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
}
boolean DigitalInputFirmata::handlePinMode(byte pin, int mode)
{
if (IS_PIN_DIGITAL(pin)) {
if (mode == INPUT || mode == PIN_MODE_PULLUP) {
portConfigInputs[pin / 8] |= (1 << (pin & 7));
if (mode == INPUT) {
pinMode(PIN_TO_DIGITAL(pin), INPUT);
} else {
pinMode(PIN_TO_DIGITAL(pin), INPUT_PULLUP);
Firmata.setPinState(pin, 1);
}
return true;
} else {
portConfigInputs[pin / 8] &= ~(1 << (pin & 7));
}
}
return false;
}
void DigitalInputFirmata::handleCapability(byte pin)
{
if (IS_PIN_DIGITAL(pin)) {
Firmata.write((byte)INPUT);
Firmata.write(1);
Firmata.write((byte)PIN_MODE_PULLUP);
Firmata.write(1);
}
}
void DigitalInputFirmata::reset()
{
for (byte i = 0; i < TOTAL_PORTS; i++) {
reportPINs[i] = false; // by default, reporting off
portConfigInputs[i] = 0; // until activated
previousPINs[i] = 0;
}
}

46
libraries/FirmataWithDeviceFeature/src-features/DigitalInputFirmata.h Normal file
View File

@@ -0,0 +1,46 @@
/*
DigitalInputFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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 DigitalInputFirmata_h
#define DigitalInputFirmata_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
void reportDigitalInputCallback(byte port, int value);
class DigitalInputFirmata: public FirmataFeature
{
public:
DigitalInputFirmata();
void reportDigital(byte port, int value);
void report(void);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte* argv);
boolean handlePinMode(byte pin, int mode);
void reset();
private:
/* digital input ports */
byte reportPINs[TOTAL_PORTS]; // 1 = report this port, 0 = silence
byte previousPINs[TOTAL_PORTS]; // previous 8 bits sent
/* pins configuration */
byte portConfigInputs[TOTAL_PORTS]; // each bit: 1 = pin in INPUT, 0 = anything else
void outputPort(byte portNumber, byte portValue, byte forceSend);
};
#endif

106
libraries/FirmataWithDeviceFeature/src-features/DigitalOutputFirmata.cpp Normal file
View File

@@ -0,0 +1,106 @@
/*
DigitalOutputFirmata.cpp - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: February 16th, 2016
*/
#include <ConfigurableFirmata.h>
#include "DigitalOutputFirmata.h"
DigitalOutputFirmata *DigitalOutputFirmataInstance;
void digitalOutputWriteCallback(byte port, int value)
{
DigitalOutputFirmataInstance->digitalWritePort(port, value);
}
/*
* Sets the value of an individual pin. Useful if you want to set a pin value but
* are not tracking the digital port state.
* Can only be used on pins configured as OUTPUT.
* Cannot be used to enable pull-ups on Digital INPUT pins.
*/
void handleSetPinValueCallback(byte pin, int value)
{
if (pin < TOTAL_PINS && IS_PIN_DIGITAL(pin)) {
if (Firmata.getPinMode(pin) == OUTPUT) {
digitalWrite(pin, value);
Firmata.setPinState(pin, value);
}
}
}
DigitalOutputFirmata::DigitalOutputFirmata()
{
DigitalOutputFirmataInstance = this;
Firmata.attach(DIGITAL_MESSAGE, digitalOutputWriteCallback);
Firmata.attach(SET_DIGITAL_PIN_VALUE, handleSetPinValueCallback);
}
boolean DigitalOutputFirmata::handleSysex(byte command, byte argc, byte* argv)
{
return false;
}
void DigitalOutputFirmata::reset()
{
}
void DigitalOutputFirmata::digitalWritePort(byte port, int value)
{
byte pin, lastPin, pinValue, 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)) {
// do not touch pins in PWM, ANALOG, SERVO or other modes
if (Firmata.getPinMode(pin) == OUTPUT || Firmata.getPinMode(pin) == INPUT) {
pinValue = ((byte)value & mask) ? 1 : 0;
if (Firmata.getPinMode(pin) == OUTPUT) {
pinWriteMask |= mask;
} else if (Firmata.getPinMode(pin) == INPUT && pinValue == 1 && Firmata.getPinState(pin) != 1) {
pinMode(pin, INPUT_PULLUP);
}
Firmata.setPinState(pin, pinValue);
}
}
mask = mask << 1;
}
writePort(port, (byte)value, pinWriteMask);
}
}
boolean DigitalOutputFirmata::handlePinMode(byte pin, int mode)
{
if (IS_PIN_DIGITAL(pin) && mode == OUTPUT && Firmata.getPinMode(pin) != PIN_MODE_IGNORE) {
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
return true;
}
return false;
}
void DigitalOutputFirmata::handleCapability(byte pin)
{
if (IS_PIN_DIGITAL(pin)) {
Firmata.write((byte)OUTPUT);
Firmata.write(1);
}
}

40
libraries/FirmataWithDeviceFeature/src-features/DigitalOutputFirmata.h Normal file
View File

@@ -0,0 +1,40 @@
/*
DigitalOutputFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: November 15th, 2015
*/
#ifndef DigitalOutputFirmata_h
#define DigitalOutputFirmata_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
void digitalOutputWriteCallback(byte port, int value);
void handleSetPinValueCallback(byte pin, int value);
class DigitalOutputFirmata: public FirmataFeature
{
public:
DigitalOutputFirmata();
void digitalWritePort(byte port, int value);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte* argv);
boolean handlePinMode(byte pin, int mode);
void reset();
private:
};
#endif

64
libraries/FirmataWithDeviceFeature/src-features/Encoder7Bit.cpp Normal file
View File

@@ -0,0 +1,64 @@
/*
Encoder7Bit.cpp - Firmata library
Copyright (C) 2012-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.
*/
#include "Encoder7Bit.h"
#include <ConfigurableFirmata.h>
Encoder7BitClass::Encoder7BitClass()
{
previous = 0;
shift = 0;
}
void Encoder7BitClass::startBinaryWrite()
{
shift = 0;
}
void Encoder7BitClass::endBinaryWrite()
{
if (shift > 0) {
Firmata.write(previous);
}
}
void Encoder7BitClass::writeBinary(byte data)
{
if (shift == 0) {
Firmata.write(data & 0x7f);
shift++;
previous = data >> 7;
}
else {
Firmata.write(((data << shift) & 0x7f) | previous);
if (shift == 6) {
Firmata.write(data >> 1);
shift = 0;
}
else {
shift++;
previous = data >> (8 - shift);
}
}
}
void Encoder7BitClass::readBinary(int outBytes, byte *inData, byte *outData)
{
for (int i = 0; i < outBytes; i++) {
int j = i << 3;
int pos = j / 7;
byte shift = j % 7;
outData[i] = (inData[pos] >> shift) | ((inData[pos + 1] << (7 - shift)) & 0xFF);
}
}
Encoder7BitClass Encoder7Bit;

35
libraries/FirmataWithDeviceFeature/src-features/Encoder7Bit.h Normal file
View File

@@ -0,0 +1,35 @@
/*
Encoder7Bit.h - Firmata library
Copyright (C) 2012-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.
*/
#ifndef Encoder7Bit_h
#define Encoder7Bit_h
#include <Arduino.h>
#define num7BitOutbytes(a)(((a)*7)>>3)
class Encoder7BitClass
{
public:
Encoder7BitClass();
void startBinaryWrite();
void endBinaryWrite();
void writeBinary(byte data);
void readBinary(int outBytes, byte *inData, byte *outData);
private:
byte previous;
int shift;
};
extern Encoder7BitClass Encoder7Bit;
#endif

103
libraries/FirmataWithDeviceFeature/src-features/EthernetClientStream.cpp Normal file
View File

@@ -0,0 +1,103 @@
/*
EthernetClientStream.cpp
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.
*/
#include "EthernetClientStream.h"
#include <Arduino.h>
#define MILLIS_RECONNECT 5000
EthernetClientStream::EthernetClientStream(Client &client, IPAddress localip, IPAddress ip, const char* host, uint16_t port)
: client(client),
localip(localip),
ip(ip),
host(host),
port(port),
connected(false)
{
}
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)
{
// temporary hack to Firmata to compile for Intel Galileo
// the issue is documented here: https://github.com/firmata/arduino/issues/218
#if !defined(ARDUINO_LINUX)
if (this->localip!=localip)
{
this->localip = localip;
if (connected)
stop();
}
#endif
}
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();
}
return connected;
}

50
libraries/FirmataWithDeviceFeature/src-features/EthernetClientStream.h Normal file
View File

@@ -0,0 +1,50 @@
/*
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.
*/
#ifndef ETHERNETCLIENTSTREAM_H
#define ETHERNETCLIENTSTREAM_H
#include <inttypes.h>
#include <stdio.h>
#include <Stream.h>
#include <Client.h>
#include <IPAddress.h>
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:
Client &client;
IPAddress localip;
IPAddress ip;
const char* host;
uint16_t port;
bool connected;
uint32_t time_connect;
bool maintain();
void stop();
};
#endif

66
libraries/FirmataWithDeviceFeature/src-features/FirmataReporting.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
FirmataReporting.cpp - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
*/
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#include "FirmataReporting.h"
void FirmataReporting::setSamplingInterval(int interval)
{
samplingInterval = interval;
}
void FirmataReporting::handleCapability(byte pin)
{
}
boolean FirmataReporting::handlePinMode(byte pin, int mode)
{
return false;
}
boolean FirmataReporting::handleSysex(byte command, byte argc, byte* argv)
{
if (command == SAMPLING_INTERVAL) {
if (argc > 1) {
samplingInterval = argv[0] + (argv[1] << 7);
if (samplingInterval < MINIMUM_SAMPLING_INTERVAL) {
samplingInterval = MINIMUM_SAMPLING_INTERVAL;
}
return true;
}
}
return false;
}
boolean FirmataReporting::elapsed()
{
currentMillis = millis();
if (currentMillis - previousMillis > samplingInterval) {
previousMillis += samplingInterval;
if (currentMillis - previousMillis > samplingInterval)
previousMillis = currentMillis - samplingInterval;
return true;
}
return false;
}
void FirmataReporting::reset()
{
previousMillis = millis();
samplingInterval = 19;
}

43
libraries/FirmataWithDeviceFeature/src-features/FirmataReporting.h Normal file
View File

@@ -0,0 +1,43 @@
/*
FirmataReporting.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: January 23rd, 2016
*/
#ifndef FirmataReporting_h
#define FirmataReporting_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#define MINIMUM_SAMPLING_INTERVAL 1
class FirmataReporting: public FirmataFeature
{
public:
void setSamplingInterval(int interval);
void handleCapability(byte pin); //empty method
boolean handlePinMode(byte pin, int mode); //empty method
boolean handleSysex(byte command, byte argc, byte* argv);
boolean elapsed();
void reset();
private:
/* timer variables */
unsigned long currentMillis; // store the current value from millis()
unsigned long previousMillis; // for comparison with currentMillis
unsigned int samplingInterval; // how often to run the main loop (in ms)
};
#endif

300
libraries/FirmataWithDeviceFeature/src-features/FirmataScheduler.cpp Normal file
View File

@@ -0,0 +1,300 @@
/*
FirmataScheduler.cpp - Firmata library
Copyright (C) 2012-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.
*/
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#include "Encoder7Bit.h"
#include "FirmataScheduler.h"
#include "FirmataExt.h"
FirmataScheduler *FirmataSchedulerInstance;
void delayTaskCallback(long delay)
{
FirmataSchedulerInstance->delayTask(delay);
}
FirmataScheduler::FirmataScheduler()
{
FirmataSchedulerInstance = this;
tasks = NULL;
running = NULL;
Firmata.attachDelayTask(delayTaskCallback);
}
void FirmataScheduler::handleCapability(byte pin)
{
}
boolean FirmataScheduler::handlePinMode(byte pin, int mode)
{
return false;
}
boolean FirmataScheduler::handleSysex(byte command, byte argc, byte* argv)
{
if (command == SCHEDULER_DATA) {
if (argc > 0) {
switch (argv[0]) {
case CREATE_FIRMATA_TASK:
{
if (argc == 4) {
createTask(argv[1], argv[2] | argv[3] << 7);
}
break;
}
case DELETE_FIRMATA_TASK:
{
if (argc == 2) {
deleteTask(argv[1]);
}
break;
}
case ADD_TO_FIRMATA_TASK:
{
if (argc > 2) {
int len = num7BitOutbytes(argc - 2);
Encoder7Bit.readBinary(len, argv + 2, argv + 2); //decode inplace
addToTask(argv[1], len, argv + 2); //addToTask copies data...
}
break;
}
case DELAY_FIRMATA_TASK:
{
if (argc == 6) {
argv++;
Encoder7Bit.readBinary(4, argv, argv); //decode inplace
delayTask(*(long*)((byte*)argv));
}
break;
}
case SCHEDULE_FIRMATA_TASK:
{
if (argc == 7) { //one byte taskid, 5 bytes to encode 4 bytes of long
Encoder7Bit.readBinary(4, argv + 2, argv + 2); //decode inplace
schedule(argv[1], *(long*)((byte*)argv + 2)); //argv[1] | argv[2]<<8 | argv[3]<<16 | argv[4]<<24
}
break;
}
case QUERY_ALL_FIRMATA_TASKS:
{
queryAllTasks();
break;
}
case QUERY_FIRMATA_TASK:
{
if (argc == 2) {
queryTask(argv[1]);
}
break;
}
case RESET_FIRMATA_TASKS:
{
reset();
}
}
}
return true;
}
return false;
};
void FirmataScheduler::createTask(byte id, int len)
{
firmata_task *existing = findTask(id);
if (existing) {
reportTask(id, existing, true);
}
else {
firmata_task *newTask = (firmata_task*)malloc(sizeof(firmata_task) + len);
newTask->id = id;
newTask->time_ms = 0;
newTask->len = len;
newTask->nextTask = tasks;
newTask->pos = 0;
tasks = newTask;
}
};
void FirmataScheduler::deleteTask(byte id)
{
firmata_task *current = tasks;
firmata_task *previous = NULL;
while (current) {
if (current->id == id) {
if (previous) {
previous->nextTask = current->nextTask;
}
else {
tasks = current->nextTask;
}
free (current);
return;
}
else {
previous = current;
current = current->nextTask;
}
}
};
void FirmataScheduler::addToTask(byte id, int additionalBytes, byte *message)
{
firmata_task *existing = findTask(id);
if (existing) { //task exists and has not been fully loaded yet
if (existing->pos + additionalBytes <= existing->len) {
for (int i = 0; i < additionalBytes; i++) {
existing->messages[existing->pos++] = message[i];
}
}
}
else {
reportTask(id, NULL, true);
}
};
void FirmataScheduler::schedule(byte id, long delay_ms)
{
firmata_task *existing = findTask(id);
if (existing) {
existing->pos = 0;
existing->time_ms = millis() + delay_ms;
}
else {
reportTask(id, NULL, true);
}
};
void FirmataScheduler::delayTask(long delay_ms)
{
if (running) {
long now = millis();
running->time_ms += delay_ms;
if (running->time_ms < now) { //if delay time allready passed by schedule to 'now'.
running->time_ms = now;
}
}
}
void FirmataScheduler::queryAllTasks()
{
Firmata.write(START_SYSEX);
Firmata.write(SCHEDULER_DATA);
Firmata.write(QUERY_ALL_TASKS_REPLY);
firmata_task *task = tasks;
while (task) {
Firmata.write(task->id);
task = task->nextTask;
}
Firmata.write(END_SYSEX);
};
void FirmataScheduler::queryTask(byte id)
{
firmata_task *task = findTask(id);
reportTask(id, task, false);
}
void FirmataScheduler::reportTask(byte id, firmata_task *task, boolean error)
{
Firmata.write(START_SYSEX);
Firmata.write(SCHEDULER_DATA);
if (error) {
Firmata.write(ERROR_TASK_REPLY);
} else {
Firmata.write(QUERY_TASK_REPLY);
}
Firmata.write(id);
if (task) {
Encoder7Bit.startBinaryWrite();
for (int i = 3; i < firmata_task_len(task); i++) {
Encoder7Bit.writeBinary(((byte *)task)[i]); //don't write first 3 bytes (firmata_task*, byte); makes use of AVR byteorder (LSB first)
}
Encoder7Bit.endBinaryWrite();
}
Firmata.write(END_SYSEX);
};
void FirmataScheduler::runTasks()
{
if (tasks) {
long now = millis();
firmata_task *current = tasks;
firmata_task *previous = NULL;
while (current) {
if (current->time_ms > 0 && current->time_ms < now) { // TODO handle overflow
if (execute(current)) {
previous = current;
current = current->nextTask;
}
else {
if (previous) {
previous->nextTask = current->nextTask;
free(current);
current = previous->nextTask;
}
else {
tasks = current->nextTask;
free(current);
current = tasks;
}
}
}
else {
current = current->nextTask;
}
}
}
};
void FirmataScheduler::reset()
{
while (tasks) {
firmata_task *nextTask = tasks->nextTask;
free(tasks);
tasks = nextTask;
}
};
//private
boolean FirmataScheduler::execute(firmata_task *task)
{
long start = task->time_ms;
int pos = task->pos;
int len = task->len;
byte *messages = task->messages;
running = task;
while (pos < len) {
Firmata.parse(messages[pos++]);
if (start != task->time_ms) { // return true if task got rescheduled during run.
task->pos = ( pos == len ? 0 : pos ); // last message executed? -> start over next time
running = NULL;
return true;
}
};
running = NULL;
return false;
}
firmata_task *FirmataScheduler::findTask(byte id)
{
firmata_task *currentTask = tasks;
while (currentTask) {
if (id == currentTask->id) {
return currentTask;
} else {
currentTask = currentTask->nextTask;
}
};
return NULL;
}

73
libraries/FirmataWithDeviceFeature/src-features/FirmataScheduler.h Normal file
View File

@@ -0,0 +1,73 @@
/*
FirmataScheduler.h - Firmata library
Copyright (C) 2012-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.
*/
#ifndef FirmataScheduler_h
#define FirmataScheduler_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#include "Encoder7Bit.h"
//subcommands
#define CREATE_FIRMATA_TASK 0
#define DELETE_FIRMATA_TASK 1
#define ADD_TO_FIRMATA_TASK 2
#define DELAY_FIRMATA_TASK 3
#define SCHEDULE_FIRMATA_TASK 4
#define QUERY_ALL_FIRMATA_TASKS 5
#define QUERY_FIRMATA_TASK 6
#define RESET_FIRMATA_TASKS 7
#define ERROR_TASK_REPLY 8
#define QUERY_ALL_TASKS_REPLY 9
#define QUERY_TASK_REPLY 10
#define firmata_task_len(a)(sizeof(firmata_task)+(a)->len)
void delayTaskCallback(long delay);
struct firmata_task
{
firmata_task *nextTask;
byte id; //only 7bits used -> supports 127 tasks
long time_ms;
int len;
int pos;
byte messages[];
};
class FirmataScheduler: public FirmataFeature
{
public:
FirmataScheduler();
void handleCapability(byte pin); //empty method
boolean handlePinMode(byte pin, int mode); //empty method
boolean handleSysex(byte command, byte argc, byte* argv);
void runTasks();
void reset();
void createTask(byte id, int len);
void deleteTask(byte id);
void addToTask(byte id, int len, byte *message);
void schedule(byte id, long time_ms);
void delayTask(long time_ms);
void queryAllTasks();
void queryTask(byte id);
private:
firmata_task *tasks;
firmata_task *running;
boolean execute(firmata_task *task);
firmata_task *findTask(byte id);
void reportTask(byte id, firmata_task *task, boolean error);
};
#endif

4
libraries/FirmataWithDeviceFeature/src-features/I2CFirmata.cpp Normal file
View File

@@ -0,0 +1,4 @@
/*
* Implementation is in I2CFirmata.h to avoid having to include Wire.h in all
* sketch files that include ConfigurableFirmata.h
*/

333
libraries/FirmataWithDeviceFeature/src-features/I2CFirmata.h Normal file
View File

@@ -0,0 +1,333 @@
/*
I2CFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
I2CFirmata.cpp has been merged into this header file as a hack to avoid having to
include Wire.h for every arduino sketch that includes ConfigurableFirmata.
Last updated by Jeff Hoefs: January 23rd, 2015
*/
#ifndef I2CFirmata_h
#define I2CFirmata_h
#include <Wire.h>
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#include "FirmataReporting.h"
#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 I2C_END_TX_MASK B01000000
#define I2C_STOP_TX 1
#define I2C_RESTART_TX 0
#define I2C_MAX_QUERIES 8
#define I2C_REGISTER_NOT_SPECIFIED -1
/* i2c data */
struct i2c_device_info {
byte addr;
int reg;
byte bytes;
byte stopTX;
};
class I2CFirmata: public FirmataFeature
{
public:
I2CFirmata();
boolean handlePinMode(byte pin, int mode);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte* argv);
void reset();
void report();
private:
/* for i2c read continuous more */
i2c_device_info query[I2C_MAX_QUERIES];
byte i2cRxData[32];
boolean isI2CEnabled;
signed char queryIndex;
unsigned int i2cReadDelayTime; // default delay time between i2c read request and Wire.requestFrom()
void readAndReportData(byte address, int theRegister, byte numBytes, byte stopTX);
void handleI2CRequest(byte argc, byte *argv);
boolean handleI2CConfig(byte argc, byte *argv);
boolean enableI2CPins();
void disableI2CPins();
};
/*
* I2CFirmata.cpp
* Copied here as a hack to avoid having to include Wire.h in all sketch files that
* include ConfigurableFirmata.h
*/
I2CFirmata::I2CFirmata()
{
isI2CEnabled = false;
queryIndex = -1;
i2cReadDelayTime = 0; // default delay time between i2c read request and Wire.requestFrom()
}
void I2CFirmata::readAndReportData(byte address, int theRegister, byte numBytes, byte stopTX) {
// 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 != I2C_REGISTER_NOT_SPECIFIED) {
Wire.beginTransmission(address);
Wire.write((byte)theRegister);
Wire.endTransmission(stopTX); // default = true
// 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] = Wire.read();
}
// send slave address, register and received bytes
Firmata.sendSysex(SYSEX_I2C_REPLY, numBytes + 2, i2cRxData);
}
boolean I2CFirmata::handlePinMode(byte pin, int mode)
{
if (IS_PIN_I2C(pin)) {
if (mode == PIN_MODE_I2C) {
// the user must call I2C_CONFIG to enable I2C for a device
return true;
} else if (isI2CEnabled) {
// disable i2c so pins can be used for other functions
// the following if statements should reconfigure the pins properly
if (Firmata.getPinMode(pin) == PIN_MODE_I2C) {
disableI2CPins();
}
}
}
return false;
}
void I2CFirmata::handleCapability(byte pin)
{
if (IS_PIN_I2C(pin)) {
Firmata.write(PIN_MODE_I2C);
Firmata.write(1); // TODO: could assign a number to map to SCL or SDA
}
}
boolean I2CFirmata::handleSysex(byte command, byte argc, byte *argv)
{
switch (command) {
case I2C_REQUEST:
if (isI2CEnabled) {
handleI2CRequest(argc, argv);
return true;
}
case I2C_CONFIG:
return handleI2CConfig(argc, argv);
}
return false;
}
void I2CFirmata::handleI2CRequest(byte argc, byte *argv)
{
byte mode;
byte stopTX;
byte slaveAddress;
byte data;
int slaveRegister;
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];
}
// need to invert the logic here since 0 will be default for client
// libraries that have not updated to add support for restart tx
if (argv[1] & I2C_END_TX_MASK) {
stopTX = I2C_RESTART_TX;
}
else {
stopTX = I2C_STOP_TX; // default
}
switch (mode) {
case I2C_WRITE:
Wire.beginTransmission(slaveAddress);
for (byte i = 2; i < argc; i += 2) {
data = argv[i] + (argv[i + 1] << 7);
Wire.write(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 = I2C_REGISTER_NOT_SPECIFIED;
data = argv[2] + (argv[3] << 7); // bytes to read
}
readAndReportData(slaveAddress, (int)slaveRegister, data, stopTX);
break;
case I2C_READ_CONTINUOUSLY:
if ((queryIndex + 1) >= I2C_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)I2C_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;
query[queryIndex].stopTX = stopTX;
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 {
queryIndexToSkip = 0;
// 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 < I2C_MAX_QUERIES) {
query[i].addr = query[i + 1].addr;
query[i].reg = query[i + 1].reg;
query[i].bytes = query[i + 1].bytes;
query[i].stopTX = query[i + 1].stopTX;
}
}
queryIndex--;
}
break;
default:
break;
}
}
boolean I2CFirmata::handleI2CConfig(byte argc, byte *argv)
{
unsigned int delayTime = (argv[0] + (argv[1] << 7));
if (delayTime > 0) {
i2cReadDelayTime = delayTime;
}
if (!isI2CEnabled) {
enableI2CPins();
}
return isI2CEnabled;
}
boolean I2CFirmata::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)) {
if (Firmata.getPinMode(i) == PIN_MODE_IGNORE) {
return false;
}
// mark pins as i2c so they are ignore in non i2c data requests
Firmata.setPinMode(i, PIN_MODE_I2C);
pinMode(i, PIN_MODE_I2C);
}
}
isI2CEnabled = true;
Wire.begin();
return true;
}
/* disable the i2c pins so they can be used for other functions */
void I2CFirmata::disableI2CPins()
{
isI2CEnabled = false;
// disable read continuous mode for all devices
queryIndex = -1;
// uncomment the following if or when the end() method is added to Wire library
// Wire.end();
}
void I2CFirmata::reset()
{
if (isI2CEnabled) {
disableI2CPins();
}
}
void I2CFirmata::report()
{
// 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, query[i].stopTX);
}
}
}
#endif /* I2CFirmata_h */

178
libraries/FirmataWithDeviceFeature/src-features/OneWireFirmata.cpp Normal file
View File

@@ -0,0 +1,178 @@
/*
OneWireFirmata.cpp - Firmata library
Copyright (C) 2012-2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: January 23rd, 2016
*/
#include <ConfigurableFirmata.h>
#include "OneWireFirmata.h"
#include "Encoder7Bit.h"
boolean OneWireFirmata::handlePinMode(byte pin, int mode)
{
if (IS_PIN_DIGITAL(pin) && mode == PIN_MODE_ONEWIRE) {
oneWireConfig(pin, ONEWIRE_POWER);
return true;
}
return false;
}
void OneWireFirmata::handleCapability(byte pin)
{
if (IS_PIN_DIGITAL(pin)) {
Firmata.write(PIN_MODE_ONEWIRE);
Firmata.write(1);
}
}
void OneWireFirmata::oneWireConfig(byte pin, boolean power)
{
ow_device_info *info = &pinOneWire[pin];
if (info->device == NULL) {
info->device = new OneWire(pin);
}
for (int i = 0; i < 8; i++) {
info->addr[i] = 0x0;
}
info->power = power;
}
boolean OneWireFirmata::handleSysex(byte command, byte argc, byte* argv)
{
if (command == ONEWIRE_DATA) {
if (argc > 1) {
byte subcommand = argv[0];
byte pin = argv[1];
ow_device_info *info = &pinOneWire[pin];
OneWire *device = info->device;
if (device || subcommand == ONEWIRE_CONFIG_REQUEST) {
switch (subcommand) {
case ONEWIRE_SEARCH_REQUEST:
case ONEWIRE_SEARCH_ALARMS_REQUEST:
{
device->reset_search();
Firmata.write(START_SYSEX);
Firmata.write(ONEWIRE_DATA);
boolean isAlarmSearch = (subcommand == ONEWIRE_SEARCH_ALARMS_REQUEST);
Firmata.write(isAlarmSearch ? (byte)ONEWIRE_SEARCH_ALARMS_REPLY : (byte)ONEWIRE_SEARCH_REPLY);
Firmata.write(pin);
Encoder7Bit.startBinaryWrite();
byte addrArray[8];
while (isAlarmSearch ? device->search(addrArray, false) : device->search(addrArray)) {
for (int i = 0; i < 8; i++) {
Encoder7Bit.writeBinary(addrArray[i]);
}
}
Encoder7Bit.endBinaryWrite();
Firmata.write(END_SYSEX);
break;
}
case ONEWIRE_CONFIG_REQUEST:
{
if (argc == 3 && Firmata.getPinMode(pin) != PIN_MODE_IGNORE) {
Firmata.setPinMode(pin, PIN_MODE_ONEWIRE);
oneWireConfig(pin, argv[2]); // this calls oneWireConfig again, this time setting the correct config (which doesn't cause harm though)
} else {
return false;
}
break;
}
default:
{
if (subcommand & ONEWIRE_RESET_REQUEST_BIT) {
device->reset();
for (int i = 0; i < 8; i++) {
info->addr[i] = 0x0;
}
}
if (subcommand & ONEWIRE_SKIP_REQUEST_BIT) {
device->skip();
for (byte i = 0; i < 8; i++) {
info->addr[i] = 0x0;
}
}
if (subcommand & ONEWIRE_WITHDATA_REQUEST_BITS) {
int numBytes = num7BitOutbytes(argc - 2);
int numReadBytes = 0;
int correlationId;
argv += 2;
Encoder7Bit.readBinary(numBytes, argv, argv); //decode inplace
if (subcommand & ONEWIRE_SELECT_REQUEST_BIT) {
if (numBytes < 8) break;
device->select(argv);
for (int i = 0; i < 8; i++) {
info->addr[i] = argv[i];
}
argv += 8;
numBytes -= 8;
}
if (subcommand & ONEWIRE_READ_REQUEST_BIT) {
if (numBytes < 4) break;
numReadBytes = *((int*)argv);
argv += 2;
correlationId = *((int*)argv);
argv += 2;
numBytes -= 4;
}
if (subcommand & ONEWIRE_DELAY_REQUEST_BIT) {
if (numBytes < 4) break;
Firmata.delayTask(*((long*)argv));
argv += 4;
numBytes -= 4;
}
if (subcommand & ONEWIRE_WRITE_REQUEST_BIT) {
for (int i = 0; i < numBytes; i++) {
info->device->write(argv[i], info->power);
}
}
if (numReadBytes > 0) {
Firmata.write(START_SYSEX);
Firmata.write(ONEWIRE_DATA);
Firmata.write(ONEWIRE_READ_REPLY);
Firmata.write(pin);
Encoder7Bit.startBinaryWrite();
Encoder7Bit.writeBinary(correlationId & 0xFF);
Encoder7Bit.writeBinary((correlationId >> 8) & 0xFF);
for (int i = 0; i < numReadBytes; i++) {
Encoder7Bit.writeBinary(device->read());
}
Encoder7Bit.endBinaryWrite();
Firmata.write(END_SYSEX);
}
}
}
}
}
return true;
}
}
return false;
}
void OneWireFirmata::reset()
{
for (int i = 0; i < TOTAL_PINS; i++) {
if (pinOneWire[i].device) {
free(pinOneWire[i].device);
pinOneWire[i].device = NULL;
}
for (int j = 0; j < 8; j++) {
pinOneWire[i].addr[j] = 0;
}
pinOneWire[i].power = false;
}
}

63
libraries/FirmataWithDeviceFeature/src-features/OneWireFirmata.h Normal file
View File

@@ -0,0 +1,63 @@
/*
OneWireFirmata.h - Firmata library
Copyright (C) 2012-2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2016 Jeff Hoefs. 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 OneWireFirmata_h
#define OneWireFirmata_h
#include <ConfigurableFirmata.h>
#include "utility/OneWire.h"
#include "FirmataFeature.h"
//subcommands:
#define ONEWIRE_SEARCH_REQUEST 0x40
#define ONEWIRE_CONFIG_REQUEST 0x41
#define ONEWIRE_SEARCH_REPLY 0x42
#define ONEWIRE_READ_REPLY 0x43
#define ONEWIRE_SEARCH_ALARMS_REQUEST 0x44
#define ONEWIRE_SEARCH_ALARMS_REPLY 0x45
#define ONEWIRE_RESET_REQUEST_BIT 0x01
#define ONEWIRE_SKIP_REQUEST_BIT 0x02
#define ONEWIRE_SELECT_REQUEST_BIT 0x04
#define ONEWIRE_READ_REQUEST_BIT 0x08
#define ONEWIRE_DELAY_REQUEST_BIT 0x10
#define ONEWIRE_WRITE_REQUEST_BIT 0x20
#define ONEWIRE_WITHDATA_REQUEST_BITS 0x3C
#define ONEWIRE_CRC 0 //for OneWire.h: crc-functions are not used by Firmata
//default value for power:
#define ONEWIRE_POWER 1
struct ow_device_info
{
OneWire* device;
byte addr[8];
boolean power;
};
class OneWireFirmata: public FirmataFeature
{
public:
boolean handlePinMode(byte pin, int mode);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte* argv);
void reset();
private:
ow_device_info pinOneWire[TOTAL_PINS];
void oneWireConfig(byte pin, boolean power);
};
#endif

358
libraries/FirmataWithDeviceFeature/src-features/SerialFirmata.cpp Normal file
View File

@@ -0,0 +1,358 @@
/*
SerialFirmata.cpp - Firmata library
Copyright (C) 2015-2016 Jeff Hoefs. 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.
Last updated March 6th, 2016
*/
#include "SerialFirmata.h"
SerialFirmata::SerialFirmata()
{
swSerial0 = NULL;
swSerial1 = NULL;
swSerial2 = NULL;
swSerial3 = NULL;
serialIndex = -1;
}
boolean SerialFirmata::handlePinMode(byte pin, int mode)
{
if (mode == PIN_MODE_SERIAL) {
// nothing else to do here since the mode is set in SERIAL_CONFIG
return true;
}
return false;
}
void SerialFirmata::handleCapability(byte pin)
{
if (IS_PIN_SERIAL(pin)) {
Firmata.write(PIN_MODE_SERIAL);
Firmata.write(getSerialPinType(pin));
}
}
boolean SerialFirmata::handleSysex(byte command, byte argc, byte *argv)
{
if (command == SERIAL_MESSAGE) {
Stream *serialPort;
byte mode = argv[0] & SERIAL_MODE_MASK;
byte portId = argv[0] & SERIAL_PORT_ID_MASK;
if (portId >= SERIAL_READ_ARR_LEN) return false;
switch (mode) {
case SERIAL_CONFIG:
{
long baud = (long)argv[1] | ((long)argv[2] << 7) | ((long)argv[3] << 14);
serial_pins pins;
lastAvailableBytes[portId] = 0;
lastReceive[portId] = 0;
// this ifdef will be removed once a command to enable RX buffering has been added to the protocol
#if defined(FIRMATA_SERIAL_PORT_RX_BUFFERING)
// 8N1 = 10 bits per char, max. 50 bits -> 50000 = 50bits * 1000ms/s
// char delay value (ms) to detect the end of a message, defaults to 50 bits * 1000 / baud rate
// a value of 0 will disable RX buffering, resulting in single byte transfers to the host with
// baud rates below approximately 56k (varies with CPU speed)
maxCharDelay[portId] = 50000 / baud;
#else
maxCharDelay[portId] = 0;
#endif
if (portId < 8) {
serialPort = getPortFromId(portId);
if (serialPort != NULL) {
pins = getSerialPinNumbers(portId);
if (pins.rx != 0 && pins.tx != 0) {
Firmata.setPinMode(pins.rx, PIN_MODE_SERIAL);
Firmata.setPinMode(pins.tx, PIN_MODE_SERIAL);
// Fixes an issue where some serial devices would not work properly with Arduino Due
// because all Arduino pins are set to OUTPUT by default in StandardFirmata.
pinMode(pins.rx, INPUT);
}
((HardwareSerial*)serialPort)->begin(baud);
}
} else {
#if defined(SoftwareSerial_h)
byte swTxPin, swRxPin;
if (argc > 4) {
swRxPin = argv[4];
swTxPin = argv[5];
} else {
// RX and TX pins must be specified when using software serial
Firmata.sendString("Specify serial RX and TX pins");
return false;
}
switch (portId) {
case SW_SERIAL0:
if (swSerial0 == NULL) {
swSerial0 = new SoftwareSerial(swRxPin, swTxPin);
}
break;
case SW_SERIAL1:
if (swSerial1 == NULL) {
swSerial1 = new SoftwareSerial(swRxPin, swTxPin);
}
break;
case SW_SERIAL2:
if (swSerial2 == NULL) {
swSerial2 = new SoftwareSerial(swRxPin, swTxPin);
}
break;
case SW_SERIAL3:
if (swSerial3 == NULL) {
swSerial3 = new SoftwareSerial(swRxPin, swTxPin);
}
break;
}
serialPort = getPortFromId(portId);
if (serialPort != NULL) {
Firmata.setPinMode(swRxPin, PIN_MODE_SERIAL);
Firmata.setPinMode(swTxPin, PIN_MODE_SERIAL);
((SoftwareSerial*)serialPort)->begin(baud);
}
#endif
}
break; // SERIAL_CONFIG
}
case SERIAL_WRITE:
{
byte data;
serialPort = getPortFromId(portId);
if (serialPort == NULL) {
break;
}
for (byte i = 1; i < argc; i += 2) {
data = argv[i] + (argv[i + 1] << 7);
serialPort->write(data);
}
break; // SERIAL_WRITE
}
case SERIAL_READ:
if (argv[1] == SERIAL_READ_CONTINUOUSLY) {
if (serialIndex + 1 >= MAX_SERIAL_PORTS) {
break;
}
if (argc > 2) {
// maximum number of bytes to read from buffer per iteration of loop()
serialBytesToRead[portId] = (int)argv[2] | ((int)argv[3] << 7);
} else {
// read all available bytes per iteration of loop()
serialBytesToRead[portId] = 0;
}
serialIndex++;
reportSerial[serialIndex] = portId;
} else if (argv[1] == SERIAL_STOP_READING) {
byte serialIndexToSkip = 0;
if (serialIndex <= 0) {
serialIndex = -1;
} else {
for (byte i = 0; i < serialIndex + 1; i++) {
if (reportSerial[i] == portId) {
serialIndexToSkip = i;
break;
}
}
// shift elements over to fill space left by removed element
for (byte i = serialIndexToSkip; i < serialIndex + 1; i++) {
if (i < MAX_SERIAL_PORTS) {
reportSerial[i] = reportSerial[i + 1];
}
}
serialIndex--;
}
}
break; // SERIAL_READ
case SERIAL_CLOSE:
serialPort = getPortFromId(portId);
if (serialPort != NULL) {
if (portId < 8) {
((HardwareSerial*)serialPort)->end();
} else {
#if defined(SoftwareSerial_h)
((SoftwareSerial*)serialPort)->end();
if (serialPort != NULL) {
free(serialPort);
serialPort = NULL;
}
#endif
}
}
break; // SERIAL_CLOSE
case SERIAL_FLUSH:
serialPort = getPortFromId(portId);
if (serialPort != NULL) {
getPortFromId(portId)->flush();
}
break; // SERIAL_FLUSH
#if defined(SoftwareSerial_h)
case SERIAL_LISTEN:
// can only call listen() on software serial ports
if (portId > 7) {
serialPort = getPortFromId(portId);
if (serialPort != NULL) {
((SoftwareSerial*)serialPort)->listen();
}
}
break; // SERIAL_LISTEN
#endif
}
return true;
}
return false;
}
void SerialFirmata::update()
{
checkSerial();
}
void SerialFirmata::reset()
{
#if defined(SoftwareSerial_h)
Stream *serialPort;
// free memory allocated for SoftwareSerial ports
for (byte i = SW_SERIAL0; i < SW_SERIAL3 + 1; i++) {
serialPort = getPortFromId(i);
if (serialPort != NULL) {
free(serialPort);
serialPort = NULL;
}
}
#endif
serialIndex = -1;
for (byte i = 0; i < SERIAL_READ_ARR_LEN; i++) {
serialBytesToRead[i] = 0;
}
}
// get a pointer to the serial port associated with the specified port id
Stream* SerialFirmata::getPortFromId(byte portId)
{
switch (portId) {
case HW_SERIAL0:
// block use of Serial (typically pins 0 and 1) until ability to reclaim Serial is implemented
//return &Serial;
return NULL;
#if defined(PIN_SERIAL1_RX)
case HW_SERIAL1:
return &Serial1;
#endif
#if defined(PIN_SERIAL2_RX)
case HW_SERIAL2:
return &Serial2;
#endif
#if defined(PIN_SERIAL3_RX)
case HW_SERIAL3:
return &Serial3;
#endif
#if defined(SoftwareSerial_h)
case SW_SERIAL0:
if (swSerial0 != NULL) {
// instances of SoftwareSerial are already pointers so simply return the instance
return swSerial0;
}
break;
case SW_SERIAL1:
if (swSerial1 != NULL) {
return swSerial1;
}
break;
case SW_SERIAL2:
if (swSerial2 != NULL) {
return swSerial2;
}
break;
case SW_SERIAL3:
if (swSerial3 != NULL) {
return swSerial3;
}
break;
#endif
}
return NULL;
}
// Check serial ports that have READ_CONTINUOUS mode set and relay any data
// for each port to the device attached to that port.
void SerialFirmata::checkSerial()
{
byte portId, serialData;
int bytesToRead = 0;
int numBytesToRead = 0;
Stream* serialPort;
if (serialIndex > -1) {
unsigned long currentMillis = millis();
// loop through all reporting (READ_CONTINUOUS) serial ports
for (byte i = 0; i < serialIndex + 1; i++) {
portId = reportSerial[i];
bytesToRead = serialBytesToRead[portId];
serialPort = getPortFromId(portId);
if (serialPort == NULL) {
continue;
}
#if defined(SoftwareSerial_h)
// only the SoftwareSerial port that is "listening" can read data
if (portId > 7 && !((SoftwareSerial*)serialPort)->isListening()) {
continue;
}
#endif
int availableBytes = serialPort->available();
if (availableBytes > 0) {
bool read = true;
// check if reading should be delayed to collect some bytes before
// forwarding (for baud rates significantly below 57600 baud)
if (maxCharDelay[portId]) {
// inter character delay exceeded or more than 48 bytes available or more bytes available than required
read = (lastAvailableBytes[portId] > 0 && (currentMillis - lastReceive[portId]) >= maxCharDelay[portId])
|| (bytesToRead == 0 && availableBytes >= 48) || (bytesToRead > 0 && availableBytes >= bytesToRead);
if (availableBytes > lastAvailableBytes[portId]) {
lastReceive[portId] = currentMillis;
lastAvailableBytes[portId] = availableBytes;
}
}
if (read) {
Firmata.write(START_SYSEX);
Firmata.write(SERIAL_MESSAGE);
Firmata.write(SERIAL_REPLY | portId);
if (bytesToRead == 0 || (serialPort->available() <= bytesToRead)) {
numBytesToRead = serialPort->available();
} else {
numBytesToRead = bytesToRead;
}
if (lastAvailableBytes[portId] - numBytesToRead >= 0) {
lastAvailableBytes[portId] -= numBytesToRead;
} else {
lastAvailableBytes[portId] = 0;
}
// relay serial data to the serial device
while (numBytesToRead > 0) {
serialData = serialPort->read();
Firmata.write(serialData & 0x7F);
Firmata.write((serialData >> 7) & 0x7F);
numBytesToRead--;
}
Firmata.write(END_SYSEX);
}
}
}
}
}

163
libraries/FirmataWithDeviceFeature/src-features/SerialFirmata.h Normal file
View File

@@ -0,0 +1,163 @@
/*
SerialFirmata.h - Firmata library
Copyright (C) 2015-2016 Jeff Hoefs. 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.
Last updated March 6th, 2016
*/
#ifndef SerialFirmata_h
#define SerialFirmata_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
// SoftwareSerial is currently only supported for AVR-based boards and the Arduino 101
// The third condition checks if the IDE is in the 1.0.x series, if so, include SoftwareSerial
#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_ARC32) || (ARDUINO >= 100 && ARDUINO < 10500)
#include <SoftwareSerial.h>
#endif
// uncomment FIRMATA_SERIAL_PORT_RX_BUFFERING to collect bytes received by serial port until the
// receive buffer gets filled or a data gap is detected to avoid forwarding single bytes at baud
// rates below 50000
//#define FIRMATA_SERIAL_PORT_RX_BUFFERING
// Serial port Ids
#define HW_SERIAL0 0x00
#define HW_SERIAL1 0x01
#define HW_SERIAL2 0x02
#define HW_SERIAL3 0x03
// extensible up to 0x07
#define SW_SERIAL0 0x08
#define SW_SERIAL1 0x09
#define SW_SERIAL2 0x0A
#define SW_SERIAL3 0x0B
// extensible up to 0x0F
#define SERIAL_PORT_ID_MASK 0x0F
#define MAX_SERIAL_PORTS 8
#define SERIAL_READ_ARR_LEN 12
// map configuration query response resolution value to serial pin type
#define RES_RX1 0x02
#define RES_TX1 0x03
#define RES_RX2 0x04
#define RES_TX2 0x05
#define RES_RX3 0x06
#define RES_TX3 0x07
// Serial command bytes
#define SERIAL_CONFIG 0x10
#define SERIAL_WRITE 0x20
#define SERIAL_READ 0x30
#define SERIAL_REPLY 0x40
#define SERIAL_CLOSE 0x50
#define SERIAL_FLUSH 0x60
#define SERIAL_LISTEN 0x70
// Serial read modes
#define SERIAL_READ_CONTINUOUSLY 0x00
#define SERIAL_STOP_READING 0x01
#define SERIAL_MODE_MASK 0xF0
struct serial_pins {
uint8_t rx;
uint8_t tx;
};
/*
* Get the serial serial pin type (RX1, TX1, RX2, TX2, etc) for the specified pin.
*/
inline uint8_t getSerialPinType(uint8_t pin) {
#if defined(PIN_SERIAL_RX)
// TODO when use of HW_SERIAL0 is enabled
#endif
#if defined(PIN_SERIAL1_RX)
if (pin == PIN_SERIAL1_RX) return RES_RX1;
if (pin == PIN_SERIAL1_TX) return RES_TX1;
#endif
#if defined(PIN_SERIAL2_RX)
if (pin == PIN_SERIAL2_RX) return RES_RX2;
if (pin == PIN_SERIAL2_TX) return RES_TX2;
#endif
#if defined(PIN_SERIAL3_RX)
if (pin == PIN_SERIAL3_RX) return RES_RX3;
if (pin == PIN_SERIAL3_TX) return RES_TX3;
#endif
return 0;
}
/*
* Get the RX and TX pins numbers for the specified HW serial port.
*/
inline serial_pins getSerialPinNumbers(uint8_t portId) {
serial_pins pins;
switch (portId) {
#if defined(PIN_SERIAL_RX)
// case HW_SERIAL0:
// // TODO when use of HW_SERIAL0 is enabled
// break;
#endif
#if defined(PIN_SERIAL1_RX)
case HW_SERIAL1:
pins.rx = PIN_SERIAL1_RX;
pins.tx = PIN_SERIAL1_TX;
break;
#endif
#if defined(PIN_SERIAL2_RX)
case HW_SERIAL2:
pins.rx = PIN_SERIAL2_RX;
pins.tx = PIN_SERIAL2_TX;
break;
#endif
#if defined(PIN_SERIAL3_RX)
case HW_SERIAL3:
pins.rx = PIN_SERIAL3_RX;
pins.tx = PIN_SERIAL3_TX;
break;
#endif
default:
pins.rx = 0;
pins.tx = 0;
}
return pins;
}
class SerialFirmata: public FirmataFeature
{
public:
SerialFirmata();
boolean handlePinMode(byte pin, int mode);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte* argv);
void update();
void reset();
void checkSerial();
private:
byte reportSerial[MAX_SERIAL_PORTS];
int serialBytesToRead[SERIAL_READ_ARR_LEN];
signed char serialIndex;
unsigned long lastReceive[SERIAL_READ_ARR_LEN];
unsigned char maxCharDelay[SERIAL_READ_ARR_LEN];
int lastAvailableBytes[SERIAL_READ_ARR_LEN];
Stream *swSerial0;
Stream *swSerial1;
Stream *swSerial2;
Stream *swSerial3;
Stream* getPortFromId(byte portId);
};
#endif /* SerialFirmata_h */

4
libraries/FirmataWithDeviceFeature/src-features/ServoFirmata.cpp Normal file
View File

@@ -0,0 +1,4 @@
/*
* Implementation is in ServoFirmata.h to avoid having to include Servo.h in all
* sketch files that include ConfigurableFirmata.h
*/

151
libraries/FirmataWithDeviceFeature/src-features/ServoFirmata.h Normal file
View File

@@ -0,0 +1,151 @@
/*
ServoFirmata.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
ServoFirmata.cpp has been merged into this header file as a hack to avoid having to
include Servo.h for every arduino sketch that includes ConfigurableFirmata.
Last updated by Jeff Hoefs: November 15th, 2015
*/
#ifndef ServoFirmata_h
#define ServoFirmata_h
#include <Servo.h>
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
void servoAnalogWrite(byte pin, int value);
class ServoFirmata: public FirmataFeature
{
public:
ServoFirmata();
boolean analogWrite(byte pin, int value);
boolean handlePinMode(byte pin, int mode);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte* argv);
void reset();
private:
Servo *servos[MAX_SERVOS];
void attach(byte pin, int minPulse, int maxPulse);
void detach(byte pin);
};
/*
* ServoFirmata.cpp
* Copied here as a hack to avoid having to include Servo.h in all sketch files that
* include ConfigurableFirmata.h
*/
ServoFirmata *ServoInstance;
void servoAnalogWrite(byte pin, int value)
{
ServoInstance->analogWrite(pin, value);
}
ServoFirmata::ServoFirmata()
{
ServoInstance = this;
}
boolean ServoFirmata::analogWrite(byte pin, int value)
{
if (IS_PIN_SERVO(pin)) {
Servo *servo = servos[PIN_TO_SERVO(pin)];
if (servo) {
servo->write(value);
return true;
}
}
return false;
}
boolean ServoFirmata::handlePinMode(byte pin, int mode)
{
if (IS_PIN_SERVO(pin)) {
if (mode == PIN_MODE_SERVO) {
attach(pin, -1, -1);
return true;
} else {
detach(pin);
}
}
return false;
}
void ServoFirmata::handleCapability(byte pin)
{
if (IS_PIN_SERVO(pin)) {
Firmata.write(PIN_MODE_SERVO);
Firmata.write(14); //14 bit resolution (Servo takes int as argument)
}
}
boolean ServoFirmata::handleSysex(byte command, byte argc, byte* argv)
{
if (command == SERVO_CONFIG) {
if (argc > 4) {
// these vars are here for clarity, they'll optimized away by the compiler
byte pin = argv[0];
if (IS_PIN_SERVO(pin) && Firmata.getPinMode(pin) != PIN_MODE_IGNORE) {
int minPulse = argv[1] + (argv[2] << 7);
int maxPulse = argv[3] + (argv[4] << 7);
Firmata.setPinMode(pin, PIN_MODE_SERVO);
attach(pin, minPulse, maxPulse);
return true;
}
}
}
return false;
}
void ServoFirmata::attach(byte pin, int minPulse, int maxPulse)
{
Servo *servo = servos[PIN_TO_SERVO(pin)];
if (!servo) {
servo = new Servo();
servos[PIN_TO_SERVO(pin)] = servo;
}
if (servo->attached())
servo->detach();
if (minPulse >= 0 || maxPulse >= 0)
servo->attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
else
servo->attach(PIN_TO_DIGITAL(pin));
}
void ServoFirmata::detach(byte pin)
{
Servo *servo = servos[PIN_TO_SERVO(pin)];
if (servo) {
if (servo->attached())
servo->detach();
free(servo);
servos[PIN_TO_SERVO(pin)] = NULL;
}
}
void ServoFirmata::reset()
{
for (byte pin = 0; pin < TOTAL_PINS; pin++) {
if (IS_PIN_SERVO(pin)) {
detach(pin);
}
}
}
#endif /* ServoFirmata_h */

151
libraries/FirmataWithDeviceFeature/src-features/StepperFirmata.cpp Normal file
View File

@@ -0,0 +1,151 @@
/*
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: January 23rd, 2016
*/
#include <ConfigurableFirmata.h>
#include "StepperFirmata.h"
#include "utility/FirmataStepper.h"
boolean StepperFirmata::handlePinMode(byte pin, int mode)
{
if (mode == PIN_MODE_STEPPER) {
if (IS_PIN_DIGITAL(pin)) {
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
return true;
}
}
return false;
}
void StepperFirmata::handleCapability(byte pin)
{
if (IS_PIN_DIGITAL(pin)) {
Firmata.write(PIN_MODE_STEPPER);
Firmata.write(21); //21 bits used for number of steps
}
}
/*==============================================================================
* SYSEX-BASED commands
*============================================================================*/
boolean StepperFirmata::handleSysex(byte command, byte argc, byte *argv)
{
if (command == STEPPER_DATA) {
byte stepCommand, deviceNum, directionPin, stepPin, stepDirection;
byte interface, interfaceType;
byte motorPin3, motorPin4;
unsigned int stepsPerRev;
long numSteps;
int stepSpeed;
int accel;
int decel;
stepCommand = argv[0];
deviceNum = argv[1];
if (deviceNum < MAX_STEPPERS) {
if (stepCommand == STEPPER_CONFIG) {
interface = argv[2]; // upper 4 bits are the stepDelay, lower 4 bits are the interface type
interfaceType = interface & 0x0F; // the interface type is specified by the lower 4 bits
stepsPerRev = (argv[3] + (argv[4] << 7));
directionPin = argv[5]; // or motorPin1 for TWO_WIRE or FOUR_WIRE interface
stepPin = argv[6]; // // or motorPin2 for TWO_WIRE or FOUR_WIRE interface
if (Firmata.getPinMode(directionPin) == PIN_MODE_IGNORE || Firmata.getPinMode(stepPin) == PIN_MODE_IGNORE)
return false;
Firmata.setPinMode(directionPin, PIN_MODE_STEPPER);
Firmata.setPinMode(stepPin, PIN_MODE_STEPPER);
if (!stepper[deviceNum]) {
numSteppers++;
}
if (interfaceType == FirmataStepper::DRIVER || interfaceType == FirmataStepper::TWO_WIRE) {
stepper[deviceNum] = new FirmataStepper(interface, stepsPerRev, directionPin, stepPin);
} else if (interfaceType == FirmataStepper::FOUR_WIRE) {
motorPin3 = argv[7];
motorPin4 = argv[8];
if (Firmata.getPinMode(motorPin3) == PIN_MODE_IGNORE || Firmata.getPinMode(motorPin4) == PIN_MODE_IGNORE)
return false;
Firmata.setPinMode(motorPin3, PIN_MODE_STEPPER);
Firmata.setPinMode(motorPin4, PIN_MODE_STEPPER);
stepper[deviceNum] = new FirmataStepper(interface, stepsPerRev, directionPin, stepPin, motorPin3, motorPin4);
}
}
else if (stepCommand == STEPPER_STEP) {
stepDirection = argv[2];
numSteps = (long)argv[3] | ((long)argv[4] << 7) | ((long)argv[5] << 14);
stepSpeed = (argv[6] + (argv[7] << 7));
if (stepDirection == 0) {
numSteps *= -1;
}
if (stepper[deviceNum]) {
if (argc >= 8 && argc < 12) {
// num steps, speed (0.01*rad/sec)
stepper[deviceNum]->setStepsToMove(numSteps, stepSpeed);
} else if (argc == 12) {
accel = (argv[8] + (argv[9] << 7));
decel = (argv[10] + (argv[11] << 7));
// num steps, speed (0.01*rad/sec), accel (0.01*rad/sec^2), decel (0.01*rad/sec^2)
stepper[deviceNum]->setStepsToMove(numSteps, stepSpeed, accel, decel);
}
}
}
return true;
}
}
return false;
}
/*==============================================================================
* SETUP()
*============================================================================*/
void StepperFirmata::reset()
{
for (byte i = 0; i < MAX_STEPPERS; i++) {
if (stepper[i]) {
free(stepper[i]);
stepper[i] = 0;
}
}
numSteppers = 0;
}
/*==============================================================================
* LOOP()
*============================================================================*/
void StepperFirmata::update()
{
if (numSteppers > 0) {
// if one or more stepper motors are used, update their position
for (byte i = 0; i < MAX_STEPPERS; i++) {
if (stepper[i]) {
bool done = stepper[i]->update();
// send command to client application when stepping is complete
if (done) {
Firmata.write(START_SYSEX);
Firmata.write(STEPPER_DATA);
Firmata.write(i);
Firmata.write(END_SYSEX);
}
}
}
}
}

40
libraries/FirmataWithDeviceFeature/src-features/StepperFirmata.h Normal file
View File

@@ -0,0 +1,40 @@
/*
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. 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 StepperFirmata_h
#define StepperFirmata_h
#include <ConfigurableFirmata.h>
#include "utility/FirmataStepper.h"
#include "FirmataFeature.h"
#define MAX_STEPPERS 6 // arbitrary value... may need to adjust
#define STEPPER_CONFIG 0
#define STEPPER_STEP 1
class StepperFirmata: public FirmataFeature
{
public:
boolean handlePinMode(byte pin, int mode);
void handleCapability(byte pin);
boolean handleSysex(byte command, byte argc, byte *argv);
void update();
void reset();
private:
FirmataStepper *stepper[MAX_STEPPERS];
byte numSteppers;
};
#endif

448
libraries/FirmataWithDeviceFeature/src-features/utility/FirmataStepper.cpp Normal file
View File

@@ -0,0 +1,448 @@
/**
FirmataStepper is a simple non-blocking stepper motor library
for 2 and 4 wire bipolar and unipolar stepper motor drive circuits
as well as EasyDriver (http://schmalzhaus.com/EasyDriver/) and
other step + direction drive circuits.
FirmataStepper (0.2) by Jeff Hoefs
EasyDriver support based on modifications by Chris Coleman
Acceleration / Deceleration algorithms and code based on:
app note: http://www.atmel.com/dyn/resources/prod_documents/doc8017.pdf
source code: http://www.atmel.com/dyn/resources/prod_documents/AVR446.zip
stepMotor function based on Stepper.cpp Stepper library for
Wiring/Arduino created by Tom Igoe, Sebastian Gassner
David Mellis and Noah Shibley.
Relevant notes from Stepper.cpp:
When wiring multiple stepper motors to a microcontroller,
you quickly run out of output pins, with each motor requiring 4 connections.
By making use of the fact that at any time two of the four motor
coils are the inverse of the other two, the number of
control connections can be reduced from 4 to 2.
A slightly modified circuit around a Darlington transistor array or an L293 H-bridge
connects to only 2 microcontroler pins, inverts the signals received,
and delivers the 4 (2 plus 2 inverted ones) output signals required
for driving a stepper motor.
The sequence of control signals for 4 control wires is as follows:
Step C0 C1 C2 C3
1 1 0 1 0
2 0 1 1 0
3 0 1 0 1
4 1 0 0 1
The sequence of controls signals for 2 control wires is as follows
(columns C1 and C2 from above):
Step C0 C1
1 0 1
2 1 1
3 1 0
4 0 0
The circuits can be found at
http://www.arduino.cc/en/Tutorial/Stepper
*/
#include "FirmataStepper.h"
/**
* Constructor.
*
* Configure a stepper for an EasyDriver or other step + direction interface or
* configure a bipolar or unipolar stepper motor for 2 wire drive mode.
* Configure a bipolar or unipolar stepper for 4 wire drive mode.
* @param interface Lower 3 bits:
* The interface type: FirmataStepper::DRIVER,
* FirmataStepper::TWO_WIRE or FirmataStepper::FOUR_WIRE
* Upper 4 bits: Any bits set = use 2 microsecond delay
* @param steps_per_rev The number of steps to make 1 revolution.
* @param first_pin The direction pin (EasyDriver) or the pin attached to the
* 1st motor coil (2 wire drive mode)
* @param second_pin The step pin (EasyDriver) or the pin attached to the 2nd
* motor coil (2 wire drive mode)
* @param motor_pin_3 The pin attached to the 3rd motor coil
* @param motor_pin_4 The pin attached to the 4th motor coil
*/
FirmataStepper::FirmataStepper(byte interface,
int steps_per_rev,
byte pin1,
byte pin2,
byte pin3,
byte pin4)
{
this->step_number = 0; // which step the motor is on
this->direction = 0; // motor direction
this->last_step_time = 0; // time stamp in ms of the last step taken
this->steps_per_rev = steps_per_rev; // total number of steps for this motor
this->running = false;
this->interface = interface & 0x0F; // default to Easy Stepper (or other step + direction driver)
// could update this in future to support additional delays if necessary
if (((interface & 0xF0) >> 4) > 0)
{
// high current driver
this->stepDelay = 2; // microseconds
}
else
{
this->stepDelay = 1; // microseconds
}
this->motor_pin_1 = pin1;
this->motor_pin_2 = pin2;
this->dir_pin = pin1;
this->step_pin = pin2;
// setup the pins on the microcontroller:
pinMode(this->motor_pin_1, OUTPUT);
pinMode(this->motor_pin_2, OUTPUT);
if (this->interface == FirmataStepper::FOUR_WIRE)
{
this->motor_pin_3 = pin3;
this->motor_pin_4 = pin4;
pinMode(this->motor_pin_3, OUTPUT);
pinMode(this->motor_pin_4, OUTPUT);
}
this->alpha = PI_2 / this->steps_per_rev;
this->at_x100 = (long)(this->alpha * T1_FREQ * 100);
this->ax20000 = (long)(this->alpha * 20000);
this->alpha_x2 = this->alpha * 2;
}
/**
* Move the stepper a given number of steps at the specified
* speed (rad/sec), acceleration (rad/sec^2) and deceleration (rad/sec^2).
*
* @param steps_to_move The number ofsteps to move the motor
* @param speed Max speed in 0.01*rad/sec
* @param accel [optional] Acceleration in 0.01*rad/sec^2
* @param decel [optional] Deceleration in 0.01*rad/sec^2
*/
void FirmataStepper::setStepsToMove(long steps_to_move, int speed, int accel, int decel)
{
unsigned long maxStepLimit;
unsigned long accelerationLimit;
this->step_number = 0;
this->lastAccelDelay = 0;
this->stepCount = 0;
this->rest = 0;
if (steps_to_move < 0)
{
this->direction = FirmataStepper::CCW;
steps_to_move = -steps_to_move;
}
else
{
this->direction = FirmataStepper::CW;
}
this->steps_to_move = steps_to_move;
// set max speed limit, by calc min_delay
// min_delay = (alpha / tt)/w
this->min_delay = this->at_x100 / speed;
// if acceleration or deceleration are not defined
// start in RUN state and do no decelerate
if (accel == 0 || decel == 0)
{
this->step_delay = this->min_delay;
this->decel_start = steps_to_move;
this->run_state = FirmataStepper::RUN;
this->accel_count = 0;
this->running = true;
return;
}
// if only moving 1 step
if (steps_to_move == 1)
{
// move one step
this->accel_count = -1;
this->run_state = FirmataStepper::DECEL;
this->step_delay = this->min_delay;
this->running = true;
}
else if (steps_to_move != 0)
{
// set initial step delay
// step_delay = 1/tt * sqrt(2*alpha/accel)
// step_delay = ( tfreq*0.676/100 )*100 * sqrt( (2*alpha*10000000000) / (accel*100) )/10000
this->step_delay = (long)((T1_FREQ_148 * sqrt(alpha_x2 / accel)) * 1000);
// find out after how many steps does the speed hit the max speed limit.
// maxSpeedLimit = speed^2 / (2*alpha*accel)
maxStepLimit = (long)speed * speed / (long)(((long)this->ax20000 * accel) / 100);
// if we hit max spped limit before 0.5 step it will round to 0.
// but in practice we need to move at least 1 step to get any speed at all.
if (maxStepLimit == 0)
{
maxStepLimit = 1;
}
// find out after how many steps we must start deceleration.
// n1 = (n1+n2)decel / (accel + decel)
accelerationLimit = (long)((steps_to_move * decel) / (accel + decel));
// we must accelerate at least 1 step before we can start deceleration
if (accelerationLimit == 0)
{
accelerationLimit = 1;
}
// use the limit we hit first to calc decel
if (accelerationLimit <= maxStepLimit)
{
this->decel_val = accelerationLimit - steps_to_move;
}
else
{
this->decel_val = -(long)(maxStepLimit * accel) / decel;
}
// we must decelerate at least 1 step to stop
if (this->decel_val == 0)
{
this->decel_val = -1;
}
// find step to start deceleration
this->decel_start = steps_to_move + this->decel_val;
// if the max speed is so low that we don't need to go via acceleration state.
if (this->step_delay <= this->min_delay)
{
this->step_delay = this->min_delay;
this->run_state = FirmataStepper::RUN;
}
else
{
this->run_state = FirmataStepper::ACCEL;
}
// reset counter
this->accel_count = 0;
this->running = true;
}
}
bool FirmataStepper::update()
{
bool done = false;
unsigned long newStepDelay = this->min_delay;
unsigned long curTimeVal = micros();
unsigned long timeDiff = curTimeVal - this->last_step_time;
if (this->running == true && timeDiff >= this->step_delay)
{
this->last_step_time = curTimeVal;
switch (this->run_state)
{
case FirmataStepper::STOP:
this->stepCount = 0;
this->rest = 0;
if (this->running)
{
done = true;
}
this->running = false;
break;
case FirmataStepper::ACCEL:
updateStepPosition();
this->stepCount++;
this->accel_count++;
newStepDelay = this->step_delay - (((2 * (long)this->step_delay) + this->rest) / (4 * this->accel_count + 1));
this->rest = ((2 * (long)this->step_delay) + this->rest) % (4 * this->accel_count + 1);
// check if we should start deceleration
if (this->stepCount >= this->decel_start)
{
this->accel_count = this->decel_val;
this->run_state = FirmataStepper::DECEL;
this->rest = 0;
}
// check if we hit max speed
else if (newStepDelay <= this->min_delay)
{
this->lastAccelDelay = newStepDelay;
newStepDelay = this->min_delay;
this->rest = 0;
this->run_state = FirmataStepper::RUN;
}
break;
case FirmataStepper::RUN:
updateStepPosition();
this->stepCount++;
// if no accel or decel was specified, go directly to STOP state
if (stepCount >= this->steps_to_move)
{
this->run_state = FirmataStepper::STOP;
}
// check if we should start deceleration
else if (this->stepCount >= this->decel_start)
{
this->accel_count = this->decel_val;
// start deceleration with same delay that accel ended with
newStepDelay = this->lastAccelDelay;
this->run_state = FirmataStepper::DECEL;
}
break;
case FirmataStepper::DECEL:
updateStepPosition();
this->stepCount++;
this->accel_count++;
newStepDelay = this->step_delay - (((2 * (long)this->step_delay) + this->rest) / (4 * this->accel_count + 1));
this->rest = ((2 * (long)this->step_delay) + this->rest) % (4 * this->accel_count + 1);
if (newStepDelay < 0) newStepDelay = -newStepDelay;
// check if we ar at the last step
if (this->accel_count >= 0)
{
this->run_state = FirmataStepper::STOP;
}
break;
}
this->step_delay = newStepDelay;
}
return done;
}
/**
* Update the step position.
* @private
*/
void FirmataStepper::updateStepPosition()
{
// increment or decrement the step number,
// depending on direction:
if (this->direction == FirmataStepper::CW)
{
this->step_number++;
if (this->step_number >= this->steps_per_rev)
{
this->step_number = 0;
}
}
else
{
if (this->step_number <= 0)
{
this->step_number = this->steps_per_rev;
}
this->step_number--;
}
// step the motor to step number 0, 1, 2, or 3:
stepMotor(this->step_number % 4, this->direction);
}
/**
* Moves the motor forward or backwards.
* @param step_num For 2 or 4 wire configurations, this is the current step in
* the 2 or 4 step sequence.
* @param direction The direction of rotation
*/
void FirmataStepper::stepMotor(byte step_num, byte direction)
{
if (this->interface == FirmataStepper::DRIVER)
{
digitalWrite(dir_pin, direction);
delayMicroseconds(this->stepDelay);
digitalWrite(step_pin, LOW);
delayMicroseconds(this->stepDelay);
digitalWrite(step_pin, HIGH);
}
else if (this->interface == FirmataStepper::TWO_WIRE)
{
switch (step_num)
{
case 0: /* 01 */
digitalWrite(motor_pin_1, LOW);
digitalWrite(motor_pin_2, HIGH);
break;
case 1: /* 11 */
digitalWrite(motor_pin_1, HIGH);
digitalWrite(motor_pin_2, HIGH);
break;
case 2: /* 10 */
digitalWrite(motor_pin_1, HIGH);
digitalWrite(motor_pin_2, LOW);
break;
case 3: /* 00 */
digitalWrite(motor_pin_1, LOW);
digitalWrite(motor_pin_2, LOW);
break;
}
}
else if (this->interface == FirmataStepper::FOUR_WIRE)
{
switch (step_num)
{
case 0: // 1010
digitalWrite(motor_pin_1, HIGH);
digitalWrite(motor_pin_2, LOW);
digitalWrite(motor_pin_3, HIGH);
digitalWrite(motor_pin_4, LOW);
break;
case 1: // 0110
digitalWrite(motor_pin_1, LOW);
digitalWrite(motor_pin_2, HIGH);
digitalWrite(motor_pin_3, HIGH);
digitalWrite(motor_pin_4, LOW);
break;
case 2: //0101
digitalWrite(motor_pin_1, LOW);
digitalWrite(motor_pin_2, HIGH);
digitalWrite(motor_pin_3, LOW);
digitalWrite(motor_pin_4, HIGH);
break;
case 3: //1001
digitalWrite(motor_pin_1, HIGH);
digitalWrite(motor_pin_2, LOW);
digitalWrite(motor_pin_3, LOW);
digitalWrite(motor_pin_4, HIGH);
break;
}
}
}
/**
* @return The version number of this library.
*/
byte FirmataStepper::version(void)
{
return 2;
}

145
libraries/FirmataWithDeviceFeature/src-features/utility/FirmataStepper.h Normal file
View File

@@ -0,0 +1,145 @@
/*
FirmataStepper is a simple non-blocking stepper motor library
for 2 and 4 wire bipolar and unipolar stepper motor drive circuits
as well as EasyDriver (http://schmalzhaus.com/EasyDriver/) and
other step + direction drive circuits.
FirmataStepper (0.2) by Jeff Hoefs
EasyDriver support based on modifications by Chris Coleman
Acceleration / Deceleration algorithms and code based on:
app note: http://www.atmel.com/dyn/resources/prod_documents/doc8017.pdf
source code: http://www.atmel.com/dyn/resources/prod_documents/AVR446.zip
stepMotor function based on Stepper.cpp Stepper library for
Wiring/Arduino created by Tom Igoe, Sebastian Gassner
David Mellis and Noah Shibley.
Relevant notes from Stepper.cpp:
When wiring multiple stepper motors to a microcontroller,
you quickly run out of output pins, with each motor requiring 4 connections.
By making use of the fact that at any time two of the four motor
coils are the inverse of the other two, the number of
control connections can be reduced from 4 to 2.
A slightly modified circuit around a Darlington transistor array or an L293 H-bridge
connects to only 2 microcontroler pins, inverts the signals received,
and delivers the 4 (2 plus 2 inverted ones) output signals required
for driving a stepper motor.
The sequence of control signals for 4 control wires is as follows:
Step C0 C1 C2 C3
1 1 0 1 0
2 0 1 1 0
3 0 1 0 1
4 1 0 0 1
The sequence of controls signals for 2 control wires is as follows
(columns C1 and C2 from above):
Step C0 C1
1 0 1
2 1 1
3 1 0
4 0 0
The circuits can be found at
http://www.arduino.cc/en/Tutorial/Stepper
*/
// ensure this library description is only included once
#ifndef FirmataStepper_h
#define FirmataStepper_h
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#define PI_2 2*3.14159
#define T1_FREQ 1000000L // provides the most accurate step delay values
#define T1_FREQ_148 ((long)((T1_FREQ*0.676)/100)) // divided by 100 and scaled by 0.676
// library interface description
class FirmataStepper
{
public:
FirmataStepper(byte interface = FirmataStepper::DRIVER,
int steps_per_rev = 200,
byte pin1 = 2,
byte pin2 = 3,
byte pin3 = 4,
byte pin4 = 5);
enum Interface
{
DRIVER = 1,
TWO_WIRE = 2,
FOUR_WIRE = 4
};
enum RunState
{
STOP = 0,
ACCEL = 1,
DECEL = 2,
RUN = 3
};
enum Direction
{
CCW = 0,
CW = 1
};
void setStepsToMove(long steps_to_move, int speed, int accel = 0, int decel = 0);
// update the stepper position
bool update();
byte version(void);
private:
void stepMotor(byte step_num, byte direction);
void updateStepPosition();
bool running;
byte interface; // Type of interface: DRIVER, TWO_WIRE or FOUR_WIRE
byte direction; // Direction of rotation
unsigned long step_delay; // delay between steps, in microseconds
int steps_per_rev; // number of steps to make one revolution
long step_number; // which step the motor is on
long steps_to_move; // total number of teps to move
byte stepDelay; // delay between steps (default = 1, increase for high current drivers)
byte run_state;
int accel_count;
unsigned long min_delay;
long decel_start;
int decel_val;
long lastAccelDelay;
long stepCount;
unsigned int rest;
float alpha; // PI * 2 / steps_per_rev
long at_x100; // alpha * T1_FREQ * 100
long ax20000; // alph a* 20000
float alpha_x2; // alpha * 2
// motor pin numbers:
byte dir_pin;
byte step_pin;
byte motor_pin_1;
byte motor_pin_2;
byte motor_pin_3;
byte motor_pin_4;
unsigned long last_step_time; // time stamp in microseconds of when the last step was taken
};
#endif

567
libraries/FirmataWithDeviceFeature/src-features/utility/OneWire.cpp Normal file
View File

@@ -0,0 +1,567 @@
/*
Copyright (c) 2007, Jim Studt (original old version - many contributors since)
The latest version of this library may be found at:
http://www.pjrc.com/teensy/td_libs_OneWire.html
OneWire has been maintained by Paul Stoffregen (paul@pjrc.com) since
January 2010. At the time, it was in need of many bug fixes, but had
been abandoned the original author (Jim Studt). None of the known
contributors were interested in maintaining OneWire. Paul typically
works on OneWire every 6 to 12 months. Patches usually wait that
long. If anyone is interested in more actively maintaining OneWire,
please contact Paul.
Version 2.3:
Unknonw chip fallback mode, Roger Clark
Teensy-LC compatibility, Paul Stoffregen
Search bug fix, Love Nystrom
Version 2.2:
Teensy 3.0 compatibility, Paul Stoffregen, paul@pjrc.com
Arduino Due compatibility, http://arduino.cc/forum/index.php?topic=141030
Fix DS18B20 example negative temperature
Fix DS18B20 example's low res modes, Ken Butcher
Improve reset timing, Mark Tillotson
Add const qualifiers, Bertrik Sikken
Add initial value input to crc16, Bertrik Sikken
Add target_search() function, Scott Roberts
Version 2.1:
Arduino 1.0 compatibility, Paul Stoffregen
Improve temperature example, Paul Stoffregen
DS250x_PROM example, Guillermo Lovato
PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com
Improvements from Glenn Trewitt:
- crc16() now works
- check_crc16() does all of calculation/checking work.
- Added read_bytes() and write_bytes(), to reduce tedious loops.
- Added ds2408 example.
Delete very old, out-of-date readme file (info is here)
Version 2.0: Modifications by Paul Stoffregen, January 2010:
http://www.pjrc.com/teensy/td_libs_OneWire.html
Search fix from Robin James
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
Use direct optimized I/O in all cases
Disable interrupts during timing critical sections
(this solves many random communication errors)
Disable interrupts during read-modify-write I/O
Reduce RAM consumption by eliminating unnecessary
variables and trimming many to 8 bits
Optimize both crc8 - table version moved to flash
Modified to work with larger numbers of devices - avoids loop.
Tested in Arduino 11 alpha with 12 sensors.
26 Sept 2008 -- Robin James
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27
Updated to work with arduino-0008 and to include skip() as of
2007/07/06. --RJL20
Modified to calculate the 8-bit CRC directly, avoiding the need for
the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010
-- Tom Pollard, Jan 23, 2008
Jim Studt's original library was modified by Josh Larios.
Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 2008
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Much of the code was inspired by Derek Yerger's code, though I don't
think much of that remains. In any event that was..
(copyleft) 2006 by Derek Yerger - Free to distribute freely.
The CRC code was excerpted and inspired by the Dallas Semiconductor
sample code bearing this copyright.
//---------------------------------------------------------------------------
// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
// Except as contained in this notice, the name of Dallas Semiconductor
// shall not be used except as stated in the Dallas Semiconductor
// Branding Policy.
//--------------------------------------------------------------------------
*/
#include "OneWire.h"
OneWire::OneWire(uint8_t pin)
{
pinMode(pin, INPUT);
bitmask = PIN_TO_BITMASK(pin);
baseReg = PIN_TO_BASEREG(pin);
#if ONEWIRE_SEARCH
reset_search();
#endif
}
// Perform the onewire reset function. We will wait up to 250uS for
// the bus to come high, if it doesn't then it is broken or shorted
// and we return a 0;
//
// Returns 1 if a device asserted a presence pulse, 0 otherwise.
//
uint8_t OneWire::reset(void)
{
IO_REG_TYPE mask = bitmask;
volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg;
uint8_t r;
uint8_t retries = 125;
noInterrupts();
DIRECT_MODE_INPUT(reg, mask);
interrupts();
// wait until the wire is high... just in case
do {
if (--retries == 0) return 0;
delayMicroseconds(2);
} while ( !DIRECT_READ(reg, mask));
noInterrupts();
DIRECT_WRITE_LOW(reg, mask);
DIRECT_MODE_OUTPUT(reg, mask); // drive output low
interrupts();
delayMicroseconds(480);
noInterrupts();
DIRECT_MODE_INPUT(reg, mask); // allow it to float
delayMicroseconds(70);
r = !DIRECT_READ(reg, mask);
interrupts();
delayMicroseconds(410);
return r;
}
//
// Write a bit. Port and bit is used to cut lookup time and provide
// more certain timing.
//
void OneWire::write_bit(uint8_t v)
{
IO_REG_TYPE mask=bitmask;
volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg;
if (v & 1) {
noInterrupts();
DIRECT_WRITE_LOW(reg, mask);
DIRECT_MODE_OUTPUT(reg, mask); // drive output low
delayMicroseconds(10);
DIRECT_WRITE_HIGH(reg, mask); // drive output high
interrupts();
delayMicroseconds(55);
} else {
noInterrupts();
DIRECT_WRITE_LOW(reg, mask);
DIRECT_MODE_OUTPUT(reg, mask); // drive output low
delayMicroseconds(65);
DIRECT_WRITE_HIGH(reg, mask); // drive output high
interrupts();
delayMicroseconds(5);
}
}
//
// Read a bit. Port and bit is used to cut lookup time and provide
// more certain timing.
//
uint8_t OneWire::read_bit(void)
{
IO_REG_TYPE mask=bitmask;
volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg;
uint8_t r;
noInterrupts();
DIRECT_MODE_OUTPUT(reg, mask);
DIRECT_WRITE_LOW(reg, mask);
delayMicroseconds(3);
DIRECT_MODE_INPUT(reg, mask); // let pin float, pull up will raise
delayMicroseconds(10);
r = DIRECT_READ(reg, mask);
interrupts();
delayMicroseconds(53);
return r;
}
//
// Write a byte. The writing code uses the active drivers to raise the
// pin high, if you need power after the write (e.g. DS18S20 in
// parasite power mode) then set 'power' to 1, otherwise the pin will
// go tri-state at the end of the write to avoid heating in a short or
// other mishap.
//
void OneWire::write(uint8_t v, uint8_t power /* = 0 */) {
uint8_t bitMask;
for (bitMask = 0x01; bitMask; bitMask <<= 1) {
OneWire::write_bit( (bitMask & v)?1:0);
}
if ( !power) {
noInterrupts();
DIRECT_MODE_INPUT(baseReg, bitmask);
DIRECT_WRITE_LOW(baseReg, bitmask);
interrupts();
}
}
void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) {
for (uint16_t i = 0 ; i < count ; i++)
write(buf[i]);
if (!power) {
noInterrupts();
DIRECT_MODE_INPUT(baseReg, bitmask);
DIRECT_WRITE_LOW(baseReg, bitmask);
interrupts();
}
}
//
// Read a byte
//
uint8_t OneWire::read() {
uint8_t bitMask;
uint8_t r = 0;
for (bitMask = 0x01; bitMask; bitMask <<= 1) {
if ( OneWire::read_bit()) r |= bitMask;
}
return r;
}
void OneWire::read_bytes(uint8_t *buf, uint16_t count) {
for (uint16_t i = 0 ; i < count ; i++)
buf[i] = read();
}
//
// Do a ROM select
//
void OneWire::select(const uint8_t rom[8])
{
uint8_t i;
write(0x55); // Choose ROM
for (i = 0; i < 8; i++) write(rom[i]);
}
//
// Do a ROM skip
//
void OneWire::skip()
{
write(0xCC); // Skip ROM
}
void OneWire::depower()
{
noInterrupts();
DIRECT_MODE_INPUT(baseReg, bitmask);
interrupts();
}
#if ONEWIRE_SEARCH
//
// You need to use this function to start a search again from the beginning.
// You do not need to do it for the first search, though you could.
//
void OneWire::reset_search()
{
// reset the search state
LastDiscrepancy = 0;
LastDeviceFlag = FALSE;
LastFamilyDiscrepancy = 0;
for(int i = 7; ; i--) {
ROM_NO[i] = 0;
if ( i == 0) break;
}
}
// Setup the search to find the device type 'family_code' on the next call
// to search(*newAddr) if it is present.
//
void OneWire::target_search(uint8_t family_code)
{
// set the search state to find SearchFamily type devices
ROM_NO[0] = family_code;
for (uint8_t i = 1; i < 8; i++)
ROM_NO[i] = 0;
LastDiscrepancy = 64;
LastFamilyDiscrepancy = 0;
LastDeviceFlag = FALSE;
}
//
// Perform a search. If this function returns a '1' then it has
// enumerated the next device and you may retrieve the ROM from the
// OneWire::address variable. If there are no devices, no further
// devices, or something horrible happens in the middle of the
// enumeration then a 0 is returned. If a new device is found then
// its address is copied to newAddr. Use OneWire::reset_search() to
// start over.
//
// --- Replaced by the one from the Dallas Semiconductor web site ---
//--------------------------------------------------------------------------
// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing
// search state.
// Return TRUE : device found, ROM number in ROM_NO buffer
// FALSE : device not found, end of search
//
uint8_t OneWire::search(uint8_t *newAddr, bool search_mode /* = true */)
{
uint8_t id_bit_number;
uint8_t last_zero, rom_byte_number, search_result;
uint8_t id_bit, cmp_id_bit;
unsigned char rom_byte_mask, search_direction;
// initialize for search
id_bit_number = 1;
last_zero = 0;
rom_byte_number = 0;
rom_byte_mask = 1;
search_result = 0;
// if the last call was not the last one
if (!LastDeviceFlag)
{
// 1-Wire reset
if (!reset())
{
// reset the search
LastDiscrepancy = 0;
LastDeviceFlag = FALSE;
LastFamilyDiscrepancy = 0;
return FALSE;
}
// issue the search command
if (search_mode == true) {
write(0xF0); // NORMAL SEARCH
} else {
write(0xEC); // CONDITIONAL SEARCH
}
// loop to do the search
do
{
// read a bit and its complement
id_bit = read_bit();
cmp_id_bit = read_bit();
// check for no devices on 1-wire
if ((id_bit == 1) && (cmp_id_bit == 1))
break;
else
{
// all devices coupled have 0 or 1
if (id_bit != cmp_id_bit)
search_direction = id_bit; // bit write value for search
else
{
// if this discrepancy if before the Last Discrepancy
// on a previous next then pick the same as last time
if (id_bit_number < LastDiscrepancy)
search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0);
else
// if equal to last pick 1, if not then pick 0
search_direction = (id_bit_number == LastDiscrepancy);
// if 0 was picked then record its position in LastZero
if (search_direction == 0)
{
last_zero = id_bit_number;
// check for Last discrepancy in family
if (last_zero < 9)
LastFamilyDiscrepancy = last_zero;
}
}
// set or clear the bit in the ROM byte rom_byte_number
// with mask rom_byte_mask
if (search_direction == 1)
ROM_NO[rom_byte_number] |= rom_byte_mask;
else
ROM_NO[rom_byte_number] &= ~rom_byte_mask;
// serial number search direction write bit
write_bit(search_direction);
// increment the byte counter id_bit_number
// and shift the mask rom_byte_mask
id_bit_number++;
rom_byte_mask <<= 1;
// if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask
if (rom_byte_mask == 0)
{
rom_byte_number++;
rom_byte_mask = 1;
}
}
}
while(rom_byte_number < 8); // loop until through all ROM bytes 0-7
// if the search was successful then
if (!(id_bit_number < 65))
{
// search successful so set LastDiscrepancy,LastDeviceFlag,search_result
LastDiscrepancy = last_zero;
// check for last device
if (LastDiscrepancy == 0)
LastDeviceFlag = TRUE;
search_result = TRUE;
}
}
// if no device found then reset counters so next 'search' will be like a first
if (!search_result || !ROM_NO[0])
{
LastDiscrepancy = 0;
LastDeviceFlag = FALSE;
LastFamilyDiscrepancy = 0;
search_result = FALSE;
} else {
for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i];
}
return search_result;
}
#endif
#if ONEWIRE_CRC
// The 1-Wire CRC scheme is described in Maxim Application Note 27:
// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
//
#if ONEWIRE_CRC8_TABLE
// This table comes from Dallas sample code where it is freely reusable,
// though Copyright (C) 2000 Dallas Semiconductor Corporation
static const uint8_t PROGMEM dscrc_table[] = {
0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
//
// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
// and the registers. (note: this might better be done without to
// table, it would probably be smaller and certainly fast enough
// compared to all those delayMicrosecond() calls. But I got
// confused, so I use this table from the examples.)
//
uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
{
uint8_t crc = 0;
while (len--) {
crc = pgm_read_byte(dscrc_table + (crc ^ *addr++));
}
return crc;
}
#else
//
// Compute a Dallas Semiconductor 8 bit CRC directly.
// this is much slower, but much smaller, than the lookup table.
//
uint8_t OneWire::crc8(const uint8_t *addr, uint8_t len)
{
uint8_t crc = 0;
while (len--) {
uint8_t inbyte = *addr++;
for (uint8_t i = 8; i; i--) {
uint8_t mix = (crc ^ inbyte) & 0x01;
crc >>= 1;
if (mix) crc ^= 0x8C;
inbyte >>= 1;
}
}
return crc;
}
#endif
#if ONEWIRE_CRC16
bool OneWire::check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc)
{
crc = ~crc16(input, len, crc);
return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1];
}
uint16_t OneWire::crc16(const uint8_t* input, uint16_t len, uint16_t crc)
{
static const uint8_t oddparity[16] =
{ 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
for (uint16_t i = 0 ; i < len ; i++) {
// Even though we're just copying a byte from the input,
// we'll be doing 16-bit computation with it.
uint16_t cdata = input[i];
cdata = (cdata ^ crc) & 0xff;
crc >>= 8;
if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4])
crc ^= 0xC001;
cdata <<= 6;
crc ^= cdata;
cdata <<= 1;
crc ^= cdata;
}
return crc;
}
#endif
#endif

367
libraries/FirmataWithDeviceFeature/src-features/utility/OneWire.h Normal file
View File

@@ -0,0 +1,367 @@
#ifndef OneWire_h
#define OneWire_h
#include <inttypes.h>
#if ARDUINO >= 100
#include "Arduino.h" // for delayMicroseconds, digitalPinToBitMask, etc
#else
#include "WProgram.h" // for delayMicroseconds
#include "pins_arduino.h" // for digitalPinToBitMask, etc
#endif
// You can exclude certain features from OneWire. In theory, this
// might save some space. In practice, the compiler automatically
// removes unused code (technically, the linker, using -fdata-sections
// and -ffunction-sections when compiling, and Wl,--gc-sections
// when linking), so most of these will not result in any code size
// reduction. Well, unless you try to use the missing features
// and redesign your program to not need them! ONEWIRE_CRC8_TABLE
// is the exception, because it selects a fast but large algorithm
// or a small but slow algorithm.
// you can exclude onewire_search by defining that to 0
#ifndef ONEWIRE_SEARCH
#define ONEWIRE_SEARCH 1
#endif
// You can exclude CRC checks altogether by defining this to 0
#ifndef ONEWIRE_CRC
#define ONEWIRE_CRC 1
#endif
// Select the table-lookup method of computing the 8-bit CRC
// by setting this to 1. The lookup table enlarges code size by
// about 250 bytes. It does NOT consume RAM (but did in very
// old versions of OneWire). If you disable this, a slower
// but very compact algorithm is used.
#ifndef ONEWIRE_CRC8_TABLE
#define ONEWIRE_CRC8_TABLE 1
#endif
// You can allow 16-bit CRC checks by defining this to 1
// (Note that ONEWIRE_CRC must also be 1.)
#ifndef ONEWIRE_CRC16
#define ONEWIRE_CRC16 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
// Platform specific I/O definitions
#if defined(__AVR__)
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM asm("r30")
#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask))
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
#define PIN_TO_BITMASK(pin) (1)
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (*((base)+512))
#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0)
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1)
#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1)
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1)
#elif defined(__MKL26Z64__)
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) ((*((base)+16) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) (*((base)+20) &= ~(mask))
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+20) |= (mask))
#define DIRECT_WRITE_LOW(base, mask) (*((base)+8) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+4) = (mask))
#elif defined(__SAM3X8E__)
// Arduino 1.5.1 may have a bug in delayMicroseconds() on Arduino Due.
// http://arduino.cc/forum/index.php/topic,141030.msg1076268.html#msg1076268
// If you have trouble with OneWire on Arduino Due, please check the
// status of delayMicroseconds() before reporting a bug in OneWire!
#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask))
#ifndef PROGMEM
#define PROGMEM
#endif
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const uint8_t *)(addr))
#endif
#elif defined(__PIC32MX__)
#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10
#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04
#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28
#elif defined(ARDUINO_ARCH_ESP8266)
#define PIN_TO_BASEREG(pin) ((volatile uint32_t*) GPO)
#define PIN_TO_BITMASK(pin) (1 << pin)
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) ((GPI & (mask)) ? 1 : 0) //GPIO_IN_ADDRESS
#define DIRECT_MODE_INPUT(base, mask) (GPE &= ~(mask)) //GPIO_ENABLE_W1TC_ADDRESS
#define DIRECT_MODE_OUTPUT(base, mask) (GPE |= (mask)) //GPIO_ENABLE_W1TS_ADDRESS
#define DIRECT_WRITE_LOW(base, mask) (GPOC = (mask)) //GPIO_OUT_W1TC_ADDRESS
#define DIRECT_WRITE_HIGH(base, mask) (GPOS = (mask)) //GPIO_OUT_W1TS_ADDRESS
#elif defined(__SAMD21G18A__)
#define PIN_TO_BASEREG(pin) portModeRegister(digitalPinToPort(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*((base)+8)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) = (mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+2)) = (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+5)) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+6)) = (mask))
#elif defined(RBL_NRF51822)
#define PIN_TO_BASEREG(pin) (0)
#define PIN_TO_BITMASK(pin) (pin)
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, pin) nrf_gpio_pin_read(pin)
#define DIRECT_WRITE_LOW(base, pin) nrf_gpio_pin_clear(pin)
#define DIRECT_WRITE_HIGH(base, pin) nrf_gpio_pin_set(pin)
#define DIRECT_MODE_INPUT(base, pin) nrf_gpio_cfg_input(pin, NRF_GPIO_PIN_NOPULL)
#define DIRECT_MODE_OUTPUT(base, pin) nrf_gpio_cfg_output(pin)
#elif defined(__arc__) /* Arduino101/Genuino101 specifics */
#include "scss_registers.h"
#include "portable.h"
#include "avr/pgmspace.h"
#define GPIO_ID(pin) (g_APinDescription[pin].ulGPIOId)
#define GPIO_TYPE(pin) (g_APinDescription[pin].ulGPIOType)
#define GPIO_BASE(pin) (g_APinDescription[pin].ulGPIOBase)
#define DIR_OFFSET_SS 0x01
#define DIR_OFFSET_SOC 0x04
#define EXT_PORT_OFFSET_SS 0x0A
#define EXT_PORT_OFFSET_SOC 0x50
/* GPIO registers base address */
#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase)
#define PIN_TO_BITMASK(pin) pin
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
static inline __attribute__((always_inline))
IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
IO_REG_TYPE ret;
if (SS_GPIO == GPIO_TYPE(pin)) {
ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS));
} else {
ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC);
}
return ((ret >> GPIO_ID(pin)) & 0x01);
}
static inline __attribute__((always_inline))
void directModeInput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG((((IO_REG_TYPE)base) + DIR_OFFSET_SS)) & ~(0x01 << GPIO_ID(pin)),
((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
} else {
MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) &= ~(0x01 << GPIO_ID(pin));
}
}
static inline __attribute__((always_inline))
void directModeOutput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG(((IO_REG_TYPE)(base) + DIR_OFFSET_SS)) | (0x01 << GPIO_ID(pin)),
((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
} else {
MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) |= (0x01 << GPIO_ID(pin));
}
}
static inline __attribute__((always_inline))
void directWriteLow(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG(base) & ~(0x01 << GPIO_ID(pin)), base);
} else {
MMIO_REG_VAL(base) &= ~(0x01 << GPIO_ID(pin));
}
}
static inline __attribute__((always_inline))
void directWriteHigh(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG(base) | (0x01 << GPIO_ID(pin)), base);
} else {
MMIO_REG_VAL(base) |= (0x01 << GPIO_ID(pin));
}
}
#define DIRECT_READ(base, pin) directRead(base, pin)
#define DIRECT_MODE_INPUT(base, pin) directModeInput(base, pin)
#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(base, pin)
#define DIRECT_WRITE_LOW(base, pin) directWriteLow(base, pin)
#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(base, pin)
#else
#define PIN_TO_BASEREG(pin) (0)
#define PIN_TO_BITMASK(pin) (pin)
#define IO_REG_TYPE unsigned int
#define IO_REG_ASM
#define DIRECT_READ(base, pin) digitalRead(pin)
#define DIRECT_WRITE_LOW(base, pin) digitalWrite(pin, LOW)
#define DIRECT_WRITE_HIGH(base, pin) digitalWrite(pin, HIGH)
#define DIRECT_MODE_INPUT(base, pin) pinMode(pin,INPUT)
#define DIRECT_MODE_OUTPUT(base, pin) pinMode(pin,OUTPUT)
#warning "OneWire. Fallback mode. Using API calls for pinMode,digitalRead and digitalWrite. Operation of this library is not guaranteed on this architecture."
#endif
class OneWire
{
private:
IO_REG_TYPE bitmask;
volatile IO_REG_TYPE *baseReg;
#if ONEWIRE_SEARCH
// global search state
unsigned char ROM_NO[8];
uint8_t LastDiscrepancy;
uint8_t LastFamilyDiscrepancy;
uint8_t LastDeviceFlag;
#endif
public:
OneWire( uint8_t pin);
// Perform a 1-Wire reset cycle. Returns 1 if a device responds
// with a presence pulse. Returns 0 if there is no device or the
// bus is shorted or otherwise held low for more than 250uS
uint8_t reset(void);
// Issue a 1-Wire rom select command, you do the reset first.
void select(const uint8_t rom[8]);
// Issue a 1-Wire rom skip command, to address all on bus.
void skip(void);
// Write a byte. If 'power' is one then the wire is held high at
// the end for parasitically powered devices. You are responsible
// for eventually depowering it by calling depower() or doing
// another read or write.
void write(uint8_t v, uint8_t power = 0);
void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0);
// Read a byte.
uint8_t read(void);
void read_bytes(uint8_t *buf, uint16_t count);
// Write a bit. The bus is always left powered at the end, see
// note in write() about that.
void write_bit(uint8_t v);
// Read a bit.
uint8_t read_bit(void);
// Stop forcing power onto the bus. You only need to do this if
// you used the 'power' flag to write() or used a write_bit() call
// and aren't about to do another read or write. You would rather
// not leave this powered if you don't have to, just in case
// someone shorts your bus.
void depower(void);
#if ONEWIRE_SEARCH
// Clear the search state so that if will start from the beginning again.
void reset_search();
// Setup the search to find the device type 'family_code' on the next call
// to search(*newAddr) if it is present.
void target_search(uint8_t family_code);
// Look for the next device. Returns 1 if a new address has been
// returned. A zero might mean that the bus is shorted, there are
// no devices, or you have already retrieved all of them. It
// might be a good idea to check the CRC to make sure you didn't
// get garbage. The order is deterministic. You will always get
// the same devices in the same order.
uint8_t search(uint8_t *newAddr, bool search_mode = true);
#endif
#if ONEWIRE_CRC
// Compute a Dallas Semiconductor 8 bit CRC, these are used in the
// ROM and scratchpad registers.
static uint8_t crc8(const uint8_t *addr, uint8_t len);
#if ONEWIRE_CRC16
// Compute the 1-Wire CRC16 and compare it against the received CRC.
// Example usage (reading a DS2408):
// // Put everything in a buffer so we can compute the CRC easily.
// uint8_t buf[13];
// buf[0] = 0xF0; // Read PIO Registers
// buf[1] = 0x88; // LSB address
// buf[2] = 0x00; // MSB address
// WriteBytes(net, buf, 3); // Write 3 cmd bytes
// ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16
// if (!CheckCRC16(buf, 11, &buf[11])) {
// // Handle error.
// }
//
// @param input - Array of bytes to checksum.
// @param len - How many bytes to use.
// @param inverted_crc - The two CRC16 bytes in the received data.
// This should just point into the received data,
// *not* at a 16-bit integer.
// @param crc - The crc starting value (optional)
// @return True, iff the CRC matches.
static bool check_crc16(const uint8_t* input, uint16_t len, const uint8_t* inverted_crc, uint16_t crc = 0);
// Compute a Dallas Semiconductor 16 bit CRC. This is required to check
// the integrity of data received from many 1-Wire devices. Note that the
// CRC computed here is *not* what you'll get from the 1-Wire network,
// for two reasons:
// 1) The CRC is transmitted bitwise inverted.
// 2) Depending on the endian-ness of your processor, the binary
// representation of the two-byte return value may have a different
// byte order than the two bytes you get from 1-Wire.
// @param input - Array of bytes to checksum.
// @param len - How many bytes to use.
// @param crc - The crc starting value (optional)
// @return The CRC16, as defined by Dallas Semiconductor.
static uint16_t crc16(const uint8_t* input, uint16_t len, uint16_t crc = 0);
#endif
#endif
};
#endif

4
libraries/FirmataWithDeviceFeature/src-features/utility/WiFi101Stream.cpp Normal file
View File

@@ -0,0 +1,4 @@
/*
* Implementation is in WiFi101Stream.h to avoid linker issues. Legacy WiFi and modern WiFi101
* both define WiFiClass which will cause linker errors whenever Firmata.h is included.
*/

259
libraries/FirmataWithDeviceFeature/src-features/utility/WiFi101Stream.h Normal file
View File

@@ -0,0 +1,259 @@
/*
WiFi101Stream.h
An Arduino Stream that wraps an instance of a WiFi101 server. For use
with Arduino WiFi 101 shield, Arduino MKR1000 and other boards and
shields that are compatible with the Arduino WiFi101 library.
Copyright (C) 2015-2016 Jesse Frush. 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 WIFI101_STREAM_H
#define WIFI101_STREAM_H
#include <inttypes.h>
#include <Stream.h>
#include <WiFi101.h>
class WiFi101Stream : public Stream
{
private:
WiFiServer _server = WiFiServer(23);
WiFiClient _client;
//configuration members
IPAddress _local_ip;
uint16_t _port = 0;
uint8_t _key_idx = 0; //WEP
const char *_key = nullptr; //WEP
const char *_passphrase = nullptr; //WPA
char *_ssid = nullptr;
inline int connect_client()
{
if( !( _client && _client.connected() ) )
{
WiFiClient newClient = _server.available();
if( !newClient )
{
return 0;
}
_client = newClient;
}
return 1;
}
inline bool is_ready()
{
uint8_t status = WiFi.status();
return !( status == WL_NO_SHIELD || status == WL_CONNECTED );
}
public:
WiFi101Stream() {};
// allows another way to configure a static IP before begin is called
inline void config(IPAddress local_ip)
{
_local_ip = local_ip;
WiFi.config( local_ip );
}
// get DCHP IP
inline IPAddress localIP()
{
return WiFi.localIP();
}
inline bool maintain()
{
if( connect_client() ) return true;
stop();
int result = 0;
if( WiFi.status() != WL_CONNECTED )
{
if( _local_ip )
{
WiFi.config( _local_ip );
}
if( _passphrase )
{
result = WiFi.begin( _ssid, _passphrase);
}
else if( _key_idx && _key )
{
result = WiFi.begin( _ssid, _key_idx, _key );
}
else
{
result = WiFi.begin( _ssid );
}
}
if( result == 0 ) return false;
_server = WiFiServer( _port );
_server.begin();
return result;
}
/******************************************************************************
* Connection functions with DHCP
******************************************************************************/
//OPEN networks
inline int begin(char *ssid, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
int result = WiFi.begin( ssid );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WEP-encrypted networks
inline int begin(char *ssid, uint8_t key_idx, const char *key, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_key_idx = key_idx;
_key = key;
int result = WiFi.begin( ssid, key_idx, key );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WPA-encrypted networks
inline int begin(char *ssid, const char *passphrase, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_passphrase = passphrase;
int result = WiFi.begin( ssid, passphrase);
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
/******************************************************************************
* Connection functions without DHCP
******************************************************************************/
//OPEN networks with static IP
inline int begin(char *ssid, IPAddress local_ip, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_local_ip = local_ip;
WiFi.config( local_ip );
int result = WiFi.begin( ssid );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WEP-encrypted networks with static IP
inline int begin(char *ssid, IPAddress local_ip, uint8_t key_idx, const char *key, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_local_ip = local_ip;
_key_idx = key_idx;
_key = key;
WiFi.config( local_ip );
int result = WiFi.begin( ssid, key_idx, key );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WPA-encrypted networks with static IP
inline int begin(char *ssid, IPAddress local_ip, const char *passphrase, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_local_ip = local_ip;
_passphrase = passphrase;
WiFi.config( local_ip );
int result = WiFi.begin( ssid, passphrase);
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
/******************************************************************************
* Stream implementations
******************************************************************************/
inline int available()
{
return connect_client() ? _client.available() : 0;
}
inline void flush()
{
if( _client ) _client.flush();
}
inline int peek()
{
return connect_client() ? _client.peek(): 0;
}
inline int read()
{
return connect_client() ? _client.read() : -1;
}
inline void stop()
{
_client.stop();
}
inline size_t write(uint8_t byte)
{
if( connect_client() ) _client.write( byte );
}
};
#endif //WIFI101_STREAM_H

4
libraries/FirmataWithDeviceFeature/src-features/utility/WiFiStream.cpp Normal file
View File

@@ -0,0 +1,4 @@
/*
* Implementation is in WiFiStream.h to avoid linker issues. Legacy WiFi and modern WiFi101 both
* define WiFiClass which will cause linker errors whenever Firmata.h is included.
*/

258
libraries/FirmataWithDeviceFeature/src-features/utility/WiFiStream.h Normal file
View File

@@ -0,0 +1,258 @@
/*
WiFiStream.h
An Arduino Stream that wraps an instance of a WiFi server. For use
with legacy Arduino WiFi shield and other boards and sheilds that
are compatible with the Arduino WiFi library.
Copyright (C) 2015-2016 Jesse Frush. 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 WIFI_STREAM_H
#define WIFI_STREAM_H
#include <inttypes.h>
#include <Stream.h>
#include <WiFi.h>
class WiFiStream : public Stream
{
private:
WiFiServer _server = WiFiServer(23);
WiFiClient _client;
//configuration members
IPAddress _local_ip;
uint16_t _port = 0;
uint8_t _key_idx = 0; //WEP
const char *_key = nullptr; //WEP
const char *_passphrase = nullptr; //WPA
char *_ssid = nullptr;
inline int connect_client()
{
if( !( _client && _client.connected() ) )
{
WiFiClient newClient = _server.available();
if( !newClient )
{
return 0;
}
_client = newClient;
}
return 1;
}
inline bool is_ready()
{
uint8_t status = WiFi.status();
return !( status == WL_NO_SHIELD || status == WL_CONNECTED );
}
public:
WiFiStream() {};
// allows another way to configure a static IP before begin is called
inline void config(IPAddress local_ip)
{
_local_ip = local_ip;
WiFi.config( local_ip );
}
// get DCHP IP
inline IPAddress localIP()
{
return WiFi.localIP();
}
inline bool maintain()
{
if( connect_client() ) return true;
stop();
int result = 0;
if( WiFi.status() != WL_CONNECTED )
{
if( _local_ip )
{
WiFi.config( _local_ip );
}
if( _passphrase )
{
result = WiFi.begin( _ssid, _passphrase);
}
else if( _key_idx && _key )
{
result = WiFi.begin( _ssid, _key_idx, _key );
}
else
{
result = WiFi.begin( _ssid );
}
}
if( result == 0 ) return false;
_server = WiFiServer( _port );
_server.begin();
return result;
}
/******************************************************************************
* Connection functions with DHCP
******************************************************************************/
//OPEN networks
inline int begin(char *ssid, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
int result = WiFi.begin( ssid );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WEP-encrypted networks
inline int begin(char *ssid, uint8_t key_idx, const char *key, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_key_idx = key_idx;
_key = key;
int result = WiFi.begin( ssid, key_idx, key );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WPA-encrypted networks
inline int begin(char *ssid, const char *passphrase, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_passphrase = passphrase;
int result = WiFi.begin( ssid, passphrase);
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
/******************************************************************************
* Connection functions without DHCP
******************************************************************************/
//OPEN networks with static IP
inline int begin(char *ssid, IPAddress local_ip, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_local_ip = local_ip;
WiFi.config( local_ip );
int result = WiFi.begin( ssid );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WEP-encrypted networks with static IP
inline int begin(char *ssid, IPAddress local_ip, uint8_t key_idx, const char *key, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_local_ip = local_ip;
_key_idx = key_idx;
_key = key;
WiFi.config( local_ip );
int result = WiFi.begin( ssid, key_idx, key );
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
//WPA-encrypted networks with static IP
inline int begin(char *ssid, IPAddress local_ip, const char *passphrase, uint16_t port)
{
if( !is_ready() ) return 0;
_ssid = ssid;
_port = port;
_local_ip = local_ip;
_passphrase = passphrase;
WiFi.config( local_ip );
int result = WiFi.begin( ssid, passphrase);
if( result == 0 ) return 0;
_server = WiFiServer( port );
_server.begin();
return result;
}
/******************************************************************************
* Stream implementations
******************************************************************************/
inline int available()
{
return connect_client() ? _client.available() : 0;
}
inline void flush()
{
if( _client ) _client.flush();
}
inline int peek()
{
return connect_client() ? _client.peek(): 0;
}
inline int read()
{
return connect_client() ? _client.read() : -1;
}
inline void stop()
{
_client.stop();
}
inline size_t write(uint8_t byte)
{
if( connect_client() ) _client.write( byte );
}
};
#endif //WIFI_STREAM_H

14
libraries/FirmataWithDeviceFeature/src-features/utility/firmataDebug.h Normal file
View File

@@ -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 */

709
libraries/FirmataWithDeviceFeature/src/ConfigurableFirmata.cpp Normal file
View File

@@ -0,0 +1,709 @@
/*
ConfigurableFirmata.pp - ConfigurableFirmata library v2.8.2 - 2016-2-16
Copyright (c) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (c) 2013 Norbert Truchsess. All rights reserved.
Copyright (c) 2013-2016 Jeff Hoefs. 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 "ConfigurableFirmata.h"
#include "HardwareSerial.h"
extern "C" {
#include <string.h>
#include <stdlib.h>
}
//******************************************************************************
//* Support Functions
//******************************************************************************
/**
* Split a 16-bit byte into two 7-bit values and write each value.
* @param value The 16-bit value to be split and written separately.
*/
void FirmataClass::sendValueAsTwo7bitBytes(int value)
{
FirmataStream->write(value & B01111111); // LSB
FirmataStream->write(value >> 7 & B01111111); // MSB
}
/**
* A helper method to write the beginning of a Sysex message transmission.
*/
void FirmataClass::startSysex(void)
{
FirmataStream->write(START_SYSEX);
}
/**
* A helper method to write the end of a Sysex message transmission.
*/
void FirmataClass::endSysex(void)
{
FirmataStream->write(END_SYSEX);
}
//******************************************************************************
//* Constructors
//******************************************************************************
/**
* The Firmata class.
* An instance named "Firmata" is created automatically for the user.
*/
FirmataClass::FirmataClass()
{
firmwareVersionCount = 0;
firmwareVersionVector = 0;
systemReset();
}
//******************************************************************************
//* Public Methods
//******************************************************************************
/**
* Initialize the default Serial transport at the default baud of 57600.
*/
void FirmataClass::begin(void)
{
begin(57600);
}
/**
* Initialize the default Serial transport and override the default baud.
* Sends the protocol version to the host application followed by the firmware version and name.
* blinkVersion is also called. To skip the call to blinkVersion, call Firmata.disableBlinkVersion()
* before calling Firmata.begin(baud).
* @param speed The baud to use. 57600 baud is the default value.
*/
void FirmataClass::begin(long speed)
{
Serial.begin(speed);
FirmataStream = &Serial;
blinkVersion();
printVersion(); // send the protocol version
printFirmwareVersion(); // send the firmware name and version
}
/**
* Reassign the Firmata stream transport.
* @param s A reference to the Stream transport object. This can be any type of
* transport that implements the Stream interface. Some examples include Ethernet, WiFi
* and other UARTs on the board (Serial1, Serial2, etc).
*/
void FirmataClass::begin(Stream &s)
{
FirmataStream = &s;
// do not call blinkVersion() here because some hardware such as the
// Ethernet shield use pin 13
printVersion(); // send the protocol version
printFirmwareVersion(); // send the firmware name and version
}
/**
* Send the Firmata protocol version to the Firmata host application.
*/
void FirmataClass::printVersion(void)
{
FirmataStream->write(REPORT_VERSION);
FirmataStream->write(FIRMATA_PROTOCOL_MAJOR_VERSION);
FirmataStream->write(FIRMATA_PROTOCOL_MINOR_VERSION);
}
/**
* Blink the Firmata protocol version to the onboard LEDs (if the board has an onboard LED).
* If VERSION_BLINK_PIN is not defined in Boards.h for a particular board, then this method
* does nothing.
* The first series of flashes indicates the firmware major version (2 flashes = 2).
* The second series of flashes indicates the firmware minor version (5 flashes = 5).
*/
void FirmataClass::blinkVersion(void)
{
#if defined(VERSION_BLINK_PIN)
if (blinkVersionDisabled) return;
// flash the pin with the protocol version
pinMode(VERSION_BLINK_PIN, OUTPUT);
strobeBlinkPin(VERSION_BLINK_PIN, FIRMATA_FIRMWARE_MAJOR_VERSION, 40, 210);
delay(250);
strobeBlinkPin(VERSION_BLINK_PIN, FIRMATA_FIRMWARE_MINOR_VERSION, 40, 210);
delay(125);
#endif
}
/**
* Provides a means to disable the version blink sequence on the onboard LED, trimming startup
* time by a couple of seconds.
* Call this before Firmata.begin(). It only applies when using the default Serial transport.
*/
void FirmataClass::disableBlinkVersion()
{
blinkVersionDisabled = true;
}
/**
* Sends the firmware name and version to the Firmata host application. The major and minor version
* numbers are the first 2 bytes in the message. The following bytes are the characters of the
* firmware name.
*/
void FirmataClass::printFirmwareVersion(void)
{
byte i;
if (firmwareVersionCount) { // make sure that the name has been set before reporting
startSysex();
FirmataStream->write(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();
}
}
/**
* Sets the name and version of the firmware. This is not the same version as the Firmata protocol
* (although at times the firmware version and protocol version may be the same number).
* @param name A pointer to the name char array
* @param major The major version number
* @param minor The minor version number
*/
void FirmataClass::setFirmwareNameAndVersion(const char *name, byte major, byte minor)
{
const char *firmwareName;
const char *extension;
// parse out ".cpp" and "applet/" that comes from using __FILE__
extension = strstr(name, ".cpp");
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 = extension - firmwareName + 2;
}
// in case anyone calls setFirmwareNameAndVersion more than once
free(firmwareVersionVector);
firmwareVersionVector = (byte *) malloc(firmwareVersionCount + 1);
firmwareVersionVector[firmwareVersionCount] = 0;
firmwareVersionVector[0] = major;
firmwareVersionVector[1] = minor;
strncpy((char *)firmwareVersionVector + 2, firmwareName, firmwareVersionCount - 2);
}
//------------------------------------------------------------------------------
// Input Stream Handling
/**
* A wrapper for Stream::available()
* @return The number of bytes remaining in the input stream buffer.
*/
int FirmataClass::available(void)
{
return FirmataStream->available();
}
/**
* Process incoming sysex messages. Handles REPORT_FIRMWARE and STRING_DATA internally.
* Calls callback function for STRING_DATA and all other sysex messages.
* @private
*/
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;
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]);
}
break;
default:
if (currentSysexCallback)
(*currentSysexCallback)(storedInputData[0], sysexBytesRead - 1, storedInputData + 1);
}
}
/**
* Read a single int from the input stream. If the value is not = -1, pass it on to parse(byte)
*/
void FirmataClass::processInput(void)
{
int inputData = FirmataStream->read(); // this is 'int' to handle -1 when no data
if (inputData != -1) {
parse(inputData);
}
}
/**
* Parse data from the input stream.
* @param inputData A single byte to be added to the parser.
*/
void FirmataClass::parse(byte inputData)
{
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:
setPinMode(storedInputData[1], storedInputData[0]);
break;
case SET_DIGITAL_PIN_VALUE:
if (currentPinValueCallback)
(*currentPinValueCallback)(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:
case SET_DIGITAL_PIN_VALUE:
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;
}
}
}
/**
* @return Returns true if the parser is actively parsing data.
*/
boolean FirmataClass::isParsingMessage(void)
{
return (waitForData > 0 || parsingSysex);
}
/**
* @return Returns true if the SYSTEM_RESET message is being executed
*/
boolean FirmataClass::isResetting(void)
{
return resetting;
}
//------------------------------------------------------------------------------
// Output Stream Handling
/**
* Send an analog message to the Firmata host application. The range of pins is limited to [0..15]
* when using the ANALOG_MESSAGE. The maximum value of the ANALOG_MESSAGE is limited to 14 bits
* (16384). To increase the pin range or value, see the documentation for the EXTENDED_ANALOG
* message.
* @param pin The analog pin to send the value of (limited to pins 0 - 15).
* @param value The value of the analog pin (0 - 1024 for 10-bit analog, 0 - 4096 for 12-bit, etc).
* The maximum value is 14-bits (16384).
*/
void FirmataClass::sendAnalog(byte pin, int value)
{
// pin can only be 0-15, so chop higher bits
FirmataStream->write(ANALOG_MESSAGE | (pin & 0xF));
sendValueAsTwo7bitBytes(value);
}
/* (intentionally left out asterix here)
* STUB - NOT IMPLEMENTED
* Send a single digital pin value to the Firmata host application.
* @param pin The digital pin to send the value of.
* @param value The value of the pin.
*/
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 an 8-bit port in a single digital message (protocol v2 and later).
* Send 14-bits in a single digital message (protocol v1).
* @param portNumber The port number to send. Note that this is not the same as a "port" on the
* physical microcontroller. Ports are defined in order per every 8 pins in ascending order
* of the Arduino digital pin numbering scheme. Port 0 = pins D0 - D7, port 1 = pins D8 - D15, etc.
* @param portData The value of the port. The value of each pin in the port is represented by a bit.
*/
void FirmataClass::sendDigitalPort(byte portNumber, int portData)
{
FirmataStream->write(DIGITAL_MESSAGE | (portNumber & 0xF));
FirmataStream->write((byte)portData % 128); // Tx bits 0-6
FirmataStream->write(portData >> 7); // Tx bits 7-13
}
/**
* Send a sysex message where all values after the command byte are packet as 2 7-bit bytes
* (this is not always the case so this function is not always used to send sysex messages).
* @param command The sysex command byte.
* @param bytec The number of data bytes in the message (excludes start, command and end bytes).
* @param bytev A pointer to the array of data bytes to send in the message.
*/
void FirmataClass::sendSysex(byte command, byte bytec, byte *bytev)
{
byte i;
startSysex();
FirmataStream->write(command);
for (i = 0; i < bytec; i++) {
sendValueAsTwo7bitBytes(bytev[i]);
}
endSysex();
}
/**
* Send a string to the Firmata host application.
* @param command Must be STRING_DATA
* @param string A pointer to the char string
*/
void FirmataClass::sendString(byte command, const char *string)
{
sendSysex(command, strlen(string), (byte *)string);
}
/**
* Send a string to the Firmata host application.
* @param string A pointer to the char string
*/
void FirmataClass::sendString(const char *string)
{
sendString(STRING_DATA, string);
}
/**
* A wrapper for Stream::available().
* Write a single byte to the output stream.
* @param c The byte to be written.
*/
void FirmataClass::write(byte c)
{
FirmataStream->write(c);
}
/**
* Attach a generic sysex callback function to a command (options are: ANALOG_MESSAGE,
* DIGITAL_MESSAGE, REPORT_ANALOG, REPORT DIGITAL, SET_PIN_MODE and SET_DIGITAL_PIN_VALUE).
* @param command The ID of the command to attach a callback function to.
* @param newFunction A reference to the callback function to attach.
*/
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;
case SET_DIGITAL_PIN_VALUE: currentPinValueCallback = newFunction; break;
}
}
/**
* Attach a callback function for the SYSTEM_RESET command.
* @param command Must be set to SYSTEM_RESET or it will be ignored.
* @param newFunction A reference to the system reset callback function to attach.
*/
void FirmataClass::attach(byte command, systemResetCallbackFunction newFunction)
{
switch (command) {
case SYSTEM_RESET: currentSystemResetCallback = newFunction; break;
}
}
/**
* Attach a callback function for the STRING_DATA command.
* @param command Must be set to STRING_DATA or it will be ignored.
* @param newFunction A reference to the string callback function to attach.
*/
void FirmataClass::attach(byte command, stringCallbackFunction newFunction)
{
switch (command) {
case STRING_DATA: currentStringCallback = newFunction; break;
}
}
/**
* Attach a generic sysex callback function to sysex command.
* @param command The ID of the command to attach a callback function to.
* @param newFunction A reference to the sysex callback function to attach.
*/
void FirmataClass::attach(byte command, sysexCallbackFunction newFunction)
{
currentSysexCallback = newFunction;
}
/**
* Detach a callback function for a specified command (such as SYSTEM_RESET, STRING_DATA,
* ANALOG_MESSAGE, DIGITAL_MESSAGE, etc).
* @param command The ID of the command to detatch the callback function from.
*/
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);
}
}
/**
* Detach a callback function for a delayed task when using FirmataScheduler
* @see FirmataScheduler
* @param newFunction A reference to the delay task callback function to attach.
*/
void FirmataClass::attachDelayTask(delayTaskCallbackFunction newFunction)
{
delayTaskCallback = newFunction;
}
/**
* Call the delayTask callback function when using FirmataScheduler. Must first attach a callback
* using attachDelayTask.
* @see FirmataScheduler
* @param delay The amount of time to delay in milliseconds.
*/
void FirmataClass::delayTask(long delay)
{
if (delayTaskCallback) {
(*delayTaskCallback)(delay);
}
}
/**
* @param pin The pin to get the configuration of.
* @return The configuration of the specified pin.
*/
byte FirmataClass::getPinMode(byte pin)
{
return pinConfig[pin];
}
/**
* Set the pin mode/configuration. The pin configuration (or mode) in Firmata represents the
* current function of the pin. Examples are digital input or output, analog input, pwm, i2c,
* serial (uart), etc.
* @param pin The pin to configure.
* @param config The configuration value for the specified pin.
*/
void FirmataClass::setPinMode(byte pin, byte config)
{
if (pinConfig[pin] == PIN_MODE_IGNORE)
return;
pinState[pin] = 0;
pinConfig[pin] = config;
if (currentPinModeCallback)
(*currentPinModeCallback)(pin, config);
}
/**
* @param pin The pin to get the state of.
* @return The state of the specified pin.
*/
int FirmataClass::getPinState(byte pin)
{
return pinState[pin];
}
/**
* Set the pin state. The pin state of an output pin is the pin value. The state of an
* input pin is 0, unless the pin has it's internal pull up resistor enabled, then the value is 1.
* @param pin The pin to set the state of
* @param state Set the state of the specified pin
*/
void FirmataClass::setPinState(byte pin, int state)
{
pinState[pin] = state;
}
// 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.
* @private
*/
void FirmataClass::systemReset(void)
{
resetting = true;
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)();
resetting = false;
}
/**
* Flashing the pin for the version number
* @private
* @param pin The pin the LED is attached to.
* @param count The number of times to flash the LED.
* @param onInterval The number of milliseconds for the LED to be ON during each interval.
* @param offInterval The number of milliseconds for the LED to be OFF during each interval.
*/
void FirmataClass::strobeBlinkPin(byte pin, int count, int onInterval, int offInterval)
{
byte i;
for (i = 0; i < count; i++) {
delay(offInterval);
digitalWrite(pin, HIGH);
delay(onInterval);
digitalWrite(pin, LOW);
}
}
// make one instance for the user to use
FirmataClass Firmata;

245
libraries/FirmataWithDeviceFeature/src/ConfigurableFirmata.h Normal file
View File

@@ -0,0 +1,245 @@
/*
ConfigurableFirmata.h - ConfigurableFirmata library v2.8.2 - 2016-2-16
Copyright (c) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (c) 2013 Norbert Truchsess. All rights reserved.
Copyright (c) 2013-2016 Jeff Hoefs. 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 Configurable_Firmata_h
#define Configurable_Firmata_h
#include "utility/Boards.h" /* Hardware Abstraction Layer + Wiring/Arduino */
/* Version numbers for the protocol. The protocol is still changing, so these
* version numbers are important.
* Query using the REPORT_VERSION message.
*/
#define FIRMATA_PROTOCOL_MAJOR_VERSION 2 // for non-compatible changes
#define FIRMATA_PROTOCOL_MINOR_VERSION 5 // for backwards compatible changes
#define FIRMATA_PROTOCOL_BUGFIX_VERSION 1 // for bugfix releases
/*
* Version numbers for the Firmata library.
* ConfigurableFirmata 2.8.1 implements version 2.5.1 of the Firmata protocol.
* The firmware version will not always equal the protocol version going forward.
* Query using the REPORT_FIRMWARE message.
*/
#define FIRMATA_FIRMWARE_MAJOR_VERSION 2 // for non-compatible changes
#define FIRMATA_FIRMWARE_MINOR_VERSION 9 // for backwards compatible changes
#define FIRMATA_FIRMWARE_BUGFIX_VERSION 3 // for bugfix releases
// DEPRECATED as of ConfigurableFirmata v2.8.1.
// Use FIRMATA_PROTOCOL_[MAJOR|MINOR|BUGFIX]_VERSION instead.
#define FIRMATA_MAJOR_VERSION 2
#define FIRMATA_MINOR_VERSION 5
#define FIRMATA_BUGFIX_VERSION 1
// DEPRECATED as of ConfigurableFirmata v2.8.1.
//Use FIRMATA_FIRMWARE_[MAJOR|MINOR|BUGFIX]_VERSION instead.
#define FIRMWARE_MAJOR_VERSION 2
#define FIRMWARE_MINOR_VERSION 8
#define FIRMWARE_BUGFIX_VERSION 2
#define MAX_DATA_BYTES 64 // max number of data bytes in incoming messages
// Arduino 101 also defines SET_PIN_MODE as a macro in scss_registers.h
#ifdef SET_PIN_MODE
#undef SET_PIN_MODE
#endif
// message command bytes (128-255/0x80-0xFF)
#define DIGITAL_MESSAGE 0x90 // send data for a digital pin
#define ANALOG_MESSAGE 0xE0 // send data for an analog pin (or PWM)
#define REPORT_ANALOG 0xC0 // enable analog input by pin #
#define REPORT_DIGITAL 0xD0 // enable digital input by port pair
//
#define SET_PIN_MODE 0xF4 // set a pin to INPUT/OUTPUT/PWM/etc
#define SET_DIGITAL_PIN_VALUE 0xF5 // set value of an individual digital pin
//
#define REPORT_VERSION 0xF9 // report protocol version
#define SYSTEM_RESET 0xFF // reset from MIDI
//
#define START_SYSEX 0xF0 // start a MIDI Sysex message
#define END_SYSEX 0xF7 // end a MIDI Sysex message
// extended command set using sysex (0-127/0x00-0x7F)
/* 0x00-0x0F reserved for user-defined commands */
#define SERIAL_MESSAGE 0x60 // communicate with serial devices, including other boards
#define ENCODER_DATA 0x61 // reply with encoders current positions
#define SERVO_CONFIG 0x70 // set max angle, minPulse, maxPulse, freq
#define STRING_DATA 0x71 // a string message with 14-bits per char
#define STEPPER_DATA 0x72 // control a stepper motor
#define ONEWIRE_DATA 0x73 // send an OneWire read/write/reset/select/skip/search request
#define SHIFT_DATA 0x75 // a bitstream to/from a shift register
#define I2C_REQUEST 0x76 // send an I2C read/write request
#define I2C_REPLY 0x77 // a reply to an I2C read request
#define I2C_CONFIG 0x78 // config I2C settings such as delay times and power pins
#define EXTENDED_ANALOG 0x6F // analog write (PWM, Servo, etc) to any pin
#define PIN_STATE_QUERY 0x6D // ask for a pin's current mode and value
#define PIN_STATE_RESPONSE 0x6E // reply with pin's current mode and value
#define CAPABILITY_QUERY 0x6B // ask for supported modes and resolution of all pins
#define CAPABILITY_RESPONSE 0x6C // reply with supported modes and resolution
#define ANALOG_MAPPING_QUERY 0x69 // ask for mapping of analog to pin numbers
#define ANALOG_MAPPING_RESPONSE 0x6A // reply with mapping info
#define REPORT_FIRMWARE 0x79 // report name and version of the firmware
#define SAMPLING_INTERVAL 0x7A // set the poll rate of the main loop
#define SCHEDULER_DATA 0x7B // send a createtask/deletetask/addtotask/schedule/querytasks/querytask request to the scheduler
#define SYSEX_NON_REALTIME 0x7E // MIDI Reserved for non-realtime messages
#define SYSEX_REALTIME 0x7F // MIDI Reserved for realtime messages
// DeviceFirmata commands
#define DEVICE_QUERY 0x30 // message requesting action from a device driver (DeviceFirmata)
#define DEVICE_RESPONSE 0x31 // message providing the device driver response (DeviceFirmata)
// these are DEPRECATED to make the naming more consistent
#define FIRMATA_STRING 0x71 // same as STRING_DATA
#define SYSEX_I2C_REQUEST 0x76 // same as I2C_REQUEST
#define SYSEX_I2C_REPLY 0x77 // same as I2C_REPLY
#define SYSEX_SAMPLING_INTERVAL 0x7A // same as SAMPLING_INTERVAL
// pin modes
//#define INPUT 0x00 // defined in Arduino.h
//#define OUTPUT 0x01 // defined in Arduino.h
#define PIN_MODE_ANALOG 0x02 // analog pin in analogInput mode
#define PIN_MODE_PWM 0x03 // digital pin in PWM output mode
#define PIN_MODE_SERVO 0x04 // digital pin in Servo output mode
#define PIN_MODE_SHIFT 0x05 // shiftIn/shiftOut mode
#define PIN_MODE_I2C 0x06 // pin included in I2C setup
#define PIN_MODE_ONEWIRE 0x07 // pin configured for 1-wire
#define PIN_MODE_STEPPER 0x08 // pin configured for stepper motor
#define PIN_MODE_ENCODER 0x09 // pin configured for rotary encoders
#define PIN_MODE_SERIAL 0x0A // pin configured for serial communication
#define PIN_MODE_PULLUP 0x0B // enable internal pull-up resistor for pin
#define PIN_MODE_IGNORE 0x7F // pin configured to be ignored by digitalWrite and capabilityResponse
#define TOTAL_PIN_MODES 13
// DEPRECATED as of Firmata v2.5
#define ANALOG 0x02 // same as PIN_MODE_ANALOG
#define PWM 0x03 // same as PIN_MODE_PWM
#define SERVO 0x04 // same as PIN_MODE_SERVO
#define SHIFT 0x05 // same as PIN_MODE_SHIFT
#define I2C 0x06 // same as PIN_MODE_I2C
#define ONEWIRE 0x07 // same as PIN_MODE_ONEWIRE
#define STEPPER 0x08 // same as PIN_MODE_STEPPER
#define ENCODER 0x09 // same as PIN_MODE_ENCODER
#define IGNORE 0x7F // same as PIN_MODE_IGNORE
extern "C" {
// callback function types
typedef void (*callbackFunction)(byte, int);
typedef void (*systemResetCallbackFunction)(void);
typedef void (*stringCallbackFunction)(char *);
typedef void (*sysexCallbackFunction)(byte command, byte argc, byte *argv);
typedef void (*delayTaskCallbackFunction)(long delay);
}
// TODO make it a subclass of a generic Serial/Stream base class
class FirmataClass
{
public:
FirmataClass();
/* Arduino constructors */
void begin();
void begin(long);
void begin(Stream &s);
/* querying functions */
void printVersion(void);
void blinkVersion(void);
void printFirmwareVersion(void);
//void setFirmwareVersion(byte major, byte minor); // see macro below
void setFirmwareNameAndVersion(const char *name, byte major, byte minor);
void disableBlinkVersion();
/* serial receive handling */
int available(void);
void processInput(void);
void parse(unsigned char value);
boolean isParsingMessage(void);
boolean isResetting(void);
/* serial send handling */
void sendAnalog(byte pin, int value);
void sendDigital(byte pin, int value); // TODO implement this
void sendDigitalPort(byte portNumber, int portData);
void sendString(const char *string);
void sendString(byte command, const char *string);
void sendSysex(byte command, byte bytec, byte *bytev);
void write(byte c);
/* attach & detach callback functions to messages */
void attach(byte command, callbackFunction newFunction);
void attach(byte command, systemResetCallbackFunction newFunction);
void attach(byte command, stringCallbackFunction newFunction);
void attach(byte command, sysexCallbackFunction newFunction);
void detach(byte command);
/* delegate to Scheduler (if any) */
void attachDelayTask(delayTaskCallbackFunction newFunction);
void delayTask(long delay);
/* access pin config */
byte getPinMode(byte pin);
void setPinMode(byte pin, byte config);
/* access pin state */
int getPinState(byte pin);
void setPinState(byte pin, int state);
/* utility methods */
void sendValueAsTwo7bitBytes(int value);
void startSysex(void);
void endSysex(void);
private:
Stream *FirmataStream;
/* firmware name and version */
byte firmwareVersionCount;
byte *firmwareVersionVector;
/* input message handling */
byte waitForData; // this flag says the next serial input will be data
byte executeMultiByteCommand; // execute this after getting multi-byte data
byte multiByteChannel; // channel data for multiByteCommands
byte storedInputData[MAX_DATA_BYTES]; // multi-byte data
/* sysex */
boolean parsingSysex;
int sysexBytesRead;
/* pins configuration */
byte pinConfig[TOTAL_PINS]; // configuration of every pin
int pinState[TOTAL_PINS]; // any value that has been written
boolean resetting;
/* callback functions */
callbackFunction currentAnalogCallback;
callbackFunction currentDigitalCallback;
callbackFunction currentReportAnalogCallback;
callbackFunction currentReportDigitalCallback;
callbackFunction currentPinModeCallback;
callbackFunction currentPinValueCallback;
systemResetCallbackFunction currentSystemResetCallback;
stringCallbackFunction currentStringCallback;
sysexCallbackFunction currentSysexCallback;
delayTaskCallbackFunction delayTaskCallback;
boolean blinkVersionDisabled = false;
/* private methods ------------------------------ */
void processSysexMessage(void);
void systemReset(void);
void strobeBlinkPin(byte pin, int count, int onInterval, int offInterval);
};
extern FirmataClass Firmata;
/*==============================================================================
* MACROS
*============================================================================*/
/* shortcut for setFirmwareNameAndVersion() that uses __FILE__ to set the
* firmware name. It needs to be a macro so that __FILE__ is included in the
* firmware source file rather than the library source file.
*/
#define setFirmwareVersion(x, y) setFirmwareNameAndVersion(__FILE__, x, y)
#endif /* Configurable_Firmata_h */

264
libraries/FirmataWithDeviceFeature/src/DeviceFirmata.cpp Normal file
View File

@@ -0,0 +1,264 @@
/*
DeviceFirmata.cpp - Firmata library
*/
#include "DeviceFirmata.h"
#include "utility/Boards.h"
#include <Base64.h>
DeviceTable *gDeviceTable;
extern DeviceDriver *selectedDevices[];
//----------------------------------------------------------------------------
DeviceFirmata::DeviceFirmata() {
gDeviceTable = new DeviceTable(selectedDevices,this);
}
//---------------------------------------------------------------------------
void DeviceFirmata::reset() {
gDeviceTable->reset();
}
// The pins that are currently being used by device drivers are already
// marked as PIN_MODE_IGNORE, so we have no additional information to
// provide to the list of capabilities.
void DeviceFirmata::handleCapability(byte pin) {}
// Device driver capabilities do not necessarily map directly to Firmata pin
// modes, and so none of the Firmata modes are recognized and all pin mode
// requests are disavowed.
boolean DeviceFirmata::handlePinMode(byte pin, int mode) {
return false;
}
void DeviceFirmata::update() {
gDeviceTable->dispatchTimers();
}
//---------------------------------------------------------------------------
// The entire body of each device driver message is encoded in base-64
// during transmission to and from this Firmata server. The first 9 bytes
// of the decoded message body form a prologue that contains slots for all
// the common query and request parameters. Following bytes in a query
// are used by the open() and write() methods; following bytes in a response
// are used by the read() method.
// Note that the base64 library adds a null terminator after the decoded data.
// This means that the decode targets need to be at least one byte bigger than
// the actual data size. This also makes it possible to use the decoded data
// as a null-terminated string without having to add the null (eg, open())
boolean DeviceFirmata::handleSysex(byte command, byte argc, byte *argv) {
if (command != DEVICE_QUERY) return false;
if (argc < 12) {
reportError(EMSGSIZE);
return true;
}
byte parameterBlock[10]; // 9-byte beginning of every decoded DEVICE_QUERY message
byte *dataBlock = 0; // data from the client for use in open() and write()
byte *inputBuffer = 0; // data from the device in response to read()
base64_decode((char *)parameterBlock, (char *)(argv), 12);
int dataBlockLength = (argc == 12) ? 0 : base64_dec_len((char *)(argv + 12), argc - 12);
if (dataBlockLength > 0) {
dataBlock = new byte[dataBlockLength+1];
if (dataBlock == 0) {
reportError(ENOMEM);
return true;
}
dataBlockLength = base64_decode((char *)dataBlock, (char *)(argv + 12), argc - 12);
}
int action = (from8LEToHost(parameterBlock) & 0x0F);
int flags = (from8LEToHost(parameterBlock) & 0xF0) >> 4;
int handle = from16LEToHost(parameterBlock+1);
int openOpts = handle;
int reg = from16LEToHost(parameterBlock+3);
int count = from16LEToHost(parameterBlock+5);
int status;
switch (action) {
case (int)DAC::OPEN:
if (dataBlockLength == 0) {
reportError(EINVAL);
} else {
status = gDeviceTable->open(openOpts, flags, (const char *)dataBlock);
reportOpen(status, openOpts, flags, dataBlock);
}
break;
case (int)DAC::READ:
if (dataBlockLength != 0) {
reportError(EINVAL);
} else {
inputBuffer = new byte[count];
if (inputBuffer == 0) {
reportError(ENOMEM);
} else {
status = gDeviceTable->read(handle, flags, reg, count, inputBuffer);
reportRead(status, handle, flags, reg, count, inputBuffer);
}
}
break;
case (int)DAC::WRITE:
if (dataBlockLength != count) {
reportError(EINVAL);
} else {
status = gDeviceTable->write(handle, flags, reg, count, dataBlock);
reportWrite(status, handle, flags, reg, count);
}
break;
case (int)DAC::CLOSE:
if (dataBlockLength != 0) {
reportError(EINVAL);
} else {
status = gDeviceTable->close(handle, flags);
reportClose(status, handle, flags);
}
break;
default:
reportError(ENOTSUP);
break;
}
delete dataBlock;
delete inputBuffer;
return true;
}
//---------------------------------------------------------------------------
void DeviceFirmata::reportClaimPin(int pin) {
Firmata.setPinMode((byte)pin, PIN_MODE_IGNORE);
}
void DeviceFirmata::reportReleasePin(int pin) {
Firmata.setPinMode((byte)pin, INPUT);
}
void DeviceFirmata::reportOpen(int status, int openOpts, int flags, const byte *buf) {
sendDeviceResponse((int)DAC::OPEN, status, openOpts, flags, 0, 0,buf);
}
/**
* Translates a message from the DeviceDriver environment to a call to a Firmata-aware method.
* @param status The status code or actual byte count associated with this read.
* @param handle The handle of the unit doing the reply
* @param reg The register identifier associated with the read() being reported
* @param count The number of bytes that were requested. May be less than or
* equal to the byte count in status after a successful read.
* @param buf The byte[] result of the read().
*/
void DeviceFirmata::reportRead(int status, int handle, int flags, int reg, int count, const byte *buf) {
sendDeviceResponse((int)DAC::READ, status, handle, flags, reg, count, buf);
}
/**
* Translates a message from the DeviceDriver environment to a call to a Firmata-aware method.
* @param status The status code or actual byte count associated with this write.
* @param handle The handle of the unit doing the reply
* @param reg The register identifier associated with the write() being reported
* @param count The number of bytes that were requested. May be less than or
* equal to the byte count in status after a successful write.
*/
void DeviceFirmata::reportWrite(int status, int handle, int flags, int reg, int count) {
sendDeviceResponse((int)DAC::WRITE, status, handle, flags, reg, count);
}
void DeviceFirmata::reportClose(int status, int handle, int flags) {
sendDeviceResponse((int)DAC::CLOSE, status, handle, flags);
}
void DeviceFirmata::reportError(int status) {
sendDeviceResponse((int)DAC::CLOSE, status);
}
void DeviceFirmata::reportString(const byte *dataBytes) {
Firmata.sendString((char *)dataBytes);
}
//---------------------------------------------------------------------------
/**
* This method is called when there is a message to be sent back to the
* client. It may be in response to a DEVICE_REQUEST that was just
* processed, or it may be an asynchronous event such as a stepper motor in
* a new position or a continuous read data packet.
*
* dmB -> decoded message body
* emB -> encoded message body
*
* @param action The method identifier to use in the response.
* @param status Status value, new handle (open), or number of bytes actually read or written
* @param handle The handle identifying the device and unit number the message is coming from
* @param reg The register number associated with this message
* @param count The number of bytes specified originally by the caller
* @param dataBytes The raw data read from the device, if any
*
* Note: The base64 encoder adds a null at the end of the encoded data. Thus the encode
* target buffer needs to be one byte longer than the calculated data length.
*/
void DeviceFirmata::sendDeviceResponse(int action, int status, int handle, int flags, int reg, int count,
const byte *dataBytes) {
byte dP[9]; // decoded (raw) message prologue
byte eP[12+1]; // encoded message prologue
byte *eD; // encoded data bytes
Firmata.write(START_SYSEX);
Firmata.write(DEVICE_RESPONSE);
dP[0] = (byte) ((flags & 0xF) << 4) | (action & 0xF);
dP[1] = (byte) lowByte(handle);
dP[2] = (byte) highByte(handle);
dP[3] = (byte) lowByte(reg);
dP[4] = (byte) highByte(reg);
dP[5] = (byte) lowByte(count);
dP[6] = (byte) highByte(count);
dP[7] = (byte) lowByte(status);
dP[8] = (byte) highByte(status);
base64_encode((char *)eP, (char *)dP, 9);
for (int idx = 0; idx < 12; idx++) {
Firmata.write(eP[idx]);
}
int rawCount = 0;
int encCount = 0;
if (dataBytes != 0) {
if (action == (int)DAC::OPEN) {
rawCount = strlen((const char *)dataBytes)+1;
} else if (action == (int)DAC::READ && status > 0) {
rawCount = status;
}
encCount = base64_enc_len(rawCount);
if (encCount > 0) {
eD = new byte[encCount+1];
if (eD == 0) {
for (int idx = 0; idx < encCount; idx++) {
Firmata.write('/'); // Memory allocation error. This value will be decoded as 0x3F, ie, all 7 bits set.
}
} else {
base64_encode((char *)eD, (char *)dataBytes, rawCount);
for (int idx = 0; idx < encCount; idx++) {
Firmata.write(eD[idx]); // Success. These are the encoded data bytes.
}
}
delete eD;
}
}
Firmata.write(END_SYSEX);
}

41
libraries/FirmataWithDeviceFeature/src/DeviceFirmata.h Normal file
View File

@@ -0,0 +1,41 @@
#ifndef DeviceFirmata_h
#define DeviceFirmata_h
#include <FirmataFeature.h>
#include <LuniLib.h>
#include <Device/DeviceDriver.h>
#include <Device/DeviceTable.h>
#include <Device/ClientReporter.h>
class DeviceFirmata: public FirmataFeature, ClientReporter {
public:
DeviceFirmata();
// FirmataFeature
void reset();
void handleCapability(byte pin);
boolean handlePinMode(byte pin, int mode);
boolean handleSysex(byte command, byte argc, byte* argv);
void update();
// ClientReporter
void reportOpen(int status, int opts, int flags, const byte *buf);
void reportRead(int status, int handle, int flags, int reg, int count, const byte *dataBytes);
void reportWrite(int status, int handle, int flags, int reg, int count);
void reportClose(int status, int handle, int flags );
void reportString(const byte *dataBytes);
void reportError(int status);
void reportClaimPin(int pin);
void reportReleasePin(int pin);
private:
void sendDeviceResponse(int action, int status, int handle = 0, int flags = 0, int reg = 0, int count = 0, const byte *dataBytes = 0);
};
#endif

117
libraries/FirmataWithDeviceFeature/src/FirmataExt.cpp Normal file
View File

@@ -0,0 +1,117 @@
/*
FirmataExt.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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.
Last updated by Jeff Hoefs: November 15th, 2015
*/
#include <ConfigurableFirmata.h>
#include "FirmataExt.h"
FirmataExt *FirmataExtInstance;
void handleSetPinModeCallback(byte pin, int mode)
{
if (!FirmataExtInstance->handlePinMode(pin, mode) && mode != PIN_MODE_IGNORE) {
Firmata.sendString("Unknown pin mode"); // TODO: put error msgs in EEPROM
}
}
void handleSysexCallback(byte command, byte argc, byte* argv)
{
if (!FirmataExtInstance->handleSysex(command, argc, argv)) {
Firmata.sendString("Unhandled sysex command");
}
}
FirmataExt::FirmataExt()
{
FirmataExtInstance = this;
Firmata.attach(SET_PIN_MODE, handleSetPinModeCallback);
Firmata.attach((byte)START_SYSEX, handleSysexCallback);
numFeatures = 0;
}
void FirmataExt::handleCapability(byte pin)
{
}
boolean FirmataExt::handlePinMode(byte pin, int mode)
{
boolean known = false;
for (byte i = 0; i < numFeatures; i++) {
known |= features[i]->handlePinMode(pin, mode);
}
return known;
}
boolean FirmataExt::handleSysex(byte command, byte argc, byte* argv)
{
switch (command) {
case PIN_STATE_QUERY:
if (argc > 0) {
byte pin = argv[0];
if (pin < TOTAL_PINS) {
Firmata.write(START_SYSEX);
Firmata.write(PIN_STATE_RESPONSE);
Firmata.write(pin);
Firmata.write(Firmata.getPinMode(pin));
int pinState = Firmata.getPinState(pin);
Firmata.write((byte)pinState & 0x7F);
if (pinState & 0xFF80) Firmata.write((byte)(pinState >> 7) & 0x7F);
if (pinState & 0xC000) Firmata.write((byte)(pinState >> 14) & 0x7F);
Firmata.write(END_SYSEX);
return true;
}
}
break;
case CAPABILITY_QUERY:
Firmata.write(START_SYSEX);
Firmata.write(CAPABILITY_RESPONSE);
for (byte pin = 0; pin < TOTAL_PINS; pin++) {
if (Firmata.getPinMode(pin) != PIN_MODE_IGNORE) {
for (byte i = 0; i < numFeatures; i++) {
features[i]->handleCapability(pin);
}
}
Firmata.write(127);
}
Firmata.write(END_SYSEX);
return true;
default:
for (byte i = 0; i < numFeatures; i++) {
if (features[i]->handleSysex(command, argc, argv)) {
return true;
}
}
break;
}
return false;
}
void FirmataExt::addFeature(FirmataFeature &capability)
{
if (numFeatures < MAX_FEATURES) {
features[numFeatures++] = &capability;
}
}
void FirmataExt::reset()
{
for (byte i = 0; i < numFeatures; i++) {
features[i]->reset();
}
}

44
libraries/FirmataWithDeviceFeature/src/FirmataExt.h Normal file
View File

@@ -0,0 +1,44 @@
/*
FirmataExt.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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 FirmataExt_h
#define FirmataExt_h
#include <ConfigurableFirmata.h>
#include "FirmataFeature.h"
#define MAX_FEATURES TOTAL_PIN_MODES + 1
void handleSetPinModeCallback(byte pin, int mode);
void handleSysexCallback(byte command, byte argc, byte* argv);
class FirmataExt: public FirmataFeature
{
public:
FirmataExt();
void handleCapability(byte pin); //empty method
boolean handlePinMode(byte pin, int mode);
boolean handleSysex(byte command, byte argc, byte* argv);
void addFeature(FirmataFeature &capability);
void reset();
private:
FirmataFeature *features[MAX_FEATURES];
byte numFeatures;
};
#endif

31
libraries/FirmataWithDeviceFeature/src/FirmataFeature.h Normal file
View File

@@ -0,0 +1,31 @@
/*
FirmataExt.h - Firmata library
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2010-2011 Paul Stoffregen. All rights reserved.
Copyright (C) 2009 Shigeru Kobayashi. All rights reserved.
Copyright (C) 2013 Norbert Truchsess. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. 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 FirmataFeature_h
#define FirmataFeature_h
#include <ConfigurableFirmata.h>
class FirmataFeature
{
public:
virtual void handleCapability(byte pin) = 0;
virtual boolean handlePinMode(byte pin, int mode) = 0;
virtual boolean handleSysex(byte command, byte argc, byte* argv) = 0;
virtual void reset() = 0;
};
#endif

610
libraries/FirmataWithDeviceFeature/src/utility/Boards.h Normal file
View File

@@ -0,0 +1,610 @@
/*
Boards.h - Hardware Abstraction Layer for Firmata library
Copyright (c) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (c) 2013 Norbert Truchsess. All rights reserved.
Copyright (c) 2013-2016 Jeff Hoefs. 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.
Last updated January 19th, 2015
*/
#ifndef Firmata_Boards_h
#define Firmata_Boards_h
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h" // for digitalRead, digitalWrite, etc
#else
#include "WProgram.h"
#endif
// Normally Servo.h must be included before Firmata.h (which then includes
// this file). If Servo.h wasn't included, this allows the code to still
// compile, but without support for any Servos. Hopefully that's what the
// user intended by not including Servo.h
#ifndef MAX_SERVOS
#define MAX_SERVOS 0
#endif
/*
Firmata Hardware Abstraction Layer
Firmata is built on top of the hardware abstraction functions of Arduino,
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,
only this file should require editing.
The key concept is every "pin" implemented by Firmata may be mapped to
any pin as implemented by Arduino. Usually a simple 1-to-1 mapping is
best, but such mapping should not be assumed. This hardware abstraction
layer allows Firmata to implement any number of pins which map onto the
Arduino implemented pins in almost any arbitrary way.
General Constants:
These constants provide basic information Firmata requires.
TOTAL_PINS: The total number of pins Firmata implemented by Firmata.
Usually this will match the number of pins the Arduino functions
implement, including any pins pins capable of analog or digital.
However, Firmata may implement any number of pins. For example,
on Arduino Mini with 8 analog inputs, 6 of these may be used
for digital functions, and 2 are analog only. On such boards,
Firmata can implement more pins than Arduino's pinMode()
function, in order to accommodate those special pins. The
Firmata protocol supports a maximum of 128 pins, so this
constant must not exceed 128.
TOTAL_ANALOG_PINS: The total number of analog input pins implemented.
The Firmata protocol allows up to 16 analog inputs, accessed
using offsets 0 to 15. Because Firmata presents the analog
inputs using different offsets than the actual pin numbers
(a legacy of Arduino's analogRead function, and the way the
analog input capable pins are physically labeled on all
Arduino boards), the total number of analog input signals
must be specified. 16 is the maximum.
VERSION_BLINK_PIN: When Firmata starts up, it will blink the version
number. This constant is the Arduino pin number where a
LED is connected.
Pin Mapping Macros:
These macros provide the mapping between pins as implemented by
Firmata protocol and the actual pin numbers used by the Arduino
functions. Even though such mappings are often simple, pin
numbers received by Firmata protocol should always be used as
input to these macros, and the result of the macro should be
used with any Arduino function.
When Firmata is extended to support a new pin mode or feature,
a pair of macros should be added and used for all hardware
access. For simple 1:1 mapping, these macros add no actual
overhead, yet their consistent use allows source code which
uses them consistently to be easily adapted to all other boards
with different requirements.
IS_PIN_XXXX(pin): The IS_PIN macros resolve to true or non-zero
if a pin as implemented by Firmata corresponds to a pin
that actually implements the named feature.
PIN_TO_XXXX(pin): The PIN_TO macros translate pin numbers as
implemented by Firmata to the pin numbers needed as inputs
to the Arduino functions. The corresponding IS_PIN macro
should always be tested before using a PIN_TO macro, so
these macros only need to handle valid Firmata pin
numbers for the named feature.
Port Access Inline Funtions:
For efficiency, Firmata protocol provides access to digital
input and output pins grouped by 8 bit ports. When these
groups of 8 correspond to actual 8 bit ports as implemented
by the hardware, these inline functions can provide high
speed direct port access. Otherwise, a default implementation
using 8 calls to digitalWrite or digitalRead is used.
When porting Firmata to a new board, it is recommended to
use the default functions first and focus only on the constants
and macros above. When those are working, if optimized port
access is desired, these inline functions may be extended.
The recommended approach defines a symbol indicating which
optimization to use, and then conditional complication is
used within these functions.
readPort(port, bitmask): Read an 8 bit port, returning the value.
port: The port number, Firmata pins port*8 to port*8+7
bitmask: The actual pins to read, indicated by 1 bits.
writePort(port, value, bitmask): Write an 8 bit port.
port: The port number, Firmata pins port*8 to port*8+7
value: The 8 bit value to write
bitmask: The actual pins to write, indicated by 1 bits.
*/
/*==============================================================================
* Board Specific Configuration
*============================================================================*/
#ifndef digitalPinHasPWM
#define digitalPinHasPWM(p) IS_PIN_DIGITAL(p)
#endif
#if defined(digitalPinToInterrupt) && defined(NOT_AN_INTERRUPT)
#define IS_PIN_INTERRUPT(p) (digitalPinToInterrupt(p) > NOT_AN_INTERRUPT)
#else
#define IS_PIN_INTERRUPT(p) (0)
#endif
// Arduino Duemilanove, Diecimila, and NG
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__)
#if defined(NUM_ANALOG_INPUTS) && NUM_ANALOG_INPUTS == 6
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 20 // 14 digital + 6 analog
#else
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS 22 // 14 digital + 8 analog
#endif
#define VERSION_BLINK_PIN 13
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#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) == 18 || (p) == 19)
#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)
#define ARDUINO_PINOUT_OPTIMIZE 1
// Wiring (and board)
#elif defined(WIRING)
#define VERSION_BLINK_PIN WLED
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= FIRST_ANALOG_PIN && (p) < (FIRST_ANALOG_PIN+TOTAL_ANALOG_PINS))
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < 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) - FIRST_ANALOG_PIN)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// old Arduinos
#elif defined(__AVR_ATmega8__)
#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) == 18 || (p) == 19)
#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)
#define ARDUINO_PINOUT_OPTIMIZE 1
// Arduino Mega
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define TOTAL_ANALOG_PINS 16
#define TOTAL_PINS 70 // 54 digital + 16 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 19
#define PIN_SERIAL1_TX 18
#define PIN_SERIAL2_RX 17
#define PIN_SERIAL2_TX 16
#define PIN_SERIAL3_RX 15
#define PIN_SERIAL3_TX 14
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 54 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 2 && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) > 13 && (p) < 20)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 54)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Arduino DUE
#elif defined(__SAM3X8E__)
#define TOTAL_ANALOG_PINS 12
#define TOTAL_PINS 66 // 54 digital + 12 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 19
#define PIN_SERIAL1_TX 18
#define PIN_SERIAL2_RX 17
#define PIN_SERIAL2_TX 16
#define PIN_SERIAL3_RX 15
#define PIN_SERIAL3_TX 14
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 54 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 2 && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21) // 70 71
#define IS_PIN_SERIAL(p) ((p) > 13 && (p) < 20)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 54)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Arduino/Genuino MKR1000
#elif defined(ARDUINO_SAMD_MKR1000)
#define TOTAL_ANALOG_PINS 7
#define TOTAL_PINS 22 // 8 digital + 3 spi + 2 i2c + 2 uart + 7 analog
#define IS_PIN_DIGITAL(p) (((p) >= 0 && (p) <= 21) && !IS_PIN_SERIAL(p))
#define IS_PIN_ANALOG(p) ((p) >= 15 && (p) < 15 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == 11 || (p) == 12) // SDA = 11, SCL = 12
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == PIN_SERIAL1_RX || (p) == PIN_SERIAL1_TX) //defined in variant.h RX = 13, TX = 14
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 15)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p) // deprecated since v2.4
// Arduino Zero
// Note this will work with an Arduino Zero Pro, but not with an Arduino M0 Pro
// Arduino M0 Pro does not properly map pins to the board labeled pin numbers
#elif defined(_VARIANT_ARDUINO_ZERO_)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 25 // 14 digital + 6 analog + 2 i2c + 3 spi
#define TOTAL_PORTS 3 // set when TOTAL_PINS > num digitial I/O pins
#define VERSION_BLINK_PIN LED_BUILTIN
//#define PIN_SERIAL1_RX 0 // already defined in zero core variant.h
//#define PIN_SERIAL1_TX 1 // already defined in zero core variant.h
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21) // SDA = 20, SCL = 21
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK) // SS = A2
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#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) // deprecated since v2.4
// Arduino 101
#elif defined(_VARIANT_ARDUINO_101_X_)
#define TOTAL_ANALOG_PINS NUM_ANALOG_INPUTS
#define TOTAL_PINS NUM_DIGITAL_PINS // 15 digital (including ATN pin) + 6 analog
#define VERSION_BLINK_PIN LED_BUILTIN
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 20)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p) // 3, 5, 6, 9
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL) // SDA = 18, SCL = 19
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#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) // deprecated since v2.4
// Teensy 1.0
#elif defined(__AVR_AT90USB162__)
#define TOTAL_ANALOG_PINS 0
#define TOTAL_PINS 21 // 21 digital + no analog
#define VERSION_BLINK_PIN 6
#define PIN_SERIAL1_RX 2
#define PIN_SERIAL1_TX 3
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) (0)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) (0)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 2 || (p) == 3)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (0)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Teensy 2.0
#elif defined(__AVR_ATmega32U4__) && defined(CORE_TEENSY)
#define TOTAL_ANALOG_PINS 12
#define TOTAL_PINS 25 // 11 digital + 12 analog
#define VERSION_BLINK_PIN 11
#define PIN_SERIAL1_RX 7
#define PIN_SERIAL1_TX 8
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 11 && (p) <= 22)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 5 || (p) == 6)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 7 || (p) == 8)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (((p) < 22) ? 21 - (p) : 11)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Teensy 3.0, 3.1 and 3.2
#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
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define PIN_SERIAL2_RX 9
#define PIN_SERIAL2_TX 10
#define PIN_SERIAL3_RX 7
#define PIN_SERIAL3_TX 8
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 33)
#define IS_PIN_ANALOG(p) (((p) >= 14 && (p) <= 23) || ((p) >= 34 && (p) <= 38))
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 18 || (p) == 19)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) (((p) > 6 && (p) < 11) || ((p) == 0 || (p) == 1))
#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)
// Teensy-LC
#elif defined(__MKL26Z64__)
#define TOTAL_ANALOG_PINS 13
#define TOTAL_PINS 27 // 27 digital + 13 analog-digital
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define PIN_SERIAL2_RX 9
#define PIN_SERIAL2_TX 10
#define PIN_SERIAL3_RX 7
#define PIN_SERIAL3_TX 8
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 26)
#define IS_PIN_ANALOG(p) ((p) >= 14)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 18 || (p) == 19)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) (((p) > 6 && (p) < 11) || ((p) == 0 || (p) == 1))
#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)
// Teensy++ 1.0 and 2.0
#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS 46 // 38 digital + 8 analog
#define VERSION_BLINK_PIN 6
#define PIN_SERIAL1_RX 2
#define PIN_SERIAL1_TX 3
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 38 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 0 || (p) == 1)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 2 || (p) == 3)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 38)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Leonardo
#elif defined(__AVR_ATmega32U4__)
#define TOTAL_ANALOG_PINS 12
#define TOTAL_PINS 30 // 14 digital + 12 analog + 4 SPI (D14-D17 on ISP header)
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 18 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) ((p) == 3 || (p) == 5 || (p) == 6 || (p) == 9 || (p) == 10 || (p) == 11 || (p) == 13)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 2 || (p) == 3)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#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)
// Intel Galileo Board (gen 1 and 2) and Intel Edison
#elif defined(ARDUINO_LINUX)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 20 // 14 digital + 6 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#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 IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#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)
// Pinoccio Scout
// Note: digital pins 9-16 are usable but not labeled on the board numerically.
// SS=9, MOSI=10, MISO=11, SCK=12, RX1=13, TX1=14, SCL=15, SDA=16
#elif defined(ARDUINO_PINOCCIO)
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS NUM_DIGITAL_PINS // 32
#define VERSION_BLINK_PIN 23
#define PIN_SERIAL1_RX 13
#define PIN_SERIAL1_TX 14
#define IS_PIN_DIGITAL(p) (((p) >= 2) && ((p) <= 16)) || (((p) >= 24) && ((p) <= 31))
#define IS_PIN_ANALOG(p) ((p) >= 24 && (p) <= 31)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == SCL || (p) == SDA)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 13 || (p) == 14)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 24)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Sanguino
#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS 32 // 24 digital + 8 analog
#define VERSION_BLINK_PIN 0
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 24 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 16 || (p) == 17)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 24)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Illuminato
#elif defined(__AVR_ATmega645__)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 42 // 36 digital + 6 analog
#define VERSION_BLINK_PIN 13
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 36 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 4 || (p) == 5)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 36)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// anything else
#else
#error "Please edit Boards.h with a hardware abstraction for this board"
#endif
// as long this is not defined for all boards:
#ifndef IS_PIN_SPI
#define IS_PIN_SPI(p) (0)
#endif
#ifndef IS_PIN_SERIAL
#define IS_PIN_SERIAL(p) 0
#endif
/*==============================================================================
* readPort() - Read an 8 bit port
*============================================================================*/
static inline unsigned char readPort(byte, byte) __attribute__((always_inline, unused));
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;
#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;
#endif
}
/*==============================================================================
* writePort() - Write an 8 bit port, only touch pins specified by a bitmask
*============================================================================*/
static inline unsigned char writePort(byte, byte, byte) __attribute__((always_inline, unused));
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();
}
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));
return 1;
#endif
}
#ifndef TOTAL_PORTS
#define TOTAL_PORTS ((TOTAL_PINS + 7) / 8)
#endif
#endif /* Firmata_Boards_h */

136
libraries/FirmataWithDeviceFeature/test/firmata_test/firmata_test.ino Normal file
View File

@@ -0,0 +1,136 @@
/*
* To run this test suite, you must first install the ArduinoUnit library
* to your Arduino/libraries/ directory.
* You can get ArduinoUnit here: https://github.com/mmurdoch/arduinounit
* Download version 2.0 or greater.
*/
#include <ArduinoUnit.h>
#include <ConfigurableFirmata.h>
void setup()
{
Serial.begin(9600);
}
void loop()
{
Test::run();
}
test(beginPrintsVersion)
{
FakeStream stream;
Firmata.begin(stream);
char expected[] = {
REPORT_VERSION,
FIRMATA_MAJOR_VERSION,
FIRMATA_MINOR_VERSION,
0
};
assertEqual(expected, stream.bytesWritten());
}
void processMessage(const byte *message, size_t length)
{
FakeStream stream;
Firmata.begin(stream);
for (size_t i = 0; i < length; i++) {
stream.nextByte(message[i]);
Firmata.processInput();
}
}
byte _digitalPort;
int _digitalPortValue;
void writeToDigitalPort(byte port, int value)
{
_digitalPort = port;
_digitalPortValue = value;
}
void setupDigitalPort()
{
_digitalPort = 0;
_digitalPortValue = 0;
}
test(processWriteDigital_0)
{
setupDigitalPort();
Firmata.attach(DIGITAL_MESSAGE, writeToDigitalPort);
byte message[] = { DIGITAL_MESSAGE, 0, 0 };
processMessage(message, 3);
assertEqual(0, _digitalPortValue);
}
test(processWriteDigital_127)
{
setupDigitalPort();
Firmata.attach(DIGITAL_MESSAGE, writeToDigitalPort);
byte message[] = { DIGITAL_MESSAGE, 127, 0 };
processMessage(message, 3);
assertEqual(127, _digitalPortValue);
}
test(processWriteDigital_128)
{
setupDigitalPort();
Firmata.attach(DIGITAL_MESSAGE, writeToDigitalPort);
byte message[] = { DIGITAL_MESSAGE, 0, 1 };
processMessage(message, 3);
assertEqual(128, _digitalPortValue);
}
test(processWriteLargestDigitalValue)
{
setupDigitalPort();
Firmata.attach(DIGITAL_MESSAGE, writeToDigitalPort);
byte message[] = { DIGITAL_MESSAGE, 0x7F, 0x7F };
processMessage(message, 3);
// Maximum of 14 bits can be set (B0011111111111111)
assertEqual(0x3FFF, _digitalPortValue);
}
test(defaultDigitalWritePortIsZero)
{
setupDigitalPort();
Firmata.attach(DIGITAL_MESSAGE, writeToDigitalPort);
byte message[] = { DIGITAL_MESSAGE, 0, 0 };
processMessage(message, 3);
assertEqual(0, _digitalPort);
}
test(specifiedDigitalWritePort)
{
setupDigitalPort();
Firmata.attach(DIGITAL_MESSAGE, writeToDigitalPort);
byte message[] = { DIGITAL_MESSAGE + 1, 0, 0 };
processMessage(message, 3);
assertEqual(1, _digitalPort);
}
test(setFirmwareVersionDoesNotLeakMemory)
{
Firmata.setFirmwareVersion(1, 0);
int initialMemory = freeMemory();
Firmata.setFirmwareVersion(1, 0);
assertEqual(0, initialMemory - freeMemory());
}

13
libraries/FirmataWithDeviceFeature/test/readme.md Normal file
View File

@@ -0,0 +1,13 @@
#Testing Firmata
Tests tests are written using the [ArduinoUnit](https://github.com/mmurdoch/arduinounit) library (version 2.0).
Follow the instructions in the [ArduinoUnit readme](https://github.com/mmurdoch/arduinounit/blob/master/readme.md) to install the library.
Compile and upload the test sketch as you would any other sketch. Then open the
Serial Monitor to view the test results.
If you make changes to Firmata.cpp, run the tests in /test/ to ensure
that your changes have not produced any unexpected errors.
You should also perform manual tests against actual hardware.