noisymime
/
Arduino
mirror of https://github.com/noisymime/Arduino.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'new-extension' of github.com:arduino/Arduino into new-extension

This commit is contained in:
David Mellis 2011-09-02 19:58:39 -04:00
parent 85bf4252f0 108df37445
commit 83da177280
171 changed files with 605 additions and 4517 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/src/processing/app/Base.java
View File

@ -1722,6 +1722,10 @@ public class Base {
* Give this Frame a Processing icon.
*/
static public void setIcon(Frame frame) {
// don't use the low-res icon on Mac OS X; the window should
// already have the right icon from the .app file.
if (Base.isMacOS()) return;
Image image = Toolkit.getDefaultToolkit().createImage(PApplet.ICON_IMAGE);
frame.setIconImage(image);
}

15
app/src/processing/app/syntax/JEditTextArea.java
View File

@ -17,6 +17,7 @@ import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.undo.*;
import javax.swing.*;
import java.awt.datatransfer.*;
import java.awt.event.*;
import java.awt.*;
@ -2025,7 +2026,19 @@ public class JEditTextArea extends JComponent
select(getMarkPosition(),xyToOffset(evt.getX(),evt.getY()));
}
public void mouseMoved(MouseEvent evt) {}
final Cursor normalCursor = new Cursor(Cursor.DEFAULT_CURSOR);
final Cursor handCursor = new Cursor(Cursor.HAND_CURSOR);
public void mouseMoved(MouseEvent evt) {
int line = yToLine(evt.getY());
int offset = xToOffset(line, evt.getX());
boolean wantHandCursor = checkClickedURL(getLineText(line), offset) != null;
JComponent src = (JComponent) evt.getSource();
if (wantHandCursor)
src.setCursor(handCursor);
else
src.setCursor(normalCursor);
}
}
class FocusHandler implements FocusListener

4
build/build.xml
View File

@ -228,9 +228,7 @@
</exec>
<copy todir="macosx/working_dir">
<fileset dir="macosx/work">
<exclude name="**/ArduinoTestSuite/**" />
</fileset>
<fileset dir="macosx/work" />
</copy>
<!-- The ant copy command does not preserve permissions. -->

2
build/shared/examples/1.Basics/AnalogReadSerial/AnalogReadSerial.pde → build/shared/examples/1.Basics/AnalogReadSerial/AnalogReadSerial.ino
View File

@ -11,5 +11,5 @@ void setup() {
void loop() {
int sensorValue = analogRead(A0);
Serial.println(sensorValue, DEC);
Serial.println(sensorValue);
}

0
build/shared/examples/1.Basics/BareMinimum/BareMinimum.pde → build/shared/examples/1.Basics/BareMinimum/BareMinimum.ino
View File

0
build/shared/examples/1.Basics/Blink/Blink.pde → build/shared/examples/1.Basics/Blink/Blink.ino
View File

2
build/shared/examples/1.Basics/DigitalReadSerial/DigitalReadSerial.pde → build/shared/examples/1.Basics/DigitalReadSerial/DigitalReadSerial.ino
View File

@ -12,7 +12,7 @@ void setup() {
void loop() {
int sensorValue = digitalRead(2);
Serial.println(sensorValue, DEC);
Serial.println(sensorValue);
}

0
build/shared/examples/1.Basics/Fade/Fade.pde → build/shared/examples/1.Basics/Fade/Fade.ino
View File

0
build/shared/examples/2.Digital/BlinkWithoutDelay/BlinkWithoutDelay.pde → build/shared/examples/2.Digital/BlinkWithoutDelay/BlinkWithoutDelay.ino
View File

2
build/shared/examples/2.Digital/Button/Button.pde → build/shared/examples/2.Digital/Button/Button.ino
View File

@ -16,7 +16,7 @@
created 2005
by DojoDave <http://www.0j0.org>
modified 28 Oct 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/2.Digital/Debounce/Debounce.pde → build/shared/examples/2.Digital/Debounce/Debounce.ino
View File

@ -17,7 +17,7 @@
created 21 November 2006
by David A. Mellis
modified 3 Jul 2009
modified 30 Aug 2011
by Limor Fried
This example code is in the public domain.

4
build/shared/examples/2.Digital/StateChangeDetection/StateChangeDetection.pde → build/shared/examples/2.Digital/StateChangeDetection/StateChangeDetection.ino
View File

@ -16,7 +16,7 @@
most Arduino boards)
created 27 Sep 2005
modified 14 Oct 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.
@ -57,7 +57,7 @@ void loop() {
buttonPushCounter++;
Serial.println("on");
Serial.print("number of button pushes: ");
Serial.println(buttonPushCounter, DEC);
Serial.println(buttonPushCounter);
}
else {
// if the current state is LOW then the button

2
build/shared/examples/2.Digital/toneKeyboard/toneKeyboard.pde → build/shared/examples/2.Digital/toneKeyboard/toneKeyboard.ino
View File

@ -9,7 +9,7 @@
* 8-ohm speaker on digital pin 8
created 21 Jan 2010
Modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/2.Digital/toneMelody/toneMelody.pde → build/shared/examples/2.Digital/toneMelody/toneMelody.ino
View File

@ -7,7 +7,7 @@
* 8-ohm speaker on digital pin 8
created 21 Jan 2010
modified 14 Oct 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

0
build/shared/examples/2.Digital/toneMultiple/toneMultiple.pde → build/shared/examples/2.Digital/toneMultiple/toneMultiple.ino
View File

2
build/shared/examples/2.Digital/tonePitchFollower/tonePitchFollower.pde → build/shared/examples/2.Digital/tonePitchFollower/tonePitchFollower.ino
View File

@ -9,7 +9,7 @@
* 4.7K resistor on analog 0 to ground
created 21 Jan 2010
Modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/3.Analog/AnalogInOutSerial/AnalogInOutSerial.pde → build/shared/examples/3.Analog/AnalogInOutSerial/AnalogInOutSerial.ino
View File

@ -12,7 +12,7 @@
* LED connected from digital pin 9 to ground
created 29 Dec. 2008
Modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/3.Analog/AnalogInput/AnalogInput.pde → build/shared/examples/3.Analog/AnalogInput/AnalogInput.ino
View File

@ -18,7 +18,7 @@
Created by David Cuartielles
Modified 4 Sep 2010
modified 30 Aug 2011
By Tom Igoe
This example code is in the public domain.

0
build/shared/examples/3.Analog/AnalogWriteMega/AnalogWriteMega.pde → build/shared/examples/3.Analog/AnalogWriteMega/AnalogWriteMega.ino
View File

2
build/shared/examples/3.Analog/Calibration/Calibration.pde → build/shared/examples/3.Analog/Calibration/Calibration.ino
View File

@ -17,7 +17,7 @@
created 29 Oct 2008
By David A Mellis
Modified 4 Sep 2010
modified 30 Aug 2011
By Tom Igoe
http://arduino.cc/en/Tutorial/Calibration

2
build/shared/examples/3.Analog/Fading/Fading.pde → build/shared/examples/3.Analog/Fading/Fading.ino
View File

@ -8,7 +8,7 @@
Created 1 Nov 2008
By David A. Mellis
Modified 17 June 2009
modified 30 Aug 2011
By Tom Igoe
http://arduino.cc/en/Tutorial/Fading

5
build/shared/examples/3.Analog/Smoothing/Smoothing.pde → build/shared/examples/3.Analog/Smoothing/Smoothing.ino
View File

@ -10,6 +10,7 @@
* Analog sensor (potentiometer will do) attached to analog input 0
Created 22 April 2007
modified 30 Aug 2011
By David A. Mellis <dam@mellis.org>
http://www.arduino.cc/en/Tutorial/Smoothing
@ -59,8 +60,8 @@ void loop() {
// calculate the average:
average = total / numReadings;
// send it to the computer (as ASCII digits)
Serial.println(average, DEC);
// send it to the computer as ASCII digits
Serial.println(average);
}

2
build/shared/examples/4.Communication/ASCIITable/ASCIITable.pde → build/shared/examples/4.Communication/ASCIITable/ASCIITable.ino
View File

@ -11,7 +11,7 @@
created 2006
by Nicholas Zambetti
modified 18 Jan 2009
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/4.Communication/Dimmer/Dimmer.pde → build/shared/examples/4.Communication/Dimmer/Dimmer.ino
View File

@ -12,7 +12,7 @@
created 2006
by David A. Mellis
modified 14 Apr 2009
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald
This example code is in the public domain.

2
build/shared/examples/4.Communication/Graph/Graph.pde → build/shared/examples/4.Communication/Graph/Graph.ino
View File

@ -18,7 +18,7 @@
created 2006
by David A. Mellis
modified 14 Apr 2009
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald
This example code is in the public domain.

2
build/shared/examples/4.Communication/MIDI/Midi.pde → build/shared/examples/4.Communication/MIDI/Midi.ino
View File

@ -13,7 +13,7 @@
Attach a MIDI cable to the jack, then to a MIDI synth, and play music.
created 13 Jun 2006
modified 2 Jul 2009
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

0
build/shared/examples/4.Communication/MultiSerialMega/MultiSerialMega.pde → build/shared/examples/4.Communication/MultiSerialMega/MultiSerialMega.ino
View File

4
build/shared/examples/4.Communication/PhysicalPixel/PhysicalPixel.pde → build/shared/examples/4.Communication/PhysicalPixel/PhysicalPixel.ino
View File

@ -15,7 +15,7 @@
created 2006
by David A. Mellis
modified 14 Apr 2009
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald
This example code is in the public domain.
@ -59,7 +59,7 @@ void loop() {
// created 2003-4
// based on examples by Casey Reas and Hernando Barragan
// modified 18 Jan 2009
// modified 30 Aug 2011
// by Tom Igoe
// This example code is in the public domain.

2
build/shared/examples/4.Communication/SerialCallResponse/SerialCallResponse.pde → build/shared/examples/4.Communication/SerialCallResponse/SerialCallResponse.ino
View File

@ -15,7 +15,7 @@
Created 26 Sept. 2005
by Tom Igoe
Modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald
This example code is in the public domain.

10
build/shared/examples/4.Communication/SerialCallResponseASCII/SerialCallResponseASCII.pde → build/shared/examples/4.Communication/SerialCallResponseASCII/SerialCallResponseASCII.ino
View File

@ -19,7 +19,7 @@
Created 26 Sept. 2005
by Tom Igoe
Modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald
This example code is in the public domain.
@ -52,15 +52,15 @@ void loop()
// delay 10ms to let the ADC recover:
delay(10);
// read second analog input, divide by 4 to make the range 0-255:
secondSensor = analogRead(1)/4;
secondSensor = analogRead(A1)/4;
// read switch, map it to 0 or 255L
thirdSensor = map(digitalRead(2), 0, 1, 0, 255);
// send sensor values:
Serial.print(firstSensor, DEC);
Serial.print(firstSensor);
Serial.print(",");
Serial.print(secondSensor, DEC);
Serial.print(secondSensor);
Serial.print(",");
Serial.println(thirdSensor, DEC);
Serial.println(thirdSensor);
}
}

27
build/shared/examples/4.Communication/SerialEvent/SerialEvent.ino
View File

@ -38,20 +38,23 @@ void loop() {
}
/*
SerialEvent occurs whenever a new byte comes in the
hardware serial RX. Don't do complex things here, as the
processor halts the regular program to run this routine:
SerialEvent occurs whenever a new data comes in the
hardware serial RX. This routine is run between each
time loop() runs, so using delay inside loop can delay
response. Multiple bytes of data may be available.
*/
void serialEvent() {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
while (Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
}
}

2
build/shared/examples/4.Communication/VirtualColorMixer/VirtualColorMixer.pde → build/shared/examples/4.Communication/VirtualColorMixer/VirtualColorMixer.ino
View File

@ -10,7 +10,7 @@
created 2 Dec 2006
by David A. Mellis
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald
This example code is in the public domain.

2
build/shared/examples/5.Control/Arrays/Arrays.pde → build/shared/examples/5.Control/Arrays/Arrays.ino
View File

@ -13,7 +13,7 @@
created 2006
by David A. Mellis
modified 5 Jul 2009
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/5.Control/ForLoopIteration/ForLoopIteration.pde → build/shared/examples/5.Control/ForLoopIteration/ForLoopIteration.ino
View File

@ -9,7 +9,7 @@
created 2006
by David A. Mellis
modified 5 Jul 2009
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

4
build/shared/examples/5.Control/IfStatementConditional/IfStatementConditional.pde → build/shared/examples/5.Control/IfStatementConditional/IfStatementConditional.ino
View File

@ -16,7 +16,7 @@
connected to pin 13, so you don't need any extra components for this example.
created 17 Jan 2009
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.
@ -50,7 +50,7 @@ void loop() {
}
// print the analog value:
Serial.println(analogValue, DEC);
Serial.println(analogValue);
}

