volume_m04_c2.c

sircs decoder, for amplifier.. this is to decode

/****************************************************************************************************/
/* $Header  : 																					  	
/* AUTHOR 	: TC PUI																		  		
/* FILE NAME: VOLUME.C																		  		
/* PURPOSE	: VOLUME CONTROL												 				 		
/* MODEL	: 2004 CIS 2-CH AMP 										  						
/* Copyright (c) 2004 Sony Corporation All Rights Reserved					  						
/****************************************************************************************************/
#define _VOLUME_C

#include "_main_M04_C2.h"
/****************************************************************************************************/
/* local variables definition which are refered only this file										
/****************************************************************************************************/
#define _VOL_NUM	2
#define _OFFSET1	64
#define _OFFSET2	96
#define VOL_MIN		255
#define VOL_MAX 	0
/****************************************************************************************************/

static unsigned char  VolStt;		/*	VOLUME state				*/
static unsigned char  SIODatCnt;	/*	Serial I/O data counter		*/	
static unsigned char  fg_start;		/*	Volume data start out flag	*/	

static unsigned char  ConverttoVIC(unsigned char);

/****************************************************************************************************/
/* FUNCTION		:	VolInitialize																			
/* PURPOSE		:	Volume Initialize					  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void VolInitialize(void)
{
	E_VOL.MASTER_VOL[0] = CLEAR;		
	E_VOL.MASTER_VOL[1] = CLEAR;		
	E_VOL.VolUpFlag 	= CLEAR;
	E_VOL.SircsVolStep 	= _STEP_MAX;
	E_VOL.VolDat[0] 	= CLEAR;
	E_VOL.VolDat[1] 	= CLEAR;
	E_VOL.VolDat[2] 	= CLEAR;
	E_VOL.ReqMute 		= CLEAR;	
	E_VOL.Muting 		= CLEAR;			
	VolStt 		= VOL_NORMAL;
	SIODatCnt 	= CLEAR;
	EVR_OUT[0] 	= CLEAR;
	EVR_OUT[1] 	= CLEAR;
	E_VOL.MASTER_VOL_BUF[0] = !E_VOL.MASTER_VOL[0];
	E_VOL.MASTER_VOL_BUF[1] = !E_VOL.MASTER_VOL[1];
	fg_start 	= OFF;
	SRC2.BYTE 	= 0x02;		/* baud rate 		*/
	SMC21.BYTE 	= 0x8B;		/* 10001011 		*/
	SMC22.BYTE	= 0x1C;		/* start transmit 	*/
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	VolDat_Set																			
/* PURPOSE		:	Prepare E_VOL.MASTER_VOL ram setting(Combine VR and Sircs Volume Step)					  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void VolDat_Set(void)
{
		
	unsigned char i=0 ;									
	unsigned short int sircstep;
	unsigned short int voldat[2];	/* must use int because this variable value would more than 255 */
	
	/*** E_VOLUME master control data (0 - FF) range ***/ 
	if ((E_VOL.ReqMute == ON) || (E_VOL.Muting == ON) || (E_VOL.SircsVolStep == 0)){
		E_VOL.MASTER_VOL[0] = VOL_MIN;
		E_VOL.MASTER_VOL[1] = VOL_MIN;
	} else {
		sircstep = (unsigned int)E_VOL.SircsVolStep;
		sircstep = _STEP_MAX - sircstep;							/* Revert sircs step 		*/
		
	/***** Combine VR data with SIRCS Data *****/					
		for (i=0; i < _VR_NUM; i++) { 
			voldat[i] = (unsigned int)EVR_OUT[i];
			if ((voldat[i] > 250) && ( voldat[i] <= VOL_MIN)){
				voldat[i] = voldat[i];								/* 0 of the sircs step 		*/
			} else if ((voldat[i] > 219) && ( voldat[i] <= 250)){
				voldat[i] = voldat[i] << 1;
				voldat[i] = voldat[i] + sircstep;					/* 0.5 of the sircs step 	*/
				voldat[i] = voldat[i] >> 1;
			} else if ((voldat[i] > 183) && ( voldat[i] <= 219)) {
				voldat[i] = voldat[i] + sircstep;					/* 1 of the sircs step 		*/
			} else if ((voldat[i] > 148) && ( voldat[i] <= 183)) {
				voldat[i] = voldat[i] << 1;	
				voldat[i] = voldat[i] + sircstep*3;					/* 1.5 of the sircs step 	*/
				voldat[i] = voldat[i] >> 1;
			} else if ((voldat[i] > 112) && ( voldat[i] <= 148)) {
					voldat[i] = voldat[i] + (sircstep << 1);		/* 2 of the sircs step 		*/
			} else if ((voldat[i] > 77) && ( voldat[i] <= 112)) {
				voldat[i] = voldat[i] << 1;
				voldat[i] = voldat[i] + sircstep*5;					/* 2.5 of the sircs step 	*/
				voldat[i] = voldat[i] >> 1;
			} else if ((voldat[i] > 41) && ( voldat[i] <= 77)) {
				voldat[i] = voldat[i] + sircstep*3;					/* 3 of the sircs step 		*/
			} else if (/*(voldat[i] >= VOL_MAX) &&*/ ( voldat[i] <= 41)) {
				voldat[i] = voldat[i] << 1;			
				voldat[i] = voldat[i] + sircstep*7;					/* 3.5 of the sircs step 	*/
				voldat[i] = voldat[i] >> 1;
			}
		
			if (voldat[i] > VOL_MIN){
				voldat[i] = VOL_MIN;		
			}
		}  		
		
		E_VOL.MASTER_VOL[0] = (unsigned char)voldat[0];				/* Left Channel 			*/
		E_VOL.MASTER_VOL[1] = (unsigned char)voldat[1];				/* Right Channel 			*/
	}
	E_VOL.ReqMute = CLEAR;
	return;	
}

