arduinotestsuite.cpp

ArduinoTestSuite

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