usart.c

butterflylogger_src_20060822 for atmel avr

//
//Atmel AVR Design Contest 2006 Registration Number AT3221
//

//***************************************************************************
//
//  File........: usart.c
//
//  Author(s)...: ATMEL Norway
//
//  Target(s)...: ATmega169
//
//  Compiler....: IAR EWAAVR 2.28a
//
//  Description.: AVR Butterfly USART routines
//
//  Revisions...: 1.0
//
//  YYYYMMDD - VER. - COMMENT                                       - SIGN.
//
//  20030116 - 1.0  - Created                                       - LHM
//
//***************************************************************************

//mtA
// only changed the includes here
//#include <inavr.h>
//#include "iom169.h"
#include <avr/io.h>
//mtE
#include "main.h"
#include "usart.h"
#include "ADC.h"
#include "BCD.h"
#include "RTC.h"
#include "alarm.h"
#include "speed.h"
#include "pgmspacehlp.h"

#include <avr/signal.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

#define SETCLOCK	 0
#define SETALARM     1

char gEOL;			//global EOL characters
int errorCount;		//global error counter used to keep track of user attempts to enter data correctly.
					//after 3 incorrect attempts most functions will terminate.

#ifdef EXTENDED_USART
const char  UART_ERROR_MSG[] PROGMEM =	"ERR:";
const char	UART_ERROR_MSG2[] PROGMEM =	"ERRS";
const char	COMPILEDATE[] PROGMEM= __DATE__ " " __TIME__ " ";
extern const char MT_AVRBF[] PROGMEM  ; // for use in status command
extern int glastSpeed;					// for use in status command
typedef void (*CMD_CALLBACK_FUNC) (char);
extern char gPowerSaveTimer;

#endif


/*****************************************************************************
*
*   Function name : USART_Init
*
*   Returns :       None
*
*   Parameters :    unsigned int baudrate
*
*   Purpose :       Initialize the USART
*
*****************************************************************************/
void USART_Init(unsigned int baudrate)
{
    // Set baud rate
    UBRRH = (unsigned char)(baudrate>>8);
    UBRRL = (unsigned char)baudrate;
	
    // Enable 2x speed
    UCSRA = (1<<U2X);
	
    // Enable receiver and transmitter
#ifdef EXTENDED_USART
    UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(0<<UDRIE);
	gUART=TRUE;// stay out of sleep mode by default
#else
		UCSRB = (1<<RXEN)|(1<<TXEN)|(0<<RXCIE)|(0<<UDRIE);
		gUART=FALSE;// only sending so go to sleep
#endif
			// Async. mode, 8N1
			UCSRC = (0<<UMSEL)|(0<<UPM0)|(0<<USBS)|(3<<UCSZ0)|(0<<UCPOL);
			
			gEOL=DEFAULT_EOL;
}


/*****************************************************************************
*
*   Function name : USART_Tx
*
*   Returns :       None
*
*   Parameters :    char data: byte to send
*
*   Purpose :       Send one byte through the USART
*
*****************************************************************************/
void USART_Tx(char data)
{
    while (!(UCSRA & (1<<UDRE)));
    UDR = data;
}


/*****************************************************************************
*
*   Function name : USART_Rx
*
*   Returns :       char: byte received
*
*   Parameters :    None
*
*   Purpose :       Receives one byte from the USART
*
*****************************************************************************/
char USART_Rx(void)
{
    while (!(UCSRA & (1<<RXC)));
    return UDR;
}


/*****************************************************************************
*
*   Function name : USART_Tx_Hex
*
*   Returns :       None
*
*   Parameters :    char data: byte to send
*
*   Purpose :       Sends one byte through the USART as a two char Hex number
*
*****************************************************************************/
void USART_Tx_Hex(char data)
{
    char low, high;
	
	high = data >> 4;
	high += '0';
    if (high > '9' ) high += 7;
	
	low = data & 0x0f;
	low += '0';
	if (low >'9') low += 7;
	
	USART_Tx(high);
	USART_Tx(low);
	
}


/*****************************************************************************
*
*   Function name : USART_Tx_Byte
*
*   Returns :       None
*
*   Parameters :    char data: byte to send
*
*   Purpose :       Sends one byte through the USART as a 2 digit decimal number
*
*****************************************************************************/
void USART_Tx_Byte(char data)
{
    char temp;
	
	temp = CHAR2BCD2(data);
	USART_Tx_Hex(temp);	
}

/*****************************************************************************
*
*   Function name : USART_Tx_Bool
*
*   Returns :       None
*
*   Parameters :    char data: byte to send
*
*   Purpose :       prints a boolean value to the usart
*
*****************************************************************************/
void USART_Tx_Bool(char data)
{
#ifdef EXTENDED_USART
	if(data){
		USART_sendmsg(PSTR("ON"));
	}else{
		USART_sendmsg(PSTR("OFF"));
	}
#else
	if(data){
		USART_Tx('1');
	}else{
		USART_Tx('0');
	}
#endif
}

/*****************************************************************************
*
*   Function name : USART_EOL
*
*   Returns :       None
*
*   Parameters :    char EOl tyoe to send. 
*
*   Purpose :       Sends EOL char(s) as specified by parameters
*
*****************************************************************************/
void USART_EOL(char eol){
	//Send apropriate EOL char
	//NOTE: EOL_WIN =EOL_MAC | EOL_UNIX so both Chars are sent.
	if (eol & EOL_MAC) USART_Tx(0x0d);
	if (eol & EOL_UNIX)	USART_Tx(0x0a);
	if (eol & EOL_TERM) USART_Tx(0x04);
	
}

//////////////////////////////////////////////////////////////////////////////
#ifdef EXTENDED_USART

const char unitlabels[]={'H','M','S','T'};	//Hour, Minute, Second, Tick
const char eolLabels[] ={'N','U','M','W','T'};	//None, Unix, Mac, Windows, EOT

//Default
void cmd_default(char shift){
	USART_Tx('?');
}

//A
void cmd_alarm(char shift){
#ifdef USART_CMD_ALARM
	if (shift){ //Set alarm
		USART_setTheClock(SETALARM);
	}
	
	//display alarm status
	ALARM_print_status();
	USART_Tx(' ');
	ALARM_print();
#endif
}

//B
void cmd_dumpB(char shift){
#ifdef USART_CMD_BDUMP
	if(shift)
		DumpFlash(DUMP_BIN);
#endif
}

//C
void cmd_clock(char shift){
#ifdef USART_CMD_CLOCK
	if(shift) // set time and date 
		USART_setTheClock(SETCLOCK);
	
	//query time and date
	USART_Tx_Byte( gHOUR);USART_Tx(':');
	USART_Tx_Byte( gMINUTE);USART_Tx(':');
	USART_Tx_Byte( gSECOND);USART_Tx(' ');
	USART_Tx_Byte( gDAY);USART_Tx('/');
	USART_Tx_Byte( gMONTH);USART_Tx('/');
	USART_Tx_Byte( gYEAR);
#endif
}

//D
void cmd_dump(char shift){
#ifdef USART_CMD_DUMP
	if(shift)// download ALL 
		DumpFlash(DUMP_ALL);
	
	else// download 
		DumpFlash(DUMP_NORMAL);
#endif
}

//E
void cmd_eol(char shift){
#ifdef USART_CMD_EOL
	if(shift){//toggle EOL chars
		gEOL++;
		if (gEOL>EOL_TERM) gEOL=EOL_NONE;		
	}
	
	//query EOL char
	USART_Tx(eolLabels[(int)gEOL]);
#endif
}

//F
void cmd_flash(char shift){
#ifdef USART_CMD_ROLLOVER
	if(shift)// toggle flash rollover
		gEnableRollover=!gEnableRollover;
	
	// query flash rollover 
	USART_Tx_Bool(gEnableRollover);
#endif
}

//G
void cmd_intervalS(char shift){
#ifdef USART_CMD_WINDINTERVAL
	char tmp;
	if(shift){//set the number of seconds to log
		if(USART_getValue(&tmp	,00,99))
			gSpeedSecondsToLog=(int) tmp*10; // enter in multiples of 10s
	}
	
	// print number actual value of gSpeedSecondsToLog
	ADC2RAW(TRUE,gSpeedSecondsToLog);
#endif
}

//I
void cmd_interval(char shift){
#ifdef USART_CMD_INTERVAL
	if(shift)//Set the logging interval
		USART_changeInterval();
	
	//display the interval
	USART_Tx(unitlabels[(int)gLogTimeUnit]);
	USART_Tx_Byte(gLogTime);
#endif
}

//L
void cmd_light(char shift){
#ifdef USART_CMD_LIGHT
	// query light level command character
	USART_sendADC(LIGHT_SENSOR,TRUE);
#endif
}

//N
void cmd_lognow(char shift){
#ifdef USART_CMD_LOGNOW
	if(shift)//Log Now
		doLogging();
	
	// show current buffer (next write)
	DF_Print_page(0,gDataPosition,DUMP_NORMAL);
#endif
}

//O
void cmd_logstatus(char shift){
#ifdef USART_CMD_LOGSTATUS
	if(shift) // toggle logging
		gLogging = !gLogging;
	// query loggin status
	USART_Tx_Bool(gLogging|glogSpeed);
#endif