rooty/Arduino
1
0
Fork 0
mirror of https://github.com/arduino/Arduino.git synced 2025-02-17 11:54:33 +01:00
Code Issues Releases Activity

Merge branch 'master' into new-extension

Browse Source
This commit is contained in:
David A. Mellis 2010-11-10 12:15:28 -05:00
commit dc3b815c29
15 changed files with 1896 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -789,6 +789,7 @@ public class Base {
// This will store the sketch count as zero
editors.remove(editor);
Editor.serialMonitor.closeSerialPort();
storeSketches();
// Save out the current prefs state
@ -826,6 +827,7 @@ public class Base {
// If quit is canceled, this will be replaced anyway
// by a later handleQuit() that is not canceled.
storeSketches();
Editor.serialMonitor.closeSerialPort();
if (handleQuitEach()) {
// make sure running sketches close before quitting

6
app/src/processing/app/Editor.java
View File

@ -151,7 +151,7 @@ public class Editor extends JFrame implements RunnerListener {
super("Arduino");
this.base = ibase;
//Base.setIcon(this);
Base.setIcon(this);
// Install default actions for Run, Present, etc.
resetHandlers();
@ -2392,10 +2392,10 @@ public class Editor extends JFrame implements RunnerListener {
if (uploading) return;
try {
serialMonitor.openSerialPort();
serialMonitor.openSerialPort();
serialMonitor.setVisible(true);
} catch (SerialException e) {
statusError(e);
statusError(e);
}
}

46
app/src/processing/app/SerialMonitor.java
View File

@ -19,6 +19,7 @@
package processing.app;
import processing.app.debug.MessageConsumer;
import processing.core.*;
import java.awt.*;
import java.awt.event.*;
@ -106,6 +107,14 @@ public class SerialMonitor extends JFrame implements MessageConsumer {
autoscrollBox = new JCheckBox("Autoscroll", true);
lineEndings = new JComboBox(new String[] { "No line ending", "Newline", "Carriage return", "Both NL & CR" });
lineEndings.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
Preferences.setInteger("serial.line_ending", lineEndings.getSelectedIndex());
}
});
if (Preferences.get("serial.line_ending") != null) {
lineEndings.setSelectedIndex(Preferences.getInteger("serial.line_ending"));
}
lineEndings.setMaximumSize(lineEndings.getMinimumSize());
String[] serialRateStrings = {
@ -127,7 +136,7 @@ public class SerialMonitor extends JFrame implements MessageConsumer {
Preferences.set("serial.debug_rate", rateString);
closeSerialPort();
try {
openSerialPort();
openSerialPort();
} catch (SerialException e) {
System.err.println(e);
}
@ -144,8 +153,40 @@ public class SerialMonitor extends JFrame implements MessageConsumer {
getContentPane().add(pane, BorderLayout.SOUTH);
pack();
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
if (Preferences.get("last.screen.height") != null) {
// if screen size has changed, the window coordinates no longer
// make sense, so don't use them unless they're identical
int screenW = Preferences.getInteger("last.screen.width");
int screenH = Preferences.getInteger("last.screen.height");
if ((screen.width == screenW) && (screen.height == screenH)) {
String locationStr = Preferences.get("last.serial.location");
if (locationStr != null) {
int[] location = PApplet.parseInt(PApplet.split(locationStr, ','));
setPlacement(location);
}
}
}
}
protected void setPlacement(int[] location) {
setBounds(location[0], location[1], location[2], location[3]);
}
protected int[] getPlacement() {
int[] location = new int[4];
// Get the dimensions of the Frame
Rectangle bounds = getBounds();
location[0] = bounds.x;
location[1] = bounds.y;
location[2] = bounds.width;
location[3] = bounds.height;
return location;
}
private void send(String s) {
if (serial != null) {
switch (lineEndings.getSelectedIndex()) {
@ -166,6 +207,9 @@ public class SerialMonitor extends JFrame implements MessageConsumer {
public void closeSerialPort() {
if (serial != null) {
int[] location = getPlacement();
String locationStr = PApplet.join(PApplet.str(location), ",");
Preferences.set("last.serial.location", locationStr);
textArea.setText("");
serial.dispose();
serial = null;

25
core/src/processing/core/PApplet.java
View File

@ -6957,18 +6957,19 @@ public class PApplet extends Applet
* GIF image of the Processing logo.
*/
static public final byte[] ICON_IMAGE = {
71, 73, 70, 56, 57, 97, 16, 0, 16, 0, -77, 0, 0, 0, 0, 0, -1, -1, -1, 12,
12, 13, -15, -15, -14, 45, 57, 74, 54, 80, 111, 47, 71, 97, 62, 88, 117,
1, 14, 27, 7, 41, 73, 15, 52, 85, 2, 31, 55, 4, 54, 94, 18, 69, 109, 37,
87, 126, -1, -1, -1, 33, -7, 4, 1, 0, 0, 15, 0, 44, 0, 0, 0, 0, 16, 0, 16,
0, 0, 4, 122, -16, -107, 114, -86, -67, 83, 30, -42, 26, -17, -100, -45,
56, -57, -108, 48, 40, 122, -90, 104, 67, -91, -51, 32, -53, 77, -78, -100,
47, -86, 12, 76, -110, -20, -74, -101, 97, -93, 27, 40, 20, -65, 65, 48,
-111, 99, -20, -112, -117, -123, -47, -105, 24, 114, -112, 74, 69, 84, 25,
93, 88, -75, 9, 46, 2, 49, 88, -116, -67, 7, -19, -83, 60, 38, 3, -34, 2,
66, -95, 27, -98, 13, 4, -17, 55, 33, 109, 11, 11, -2, -128, 121, 123, 62,
91, 120, -128, 127, 122, 115, 102, 2, 119, 0, -116, -113, -119, 6, 102,
121, -108, -126, 5, 18, 6, 4, -102, -101, -100, 114, 15, 17, 0, 59
71, 73, 70, 56, 57, 97, 16, 0, 16, 0, -60, 0, 0, 0, 0, 0,
0, 0, -127, 0, -127, 0, 0, -127, -127, -127, 0, 0, -127, 0, -127, -127,
-127, 0, -127, -127, -127, -63, -63, -63, 0, 0, -1, 0, -1, 0, 0, -1,
-1, -1, 0, 0, -1, 0, -1, -1, -1, 0, -1, -1, -1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 33, -7, 4,
9, 0, 0, 16, 0, 44, 0, 0, 0, 0, 16, 0, 16, 0, 0, 5,
75, 32, 36, -118, -57, 96, 14, -57, -88, 66, -27, -23, -90, -86, 43, -97,
99, 59, -65, -30, 125, -77, 3, -14, -4, 8, -109, 15, -120, -22, 61, 78,
15, -124, 15, 25, 28, 28, 93, 63, -45, 115, -22, -116, 90, -83, 82, 89,
-44, -103, 61, 44, -91, -54, -89, 19, -111, 50, 18, -51, -55, 1, 73, -121,
-53, -79, 77, 43, -101, 12, -74, -30, -99, -24, -94, 16, 0, 59,
};

119
hardware/arduino/cores/arduino/Tone.cpp
View File

@ -28,7 +28,7 @@ Version Modified By Date Comments
09/11/25 Changed pin toggle method to XOR
09/11/25 Fixed timer0 from being excluded
0006 D Mellis 09/12/29 Replaced objects with functions
0007 M Sproul 10/08/29 Changed #ifdefs from cpu to register
*************************************************/
#include <avr/interrupt.h>
@ -36,7 +36,7 @@ Version Modified By Date Comments
#include "wiring.h"
#include "pins_arduino.h"
#if defined(__AVR_ATmega8__)
#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
#define TCCR2A TCCR2
#define TCCR2B TCCR2
#define COM2A1 COM21
@ -66,19 +66,26 @@ volatile long timer2_toggle_count;
volatile uint8_t *timer2_pin_port;
volatile uint8_t timer2_pin_mask;
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#if defined(TIMSK3)
volatile long timer3_toggle_count;
volatile uint8_t *timer3_pin_port;
volatile uint8_t timer3_pin_mask;
#endif
#if defined(TIMSK4)
volatile long timer4_toggle_count;
volatile uint8_t *timer4_pin_port;
volatile uint8_t timer4_pin_mask;
#endif
#if defined(TIMSK5)
volatile long timer5_toggle_count;
volatile uint8_t *timer5_pin_port;
volatile uint8_t timer5_pin_mask;
#endif
// MLS: This does not make sense, the 3 options are the same
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define AVAILABLE_TONE_PINS 1
@ -133,7 +140,7 @@ static int8_t toneBegin(uint8_t _pin)
// whereas 16 bit timers are set to either ck/1 or ck/64 prescalar
switch (_timer)
{
#if !defined(__AVR_ATmega8__)
#if defined(TCCR0A) && defined(TCCR0B)
case 0:
// 8 bit timer
TCCR0A = 0;
@ -143,8 +150,9 @@ static int8_t toneBegin(uint8_t _pin)
timer0_pin_port = portOutputRegister(digitalPinToPort(_pin));
timer0_pin_mask = digitalPinToBitMask(_pin);
break;
#endif
#endif
#if defined(TCCR1A) && defined(TCCR1B) && defined(WGM12)
case 1:
// 16 bit timer
TCCR1A = 0;
@ -154,6 +162,9 @@ static int8_t toneBegin(uint8_t _pin)
timer1_pin_port = portOutputRegister(digitalPinToPort(_pin));
timer1_pin_mask = digitalPinToBitMask(_pin);
break;
#endif
#if defined(TCCR2A) && defined(TCCR2B)
case 2:
// 8 bit timer
TCCR2A = 0;
@ -163,8 +174,9 @@ static int8_t toneBegin(uint8_t _pin)
timer2_pin_port = portOutputRegister(digitalPinToPort(_pin));
timer2_pin_mask = digitalPinToBitMask(_pin);
break;
#endif
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#if defined(TCCR3A) && defined(TCCR3B) && defined(TIMSK3)
case 3:
// 16 bit timer
TCCR3A = 0;
@ -174,15 +186,27 @@ static int8_t toneBegin(uint8_t _pin)
timer3_pin_port = portOutputRegister(digitalPinToPort(_pin));
timer3_pin_mask = digitalPinToBitMask(_pin);
break;
#endif
#if defined(TCCR4A) && defined(TCCR4B) && defined(TIMSK4)
case 4:
// 16 bit timer
TCCR4A = 0;
TCCR4B = 0;
bitWrite(TCCR4B, WGM42, 1);
#if defined(WGM42)
bitWrite(TCCR4B, WGM42, 1);
#elif defined(CS43)
#warning this may not be correct
// atmega32u4
bitWrite(TCCR4B, CS43, 1);
#endif
bitWrite(TCCR4B, CS40, 1);
timer4_pin_port = portOutputRegister(digitalPinToPort(_pin));
timer4_pin_mask = digitalPinToBitMask(_pin);
break;
#endif
#if defined(TCCR5A) && defined(TCCR5B) && defined(TIMSK5)
case 5:
// 16 bit timer
TCCR5A = 0;
@ -192,7 +216,7 @@ static int8_t toneBegin(uint8_t _pin)
timer5_pin_port = portOutputRegister(digitalPinToPort(_pin));
timer5_pin_mask = digitalPinToBitMask(_pin);
break;
#endif
#endif
}
}
@ -258,12 +282,22 @@ void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
}
}
#if !defined(__AVR_ATmega8__)
#if defined(TCCR0B)
if (_timer == 0)
{
TCCR0B = prescalarbits;
}
else
#endif
#if defined(TCCR2B)
{
TCCR2B = prescalarbits;
}
#else
{
// dummy place holder to make the above ifdefs work
}
#endif
}
else
{
@ -278,12 +312,20 @@ void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
}
if (_timer == 1)
{
#if defined(TCCR1B)
TCCR1B = (TCCR1B & 0b11111000) | prescalarbits;
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#endif
}
#if defined(TCCR3B)
else if (_timer == 3)
TCCR3B = (TCCR3B & 0b11111000) | prescalarbits;
#endif
#if defined(TCCR4B)
else if (_timer == 4)
TCCR4B = (TCCR4B & 0b11111000) | prescalarbits;
#endif
#if defined(TCCR5B)
else if (_timer == 5)
TCCR5B = (TCCR5B & 0b11111000) | prescalarbits;
#endif
@ -307,7 +349,7 @@ void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
switch (_timer)
{
#if !defined(__AVR_ATmega8__)
#if defined(OCR0A) && defined(TIMSK0) && defined(OCIE0A)
case 0:
OCR0A = ocr;
timer0_toggle_count = toggle_count;
@ -316,27 +358,43 @@ void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
#endif
case 1:
#if defined(OCR1A) && defined(TIMSK1) && defined(OCIE1A)
OCR1A = ocr;
timer1_toggle_count = toggle_count;
bitWrite(TIMSK1, OCIE1A, 1);
#elif defined(OCR1A) && defined(TIMSK) && defined(OCIE1A)
// this combination is for at least the ATmega32
OCR1A = ocr;
timer1_toggle_count = toggle_count;
bitWrite(TIMSK, OCIE1A, 1);
#endif
break;
#if defined(OCR2A) && defined(TIMSK2) && defined(OCIE2A)
case 2:
OCR2A = ocr;
timer2_toggle_count = toggle_count;
bitWrite(TIMSK2, OCIE2A, 1);
break;
#endif
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#if defined(TIMSK3)
case 3:
OCR3A = ocr;
timer3_toggle_count = toggle_count;
bitWrite(TIMSK3, OCIE3A, 1);
break;
#endif
#if defined(TIMSK4)
case 4:
OCR4A = ocr;
timer4_toggle_count = toggle_count;
bitWrite(TIMSK4, OCIE4A, 1);
break;
#endif
#if defined(OCR5A) && defined(TIMSK5) && defined(OCIE5A)
case 5:
OCR5A = ocr;
timer5_toggle_count = toggle_count;
@ -356,27 +414,48 @@ void disableTimer(uint8_t _timer)
{
switch (_timer)
{
#if !defined(__AVR_ATmega8__)
case 0:
TIMSK0 = 0;
#if defined(TIMSK0)
TIMSK0 = 0;
#elif defined(TIMSK)
TIMSK = 0; // atmega32
#endif
break;
#endif
#if defined(TIMSK1) && defined(OCIE1A)
case 1:
bitWrite(TIMSK1, OCIE1A, 0);
break;
#endif
case 2:
bitWrite(TIMSK2, OCIE2A, 0); // disable interrupt
TCCR2A = (1 << WGM20);
TCCR2B = (TCCR2B & 0b11111000) | (1 << CS22);
OCR2A = 0;
#if defined(TIMSK2) && defined(OCIE2A)
bitWrite(TIMSK2, OCIE2A, 0); // disable interrupt
#endif
#if defined(TCCR2A) && defined(WGM20)
TCCR2A = (1 << WGM20);
#endif
#if defined(TCCR2B) && defined(CS22)
TCCR2B = (TCCR2B & 0b11111000) | (1 << CS22);
#endif
#if defined(OCR2A)
OCR2A = 0;
#endif
break;
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#if defined(TIMSK3)
case 3:
TIMSK3 = 0;
break;
#endif
#if defined(TIMSK4)
case 4:
TIMSK4 = 0;
break;
#endif
#if defined(TIMSK5)
case 5:
TIMSK5 = 0;
break;

715
libraries/ArduinoTestSuite/ArduinoTestSuite.cpp Normal file
View File

@ -0,0 +1,715 @@
//************************************************************************
//* 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 "WProgram.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 Normal file
View File

@ -0,0 +1,74 @@
//************************************************************************
//************************************************************************
//* Aug 31, 2010 <MLS> Started on TestArduino
//************************************************************************
#ifndef _AVR_IO_H_
#include <avr/io.h>
#endif
#ifndef WProgram_h
#include "WProgram.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 Normal file
View File

@ -0,0 +1,186 @@
//**************************************************************************************************
//*
//* 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

76
libraries/ArduinoTestSuite/examples/ATS_Constants/ATS_Constants.pde Normal file
View File

@ -0,0 +1,76 @@
//************************************************************************
//* 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 "WProgram.h"
#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 Normal file
View File

@ -0,0 +1 @@
//************************************************************************ //* 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 "WProgram.h" #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() { }

94
libraries/ArduinoTestSuite/examples/ATS_General/ATS_General.pde Normal file
View File

@ -0,0 +1,94 @@
//************************************************************************
//* 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 "WProgram.h"
#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()
{
}

52
libraries/ArduinoTestSuite/examples/ATS_Skeleton/ATS_Skeleton.pde Normal file
View File

@ -0,0 +1,52 @@
//************************************************************************
//* 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 "WProgram.h"
#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()
{
}

102
libraries/ArduinoTestSuite/examples/ATS_StringIndexOfMemory/ATS_StringIndexOfMemory.pde Normal file
View File

@ -0,0 +1,102 @@
//************************************************************************
//* 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 "WProgram.h"
#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()
{
}

184
libraries/ArduinoTestSuite/examples/ATS_StringTest/ATS_StringTest.pde Normal file
View File

@ -0,0 +1,184 @@
//************************************************************************
//* Arduino String Test
//* (C) 2010 by Rick Anderson
//* Open source as per standard Arduino code
//*
//************************************************************************
//* Oct 16, 2010 <ROA> Started on String Test
//************************************************************************
#include "WProgram.h"
#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()
{
}

250
libraries/ArduinoTestSuite/examples/ATS_ToneTest/ATS_ToneTest.pde Normal file
View File

@ -0,0 +1,250 @@
//************************************************************************
//* 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 "WProgram.h"
#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()
{
}