udisk.c

51读写u盘 uart.c main.c rwudiskdemo.c

//#include "stdafx.h"
//#include "CommPort.h"
//extern CCommPort Comm;
//#define SendResponse(buff,len)	Comm.SendData(buff, NULL, len, 10000, 1, 0, FALSE);  //发送数据

#include "config.h"
#include "string.h"
#include "udisk.h"


#ifndef NULL
#define NULL	0
#endif

#define MAX_FILE_SIZE 	512
#define WAIT_TIME_OUT	0x2fff


FHANDLE	g_handle={0xff,0};


CONTR_DISK	rwdisk;
void SendResponse(uint8 *buff,uint16 len);
void FreeFHandle(void);
void ReceOneChar(uint8 ReceChar);

/*********************************************************************************************************
** 函数名称: wait_ack
** 功能描述: 等待应答帧
**
** 输　入: 无
** 输　出: 正常应答返回：TRUE，超时出错返回：FALSE
********************************************************************************************************/
uint8 wait_ack(void)
{
	uint32 i;
	rwdisk.state = 0;

	for(i=0;i<WAIT_TIME_OUT;i++)	// 软件延时等待
	{
		if(0xff==rwdisk.state)
			return TRUE;
	}
	return FALSE;
}

/*
uint8 wait_ack(void)
{
	uint8	rt = TRUE ,ret;
	uint32 i;
	rwdisk.state = 0;
	uint8 tempbuff[512];
	while(0xff!=rwdisk.state)
	{
		ret = Comm.ReadBlock(tempbuff, 6,500);					   // 读出数据
		if(ret==0)
		{
			for(i=0;i<6;i++)
				ReceOneChar(tempbuff[i]);
		}
		else
		{
			rt = FALSE;
			break;
		}
		
		if(rwdisk.rlen==0)
			break;
		ret = Comm.ReadBlock(tempbuff, rwdisk.rlen,500);					   // 读出数据
		if(ret==0)
		{
			for(i=0; i<rwdisk.rlen; i++)
				ReceOneChar(tempbuff[i]);
		}
		else
		{
			rt = FALSE;
			break;
		}
	}
	return rt;
}
*/
//********************************************************************************************************
// 函数名称：ReceOneChar
// 输入参数：ReceCharacter
// 输出参数：无
// 功能描述：接收一个字符处理
//           要求:接收到一个字符后立即传入该函数处理。
//********************************************************************************************************
void ReceOneChar(uint8 ReceChar)
{
	static uint8 	HFNumber = 0;
	static uint8	HFBuffer[6];
	static uint16	DataLen;
	static uint8	state=0;

	if(rwdisk.state!=0)
		return;

	switch(state)
	{
		case 0:
			HFBuffer[HFNumber++] = ReceChar;
			if(HFBuffer[0]!='S')				// 
				if( HFNumber == 2 )
					if(HFBuffer[1]!=':')
						HFNumber = 0;
			if( HFNumber == 6 )
			{	HFNumber = 0;
				rwdisk.cmd 	= HFBuffer[2];
				rwdisk.cmds	= HFBuffer[3];
				DataLen = HFBuffer[4] + HFBuffer[5]*0x100;
				rwdisk.rlen = DataLen;
				rwdisk.wlen = 0;
				if(DataLen!=0)
				{
					state = 1;
				}
				else
				{
					rwdisk.state = 0xff;		// 设置状态
				}
			}
			break;
		case 1:
			rwdisk.write_ptr[rwdisk.wlen++] = ReceChar;
			if(DataLen==rwdisk.wlen)
			{
				rwdisk.state = 0xff;		// 设置状态
				state = 0;
			}
			break;
		default :
            break;
	}
}


void DriverIni(void)
{
   FreeFHandle();				// 释入文件句柄
   rwdisk.state = 0xff;			// 不接收串口数据
}

/*********************************************************************************************************
** 函数名称: GetFHandle
** 功能描述: 获取文件操作包柄
**
** 输　入: 无
** 输　出: 无
********************************************************************************************************/
FHANDLE *GetFHandle(void)
{
	if(g_handle.fh==0xff)
		return &g_handle;
	else
		return NULL;
}

