vs1003.c

Read MP3 from sd,send vs1003 decode

/*********************************************************************************************************
** Function name:		Sine_Off
**
** Descriptions:		vs sine test
**
** input parameters:		freq
** Returned value:		none
**         
** Used global variables:	none
** Calling modules:		None
**
** Created by:			JOSEPH
** Created Date:		2006/10/19
**-------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
void Sine_Off(void) 
{ 
	uint8 buf[4]; 

	buf[0] = 0x45; 
	buf[1] = 0x78; 
	buf[2] = 0x69; 
	buf[3] = 0x74; 
	while(!MP3_DATA_REQ_STATUS());         // wait for DREQ 
	VS1003_Stream(&buf[0],4); 

	buf[0] = 0x00; 
	buf[1] = 0x00; 
	buf[2] = 0x00; 
	buf[3] = 0x00; 
	while(!MP3_DATA_REQ_STATUS());         // wait for DREQ 
	VS1003_Stream(&buf[0],4); 
} 

//
// send three 1kHz sinewave beeps
//
uint8 send_sinewave_beeps(void)
{
	unsigned char i;

	for (i=0;i<3;i++)
	{
		Sine_On(62);		// 1 kHz sine
		ms_wait(100);
		Sine_Off();
		ms_wait(100);
	}
	return 0;	
}


/*********************************************************************************************************
** Function name:		Sine_Sweep
**
** Descriptions:		vs sine test
**
** input parameters:		freq
** Returned value:		none
**         
** Used global variables:	none
** Calling modules:		None
**
** Created by:			JOSEPH
** Created Date:		2006/10/19
**-------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
int Sine_Sweep(void) 
{ 
  	unsigned int buf[2]; 
  	unsigned int i; 
	while(!MP3_DATA_REQ_STATUS());         // wait for DREQ 
	buf[0] = 0x0820; 
	VS1003_Write(SPI_MODE,1,buf); 
	ms_wait(2); 

	while(!MP3_DATA_REQ_STATUS());         // wait for DREQ 
	VS1003_SetVolume(0,0); 

	for (i=0;i<20000;i+=1000) 
  		{ 
  			Sine_Off(); 
  			Sine_On(i); 
  			ms_wait(300); 
  		} 
	Sine_Off(); 
	return 0;
} 
///////////////////////////////////////////////////////////
//
//	 the under functions is various test stuff
//
/////////////////////////////////////////////////////


/*********************************************************************************************************
** Function name:		bus_test
**
** Descriptions:		read register data for 0 ~ 12 address of register
**
** input parameters:		none
** Returned value:		none
**         
** Used global variables:	none
** Calling modules:		None
**
** Created by:			JOSEPH
** Created Date:		2006/10/23
**-------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/

uint8 bus_test(void)
{
	uint32 read_data[20];
	uint8 reg_num;

	for (reg_num = 0; reg_num < 12; reg_num++)	// for each register
		{
			Uart_Printf("Reg: %d", reg_num);
			//read_data = (uint16)(Mp3ReadRegister(reg_num));
			VS1003_Read(reg_num, 1, read_data);
			Uart_Printf(" \t \t Value: %04x\n", read_data[0]);
		}
	Uart_Printf("\n");
	return 0;	
}
//
// test registers, by writing a value and re-reading it
//
uint8 reg_test(void)
{
	uint32 buf[20];
	uint8 j;

	for (j=0;j<20;j++)	// for each register
	{
		buf[0] = j*256+j;
		VS1003_Write(SPI_CLOCKF, 1, buf);
		Uart_Printf("Wrote: ");
		Uart_Printf("  %4d\n", buf[0]);
		buf[0] = 0xffff;
		
		VS1003_Read(SPI_CLOCKF, 1, buf);
		Uart_Printf("Read: ");
		Uart_Printf("   %4d\n", buf[0]);
		
		if (buf[0] != j*256+j)
			{
				return 1;
			}
	}
	return 0;
}

//
// run the VS1001 built in memory test
//
uint8 mem_test(void)
{
	uint8 i, buf[4];
	uint32 inbuf[2];

	// memtest
	buf[0] = 0x4D;	buf[1] = 0xEA;	buf[2] = 0x6D;	buf[3] = 0x54;

	for (i=0;i<4;i++)
		{
			vs1003_data_write(buf[i]);
		}

	VS1003_nulls(4);

	ms_wait(500);
	
	VS1003_Read(SPI_HDAT0, 1, inbuf);
	//inbuf[0] = vs1003_read(SPI_HDAT0);	
	//Mp3ReadRegister(SPI_HDAT0);	
	if ((inbuf[0] & 0xFF) == 0x7F)
		return 0;
	else 
		return (inbuf[0] & 0xFF);
}

//
// play with volume settings
//
uint8 volume_test(void)
{
	uint8 i;
	
	Sine_On(0x30);
	
	for (i=0;i<0x40;i++)
	{
		Mp3SetVolume(i,i);
		ms_wait(20);
	}

	Mp3SetVolume(20,20);

	for (i=0;i<21;i++)
	{
		Mp3SetVolume(20-i,20+i);
		ms_wait(20);
	}
	
	for (i=0;i<40;i++)
	{
		Mp3SetVolume(i,40-i);
		ms_wait(20);
	}
		
	Sine_Off();

	Mp3SetVolume(12,12);

	return 0;

}

//
// test the clock doubler by playing a sine wave 
// with and without the doubler active
//
uint8 clock_doubler(void)
{
	uint32 buf[2];

	// set CLOCKF to compensate for a x-tal and doubler

	// first test default 24.576 MHz clock

	buf[0] = 12288;
	VS1003_Write(SPI_CLOCKF, 1, buf);	

	Sine_On(62);
	ms_wait(500);
	Sine_Off();
	ms_wait(500);
	
	// now test clock doubler (12.288 MHz xtal assumed)

	buf[0] = 0x8000 + 6144;
	VS1003_Write(SPI_CLOCKF, 1, buf);	

	Sine_On(62);
	ms_wait(500);
	Sine_Off();
	ms_wait(500);
	
	return 0;
}



/*********************************************************************************************************
** Function name:		PlayMP3
**
** Descriptions:		Set vs Volume
**
** input parameters:		none
** Returned value:		none
**         
** Used global variables:	none
** Calling modules:		None
**
** Created by:			JOSEPH
** Created Date:		2006/10/19
**-------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/

/*
void PlayMP3(void) 
{ 
	uint8 i,temp[32]; 
	unsigned long j=0; 
	while(j < 0x2e1f) 
  		{ 
      		for(i=0;i<32;i++) 
      			{ 

					VS1003_Stream(vsBeepMP3,32); 
      			} 
    		while(!MP3_DATA_REQ_STATUS());         // wait for DREQ 
    		VS1003_Stream(temp,32); 
		} 
} 
*/
void PlayMP3(void) 
{
	unsigned int data_pointer;
	unsigned char i,j = 0;
//	uint8 temp[32] = {0};

	for(data_pointer = 0; data_pointer < 0x8854; data_pointer += 32)
        { 
            Uart_Printf("\n %4d group datas is sent now!\n",j++);
					for(i=0;i<32;i++)
               			{
               				Uart_Printf("0x%x \t", midi[data_pointer]);
         					//vs1003_data_write(vsBeepMP3[data_pointer]);
//							Write_Byte_SPI(vsBeep[data_pointer]);
         					data_pointer++;
//							VS1003_Stream(&vsBeepMP3[32*data_pointer - 32], 32);
                		}
			while(!MP3_DATA_REQ_Chk());
			VS1003_Stream(midi + data_pointer - 32, 32);
		}
	SendZerosToVS10xx(2048);
}  

//************************************* 
// void main(void) 
//************************************* 
int vs1003test(void) 
{ 
	int i; 

	UART0_Init(); 
	ms_wait(100);
	Uart_Printf("LPC2210 UART TEST....\n"); 
	
	MP3_Port_Init();
	VS1003_Init();
	
	
	while(1) 
		{ 
////////////////////////////////////////////////
			Uart_Printf("VS1003 initing....\n"); 
			
			VS1003Init(HARD); 
			Uart_Printf("\t\t ok!\n"); 
/////////////////////////////////////////////////			
			//PORTF &= ~0x02; 
			Uart_Printf("VS1003 working testing....\n"); 
			Working_Test(); 
			//PORTF |= 0x02; 
			Uart_Printf("\t\t ok!\n"); 
/////////////////////////////////////////////////			
			Uart_Printf("VS1003 reg testing....\n"); 
			if(!reg_test()) 
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 
				}
/////////////////////////////////////////////////		
			Uart_Printf("VS1003 memory testing....\n"); 
			if(!mem_test()) 					//  read value is not 0x7f ?
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 	
				}
			
			VS1003_Init();

/////////////////////////////////////////////////	
			Uart_Printf("VS1003 bus testing....\n"); 
			if(!bus_test()) 
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 	
				}
/////////////////////////////////////////////////
			Uart_Printf("VS1003 Sine testing....\n"); 
			if(!send_sinewave_beeps()) 
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 	
				}
/////////////////////////////////////////////////
			VS1003_SetVolume(200,200); 
			Uart_Printf("VS1003 sine sweeping testing....\n"); 
			for(i=0;i<3;i++) 
			if(!Sine_Sweep())
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 	
				}
////////////////////////////////////////////////
			Uart_Printf("VS1003 Volume testing....\n"); 
			if(!volume_test())
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 	
				}
/////////////////////////////////////////////////		
			Uart_Printf("VS1003 Clock Doubler testing....\n"); 
			if(!clock_doubler()) 
				{
					Uart_Printf("\t\t ok!\n"); 
				}
			else 
				{
					Uart_Printf("\t\t fail!\n"); 	
				}
/////////////////////////////////////////////////	

			Uart_Printf("VS1003 mp3 playing testing....\n"); 
			//VS1003Init(0); 
			PlayMP3(); 
			Uart_Printf("\t\t ok!\n"); 
	} 
}