audio.c

PEAKAUDIO用于EV2板的MCU控制源码

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

	Audio.c

	Line command routines to control the audio on the CobraNet Eval board.
 
	Line commands supported: ROUTE, AUDIO

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

#include <8051.h>
#include <intrpt.h>
#include <conio.h>
#include <string.h>
#include "serial.h"
#include "cnmutil.h"
#include "command.h"
#include "error.h"
#include "test.h"
#include "mystrings.h"
#include "audio.h"

void audio_preroute( unsigned char in_selection, 
										 unsigned char out_selection );
void route_help( unsigned char detailed );
void audio_help( unsigned char detailed );

/*************************************************************************
*															 ROUTE COMMAND														 *
*************************************************************************/
void route( char * com_arg_ptr[] );

code struct command_item_t route_command = {
	( code char * ) str_Com_route,
	( code command_function_t ) route
};

void route( char * com_arg_ptr[] )	{
	unsigned char c_in;		//this is the index for the input argument
	unsigned char c_out;	//this is the index for the output argument

	if ( com_arg_ptr[ 1 ] == NULL )	//look for the command without arguments
		route_help( cHELP_SHORT );		//this would be the short help string
	else	{
		if ( *com_arg_ptr[ 1 ] == '?' )	//the long help string
			route_help( cHELP_LONG );
		else
			if ( com_arg_ptr[ 2 ] == NULL )
				printErrString( get_error_string( cERR_MISSING_ARG ) );
			else	{
				c_in = 0;
				while ( ( strCodecmp( audio_inputs[ c_in ], com_arg_ptr[ 1 ] ) ) &&
								( audio_inputs[ c_in ] != NULL ) )
					c_in++;
				if ( audio_inputs[ c_in ] == NULL )	//not a valid input argument
					printErrString( get_error_string( cERR_ARGUMENT ) );
				else	{
					c_out = 0;
					while ( ( strCodecmp( audio_outputs[ c_out ], com_arg_ptr[ 2 ] ) )
									&& ( audio_outputs[ c_out ] != NULL ) )
						c_out++;
					if ( audio_outputs[ c_out ] == NULL )//not a valid output argument
						printErrString( get_error_string( cERR_ARGUMENT ) );
					else
						audio_preroute( c_in, c_out );	//valid line command
				}
			}
	}
}

void route_help( unsigned char detailed )	{
	printStrCodeC( route_str_help1 );
	if ( detailed )
		printStrCodeC( route_str_help2 );
}


void audio_preroute( unsigned char in_selection, 
										unsigned char out_selection )	{
	char * reg_int_ptr = NULL;

  switch( out_selection )	{
		//sets up pointer to output channel register
    case cAUDIO_SSI0:
      reg_int_ptr = ( char * ) cSSI_REG0_ptr;
      break;
    case cAUDIO_SSI1:
      reg_int_ptr = ( char * ) cSSI_REG1_ptr;
      break;
    case cAUDIO_SSI2:
      reg_int_ptr = ( char * ) cSSI_REG2_ptr;
      break;
    case cAUDIO_SSI3:
      reg_int_ptr = ( char * ) cSSI_REG3_ptr;
      break;
    case cAUDIO_DAC:
      reg_int_ptr = ( char * ) cDAC_REG_ptr;
      break;
    case cAUDIO_AES:
      reg_int_ptr = ( char * ) cAES_REG_ptr;
      break;
    default:
      break;
	};	//switch

  if ( in_selection == cAUDIO_MUTE )
		audio_mute( reg_int_ptr );	//mute the audio
	else	{
		audio_put_route( in_selection, reg_int_ptr );
		audio_unmute( reg_int_ptr );
	}
}

extern void audio_put_route( unsigned char source, char * target )	{
  char * target_ptr = ( char * ) target;

  *target_ptr = source;
}

extern char audio_get_route( char * target )	{
  char * target_ptr = ( char * ) target;

  return( *target_ptr );
}

extern void audio_mute( char * target )	{
  char * iDAC_ptr = ( char * ) ( target + 1 );

  *( iDAC_ptr ) = cMUTE_ON;
}

extern void audio_unmute( char * target )	{
  char * iDAC_ptr = ( char * ) ( target + 1 );

  *( iDAC_ptr ) = cMUTE_OFF;
}

extern void audio_DACMode( unsigned char the_mode )	{
//sets the speed mode for the DAC
  char * iDAC_ptr = ( char * ) cDAC_MODE_ptr;

  *( iDAC_ptr ) = the_mode;
	audio_DACreset( cDAC_RESET_ON );
	waiting( 0x0606,0x00 ); //hold in reset for a while
	audio_DACreset( cDAC_RESET_OFF );
}

extern void audio_DACreset( unsigned char resetit )	{
//put DAC in or out of reset
  char * iDAC_ptr = ( char * ) cDAC_RESET_ptr;

  *( iDAC_ptr ) = resetit;
}

extern void audio_ADCCaste( unsigned char the_caste )	{
//configure ADC as master or slave
  char * iDAC_ptr = ( char * ) cADC_SLAVE_ptr;

  *( iDAC_ptr ) = the_caste;
}


/*************************************************************************
*															 AUDIO COMMAND														 *
*************************************************************************/

void audio( char * com_arg_ptr[] );
void audio_execute( unsigned char audio_selection, char * com_arg_ptr[] );

code struct command_item_t audio_command =	{
	( code char * ) str_Com_audio,
	( code command_function_t ) audio
};