/*********************************************************************************************************
** 函数名称: FreeFHandle
** 功能描述: 释放文件操作句柄
**
** 输　入: 无
** 输　出: 无
********************************************************************************************************/
void FreeFHandle(void)
{
	g_handle.fh = 0xff;
	g_handle.fsize = 0;
}





/*********************************************************************************************************
** 函数名称: GetDiskInfo
** 功能描述: 获取系统信息
**
** 输　入: sysinfptr:系统信息数据结构指针
** 输　出: 正常设置返回：TRUE，出错返回：FALSE
********************************************************************************************************/
uint8 GetDiskInfo(SYSINF *sysinfptr)
{
	uint8	reqbuff[14];
	
	reqbuff[0] = 'U';	reqbuff[1]= ':';	reqbuff[2] = 0x00;
	reqbuff[3] = 0;		reqbuff[4] = 0;	reqbuff[5] = 0;
	SendResponse(reqbuff,6);		// 发送命令请求帧
	sysinfptr->DiskIn = 0;			//  标记U盘不存在
	rwdisk.write_ptr = reqbuff;

	if(wait_ack())					// 等待应答
	{
		if(rwdisk.cmds==0)
		{	sysinfptr->Baud = reqbuff[0];
			sysinfptr->Year = reqbuff[1];
			sysinfptr->Month= reqbuff[2];
			sysinfptr->Dom = reqbuff[3];
			sysinfptr->Hour = reqbuff[4];
			sysinfptr->Min = reqbuff[5];
			sysinfptr->Sec = reqbuff[6];
				
			sysinfptr->DiskIn= reqbuff[7];
			sysinfptr->FH.fh= reqbuff[8];
			sysinfptr->FH.fsize= reqbuff[9]+
						reqbuff[10]*0x100+
						reqbuff[11]*0x10000+
						reqbuff[12]*0x1000000;
			sysinfptr->version = reqbuff[13];
			return	TRUE;
		}
	}
	
	return	FALSE;
}

/*********************************************************************************************************
** 函数名称: SetDiskInfo
** 功能描述: 设置系统信息
**
** 输　入: sysinfptr:系统信息数据结构指针
** 输　出: 正常设置返回：TRUE，出错返回：FALSE
********************************************************************************************************/
uint8  SetDiskInfo(SYSINF *sysinfptr)
{
	uint8	reqbuff[13];
	reqbuff[0] = 'U';	reqbuff[1]= ':';	reqbuff[2] = 0x01;
	reqbuff[3] = 0;		reqbuff[4] = 7;	reqbuff[5] = 0;
	
	reqbuff[6] = sysinfptr->Baud ;
	reqbuff[7] = sysinfptr->Year ;
	reqbuff[8] = sysinfptr->Month;
	reqbuff[9] = sysinfptr->Dom;
	reqbuff[10] = sysinfptr->Hour;
	reqbuff[11] = sysinfptr->Min;
	reqbuff[12] = sysinfptr->Sec;
				
	SendResponse(reqbuff,13);		// 发送命令请求帧
	
	rwdisk.write_ptr = reqbuff;
	if(wait_ack())// 等待应答
	{
		if(rwdisk.cmds==0)
		{	
			return	TRUE;
		}
	}
	
	return	FALSE;
}

/*********************************************************************************************************
** 函数名称: FileOpen
** 功能描述: 以指定方式打开文件
**
** 输　入: DirFileName:用户使用的文件名
** 输　出: 文件句柄，NULL为不能打开
**	   非零值为打开文件的指针
**
********************************************************************************************************/
        FHANDLE *FileOpen(char *DirFileName)
{
	uint8	reqbuff[6];
	uint8	namelen;
	FHANDLE	*handle;
	handle = GetFHandle();
	if(handle==NULL)				// 没有可用的包柄
		return handle;
	reqbuff[0] = 'U';reqbuff[1]= ':';
	reqbuff[2] = 0x10;reqbuff[3] = 0xff;
	namelen = strlen(DirFileName);			// 获取文件名字符串长度
	reqbuff[4] = namelen; reqbuff[5] = 0;
	
	SendResponse(reqbuff,6);			// 发送命令请求帧
	SendResponse((uint8*)DirFileName,namelen);	// 发送命令请求帧
	
	rwdisk.write_ptr = reqbuff;
	
	if(wait_ack())// 等待应答
	{
		if(rwdisk.cmds==0)
		{	handle->fh = reqbuff[0];
			handle->fsize = reqbuff[1]+
					reqbuff[2]*0x100+
					reqbuff[3]*0x10000+
					reqbuff[4]*0x1000000;	
		}
		else
			handle = NULL;
	}
	else	
		handle = NULL;
		
	return handle;
}

