예제 #1
0
signed char FAT_get_BS_data(void)
{
  signed char resp;
  struct MBR_struct *mbr;
  uint32_t firstSec=0,uliTemp;
  char buf[16];

  resp=sd_readSector(0,SD_SECSIZE); 
  if(resp==-1)
    return resp;
  
  if(sd_buf[0]!=0xE9 && sd_buf[0]!=0xEB)
  {
    if(sd_buf[510]==0x55 && sd_buf[511]==0xAA)
    {
      mbr=(struct MBR_struct *)sd_buf;   
      firstSec=(mbr->partitionData[11]<<24)|(mbr->partitionData[10]<<16)|(mbr->partitionData[9]<<8)|(mbr->partitionData[8]);
      resp=sd_readSector(firstSec,SD_SECSIZE);
    }
    else
      return -1;				//NOT BS nor MBR
  }

  if(sd_buf[0x52+3]=='3')
  {
    FATType=FAT32;
    usart1_puts("\n\rVOLUME Label: ");
    for(resp=0;resp<11;resp++)
      usart1_putch(sd_buf[0x47+resp]);

    usart1_puts("\n\rFAT Type:");
    for(resp=0;resp<8;resp++)
      usart1_putch(sd_buf[0x52+resp]);

    F32_getParameters(sd_buf,firstSec);
  }
  else
  {
    FATType=FAT16;    
    usart1_puts("\n\rVOLUME Label: ");
    for(resp=0;resp<11;resp++)
      usart1_putch(sd_buf[0x2b+resp]);

    usart1_puts("\n\rFAT Type:");
    for(resp=0;resp<8;resp++)
      usart1_putch(sd_buf[0x36+resp]);
    //F16_getParameters(sd_buf);
  }

  return 0;
}
예제 #2
0
euint32 read_file_chain_length(SDfile fileInfo)
{
	euint32 current_address = (fileInfo.startL | (euint32)fileInfo.startH<<16);
	euint32 FAT_start = LBAbegin + Part_Boot.res_sec;
	euint8 buffer1[size];
	euint32 length = 0;
	euint32 modulus = 0;
	while(current_address < 0x0FFFFFF8)
		{
			//NOTE 0x0FFFFFF7 means the cluster is bad so we may need to skip
			euint32 FATNumber = (current_address*4)/512;// will floor for us
			// Read in the new sector
			sd_readSector(FAT_start+FATNumber,buffer1);	//reads FAT
			// Find the offset from start of FATNumber as per the modulus
			modulus = (current_address/4)%512;
			// Increment now to try and catch the last entry as well
			length++;
			// Get next address
			current_address = (euint32)buffer1[current_address*4+3] << 24 |
					(euint32)buffer1[current_address*4+2] << 16 |
					(euint32)buffer1[current_address*4+1] << 8 |
					(euint32)buffer1[current_address*4];
		}
	// vvv For debugging only vvv
	printf("Length of Chain: %d\r\n", length);
	return length;
}
예제 #3
0
파일: dsp67xx.c 프로젝트: Godzil/quickdev16
short if_readBuf(hwInterface* file,euint32 address,unsigned char* buf)
{
	short r;
	r=sd_readSector(file,address,buf,512);
	if(r!=0)printf("ERROR READING SECTOR %i\n",address);
	return(r);
}
예제 #4
0
euint8 read_rootTable(euint32 LBABegin,euint32 ResSect)
{
	euint8 buffer[size];
	sd_readSector(LBABegin+ResSect+3,buffer);

	printf("\n");
	return 0;
}
예제 #5
0
euint8 read_mboot(euint8* buffer)
{
	if(sd_readSector(mboot,buffer) != 0)
	{
		printf("failed sector read\n");
		return(-1);
	}
	return(0);
}
예제 #6
0
파일: msp2617.c 프로젝트: kono123/iam
esint8 if_readBuf(hwInterface* file,euint32 address,euint8* buf)
{
	esint8 res;
	
	if_spiSelectDevice(file);
	res = sd_readSector(file,address,buf,512);
	if_spiUnselectDevice(file);
	
	return(res);
}
예제 #7
0
void writeTest()
{
  unsigned long int secNum;

  secNum=F32_getFirstSector(8);
  sd_writeSector(secNum,sd_buf);
  //uart0_dump(sd_buf,512,32);
  usart1_puts("\n\r");
  sd_readSector(secNum,512);
  //uart0_dump(sd_buf,512,32);
}
예제 #8
0
euint8 read_part_boot()
{
	euint8 buffer[size];
	if(sd_readSector(LBAbegin,buffer) != 0)
	{
		printf("failed sector read\n");
		return(-1);
	}
	Part_Boot.bytes_per_sec = (buffer[11]|((euint16) buffer[12])<<8);
	Part_Boot.sec_per_clust = (euint8)buffer[13];
	Part_Boot.res_sec = (buffer[14]|((euint16) buffer[15])<<8);
	Part_Boot.FAT_num = (euint8)buffer[16];
	Part_Boot.sec_num_small =(buffer[19]|((euint16) buffer[20])<<8);
	Part_Boot.sec_num_big = ((euint32)buffer[32]|((euint32) buffer[33])<<8|((euint32) buffer[34])<<16|((euint32) buffer[35])<<24);
	Part_Boot.sec_per_FAT = ((euint32)buffer[36]|((euint32) buffer[37])<<8|((euint32) buffer[38])<<16|((euint32) buffer[39])<<24);
	Part_Boot.clust_num = ((euint32)buffer[44]|((euint32) buffer[45])<<8|((euint32) buffer[46])<<16|((euint32) buffer[47])<<24);
	return(0);
}
예제 #9
0
//returns the address stored in FAT table in the address'th entry of the FAT table
euint32 next_sect_address(euint32 address,euint32* next_FAT_address)
{
	euint8 buffer[512];
	euint32 FATnumber = (address*4)/512;
	euint32 FAT_address;
	euint32 relative_address;
	euint32 next_address;
	euint8 i;
	
	FAT_address = FAT_start + FATnumber;
	relative_address = (address*4 + FAT_start*512) - FAT_address*512;
	relative_address = (address*4)%512;
	sd_readSector(FAT_address,buffer);
	next_address = 	(euint32)buffer[relative_address]
	             | 	((euint32)buffer[relative_address+1])<<8
	             |	((euint32)buffer[relative_address+2])<<16
	             |	((euint32)buffer[relative_address+3])<<24;
	*next_FAT_address = next_address;
	next_address = (next_address -2)*Part_Boot.sec_per_clust + clust_start;
	return(next_address);
}
예제 #10
0
esint8
if_readBuf(hwInterface* file,euint32 address,euint8* buf)
{
        return(sd_readSector(file,address,buf,512));
}
예제 #11
0
euint8 open_wav(SDfile fileinfo)
{
	euint8 buff[600];
	euint32 buff2[512];
	euint32 right[512];
	euint32 left[512];
	euint8 leftovers[512];
	euint8 leftoverCount=0;
	euint32 count = 0;
	euint32 i,zz;
	euint32 tempright;
	euint32 temp[5];
	euint32 overflow_amount = 0;
	euint32 LoopC = 0;
	euint32 stuff_to_write = 0;
	euint32 ints_to_send = 0;
	euint32 sample_rate = 0;
	euint32 bitdepth = 0;
	euint32 channels = 0;
	euint32 formatcode = 0;
	euint32 blocksize = 0;
	euint32 header_size = 0;
	euint32 next_address = 0;
	euint32 clust_address = 0;
	euint32 FAT_address = 0;
	euint32 filesize = 0;
	euint32 end_offset = 0;
	euint32 bytes_read = 0;
	euint8 end_of_file = 0;

	alt_up_audio_dev*  audio_dev = alt_up_audio_open_dev(AUDIO_NAME);
	alt_up_audio_reset_audio_core(audio_dev);

	filesize = fileinfo.file_size;

	FAT_address = (euint32)fileinfo.startL | ((euint32)fileinfo.startH)<<16;

	clust_address = (FAT_address-2)*Part_Boot.sec_per_clust + clust_start;

	sd_readSector(clust_address,buff);		//read in wav header info
	bytes_read += 512;

	//address = next_sect_address(address);

	header_size = get_wav_header(buff,&sample_rate,&bitdepth,&channels,&formatcode,&blocksize); //psuedo code for reading in wav details, returns wav info

	if(formatcode != 1)
	{
		UART_write("Error: incorrect wav format type, please use PCM\n\r");
		return(1);
	}
	if(channels != 2)
	{
		UART_write("Error, number of channels must be 2\n\r");
		return(1);
	}
	if((bitdepth != 32)&&(bitdepth != 16)&&(bitdepth != 24)&&(bitdepth != 8))
	{
		UART_write("Error, bitdepth is incorrect\n\r");
		return(1);
	}
	if(sample_rate != 8000)
		{
			UART_write("Error, sample rate is incorrect\n\r");
			return(1);
		}
	switch(sample_rate)
		{
		  case 8000:  AUDIO_SetSampleRate(RATE_ADC8K_DAC8K_USB); break;
		  case 32000: AUDIO_SetSampleRate(RATE_ADC32K_DAC32K_USB); break;
		  case 44100: AUDIO_SetSampleRate(RATE_ADC44K_DAC44K_USB); break;
		  case 48000: AUDIO_SetSampleRate(RATE_ADC48K_DAC48K_USB); break;
		  case 96000: AUDIO_SetSampleRate(RATE_ADC96K_DAC96K_USB); break;
		  default:  printf("Non-standard sampling rate\n"); return -1;
	   }
	count = count + header_size;
	while(end_of_file == 0)	//start reading bytes from offset position, if  there are bytes to be read, continue
	{
		//convert char buffer into 32 bit buffer
		while(LoopC < Part_Boot.sec_per_clust)
		{
			if(bitdepth == 32)
			{
				for(i=0;i<128;i++)
				{
					*((unsigned char*)&buff2[i]+0) = buff[count+0];
					*((unsigned char*)&buff2[i]+1) = buff[count+1];
					*((unsigned char*)&buff2[i]+2) = buff[count+2];
					*((unsigned char*)&buff2[i]+3) = buff[count+3];
					count += 4;
					if(count > 512)
					{
						ints_to_send = i+1;
						break;
					}
					if(i==127) ints_to_send = i+1;
				}
				count = 0;
			}
			if(bitdepth == 24)
			{
				for(i=0;i<170;i++)		// PROBLEM HERE PROBS SINCE 512/3 ISNT WHOLE NUMBER
				{
					*((unsigned char*)&buff2[i]+0) = 0;
					*((unsigned char*)&buff2[i]+1) = buff[count+0];
					*((unsigned char*)&buff2[i]+2) = buff[count+1];
					*((unsigned char*)&buff2[i]+3) = buff[count+2];
					count += 3;
					if(count >= 512)
					{
						count = (count-512)+3;
						ints_to_send = i+1;
						break;
					}
				}
			}
			if(bitdepth == 16)
			{
				for(i=0;i<256;i++)
				{
					*((unsigned char*)&buff2[i]+0) = 0;
					*((unsigned char*)&buff2[i]+1) = 0;
					*((unsigned char*)&buff2[i]+2) = buff[count+0];
					*((unsigned char*)&buff2[i]+3) = buff[count+1];
					count += 2;

					if(count > 512)
					{
						ints_to_send = i+1;
						break;
					}
					if(i==255) ints_to_send = i+1;
				}
				count = 0;
			}
			if(bitdepth == 8)
			{
				for(i=0;i<512;i++)
				{
					*((unsigned char*)&buff2[i]+0) = 0;
					*((unsigned char*)&buff2[i]+1) = 0;
					*((unsigned char*)&buff2[i]+2) = 0;
					*((unsigned char*)&buff2[i]+3) = buff[count+0];
					count++;

					if(count > 512)
					{
						ints_to_send = i+1;
						break;
					}
					if(i==511) ints_to_send = i+1;
				}
				count = 0;
			}
			// pass to left and right channels
			for(i=0;i<256;i++)
			{
				left[i] = buff2[i*2];
				right[i] = buff2[i*2+1];
			}

			if(end_offset != 0)
			{
				stuff_to_write = end_offset/(1024/ints_to_send);
				end_of_file = 1;
				end_offset = 0;
			}
			else
			{
				stuff_to_write = ints_to_send/2;
			}
			//is there space in the fifo?
			while(alt_up_audio_write_fifo_space(audio_dev,0) < stuff_to_write);
			//send to audio channels
			alt_up_audio_write_fifo(audio_dev,right,stuff_to_write,ALT_UP_AUDIO_RIGHT);
			alt_up_audio_write_fifo(audio_dev,left,stuff_to_write,ALT_UP_AUDIO_LEFT);
			clust_address++;
			sd_readSector(clust_address,buff);
			bytes_read += 512;
			LoopC++;
			if(bytes_read >= filesize)
			{
				end_of_file = 1;
				//end_offset = 512 - (bytes_read-filesize);
			}
		}
		LoopC = 0;
		clust_address = next_sect_address(FAT_address,&next_address);
		FAT_address = next_address;
		if(bytes_read >= filesize)
		{
			end_of_file = 1;
			//end_offset = 512 - (bytes_read-filesize);
		}
	}
	return(0);
}
예제 #12
0
파일: spi.c 프로젝트: swen3027/APB_R2
int8_t if_readBuf(hwInterface* file, uint32_t address,uint8_t * buf)
{
	return(sd_readSector(file,address,buf,512));
}