Merge branch 'ide-1.5.x-library-to-new-format' into ide-1.5.x
This commit is contained in:
commit
a8193ed933
|
@ -1,50 +0,0 @@
|
||||||
/*
|
|
||||||
EEPROM.cpp - EEPROM library
|
|
||||||
Copyright (c) 2006 David A. Mellis. All right reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
*/
|
|
||||||
|
|
||||||
/******************************************************************************
|
|
||||||
* Includes
|
|
||||||
******************************************************************************/
|
|
||||||
|
|
||||||
#include <avr/eeprom.h>
|
|
||||||
#include "Arduino.h"
|
|
||||||
#include "EEPROM.h"
|
|
||||||
|
|
||||||
/******************************************************************************
|
|
||||||
* Definitions
|
|
||||||
******************************************************************************/
|
|
||||||
|
|
||||||
/******************************************************************************
|
|
||||||
* Constructors
|
|
||||||
******************************************************************************/
|
|
||||||
|
|
||||||
/******************************************************************************
|
|
||||||
* User API
|
|
||||||
******************************************************************************/
|
|
||||||
|
|
||||||
uint8_t EEPROMClass::read(int address)
|
|
||||||
{
|
|
||||||
return eeprom_read_byte((unsigned char *) address);
|
|
||||||
}
|
|
||||||
|
|
||||||
void EEPROMClass::write(int address, uint8_t value)
|
|
||||||
{
|
|
||||||
eeprom_write_byte((unsigned char *) address, value);
|
|
||||||
}
|
|
||||||
|
|
||||||
EEPROMClass EEPROM;
|
|
|
@ -1,35 +0,0 @@
|
||||||
/*
|
|
||||||
EEPROM.h - EEPROM library
|
|
||||||
Copyright (c) 2006 David A. Mellis. All right reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef EEPROM_h
|
|
||||||
#define EEPROM_h
|
|
||||||
|
|
||||||
#include <inttypes.h>
|
|
||||||
|
|
||||||
class EEPROMClass
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
uint8_t read(int);
|
|
||||||
void write(int, uint8_t);
|
|
||||||
};
|
|
||||||
|
|
||||||
extern EEPROMClass EEPROM;
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
|
@ -1,23 +0,0 @@
|
||||||
/*
|
|
||||||
* EEPROM Clear
|
|
||||||
*
|
|
||||||
* Sets all of the bytes of the EEPROM to 0.
|
|
||||||
* This example code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <EEPROM.h>
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
// write a 0 to all 512 bytes of the EEPROM
|
|
||||||
for (int i = 0; i < 512; i++)
|
|
||||||
EEPROM.write(i, 0);
|
|
||||||
|
|
||||||
// turn the LED on when we're done
|
|
||||||
digitalWrite(13, HIGH);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
}
|
|
|
@ -1,43 +0,0 @@
|
||||||
/*
|
|
||||||
* EEPROM Read
|
|
||||||
*
|
|
||||||
* Reads the value of each byte of the EEPROM and prints it
|
|
||||||
* to the computer.
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <EEPROM.h>
|
|
||||||
|
|
||||||
// start reading from the first byte (address 0) of the EEPROM
|
|
||||||
int address = 0;
|
|
||||||
byte value;
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
// initialize serial and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
// read a byte from the current address of the EEPROM
|
|
||||||
value = EEPROM.read(address);
|
|
||||||
|
|
||||||
Serial.print(address);
|
|
||||||
Serial.print("\t");
|
|
||||||
Serial.print(value, DEC);
|
|
||||||
Serial.println();
|
|
||||||
|
|
||||||
// advance to the next address of the EEPROM
|
|
||||||
address = address + 1;
|
|
||||||
|
|
||||||
// there are only 512 bytes of EEPROM, from 0 to 511, so if we're
|
|
||||||
// on address 512, wrap around to address 0
|
|
||||||
if (address == 512)
|
|
||||||
address = 0;
|
|
||||||
|
|
||||||
delay(500);
|
|
||||||
}
|
|
|
@ -1,38 +0,0 @@
|
||||||
/*
|
|
||||||
* EEPROM Write
|
|
||||||
*
|
|
||||||
* Stores values read from analog input 0 into the EEPROM.
|
|
||||||
* These values will stay in the EEPROM when the board is
|
|
||||||
* turned off and may be retrieved later by another sketch.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <EEPROM.h>
|
|
||||||
|
|
||||||
// the current address in the EEPROM (i.e. which byte
|
|
||||||
// we're going to write to next)
|
|
||||||
int addr = 0;
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
// need to divide by 4 because analog inputs range from
|
|
||||||
// 0 to 1023 and each byte of the EEPROM can only hold a
|
|
||||||
// value from 0 to 255.
|
|
||||||
int val = analogRead(0) / 4;
|
|
||||||
|
|
||||||
// write the value to the appropriate byte of the EEPROM.
|
|
||||||
// these values will remain there when the board is
|
|
||||||
// turned off.
|
|
||||||
EEPROM.write(addr, val);
|
|
||||||
|
|
||||||
// advance to the next address. there are 512 bytes in
|
|
||||||
// the EEPROM, so go back to 0 when we hit 512.
|
|
||||||
addr = addr + 1;
|
|
||||||
if (addr == 512)
|
|
||||||
addr = 0;
|
|
||||||
|
|
||||||
delay(100);
|
|
||||||
}
|
|
|
@ -1,18 +0,0 @@
|
||||||
#######################################
|
|
||||||
# Syntax Coloring Map For Ultrasound
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Datatypes (KEYWORD1)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
EEPROM KEYWORD1
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Methods and Functions (KEYWORD2)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Constants (LITERAL1)
|
|
||||||
#######################################
|
|
||||||
|
|
|
@ -1,38 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Accelerometer
|
|
||||||
|
|
||||||
This sketch shows you how to read the values from the accelerometer.
|
|
||||||
To see it in action, open the serial monitor and tilt the board. You'll see
|
|
||||||
the accelerometer values for each axis change when you tilt the board
|
|
||||||
on that axis.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Serial.begin(9600); // initialize serial communications with your computer
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
int xAxis = Esplora.readAccelerometer(X_AXIS); // read the X axis
|
|
||||||
int yAxis = Esplora.readAccelerometer(Y_AXIS); // read the Y axis
|
|
||||||
int zAxis = Esplora.readAccelerometer(Z_AXIS); // read the Z axis
|
|
||||||
|
|
||||||
Serial.print("x: "); // print the label for X
|
|
||||||
Serial.print(xAxis); // print the value for the X axis
|
|
||||||
Serial.print("\ty: "); // print a tab character, then the label for Y
|
|
||||||
Serial.print(yAxis); // print the value for the Y axis
|
|
||||||
Serial.print("\tz: "); // print a tab character, then the label for Z
|
|
||||||
Serial.println(zAxis); // print the value for the Z axis
|
|
||||||
|
|
||||||
delay(500); // wait half a second (500 milliseconds)
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,42 +0,0 @@
|
||||||
|
|
||||||
/*
|
|
||||||
Esplora Blink
|
|
||||||
|
|
||||||
This sketch blinks the Esplora's RGB LED. It goes through
|
|
||||||
all three primary colors (red, green, blue), then it
|
|
||||||
combines them for secondary colors(yellow, cyan, magenta), then
|
|
||||||
it turns on all the colors for white.
|
|
||||||
For best results cover the LED with a piece of white paper to see the colors.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// There's nothing to set up for this sketch
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
Esplora.writeRGB(255,0,0); // make the LED red
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
Esplora.writeRGB(0,255,0); // make the LED green
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
Esplora.writeRGB(0,0,255); // make the LED blue
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
Esplora.writeRGB(255,255,0); // make the LED yellow
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
Esplora.writeRGB(0,255,255); // make the LED cyan
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
Esplora.writeRGB(255,0,255); // make the LED magenta
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
Esplora.writeRGB(255,255,255);// make the LED white
|
|
||||||
delay(1000); // wait 1 second
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,50 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Joystick Mouse
|
|
||||||
|
|
||||||
This sketch shows you how to read the joystick and use it to control the movement
|
|
||||||
of the cursor on your computer. You're making your Esplora into a mouse!
|
|
||||||
|
|
||||||
WARNING: this sketch will take over your mouse movement. If you lose control
|
|
||||||
of your mouse do the following:
|
|
||||||
1) unplug the Esplora.
|
|
||||||
2) open the EsploraBlink sketch
|
|
||||||
3) hold the reset button down while plugging your Esplora back in
|
|
||||||
4) while holding reset, click "Upload"
|
|
||||||
5) when you see the message "Done compiling", release the reset button.
|
|
||||||
|
|
||||||
This will stop your Esplora from controlling your mouse while you upload a sketch
|
|
||||||
that doesn't take control of the mouse.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Serial.begin(9600); // initialize serial communication with your computer
|
|
||||||
Mouse.begin(); // take control of the mouse
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
int xValue = Esplora.readJoystickX(); // read the joystick's X position
|
|
||||||
int yValue = Esplora.readJoystickY(); // read the joystick's Y position
|
|
||||||
int button = Esplora.readJoystickSwitch(); // read the joystick pushbutton
|
|
||||||
Serial.print("Joystick X: "); // print a label for the X value
|
|
||||||
Serial.print(xValue); // print the X value
|
|
||||||
Serial.print("\tY: "); // print a tab character and a label for the Y value
|
|
||||||
Serial.print(yValue); // print the Y value
|
|
||||||
Serial.print("\tButton: "); // print a tab character and a label for the button
|
|
||||||
Serial.print(button); // print the button value
|
|
||||||
|
|
||||||
int mouseX = map( xValue,-512, 512, 10, -10); // map the X value to a range of movement for the mouse X
|
|
||||||
int mouseY = map( yValue,-512, 512, -10, 10); // map the Y value to a range of movement for the mouse Y
|
|
||||||
Mouse.move(mouseX, mouseY, 0); // move the mouse
|
|
||||||
|
|
||||||
delay(10); // a short delay before moving again
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,42 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora LED Show
|
|
||||||
|
|
||||||
Makes the RGB LED bright and glow as the joystick or the
|
|
||||||
slider are moved.
|
|
||||||
|
|
||||||
Created on 22 november 2012
|
|
||||||
By Enrico Gueli <enrico.gueli@gmail.com>
|
|
||||||
Modified 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
*/
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// initialize the serial communication:
|
|
||||||
Serial.begin(9600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the sensors into variables:
|
|
||||||
int xAxis = Esplora.readJoystickX();
|
|
||||||
int yAxis = Esplora.readJoystickY();
|
|
||||||
int slider = Esplora.readSlider();
|
|
||||||
|
|
||||||
// convert the sensor readings to light levels:
|
|
||||||
byte red = map(xAxis, -512, 512, 0, 255);
|
|
||||||
byte green = map(yAxis, -512, 512, 0, 255);
|
|
||||||
byte blue = slider/4;
|
|
||||||
|
|
||||||
// print the light levels:
|
|
||||||
Serial.print(red);
|
|
||||||
Serial.print(' ');
|
|
||||||
Serial.print(green);
|
|
||||||
Serial.print(' ');
|
|
||||||
Serial.println(blue);
|
|
||||||
|
|
||||||
// write the light levels to the LED.
|
|
||||||
Esplora.writeRGB(red, green, blue);
|
|
||||||
|
|
||||||
// add a delay to keep the LED from flickering:
|
|
||||||
delay(10);
|
|
||||||
}
|
|
|
@ -1,55 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Led/Microphone
|
|
||||||
|
|
||||||
This simple sketch reads the microphone, light sensor, and slider.
|
|
||||||
Then it uses those readings to set the brightness of red, green and blue
|
|
||||||
channels of the RGB LED. The red channel will change with the loudness
|
|
||||||
"heared" by the microphone, the green channel changes as the
|
|
||||||
amount of light in the room and the blue channel will change
|
|
||||||
with the position of the slider.
|
|
||||||
|
|
||||||
Created on 22 november 2012
|
|
||||||
By Enrico Gueli <enrico.gueli@gmail.com>
|
|
||||||
Modified 24 Nov 2012
|
|
||||||
by Tom Igoe
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// initialize the serial communication:
|
|
||||||
Serial.begin(9600);
|
|
||||||
}
|
|
||||||
|
|
||||||
int lowLight = 400; // the light sensor reading when it's covered
|
|
||||||
int highLight = 1023; // the maximum light sensor reading
|
|
||||||
int minGreen = 0; // minimum brightness of the green LED
|
|
||||||
int maxGreen = 100; // maximum brightness of the green LED
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the sensors into variables:
|
|
||||||
int mic = Esplora.readMicrophone();
|
|
||||||
int light = Esplora.readLightSensor();
|
|
||||||
int slider = Esplora.readSlider();
|
|
||||||
|
|
||||||
// convert the sensor readings to light levels:
|
|
||||||
byte red = constrain(mic, 0, 255);
|
|
||||||
byte green = constrain(
|
|
||||||
map(light, lowLight, highLight, minGreen, maxGreen),
|
|
||||||
0, 255);
|
|
||||||
byte blue = slider/4;
|
|
||||||
|
|
||||||
// print the light levels (to see what's going on):
|
|
||||||
Serial.print(red);
|
|
||||||
Serial.print(' ');
|
|
||||||
Serial.print(green);
|
|
||||||
Serial.print(' ');
|
|
||||||
Serial.println(blue);
|
|
||||||
|
|
||||||
// write the light levels to the LED.
|
|
||||||
// note that the green value is always 0:
|
|
||||||
Esplora.writeRGB(red, green, blue);
|
|
||||||
|
|
||||||
// add a delay to keep the LED from flickering:
|
|
||||||
delay(10);
|
|
||||||
}
|
|
|
@ -1,91 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Led calibration
|
|
||||||
|
|
||||||
This sketch shows you how to read and calibrate the light sensor.
|
|
||||||
Because light levels vary from one location to another, you need to calibrate the
|
|
||||||
sensor for each location. To do this, you read the sensor for a few seconds,
|
|
||||||
and save the highest and lowest readings as maximum and minimum.
|
|
||||||
Then, when you're using the sensor's reading (for example, to set the brightness
|
|
||||||
of the LED), you map the sensor's reading to a range between the minimum
|
|
||||||
and the maximum.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
// variables:
|
|
||||||
int lightMin = 1023; // minimum sensor value
|
|
||||||
int lightMax = 0; // maximum sensor value
|
|
||||||
boolean calibrated = false; // whether the sensor's been calibrated yet
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// initialize the serial communication:
|
|
||||||
Serial.begin(9600);
|
|
||||||
|
|
||||||
// print an intial message
|
|
||||||
Serial.println("To calibrate the light sensor, press and hold Switch 1");
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// if switch 1 is pressed, go to the calibration function again:
|
|
||||||
if (Esplora.readButton(1) == LOW) {
|
|
||||||
calibrate();
|
|
||||||
}
|
|
||||||
// read the sensor into a variable:
|
|
||||||
int light = Esplora.readLightSensor();
|
|
||||||
|
|
||||||
// map the light level to a brightness level for the LED
|
|
||||||
// using the calibration min and max:
|
|
||||||
int brightness = map(light, lightMin, lightMax, 0, 255);
|
|
||||||
// limit the brightness to a range from 0 to 255:
|
|
||||||
brightness = constrain(brightness, 0, 255);
|
|
||||||
// write the brightness to the blue LED.
|
|
||||||
Esplora.writeBlue(brightness);
|
|
||||||
|
|
||||||
// if the calibration's been done, show the sensor and brightness
|
|
||||||
// levels in the serial monitor:
|
|
||||||
if (calibrated == true) {
|
|
||||||
// print the light sensor levels and the LED levels (to see what's going on):
|
|
||||||
Serial.print("light sensor level: ");
|
|
||||||
Serial.print(light);
|
|
||||||
Serial.print(" blue brightness: ");
|
|
||||||
Serial.println(brightness);
|
|
||||||
}
|
|
||||||
// add a delay to keep the LED from flickering:
|
|
||||||
delay(10);
|
|
||||||
}
|
|
||||||
|
|
||||||
void calibrate() {
|
|
||||||
// tell the user what do to using the serial monitor:
|
|
||||||
Serial.println("While holding switch 1, shine a light on the light sensor, then cover it.");
|
|
||||||
|
|
||||||
// calibrate while switch 1 is pressed:
|
|
||||||
while(Esplora.readButton(1) == LOW) {
|
|
||||||
// read the sensor value:
|
|
||||||
int light = Esplora.readLightSensor();
|
|
||||||
|
|
||||||
// record the maximum sensor value:
|
|
||||||
if (light > lightMax) {
|
|
||||||
lightMax = light;
|
|
||||||
}
|
|
||||||
|
|
||||||
// record the minimum sensor value:
|
|
||||||
if (light < lightMin) {
|
|
||||||
lightMin = light;
|
|
||||||
}
|
|
||||||
// note that you're calibrated, for future reference:
|
|
||||||
calibrated = true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,53 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Music
|
|
||||||
|
|
||||||
This sketch turns the Esplora in a simple musical instrument.
|
|
||||||
Press the Switch 1 and move the slider to see how it works.
|
|
||||||
|
|
||||||
Created on 22 november 2012
|
|
||||||
By Enrico Gueli <enrico.gueli@gmail.com>
|
|
||||||
modified 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
// these are the frequencies for the notes from middle C
|
|
||||||
// to one octave above middle C:
|
|
||||||
const int note[] = {
|
|
||||||
262, // C
|
|
||||||
277, // C#
|
|
||||||
294, // D
|
|
||||||
311, // D#
|
|
||||||
330, // E
|
|
||||||
349, // F
|
|
||||||
370, // F#
|
|
||||||
392, // G
|
|
||||||
415, // G#
|
|
||||||
440, // A
|
|
||||||
466, // A#
|
|
||||||
494, // B
|
|
||||||
523 // C next octave
|
|
||||||
};
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the button labeled SWITCH_DOWN. If it's low,
|
|
||||||
// then play a note:
|
|
||||||
if (Esplora.readButton(SWITCH_DOWN) == LOW) {
|
|
||||||
int slider = Esplora.readSlider();
|
|
||||||
|
|
||||||
// use map() to map the slider's range to the
|
|
||||||
// range of notes you have:
|
|
||||||
byte thisNote = map(slider, 0, 1023, 0, 13);
|
|
||||||
// play the note corresponding to the slider's position:
|
|
||||||
Esplora.tone(note[thisNote]);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if the button isn't pressed, turn the note off:
|
|
||||||
Esplora.noTone();
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,41 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Sound Sensor
|
|
||||||
|
|
||||||
This sketch shows you how to read the microphone sensor. The microphone
|
|
||||||
will range from 0 (total silence) to 1023 (really loud).
|
|
||||||
When you're using the sensor's reading (for example, to set the brightness
|
|
||||||
of the LED), you map the sensor's reading to a range between the minimum
|
|
||||||
and the maximum.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// initialize the serial communication:
|
|
||||||
Serial.begin(9600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the sensor into a variable:
|
|
||||||
int loudness = Esplora.readMicrophone();
|
|
||||||
|
|
||||||
// map the sound level to a brightness level for the LED:
|
|
||||||
int brightness = map(loudness, 0, 1023, 0, 255);
|
|
||||||
// write the brightness to the green LED:
|
|
||||||
Esplora.writeGreen(brightness);
|
|
||||||
|
|
||||||
|
|
||||||
// print the microphone levels and the LED levels (to see what's going on):
|
|
||||||
Serial.print("sound level: ");
|
|
||||||
Serial.print(loudness);
|
|
||||||
Serial.print(" Green brightness: ");
|
|
||||||
Serial.println(brightness);
|
|
||||||
// add a delay to keep the LED from flickering:
|
|
||||||
delay(10);
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,37 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Temperature Sensor
|
|
||||||
|
|
||||||
This sketch shows you how to read the Esplora's temperature sensor
|
|
||||||
You can read the temperature sensor in Farhenheit or Celsius.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Serial.begin(9600); // initialize serial communications with your computer
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
// read the temperature sensor in Celsius, then Fahrenheit:
|
|
||||||
int celsius = Esplora.readTemperature(DEGREES_C);
|
|
||||||
int fahrenheit = Esplora.readTemperature(DEGREES_F);
|
|
||||||
|
|
||||||
// print the results:
|
|
||||||
Serial.print("Temperature is: ");
|
|
||||||
Serial.print(celsius);
|
|
||||||
Serial.print(" degrees Celsius, or ");
|
|
||||||
Serial.print(fahrenheit);
|
|
||||||
Serial.println(" degrees Fahrenheit.");
|
|
||||||
Serial.println(" Fahrenheit = (9/5 * Celsius) + 32");
|
|
||||||
|
|
||||||
// wait a second before reading again:
|
|
||||||
delay(1000);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,184 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora.cpp - Arduino Esplora board library
|
|
||||||
Written by Enrico Gueli
|
|
||||||
Copyright (c) 2012 Arduino(TM) All right reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#include "Esplora.h"
|
|
||||||
|
|
||||||
_Esplora Esplora;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The following constants tell, for each accelerometer
|
|
||||||
* axis, which values are returned when the axis measures
|
|
||||||
* zero acceleration.
|
|
||||||
*/
|
|
||||||
const int ACCEL_ZERO_X = 320;
|
|
||||||
const int ACCEL_ZERO_Y = 330;
|
|
||||||
const int ACCEL_ZERO_Z = 310;
|
|
||||||
|
|
||||||
const byte MUX_ADDR_PINS[] = { A0, A1, A2, A3 };
|
|
||||||
const byte MUX_COM_PIN = A4;
|
|
||||||
|
|
||||||
const int JOYSTICK_DEAD_ZONE = 100;
|
|
||||||
|
|
||||||
const byte RED_PIN = 5;
|
|
||||||
const byte BLUE_PIN = 9;
|
|
||||||
const byte GREEN_PIN = 10;
|
|
||||||
|
|
||||||
const byte BUZZER_PIN = 6;
|
|
||||||
|
|
||||||
// non-multiplexer Esplora pins:
|
|
||||||
// Accelerometer: x-A5, y-A7, z-A6
|
|
||||||
// External outputs: D3, D11
|
|
||||||
// Buzzer: A8
|
|
||||||
// RGB Led: red-D5, green-D10/A11, blue-D9/A10
|
|
||||||
// Led 13: D13
|
|
||||||
|
|
||||||
const byte ACCEL_X_PIN = A5;
|
|
||||||
const byte ACCEL_Y_PIN = A11;
|
|
||||||
const byte ACCEL_Z_PIN = A6;
|
|
||||||
|
|
||||||
const byte LED_PIN = 13;
|
|
||||||
|
|
||||||
_Esplora::_Esplora() {
|
|
||||||
for (byte p=0; p<4; p++) {
|
|
||||||
pinMode(MUX_ADDR_PINS[p], OUTPUT);
|
|
||||||
}
|
|
||||||
pinMode(RED_PIN, OUTPUT);
|
|
||||||
pinMode(GREEN_PIN, OUTPUT);
|
|
||||||
pinMode(BLUE_PIN, OUTPUT);
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int _Esplora::readChannel(byte channel) {
|
|
||||||
digitalWrite(MUX_ADDR_PINS[0], (channel & 1) ? HIGH : LOW);
|
|
||||||
digitalWrite(MUX_ADDR_PINS[1], (channel & 2) ? HIGH : LOW);
|
|
||||||
digitalWrite(MUX_ADDR_PINS[2], (channel & 4) ? HIGH : LOW);
|
|
||||||
digitalWrite(MUX_ADDR_PINS[3], (channel & 8) ? HIGH : LOW);
|
|
||||||
// workaround to cope with lack of pullup resistor on joystick switch
|
|
||||||
if (channel == CH_JOYSTICK_SW) {
|
|
||||||
pinMode(MUX_COM_PIN, INPUT_PULLUP);
|
|
||||||
unsigned int joystickSwitchState = (digitalRead(MUX_COM_PIN) == HIGH) ? 1023 : 0;
|
|
||||||
digitalWrite(MUX_COM_PIN, LOW);
|
|
||||||
return joystickSwitchState;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return analogRead(MUX_COM_PIN);
|
|
||||||
}
|
|
||||||
|
|
||||||
boolean _Esplora::joyLowHalf(byte joyCh) {
|
|
||||||
return (readChannel(joyCh) < 512 - JOYSTICK_DEAD_ZONE)
|
|
||||||
? LOW : HIGH;
|
|
||||||
}
|
|
||||||
|
|
||||||
boolean _Esplora::joyHighHalf(byte joyCh) {
|
|
||||||
return (readChannel(joyCh) > 512 + JOYSTICK_DEAD_ZONE)
|
|
||||||
? LOW : HIGH;
|
|
||||||
}
|
|
||||||
|
|
||||||
boolean _Esplora::readButton(byte ch) {
|
|
||||||
if (ch >= SWITCH_1 && ch <= SWITCH_4) {
|
|
||||||
ch--;
|
|
||||||
}
|
|
||||||
|
|
||||||
switch(ch) {
|
|
||||||
case JOYSTICK_RIGHT:
|
|
||||||
return joyLowHalf(CH_JOYSTICK_X);
|
|
||||||
case JOYSTICK_LEFT:
|
|
||||||
return joyHighHalf(CH_JOYSTICK_X);
|
|
||||||
case JOYSTICK_UP:
|
|
||||||
return joyLowHalf(CH_JOYSTICK_Y);
|
|
||||||
case JOYSTICK_DOWN:
|
|
||||||
return joyHighHalf(CH_JOYSTICK_Y);
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int val = readChannel(ch);
|
|
||||||
return (val > 512) ? HIGH : LOW;
|
|
||||||
}
|
|
||||||
|
|
||||||
boolean _Esplora::readJoystickButton() {
|
|
||||||
if (readChannel(CH_JOYSTICK_SW) == 1023) {
|
|
||||||
return HIGH;
|
|
||||||
} else if (readChannel(CH_JOYSTICK_SW) == 0) {
|
|
||||||
return LOW;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void _Esplora::writeRGB(byte r, byte g, byte b) {
|
|
||||||
writeRed(r);
|
|
||||||
writeGreen(g);
|
|
||||||
writeBlue(b);
|
|
||||||
}
|
|
||||||
|
|
||||||
#define RGB_FUNC(name, pin, lastVar) \
|
|
||||||
void _Esplora::write##name(byte val) { \
|
|
||||||
if (val == lastVar) \
|
|
||||||
return; \
|
|
||||||
analogWrite(pin, val); \
|
|
||||||
lastVar = val; \
|
|
||||||
delay(5); \
|
|
||||||
} \
|
|
||||||
\
|
|
||||||
byte _Esplora::read##name() { \
|
|
||||||
return lastVar; \
|
|
||||||
}
|
|
||||||
|
|
||||||
RGB_FUNC(Red, RED_PIN, lastRed)
|
|
||||||
RGB_FUNC(Green, GREEN_PIN, lastGreen)
|
|
||||||
RGB_FUNC(Blue, BLUE_PIN, lastBlue)
|
|
||||||
|
|
||||||
void _Esplora::tone(unsigned int freq) {
|
|
||||||
if (freq > 0)
|
|
||||||
::tone(BUZZER_PIN, freq);
|
|
||||||
else
|
|
||||||
::noTone(BUZZER_PIN);
|
|
||||||
}
|
|
||||||
|
|
||||||
void _Esplora::tone(unsigned int freq, unsigned long duration) {
|
|
||||||
if (freq > 0)
|
|
||||||
::tone(BUZZER_PIN, freq, duration);
|
|
||||||
else
|
|
||||||
::noTone(BUZZER_PIN);
|
|
||||||
}
|
|
||||||
|
|
||||||
void _Esplora::noTone() {
|
|
||||||
::noTone(BUZZER_PIN);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _Esplora::readTemperature(const byte scale) {
|
|
||||||
long rawT = readChannel(CH_TEMPERATURE);
|
|
||||||
if (scale == DEGREES_C) {
|
|
||||||
return (int)((rawT * 500 / 1024) - 50);
|
|
||||||
}
|
|
||||||
else if (scale == DEGREES_F) {
|
|
||||||
return (int)((rawT * 450 / 512 ) - 58);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
return readTemperature(DEGREES_C);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int _Esplora::readAccelerometer(const byte axis) {
|
|
||||||
switch (axis) {
|
|
||||||
case X_AXIS: return analogRead(ACCEL_X_PIN) - ACCEL_ZERO_X;
|
|
||||||
case Y_AXIS: return analogRead(ACCEL_Y_PIN) - ACCEL_ZERO_Y;
|
|
||||||
case Z_AXIS: return analogRead(ACCEL_Z_PIN) - ACCEL_ZERO_Z;
|
|
||||||
default: return 0;
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,165 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora.h - Arduino Esplora board library
|
|
||||||
Written by Enrico Gueli
|
|
||||||
Copyright (c) 2012 Arduino(TM) All right reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef ESPLORA_H_
|
|
||||||
#define ESPLORA_H_
|
|
||||||
|
|
||||||
#include <Arduino.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The following constants are used internally by the Esplora
|
|
||||||
* library code.
|
|
||||||
*/
|
|
||||||
|
|
||||||
const byte JOYSTICK_BASE = 16; // it's a "virtual" channel: its ID won't conflict with real ones
|
|
||||||
|
|
||||||
const byte MAX_CHANNELS = 13;
|
|
||||||
|
|
||||||
const byte CH_SWITCH_1 = 0;
|
|
||||||
const byte CH_SWITCH_2 = 1;
|
|
||||||
const byte CH_SWITCH_3 = 2;
|
|
||||||
const byte CH_SWITCH_4 = 3;
|
|
||||||
const byte CH_SLIDER = 4;
|
|
||||||
const byte CH_LIGHT = 5;
|
|
||||||
const byte CH_TEMPERATURE = 6;
|
|
||||||
const byte CH_MIC = 7;
|
|
||||||
const byte CH_JOYSTICK_SW = 10;
|
|
||||||
const byte CH_JOYSTICK_X = 11;
|
|
||||||
const byte CH_JOYSTICK_Y = 12;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The following constants can be used with the readButton()
|
|
||||||
* method.
|
|
||||||
*/
|
|
||||||
|
|
||||||
const byte SWITCH_1 = 1;
|
|
||||||
const byte SWITCH_2 = 2;
|
|
||||||
const byte SWITCH_3 = 3;
|
|
||||||
const byte SWITCH_4 = 4;
|
|
||||||
|
|
||||||
const byte SWITCH_DOWN = SWITCH_1;
|
|
||||||
const byte SWITCH_LEFT = SWITCH_2;
|
|
||||||
const byte SWITCH_UP = SWITCH_3;
|
|
||||||
const byte SWITCH_RIGHT = SWITCH_4;
|
|
||||||
|
|
||||||
const byte JOYSTICK_DOWN = JOYSTICK_BASE;
|
|
||||||
const byte JOYSTICK_LEFT = JOYSTICK_BASE+1;
|
|
||||||
const byte JOYSTICK_UP = JOYSTICK_BASE+2;
|
|
||||||
const byte JOYSTICK_RIGHT = JOYSTICK_BASE+3;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* These constants can be use for comparison with the value returned
|
|
||||||
* by the readButton() method.
|
|
||||||
*/
|
|
||||||
const boolean PRESSED = LOW;
|
|
||||||
const boolean RELEASED = HIGH;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The following constants can be used with the readTemperature()
|
|
||||||
* method to specify the desired scale.
|
|
||||||
*/
|
|
||||||
const byte DEGREES_C = 0;
|
|
||||||
const byte DEGREES_F = 1;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The following constants can be used with the readAccelerometer()
|
|
||||||
* method to specify the desired axis to return.
|
|
||||||
*/
|
|
||||||
const byte X_AXIS = 0;
|
|
||||||
const byte Y_AXIS = 1;
|
|
||||||
const byte Z_AXIS = 2;
|
|
||||||
|
|
||||||
|
|
||||||
class _Esplora {
|
|
||||||
private:
|
|
||||||
byte lastRed;
|
|
||||||
byte lastGreen;
|
|
||||||
byte lastBlue;
|
|
||||||
|
|
||||||
unsigned int readChannel(byte channel);
|
|
||||||
|
|
||||||
boolean joyLowHalf(byte joyCh);
|
|
||||||
boolean joyHighHalf(byte joyCh);
|
|
||||||
|
|
||||||
public:
|
|
||||||
_Esplora();
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns a number corresponding to the position of the
|
|
||||||
* linear potentiometer. 0 means full right, 1023 means
|
|
||||||
* full left.
|
|
||||||
*/
|
|
||||||
inline unsigned int readSlider() { return readChannel(CH_SLIDER); }
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns a number corresponding to the amount of ambient
|
|
||||||
* light sensed by the light sensor.
|
|
||||||
*/
|
|
||||||
inline unsigned int readLightSensor() { return readChannel(CH_LIGHT); }
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns the current ambient temperature, expressed either in Celsius
|
|
||||||
* or Fahreneit scale.
|
|
||||||
*/
|
|
||||||
int readTemperature(const byte scale);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns a number corresponding to the amount of ambient noise.
|
|
||||||
*/
|
|
||||||
inline unsigned int readMicrophone() { return readChannel(CH_MIC); }
|
|
||||||
|
|
||||||
inline unsigned int readJoystickSwitch() { return readChannel(CH_JOYSTICK_SW); }
|
|
||||||
|
|
||||||
inline int readJoystickX() {
|
|
||||||
return readChannel(CH_JOYSTICK_X) - 512;
|
|
||||||
}
|
|
||||||
inline int readJoystickY() {
|
|
||||||
return readChannel(CH_JOYSTICK_Y) - 512;
|
|
||||||
}
|
|
||||||
|
|
||||||
int readAccelerometer(const byte axis);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Reads the current state of a button. It will return
|
|
||||||
* LOW if the button is pressed, and HIGH otherwise.
|
|
||||||
*/
|
|
||||||
boolean readButton(byte channel);
|
|
||||||
|
|
||||||
boolean readJoystickButton();
|
|
||||||
|
|
||||||
void writeRGB(byte red, byte green, byte blue);
|
|
||||||
void writeRed(byte red);
|
|
||||||
void writeGreen(byte green);
|
|
||||||
void writeBlue(byte blue);
|
|
||||||
|
|
||||||
byte readRed();
|
|
||||||
byte readGreen();
|
|
||||||
byte readBlue();
|
|
||||||
|
|
||||||
void tone(unsigned int freq);
|
|
||||||
void tone(unsigned int freq, unsigned long duration);
|
|
||||||
void noTone();
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
extern _Esplora Esplora;
|
|
||||||
|
|
||||||
#endif // ESPLORA_H_
|
|
|
@ -1,125 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Kart
|
|
||||||
|
|
||||||
This sketch turns the Esplora into a PC game pad.
|
|
||||||
|
|
||||||
It uses the both the analog joystick and the four switches.
|
|
||||||
By moving the joystick in a direction or by pressing a switch,
|
|
||||||
the PC will "see" that a key is pressed. If the PC is running
|
|
||||||
a game that has keyboard input, the Esplora can control it.
|
|
||||||
|
|
||||||
The default configuration is suitable for SuperTuxKart, an
|
|
||||||
open-source racing game. It can be downloaded from
|
|
||||||
http://supertuxkart.sourceforge.net/ .
|
|
||||||
|
|
||||||
Created on 22 november 2012
|
|
||||||
By Enrico Gueli <enrico.gueli@gmail.com>
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
You're going to handle eight different buttons. You'll use arrays,
|
|
||||||
which are ordered lists of variables with a fixed size. Each array
|
|
||||||
has an index (counting from 0) to keep track of the position
|
|
||||||
you're reading in the array, and each position can contain a number.
|
|
||||||
|
|
||||||
This code uses three different arrays: one for the buttons you'll read;
|
|
||||||
a second to hold the current states of those buttons; and a third to hold
|
|
||||||
the keystrokes associated with each button.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
This array holds the last sensed state of each of the buttons
|
|
||||||
you're reading.
|
|
||||||
Later in the code, you'll read the button states, and compare them
|
|
||||||
to the previous states that are stored in this array. If the two
|
|
||||||
states are different, it means that the button was either
|
|
||||||
pressed or released.
|
|
||||||
*/
|
|
||||||
boolean buttonStates[8];
|
|
||||||
|
|
||||||
/*
|
|
||||||
This array holds the names of the buttons being read.
|
|
||||||
Later in the sketch, you'll use these names with
|
|
||||||
the method Esplora.readButton(x), where x
|
|
||||||
is one of these buttons.
|
|
||||||
*/
|
|
||||||
const byte buttons[] = {
|
|
||||||
JOYSTICK_DOWN,
|
|
||||||
JOYSTICK_LEFT,
|
|
||||||
JOYSTICK_UP,
|
|
||||||
JOYSTICK_RIGHT,
|
|
||||||
SWITCH_RIGHT, // fire
|
|
||||||
SWITCH_LEFT, // bend
|
|
||||||
SWITCH_UP, // nitro
|
|
||||||
SWITCH_DOWN, // look back
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
This array tells what keystroke to send to the PC when a
|
|
||||||
button is pressed.
|
|
||||||
If you look at this array and the above one, you can see that
|
|
||||||
the "cursor down" keystroke is sent when the joystick is moved
|
|
||||||
down, the "cursor up" keystroke when the joystick is moved up
|
|
||||||
and so on.
|
|
||||||
*/
|
|
||||||
const char keystrokes[] = {
|
|
||||||
KEY_DOWN_ARROW,
|
|
||||||
KEY_LEFT_ARROW,
|
|
||||||
KEY_UP_ARROW,
|
|
||||||
KEY_RIGHT_ARROW,
|
|
||||||
' ',
|
|
||||||
'V',
|
|
||||||
'N',
|
|
||||||
'B'
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
This is code is run only at startup, to initialize the
|
|
||||||
virtual USB keyboard.
|
|
||||||
*/
|
|
||||||
void setup() {
|
|
||||||
Keyboard.begin();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
After setup() is finished, this code is run continuously.
|
|
||||||
Here we continuously check if something happened with the
|
|
||||||
buttons.
|
|
||||||
*/
|
|
||||||
void loop() {
|
|
||||||
|
|
||||||
// Iterate through all the buttons:
|
|
||||||
for (byte thisButton=0; thisButton<8; thisButton++) {
|
|
||||||
boolean lastState = buttonStates[thisButton];
|
|
||||||
boolean newState = Esplora.readButton(buttons[thisButton]);
|
|
||||||
if (lastState != newState) { // Something changed!
|
|
||||||
/*
|
|
||||||
The Keyboard library allows you to "press" and "release" the
|
|
||||||
keys as two distinct actions. These actions can be
|
|
||||||
linked to the buttons we're handling.
|
|
||||||
*/
|
|
||||||
if (newState == PRESSED) {
|
|
||||||
Keyboard.press(keystrokes[thisButton]);
|
|
||||||
}
|
|
||||||
else if (newState == RELEASED) {
|
|
||||||
Keyboard.release(keystrokes[thisButton]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Store the new button state, so you can sense a difference later:
|
|
||||||
buttonStates[thisButton] = newState;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Wait a little bit (50ms) between a check and another.
|
|
||||||
When a mechanical switch is pressed or released, the
|
|
||||||
contacts may bounce very rapidly. If the check is done too
|
|
||||||
fast, these bounces may be confused as multiple presses and
|
|
||||||
may lead to unexpected behaviour.
|
|
||||||
*/
|
|
||||||
delay(50);
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,44 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Pong
|
|
||||||
|
|
||||||
This sketch connects serially to a Processing sketch to control a Pong game.
|
|
||||||
It sends the position of the slider and the states of three pushbuttons to the
|
|
||||||
Processing sketch serially, separated by commas. The Processing sketch uses that
|
|
||||||
data to control the graphics in the sketch.
|
|
||||||
|
|
||||||
The slider sets a paddle's height
|
|
||||||
Switch 1 is resets the game
|
|
||||||
Switch 2 resets the ball to the center
|
|
||||||
Switch 3 reverses the players
|
|
||||||
|
|
||||||
You can play this game with one or two Esploras.
|
|
||||||
|
|
||||||
Created on 22 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This example is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
Serial.begin(9600); // initialize serial communication
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the slider and three of the buttons
|
|
||||||
int slider = Esplora.readSlider();
|
|
||||||
int resetButton = Esplora.readButton(SWITCH_1);
|
|
||||||
int serveButton = Esplora.readButton(SWITCH_3);
|
|
||||||
int switchPlayerButton = Esplora.readButton(SWITCH_4);
|
|
||||||
|
|
||||||
Serial.print(slider); // print the slider value
|
|
||||||
Serial.print(","); // add a comma
|
|
||||||
Serial.print(resetButton); // print the reset button value
|
|
||||||
Serial.print(","); // add another comma
|
|
||||||
Serial.print(serveButton); // print the serve button value
|
|
||||||
Serial.print(","); // add another comma
|
|
||||||
Serial.println(switchPlayerButton); // print the last button with a newline
|
|
||||||
delay(10); // delay before sending the next set
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,116 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Remote
|
|
||||||
|
|
||||||
This sketch allows to test all the Esplora's peripherals.
|
|
||||||
It is also used with the ProcessingStart sketch (for Processing).
|
|
||||||
|
|
||||||
When uploaded, you can open the Serial monitor and write one of
|
|
||||||
the following commands (without quotes) to get an answer:
|
|
||||||
|
|
||||||
"D": prints the current value of all sensors, separated by a comma.
|
|
||||||
See the dumpInputs() function below to get the meaning of
|
|
||||||
each value.
|
|
||||||
|
|
||||||
"Rxxx"
|
|
||||||
"Gxxx"
|
|
||||||
"Bxxx": set the color of the RGB led. For example, write "R255"
|
|
||||||
to turn on the red to full brightness, "G128" to turn
|
|
||||||
the green to half brightness, or "G0" to turn off
|
|
||||||
the green channel.
|
|
||||||
|
|
||||||
"Txxxx": play a tone with the buzzer. The number is the
|
|
||||||
frequency, e.g. "T440" plays the central A note.
|
|
||||||
Write "T0" to turn off the buzzer.
|
|
||||||
|
|
||||||
|
|
||||||
Created on 22 november 2012
|
|
||||||
By Enrico Gueli <enrico.gueli@gmail.com>
|
|
||||||
Modified 23 Dec 2012
|
|
||||||
by Tom Igoe
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
while(!Serial); // needed for Leonardo-based board like Esplora
|
|
||||||
Serial.begin(9600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
if (Serial.available())
|
|
||||||
parseCommand();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function reads a character from the serial line and
|
|
||||||
* decide what to do next. The "what to do" part is given by
|
|
||||||
* function it calls (e.g. dumpInputs(), setRed() and so on).
|
|
||||||
*/
|
|
||||||
void parseCommand() {
|
|
||||||
char cmd = Serial.read();
|
|
||||||
switch(cmd) {
|
|
||||||
case 'D':
|
|
||||||
dumpInputs();
|
|
||||||
break;
|
|
||||||
case 'R':
|
|
||||||
setRed();
|
|
||||||
break;
|
|
||||||
case 'G':
|
|
||||||
setGreen();
|
|
||||||
break;
|
|
||||||
case 'B':
|
|
||||||
setBlue();
|
|
||||||
break;
|
|
||||||
case 'T':
|
|
||||||
setTone();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void dumpInputs() {
|
|
||||||
Serial.print(Esplora.readButton(SWITCH_1));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readButton(SWITCH_2));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readButton(SWITCH_3));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readButton(SWITCH_4));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readSlider());
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readLightSensor());
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readTemperature(DEGREES_C));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readMicrophone());
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readJoystickSwitch());
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readJoystickX());
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readJoystickY());
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readAccelerometer(X_AXIS));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readAccelerometer(Y_AXIS));
|
|
||||||
Serial.print(',');
|
|
||||||
Serial.print(Esplora.readAccelerometer(Z_AXIS));
|
|
||||||
Serial.println();
|
|
||||||
}
|
|
||||||
|
|
||||||
void setRed() {
|
|
||||||
Esplora.writeRed(Serial.parseInt());
|
|
||||||
}
|
|
||||||
|
|
||||||
void setGreen() {
|
|
||||||
Esplora.writeGreen(Serial.parseInt());
|
|
||||||
}
|
|
||||||
|
|
||||||
void setBlue() {
|
|
||||||
Esplora.writeBlue(Serial.parseInt());
|
|
||||||
}
|
|
||||||
|
|
||||||
void setTone() {
|
|
||||||
Esplora.tone(Serial.parseInt());
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,213 +0,0 @@
|
||||||
/*
|
|
||||||
Esplora Table
|
|
||||||
|
|
||||||
Acts like a keyboard that prints sensor
|
|
||||||
data in a table-like text, row by row.
|
|
||||||
|
|
||||||
At startup, it does nothing. It waits for you to open a
|
|
||||||
spreadsheet (e.g. Google Drive spreadsheet) so it can write
|
|
||||||
data. By pressing Switch 1, it starts printing the table
|
|
||||||
headers and the first row of data. It waits a bit, then it
|
|
||||||
will print another row, and so on.
|
|
||||||
|
|
||||||
The amount of time between each row is determined by the slider.
|
|
||||||
If put to full left, the sketch will wait 10 seconds; at
|
|
||||||
full right position, it will wait 5 minutes. An intermediate
|
|
||||||
position will make the sketch wait for some time in-between.
|
|
||||||
|
|
||||||
Clicking the Switch 1 at any time will stop the logging.
|
|
||||||
|
|
||||||
The color LED shows what the sketch is doing:
|
|
||||||
blue = idle, waiting for you to press Switch 1 to start logging
|
|
||||||
green = active; will print soon
|
|
||||||
red = printing data to the PC
|
|
||||||
|
|
||||||
Created on 22 november 2012
|
|
||||||
By Enrico Gueli <enrico.gueli@gmail.com>
|
|
||||||
modified 24 Nov 2012
|
|
||||||
by Tom Igoe
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Esplora.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* this variable tells if the data-logging is currently active.
|
|
||||||
*/
|
|
||||||
boolean active = false;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* this variable holds the time in the future when the sketch
|
|
||||||
* will "sample" the data (sampling is the act of reading some
|
|
||||||
* input at a known time). This variable is checked continuously
|
|
||||||
* against millis() to know when it's time to sample.
|
|
||||||
*/
|
|
||||||
unsigned long nextSampleAt = 0;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This variable just holds the millis() value at the time the
|
|
||||||
* logging was activated. This is needed to enter the correct
|
|
||||||
* value in the "Time" column in the printed table.
|
|
||||||
*/
|
|
||||||
unsigned long startedAt = 0;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* when the "active" variable is set to true, the same is done
|
|
||||||
* with this variable. This is needed because the code that does
|
|
||||||
* the "just-after-activation" stuff is run some time later than
|
|
||||||
* the code that says "be active now".
|
|
||||||
*/
|
|
||||||
boolean justActivated = false;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* this variable holds the last sensed status of the switch press
|
|
||||||
* button. If the code sees a difference between the value of
|
|
||||||
* this variable and the current status of the switch, it means
|
|
||||||
* that the button was either pressed or released.
|
|
||||||
*/
|
|
||||||
boolean lastStartBtn = HIGH;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialization code. The virtual USB keyboard must be
|
|
||||||
* initialized; the Serial class is needed just for debugging.
|
|
||||||
*/
|
|
||||||
void setup() {
|
|
||||||
Keyboard.begin();
|
|
||||||
Serial.begin(9600);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This code is run continuously.
|
|
||||||
*/
|
|
||||||
void loop() {
|
|
||||||
/*
|
|
||||||
* note: we don't use Arduino's delay() here, because we can't
|
|
||||||
* normally do anything while delaying. Our own version lets us
|
|
||||||
* check for button presses often enough to not miss any event.
|
|
||||||
*/
|
|
||||||
activeDelay(50);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* the justActivated variable may be set to true in the
|
|
||||||
* checkSwitchPress() function. Here we check its status to
|
|
||||||
* print the table headers and configure what's needed to.
|
|
||||||
*/
|
|
||||||
if (justActivated == true) {
|
|
||||||
justActivated = false; // do this just once
|
|
||||||
printHeaders();
|
|
||||||
// do next sampling ASAP
|
|
||||||
nextSampleAt = startedAt = millis();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (active == true) {
|
|
||||||
if (nextSampleAt < millis()) {
|
|
||||||
// it's time to sample!
|
|
||||||
int slider = Esplora.readSlider();
|
|
||||||
// the row below maps the slider position to a range between
|
|
||||||
// 10 and 290 seconds.
|
|
||||||
int sampleInterval = map(slider, 0, 1023, 10, 290);
|
|
||||||
nextSampleAt = millis() + sampleInterval * 1000;
|
|
||||||
|
|
||||||
logAndPrint();
|
|
||||||
}
|
|
||||||
|
|
||||||
// let the RGB led blink green once per second, for 200ms.
|
|
||||||
unsigned int ms = millis() % 1000;
|
|
||||||
if (ms < 200)
|
|
||||||
Esplora.writeGreen(50);
|
|
||||||
else
|
|
||||||
Esplora.writeGreen(0);
|
|
||||||
|
|
||||||
Esplora.writeBlue(0);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
// while not active, keep a reassuring blue color coming
|
|
||||||
// from the Esplora...
|
|
||||||
Esplora.writeBlue(20);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Print the table headers.
|
|
||||||
*/
|
|
||||||
void printHeaders() {
|
|
||||||
Keyboard.print("Time");
|
|
||||||
Keyboard.write(KEY_TAB);
|
|
||||||
activeDelay(300); // Some spreadsheets are slow, e.g. Google
|
|
||||||
// Drive that wants to save every edit.
|
|
||||||
Keyboard.print("Accel X");
|
|
||||||
Keyboard.write(KEY_TAB);
|
|
||||||
activeDelay(300);
|
|
||||||
Keyboard.print("Accel Y");
|
|
||||||
Keyboard.write(KEY_TAB);
|
|
||||||
activeDelay(300);
|
|
||||||
Keyboard.print("Accel Z");
|
|
||||||
Keyboard.println();
|
|
||||||
activeDelay(300);
|
|
||||||
}
|
|
||||||
|
|
||||||
void logAndPrint() {
|
|
||||||
// do all the samplings at once, because keystrokes have delays
|
|
||||||
unsigned long timeSecs = (millis() - startedAt) /1000;
|
|
||||||
int xAxis = Esplora.readAccelerometer(X_AXIS);
|
|
||||||
int yAxis = Esplora.readAccelerometer(Y_AXIS);
|
|
||||||
int zAxis = Esplora.readAccelerometer(Z_AXIS);
|
|
||||||
|
|
||||||
Esplora.writeRed(100);
|
|
||||||
|
|
||||||
Keyboard.print(timeSecs);
|
|
||||||
Keyboard.write(KEY_TAB);
|
|
||||||
activeDelay(300);
|
|
||||||
Keyboard.print(xAxis);
|
|
||||||
Keyboard.write(KEY_TAB);
|
|
||||||
activeDelay(300);
|
|
||||||
Keyboard.print(yAxis);
|
|
||||||
Keyboard.write(KEY_TAB);
|
|
||||||
activeDelay(300);
|
|
||||||
Keyboard.print(zAxis);
|
|
||||||
Keyboard.println();
|
|
||||||
activeDelay(300);
|
|
||||||
Keyboard.write(KEY_HOME);
|
|
||||||
|
|
||||||
Esplora.writeRed(0);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Similar to delay(), but allows the program to do something else
|
|
||||||
* in the meanwhile. In particular, it calls checkSwitchPress().
|
|
||||||
* Note 1: it may wait longer than the specified amount, not less;
|
|
||||||
* Note 2: beware of data synchronization issues, e.g. if the
|
|
||||||
* activeDelay() function alters some variables used by the
|
|
||||||
* caller of this function.
|
|
||||||
*/
|
|
||||||
void activeDelay(unsigned long amount) {
|
|
||||||
unsigned long at = millis() + amount;
|
|
||||||
while (millis() < at) {
|
|
||||||
checkSwitchPress();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function reads the status of the switch; if it sees that
|
|
||||||
* it was pressed, toggles the status of the "active" variable.
|
|
||||||
* If it's set to true, also the justActivated variable is set to
|
|
||||||
* true, so the loop() function above can do the right things.
|
|
||||||
* This function should be called as often as possible and do as
|
|
||||||
* little as possible, because it can be called while another
|
|
||||||
* function is running.
|
|
||||||
*/
|
|
||||||
void checkSwitchPress() {
|
|
||||||
boolean startBtn = Esplora.readButton(SWITCH_DOWN);
|
|
||||||
|
|
||||||
if (startBtn != lastStartBtn) {
|
|
||||||
if (startBtn == HIGH) { // button released
|
|
||||||
active = !active;
|
|
||||||
if (active)
|
|
||||||
justActivated = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
lastStartBtn = startBtn;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,69 +0,0 @@
|
||||||
#######################################
|
|
||||||
# Syntax Coloring Map For Esplora
|
|
||||||
#######################################
|
|
||||||
# Class
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
Esplora KEYWORD3
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Methods and Functions
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
begin KEYWORD2
|
|
||||||
readSlider KEYWORD2
|
|
||||||
readLightSensor KEYWORD2
|
|
||||||
readTemperature KEYWORD2
|
|
||||||
readMicrophone KEYWORD2
|
|
||||||
readJoystickSwitch KEYWORD2
|
|
||||||
readJoystickButton KEYWORD2
|
|
||||||
readJoystickX KEYWORD2
|
|
||||||
readJoystickY KEYWORD2
|
|
||||||
readAccelerometer KEYWORD2
|
|
||||||
readButton KEYWORD2
|
|
||||||
writeRGB KEYWORD2
|
|
||||||
writeRed KEYWORD2
|
|
||||||
writeGreen KEYWORD2
|
|
||||||
writeBlue KEYWORD2
|
|
||||||
readRed KEYWORD2
|
|
||||||
readGreen KEYWORD2
|
|
||||||
readBlue KEYWORD2
|
|
||||||
tone KEYWORD2
|
|
||||||
noTone KEYWORD2
|
|
||||||
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Constants
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
JOYSTICK_BASE LITERAL1
|
|
||||||
MAX_CHANNELS LITERAL1
|
|
||||||
CH_SWITCH_1 LITERAL1
|
|
||||||
CH_SWITCH_2 LITERAL1
|
|
||||||
CH_SWITCH_3 LITERAL1
|
|
||||||
CH_SWITCH_4 LITERAL1
|
|
||||||
CH_SLIDER LITERAL1
|
|
||||||
CH_LIGHT LITERAL1
|
|
||||||
CH_TEMPERATURE LITERAL1
|
|
||||||
CH_MIC LITERAL1
|
|
||||||
CH_JOYSTICK_SW LITERAL1
|
|
||||||
CH_JOYSTICK_X LITERAL1
|
|
||||||
CH_JOYSTICK_Y LITERAL1
|
|
||||||
SWITCH_1 LITERAL1
|
|
||||||
SWITCH_2 LITERAL1
|
|
||||||
SWITCH_3 LITERAL1
|
|
||||||
SWITCH_4 LITERAL1
|
|
||||||
SWITCH_DOWN LITERAL1
|
|
||||||
SWITCH_LEFT LITERAL1
|
|
||||||
SWITCH_UP LITERAL1
|
|
||||||
SWITCH_RIGHT LITERAL1
|
|
||||||
JOYSTICK_DOWN LITERAL1
|
|
||||||
JOYSTICK_LEFT LITERAL1
|
|
||||||
JOYSTICK_UP LITERAL1
|
|
||||||
PRESSED LITERAL1
|
|
||||||
RELEASED LITERAL1
|
|
||||||
DEGREES_C LITERAL1
|
|
||||||
DEGREES_F LITERAL1
|
|
||||||
X_AXIS LITERAL1
|
|
||||||
Y_AXIS LITERAL1
|
|
||||||
Z_AXIS LITERAL1
|
|
|
@ -1,480 +0,0 @@
|
||||||
// DHCP Library v0.3 - April 25, 2009
|
|
||||||
// Author: Jordan Terrell - blog.jordanterrell.com
|
|
||||||
|
|
||||||
#include "w5100.h"
|
|
||||||
|
|
||||||
#include <string.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include "Dhcp.h"
|
|
||||||
#include "Arduino.h"
|
|
||||||
#include "util.h"
|
|
||||||
|
|
||||||
int DhcpClass::beginWithDHCP(uint8_t *mac, unsigned long timeout, unsigned long responseTimeout)
|
|
||||||
{
|
|
||||||
_dhcpLeaseTime=0;
|
|
||||||
_dhcpT1=0;
|
|
||||||
_dhcpT2=0;
|
|
||||||
_lastCheck=0;
|
|
||||||
_timeout = timeout;
|
|
||||||
_responseTimeout = responseTimeout;
|
|
||||||
|
|
||||||
// zero out _dhcpMacAddr
|
|
||||||
memset(_dhcpMacAddr, 0, 6);
|
|
||||||
reset_DHCP_lease();
|
|
||||||
|
|
||||||
memcpy((void*)_dhcpMacAddr, (void*)mac, 6);
|
|
||||||
_dhcp_state = STATE_DHCP_START;
|
|
||||||
return request_DHCP_lease();
|
|
||||||
}
|
|
||||||
|
|
||||||
void DhcpClass::reset_DHCP_lease(){
|
|
||||||
// zero out _dhcpSubnetMask, _dhcpGatewayIp, _dhcpLocalIp, _dhcpDhcpServerIp, _dhcpDnsServerIp
|
|
||||||
memset(_dhcpLocalIp, 0, 20);
|
|
||||||
}
|
|
||||||
|
|
||||||
//return:0 on error, 1 if request is sent and response is received
|
|
||||||
int DhcpClass::request_DHCP_lease(){
|
|
||||||
|
|
||||||
uint8_t messageType = 0;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// Pick an initial transaction ID
|
|
||||||
_dhcpTransactionId = random(1UL, 2000UL);
|
|
||||||
_dhcpInitialTransactionId = _dhcpTransactionId;
|
|
||||||
|
|
||||||
_dhcpUdpSocket.stop();
|
|
||||||
if (_dhcpUdpSocket.begin(DHCP_CLIENT_PORT) == 0)
|
|
||||||
{
|
|
||||||
// Couldn't get a socket
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
presend_DHCP();
|
|
||||||
|
|
||||||
int result = 0;
|
|
||||||
|
|
||||||
unsigned long startTime = millis();
|
|
||||||
|
|
||||||
while(_dhcp_state != STATE_DHCP_LEASED)
|
|
||||||
{
|
|
||||||
if(_dhcp_state == STATE_DHCP_START)
|
|
||||||
{
|
|
||||||
_dhcpTransactionId++;
|
|
||||||
|
|
||||||
send_DHCP_MESSAGE(DHCP_DISCOVER, ((millis() - startTime) / 1000));
|
|
||||||
_dhcp_state = STATE_DHCP_DISCOVER;
|
|
||||||
}
|
|
||||||
else if(_dhcp_state == STATE_DHCP_REREQUEST){
|
|
||||||
_dhcpTransactionId++;
|
|
||||||
send_DHCP_MESSAGE(DHCP_REQUEST, ((millis() - startTime)/1000));
|
|
||||||
_dhcp_state = STATE_DHCP_REQUEST;
|
|
||||||
}
|
|
||||||
else if(_dhcp_state == STATE_DHCP_DISCOVER)
|
|
||||||
{
|
|
||||||
uint32_t respId;
|
|
||||||
messageType = parseDHCPResponse(_responseTimeout, respId);
|
|
||||||
if(messageType == DHCP_OFFER)
|
|
||||||
{
|
|
||||||
// We'll use the transaction ID that the offer came with,
|
|
||||||
// rather than the one we were up to
|
|
||||||
_dhcpTransactionId = respId;
|
|
||||||
send_DHCP_MESSAGE(DHCP_REQUEST, ((millis() - startTime) / 1000));
|
|
||||||
_dhcp_state = STATE_DHCP_REQUEST;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if(_dhcp_state == STATE_DHCP_REQUEST)
|
|
||||||
{
|
|
||||||
uint32_t respId;
|
|
||||||
messageType = parseDHCPResponse(_responseTimeout, respId);
|
|
||||||
if(messageType == DHCP_ACK)
|
|
||||||
{
|
|
||||||
_dhcp_state = STATE_DHCP_LEASED;
|
|
||||||
result = 1;
|
|
||||||
//use default lease time if we didn't get it
|
|
||||||
if(_dhcpLeaseTime == 0){
|
|
||||||
_dhcpLeaseTime = DEFAULT_LEASE;
|
|
||||||
}
|
|
||||||
//calculate T1 & T2 if we didn't get it
|
|
||||||
if(_dhcpT1 == 0){
|
|
||||||
//T1 should be 50% of _dhcpLeaseTime
|
|
||||||
_dhcpT1 = _dhcpLeaseTime >> 1;
|
|
||||||
}
|
|
||||||
if(_dhcpT2 == 0){
|
|
||||||
//T2 should be 87.5% (7/8ths) of _dhcpLeaseTime
|
|
||||||
_dhcpT2 = _dhcpT1 << 1;
|
|
||||||
}
|
|
||||||
_renewInSec = _dhcpT1;
|
|
||||||
_rebindInSec = _dhcpT2;
|
|
||||||
}
|
|
||||||
else if(messageType == DHCP_NAK)
|
|
||||||
_dhcp_state = STATE_DHCP_START;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(messageType == 255)
|
|
||||||
{
|
|
||||||
messageType = 0;
|
|
||||||
_dhcp_state = STATE_DHCP_START;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(result != 1 && ((millis() - startTime) > _timeout))
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
// We're done with the socket now
|
|
||||||
_dhcpUdpSocket.stop();
|
|
||||||
_dhcpTransactionId++;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
void DhcpClass::presend_DHCP()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
void DhcpClass::send_DHCP_MESSAGE(uint8_t messageType, uint16_t secondsElapsed)
|
|
||||||
{
|
|
||||||
uint8_t buffer[32];
|
|
||||||
memset(buffer, 0, 32);
|
|
||||||
IPAddress dest_addr( 255, 255, 255, 255 ); // Broadcast address
|
|
||||||
|
|
||||||
if (-1 == _dhcpUdpSocket.beginPacket(dest_addr, DHCP_SERVER_PORT))
|
|
||||||
{
|
|
||||||
// FIXME Need to return errors
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
buffer[0] = DHCP_BOOTREQUEST; // op
|
|
||||||
buffer[1] = DHCP_HTYPE10MB; // htype
|
|
||||||
buffer[2] = DHCP_HLENETHERNET; // hlen
|
|
||||||
buffer[3] = DHCP_HOPS; // hops
|
|
||||||
|
|
||||||
// xid
|
|
||||||
unsigned long xid = htonl(_dhcpTransactionId);
|
|
||||||
memcpy(buffer + 4, &(xid), 4);
|
|
||||||
|
|
||||||
// 8, 9 - seconds elapsed
|
|
||||||
buffer[8] = ((secondsElapsed & 0xff00) >> 8);
|
|
||||||
buffer[9] = (secondsElapsed & 0x00ff);
|
|
||||||
|
|
||||||
// flags
|
|
||||||
unsigned short flags = htons(DHCP_FLAGSBROADCAST);
|
|
||||||
memcpy(buffer + 10, &(flags), 2);
|
|
||||||
|
|
||||||
// ciaddr: already zeroed
|
|
||||||
// yiaddr: already zeroed
|
|
||||||
// siaddr: already zeroed
|
|
||||||
// giaddr: already zeroed
|
|
||||||
|
|
||||||
//put data in W5100 transmit buffer
|
|
||||||
_dhcpUdpSocket.write(buffer, 28);
|
|
||||||
|
|
||||||
memset(buffer, 0, 32); // clear local buffer
|
|
||||||
|
|
||||||
memcpy(buffer, _dhcpMacAddr, 6); // chaddr
|
|
||||||
|
|
||||||
//put data in W5100 transmit buffer
|
|
||||||
_dhcpUdpSocket.write(buffer, 16);
|
|
||||||
|
|
||||||
memset(buffer, 0, 32); // clear local buffer
|
|
||||||
|
|
||||||
// leave zeroed out for sname && file
|
|
||||||
// put in W5100 transmit buffer x 6 (192 bytes)
|
|
||||||
|
|
||||||
for(int i = 0; i < 6; i++) {
|
|
||||||
_dhcpUdpSocket.write(buffer, 32);
|
|
||||||
}
|
|
||||||
|
|
||||||
// OPT - Magic Cookie
|
|
||||||
buffer[0] = (uint8_t)((MAGIC_COOKIE >> 24)& 0xFF);
|
|
||||||
buffer[1] = (uint8_t)((MAGIC_COOKIE >> 16)& 0xFF);
|
|
||||||
buffer[2] = (uint8_t)((MAGIC_COOKIE >> 8)& 0xFF);
|
|
||||||
buffer[3] = (uint8_t)(MAGIC_COOKIE& 0xFF);
|
|
||||||
|
|
||||||
// OPT - message type
|
|
||||||
buffer[4] = dhcpMessageType;
|
|
||||||
buffer[5] = 0x01;
|
|
||||||
buffer[6] = messageType; //DHCP_REQUEST;
|
|
||||||
|
|
||||||
// OPT - client identifier
|
|
||||||
buffer[7] = dhcpClientIdentifier;
|
|
||||||
buffer[8] = 0x07;
|
|
||||||
buffer[9] = 0x01;
|
|
||||||
memcpy(buffer + 10, _dhcpMacAddr, 6);
|
|
||||||
|
|
||||||
// OPT - host name
|
|
||||||
buffer[16] = hostName;
|
|
||||||
buffer[17] = strlen(HOST_NAME) + 6; // length of hostname + last 3 bytes of mac address
|
|
||||||
strcpy((char*)&(buffer[18]), HOST_NAME);
|
|
||||||
|
|
||||||
printByte((char*)&(buffer[24]), _dhcpMacAddr[3]);
|
|
||||||
printByte((char*)&(buffer[26]), _dhcpMacAddr[4]);
|
|
||||||
printByte((char*)&(buffer[28]), _dhcpMacAddr[5]);
|
|
||||||
|
|
||||||
//put data in W5100 transmit buffer
|
|
||||||
_dhcpUdpSocket.write(buffer, 30);
|
|
||||||
|
|
||||||
if(messageType == DHCP_REQUEST)
|
|
||||||
{
|
|
||||||
buffer[0] = dhcpRequestedIPaddr;
|
|
||||||
buffer[1] = 0x04;
|
|
||||||
buffer[2] = _dhcpLocalIp[0];
|
|
||||||
buffer[3] = _dhcpLocalIp[1];
|
|
||||||
buffer[4] = _dhcpLocalIp[2];
|
|
||||||
buffer[5] = _dhcpLocalIp[3];
|
|
||||||
|
|
||||||
buffer[6] = dhcpServerIdentifier;
|
|
||||||
buffer[7] = 0x04;
|
|
||||||
buffer[8] = _dhcpDhcpServerIp[0];
|
|
||||||
buffer[9] = _dhcpDhcpServerIp[1];
|
|
||||||
buffer[10] = _dhcpDhcpServerIp[2];
|
|
||||||
buffer[11] = _dhcpDhcpServerIp[3];
|
|
||||||
|
|
||||||
//put data in W5100 transmit buffer
|
|
||||||
_dhcpUdpSocket.write(buffer, 12);
|
|
||||||
}
|
|
||||||
|
|
||||||
buffer[0] = dhcpParamRequest;
|
|
||||||
buffer[1] = 0x06;
|
|
||||||
buffer[2] = subnetMask;
|
|
||||||
buffer[3] = routersOnSubnet;
|
|
||||||
buffer[4] = dns;
|
|
||||||
buffer[5] = domainName;
|
|
||||||
buffer[6] = dhcpT1value;
|
|
||||||
buffer[7] = dhcpT2value;
|
|
||||||
buffer[8] = endOption;
|
|
||||||
|
|
||||||
//put data in W5100 transmit buffer
|
|
||||||
_dhcpUdpSocket.write(buffer, 9);
|
|
||||||
|
|
||||||
_dhcpUdpSocket.endPacket();
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t DhcpClass::parseDHCPResponse(unsigned long responseTimeout, uint32_t& transactionId)
|
|
||||||
{
|
|
||||||
uint8_t type = 0;
|
|
||||||
uint8_t opt_len = 0;
|
|
||||||
|
|
||||||
unsigned long startTime = millis();
|
|
||||||
|
|
||||||
while(_dhcpUdpSocket.parsePacket() <= 0)
|
|
||||||
{
|
|
||||||
if((millis() - startTime) > responseTimeout)
|
|
||||||
{
|
|
||||||
return 255;
|
|
||||||
}
|
|
||||||
delay(50);
|
|
||||||
}
|
|
||||||
// start reading in the packet
|
|
||||||
RIP_MSG_FIXED fixedMsg;
|
|
||||||
_dhcpUdpSocket.read((uint8_t*)&fixedMsg, sizeof(RIP_MSG_FIXED));
|
|
||||||
|
|
||||||
if(fixedMsg.op == DHCP_BOOTREPLY && _dhcpUdpSocket.remotePort() == DHCP_SERVER_PORT)
|
|
||||||
{
|
|
||||||
transactionId = ntohl(fixedMsg.xid);
|
|
||||||
if(memcmp(fixedMsg.chaddr, _dhcpMacAddr, 6) != 0 || (transactionId < _dhcpInitialTransactionId) || (transactionId > _dhcpTransactionId))
|
|
||||||
{
|
|
||||||
// Need to read the rest of the packet here regardless
|
|
||||||
_dhcpUdpSocket.flush();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
memcpy(_dhcpLocalIp, fixedMsg.yiaddr, 4);
|
|
||||||
|
|
||||||
// Skip to the option part
|
|
||||||
// Doing this a byte at a time so we don't have to put a big buffer
|
|
||||||
// on the stack (as we don't have lots of memory lying around)
|
|
||||||
for (int i =0; i < (240 - (int)sizeof(RIP_MSG_FIXED)); i++)
|
|
||||||
{
|
|
||||||
_dhcpUdpSocket.read(); // we don't care about the returned byte
|
|
||||||
}
|
|
||||||
|
|
||||||
while (_dhcpUdpSocket.available() > 0)
|
|
||||||
{
|
|
||||||
switch (_dhcpUdpSocket.read())
|
|
||||||
{
|
|
||||||
case endOption :
|
|
||||||
break;
|
|
||||||
|
|
||||||
case padOption :
|
|
||||||
break;
|
|
||||||
|
|
||||||
case dhcpMessageType :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
type = _dhcpUdpSocket.read();
|
|
||||||
break;
|
|
||||||
|
|
||||||
case subnetMask :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
_dhcpUdpSocket.read(_dhcpSubnetMask, 4);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case routersOnSubnet :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
_dhcpUdpSocket.read(_dhcpGatewayIp, 4);
|
|
||||||
for (int i = 0; i < opt_len-4; i++)
|
|
||||||
{
|
|
||||||
_dhcpUdpSocket.read();
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case dns :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
_dhcpUdpSocket.read(_dhcpDnsServerIp, 4);
|
|
||||||
for (int i = 0; i < opt_len-4; i++)
|
|
||||||
{
|
|
||||||
_dhcpUdpSocket.read();
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case dhcpServerIdentifier :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
if( *((uint32_t*)_dhcpDhcpServerIp) == 0 ||
|
|
||||||
IPAddress(_dhcpDhcpServerIp) == _dhcpUdpSocket.remoteIP() )
|
|
||||||
{
|
|
||||||
_dhcpUdpSocket.read(_dhcpDhcpServerIp, sizeof(_dhcpDhcpServerIp));
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// Skip over the rest of this option
|
|
||||||
while (opt_len--)
|
|
||||||
{
|
|
||||||
_dhcpUdpSocket.read();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case dhcpT1value :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
_dhcpUdpSocket.read((uint8_t*)&_dhcpT1, sizeof(_dhcpT1));
|
|
||||||
_dhcpT1 = ntohl(_dhcpT1);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case dhcpT2value :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
_dhcpUdpSocket.read((uint8_t*)&_dhcpT2, sizeof(_dhcpT2));
|
|
||||||
_dhcpT2 = ntohl(_dhcpT2);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case dhcpIPaddrLeaseTime :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
_dhcpUdpSocket.read((uint8_t*)&_dhcpLeaseTime, sizeof(_dhcpLeaseTime));
|
|
||||||
_dhcpLeaseTime = ntohl(_dhcpLeaseTime);
|
|
||||||
_renewInSec = _dhcpLeaseTime;
|
|
||||||
break;
|
|
||||||
|
|
||||||
default :
|
|
||||||
opt_len = _dhcpUdpSocket.read();
|
|
||||||
// Skip over the rest of this option
|
|
||||||
while (opt_len--)
|
|
||||||
{
|
|
||||||
_dhcpUdpSocket.read();
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Need to skip to end of the packet regardless here
|
|
||||||
_dhcpUdpSocket.flush();
|
|
||||||
|
|
||||||
return type;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
returns:
|
|
||||||
0/DHCP_CHECK_NONE: nothing happened
|
|
||||||
1/DHCP_CHECK_RENEW_FAIL: renew failed
|
|
||||||
2/DHCP_CHECK_RENEW_OK: renew success
|
|
||||||
3/DHCP_CHECK_REBIND_FAIL: rebind fail
|
|
||||||
4/DHCP_CHECK_REBIND_OK: rebind success
|
|
||||||
*/
|
|
||||||
int DhcpClass::checkLease(){
|
|
||||||
//this uses a signed / unsigned trick to deal with millis overflow
|
|
||||||
unsigned long now = millis();
|
|
||||||
signed long snow = (long)now;
|
|
||||||
int rc=DHCP_CHECK_NONE;
|
|
||||||
if (_lastCheck != 0){
|
|
||||||
signed long factor;
|
|
||||||
//calc how many ms past the timeout we are
|
|
||||||
factor = snow - (long)_secTimeout;
|
|
||||||
//if on or passed the timeout, reduce the counters
|
|
||||||
if ( factor >= 0 ){
|
|
||||||
//next timeout should be now plus 1000 ms minus parts of second in factor
|
|
||||||
_secTimeout = snow + 1000 - factor % 1000;
|
|
||||||
//how many seconds late are we, minimum 1
|
|
||||||
factor = factor / 1000 +1;
|
|
||||||
|
|
||||||
//reduce the counters by that mouch
|
|
||||||
//if we can assume that the cycle time (factor) is fairly constant
|
|
||||||
//and if the remainder is less than cycle time * 2
|
|
||||||
//do it early instead of late
|
|
||||||
if(_renewInSec < factor*2 )
|
|
||||||
_renewInSec = 0;
|
|
||||||
else
|
|
||||||
_renewInSec -= factor;
|
|
||||||
|
|
||||||
if(_rebindInSec < factor*2 )
|
|
||||||
_rebindInSec = 0;
|
|
||||||
else
|
|
||||||
_rebindInSec -= factor;
|
|
||||||
}
|
|
||||||
|
|
||||||
//if we have a lease but should renew, do it
|
|
||||||
if (_dhcp_state == STATE_DHCP_LEASED && _renewInSec <=0){
|
|
||||||
_dhcp_state = STATE_DHCP_REREQUEST;
|
|
||||||
rc = 1 + request_DHCP_lease();
|
|
||||||
}
|
|
||||||
|
|
||||||
//if we have a lease or is renewing but should bind, do it
|
|
||||||
if( (_dhcp_state == STATE_DHCP_LEASED || _dhcp_state == STATE_DHCP_START) && _rebindInSec <=0){
|
|
||||||
//this should basically restart completely
|
|
||||||
_dhcp_state = STATE_DHCP_START;
|
|
||||||
reset_DHCP_lease();
|
|
||||||
rc = 3 + request_DHCP_lease();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else{
|
|
||||||
_secTimeout = snow + 1000;
|
|
||||||
}
|
|
||||||
|
|
||||||
_lastCheck = now;
|
|
||||||
return rc;
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress DhcpClass::getLocalIp()
|
|
||||||
{
|
|
||||||
return IPAddress(_dhcpLocalIp);
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress DhcpClass::getSubnetMask()
|
|
||||||
{
|
|
||||||
return IPAddress(_dhcpSubnetMask);
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress DhcpClass::getGatewayIp()
|
|
||||||
{
|
|
||||||
return IPAddress(_dhcpGatewayIp);
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress DhcpClass::getDhcpServerIp()
|
|
||||||
{
|
|
||||||
return IPAddress(_dhcpDhcpServerIp);
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress DhcpClass::getDnsServerIp()
|
|
||||||
{
|
|
||||||
return IPAddress(_dhcpDnsServerIp);
|
|
||||||
}
|
|
||||||
|
|
||||||
void DhcpClass::printByte(char * buf, uint8_t n ) {
|
|
||||||
char *str = &buf[1];
|
|
||||||
buf[0]='0';
|
|
||||||
do {
|
|
||||||
unsigned long m = n;
|
|
||||||
n /= 16;
|
|
||||||
char c = m - 16 * n;
|
|
||||||
*str-- = c < 10 ? c + '0' : c + 'A' - 10;
|
|
||||||
} while(n);
|
|
||||||
}
|
|
|
@ -1,178 +0,0 @@
|
||||||
// DHCP Library v0.3 - April 25, 2009
|
|
||||||
// Author: Jordan Terrell - blog.jordanterrell.com
|
|
||||||
|
|
||||||
#ifndef Dhcp_h
|
|
||||||
#define Dhcp_h
|
|
||||||
|
|
||||||
#include "EthernetUdp.h"
|
|
||||||
|
|
||||||
/* DHCP state machine. */
|
|
||||||
#define STATE_DHCP_START 0
|
|
||||||
#define STATE_DHCP_DISCOVER 1
|
|
||||||
#define STATE_DHCP_REQUEST 2
|
|
||||||
#define STATE_DHCP_LEASED 3
|
|
||||||
#define STATE_DHCP_REREQUEST 4
|
|
||||||
#define STATE_DHCP_RELEASE 5
|
|
||||||
|
|
||||||
#define DHCP_FLAGSBROADCAST 0x8000
|
|
||||||
|
|
||||||
/* UDP port numbers for DHCP */
|
|
||||||
#define DHCP_SERVER_PORT 67 /* from server to client */
|
|
||||||
#define DHCP_CLIENT_PORT 68 /* from client to server */
|
|
||||||
|
|
||||||
/* DHCP message OP code */
|
|
||||||
#define DHCP_BOOTREQUEST 1
|
|
||||||
#define DHCP_BOOTREPLY 2
|
|
||||||
|
|
||||||
/* DHCP message type */
|
|
||||||
#define DHCP_DISCOVER 1
|
|
||||||
#define DHCP_OFFER 2
|
|
||||||
#define DHCP_REQUEST 3
|
|
||||||
#define DHCP_DECLINE 4
|
|
||||||
#define DHCP_ACK 5
|
|
||||||
#define DHCP_NAK 6
|
|
||||||
#define DHCP_RELEASE 7
|
|
||||||
#define DHCP_INFORM 8
|
|
||||||
|
|
||||||
#define DHCP_HTYPE10MB 1
|
|
||||||
#define DHCP_HTYPE100MB 2
|
|
||||||
|
|
||||||
#define DHCP_HLENETHERNET 6
|
|
||||||
#define DHCP_HOPS 0
|
|
||||||
#define DHCP_SECS 0
|
|
||||||
|
|
||||||
#define MAGIC_COOKIE 0x63825363
|
|
||||||
#define MAX_DHCP_OPT 16
|
|
||||||
|
|
||||||
#define HOST_NAME "WIZnet"
|
|
||||||
#define DEFAULT_LEASE (900) //default lease time in seconds
|
|
||||||
|
|
||||||
#define DHCP_CHECK_NONE (0)
|
|
||||||
#define DHCP_CHECK_RENEW_FAIL (1)
|
|
||||||
#define DHCP_CHECK_RENEW_OK (2)
|
|
||||||
#define DHCP_CHECK_REBIND_FAIL (3)
|
|
||||||
#define DHCP_CHECK_REBIND_OK (4)
|
|
||||||
|
|
||||||
enum
|
|
||||||
{
|
|
||||||
padOption = 0,
|
|
||||||
subnetMask = 1,
|
|
||||||
timerOffset = 2,
|
|
||||||
routersOnSubnet = 3,
|
|
||||||
/* timeServer = 4,
|
|
||||||
nameServer = 5,*/
|
|
||||||
dns = 6,
|
|
||||||
/*logServer = 7,
|
|
||||||
cookieServer = 8,
|
|
||||||
lprServer = 9,
|
|
||||||
impressServer = 10,
|
|
||||||
resourceLocationServer = 11,*/
|
|
||||||
hostName = 12,
|
|
||||||
/*bootFileSize = 13,
|
|
||||||
meritDumpFile = 14,*/
|
|
||||||
domainName = 15,
|
|
||||||
/*swapServer = 16,
|
|
||||||
rootPath = 17,
|
|
||||||
extentionsPath = 18,
|
|
||||||
IPforwarding = 19,
|
|
||||||
nonLocalSourceRouting = 20,
|
|
||||||
policyFilter = 21,
|
|
||||||
maxDgramReasmSize = 22,
|
|
||||||
defaultIPTTL = 23,
|
|
||||||
pathMTUagingTimeout = 24,
|
|
||||||
pathMTUplateauTable = 25,
|
|
||||||
ifMTU = 26,
|
|
||||||
allSubnetsLocal = 27,
|
|
||||||
broadcastAddr = 28,
|
|
||||||
performMaskDiscovery = 29,
|
|
||||||
maskSupplier = 30,
|
|
||||||
performRouterDiscovery = 31,
|
|
||||||
routerSolicitationAddr = 32,
|
|
||||||
staticRoute = 33,
|
|
||||||
trailerEncapsulation = 34,
|
|
||||||
arpCacheTimeout = 35,
|
|
||||||
ethernetEncapsulation = 36,
|
|
||||||
tcpDefaultTTL = 37,
|
|
||||||
tcpKeepaliveInterval = 38,
|
|
||||||
tcpKeepaliveGarbage = 39,
|
|
||||||
nisDomainName = 40,
|
|
||||||
nisServers = 41,
|
|
||||||
ntpServers = 42,
|
|
||||||
vendorSpecificInfo = 43,
|
|
||||||
netBIOSnameServer = 44,
|
|
||||||
netBIOSdgramDistServer = 45,
|
|
||||||
netBIOSnodeType = 46,
|
|
||||||
netBIOSscope = 47,
|
|
||||||
xFontServer = 48,
|
|
||||||
xDisplayManager = 49,*/
|
|
||||||
dhcpRequestedIPaddr = 50,
|
|
||||||
dhcpIPaddrLeaseTime = 51,
|
|
||||||
/*dhcpOptionOverload = 52,*/
|
|
||||||
dhcpMessageType = 53,
|
|
||||||
dhcpServerIdentifier = 54,
|
|
||||||
dhcpParamRequest = 55,
|
|
||||||
/*dhcpMsg = 56,
|
|
||||||
dhcpMaxMsgSize = 57,*/
|
|
||||||
dhcpT1value = 58,
|
|
||||||
dhcpT2value = 59,
|
|
||||||
/*dhcpClassIdentifier = 60,*/
|
|
||||||
dhcpClientIdentifier = 61,
|
|
||||||
endOption = 255
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef struct _RIP_MSG_FIXED
|
|
||||||
{
|
|
||||||
uint8_t op;
|
|
||||||
uint8_t htype;
|
|
||||||
uint8_t hlen;
|
|
||||||
uint8_t hops;
|
|
||||||
uint32_t xid;
|
|
||||||
uint16_t secs;
|
|
||||||
uint16_t flags;
|
|
||||||
uint8_t ciaddr[4];
|
|
||||||
uint8_t yiaddr[4];
|
|
||||||
uint8_t siaddr[4];
|
|
||||||
uint8_t giaddr[4];
|
|
||||||
uint8_t chaddr[6];
|
|
||||||
}RIP_MSG_FIXED;
|
|
||||||
|
|
||||||
class DhcpClass {
|
|
||||||
private:
|
|
||||||
uint32_t _dhcpInitialTransactionId;
|
|
||||||
uint32_t _dhcpTransactionId;
|
|
||||||
uint8_t _dhcpMacAddr[6];
|
|
||||||
uint8_t _dhcpLocalIp[4];
|
|
||||||
uint8_t _dhcpSubnetMask[4];
|
|
||||||
uint8_t _dhcpGatewayIp[4];
|
|
||||||
uint8_t _dhcpDhcpServerIp[4];
|
|
||||||
uint8_t _dhcpDnsServerIp[4];
|
|
||||||
uint32_t _dhcpLeaseTime;
|
|
||||||
uint32_t _dhcpT1, _dhcpT2;
|
|
||||||
signed long _renewInSec;
|
|
||||||
signed long _rebindInSec;
|
|
||||||
signed long _lastCheck;
|
|
||||||
unsigned long _timeout;
|
|
||||||
unsigned long _responseTimeout;
|
|
||||||
unsigned long _secTimeout;
|
|
||||||
uint8_t _dhcp_state;
|
|
||||||
EthernetUDP _dhcpUdpSocket;
|
|
||||||
|
|
||||||
int request_DHCP_lease();
|
|
||||||
void reset_DHCP_lease();
|
|
||||||
void presend_DHCP();
|
|
||||||
void send_DHCP_MESSAGE(uint8_t, uint16_t);
|
|
||||||
void printByte(char *, uint8_t);
|
|
||||||
|
|
||||||
uint8_t parseDHCPResponse(unsigned long responseTimeout, uint32_t& transactionId);
|
|
||||||
public:
|
|
||||||
IPAddress getLocalIp();
|
|
||||||
IPAddress getSubnetMask();
|
|
||||||
IPAddress getGatewayIp();
|
|
||||||
IPAddress getDhcpServerIp();
|
|
||||||
IPAddress getDnsServerIp();
|
|
||||||
|
|
||||||
int beginWithDHCP(uint8_t *, unsigned long timeout = 60000, unsigned long responseTimeout = 4000);
|
|
||||||
int checkLease();
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,423 +0,0 @@
|
||||||
// Arduino DNS client for WizNet5100-based Ethernet shield
|
|
||||||
// (c) Copyright 2009-2010 MCQN Ltd.
|
|
||||||
// Released under Apache License, version 2.0
|
|
||||||
|
|
||||||
#include "w5100.h"
|
|
||||||
#include "EthernetUdp.h"
|
|
||||||
#include "util.h"
|
|
||||||
|
|
||||||
#include "Dns.h"
|
|
||||||
#include <string.h>
|
|
||||||
//#include <stdlib.h>
|
|
||||||
#include "Arduino.h"
|
|
||||||
|
|
||||||
|
|
||||||
#define SOCKET_NONE 255
|
|
||||||
// Various flags and header field values for a DNS message
|
|
||||||
#define UDP_HEADER_SIZE 8
|
|
||||||
#define DNS_HEADER_SIZE 12
|
|
||||||
#define TTL_SIZE 4
|
|
||||||
#define QUERY_FLAG (0)
|
|
||||||
#define RESPONSE_FLAG (1<<15)
|
|
||||||
#define QUERY_RESPONSE_MASK (1<<15)
|
|
||||||
#define OPCODE_STANDARD_QUERY (0)
|
|
||||||
#define OPCODE_INVERSE_QUERY (1<<11)
|
|
||||||
#define OPCODE_STATUS_REQUEST (2<<11)
|
|
||||||
#define OPCODE_MASK (15<<11)
|
|
||||||
#define AUTHORITATIVE_FLAG (1<<10)
|
|
||||||
#define TRUNCATION_FLAG (1<<9)
|
|
||||||
#define RECURSION_DESIRED_FLAG (1<<8)
|
|
||||||
#define RECURSION_AVAILABLE_FLAG (1<<7)
|
|
||||||
#define RESP_NO_ERROR (0)
|
|
||||||
#define RESP_FORMAT_ERROR (1)
|
|
||||||
#define RESP_SERVER_FAILURE (2)
|
|
||||||
#define RESP_NAME_ERROR (3)
|
|
||||||
#define RESP_NOT_IMPLEMENTED (4)
|
|
||||||
#define RESP_REFUSED (5)
|
|
||||||
#define RESP_MASK (15)
|
|
||||||
#define TYPE_A (0x0001)
|
|
||||||
#define CLASS_IN (0x0001)
|
|
||||||
#define LABEL_COMPRESSION_MASK (0xC0)
|
|
||||||
// Port number that DNS servers listen on
|
|
||||||
#define DNS_PORT 53
|
|
||||||
|
|
||||||
// Possible return codes from ProcessResponse
|
|
||||||
#define SUCCESS 1
|
|
||||||
#define TIMED_OUT -1
|
|
||||||
#define INVALID_SERVER -2
|
|
||||||
#define TRUNCATED -3
|
|
||||||
#define INVALID_RESPONSE -4
|
|
||||||
|
|
||||||
void DNSClient::begin(const IPAddress& aDNSServer)
|
|
||||||
{
|
|
||||||
iDNSServer = aDNSServer;
|
|
||||||
iRequestId = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int DNSClient::inet_aton(const char* aIPAddrString, IPAddress& aResult)
|
|
||||||
{
|
|
||||||
// See if we've been given a valid IP address
|
|
||||||
const char* p =aIPAddrString;
|
|
||||||
while (*p &&
|
|
||||||
( (*p == '.') || (*p >= '0') || (*p <= '9') ))
|
|
||||||
{
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (*p == '\0')
|
|
||||||
{
|
|
||||||
// It's looking promising, we haven't found any invalid characters
|
|
||||||
p = aIPAddrString;
|
|
||||||
int segment =0;
|
|
||||||
int segmentValue =0;
|
|
||||||
while (*p && (segment < 4))
|
|
||||||
{
|
|
||||||
if (*p == '.')
|
|
||||||
{
|
|
||||||
// We've reached the end of a segment
|
|
||||||
if (segmentValue > 255)
|
|
||||||
{
|
|
||||||
// You can't have IP address segments that don't fit in a byte
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
aResult[segment] = (byte)segmentValue;
|
|
||||||
segment++;
|
|
||||||
segmentValue = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// Next digit
|
|
||||||
segmentValue = (segmentValue*10)+(*p - '0');
|
|
||||||
}
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
// We've reached the end of address, but there'll still be the last
|
|
||||||
// segment to deal with
|
|
||||||
if ((segmentValue > 255) || (segment > 3))
|
|
||||||
{
|
|
||||||
// You can't have IP address segments that don't fit in a byte,
|
|
||||||
// or more than four segments
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
aResult[segment] = (byte)segmentValue;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int DNSClient::getHostByName(const char* aHostname, IPAddress& aResult)
|
|
||||||
{
|
|
||||||
int ret =0;
|
|
||||||
|
|
||||||
// See if it's a numeric IP address
|
|
||||||
if (inet_aton(aHostname, aResult))
|
|
||||||
{
|
|
||||||
// It is, our work here is done
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check we've got a valid DNS server to use
|
|
||||||
if (iDNSServer == INADDR_NONE)
|
|
||||||
{
|
|
||||||
return INVALID_SERVER;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find a socket to use
|
|
||||||
if (iUdp.begin(1024+(millis() & 0xF)) == 1)
|
|
||||||
{
|
|
||||||
// Try up to three times
|
|
||||||
int retries = 0;
|
|
||||||
// while ((retries < 3) && (ret <= 0))
|
|
||||||
{
|
|
||||||
// Send DNS request
|
|
||||||
ret = iUdp.beginPacket(iDNSServer, DNS_PORT);
|
|
||||||
if (ret != 0)
|
|
||||||
{
|
|
||||||
// Now output the request data
|
|
||||||
ret = BuildRequest(aHostname);
|
|
||||||
if (ret != 0)
|
|
||||||
{
|
|
||||||
// And finally send the request
|
|
||||||
ret = iUdp.endPacket();
|
|
||||||
if (ret != 0)
|
|
||||||
{
|
|
||||||
// Now wait for a response
|
|
||||||
int wait_retries = 0;
|
|
||||||
ret = TIMED_OUT;
|
|
||||||
while ((wait_retries < 3) && (ret == TIMED_OUT))
|
|
||||||
{
|
|
||||||
ret = ProcessResponse(5000, aResult);
|
|
||||||
wait_retries++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
retries++;
|
|
||||||
}
|
|
||||||
|
|
||||||
// We're done with the socket now
|
|
||||||
iUdp.stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t DNSClient::BuildRequest(const char* aName)
|
|
||||||
{
|
|
||||||
// Build header
|
|
||||||
// 1 1 1 1 1 1
|
|
||||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// | ID |
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// |QR| Opcode |AA|TC|RD|RA| Z | RCODE |
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// | QDCOUNT |
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// | ANCOUNT |
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// | NSCOUNT |
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// | ARCOUNT |
|
|
||||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
|
||||||
// As we only support one request at a time at present, we can simplify
|
|
||||||
// some of this header
|
|
||||||
iRequestId = millis(); // generate a random ID
|
|
||||||
uint16_t twoByteBuffer;
|
|
||||||
|
|
||||||
// FIXME We should also check that there's enough space available to write to, rather
|
|
||||||
// FIXME than assume there's enough space (as the code does at present)
|
|
||||||
iUdp.write((uint8_t*)&iRequestId, sizeof(iRequestId));
|
|
||||||
|
|
||||||
twoByteBuffer = htons(QUERY_FLAG | OPCODE_STANDARD_QUERY | RECURSION_DESIRED_FLAG);
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
|
|
||||||
twoByteBuffer = htons(1); // One question record
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
|
|
||||||
twoByteBuffer = 0; // Zero answer records
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
// and zero additional records
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
|
|
||||||
// Build question
|
|
||||||
const char* start =aName;
|
|
||||||
const char* end =start;
|
|
||||||
uint8_t len;
|
|
||||||
// Run through the name being requested
|
|
||||||
while (*end)
|
|
||||||
{
|
|
||||||
// Find out how long this section of the name is
|
|
||||||
end = start;
|
|
||||||
while (*end && (*end != '.') )
|
|
||||||
{
|
|
||||||
end++;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (end-start > 0)
|
|
||||||
{
|
|
||||||
// Write out the size of this section
|
|
||||||
len = end-start;
|
|
||||||
iUdp.write(&len, sizeof(len));
|
|
||||||
// And then write out the section
|
|
||||||
iUdp.write((uint8_t*)start, end-start);
|
|
||||||
}
|
|
||||||
start = end+1;
|
|
||||||
}
|
|
||||||
|
|
||||||
// We've got to the end of the question name, so
|
|
||||||
// terminate it with a zero-length section
|
|
||||||
len = 0;
|
|
||||||
iUdp.write(&len, sizeof(len));
|
|
||||||
// Finally the type and class of question
|
|
||||||
twoByteBuffer = htons(TYPE_A);
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
|
|
||||||
twoByteBuffer = htons(CLASS_IN); // Internet class of question
|
|
||||||
iUdp.write((uint8_t*)&twoByteBuffer, sizeof(twoByteBuffer));
|
|
||||||
// Success! Everything buffered okay
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
uint16_t DNSClient::ProcessResponse(uint16_t aTimeout, IPAddress& aAddress)
|
|
||||||
{
|
|
||||||
uint32_t startTime = millis();
|
|
||||||
|
|
||||||
// Wait for a response packet
|
|
||||||
while(iUdp.parsePacket() <= 0)
|
|
||||||
{
|
|
||||||
if((millis() - startTime) > aTimeout)
|
|
||||||
return TIMED_OUT;
|
|
||||||
delay(50);
|
|
||||||
}
|
|
||||||
|
|
||||||
// We've had a reply!
|
|
||||||
// Read the UDP header
|
|
||||||
uint8_t header[DNS_HEADER_SIZE]; // Enough space to reuse for the DNS header
|
|
||||||
// Check that it's a response from the right server and the right port
|
|
||||||
if ( (iDNSServer != iUdp.remoteIP()) ||
|
|
||||||
(iUdp.remotePort() != DNS_PORT) )
|
|
||||||
{
|
|
||||||
// It's not from who we expected
|
|
||||||
return INVALID_SERVER;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read through the rest of the response
|
|
||||||
if (iUdp.available() < DNS_HEADER_SIZE)
|
|
||||||
{
|
|
||||||
return TRUNCATED;
|
|
||||||
}
|
|
||||||
iUdp.read(header, DNS_HEADER_SIZE);
|
|
||||||
|
|
||||||
uint16_t header_flags = htons(*((uint16_t*)&header[2]));
|
|
||||||
// Check that it's a response to this request
|
|
||||||
if ( ( iRequestId != (*((uint16_t*)&header[0])) ) ||
|
|
||||||
((header_flags & QUERY_RESPONSE_MASK) != (uint16_t)RESPONSE_FLAG) )
|
|
||||||
{
|
|
||||||
// Mark the entire packet as read
|
|
||||||
iUdp.flush();
|
|
||||||
return INVALID_RESPONSE;
|
|
||||||
}
|
|
||||||
// Check for any errors in the response (or in our request)
|
|
||||||
// although we don't do anything to get round these
|
|
||||||
if ( (header_flags & TRUNCATION_FLAG) || (header_flags & RESP_MASK) )
|
|
||||||
{
|
|
||||||
// Mark the entire packet as read
|
|
||||||
iUdp.flush();
|
|
||||||
return -5; //INVALID_RESPONSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
// And make sure we've got (at least) one answer
|
|
||||||
uint16_t answerCount = htons(*((uint16_t*)&header[6]));
|
|
||||||
if (answerCount == 0 )
|
|
||||||
{
|
|
||||||
// Mark the entire packet as read
|
|
||||||
iUdp.flush();
|
|
||||||
return -6; //INVALID_RESPONSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Skip over any questions
|
|
||||||
for (uint16_t i =0; i < htons(*((uint16_t*)&header[4])); i++)
|
|
||||||
{
|
|
||||||
// Skip over the name
|
|
||||||
uint8_t len;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
iUdp.read(&len, sizeof(len));
|
|
||||||
if (len > 0)
|
|
||||||
{
|
|
||||||
// Don't need to actually read the data out for the string, just
|
|
||||||
// advance ptr to beyond it
|
|
||||||
while(len--)
|
|
||||||
{
|
|
||||||
iUdp.read(); // we don't care about the returned byte
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} while (len != 0);
|
|
||||||
|
|
||||||
// Now jump over the type and class
|
|
||||||
for (int i =0; i < 4; i++)
|
|
||||||
{
|
|
||||||
iUdp.read(); // we don't care about the returned byte
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now we're up to the bit we're interested in, the answer
|
|
||||||
// There might be more than one answer (although we'll just use the first
|
|
||||||
// type A answer) and some authority and additional resource records but
|
|
||||||
// we're going to ignore all of them.
|
|
||||||
|
|
||||||
for (uint16_t i =0; i < answerCount; i++)
|
|
||||||
{
|
|
||||||
// Skip the name
|
|
||||||
uint8_t len;
|
|
||||||
do
|
|
||||||
{
|
|
||||||
iUdp.read(&len, sizeof(len));
|
|
||||||
if ((len & LABEL_COMPRESSION_MASK) == 0)
|
|
||||||
{
|
|
||||||
// It's just a normal label
|
|
||||||
if (len > 0)
|
|
||||||
{
|
|
||||||
// And it's got a length
|
|
||||||
// Don't need to actually read the data out for the string,
|
|
||||||
// just advance ptr to beyond it
|
|
||||||
while(len--)
|
|
||||||
{
|
|
||||||
iUdp.read(); // we don't care about the returned byte
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// This is a pointer to a somewhere else in the message for the
|
|
||||||
// rest of the name. We don't care about the name, and RFC1035
|
|
||||||
// says that a name is either a sequence of labels ended with a
|
|
||||||
// 0 length octet or a pointer or a sequence of labels ending in
|
|
||||||
// a pointer. Either way, when we get here we're at the end of
|
|
||||||
// the name
|
|
||||||
// Skip over the pointer
|
|
||||||
iUdp.read(); // we don't care about the returned byte
|
|
||||||
// And set len so that we drop out of the name loop
|
|
||||||
len = 0;
|
|
||||||
}
|
|
||||||
} while (len != 0);
|
|
||||||
|
|
||||||
// Check the type and class
|
|
||||||
uint16_t answerType;
|
|
||||||
uint16_t answerClass;
|
|
||||||
iUdp.read((uint8_t*)&answerType, sizeof(answerType));
|
|
||||||
iUdp.read((uint8_t*)&answerClass, sizeof(answerClass));
|
|
||||||
|
|
||||||
// Ignore the Time-To-Live as we don't do any caching
|
|
||||||
for (int i =0; i < TTL_SIZE; i++)
|
|
||||||
{
|
|
||||||
iUdp.read(); // we don't care about the returned byte
|
|
||||||
}
|
|
||||||
|
|
||||||
// And read out the length of this answer
|
|
||||||
// Don't need header_flags anymore, so we can reuse it here
|
|
||||||
iUdp.read((uint8_t*)&header_flags, sizeof(header_flags));
|
|
||||||
|
|
||||||
if ( (htons(answerType) == TYPE_A) && (htons(answerClass) == CLASS_IN) )
|
|
||||||
{
|
|
||||||
if (htons(header_flags) != 4)
|
|
||||||
{
|
|
||||||
// It's a weird size
|
|
||||||
// Mark the entire packet as read
|
|
||||||
iUdp.flush();
|
|
||||||
return -9;//INVALID_RESPONSE;
|
|
||||||
}
|
|
||||||
iUdp.read(aAddress.raw_address(), 4);
|
|
||||||
return SUCCESS;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// This isn't an answer type we're after, move onto the next one
|
|
||||||
for (uint16_t i =0; i < htons(header_flags); i++)
|
|
||||||
{
|
|
||||||
iUdp.read(); // we don't care about the returned byte
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Mark the entire packet as read
|
|
||||||
iUdp.flush();
|
|
||||||
|
|
||||||
// If we get here then we haven't found an answer
|
|
||||||
return -10;//INVALID_RESPONSE;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,41 +0,0 @@
|
||||||
// Arduino DNS client for WizNet5100-based Ethernet shield
|
|
||||||
// (c) Copyright 2009-2010 MCQN Ltd.
|
|
||||||
// Released under Apache License, version 2.0
|
|
||||||
|
|
||||||
#ifndef DNSClient_h
|
|
||||||
#define DNSClient_h
|
|
||||||
|
|
||||||
#include <EthernetUdp.h>
|
|
||||||
|
|
||||||
class DNSClient
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
// ctor
|
|
||||||
void begin(const IPAddress& aDNSServer);
|
|
||||||
|
|
||||||
/** Convert a numeric IP address string into a four-byte IP address.
|
|
||||||
@param aIPAddrString IP address to convert
|
|
||||||
@param aResult IPAddress structure to store the returned IP address
|
|
||||||
@result 1 if aIPAddrString was successfully converted to an IP address,
|
|
||||||
else error code
|
|
||||||
*/
|
|
||||||
int inet_aton(const char *aIPAddrString, IPAddress& aResult);
|
|
||||||
|
|
||||||
/** Resolve the given hostname to an IP address.
|
|
||||||
@param aHostname Name to be resolved
|
|
||||||
@param aResult IPAddress structure to store the returned IP address
|
|
||||||
@result 1 if aIPAddrString was successfully converted to an IP address,
|
|
||||||
else error code
|
|
||||||
*/
|
|
||||||
int getHostByName(const char* aHostname, IPAddress& aResult);
|
|
||||||
|
|
||||||
protected:
|
|
||||||
uint16_t BuildRequest(const char* aName);
|
|
||||||
uint16_t ProcessResponse(uint16_t aTimeout, IPAddress& aAddress);
|
|
||||||
|
|
||||||
IPAddress iDNSServer;
|
|
||||||
uint16_t iRequestId;
|
|
||||||
EthernetUDP iUdp;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,122 +0,0 @@
|
||||||
#include "w5100.h"
|
|
||||||
#include "Ethernet.h"
|
|
||||||
#include "Dhcp.h"
|
|
||||||
|
|
||||||
// XXX: don't make assumptions about the value of MAX_SOCK_NUM.
|
|
||||||
uint8_t EthernetClass::_state[MAX_SOCK_NUM] = {
|
|
||||||
0, 0, 0, 0 };
|
|
||||||
uint16_t EthernetClass::_server_port[MAX_SOCK_NUM] = {
|
|
||||||
0, 0, 0, 0 };
|
|
||||||
|
|
||||||
int EthernetClass::begin(uint8_t *mac_address)
|
|
||||||
{
|
|
||||||
static DhcpClass s_dhcp;
|
|
||||||
_dhcp = &s_dhcp;
|
|
||||||
|
|
||||||
|
|
||||||
// Initialise the basic info
|
|
||||||
W5100.init();
|
|
||||||
W5100.setMACAddress(mac_address);
|
|
||||||
W5100.setIPAddress(IPAddress(0,0,0,0).raw_address());
|
|
||||||
|
|
||||||
// Now try to get our config info from a DHCP server
|
|
||||||
int ret = _dhcp->beginWithDHCP(mac_address);
|
|
||||||
if(ret == 1)
|
|
||||||
{
|
|
||||||
// We've successfully found a DHCP server and got our configuration info, so set things
|
|
||||||
// accordingly
|
|
||||||
W5100.setIPAddress(_dhcp->getLocalIp().raw_address());
|
|
||||||
W5100.setGatewayIp(_dhcp->getGatewayIp().raw_address());
|
|
||||||
W5100.setSubnetMask(_dhcp->getSubnetMask().raw_address());
|
|
||||||
_dnsServerAddress = _dhcp->getDnsServerIp();
|
|
||||||
}
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip)
|
|
||||||
{
|
|
||||||
// Assume the DNS server will be the machine on the same network as the local IP
|
|
||||||
// but with last octet being '1'
|
|
||||||
IPAddress dns_server = local_ip;
|
|
||||||
dns_server[3] = 1;
|
|
||||||
begin(mac_address, local_ip, dns_server);
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server)
|
|
||||||
{
|
|
||||||
// Assume the gateway will be the machine on the same network as the local IP
|
|
||||||
// but with last octet being '1'
|
|
||||||
IPAddress gateway = local_ip;
|
|
||||||
gateway[3] = 1;
|
|
||||||
begin(mac_address, local_ip, dns_server, gateway);
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway)
|
|
||||||
{
|
|
||||||
IPAddress subnet(255, 255, 255, 0);
|
|
||||||
begin(mac_address, local_ip, dns_server, gateway, subnet);
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet)
|
|
||||||
{
|
|
||||||
W5100.init();
|
|
||||||
W5100.setMACAddress(mac);
|
|
||||||
W5100.setIPAddress(local_ip._address);
|
|
||||||
W5100.setGatewayIp(gateway._address);
|
|
||||||
W5100.setSubnetMask(subnet._address);
|
|
||||||
_dnsServerAddress = dns_server;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClass::maintain(){
|
|
||||||
int rc = DHCP_CHECK_NONE;
|
|
||||||
if(_dhcp != NULL){
|
|
||||||
//we have a pointer to dhcp, use it
|
|
||||||
rc = _dhcp->checkLease();
|
|
||||||
switch ( rc ){
|
|
||||||
case DHCP_CHECK_NONE:
|
|
||||||
//nothing done
|
|
||||||
break;
|
|
||||||
case DHCP_CHECK_RENEW_OK:
|
|
||||||
case DHCP_CHECK_REBIND_OK:
|
|
||||||
//we might have got a new IP.
|
|
||||||
W5100.setIPAddress(_dhcp->getLocalIp().raw_address());
|
|
||||||
W5100.setGatewayIp(_dhcp->getGatewayIp().raw_address());
|
|
||||||
W5100.setSubnetMask(_dhcp->getSubnetMask().raw_address());
|
|
||||||
_dnsServerAddress = _dhcp->getDnsServerIp();
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
//this is actually a error, it will retry though
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return rc;
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress EthernetClass::localIP()
|
|
||||||
{
|
|
||||||
IPAddress ret;
|
|
||||||
W5100.getIPAddress(ret.raw_address());
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress EthernetClass::subnetMask()
|
|
||||||
{
|
|
||||||
IPAddress ret;
|
|
||||||
W5100.getSubnetMask(ret.raw_address());
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress EthernetClass::gatewayIP()
|
|
||||||
{
|
|
||||||
IPAddress ret;
|
|
||||||
W5100.getGatewayIp(ret.raw_address());
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
IPAddress EthernetClass::dnsServerIP()
|
|
||||||
{
|
|
||||||
return _dnsServerAddress;
|
|
||||||
}
|
|
||||||
|
|
||||||
EthernetClass Ethernet;
|
|
|
@ -1,41 +0,0 @@
|
||||||
#ifndef ethernet_h
|
|
||||||
#define ethernet_h
|
|
||||||
|
|
||||||
#include <inttypes.h>
|
|
||||||
//#include "w5100.h"
|
|
||||||
#include "IPAddress.h"
|
|
||||||
#include "EthernetClient.h"
|
|
||||||
#include "EthernetServer.h"
|
|
||||||
#include "Dhcp.h"
|
|
||||||
|
|
||||||
#define MAX_SOCK_NUM 4
|
|
||||||
|
|
||||||
class EthernetClass {
|
|
||||||
private:
|
|
||||||
IPAddress _dnsServerAddress;
|
|
||||||
DhcpClass* _dhcp;
|
|
||||||
public:
|
|
||||||
static uint8_t _state[MAX_SOCK_NUM];
|
|
||||||
static uint16_t _server_port[MAX_SOCK_NUM];
|
|
||||||
// Initialise the Ethernet shield to use the provided MAC address and gain the rest of the
|
|
||||||
// configuration through DHCP.
|
|
||||||
// Returns 0 if the DHCP configuration failed, and 1 if it succeeded
|
|
||||||
int begin(uint8_t *mac_address);
|
|
||||||
void begin(uint8_t *mac_address, IPAddress local_ip);
|
|
||||||
void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server);
|
|
||||||
void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway);
|
|
||||||
void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress dns_server, IPAddress gateway, IPAddress subnet);
|
|
||||||
int maintain();
|
|
||||||
|
|
||||||
IPAddress localIP();
|
|
||||||
IPAddress subnetMask();
|
|
||||||
IPAddress gatewayIP();
|
|
||||||
IPAddress dnsServerIP();
|
|
||||||
|
|
||||||
friend class EthernetClient;
|
|
||||||
friend class EthernetServer;
|
|
||||||
};
|
|
||||||
|
|
||||||
extern EthernetClass Ethernet;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,165 +0,0 @@
|
||||||
#include "w5100.h"
|
|
||||||
#include "socket.h"
|
|
||||||
|
|
||||||
extern "C" {
|
|
||||||
#include "string.h"
|
|
||||||
}
|
|
||||||
|
|
||||||
#include "Arduino.h"
|
|
||||||
|
|
||||||
#include "Ethernet.h"
|
|
||||||
#include "EthernetClient.h"
|
|
||||||
#include "EthernetServer.h"
|
|
||||||
#include "Dns.h"
|
|
||||||
|
|
||||||
uint16_t EthernetClient::_srcport = 1024;
|
|
||||||
|
|
||||||
EthernetClient::EthernetClient() : _sock(MAX_SOCK_NUM) {
|
|
||||||
}
|
|
||||||
|
|
||||||
EthernetClient::EthernetClient(uint8_t sock) : _sock(sock) {
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClient::connect(const char* host, uint16_t port) {
|
|
||||||
// Look up the host first
|
|
||||||
int ret = 0;
|
|
||||||
DNSClient dns;
|
|
||||||
IPAddress remote_addr;
|
|
||||||
|
|
||||||
dns.begin(Ethernet.dnsServerIP());
|
|
||||||
ret = dns.getHostByName(host, remote_addr);
|
|
||||||
if (ret == 1) {
|
|
||||||
return connect(remote_addr, port);
|
|
||||||
} else {
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClient::connect(IPAddress ip, uint16_t port) {
|
|
||||||
if (_sock != MAX_SOCK_NUM)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < MAX_SOCK_NUM; i++) {
|
|
||||||
uint8_t s = W5100.readSnSR(i);
|
|
||||||
if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT || s == SnSR::CLOSE_WAIT) {
|
|
||||||
_sock = i;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (_sock == MAX_SOCK_NUM)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
_srcport++;
|
|
||||||
if (_srcport == 0) _srcport = 1024;
|
|
||||||
socket(_sock, SnMR::TCP, _srcport, 0);
|
|
||||||
|
|
||||||
if (!::connect(_sock, rawIPAddress(ip), port)) {
|
|
||||||
_sock = MAX_SOCK_NUM;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
while (status() != SnSR::ESTABLISHED) {
|
|
||||||
delay(1);
|
|
||||||
if (status() == SnSR::CLOSED) {
|
|
||||||
_sock = MAX_SOCK_NUM;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t EthernetClient::write(uint8_t b) {
|
|
||||||
return write(&b, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t EthernetClient::write(const uint8_t *buf, size_t size) {
|
|
||||||
if (_sock == MAX_SOCK_NUM) {
|
|
||||||
setWriteError();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if (!send(_sock, buf, size)) {
|
|
||||||
setWriteError();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClient::available() {
|
|
||||||
if (_sock != MAX_SOCK_NUM)
|
|
||||||
return W5100.getRXReceivedSize(_sock);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClient::read() {
|
|
||||||
uint8_t b;
|
|
||||||
if ( recv(_sock, &b, 1) > 0 )
|
|
||||||
{
|
|
||||||
// recv worked
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// No data available
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClient::read(uint8_t *buf, size_t size) {
|
|
||||||
return recv(_sock, buf, size);
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetClient::peek() {
|
|
||||||
uint8_t b;
|
|
||||||
// Unlike recv, peek doesn't check to see if there's any data available, so we must
|
|
||||||
if (!available())
|
|
||||||
return -1;
|
|
||||||
::peek(_sock, &b);
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetClient::flush() {
|
|
||||||
while (available())
|
|
||||||
read();
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetClient::stop() {
|
|
||||||
if (_sock == MAX_SOCK_NUM)
|
|
||||||
return;
|
|
||||||
|
|
||||||
// attempt to close the connection gracefully (send a FIN to other side)
|
|
||||||
disconnect(_sock);
|
|
||||||
unsigned long start = millis();
|
|
||||||
|
|
||||||
// wait a second for the connection to close
|
|
||||||
while (status() != SnSR::CLOSED && millis() - start < 1000)
|
|
||||||
delay(1);
|
|
||||||
|
|
||||||
// if it hasn't closed, close it forcefully
|
|
||||||
if (status() != SnSR::CLOSED)
|
|
||||||
close(_sock);
|
|
||||||
|
|
||||||
EthernetClass::_server_port[_sock] = 0;
|
|
||||||
_sock = MAX_SOCK_NUM;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t EthernetClient::connected() {
|
|
||||||
if (_sock == MAX_SOCK_NUM) return 0;
|
|
||||||
|
|
||||||
uint8_t s = status();
|
|
||||||
return !(s == SnSR::LISTEN || s == SnSR::CLOSED || s == SnSR::FIN_WAIT ||
|
|
||||||
(s == SnSR::CLOSE_WAIT && !available()));
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t EthernetClient::status() {
|
|
||||||
if (_sock == MAX_SOCK_NUM) return SnSR::CLOSED;
|
|
||||||
return W5100.readSnSR(_sock);
|
|
||||||
}
|
|
||||||
|
|
||||||
// the next function allows us to use the client returned by
|
|
||||||
// EthernetServer::available() as the condition in an if-statement.
|
|
||||||
|
|
||||||
EthernetClient::operator bool() {
|
|
||||||
return _sock != MAX_SOCK_NUM;
|
|
||||||
}
|
|
|
@ -1,37 +0,0 @@
|
||||||
#ifndef ethernetclient_h
|
|
||||||
#define ethernetclient_h
|
|
||||||
#include "Arduino.h"
|
|
||||||
#include "Print.h"
|
|
||||||
#include "Client.h"
|
|
||||||
#include "IPAddress.h"
|
|
||||||
|
|
||||||
class EthernetClient : public Client {
|
|
||||||
|
|
||||||
public:
|
|
||||||
EthernetClient();
|
|
||||||
EthernetClient(uint8_t sock);
|
|
||||||
|
|
||||||
uint8_t status();
|
|
||||||
virtual int connect(IPAddress ip, uint16_t port);
|
|
||||||
virtual int connect(const char *host, uint16_t port);
|
|
||||||
virtual size_t write(uint8_t);
|
|
||||||
virtual size_t write(const uint8_t *buf, size_t size);
|
|
||||||
virtual int available();
|
|
||||||
virtual int read();
|
|
||||||
virtual int read(uint8_t *buf, size_t size);
|
|
||||||
virtual int peek();
|
|
||||||
virtual void flush();
|
|
||||||
virtual void stop();
|
|
||||||
virtual uint8_t connected();
|
|
||||||
virtual operator bool();
|
|
||||||
|
|
||||||
friend class EthernetServer;
|
|
||||||
|
|
||||||
using Print::write;
|
|
||||||
|
|
||||||
private:
|
|
||||||
static uint16_t _srcport;
|
|
||||||
uint8_t _sock;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,91 +0,0 @@
|
||||||
#include "w5100.h"
|
|
||||||
#include "socket.h"
|
|
||||||
extern "C" {
|
|
||||||
#include "string.h"
|
|
||||||
}
|
|
||||||
|
|
||||||
#include "Ethernet.h"
|
|
||||||
#include "EthernetClient.h"
|
|
||||||
#include "EthernetServer.h"
|
|
||||||
|
|
||||||
EthernetServer::EthernetServer(uint16_t port)
|
|
||||||
{
|
|
||||||
_port = port;
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetServer::begin()
|
|
||||||
{
|
|
||||||
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
|
|
||||||
EthernetClient client(sock);
|
|
||||||
if (client.status() == SnSR::CLOSED) {
|
|
||||||
socket(sock, SnMR::TCP, _port, 0);
|
|
||||||
listen(sock);
|
|
||||||
EthernetClass::_server_port[sock] = _port;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetServer::accept()
|
|
||||||
{
|
|
||||||
int listening = 0;
|
|
||||||
|
|
||||||
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
|
|
||||||
EthernetClient client(sock);
|
|
||||||
|
|
||||||
if (EthernetClass::_server_port[sock] == _port) {
|
|
||||||
if (client.status() == SnSR::LISTEN) {
|
|
||||||
listening = 1;
|
|
||||||
}
|
|
||||||
else if (client.status() == SnSR::CLOSE_WAIT && !client.available()) {
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!listening) {
|
|
||||||
begin();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
EthernetClient EthernetServer::available()
|
|
||||||
{
|
|
||||||
accept();
|
|
||||||
|
|
||||||
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
|
|
||||||
EthernetClient client(sock);
|
|
||||||
if (EthernetClass::_server_port[sock] == _port &&
|
|
||||||
(client.status() == SnSR::ESTABLISHED ||
|
|
||||||
client.status() == SnSR::CLOSE_WAIT)) {
|
|
||||||
if (client.available()) {
|
|
||||||
// XXX: don't always pick the lowest numbered socket.
|
|
||||||
return client;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return EthernetClient(MAX_SOCK_NUM);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t EthernetServer::write(uint8_t b)
|
|
||||||
{
|
|
||||||
return write(&b, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t EthernetServer::write(const uint8_t *buffer, size_t size)
|
|
||||||
{
|
|
||||||
size_t n = 0;
|
|
||||||
|
|
||||||
accept();
|
|
||||||
|
|
||||||
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
|
|
||||||
EthernetClient client(sock);
|
|
||||||
|
|
||||||
if (EthernetClass::_server_port[sock] == _port &&
|
|
||||||
client.status() == SnSR::ESTABLISHED) {
|
|
||||||
n += client.write(buffer, size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return n;
|
|
||||||
}
|
|
|
@ -1,22 +0,0 @@
|
||||||
#ifndef ethernetserver_h
|
|
||||||
#define ethernetserver_h
|
|
||||||
|
|
||||||
#include "Server.h"
|
|
||||||
|
|
||||||
class EthernetClient;
|
|
||||||
|
|
||||||
class EthernetServer :
|
|
||||||
public Server {
|
|
||||||
private:
|
|
||||||
uint16_t _port;
|
|
||||||
void accept();
|
|
||||||
public:
|
|
||||||
EthernetServer(uint16_t);
|
|
||||||
EthernetClient available();
|
|
||||||
virtual void begin();
|
|
||||||
virtual size_t write(uint8_t);
|
|
||||||
virtual size_t write(const uint8_t *buf, size_t size);
|
|
||||||
using Print::write;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,218 +0,0 @@
|
||||||
/*
|
|
||||||
* Udp.cpp: Library to send/receive UDP packets with the Arduino ethernet shield.
|
|
||||||
* This version only offers minimal wrapping of socket.c/socket.h
|
|
||||||
* Drop Udp.h/.cpp into the Ethernet library directory at hardware/libraries/Ethernet/
|
|
||||||
*
|
|
||||||
* MIT License:
|
|
||||||
* Copyright (c) 2008 Bjoern Hartmann
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* bjoern@cs.stanford.edu 12/30/2008
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "w5100.h"
|
|
||||||
#include "socket.h"
|
|
||||||
#include "Ethernet.h"
|
|
||||||
#include "Udp.h"
|
|
||||||
#include "Dns.h"
|
|
||||||
|
|
||||||
/* Constructor */
|
|
||||||
EthernetUDP::EthernetUDP() : _sock(MAX_SOCK_NUM) {}
|
|
||||||
|
|
||||||
/* Start EthernetUDP socket, listening at local port PORT */
|
|
||||||
uint8_t EthernetUDP::begin(uint16_t port) {
|
|
||||||
if (_sock != MAX_SOCK_NUM)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < MAX_SOCK_NUM; i++) {
|
|
||||||
uint8_t s = W5100.readSnSR(i);
|
|
||||||
if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT) {
|
|
||||||
_sock = i;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (_sock == MAX_SOCK_NUM)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
_port = port;
|
|
||||||
_remaining = 0;
|
|
||||||
socket(_sock, SnMR::UDP, _port, 0);
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return number of bytes available in the current packet,
|
|
||||||
will return zero if parsePacket hasn't been called yet */
|
|
||||||
int EthernetUDP::available() {
|
|
||||||
return _remaining;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Release any resources being used by this EthernetUDP instance */
|
|
||||||
void EthernetUDP::stop()
|
|
||||||
{
|
|
||||||
if (_sock == MAX_SOCK_NUM)
|
|
||||||
return;
|
|
||||||
|
|
||||||
close(_sock);
|
|
||||||
|
|
||||||
EthernetClass::_server_port[_sock] = 0;
|
|
||||||
_sock = MAX_SOCK_NUM;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::beginPacket(const char *host, uint16_t port)
|
|
||||||
{
|
|
||||||
// Look up the host first
|
|
||||||
int ret = 0;
|
|
||||||
DNSClient dns;
|
|
||||||
IPAddress remote_addr;
|
|
||||||
|
|
||||||
dns.begin(Ethernet.dnsServerIP());
|
|
||||||
ret = dns.getHostByName(host, remote_addr);
|
|
||||||
if (ret == 1) {
|
|
||||||
return beginPacket(remote_addr, port);
|
|
||||||
} else {
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::beginPacket(IPAddress ip, uint16_t port)
|
|
||||||
{
|
|
||||||
_offset = 0;
|
|
||||||
return startUDP(_sock, rawIPAddress(ip), port);
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::endPacket()
|
|
||||||
{
|
|
||||||
return sendUDP(_sock);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t EthernetUDP::write(uint8_t byte)
|
|
||||||
{
|
|
||||||
return write(&byte, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t EthernetUDP::write(const uint8_t *buffer, size_t size)
|
|
||||||
{
|
|
||||||
uint16_t bytes_written = bufferData(_sock, _offset, buffer, size);
|
|
||||||
_offset += bytes_written;
|
|
||||||
return bytes_written;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::parsePacket()
|
|
||||||
{
|
|
||||||
// discard any remaining bytes in the last packet
|
|
||||||
flush();
|
|
||||||
|
|
||||||
if (W5100.getRXReceivedSize(_sock) > 0)
|
|
||||||
{
|
|
||||||
//HACK - hand-parse the UDP packet using TCP recv method
|
|
||||||
uint8_t tmpBuf[8];
|
|
||||||
int ret =0;
|
|
||||||
//read 8 header bytes and get IP and port from it
|
|
||||||
ret = recv(_sock,tmpBuf,8);
|
|
||||||
if (ret > 0)
|
|
||||||
{
|
|
||||||
_remoteIP = tmpBuf;
|
|
||||||
_remotePort = tmpBuf[4];
|
|
||||||
_remotePort = (_remotePort << 8) + tmpBuf[5];
|
|
||||||
_remaining = tmpBuf[6];
|
|
||||||
_remaining = (_remaining << 8) + tmpBuf[7];
|
|
||||||
|
|
||||||
// When we get here, any remaining bytes are the data
|
|
||||||
ret = _remaining;
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
// There aren't any packets available
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::read()
|
|
||||||
{
|
|
||||||
uint8_t byte;
|
|
||||||
|
|
||||||
if ((_remaining > 0) && (recv(_sock, &byte, 1) > 0))
|
|
||||||
{
|
|
||||||
// We read things without any problems
|
|
||||||
_remaining--;
|
|
||||||
return byte;
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we get here, there's no data available
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::read(unsigned char* buffer, size_t len)
|
|
||||||
{
|
|
||||||
|
|
||||||
if (_remaining > 0)
|
|
||||||
{
|
|
||||||
|
|
||||||
int got;
|
|
||||||
|
|
||||||
if (_remaining <= len)
|
|
||||||
{
|
|
||||||
// data should fit in the buffer
|
|
||||||
got = recv(_sock, buffer, _remaining);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// too much data for the buffer,
|
|
||||||
// grab as much as will fit
|
|
||||||
got = recv(_sock, buffer, len);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (got > 0)
|
|
||||||
{
|
|
||||||
_remaining -= got;
|
|
||||||
return got;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we get here, there's no data available or recv failed
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
int EthernetUDP::peek()
|
|
||||||
{
|
|
||||||
uint8_t b;
|
|
||||||
// Unlike recv, peek doesn't check to see if there's any data available, so we must.
|
|
||||||
// If the user hasn't called parsePacket yet then return nothing otherwise they
|
|
||||||
// may get the UDP header
|
|
||||||
if (!_remaining)
|
|
||||||
return -1;
|
|
||||||
::peek(_sock, &b);
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
void EthernetUDP::flush()
|
|
||||||
{
|
|
||||||
// could this fail (loop endlessly) if _remaining > 0 and recv in read fails?
|
|
||||||
// should only occur if recv fails after telling us the data is there, lets
|
|
||||||
// hope the w5100 always behaves :)
|
|
||||||
|
|
||||||
while (_remaining)
|
|
||||||
{
|
|
||||||
read();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,99 +0,0 @@
|
||||||
/*
|
|
||||||
* Udp.cpp: Library to send/receive UDP packets with the Arduino ethernet shield.
|
|
||||||
* This version only offers minimal wrapping of socket.c/socket.h
|
|
||||||
* Drop Udp.h/.cpp into the Ethernet library directory at hardware/libraries/Ethernet/
|
|
||||||
*
|
|
||||||
* NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
|
|
||||||
* 1) UDP does not guarantee the order in which assembled UDP packets are received. This
|
|
||||||
* might not happen often in practice, but in larger network topologies, a UDP
|
|
||||||
* packet can be received out of sequence.
|
|
||||||
* 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
|
|
||||||
* aware of it. Again, this may not be a concern in practice on small local networks.
|
|
||||||
* For more information, see http://www.cafeaulait.org/course/week12/35.html
|
|
||||||
*
|
|
||||||
* MIT License:
|
|
||||||
* Copyright (c) 2008 Bjoern Hartmann
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* bjoern@cs.stanford.edu 12/30/2008
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef ethernetudp_h
|
|
||||||
#define ethernetudp_h
|
|
||||||
|
|
||||||
#include <Udp.h>
|
|
||||||
|
|
||||||
#define UDP_TX_PACKET_MAX_SIZE 24
|
|
||||||
|
|
||||||
class EthernetUDP : public UDP {
|
|
||||||
private:
|
|
||||||
uint8_t _sock; // socket ID for Wiz5100
|
|
||||||
uint16_t _port; // local port to listen on
|
|
||||||
IPAddress _remoteIP; // remote IP address for the incoming packet whilst it's being processed
|
|
||||||
uint16_t _remotePort; // remote port for the incoming packet whilst it's being processed
|
|
||||||
uint16_t _offset; // offset into the packet being sent
|
|
||||||
uint16_t _remaining; // remaining bytes of incoming packet yet to be processed
|
|
||||||
|
|
||||||
public:
|
|
||||||
EthernetUDP(); // Constructor
|
|
||||||
virtual uint8_t begin(uint16_t); // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
|
|
||||||
virtual void stop(); // Finish with the UDP socket
|
|
||||||
|
|
||||||
// Sending UDP packets
|
|
||||||
|
|
||||||
// Start building up a packet to send to the remote host specific in ip and port
|
|
||||||
// Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
|
|
||||||
virtual int beginPacket(IPAddress ip, uint16_t port);
|
|
||||||
// Start building up a packet to send to the remote host specific in host and port
|
|
||||||
// Returns 1 if successful, 0 if there was a problem resolving the hostname or port
|
|
||||||
virtual int beginPacket(const char *host, uint16_t port);
|
|
||||||
// Finish off this packet and send it
|
|
||||||
// Returns 1 if the packet was sent successfully, 0 if there was an error
|
|
||||||
virtual int endPacket();
|
|
||||||
// Write a single byte into the packet
|
|
||||||
virtual size_t write(uint8_t);
|
|
||||||
// Write size bytes from buffer into the packet
|
|
||||||
virtual size_t write(const uint8_t *buffer, size_t size);
|
|
||||||
|
|
||||||
using Print::write;
|
|
||||||
|
|
||||||
// Start processing the next available incoming packet
|
|
||||||
// Returns the size of the packet in bytes, or 0 if no packets are available
|
|
||||||
virtual int parsePacket();
|
|
||||||
// Number of bytes remaining in the current packet
|
|
||||||
virtual int available();
|
|
||||||
// Read a single byte from the current packet
|
|
||||||
virtual int read();
|
|
||||||
// Read up to len bytes from the current packet and place them into buffer
|
|
||||||
// Returns the number of bytes read, or 0 if none are available
|
|
||||||
virtual int read(unsigned char* buffer, size_t len);
|
|
||||||
// Read up to len characters from the current packet and place them into buffer
|
|
||||||
// Returns the number of characters read, or 0 if none are available
|
|
||||||
virtual int read(char* buffer, size_t len) { return read((unsigned char*)buffer, len); };
|
|
||||||
// Return the next byte from the current packet without moving on to the next byte
|
|
||||||
virtual int peek();
|
|
||||||
virtual void flush(); // Finish reading the current packet
|
|
||||||
|
|
||||||
// Return the IP address of the host who sent the current incoming packet
|
|
||||||
virtual IPAddress remoteIP() { return _remoteIP; };
|
|
||||||
// Return the port of the host who sent the current incoming packet
|
|
||||||
virtual uint16_t remotePort() { return _remotePort; };
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,222 +0,0 @@
|
||||||
/*
|
|
||||||
SCP1000 Barometric Pressure Sensor Display
|
|
||||||
|
|
||||||
Serves the output of a Barometric Pressure Sensor as a web page.
|
|
||||||
Uses the SPI library. For details on the sensor, see:
|
|
||||||
http://www.sparkfun.com/commerce/product_info.php?products_id=8161
|
|
||||||
http://www.vti.fi/en/support/obsolete_products/pressure_sensors/
|
|
||||||
|
|
||||||
This sketch adapted from Nathan Seidle's SCP1000 example for PIC:
|
|
||||||
http://www.sparkfun.com/datasheets/Sensors/SCP1000-Testing.zip
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
SCP1000 sensor attached to pins 6,7, and 11 - 13:
|
|
||||||
DRDY: pin 6
|
|
||||||
CSB: pin 7
|
|
||||||
MOSI: pin 11
|
|
||||||
MISO: pin 12
|
|
||||||
SCK: pin 13
|
|
||||||
|
|
||||||
created 31 July 2010
|
|
||||||
by Tom Igoe
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Ethernet.h>
|
|
||||||
// the sensor communicates using SPI, so include the library:
|
|
||||||
#include <SPI.h>
|
|
||||||
|
|
||||||
|
|
||||||
// assign a MAC address for the ethernet controller.
|
|
||||||
// fill in your address here:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
|
|
||||||
// assign an IP address for the controller:
|
|
||||||
IPAddress ip(192,168,1,20);
|
|
||||||
IPAddress gateway(192,168,1,1);
|
|
||||||
IPAddress subnet(255, 255, 255, 0);
|
|
||||||
|
|
||||||
|
|
||||||
// Initialize the Ethernet server library
|
|
||||||
// with the IP address and port you want to use
|
|
||||||
// (port 80 is default for HTTP):
|
|
||||||
EthernetServer server(80);
|
|
||||||
|
|
||||||
|
|
||||||
//Sensor's memory register addresses:
|
|
||||||
const int PRESSURE = 0x1F; //3 most significant bits of pressure
|
|
||||||
const int PRESSURE_LSB = 0x20; //16 least significant bits of pressure
|
|
||||||
const int TEMPERATURE = 0x21; //16 bit temperature reading
|
|
||||||
|
|
||||||
// pins used for the connection with the sensor
|
|
||||||
// the others you need are controlled by the SPI library):
|
|
||||||
const int dataReadyPin = 6;
|
|
||||||
const int chipSelectPin = 7;
|
|
||||||
|
|
||||||
float temperature = 0.0;
|
|
||||||
long pressure = 0;
|
|
||||||
long lastReadingTime = 0;
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// start the SPI library:
|
|
||||||
SPI.begin();
|
|
||||||
|
|
||||||
// start the Ethernet connection and the server:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
server.begin();
|
|
||||||
|
|
||||||
// initalize the data ready and chip select pins:
|
|
||||||
pinMode(dataReadyPin, INPUT);
|
|
||||||
pinMode(chipSelectPin, OUTPUT);
|
|
||||||
|
|
||||||
Serial.begin(9600);
|
|
||||||
|
|
||||||
//Configure SCP1000 for low noise configuration:
|
|
||||||
writeRegister(0x02, 0x2D);
|
|
||||||
writeRegister(0x01, 0x03);
|
|
||||||
writeRegister(0x03, 0x02);
|
|
||||||
|
|
||||||
// give the sensor and Ethernet shield time to set up:
|
|
||||||
delay(1000);
|
|
||||||
|
|
||||||
//Set the sensor to high resolution mode tp start readings:
|
|
||||||
writeRegister(0x03, 0x0A);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// check for a reading no more than once a second.
|
|
||||||
if (millis() - lastReadingTime > 1000){
|
|
||||||
// if there's a reading ready, read it:
|
|
||||||
// don't do anything until the data ready pin is high:
|
|
||||||
if (digitalRead(dataReadyPin) == HIGH) {
|
|
||||||
getData();
|
|
||||||
// timestamp the last time you got a reading:
|
|
||||||
lastReadingTime = millis();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// listen for incoming Ethernet connections:
|
|
||||||
listenForEthernetClients();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void getData() {
|
|
||||||
Serial.println("Getting reading");
|
|
||||||
//Read the temperature data
|
|
||||||
int tempData = readRegister(0x21, 2);
|
|
||||||
|
|
||||||
// convert the temperature to celsius and display it:
|
|
||||||
temperature = (float)tempData / 20.0;
|
|
||||||
|
|
||||||
//Read the pressure data highest 3 bits:
|
|
||||||
byte pressureDataHigh = readRegister(0x1F, 1);
|
|
||||||
pressureDataHigh &= 0b00000111; //you only needs bits 2 to 0
|
|
||||||
|
|
||||||
//Read the pressure data lower 16 bits:
|
|
||||||
unsigned int pressureDataLow = readRegister(0x20, 2);
|
|
||||||
//combine the two parts into one 19-bit number:
|
|
||||||
pressure = ((pressureDataHigh << 16) | pressureDataLow)/4;
|
|
||||||
|
|
||||||
Serial.print("Temperature: ");
|
|
||||||
Serial.print(temperature);
|
|
||||||
Serial.println(" degrees C");
|
|
||||||
Serial.print("Pressure: " + String(pressure));
|
|
||||||
Serial.println(" Pa");
|
|
||||||
}
|
|
||||||
|
|
||||||
void listenForEthernetClients() {
|
|
||||||
// listen for incoming clients
|
|
||||||
EthernetClient client = server.available();
|
|
||||||
if (client) {
|
|
||||||
Serial.println("Got a client");
|
|
||||||
// an http request ends with a blank line
|
|
||||||
boolean currentLineIsBlank = true;
|
|
||||||
while (client.connected()) {
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
// if you've gotten to the end of the line (received a newline
|
|
||||||
// character) and the line is blank, the http request has ended,
|
|
||||||
// so you can send a reply
|
|
||||||
if (c == '\n' && currentLineIsBlank) {
|
|
||||||
// send a standard http response header
|
|
||||||
client.println("HTTP/1.1 200 OK");
|
|
||||||
client.println("Content-Type: text/html");
|
|
||||||
client.println();
|
|
||||||
// print the current readings, in HTML format:
|
|
||||||
client.print("Temperature: ");
|
|
||||||
client.print(temperature);
|
|
||||||
client.print(" degrees C");
|
|
||||||
client.println("<br />");
|
|
||||||
client.print("Pressure: " + String(pressure));
|
|
||||||
client.print(" Pa");
|
|
||||||
client.println("<br />");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if (c == '\n') {
|
|
||||||
// you're starting a new line
|
|
||||||
currentLineIsBlank = true;
|
|
||||||
}
|
|
||||||
else if (c != '\r') {
|
|
||||||
// you've gotten a character on the current line
|
|
||||||
currentLineIsBlank = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// give the web browser time to receive the data
|
|
||||||
delay(1);
|
|
||||||
// close the connection:
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//Send a write command to SCP1000
|
|
||||||
void writeRegister(byte registerName, byte registerValue) {
|
|
||||||
// SCP1000 expects the register name in the upper 6 bits
|
|
||||||
// of the byte:
|
|
||||||
registerName <<= 2;
|
|
||||||
// command (read or write) goes in the lower two bits:
|
|
||||||
registerName |= 0b00000010; //Write command
|
|
||||||
|
|
||||||
// take the chip select low to select the device:
|
|
||||||
digitalWrite(chipSelectPin, LOW);
|
|
||||||
|
|
||||||
SPI.transfer(registerName); //Send register location
|
|
||||||
SPI.transfer(registerValue); //Send value to record into register
|
|
||||||
|
|
||||||
// take the chip select high to de-select:
|
|
||||||
digitalWrite(chipSelectPin, HIGH);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//Read register from the SCP1000:
|
|
||||||
unsigned int readRegister(byte registerName, int numBytes) {
|
|
||||||
byte inByte = 0; // incoming from the SPI read
|
|
||||||
unsigned int result = 0; // result to return
|
|
||||||
|
|
||||||
// SCP1000 expects the register name in the upper 6 bits
|
|
||||||
// of the byte:
|
|
||||||
registerName <<= 2;
|
|
||||||
// command (read or write) goes in the lower two bits:
|
|
||||||
registerName &= 0b11111100; //Read command
|
|
||||||
|
|
||||||
// take the chip select low to select the device:
|
|
||||||
digitalWrite(chipSelectPin, LOW);
|
|
||||||
// send the device the register you want to read:
|
|
||||||
int command = SPI.transfer(registerName);
|
|
||||||
// send a value of 0 to read the first byte returned:
|
|
||||||
inByte = SPI.transfer(0x00);
|
|
||||||
|
|
||||||
result = inByte;
|
|
||||||
// if there's more than one byte returned,
|
|
||||||
// shift the first byte then get the second byte:
|
|
||||||
if (numBytes > 1){
|
|
||||||
result = inByte << 8;
|
|
||||||
inByte = SPI.transfer(0x00);
|
|
||||||
result = result |inByte;
|
|
||||||
}
|
|
||||||
// take the chip select high to de-select:
|
|
||||||
digitalWrite(chipSelectPin, HIGH);
|
|
||||||
// return the result:
|
|
||||||
return(result);
|
|
||||||
}
|
|
|
@ -1,79 +0,0 @@
|
||||||
/*
|
|
||||||
Chat Server
|
|
||||||
|
|
||||||
A simple server that distributes any incoming messages to all
|
|
||||||
connected clients. To use telnet to your device's IP address and type.
|
|
||||||
You can see the client's input in the serial monitor as well.
|
|
||||||
Using an Arduino Wiznet Ethernet shield.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
* Analog inputs attached to pins A0 through A5 (optional)
|
|
||||||
|
|
||||||
created 18 Dec 2009
|
|
||||||
by David A. Mellis
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// Enter a MAC address and IP address for your controller below.
|
|
||||||
// The IP address will be dependent on your local network.
|
|
||||||
// gateway and subnet are optional:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
|
|
||||||
IPAddress ip(192,168,1, 177);
|
|
||||||
IPAddress gateway(192,168,1, 1);
|
|
||||||
IPAddress subnet(255, 255, 0, 0);
|
|
||||||
|
|
||||||
|
|
||||||
// telnet defaults to port 23
|
|
||||||
EthernetServer server(23);
|
|
||||||
boolean alreadyConnected = false; // whether or not the client was connected previously
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// initialize the ethernet device
|
|
||||||
Ethernet.begin(mac, ip, gateway, subnet);
|
|
||||||
// start listening for clients
|
|
||||||
server.begin();
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
Serial.print("Chat server address:");
|
|
||||||
Serial.println(Ethernet.localIP());
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// wait for a new client:
|
|
||||||
EthernetClient client = server.available();
|
|
||||||
|
|
||||||
// when the client sends the first byte, say hello:
|
|
||||||
if (client) {
|
|
||||||
if (!alreadyConnected) {
|
|
||||||
// clead out the input buffer:
|
|
||||||
client.flush();
|
|
||||||
Serial.println("We have a new client");
|
|
||||||
client.println("Hello, client!");
|
|
||||||
alreadyConnected = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (client.available() > 0) {
|
|
||||||
// read the bytes incoming from the client:
|
|
||||||
char thisChar = client.read();
|
|
||||||
// echo the bytes back to the client:
|
|
||||||
server.write(thisChar);
|
|
||||||
// echo the bytes to the server as well:
|
|
||||||
Serial.write(thisChar);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,161 +0,0 @@
|
||||||
/*
|
|
||||||
Cosm sensor client
|
|
||||||
|
|
||||||
This sketch connects an analog sensor to Cosm (http://www.cosm.com)
|
|
||||||
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
|
|
||||||
the Adafruit Ethernet shield, either one will work, as long as it's got
|
|
||||||
a Wiznet Ethernet module on board.
|
|
||||||
|
|
||||||
This example has been updated to use version 2.0 of the cosm.com API.
|
|
||||||
To make it work, create a feed with a datastream, and give it the ID
|
|
||||||
sensor1. Or change the code below to match your feed.
|
|
||||||
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Analog sensor attached to analog in 0
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 15 March 2010
|
|
||||||
updated 14 May 2012
|
|
||||||
by Tom Igoe with input from Usman Haque and Joe Saavedra
|
|
||||||
|
|
||||||
http://arduino.cc/en/Tutorial/CosmClient
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
#define APIKEY "YOUR API KEY GOES HERE" // replace your Cosm api key here
|
|
||||||
#define FEEDID 00000 // replace your feed ID
|
|
||||||
#define USERAGENT "My Project" // user agent is the project name
|
|
||||||
|
|
||||||
// assign a MAC address for the ethernet controller.
|
|
||||||
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
|
|
||||||
// fill in your address here:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
|
|
||||||
|
|
||||||
// fill in an available IP address on your network here,
|
|
||||||
// for manual configuration:
|
|
||||||
IPAddress ip(10,0,1,20);
|
|
||||||
|
|
||||||
// initialize the library instance:
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
// if you don't want to use DNS (and reduce your sketch size)
|
|
||||||
// use the numeric IP instead of the name for the server:
|
|
||||||
//IPAddress server(216,52,233,121); // numeric IP for api.cosm.com
|
|
||||||
char server[] = "api.cosm.com"; // name address for cosm API
|
|
||||||
|
|
||||||
unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
|
|
||||||
boolean lastConnected = false; // state of the connection last time through the main loop
|
|
||||||
const unsigned long postingInterval = 10L*1000L; // delay between updates to cosm.com
|
|
||||||
// the "L" is needed to use long type numbers
|
|
||||||
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// start serial port:
|
|
||||||
Serial.begin(9600);
|
|
||||||
// start the Ethernet connection:
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// DHCP failed, so use a fixed IP address:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the analog sensor:
|
|
||||||
int sensorReading = analogRead(A0);
|
|
||||||
|
|
||||||
// if there's incoming data from the net connection.
|
|
||||||
// send it out the serial port. This is for debugging
|
|
||||||
// purposes only:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if there's no net connection, but there was one last time
|
|
||||||
// through the loop, then stop the client:
|
|
||||||
if (!client.connected() && lastConnected) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
// if you're not connected, and ten seconds have passed since
|
|
||||||
// your last connection, then connect again and send data:
|
|
||||||
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
|
|
||||||
sendData(sensorReading);
|
|
||||||
}
|
|
||||||
// store the state of the connection for next time through
|
|
||||||
// the loop:
|
|
||||||
lastConnected = client.connected();
|
|
||||||
}
|
|
||||||
|
|
||||||
// this method makes a HTTP connection to the server:
|
|
||||||
void sendData(int thisData) {
|
|
||||||
// if there's a successful connection:
|
|
||||||
if (client.connect(server, 80)) {
|
|
||||||
Serial.println("connecting...");
|
|
||||||
// send the HTTP PUT request:
|
|
||||||
client.print("PUT /v2/feeds/");
|
|
||||||
client.print(FEEDID);
|
|
||||||
client.println(".csv HTTP/1.1");
|
|
||||||
client.println("Host: api.cosm.com");
|
|
||||||
client.print("X-ApiKey: ");
|
|
||||||
client.println(APIKEY);
|
|
||||||
client.print("User-Agent: ");
|
|
||||||
client.println(USERAGENT);
|
|
||||||
client.print("Content-Length: ");
|
|
||||||
|
|
||||||
// calculate the length of the sensor reading in bytes:
|
|
||||||
// 8 bytes for "sensor1," + number of digits of the data:
|
|
||||||
int thisLength = 8 + getLength(thisData);
|
|
||||||
client.println(thisLength);
|
|
||||||
|
|
||||||
// last pieces of the HTTP PUT request:
|
|
||||||
client.println("Content-Type: text/csv");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
|
|
||||||
// here's the actual content of the PUT request:
|
|
||||||
client.print("sensor1,");
|
|
||||||
client.println(thisData);
|
|
||||||
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you couldn't make a connection:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
// note the time that the connection was made or attempted:
|
|
||||||
lastConnectionTime = millis();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// This method calculates the number of digits in the
|
|
||||||
// sensor reading. Since each digit of the ASCII decimal
|
|
||||||
// representation is a byte, the number of digits equals
|
|
||||||
// the number of bytes:
|
|
||||||
|
|
||||||
int getLength(int someValue) {
|
|
||||||
// there's at least one byte:
|
|
||||||
int digits = 1;
|
|
||||||
// continually divide the value by ten,
|
|
||||||
// adding one to the digit count for each
|
|
||||||
// time you divide, until you're at 0:
|
|
||||||
int dividend = someValue /10;
|
|
||||||
while (dividend > 0) {
|
|
||||||
dividend = dividend /10;
|
|
||||||
digits++;
|
|
||||||
}
|
|
||||||
// return the number of digits:
|
|
||||||
return digits;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,146 +0,0 @@
|
||||||
/*
|
|
||||||
Cosm sensor client with Strings
|
|
||||||
|
|
||||||
This sketch connects an analog sensor to Cosm (http://www.cosm.com)
|
|
||||||
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
|
|
||||||
the Adafruit Ethernet shield, either one will work, as long as it's got
|
|
||||||
a Wiznet Ethernet module on board.
|
|
||||||
|
|
||||||
This example has been updated to use version 2.0 of the Cosm.com API.
|
|
||||||
To make it work, create a feed with two datastreams, and give them the IDs
|
|
||||||
sensor1 and sensor2. Or change the code below to match your feed.
|
|
||||||
|
|
||||||
This example uses the String library, which is part of the Arduino core from
|
|
||||||
version 0019.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Analog sensor attached to analog in 0
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 15 March 2010
|
|
||||||
updated 14 May 2012
|
|
||||||
by Tom Igoe with input from Usman Haque and Joe Saavedra
|
|
||||||
|
|
||||||
http://arduino.cc/en/Tutorial/CosmClientString
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
|
|
||||||
#define APIKEY "YOUR API KEY GOES HERE" // replace your Cosm api key here
|
|
||||||
#define FEEDID 00000 // replace your feed ID
|
|
||||||
#define USERAGENT "My Project" // user agent is the project name
|
|
||||||
|
|
||||||
// assign a MAC address for the ethernet controller.
|
|
||||||
// fill in your address here:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
|
|
||||||
|
|
||||||
// fill in an available IP address on your network here,
|
|
||||||
// for manual configuration:
|
|
||||||
IPAddress ip(10,0,1,20);
|
|
||||||
|
|
||||||
// initialize the library instance:
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
// if you don't want to use DNS (and reduce your sketch size)
|
|
||||||
// use the numeric IP instead of the name for the server:
|
|
||||||
//IPAddress server(216,52,233,121); // numeric IP for api.cosm.com
|
|
||||||
char server[] = "api.cosm.com"; // name address for Cosm API
|
|
||||||
|
|
||||||
unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
|
|
||||||
boolean lastConnected = false; // state of the connection last time through the main loop
|
|
||||||
const unsigned long postingInterval = 10L*1000L; // delay between updates to Cosm.com
|
|
||||||
// the "L" is needed to use long type numbers
|
|
||||||
void setup() {
|
|
||||||
// start serial port:
|
|
||||||
Serial.begin(9600);
|
|
||||||
// give the ethernet module time to boot up:
|
|
||||||
delay(1000);
|
|
||||||
// start the Ethernet connection:
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// DHCP failed, so use a fixed IP address:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the analog sensor:
|
|
||||||
int sensorReading = analogRead(A0);
|
|
||||||
// convert the data to a String to send it:
|
|
||||||
|
|
||||||
String dataString = "sensor1,";
|
|
||||||
dataString += sensorReading;
|
|
||||||
|
|
||||||
// you can append multiple readings to this String if your
|
|
||||||
// Cosm feed is set up to handle multiple values:
|
|
||||||
int otherSensorReading = analogRead(A1);
|
|
||||||
dataString += "\nsensor2,";
|
|
||||||
dataString += otherSensorReading;
|
|
||||||
|
|
||||||
// if there's incoming data from the net connection.
|
|
||||||
// send it out the serial port. This is for debugging
|
|
||||||
// purposes only:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if there's no net connection, but there was one last time
|
|
||||||
// through the loop, then stop the client:
|
|
||||||
if (!client.connected() && lastConnected) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
// if you're not connected, and ten seconds have passed since
|
|
||||||
// your last connection, then connect again and send data:
|
|
||||||
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
|
|
||||||
sendData(dataString);
|
|
||||||
}
|
|
||||||
// store the state of the connection for next time through
|
|
||||||
// the loop:
|
|
||||||
lastConnected = client.connected();
|
|
||||||
}
|
|
||||||
|
|
||||||
// this method makes a HTTP connection to the server:
|
|
||||||
void sendData(String thisData) {
|
|
||||||
// if there's a successful connection:
|
|
||||||
if (client.connect(server, 80)) {
|
|
||||||
Serial.println("connecting...");
|
|
||||||
// send the HTTP PUT request:
|
|
||||||
client.print("PUT /v2/feeds/");
|
|
||||||
client.print(FEEDID);
|
|
||||||
client.println(".csv HTTP/1.1");
|
|
||||||
client.println("Host: api.cosm.com");
|
|
||||||
client.print("X-ApiKey: ");
|
|
||||||
client.println(APIKEY);
|
|
||||||
client.print("User-Agent: ");
|
|
||||||
client.println(USERAGENT);
|
|
||||||
client.print("Content-Length: ");
|
|
||||||
client.println(thisData.length());
|
|
||||||
|
|
||||||
// last pieces of the HTTP PUT request:
|
|
||||||
client.println("Content-Type: text/csv");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
|
|
||||||
// here's the actual content of the PUT request:
|
|
||||||
client.println(thisData);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you couldn't make a connection:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
// note the time that the connection was made or attempted:
|
|
||||||
lastConnectionTime = millis();
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,59 +0,0 @@
|
||||||
/*
|
|
||||||
DHCP-based IP printer
|
|
||||||
|
|
||||||
This sketch uses the DHCP extensions to the Ethernet library
|
|
||||||
to get an IP address via DHCP and print the address obtained.
|
|
||||||
using an Arduino Wiznet Ethernet shield.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 12 April 2011
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// Enter a MAC address for your controller below.
|
|
||||||
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
|
|
||||||
byte mac[] = {
|
|
||||||
0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
|
|
||||||
|
|
||||||
// Initialize the Ethernet client library
|
|
||||||
// with the IP address and port of the server
|
|
||||||
// that you want to connect to (port 80 is default for HTTP):
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
// this check is only needed on the Leonardo:
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
// start the Ethernet connection:
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// no point in carrying on, so do nothing forevermore:
|
|
||||||
for(;;)
|
|
||||||
;
|
|
||||||
}
|
|
||||||
// print your local IP address:
|
|
||||||
Serial.print("My IP address: ");
|
|
||||||
for (byte thisByte = 0; thisByte < 4; thisByte++) {
|
|
||||||
// print the value of each byte of the IP address:
|
|
||||||
Serial.print(Ethernet.localIP()[thisByte], DEC);
|
|
||||||
Serial.print(".");
|
|
||||||
}
|
|
||||||
Serial.println();
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,87 +0,0 @@
|
||||||
/*
|
|
||||||
DHCP Chat Server
|
|
||||||
|
|
||||||
A simple server that distributes any incoming messages to all
|
|
||||||
connected clients. To use telnet to your device's IP address and type.
|
|
||||||
You can see the client's input in the serial monitor as well.
|
|
||||||
Using an Arduino Wiznet Ethernet shield.
|
|
||||||
|
|
||||||
THis version attempts to get an IP address using DHCP
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 21 May 2011
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
Based on ChatServer example by David A. Mellis
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// Enter a MAC address and IP address for your controller below.
|
|
||||||
// The IP address will be dependent on your local network.
|
|
||||||
// gateway and subnet are optional:
|
|
||||||
byte mac[] = {
|
|
||||||
0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
|
|
||||||
IPAddress ip(192,168,1, 177);
|
|
||||||
IPAddress gateway(192,168,1, 1);
|
|
||||||
IPAddress subnet(255, 255, 0, 0);
|
|
||||||
|
|
||||||
// telnet defaults to port 23
|
|
||||||
EthernetServer server(23);
|
|
||||||
boolean gotAMessage = false; // whether or not you got a message from the client yet
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
// this check is only needed on the Leonardo:
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// start the Ethernet connection:
|
|
||||||
Serial.println("Trying to get an IP address using DHCP");
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// initialize the ethernet device not using DHCP:
|
|
||||||
Ethernet.begin(mac, ip, gateway, subnet);
|
|
||||||
}
|
|
||||||
// print your local IP address:
|
|
||||||
Serial.print("My IP address: ");
|
|
||||||
ip = Ethernet.localIP();
|
|
||||||
for (byte thisByte = 0; thisByte < 4; thisByte++) {
|
|
||||||
// print the value of each byte of the IP address:
|
|
||||||
Serial.print(ip[thisByte], DEC);
|
|
||||||
Serial.print(".");
|
|
||||||
}
|
|
||||||
Serial.println();
|
|
||||||
// start listening for clients
|
|
||||||
server.begin();
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// wait for a new client:
|
|
||||||
EthernetClient client = server.available();
|
|
||||||
|
|
||||||
// when the client sends the first byte, say hello:
|
|
||||||
if (client) {
|
|
||||||
if (!gotAMessage) {
|
|
||||||
Serial.println("We have a new client");
|
|
||||||
client.println("Hello, client!");
|
|
||||||
gotAMessage = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
// read the bytes incoming from the client:
|
|
||||||
char thisChar = client.read();
|
|
||||||
// echo the bytes back to the client:
|
|
||||||
server.write(thisChar);
|
|
||||||
// echo the bytes to the server as well:
|
|
||||||
Serial.print(thisChar);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,163 +0,0 @@
|
||||||
/*
|
|
||||||
Pachube sensor client
|
|
||||||
|
|
||||||
This sketch connects an analog sensor to Pachube (http://www.pachube.com)
|
|
||||||
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
|
|
||||||
the Adafruit Ethernet shield, either one will work, as long as it's got
|
|
||||||
a Wiznet Ethernet module on board.
|
|
||||||
|
|
||||||
This example has been updated to use version 2.0 of the Pachube.com API.
|
|
||||||
To make it work, create a feed with a datastream, and give it the ID
|
|
||||||
sensor1. Or change the code below to match your feed.
|
|
||||||
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Analog sensor attached to analog in 0
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 15 March 2010
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe with input from Usman Haque and Joe Saavedra
|
|
||||||
|
|
||||||
http://arduino.cc/en/Tutorial/PachubeClient
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
#define APIKEY "YOUR API KEY GOES HERE" // replace your pachube api key here
|
|
||||||
#define FEEDID 00000 // replace your feed ID
|
|
||||||
#define USERAGENT "My Project" // user agent is the project name
|
|
||||||
|
|
||||||
// assign a MAC address for the ethernet controller.
|
|
||||||
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
|
|
||||||
// fill in your address here:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
|
|
||||||
|
|
||||||
// fill in an available IP address on your network here,
|
|
||||||
// for manual configuration:
|
|
||||||
IPAddress ip(10,0,1,20);
|
|
||||||
// initialize the library instance:
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
// if you don't want to use DNS (and reduce your sketch size)
|
|
||||||
// use the numeric IP instead of the name for the server:
|
|
||||||
IPAddress server(216,52,233,122); // numeric IP for api.pachube.com
|
|
||||||
//char server[] = "api.pachube.com"; // name address for pachube API
|
|
||||||
|
|
||||||
unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
|
|
||||||
boolean lastConnected = false; // state of the connection last time through the main loop
|
|
||||||
const unsigned long postingInterval = 10*1000; //delay between updates to Pachube.com
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// start the Ethernet connection:
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// DHCP failed, so use a fixed IP address:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the analog sensor:
|
|
||||||
int sensorReading = analogRead(A0);
|
|
||||||
|
|
||||||
// if there's incoming data from the net connection.
|
|
||||||
// send it out the serial port. This is for debugging
|
|
||||||
// purposes only:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if there's no net connection, but there was one last time
|
|
||||||
// through the loop, then stop the client:
|
|
||||||
if (!client.connected() && lastConnected) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
// if you're not connected, and ten seconds have passed since
|
|
||||||
// your last connection, then connect again and send data:
|
|
||||||
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
|
|
||||||
sendData(sensorReading);
|
|
||||||
}
|
|
||||||
// store the state of the connection for next time through
|
|
||||||
// the loop:
|
|
||||||
lastConnected = client.connected();
|
|
||||||
}
|
|
||||||
|
|
||||||
// this method makes a HTTP connection to the server:
|
|
||||||
void sendData(int thisData) {
|
|
||||||
// if there's a successful connection:
|
|
||||||
if (client.connect(server, 80)) {
|
|
||||||
Serial.println("connecting...");
|
|
||||||
// send the HTTP PUT request:
|
|
||||||
client.print("PUT /v2/feeds/");
|
|
||||||
client.print(FEEDID);
|
|
||||||
client.println(".csv HTTP/1.1");
|
|
||||||
client.println("Host: api.pachube.com");
|
|
||||||
client.print("X-PachubeApiKey: ");
|
|
||||||
client.println(APIKEY);
|
|
||||||
client.print("User-Agent: ");
|
|
||||||
client.println(USERAGENT);
|
|
||||||
client.print("Content-Length: ");
|
|
||||||
|
|
||||||
// calculate the length of the sensor reading in bytes:
|
|
||||||
// 8 bytes for "sensor1," + number of digits of the data:
|
|
||||||
int thisLength = 8 + getLength(thisData);
|
|
||||||
client.println(thisLength);
|
|
||||||
|
|
||||||
// last pieces of the HTTP PUT request:
|
|
||||||
client.println("Content-Type: text/csv");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
|
|
||||||
// here's the actual content of the PUT request:
|
|
||||||
client.print("sensor1,");
|
|
||||||
client.println(thisData);
|
|
||||||
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you couldn't make a connection:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
// note the time that the connection was made or attempted:
|
|
||||||
lastConnectionTime = millis();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// This method calculates the number of digits in the
|
|
||||||
// sensor reading. Since each digit of the ASCII decimal
|
|
||||||
// representation is a byte, the number of digits equals
|
|
||||||
// the number of bytes:
|
|
||||||
|
|
||||||
int getLength(int someValue) {
|
|
||||||
// there's at least one byte:
|
|
||||||
int digits = 1;
|
|
||||||
// continually divide the value by ten,
|
|
||||||
// adding one to the digit count for each
|
|
||||||
// time you divide, until you're at 0:
|
|
||||||
int dividend = someValue /10;
|
|
||||||
while (dividend > 0) {
|
|
||||||
dividend = dividend /10;
|
|
||||||
digits++;
|
|
||||||
}
|
|
||||||
// return the number of digits:
|
|
||||||
return digits;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,152 +0,0 @@
|
||||||
/*
|
|
||||||
Cosm sensor client with Strings
|
|
||||||
|
|
||||||
This sketch connects an analog sensor to Cosm (http://www.cosm.com)
|
|
||||||
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
|
|
||||||
the Adafruit Ethernet shield, either one will work, as long as it's got
|
|
||||||
a Wiznet Ethernet module on board.
|
|
||||||
|
|
||||||
This example has been updated to use version 2.0 of the Cosm.com API.
|
|
||||||
To make it work, create a feed with two datastreams, and give them the IDs
|
|
||||||
sensor1 and sensor2. Or change the code below to match your feed.
|
|
||||||
|
|
||||||
This example uses the String library, which is part of the Arduino core from
|
|
||||||
version 0019.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Analog sensor attached to analog in 0
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 15 March 2010
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe with input from Usman Haque and Joe Saavedra
|
|
||||||
|
|
||||||
http://arduino.cc/en/Tutorial/CosmClientString
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
|
|
||||||
/#define APIKEY "YOUR API KEY GOES HERE" // replace your Cosm api key here
|
|
||||||
#define FEEDID 00000 // replace your feed ID
|
|
||||||
#define USERAGENT "My Project" // user agent is the project name
|
|
||||||
|
|
||||||
|
|
||||||
// assign a MAC address for the ethernet controller.
|
|
||||||
// fill in your address here:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
|
|
||||||
|
|
||||||
// fill in an available IP address on your network here,
|
|
||||||
// for manual configuration:
|
|
||||||
IPAddress ip(10,0,1,20);
|
|
||||||
|
|
||||||
// initialize the library instance:
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
// if you don't want to use DNS (and reduce your sketch size)
|
|
||||||
// use the numeric IP instead of the name for the server:
|
|
||||||
IPAddress server(216,52,233,121); // numeric IP for api.cosm.com
|
|
||||||
//char server[] = "api.cosm.com"; // name address for Cosm API
|
|
||||||
|
|
||||||
unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
|
|
||||||
boolean lastConnected = false; // state of the connection last time through the main loop
|
|
||||||
const unsigned long postingInterval = 10*1000; //delay between updates to Cosm.com
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// give the ethernet module time to boot up:
|
|
||||||
delay(1000);
|
|
||||||
// start the Ethernet connection:
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// DHCP failed, so use a fixed IP address:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// read the analog sensor:
|
|
||||||
int sensorReading = analogRead(A0);
|
|
||||||
// convert the data to a String to send it:
|
|
||||||
|
|
||||||
String dataString = "sensor1,";
|
|
||||||
dataString += sensorReading;
|
|
||||||
|
|
||||||
// you can append multiple readings to this String if your
|
|
||||||
// Cosm feed is set up to handle multiple values:
|
|
||||||
int otherSensorReading = analogRead(A1);
|
|
||||||
dataString += "\nsensor2,";
|
|
||||||
dataString += otherSensorReading;
|
|
||||||
|
|
||||||
// if there's incoming data from the net connection.
|
|
||||||
// send it out the serial port. This is for debugging
|
|
||||||
// purposes only:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if there's no net connection, but there was one last time
|
|
||||||
// through the loop, then stop the client:
|
|
||||||
if (!client.connected() && lastConnected) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
// if you're not connected, and ten seconds have passed since
|
|
||||||
// your last connection, then connect again and send data:
|
|
||||||
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
|
|
||||||
sendData(dataString);
|
|
||||||
}
|
|
||||||
// store the state of the connection for next time through
|
|
||||||
// the loop:
|
|
||||||
lastConnected = client.connected();
|
|
||||||
}
|
|
||||||
|
|
||||||
// this method makes a HTTP connection to the server:
|
|
||||||
void sendData(String thisData) {
|
|
||||||
// if there's a successful connection:
|
|
||||||
if (client.connect(server, 80)) {
|
|
||||||
Serial.println("connecting...");
|
|
||||||
// send the HTTP PUT request:
|
|
||||||
client.print("PUT /v2/feeds/");
|
|
||||||
client.print(FEEDID);
|
|
||||||
client.println(".csv HTTP/1.1");
|
|
||||||
client.println("Host: api.cosm.com");
|
|
||||||
client.print("X-CosmApiKey: ");
|
|
||||||
client.println(APIKEY);
|
|
||||||
client.print("User-Agent: ");
|
|
||||||
client.println(USERAGENT);
|
|
||||||
client.print("Content-Length: ");
|
|
||||||
client.println(thisData.length());
|
|
||||||
|
|
||||||
// last pieces of the HTTP PUT request:
|
|
||||||
client.println("Content-Type: text/csv");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
|
|
||||||
// here's the actual content of the PUT request:
|
|
||||||
client.println(thisData);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you couldn't make a connection:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
// note the time that the connection was made or attempted:
|
|
||||||
lastConnectionTime = millis();
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,93 +0,0 @@
|
||||||
/*
|
|
||||||
Telnet client
|
|
||||||
|
|
||||||
This sketch connects to a a telnet server (http://www.google.com)
|
|
||||||
using an Arduino Wiznet Ethernet shield. You'll need a telnet server
|
|
||||||
to test this with.
|
|
||||||
Processing's ChatServer example (part of the network library) works well,
|
|
||||||
running on port 10002. It can be found as part of the examples
|
|
||||||
in the Processing application, available at
|
|
||||||
http://processing.org/
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 14 Sep 2010
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// Enter a MAC address and IP address for your controller below.
|
|
||||||
// The IP address will be dependent on your local network:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
|
|
||||||
IPAddress ip(192,168,1,177);
|
|
||||||
|
|
||||||
// Enter the IP address of the server you're connecting to:
|
|
||||||
IPAddress server(1,1,1,1);
|
|
||||||
|
|
||||||
// Initialize the Ethernet client library
|
|
||||||
// with the IP address and port of the server
|
|
||||||
// that you want to connect to (port 23 is default for telnet;
|
|
||||||
// if you're using Processing's ChatServer, use port 10002):
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// start the Ethernet connection:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// give the Ethernet shield a second to initialize:
|
|
||||||
delay(1000);
|
|
||||||
Serial.println("connecting...");
|
|
||||||
|
|
||||||
// if you get a connection, report back via serial:
|
|
||||||
if (client.connect(server, 10002)) {
|
|
||||||
Serial.println("connected");
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you didn't get a connection to the server:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
// if there are incoming bytes available
|
|
||||||
// from the server, read them and print them:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// as long as there are bytes in the serial queue,
|
|
||||||
// read them and send them out the socket if it's open:
|
|
||||||
while (Serial.available() > 0) {
|
|
||||||
char inChar = Serial.read();
|
|
||||||
if (client.connected()) {
|
|
||||||
client.print(inChar);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// if the server's disconnected, stop the client:
|
|
||||||
if (!client.connected()) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
// do nothing:
|
|
||||||
while(true);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,136 +0,0 @@
|
||||||
/*
|
|
||||||
Twitter Client with Strings
|
|
||||||
|
|
||||||
This sketch connects to Twitter using an Ethernet shield. It parses the XML
|
|
||||||
returned, and looks for <text>this is a tweet</text>
|
|
||||||
|
|
||||||
You can use the Arduino Ethernet shield, or the Adafruit Ethernet shield,
|
|
||||||
either one will work, as long as it's got a Wiznet Ethernet module on board.
|
|
||||||
|
|
||||||
This example uses the DHCP routines in the Ethernet library which is part of the
|
|
||||||
Arduino core from version 1.0 beta 1
|
|
||||||
|
|
||||||
This example uses the String library, which is part of the Arduino core from
|
|
||||||
version 0019.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 21 May 2011
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
|
|
||||||
// Enter a MAC address and IP address for your controller below.
|
|
||||||
// The IP address will be dependent on your local network:
|
|
||||||
byte mac[] = {
|
|
||||||
0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 };
|
|
||||||
IPAddress ip(192,168,1,20);
|
|
||||||
|
|
||||||
// initialize the library instance:
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
const unsigned long requestInterval = 60000; // delay between requests
|
|
||||||
|
|
||||||
char serverName[] = "api.twitter.com"; // twitter URL
|
|
||||||
|
|
||||||
boolean requested; // whether you've made a request since connecting
|
|
||||||
unsigned long lastAttemptTime = 0; // last time you connected to the server, in milliseconds
|
|
||||||
|
|
||||||
String currentLine = ""; // string to hold the text from server
|
|
||||||
String tweet = ""; // string to hold the tweet
|
|
||||||
boolean readingTweet = false; // if you're currently reading the tweet
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// reserve space for the strings:
|
|
||||||
currentLine.reserve(256);
|
|
||||||
tweet.reserve(150);
|
|
||||||
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// attempt a DHCP connection:
|
|
||||||
Serial.println("Attempting to get an IP address using DHCP:");
|
|
||||||
if (!Ethernet.begin(mac)) {
|
|
||||||
// if DHCP fails, start with a hard-coded address:
|
|
||||||
Serial.println("failed to get an IP address using DHCP, trying manually");
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
}
|
|
||||||
Serial.print("My address:");
|
|
||||||
Serial.println(Ethernet.localIP());
|
|
||||||
// connect to Twitter:
|
|
||||||
connectToServer();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
if (client.connected()) {
|
|
||||||
if (client.available()) {
|
|
||||||
// read incoming bytes:
|
|
||||||
char inChar = client.read();
|
|
||||||
|
|
||||||
// add incoming byte to end of line:
|
|
||||||
currentLine += inChar;
|
|
||||||
|
|
||||||
// if you get a newline, clear the line:
|
|
||||||
if (inChar == '\n') {
|
|
||||||
currentLine = "";
|
|
||||||
}
|
|
||||||
// if the current line ends with <text>, it will
|
|
||||||
// be followed by the tweet:
|
|
||||||
if ( currentLine.endsWith("<text>")) {
|
|
||||||
// tweet is beginning. Clear the tweet string:
|
|
||||||
readingTweet = true;
|
|
||||||
tweet = "";
|
|
||||||
}
|
|
||||||
// if you're currently reading the bytes of a tweet,
|
|
||||||
// add them to the tweet String:
|
|
||||||
if (readingTweet) {
|
|
||||||
if (inChar != '<') {
|
|
||||||
tweet += inChar;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you got a "<" character,
|
|
||||||
// you've reached the end of the tweet:
|
|
||||||
readingTweet = false;
|
|
||||||
Serial.println(tweet);
|
|
||||||
// close the connection to the server:
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (millis() - lastAttemptTime > requestInterval) {
|
|
||||||
// if you're not connected, and two minutes have passed since
|
|
||||||
// your last connection, then attempt to connect again:
|
|
||||||
connectToServer();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void connectToServer() {
|
|
||||||
// attempt to connect, and wait a millisecond:
|
|
||||||
Serial.println("connecting to server...");
|
|
||||||
if (client.connect(serverName, 80)) {
|
|
||||||
Serial.println("making HTTP request...");
|
|
||||||
// make HTTP GET request to twitter:
|
|
||||||
client.println("GET /1/statuses/user_timeline.xml?screen_name=arduino&count=1 HTTP/1.1");
|
|
||||||
client.println("HOST: api.twitter.com");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
}
|
|
||||||
// note the time of this connect attempt:
|
|
||||||
lastAttemptTime = millis();
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,118 +0,0 @@
|
||||||
/*
|
|
||||||
UDPSendReceive.pde:
|
|
||||||
This sketch receives UDP message strings, prints them to the serial port
|
|
||||||
and sends an "acknowledge" string back to the sender
|
|
||||||
|
|
||||||
A Processing sketch is included at the end of file that can be used to send
|
|
||||||
and received messages for testing with a computer.
|
|
||||||
|
|
||||||
created 21 Aug 2010
|
|
||||||
by Michael Margolis
|
|
||||||
|
|
||||||
This code is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#include <SPI.h> // needed for Arduino versions later than 0018
|
|
||||||
#include <Ethernet.h>
|
|
||||||
#include <EthernetUdp.h> // UDP library from: bjoern@cs.stanford.edu 12/30/2008
|
|
||||||
|
|
||||||
|
|
||||||
// Enter a MAC address and IP address for your controller below.
|
|
||||||
// The IP address will be dependent on your local network:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
|
|
||||||
IPAddress ip(192, 168, 1, 177);
|
|
||||||
|
|
||||||
unsigned int localPort = 8888; // local port to listen on
|
|
||||||
|
|
||||||
// buffers for receiving and sending data
|
|
||||||
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
|
|
||||||
char ReplyBuffer[] = "acknowledged"; // a string to send back
|
|
||||||
|
|
||||||
// An EthernetUDP instance to let us send and receive packets over UDP
|
|
||||||
EthernetUDP Udp;
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// start the Ethernet and UDP:
|
|
||||||
Ethernet.begin(mac,ip);
|
|
||||||
Udp.begin(localPort);
|
|
||||||
|
|
||||||
Serial.begin(9600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// if there's data available, read a packet
|
|
||||||
int packetSize = Udp.parsePacket();
|
|
||||||
if(packetSize)
|
|
||||||
{
|
|
||||||
Serial.print("Received packet of size ");
|
|
||||||
Serial.println(packetSize);
|
|
||||||
Serial.print("From ");
|
|
||||||
IPAddress remote = Udp.remoteIP();
|
|
||||||
for (int i =0; i < 4; i++)
|
|
||||||
{
|
|
||||||
Serial.print(remote[i], DEC);
|
|
||||||
if (i < 3)
|
|
||||||
{
|
|
||||||
Serial.print(".");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Serial.print(", port ");
|
|
||||||
Serial.println(Udp.remotePort());
|
|
||||||
|
|
||||||
// read the packet into packetBufffer
|
|
||||||
Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
|
|
||||||
Serial.println("Contents:");
|
|
||||||
Serial.println(packetBuffer);
|
|
||||||
|
|
||||||
// send a reply, to the IP address and port that sent us the packet we received
|
|
||||||
Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
|
|
||||||
Udp.write(ReplyBuffer);
|
|
||||||
Udp.endPacket();
|
|
||||||
}
|
|
||||||
delay(10);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
Processing sketch to run with this example
|
|
||||||
=====================================================
|
|
||||||
|
|
||||||
// Processing UDP example to send and receive string data from Arduino
|
|
||||||
// press any key to send the "Hello Arduino" message
|
|
||||||
|
|
||||||
|
|
||||||
import hypermedia.net.*;
|
|
||||||
|
|
||||||
UDP udp; // define the UDP object
|
|
||||||
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
udp = new UDP( this, 6000 ); // create a new datagram connection on port 6000
|
|
||||||
//udp.log( true ); // <-- printout the connection activity
|
|
||||||
udp.listen( true ); // and wait for incoming message
|
|
||||||
}
|
|
||||||
|
|
||||||
void draw()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
void keyPressed() {
|
|
||||||
String ip = "192.168.1.177"; // the remote IP address
|
|
||||||
int port = 8888; // the destination port
|
|
||||||
|
|
||||||
udp.send("Hello World", ip, port ); // the message to send
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void receive( byte[] data ) { // <-- default handler
|
|
||||||
//void receive( byte[] data, String ip, int port ) { // <-- extended handler
|
|
||||||
|
|
||||||
for(int i=0; i < data.length; i++)
|
|
||||||
print(char(data[i]));
|
|
||||||
println();
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
|
@ -1,141 +0,0 @@
|
||||||
/*
|
|
||||||
|
|
||||||
Udp NTP Client
|
|
||||||
|
|
||||||
Get the time from a Network Time Protocol (NTP) time server
|
|
||||||
Demonstrates use of UDP sendPacket and ReceivePacket
|
|
||||||
For more on NTP time servers and the messages needed to communicate with them,
|
|
||||||
see http://en.wikipedia.org/wiki/Network_Time_Protocol
|
|
||||||
|
|
||||||
created 4 Sep 2010
|
|
||||||
by Michael Margolis
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
#include <EthernetUdp.h>
|
|
||||||
|
|
||||||
// Enter a MAC address for your controller below.
|
|
||||||
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
|
|
||||||
|
|
||||||
unsigned int localPort = 8888; // local port to listen for UDP packets
|
|
||||||
|
|
||||||
IPAddress timeServer(192, 43, 244, 18); // time.nist.gov NTP server
|
|
||||||
|
|
||||||
const int NTP_PACKET_SIZE= 48; // NTP time stamp is in the first 48 bytes of the message
|
|
||||||
|
|
||||||
byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets
|
|
||||||
|
|
||||||
// A UDP instance to let us send and receive packets over UDP
|
|
||||||
EthernetUDP Udp;
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// start Ethernet and UDP
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// no point in carrying on, so do nothing forevermore:
|
|
||||||
for(;;)
|
|
||||||
;
|
|
||||||
}
|
|
||||||
Udp.begin(localPort);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
sendNTPpacket(timeServer); // send an NTP packet to a time server
|
|
||||||
|
|
||||||
// wait to see if a reply is available
|
|
||||||
delay(1000);
|
|
||||||
if ( Udp.parsePacket() ) {
|
|
||||||
// We've received a packet, read the data from it
|
|
||||||
Udp.read(packetBuffer,NTP_PACKET_SIZE); // read the packet into the buffer
|
|
||||||
|
|
||||||
//the timestamp starts at byte 40 of the received packet and is four bytes,
|
|
||||||
// or two words, long. First, esxtract the two words:
|
|
||||||
|
|
||||||
unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
|
|
||||||
unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
|
|
||||||
// combine the four bytes (two words) into a long integer
|
|
||||||
// this is NTP time (seconds since Jan 1 1900):
|
|
||||||
unsigned long secsSince1900 = highWord << 16 | lowWord;
|
|
||||||
Serial.print("Seconds since Jan 1 1900 = " );
|
|
||||||
Serial.println(secsSince1900);
|
|
||||||
|
|
||||||
// now convert NTP time into everyday time:
|
|
||||||
Serial.print("Unix time = ");
|
|
||||||
// Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
|
|
||||||
const unsigned long seventyYears = 2208988800UL;
|
|
||||||
// subtract seventy years:
|
|
||||||
unsigned long epoch = secsSince1900 - seventyYears;
|
|
||||||
// print Unix time:
|
|
||||||
Serial.println(epoch);
|
|
||||||
|
|
||||||
|
|
||||||
// print the hour, minute and second:
|
|
||||||
Serial.print("The UTC time is "); // UTC is the time at Greenwich Meridian (GMT)
|
|
||||||
Serial.print((epoch % 86400L) / 3600); // print the hour (86400 equals secs per day)
|
|
||||||
Serial.print(':');
|
|
||||||
if ( ((epoch % 3600) / 60) < 10 ) {
|
|
||||||
// In the first 10 minutes of each hour, we'll want a leading '0'
|
|
||||||
Serial.print('0');
|
|
||||||
}
|
|
||||||
Serial.print((epoch % 3600) / 60); // print the minute (3600 equals secs per minute)
|
|
||||||
Serial.print(':');
|
|
||||||
if ( (epoch % 60) < 10 ) {
|
|
||||||
// In the first 10 seconds of each minute, we'll want a leading '0'
|
|
||||||
Serial.print('0');
|
|
||||||
}
|
|
||||||
Serial.println(epoch %60); // print the second
|
|
||||||
}
|
|
||||||
// wait ten seconds before asking for the time again
|
|
||||||
delay(10000);
|
|
||||||
}
|
|
||||||
|
|
||||||
// send an NTP request to the time server at the given address
|
|
||||||
unsigned long sendNTPpacket(IPAddress& address)
|
|
||||||
{
|
|
||||||
// set all bytes in the buffer to 0
|
|
||||||
memset(packetBuffer, 0, NTP_PACKET_SIZE);
|
|
||||||
// Initialize values needed to form NTP request
|
|
||||||
// (see URL above for details on the packets)
|
|
||||||
packetBuffer[0] = 0b11100011; // LI, Version, Mode
|
|
||||||
packetBuffer[1] = 0; // Stratum, or type of clock
|
|
||||||
packetBuffer[2] = 6; // Polling Interval
|
|
||||||
packetBuffer[3] = 0xEC; // Peer Clock Precision
|
|
||||||
// 8 bytes of zero for Root Delay & Root Dispersion
|
|
||||||
packetBuffer[12] = 49;
|
|
||||||
packetBuffer[13] = 0x4E;
|
|
||||||
packetBuffer[14] = 49;
|
|
||||||
packetBuffer[15] = 52;
|
|
||||||
|
|
||||||
// all NTP fields have been given values, now
|
|
||||||
// you can send a packet requesting a timestamp:
|
|
||||||
Udp.beginPacket(address, 123); //NTP requests are to port 123
|
|
||||||
Udp.write(packetBuffer,NTP_PACKET_SIZE);
|
|
||||||
Udp.endPacket();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,88 +0,0 @@
|
||||||
/*
|
|
||||||
Web client
|
|
||||||
|
|
||||||
This sketch connects to a website (http://www.google.com)
|
|
||||||
using an Arduino Wiznet Ethernet shield.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 18 Dec 2009
|
|
||||||
by David A. Mellis
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe, based on work by Adrian McEwen
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// Enter a MAC address for your controller below.
|
|
||||||
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
|
|
||||||
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
|
|
||||||
// if you don't want to use DNS (and reduce your sketch size)
|
|
||||||
// use the numeric IP instead of the name for the server:
|
|
||||||
//IPAddress server(74,125,232,128); // numeric IP for Google (no DNS)
|
|
||||||
char server[] = "www.google.com"; // name address for Google (using DNS)
|
|
||||||
|
|
||||||
// Set the static IP address to use if the DHCP fails to assign
|
|
||||||
IPAddress ip(192,168,0,177);
|
|
||||||
|
|
||||||
// Initialize the Ethernet client library
|
|
||||||
// with the IP address and port of the server
|
|
||||||
// that you want to connect to (port 80 is default for HTTP):
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
// start the Ethernet connection:
|
|
||||||
if (Ethernet.begin(mac) == 0) {
|
|
||||||
Serial.println("Failed to configure Ethernet using DHCP");
|
|
||||||
// no point in carrying on, so do nothing forevermore:
|
|
||||||
// try to congifure using IP address instead of DHCP:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
}
|
|
||||||
// give the Ethernet shield a second to initialize:
|
|
||||||
delay(1000);
|
|
||||||
Serial.println("connecting...");
|
|
||||||
|
|
||||||
// if you get a connection, report back via serial:
|
|
||||||
if (client.connect(server, 80)) {
|
|
||||||
Serial.println("connected");
|
|
||||||
// Make a HTTP request:
|
|
||||||
client.println("GET /search?q=arduino HTTP/1.1");
|
|
||||||
client.println("Host: www.google.com");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// kf you didn't get a connection to the server:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
// if there are incoming bytes available
|
|
||||||
// from the server, read them and print them:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if the server's disconnected, stop the client:
|
|
||||||
if (!client.connected()) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
|
|
||||||
// do nothing forevermore:
|
|
||||||
while(true);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,111 +0,0 @@
|
||||||
/*
|
|
||||||
Repeating Web client
|
|
||||||
|
|
||||||
This sketch connects to a a web server and makes a request
|
|
||||||
using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
|
|
||||||
the Adafruit Ethernet shield, either one will work, as long as it's got
|
|
||||||
a Wiznet Ethernet module on board.
|
|
||||||
|
|
||||||
This example uses DNS, by assigning the Ethernet client with a MAC address,
|
|
||||||
IP address, and DNS address.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
|
|
||||||
created 19 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
http://arduino.cc/en/Tutorial/WebClientRepeating
|
|
||||||
This code is in the public domain.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// assign a MAC address for the ethernet controller.
|
|
||||||
// fill in your address here:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
|
|
||||||
// fill in an available IP address on your network here,
|
|
||||||
// for manual configuration:
|
|
||||||
IPAddress ip(10,0,0,20);
|
|
||||||
|
|
||||||
// fill in your Domain Name Server address here:
|
|
||||||
IPAddress myDns(1,1,1,1);
|
|
||||||
|
|
||||||
// initialize the library instance:
|
|
||||||
EthernetClient client;
|
|
||||||
|
|
||||||
char server[] = "www.arduino.cc";
|
|
||||||
|
|
||||||
unsigned long lastConnectionTime = 0; // last time you connected to the server, in milliseconds
|
|
||||||
boolean lastConnected = false; // state of the connection last time through the main loop
|
|
||||||
const unsigned long postingInterval = 60L*1000L; // delay between updates, in milliseconds
|
|
||||||
// the "L" is needed to use long type numbers
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// start serial port:
|
|
||||||
Serial.begin(9600);
|
|
||||||
// give the ethernet module time to boot up:
|
|
||||||
delay(1000);
|
|
||||||
// start the Ethernet connection using a fixed IP address and DNS server:
|
|
||||||
Ethernet.begin(mac, ip, myDns);
|
|
||||||
// print the Ethernet board/shield's IP address:
|
|
||||||
Serial.print("My IP address: ");
|
|
||||||
Serial.println(Ethernet.localIP());
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// if there's incoming data from the net connection.
|
|
||||||
// send it out the serial port. This is for debugging
|
|
||||||
// purposes only:
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.print(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
// if there's no net connection, but there was one last time
|
|
||||||
// through the loop, then stop the client:
|
|
||||||
if (!client.connected() && lastConnected) {
|
|
||||||
Serial.println();
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
// if you're not connected, and ten seconds have passed since
|
|
||||||
// your last connection, then connect again and send data:
|
|
||||||
if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
|
|
||||||
httpRequest();
|
|
||||||
}
|
|
||||||
// store the state of the connection for next time through
|
|
||||||
// the loop:
|
|
||||||
lastConnected = client.connected();
|
|
||||||
}
|
|
||||||
|
|
||||||
// this method makes a HTTP connection to the server:
|
|
||||||
void httpRequest() {
|
|
||||||
// if there's a successful connection:
|
|
||||||
if (client.connect(server, 80)) {
|
|
||||||
Serial.println("connecting...");
|
|
||||||
// send the HTTP PUT request:
|
|
||||||
client.println("GET /latest.txt HTTP/1.1");
|
|
||||||
client.println("Host: www.arduino.cc");
|
|
||||||
client.println("User-Agent: arduino-ethernet");
|
|
||||||
client.println("Connection: close");
|
|
||||||
client.println();
|
|
||||||
|
|
||||||
// note the time that the connection was made:
|
|
||||||
lastConnectionTime = millis();
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// if you couldn't make a connection:
|
|
||||||
Serial.println("connection failed");
|
|
||||||
Serial.println("disconnecting.");
|
|
||||||
client.stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,100 +0,0 @@
|
||||||
/*
|
|
||||||
Web Server
|
|
||||||
|
|
||||||
A simple web server that shows the value of the analog input pins.
|
|
||||||
using an Arduino Wiznet Ethernet shield.
|
|
||||||
|
|
||||||
Circuit:
|
|
||||||
* Ethernet shield attached to pins 10, 11, 12, 13
|
|
||||||
* Analog inputs attached to pins A0 through A5 (optional)
|
|
||||||
|
|
||||||
created 18 Dec 2009
|
|
||||||
by David A. Mellis
|
|
||||||
modified 9 Apr 2012
|
|
||||||
by Tom Igoe
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <SPI.h>
|
|
||||||
#include <Ethernet.h>
|
|
||||||
|
|
||||||
// Enter a MAC address and IP address for your controller below.
|
|
||||||
// The IP address will be dependent on your local network:
|
|
||||||
byte mac[] = {
|
|
||||||
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
|
|
||||||
IPAddress ip(192,168,1,177);
|
|
||||||
|
|
||||||
// Initialize the Ethernet server library
|
|
||||||
// with the IP address and port you want to use
|
|
||||||
// (port 80 is default for HTTP):
|
|
||||||
EthernetServer server(80);
|
|
||||||
|
|
||||||
void setup() {
|
|
||||||
// Open serial communications and wait for port to open:
|
|
||||||
Serial.begin(9600);
|
|
||||||
while (!Serial) {
|
|
||||||
; // wait for serial port to connect. Needed for Leonardo only
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// start the Ethernet connection and the server:
|
|
||||||
Ethernet.begin(mac, ip);
|
|
||||||
server.begin();
|
|
||||||
Serial.print("server is at ");
|
|
||||||
Serial.println(Ethernet.localIP());
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void loop() {
|
|
||||||
// listen for incoming clients
|
|
||||||
EthernetClient client = server.available();
|
|
||||||
if (client) {
|
|
||||||
Serial.println("new client");
|
|
||||||
// an http request ends with a blank line
|
|
||||||
boolean currentLineIsBlank = true;
|
|
||||||
while (client.connected()) {
|
|
||||||
if (client.available()) {
|
|
||||||
char c = client.read();
|
|
||||||
Serial.write(c);
|
|
||||||
// if you've gotten to the end of the line (received a newline
|
|
||||||
// character) and the line is blank, the http request has ended,
|
|
||||||
// so you can send a reply
|
|
||||||
if (c == '\n' && currentLineIsBlank) {
|
|
||||||
// send a standard http response header
|
|
||||||
client.println("HTTP/1.1 200 OK");
|
|
||||||
client.println("Content-Type: text/html");
|
|
||||||
client.println("Connection: close"); // the connection will be closed after completion of the response
|
|
||||||
client.println("Refresh: 5"); // refresh the page automatically every 5 sec
|
|
||||||
client.println();
|
|
||||||
client.println("<!DOCTYPE HTML>");
|
|
||||||
client.println("<html>");
|
|
||||||
// output the value of each analog input pin
|
|
||||||
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
|
|
||||||
int sensorReading = analogRead(analogChannel);
|
|
||||||
client.print("analog input ");
|
|
||||||
client.print(analogChannel);
|
|
||||||
client.print(" is ");
|
|
||||||
client.print(sensorReading);
|
|
||||||
client.println("<br />");
|
|
||||||
}
|
|
||||||
client.println("</html>");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if (c == '\n') {
|
|
||||||
// you're starting a new line
|
|
||||||
currentLineIsBlank = true;
|
|
||||||
}
|
|
||||||
else if (c != '\r') {
|
|
||||||
// you've gotten a character on the current line
|
|
||||||
currentLineIsBlank = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// give the web browser time to receive the data
|
|
||||||
delay(1);
|
|
||||||
// close the connection:
|
|
||||||
client.stop();
|
|
||||||
Serial.println("client disonnected");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,37 +0,0 @@
|
||||||
#######################################
|
|
||||||
# Syntax Coloring Map For Ethernet
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Datatypes (KEYWORD1)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
Ethernet KEYWORD1
|
|
||||||
EthernetClient KEYWORD1
|
|
||||||
EthernetServer KEYWORD1
|
|
||||||
IPAddress KEYWORD1
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Methods and Functions (KEYWORD2)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
status KEYWORD2
|
|
||||||
connect KEYWORD2
|
|
||||||
write KEYWORD2
|
|
||||||
available KEYWORD2
|
|
||||||
read KEYWORD2
|
|
||||||
peek KEYWORD2
|
|
||||||
flush KEYWORD2
|
|
||||||
stop KEYWORD2
|
|
||||||
connected KEYWORD2
|
|
||||||
begin KEYWORD2
|
|
||||||
beginPacket KEYWORD2
|
|
||||||
endPacket KEYWORD2
|
|
||||||
parsePacket KEYWORD2
|
|
||||||
remoteIP KEYWORD2
|
|
||||||
remotePort KEYWORD2
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Constants (LITERAL1)
|
|
||||||
#######################################
|
|
||||||
|
|
|
@ -1,13 +0,0 @@
|
||||||
#ifndef UTIL_H
|
|
||||||
#define UTIL_H
|
|
||||||
|
|
||||||
#define htons(x) ( ((x)<<8) | (((x)>>8)&0xFF) )
|
|
||||||
#define ntohs(x) htons(x)
|
|
||||||
|
|
||||||
#define htonl(x) ( ((x)<<24 & 0xFF000000UL) | \
|
|
||||||
((x)<< 8 & 0x00FF0000UL) | \
|
|
||||||
((x)>> 8 & 0x0000FF00UL) | \
|
|
||||||
((x)>>24 & 0x000000FFUL) )
|
|
||||||
#define ntohl(x) htonl(x)
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,400 +0,0 @@
|
||||||
#include "w5100.h"
|
|
||||||
#include "socket.h"
|
|
||||||
|
|
||||||
static uint16_t local_port;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This Socket function initialize the channel in perticular mode, and set the port and wait for W5100 done it.
|
|
||||||
* @return 1 for success else 0.
|
|
||||||
*/
|
|
||||||
uint8_t socket(SOCKET s, uint8_t protocol, uint16_t port, uint8_t flag)
|
|
||||||
{
|
|
||||||
if ((protocol == SnMR::TCP) || (protocol == SnMR::UDP) || (protocol == SnMR::IPRAW) || (protocol == SnMR::MACRAW) || (protocol == SnMR::PPPOE))
|
|
||||||
{
|
|
||||||
close(s);
|
|
||||||
W5100.writeSnMR(s, protocol | flag);
|
|
||||||
if (port != 0) {
|
|
||||||
W5100.writeSnPORT(s, port);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
local_port++; // if don't set the source port, set local_port number.
|
|
||||||
W5100.writeSnPORT(s, local_port);
|
|
||||||
}
|
|
||||||
|
|
||||||
W5100.execCmdSn(s, Sock_OPEN);
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function close the socket and parameter is "s" which represent the socket number
|
|
||||||
*/
|
|
||||||
void close(SOCKET s)
|
|
||||||
{
|
|
||||||
W5100.execCmdSn(s, Sock_CLOSE);
|
|
||||||
W5100.writeSnIR(s, 0xFF);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function established the connection for the channel in passive (server) mode. This function waits for the request from the peer.
|
|
||||||
* @return 1 for success else 0.
|
|
||||||
*/
|
|
||||||
uint8_t listen(SOCKET s)
|
|
||||||
{
|
|
||||||
if (W5100.readSnSR(s) != SnSR::INIT)
|
|
||||||
return 0;
|
|
||||||
W5100.execCmdSn(s, Sock_LISTEN);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function established the connection for the channel in Active (client) mode.
|
|
||||||
* This function waits for the untill the connection is established.
|
|
||||||
*
|
|
||||||
* @return 1 for success else 0.
|
|
||||||
*/
|
|
||||||
uint8_t connect(SOCKET s, uint8_t * addr, uint16_t port)
|
|
||||||
{
|
|
||||||
if
|
|
||||||
(
|
|
||||||
((addr[0] == 0xFF) && (addr[1] == 0xFF) && (addr[2] == 0xFF) && (addr[3] == 0xFF)) ||
|
|
||||||
((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
|
|
||||||
(port == 0x00)
|
|
||||||
)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
// set destination IP
|
|
||||||
W5100.writeSnDIPR(s, addr);
|
|
||||||
W5100.writeSnDPORT(s, port);
|
|
||||||
W5100.execCmdSn(s, Sock_CONNECT);
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function used for disconnect the socket and parameter is "s" which represent the socket number
|
|
||||||
* @return 1 for success else 0.
|
|
||||||
*/
|
|
||||||
void disconnect(SOCKET s)
|
|
||||||
{
|
|
||||||
W5100.execCmdSn(s, Sock_DISCON);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function used to send the data in TCP mode
|
|
||||||
* @return 1 for success else 0.
|
|
||||||
*/
|
|
||||||
uint16_t send(SOCKET s, const uint8_t * buf, uint16_t len)
|
|
||||||
{
|
|
||||||
uint8_t status=0;
|
|
||||||
uint16_t ret=0;
|
|
||||||
uint16_t freesize=0;
|
|
||||||
|
|
||||||
if (len > W5100.SSIZE)
|
|
||||||
ret = W5100.SSIZE; // check size not to exceed MAX size.
|
|
||||||
else
|
|
||||||
ret = len;
|
|
||||||
|
|
||||||
// if freebuf is available, start.
|
|
||||||
do
|
|
||||||
{
|
|
||||||
freesize = W5100.getTXFreeSize(s);
|
|
||||||
status = W5100.readSnSR(s);
|
|
||||||
if ((status != SnSR::ESTABLISHED) && (status != SnSR::CLOSE_WAIT))
|
|
||||||
{
|
|
||||||
ret = 0;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (freesize < ret);
|
|
||||||
|
|
||||||
// copy data
|
|
||||||
W5100.send_data_processing(s, (uint8_t *)buf, ret);
|
|
||||||
W5100.execCmdSn(s, Sock_SEND);
|
|
||||||
|
|
||||||
/* +2008.01 bj */
|
|
||||||
while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
|
|
||||||
{
|
|
||||||
/* m2008.01 [bj] : reduce code */
|
|
||||||
if ( W5100.readSnSR(s) == SnSR::CLOSED )
|
|
||||||
{
|
|
||||||
close(s);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* +2008.01 bj */
|
|
||||||
W5100.writeSnIR(s, SnIR::SEND_OK);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function is an application I/F function which is used to receive the data in TCP mode.
|
|
||||||
* It continues to wait for data as much as the application wants to receive.
|
|
||||||
*
|
|
||||||
* @return received data size for success else -1.
|
|
||||||
*/
|
|
||||||
int16_t recv(SOCKET s, uint8_t *buf, int16_t len)
|
|
||||||
{
|
|
||||||
// Check how much data is available
|
|
||||||
int16_t ret = W5100.getRXReceivedSize(s);
|
|
||||||
if ( ret == 0 )
|
|
||||||
{
|
|
||||||
// No data available.
|
|
||||||
uint8_t status = W5100.readSnSR(s);
|
|
||||||
if ( status == SnSR::LISTEN || status == SnSR::CLOSED || status == SnSR::CLOSE_WAIT )
|
|
||||||
{
|
|
||||||
// The remote end has closed its side of the connection, so this is the eof state
|
|
||||||
ret = 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// The connection is still up, but there's no data waiting to be read
|
|
||||||
ret = -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (ret > len)
|
|
||||||
{
|
|
||||||
ret = len;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( ret > 0 )
|
|
||||||
{
|
|
||||||
W5100.recv_data_processing(s, buf, ret);
|
|
||||||
W5100.execCmdSn(s, Sock_RECV);
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief Returns the first byte in the receive queue (no checking)
|
|
||||||
*
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
uint16_t peek(SOCKET s, uint8_t *buf)
|
|
||||||
{
|
|
||||||
W5100.recv_data_processing(s, buf, 1, 1);
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function is an application I/F function which is used to send the data for other then TCP mode.
|
|
||||||
* Unlike TCP transmission, The peer's destination address and the port is needed.
|
|
||||||
*
|
|
||||||
* @return This function return send data size for success else -1.
|
|
||||||
*/
|
|
||||||
uint16_t sendto(SOCKET s, const uint8_t *buf, uint16_t len, uint8_t *addr, uint16_t port)
|
|
||||||
{
|
|
||||||
uint16_t ret=0;
|
|
||||||
|
|
||||||
if (len > W5100.SSIZE) ret = W5100.SSIZE; // check size not to exceed MAX size.
|
|
||||||
else ret = len;
|
|
||||||
|
|
||||||
if
|
|
||||||
(
|
|
||||||
((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
|
|
||||||
((port == 0x00)) ||(ret == 0)
|
|
||||||
)
|
|
||||||
{
|
|
||||||
/* +2008.01 [bj] : added return value */
|
|
||||||
ret = 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
W5100.writeSnDIPR(s, addr);
|
|
||||||
W5100.writeSnDPORT(s, port);
|
|
||||||
|
|
||||||
// copy data
|
|
||||||
W5100.send_data_processing(s, (uint8_t *)buf, ret);
|
|
||||||
W5100.execCmdSn(s, Sock_SEND);
|
|
||||||
|
|
||||||
/* +2008.01 bj */
|
|
||||||
while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
|
|
||||||
{
|
|
||||||
if (W5100.readSnIR(s) & SnIR::TIMEOUT)
|
|
||||||
{
|
|
||||||
/* +2008.01 [bj]: clear interrupt */
|
|
||||||
W5100.writeSnIR(s, (SnIR::SEND_OK | SnIR::TIMEOUT)); /* clear SEND_OK & TIMEOUT */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* +2008.01 bj */
|
|
||||||
W5100.writeSnIR(s, SnIR::SEND_OK);
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function is an application I/F function which is used to receive the data in other then
|
|
||||||
* TCP mode. This function is used to receive UDP, IP_RAW and MAC_RAW mode, and handle the header as well.
|
|
||||||
*
|
|
||||||
* @return This function return received data size for success else -1.
|
|
||||||
*/
|
|
||||||
uint16_t recvfrom(SOCKET s, uint8_t *buf, uint16_t len, uint8_t *addr, uint16_t *port)
|
|
||||||
{
|
|
||||||
uint8_t head[8];
|
|
||||||
uint16_t data_len=0;
|
|
||||||
uint16_t ptr=0;
|
|
||||||
|
|
||||||
if ( len > 0 )
|
|
||||||
{
|
|
||||||
ptr = W5100.readSnRX_RD(s);
|
|
||||||
switch (W5100.readSnMR(s) & 0x07)
|
|
||||||
{
|
|
||||||
case SnMR::UDP :
|
|
||||||
W5100.read_data(s, (uint8_t *)ptr, head, 0x08);
|
|
||||||
ptr += 8;
|
|
||||||
// read peer's IP address, port number.
|
|
||||||
addr[0] = head[0];
|
|
||||||
addr[1] = head[1];
|
|
||||||
addr[2] = head[2];
|
|
||||||
addr[3] = head[3];
|
|
||||||
*port = head[4];
|
|
||||||
*port = (*port << 8) + head[5];
|
|
||||||
data_len = head[6];
|
|
||||||
data_len = (data_len << 8) + head[7];
|
|
||||||
|
|
||||||
W5100.read_data(s, (uint8_t *)ptr, buf, data_len); // data copy.
|
|
||||||
ptr += data_len;
|
|
||||||
|
|
||||||
W5100.writeSnRX_RD(s, ptr);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case SnMR::IPRAW :
|
|
||||||
W5100.read_data(s, (uint8_t *)ptr, head, 0x06);
|
|
||||||
ptr += 6;
|
|
||||||
|
|
||||||
addr[0] = head[0];
|
|
||||||
addr[1] = head[1];
|
|
||||||
addr[2] = head[2];
|
|
||||||
addr[3] = head[3];
|
|
||||||
data_len = head[4];
|
|
||||||
data_len = (data_len << 8) + head[5];
|
|
||||||
|
|
||||||
W5100.read_data(s, (uint8_t *)ptr, buf, data_len); // data copy.
|
|
||||||
ptr += data_len;
|
|
||||||
|
|
||||||
W5100.writeSnRX_RD(s, ptr);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case SnMR::MACRAW:
|
|
||||||
W5100.read_data(s,(uint8_t*)ptr,head,2);
|
|
||||||
ptr+=2;
|
|
||||||
data_len = head[0];
|
|
||||||
data_len = (data_len<<8) + head[1] - 2;
|
|
||||||
|
|
||||||
W5100.read_data(s,(uint8_t*) ptr,buf,data_len);
|
|
||||||
ptr += data_len;
|
|
||||||
W5100.writeSnRX_RD(s, ptr);
|
|
||||||
break;
|
|
||||||
|
|
||||||
default :
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
W5100.execCmdSn(s, Sock_RECV);
|
|
||||||
}
|
|
||||||
return data_len;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
uint16_t igmpsend(SOCKET s, const uint8_t * buf, uint16_t len)
|
|
||||||
{
|
|
||||||
uint8_t status=0;
|
|
||||||
uint16_t ret=0;
|
|
||||||
|
|
||||||
if (len > W5100.SSIZE)
|
|
||||||
ret = W5100.SSIZE; // check size not to exceed MAX size.
|
|
||||||
else
|
|
||||||
ret = len;
|
|
||||||
|
|
||||||
if (ret == 0)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
W5100.send_data_processing(s, (uint8_t *)buf, ret);
|
|
||||||
W5100.execCmdSn(s, Sock_SEND);
|
|
||||||
|
|
||||||
while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
|
|
||||||
{
|
|
||||||
status = W5100.readSnSR(s);
|
|
||||||
if (W5100.readSnIR(s) & SnIR::TIMEOUT)
|
|
||||||
{
|
|
||||||
/* in case of igmp, if send fails, then socket closed */
|
|
||||||
/* if you want change, remove this code. */
|
|
||||||
close(s);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
W5100.writeSnIR(s, SnIR::SEND_OK);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bufferData(SOCKET s, uint16_t offset, const uint8_t* buf, uint16_t len)
|
|
||||||
{
|
|
||||||
uint16_t ret =0;
|
|
||||||
if (len > W5100.getTXFreeSize(s))
|
|
||||||
{
|
|
||||||
ret = W5100.getTXFreeSize(s); // check size not to exceed MAX size.
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
ret = len;
|
|
||||||
}
|
|
||||||
W5100.send_data_processing_offset(s, offset, buf, ret);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int startUDP(SOCKET s, uint8_t* addr, uint16_t port)
|
|
||||||
{
|
|
||||||
if
|
|
||||||
(
|
|
||||||
((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
|
|
||||||
((port == 0x00))
|
|
||||||
)
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
W5100.writeSnDIPR(s, addr);
|
|
||||||
W5100.writeSnDPORT(s, port);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int sendUDP(SOCKET s)
|
|
||||||
{
|
|
||||||
W5100.execCmdSn(s, Sock_SEND);
|
|
||||||
|
|
||||||
/* +2008.01 bj */
|
|
||||||
while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
|
|
||||||
{
|
|
||||||
if (W5100.readSnIR(s) & SnIR::TIMEOUT)
|
|
||||||
{
|
|
||||||
/* +2008.01 [bj]: clear interrupt */
|
|
||||||
W5100.writeSnIR(s, (SnIR::SEND_OK|SnIR::TIMEOUT));
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* +2008.01 bj */
|
|
||||||
W5100.writeSnIR(s, SnIR::SEND_OK);
|
|
||||||
|
|
||||||
/* Sent ok */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,41 +0,0 @@
|
||||||
#ifndef _SOCKET_H_
|
|
||||||
#define _SOCKET_H_
|
|
||||||
|
|
||||||
#include "w5100.h"
|
|
||||||
|
|
||||||
extern uint8_t socket(SOCKET s, uint8_t protocol, uint16_t port, uint8_t flag); // Opens a socket(TCP or UDP or IP_RAW mode)
|
|
||||||
extern void close(SOCKET s); // Close socket
|
|
||||||
extern uint8_t connect(SOCKET s, uint8_t * addr, uint16_t port); // Establish TCP connection (Active connection)
|
|
||||||
extern void disconnect(SOCKET s); // disconnect the connection
|
|
||||||
extern uint8_t listen(SOCKET s); // Establish TCP connection (Passive connection)
|
|
||||||
extern uint16_t send(SOCKET s, const uint8_t * buf, uint16_t len); // Send data (TCP)
|
|
||||||
extern int16_t recv(SOCKET s, uint8_t * buf, int16_t len); // Receive data (TCP)
|
|
||||||
extern uint16_t peek(SOCKET s, uint8_t *buf);
|
|
||||||
extern uint16_t sendto(SOCKET s, const uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t port); // Send data (UDP/IP RAW)
|
|
||||||
extern uint16_t recvfrom(SOCKET s, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t *port); // Receive data (UDP/IP RAW)
|
|
||||||
|
|
||||||
extern uint16_t igmpsend(SOCKET s, const uint8_t * buf, uint16_t len);
|
|
||||||
|
|
||||||
// Functions to allow buffered UDP send (i.e. where the UDP datagram is built up over a
|
|
||||||
// number of calls before being sent
|
|
||||||
/*
|
|
||||||
@brief This function sets up a UDP datagram, the data for which will be provided by one
|
|
||||||
or more calls to bufferData and then finally sent with sendUDP.
|
|
||||||
@return 1 if the datagram was successfully set up, or 0 if there was an error
|
|
||||||
*/
|
|
||||||
extern int startUDP(SOCKET s, uint8_t* addr, uint16_t port);
|
|
||||||
/*
|
|
||||||
@brief This function copies up to len bytes of data from buf into a UDP datagram to be
|
|
||||||
sent later by sendUDP. Allows datagrams to be built up from a series of bufferData calls.
|
|
||||||
@return Number of bytes successfully buffered
|
|
||||||
*/
|
|
||||||
uint16_t bufferData(SOCKET s, uint16_t offset, const uint8_t* buf, uint16_t len);
|
|
||||||
/*
|
|
||||||
@brief Send a UDP datagram built up from a sequence of startUDP followed by one or more
|
|
||||||
calls to bufferData.
|
|
||||||
@return 1 if the datagram was successfully sent, or 0 if there was an error
|
|
||||||
*/
|
|
||||||
int sendUDP(SOCKET s);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
/* _SOCKET_H_ */
|
|
|
@ -1,188 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2010 by Cristian Maglie <c.maglie@bug.st>
|
|
||||||
*
|
|
||||||
* This file is free software; you can redistribute it and/or modify
|
|
||||||
* it under the terms of either the GNU General Public License version 2
|
|
||||||
* or the GNU Lesser General Public License version 2.1, both as
|
|
||||||
* published by the Free Software Foundation.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <avr/interrupt.h>
|
|
||||||
|
|
||||||
#include "w5100.h"
|
|
||||||
|
|
||||||
// W5100 controller instance
|
|
||||||
W5100Class W5100;
|
|
||||||
|
|
||||||
#define TX_RX_MAX_BUF_SIZE 2048
|
|
||||||
#define TX_BUF 0x1100
|
|
||||||
#define RX_BUF (TX_BUF + TX_RX_MAX_BUF_SIZE)
|
|
||||||
|
|
||||||
#define TXBUF_BASE 0x4000
|
|
||||||
#define RXBUF_BASE 0x6000
|
|
||||||
|
|
||||||
void W5100Class::init(void)
|
|
||||||
{
|
|
||||||
delay(300);
|
|
||||||
|
|
||||||
SPI.begin();
|
|
||||||
initSS();
|
|
||||||
|
|
||||||
writeMR(1<<RST);
|
|
||||||
writeTMSR(0x55);
|
|
||||||
writeRMSR(0x55);
|
|
||||||
|
|
||||||
for (int i=0; i<MAX_SOCK_NUM; i++) {
|
|
||||||
SBASE[i] = TXBUF_BASE + SSIZE * i;
|
|
||||||
RBASE[i] = RXBUF_BASE + RSIZE * i;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t W5100Class::getTXFreeSize(SOCKET s)
|
|
||||||
{
|
|
||||||
uint16_t val=0, val1=0;
|
|
||||||
do {
|
|
||||||
val1 = readSnTX_FSR(s);
|
|
||||||
if (val1 != 0)
|
|
||||||
val = readSnTX_FSR(s);
|
|
||||||
}
|
|
||||||
while (val != val1);
|
|
||||||
return val;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t W5100Class::getRXReceivedSize(SOCKET s)
|
|
||||||
{
|
|
||||||
uint16_t val=0,val1=0;
|
|
||||||
do {
|
|
||||||
val1 = readSnRX_RSR(s);
|
|
||||||
if (val1 != 0)
|
|
||||||
val = readSnRX_RSR(s);
|
|
||||||
}
|
|
||||||
while (val != val1);
|
|
||||||
return val;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void W5100Class::send_data_processing(SOCKET s, const uint8_t *data, uint16_t len)
|
|
||||||
{
|
|
||||||
// This is same as having no offset in a call to send_data_processing_offset
|
|
||||||
send_data_processing_offset(s, 0, data, len);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::send_data_processing_offset(SOCKET s, uint16_t data_offset, const uint8_t *data, uint16_t len)
|
|
||||||
{
|
|
||||||
uint16_t ptr = readSnTX_WR(s);
|
|
||||||
ptr += data_offset;
|
|
||||||
uint16_t offset = ptr & SMASK;
|
|
||||||
uint16_t dstAddr = offset + SBASE[s];
|
|
||||||
|
|
||||||
if (offset + len > SSIZE)
|
|
||||||
{
|
|
||||||
// Wrap around circular buffer
|
|
||||||
uint16_t size = SSIZE - offset;
|
|
||||||
write(dstAddr, data, size);
|
|
||||||
write(SBASE[s], data + size, len - size);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
write(dstAddr, data, len);
|
|
||||||
}
|
|
||||||
|
|
||||||
ptr += len;
|
|
||||||
writeSnTX_WR(s, ptr);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void W5100Class::recv_data_processing(SOCKET s, uint8_t *data, uint16_t len, uint8_t peek)
|
|
||||||
{
|
|
||||||
uint16_t ptr;
|
|
||||||
ptr = readSnRX_RD(s);
|
|
||||||
read_data(s, (uint8_t *)ptr, data, len);
|
|
||||||
if (!peek)
|
|
||||||
{
|
|
||||||
ptr += len;
|
|
||||||
writeSnRX_RD(s, ptr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::read_data(SOCKET s, volatile uint8_t *src, volatile uint8_t *dst, uint16_t len)
|
|
||||||
{
|
|
||||||
uint16_t size;
|
|
||||||
uint16_t src_mask;
|
|
||||||
uint16_t src_ptr;
|
|
||||||
|
|
||||||
src_mask = (uint16_t)src & RMASK;
|
|
||||||
src_ptr = RBASE[s] + src_mask;
|
|
||||||
|
|
||||||
if( (src_mask + len) > RSIZE )
|
|
||||||
{
|
|
||||||
size = RSIZE - src_mask;
|
|
||||||
read(src_ptr, (uint8_t *)dst, size);
|
|
||||||
dst += size;
|
|
||||||
read(RBASE[s], (uint8_t *) dst, len - size);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
read(src_ptr, (uint8_t *) dst, len);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
uint8_t W5100Class::write(uint16_t _addr, uint8_t _data)
|
|
||||||
{
|
|
||||||
setSS();
|
|
||||||
SPI.transfer(0xF0);
|
|
||||||
SPI.transfer(_addr >> 8);
|
|
||||||
SPI.transfer(_addr & 0xFF);
|
|
||||||
SPI.transfer(_data);
|
|
||||||
resetSS();
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t W5100Class::write(uint16_t _addr, const uint8_t *_buf, uint16_t _len)
|
|
||||||
{
|
|
||||||
for (uint16_t i=0; i<_len; i++)
|
|
||||||
{
|
|
||||||
setSS();
|
|
||||||
SPI.transfer(0xF0);
|
|
||||||
SPI.transfer(_addr >> 8);
|
|
||||||
SPI.transfer(_addr & 0xFF);
|
|
||||||
_addr++;
|
|
||||||
SPI.transfer(_buf[i]);
|
|
||||||
resetSS();
|
|
||||||
}
|
|
||||||
return _len;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t W5100Class::read(uint16_t _addr)
|
|
||||||
{
|
|
||||||
setSS();
|
|
||||||
SPI.transfer(0x0F);
|
|
||||||
SPI.transfer(_addr >> 8);
|
|
||||||
SPI.transfer(_addr & 0xFF);
|
|
||||||
uint8_t _data = SPI.transfer(0);
|
|
||||||
resetSS();
|
|
||||||
return _data;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t W5100Class::read(uint16_t _addr, uint8_t *_buf, uint16_t _len)
|
|
||||||
{
|
|
||||||
for (uint16_t i=0; i<_len; i++)
|
|
||||||
{
|
|
||||||
setSS();
|
|
||||||
SPI.transfer(0x0F);
|
|
||||||
SPI.transfer(_addr >> 8);
|
|
||||||
SPI.transfer(_addr & 0xFF);
|
|
||||||
_addr++;
|
|
||||||
_buf[i] = SPI.transfer(0);
|
|
||||||
resetSS();
|
|
||||||
}
|
|
||||||
return _len;
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::execCmdSn(SOCKET s, SockCMD _cmd) {
|
|
||||||
// Send command to socket
|
|
||||||
writeSnCR(s, _cmd);
|
|
||||||
// Wait for command to complete
|
|
||||||
while (readSnCR(s))
|
|
||||||
;
|
|
||||||
}
|
|
|
@ -1,404 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2010 by Cristian Maglie <c.maglie@bug.st>
|
|
||||||
*
|
|
||||||
* This file is free software; you can redistribute it and/or modify
|
|
||||||
* it under the terms of either the GNU General Public License version 2
|
|
||||||
* or the GNU Lesser General Public License version 2.1, both as
|
|
||||||
* published by the Free Software Foundation.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef W5100_H_INCLUDED
|
|
||||||
#define W5100_H_INCLUDED
|
|
||||||
|
|
||||||
#include <avr/pgmspace.h>
|
|
||||||
#include <SPI.h>
|
|
||||||
|
|
||||||
#define MAX_SOCK_NUM 4
|
|
||||||
|
|
||||||
typedef uint8_t SOCKET;
|
|
||||||
|
|
||||||
#define IDM_OR 0x8000
|
|
||||||
#define IDM_AR0 0x8001
|
|
||||||
#define IDM_AR1 0x8002
|
|
||||||
#define IDM_DR 0x8003
|
|
||||||
/*
|
|
||||||
class MR {
|
|
||||||
public:
|
|
||||||
static const uint8_t RST = 0x80;
|
|
||||||
static const uint8_t PB = 0x10;
|
|
||||||
static const uint8_t PPPOE = 0x08;
|
|
||||||
static const uint8_t LB = 0x04;
|
|
||||||
static const uint8_t AI = 0x02;
|
|
||||||
static const uint8_t IND = 0x01;
|
|
||||||
};
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
class IR {
|
|
||||||
public:
|
|
||||||
static const uint8_t CONFLICT = 0x80;
|
|
||||||
static const uint8_t UNREACH = 0x40;
|
|
||||||
static const uint8_t PPPoE = 0x20;
|
|
||||||
static const uint8_t SOCK0 = 0x01;
|
|
||||||
static const uint8_t SOCK1 = 0x02;
|
|
||||||
static const uint8_t SOCK2 = 0x04;
|
|
||||||
static const uint8_t SOCK3 = 0x08;
|
|
||||||
static inline uint8_t SOCK(SOCKET ch) { return (0x01 << ch); };
|
|
||||||
};
|
|
||||||
*/
|
|
||||||
|
|
||||||
class SnMR {
|
|
||||||
public:
|
|
||||||
static const uint8_t CLOSE = 0x00;
|
|
||||||
static const uint8_t TCP = 0x01;
|
|
||||||
static const uint8_t UDP = 0x02;
|
|
||||||
static const uint8_t IPRAW = 0x03;
|
|
||||||
static const uint8_t MACRAW = 0x04;
|
|
||||||
static const uint8_t PPPOE = 0x05;
|
|
||||||
static const uint8_t ND = 0x20;
|
|
||||||
static const uint8_t MULTI = 0x80;
|
|
||||||
};
|
|
||||||
|
|
||||||
enum SockCMD {
|
|
||||||
Sock_OPEN = 0x01,
|
|
||||||
Sock_LISTEN = 0x02,
|
|
||||||
Sock_CONNECT = 0x04,
|
|
||||||
Sock_DISCON = 0x08,
|
|
||||||
Sock_CLOSE = 0x10,
|
|
||||||
Sock_SEND = 0x20,
|
|
||||||
Sock_SEND_MAC = 0x21,
|
|
||||||
Sock_SEND_KEEP = 0x22,
|
|
||||||
Sock_RECV = 0x40
|
|
||||||
};
|
|
||||||
|
|
||||||
/*class SnCmd {
|
|
||||||
public:
|
|
||||||
static const uint8_t OPEN = 0x01;
|
|
||||||
static const uint8_t LISTEN = 0x02;
|
|
||||||
static const uint8_t CONNECT = 0x04;
|
|
||||||
static const uint8_t DISCON = 0x08;
|
|
||||||
static const uint8_t CLOSE = 0x10;
|
|
||||||
static const uint8_t SEND = 0x20;
|
|
||||||
static const uint8_t SEND_MAC = 0x21;
|
|
||||||
static const uint8_t SEND_KEEP = 0x22;
|
|
||||||
static const uint8_t RECV = 0x40;
|
|
||||||
};
|
|
||||||
*/
|
|
||||||
|
|
||||||
class SnIR {
|
|
||||||
public:
|
|
||||||
static const uint8_t SEND_OK = 0x10;
|
|
||||||
static const uint8_t TIMEOUT = 0x08;
|
|
||||||
static const uint8_t RECV = 0x04;
|
|
||||||
static const uint8_t DISCON = 0x02;
|
|
||||||
static const uint8_t CON = 0x01;
|
|
||||||
};
|
|
||||||
|
|
||||||
class SnSR {
|
|
||||||
public:
|
|
||||||
static const uint8_t CLOSED = 0x00;
|
|
||||||
static const uint8_t INIT = 0x13;
|
|
||||||
static const uint8_t LISTEN = 0x14;
|
|
||||||
static const uint8_t SYNSENT = 0x15;
|
|
||||||
static const uint8_t SYNRECV = 0x16;
|
|
||||||
static const uint8_t ESTABLISHED = 0x17;
|
|
||||||
static const uint8_t FIN_WAIT = 0x18;
|
|
||||||
static const uint8_t CLOSING = 0x1A;
|
|
||||||
static const uint8_t TIME_WAIT = 0x1B;
|
|
||||||
static const uint8_t CLOSE_WAIT = 0x1C;
|
|
||||||
static const uint8_t LAST_ACK = 0x1D;
|
|
||||||
static const uint8_t UDP = 0x22;
|
|
||||||
static const uint8_t IPRAW = 0x32;
|
|
||||||
static const uint8_t MACRAW = 0x42;
|
|
||||||
static const uint8_t PPPOE = 0x5F;
|
|
||||||
};
|
|
||||||
|
|
||||||
class IPPROTO {
|
|
||||||
public:
|
|
||||||
static const uint8_t IP = 0;
|
|
||||||
static const uint8_t ICMP = 1;
|
|
||||||
static const uint8_t IGMP = 2;
|
|
||||||
static const uint8_t GGP = 3;
|
|
||||||
static const uint8_t TCP = 6;
|
|
||||||
static const uint8_t PUP = 12;
|
|
||||||
static const uint8_t UDP = 17;
|
|
||||||
static const uint8_t IDP = 22;
|
|
||||||
static const uint8_t ND = 77;
|
|
||||||
static const uint8_t RAW = 255;
|
|
||||||
};
|
|
||||||
|
|
||||||
class W5100Class {
|
|
||||||
|
|
||||||
public:
|
|
||||||
void init();
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function is being used for copy the data form Receive buffer of the chip to application buffer.
|
|
||||||
*
|
|
||||||
* It calculate the actual physical address where one has to read
|
|
||||||
* the data from Receive buffer. Here also take care of the condition while it exceed
|
|
||||||
* the Rx memory uper-bound of socket.
|
|
||||||
*/
|
|
||||||
void read_data(SOCKET s, volatile uint8_t * src, volatile uint8_t * dst, uint16_t len);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function is being called by send() and sendto() function also.
|
|
||||||
*
|
|
||||||
* This function read the Tx write pointer register and after copy the data in buffer update the Tx write pointer
|
|
||||||
* register. User should read upper byte first and lower byte later to get proper value.
|
|
||||||
*/
|
|
||||||
void send_data_processing(SOCKET s, const uint8_t *data, uint16_t len);
|
|
||||||
/**
|
|
||||||
* @brief A copy of send_data_processing that uses the provided ptr for the
|
|
||||||
* write offset. Only needed for the "streaming" UDP API, where
|
|
||||||
* a single UDP packet is built up over a number of calls to
|
|
||||||
* send_data_processing_ptr, because TX_WR doesn't seem to get updated
|
|
||||||
* correctly in those scenarios
|
|
||||||
* @param ptr value to use in place of TX_WR. If 0, then the value is read
|
|
||||||
* in from TX_WR
|
|
||||||
* @return New value for ptr, to be used in the next call
|
|
||||||
*/
|
|
||||||
// FIXME Update documentation
|
|
||||||
void send_data_processing_offset(SOCKET s, uint16_t data_offset, const uint8_t *data, uint16_t len);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @brief This function is being called by recv() also.
|
|
||||||
*
|
|
||||||
* This function read the Rx read pointer register
|
|
||||||
* and after copy the data from receive buffer update the Rx write pointer register.
|
|
||||||
* User should read upper byte first and lower byte later to get proper value.
|
|
||||||
*/
|
|
||||||
void recv_data_processing(SOCKET s, uint8_t *data, uint16_t len, uint8_t peek = 0);
|
|
||||||
|
|
||||||
inline void setGatewayIp(uint8_t *_addr);
|
|
||||||
inline void getGatewayIp(uint8_t *_addr);
|
|
||||||
|
|
||||||
inline void setSubnetMask(uint8_t *_addr);
|
|
||||||
inline void getSubnetMask(uint8_t *_addr);
|
|
||||||
|
|
||||||
inline void setMACAddress(uint8_t * addr);
|
|
||||||
inline void getMACAddress(uint8_t * addr);
|
|
||||||
|
|
||||||
inline void setIPAddress(uint8_t * addr);
|
|
||||||
inline void getIPAddress(uint8_t * addr);
|
|
||||||
|
|
||||||
inline void setRetransmissionTime(uint16_t timeout);
|
|
||||||
inline void setRetransmissionCount(uint8_t _retry);
|
|
||||||
|
|
||||||
void execCmdSn(SOCKET s, SockCMD _cmd);
|
|
||||||
|
|
||||||
uint16_t getTXFreeSize(SOCKET s);
|
|
||||||
uint16_t getRXReceivedSize(SOCKET s);
|
|
||||||
|
|
||||||
|
|
||||||
// W5100 Registers
|
|
||||||
// ---------------
|
|
||||||
private:
|
|
||||||
static uint8_t write(uint16_t _addr, uint8_t _data);
|
|
||||||
static uint16_t write(uint16_t addr, const uint8_t *buf, uint16_t len);
|
|
||||||
static uint8_t read(uint16_t addr);
|
|
||||||
static uint16_t read(uint16_t addr, uint8_t *buf, uint16_t len);
|
|
||||||
|
|
||||||
#define __GP_REGISTER8(name, address) \
|
|
||||||
static inline void write##name(uint8_t _data) { \
|
|
||||||
write(address, _data); \
|
|
||||||
} \
|
|
||||||
static inline uint8_t read##name() { \
|
|
||||||
return read(address); \
|
|
||||||
}
|
|
||||||
#define __GP_REGISTER16(name, address) \
|
|
||||||
static void write##name(uint16_t _data) { \
|
|
||||||
write(address, _data >> 8); \
|
|
||||||
write(address+1, _data & 0xFF); \
|
|
||||||
} \
|
|
||||||
static uint16_t read##name() { \
|
|
||||||
uint16_t res = read(address); \
|
|
||||||
res = (res << 8) + read(address + 1); \
|
|
||||||
return res; \
|
|
||||||
}
|
|
||||||
#define __GP_REGISTER_N(name, address, size) \
|
|
||||||
static uint16_t write##name(uint8_t *_buff) { \
|
|
||||||
return write(address, _buff, size); \
|
|
||||||
} \
|
|
||||||
static uint16_t read##name(uint8_t *_buff) { \
|
|
||||||
return read(address, _buff, size); \
|
|
||||||
}
|
|
||||||
|
|
||||||
public:
|
|
||||||
__GP_REGISTER8 (MR, 0x0000); // Mode
|
|
||||||
__GP_REGISTER_N(GAR, 0x0001, 4); // Gateway IP address
|
|
||||||
__GP_REGISTER_N(SUBR, 0x0005, 4); // Subnet mask address
|
|
||||||
__GP_REGISTER_N(SHAR, 0x0009, 6); // Source MAC address
|
|
||||||
__GP_REGISTER_N(SIPR, 0x000F, 4); // Source IP address
|
|
||||||
__GP_REGISTER8 (IR, 0x0015); // Interrupt
|
|
||||||
__GP_REGISTER8 (IMR, 0x0016); // Interrupt Mask
|
|
||||||
__GP_REGISTER16(RTR, 0x0017); // Timeout address
|
|
||||||
__GP_REGISTER8 (RCR, 0x0019); // Retry count
|
|
||||||
__GP_REGISTER8 (RMSR, 0x001A); // Receive memory size
|
|
||||||
__GP_REGISTER8 (TMSR, 0x001B); // Transmit memory size
|
|
||||||
__GP_REGISTER8 (PATR, 0x001C); // Authentication type address in PPPoE mode
|
|
||||||
__GP_REGISTER8 (PTIMER, 0x0028); // PPP LCP Request Timer
|
|
||||||
__GP_REGISTER8 (PMAGIC, 0x0029); // PPP LCP Magic Number
|
|
||||||
__GP_REGISTER_N(UIPR, 0x002A, 4); // Unreachable IP address in UDP mode
|
|
||||||
__GP_REGISTER16(UPORT, 0x002E); // Unreachable Port address in UDP mode
|
|
||||||
|
|
||||||
#undef __GP_REGISTER8
|
|
||||||
#undef __GP_REGISTER16
|
|
||||||
#undef __GP_REGISTER_N
|
|
||||||
|
|
||||||
// W5100 Socket registers
|
|
||||||
// ----------------------
|
|
||||||
private:
|
|
||||||
static inline uint8_t readSn(SOCKET _s, uint16_t _addr);
|
|
||||||
static inline uint8_t writeSn(SOCKET _s, uint16_t _addr, uint8_t _data);
|
|
||||||
static inline uint16_t readSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t len);
|
|
||||||
static inline uint16_t writeSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t len);
|
|
||||||
|
|
||||||
static const uint16_t CH_BASE = 0x0400;
|
|
||||||
static const uint16_t CH_SIZE = 0x0100;
|
|
||||||
|
|
||||||
#define __SOCKET_REGISTER8(name, address) \
|
|
||||||
static inline void write##name(SOCKET _s, uint8_t _data) { \
|
|
||||||
writeSn(_s, address, _data); \
|
|
||||||
} \
|
|
||||||
static inline uint8_t read##name(SOCKET _s) { \
|
|
||||||
return readSn(_s, address); \
|
|
||||||
}
|
|
||||||
#define __SOCKET_REGISTER16(name, address) \
|
|
||||||
static void write##name(SOCKET _s, uint16_t _data) { \
|
|
||||||
writeSn(_s, address, _data >> 8); \
|
|
||||||
writeSn(_s, address+1, _data & 0xFF); \
|
|
||||||
} \
|
|
||||||
static uint16_t read##name(SOCKET _s) { \
|
|
||||||
uint16_t res = readSn(_s, address); \
|
|
||||||
uint16_t res2 = readSn(_s,address + 1); \
|
|
||||||
res = res << 8; \
|
|
||||||
res2 = res2 & 0xFF; \
|
|
||||||
res = res | res2; \
|
|
||||||
return res; \
|
|
||||||
}
|
|
||||||
#define __SOCKET_REGISTER_N(name, address, size) \
|
|
||||||
static uint16_t write##name(SOCKET _s, uint8_t *_buff) { \
|
|
||||||
return writeSn(_s, address, _buff, size); \
|
|
||||||
} \
|
|
||||||
static uint16_t read##name(SOCKET _s, uint8_t *_buff) { \
|
|
||||||
return readSn(_s, address, _buff, size); \
|
|
||||||
}
|
|
||||||
|
|
||||||
public:
|
|
||||||
__SOCKET_REGISTER8(SnMR, 0x0000) // Mode
|
|
||||||
__SOCKET_REGISTER8(SnCR, 0x0001) // Command
|
|
||||||
__SOCKET_REGISTER8(SnIR, 0x0002) // Interrupt
|
|
||||||
__SOCKET_REGISTER8(SnSR, 0x0003) // Status
|
|
||||||
__SOCKET_REGISTER16(SnPORT, 0x0004) // Source Port
|
|
||||||
__SOCKET_REGISTER_N(SnDHAR, 0x0006, 6) // Destination Hardw Addr
|
|
||||||
__SOCKET_REGISTER_N(SnDIPR, 0x000C, 4) // Destination IP Addr
|
|
||||||
__SOCKET_REGISTER16(SnDPORT, 0x0010) // Destination Port
|
|
||||||
__SOCKET_REGISTER16(SnMSSR, 0x0012) // Max Segment Size
|
|
||||||
__SOCKET_REGISTER8(SnPROTO, 0x0014) // Protocol in IP RAW Mode
|
|
||||||
__SOCKET_REGISTER8(SnTOS, 0x0015) // IP TOS
|
|
||||||
__SOCKET_REGISTER8(SnTTL, 0x0016) // IP TTL
|
|
||||||
__SOCKET_REGISTER16(SnTX_FSR, 0x0020) // TX Free Size
|
|
||||||
__SOCKET_REGISTER16(SnTX_RD, 0x0022) // TX Read Pointer
|
|
||||||
__SOCKET_REGISTER16(SnTX_WR, 0x0024) // TX Write Pointer
|
|
||||||
__SOCKET_REGISTER16(SnRX_RSR, 0x0026) // RX Free Size
|
|
||||||
__SOCKET_REGISTER16(SnRX_RD, 0x0028) // RX Read Pointer
|
|
||||||
__SOCKET_REGISTER16(SnRX_WR, 0x002A) // RX Write Pointer (supported?)
|
|
||||||
|
|
||||||
#undef __SOCKET_REGISTER8
|
|
||||||
#undef __SOCKET_REGISTER16
|
|
||||||
#undef __SOCKET_REGISTER_N
|
|
||||||
|
|
||||||
|
|
||||||
private:
|
|
||||||
static const uint8_t RST = 7; // Reset BIT
|
|
||||||
|
|
||||||
static const int SOCKETS = 4;
|
|
||||||
static const uint16_t SMASK = 0x07FF; // Tx buffer MASK
|
|
||||||
static const uint16_t RMASK = 0x07FF; // Rx buffer MASK
|
|
||||||
public:
|
|
||||||
static const uint16_t SSIZE = 2048; // Max Tx buffer size
|
|
||||||
private:
|
|
||||||
static const uint16_t RSIZE = 2048; // Max Rx buffer size
|
|
||||||
uint16_t SBASE[SOCKETS]; // Tx buffer base address
|
|
||||||
uint16_t RBASE[SOCKETS]; // Rx buffer base address
|
|
||||||
|
|
||||||
private:
|
|
||||||
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
|
|
||||||
inline static void initSS() { DDRB |= _BV(4); };
|
|
||||||
inline static void setSS() { PORTB &= ~_BV(4); };
|
|
||||||
inline static void resetSS() { PORTB |= _BV(4); };
|
|
||||||
#elif defined(__AVR_ATmega32U4__)
|
|
||||||
inline static void initSS() { DDRB |= _BV(6); };
|
|
||||||
inline static void setSS() { PORTB &= ~_BV(6); };
|
|
||||||
inline static void resetSS() { PORTB |= _BV(6); };
|
|
||||||
#elif defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB162__)
|
|
||||||
inline static void initSS() { DDRB |= _BV(0); };
|
|
||||||
inline static void setSS() { PORTB &= ~_BV(0); };
|
|
||||||
inline static void resetSS() { PORTB |= _BV(0); };
|
|
||||||
#else
|
|
||||||
inline static void initSS() { DDRB |= _BV(2); };
|
|
||||||
inline static void setSS() { PORTB &= ~_BV(2); };
|
|
||||||
inline static void resetSS() { PORTB |= _BV(2); };
|
|
||||||
#endif
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
extern W5100Class W5100;
|
|
||||||
|
|
||||||
uint8_t W5100Class::readSn(SOCKET _s, uint16_t _addr) {
|
|
||||||
return read(CH_BASE + _s * CH_SIZE + _addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t W5100Class::writeSn(SOCKET _s, uint16_t _addr, uint8_t _data) {
|
|
||||||
return write(CH_BASE + _s * CH_SIZE + _addr, _data);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t W5100Class::readSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t _len) {
|
|
||||||
return read(CH_BASE + _s * CH_SIZE + _addr, _buf, _len);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t W5100Class::writeSn(SOCKET _s, uint16_t _addr, uint8_t *_buf, uint16_t _len) {
|
|
||||||
return write(CH_BASE + _s * CH_SIZE + _addr, _buf, _len);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::getGatewayIp(uint8_t *_addr) {
|
|
||||||
readGAR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::setGatewayIp(uint8_t *_addr) {
|
|
||||||
writeGAR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::getSubnetMask(uint8_t *_addr) {
|
|
||||||
readSUBR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::setSubnetMask(uint8_t *_addr) {
|
|
||||||
writeSUBR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::getMACAddress(uint8_t *_addr) {
|
|
||||||
readSHAR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::setMACAddress(uint8_t *_addr) {
|
|
||||||
writeSHAR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::getIPAddress(uint8_t *_addr) {
|
|
||||||
readSIPR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::setIPAddress(uint8_t *_addr) {
|
|
||||||
writeSIPR(_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::setRetransmissionTime(uint16_t _timeout) {
|
|
||||||
writeRTR(_timeout);
|
|
||||||
}
|
|
||||||
|
|
||||||
void W5100Class::setRetransmissionCount(uint8_t _retry) {
|
|
||||||
writeRCR(_retry);
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,366 +0,0 @@
|
||||||
/* Boards.h - Hardware Abstraction Layer for Firmata library */
|
|
||||||
|
|
||||||
#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 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
|
|
||||||
|
|
||||||
// Arduino Duemilanove, Diecimila, and NG
|
|
||||||
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)
|
|
||||||
#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 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 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 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 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)
|
|
||||||
|
|
||||||
|
|
||||||
// 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 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 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__)
|
|
||||||
#define TOTAL_ANALOG_PINS 12
|
|
||||||
#define TOTAL_PINS 25 // 11 digital + 12 analog
|
|
||||||
#define VERSION_BLINK_PIN 11
|
|
||||||
#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 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++ 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 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 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)
|
|
||||||
|
|
||||||
|
|
||||||
// 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
|
|
||||||
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* 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();
|
|
||||||
}
|
|
||||||
#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));
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef TOTAL_PORTS
|
|
||||||
#define TOTAL_PORTS ((TOTAL_PINS + 7) / 8)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#endif /* Firmata_Boards_h */
|
|
||||||
|
|
|
@ -1,444 +0,0 @@
|
||||||
/*
|
|
||||||
Firmata.cpp - Firmata library
|
|
||||||
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
See file LICENSE.txt for further informations on licensing terms.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//******************************************************************************
|
|
||||||
//* Includes
|
|
||||||
//******************************************************************************
|
|
||||||
|
|
||||||
#include "Firmata.h"
|
|
||||||
#include "HardwareSerial.h"
|
|
||||||
|
|
||||||
extern "C" {
|
|
||||||
#include <string.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
}
|
|
||||||
|
|
||||||
//******************************************************************************
|
|
||||||
//* Support Functions
|
|
||||||
//******************************************************************************
|
|
||||||
|
|
||||||
void FirmataClass::sendValueAsTwo7bitBytes(int value)
|
|
||||||
{
|
|
||||||
FirmataSerial.write(value & B01111111); // LSB
|
|
||||||
FirmataSerial.write(value >> 7 & B01111111); // MSB
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::startSysex(void)
|
|
||||||
{
|
|
||||||
FirmataSerial.write(START_SYSEX);
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::endSysex(void)
|
|
||||||
{
|
|
||||||
FirmataSerial.write(END_SYSEX);
|
|
||||||
}
|
|
||||||
|
|
||||||
//******************************************************************************
|
|
||||||
//* Constructors
|
|
||||||
//******************************************************************************
|
|
||||||
|
|
||||||
FirmataClass::FirmataClass(Stream &s) : FirmataSerial(s)
|
|
||||||
{
|
|
||||||
firmwareVersionCount = 0;
|
|
||||||
systemReset();
|
|
||||||
}
|
|
||||||
|
|
||||||
//******************************************************************************
|
|
||||||
//* Public Methods
|
|
||||||
//******************************************************************************
|
|
||||||
|
|
||||||
/* begin method for overriding default serial bitrate */
|
|
||||||
void FirmataClass::begin(void)
|
|
||||||
{
|
|
||||||
begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* begin method for overriding default serial bitrate */
|
|
||||||
void FirmataClass::begin(long speed)
|
|
||||||
{
|
|
||||||
Serial.begin(speed);
|
|
||||||
FirmataSerial = Serial;
|
|
||||||
blinkVersion();
|
|
||||||
printVersion();
|
|
||||||
printFirmwareVersion();
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::begin(Stream &s)
|
|
||||||
{
|
|
||||||
FirmataSerial = s;
|
|
||||||
systemReset();
|
|
||||||
printVersion();
|
|
||||||
printFirmwareVersion();
|
|
||||||
}
|
|
||||||
|
|
||||||
// output the protocol version message to the serial port
|
|
||||||
void FirmataClass::printVersion(void) {
|
|
||||||
FirmataSerial.write(REPORT_VERSION);
|
|
||||||
FirmataSerial.write(FIRMATA_MAJOR_VERSION);
|
|
||||||
FirmataSerial.write(FIRMATA_MINOR_VERSION);
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::blinkVersion(void)
|
|
||||||
{
|
|
||||||
// flash the pin with the protocol version
|
|
||||||
pinMode(VERSION_BLINK_PIN,OUTPUT);
|
|
||||||
pin13strobe(FIRMATA_MAJOR_VERSION, 40, 210);
|
|
||||||
delay(250);
|
|
||||||
pin13strobe(FIRMATA_MINOR_VERSION, 40, 210);
|
|
||||||
delay(125);
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::printFirmwareVersion(void)
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
|
|
||||||
if(firmwareVersionCount) { // make sure that the name has been set before reporting
|
|
||||||
startSysex();
|
|
||||||
FirmataSerial.write(REPORT_FIRMWARE);
|
|
||||||
FirmataSerial.write(firmwareVersionVector[0]); // major version number
|
|
||||||
FirmataSerial.write(firmwareVersionVector[1]); // minor version number
|
|
||||||
for(i=2; i<firmwareVersionCount; ++i) {
|
|
||||||
sendValueAsTwo7bitBytes(firmwareVersionVector[i]);
|
|
||||||
}
|
|
||||||
endSysex();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::setFirmwareNameAndVersion(const char *name, byte major, byte minor)
|
|
||||||
{
|
|
||||||
const char *filename;
|
|
||||||
char *extension;
|
|
||||||
|
|
||||||
// parse out ".cpp" and "applet/" that comes from using __FILE__
|
|
||||||
extension = strstr(name, ".cpp");
|
|
||||||
filename = strrchr(name, '/') + 1; //points to slash, +1 gets to start of filename
|
|
||||||
// add two bytes for version numbers
|
|
||||||
if(extension && filename) {
|
|
||||||
firmwareVersionCount = extension - filename + 2;
|
|
||||||
} else {
|
|
||||||
firmwareVersionCount = strlen(name) + 2;
|
|
||||||
filename = name;
|
|
||||||
}
|
|
||||||
firmwareVersionVector = (byte *) malloc(firmwareVersionCount);
|
|
||||||
firmwareVersionVector[firmwareVersionCount] = 0;
|
|
||||||
firmwareVersionVector[0] = major;
|
|
||||||
firmwareVersionVector[1] = minor;
|
|
||||||
strncpy((char*)firmwareVersionVector + 2, filename, firmwareVersionCount - 2);
|
|
||||||
// alas, no snprintf on Arduino
|
|
||||||
// snprintf(firmwareVersionVector, MAX_DATA_BYTES, "%c%c%s",
|
|
||||||
// (char)major, (char)minor, firmwareVersionVector);
|
|
||||||
}
|
|
||||||
|
|
||||||
//------------------------------------------------------------------------------
|
|
||||||
// Serial Receive Handling
|
|
||||||
|
|
||||||
int FirmataClass::available(void)
|
|
||||||
{
|
|
||||||
return FirmataSerial.available();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void FirmataClass::processSysexMessage(void)
|
|
||||||
{
|
|
||||||
switch(storedInputData[0]) { //first byte in buffer is command
|
|
||||||
case REPORT_FIRMWARE:
|
|
||||||
printFirmwareVersion();
|
|
||||||
break;
|
|
||||||
case STRING_DATA:
|
|
||||||
if(currentStringCallback) {
|
|
||||||
byte bufferLength = (sysexBytesRead - 1) / 2;
|
|
||||||
char *buffer = (char*)malloc(bufferLength * sizeof(char));
|
|
||||||
byte i = 1;
|
|
||||||
byte j = 0;
|
|
||||||
while(j < bufferLength) {
|
|
||||||
buffer[j] = (char)storedInputData[i];
|
|
||||||
i++;
|
|
||||||
buffer[j] += (char)(storedInputData[i] << 7);
|
|
||||||
i++;
|
|
||||||
j++;
|
|
||||||
}
|
|
||||||
(*currentStringCallback)(buffer);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
if(currentSysexCallback)
|
|
||||||
(*currentSysexCallback)(storedInputData[0], sysexBytesRead - 1, storedInputData + 1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::processInput(void)
|
|
||||||
{
|
|
||||||
int inputData = FirmataSerial.read(); // this is 'int' to handle -1 when no data
|
|
||||||
int command;
|
|
||||||
|
|
||||||
// TODO make sure it handles -1 properly
|
|
||||||
|
|
||||||
if (parsingSysex) {
|
|
||||||
if(inputData == END_SYSEX) {
|
|
||||||
//stop sysex byte
|
|
||||||
parsingSysex = false;
|
|
||||||
//fire off handler function
|
|
||||||
processSysexMessage();
|
|
||||||
} else {
|
|
||||||
//normal data byte - add to buffer
|
|
||||||
storedInputData[sysexBytesRead] = inputData;
|
|
||||||
sysexBytesRead++;
|
|
||||||
}
|
|
||||||
} else if( (waitForData > 0) && (inputData < 128) ) {
|
|
||||||
waitForData--;
|
|
||||||
storedInputData[waitForData] = inputData;
|
|
||||||
if( (waitForData==0) && executeMultiByteCommand ) { // got the whole message
|
|
||||||
switch(executeMultiByteCommand) {
|
|
||||||
case ANALOG_MESSAGE:
|
|
||||||
if(currentAnalogCallback) {
|
|
||||||
(*currentAnalogCallback)(multiByteChannel,
|
|
||||||
(storedInputData[0] << 7)
|
|
||||||
+ storedInputData[1]);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case DIGITAL_MESSAGE:
|
|
||||||
if(currentDigitalCallback) {
|
|
||||||
(*currentDigitalCallback)(multiByteChannel,
|
|
||||||
(storedInputData[0] << 7)
|
|
||||||
+ storedInputData[1]);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case SET_PIN_MODE:
|
|
||||||
if(currentPinModeCallback)
|
|
||||||
(*currentPinModeCallback)(storedInputData[1], storedInputData[0]);
|
|
||||||
break;
|
|
||||||
case REPORT_ANALOG:
|
|
||||||
if(currentReportAnalogCallback)
|
|
||||||
(*currentReportAnalogCallback)(multiByteChannel,storedInputData[0]);
|
|
||||||
break;
|
|
||||||
case REPORT_DIGITAL:
|
|
||||||
if(currentReportDigitalCallback)
|
|
||||||
(*currentReportDigitalCallback)(multiByteChannel,storedInputData[0]);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
executeMultiByteCommand = 0;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// remove channel info from command byte if less than 0xF0
|
|
||||||
if(inputData < 0xF0) {
|
|
||||||
command = inputData & 0xF0;
|
|
||||||
multiByteChannel = inputData & 0x0F;
|
|
||||||
} else {
|
|
||||||
command = inputData;
|
|
||||||
// commands in the 0xF* range don't use channel data
|
|
||||||
}
|
|
||||||
switch (command) {
|
|
||||||
case ANALOG_MESSAGE:
|
|
||||||
case DIGITAL_MESSAGE:
|
|
||||||
case SET_PIN_MODE:
|
|
||||||
waitForData = 2; // two data bytes needed
|
|
||||||
executeMultiByteCommand = command;
|
|
||||||
break;
|
|
||||||
case REPORT_ANALOG:
|
|
||||||
case REPORT_DIGITAL:
|
|
||||||
waitForData = 1; // one data byte needed
|
|
||||||
executeMultiByteCommand = command;
|
|
||||||
break;
|
|
||||||
case START_SYSEX:
|
|
||||||
parsingSysex = true;
|
|
||||||
sysexBytesRead = 0;
|
|
||||||
break;
|
|
||||||
case SYSTEM_RESET:
|
|
||||||
systemReset();
|
|
||||||
break;
|
|
||||||
case REPORT_VERSION:
|
|
||||||
Firmata.printVersion();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//------------------------------------------------------------------------------
|
|
||||||
// Serial Send Handling
|
|
||||||
|
|
||||||
// send an analog message
|
|
||||||
void FirmataClass::sendAnalog(byte pin, int value)
|
|
||||||
{
|
|
||||||
// pin can only be 0-15, so chop higher bits
|
|
||||||
FirmataSerial.write(ANALOG_MESSAGE | (pin & 0xF));
|
|
||||||
sendValueAsTwo7bitBytes(value);
|
|
||||||
}
|
|
||||||
|
|
||||||
// send a single digital pin in a digital message
|
|
||||||
void FirmataClass::sendDigital(byte pin, int value)
|
|
||||||
{
|
|
||||||
/* TODO add single pin digital messages to the protocol, this needs to
|
|
||||||
* track the last digital data sent so that it can be sure to change just
|
|
||||||
* one bit in the packet. This is complicated by the fact that the
|
|
||||||
* numbering of the pins will probably differ on Arduino, Wiring, and
|
|
||||||
* other boards. The DIGITAL_MESSAGE sends 14 bits at a time, but it is
|
|
||||||
* probably easier to send 8 bit ports for any board with more than 14
|
|
||||||
* digital pins.
|
|
||||||
*/
|
|
||||||
|
|
||||||
// TODO: the digital message should not be sent on the serial port every
|
|
||||||
// time sendDigital() is called. Instead, it should add it to an int
|
|
||||||
// which will be sent on a schedule. If a pin changes more than once
|
|
||||||
// before the digital message is sent on the serial port, it should send a
|
|
||||||
// digital message for each change.
|
|
||||||
|
|
||||||
// if(value == 0)
|
|
||||||
// sendDigitalPortPair();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// send 14-bits in a single digital message (protocol v1)
|
|
||||||
// send an 8-bit port in a single digital message (protocol v2)
|
|
||||||
void FirmataClass::sendDigitalPort(byte portNumber, int portData)
|
|
||||||
{
|
|
||||||
FirmataSerial.write(DIGITAL_MESSAGE | (portNumber & 0xF));
|
|
||||||
FirmataSerial.write((byte)portData % 128); // Tx bits 0-6
|
|
||||||
FirmataSerial.write(portData >> 7); // Tx bits 7-13
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void FirmataClass::sendSysex(byte command, byte bytec, byte* bytev)
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
startSysex();
|
|
||||||
FirmataSerial.write(command);
|
|
||||||
for(i=0; i<bytec; i++) {
|
|
||||||
sendValueAsTwo7bitBytes(bytev[i]);
|
|
||||||
}
|
|
||||||
endSysex();
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::sendString(byte command, const char* string)
|
|
||||||
{
|
|
||||||
sendSysex(command, strlen(string), (byte *)string);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// send a string as the protocol string type
|
|
||||||
void FirmataClass::sendString(const char* string)
|
|
||||||
{
|
|
||||||
sendString(STRING_DATA, string);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Internal Actions/////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// generic callbacks
|
|
||||||
void FirmataClass::attach(byte command, callbackFunction newFunction)
|
|
||||||
{
|
|
||||||
switch(command) {
|
|
||||||
case ANALOG_MESSAGE: currentAnalogCallback = newFunction; break;
|
|
||||||
case DIGITAL_MESSAGE: currentDigitalCallback = newFunction; break;
|
|
||||||
case REPORT_ANALOG: currentReportAnalogCallback = newFunction; break;
|
|
||||||
case REPORT_DIGITAL: currentReportDigitalCallback = newFunction; break;
|
|
||||||
case SET_PIN_MODE: currentPinModeCallback = newFunction; break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::attach(byte command, systemResetCallbackFunction newFunction)
|
|
||||||
{
|
|
||||||
switch(command) {
|
|
||||||
case SYSTEM_RESET: currentSystemResetCallback = newFunction; break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::attach(byte command, stringCallbackFunction newFunction)
|
|
||||||
{
|
|
||||||
switch(command) {
|
|
||||||
case STRING_DATA: currentStringCallback = newFunction; break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::attach(byte command, sysexCallbackFunction newFunction)
|
|
||||||
{
|
|
||||||
currentSysexCallback = newFunction;
|
|
||||||
}
|
|
||||||
|
|
||||||
void FirmataClass::detach(byte command)
|
|
||||||
{
|
|
||||||
switch(command) {
|
|
||||||
case SYSTEM_RESET: currentSystemResetCallback = NULL; break;
|
|
||||||
case STRING_DATA: currentStringCallback = NULL; break;
|
|
||||||
case START_SYSEX: currentSysexCallback = NULL; break;
|
|
||||||
default:
|
|
||||||
attach(command, (callbackFunction)NULL);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// sysex callbacks
|
|
||||||
/*
|
|
||||||
* this is too complicated for analogReceive, but maybe for Sysex?
|
|
||||||
void FirmataClass::attachSysex(sysexFunction newFunction)
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
byte tmpCount = analogReceiveFunctionCount;
|
|
||||||
analogReceiveFunction* tmpArray = analogReceiveFunctionArray;
|
|
||||||
analogReceiveFunctionCount++;
|
|
||||||
analogReceiveFunctionArray = (analogReceiveFunction*) calloc(analogReceiveFunctionCount, sizeof(analogReceiveFunction));
|
|
||||||
for(i = 0; i < tmpCount; i++) {
|
|
||||||
analogReceiveFunctionArray[i] = tmpArray[i];
|
|
||||||
}
|
|
||||||
analogReceiveFunctionArray[tmpCount] = newFunction;
|
|
||||||
free(tmpArray);
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
//******************************************************************************
|
|
||||||
//* Private Methods
|
|
||||||
//******************************************************************************
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// resets the system state upon a SYSTEM_RESET message from the host software
|
|
||||||
void FirmataClass::systemReset(void)
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
|
|
||||||
waitForData = 0; // this flag says the next serial input will be data
|
|
||||||
executeMultiByteCommand = 0; // execute this after getting multi-byte data
|
|
||||||
multiByteChannel = 0; // channel data for multiByteCommands
|
|
||||||
|
|
||||||
|
|
||||||
for(i=0; i<MAX_DATA_BYTES; i++) {
|
|
||||||
storedInputData[i] = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
parsingSysex = false;
|
|
||||||
sysexBytesRead = 0;
|
|
||||||
|
|
||||||
if(currentSystemResetCallback)
|
|
||||||
(*currentSystemResetCallback)();
|
|
||||||
|
|
||||||
//flush(); //TODO uncomment when Firmata is a subclass of HardwareSerial
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// =============================================================================
|
|
||||||
// used for flashing the pin for the version number
|
|
||||||
void FirmataClass::pin13strobe(int count, int onInterval, int offInterval)
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
pinMode(VERSION_BLINK_PIN, OUTPUT);
|
|
||||||
for(i=0; i<count; i++) {
|
|
||||||
delay(offInterval);
|
|
||||||
digitalWrite(VERSION_BLINK_PIN, HIGH);
|
|
||||||
delay(onInterval);
|
|
||||||
digitalWrite(VERSION_BLINK_PIN, LOW);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// make one instance for the user to use
|
|
||||||
FirmataClass Firmata(Serial);
|
|
||||||
|
|
||||||
|
|
|
@ -1,163 +0,0 @@
|
||||||
/*
|
|
||||||
Firmata.h - Firmata library
|
|
||||||
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
See file LICENSE.txt for further informations on licensing terms.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef Firmata_h
|
|
||||||
#define Firmata_h
|
|
||||||
|
|
||||||
#include "Boards.h" /* Hardware Abstraction Layer + Wiring/Arduino */
|
|
||||||
|
|
||||||
/* Version numbers for the protocol. The protocol is still changing, so these
|
|
||||||
* version numbers are important. This number can be queried so that host
|
|
||||||
* software can test whether it will be compatible with the currently
|
|
||||||
* installed firmware. */
|
|
||||||
#define FIRMATA_MAJOR_VERSION 2 // for non-compatible changes
|
|
||||||
#define FIRMATA_MINOR_VERSION 3 // for backwards compatible changes
|
|
||||||
#define FIRMATA_BUGFIX_VERSION 1 // for bugfix releases
|
|
||||||
|
|
||||||
#define MAX_DATA_BYTES 32 // max number of data bytes in non-Sysex messages
|
|
||||||
|
|
||||||
// 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 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 SERVO_CONFIG 0x70 // set max angle, minPulse, maxPulse, freq
|
|
||||||
#define STRING_DATA 0x71 // a string message with 14-bits per char
|
|
||||||
#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 SYSEX_NON_REALTIME 0x7E // MIDI Reserved for non-realtime messages
|
|
||||||
#define SYSEX_REALTIME 0x7F // MIDI Reserved for realtime messages
|
|
||||||
// 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 wiring.h
|
|
||||||
//#define OUTPUT 0x01 // defined in wiring.h
|
|
||||||
#define ANALOG 0x02 // analog pin in analogInput mode
|
|
||||||
#define PWM 0x03 // digital pin in PWM output mode
|
|
||||||
#define SERVO 0x04 // digital pin in Servo output mode
|
|
||||||
#define SHIFT 0x05 // shiftIn/shiftOut mode
|
|
||||||
#define I2C 0x06 // pin included in I2C setup
|
|
||||||
#define TOTAL_PIN_MODES 7
|
|
||||||
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// TODO make it a subclass of a generic Serial/Stream base class
|
|
||||||
class FirmataClass
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
FirmataClass(Stream &s);
|
|
||||||
/* 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);
|
|
||||||
/* serial receive handling */
|
|
||||||
int available(void);
|
|
||||||
void processInput(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);
|
|
||||||
/* 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);
|
|
||||||
|
|
||||||
private:
|
|
||||||
Stream &FirmataSerial;
|
|
||||||
/* 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;
|
|
||||||
/* callback functions */
|
|
||||||
callbackFunction currentAnalogCallback;
|
|
||||||
callbackFunction currentDigitalCallback;
|
|
||||||
callbackFunction currentReportAnalogCallback;
|
|
||||||
callbackFunction currentReportDigitalCallback;
|
|
||||||
callbackFunction currentPinModeCallback;
|
|
||||||
systemResetCallbackFunction currentSystemResetCallback;
|
|
||||||
stringCallbackFunction currentStringCallback;
|
|
||||||
sysexCallbackFunction currentSysexCallback;
|
|
||||||
|
|
||||||
/* private methods ------------------------------ */
|
|
||||||
void processSysexMessage(void);
|
|
||||||
void systemReset(void);
|
|
||||||
void pin13strobe(int count, int onInterval, int offInterval);
|
|
||||||
void sendValueAsTwo7bitBytes(int value);
|
|
||||||
void startSysex(void);
|
|
||||||
void endSysex(void);
|
|
||||||
};
|
|
||||||
|
|
||||||
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 /* Firmata_h */
|
|
||||||
|
|
|
@ -1,458 +0,0 @@
|
||||||
|
|
||||||
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.
|
|
||||||
|
|
|
@ -1,14 +0,0 @@
|
||||||
|
|
||||||
- make Firmata a subclass of HardwareSerial
|
|
||||||
|
|
||||||
- per-pin digital callback, since the per-port callback is a bit complicated
|
|
||||||
for beginners (maybe Firmata is not for beginners...)
|
|
||||||
|
|
||||||
- simplify SimpleDigitalFirmata, take out the code that checks to see if the
|
|
||||||
data has changed, since it is a bit complicated for this example. Ideally
|
|
||||||
this example would be based on a call
|
|
||||||
|
|
||||||
- turn current SimpleDigitalFirmata into DigitalPortFirmata for a more complex
|
|
||||||
example using the code which checks for changes before doing anything
|
|
||||||
|
|
||||||
- test integration with Wiring
|
|
|
@ -1,90 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This firmware reads all inputs and sends them as fast as it can. It was
|
|
||||||
* inspired by the ease-of-use of the Arduino2Max program.
|
|
||||||
*
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
byte pin;
|
|
||||||
|
|
||||||
int analogValue;
|
|
||||||
int previousAnalogValues[TOTAL_ANALOG_PINS];
|
|
||||||
|
|
||||||
byte portStatus[TOTAL_PORTS]; // each bit: 1=pin is digital input, 0=other/ignore
|
|
||||||
byte previousPINs[TOTAL_PORTS];
|
|
||||||
|
|
||||||
/* timer variables */
|
|
||||||
unsigned long currentMillis; // store the current value from millis()
|
|
||||||
unsigned long previousMillis; // for comparison with currentMillis
|
|
||||||
/* make sure that the FTDI buffer doesn't go over 60 bytes, otherwise you
|
|
||||||
get long, random delays. So only read analogs every 20ms or so */
|
|
||||||
int samplingInterval = 19; // how often to run the main loop (in ms)
|
|
||||||
|
|
||||||
void sendPort(byte portNumber, byte portValue)
|
|
||||||
{
|
|
||||||
portValue = portValue & portStatus[portNumber];
|
|
||||||
if(previousPINs[portNumber] != portValue) {
|
|
||||||
Firmata.sendDigitalPort(portNumber, portValue);
|
|
||||||
previousPINs[portNumber] = portValue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
byte i, port, status;
|
|
||||||
|
|
||||||
Firmata.setFirmwareVersion(0, 1);
|
|
||||||
|
|
||||||
for(pin = 0; pin < TOTAL_PINS; pin++) {
|
|
||||||
if IS_PIN_DIGITAL(pin) pinMode(PIN_TO_DIGITAL(pin), INPUT);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (port=0; port<TOTAL_PORTS; port++) {
|
|
||||||
status = 0;
|
|
||||||
for (i=0; i<8; i++) {
|
|
||||||
if (IS_PIN_DIGITAL(port * 8 + i)) status |= (1 << i);
|
|
||||||
}
|
|
||||||
portStatus[port] = status;
|
|
||||||
}
|
|
||||||
|
|
||||||
Firmata.begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
|
|
||||||
for (i=0; i<TOTAL_PORTS; i++) {
|
|
||||||
sendPort(i, readPort(i, 0xff));
|
|
||||||
}
|
|
||||||
/* make sure that the FTDI buffer doesn't go over 60 bytes, otherwise you
|
|
||||||
get long, random delays. So only read analogs every 20ms or so */
|
|
||||||
currentMillis = millis();
|
|
||||||
if(currentMillis - previousMillis > samplingInterval) {
|
|
||||||
previousMillis += samplingInterval;
|
|
||||||
while(Firmata.available()) {
|
|
||||||
Firmata.processInput();
|
|
||||||
}
|
|
||||||
for(pin = 0; pin < TOTAL_ANALOG_PINS; pin++) {
|
|
||||||
analogValue = analogRead(pin);
|
|
||||||
if(analogValue != previousAnalogValues[pin]) {
|
|
||||||
Firmata.sendAnalog(pin, analogValue);
|
|
||||||
previousAnalogValues[pin] = analogValue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,94 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* This firmware supports as many analog ports as possible, all analog inputs,
|
|
||||||
* four PWM outputs, and two with servo support.
|
|
||||||
*
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
#include <Servo.h>
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* GLOBAL VARIABLES
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
/* servos */
|
|
||||||
Servo servo9, servo10; // one instance per pin
|
|
||||||
/* analog inputs */
|
|
||||||
int analogInputsToReport = 0; // bitwise array to store pin reporting
|
|
||||||
int analogPin = 0; // counter for reading analog pins
|
|
||||||
/* timer variables */
|
|
||||||
unsigned long currentMillis; // store the current value from millis()
|
|
||||||
unsigned long previousMillis; // for comparison with currentMillis
|
|
||||||
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* FUNCTIONS
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
void analogWriteCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
switch(pin) {
|
|
||||||
case 9: servo9.write(value); break;
|
|
||||||
case 10: servo10.write(value); break;
|
|
||||||
case 3:
|
|
||||||
case 5:
|
|
||||||
case 6:
|
|
||||||
case 11: // PWM pins
|
|
||||||
analogWrite(pin, value);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// -----------------------------------------------------------------------------
|
|
||||||
// sets bits in a bit array (int) to toggle the reporting of the analogIns
|
|
||||||
void reportAnalogCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
if(value == 0) {
|
|
||||||
analogInputsToReport = analogInputsToReport &~ (1 << pin);
|
|
||||||
}
|
|
||||||
else { // everything but 0 enables reporting of that pin
|
|
||||||
analogInputsToReport = analogInputsToReport | (1 << pin);
|
|
||||||
}
|
|
||||||
// TODO: save status to EEPROM here, if changed
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* SETUP()
|
|
||||||
*============================================================================*/
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Firmata.setFirmwareVersion(0, 2);
|
|
||||||
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
|
|
||||||
Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
|
|
||||||
|
|
||||||
servo9.attach(9);
|
|
||||||
servo10.attach(10);
|
|
||||||
Firmata.begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* LOOP()
|
|
||||||
*============================================================================*/
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
while(Firmata.available())
|
|
||||||
Firmata.processInput();
|
|
||||||
currentMillis = millis();
|
|
||||||
if(currentMillis - previousMillis > 20) {
|
|
||||||
previousMillis += 20; // run this every 20ms
|
|
||||||
for(analogPin=0;analogPin<TOTAL_ANALOG_PINS;analogPin++) {
|
|
||||||
if( analogInputsToReport & (1 << analogPin) )
|
|
||||||
Firmata.sendAnalog(analogPin, analogRead(analogPin));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,46 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* This sketch accepts strings and raw sysex messages and echos them back.
|
|
||||||
*
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
byte analogPin;
|
|
||||||
|
|
||||||
void stringCallback(char *myString)
|
|
||||||
{
|
|
||||||
Firmata.sendString(myString);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void sysexCallback(byte command, byte argc, byte*argv)
|
|
||||||
{
|
|
||||||
Firmata.sendSysex(command, argc, argv);
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Firmata.setFirmwareVersion(0, 1);
|
|
||||||
Firmata.attach(STRING_DATA, stringCallback);
|
|
||||||
Firmata.attach(START_SYSEX, sysexCallback);
|
|
||||||
Firmata.begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
while(Firmata.available()) {
|
|
||||||
Firmata.processInput();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,228 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
Copyright (C) 2009 Jeff Hoefs. All rights reserved.
|
|
||||||
Copyright (C) 2009 Shigeru Kobayashi. 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 <Wire.h>
|
|
||||||
#include <Firmata.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 MAX_QUERIES 8
|
|
||||||
|
|
||||||
unsigned long currentMillis; // store the current value from millis()
|
|
||||||
unsigned long previousMillis; // for comparison with currentMillis
|
|
||||||
unsigned int samplingInterval = 32; // default sampling interval is 33ms
|
|
||||||
unsigned int i2cReadDelayTime = 0; // default delay time between i2c read request and Wire.requestFrom()
|
|
||||||
unsigned int powerPinsEnabled = 0; // use as boolean to prevent enablePowerPins from being called more than once
|
|
||||||
|
|
||||||
#define MINIMUM_SAMPLING_INTERVAL 10
|
|
||||||
|
|
||||||
#define REGISTER_NOT_SPECIFIED -1
|
|
||||||
|
|
||||||
struct i2c_device_info {
|
|
||||||
byte addr;
|
|
||||||
byte reg;
|
|
||||||
byte bytes;
|
|
||||||
};
|
|
||||||
|
|
||||||
i2c_device_info query[MAX_QUERIES];
|
|
||||||
|
|
||||||
byte i2cRxData[32];
|
|
||||||
boolean readingContinuously = false;
|
|
||||||
byte queryIndex = 0;
|
|
||||||
|
|
||||||
void readAndReportData(byte address, int theRegister, byte numBytes)
|
|
||||||
{
|
|
||||||
if (theRegister != REGISTER_NOT_SPECIFIED) {
|
|
||||||
Wire.beginTransmission(address);
|
|
||||||
Wire.write((byte)theRegister);
|
|
||||||
Wire.endTransmission();
|
|
||||||
delayMicroseconds(i2cReadDelayTime); // delay is necessary for some devices such as WiiNunchuck
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
theRegister = 0; // fill the register with a dummy value
|
|
||||||
}
|
|
||||||
|
|
||||||
Wire.requestFrom(address, numBytes);
|
|
||||||
|
|
||||||
// check to be sure correct number of bytes were returned by slave
|
|
||||||
if(numBytes == Wire.available()) {
|
|
||||||
i2cRxData[0] = address;
|
|
||||||
i2cRxData[1] = theRegister;
|
|
||||||
for (int i = 0; i < numBytes; i++) {
|
|
||||||
i2cRxData[2 + i] = Wire.read();
|
|
||||||
}
|
|
||||||
// send slave address, register and received bytes
|
|
||||||
Firmata.sendSysex(I2C_REPLY, numBytes + 2, i2cRxData);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if(numBytes > Wire.available()) {
|
|
||||||
Firmata.sendString("I2C Read Error: Too many bytes received");
|
|
||||||
} else {
|
|
||||||
Firmata.sendString("I2C Read Error: Too few bytes received");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void sysexCallback(byte command, byte argc, byte *argv)
|
|
||||||
{
|
|
||||||
byte mode;
|
|
||||||
byte slaveAddress;
|
|
||||||
byte slaveRegister;
|
|
||||||
byte data;
|
|
||||||
int delayTime;
|
|
||||||
|
|
||||||
if (command == I2C_REQUEST) {
|
|
||||||
mode = argv[1] & I2C_READ_WRITE_MODE_MASK;
|
|
||||||
slaveAddress = argv[0];
|
|
||||||
|
|
||||||
switch(mode) {
|
|
||||||
case I2C_WRITE:
|
|
||||||
Wire.beginTransmission(slaveAddress);
|
|
||||||
for (byte i = 2; i < argc; i += 2) {
|
|
||||||
data = argv[i] + (argv[i + 1] << 7);
|
|
||||||
Wire.write(data);
|
|
||||||
}
|
|
||||||
Wire.endTransmission();
|
|
||||||
delayMicroseconds(70); // TODO is this needed?
|
|
||||||
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
|
|
||||||
readAndReportData(slaveAddress, (int)slaveRegister, data);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// a slave register is NOT specified
|
|
||||||
data = argv[2] + (argv[3] << 7); // bytes to read
|
|
||||||
readAndReportData(slaveAddress, (int)REGISTER_NOT_SPECIFIED, data);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case I2C_READ_CONTINUOUSLY:
|
|
||||||
if ((queryIndex + 1) >= MAX_QUERIES) {
|
|
||||||
// too many queries, just ignore
|
|
||||||
Firmata.sendString("too many queries");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
query[queryIndex].addr = slaveAddress;
|
|
||||||
query[queryIndex].reg = argv[2] + (argv[3] << 7);
|
|
||||||
query[queryIndex].bytes = argv[4] + (argv[5] << 7);
|
|
||||||
readingContinuously = true;
|
|
||||||
queryIndex++;
|
|
||||||
break;
|
|
||||||
case I2C_STOP_READING:
|
|
||||||
readingContinuously = false;
|
|
||||||
queryIndex = 0;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (command == SAMPLING_INTERVAL) {
|
|
||||||
samplingInterval = argv[0] + (argv[1] << 7);
|
|
||||||
|
|
||||||
if (samplingInterval < MINIMUM_SAMPLING_INTERVAL) {
|
|
||||||
samplingInterval = MINIMUM_SAMPLING_INTERVAL;
|
|
||||||
}
|
|
||||||
|
|
||||||
samplingInterval -= 1;
|
|
||||||
Firmata.sendString("sampling interval");
|
|
||||||
}
|
|
||||||
|
|
||||||
else if (command == I2C_CONFIG) {
|
|
||||||
delayTime = (argv[4] + (argv[5] << 7)); // MSB
|
|
||||||
delayTime = (delayTime << 8) + (argv[2] + (argv[3] << 7)); // add LSB
|
|
||||||
|
|
||||||
if((argv[0] + (argv[1] << 7)) > 0) {
|
|
||||||
enablePowerPins(PORTC3, PORTC2);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(delayTime > 0) {
|
|
||||||
i2cReadDelayTime = delayTime;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(argc > 6) {
|
|
||||||
// If you extend I2C_Config, handle your data here
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void systemResetCallback()
|
|
||||||
{
|
|
||||||
readingContinuously = false;
|
|
||||||
queryIndex = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* reference: BlinkM_funcs.h by Tod E. Kurt, ThingM, http://thingm.com/ */
|
|
||||||
// Enables Pins A2 and A3 to be used as GND and Power
|
|
||||||
// so that I2C devices can be plugged directly
|
|
||||||
// into Arduino header (pins A2 - A5)
|
|
||||||
static void enablePowerPins(byte pwrpin, byte gndpin)
|
|
||||||
{
|
|
||||||
if(powerPinsEnabled == 0) {
|
|
||||||
DDRC |= _BV(pwrpin) | _BV(gndpin);
|
|
||||||
PORTC &=~ _BV(gndpin);
|
|
||||||
PORTC |= _BV(pwrpin);
|
|
||||||
powerPinsEnabled = 1;
|
|
||||||
Firmata.sendString("Power pins enabled");
|
|
||||||
delay(100);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Firmata.setFirmwareVersion(2, 0);
|
|
||||||
|
|
||||||
Firmata.attach(START_SYSEX, sysexCallback);
|
|
||||||
Firmata.attach(SYSTEM_RESET, systemResetCallback);
|
|
||||||
|
|
||||||
for (int i = 0; i < TOTAL_PINS; ++i) {
|
|
||||||
pinMode(i, OUTPUT);
|
|
||||||
}
|
|
||||||
|
|
||||||
Firmata.begin(57600);
|
|
||||||
Wire.begin();
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
while (Firmata.available()) {
|
|
||||||
Firmata.processInput();
|
|
||||||
}
|
|
||||||
|
|
||||||
currentMillis = millis();
|
|
||||||
if (currentMillis - previousMillis > samplingInterval) {
|
|
||||||
previousMillis += samplingInterval;
|
|
||||||
|
|
||||||
for (byte i = 0; i < queryIndex; i++) {
|
|
||||||
readAndReportData(query[i].addr, query[i].reg, query[i].bytes);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,458 +0,0 @@
|
||||||
|
|
||||||
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.
|
|
||||||
|
|
|
@ -1,239 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
See file LICENSE.txt for further informations on licensing terms.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is an old version of StandardFirmata (v2.0). It is kept here because
|
|
||||||
* its the last version that works on an ATMEGA8 chip. Also, it can be used
|
|
||||||
* for host software that has not been updated to a newer version of the
|
|
||||||
* protocol. It also uses the old baud rate of 115200 rather than 57600.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <EEPROM.h>
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* GLOBAL VARIABLES
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
/* analog inputs */
|
|
||||||
int analogInputsToReport = 0; // bitwise array to store pin reporting
|
|
||||||
int analogPin = 0; // counter for reading analog pins
|
|
||||||
|
|
||||||
/* digital pins */
|
|
||||||
byte reportPINs[TOTAL_PORTS]; // PIN == input port
|
|
||||||
byte previousPINs[TOTAL_PORTS]; // PIN == input port
|
|
||||||
byte pinStatus[TOTAL_PINS]; // store pin status, default OUTPUT
|
|
||||||
byte portStatus[TOTAL_PORTS];
|
|
||||||
|
|
||||||
/* timer variables */
|
|
||||||
unsigned long currentMillis; // store the current value from millis()
|
|
||||||
unsigned long previousMillis; // for comparison with currentMillis
|
|
||||||
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* FUNCTIONS
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
void outputPort(byte portNumber, byte portValue)
|
|
||||||
{
|
|
||||||
portValue = portValue &~ portStatus[portNumber];
|
|
||||||
if(previousPINs[portNumber] != portValue) {
|
|
||||||
Firmata.sendDigitalPort(portNumber, portValue);
|
|
||||||
previousPINs[portNumber] = portValue;
|
|
||||||
Firmata.sendDigitalPort(portNumber, portValue);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* -----------------------------------------------------------------------------
|
|
||||||
* check all the active digital inputs for change of state, then add any events
|
|
||||||
* to the Serial output queue using Serial.print() */
|
|
||||||
void checkDigitalInputs(void)
|
|
||||||
{
|
|
||||||
byte i, tmp;
|
|
||||||
for(i=0; i < TOTAL_PORTS; i++) {
|
|
||||||
if(reportPINs[i]) {
|
|
||||||
switch(i) {
|
|
||||||
case 0: outputPort(0, PIND &~ B00000011); break; // ignore Rx/Tx 0/1
|
|
||||||
case 1: outputPort(1, PINB); break;
|
|
||||||
case 2: outputPort(2, PINC); break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------------
|
|
||||||
/* sets the pin mode to the correct state and sets the relevant bits in the
|
|
||||||
* two bit-arrays that track Digital I/O and PWM status
|
|
||||||
*/
|
|
||||||
void setPinModeCallback(byte pin, int mode) {
|
|
||||||
byte port = 0;
|
|
||||||
byte offset = 0;
|
|
||||||
|
|
||||||
if (pin < 8) {
|
|
||||||
port = 0;
|
|
||||||
offset = 0;
|
|
||||||
} else if (pin < 14) {
|
|
||||||
port = 1;
|
|
||||||
offset = 8;
|
|
||||||
} else if (pin < 22) {
|
|
||||||
port = 2;
|
|
||||||
offset = 14;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(pin > 1) { // ignore RxTx (pins 0 and 1)
|
|
||||||
pinStatus[pin] = mode;
|
|
||||||
switch(mode) {
|
|
||||||
case INPUT:
|
|
||||||
pinMode(pin, INPUT);
|
|
||||||
portStatus[port] = portStatus[port] &~ (1 << (pin - offset));
|
|
||||||
break;
|
|
||||||
case OUTPUT:
|
|
||||||
digitalWrite(pin, LOW); // disable PWM
|
|
||||||
case PWM:
|
|
||||||
pinMode(pin, OUTPUT);
|
|
||||||
portStatus[port] = portStatus[port] | (1 << (pin - offset));
|
|
||||||
break;
|
|
||||||
//case ANALOG: // TODO figure this out
|
|
||||||
default:
|
|
||||||
Firmata.sendString("");
|
|
||||||
}
|
|
||||||
// TODO: save status to EEPROM here, if changed
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void analogWriteCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
setPinModeCallback(pin,PWM);
|
|
||||||
analogWrite(pin, value);
|
|
||||||
}
|
|
||||||
|
|
||||||
void digitalWriteCallback(byte port, int value)
|
|
||||||
{
|
|
||||||
switch(port) {
|
|
||||||
case 0: // pins 2-7 (don't change Rx/Tx, pins 0 and 1)
|
|
||||||
// 0xFF03 == B1111111100000011 0x03 == B00000011
|
|
||||||
PORTD = (value &~ 0xFF03) | (PORTD & 0x03);
|
|
||||||
break;
|
|
||||||
case 1: // pins 8-13 (14,15 are disabled for the crystal)
|
|
||||||
PORTB = (byte)value;
|
|
||||||
break;
|
|
||||||
case 2: // analog pins used as digital
|
|
||||||
PORTC = (byte)value;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------------
|
|
||||||
/* sets bits in a bit array (int) to toggle the reporting of the analogIns
|
|
||||||
*/
|
|
||||||
//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
|
|
||||||
//}
|
|
||||||
void reportAnalogCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
if(value == 0) {
|
|
||||||
analogInputsToReport = analogInputsToReport &~ (1 << pin);
|
|
||||||
}
|
|
||||||
else { // everything but 0 enables reporting of that pin
|
|
||||||
analogInputsToReport = analogInputsToReport | (1 << pin);
|
|
||||||
}
|
|
||||||
// TODO: save status to EEPROM here, if changed
|
|
||||||
}
|
|
||||||
|
|
||||||
void reportDigitalCallback(byte port, int value)
|
|
||||||
{
|
|
||||||
reportPINs[port] = (byte)value;
|
|
||||||
if(port == 2) // turn off analog reporting when used as digital
|
|
||||||
analogInputsToReport = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* SETUP()
|
|
||||||
*============================================================================*/
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
|
|
||||||
Firmata.setFirmwareVersion(2, 0);
|
|
||||||
|
|
||||||
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
|
|
||||||
Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
|
|
||||||
Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
|
|
||||||
Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
|
|
||||||
Firmata.attach(SET_PIN_MODE, setPinModeCallback);
|
|
||||||
|
|
||||||
portStatus[0] = B00000011; // ignore Tx/RX pins
|
|
||||||
portStatus[1] = B11000000; // ignore 14/15 pins
|
|
||||||
portStatus[2] = B00000000;
|
|
||||||
|
|
||||||
// for(i=0; i<TOTAL_PINS; ++i) { // TODO make this work with analogs
|
|
||||||
for(i=0; i<14; ++i) {
|
|
||||||
setPinModeCallback(i,OUTPUT);
|
|
||||||
}
|
|
||||||
// set all outputs to 0 to make sure internal pull-up resistors are off
|
|
||||||
PORTB = 0; // pins 8-15
|
|
||||||
PORTC = 0; // analog port
|
|
||||||
PORTD = 0; // pins 0-7
|
|
||||||
|
|
||||||
// TODO rethink the init, perhaps it should report analog on default
|
|
||||||
for(i=0; i<TOTAL_PORTS; ++i) {
|
|
||||||
reportPINs[i] = false;
|
|
||||||
}
|
|
||||||
// TODO: load state from EEPROM here
|
|
||||||
|
|
||||||
/* send digital inputs here, if enabled, to set the initial state on the
|
|
||||||
* host computer, since once in the loop(), this firmware will only send
|
|
||||||
* digital data on change. */
|
|
||||||
if(reportPINs[0]) outputPort(0, PIND &~ B00000011); // ignore Rx/Tx 0/1
|
|
||||||
if(reportPINs[1]) outputPort(1, PINB);
|
|
||||||
if(reportPINs[2]) outputPort(2, PINC);
|
|
||||||
|
|
||||||
Firmata.begin(115200);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* LOOP()
|
|
||||||
*============================================================================*/
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
/* DIGITALREAD - as fast as possible, check for changes and output them to the
|
|
||||||
* FTDI buffer using Serial.print() */
|
|
||||||
checkDigitalInputs();
|
|
||||||
currentMillis = millis();
|
|
||||||
if(currentMillis - previousMillis > 20) {
|
|
||||||
previousMillis += 20; // run this every 20ms
|
|
||||||
/* SERIALREAD - Serial.read() uses a 128 byte circular buffer, so handle
|
|
||||||
* all serialReads at once, i.e. empty the buffer */
|
|
||||||
while(Firmata.available())
|
|
||||||
Firmata.processInput();
|
|
||||||
/* SEND FTDI WRITE BUFFER - make sure that the FTDI buffer doesn't go over
|
|
||||||
* 60 bytes. use a timer to sending an event character every 4 ms to
|
|
||||||
* trigger the buffer to dump. */
|
|
||||||
|
|
||||||
/* ANALOGREAD - right after the event character, do all of the
|
|
||||||
* analogReads(). These only need to be done every 4ms. */
|
|
||||||
for(analogPin=0;analogPin<TOTAL_ANALOG_PINS;analogPin++) {
|
|
||||||
if( analogInputsToReport & (1 << analogPin) ) {
|
|
||||||
Firmata.sendAnalog(analogPin, analogRead(analogPin));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,53 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* This firmware supports as many servos as possible using the Servo library
|
|
||||||
* included in Arduino 0017
|
|
||||||
*
|
|
||||||
* TODO add message to configure minPulse/maxPulse/degrees
|
|
||||||
*
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Servo.h>
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
Servo servos[MAX_SERVOS];
|
|
||||||
|
|
||||||
void analogWriteCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
if (IS_PIN_SERVO(pin)) {
|
|
||||||
servos[PIN_TO_SERVO(pin)].write(value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
byte pin;
|
|
||||||
|
|
||||||
Firmata.setFirmwareVersion(0, 2);
|
|
||||||
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
|
|
||||||
|
|
||||||
for (pin=0; pin < TOTAL_PINS; pin++) {
|
|
||||||
if (IS_PIN_SERVO(pin)) {
|
|
||||||
servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Firmata.begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
while(Firmata.available())
|
|
||||||
Firmata.processInput();
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,46 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Supports as many analog inputs and analog PWM outputs as possible.
|
|
||||||
*
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
byte analogPin = 0;
|
|
||||||
|
|
||||||
void analogWriteCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
if (IS_PIN_PWM(pin)) {
|
|
||||||
pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
|
|
||||||
analogWrite(PIN_TO_PWM(pin), value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Firmata.setFirmwareVersion(0, 1);
|
|
||||||
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
|
|
||||||
Firmata.begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
while(Firmata.available()) {
|
|
||||||
Firmata.processInput();
|
|
||||||
}
|
|
||||||
// do one analogRead per loop, so if PC is sending a lot of
|
|
||||||
// analog write messages, we will only delay 1 analogRead
|
|
||||||
Firmata.sendAnalog(analogPin, analogRead(analogPin));
|
|
||||||
analogPin = analogPin + 1;
|
|
||||||
if (analogPin >= TOTAL_ANALOG_PINS) analogPin = 0;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,72 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Supports as many digital inputs and outputs as possible.
|
|
||||||
*
|
|
||||||
* This example code is in the public domain.
|
|
||||||
*/
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
byte previousPIN[TOTAL_PORTS]; // PIN means PORT for input
|
|
||||||
byte previousPORT[TOTAL_PORTS];
|
|
||||||
|
|
||||||
void outputPort(byte portNumber, byte portValue)
|
|
||||||
{
|
|
||||||
// only send the data when it changes, otherwise you get too many messages!
|
|
||||||
if (previousPIN[portNumber] != portValue) {
|
|
||||||
Firmata.sendDigitalPort(portNumber, portValue);
|
|
||||||
previousPIN[portNumber] = portValue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setPinModeCallback(byte pin, int mode) {
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
pinMode(PIN_TO_DIGITAL(pin), mode);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void digitalWriteCallback(byte port, int value)
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
byte currentPinValue, previousPinValue;
|
|
||||||
|
|
||||||
if (port < TOTAL_PORTS && value != previousPORT[port]) {
|
|
||||||
for(i=0; i<8; i++) {
|
|
||||||
currentPinValue = (byte) value & (1 << i);
|
|
||||||
previousPinValue = previousPORT[port] & (1 << i);
|
|
||||||
if(currentPinValue != previousPinValue) {
|
|
||||||
digitalWrite(i + (port*8), currentPinValue);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
previousPORT[port] = value;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Firmata.setFirmwareVersion(0, 1);
|
|
||||||
Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
|
|
||||||
Firmata.attach(SET_PIN_MODE, setPinModeCallback);
|
|
||||||
Firmata.begin(57600);
|
|
||||||
}
|
|
||||||
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
|
|
||||||
for (i=0; i<TOTAL_PORTS; i++) {
|
|
||||||
outputPort(i, readPort(i, 0xff));
|
|
||||||
}
|
|
||||||
|
|
||||||
while(Firmata.available()) {
|
|
||||||
Firmata.processInput();
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,458 +0,0 @@
|
||||||
|
|
||||||
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.
|
|
||||||
|
|
|
@ -1,636 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*
|
|
||||||
* http://firmata.org/wiki/Download
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
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) 2009-2011 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.
|
|
||||||
|
|
||||||
formatted using the GNU C formatting and indenting
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* TODO: use Program Control to load stored profiles from EEPROM
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <Servo.h>
|
|
||||||
#include <Wire.h>
|
|
||||||
#include <Firmata.h>
|
|
||||||
|
|
||||||
// move the following defines to Firmata.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 MAX_QUERIES 8
|
|
||||||
#define MINIMUM_SAMPLING_INTERVAL 10
|
|
||||||
|
|
||||||
#define REGISTER_NOT_SPECIFIED -1
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* GLOBAL VARIABLES
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
/* analog inputs */
|
|
||||||
int analogInputsToReport = 0; // bitwise array to store pin reporting
|
|
||||||
|
|
||||||
/* digital input ports */
|
|
||||||
byte reportPINs[TOTAL_PORTS]; // 1 = report this port, 0 = silence
|
|
||||||
byte previousPINs[TOTAL_PORTS]; // previous 8 bits sent
|
|
||||||
|
|
||||||
/* pins configuration */
|
|
||||||
byte pinConfig[TOTAL_PINS]; // configuration of every pin
|
|
||||||
byte portConfigInputs[TOTAL_PORTS]; // each bit: 1 = pin in INPUT, 0 = anything else
|
|
||||||
int pinState[TOTAL_PINS]; // any value that has been written
|
|
||||||
|
|
||||||
/* timer variables */
|
|
||||||
unsigned long currentMillis; // store the current value from millis()
|
|
||||||
unsigned long previousMillis; // for comparison with currentMillis
|
|
||||||
int samplingInterval = 19; // how often to run the main loop (in ms)
|
|
||||||
|
|
||||||
/* i2c data */
|
|
||||||
struct i2c_device_info {
|
|
||||||
byte addr;
|
|
||||||
byte reg;
|
|
||||||
byte bytes;
|
|
||||||
};
|
|
||||||
|
|
||||||
/* for i2c read continuous more */
|
|
||||||
i2c_device_info query[MAX_QUERIES];
|
|
||||||
|
|
||||||
byte i2cRxData[32];
|
|
||||||
boolean isI2CEnabled = false;
|
|
||||||
signed char queryIndex = -1;
|
|
||||||
unsigned int i2cReadDelayTime = 0; // default delay time between i2c read request and Wire.requestFrom()
|
|
||||||
|
|
||||||
Servo servos[MAX_SERVOS];
|
|
||||||
/*==============================================================================
|
|
||||||
* FUNCTIONS
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
void readAndReportData(byte address, int theRegister, byte numBytes) {
|
|
||||||
// allow I2C requests that don't require a register read
|
|
||||||
// for example, some devices using an interrupt pin to signify new data available
|
|
||||||
// do not always require the register read so upon interrupt you call Wire.requestFrom()
|
|
||||||
if (theRegister != REGISTER_NOT_SPECIFIED) {
|
|
||||||
Wire.beginTransmission(address);
|
|
||||||
#if ARDUINO >= 100
|
|
||||||
Wire.write((byte)theRegister);
|
|
||||||
#else
|
|
||||||
Wire.send((byte)theRegister);
|
|
||||||
#endif
|
|
||||||
Wire.endTransmission();
|
|
||||||
delayMicroseconds(i2cReadDelayTime); // delay is necessary for some devices such as WiiNunchuck
|
|
||||||
} 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()) {
|
|
||||||
i2cRxData[0] = address;
|
|
||||||
i2cRxData[1] = theRegister;
|
|
||||||
for (int i = 0; i < numBytes; i++) {
|
|
||||||
#if ARDUINO >= 100
|
|
||||||
i2cRxData[2 + i] = Wire.read();
|
|
||||||
#else
|
|
||||||
i2cRxData[2 + i] = Wire.receive();
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if(numBytes > Wire.available()) {
|
|
||||||
Firmata.sendString("I2C Read Error: Too many bytes received");
|
|
||||||
} else {
|
|
||||||
Firmata.sendString("I2C Read Error: Too few bytes received");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// send slave address, register and received bytes
|
|
||||||
Firmata.sendSysex(SYSEX_I2C_REPLY, numBytes + 2, i2cRxData);
|
|
||||||
}
|
|
||||||
|
|
||||||
void outputPort(byte portNumber, byte portValue, byte forceSend)
|
|
||||||
{
|
|
||||||
// pins not configured as INPUT are cleared to zeros
|
|
||||||
portValue = portValue & portConfigInputs[portNumber];
|
|
||||||
// only send if the value is different than previously sent
|
|
||||||
if(forceSend || previousPINs[portNumber] != portValue) {
|
|
||||||
Firmata.sendDigitalPort(portNumber, portValue);
|
|
||||||
previousPINs[portNumber] = portValue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* -----------------------------------------------------------------------------
|
|
||||||
* check all the active digital inputs for change of state, then add any events
|
|
||||||
* to the Serial output queue using Serial.print() */
|
|
||||||
void checkDigitalInputs(void)
|
|
||||||
{
|
|
||||||
/* Using non-looping code allows constants to be given to readPort().
|
|
||||||
* The compiler will apply substantial optimizations if the inputs
|
|
||||||
* to readPort() are compile-time constants. */
|
|
||||||
if (TOTAL_PORTS > 0 && reportPINs[0]) outputPort(0, readPort(0, portConfigInputs[0]), false);
|
|
||||||
if (TOTAL_PORTS > 1 && reportPINs[1]) outputPort(1, readPort(1, portConfigInputs[1]), false);
|
|
||||||
if (TOTAL_PORTS > 2 && reportPINs[2]) outputPort(2, readPort(2, portConfigInputs[2]), false);
|
|
||||||
if (TOTAL_PORTS > 3 && reportPINs[3]) outputPort(3, readPort(3, portConfigInputs[3]), false);
|
|
||||||
if (TOTAL_PORTS > 4 && reportPINs[4]) outputPort(4, readPort(4, portConfigInputs[4]), false);
|
|
||||||
if (TOTAL_PORTS > 5 && reportPINs[5]) outputPort(5, readPort(5, portConfigInputs[5]), false);
|
|
||||||
if (TOTAL_PORTS > 6 && reportPINs[6]) outputPort(6, readPort(6, portConfigInputs[6]), false);
|
|
||||||
if (TOTAL_PORTS > 7 && reportPINs[7]) outputPort(7, readPort(7, portConfigInputs[7]), false);
|
|
||||||
if (TOTAL_PORTS > 8 && reportPINs[8]) outputPort(8, readPort(8, portConfigInputs[8]), false);
|
|
||||||
if (TOTAL_PORTS > 9 && reportPINs[9]) outputPort(9, readPort(9, portConfigInputs[9]), false);
|
|
||||||
if (TOTAL_PORTS > 10 && reportPINs[10]) outputPort(10, readPort(10, portConfigInputs[10]), false);
|
|
||||||
if (TOTAL_PORTS > 11 && reportPINs[11]) outputPort(11, readPort(11, portConfigInputs[11]), false);
|
|
||||||
if (TOTAL_PORTS > 12 && reportPINs[12]) outputPort(12, readPort(12, portConfigInputs[12]), false);
|
|
||||||
if (TOTAL_PORTS > 13 && reportPINs[13]) outputPort(13, readPort(13, portConfigInputs[13]), false);
|
|
||||||
if (TOTAL_PORTS > 14 && reportPINs[14]) outputPort(14, readPort(14, portConfigInputs[14]), false);
|
|
||||||
if (TOTAL_PORTS > 15 && reportPINs[15]) outputPort(15, readPort(15, portConfigInputs[15]), false);
|
|
||||||
}
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------------
|
|
||||||
/* sets the pin mode to the correct state and sets the relevant bits in the
|
|
||||||
* two bit-arrays that track Digital I/O and PWM status
|
|
||||||
*/
|
|
||||||
void setPinModeCallback(byte pin, int mode)
|
|
||||||
{
|
|
||||||
if (pinConfig[pin] == I2C && isI2CEnabled && mode != I2C) {
|
|
||||||
// disable i2c so pins can be used for other functions
|
|
||||||
// the following if statements should reconfigure the pins properly
|
|
||||||
disableI2CPins();
|
|
||||||
}
|
|
||||||
if (IS_PIN_SERVO(pin) && mode != SERVO && servos[PIN_TO_SERVO(pin)].attached()) {
|
|
||||||
servos[PIN_TO_SERVO(pin)].detach();
|
|
||||||
}
|
|
||||||
if (IS_PIN_ANALOG(pin)) {
|
|
||||||
reportAnalogCallback(PIN_TO_ANALOG(pin), mode == ANALOG ? 1 : 0); // turn on/off reporting
|
|
||||||
}
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
if (mode == INPUT) {
|
|
||||||
portConfigInputs[pin/8] |= (1 << (pin & 7));
|
|
||||||
} else {
|
|
||||||
portConfigInputs[pin/8] &= ~(1 << (pin & 7));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pinState[pin] = 0;
|
|
||||||
switch(mode) {
|
|
||||||
case ANALOG:
|
|
||||||
if (IS_PIN_ANALOG(pin)) {
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
|
|
||||||
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
|
|
||||||
}
|
|
||||||
pinConfig[pin] = ANALOG;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case INPUT:
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
|
|
||||||
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
|
|
||||||
pinConfig[pin] = INPUT;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case OUTPUT:
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
|
|
||||||
pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
|
|
||||||
pinConfig[pin] = OUTPUT;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case PWM:
|
|
||||||
if (IS_PIN_PWM(pin)) {
|
|
||||||
pinMode(PIN_TO_PWM(pin), OUTPUT);
|
|
||||||
analogWrite(PIN_TO_PWM(pin), 0);
|
|
||||||
pinConfig[pin] = PWM;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case SERVO:
|
|
||||||
if (IS_PIN_SERVO(pin)) {
|
|
||||||
pinConfig[pin] = SERVO;
|
|
||||||
if (!servos[PIN_TO_SERVO(pin)].attached()) {
|
|
||||||
servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case I2C:
|
|
||||||
if (IS_PIN_I2C(pin)) {
|
|
||||||
// mark the pin as i2c
|
|
||||||
// the user must call I2C_CONFIG to enable I2C for a device
|
|
||||||
pinConfig[pin] = I2C;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
Firmata.sendString("Unknown pin mode"); // TODO: put error msgs in EEPROM
|
|
||||||
}
|
|
||||||
// TODO: save status to EEPROM here, if changed
|
|
||||||
}
|
|
||||||
|
|
||||||
void analogWriteCallback(byte pin, int value)
|
|
||||||
{
|
|
||||||
if (pin < TOTAL_PINS) {
|
|
||||||
switch(pinConfig[pin]) {
|
|
||||||
case SERVO:
|
|
||||||
if (IS_PIN_SERVO(pin))
|
|
||||||
servos[PIN_TO_SERVO(pin)].write(value);
|
|
||||||
pinState[pin] = value;
|
|
||||||
break;
|
|
||||||
case PWM:
|
|
||||||
if (IS_PIN_PWM(pin))
|
|
||||||
analogWrite(PIN_TO_PWM(pin), value);
|
|
||||||
pinState[pin] = value;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void digitalWriteCallback(byte port, int value)
|
|
||||||
{
|
|
||||||
byte pin, lastPin, mask=1, pinWriteMask=0;
|
|
||||||
|
|
||||||
if (port < TOTAL_PORTS) {
|
|
||||||
// create a mask of the pins on this port that are writable.
|
|
||||||
lastPin = port*8+8;
|
|
||||||
if (lastPin > TOTAL_PINS) lastPin = TOTAL_PINS;
|
|
||||||
for (pin=port*8; pin < lastPin; pin++) {
|
|
||||||
// do not disturb non-digital pins (eg, Rx & Tx)
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
// only write to OUTPUT and INPUT (enables pullup)
|
|
||||||
// do not touch pins in PWM, ANALOG, SERVO or other modes
|
|
||||||
if (pinConfig[pin] == OUTPUT || pinConfig[pin] == INPUT) {
|
|
||||||
pinWriteMask |= mask;
|
|
||||||
pinState[pin] = ((byte)value & mask) ? 1 : 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
mask = mask << 1;
|
|
||||||
}
|
|
||||||
writePort(port, (byte)value, pinWriteMask);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// -----------------------------------------------------------------------------
|
|
||||||
/* sets bits in a bit array (int) to toggle the reporting of the analogIns
|
|
||||||
*/
|
|
||||||
//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
|
|
||||||
//}
|
|
||||||
void reportAnalogCallback(byte analogPin, int value)
|
|
||||||
{
|
|
||||||
if (analogPin < TOTAL_ANALOG_PINS) {
|
|
||||||
if(value == 0) {
|
|
||||||
analogInputsToReport = analogInputsToReport &~ (1 << analogPin);
|
|
||||||
} else {
|
|
||||||
analogInputsToReport = analogInputsToReport | (1 << analogPin);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// TODO: save status to EEPROM here, if changed
|
|
||||||
}
|
|
||||||
|
|
||||||
void reportDigitalCallback(byte port, int value)
|
|
||||||
{
|
|
||||||
if (port < TOTAL_PORTS) {
|
|
||||||
reportPINs[port] = (byte)value;
|
|
||||||
}
|
|
||||||
// do not disable analog reporting on these 8 pins, to allow some
|
|
||||||
// pins used for digital, others analog. Instead, allow both types
|
|
||||||
// of reporting to be enabled, but check if the pin is configured
|
|
||||||
// as analog when sampling the analog inputs. Likewise, while
|
|
||||||
// scanning digital pins, portConfigInputs will mask off values from any
|
|
||||||
// pins configured as analog
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* SYSEX-BASED commands
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
void sysexCallback(byte command, byte argc, byte *argv)
|
|
||||||
{
|
|
||||||
byte mode;
|
|
||||||
byte slaveAddress;
|
|
||||||
byte slaveRegister;
|
|
||||||
byte data;
|
|
||||||
unsigned int delayTime;
|
|
||||||
|
|
||||||
switch(command) {
|
|
||||||
case I2C_REQUEST:
|
|
||||||
mode = argv[1] & I2C_READ_WRITE_MODE_MASK;
|
|
||||||
if (argv[1] & I2C_10BIT_ADDRESS_MODE_MASK) {
|
|
||||||
Firmata.sendString("10-bit addressing mode is not yet supported");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
slaveAddress = argv[0];
|
|
||||||
}
|
|
||||||
|
|
||||||
switch(mode) {
|
|
||||||
case I2C_WRITE:
|
|
||||||
Wire.beginTransmission(slaveAddress);
|
|
||||||
for (byte i = 2; i < argc; i += 2) {
|
|
||||||
data = argv[i] + (argv[i + 1] << 7);
|
|
||||||
#if ARDUINO >= 100
|
|
||||||
Wire.write(data);
|
|
||||||
#else
|
|
||||||
Wire.send(data);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
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
|
|
||||||
readAndReportData(slaveAddress, (int)slaveRegister, data);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// a slave register is NOT specified
|
|
||||||
data = argv[2] + (argv[3] << 7); // bytes to read
|
|
||||||
readAndReportData(slaveAddress, (int)REGISTER_NOT_SPECIFIED, data);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case I2C_READ_CONTINUOUSLY:
|
|
||||||
if ((queryIndex + 1) >= MAX_QUERIES) {
|
|
||||||
// too many queries, just ignore
|
|
||||||
Firmata.sendString("too many queries");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
queryIndex++;
|
|
||||||
query[queryIndex].addr = slaveAddress;
|
|
||||||
query[queryIndex].reg = argv[2] + (argv[3] << 7);
|
|
||||||
query[queryIndex].bytes = argv[4] + (argv[5] << 7);
|
|
||||||
break;
|
|
||||||
case I2C_STOP_READING:
|
|
||||||
byte queryIndexToSkip;
|
|
||||||
// if read continuous mode is enabled for only 1 i2c device, disable
|
|
||||||
// read continuous reporting for that device
|
|
||||||
if (queryIndex <= 0) {
|
|
||||||
queryIndex = -1;
|
|
||||||
} else {
|
|
||||||
// if read continuous mode is enabled for multiple devices,
|
|
||||||
// determine which device to stop reading and remove it's data from
|
|
||||||
// the array, shifiting other array data to fill the space
|
|
||||||
for (byte i = 0; i < queryIndex + 1; i++) {
|
|
||||||
if (query[i].addr = slaveAddress) {
|
|
||||||
queryIndexToSkip = i;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for (byte i = queryIndexToSkip; i<queryIndex + 1; i++) {
|
|
||||||
if (i < MAX_QUERIES) {
|
|
||||||
query[i].addr = query[i+1].addr;
|
|
||||||
query[i].reg = query[i+1].addr;
|
|
||||||
query[i].bytes = query[i+1].bytes;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
queryIndex--;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case I2C_CONFIG:
|
|
||||||
delayTime = (argv[0] + (argv[1] << 7));
|
|
||||||
|
|
||||||
if(delayTime > 0) {
|
|
||||||
i2cReadDelayTime = delayTime;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!isI2CEnabled) {
|
|
||||||
enableI2CPins();
|
|
||||||
}
|
|
||||||
|
|
||||||
break;
|
|
||||||
case SERVO_CONFIG:
|
|
||||||
if(argc > 4) {
|
|
||||||
// these vars are here for clarity, they'll optimized away by the compiler
|
|
||||||
byte pin = argv[0];
|
|
||||||
int minPulse = argv[1] + (argv[2] << 7);
|
|
||||||
int maxPulse = argv[3] + (argv[4] << 7);
|
|
||||||
|
|
||||||
if (IS_PIN_SERVO(pin)) {
|
|
||||||
if (servos[PIN_TO_SERVO(pin)].attached())
|
|
||||||
servos[PIN_TO_SERVO(pin)].detach();
|
|
||||||
servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
|
|
||||||
setPinModeCallback(pin, SERVO);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case SAMPLING_INTERVAL:
|
|
||||||
if (argc > 1) {
|
|
||||||
samplingInterval = argv[0] + (argv[1] << 7);
|
|
||||||
if (samplingInterval < MINIMUM_SAMPLING_INTERVAL) {
|
|
||||||
samplingInterval = MINIMUM_SAMPLING_INTERVAL;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
//Firmata.sendString("Not enough data");
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case EXTENDED_ANALOG:
|
|
||||||
if (argc > 1) {
|
|
||||||
int val = argv[1];
|
|
||||||
if (argc > 2) val |= (argv[2] << 7);
|
|
||||||
if (argc > 3) val |= (argv[3] << 14);
|
|
||||||
analogWriteCallback(argv[0], val);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case CAPABILITY_QUERY:
|
|
||||||
Serial.write(START_SYSEX);
|
|
||||||
Serial.write(CAPABILITY_RESPONSE);
|
|
||||||
for (byte pin=0; pin < TOTAL_PINS; pin++) {
|
|
||||||
if (IS_PIN_DIGITAL(pin)) {
|
|
||||||
Serial.write((byte)INPUT);
|
|
||||||
Serial.write(1);
|
|
||||||
Serial.write((byte)OUTPUT);
|
|
||||||
Serial.write(1);
|
|
||||||
}
|
|
||||||
if (IS_PIN_ANALOG(pin)) {
|
|
||||||
Serial.write(ANALOG);
|
|
||||||
Serial.write(10);
|
|
||||||
}
|
|
||||||
if (IS_PIN_PWM(pin)) {
|
|
||||||
Serial.write(PWM);
|
|
||||||
Serial.write(8);
|
|
||||||
}
|
|
||||||
if (IS_PIN_SERVO(pin)) {
|
|
||||||
Serial.write(SERVO);
|
|
||||||
Serial.write(14);
|
|
||||||
}
|
|
||||||
if (IS_PIN_I2C(pin)) {
|
|
||||||
Serial.write(I2C);
|
|
||||||
Serial.write(1); // to do: determine appropriate value
|
|
||||||
}
|
|
||||||
Serial.write(127);
|
|
||||||
}
|
|
||||||
Serial.write(END_SYSEX);
|
|
||||||
break;
|
|
||||||
case PIN_STATE_QUERY:
|
|
||||||
if (argc > 0) {
|
|
||||||
byte pin=argv[0];
|
|
||||||
Serial.write(START_SYSEX);
|
|
||||||
Serial.write(PIN_STATE_RESPONSE);
|
|
||||||
Serial.write(pin);
|
|
||||||
if (pin < TOTAL_PINS) {
|
|
||||||
Serial.write((byte)pinConfig[pin]);
|
|
||||||
Serial.write((byte)pinState[pin] & 0x7F);
|
|
||||||
if (pinState[pin] & 0xFF80) Serial.write((byte)(pinState[pin] >> 7) & 0x7F);
|
|
||||||
if (pinState[pin] & 0xC000) Serial.write((byte)(pinState[pin] >> 14) & 0x7F);
|
|
||||||
}
|
|
||||||
Serial.write(END_SYSEX);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ANALOG_MAPPING_QUERY:
|
|
||||||
Serial.write(START_SYSEX);
|
|
||||||
Serial.write(ANALOG_MAPPING_RESPONSE);
|
|
||||||
for (byte pin=0; pin < TOTAL_PINS; pin++) {
|
|
||||||
Serial.write(IS_PIN_ANALOG(pin) ? PIN_TO_ANALOG(pin) : 127);
|
|
||||||
}
|
|
||||||
Serial.write(END_SYSEX);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void enableI2CPins()
|
|
||||||
{
|
|
||||||
byte i;
|
|
||||||
// is there a faster way to do this? would probaby require importing
|
|
||||||
// Arduino.h to get SCL and SDA pins
|
|
||||||
for (i=0; i < TOTAL_PINS; i++) {
|
|
||||||
if(IS_PIN_I2C(i)) {
|
|
||||||
// mark pins as i2c so they are ignore in non i2c data requests
|
|
||||||
setPinModeCallback(i, I2C);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
isI2CEnabled = true;
|
|
||||||
|
|
||||||
// is there enough time before the first I2C request to call this here?
|
|
||||||
Wire.begin();
|
|
||||||
}
|
|
||||||
|
|
||||||
/* disable the i2c pins so they can be used for other functions */
|
|
||||||
void disableI2CPins() {
|
|
||||||
isI2CEnabled = false;
|
|
||||||
// disable read continuous mode for all devices
|
|
||||||
queryIndex = -1;
|
|
||||||
// uncomment the following if or when the end() method is added to Wire library
|
|
||||||
// Wire.end();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* SETUP()
|
|
||||||
*============================================================================*/
|
|
||||||
|
|
||||||
void systemResetCallback()
|
|
||||||
{
|
|
||||||
// initialize a defalt state
|
|
||||||
// TODO: option to load config from EEPROM instead of default
|
|
||||||
if (isI2CEnabled) {
|
|
||||||
disableI2CPins();
|
|
||||||
}
|
|
||||||
for (byte i=0; i < TOTAL_PORTS; i++) {
|
|
||||||
reportPINs[i] = false; // by default, reporting off
|
|
||||||
portConfigInputs[i] = 0; // until activated
|
|
||||||
previousPINs[i] = 0;
|
|
||||||
}
|
|
||||||
// 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)) {
|
|
||||||
// turns off pullup, configures everything
|
|
||||||
setPinModeCallback(i, ANALOG);
|
|
||||||
} else {
|
|
||||||
// sets the output to 0, configures portConfigInputs
|
|
||||||
setPinModeCallback(i, OUTPUT);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// by default, do not report any analog inputs
|
|
||||||
analogInputsToReport = 0;
|
|
||||||
|
|
||||||
/* send digital inputs to set the initial state on the host computer,
|
|
||||||
* since once in the loop(), this firmware will only send on change */
|
|
||||||
/*
|
|
||||||
TODO: this can never execute, since no pins default to digital input
|
|
||||||
but it will be needed when/if we support EEPROM stored config
|
|
||||||
for (byte i=0; i < TOTAL_PORTS; i++) {
|
|
||||||
outputPort(i, readPort(i, portConfigInputs[i]), true);
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
void setup()
|
|
||||||
{
|
|
||||||
Firmata.setFirmwareVersion(FIRMATA_MAJOR_VERSION, FIRMATA_MINOR_VERSION);
|
|
||||||
|
|
||||||
Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
|
|
||||||
Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
|
|
||||||
Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
|
|
||||||
Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
|
|
||||||
Firmata.attach(SET_PIN_MODE, setPinModeCallback);
|
|
||||||
Firmata.attach(START_SYSEX, sysexCallback);
|
|
||||||
Firmata.attach(SYSTEM_RESET, systemResetCallback);
|
|
||||||
|
|
||||||
Firmata.begin(57600);
|
|
||||||
systemResetCallback(); // reset to default config
|
|
||||||
}
|
|
||||||
|
|
||||||
/*==============================================================================
|
|
||||||
* LOOP()
|
|
||||||
*============================================================================*/
|
|
||||||
void loop()
|
|
||||||
{
|
|
||||||
byte pin, analogPin;
|
|
||||||
|
|
||||||
/* DIGITALREAD - as fast as possible, check for changes and output them to the
|
|
||||||
* FTDI buffer using Serial.print() */
|
|
||||||
checkDigitalInputs();
|
|
||||||
|
|
||||||
/* SERIALREAD - processing incoming messagse as soon as possible, while still
|
|
||||||
* checking digital inputs. */
|
|
||||||
while(Firmata.available())
|
|
||||||
Firmata.processInput();
|
|
||||||
|
|
||||||
/* SEND FTDI WRITE BUFFER - make sure that the FTDI buffer doesn't go over
|
|
||||||
* 60 bytes. use a timer to sending an event character every 4 ms to
|
|
||||||
* trigger the buffer to dump. */
|
|
||||||
|
|
||||||
currentMillis = millis();
|
|
||||||
if (currentMillis - previousMillis > samplingInterval) {
|
|
||||||
previousMillis += samplingInterval;
|
|
||||||
/* ANALOGREAD - do all analogReads() at the configured sampling interval */
|
|
||||||
for(pin=0; pin<TOTAL_PINS; pin++) {
|
|
||||||
if (IS_PIN_ANALOG(pin) && pinConfig[pin] == ANALOG) {
|
|
||||||
analogPin = PIN_TO_ANALOG(pin);
|
|
||||||
if (analogInputsToReport & (1 << analogPin)) {
|
|
||||||
Firmata.sendAnalog(analogPin, analogRead(analogPin));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// report i2c data for all device with read continuous mode enabled
|
|
||||||
if (queryIndex > -1) {
|
|
||||||
for (byte i = 0; i < queryIndex + 1; i++) {
|
|
||||||
readAndReportData(query[i].addr, query[i].reg, query[i].bytes);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,62 +0,0 @@
|
||||||
#######################################
|
|
||||||
# Syntax Coloring Map For Firmata
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Datatypes (KEYWORD1)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
Firmata KEYWORD1
|
|
||||||
callbackFunction KEYWORD1
|
|
||||||
systemResetCallbackFunction KEYWORD1
|
|
||||||
stringCallbackFunction KEYWORD1
|
|
||||||
sysexCallbackFunction KEYWORD1
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Methods and Functions (KEYWORD2)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
begin KEYWORD2
|
|
||||||
begin KEYWORD2
|
|
||||||
printVersion KEYWORD2
|
|
||||||
blinkVersion KEYWORD2
|
|
||||||
printFirmwareVersion KEYWORD2
|
|
||||||
setFirmwareVersion KEYWORD2
|
|
||||||
setFirmwareNameAndVersion KEYWORD2
|
|
||||||
available KEYWORD2
|
|
||||||
processInput KEYWORD2
|
|
||||||
sendAnalog KEYWORD2
|
|
||||||
sendDigital KEYWORD2
|
|
||||||
sendDigitalPortPair KEYWORD2
|
|
||||||
sendDigitalPort KEYWORD2
|
|
||||||
sendString KEYWORD2
|
|
||||||
sendString KEYWORD2
|
|
||||||
sendSysex KEYWORD2
|
|
||||||
attach KEYWORD2
|
|
||||||
detach KEYWORD2
|
|
||||||
flush KEYWORD2
|
|
||||||
|
|
||||||
|
|
||||||
#######################################
|
|
||||||
# Constants (LITERAL1)
|
|
||||||
#######################################
|
|
||||||
|
|
||||||
MAX_DATA_BYTES LITERAL1
|
|
||||||
|
|
||||||
DIGITAL_MESSAGE LITERAL1
|
|
||||||
ANALOG_MESSAGE LITERAL1
|
|
||||||
REPORT_ANALOG LITERAL1
|
|
||||||
REPORT_DIGITAL LITERAL1
|
|
||||||
REPORT_VERSION LITERAL1
|
|
||||||
SET_PIN_MODE LITERAL1
|
|
||||||
SYSTEM_RESET LITERAL1
|
|
||||||
|
|
||||||
START_SYSEX LITERAL1
|
|
||||||
END_SYSEX LITERAL1
|
|
||||||
|
|
||||||
PWM LITERAL1
|
|
||||||
|
|
||||||
TOTAL_ANALOG_PINS LITERAL1
|
|
||||||
TOTAL_DIGITAL_PINS LITERAL1
|
|
||||||
TOTAL_PORTS LITERAL1
|
|
||||||
ANALOG_PORT LITERAL1
|
|
|
@ -1,68 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3SIMPLIFIERFILE_
|
|
||||||
#define _GSM3SIMPLIFIERFILE_
|
|
||||||
|
|
||||||
// This file simplifies the use of the GSM3 library
|
|
||||||
// First we include everything.
|
|
||||||
|
|
||||||
#include <GSM3CircularBuffer.h>
|
|
||||||
#include <GSM3MobileCellManagement.h>
|
|
||||||
#include <GSM3MobileClientService.h>
|
|
||||||
#include <GSM3MobileNetworkRegistry.h>
|
|
||||||
#include <GSM3MobileServerService.h>
|
|
||||||
#include <GSM3ShieldV1AccessProvider.h>
|
|
||||||
#include <GSM3ShieldV1BandManagement.h>
|
|
||||||
#include <GSM3ShieldV1ClientProvider.h>
|
|
||||||
#include <GSM3ShieldV1DataNetworkProvider.h>
|
|
||||||
#include <GSM3ShieldV1ModemVerification.h>
|
|
||||||
#include <GSM3ShieldV1PinManagement.h>
|
|
||||||
#include <GSM3ShieldV1ScanNetworks.h>
|
|
||||||
#include <GSM3SMSService.h>
|
|
||||||
#include <GSM3VoiceCallService.h>
|
|
||||||
|
|
||||||
#define GSM GSM3ShieldV1AccessProvider
|
|
||||||
#define GPRS GSM3ShieldV1DataNetworkProvider
|
|
||||||
#define GSMClient GSM3MobileClientService
|
|
||||||
#define GSMServer GSM3MobileServerService
|
|
||||||
#define GSMVoiceCall GSM3VoiceCallService
|
|
||||||
#define GSM_SMS GSM3SMSService
|
|
||||||
|
|
||||||
#define GSMPIN GSM3ShieldV1PinManagement
|
|
||||||
#define GSMModem GSM3ShieldV1ModemVerification
|
|
||||||
#define GSMCell GSM3CellManagement
|
|
||||||
#define GSMBand GSM3ShieldV1BandManagement
|
|
||||||
#define GSMScanner GSM3ShieldV1ScanNetworks
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,319 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include "GSM3CircularBuffer.h"
|
|
||||||
#include <HardwareSerial.h>
|
|
||||||
|
|
||||||
GSM3CircularBuffer::GSM3CircularBuffer(GSM3CircularBufferManager* mgr)
|
|
||||||
{
|
|
||||||
head=0;
|
|
||||||
tail=0;
|
|
||||||
cbm=mgr;
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3CircularBuffer::write(char c)
|
|
||||||
{
|
|
||||||
byte aux=(tail+1)& __BUFFERMASK__;
|
|
||||||
if(aux!=head)
|
|
||||||
{
|
|
||||||
theBuffer[tail]=c;
|
|
||||||
// Lets put an extra zero at the end, so we can
|
|
||||||
// read chains as we like.
|
|
||||||
// This is not exactly perfect, we are always 1+ behind the head
|
|
||||||
theBuffer[aux]=0;
|
|
||||||
tail=aux;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
char GSM3CircularBuffer::read()
|
|
||||||
{
|
|
||||||
char res;
|
|
||||||
if(head!=tail)
|
|
||||||
{
|
|
||||||
res=theBuffer[head];
|
|
||||||
head=(head+1)& __BUFFERMASK__;
|
|
||||||
//if(cbm)
|
|
||||||
// cbm->spaceAvailable();
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
char GSM3CircularBuffer::peek(int increment)
|
|
||||||
{
|
|
||||||
char res;
|
|
||||||
byte num_aux;
|
|
||||||
|
|
||||||
if (tail>head) num_aux = tail-head;
|
|
||||||
else num_aux = 128 - head + tail;
|
|
||||||
|
|
||||||
if(increment < num_aux)
|
|
||||||
{
|
|
||||||
res=theBuffer[head];
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3CircularBufferManager::spaceAvailable(){return;};
|
|
||||||
|
|
||||||
void GSM3CircularBuffer::flush()
|
|
||||||
{
|
|
||||||
head=tail;
|
|
||||||
}
|
|
||||||
|
|
||||||
char* GSM3CircularBuffer::nextString()
|
|
||||||
{
|
|
||||||
while(head!=tail)
|
|
||||||
{
|
|
||||||
head=(head+1) & __BUFFERMASK__;
|
|
||||||
if(theBuffer[head]==0)
|
|
||||||
{
|
|
||||||
head=(head+1) & __BUFFERMASK__;
|
|
||||||
return (char*)theBuffer+head;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
bool GSM3CircularBuffer::locate(const char* reference)
|
|
||||||
{
|
|
||||||
|
|
||||||
return locate(reference, head, tail, 0, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool GSM3CircularBuffer::chopUntil(const char* reference, bool movetotheend, bool usehead)
|
|
||||||
{
|
|
||||||
byte from, to;
|
|
||||||
|
|
||||||
if(locate(reference, head, tail, &from, &to))
|
|
||||||
{
|
|
||||||
if(usehead)
|
|
||||||
{
|
|
||||||
if(movetotheend)
|
|
||||||
head=(to+1) & __BUFFERMASK__;
|
|
||||||
else
|
|
||||||
head=from;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
if(movetotheend)
|
|
||||||
tail=(to+1) & __BUFFERMASK__;
|
|
||||||
else
|
|
||||||
tail=from;
|
|
||||||
}
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool GSM3CircularBuffer::locate(const char* reference, byte thishead, byte thistail, byte* from, byte* to)
|
|
||||||
{
|
|
||||||
int refcursor=0;
|
|
||||||
bool into=false;
|
|
||||||
byte b2, binit;
|
|
||||||
bool possible=1;
|
|
||||||
|
|
||||||
if(reference[0]==0)
|
|
||||||
return true;
|
|
||||||
|
|
||||||
for(byte b1=thishead; b1!=thistail;b1=(b1+1)& __BUFFERMASK__)
|
|
||||||
{
|
|
||||||
possible = 1;
|
|
||||||
b2 = b1;
|
|
||||||
while (possible&&(b2!=thistail))
|
|
||||||
{
|
|
||||||
if(theBuffer[b2]==reference[refcursor])
|
|
||||||
{
|
|
||||||
if(!into)
|
|
||||||
binit=b2;
|
|
||||||
into=true;
|
|
||||||
refcursor++;
|
|
||||||
if(reference[refcursor]==0)
|
|
||||||
{
|
|
||||||
if(from)
|
|
||||||
*from=binit;
|
|
||||||
if(to)
|
|
||||||
*to=b2;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (into==true)
|
|
||||||
{
|
|
||||||
possible = 0;
|
|
||||||
into=false;
|
|
||||||
refcursor=0;
|
|
||||||
}
|
|
||||||
b2=(b2+1)& __BUFFERMASK__;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool GSM3CircularBuffer::extractSubstring(const char* from, const char* to, char* buffer, int bufsize)
|
|
||||||
{
|
|
||||||
byte t1;
|
|
||||||
byte h2;
|
|
||||||
byte b;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
//DEBUG
|
|
||||||
//Serial.println("Beginning extractSubstring");
|
|
||||||
//Serial.print("head,tail=");Serial.print(int(head));Serial.print(",");Serial.println(int(tail));
|
|
||||||
|
|
||||||
if(!locate(from, head, tail, 0, &t1))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
//DEBUG
|
|
||||||
//Serial.println("Located chain from.");
|
|
||||||
|
|
||||||
t1++; //To point the next.
|
|
||||||
if(!locate(to, t1, tail, &h2, 0))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
//DEBUG
|
|
||||||
//Serial.println("Located chain to.");
|
|
||||||
/*Serial.print("t1=");Serial.println(int(t1));
|
|
||||||
Serial.print("h2=");Serial.println(int(h2));*/
|
|
||||||
|
|
||||||
|
|
||||||
for(i=0,b=t1;i<bufsize, b!=((h2) & __BUFFERMASK__); i++, b=(b+1)& __BUFFERMASK__)
|
|
||||||
buffer[i]=theBuffer[b];
|
|
||||||
buffer[i]=0;
|
|
||||||
|
|
||||||
//DEBUG
|
|
||||||
//Serial.println("");
|
|
||||||
//Serial.println("Finishing extractSubstring");
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3CircularBuffer::readInt()
|
|
||||||
{
|
|
||||||
int res=0;
|
|
||||||
byte c;
|
|
||||||
bool anyfound=false;
|
|
||||||
bool negative=false;
|
|
||||||
for(byte b=head + 1; b!=tail; b=(b+1)& __BUFFERMASK__)
|
|
||||||
{
|
|
||||||
c=theBuffer[b];
|
|
||||||
if((c==' ' )&&(!anyfound))
|
|
||||||
{
|
|
||||||
} else if((c=='-' )&&(!anyfound))
|
|
||||||
{
|
|
||||||
negative=true;
|
|
||||||
anyfound=true; // Don't admit blanks after -
|
|
||||||
} else if((c>='0')&&(c<='9'))
|
|
||||||
{
|
|
||||||
anyfound=true;
|
|
||||||
res=(res*10)+(int)c-48;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
if(negative)
|
|
||||||
res=(-1)*res;
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(negative)
|
|
||||||
res=(-1)*res;
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3CircularBuffer::debugBuffer()
|
|
||||||
{
|
|
||||||
byte h1=head;
|
|
||||||
byte t1=tail;
|
|
||||||
Serial.println();
|
|
||||||
Serial.print(h1);
|
|
||||||
Serial.print(" ");
|
|
||||||
Serial.print(t1);
|
|
||||||
Serial.print('>');
|
|
||||||
for(byte b=h1; b!=t1; b=(b+1)& __BUFFERMASK__)
|
|
||||||
printCharDebug(theBuffer[b]);
|
|
||||||
Serial.println();
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3CircularBuffer::printCharDebug(uint8_t c)
|
|
||||||
{
|
|
||||||
if((c>31)&&(c<127))
|
|
||||||
Serial.print((char)c);
|
|
||||||
else
|
|
||||||
{
|
|
||||||
Serial.print('%');
|
|
||||||
Serial.print(c);
|
|
||||||
Serial.print('%');
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool GSM3CircularBuffer::retrieveBuffer(char* buffer, int bufsize, int& SizeWritten)
|
|
||||||
{
|
|
||||||
byte b;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
/*for(i=0,b=head;i<bufsize, b!=tail; i++, b=(b+1)& __BUFFERMASK__)
|
|
||||||
{
|
|
||||||
buffer[i]=theBuffer[b];
|
|
||||||
}
|
|
||||||
buffer[i]=0;
|
|
||||||
SizeWritten = i;*/
|
|
||||||
b=head;
|
|
||||||
for(i=0;i<bufsize; i++)
|
|
||||||
{
|
|
||||||
if (b!=tail)
|
|
||||||
{
|
|
||||||
buffer[i]=theBuffer[b];
|
|
||||||
buffer[i+1]=0;
|
|
||||||
b=(b+1)& __BUFFERMASK__;
|
|
||||||
SizeWritten = i + 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,205 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef __GSM3_CIRCULARBUFFER__
|
|
||||||
#define __GSM3_CIRCULARBUFFER__
|
|
||||||
|
|
||||||
|
|
||||||
#include <inttypes.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
#ifndef byte
|
|
||||||
#define byte uint8_t
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// These values have to be interrelated
|
|
||||||
// To-Do: may we have just one? (BUFFERMASK)
|
|
||||||
#define __BUFFERSIZE__ 128
|
|
||||||
#define __BUFFERMASK__ 0x7F
|
|
||||||
|
|
||||||
class GSM3CircularBufferManager
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** If there is spaceAvailable in the buffer, lets send a XON
|
|
||||||
*/
|
|
||||||
virtual void spaceAvailable();
|
|
||||||
};
|
|
||||||
|
|
||||||
class GSM3CircularBuffer
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
// Buffer pointers.
|
|
||||||
// head=tail means buffer empty
|
|
||||||
// tail=head-1 means buffer full
|
|
||||||
// tail=head+1 means just one char (pointed by head)
|
|
||||||
// REMEMBER. head can be moved only by the main program
|
|
||||||
// REMEMBER. tail can be moved only by the other thread (interrupts)
|
|
||||||
// REMEMBER. head and tail can move only FORWARD
|
|
||||||
volatile byte head; // First written one
|
|
||||||
volatile byte tail; // Last written one.
|
|
||||||
|
|
||||||
GSM3CircularBufferManager* cbm; // Circular buffer manager
|
|
||||||
|
|
||||||
// The buffer
|
|
||||||
volatile byte theBuffer[__BUFFERSIZE__];
|
|
||||||
|
|
||||||
/** Checks if a substring exists in the buffer
|
|
||||||
@param reference Substring
|
|
||||||
@param thishead Head
|
|
||||||
@param thistail Tail
|
|
||||||
@param from Initial byte position
|
|
||||||
@param to Final byte position
|
|
||||||
@return true if exists, in otherwise return false
|
|
||||||
*/
|
|
||||||
bool locate(const char* reference, byte thishead, byte thistail, byte* from=0, byte* to=0);
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Constructor
|
|
||||||
@param mgr Circular buffer manager
|
|
||||||
*/
|
|
||||||
GSM3CircularBuffer(GSM3CircularBufferManager* mgr=0);
|
|
||||||
|
|
||||||
// TO-DO.Check if this formule runs too at the buffer limit
|
|
||||||
|
|
||||||
/** Get available bytes in circular buffer
|
|
||||||
@return available bytes
|
|
||||||
*/
|
|
||||||
inline byte availableBytes(){ return ((head-(tail+1))&__BUFFERMASK__);};
|
|
||||||
|
|
||||||
/** Stored bytes in circular buffer
|
|
||||||
@return stored bytes
|
|
||||||
*/
|
|
||||||
inline byte storedBytes(){ return ((tail-head)&__BUFFERMASK__);};
|
|
||||||
|
|
||||||
/** Write a character in circular buffer
|
|
||||||
@param c Character
|
|
||||||
@return 1 if successful
|
|
||||||
*/
|
|
||||||
int write(char c);
|
|
||||||
|
|
||||||
/** Returns a character and moves the pointer
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
char read();
|
|
||||||
|
|
||||||
/** Returns a character but does not move the pointer.
|
|
||||||
@param increment Increment
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
char peek(int increment);
|
|
||||||
|
|
||||||
/** Returns a pointer to the head of the buffer
|
|
||||||
@return buffer with pointer in head
|
|
||||||
*/
|
|
||||||
inline char* firstString(){return (char*)theBuffer+head;};
|
|
||||||
|
|
||||||
/** Go forward one string
|
|
||||||
@return buffer with one string advance
|
|
||||||
*/
|
|
||||||
char* nextString();
|
|
||||||
|
|
||||||
/** Flush circular buffer
|
|
||||||
*/
|
|
||||||
void flush();
|
|
||||||
|
|
||||||
/** Get tail
|
|
||||||
@return tail
|
|
||||||
*/
|
|
||||||
inline byte getTail(){return tail;};
|
|
||||||
|
|
||||||
/** Get head
|
|
||||||
@return head
|
|
||||||
*/
|
|
||||||
inline byte getHead(){return head;};
|
|
||||||
|
|
||||||
// Only can be executed from the interrupt!
|
|
||||||
/** Delete circular buffer to the end
|
|
||||||
@param from Initial byte position
|
|
||||||
*/
|
|
||||||
inline void deleteToTheEnd(byte from){tail=from;};
|
|
||||||
|
|
||||||
/** Checks if a substring exists in the buffer
|
|
||||||
move=0, dont move, =1,put head at the beginning of the string, =2, put head at the end
|
|
||||||
@param reference
|
|
||||||
@return true if exists, in otherwise return false
|
|
||||||
*/
|
|
||||||
bool locate(const char* reference);
|
|
||||||
|
|
||||||
/** Locates reference. If found, moves head (or tail) to the beginning (or end)
|
|
||||||
@param reference
|
|
||||||
@param movetotheend
|
|
||||||
@param head
|
|
||||||
@return true if successful
|
|
||||||
*/
|
|
||||||
bool chopUntil(const char* reference, bool movetotheend, bool head=true);
|
|
||||||
|
|
||||||
/** Reads an integer from the head. Stops with first non blank, non number character
|
|
||||||
@return integer from the head
|
|
||||||
*/
|
|
||||||
int readInt();
|
|
||||||
|
|
||||||
// Caveat: copies the first bytes until buffer is full
|
|
||||||
|
|
||||||
/** Extract a substring from circular buffer
|
|
||||||
@param from Initial byte position
|
|
||||||
@param to Final byte position
|
|
||||||
@param buffer Buffer for copy substring
|
|
||||||
@param bufsize Buffer size
|
|
||||||
@return true if successful, false if substring does not exists
|
|
||||||
*/
|
|
||||||
bool extractSubstring(const char* from, const char* to, char* buffer, int bufsize);
|
|
||||||
|
|
||||||
/** Retrieve all the contents of buffer from head to tail
|
|
||||||
@param buffer
|
|
||||||
@param bufsize
|
|
||||||
@param SizeWritten
|
|
||||||
@return true if successful
|
|
||||||
*/
|
|
||||||
bool retrieveBuffer(char* buffer, int bufsize, int& SizeWritten);
|
|
||||||
|
|
||||||
/** Debug function to print the buffer after receiving data from the modem.
|
|
||||||
*/
|
|
||||||
void debugBuffer();
|
|
||||||
|
|
||||||
/** Utility: dump character if printable, else, put in %x%
|
|
||||||
@param c Character
|
|
||||||
*/
|
|
||||||
static void printCharDebug(uint8_t c);
|
|
||||||
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,3 +0,0 @@
|
||||||
#include <GSM3MobileAccessProvider.h>
|
|
||||||
|
|
||||||
GSM3MobileAccessProvider* theGSM3MobileAccessProvider;
|
|
|
@ -1,68 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILEACCESSPROVIDER_
|
|
||||||
#define _GSM3MOBILEACCESSPROVIDER_
|
|
||||||
|
|
||||||
enum GSM3_NetworkStatus_t { ERROR, IDLE, CONNECTING, GSM_READY, GPRS_READY, TRANSPARENT_CONNECTED};
|
|
||||||
|
|
||||||
class GSM3MobileAccessProvider
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
// Access functions
|
|
||||||
//Configuration functions.
|
|
||||||
/** Establish GSM connection
|
|
||||||
@param pin PIN code
|
|
||||||
@param restart Determines if hardware restart
|
|
||||||
@param synchronous Determines sync mode
|
|
||||||
@return If synchronous, GSM3_NetworkStatus_t. If asynchronous, returns 0.
|
|
||||||
*/
|
|
||||||
virtual inline GSM3_NetworkStatus_t begin(char* pin=0,bool restart=true, bool synchronous=true)=0;
|
|
||||||
|
|
||||||
/** Check network access status
|
|
||||||
@return 1 if Alive, 0 if down
|
|
||||||
*/
|
|
||||||
virtual inline int isAccessAlive()=0;
|
|
||||||
|
|
||||||
/** Shutdown the modem (power off really)
|
|
||||||
@return true if successful
|
|
||||||
*/
|
|
||||||
virtual inline bool shutdown()=0;
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1 +0,0 @@
|
||||||
#include <GSM3MobileCellManagement.h>
|
|
|
@ -1,53 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILECELLMANAGEMENT_
|
|
||||||
#define _GSM3MOBILECELLMANAGEMENT_
|
|
||||||
|
|
||||||
#include <Arduino.h>
|
|
||||||
|
|
||||||
class GSM3MobileCellManagement
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
virtual inline int getLocation() {return 0;};
|
|
||||||
|
|
||||||
virtual inline int getICCID() {return 0;};
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,3 +0,0 @@
|
||||||
#include <GSM3MobileClientProvider.h>
|
|
||||||
|
|
||||||
GSM3MobileClientProvider* theGSM3MobileClientProvider;
|
|
|
@ -1,156 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef __GSM3_MOBILECLIENTPROVIDER__
|
|
||||||
#define __GSM3_MOBILECLIENTPROVIDER__
|
|
||||||
|
|
||||||
#include <Arduino.h>
|
|
||||||
#include <IPAddress.h>
|
|
||||||
|
|
||||||
class GSM3MobileClientProvider
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
|
|
||||||
uint8_t sockets;
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Constructor */
|
|
||||||
GSM3MobileClientProvider(){};
|
|
||||||
|
|
||||||
/** Minimum socket
|
|
||||||
@return socket
|
|
||||||
*/
|
|
||||||
virtual inline int minSocket()=0;
|
|
||||||
|
|
||||||
/** Maximum socket
|
|
||||||
@return socket
|
|
||||||
*/
|
|
||||||
virtual inline int maxSocket()=0;
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
|
|
||||||
/** Get status socket client
|
|
||||||
@param socket Socket
|
|
||||||
@return 1 if connected
|
|
||||||
*/
|
|
||||||
virtual bool getStatusSocketClient(uint8_t socket)=0;
|
|
||||||
|
|
||||||
// Socket management
|
|
||||||
|
|
||||||
/** Get socket
|
|
||||||
@param socket Socket
|
|
||||||
@return socket
|
|
||||||
*/
|
|
||||||
virtual int getSocket(int socket=-1)=0;
|
|
||||||
|
|
||||||
/** Release socket
|
|
||||||
@param socket Socket
|
|
||||||
*/
|
|
||||||
virtual void releaseSocket(int socket)=0;
|
|
||||||
|
|
||||||
// Client socket functions
|
|
||||||
|
|
||||||
/** Connect to a server via TCP connection
|
|
||||||
@param server Server name or IP address in a String
|
|
||||||
@param port Port
|
|
||||||
@param id_socket Socket
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
virtual int connectTCPClient(const char* server, int port, int id_socket)=0;
|
|
||||||
|
|
||||||
/** Connect to a server (by IP address) via TCP connection
|
|
||||||
@param add IP address in IPAddress format
|
|
||||||
@param port Port
|
|
||||||
@param id_socket Socket
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
virtual int connectTCPClient(IPAddress add, int port, int id_socket)=0;
|
|
||||||
|
|
||||||
/** Begin writing through a socket
|
|
||||||
@param client1Server0 1 if modem acts as client, 0 if acts as server
|
|
||||||
@param id_socket Local socket number
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
virtual void beginWriteSocket(bool client1Server0, int id_socket)=0;
|
|
||||||
|
|
||||||
/** Write through a socket. MUST go after beginWriteSocket()
|
|
||||||
@param c character to be written
|
|
||||||
*/
|
|
||||||
virtual void writeSocket(uint8_t c)=0;
|
|
||||||
|
|
||||||
/** Write through a socket. MUST go after beginWriteSocket()
|
|
||||||
@param buf characters to be written (final 0 will not be written)
|
|
||||||
*/
|
|
||||||
virtual void writeSocket(const char* buf)=0;
|
|
||||||
|
|
||||||
/** Finish current writing
|
|
||||||
*/
|
|
||||||
virtual void endWriteSocket()=0;
|
|
||||||
|
|
||||||
/** Check if there are data to be read in socket.
|
|
||||||
@param client1Server0 1 if modem acts as client, 0 if acts as server
|
|
||||||
@param id_socket Local socket number
|
|
||||||
@return 0 if command running, 1 if there are data available, 4 if no data, otherwise error
|
|
||||||
*/
|
|
||||||
virtual int availableSocket(bool client, int id_socket)=0;
|
|
||||||
|
|
||||||
/** Read data (get a character) available in socket
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
virtual int readSocket()=0;
|
|
||||||
|
|
||||||
/** Flush socket
|
|
||||||
*/
|
|
||||||
virtual void flushSocket()=0;
|
|
||||||
|
|
||||||
/** Get a character but will not advance the buffer head
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
virtual int peekSocket()=0;
|
|
||||||
|
|
||||||
/** Close a socket
|
|
||||||
@param client1Server0 1 if modem acts as client, 0 if acts as server
|
|
||||||
@param id_socket Socket
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
virtual int disconnectTCP(bool client1Server0, int idsocket)=0;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileClientProvider* theGSM3MobileClientProvider;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,260 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include <GSM3MobileClientService.h>
|
|
||||||
#include <GSM3MobileClientProvider.h>
|
|
||||||
#include <Arduino.h>
|
|
||||||
|
|
||||||
// While there is only a shield (ShieldV1) we will include it by default
|
|
||||||
#include <GSM3ShieldV1ClientProvider.h>
|
|
||||||
GSM3ShieldV1ClientProvider theShieldV1ClientProvider;
|
|
||||||
|
|
||||||
|
|
||||||
#define GSM3MOBILECLIENTSERVICE_CLIENT 0x01 // 1: This side is Client. 0: This side is Server
|
|
||||||
#define GSM3MOBILECLIENTSERVICE_WRITING 0x02 // 1: TRUE 0: FALSE
|
|
||||||
#define GSM3MOBILECLIENTSERVICE_SYNCH 0x04 // 1: TRUE, compatible with other clients 0: FALSE
|
|
||||||
|
|
||||||
#define __TOUTBEGINWRITE__ 10000
|
|
||||||
|
|
||||||
|
|
||||||
GSM3MobileClientService::GSM3MobileClientService(bool synch)
|
|
||||||
{
|
|
||||||
flags = GSM3MOBILECLIENTSERVICE_CLIENT;
|
|
||||||
if(synch)
|
|
||||||
flags |= GSM3MOBILECLIENTSERVICE_SYNCH;
|
|
||||||
mySocket=255;
|
|
||||||
}
|
|
||||||
|
|
||||||
GSM3MobileClientService::GSM3MobileClientService(int socket, bool synch)
|
|
||||||
{
|
|
||||||
// We are creating a socket on an existing, occupied one.
|
|
||||||
flags=0;
|
|
||||||
if(synch)
|
|
||||||
flags |= GSM3MOBILECLIENTSERVICE_SYNCH;
|
|
||||||
mySocket=socket;
|
|
||||||
theGSM3MobileClientProvider->getSocket(socket);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns 0 if last command is still executing
|
|
||||||
// 1 if success
|
|
||||||
// >1 if error
|
|
||||||
int GSM3MobileClientService::ready()
|
|
||||||
{
|
|
||||||
return theGSM3MobileClientProvider->ready();
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3MobileClientService::connect(IPAddress add, uint16_t port)
|
|
||||||
{
|
|
||||||
if(theGSM3MobileClientProvider==0)
|
|
||||||
return 2;
|
|
||||||
|
|
||||||
// TODO: ask for the socket id
|
|
||||||
mySocket=theGSM3MobileClientProvider->getSocket();
|
|
||||||
|
|
||||||
if(mySocket<0)
|
|
||||||
return 2;
|
|
||||||
|
|
||||||
int res=theGSM3MobileClientProvider->connectTCPClient(add, port, mySocket);
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_SYNCH)
|
|
||||||
res=waitForAnswer();
|
|
||||||
|
|
||||||
return res;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileClientService::connect(const char *host, uint16_t port)
|
|
||||||
{
|
|
||||||
|
|
||||||
if(theGSM3MobileClientProvider==0)
|
|
||||||
return 2;
|
|
||||||
// TODO: ask for the socket id
|
|
||||||
mySocket=theGSM3MobileClientProvider->getSocket();
|
|
||||||
|
|
||||||
if(mySocket<0)
|
|
||||||
return 2;
|
|
||||||
|
|
||||||
int res=theGSM3MobileClientProvider->connectTCPClient(host, port, mySocket);
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_SYNCH)
|
|
||||||
res=waitForAnswer();
|
|
||||||
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3MobileClientService::waitForAnswer()
|
|
||||||
{
|
|
||||||
unsigned long m;
|
|
||||||
m=millis();
|
|
||||||
int res;
|
|
||||||
|
|
||||||
while(((millis()-m)< __TOUTBEGINWRITE__ )&&(ready()==0))
|
|
||||||
delay(100);
|
|
||||||
|
|
||||||
res=ready();
|
|
||||||
|
|
||||||
// If we get something different from a 1, we are having a problem
|
|
||||||
if(res!=1)
|
|
||||||
res=0;
|
|
||||||
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileClientService::beginWrite(bool sync)
|
|
||||||
{
|
|
||||||
flags |= GSM3MOBILECLIENTSERVICE_WRITING;
|
|
||||||
theGSM3MobileClientProvider->beginWriteSocket(flags & GSM3MOBILECLIENTSERVICE_CLIENT, mySocket);
|
|
||||||
if(sync)
|
|
||||||
waitForAnswer();
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t GSM3MobileClientService::write(uint8_t c)
|
|
||||||
{
|
|
||||||
if(!(flags & GSM3MOBILECLIENTSERVICE_WRITING))
|
|
||||||
beginWrite(true);
|
|
||||||
theGSM3MobileClientProvider->writeSocket(c);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t GSM3MobileClientService::write(const uint8_t* buf)
|
|
||||||
{
|
|
||||||
if(!(flags & GSM3MOBILECLIENTSERVICE_WRITING))
|
|
||||||
beginWrite(true);
|
|
||||||
theGSM3MobileClientProvider->writeSocket((const char*)(buf));
|
|
||||||
return strlen((const char*)buf);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t GSM3MobileClientService::write(const uint8_t* buf, size_t sz)
|
|
||||||
{
|
|
||||||
if(!(flags & GSM3MOBILECLIENTSERVICE_WRITING))
|
|
||||||
beginWrite(true);
|
|
||||||
for(int i=0;i<sz;i++)
|
|
||||||
theGSM3MobileClientProvider->writeSocket(buf[i]);
|
|
||||||
return sz;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileClientService::endWrite(bool sync)
|
|
||||||
{
|
|
||||||
flags ^= GSM3MOBILECLIENTSERVICE_WRITING;
|
|
||||||
theGSM3MobileClientProvider->endWriteSocket();
|
|
||||||
if(sync)
|
|
||||||
waitForAnswer();
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t GSM3MobileClientService::connected()
|
|
||||||
{
|
|
||||||
if(mySocket==255)
|
|
||||||
return 0;
|
|
||||||
return theGSM3MobileClientProvider->getStatusSocketClient(mySocket);
|
|
||||||
}
|
|
||||||
|
|
||||||
GSM3MobileClientService::operator bool()
|
|
||||||
{
|
|
||||||
return connected()==1;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileClientService::available()
|
|
||||||
{
|
|
||||||
int res;
|
|
||||||
|
|
||||||
// Even if not connected, we are looking for available data
|
|
||||||
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_WRITING)
|
|
||||||
endWrite(true);
|
|
||||||
|
|
||||||
res=theGSM3MobileClientProvider->availableSocket(flags & GSM3MOBILECLIENTSERVICE_CLIENT,mySocket);
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_SYNCH)
|
|
||||||
res=waitForAnswer();
|
|
||||||
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3MobileClientService::read(uint8_t *buf, size_t size)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
uint8_t c;
|
|
||||||
|
|
||||||
for(i=0;i<size;i++)
|
|
||||||
{
|
|
||||||
c=read();
|
|
||||||
if(c==0)
|
|
||||||
break;
|
|
||||||
buf[i]=c;
|
|
||||||
}
|
|
||||||
|
|
||||||
return i;
|
|
||||||
/* This is the old implementation, testing a simpler one
|
|
||||||
int res;
|
|
||||||
// If we were writing, just stop doing it.
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_WRITING)
|
|
||||||
endWrite(true);
|
|
||||||
res=theGSM3MobileClientProvider->readSocket(flags & GSM3MOBILECLIENTSERVICE_CLIENT, (char *)(buf), size, mySocket);
|
|
||||||
|
|
||||||
return res;
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3MobileClientService::read()
|
|
||||||
{
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_WRITING)
|
|
||||||
endWrite(true);
|
|
||||||
int c=theGSM3MobileClientProvider->readSocket();
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3MobileClientService::peek()
|
|
||||||
{
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_WRITING)
|
|
||||||
endWrite(true);
|
|
||||||
return theGSM3MobileClientProvider->peekSocket(/*mySocket, false*/);
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileClientService::flush()
|
|
||||||
{
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_WRITING)
|
|
||||||
endWrite(true);
|
|
||||||
theGSM3MobileClientProvider->flushSocket(/*mySocket*/);
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_SYNCH)
|
|
||||||
waitForAnswer();
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileClientService::stop()
|
|
||||||
{
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_WRITING)
|
|
||||||
endWrite(true);
|
|
||||||
theGSM3MobileClientProvider->disconnectTCP(flags & GSM3MOBILECLIENTSERVICE_CLIENT, mySocket);
|
|
||||||
theGSM3MobileClientProvider->releaseSocket(mySocket);
|
|
||||||
mySocket = 0;
|
|
||||||
if(flags & GSM3MOBILECLIENTSERVICE_SYNCH)
|
|
||||||
waitForAnswer();
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,162 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILECLIENTSERVICE_
|
|
||||||
#define _GSM3MOBILECLIENTSERVICE_
|
|
||||||
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
#include <Client.h>
|
|
||||||
|
|
||||||
|
|
||||||
class GSM3MobileClientService : public Client
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
|
|
||||||
uint8_t mySocket;
|
|
||||||
uint8_t flags;
|
|
||||||
|
|
||||||
/** Blocks waiting for an answer
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
int waitForAnswer();
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Constructor
|
|
||||||
@param synch Sync mode
|
|
||||||
*/
|
|
||||||
GSM3MobileClientService(bool synch=true);
|
|
||||||
|
|
||||||
/** Constructor
|
|
||||||
@param socket Socket
|
|
||||||
@param synch Sync mode
|
|
||||||
*/
|
|
||||||
GSM3MobileClientService(int socket, bool synch);
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
int ready();
|
|
||||||
|
|
||||||
// we take this function out as IPAddress is complex to bring to
|
|
||||||
// version 1.
|
|
||||||
/** Connect to server by IP address
|
|
||||||
@param (IPAddress)
|
|
||||||
@param (uint16_t)
|
|
||||||
@return returns 0 if last command is still executing, 1 success, 2 if there are no resources
|
|
||||||
*/
|
|
||||||
inline int connect(IPAddress, uint16_t);
|
|
||||||
|
|
||||||
/** Connect to server by hostname
|
|
||||||
@param host Hostname
|
|
||||||
@param port Port
|
|
||||||
@return returns 0 if last command is still executing, 1 success, 2 if there are no resources
|
|
||||||
*/
|
|
||||||
int connect(const char *host, uint16_t port);
|
|
||||||
|
|
||||||
/** Initialize write in request
|
|
||||||
@param sync Sync mode
|
|
||||||
*/
|
|
||||||
void beginWrite(bool sync=false);
|
|
||||||
|
|
||||||
/** Write a character in request
|
|
||||||
@param c Character
|
|
||||||
@return size
|
|
||||||
*/
|
|
||||||
size_t write(uint8_t c);
|
|
||||||
|
|
||||||
/** Write a characters buffer in request
|
|
||||||
@param buf Buffer
|
|
||||||
@return buffer size
|
|
||||||
*/
|
|
||||||
size_t write(const uint8_t *buf);
|
|
||||||
|
|
||||||
/** Write a characters buffer with size in request
|
|
||||||
@param (uint8_t*) Buffer
|
|
||||||
@param (size_t) Buffer size
|
|
||||||
@return buffer size
|
|
||||||
*/
|
|
||||||
size_t write(const uint8_t*, size_t);
|
|
||||||
|
|
||||||
/** Finish write request
|
|
||||||
@param sync Sync mode
|
|
||||||
*/
|
|
||||||
void endWrite(bool sync=false);
|
|
||||||
|
|
||||||
/** Check if connected to server
|
|
||||||
@return 1 if connected
|
|
||||||
*/
|
|
||||||
uint8_t connected();
|
|
||||||
|
|
||||||
operator bool();
|
|
||||||
|
|
||||||
/** Read from response buffer and copy size specified to buffer
|
|
||||||
@param buf Buffer
|
|
||||||
@param size Buffer size
|
|
||||||
@return bytes read
|
|
||||||
*/
|
|
||||||
int read(uint8_t *buf, size_t size);
|
|
||||||
|
|
||||||
/** Read a character from response buffer
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
int read();
|
|
||||||
|
|
||||||
/** Check if exists a response available
|
|
||||||
@return 1 if exists, 0 if not exists
|
|
||||||
*/
|
|
||||||
int available();
|
|
||||||
|
|
||||||
/** Read a character from response buffer but does not move the pointer.
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
int peek();
|
|
||||||
|
|
||||||
/** Flush response buffer
|
|
||||||
*/
|
|
||||||
void flush();
|
|
||||||
|
|
||||||
/** Stop client
|
|
||||||
*/
|
|
||||||
void stop();
|
|
||||||
|
|
||||||
/** Get socket
|
|
||||||
@return socket
|
|
||||||
*/
|
|
||||||
inline int getSocket(){return (int)mySocket;};
|
|
||||||
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,3 +0,0 @@
|
||||||
#include <GSM3MobileDataNetworkProvider.h>
|
|
||||||
|
|
||||||
// GSM3MobileDataNetworkProvider* theGSM3MobileDataNetworkProvider;
|
|
|
@ -1,62 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILEDATANETWORKPROVIDER_
|
|
||||||
#define _GSM3MOBILEDATANETWORKPROVIDER_
|
|
||||||
|
|
||||||
#include <GSM3MobileAccessProvider.h>
|
|
||||||
|
|
||||||
// This class is not really useful, but serves as a guideline for programmers
|
|
||||||
// We keep it but it should never be linked
|
|
||||||
class GSM3MobileDataNetworkProvider
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Attach to GPRS/GSM network
|
|
||||||
@param networkId APN GPRS
|
|
||||||
@param user Username
|
|
||||||
@param pass Password
|
|
||||||
@return connection status
|
|
||||||
*/
|
|
||||||
virtual GSM3_NetworkStatus_t networkAttach(char* networId, char* user, char* pass)=0;
|
|
||||||
|
|
||||||
/** Detach GPRS/GSM network
|
|
||||||
@return connection status
|
|
||||||
*/
|
|
||||||
virtual GSM3_NetworkStatus_t networkDetach()=0;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileDataNetworkProvider* theGSM3MobileDataNetworkProvider;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,191 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
#include <GSM3MobileMockupProvider.h>
|
|
||||||
#include <inttypes.h>
|
|
||||||
#include <HardwareSerial.h>
|
|
||||||
|
|
||||||
|
|
||||||
GSM3MobileMockupProvider::GSM3MobileMockupProvider()
|
|
||||||
{
|
|
||||||
lineStatus=IDLE;
|
|
||||||
msgExample="Hello#World";
|
|
||||||
msgIndex=0;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::begin(char* pin)
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::begin()");
|
|
||||||
return 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::ready()
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::ready()");
|
|
||||||
return 1;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::beginSMS(const char* number)
|
|
||||||
{
|
|
||||||
Serial.println("SM3MobileMockupProvider::beginSMS()");
|
|
||||||
return 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
void GSM3MobileMockupProvider::writeSMS(char c)
|
|
||||||
{
|
|
||||||
Serial.print(c);
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::endSMS()
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::endSMS()");
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::availableSMS()
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::availableSMS()");
|
|
||||||
return 120;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::peek()
|
|
||||||
{
|
|
||||||
return (int)'H';
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::remoteSMSNumber(char* number, int nlength)
|
|
||||||
{
|
|
||||||
if(nlength>=13)
|
|
||||||
strcpy(number, "+34630538546");
|
|
||||||
return 12;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
void GSM3MobileMockupProvider::flushSMS()
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::flushSMS()");
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::readSMS()
|
|
||||||
{
|
|
||||||
if(msgExample[msgIndex]==0)
|
|
||||||
{
|
|
||||||
msgIndex=0;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
msgIndex++;
|
|
||||||
return msgExample[msgIndex-1];
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::connectTCPClient(const char* server, int port, int id_socket)
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::connectTCPClient()");
|
|
||||||
Serial.print(server);Serial.print(":");Serial.print(port);Serial.print("-");Serial.println(id_socket);
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileMockupProvider::writeSocket(const uint8_t *buf, size_t size, int id_socket)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
for(i=0;i<size;i++)
|
|
||||||
Serial.print(buf[i]);
|
|
||||||
}
|
|
||||||
/* I'm taking this off. We'll reply from the NetworkProvider
|
|
||||||
uint8_t GSM3MobileMockupProvider::getStatus(uint8_t socket)
|
|
||||||
{
|
|
||||||
if((socket>=minSocket())&&(socket<=maxSocket()))
|
|
||||||
return 1;
|
|
||||||
else
|
|
||||||
return 0;
|
|
||||||
};
|
|
||||||
*/
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::readSocket(uint8_t *buf, size_t size, int idsocket)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
int l=strlen(msgExample);
|
|
||||||
for(i=0;(i<size)&&(i<l);i++)
|
|
||||||
buf[i]=msgExample[i];
|
|
||||||
buf[i]=0;
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::availableSocket(int idsocket)
|
|
||||||
{
|
|
||||||
return 1;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::readSocket(int idsocket, bool advance)
|
|
||||||
{
|
|
||||||
char c;
|
|
||||||
if(msgExample[msgIndex]==0)
|
|
||||||
{
|
|
||||||
msgIndex=0;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
c=msgExample[msgIndex];
|
|
||||||
if(advance)
|
|
||||||
msgIndex++;
|
|
||||||
};
|
|
||||||
return c;
|
|
||||||
};
|
|
||||||
|
|
||||||
void GSM3MobileMockupProvider::flushSocket(int idsocket)
|
|
||||||
{
|
|
||||||
while(readSocket(idsocket));
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::disconnectTCP(int idsocket)
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::disconnectTCP()");
|
|
||||||
return 1;
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3MobileMockupProvider::connectTCPServer(int port, char* localIP, int* localIPlength)
|
|
||||||
{
|
|
||||||
Serial.println("GSM3MobileMockupProvider::connectTCPServer()");
|
|
||||||
if((localIP!=0)&&(*localIPlength>12))
|
|
||||||
strcpy("192.168.1.1", localIP);
|
|
||||||
return 1;
|
|
||||||
};
|
|
||||||
|
|
||||||
bool GSM3MobileMockupProvider::getSocketModemStatus(uint8_t s)
|
|
||||||
{
|
|
||||||
// Feeling lazy
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,255 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILEMOCKUPPROVIDER_
|
|
||||||
#define _GSM3MOBILEMOCKUPPROVIDER_
|
|
||||||
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
#include <GSM3MobileVoiceProvider.h>
|
|
||||||
|
|
||||||
class GSM3MobileMockupProvider: public GSM3MobileNetworkProvider
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
// Introducing this status is quite "heavy". But something like this should
|
|
||||||
// be added to ShieldV1. Or not.
|
|
||||||
// Note, in ShieldV1 there is no "RECEIVINGSMS" status.
|
|
||||||
enum GSM3_modemlinest_e { IDLE, WAITINGANSWER, SENDINGSMS};
|
|
||||||
GSM3_modemlinest_e lineStatus;
|
|
||||||
char* msgExample;
|
|
||||||
int msgIndex;
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Minimum socket
|
|
||||||
@return 1
|
|
||||||
*/
|
|
||||||
inline int minSocket(){return 1;};
|
|
||||||
|
|
||||||
/** Maximum socket
|
|
||||||
@return 8
|
|
||||||
*/
|
|
||||||
inline int maxSocket(){return 8;};
|
|
||||||
|
|
||||||
/** Constructor */
|
|
||||||
GSM3MobileMockupProvider();
|
|
||||||
|
|
||||||
/** Get network status
|
|
||||||
@return network status
|
|
||||||
*/
|
|
||||||
inline GSM3_NetworkStatus_t getStatus(){return ERROR;};
|
|
||||||
|
|
||||||
/** Get voice call status
|
|
||||||
@return call status
|
|
||||||
*/
|
|
||||||
inline GSM3_voiceCall_st getvoiceCallStatus(){return IDLE_CALL;};
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return Returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
int ready();
|
|
||||||
inline void closeCommand(int code){};
|
|
||||||
|
|
||||||
//Configuration functions.
|
|
||||||
|
|
||||||
/** Begin connection
|
|
||||||
@param pin PIN code
|
|
||||||
@return
|
|
||||||
*/
|
|
||||||
int begin(char* pin=0);
|
|
||||||
|
|
||||||
/** Check if is modem alive
|
|
||||||
@return 0
|
|
||||||
*/
|
|
||||||
inline int isModemAlive(){return 0;};
|
|
||||||
|
|
||||||
/** Shutdown the modem (power off really)
|
|
||||||
@return true if successful
|
|
||||||
*/
|
|
||||||
inline bool shutdown(){return false;};
|
|
||||||
|
|
||||||
//Call functions
|
|
||||||
|
|
||||||
/** Launch a voice call
|
|
||||||
@param number Phone number to be called
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
inline int voiceCall(const char* number){return 0;};
|
|
||||||
|
|
||||||
/** Answer a voice call
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
inline int answerCall(){return 0;};
|
|
||||||
|
|
||||||
/** Hang a voice call
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
inline int hangCall(){return 0;};
|
|
||||||
|
|
||||||
/** Retrieve phone number of caller
|
|
||||||
@param buffer Buffer for copy phone number
|
|
||||||
@param bufsize Buffer size
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
inline int retrieveCallingNumber(char* buffer, int*& bufsize){return 0;};
|
|
||||||
|
|
||||||
// SMS functions
|
|
||||||
|
|
||||||
/** Begin a SMS to send it
|
|
||||||
@param number Destination
|
|
||||||
@return error command if it exists
|
|
||||||
*/
|
|
||||||
int beginSMS(const char* number);
|
|
||||||
|
|
||||||
/** End SMS
|
|
||||||
@return error command if it exists
|
|
||||||
*/
|
|
||||||
int endSMS();
|
|
||||||
|
|
||||||
/** Check if SMS available and prepare it to be read
|
|
||||||
@return error command if it exists
|
|
||||||
*/
|
|
||||||
int availableSMS();
|
|
||||||
|
|
||||||
/** Read a byte but do not advance the buffer header (circular buffer)
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
int peek();
|
|
||||||
|
|
||||||
/** Delete the SMS from Modem memory and proccess answer
|
|
||||||
*/
|
|
||||||
void flushSMS();
|
|
||||||
|
|
||||||
/** Read sender number phone
|
|
||||||
@param number Buffer for save number phone
|
|
||||||
@param nlength Buffer length
|
|
||||||
@return 1 success, >1 error
|
|
||||||
*/
|
|
||||||
int remoteSMSNumber(char* number, int nlength);
|
|
||||||
|
|
||||||
/** Read one char for SMS buffer (advance circular buffer)
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
int readSMS();
|
|
||||||
|
|
||||||
/** Write a SMS character by character
|
|
||||||
@param c Character
|
|
||||||
*/
|
|
||||||
void writeSMS(char c);
|
|
||||||
|
|
||||||
// Socket functions
|
|
||||||
|
|
||||||
/** Connect to a remote TCP server
|
|
||||||
@param server String with IP or server name
|
|
||||||
@param port Remote port number
|
|
||||||
@param id_socket Local socket number
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
int connectTCPClient(const char* server, int port, int id_socket);
|
|
||||||
|
|
||||||
// Attention to parameter rewriting in ShieldV1
|
|
||||||
/** Write buffer information into a socket
|
|
||||||
@param buf Buffer
|
|
||||||
@param size Buffer size
|
|
||||||
@param idsocket Socket
|
|
||||||
*/
|
|
||||||
void writeSocket(const uint8_t *buf, size_t size, int idsocket);
|
|
||||||
|
|
||||||
// ShieldV1 will have two reading mechanisms:
|
|
||||||
// Mechanism 1: Call AT+QIRD for size bytes. Put them in the circular buffer,
|
|
||||||
// fill buf. Take care to xon/xoff effect, as we may copy just a part of the
|
|
||||||
// incoming bytes.
|
|
||||||
/** Read socket and put information in a buffer
|
|
||||||
@param buf Buffer
|
|
||||||
@param size Buffer size
|
|
||||||
@param idsocket Socket
|
|
||||||
@return
|
|
||||||
*/
|
|
||||||
int readSocket(uint8_t *buf, size_t size, int idsocket);
|
|
||||||
|
|
||||||
// Mechanism 2 in ShieldV1:
|
|
||||||
// When called "available()" or "read()" reuse readSocket code to execute
|
|
||||||
// QIRD SYNCHRONOUSLY. Ask the modem for 1500 bytes but do not copy them anywhere,
|
|
||||||
// leave data in the circular buffer. Put buffer head at the start of received data.
|
|
||||||
// Peek() will get a character but will not advance the buffer head.
|
|
||||||
// Read() will get one character. XON/XOFF will take care of buffer filling
|
|
||||||
// If Read() gets to the end of the QIRD response, execute again QIRD SYNCHRONOUSLY
|
|
||||||
// If the user executes flush(), execute read() until there is nothing more to read()
|
|
||||||
// (the modem gives no way to empty the socket of incoming data)
|
|
||||||
|
|
||||||
/** Check if there are data to be read in socket.
|
|
||||||
@param idsocket Local socket number
|
|
||||||
@return 0 if command running, 1 if there are data available, 4 if no data, otherwise error
|
|
||||||
*/
|
|
||||||
int availableSocket(int idsocket);
|
|
||||||
|
|
||||||
/** Read data (get a character) available in socket
|
|
||||||
@param idsocket Socket
|
|
||||||
@param advance Determines if advance the buffer head
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
int readSocket(int idsocket, bool advance=true);
|
|
||||||
|
|
||||||
/** Flush socket
|
|
||||||
@param idsocket Socket
|
|
||||||
*/
|
|
||||||
void flushSocket(int idsocket);
|
|
||||||
|
|
||||||
// This is the same in ShieldV1
|
|
||||||
/** Close a socket
|
|
||||||
@param idsocket Socket
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
int disconnectTCP(int idsocket);
|
|
||||||
|
|
||||||
// TCP Server. Attention. Changing the int*&. We'll receive a buffer for the IP
|
|
||||||
// If the pointer ins NULL just forget it
|
|
||||||
// I think that opening a server does not occupy a socket. Is that true?
|
|
||||||
/** Establish a TCP connection
|
|
||||||
@param port Port
|
|
||||||
@param localIP IP address
|
|
||||||
@param localIPlength IP address size in characters
|
|
||||||
@return command error if exists
|
|
||||||
*/
|
|
||||||
int connectTCPServer(int port, char* localIP, int* localIPlength);
|
|
||||||
|
|
||||||
// Modem sockets status. Return TRUE if the modem thinks the socket is occupied.
|
|
||||||
// This should be detected through an unrequisited response
|
|
||||||
/** Get modem status
|
|
||||||
@param s Socket
|
|
||||||
@return modem status (true if connected)
|
|
||||||
*/
|
|
||||||
bool getSocketModemStatus(uint8_t s);
|
|
||||||
|
|
||||||
|
|
||||||
};
|
|
||||||
#endif
|
|
|
@ -1,72 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
#include <HardwareSerial.h>
|
|
||||||
|
|
||||||
GSM3MobileNetworkProvider* theProvider;
|
|
||||||
|
|
||||||
GSM3MobileNetworkProvider::GSM3MobileNetworkProvider()
|
|
||||||
{
|
|
||||||
socketsAsServer=0x0000;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
int GSM3MobileNetworkProvider::getNewOccupiedSocketAsServer()
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
for(i=minSocketAsServer(); i<=maxSocketAsServer(); i++)
|
|
||||||
{
|
|
||||||
if ((!(socketsAsServer&(0x0001<<i))) && getSocketAsServerModemStatus(i))
|
|
||||||
{
|
|
||||||
socketsAsServer|=((0x0001)<<i);
|
|
||||||
//Serial.print("New occupied=");Serial.println(i);
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//Serial.println("No new occupied");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
bool GSM3MobileNetworkProvider::getStatusSocketAsServer(uint8_t socket)
|
|
||||||
{
|
|
||||||
if(socketsAsServer&(0x0001<<socket))
|
|
||||||
return 1;
|
|
||||||
else
|
|
||||||
return 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -1,136 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILENETWORKPROVIDER_
|
|
||||||
#define _GSM3MOBILENETWORKPROVIDER_
|
|
||||||
|
|
||||||
#include <GSM3MobileAccessProvider.h>
|
|
||||||
#include <inttypes.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
#include <IPAddress.h>
|
|
||||||
|
|
||||||
class GSM3MobileNetworkProvider
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
|
|
||||||
/** Restart hardware
|
|
||||||
@return 1 if successful
|
|
||||||
*/
|
|
||||||
int HWrestart();
|
|
||||||
|
|
||||||
uint16_t socketsAsServer; // Server socket
|
|
||||||
|
|
||||||
/** Get modem status
|
|
||||||
@param s Socket
|
|
||||||
@return modem status (true if connected)
|
|
||||||
*/
|
|
||||||
virtual inline bool getSocketAsServerModemStatus(int s){return false;};
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** minSocketAsServer
|
|
||||||
@return 0
|
|
||||||
*/
|
|
||||||
virtual inline int minSocketAsServer(){return 0;};
|
|
||||||
|
|
||||||
/** maxSocketAsServer
|
|
||||||
@return 0
|
|
||||||
*/
|
|
||||||
virtual inline int maxSocketAsServer(){return 0;};
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
|
|
||||||
/** Constructor */
|
|
||||||
GSM3MobileNetworkProvider();
|
|
||||||
|
|
||||||
/** Get network status
|
|
||||||
@return network status
|
|
||||||
*/
|
|
||||||
virtual inline GSM3_NetworkStatus_t getStatus(){return ERROR;};
|
|
||||||
|
|
||||||
/** Get socket client status
|
|
||||||
@param socket Socket
|
|
||||||
@return 1 if connected, 0 otherwise
|
|
||||||
*/
|
|
||||||
bool getStatusSocketClient(uint8_t socket);
|
|
||||||
|
|
||||||
/** Close a AT command
|
|
||||||
@param code Close code
|
|
||||||
*/
|
|
||||||
virtual inline void closeCommand(int code){};
|
|
||||||
|
|
||||||
/** Establish a TCP connection
|
|
||||||
@param port Port
|
|
||||||
@param localIP IP address
|
|
||||||
@param localIPlength IP address size in characters
|
|
||||||
@return command error if exists
|
|
||||||
*/
|
|
||||||
virtual inline int connectTCPServer(int port, char* localIP, int localIPlength){return 0;};
|
|
||||||
|
|
||||||
/** Get local IP address
|
|
||||||
@param LocalIP Buffer for save IP address
|
|
||||||
@param LocalIPlength Buffer size
|
|
||||||
*/
|
|
||||||
virtual inline int getIP(char* LocalIP, int LocalIPlength){return 0;};
|
|
||||||
|
|
||||||
/** Get new occupied socket
|
|
||||||
@return -1 if no new socket has been occupied
|
|
||||||
*/
|
|
||||||
int getNewOccupiedSocketAsServer();
|
|
||||||
|
|
||||||
/** Get socket status as server
|
|
||||||
@param socket Socket to get status
|
|
||||||
@return socket status
|
|
||||||
*/
|
|
||||||
bool getStatusSocketAsServer(uint8_t socket);
|
|
||||||
|
|
||||||
/** Close a socket
|
|
||||||
@param client1Server0 1 if modem acts as client, 0 if acts as server
|
|
||||||
@param id_socket Local socket number
|
|
||||||
@return 0 if command running, 1 if success, otherwise error
|
|
||||||
*/
|
|
||||||
int disconnectTCP(bool client1Server0, int idsocket){return 1;};
|
|
||||||
|
|
||||||
/** Release socket
|
|
||||||
@param socket Socket
|
|
||||||
*/
|
|
||||||
void releaseSocket(int socket){};
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileNetworkProvider* theProvider;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,51 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include <GSM3MobileNetworkRegistry.h>
|
|
||||||
|
|
||||||
GSM3MobileNetworkRegistry::GSM3MobileNetworkRegistry()
|
|
||||||
{
|
|
||||||
theProvider=0;
|
|
||||||
};
|
|
||||||
|
|
||||||
void GSM3MobileNetworkRegistry::registerMobileNetworkProvider(GSM3MobileNetworkProvider* provider)
|
|
||||||
{
|
|
||||||
theProvider=provider;
|
|
||||||
}
|
|
||||||
|
|
||||||
GSM3MobileNetworkProvider* GSM3MobileNetworkRegistry::getMobileNetworkProvider()
|
|
||||||
{
|
|
||||||
return theProvider;
|
|
||||||
}
|
|
||||||
|
|
||||||
GSM3MobileNetworkRegistry theMobileNetworkRegistry;
|
|
|
@ -1,63 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILENETWORKREGISTRY_
|
|
||||||
#define _GSM3MOBILENETWORKREGISTRY_
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
|
|
||||||
class GSM3MobileNetworkRegistry
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
|
|
||||||
GSM3MobileNetworkProvider* theProvider; // Network provider
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Constructor */
|
|
||||||
GSM3MobileNetworkRegistry();
|
|
||||||
|
|
||||||
/** Register in mobile network provider
|
|
||||||
@param provider Provider
|
|
||||||
*/
|
|
||||||
void registerMobileNetworkProvider(GSM3MobileNetworkProvider* provider);
|
|
||||||
|
|
||||||
/** Returns network provider object pointer
|
|
||||||
@return mobile network provider
|
|
||||||
*/
|
|
||||||
GSM3MobileNetworkProvider* getMobileNetworkProvider();
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileNetworkRegistry theMobileNetworkRegistry;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,3 +0,0 @@
|
||||||
#include <GSM3MobileSMSProvider.h>
|
|
||||||
|
|
||||||
GSM3MobileSMSProvider* theGSM3SMSProvider;
|
|
|
@ -1,91 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILESMSPROVIDER_
|
|
||||||
#define _GSM3MOBILESMSPROVIDER_
|
|
||||||
|
|
||||||
class GSM3MobileSMSProvider
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Begin a SMS to send it
|
|
||||||
@param to Destination
|
|
||||||
@return error command if it exists
|
|
||||||
*/
|
|
||||||
virtual inline int beginSMS(const char* to){return 0;};
|
|
||||||
|
|
||||||
/** Write a SMS character by character
|
|
||||||
@param c Character
|
|
||||||
*/
|
|
||||||
virtual inline void writeSMS(const char c){};
|
|
||||||
|
|
||||||
/** End SMS
|
|
||||||
@return error command if it exists
|
|
||||||
*/
|
|
||||||
virtual inline int endSMS(){return 0;};
|
|
||||||
|
|
||||||
/** Check if SMS available and prepare it to be read
|
|
||||||
@return number of bytes in a received SMS
|
|
||||||
*/
|
|
||||||
virtual inline int availableSMS(){return 0;};
|
|
||||||
|
|
||||||
/** Read a byte but do not advance the buffer header (circular buffer)
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
virtual inline int peekSMS(){return 0;};
|
|
||||||
|
|
||||||
/** Delete the SMS from Modem memory and proccess answer
|
|
||||||
*/
|
|
||||||
virtual inline void flushSMS(){return;};
|
|
||||||
|
|
||||||
/** Read sender number phone
|
|
||||||
@param number Buffer for save number phone
|
|
||||||
@param nlength Buffer length
|
|
||||||
@return 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual inline int remoteSMSNumber(char* number, int nlength){return 0;};
|
|
||||||
|
|
||||||
/** Read one char for SMS buffer (advance circular buffer)
|
|
||||||
@return character
|
|
||||||
*/
|
|
||||||
virtual inline int readSMS(){return 0;};
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileSMSProvider* theGSM3SMSProvider;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,5 +0,0 @@
|
||||||
#include <GSM3MobileServerProvider.h>
|
|
||||||
|
|
||||||
GSM3MobileServerProvider* theGSM3MobileServerProvider;
|
|
||||||
|
|
||||||
|
|
|
@ -1,95 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef __GSM3_MOBILESERVERPROVIDER__
|
|
||||||
#define __GSM3_MOBILESERVERPROVIDER__
|
|
||||||
|
|
||||||
|
|
||||||
#include <GSM3MobileAccessProvider.h>
|
|
||||||
#include <inttypes.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
|
|
||||||
class GSM3MobileServerProvider
|
|
||||||
{
|
|
||||||
/** Get socket status
|
|
||||||
@param s Socket
|
|
||||||
@return modem status (true if connected)
|
|
||||||
*/
|
|
||||||
virtual bool getSocketAsServerModemStatus(int s)=0;
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** minSocketAsServer
|
|
||||||
@return socket
|
|
||||||
*/
|
|
||||||
virtual int minSocketAsServer()=0;
|
|
||||||
|
|
||||||
/** maxSocketAsServer
|
|
||||||
@return socket
|
|
||||||
*/
|
|
||||||
virtual int maxSocketAsServer()=0;
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
|
|
||||||
/** Constructor */
|
|
||||||
GSM3MobileServerProvider(){};
|
|
||||||
|
|
||||||
/** Connect server to TCP port
|
|
||||||
@param port TCP port
|
|
||||||
@return command error if exists
|
|
||||||
*/
|
|
||||||
virtual int connectTCPServer(int port)=0;
|
|
||||||
//virtual int getIP(char* LocalIP, int LocalIPlength)=0;
|
|
||||||
|
|
||||||
/** Get new occupied socket as server
|
|
||||||
@return return -1 if no new socket has been occupied
|
|
||||||
*/
|
|
||||||
virtual int getNewOccupiedSocketAsServer()=0;
|
|
||||||
|
|
||||||
/** Get socket status
|
|
||||||
@param socket Socket
|
|
||||||
@return socket status (true if connected)
|
|
||||||
*/
|
|
||||||
virtual bool getStatusSocketAsServer(uint8_t socket)=0;
|
|
||||||
|
|
||||||
// virtual int disconnectTCP(bool client1Server0, int idsocket)=0;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileServerProvider* theGSM3MobileServerProvider;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,159 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include <GSM3MobileServerService.h>
|
|
||||||
#include <GSM3MobileServerProvider.h>
|
|
||||||
#include <GSM3MobileClientProvider.h>
|
|
||||||
|
|
||||||
|
|
||||||
#define __TOUTSERVER__ 10000
|
|
||||||
#define BUFFERSIZETWEET 100
|
|
||||||
|
|
||||||
#define GSM3MOBILESERVERSERVICE_SYNCH 0x01 // 1: TRUE, compatible with other clients 0: FALSE
|
|
||||||
|
|
||||||
// While there is only a shield (ShieldV1) we will include it by default
|
|
||||||
#include <GSM3ShieldV1ServerProvider.h>
|
|
||||||
GSM3ShieldV1ServerProvider theShieldV1ServerProvider;
|
|
||||||
|
|
||||||
|
|
||||||
GSM3MobileServerService::GSM3MobileServerService(uint8_t port, bool synch)
|
|
||||||
{
|
|
||||||
mySocket=0;
|
|
||||||
_port=port;
|
|
||||||
flags = 0;
|
|
||||||
|
|
||||||
// If synchronous
|
|
||||||
if(synch)
|
|
||||||
flags |= GSM3MOBILESERVERSERVICE_SYNCH;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns 0 if last command is still executing
|
|
||||||
// 1 if success
|
|
||||||
// >1 if error
|
|
||||||
int GSM3MobileServerService::ready()
|
|
||||||
{
|
|
||||||
return theGSM3MobileServerProvider->ready();
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileServerService::begin()
|
|
||||||
{
|
|
||||||
if(theGSM3MobileServerProvider==0)
|
|
||||||
return;
|
|
||||||
theGSM3MobileServerProvider->connectTCPServer(_port);
|
|
||||||
|
|
||||||
if(flags & GSM3MOBILESERVERSERVICE_SYNCH)
|
|
||||||
waitForAnswer();
|
|
||||||
}
|
|
||||||
|
|
||||||
GSM3MobileClientService GSM3MobileServerService::available(bool synch)
|
|
||||||
{
|
|
||||||
int newSocket;
|
|
||||||
// In case we are debugging, we'll need to force a look at the buffer
|
|
||||||
ready();
|
|
||||||
|
|
||||||
newSocket=theGSM3MobileServerProvider->getNewOccupiedSocketAsServer();
|
|
||||||
|
|
||||||
// Instatiate new client. If we are synch, the client is synchronous/blocking
|
|
||||||
GSM3MobileClientService client((uint8_t)(newSocket), (flags & GSM3MOBILESERVERSERVICE_SYNCH));
|
|
||||||
|
|
||||||
return client;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t GSM3MobileServerService::write(uint8_t c)
|
|
||||||
{
|
|
||||||
// Adapt to the new, lean implementation
|
|
||||||
// theGSM3MobileServerProvider->writeSocket(c);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileServerService::beginWrite()
|
|
||||||
{
|
|
||||||
// Adapt to the new, lean implementation
|
|
||||||
// theGSM3MobileServerProvider->beginWriteSocket(local1Remote0, mySocket);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t GSM3MobileServerService::write(const uint8_t* buf)
|
|
||||||
{
|
|
||||||
// Adapt to the new, lean implementation
|
|
||||||
// theGSM3MobileServerProvider->writeSocket((const char*)(buf));
|
|
||||||
return strlen((const char*)buf);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t GSM3MobileServerService::write(const uint8_t* buf, size_t sz)
|
|
||||||
{
|
|
||||||
// Adapt to the new, lean implementation
|
|
||||||
// theGSM3MobileServerProvider->writeSocket((const char*)(buf));
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileServerService::endWrite()
|
|
||||||
{
|
|
||||||
// Adapt to the new, lean implementation
|
|
||||||
// theGSM3MobileServerProvider->endWriteSocket();
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3MobileServerService::stop()
|
|
||||||
{
|
|
||||||
|
|
||||||
// Review, should be the server?
|
|
||||||
theGSM3MobileClientProvider->disconnectTCP(local1Remote0, mySocket);
|
|
||||||
if(flags & GSM3MOBILESERVERSERVICE_SYNCH)
|
|
||||||
waitForAnswer();
|
|
||||||
theGSM3MobileClientProvider->releaseSocket(mySocket);
|
|
||||||
mySocket = -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*int GSM3MobileServerService::getIP(char* LocalIP, int LocalIPlength)
|
|
||||||
{
|
|
||||||
return theGSM3MobileServerProvider->getIP(LocalIP, LocalIPlength);
|
|
||||||
}*/
|
|
||||||
|
|
||||||
int GSM3MobileServerService::waitForAnswer()
|
|
||||||
{
|
|
||||||
unsigned long m;
|
|
||||||
m=millis();
|
|
||||||
int res;
|
|
||||||
|
|
||||||
while(((millis()-m)< __TOUTSERVER__ )&&(ready()==0))
|
|
||||||
delay(10);
|
|
||||||
|
|
||||||
res=ready();
|
|
||||||
|
|
||||||
// If we get something different from a 1, we are having a problem
|
|
||||||
if(res!=1)
|
|
||||||
res=0;
|
|
||||||
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,124 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILESERVERSERVICE_
|
|
||||||
#define _GSM3MOBILESERVERSERVICE_
|
|
||||||
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
#include <GSM3MobileClientService.h>
|
|
||||||
#include <Server.h>
|
|
||||||
|
|
||||||
class GSM3MobileServerService : public Server
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
|
|
||||||
uint8_t _port; // Port
|
|
||||||
uint8_t mySocket; // Actual socket
|
|
||||||
uint8_t flags;
|
|
||||||
bool local1Remote0;
|
|
||||||
|
|
||||||
/** Internal utility, used in synchronous calls
|
|
||||||
@return operation result, 1 if success, 0 otherwise
|
|
||||||
*/
|
|
||||||
int waitForAnswer();
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Constructor
|
|
||||||
@param port Port
|
|
||||||
@param synch True if the server acts synchronously
|
|
||||||
*/
|
|
||||||
GSM3MobileServerService(uint8_t port, bool synch=true);
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
int ready();
|
|
||||||
|
|
||||||
/** Initialize server
|
|
||||||
*/
|
|
||||||
void begin();
|
|
||||||
|
|
||||||
/** Check if there is an incoming client request
|
|
||||||
@param synch If true, the returned client is synchronous or
|
|
||||||
blocking.
|
|
||||||
@return Client if successful, else error
|
|
||||||
*/
|
|
||||||
GSM3MobileClientService available(bool synch=true);
|
|
||||||
|
|
||||||
// Just to keep in line with Ethernet.
|
|
||||||
// Write to every open socket...
|
|
||||||
//void write(uint8_t);
|
|
||||||
//void write(const uint8_t *buf, size_t size);
|
|
||||||
|
|
||||||
/** Begin write in socket
|
|
||||||
*/
|
|
||||||
void beginWrite();
|
|
||||||
|
|
||||||
/** Write character in socket
|
|
||||||
@param c Character
|
|
||||||
@return size
|
|
||||||
*/
|
|
||||||
size_t write(uint8_t c);
|
|
||||||
|
|
||||||
/** Write buffer in socket
|
|
||||||
@param buf Buffer
|
|
||||||
@return size
|
|
||||||
*/
|
|
||||||
size_t write(const uint8_t *buf);
|
|
||||||
|
|
||||||
/** Write buffer in socket with size
|
|
||||||
@param buf Buffer
|
|
||||||
@param sz Buffer size
|
|
||||||
@return size
|
|
||||||
*/
|
|
||||||
size_t write(const uint8_t *buf, size_t sz);
|
|
||||||
|
|
||||||
/** End write in socket
|
|
||||||
*/
|
|
||||||
void endWrite();
|
|
||||||
|
|
||||||
/** Stop server
|
|
||||||
*/
|
|
||||||
void stop();
|
|
||||||
|
|
||||||
// we take this function out as IPAddress is complex to bring to
|
|
||||||
// version 1.
|
|
||||||
// inline int connect(IPAddress ip, uint16_t port){return 0;};
|
|
||||||
// Returns 2 if there are no resources
|
|
||||||
//int getIP(char* LocalIP, int LocalIPlength);
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,4 +0,0 @@
|
||||||
#include <GSM3MobileVoiceProvider.h>
|
|
||||||
|
|
||||||
|
|
||||||
GSM3MobileVoiceProvider* theGSM3MobileVoiceProvider;
|
|
|
@ -1,90 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#ifndef _GSM3MOBILEVOICEPROVIDER_
|
|
||||||
#define _GSM3MOBILEVOICEPROVIDER_
|
|
||||||
|
|
||||||
enum GSM3_voiceCall_st { IDLE_CALL, CALLING, RECEIVINGCALL, TALKING};
|
|
||||||
|
|
||||||
class GSM3MobileVoiceProvider
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Initialize the object relating it to the general infrastructure
|
|
||||||
@param
|
|
||||||
@return void
|
|
||||||
*/
|
|
||||||
virtual void initialize(){};
|
|
||||||
|
|
||||||
/** Launch a voice call
|
|
||||||
@param number Phone number to be called
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
virtual int voiceCall(const char* number)=0;
|
|
||||||
|
|
||||||
/** Answer a voice call
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
virtual int answerCall()=0;
|
|
||||||
|
|
||||||
/** Hang a voice call
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
virtual int hangCall()=0;
|
|
||||||
|
|
||||||
/** Retrieve phone number of caller
|
|
||||||
@param buffer Buffer for copy phone number
|
|
||||||
@param bufsize Buffer size
|
|
||||||
@return If asynchronous, returns 0. If synchronous, 1 if success, other if error
|
|
||||||
*/
|
|
||||||
virtual int retrieveCallingNumber(char* buffer, int bufsize)=0;
|
|
||||||
|
|
||||||
/** Returns voice call status
|
|
||||||
@return voice call status
|
|
||||||
*/
|
|
||||||
virtual GSM3_voiceCall_st getvoiceCallStatus()=0;
|
|
||||||
|
|
||||||
/** Set voice call status
|
|
||||||
@param status New status for voice call
|
|
||||||
*/
|
|
||||||
virtual void setvoiceCallStatus(GSM3_voiceCall_st status)=0;
|
|
||||||
|
|
||||||
/** Get last command status
|
|
||||||
@return Returns 0 if last command is still executing, 1 success, >1 error
|
|
||||||
*/
|
|
||||||
virtual int ready()=0;
|
|
||||||
};
|
|
||||||
|
|
||||||
extern GSM3MobileVoiceProvider* theGSM3MobileVoiceProvider;
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,126 +0,0 @@
|
||||||
/*
|
|
||||||
This file is part of the GSM3 communications library for Arduino
|
|
||||||
-- Multi-transport communications platform
|
|
||||||
-- Fully asynchronous
|
|
||||||
-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
|
|
||||||
-- Voice calls
|
|
||||||
-- SMS
|
|
||||||
-- TCP/IP connections
|
|
||||||
-- HTTP basic clients
|
|
||||||
|
|
||||||
This library has been developed by Telefónica Digital - PDI -
|
|
||||||
- Physical Internet Lab, as part as its collaboration with
|
|
||||||
Arduino and the Open Hardware Community.
|
|
||||||
|
|
||||||
September-December 2012
|
|
||||||
|
|
||||||
This library is free software; you can redistribute it and/or
|
|
||||||
modify it under the terms of the GNU Lesser General Public
|
|
||||||
License as published by the Free Software Foundation; either
|
|
||||||
version 2.1 of the License, or (at your option) any later version.
|
|
||||||
|
|
||||||
This library is distributed in the hope that it will be useful,
|
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
Lesser General Public License for more details.
|
|
||||||
|
|
||||||
You should have received a copy of the GNU Lesser General Public
|
|
||||||
License along with this library; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
|
|
||||||
The latest version of this library can always be found at
|
|
||||||
https://github.com/BlueVia/Official-Arduino
|
|
||||||
*/
|
|
||||||
#include <GSM3SMSService.h>
|
|
||||||
#include <GSM3MobileNetworkProvider.h>
|
|
||||||
#include <Arduino.h>
|
|
||||||
|
|
||||||
// While there is only a shield (ShieldV1) we will include it by default
|
|
||||||
#include <GSM3ShieldV1SMSProvider.h>
|
|
||||||
GSM3ShieldV1SMSProvider theShieldV1SMSProvider;
|
|
||||||
|
|
||||||
#define GSM3SMSSERVICE_SYNCH 0x01 // 1: synchronous 0: asynchronous
|
|
||||||
#define __TOUT__ 10000
|
|
||||||
|
|
||||||
|
|
||||||
GSM3SMSService::GSM3SMSService(bool synch)
|
|
||||||
{
|
|
||||||
if(synch)
|
|
||||||
flags |= GSM3SMSSERVICE_SYNCH;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns 0 if last command is still executing
|
|
||||||
// 1 if success
|
|
||||||
// >1 if error
|
|
||||||
int GSM3SMSService::ready()
|
|
||||||
{
|
|
||||||
return theGSM3SMSProvider->ready();
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3SMSService::beginSMS(const char *number)
|
|
||||||
{
|
|
||||||
return waitForAnswerIfNeeded(theGSM3SMSProvider->beginSMS(number));
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3SMSService::endSMS()
|
|
||||||
{
|
|
||||||
return waitForAnswerIfNeeded(theGSM3SMSProvider->endSMS());
|
|
||||||
};
|
|
||||||
|
|
||||||
size_t GSM3SMSService::write(uint8_t c)
|
|
||||||
{
|
|
||||||
theGSM3SMSProvider->writeSMS(c);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GSM3SMSService::flush()
|
|
||||||
{
|
|
||||||
theGSM3SMSProvider->flushSMS();
|
|
||||||
waitForAnswerIfNeeded(1);
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3SMSService::available()
|
|
||||||
{
|
|
||||||
return waitForAnswerIfNeeded(theGSM3SMSProvider->availableSMS());
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3SMSService::remoteNumber(char* number, int nlength)
|
|
||||||
{
|
|
||||||
return theGSM3SMSProvider->remoteSMSNumber(number, nlength);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
int GSM3SMSService::read()
|
|
||||||
{
|
|
||||||
return theGSM3SMSProvider->readSMS();
|
|
||||||
};
|
|
||||||
int GSM3SMSService::peek()
|
|
||||||
{
|
|
||||||
return theGSM3SMSProvider->peekSMS();
|
|
||||||
};
|
|
||||||
|
|
||||||
int GSM3SMSService::waitForAnswerIfNeeded(int returnvalue)
|
|
||||||
{
|
|
||||||
// If synchronous
|
|
||||||
if(flags & GSM3SMSSERVICE_SYNCH )
|
|
||||||
{
|
|
||||||
unsigned long m;
|
|
||||||
m=millis();
|
|
||||||
// Wait for __TOUT__
|
|
||||||
while(((millis()-m)< __TOUT__ )&&(ready()==0))
|
|
||||||
delay(100);
|
|
||||||
// If everything was OK, return 1
|
|
||||||
// else (timeout or error codes) return 0;
|
|
||||||
if(ready()==1)
|
|
||||||
return 1;
|
|
||||||
else
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
// If not synchronous just kick ahead the coming result
|
|
||||||
return ready();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue