serial.c

PEAKAUDIO用于EV2板的MCU控制源码

/*************************************************************************

	serial.c

	These are the routines to control the serial port and a serial stream
	on the 8051 as well as many utility routines to manipulate strings.
	The processor uses a 256 byte buffer for the serial in and out.
	Buffer pointers chase one another.

	Copyright (C) 2001-2004 by Cirrus Logic Inc. All Rights Reserved
*************************************************************************/


#include <8051.h>
#include <intrpt.h>
#include <conio.h>
#include <ctype.h>
#include "command.h"
#include "packet.h"
#include "cnmutil.h"
#include "mystrings.h"
#include "serial.h"

#define cSER_BUF_LEN	256

static unsigned char	T2MOD @ 0xC9;
static unsigned char	gPrintToPacket = 0;
static char gRXD_Buffer[ cSER_BUF_LEN ];
static char gTXD_Buffer[ cSER_BUF_LEN ];
near unsigned char gRXD_RD_idx;
near unsigned char gRXD_WR_idx;
near unsigned char gTXD_RD_idx;
near unsigned char gTXD_WR_idx;
near unsigned char gIS_Transmitting;

interrupt void serial_int();

void init_uart ( void )	{
  RCAP2H = 0xff;		//for a baud rate of...
  RCAP2L = BAUD;		//see include file for def of BAUD

  T2CON = 0x34;			//Use timer 2 for RCLK & TCLK. start timer 2
  T2MOD = 0;				//count up and don't enable output bit

  //SCON = 0xD8;			//serial 9 bit UART mode (mode 3), receiver enabled
	SCON = 0x50;
  TI = 0;
	RI = 0;						//clear the input buffer

	gRXD_RD_idx = 0;
	gRXD_WR_idx = 0;
	gTXD_RD_idx	= 0;
	gTXD_WR_idx = 0;

	ROM_VECTOR( SERIAL,serial_int );	//put interrupt vector in proper place
	gIS_Transmitting = 0;
	ES = 1;														//enable serial interrupts
}

extern void putch( char c )	{
	unsigned char temp_num;

	EA = 0;
	if ( ( gTXD_WR_idx == gTXD_RD_idx ) && ( !gIS_Transmitting ) )
		TI = 1;			//if empty then need to prime so get the transmit going
	else	{
		temp_num = gTXD_WR_idx + 1;
		if ( temp_num == gTXD_RD_idx )	{//is it almost full?
			EA = 1;																		//reenable interrupts
			while ( temp_num == gTXD_RD_idx )	//wait to clear
				;
			EA= 0;
		}
	}
	gTXD_Buffer[ gTXD_WR_idx++ ] = c;		//store in buffer.

	EA = 1;
}

extern char getch( void )	{
	char c;

	c = gRXD_Buffer[ gRXD_RD_idx++ ];
	return( c );
}

char getche( void )	{
  char	c;

	putch( c = getch() );
	return c;
}

interrupt void serial_int()	{
	EA = 0;
	if ( TI )	{
		TI = 0;
		gIS_Transmitting = 0;
		if ( gTXD_RD_idx != gTXD_WR_idx )	{
			SBUF = gTXD_Buffer[ gTXD_RD_idx++ ];
			gIS_Transmitting = 1;
		}
	}
	if ( RI )	{
		RI = 0;
		gRXD_Buffer[ gRXD_WR_idx++ ] = SBUF;
	}
	EA = 1;
}

unsigned char is_empty( unsigned char idx_1, unsigned char idx_2 )	{
	return( idx_1 & idx_2 );
}
extern char * long2str( long the_long, char leading_zeros, char num_char )	{
//accepts a long (24 or 32-bit) and returns the hex string at the output
//pointer leading_zeros ==> 0 no leading zeros, 1 (nonzero) keep leading
//zeros six_eight - 0 is six bytes, 1 (nonzero) is eight bytes
  static		char		theStr[ 9 ];		//8 bytes plus null
	register	char *	char_ptr;
	unsigned char i;

	char_ptr = theStr;
	for ( i = 0; i < ( sizeof( theStr ) ); i++ )	//fill with zeros
		*char_ptr++ = '0';

	*--char_ptr = cASCII_NULL;		//null terminate
	if ( the_long == 0 )
		char_ptr--;
	while ( the_long )  {
    *--char_ptr = byte2ASCII( the_long );
    the_long >>= 4;
  }
	if ( leading_zeros )
		return( theStr + ( cEIGHT_BYTES - num_char );
	else
		return( char_ptr );
}

extern char * byte2str ( char theByte )	{
  static char buf[ 3 ];

  buf[ 2 ] = cASCII_NULL;
  buf[ 1 ] = byte2ASCII( theByte );
  theByte >>= 4;
  buf[ 0 ] = byte2ASCII( theByte );
  return buf;
}

extern char byte2ASCII( char theByte )	{//nibble to ASCII actually

	theByte &= 0x0f;		//restrict to range of hex values
  return str_HexAscii[ theByte ];
}

extern unsigned char ASCII2char ( unsigned char ascii_char ) {
	// this routine assumes a valid ASCII Hex char
  unsigned char num;

  num = ascii_char - '0';
  if ( ascii_char > 'F' )
    ascii_char -= 'a' - 'A';     // lower case --> upper case
  if ( ascii_char > '9' )
    num = ascii_char - 'A' + 10; // convert upper case to hex
  return num;
}

extern long str2Long( char * someStr )	{
	//this takes a hex string and converts to a long
  unsigned long temp = 0;
  unsigned char ch;

	while( ch = *someStr++ )	{
		temp = temp << 4;
		temp += ASCII2char ( ch );
	}
  return temp;
}

extern unsigned long alpha2long( register const char * s )	{
	//this converts a decimal string to a long
	static unsigned long a;
	char * temp = s;

	a = 0;
	while ( *s != cASCII_NULL )	{
		if ( !( isdigit( *s ) ) )	{
			*temp = cASCII_NULL;
			return ( 0 );
		}
		a = a*10L + ( *s++ - '0' );
	}
	return( a );
}


extern char * long2ascii( long the_long )	{
	// convert long to decimal ascii
	static char	 buf[ 16 ];
	register char * char_ptr;
	unsigned short	 neg = 0;

	buf[ 0 ] = '0';
	buf[ 1 ] = cASCII_NULL;
	if ( the_long == 0 )
		return( buf );
	if ( the_long < 0 ) {
		the_long = -the_long;
		neg++;
	}
	char_ptr = buf + sizeof( buf );
	*--char_ptr = '\0';
	while ( the_long ) {
		*--char_ptr = the_long % 10 + '0';
		the_long /= 10;
	}
  if ( neg )
		*--char_ptr = '-';
  return( char_ptr );
}

//auxilliary routines for strings in code memory.
extern char strCodecmp( code char * s1, register const char * s2 )	{
	register signed char	r;

	while( !( r = *s1 - *s2++ ) && *s1++ )
		continue;
	return r;
}

extern char * strCodecpy( char * to, code char * from )	{
	register char *	cp;

	cp = to;
	while( *cp++ = *from++ )
		continue;
	return to;
}

extern char * strCodecat( register char * to, code char * from )	{
	register char *	cp;

	cp = to;
	while( *cp )
		cp++;
	while( *cp++ = *from++ )
		continue;
	return to;
}

// *********** Print utilities start here ***********

// print the string which is located in SRAM
extern void printStr( const char * str )	{
  unsigned char c;
	if ( gPrintToPacket )
		print_packet_str( ( char * ) str );
	else	{
		for( ; c = *str; str++ )
			putch( c );
	}
}

// print the string which is located in SRAM plus CR and LF
extern void printStrC( const char * str )	{
  unsigned char c;

	if ( gPrintToPacket )
		print_packet_strC( ( char * ) str );
	else	{
		for( ; c = *str; str++ )
			putch( c );
		putch ( '\r' );
		putch ( '\n' );
	}
}

// print the string which is located in Code memory
extern void printStrCode( code char * str )	{
  unsigned char c;
	
	if ( gPrintToPacket )
		print_packet_codestr( str );
	else	{
		for( ; c = *str; str++ )
			putch( c );
	}
}

// print the string which is located in Code memory
extern void printStrCodeC( code char * str )	{
  unsigned char c;

	if ( gPrintToPacket )
			print_packet_codestrC( str );
	else	{
		for( ; c = *str; str++ )
			putch( c );
		putch ( '\r' );
		putch ( '\n' );
	}
}

extern void set_print_packet( void )	{
	gPrintToPacket = 1;
}

extern void clr_print_packet( void )	{
	gPrintToPacket = 0;
}