/*********************************************************************************************************
** 函数名称: FileClose
** 功能描述: 关闭指定文件
**
** 输　入: Handle:文件句柄
**
** 输　出: RETURN_OK:成功
**        其它参考fat.h中关于返回值的说明 
********************************************************************************************************/
uint8 FileClose(void)
{
	uint8 	reqbuff[6];
	
	reqbuff[0] = 'U';	reqbuff[1]= ':';	reqbuff[2] = 0x12;
	reqbuff[3] = 0;		reqbuff[4] = 0;		reqbuff[5] = 0;
	
	FreeFHandle();
	rwdisk.write_ptr = reqbuff;
	SendResponse(reqbuff,6);		// 发送命令请求帧
	
	if(wait_ack())// 等待应答
	{
		
		return rwdisk.cmds;
	}
	else
		return	0xf0;				// 没应答
	
}

/*********************************************************************************************************
** 函数名称: S_FileWrite
** 功能描述: 写文件
**
** 输　入: Buf:要写的数据
**        Size:要写的字节数
**        Handle:文件句柄
** 输　出: 实际写的字节数
********************************************************************************************************/
uint16	S_FileWrite(void *Buf, uint16 Size, FHANDLE *Handle)
{
	uint8	reqbuff[10];
	if(Handle==NULL)	return	0;
	reqbuff[0] = 'U';reqbuff[1]= ':';	reqbuff[2] = 0x20;
	if(Handle->fh!=0xff) reqbuff[3] = Handle->fh;
	else return	0;
	reqbuff[4] = (uint8)Size;
	reqbuff[5] = (uint8)(Size/0x100);
	rwdisk.write_ptr = &reqbuff[6];

	SendResponse(reqbuff,6);		// 发送命令请求帧
	SendResponse((uint8*)Buf,Size);		// 发送命令请求帧

/*	
	uint8	tempbuf[512+6];
	memcpy(tempbuf,reqbuff,6); 
	memcpy(tempbuf+6,Buf,Size); 
	SendResponse(tempbuf,6+Size);
*/

	if(wait_ack())// 等待应答
	{	if(rwdisk.cmds!=0)
			return 0;
	}
	else	
		return 0;
	return (uint16)(reqbuff[6]+reqbuff[7]*0x100); // reqbuff[8]，reqbuff[9] 不处理 
}

/*********************************************************************************************************
** 函数名称: FileWrite
** 功能描述: 写文件
**
** 输　入: Buf:要写的数据
**        Size:要写的字节数
**        Handle:文件句柄
** 输　出: 实际写的字节数
********************************************************************************************************/
uint32 FileWrite(uint8 *Buf, uint32 Size, FHANDLE *Handle)
{
	uint32	allwrite=0;
	uint16  bewrite;
	
	while((Size/MAX_FILE_SIZE)>0)
	{
		Size -= MAX_FILE_SIZE;
		bewrite = S_FileWrite( Buf+allwrite,MAX_FILE_SIZE,Handle);
		if(bewrite == MAX_FILE_SIZE)
		{
			allwrite += bewrite;
		}
		else	// 写文件出错
		{
			return allwrite;
		}
	}

	bewrite = 0;
	if(Size)
	{
		bewrite = S_FileWrite(Buf+allwrite,(uint16) Size,Handle);
	}

	return allwrite+bewrite;
}

