sta013.c

用LPC932控制sta013解码芯片

   SendByte(suba);            /*发送器件子地址*/
   if(ack==0)return(0);

   for(i=0;i<no;i++)
   {   
     SendByte(*s);            /*发送数据*/
     if(ack==0)return(0);
     s++;
   } 
   Stop_I2c();                /*结束总线*/ 
   return(1);
}

/*******************************************************************
                    向有子地址器件读取多字节数据函数               
函数原型: bit  ISendStr(uchar sla,uchar suba,uchar *s,uchar no);  
功能:     从启动总线到发送地址，子地址,读数据，结束总线的全过程,从器件
          地址sla，子地址suba，读出的内容放入s指向的存储区，读no个字节。
           如果返回1表示操作成功，否则操作有误。
注意：    使用前必须已结束总线。
********************************************************************/
bit IRcvStr(uchar sla,uchar suba,uchar *s,uchar no)
{
   uchar i;

   Start_I2c();                  /*启动总线*/
   SendByte(sla);                /*发送器件地址*/
   if(ack==0)return(0);
   SendByte(suba);               /*发送器件子地址*/
   if(ack==0)return(0);

   Start_I2c();			 /*重新启动总线*/
   SendByte(sla+1);
   if(ack==0)return(0);
   for(i=0;i<no-1;i++)
   {   
     *s=RcvByte();               /*发送数据*/
      Ack_I2c(0);                /*发送就答位*/  
     s++;
   } 
   *s=RcvByte();
   Ack_I2c(1);                   /*发送非应位*/
   Stop_I2c();                   /*结束总线*/ 
   return(1);
}


//求最大值
s8 MAX(s8 onedata, s8 twodata)
{   
    if(onedata>twodata)return onedata;
    return twodata;
}     

//求最小值
s8 MIN(s8 onedata, s8 twodata)
{ 
    if(onedata>twodata)return twodata;
    return onedata;
}

//读寄存器
u8 sta_ReadReg(u8 reg)
{
	u8 mydata;
    
	u8 errorcount=10;
	while(errorcount--)
	{
	   if(IRcvStr(STA_I2C_DEV, reg, &mydata, 1)==0) continue; 
       return mydata;
	   break;
	}
}

//写寄存器
void sta_WriteReg(u8 reg, u8 sta_data)
{
   	u8 errorcount=10;
    while(errorcount--)
	{
	   if(ISendStr(STA_I2C_DEV, reg, &sta_data, 1)==0) continue;
	   break;
    }
}

//写配置文件
void sta_DownloadUpdate(void)
{
	u16 i=0;
	u8 reg, mydata;
	reg = STA013_UpdateData[i++];
	mydata = STA013_UpdateData[i++];
	//结束标志"0xFF"
	while( (reg != 0xff) )
	{
		sta_WriteReg(reg, mydata);
        if(reg==0x10)
		{
		   Delays(50);
		}
		reg = STA013_UpdateData[i++];
		mydata =STA013_UpdateData[i++];

	}
}

//设置音调
void sta_SetTone(s8 bassEnh, u16 bassFreq, s8 trebleEnh, u16 trebleFreq)
{
	//设置低音增益
	sta_WriteReg(STA_REG_BASS_FREQUENCY_LOW,  (bassFreq   ) & 0xFF );
	sta_WriteReg(STA_REG_BASS_FREQUENCY_HIGH, (bassFreq>>8) & 0xFF );
	
	//注意界限
	bassEnh = MIN(bassEnh,MAX_BASS_ENHANCE);
	bassEnh = MAX(bassEnh,MIN_BASS_ENHANCE);
	sta_WriteReg(STA_REG_BASS_ENHANCE, bassEnh);
    
	//设置高音增益
	sta_WriteReg(STA_REG_TREBLE_FREQUENCY_LOW,  (trebleFreq   ) & 0xFF );
	sta_WriteReg(STA_REG_TREBLE_FREQUENCY_HIGH, (trebleFreq>>8) & 0xFF );

	//注意界限
	trebleEnh = MIN(trebleEnh,MAX_TREBLE_ENHANCE);
	trebleEnh = MAX(trebleEnh,MIN_TREBLE_ENHANCE);
	sta_WriteReg(STA_REG_TREBLE_ENHANCE, trebleEnh);
    
	//
	sta_WriteReg( STA_REG_TONE_ATTEN, MAX(bassEnh,trebleEnh));
}