2
build/shared/examples/5.Control/WhileStatementConditional/WhileStatementConditional.pde → build/shared/examples/5.Control/WhileStatementConditional/WhileStatementConditional.ino
View File

@ -17,7 +17,7 @@
* 10K resistor attached from pin 2 to ground
created 17 Jan 2009
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/5.Control/switchCase/switchCase.pde → build/shared/examples/5.Control/switchCase/switchCase.ino
View File

@ -14,7 +14,7 @@
* 10K resistor from analog in 0 to ground
created 1 Jul 2009
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

0
build/shared/examples/5.Control/switchCase2/switchCase2.pde → build/shared/examples/5.Control/switchCase2/switchCase2.ino
View File

2
build/shared/examples/6.Sensors/ADXL3xx/ADXL3xx.pde → build/shared/examples/6.Sensors/ADXL3xx/ADXL3xx.ino
View File

@ -19,7 +19,7 @@
created 2 Jul 2008
by David A. Mellis
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/6.Sensors/Knock/Knock.pde → build/shared/examples/6.Sensors/Knock/Knock.ino
View File

@ -14,7 +14,7 @@
created 25 Mar 2007
by David Cuartielles <http://www.0j0.org>
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/6.Sensors/Memsic2125/Memsic2125.pde → build/shared/examples/6.Sensors/Memsic2125/Memsic2125.ino
View File

@ -16,7 +16,7 @@
created 6 Nov 2008
by David A. Mellis
modified 30 Jun 2009
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/6.Sensors/Ping/Ping.pde → build/shared/examples/6.Sensors/Ping/Ping.ino
View File

@ -15,7 +15,7 @@
created 3 Nov 2008
by David A. Mellis
modified 30 Jun 2009
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.

2
build/shared/examples/7.Display/RowColumnScanning/RowColumnScanning.pde → build/shared/examples/7.Display/RowColumnScanning/RowColumnScanning.ino
View File

@ -4,7 +4,7 @@
This example controls an 8x8 LED matrix using two analog inputs
created 27 May 2009
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
This example works for the Lumex LDM-24488NI Matrix. See

0
build/shared/examples/7.Display/barGraph/barGraph.pde → build/shared/examples/7.Display/barGraph/barGraph.ino
View File

0
build/shared/examples/8.Strings/CharacterAnalysis/CharacterAnalysis.pde → build/shared/examples/8.Strings/CharacterAnalysis/CharacterAnalysis.ino
View File

2
build/shared/examples/8.Strings/StringAdditionOperator/StringAdditionOperator.pde → build/shared/examples/8.Strings/StringAdditionOperator/StringAdditionOperator.ino
View File

@ -5,7 +5,7 @@
You can also add several different data types to string, as shown here:
created 27 July 2010
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
http://arduino.cc/en/Tutorial/StringAdditionOperator

2
build/shared/examples/8.Strings/StringAppendOperator/StringAppendOperator.pde → build/shared/examples/8.Strings/StringAppendOperator/StringAppendOperator.ino
View File

@ -4,7 +4,7 @@
Examples of how to append different data types to strings
created 27 July 2010
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
http://arduino.cc/en/Tutorial/StringAppendOperator

0
build/shared/examples/8.Strings/StringCaseChanges/StringCaseChanges.pde → build/shared/examples/8.Strings/StringCaseChanges/StringCaseChanges.ino
View File

0
build/shared/examples/8.Strings/StringCharacters/StringCharacters.pde → build/shared/examples/8.Strings/StringCharacters/StringCharacters.ino
View File

2
build/shared/examples/8.Strings/StringComparisonOperators/StringComparisonOperators.pde → build/shared/examples/8.Strings/StringComparisonOperators/StringComparisonOperators.ino
View File

@ -4,7 +4,7 @@
Examples of how to compare strings using the comparison operators
created 27 July 2010
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
http://arduino.cc/en/Tutorial/StringComparisonOperators

2
build/shared/examples/8.Strings/StringConstructors/StringConstructors.pde → build/shared/examples/8.Strings/StringConstructors/StringConstructors.ino
View File

@ -4,7 +4,7 @@
Examples of how to create strings from other data types
created 27 July 2010
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
http://arduino.cc/en/Tutorial/StringConstructors

0
build/shared/examples/8.Strings/StringIndexOf/StringIndexOf.pde → build/shared/examples/8.Strings/StringIndexOf/StringIndexOf.ino
View File

0
build/shared/examples/8.Strings/StringLength/StringLength.pde → build/shared/examples/8.Strings/StringLength/StringLength.ino
View File

0
build/shared/examples/8.Strings/StringLengthTrim/StringLengthTrim.pde → build/shared/examples/8.Strings/StringLengthTrim/StringLengthTrim.ino
View File

0
build/shared/examples/8.Strings/StringReplace/StringReplace.pde → build/shared/examples/8.Strings/StringReplace/StringReplace.ino
View File

2
build/shared/examples/8.Strings/StringStartsWithEndsWith/StringStartsWithEndsWith.pde → build/shared/examples/8.Strings/StringStartsWithEndsWith/StringStartsWithEndsWith.ino
View File

@ -4,7 +4,7 @@
Examples of how to use startsWith() and endsWith() in a String
created 27 July 2010
modified 4 Sep 2010
modified 30 Aug 2011
by Tom Igoe
http://arduino.cc/en/Tutorial/StringStartsWithEndsWith

0
build/shared/examples/8.Strings/StringSubstring/StringSubstring.pde → build/shared/examples/8.Strings/StringSubstring/StringSubstring.ino
View File

0
build/shared/examples/8.Strings/StringToInt/StringToInt.pde → build/shared/examples/8.Strings/StringToInt/StringToInt.ino
View File

0
build/shared/examples/8.Strings/StringToIntRGB/StringToIntRGB.pde → build/shared/examples/8.Strings/StringToIntRGB/StringToIntRGB.ino
View File

0
build/shared/examples/ArduinoISP/ArduinoISP.pde → build/shared/examples/ArduinoISP/ArduinoISP.ino
View File

23
hardware/arduino/boards.txt
View File

@ -102,7 +102,7 @@ nano.build.variant=eightanaloginputs
##############################################################
mega2560.name=Arduino Mega 2560
mega2560.name=Arduino Mega 2560 or Mega ADK
mega2560.upload.protocol=stk500v2
mega2560.upload.maximum_size=258048
@ -165,6 +165,27 @@ mini.build.variant=eightanaloginputs
##############################################################
ethernet.name=Arduino Ethernet
ethernet.upload.protocol=stk500
ethernet.upload.maximum_size=32256
ethernet.upload.speed=115200
ethernet.bootloader.low_fuses=0xff
ethernet.bootloader.high_fuses=0xde
ethernet.bootloader.extended_fuses=0x05
ethernet.bootloader.path=optiboot
ethernet.bootloader.file=optiboot_atmega328.hex
ethernet.bootloader.unlock_bits=0x3F
ethernet.bootloader.lock_bits=0x0F
ethernet.build.variant=standard
ethernet.build.mcu=atmega328p
ethernet.build.f_cpu=16000000L
ethernet.build.core=arduino
##############################################################
fio.name=Arduino Fio
fio.upload.protocol=arduino

27
hardware/arduino/cores/arduino/Client.h Normal file
View File

@ -0,0 +1,27 @@
#ifndef client_h
#define client_h
#include "Print.h"
#include "Stream.h"
#include "IPAddress.h"
class Client : public Stream {
public:
virtual int connect(IPAddress ip, uint16_t port) =0;
virtual int connect(const char *host, uint16_t port) =0;
virtual size_t write(uint8_t) =0;
virtual size_t write(const char *str) =0;
virtual size_t write(const uint8_t *buf, size_t size) =0;
virtual int available() = 0;
virtual int read() = 0;
virtual int read(uint8_t *buf, size_t size) = 0;
virtual int peek() = 0;
virtual void flush() = 0;
virtual void stop() = 0;
virtual uint8_t connected() = 0;
virtual operator bool() = 0;
protected:
uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
};
#endif

53
hardware/arduino/cores/arduino/HardwareSerial.cpp
View File

@ -88,6 +88,8 @@ inline void store_char(unsigned char c, ring_buffer *buffer)
#else
void serialEvent() __attribute__((weak));
void serialEvent() {}
volatile static unsigned char serialEvent_flag = 0;
#define serialEvent_implemented
#if defined(USART_RX_vect)
SIGNAL(USART_RX_vect)
#elif defined(SIG_USART0_RECV)
@ -108,18 +110,20 @@ inline void store_char(unsigned char c, ring_buffer *buffer)
#error UDR not defined
#endif
store_char(c, &rx_buffer);
serialEvent();
serialEvent_flag = 1;
}
#endif
#if defined(USART1_RX_vect)
void serialEvent1() __attribute__((weak));
void serialEvent1() {}
volatile static unsigned char serialEvent1_flag = 0;
#define serialEvent1_implemented
SIGNAL(USART1_RX_vect)
{
unsigned char c = UDR1;
store_char(c, &rx_buffer1);
serialEvent1();
serialEvent1_flag = 1;
}
#elif defined(SIG_USART1_RECV)
#error SIG_USART1_RECV
@ -128,11 +132,13 @@ inline void store_char(unsigned char c, ring_buffer *buffer)
#if defined(USART2_RX_vect) && defined(UDR2)
void serialEvent2() __attribute__((weak));
void serialEvent2() {}
volatile static unsigned char serialEvent2_flag = 0;
#define serialEvent2_implemented
SIGNAL(USART2_RX_vect)
{
unsigned char c = UDR2;
store_char(c, &rx_buffer2);
serialEvent2();
serialEvent2_flag = 1;
}
#elif defined(SIG_USART2_RECV)
#error SIG_USART2_RECV
@ -141,16 +147,55 @@ inline void store_char(unsigned char c, ring_buffer *buffer)
#if defined(USART3_RX_vect) && defined(UDR3)
void serialEvent3() __attribute__((weak));
void serialEvent3() {}
volatile static unsigned char serialEvent3_flag = 0;
#define serialEvent3_implemented
SIGNAL(USART3_RX_vect)
{
unsigned char c = UDR3;
store_char(c, &rx_buffer3);
serialEvent3();
serialEvent3_flag = 1;
}
#elif defined(SIG_USART3_RECV)
#error SIG_USART3_RECV
#endif
void serialEventRun(void)
{
unsigned char flag, oldSREG;
#ifdef serialEvent_implemented
oldSREG = SREG;
noInterrupts();
flag = serialEvent_flag;
serialEvent_flag = 0;
SREG = oldSREG;
if (flag) serialEvent();
#endif
#ifdef serialEvent1_implemented
oldSREG = SREG;
noInterrupts();
flag = serialEvent1_flag;
serialEvent1_flag = 0;
SREG = oldSREG;
if (flag) serialEvent1();
#endif
#ifdef serialEvent2_implemented
oldSREG = SREG;
noInterrupts();
flag = serialEvent2_flag;
serialEvent2_flag = 0;
SREG = oldSREG;
if (flag) serialEvent2();
#endif
#ifdef serialEvent3_implemented
oldSREG = SREG;
noInterrupts();
flag = serialEvent3_flag;
serialEvent3_flag = 0;
SREG = oldSREG;
if (flag) serialEvent3();
#endif
}
#if !defined(UART0_UDRE_vect) && !defined(UART_UDRE_vect) && !defined(USART0_UDRE_vect) && !defined(USART_UDRE_vect)
#error Don't know what the Data Register Empty vector is called for the first UART

2
hardware/arduino/cores/arduino/HardwareSerial.h
View File

@ -74,4 +74,6 @@ class HardwareSerial : public Stream
extern HardwareSerial Serial3;
#endif
extern void serialEventRun(void);
#endif

0
libraries/Ethernet/IPAddress.cpp → hardware/arduino/cores/arduino/IPAddress.cpp
View File

0
libraries/Ethernet/IPAddress.h → hardware/arduino/cores/arduino/IPAddress.h
View File

2
hardware/arduino/cores/arduino/Print.h
View File

@ -42,7 +42,7 @@ class Print
public:
Print() : write_error(0) {}
int writeError() { return write_error; }
int getWriteError() { return write_error; }
void clearWriteError() { setWriteError(0); }
virtual size_t write(uint8_t) = 0;

3
hardware/arduino/cores/arduino/Printable.h
View File