/****************************************************************************************************/
/* FUNCTION		:	GetVolState																			
/* PURPOSE		:	Return Volume Status					  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char GetVolState(void){
	
	return VolStt;
}

/****************************************************************************************************/
/* FUNCTION		:	VolDatStart																			
/* PURPOSE		:	Set Volume Data Out Flag ON					  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void VolDatStart(void)
{
	fg_start = ON;							/* volume data start out flag ON		*/
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	VolDatStop																			
/* PURPOSE		:	Set Volume Data Out Flag OFF				  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void VolDatStop(void)
{
	fg_start = OFF;							/* volume data start out flag OFF		*/
	return;	
}

/****************************************************************************************************/
/* FUNCTION		:	VolDat_out																			
/* PURPOSE		:	Output Volume Data				  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/	
void VolDat_out(void)
{
	unsigned char dat;
	
	if(fg_start==OFF){	
		return;
	}
	if(SSD2.BIT.TDRE == ON){				/* transmission data register empty?	*/
		dat = SIODatCnt; 

		if (SIODatCnt == VOLDAT_C){			/* Vol data LCH transmit complete 		*/
			VolDatStop();	 
			P_VOL_STB = SET;
			P_VOL_STB = CLEAR;
			VolStt = VOL_NORMAL;
		} else {
			SODR2.BYTE = E_VOL.VolDat[dat];	/* transmit data 						*/
			SMC22.BIT.TXE = ON;				/* start transmit 						*/
		}
		SIODatCnt = SIODatCnt + 1;			/* increase counter 					*/	
	}
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	VolControl																			
/* PURPOSE		:	Volume Control						  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void VolControl(void)
{	
	
	VolDat_Set();						/* Prepare E_VOL.MASTER_VOL ram setting for SIRCS & VR input 	*/
					
	switch(VolStt) {
		case VOL_INIT:	if ( POW_ACTIVE == ON) {
							VolStt = VOL_SET;
						}
						break;	

		case VOL_SET:	SetVolumeData();				/* SET E_VOL.VolDat data & Enable output	 	*/
						VolStt = VOL_SEND; 
						break;

		case VOL_NORMAL:if (E_VOL.MASTER_VOL_BUF[0] > E_VOL.MASTER_VOL[0]||E_VOL.MASTER_VOL_BUF[1] > E_VOL.MASTER_VOL[1]){
							E_VOL.MASTER_VOL_BUF[0] = E_VOL.MASTER_VOL[0];		/* Left Channel 		*/
							E_VOL.MASTER_VOL_BUF[1] = E_VOL.MASTER_VOL[1];		/* Right Channel 		*/
							VolStt = VOL_INIT;
							E_VOL.VolUpFlag = SET;								/* Volume up flag set	*/
						}else if (E_VOL.MASTER_VOL_BUF[0] < E_VOL.MASTER_VOL[0]||E_VOL.MASTER_VOL_BUF[1] < E_VOL.MASTER_VOL[1]){
							E_VOL.MASTER_VOL_BUF[0] = E_VOL.MASTER_VOL[0];		/* Left Channel 		*/
							E_VOL.MASTER_VOL_BUF[1] = E_VOL.MASTER_VOL[1];		/* Right Channel 		*/
							VolStt = VOL_INIT;
							E_VOL.VolUpFlag = CLEAR;							/* Volume up flag clear	*/
						}	
						break;
		
		default:		break;
		
	}
	VolDat_out();										/* Send data to volume IC			*/
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	SetVolumeData																			
/* PURPOSE		:	Set Volume Data 				  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void SetVolumeData(void)
{

	unsigned char volout[3];
		
	volout[0] = ConverttoVIC(E_VOL.MASTER_VOL_BUF[0]);	/* convert to Volume ic data(left) 	*/
	volout[1] = ConverttoVIC(E_VOL.MASTER_VOL_BUF[1]);	/* convert to Volume ic data(right) */

	volout[2] = CIPSEL_0|TI_0|S1S0_01;					/* Set S1 = 0, S0 = 1				*/
	if (E_VOL.VolUpFlag == SET){						/* Volume up?						*/
		volout[2] = CIPSEL_0|TI_0|S1S0_10;				/* Set S1 = 1, S0 = 0				*/
	}

	E_VOL.VolDat[0] = volout[1];						/* due to hardware LR reverse 		*/
	E_VOL.VolDat[1] = volout[0];						/* due to hardware LR reverse 		*/
	E_VOL.VolDat[2] = volout[2];
	
	SIODatCnt = CLEAR;

	VolDatStart();										/* Enable output					*/				
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	ConverttoVIC																		
/* PURPOSE		:	Convert to Volume IC data						  										
/* INPUT		:	volout																
/* RETURN VALUE	:	Volume IC data																			
/****************************************************************************************************/
static unsigned char ConverttoVIC(unsigned char voldat)
{
	if ((voldat >= 64)&&(voldat <=VOL_MIN)) {
		voldat = voldat - _OFFSET1;						/* offset							*/
	} else if (voldat == 63) {							/* c/m for minus 64 become overflow	*/		
		voldat = 0x00;									/* 0 dB 							*/
	} else if ((voldat >= 32)&&( voldat <= 62)) {
		voldat = _OFFSET1 - voldat;						/* offset							*/
		voldat = voldat >> 2;							/* divide 4 						*/
		voldat = voldat |0xC0;							/* set to trim volume 				*/
	} else if (voldat < 32) {
		voldat = _OFFSET2 - voldat;						/* offset							*/
		voldat = voldat >> 3;							/* divide 8 						*/
		voldat = voldat |0xC0;							/* set to trim volume 				*/
	}
	return voldat;
}