//配置STA013并开始解压
void sta_StartDecoder(void)
{   
	//软件复位
	sta_WriteReg(STA_REG_SOFT_RESET, 0x01);
	sta_WriteReg(STA_REG_SOFT_RESET,		0x00);
    
	//静音与配置DAC输出
	sta_WriteReg(STA_REG_MUTE,				0x01);
	sta_WriteReg(STA_REG_PCMDIVIDER,		0x01);	// 32-bit mode, O_FAC = 256
	sta_WriteReg(STA_REG_PCMCONF,			0x31);	// 18-bit mode & more
    
	//配置PLL
	sta_WriteReg(STA_REG_PLLFRAC_441_H,		0x67);
	sta_WriteReg(STA_REG_PLLFRAC_441_L,		0x77);
	sta_WriteReg(STA_REG_PLLFRAC_H,			0xbb);
	sta_WriteReg(STA_REG_PLLFRAC_L,			0x3a);
	sta_WriteReg(STA_REG_MFSDF_441,			0x10);
	sta_WriteReg(STA_REG_MFSDF,				0x0F);
     
	//配置界面等
	sta_WriteReg(STA_REG_PLLCTL_2,			0x0C);
	sta_WriteReg(STA_REG_PLLCTL_3,			0x00);
	sta_WriteReg(STA_REG_PLLCTL_1,			0xA1);
	sta_WriteReg(STA_REG_SCLK_POL,			0x00);	// data sampled on rising edge
	sta_WriteReg(STA_REG_REQ_POL,			0x01);	// REQ line active high
	sta_WriteReg(STA_REG_DATA_REQ_ENABLE,	0x04);
	sta_WriteReg(STA_REG_PLLCTL_1,			0xA1);
    
	//设置音调
	sta_SetTone(0, 0, 0, 0);
    
	//STA013开始运行
	sta_WriteReg(STA_REG_RUN,  0x01);
	sta_WriteReg(STA_REG_PLAY, 0x01);
	sta_WriteReg(STA_REG_MUTE, 0x00);
}

//STA013初始化
u8 sta_Init(void)
{   
	//复位
	sta_Reset();

	//识别STA013
	if(sta_ReadReg(STA_REG_IDENT) != STA_IDENT)
	{
		return 0;
	}
	//配置STA013
    sta_DownloadUpdate();
//	sta_updata();
	//开始解压
	sta_StartDecoder();	
	return 1;
}

void sta_SetVolume(u8 volume, s8 balance)
{
	char attenL, attenR;

	// volume is expected as 0-100 value
	// Note:
	#define MIN_VOLUME_ATTENUATION     0
	#define MAX_VOLUME_ATTENUATION     96

	if( balance > 0)
	{	// balance to the left, attenuate right
		attenL = (100 - volume);
		attenR = (100 - volume) - (balance);
	}
	else
	{	// balance to the right, attenuate left
		attenL = (100 - volume) + (balance);
		attenR = (100 - volume);
	}
	// respect limits
	attenL = MIN(attenL,MAX_VOLUME_ATTENUATION);
	attenL = MAX(attenL,MIN_VOLUME_ATTENUATION);
	attenR = MIN(attenR,MAX_VOLUME_ATTENUATION);
	attenR = MAX(attenR,MIN_VOLUME_ATTENUATION);

	// set volume
	sta_WriteReg(STA_REG_DLA, attenL);
	sta_WriteReg(STA_REG_DLB, MAX_VOLUME_ATTENUATION);
	sta_WriteReg(STA_REG_DRA, attenR);
	sta_WriteReg(STA_REG_DRB, MAX_VOLUME_ATTENUATION);
}

void spiSendbyte()
{   
   unsigned int i=0;
   unsigned char done;
   while(done)
   {
      while(DATA_REQ)        
      {
        SPDAT=readdata[i++];                         //向从机发送数据
        while((SPSTAT & 0x80)==0);         //等待SPIF为1
        SPSTAT=0xC0;
 	    if(i==512)
		{
		   done=0;
		   break;
		}
      }
   }
}

void read(unsigned int block,unsigned int page,unsigned char *buffer)  //读操作
{
   unsigned int i;
   unsigned int blockpage=(block<<4)+page;
//写命令
   flash_ce=0;  
   flash_cle=1;
   flash_we=0;
   P0=0x00;
   flash_we=1;
   flash_cle=0;
   flash_ale=1;

//写地址
   flash_we=0;
   P0=0x00;
   i++;
   flash_we=1;
   
   flash_we=0;
   P0=blockpage & 0xff;
   i++;
   flash_we=1;
   
   flash_we=0;
   P0=(blockpage>>8) & 0xff;
   i++;
   flash_we=1;
   flash_ale=0;
   
   while(!flash_rb);
   P0M1=0xff;
   P0M2=0x00;
   for(i=0;i<512;i++)
   {
      flash_re=0;
      *(buffer+i)=P0;
      flash_re=1;
   }
   P0M1=0x00;
   P0M2=0x00;  
   flash_ce=1;
}

void sta_SendToDecoder()
{
    unsigned int data flash_block;
	unsigned char data flash_page;
       for(flash_block=1;flash_block<5;flash_block++)
       {
          for(flash_page=0;flash_page<16;flash_page++)
          {
	         read(flash_block,flash_page,&readdata);
             spiSendbyte();
          }
       }
}

void main(void)
{
    BIT_EN=1;
	IoIni();
    sta_Init();
	sta_SetVolume(50,10);
	while(1)
	{
	sta_SendToDecoder();
	}
}