diff --git a/libraries/ArduinoTestSuite/ArduinoTestSuite.cpp b/libraries/ArduinoTestSuite/ArduinoTestSuite.cpp new file mode 100644 index 000000000..845e2efef --- /dev/null +++ b/libraries/ArduinoTestSuite/ArduinoTestSuite.cpp @@ -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 Started on TestArduino +//* Oct 18, 2010 Added memory testing +//************************************************************************ + +#include +#include +#include + + + +#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; +} + + diff --git a/libraries/ArduinoTestSuite/ArduinoTestSuite.h b/libraries/ArduinoTestSuite/ArduinoTestSuite.h new file mode 100644 index 000000000..9501d67a2 --- /dev/null +++ b/libraries/ArduinoTestSuite/ArduinoTestSuite.h @@ -0,0 +1,74 @@ +//************************************************************************ +//************************************************************************ +//* Aug 31, 2010 Started on TestArduino +//************************************************************************ + +#ifndef _AVR_IO_H_ + #include +#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 + diff --git a/libraries/ArduinoTestSuite/avr_cpunames.h b/libraries/ArduinoTestSuite/avr_cpunames.h new file mode 100644 index 000000000..80832164c --- /dev/null +++ b/libraries/ArduinoTestSuite/avr_cpunames.h @@ -0,0 +1,186 @@ +//************************************************************************************************** +//* +//* Atmel AVR CPU name strings +//* +//************************************************************************************************** +//* Sep 19, 2010 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 diff --git a/libraries/ArduinoTestSuite/examples/ATS_Constants/ATS_Constants.pde b/libraries/ArduinoTestSuite/examples/ATS_Constants/ATS_Constants.pde new file mode 100644 index 000000000..d58e8bac6 --- /dev/null +++ b/libraries/ArduinoTestSuite/examples/ATS_Constants/ATS_Constants.pde @@ -0,0 +1,76 @@ +//************************************************************************ +//* Arduino Test of Arduino Constants +//* (C) 2010 by Rick Anderson +//* Open source as per standard Arduino code +//* +//************************************************************************ +//* Oct 16, 2010 Test of Arduino Constants +//************************************************************************ + +#include "WProgram.h" +#include "HardwareSerial.h" +#include + +//************************************************************************ +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() +{ + + +} + + + + + diff --git a/libraries/ArduinoTestSuite/examples/ATS_Delay/ATS_Delay.pde b/libraries/ArduinoTestSuite/examples/ATS_Delay/ATS_Delay.pde new file mode 100644 index 000000000..8ac9fd202 --- /dev/null +++ b/libraries/ArduinoTestSuite/examples/ATS_Delay/ATS_Delay.pde @@ -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 Started on TestArduino //* Oct 28, 2010 Started on Delay //************************************************************************ #include "WProgram.h" #include "HardwareSerial.h" #include //************************************************************************ 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() { } \ No newline at end of file diff --git a/libraries/ArduinoTestSuite/examples/ATS_General/ATS_General.pde b/libraries/ArduinoTestSuite/examples/ATS_General/ATS_General.pde new file mode 100644 index 000000000..502248a23 --- /dev/null +++ b/libraries/ArduinoTestSuite/examples/ATS_General/ATS_General.pde @@ -0,0 +1,94 @@ +//************************************************************************ +//* Arduino Test Suite +//* (C) 2010 by Mark Sproul +//* Open source as per standard Arduino code +//* +//************************************************************************ +//* Aug 31, 2010 Started on TestArduino +//* Oct 18, 2010 Added memory testing +//************************************************************************ + +#include "WProgram.h" +#include "HardwareSerial.h" +#include "pins_arduino.h" +#include +#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 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() +{ + + +} + + + + + diff --git a/libraries/ArduinoTestSuite/examples/ATS_Skeleton/ATS_Skeleton.pde b/libraries/ArduinoTestSuite/examples/ATS_Skeleton/ATS_Skeleton.pde new file mode 100644 index 000000000..33fc81680 --- /dev/null +++ b/libraries/ArduinoTestSuite/examples/ATS_Skeleton/ATS_Skeleton.pde @@ -0,0 +1,52 @@ +//************************************************************************ +//* Arduino Test Example Skeleton +//* (C) 2010 by Rick Anderson +//* Open source as per standard Arduino code +//* +//************************************************************************ +//* Oct 16, 2010 Started on String Test +//************************************************************************ + +#include "WProgram.h" +#include "HardwareSerial.h" +#include + +//************************************************************************ +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() +{ + + +} + + + + diff --git a/libraries/ArduinoTestSuite/examples/ATS_StringIndexOfMemory/ATS_StringIndexOfMemory.pde b/libraries/ArduinoTestSuite/examples/ATS_StringIndexOfMemory/ATS_StringIndexOfMemory.pde new file mode 100644 index 000000000..71a6bea19 --- /dev/null +++ b/libraries/ArduinoTestSuite/examples/ATS_StringIndexOfMemory/ATS_StringIndexOfMemory.pde @@ -0,0 +1,102 @@ +//************************************************************************ +//* Arduino Test Example Skeleton +//* (C) 2010 by Rick Anderson +//* Open source as per standard Arduino code +//* +//************************************************************************ +//* Oct 16, 2010 Started on String Test +//************************************************************************ + +#include "WProgram.h" +#include "HardwareSerial.h" +#include + +//************************************************************************ +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 = ""; + firstClosingBracket = stringOne.indexOf('>'); + Serial.println("The index of > in the string " + stringOne + " is " + firstClosingBracket); + + stringOne = ""; + 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 = ""; + bodyTag = stringOne.indexOf(""); + Serial.println("The index of the body tag in the string " + stringOne + " is " + bodyTag); + + stringOne = "
  • item
  • item
  • item
"; + firstListItem = stringOne.indexOf("
  • "); + 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("
  • "); + Serial.println("The index of the last list item in the string " + stringOne + " is " + lastListItem); + + + // lastIndexOf() can also search for a string: + stringOne = "

    Lorem ipsum dolor sit amet

    Ipsem

    Quod

    "; + lastParagraph = stringOne.lastIndexOf(" Started on String Test +//************************************************************************ + +#include "WProgram.h" +#include "HardwareSerial.h" +#include + +//************************************************************************ +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() +{ + + +} + + + + + + + + + + + + diff --git a/libraries/ArduinoTestSuite/examples/ATS_ToneTest/ATS_ToneTest.pde b/libraries/ArduinoTestSuite/examples/ATS_ToneTest/ATS_ToneTest.pde new file mode 100644 index 000000000..8bec6be2a --- /dev/null +++ b/libraries/ArduinoTestSuite/examples/ATS_ToneTest/ATS_ToneTest.pde @@ -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 Started on TestArduino +//* Oct 23, 2010 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 + +//************************************************************************ +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