void audio( char * com_arg_ptr[] )	{
	unsigned char c_op;

	if ( com_arg_ptr[ 1 ] == NULL )	//look for the command without arguments
		audio_help( cHELP_SHORT );
	else	{
		if ( *com_arg_ptr[ 1 ] == '?' )
			audio_help( cHELP_LONG );
		else	{
			c_op = 0;
			while ( ( strCodecmp( audio_ops[ c_op ], com_arg_ptr[ 1 ] ) ) && 
															( audio_ops[ c_op ] != NULL ) )
				c_op++;
			if ( audio_ops[ c_op ] == NULL )
				printErrString( get_error_string( cERR_ARGUMENT ) );
			else
				audio_execute( c_op, com_arg_ptr );
		}
	}
}

void do_audio_samplerate( char * the_value )	{
	unsigned char c_op;

	if ( the_value == NULL )	{	//look for missing argument
		printErr( cERR_MISSING_ARG );
		return;
	}
	else	{
		c_op = 0;
		while ( ( strCodecmp( str_SampleRate[ c_op ], the_value ) ) && 
															( str_SampleRate[ c_op ] != NULL ) )
				c_op++;
		if ( str_SampleRate[ c_op ] == NULL )	//invalid argument
			printErrString( get_error_string( cERR_ARGUMENT ) );
		else
			switch ( c_op )	{
				case cAUDIO_48K:
					audio_DACMode( cDAC_SINGLE_SPEED );	//48 kHz
					break;
				case cAUDIO_96K:
					audio_DACMode( cDAC_DOUBLE_SPEED );	//96 kHz
					break;
				case cAUDIO_48KD:
					audio_DACMode( cDAC_SINGLE_DEEM );	//48 kHz w/deemphasis
					break;
				case cAUDIO_192K:
					audio_DACMode( cDAC_QUAD_SPEED );		//192k (not supported)
					break;
				default:
					break;
			};
	}
}

void do_audio_gain( char * the_value )	{
//check the gain argument
	unsigned char c_op;

	if ( the_value == NULL )	{	//check for missing argument
		printErr( cERR_MISSING_ARG );
		return;
	}
	else	{
		c_op = 0;
		while ( ( strCodecmp( str_Gain[ c_op ], the_value ) ) && 
															( str_Gain[ c_op ] != NULL ) )
				c_op++;
		if ( str_Gain[ c_op ] == NULL )	//invalid gain argument
			printErrString( get_error_string( cERR_ARGUMENT ) );
		else
			sine_gain( c_op );	//good argument, set new gain.
	}
}

void do_audio_frequency( char * the_value )	{
//check the frequency argument
	unsigned char freq_op;
	unsigned char error_code = 0;

	if ( the_value == NULL )	{	//check for missing argument
		printErr( cERR_MISSING_ARG );
		return;
	}
	else	{
		if (  error_code = validate_hex_string( the_value, c2_HEX_CHAR ) )
			printTwoErrorString( get_error_string( cERR_ARGUMENT ),
													 get_error_string( error_code ) );
		else	{
			freq_op = ( unsigned char ) str2Long( the_value + 2 );
			if ( ( freq_op > 8 ) || ( freq_op < 1 ) )
				printErr( cERR_OUT_OF_RANGE );	//invalid frequency argument
			else
				sine_freq( freq_op );
		}
	}
}

void audio_execute( unsigned char audio_selection, char * com_arg_ptr[] )	{
//execute the audio command selection
  switch( audio_selection )	{
    case cAUDIO_SAMPLERATE:
			do_audio_samplerate( com_arg_ptr[ 2 ] );
      break;
    case cAUDIO_CALIBRATE:
			ad_cal( cADCAL_ON );
			waiting( mMSECOND10 );
			ad_cal( cADCAL_OFF );
      break;
		case cAUDIO_GAIN:
			do_audio_gain( com_arg_ptr[ 2 ] );
			break;
		case cAUDIO_FREQUENCY:
			do_audio_frequency( com_arg_ptr[ 2 ] );
			break;
    default:
      break;
	};	//switch
}

//sets or resets the AD calibration mode or returns the current state of
//the calibration. On power up the FPGA initiates a calibration cycle;
//this routine can check if that calibration is still in progress.
extern char ad_cal( unsigned char the_op )	{
	far char * ad_loc_ptr = ( far char * ) cAD_CAL_ADDR_ptr;
	unsigned char return_char = 0;

	switch( the_op )	{
		case cADCAL_OFF:
			*ad_loc_ptr = 0;
			break;
		case cADCAL_ON:
			*ad_loc_ptr = 1;
			break;
		case cADCAL_CHECK:
			return_char = *ad_loc_ptr & 0x01;
			break;
		default:
			break;
	}	//switch

  return( return_char );  
}

extern void sine_gain( unsigned char the_gain )	{
// set the gain for the sinewave generator
  char * GAIN_ptr = ( char * ) ( cGAIN_ptr );

  *( GAIN_ptr ) = the_gain;
}

extern void sine_freq( unsigned char the_frequency )	{
// set the frequency for the sinewave generator
  char * FREQ_ptr = ( char * ) ( cFREQ_ptr );

  *( FREQ_ptr ) = the_frequency;
}

void audio_help( unsigned char detailed )	{
	printStrCodeC( audio_str_help1 );
	if ( detailed )
		printStrCodeC( audio_str_help2 );
}