@ -20,6 +20,8 @@
#ifndef Printable_h
#define Printable_h
#include <new.h>
class Print;
/** The Printable class provides a way for new classes to allow themselves to be printed.
@ -27,6 +29,7 @@ class Print;
for users to print out instances of this class by passing them into the usual
Print::print and Print::println methods.
*/
class Printable
{
public:

9
hardware/arduino/cores/arduino/Server.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef server_h
#define server_h
class Server {
public:
virtual void begin() =0;
};
#endif

90
hardware/arduino/cores/arduino/Udp.h Normal file
View File

@ -0,0 +1,90 @@
/*
* Udp.cpp: Library to send/receive UDP packets.
*
* 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 udp_h
#define udp_h
#include <Stream.h>
#include <IPAddress.h>
class UDP : public Stream {
public:
virtual uint8_t begin(uint16_t) =0; // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
virtual void stop() =0; // 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) =0;
// 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) =0;
// Finish off this packet and send it
// Returns 1 if the packet was sent successfully, 0 if there was an error
virtual int endPacket() =0;
// Write a single byte into the packet
virtual size_t write(uint8_t) =0;
// Write a string of characters into the packet
virtual size_t write(const char *str) =0;
// Write size bytes from buffer into the packet
virtual size_t write(const uint8_t *buffer, size_t size) =0;
// 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() =0;
// Number of bytes remaining in the current packet
virtual int available() =0;
// Read a single byte from the current packet
virtual int read() =0;
// 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) =0;
// 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) =0;
// Return the next byte from the current packet without moving on to the next byte
virtual int peek() =0;
virtual void flush() =0; // Finish reading the current packet
// Return the IP address of the host who sent the current incoming packet
virtual IPAddress remoteIP() =0;
// Return the port of the host who sent the current incoming packet
virtual uint16_t remotePort() =0;
protected:
uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
};
#endif

4
hardware/arduino/cores/arduino/main.cpp
View File

@ -7,8 +7,10 @@ int main(void)
setup();
for (;;)
for (;;) {
loop();
serialEventRun();
}
return 0;
}

18
hardware/arduino/cores/arduino/new.cpp Normal file
View File

@ -0,0 +1,18 @@
#include <new.h>
void * operator new(size_t size)
{
return malloc(size);
}
void operator delete(void * ptr)
{
free(ptr);
}
int __cxa_guard_acquire(__guard *g) {return !*(char *)(g);};
void __cxa_guard_release (__guard *g) {*(char *)g = 1;};
void __cxa_guard_abort (__guard *) {};
void __cxa_pure_virtual(void) {};

22
hardware/arduino/cores/arduino/new.h Normal file
View File

@ -0,0 +1,22 @@
/* Header to define new/delete operators as they aren't provided by avr-gcc by default
Taken from http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=59453
*/
#ifndef NEW_H
#define NEW_H
#include <stdlib.h>
void * operator new(size_t size);
void operator delete(void * ptr);
__extension__ typedef int __guard __attribute__((mode (__DI__)));
extern "C" int __cxa_guard_acquire(__guard *);
extern "C" void __cxa_guard_release (__guard *);
extern "C" void __cxa_guard_abort (__guard *);
extern "C" void __cxa_pure_virtual(void);
#endif

715
libraries/ArduinoTestSuite/ArduinoTestSuite.cpp
View File

@ -1,715 +0,0 @@
//************************************************************************
//* Arduino Test Suite
//* (C) 2010 by Mark Sproul
//* Open source as per standard Arduino code
//*
//* 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.
//************************************************************************
//* Aug 31, 2010 <MLS> Started on TestArduino
//* Oct 18, 2010 <MLS> Added memory testing
//************************************************************************
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/eeprom.h>
#include "ArduinoTestSuite.h"
#include "Arduino.h"
#include "HardwareSerial.h"
#include "pins_arduino.h"
#include "avr_cpunames.h"
#if defined(USART3_RX_vect)
#define SERIAL_PORT_COUNT 4
#elif defined(USART1_RX_vect)
#define SERIAL_PORT_COUNT 2
#else
#define SERIAL_PORT_COUNT 1
#endif
//************************************************************************
enum
{
ATS_Manufacturer = 1,
ATS_CPU,
ATS_GCC_version,
ATS_LIBC_version,
ATS_CompiledDate,
ATS_TestSuiteName,
ATS_FreeMemory,
};
unsigned long gTestStartTime;
short gTagIndent;
int gYotalErrors;
int gTestCount;
prog_char gTextMsg_Manufacturer[] PROGMEM = "MANUFACTURER";
prog_char gTextMsg_CPUname[] PROGMEM = "CPU-NAME";
prog_char gTextMsg_GCC_VERSION[] PROGMEM = "GCC-Version";
prog_char gTextMsg_AVR_LIBC[] PROGMEM = "AVR-LibC-Ver";
prog_char gTextMsg_COMPILED_DATE[] PROGMEM = "Compiled-date";
prog_char gTextMsg_TEST_SUITE_NAME[] PROGMEM = "Test-Suite-Name";
prog_char gTextMsg_memoryUsage[] PROGMEM = "Free-memory";
prog_char gTextMsg_dotdotdot[] PROGMEM = "... ";
prog_char gTextMsg_ok[] PROGMEM = "ok";
prog_char gTextMsg_FAIL[] PROGMEM = "FAIL";
prog_char gTextMsg_spaceEqual[] PROGMEM = " = ";
prog_char gTextMsg_info[] PROGMEM = "info.";
prog_char gTextMsg_dashLine[] PROGMEM = "--------------------------";
prog_char gTextMsg_DigitalRW[] PROGMEM = "DigitalReadWrite_";
prog_char gTextMsg_PWMoutput[] PROGMEM = "PWMoutput_";
prog_char gTextMsg_AnalogInput[] PROGMEM = "AnalogInput_";
//************************************************************************
void Serial_print_P(prog_char *flashMemStr)
{
char theChar;
int ii;
ii = 0;
#if (FLASHEND > 0x10000)
while (theChar = pgm_read_byte_far(flashMemStr + ii++))
#else
while (theChar = pgm_read_byte_near(flashMemStr + ii++))
#endif
{
Serial.print(theChar);
}
}
//************************************************************************
void Serial_println_P(prog_char *flashMemStr)
{
Serial_print_P(flashMemStr);
Serial.println();
}
//************************************************************************
//* this is for internal use only, not made pubic to the API
static void ATS_PrintProperty( int propertyTagNum,
char *propertyName,
char *propertyValue)
{
char lineBuffer[64];
strcpy_P(lineBuffer, gTextMsg_info);
switch(propertyTagNum)
{
case 0:
strcat(lineBuffer, propertyName);
break;
case ATS_Manufacturer:
strcat_P(lineBuffer, gTextMsg_Manufacturer);
break;
case ATS_CPU:
strcat_P(lineBuffer, gTextMsg_CPUname);
break;
case ATS_GCC_version:
strcat_P(lineBuffer, gTextMsg_GCC_VERSION);
break;
case ATS_LIBC_version:
strcat_P(lineBuffer, gTextMsg_AVR_LIBC);
break;
case ATS_CompiledDate:
strcat_P(lineBuffer, gTextMsg_COMPILED_DATE);
break;
case ATS_TestSuiteName:
strcat_P(lineBuffer, gTextMsg_TEST_SUITE_NAME);
break;
case ATS_FreeMemory:
strcat_P(lineBuffer, gTextMsg_memoryUsage);
break;
}
while (strlen(lineBuffer) < 20)
{
strcat(lineBuffer, " ");
}
strcat_P(lineBuffer, gTextMsg_spaceEqual);
if (propertyValue != 0)
{
strcat(lineBuffer, propertyValue);
}
Serial.println(lineBuffer);
}
//************************************************************************
void ATS_begin(char *manufName, char *testSuiteName)
{
int freeMemory;
char memoryMsg[48];
gYotalErrors = 0;
gTestCount = 0;
Serial.begin(9600);
delay(1000);
gTestStartTime = millis();
Serial.println();
Serial.println();
Serial.println();
ATS_PrintProperty(ATS_Manufacturer, 0, manufName);
ATS_PrintProperty(ATS_CPU, 0, _AVR_CPU_NAME_);
ATS_PrintProperty(ATS_GCC_version, 0, __VERSION__);
ATS_PrintProperty(ATS_LIBC_version, 0, __AVR_LIBC_VERSION_STRING__);
ATS_PrintProperty(ATS_CompiledDate, 0, __DATE__);
ATS_PrintProperty(ATS_TestSuiteName, 0, testSuiteName);
freeMemory = ATS_GetFreeMemory();
sprintf(memoryMsg, "%d bytes", freeMemory);
ATS_PrintProperty(ATS_FreeMemory, 0, memoryMsg);
randomSeed(analogRead(0));
}
//************************************************************************
void ATS_end()
{
long seconds;
long milliSecs;
Serial_println_P(gTextMsg_dashLine);
// Ran 4 tests in 0.000s
Serial.print("Ran ");
Serial.print(gTestCount);
Serial.print(" tests in ");
seconds = millis() / 1000;
milliSecs = millis() % 1000;
Serial.print(seconds);
Serial.print('.');
Serial.print(milliSecs);
Serial.print('s');
Serial.println();
Serial.println();
if (gYotalErrors == 0)
{
Serial.print("OK");
}
else
{
Serial.print("FAILED (failures=");
Serial.print(gYotalErrors);
Serial.print(")");
}
Serial.println();
//* send control D to terminate (End Of File)
Serial.write(0x04);
}
//************************************************************************
void ATS_PrintTestStatus(char *testString, boolean passed)
{
int sLen;
Serial.print(testString);
sLen = strlen(testString);
while (sLen < 60)
{
Serial.print(' ');
sLen++;
}
Serial_print_P(gTextMsg_dotdotdot);
if (passed)
{
Serial_print_P(gTextMsg_ok);
}
else
{
Serial_print_P(gTextMsg_FAIL);
gYotalErrors++;
}
Serial.println();
gTestCount++;
}
//************************************************************************
//* returns true if no errors, false if there is an error
int ATS_Test_DigitalPinWithHelper(uint8_t digitalPinToTest, uint8_t helperpin)
{
boolean passedOK;
int pinValue;
char testName[64];
char numString[32];
strcpy_P(testName, gTextMsg_DigitalRW);
sprintf(numString, "%02d", digitalPinToTest);
strcat(testName, numString);
passedOK = true;
//* test senario 1
pinMode(digitalPinToTest, OUTPUT);
pinMode(helperpin, INPUT);
digitalWrite(digitalPinToTest, HIGH);
pinValue = digitalRead(helperpin);
if (pinValue != HIGH)
{
passedOK = false;
}
digitalWrite(digitalPinToTest, LOW);
pinValue = digitalRead(helperpin);
if (pinValue != LOW)
{
passedOK = false;
}
//* now reverse the input/output
pinMode(digitalPinToTest, INPUT);
pinMode(helperpin, OUTPUT);
digitalWrite(helperpin, HIGH);
pinValue = digitalRead(digitalPinToTest);
if (pinValue != HIGH)
{
passedOK = false;
}
digitalWrite(helperpin, LOW);
pinValue = digitalRead(digitalPinToTest);
if (pinValue != LOW)
{
passedOK = false;
}
if (! passedOK)
{
sprintf(numString, " (helper pin=%02d)", helperpin);
strcat(testName, numString);
}
ATS_PrintTestStatus(testName, passedOK);
return(passedOK);
}
//************************************************************************
boolean ATS_Test_DigitalPin(uint8_t digitalPinToTest)
{
boolean passedOK;
uint8_t helperpin;
if ((digitalPinToTest % 2) == 0)
{
//* if its EVEN, add 1
helperpin = digitalPinToTest + 1;
}
else
{
//* if its ODD
helperpin = digitalPinToTest - 1;
}
passedOK = ATS_Test_DigitalPinWithHelper(digitalPinToTest, helperpin);
return(passedOK);
}
//************************************************************************
//* returns true if no errors, false if there is an error
int ATS_TestTimer( uint8_t timerPinNumber,
uint8_t inputPin,
char *statusString,
char *errorString)
{
boolean passedOK;
unsigned long loopCounter;
unsigned long lowCount;
unsigned long highCount;
unsigned long startTime;
int percentLow;
int percentHigh;
int pinValue;
char numString[48];
int pwmValue;
pwmValue = 128;
loopCounter = 0;
lowCount = 0;
highCount = 0;
passedOK = true;
startTime = millis();
pinMode(inputPin, INPUT);
analogWrite(timerPinNumber, pwmValue);
while ((millis() - startTime) < 500)
{
pinValue = digitalRead(inputPin);
if (pinValue == HIGH)
{
highCount++;
}
else
{
lowCount++;
}
}
analogWrite(timerPinNumber, 0);
//* the difference should be about 50%
percentLow = lowCount / ((lowCount + highCount) / 100);
percentHigh = highCount / ((lowCount + highCount) / 100);
if ((percentLow > 45) && (percentLow < 55))
{
passedOK = true;
}
else
{
passedOK = false;
strcat(errorString, " PWM ERROR");
}
sprintf(numString, " (PWM=%02d %d%% LOW %d%% HIGH)", pwmValue, percentLow, percentHigh);
strcat(statusString, numString);
return(passedOK);
}
//************************************************************************
//* returns true if no errors, false if there is an error
boolean ATS_Test_PWMPinWithHelper(uint8_t pwmPinToTest, uint8_t helperpin)
{
boolean passedOK;
char testName[64];
char errorString[48];
char numString[8];
uint8_t timerNumber;
strcpy_P(testName, gTextMsg_PWMoutput);
sprintf(numString, "%02d", pwmPinToTest);
strcat(testName, numString);
passedOK = true;
errorString[0] = 0;
//* is pin1 a timer?
timerNumber = digitalPinToTimer(pwmPinToTest);
if (timerNumber != NOT_ON_TIMER)
{
passedOK = ATS_TestTimer(pwmPinToTest, helperpin, testName, errorString);
}
else
{
//* we should not get here
passedOK = false;
}
ATS_PrintTestStatus(testName, passedOK);
return(passedOK);
}
//************************************************************************
boolean ATS_Test_PWM_Pin(uint8_t pwmPinToTest)
{
boolean passedOK;
uint8_t helperpin;
if ((pwmPinToTest % 2) == 0)
{
//* if its EVEN, add 1
helperpin = pwmPinToTest + 1;
}
else
{
//* if its ODD
helperpin = pwmPinToTest - 1;
}
passedOK = ATS_Test_PWMPinWithHelper(pwmPinToTest, helperpin);
return(passedOK);
}
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define kAnalogPinOffset 54
#else
#define kAnalogPinOffset 14
#endif
//************************************************************************
boolean ATS_Test_AnalogInputWithHelper(uint8_t analogPintoTest, uint8_t helperPin)
{
boolean passedOK;
char testName[64];
char infoString[48];
int analogValueHigh;
int analogValueLow;
//* first we have to set the ANALOG pin to INPUT
pinMode(analogPintoTest + kAnalogPinOffset, INPUT);
passedOK = true;
strcpy_P(testName, gTextMsg_AnalogInput);
sprintf(infoString, "%02d", analogPintoTest);
strcat(testName, infoString);
pinMode(helperPin, OUTPUT);
digitalWrite(helperPin, LOW);
analogValueLow = analogRead(analogPintoTest);
if (analogValueLow > 100)
{
passedOK = false;
}
digitalWrite(helperPin, HIGH);
analogValueHigh = analogRead(analogPintoTest);
if (analogValueHigh < 1000)
{
passedOK = false;
}
sprintf(infoString, " (Low=%4d High=%4d helper pin=%d)", analogValueLow, analogValueHigh, helperPin);
strcat(testName, infoString);
ATS_PrintTestStatus(testName, passedOK);
return(passedOK);
}
//************************************************************************
boolean ATS_Test_AnalogInput(uint8_t analogPinToTest)
{
boolean passedOK;
uint8_t helperpin;
if ((analogPinToTest % 2) == 0)
{
//* if its EVEN, add 1
helperpin = kAnalogPinOffset + analogPinToTest + 1;
}
else
{
//* if its ODD
helperpin = kAnalogPinOffset + analogPinToTest - 1;
}
passedOK = ATS_Test_AnalogInputWithHelper(analogPinToTest, helperpin);
return(passedOK);
}
#define kSerialTestBaudRate 9600
#define kSerialTestDelay 3
#if (SERIAL_PORT_COUNT > 1) && !defined(__AVR_ATmega32U4__)
//************************************************************************
//* retunrs 0 if no errors, 1 if an error occured
short ATS_TestSerialLoopback(HardwareSerial *theSerialPort, char *serialPortName)
{
char xmitChar;
char rcvChar;
short ii;
short serialErrCt;
short timeOutLoopCtr;
serialErrCt = 1;
if (theSerialPort != 0)
{
serialErrCt = 0;
theSerialPort->begin(kSerialTestBaudRate);
for (ii=0; ii<150; ii++)
{
xmitChar = ii;
theSerialPort->print(xmitChar);
timeOutLoopCtr = 0;
//* wait for data to come back or timeout
while (!theSerialPort->available() && (timeOutLoopCtr < kSerialTestDelay))
{
delay(1);
timeOutLoopCtr++;
}
if (theSerialPort->available())
{
//* get the char
rcvChar = theSerialPort->read();
if (rcvChar != xmitChar)
{
serialErrCt = 1;
}
}
else
{
serialErrCt = 1;
}
}
theSerialPort->end();
if (serialErrCt == 0)
{
ATS_PrintTestStatus(serialPortName, PASSED);
}
else
{
ATS_PrintTestStatus(serialPortName, FAILED);
}
}
return(serialErrCt);
}
#endif
//************************************************************************
boolean ATS_Test_EEPROM(void)
{
boolean passedOK;
uint8_t dataByte;
uint8_t dataByteRead;
uint16_t dataWord;
uint16_t dataWordRead;
uint32_t dataLongWord;
uint32_t dataLongWordRead;
int addressPtr;
char reportString[48];
passedOK = true;
//* test BYTE read/write
addressPtr = random(E2END);
dataByte = 0x5A;
eeprom_write_byte((uint8_t *)addressPtr, dataByte);
dataByteRead = eeprom_read_byte((uint8_t *)addressPtr);
sprintf(reportString, "EEPROM_byte_rw (addr= 0x%04X)", addressPtr);
if (dataByteRead == dataByte)
{
ATS_PrintTestStatus(reportString, PASSED);
}
else
{
ATS_PrintTestStatus(reportString, FAILED);
passedOK = false;
}
//* test WORD read/write
addressPtr = random(E2END);
dataWord = 0xA55A;
eeprom_write_word((uint16_t *)addressPtr, dataWord);
dataWordRead = eeprom_read_word((uint16_t *)addressPtr);
sprintf(reportString, "EEPROM_word_rw (addr= 0x%04X)", addressPtr);
if (dataWordRead == dataWord)
{
ATS_PrintTestStatus(reportString, PASSED);
}
else
{
ATS_PrintTestStatus(reportString, FAILED);
passedOK = false;
}
//* test Long WORD read/write
addressPtr = random(E2END);
dataLongWord = 0x5AA5A55A;
eeprom_write_dword((uint32_t *)addressPtr, dataLongWord);
dataLongWordRead = eeprom_read_dword((uint32_t *)addressPtr);
sprintf(reportString, "EEPROM_dword_rw (addr= 0x%04X)", addressPtr);
if (dataLongWordRead == dataLongWord)
{
ATS_PrintTestStatus(reportString, PASSED);
}
else
{
ATS_PrintTestStatus(reportString, FAILED);
passedOK = false;
}
return(passedOK);
}
//************************************************************************
extern unsigned int __data_start;
extern unsigned int __data_end;
extern unsigned int __bss_start;
extern unsigned int __bss_end;
extern unsigned int __heap_start;
extern void *__brkval;
//************************************************************************
int ATS_GetFreeMemory()
{
int free_memory;
if((int)__brkval == 0)
{
free_memory = ((int)&free_memory) - ((int)&__bss_end);
}
else
{
free_memory = ((int)&free_memory) - ((int)__brkval);
}
return free_memory;
}

74
libraries/ArduinoTestSuite/ArduinoTestSuite.h
View File

@ -1,74 +0,0 @@
//************************************************************************
//************************************************************************
//* Aug 31, 2010 <MLS> Started on TestArduino
//************************************************************************
#ifndef _AVR_IO_H_
#include <avr/io.h>
#endif
#ifndef Arduino_h
#include "Arduino.h"
#endif
#ifndef HardwareSerial_h
#include "HardwareSerial.h"
#endif
#if defined(USART3_RX_vect)
#define SERIAL_PORT_COUNT 4
#elif defined(USART1_RX_vect)
#define SERIAL_PORT_COUNT 2
#else
#define SERIAL_PORT_COUNT 1
#endif
void ATS_begin(char *manufName, char *testSuiteName);
void ATS_end();
void ATS_PrintTestStatus(char *testString, boolean passed);
boolean ATS_Test_DigitalPin(uint8_t digitalPinToTest);
boolean ATS_Test_PWM_Pin(uint8_t digitalPinToTest);
boolean ATS_Test_AnalogInput(uint8_t analogPintoTest);
boolean ATS_Test_EEPROM(void);
short ATS_TestSerialLoopback(HardwareSerial *theSerialPort, char *serialPortName);
int ATS_GetFreeMemory();
//************************************************************************
//* this has to be an inline function because calling subroutines affects free memory
inline void ATS_ReportMemoryUsage(int _memoryUsageAtStart)
{
int freeMemoryAtEnd;
int lostMemory;
boolean memoryOK;
char memoryUsage[48];
freeMemoryAtEnd = ATS_GetFreeMemory();
lostMemory = _memoryUsageAtStart - freeMemoryAtEnd;
if (lostMemory == 0)
{
strcpy(memoryUsage, "Memory Usage");
memoryOK = true;
}
else
{
sprintf(memoryUsage, "Memory Usage (lost %d bytes)", lostMemory);
memoryOK = false;
}
ATS_PrintTestStatus(memoryUsage, memoryOK);
}
extern unsigned long gTestStartTime;
extern int gYotalErrors;
extern int gTestCount;
#define PASSED true
#define FAILED false

186
libraries/ArduinoTestSuite/avr_cpunames.h
View File

@ -1,186 +0,0 @@
//**************************************************************************************************
//*
//* Atmel AVR CPU name strings
//*
//**************************************************************************************************
//* Sep 19, 2010 <MLS> Started on avr_cpunames.h
//**************************************************************************************************
//#include "avr_cpunames.h"
//**************************************************************************************************
#if defined (__AVR_AT94K__)
#define _AVR_CPU_NAME_ "AT94k"
#elif defined (__AVR_AT43USB320__)
#elif defined (__AVR_AT43USB355__)
#elif defined (__AVR_AT76C711__)
#elif defined (__AVR_AT86RF401__)
#elif defined (__AVR_AT90PWM1__)
#elif defined (__AVR_AT90PWM2__)
#elif defined (__AVR_AT90PWM2B__)
#elif defined (__AVR_AT90PWM3__)
#elif defined (__AVR_AT90PWM3B__)
#elif defined (__AVR_AT90PWM216__)
#elif defined (__AVR_AT90PWM316__)
#elif defined (__AVR_ATmega32C1__)
#elif defined (__AVR_ATmega32M1__)
#elif defined (__AVR_ATmega32U4__)
#define _AVR_CPU_NAME_ "ATmega32U4"
#elif defined (__AVR_ATmega32U6__)
#define _AVR_CPU_NAME_ "ATmega32U6"
#elif defined (__AVR_ATmega128__)
#define _AVR_CPU_NAME_ "Atmega128"
#elif defined (__AVR_ATmega1280__)
#define _AVR_CPU_NAME_ "ATmega1280"
#elif defined (__AVR_ATmega1281__)
#define _AVR_CPU_NAME_ "ATmega1281"
#elif defined (__AVR_ATmega1284P__)
#define _AVR_CPU_NAME_ "ATmega1284"
#elif defined (__AVR_ATmega2560__)
#define _AVR_CPU_NAME_ "ATmega2560"
#elif defined (__AVR_ATmega2561__)
#define _AVR_CPU_NAME_ "ATmega2561"
#elif defined (__AVR_AT90CAN32__)
#define _AVR_CPU_NAME_ "AT90CAN32"
#elif defined (__AVR_AT90CAN64__)
#define _AVR_CPU_NAME_ "AT90CAN64"
#elif defined (__AVR_AT90CAN128__)
#define _AVR_CPU_NAME_ "AT90CAN128"
#elif defined (__AVR_AT90USB82__)
#define _AVR_CPU_NAME_ "AT90USB82"
#elif defined (__AVR_AT90USB162__)
#define _AVR_CPU_NAME_ "AT90USB162"
#elif defined (__AVR_AT90USB646__)
#define _AVR_CPU_NAME_ "AT90USB646"
#elif defined (__AVR_AT90USB647__)
#define _AVR_CPU_NAME_ "AT90USB647"
#elif defined (__AVR_AT90USB1286__)
#define _AVR_CPU_NAME_ "AT90USB1286"
#elif defined (__AVR_AT90USB1287__)
#define _AVR_CPU_NAME_ "AT90USB1287"
#elif defined (__AVR_ATmega64__)
#define _AVR_CPU_NAME_ "ATmega64"
#elif defined (__AVR_ATmega640__)
#define _AVR_CPU_NAME_ "ATmega640"
#elif defined (__AVR_ATmega644__)
#define _AVR_CPU_NAME_ "ATmega644"
#elif defined (__AVR_ATmega644P__)
#define _AVR_CPU_NAME_ "ATmega644P"
#elif defined (__AVR_ATmega645__)
#define _AVR_CPU_NAME_ "ATmega645"
#elif defined (__AVR_ATmega6450__)
#define _AVR_CPU_NAME_ "ATmega6450"
#elif defined (__AVR_ATmega649__)
#define _AVR_CPU_NAME_ "ATmega649"
#elif defined (__AVR_ATmega6490__)
#define _AVR_CPU_NAME_ "ATmega6490"
#elif defined (__AVR_ATmega103__)
#define _AVR_CPU_NAME_ "ATmega103"
#elif defined (__AVR_ATmega32__)
#define _AVR_CPU_NAME_ "Atmega32"
#elif defined (__AVR_ATmega323__)
#define _AVR_CPU_NAME_ "ATmega323"
#elif defined (__AVR_ATmega324P__)
#define _AVR_CPU_NAME_ "ATmega324P"
#elif defined (__AVR_ATmega325__)
#define _AVR_CPU_NAME_ "ATmega325"
#elif defined (__AVR_ATmega325P__)
#define _AVR_CPU_NAME_ "ATmega325P"
#elif defined (__AVR_ATmega3250__)
#define _AVR_CPU_NAME_ "ATmega3250"
#elif defined (__AVR_ATmega3250P__)
#define _AVR_CPU_NAME_ "ATmega3250P"
#elif defined (__AVR_ATmega328P__)
#define _AVR_CPU_NAME_ "ATmega328P"
#elif defined (__AVR_ATmega329__)
#define _AVR_CPU_NAME_ "ATmega329"
#elif defined (__AVR_ATmega329P__)
#define _AVR_CPU_NAME_ "ATmega329P"
#elif defined (__AVR_ATmega3290__)
#define _AVR_CPU_NAME_ "ATmega3290"
#elif defined (__AVR_ATmega3290P__)
#define _AVR_CPU_NAME_ "ATmega3290P"
#elif defined (__AVR_ATmega32HVB__)
#define _AVR_CPU_NAME_ "ATmega32HVB"
#elif defined (__AVR_ATmega406__)
#define _AVR_CPU_NAME_ "ATmega406"
#elif defined (__AVR_ATmega16__)
#define _AVR_CPU_NAME_ "Atmega16"
#elif defined (__AVR_ATmega161__)
#define _AVR_CPU_NAME_ "ATmega161"
#elif defined (__AVR_ATmega162__)
#define _AVR_CPU_NAME_ "ATmega162"
#elif defined (__AVR_ATmega163__)
#define _AVR_CPU_NAME_ "ATmega163"
#elif defined (__AVR_ATmega164P__)
#define _AVR_CPU_NAME_ "ATmega164P"
#elif defined (__AVR_ATmega165__)
#define _AVR_CPU_NAME_ "ATmega165"
#elif defined (__AVR_ATmega165P__)
#define _AVR_CPU_NAME_ "ATmega165P"
#elif defined (__AVR_ATmega168__)
#define _AVR_CPU_NAME_ "ATmega168"
#elif defined (__AVR_ATmega168P__)
#define _AVR_CPU_NAME_ "ATmega168P"
#elif defined (__AVR_ATmega169__)
#define _AVR_CPU_NAME_ "Atmega169"
#elif defined (__AVR_ATmega169P__)
#define _AVR_CPU_NAME_ "ATmega169P"
#elif defined (__AVR_ATmega8HVA__)
#define _AVR_CPU_NAME_ "ATmega8HVA"
#elif defined (__AVR_ATmega16HVA__)
#define _AVR_CPU_NAME_ "ATmega16HVA"
#elif defined (__AVR_ATmega8__)
#define _AVR_CPU_NAME_ "ATmega8"
#elif defined (__AVR_ATmega48__)
#define _AVR_CPU_NAME_ "ATmega48"
#elif defined (__AVR_ATmega48P__)
#define _AVR_CPU_NAME_ "ATmega48P"
#elif defined (__AVR_ATmega88__)
#define _AVR_CPU_NAME_ "ATmega88"
#elif defined (__AVR_ATmega88P__)
#define _AVR_CPU_NAME_ "ATmega88P"
#elif defined (__AVR_ATmega8515__)
#define _AVR_CPU_NAME_ "ATmega8515"
#elif defined (__AVR_ATmega8535__)
#define _AVR_CPU_NAME_ "ATmega8535"
#elif defined (__AVR_AT90S8535__)
#elif defined (__AVR_AT90C8534__)
#elif defined (__AVR_AT90S8515__)
#elif defined (__AVR_AT90S4434__)
#elif defined (__AVR_AT90S4433__)
#elif defined (__AVR_AT90S4414__)
#elif defined (__AVR_ATtiny22__)
#elif defined (__AVR_ATtiny26__)
#elif defined (__AVR_AT90S2343__)
#elif defined (__AVR_AT90S2333__)
#elif defined (__AVR_AT90S2323__)
#elif defined (__AVR_AT90S2313__)
#elif defined (__AVR_ATtiny2313__)
#define _AVR_CPU_NAME_ "ATtiny2313"
#elif defined (__AVR_ATtiny13__)
#elif defined (__AVR_ATtiny13A__)
#elif defined (__AVR_ATtiny25__)
#elif defined (__AVR_ATtiny45__)
#elif defined (__AVR_ATtiny85__)
#elif defined (__AVR_ATtiny24__)
#elif defined (__AVR_ATtiny44__)
#elif defined (__AVR_ATtiny84__)
#elif defined (__AVR_ATtiny261__)
#elif defined (__AVR_ATtiny461__)
#elif defined (__AVR_ATtiny861__)
#elif defined (__AVR_ATtiny43U__)
#elif defined (__AVR_ATtiny48__)
#elif defined (__AVR_ATtiny88__)
#elif defined (__AVR_ATtiny167__)
#else
#error cpu not defined
#endif
#if !defined (_AVR_CPU_NAME_)
// #define _AVR_CPU_NAME_ "UNKNOWN"
#endif

75
libraries/ArduinoTestSuite/examples/ATS_Constants/ATS_Constants.pde
View File

@ -1,75 +0,0 @@
//************************************************************************
//* Arduino Test of Arduino Constants
//* (C) 2010 by Rick Anderson
//* Open source as per standard Arduino code
//*
//************************************************************************
//* Oct 16, 2010 <ROA> Test of Arduino Constants
//************************************************************************
#include "HardwareSerial.h"
#include <ArduinoTestSuite.h>
//************************************************************************
void setup()
{
int startMemoryUsage;
//Start memory usage must be site prior to ATS_begin
startMemoryUsage = ATS_GetFreeMemory();
ATS_begin("Arduino", "Test of Arduino Constants");
/*
* Test Run Start
*/
//test true constant
ATS_PrintTestStatus("1. Test of true constant", true == 1);
//test false consts
ATS_PrintTestStatus( "2. Test of false constant", false == 0);
//Test of HIGH == 1
ATS_PrintTestStatus( "3. Test of HIGH == 1", HIGH == 1);
//Test of LOW == 0
ATS_PrintTestStatus( "4. Test of LOW == 0", LOW == 0);
//Test of INPUT == 1
ATS_PrintTestStatus( "5. Test of INPUT == 1", HIGH == 1);
//Test of OUTPUT == 0
ATS_PrintTestStatus( "6. Test of OUTPUT == 0", LOW == 0);
//test decimal
ATS_PrintTestStatus( "7. Test of decimal constant", 101 == ((1 * pow(10,2)) + (0 * pow(10,1)) + 1));
//test binary
ATS_PrintTestStatus( "8. Test of binary constant", B101 == 5);
//test octal
ATS_PrintTestStatus( "9. Test of octal constant", 0101 == 65);
//test hexadecimal
ATS_PrintTestStatus( "7. Test of hexadecimal constant", (0x101 == 257));
/*
* Test Run End
*/
ATS_ReportMemoryUsage(startMemoryUsage);
ATS_end();
}
//************************************************************************
void loop()
{
}

1
libraries/ArduinoTestSuite/examples/ATS_Delay/ATS_Delay.pde
View File

@ -1 +0,0 @@
//************************************************************************ //* Arduino Test Suite //* ATS_ToneTest //* //* Copyright (c) 2010 Mark Sproul 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 //************************************************************************ //* Aug 31, 2010 <MLS> Started on TestArduino //* Oct 28, 2010 <MLS> Started on Delay //************************************************************************ #include "HardwareSerial.h" #include <ArduinoTestSuite.h> //************************************************************************ void setup() { short ii; short testNum; int startMemoryUsage; unsigned long startMillis; unsigned long endMillis; unsigned long deltaMillis; unsigned long errMillis; boolean passed; char testNameString[80]; startMemoryUsage = ATS_GetFreeMemory(); ATS_begin("Arduino", "DelayTest"); testNum = 1; //* we start at 2 because 0/1 are RXD/TXD for (ii=0; ii<1000; ii+= 15) { startMillis = millis(); delay(ii); endMillis = millis(); deltaMillis = endMillis - startMillis; if (deltaMillis >= ii) { errMillis = deltaMillis - ii; } else { errMillis = ii - deltaMillis; } if (errMillis <= 1) { passed = true; } else { passed = false; } sprintf(testNameString, "DelayTest.%02d (delay= %4d actual delay=%ld err=%ld)", testNum, ii, deltaMillis, errMillis); ATS_PrintTestStatus(testNameString, passed); testNum++; } ATS_ReportMemoryUsage(startMemoryUsage); ATS_end(); } //************************************************************************ void loop() { }

93
libraries/ArduinoTestSuite/examples/ATS_General/ATS_General.pde
View File

@ -1,93 +0,0 @@
//************************************************************************
//* Arduino Test Suite
//* (C) 2010 by Mark Sproul
//* Open source as per standard Arduino code
//*
//************************************************************************
//* Aug 31, 2010 <MLS> Started on TestArduino
//* Oct 18, 2010 <MLS> Added memory testing
//************************************************************************
#include "HardwareSerial.h"
#include "pins_arduino.h"
#include <ArduinoTestSuite.h>
#include "avr_cpunames.h"
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)
#define kBoard_PinCount 20
#define kBoard_AnalogCount 6
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define kBoard_PinCount 70
#define kBoard_AnalogCount 16
#endif
//************************************************************************
void setup()
{
short ii;
uint8_t timerNumber;
int startMemoryUsage;
startMemoryUsage = ATS_GetFreeMemory();
ATS_begin("Arduino", "general");
//* test digital pins
//* we start at 2 because 0/1 are RXD/TXD
for (ii=2; ii<kBoard_PinCount; ii++)
{
ATS_Test_DigitalPin(ii);
}
//* test PWM pins
//* we start at 2 because 0/1 are RXD/TXD
for (ii=2; ii<kBoard_PinCount; ii++)
{
timerNumber = digitalPinToTimer(ii);
if (timerNumber != NOT_ON_TIMER)
{
ATS_Test_PWM_Pin(ii);
}
}
for (ii=0; ii<kBoard_AnalogCount; ii++)
{
ATS_Test_AnalogInput(ii);
}
#if (SERIAL_PORT_COUNT > 1)
ATS_TestSerialLoopback(&Serial1, "Serial1");
#endif
#if (SERIAL_PORT_COUNT > 2)
ATS_TestSerialLoopback(&Serial2, "Serial2");
#endif
#if (SERIAL_PORT_COUNT > 3)
ATS_TestSerialLoopback(&Serial3, "Serial3");
#endif
ATS_Test_EEPROM();
ATS_ReportMemoryUsage(startMemoryUsage);
ATS_end();
}
//************************************************************************
void loop()
{
}