/*********************************************************************************************************
** 函数名称: FileRead
** 功能描述: 读取文件
**
** 输　入: Buf:保存读回的数据
**        Size:要读的字节数
**        Handle:文件句柄
** 输　出: 实际读到的字节数
********************************************************************************************************/
uint16 S_FileRead(void *Buf, uint16 Size, FHANDLE *Handle)
{
	uint8	reqbuff[10];
	if(Handle==NULL)	return	0;
	reqbuff[0] = 'U';reqbuff[1]= ':';	reqbuff[2] = 0x30;
	if(Handle->fh!=0xff) reqbuff[3] = Handle->fh;
	else return	0;
	reqbuff[4] = 4;
	reqbuff[5] = 0;
	reqbuff[6] = (uint8)Size;
	reqbuff[7] = (uint8)(Size/0x100);
	reqbuff[8] = 0;
	reqbuff[9] = 0;
	
	rwdisk.write_ptr = (uint8*)Buf;
	SendResponse(reqbuff,10);		// 发送命令请求帧

	
	if(wait_ack())// 等待应答
	{	if(rwdisk.cmds!=0)
			return 0;
	}
	else	return 0;
	return (uint16)rwdisk.wlen;
}

/*********************************************************************************************************
** 函数名称: FileRead
** 功能描述: 读取文件
**
** 输　入: Buf:保存读回的数据
**        Size:要读的字节数
**        Handle:文件句柄
** 输　出: 实际读到的字节数
********************************************************************************************************/
uint32 FileRead(uint8 *Buf, uint32 Size, FHANDLE *Handle)
{
	uint32	allread=0;
	uint16  beread;
	
	while((Size/MAX_FILE_SIZE)>0)
	{
		Size -= MAX_FILE_SIZE;
		beread = S_FileRead( Buf+allread,MAX_FILE_SIZE,Handle);
		if(beread==MAX_FILE_SIZE)
		{
			allread += beread;
		}
		else	// 写文件出错
		{
			return allread;
		}
	}
	beread = 0;
	if(Size)
	{
		beread = S_FileRead(Buf+allread,(uint16) Size,Handle);
	}
	return allread+beread;
}



/*********************************************************************************************************
** 函数名称: FileSeek
** 功能描述: 移动文件读\写位置
**
** 输　入: Handle:文件句柄
**        offset:移动偏移量
**        Whence:移动模式SEEK_SET:从文件头计算SEEK_CUR:从当前位置计算SEEK_END:从文件尾计算
** 输　出: 成功返回0
**         出错返回非0值
********************************************************************************************************/
uint8 FileSeek(FHANDLE *Handle, int32 offset, uint8 Whence)
{
	uint8	reqbuff[11];
	if(Handle==NULL)	return	PARAMETER_ERR;
	reqbuff[0] = 'U';	reqbuff[1]= ':';	reqbuff[2] = 0x40;
	if(Handle->fh!=0xff) 
		reqbuff[3] = Handle->fh;
	else 
		return	PARAMETER_ERR;
	reqbuff[4] = 5;
	reqbuff[5] = 0;
	
	reqbuff[6] = offset & 0xff;
	reqbuff[7] = (offset>>8) & 0xff ;
	reqbuff[8] = (offset>>16) & 0xff;
	reqbuff[9] = (offset>>24) & 0xff;
	
	reqbuff[10] = Whence;

	rwdisk.write_ptr = reqbuff;
	SendResponse(reqbuff,11);		// 发送命令请求帧
	
	if(wait_ack())// 等待应答
	{	
		return rwdisk.cmds;
	}
	else	
		return 0xff;
}

/*********************************************************************************************************
** 函数名称: MakeDir
** 功能描述: 建立目录
**
** 输　入: Path:路径名
**
** 输　出: 成功返回0
**         出错返回非0值
********************************************************************************************************/
uint8 MakeDir(char *Path)
{
	uint8	reqbuff[6];
	uint8	namelen;
	uint8	rt;

	reqbuff[0] = 'U';reqbuff[1]= ':';
	reqbuff[2] = 0x50;reqbuff[3] = 0xff;
	namelen = strlen(Path);					// 获取文件夹名字符串长度
	reqbuff[4] = namelen; reqbuff[5] = 0;
	
	SendResponse(reqbuff,6);				// 发送命令请求帧
	SendResponse((uint8*)Path,namelen);		// 发送命令请求帧
	
	rwdisk.write_ptr = reqbuff;
	
	if(wait_ack())							// 等待应答
	{
		rt = rwdisk.cmds;
	}
	else	
		rt = 0xff;
		
	return rt;
}