yampp2.c

yampp的MP3资料 非常好大家来看一看

int main(void) 
{

// 	unsigned int  i;
  	unsigned char c;
 	char *p, *q;
//	unsigned long a1;
	unsigned int dentry = 0;
 	long filesize = 0;

/*	unsigned char c_min;
	unsigned char c_sec;
	unsigned long p_time;
*/
	unsigned char volume = 0x2C;

	event_e event = EV_IDLE;
//	int		bass_level = 15;
//	int		treb_level = 15;
	unsigned char mute = 0;
 
 //------------------------------
 // Initialize 
 //------------------------------


//////////////////////////////////////////////////////////////////
// B - Port
//////////////////////////////////////////////////////////////////

	sbi(PORTB, 0);	// DIOW- hi
	sbi(DDRB, 0);	// pin PB0 is output, DIOW- 

	sbi(PORTB, 1);	// DIOR- hi
	sbi(DDRB, 1);	// pin PB1 is output, DIOR- 

	cbi(DDRB, 2);	// pin PB2 is input, DEMAND
	sbi(PORTB, 2);	// activate pullup

	// PB3 and PB4 is used for I2C Bus

	// PB5 (MOSI) is used for SPI
	// PB6 (MISO) is used for SPI
	// PB7 (SCK) is used for SPI

//////////////////////////////////////////////////////////////////
// D - Port
//////////////////////////////////////////////////////////////////

	// PD0 and PD1 are TX and RX signals

	// PD2 is used for the IR receiver

	// PD3 is available

	sbi(DDRD, 4);	// pin PD4 is output, RESET-
	cbi(PORTD, 4);	// RESET- lo
	
	// PD5 is used by LCD module

	// PD6 and PD7 are RD and WR signals
	// but we need to set their default states used
	// when the external memory interface is disabled
    // they should then both be high to avoid disturbing
	// RAM contents
	
	sbi(DDRD, 6);		// as outputs
	sbi(DDRD, 7);
	sbi(PORTD, 6);		// and both hi
	sbi(PORTD, 7);


 //----------------------------------------------------------------------------
 // 
 //----------------------------------------------------------------------------

    lcd_init(0/*(1<<LCD_ON_CURSOR)*/, LCD_FUNCTION_DEFAULT); 	// also sets up EXTRAM pins
	lcd_puts("MP3-Player Alive");

	UART_Init();	// init RS-232 link
	i2c_init();		// initialize I2C bus pins
	init_spi();		// set up SPI interface
	init_rec80();	// set up IR receiver interface

 //----------------------------------------------------------------------------
 // setup some pointers
 //----------------------------------------------------------------------------

	SectorBuffer = (unsigned char *) SECTOR_BUFFER;
	scroll_line  = (unsigned char *) SCROLL_LINE;
	i2cdata	 	 = (unsigned char *) I2CDATA;

	// say hello
  	PRINT("IDE Test\r\n");


 //----------------------------------------------------------------------------
 // Let things settle, and after that, remove RESET from drive
 //----------------------------------------------------------------------------                        

  	delay(5000);	// 5 mS
	sbi(PORTD, 4);	// RESET- hi


// wait for drive

  	PRINT("Wait..\r\n"); 
  	WriteBYTE(CMD, 6, 0xA0); // Set drive/Head register, ie. select drive 0
   	while (( (c=ReadBYTE(CMD,7)) & 0xC0)!=0x40); // Wait for DRDY and NOT BUSY
  	PRINT("Drive ready!\r\n");

	// reset drive ???

	ATA_SW_Reset();

	// read structures
	init_fat(DRIVE0);

	// setup buffer structure

	buffer1 = (unsigned char *)BUFFERSTART;	 /* S_P_C is normally 8 */
	buffer2 = (unsigned char *)BUFFERSTART + Sectors_Per_Cluster * 512 * 1;
	buffer3 = (unsigned char *)BUFFERSTART + Sectors_Per_Cluster * 512 * 2;
	buffer4 = (unsigned char *)BUFFERSTART + Sectors_Per_Cluster * 512 * 3;

	MAS_init();		// init MAS decoder
	DAC_init();		// init D/A converter

#ifdef MAS_INFO
	mas_info();     // print some MAS chip info
#endif
	
	// copy tone tables to ext ram
/*	
	tonetable = (unsigned int *) TONETABLES;

	p = (unsigned char*)tonetable;
	q = (unsigned char*)ROM_bass_table;
	for (i=0;i<62;i++)
	{
		*p = PRG_RDB(q);
		p++;
		q++;
	}
	bass_table = tonetable;
	

	p = (unsigned char*)(&tonetable[32]);
	q = (unsigned char*)ROM_treb_table;
	for (i=0;i<62;i++)
	{
		*p = PRG_RDB(q);
		p++;
		q++;
	}

	treb_table = &tonetable[32];		
*/

	
///////////////////////////////////////////////////////////////////////////////


  	while (1) 
  	{
		
		if (UART_HasChar())
			event = get_char_event();

		if (rec80_active)
			event = ir_event();

		switch (event)
		{
			default:
			case EV_IDLE: 
				break;
			case EV_RESET:
		      	cbi(PORTD,4); delay(5000); sbi(PORTD, 4); 	// hard reset
		      	event = EV_IDLE;
				break;
			case EV_PREV:
				dentry-=2;	
				if ((int)dentry <= -2)
					dentry = (unsigned int)-1;
				// fall through		
			case EV_NEXT:
				dentry++;
				// fall through
			case EV_PLAY:
			
				// setup for play
				if ( (mycluster = get_dir_entry(dentry,0)) == 0)	// no more
				{	
					event = EV_NEXT;
					dentry = -1;
					isPlaying = 0;
					break;
				}	
				filesize = get_filesize();

				// start playing
				PRINT("\r\nPlaying #"); UART_Printfu08(dentry); UART_SendByte(' ');
				UART_Puts( get_dirname() ); 
				UART_Putsln( (p = get_filename()) );
				q = scroll_line;
				scroll_pos = 0;
				scroll_length = 0;
				while ( (*q = *p) != 0)
				{	
					scroll_length++;
					q++;
					p++;
				}
				*((unsigned long*)q)++ = 0x20202020L;
//				*q++ = ' ';	*q++ = ' ';	*q++ = ' ';
				*q++ = 0;

			    // preload buffers
				load_sectors(mycluster,buffer1);
				mycluster = next_cluster(mycluster);
				load_sectors(mycluster,buffer2);
				mycluster = next_cluster(mycluster);
				load_sectors(mycluster,buffer3);
				mycluster = next_cluster(mycluster);

			    outptr = buffer1;
				isPlaying = 1;
				updbuf = 0;
				event = EV_IDLE;
				break;					

			case EV_STOP:
				isPlaying = 0;
				event = EV_IDLE;
				break;				

			case EV_VOLUP: 
				if (volume < 0x38) volume++; 
				DAC_SetVolume(volume,volume); 
				event = EV_IDLE;
				break;

			case EV_VOLDN: 
				if (volume > 0) volume--; 
				DAC_SetVolume(volume,volume); 
				event = EV_IDLE;
				break;

			case EV_NEUTRAL: 
				volume = 0x2C;
//				bass_level = 15;
//				treb_level = 15;
				DAC_SetVolume(volume,volume); 
//				write_register(0x6b,(unsigned long)bass_table[bass_level] << 8);				
//				write_register(0x6f,(unsigned long)treb_table[treb_level] << 8);				
				event = EV_IDLE;
				break;
/*				
			case EV_BASSDN:
				bass_level++;
				if (bass_level > 30)
					bass_level = 30;
				a1 = (unsigned long)bass_table[bass_level] << 8;	
				EOL();
				UART_Printfu32(a1);
				EOL();
				write_register(0x6b,a1);				
				event = EV_IDLE;
				break;

			case EV_BASSUP:
				bass_level--;
				if (bass_level < 0)
					bass_level = 0;
				a1 = (unsigned long)bass_table[bass_level] << 8;	
				EOL();
				UART_Printfu32(a1);
				EOL();
				write_register(0x6b,a1);				
				event = EV_IDLE;
				break;

			case EV_TREBDN:
				treb_level++;
				if (treb_level > 30)
					treb_level = 30;
				a1 = (unsigned long)treb_table[treb_level] << 8;	
				EOL();
				UART_Printfu32(a1);
				EOL();
				write_register(0x6f,a1);				
				event = EV_IDLE;
				break;

			case EV_TREBUP:
				treb_level--;
				if (treb_level < 0)
					treb_level = 0;
				a1 = (unsigned long)treb_table[treb_level] << 8;	
				EOL();
				UART_Printfu32(a1);
				EOL();
				write_register(0x6f,a1);				
				event = EV_IDLE;
				break;

*/				
			case EV_MUTE:
				mute = 1-mute;
				write_register(0xaa,(unsigned long)mute);				
				event = EV_IDLE;
				break;
		}
	
	
		// time to update a buffer ?
		if (updbuf)
		{
			load_sectors(mycluster,updbuf);			// load a clusterfull of data
			mycluster = next_cluster(mycluster);	// follow FAT chain
			updbuf = (unsigned char *)0;			// mark as done
			scroll_flag++;
			time_flag++;
			UART_SendByte('!');
		}

		
		// 
		if (isPlaying)
		{
			if ( bit_is_set(PINB, PB2) )
				UART_SendByte('*');
			
			while ( bit_is_set(PINB, PB2) )			// while DEMAND is high 
			{
				//send data on SPI bus
				outp(*outptr++, SPDR);

				// buffers are updated approx every 250 mS  ( at 128 kBs datastream )

				// check for buffer wrap
				if (outptr == buffer2)
					updbuf = buffer1;
				else if (outptr == buffer3)
					updbuf = buffer2;
				else if (outptr == buffer4)
				{
					updbuf = buffer3;
					outptr = buffer1;
				}

				// check if we're done
				if (--filesize <= 0)
				{
					isPlaying = 0;					// the end is near 
					// try autoplay next song
					event = EV_NEXT;
					break;
				}

				// wait for data to be sent
				loop_until_bit_is_set(SPSR, SPIF);	
				// clear SPIF flag by reading status register
			    inp(SPSR);							
			}

			UART_SendByte('-');


/*			
			// scroll display on every 2 buffer updates (approx 500 ms)
			if (scroll_flag == 2)
			{
				lcd_gotoxy(0,0);
				for (i=0;i<16;i++)
					lcd_putchar( scroll_line[ (scroll_pos+i) % (scroll_length+4) ] );
				scroll_pos++;
				scroll_flag = 0;
			}    
*/
			
/*			
			// update timer on every  buffer updates (approx 250 ms)
			if (time_flag == 1)
			{
				p_time = default_read();
				p_time = p_time * 26;		// framelen festgelegt auf 26.2ms (90% der Faelle..)
				p_time = p_time / 1000;		// ins sec
				c_min = p_time / 60;
				c_sec = p_time % 60;
				p = SectorBuffer;
			
				*p++ = '0' + c_min/10;
				*p++ = '0' + c_min%10;
				*p++ = ':';
				*p++ = '0' + c_sec/10;
				*p++ = '0' + c_sec%10;
				*p++ = 0;

				lcd_gotoxy(6,1);				
				lcd_puts(SectorBuffer);
				time_flag = 0;
			}
*/
		}
  	}    
}