106
libraries/ArduinoTestSuite/examples/ATS_SD_File/ATS_SD_File.pde
View File

@ -1,106 +0,0 @@
// Tests writing to and reading from a file, in particular the
// the Stream implementation (e.g. read() and peek()).
#include <SD.h>
#include <ArduinoTestSuite.h>
void setup()
{
int startMemoryUsage = ATS_GetFreeMemory();
boolean b;
File f;
ATS_begin("Arduino", "SD Test");
ATS_PrintTestStatus("SD.begin()", b = SD.begin(4));
if (!b) goto done;
SD.remove("test.txt");
f = SD.open("test.txt", FILE_WRITE);
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
f.print("abc");
f.print("de");
f.close();
f = SD.open("test.txt", FILE_WRITE);
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
f.print("fgh");
f.close();
f = SD.open("test.txt");
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
ATS_PrintTestStatus("read()", f.read() == 'a');
ATS_PrintTestStatus("peek()", f.peek() == 'b');
ATS_PrintTestStatus("read()", f.read() == 'b');
ATS_PrintTestStatus("read()", f.read() == 'c');
ATS_PrintTestStatus("peek()", f.peek() == 'd');
ATS_PrintTestStatus("peek()", f.peek() == 'd');
ATS_PrintTestStatus("peek()", f.peek() == 'd');
ATS_PrintTestStatus("peek()", f.peek() == 'd');
ATS_PrintTestStatus("read()", f.read() == 'd');
ATS_PrintTestStatus("available()", f.available() != 0);
ATS_PrintTestStatus("read()", f.read() == 'e');
ATS_PrintTestStatus("available()", f.available() != 0);
ATS_PrintTestStatus("peek()", f.peek() == 'f');
ATS_PrintTestStatus("read()", f.read() == 'f');
ATS_PrintTestStatus("peek()", f.peek() == 'g');
ATS_PrintTestStatus("available()", f.available() != 0);
ATS_PrintTestStatus("peek()", f.peek() == 'g');
ATS_PrintTestStatus("read()", f.read() == 'g');
ATS_PrintTestStatus("available()", f.available() != 0);
ATS_PrintTestStatus("available()", f.available() != 0);
ATS_PrintTestStatus("available()", f.available() != 0);
ATS_PrintTestStatus("peek()", f.peek() == 'h');
ATS_PrintTestStatus("read()", f.read() == 'h');
ATS_PrintTestStatus("available()", f.available() == 0);
ATS_PrintTestStatus("peek()", f.peek() == -1);
ATS_PrintTestStatus("read()", f.read() == -1);
ATS_PrintTestStatus("peek()", f.peek() == -1);
ATS_PrintTestStatus("read()", f.read() == -1);
f.close();
SD.remove("test2.txt");
f = SD.open("test2.txt", FILE_WRITE);
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
f.print("ABC");
f.close();
f = SD.open("test.txt");
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
ATS_PrintTestStatus("peek()", f.peek() == 'a');
f.close();
f = SD.open("test2.txt");
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
ATS_PrintTestStatus("peek()", f.peek() == 'A');
ATS_PrintTestStatus("read()", f.read() == 'A');
f.close();
done:
ATS_ReportMemoryUsage(startMemoryUsage);
ATS_end();
}
void loop() {}

78
libraries/ArduinoTestSuite/examples/ATS_SD_Files/ATS_SD_Files.pde
View File

@ -1,78 +0,0 @@
#include <SD.h>
#include <ArduinoTestSuite.h>
void setup()
{
int startMemoryUsage = ATS_GetFreeMemory();
boolean b;
File f;
ATS_begin("Arduino", "SD Files Test");
ATS_PrintTestStatus("SD.begin()", b = SD.begin(4));
if (!b) goto done;
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf.txt"));
ATS_PrintTestStatus("SD.open()", f = SD.open("asdf.txt", FILE_WRITE)); f.close();
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf.txt"));
ATS_PrintTestStatus("SD.exists()", SD.exists("/asdf.txt"));
ATS_PrintTestStatus("SD.remove()", SD.remove("asdf.txt"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf.txt"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf"));
ATS_PrintTestStatus("SD.mkdir()", SD.mkdir("asdf"));
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf"));
ATS_PrintTestStatus("SD.exists()", SD.exists("/asdf"));
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf/"));
ATS_PrintTestStatus("SD.rmdir()", SD.rmdir("asdf"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf"));
ATS_PrintTestStatus("SD.mkdir()", SD.mkdir("x/y/z"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x/"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x/y"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x/y/"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x/y/z"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x/y/z/"));
ATS_PrintTestStatus("SD.exists()", SD.exists("/x/y/z/"));
ATS_PrintTestStatus("SD.rmdir()", SD.rmdir("x/y/z"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x/y"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("x/y/z"));
ATS_PrintTestStatus("SD.rmdir()", SD.rmdir("x/y/"));
ATS_PrintTestStatus("SD.exists()", SD.exists("x"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("x/y"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("x/y/z"));
ATS_PrintTestStatus("SD.rmdir()", SD.rmdir("/x"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("x"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("x/y"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("x/y/z"));
ATS_PrintTestStatus("!SD.open()", !(f = SD.open("asdf/asdf.txt", FILE_WRITE))); f.close();
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf.txt"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf/asdf.txt"));
ATS_PrintTestStatus("SD.mkdir()", SD.mkdir("asdf"));
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf"));
ATS_PrintTestStatus("SD.open()", f = SD.open("asdf/asdf.txt", FILE_WRITE)); f.close();
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf/asdf.txt"));
ATS_PrintTestStatus("!SD.rmdir()", !SD.rmdir("asdf"));
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf"));
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf/asdf.txt"));
ATS_PrintTestStatus("SD.remove()", SD.remove("asdf/asdf.txt"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf/asdf.txt"));
ATS_PrintTestStatus("SD.exists()", SD.exists("asdf"));
ATS_PrintTestStatus("SD.rmdir()", SD.rmdir("asdf"));
ATS_PrintTestStatus("!SD.exists()", !SD.exists("asdf"));
done:
ATS_ReportMemoryUsage(startMemoryUsage);
ATS_end();
}
void loop() {}

109
libraries/ArduinoTestSuite/examples/ATS_SD_Seek/ATS_SD_Seek.pde
View File

@ -1,109 +0,0 @@
// Tests writing to and reading from a file, in particular the
// the Stream implementation (e.g. read() and peek()).
#include <SD.h>
#include <ArduinoTestSuite.h>
void setup()
{
int startMemoryUsage = ATS_GetFreeMemory();
boolean b;
File f;
ATS_begin("Arduino", "SD Test");
ATS_PrintTestStatus("SD.begin()", b = SD.begin(4));
if (!b) goto done;
SD.remove("test.txt");
f = SD.open("test.txt", FILE_WRITE);
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
ATS_PrintTestStatus("initial position", f.position() == 0);
ATS_PrintTestStatus("initial size", f.size() == 0);
f.print("0123456789");
ATS_PrintTestStatus("position after writing", f.position() == 10);
ATS_PrintTestStatus("size after writing", f.size() == 10);
f.seek(0);
ATS_PrintTestStatus("size after seek", f.size() == 10);
ATS_PrintTestStatus("position after seek", f.position() == 0);
f.seek(7);
ATS_PrintTestStatus("position after seek", f.position() == 7);
ATS_PrintTestStatus("reading after seek", f.read() == '7');
ATS_PrintTestStatus("position after reading after seeking", f.position() == 8);
ATS_PrintTestStatus("reading after reading after seeking", f.read() == '8');
f.seek(3);
ATS_PrintTestStatus("position after seeking", f.position() == 3);
ATS_PrintTestStatus("peeking after seeking", f.peek() == '3');
ATS_PrintTestStatus("position after peeking after seeking", f.position() == 3);
ATS_PrintTestStatus("peeking after peeking after seeking", f.peek() == '3');
ATS_PrintTestStatus("position after peeking after seeking", f.position() == 3);
ATS_PrintTestStatus("peeking after peeking after seeking", f.read() == '3');
ATS_PrintTestStatus("position after peeking after seeking", f.position() == 4);
f.seek(1);
ATS_PrintTestStatus("position after seeking", f.position() == 1);
ATS_PrintTestStatus("peeking after seeking", f.peek() == '1');
f.seek(4);
ATS_PrintTestStatus("position after seeking", f.position() == 4);
ATS_PrintTestStatus("peeking after seeking", f.peek() == '4');
f.seek(7);
ATS_PrintTestStatus("position()", f.position() == 7);
ATS_PrintTestStatus("read()", f.read() == '7');
f.seek(0);
f.peek();
f.print("AB");
ATS_PrintTestStatus("position()", f.position() == 2);
ATS_PrintTestStatus("size()", f.size() == 10);
ATS_PrintTestStatus("read()", f.read() == '2');
f.seek(0);
ATS_PrintTestStatus("read()", f.read() == 'A');
ATS_PrintTestStatus("read()", f.read() == 'B');
ATS_PrintTestStatus("read()", f.read() == '2');
f.close();
f = SD.open("test.txt");
ATS_PrintTestStatus("SD.open()", f);
if (!f) goto done;
ATS_PrintTestStatus("position()", f.position() == 0);
ATS_PrintTestStatus("size()", f.size() == 10);
ATS_PrintTestStatus("peek()", f.peek() == 'A');
ATS_PrintTestStatus("read()", f.read() == 'A');
f.seek(4);
ATS_PrintTestStatus("position()", f.position() == 4);
ATS_PrintTestStatus("size()", f.size() == 10);
ATS_PrintTestStatus("peek()", f.peek() == '4');
ATS_PrintTestStatus("read()", f.read() == '4');
f.close();
done:
ATS_ReportMemoryUsage(startMemoryUsage);
ATS_end();
}
void loop() {}

51
libraries/ArduinoTestSuite/examples/ATS_Skeleton/ATS_Skeleton.pde
View File

@ -1,51 +0,0 @@
//************************************************************************
//* Arduino Test Example Skeleton
//* (C) 2010 by Rick Anderson
//* Open source as per standard Arduino code
//*
//************************************************************************
//* Oct 16, 2010 <ROA> Started on String Test
//************************************************************************
#include "HardwareSerial.h"
#include <ArduinoTestSuite.h>
//************************************************************************
void setup()
{
int startMemoryUsage;
//startMemoryUsage must be set directly before ATS_begin
startMemoryUsage = ATS_GetFreeMemory();
ATS_begin("Arduino", "Skeleton Test");
/*
* Test Run Start
* Test one passes because result is set to true
* Test two fails becuase result is set to false
* You can test memory for any set of tests by using the ATS_ReportMemoryUsage test
* There is also a way to print current memeory for debugging
*/
ATS_PrintTestStatus("1. Test of true test status", true);
ATS_PrintTestStatus("2. Test of false test status, this will fail.", false);
ATS_ReportMemoryUsage(startMemoryUsage);
/*
* Test Run End
*/
ATS_end();
}
//************************************************************************
void loop()
{
}

101
libraries/ArduinoTestSuite/examples/ATS_StringIndexOfMemory/ATS_StringIndexOfMemory.pde
View File

@ -1,101 +0,0 @@
//************************************************************************
//* Arduino Test Example Skeleton
//* (C) 2010 by Rick Anderson
//* Open source as per standard Arduino code
//*
//************************************************************************
//* Oct 16, 2010 <ROA> Started on String Test
//************************************************************************
#include "HardwareSerial.h"
#include <ArduinoTestSuite.h>
//************************************************************************
void setup()
{
char testName[64];
int startMemoryUsage;
/*
* Create variable for the tests.
*/
String stringOne;
int firstClosingBracket;
int firstOpeningBracket;
int secondOpeningBracket;
int secondClosingBracket;
int bodyTag;
int firstListItem;
int secondListItem;
int lastOpeningBracket;
int lastListItem;
int lastParagraph;
int secondLastGraf;
/*;
* initiate the test run
*/
startMemoryUsage = ATS_GetFreeMemory();
ATS_begin("Arduino", "String Memory Test");
// indexOf() returns the position (i.e. index) of a particular character
// in a string. For example, if you were parsing HTML tags, you could use it:
stringOne = "<HTML><HEAD><BODY>";
firstClosingBracket = stringOne.indexOf('>');
Serial.println("The index of > in the string " + stringOne + " is " + firstClosingBracket);
stringOne = "<HTML><HEAD><BODY>";
secondOpeningBracket = firstClosingBracket + 1;
secondClosingBracket = stringOne.indexOf('>', secondOpeningBracket );
Serial.println("The index of the second > in the string " + stringOne + " is " + secondClosingBracket);
// you can also use indexOf() to search for Strings:
stringOne = "<HTML><HEAD><BODY>";
bodyTag = stringOne.indexOf("<BODY>");
Serial.println("The index of the body tag in the string " + stringOne + " is " + bodyTag);
stringOne = "<UL><LI>item<LI>item<LI>item</UL>";
firstListItem = stringOne.indexOf("<LI>");
secondListItem = stringOne.indexOf("item", firstListItem + 1 );
Serial.println("The index of the second list item in the string " + stringOne + " is " + secondClosingBracket);
// lastIndexOf() gives you the last occurrence of a character or string:
lastOpeningBracket = stringOne.lastIndexOf('<');
Serial.println("The index of the last < in the string " + stringOne + " is " + lastOpeningBracket);
lastListItem = stringOne.lastIndexOf("<LI>");
Serial.println("The index of the last list item in the string " + stringOne + " is " + lastListItem);
// lastIndexOf() can also search for a string:
stringOne = "<p>Lorem ipsum dolor sit amet</p><p>Ipsem</p><p>Quod</p>";
lastParagraph = stringOne.lastIndexOf("<p");
secondLastGraf = stringOne.lastIndexOf("<p", lastParagraph - 1);
Serial.println("The index of the second last paragraph tag " + stringOne + " is " + secondLastGraf);
ATS_ReportMemoryUsage(startMemoryUsage);
/*
* Test complete
*/
ATS_end();
}
//************************************************************************
void loop()
{
}

183
libraries/ArduinoTestSuite/examples/ATS_StringTest/ATS_StringTest.pde
View File

@ -1,183 +0,0 @@
//************************************************************************
//* Arduino String Test
//* (C) 2010 by Rick Anderson
//* Open source as per standard Arduino code
//*
//************************************************************************
//* Oct 16, 2010 <ROA> Started on String Test
//************************************************************************
#include "HardwareSerial.h"
#include <ArduinoTestSuite.h>
//************************************************************************
void setup()
{
int startMemoryUsage;
ATS_begin("Arduino", "Test of String Library");
/*
* Test Variable Setup
* Best practive set all your test variables prior to teseting.
* This is required for Memory tests.
*/
String stringOne = String("stringThree = ");
String stringTwo = String("this string");
String stringThree = String ();
char charResult[100];
/*
* Run the tests
*/
// adding a constant integer to a string:
stringThree = stringOne + 123;
//strcpy(charResult, "\0");
stringThree.toCharArray(charResult, sizeof(charResult));
ATS_PrintTestStatus("1. Adding a constant integer to a string:", strcmp(charResult,"stringThree = 123" ) == 0);
// adding a constant long interger to a string:
stringThree = stringOne + 123456789;
stringThree.toCharArray(charResult, sizeof(charResult));
ATS_PrintTestStatus("2. Adding a constant long interger to a string", strcmp(charResult,"stringThree = 123456789" ) == 0);
// adding a constant character to a string:
stringThree = stringOne + 'A';
stringThree.toCharArray(charResult, sizeof(charResult));
ATS_PrintTestStatus("3. Adding a constant character to a string", strcmp(charResult,"stringThree = A" ) == 0);
// adding a constant string to a string:
stringThree = stringOne + "abc";
stringThree.toCharArray(charResult, sizeof(charResult));
ATS_PrintTestStatus("4. Adding a constant string variable to a string", strcmp(charResult,"stringThree = abc" ) == 0);
//"5. Adding a constant long interger to a string"
stringThree = stringOne + stringTwo;
stringThree.toCharArray(charResult, sizeof(charResult));
ATS_PrintTestStatus("5. Adding a constant long interger to a string", strcmp(charResult,"stringThree = this string" ) == 0);
/*
* setup up String Comparison Operater Tests
*/
stringOne = String("this");
stringTwo = String("that");
// two strings equal:
ATS_PrintTestStatus("6. Two strings equal",stringOne == "this");
// two strings not equal:
ATS_PrintTestStatus("7. Two strings not equal",stringOne != stringTwo);
// two strings not equal (case sensitivity matters):
stringOne = "This";
stringTwo = "this";
ATS_PrintTestStatus("8. Two strings not equal [case sensitivity matters]", stringOne != stringTwo);
// you can also use equals() to see if two strings are the same:
stringOne = "this";
stringTwo = "this";
ATS_PrintTestStatus("9. Equals() method equals", stringOne.equals(stringTwo));
// you can also use not equals() to see if two strings are not the same:
stringOne = String("This");
stringTwo = String("this");
ATS_PrintTestStatus("10. Not equals() method equals", !stringOne.equals(stringTwo));
// or perhaps you want to ignore case:
ATS_PrintTestStatus("11. EqualsIgnoreCase() method equals", stringOne.equalsIgnoreCase(stringTwo));
// a numeric string compared to the number it represents:
stringOne = "1";
int numberOne = 1;
ATS_PrintTestStatus("12. A numeric string compared to the number it represents", stringOne == numberOne);
// two numeric strings compared:
stringOne = "2";
stringTwo = "1";
ATS_PrintTestStatus("13. Two numeric strings compared",stringOne >= stringTwo);
// comparison operators can be used to compare strings for alphabetic sorting too:
/*
stringOne = String("Brown");
ATS_PrintTestStatus("14. comparison operator < can be used to compare strings for alphabetic sorting ",stringOne < "Charles");
ATS_PrintTestStatus("15. comparison operator > can be used to compare strings for alphabetic sorting ",stringOne > "Adams");
ATS_PrintTestStatus("16. comparison operator <= can be used to compare strings for alphabetic sorting ",stringOne <= "Browne");
ATS_PrintTestStatus("17. comparison operator >= can be used to compare strings for alphabetic sorting ",stringOne >= "Brow");
*/
// the compareTo() operator also allows you to compare strings
stringOne = "Cucumber";
stringTwo = "Cucuracha";
ATS_PrintTestStatus("18. The compareTo() operator also allows you to compare strings", stringOne.compareTo(stringTwo) < 0);
// compareTo() String with numnber > String with number:
stringOne = "Sensor: 50";
stringTwo= "Sensor: 150";
ATS_PrintTestStatus("19. The compareTo() String with integers", stringOne.compareTo(stringTwo) < 0);
// compareTo() String with numnber > String with number append integer, matches example code:
stringOne = "Sensor: ";
stringTwo= "Sensor: ";
stringOne += 50;
stringTwo += 150;
ATS_PrintTestStatus("20. The compareTo() compare strings with appended integers", stringOne.compareTo(stringTwo) < 0);
/*
* setup up String Append Operation Tests
*/
// Serious awful problem here
stringOne = String("Sensor ");
stringTwo = String("value");
stringOne += stringTwo;
ATS_PrintTestStatus("21. Adding string to string += ", stringOne.equals("Sensor value"));
ATS_PrintTestStatus("22. The compareTo() compare strings with appended integers", stringOne.compareTo(stringTwo) < 0);
/*
* Test complete
*/
ATS_end();
}
//************************************************************************
void loop()
{
}

61
libraries/ArduinoTestSuite/examples/ATS_String_Addition/ATS_String_Addition.pde
View File

@ -1,61 +0,0 @@
#include <ArduinoTestSuite.h>
void Test_Equal(char *testString, char *expected, const String &actual)
{
char buf[100]; actual.toCharArray(buf, 100);
boolean b = (strcmp(buf, expected) == 0);
ATS_PrintTestStatus(testString, b);
if (!b) {
Serial.print("expected '");
Serial.print(expected);
Serial.print("', actual '");
Serial.print(actual);
Serial.println("'");
}
}
void setup()
{
ATS_begin("Arduino", "String Addition Test");
String stringOne = String("string");
String stringTwo = String("other");
String stringThree = stringOne + stringTwo;
Test_Equal("Add strings", "stringother", stringThree);
Test_Equal("Adding strings doesn't change them", "string", stringOne);
Test_Equal("Adding strings doesn't change them", "other", stringTwo);
Test_Equal("Add strings", "stringotherstringstringstringother", stringOne + stringTwo + stringOne + stringOne + stringOne + stringTwo);
Test_Equal("Add string to integer", "string12345", stringOne + 12345);
Test_Equal("Add string to negative integer", "string-12345", stringOne + -12345);
Test_Equal("Add integer to string", "123string", 123 + stringOne);
Test_Equal("Add string to integers", "string123456789", stringOne + 123 + 456 + 789);
Test_Equal("Add integer to string", "123string456789", 123 + stringOne + 456 + 789);
Test_Equal("Add string to long", "string123456789", stringOne + 123456789L);
Test_Equal("Add string to negative long", "string-123456789", stringOne + -123456789L);
Test_Equal("Add string to unsigned long", "string123456789", stringOne + 123456789UL);
Test_Equal("Add string to byte", "string123", stringOne + byte(123));
Test_Equal("Add char", "stringA", stringOne + 'A');
Test_Equal("Add char", "Astring", 'A' + stringOne);
Test_Equal("Add \"string\"", "stringabc", stringOne + "abc");
Test_Equal("Add \"string\"", "abcstring", "abc" + stringOne);
Test_Equal("Add multiple \"string\"", "stringabcdef", stringOne + "abc" + "def");
Test_Equal("Add multiple \"string\"", "abcstringdef", "abc" + stringOne + "def");
Test_Equal("Add \"string\" and int", "bc", "abc" + 1);
ATS_end();
}
void loop() {}

249
libraries/ArduinoTestSuite/examples/ATS_ToneTest/ATS_ToneTest.pde
View File

@ -1,249 +0,0 @@
//************************************************************************
//* Arduino Test Suite
//* ATS_ToneTest
//*
//* Copyright (c) 2010 Mark Sproul 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
//************************************************************************
//* Aug 31, 2010 <MLS> Started on TestArduino
//* Oct 23, 2010 <MLS> Started on ToneTest
//************************************************************************
#include "HardwareSerial.h"
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)
#define kBoard_PinCount 20
#define kBoard_AnalogCount 6
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define kBoard_PinCount 70
#define kBoard_AnalogCount 16
#endif
#include <ArduinoTestSuite.h>
//************************************************************************
void TestTonePin(uint8_t toneOutputPinNumber)
{
uint8_t helperpin;
unsigned long startMilliSecs;
unsigned long highCount, lowCount;
int previousState;
int currentState;
char testNameString[80];
long outputFreq;
long measuredFreq;
boolean passed;
long percentError;
long deltaFreq;
if ((toneOutputPinNumber % 2) == 0)
{
//* if its EVEN, add 1
helperpin = toneOutputPinNumber + 1;
}
else
{
//* if its ODD
helperpin = toneOutputPinNumber - 1;
}
//* dont set the mode of the OUTPUT pin, the tone command does that
pinMode(helperpin, INPUT);
previousState = digitalRead(helperpin);
startMilliSecs = millis();
highCount = 0;
lowCount = 0;
measuredFreq = 0;
//* we are going to watch for one second
outputFreq = random(200, 2000);
tone(toneOutputPinNumber, outputFreq);
while ((millis() - startMilliSecs) < 1000)
{
currentState = digitalRead(helperpin);
if (currentState == HIGH)
{
highCount++;
}
else
{
lowCount++;
}
//* check to see if it changed state
if ((currentState == HIGH) && (previousState == LOW))
{
measuredFreq++;
}
previousState = currentState;
}
noTone(toneOutputPinNumber);
deltaFreq = abs(measuredFreq - outputFreq);
percentError = 100 - abs(((outputFreq - deltaFreq) * 100) / outputFreq);
sprintf(testNameString, "ToneTest.%02d (out freq= %4ld measured freq= %4ld err= %ld%%)", toneOutputPinNumber, outputFreq, measuredFreq, percentError);
if (percentError < 5)
{
passed = true;
}
else
{
passed = false;
}
ATS_PrintTestStatus(testNameString, passed);
}
//************************************************************************
//* this test to make sure the duration option works
void TestToneDuration(uint8_t toneOutputPinNumber)
{
uint8_t helperpin;
unsigned long startMilliSecs;
unsigned long highCount, lowCount;
int previousState;
int currentState;
char testNameString[80];
long outputFreq;
long measuredFreq;
boolean passed;
long percentError;
long deltaFreq;
long durationTime;
if ((toneOutputPinNumber % 2) == 0)
{
//* if its EVEN, add 1
helperpin = toneOutputPinNumber + 1;
}
else
{
//* if its ODD
helperpin = toneOutputPinNumber - 1;
}
//* dont set the mode of the OUTPUT pin, the tone command does that
pinMode(helperpin, INPUT);
previousState = digitalRead(helperpin);
startMilliSecs = millis();
highCount = 0;
lowCount = 0;
measuredFreq = 0;
durationTime = 0;
//* we are going to watch for one second
outputFreq = random(500, 2000);
tone(toneOutputPinNumber, outputFreq, 1000);
while ((millis() - startMilliSecs) < 2000)
{
currentState = digitalRead(helperpin);
if (currentState == HIGH)
{
highCount++;
}
else
{
lowCount++;
}
//* count the freq
if ((currentState == HIGH) && (previousState == LOW))
{
measuredFreq++;
}
//* check to see if it changed state
if (currentState != previousState)
{
durationTime = millis() - startMilliSecs;
}
previousState = currentState;
}
deltaFreq = abs(measuredFreq - outputFreq);
percentError = 100 - abs(((outputFreq - deltaFreq) * 100) / outputFreq);
sprintf(testNameString, "ToneTesDurationt.%02d (durationTime =%4ld/1000 freq err= %ld%%)", toneOutputPinNumber, durationTime, percentError);
if ((durationTime > 990) && (durationTime < 1010) && (percentError < 5))
{
passed = true;
}
else
{
passed = false;
}
noTone(toneOutputPinNumber);
ATS_PrintTestStatus(testNameString, passed);
}
//************************************************************************
void setup()
{
short ii;
uint8_t timerNumber;
int startMemoryUsage;
startMemoryUsage = ATS_GetFreeMemory();
ATS_begin("Arduino", "ToneTest");
//* we start at 2 because 0/1 are RXD/TXD
for (ii=2; ii<kBoard_PinCount; ii++)
{
TestTonePin(ii);
}
//* we dont need to test every pin
for (ii=2; ii<kBoard_PinCount; ii += 5)
{
TestToneDuration(ii);
}
ATS_ReportMemoryUsage(startMemoryUsage);
ATS_end();
}
//************************************************************************
void loop()
{
}

61
libraries/ArduinoTestSuite/examples/ATS_Write_Print/ATS_Write_Print.ino
View File

@ -1,61 +0,0 @@
#include <ArduinoTestSuite.h>
void Test_Equal(long actual, long expected)
{
char buf[100];
boolean b = expected == actual;
ATS_PrintTestStatus("", b);
if (!b) {
Serial.print("expected '");
Serial.print(expected);
Serial.print("', actual '");
Serial.print(actual);
Serial.println("'");
}
}
void setup()
{
byte buf[5] = { 65, 66, 67, 0, 69 };
ATS_begin("Arduino", "Write & Print Return Values Test");
Test_Equal(Serial.write('a'), 1);
Test_Equal(Serial.write(byte(0)), 1);
Test_Equal(Serial.write("abc"), 3);
Test_Equal(Serial.write(""), 0);
Test_Equal(Serial.write(buf, 5), 5);
Test_Equal(Serial.print(0), 1);
Test_Equal(Serial.print(""), 0);
Test_Equal(Serial.print("abc"), 3);
Test_Equal(Serial.print(0), 1);
Test_Equal(Serial.print(1), 1);
Test_Equal(Serial.print(11), 2);
Test_Equal(Serial.print(12345), 5);
Test_Equal(Serial.print(-1), 2);
Test_Equal(Serial.print(-123), 4);
Test_Equal(Serial.println(), 2);
Test_Equal(Serial.println(""), 2);
Test_Equal(Serial.println("abc"), 5);
Test_Equal(Serial.println(0), 3);
Test_Equal(Serial.println(1), 3);
Test_Equal(Serial.println(11), 4);
Test_Equal(Serial.println(12345), 7);
Test_Equal(Serial.println(-1), 4);
Test_Equal(Serial.println(-123), 6);
ATS_end();
}
void loop() {}

0
libraries/EEPROM/examples/eeprom_clear/eeprom_clear.pde → libraries/EEPROM/examples/eeprom_clear/eeprom_clear.ino
View File

0
libraries/EEPROM/examples/eeprom_read/eeprom_read.pde → libraries/EEPROM/examples/eeprom_read/eeprom_read.ino
View File

0
libraries/EEPROM/examples/eeprom_write/eeprom_write.pde → libraries/EEPROM/examples/eeprom_write/eeprom_write.ino
View File

8
libraries/Ethernet/Dhcp.cpp
View File

@ -271,11 +271,19 @@ uint8_t DhcpClass::parseDHCPResponse(unsigned long responseTimeout, uint32_t& tr
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 :

4
libraries/Ethernet/Dhcp.h
View File

@ -4,7 +4,7 @@
#ifndef Dhcp_h
#define Dhcp_h
#include "Udp.h"
#include "EthernetUdp.h"
/* DHCP state machine. */
#define STATE_DHCP_START 0
@ -139,7 +139,7 @@ private:
uint8_t _dhcpGatewayIp[4];
uint8_t _dhcpDhcpServerIp[4];
uint8_t _dhcpDnsServerIp[4];
UDP _dhcpUdpSocket;
EthernetUDP _dhcpUdpSocket;
void presend_DHCP();
void send_DHCP_MESSAGE(uint8_t, uint16_t);

2
libraries/Ethernet/Dns.cpp
View File

@ -3,7 +3,7 @@
// Released under Apache License, version 2.0
#include "w5100.h"
#include "Udp.h"
#include "EthernetUdp.h"
#include "util.h"
#include "Dns.h"

4
libraries/Ethernet/Dns.h
View File

@ -5,7 +5,7 @@
#ifndef DNSClient_h
#define DNSClient_h
#include <Udp.h>
#include <EthernetUdp.h>
class DNSClient
{
@ -35,7 +35,7 @@ protected:
IPAddress iDNSServer;
uint16_t iRequestId;
UDP iUdp;
EthernetUDP iUdp;
};
#endif

18
libraries/Ethernet/Ethernet.cpp
View File

@ -33,27 +33,37 @@ int EthernetClass::begin(uint8_t *mac_address)
}
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, gateway);
begin(mac_address, local_ip, dns_server, gateway);
}
void EthernetClass::begin(uint8_t *mac_address, IPAddress local_ip, IPAddress 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, gateway, subnet);
begin(mac_address, local_ip, dns_server, gateway, subnet);
}
void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress gateway, IPAddress 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;
}
IPAddress EthernetClass::localIP()

13
libraries/Ethernet/Ethernet.h
View File

@ -4,8 +4,8 @@
#include <inttypes.h>
//#include "w5100.h"
#include "IPAddress.h"
#include "Client.h"
#include "Server.h"
#include "EthernetClient.h"
#include "EthernetServer.h"
#define MAX_SOCK_NUM 4
@ -20,16 +20,17 @@ public:
// 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 gateway);
void begin(uint8_t *mac_address, IPAddress local_ip, IPAddress gateway, IPAddress subnet);
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);
IPAddress localIP();
IPAddress subnetMask();
IPAddress gatewayIP();
IPAddress dnsServerIP();
friend class Client;
friend class Server;
friend class EthernetClient;
friend class EthernetServer;
};
extern EthernetClass Ethernet;

42
libraries/Ethernet/Client.cpp → libraries/Ethernet/EthernetClient.cpp
View File

@ -8,19 +8,19 @@ extern "C" {
#include "Arduino.h"
#include "Ethernet.h"
#include "Client.h"
#include "Server.h"
#include "EthernetClient.h"
#include "EthernetServer.h"
#include "Dns.h"
uint16_t Client::_srcport = 1024;
uint16_t EthernetClient::_srcport = 1024;
Client::Client() : _sock(MAX_SOCK_NUM) {
EthernetClient::EthernetClient() : _sock(MAX_SOCK_NUM) {
}
Client::Client(uint8_t sock) : _sock(sock) {
EthernetClient::EthernetClient(uint8_t sock) : _sock(sock) {
}
int Client::connect(const char* host, uint16_t port) {
int EthernetClient::connect(const char* host, uint16_t port) {
// Look up the host first
int ret = 0;
DNSClient dns;
@ -35,7 +35,7 @@ int Client::connect(const char* host, uint16_t port) {
}
}
int Client::connect(IPAddress ip, uint16_t port) {
int EthernetClient::connect(IPAddress ip, uint16_t port) {
if (_sock != MAX_SOCK_NUM)
return 0;
@ -54,7 +54,7 @@ int Client::connect(IPAddress ip, uint16_t port) {
if (_srcport == 0) _srcport = 1024;
socket(_sock, SnMR::TCP, _srcport, 0);
if (!::connect(_sock, ip.raw_address(), port)) {
if (!::connect(_sock, rawIPAddress(ip), port)) {
_sock = MAX_SOCK_NUM;
return 0;
}
@ -70,15 +70,15 @@ int Client::connect(IPAddress ip, uint16_t port) {
return 1;
}
size_t Client::write(uint8_t b) {
size_t EthernetClient::write(uint8_t b) {
return write(&b, 1);
}
size_t Client::write(const char *str) {
size_t EthernetClient::write(const char *str) {
return write((const uint8_t *) str, strlen(str));
}
size_t Client::write(const uint8_t *buf, size_t size) {
size_t EthernetClient::write(const uint8_t *buf, size_t size) {
if (_sock == MAX_SOCK_NUM) {
setWriteError();
return 0;
@ -90,13 +90,13 @@ size_t Client::write(const uint8_t *buf, size_t size) {
return size;
}
int Client::available() {
int EthernetClient::available() {
if (_sock != MAX_SOCK_NUM)
return W5100.getRXReceivedSize(_sock);
return 0;
}
int Client::read() {
int EthernetClient::read() {
uint8_t b;
if ( recv(_sock, &b, 1) > 0 )
{
@ -110,11 +110,11 @@ int Client::read() {
}
}
int Client::read(uint8_t *buf, size_t size) {
int EthernetClient::read(uint8_t *buf, size_t size) {
return recv(_sock, buf, size);
}
int Client::peek() {
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())
@ -123,12 +123,12 @@ int Client::peek() {
return b;
}
void Client::flush() {
void EthernetClient::flush() {
while (available())
read();
}
void Client::stop() {
void EthernetClient::stop() {
if (_sock == MAX_SOCK_NUM)
return;
@ -148,7 +148,7 @@ void Client::stop() {
_sock = MAX_SOCK_NUM;
}
uint8_t Client::connected() {
uint8_t EthernetClient::connected() {
if (_sock == MAX_SOCK_NUM) return 0;
uint8_t s = status();
@ -156,14 +156,14 @@ uint8_t Client::connected() {
(s == SnSR::CLOSE_WAIT && !available()));
}
uint8_t Client::status() {
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
// Server::available() as the condition in an if-statement.
// EthernetServer::available() as the condition in an if-statement.
Client::operator bool() {
EthernetClient::operator bool() {
return _sock != MAX_SOCK_NUM;
}

24
libraries/Ethernet/Client.h → libraries/Ethernet/EthernetClient.h
View File

@ -1,17 +1,19 @@
#ifndef client_h
#define client_h
#ifndef ethernetclient_h
#define ethernetclient_h
#include "Arduino.h"
#include "Print.h"
#include "Client.h"
#include "IPAddress.h"
class Client : public Stream {
class EthernetClient : public Client {
public:
Client();
Client(uint8_t sock);
EthernetClient();
EthernetClient(uint8_t sock);
uint8_t status();
int connect(IPAddress ip, uint16_t port);
int connect(const char *host, uint16_t port);
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 char *str);
virtual size_t write(const uint8_t *buf, size_t size);
@ -20,11 +22,11 @@ public:
virtual int read(uint8_t *buf, size_t size);
virtual int peek();
virtual void flush();
void stop();
uint8_t connected();
operator bool();
virtual void stop();
virtual uint8_t connected();
virtual operator bool();
friend class Server;
friend class EthernetServer;
private:
static uint16_t _srcport;

28
libraries/Ethernet/Server.cpp → libraries/Ethernet/EthernetServer.cpp
View File

@ -5,18 +5,18 @@ extern "C" {
}
#include "Ethernet.h"
#include "Client.h"
#include "Server.h"
#include "EthernetClient.h"
#include "EthernetServer.h"
Server::Server(uint16_t port)
EthernetServer::EthernetServer(uint16_t port)
{
_port = port;
}
void Server::begin()
void EthernetServer::begin()
{
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
Client client(sock);
EthernetClient client(sock);
if (client.status() == SnSR::CLOSED) {
socket(sock, SnMR::TCP, _port, 0);
listen(sock);
@ -26,12 +26,12 @@ void Server::begin()
}
}
void Server::accept()
void EthernetServer::accept()
{
int listening = 0;
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
Client client(sock);
EthernetClient client(sock);
if (EthernetClass::_server_port[sock] == _port) {
if (client.status() == SnSR::LISTEN) {
@ -48,12 +48,12 @@ void Server::accept()
}
}
Client Server::available()
EthernetClient EthernetServer::available()
{
accept();
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
Client client(sock);
EthernetClient client(sock);
if (EthernetClass::_server_port[sock] == _port &&
(client.status() == SnSR::ESTABLISHED ||
client.status() == SnSR::CLOSE_WAIT)) {
@ -64,27 +64,27 @@ Client Server::available()
}
}
return Client(MAX_SOCK_NUM);
return EthernetClient(MAX_SOCK_NUM);
}
size_t Server::write(uint8_t b)
size_t EthernetServer::write(uint8_t b)
{
write(&b, 1);
}
size_t Server::write(const char *str)
size_t EthernetServer::write(const char *str)
{
write((const uint8_t *)str, strlen(str));
}
size_t Server::write(const uint8_t *buffer, size_t size)
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++) {
Client client(sock);
EthernetClient client(sock);
if (EthernetClass::_server_port[sock] == _port &&
client.status() == SnSR::ESTABLISHED) {

Some files were not shown because too many files have changed in this diff Show More