2019-08-05 11:29:02 gajicat 阅读数 487
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3411 人正在学习 去看看 朱有鹏

使用的芯片是STC15系列的IAP15F2K61S2,开发板是51的xl2000。把芯片座上的51芯片拔掉换成STC的,混合模式。(配置够低吧)
源码由51开发板例程的实验26修改而来。
浏览了网上的教程,目前SD卡基本有以下几种,对应着不同的初始化和读写方式:

一般来说刚上电时,
SD卡不支持CMD1而支持CMD55,
MMC卡不支持CMD55而支持CMD1.
通过CMD8来区分SD1.1和SD2.0卡,
通过ACMD41来区分SD2.0 SDSC or SDHC.

我手头有六张1~16GB的不同容量的SD卡,1G/2G/8G/16G各一张,4G两张。经过测试,已经可以成功地向其中的5张SD卡读写数据块,另有一张class6的4G卡没有读写成功。在这过程中,初始化的过程与大佬们前述的结果并不一样,例如协议1.0与2.0的卡在CMD8命令下均返回0x01,SD2.0 SDSC卡初始化可以返回正常值但不能读出写入,等等。在此列出1G,2G,4G及以上SD卡不同的初始化代码以及测试代码。

其中只有HAL.c的SdInit函数不一样,其他代码是共用的。

SD卡模块
HAL.h

#include	"config.h"

sbit SD_CS	=P1^1;		
sbit SD_DI	=P1^2;
sbit SD_CLK	=P1^3;
sbit SD_DO	=P1^4;

unsigned char SdInit(void);
unsigned char SdReadBlock(unsigned char *Block, unsigned long address,int len);
unsigned char SdWriteBlock(unsigned char *Block, unsigned long address,int len);
unsigned char SdWriteBlock2(unsigned char *Block, unsigned long address,int len);

void ComSendByte(unsigned char c);

HAL.c
1G卡:CMD0+CMD8+CMD1

#include "HAL.H"

char csd[16];

//============================================================
//写一字节到SD卡,模拟SPI总线方式
void SdWrite(unsigned char  n)
{
    
  unsigned char i;

  for(i=8;i;i--)
   {
    SD_CLK=0;
    SD_DI=(n&0x80);
    n<<=1;
    SD_CLK=1;
   }
  SD_DI=1;      
}   
//================================================================
//从SD卡读一字节,模拟SPI总线方式
unsigned char SdRead()
{
 unsigned char n,i;
 for(i=8;i;i--)
  {
   SD_CLK=0;
   SD_CLK=1;
   n<<=1;
   if(SD_DO) n|=1;

  }
 return n;
}
//================================================================
//检测SD卡的响应
unsigned char SdResponse()
{
  unsigned char i=0,response;
  
  while(i<=8)
  {
    response = SdRead();
    if(response==0x00)
      break;
    if(response==0x01)
      break;
    i++;
  }
  return response;
}  
//================================================================
//发命令到SD卡
void SdCommand(unsigned char command, unsigned long argument, unsigned char CRC)
{
  
  SdWrite(command|0x40);
  SdWrite(((unsigned char *)&argument)[0]);
  SdWrite(((unsigned char *)&argument)[1]);
  SdWrite(((unsigned char *)&argument)[2]);
  SdWrite(((unsigned char *)&argument)[3]);
  SdWrite(CRC);
}
//================================================================
//初始化SD卡
unsigned char SdInit(void)
{
  int delay=0, trials=0;
  unsigned char i;
  unsigned char response=0x01;

  SD_CS=1;
  for (i=0;i<0x0f;i++)    
   {
    SdWrite(0xff);
	}
  SD_CS=0;
  
  //Send Command 0 to put MMC in SPI mode

  do{

  SdCommand(0x00,0,0x95);

  
  response=SdResponse();
  trials++;
	if(trials>=200){
	  return 0xfe;
	}


  }while(response!=0x01);

   
  
   
  trials=0;
   do{
	  


	  SdCommand(0x08,0x1AA,0x87);
	
	  
	  response=SdResponse();
		  
	  trials++;
	if(trials>=200){
	  return 0xfd;
	}


  }while(response!=0x01);
   
	   	   

trials = 0;
  
  do{
     SD_CS=1;
    SdWrite(0xff);
    SD_CS=0;
    SdCommand(0x01,0x00ffc000,0xff);
    response=SdResponse();
	
	trials++;
	if(trials>=200){
	  return 0xfa;
	}
  } while(response==0x01);
   

  	   

	
  SD_CS=1;
  SdWrite(0xff);
 return 1; 
}
//================================================================
//往SD卡指定地址写数据,一次最多512字节
unsigned char SdWriteBlock(unsigned char *Block, unsigned long address,int len)
{
  unsigned int  count;
  unsigned char dataResp;
  //Block size is 512 bytes exactly
  //First Lower SS

  SD_CS=0;
  //Then send write command
  SdCommand(0x18,address,0xff);
  	
  if(SdResponse()==0x00)
  {

	
    SdWrite(0xff);
	SdWrite(0xff);
	SdWrite(0xff);
    //command was a success - now send data
    //start with DATA TOKEN = 0xFE
    SdWrite(0xfe);
    //now send data
    for(count=0;count<len;count++) SdWrite(*Block++);
    
	for(;count<512;count++) SdWrite(0);
    //data block sent - now send checksum
    SdWrite(0xff);								//两字节CRC校验, 为0XFFFF 表示不考虑CRC
    SdWrite(0xff);
    //Now read in the DATA RESPONSE token
    dataResp=SdRead();
    //Following the DATA RESPONSE token
    //are a number of BUSY bytes
    //a zero byte indicates the MMC is busy
	
    while(SdRead()==0);

    dataResp=dataResp&0x0f;	//mask the high byte of the DATA RESPONSE token
    SD_CS=1;
    SdWrite(0xff);
    if(dataResp==0x0b)
      {
	  //P0=0x0b;
      //printf("DATA WAS NOT ACCEPTED BY CARD -- CRC ERROR\n");
      return 0;
      }
    if(dataResp==0x05){
	//P0=0x05;
	      return 1;
	   }
    //printf("Invalid data Response token.\n");
	//P0=0x02;
    return 0;
 }
 //P0=0x01;
  //printf("Command 0x18 (Write) was not received by the MMC.\n");
  return 0;
}
//=======================================================================
//从SD卡指定地址读取数据,一次最多512字节
unsigned char SdReadBlock(unsigned char *Block, unsigned long address,int len)
{
   unsigned int count;
   int trials=0;
  //Block size is 512 bytes exactly
  //First Lower SS
  
//  printf("MMC_read_block\n");
 
  SD_CS=0;
  //Then send write command

  SdCommand(0x11,address,0xff);
  
  if(SdResponse()==0x00)
  {	
    //command was a success - now send data
    //start with DATA TOKEN = 0xFE
	
    while(SdRead()!=0xfe);
	
    for(count=0;count<len;count++) *Block++=SdRead();    

	for(;count<512;count++)  SdRead();
	 
    //data block sent - now send checksum
    SdRead();
    SdRead();
    //Now read in the DATA RESPONSE token
    SD_CS=1;
    SdRead();
    return 1;
 }
//  printf("Command 0x11 (Read) was not received by the MMC.\n");
  return 0;
}

HAL.c
2G卡:CMD0+CMD8+CMD55+CMD1

#include "HAL.H"

char csd[16];

//============================================================
//写一字节到SD卡,模拟SPI总线方式
void SdWrite(unsigned char  n)
{
    
  unsigned char i;

  for(i=8;i;i--)
   {
    SD_CLK=0;
    SD_DI=(n&0x80);
    n<<=1;
    SD_CLK=1;
   }
  SD_DI=1;      
}   
//================================================================
//从SD卡读一字节,模拟SPI总线方式
unsigned char SdRead()
{
 unsigned char n,i;
 for(i=8;i;i--)
  {
   SD_CLK=0;
   SD_CLK=1;
   n<<=1;
   if(SD_DO) n|=1;

  }
 return n;
}
//================================================================
//检测SD卡的响应
unsigned char SdResponse()
{
  unsigned char i=0,response;
  
  while(i<=8)
  {
    response = SdRead();
    if(response==0x00)
      break;
    if(response==0x01)
      break;
    i++;
  }
  return response;
}  
//================================================================
//发命令到SD卡
void SdCommand(unsigned char command, unsigned long argument, unsigned char CRC)
{
  
  SdWrite(command|0x40);
  SdWrite(((unsigned char *)&argument)[0]);
  SdWrite(((unsigned char *)&argument)[1]);
  SdWrite(((unsigned char *)&argument)[2]);
  SdWrite(((unsigned char *)&argument)[3]);
  SdWrite(CRC);
}
//================================================================
//初始化SD卡
unsigned char SdInit(void)
{
  int delay=0, trials=0;
  unsigned char i;
  unsigned char response=0x01;

  SD_CS=1;
  for (i=0;i<0x0f;i++)    
   {
    SdWrite(0xff);
	}
  SD_CS=0;
  
  //Send Command 0 to put MMC in SPI mode

  do{

  SdCommand(0x00,0,0x95);

  
  response=SdResponse();
  trials++;
	if(trials>=200){
	  return 0xfe;
	}


  }while(response!=0x01);

   
  
   
   trials=0;
   do{
	  


	   SdCommand(0x08,0x1AA,0x87);
	
	  
	   response=SdResponse();
		  
	   trials++;
	   if(trials>=200){
	     return 0xfd;
      }


  }while(response!=0x01);
   
   

 
    SdCommand(55, 0, 0);
	response=SdResponse();
	   	   

   trials = 0;
  
  do{
     SD_CS=1;
    SdWrite(0xff);
    SD_CS=0;
    SdCommand(0x01,0x00ffc000,0xff);
    response=SdResponse();
	
	trials++;
	if(trials>=200){
	  return 0xfa;
	}
  } while(response==0x01);
   

  	   

	
SD_CS=1;
  SdWrite(0xff);
 return 1; 
}
//================================================================
//往SD卡指定地址写数据,一次最多512字节
unsigned char SdWriteBlock(unsigned char *Block, unsigned long address,int len)
{
  unsigned int  count;
  unsigned char dataResp;
  //Block size is 512 bytes exactly
  //First Lower SS

  SD_CS=0;
  //Then send write command
  SdCommand(0x18,address,0xff);
  	
  if(SdResponse()==0x00)
  {

	
    SdWrite(0xff);
	SdWrite(0xff);
	SdWrite(0xff);
    //command was a success - now send data
    //start with DATA TOKEN = 0xFE
    SdWrite(0xfe);
    //now send data
    for(count=0;count<len;count++) SdWrite(*Block++);
    
	for(;count<512;count++) SdWrite(0);
    //data block sent - now send checksum
    SdWrite(0xff);								//两字节CRC校验, 为0XFFFF 表示不考虑CRC
    SdWrite(0xff);
    //Now read in the DATA RESPONSE token
    dataResp=SdRead();
    //Following the DATA RESPONSE token
    //are a number of BUSY bytes
    //a zero byte indicates the MMC is busy
	
    while(SdRead()==0);

    dataResp=dataResp&0x0f;	//mask the high byte of the DATA RESPONSE token
    SD_CS=1;
    SdWrite(0xff);
    if(dataResp==0x0b)
      {
	  //P0=0x0b;
      //printf("DATA WAS NOT ACCEPTED BY CARD -- CRC ERROR\n");
      return 0;
      }
    if(dataResp==0x05){
	//P0=0x05;
	      return 1;
	   }
    //printf("Invalid data Response token.\n");
	//P0=0x02;
    return 0;
 }
 //P0=0x01;
  //printf("Command 0x18 (Write) was not received by the MMC.\n");
  return 0;
}
//=======================================================================
//从SD卡指定地址读取数据,一次最多512字节
unsigned char SdReadBlock(unsigned char *Block, unsigned long address,int len)
{
   unsigned int count;
   int trials=0;
  //Block size is 512 bytes exactly
  //First Lower SS
  
//  printf("MMC_read_block\n");
 
  SD_CS=0;
  //Then send write command

  SdCommand(0x11,address,0xff);
  
  if(SdResponse()==0x00)
  {	
    //command was a success - now send data
    //start with DATA TOKEN = 0xFE
	
    while(SdRead()!=0xfe);
	
    for(count=0;count<len;count++) *Block++=SdRead();    

	for(;count<512;count++)  SdRead();
	 
    //data block sent - now send checksum
    SdRead();
    SdRead();
    //Now read in the DATA RESPONSE token
    SD_CS=1;
    SdRead();
    return 1;
 }
//  printf("Command 0x11 (Read) was not received by the MMC.\n");
  return 0;
}

HAL.c
4G以上:CMD0+CMD8+CMD55+CMD41

#include "HAL.H"


//============================================================
//写一字节到SD卡,模拟SPI总线方式
void SdWrite(unsigned char  n)
{
    
  unsigned char i;

  for(i=8;i;i--)
   {
    SD_CLK=0;
    SD_DI=(n&0x80);
    n<<=1;
    SD_CLK=1;
   }
  SD_DI=1;      
}   
//================================================================
//从SD卡读一字节,模拟SPI总线方式
unsigned char SdRead()
{
 unsigned char n,i;
 for(i=8;i;i--)
  {
   SD_CLK=0;
   SD_CLK=1;
   n<<=1;
   if(SD_DO) n|=1;

  }
 return n;
}
//================================================================
//检测SD卡的响应
unsigned char SdResponse()
{
  unsigned char i=0,response;
  
  while(i<=8)
  {
    response = SdRead();
    if(response==0x00)
      break;
    if(response==0x01)
      break;
    i++;
  }
  return response;
}  
//================================================================
//发命令到SD卡
void SdCommand(unsigned char command, unsigned long argument, unsigned char CRC)
{
  
  SdWrite(command|0x40);
  SdWrite(((unsigned char *)&argument)[0]);
  SdWrite(((unsigned char *)&argument)[1]);
  SdWrite(((unsigned char *)&argument)[2]);
  SdWrite(((unsigned char *)&argument)[3]);
  SdWrite(CRC);
}
//================================================================
//初始化SD卡
unsigned char SdInit(void)
{
  int delay=0, trials=0;
  unsigned char i;
  unsigned char response=0x01;

  SD_CS=1;
  for (i=0;i<0x0f;i++)    
   {
    SdWrite(0xff);
	}
  SD_CS=0;
  
  //Send Command 0 to put MMC in SPI mode

  do{

  SdCommand(0x00,0,0x95);

  
  response=SdResponse();
  trials++;
	if(trials>=200){
	  return 0xfe;
	}


  }while(response!=0x01);

   
  
   
   
   ////////////////////USB2.0
  trials=0;
   do{
	  


	  SdCommand(0x08,0x1AA,0x87);
	
	  
	  response=SdResponse();
		  
	  trials++;
	if(trials>=200){
	  return 0xfd;
	}


  }while(response!=0x01);
   
   

 	SD_CS=1;
    SdWrite(0xff);
    SD_CS=0;
	trials =0;
	 
	do
   {
	   SdRead();SdRead();SdRead();SdRead();
	   SdCommand(55, 0, 0);
	   response=SdResponse();
	   	   
		 if(response!=0x01)
         {
            return 0xfb;
			  
         }

	     SdCommand(41, 0x40000000, 0);
	 	 response=SdResponse();
			
			
		trials++;
		if(trials>=200){
			  return 0xf7;
		}
      
    }while(response!=0x00);
	

	
  SD_CS=1;
  SdWrite(0xff);
   return 1; 
}
//================================================================
//往SD卡指定地址写数据,一次最多512字节
unsigned char SdWriteBlock(unsigned char *Block, unsigned long address,int len)
{
  unsigned int  count;
  unsigned char dataResp;
  //Block size is 512 bytes exactly
  //First Lower SS

  SD_CS=0;
  //Then send write command
  SdCommand(0x18,address,0xff);
  
  if(SdResponse()==0x00)
  {
	SdWrite(0xff);
	SdWrite(0xff);
	SdWrite(0xff);
    //command was a success - now send data
    //start with DATA TOKEN = 0xFE
    SdWrite(0xfe);
    //now send data
    for(count=0;count<len;count++) SdWrite(*Block++);
    
	for(;count<512;count++) SdWrite(0);
    //data block sent - now send checksum
    SdWrite(0xff);								//两字节CRC校验, 为0XFFFF 表示不考虑CRC
    SdWrite(0xff);
    //Now read in the DATA RESPONSE token
    dataResp=SdRead();
    //Following the DATA RESPONSE token
    //are a number of BUSY bytes
    //a zero byte indicates the MMC is busy
	
    while(SdRead()==0);

    dataResp=dataResp&0x0f;	//mask the high byte of the DATA RESPONSE token
    SD_CS=1;
    SdWrite(0xff);
    if(dataResp==0x0b)
      {
	  //P0=0x0b;
      //printf("DATA WAS NOT ACCEPTED BY CARD -- CRC ERROR\n");
      return 0;
      }
    if(dataResp==0x05){
	//P0=0x05;
	      return 1;
	   }
    //printf("Invalid data Response token.\n");
	//P0=0x02;
    return 0;
 }
 //P0=0x01;
  //printf("Command 0x18 (Write) was not received by the MMC.\n");
  return 0;
}
//=======================================================================
//从SD卡指定地址读取数据,一次最多512字节
unsigned char SdReadBlock(unsigned char *Block, unsigned long address,int len)
{
   unsigned int count;
   int trials=0;
  //Block size is 512 bytes exactly
  //First Lower SS
  
//  printf("MMC_read_block\n");

  SD_CS=0;
  //Then send write command

  SdCommand(0x11,address,0xff);  
  	
  if(SdResponse()==0x00)
  {	
    //command was a success - now send data
    //start with DATA TOKEN = 0xFE
	
    while(SdRead()!=0xfe);
	
    for(count=0;count<len;count++) *Block++=SdRead();    

	for(;count<512;count++)  SdRead();
	 
    //data block sent - now send checksum
    SdRead();
    SdRead();
    //Now read in the DATA RESPONSE token
    SD_CS=1;
    SdRead();
    return 1;
 }
//  printf("Command 0x11 (Read) was not received by the MMC.\n");
  return 0;
}

main.c
略有改动,以确认读出的数据确实是之前写入。

#include <string.h>
#include "HAL.H"

char buf[16];
char buf2[16]={0xAA,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0};

//=======================================================
//延时子程序
void delay()
{
 unsigned int i;
 for(i=0;i<0x8000;i++);
}
//=======================================================
//主程序
char code SST516[3] _at_ 0x003b;
main()
{
unsigned char rsp;
  CLK_DIV=0x03;

  	P0M0=0xff;//		   00000000	  11111111	高阻 下同
	P0M1=0xff;//   
    
	P1M0=0xff;//           11111111  11111111 
	P1M1=0xff;//
	
	P2M0=0xff;//	11111111   111111111
	P2M1=0xff;//常规       
    
	P3M0=0xff; 
	P3M1=0xff;//TXD推挽RXD常规	 11111111   11111111
	
	P4M0=0xff; 
	P4M1=0xff;//11111111   11111111
	
	P5M0=0xff; 
	P5M1=0xff;// 00000000   00000010

  	 P1M0=0xef;//           11111111  11110001 
   	P1M1=0xe1;//			P11 推挽 P12推挽 P13推挽 P14常规

 /*
sbit SD_CS	=P1^1;		//SD/MMC接口定义  qinyg@163.net
sbit SD_DI	=P1^2;
sbit SD_CLK	=P1^3;
sbit SD_DO	=P1^4;
  */



  delay();									//上电延时
  delay();
  delay();
  delay();
   delay();									//上电延时
  delay();
  delay();
  delay();
  SdInit();
   

  while(1) 
  {
   	rsp=SdInit();	
   //P0=rsp;
  if(rsp==1)							//初始化SD卡
    {
	 
     SdReadBlock(buf2,1024,16);				//从SD卡地址为1024的地方读16字节数据到BUFFER,  最多一次只能读512字节
	 //buf2[0]+=2;
	P0 = buf2[0];							//只用第一字节, 送到P0口
	 buf[0]++;								//自加1
	 delay();

	//rewrapBlock();

    //delay();								//延时

     SdWriteBlock(buf,1024,sizeof(buf));
	     //写回SD卡	 
    }
	
   delay();	
   
   								//延时
  }	

}

测试成功,得出判断是所有的卡都支持2.0,其中1G卡很可能是SD SC卡,2G卡类型还不确定,4G及以上都是SD HC卡。
很可惜,还有一张class6的4G卡虽然初始化返回正确但无法读写数据(成功的那张是class4)。尝试了不同的读写速度也无济于事。留待日后琢磨。
不像51必须用IO口模拟时序,STC15自带SPI机制。所以接下去打算利用芯片的SPI功能改写读写逻辑,以及学习利用znFTP或CH375/376实现文件访问。

2014-09-27 17:15:23 sparkstrike 阅读数 4684
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3411 人正在学习 去看看 朱有鹏

单片机:STC12C5A60S2 晶振:24MHZ

51单片机读sd卡资料:http://download.csdn.net/detail/sparkstrike/7982195

sd卡引脚



一.IO接口

sbit CLK = P3^4;//同步时钟
sbit DI = P3^5;//Cmd/DataIn
sbit DO = P3^6;//DataOut
sbit CS = P3^7;//片选



二.模拟SPI

注:spi相关见http://blog.csdn.net/sparkstrike/article/details/39609235

//***********模拟spi写函数
void SPI_W(unsigned char Data){
	unsigned char i;
	for(i = 0; i<8; i++){
		Data <<= 1;
		CLK = 0;
		DI = CY;
		CLK = 1;
	};
	DI = 1;
}

//***********模拟spi读函数
unsigned char SPI_R(){
	unsigned char Data,i;
	DO = 1;//设置DO接口为输入状态
	for(i = 0; i<8; i++){
		Data <<= 1;
		CLK = 0;
		CLK = 1;
		Data |= DO;
	};
	return Data;
}

三.等待SD卡的回应(在写入一些命令后,sd卡会回应一些东西)

//**************读sd卡回应
unsigned char SD_Response(){
	unsigned char i,Response;
	for(i = 0; i<10; i++){
		Response = SPI_R();
		if(Response == 0x00)
			break;
		if(Response == 0x01)
			break;
	};
	return Response;
}


四.向sd卡写入命令

Cmd为命令,命令有复位命令、读命令、写命令等,4位的Arguement为地址,CRC为校验码

//***************向SD发命令
void SD_Cmd(unsigned char Cmd, unsigned long Argument, unsigned char CRC){
	unsigned char arg[4];
	arg[0] = (unsigned char)Argument;
	arg[1] = (unsigned char)(Argument >> 8);
	arg[2] = (unsigned char)(Argument >> 16);
	arg[3] = (unsigned char)(Argument >> 24);

	SPI_W(Cmd | 0x40);
	SPI_W(arg[3]);
	SPI_W(arg[2]);
	SPI_W(arg[1]);
	SPI_W(arg[0]);
	SPI_W(CRC);
}

五.初始化SD卡

SD卡有两种读写模式:SD模式和SPI模式,默认的读写模式为SD模式,单片机用SPI模式比较方便,要使用SPI模式需要在SD卡上电是对它写入CMD0命令和CMD1命令

/*************SD卡初始化,设置SPI模式
unsigned char SD_Init(){
	unsigned int delay = 0;
	unsigned char i;
	unsigned char Response = 0xff;
	
	CS = 1;
	for(i = 0; i<10; i++){
		SPI_W(0xff);//上电后给74个以上的时间脉冲
	};

	CS = 0;
	SD_Cmd(0x00, 0, 0x95);//命令CMD0,复位SD卡

	//等待复位成功
	i = 0;
	while(SD_Response() != 0x01){//等待SD卡回应信号
		i++;
		if(i > 100){
			return 0;//失败返回0
		};
	};

	CS = 1;
	SPI_W(0xff);//关片选后写8个空脉冲,SD卡复位完毕

	//设置SPI
	i = 0;
	CS = 0;
	while(Response != 0x00){//循环等待成功回应,若成功,回应信号为0x00
		SD_Cmd(0x01, 0, 0xff);//CMD1,将SD卡设置为SPI模式,无需CRC校验,填入0xff
		Response = SD_Response();
		if(i > 100){
			return 0;//尝试100次,失败返回0
		};
	};
	CS = 1;

	SPI_W(0xff);//给8个空脉冲
	return 1;
}


六.SD卡读写数据

因为sd卡的读写都是以扇区为单位的,所以这里定义一个全局变量,512表示一个扇区

unsigned int const len = 512;//扇区大小


1.写入数据:

adress为开始写的地址,一定要为512的整数倍,block为一个512字节的数组

//***************SD卡写入数据块
unsigned char SD_Block_W(unsigned char* block, unsigned long address){
	unsigned int i;
	unsigned char Response_Write;
	CS =0;
	SD_Cmd(0x18, address, 0xff);//CMD18,块写入命令
	while(SD_Response() != 0x00);//循环等待命令回应0x00
	for(i = 0; i<10; i++){
		SPI_W(0xff);//写入一定量空脉冲
	};

	SPI_W(0xfe);//0xfe为块头部,后面跟512b字节,+2bCRC(0xff,0xff)

	for(i=0; i<len; i++){
		SPI_W(block[i]);//写入512b字节
	};

	SPI_W(0xff);
	SPI_W(0xff);

	Response_Write = SPI_R()&0x0f;//写入CRC码后SD卡会回应一个xxx0,1001
	while(SPI_R() == 0);//等待SD卡回应

	CS = 1;
	SPI_W(0xff);//写入8个空脉冲

	if(Response_Write == 0x05){
		return 1;
	}else{
		return 0;
	};
}

2.读数据:

adress为开始读的地址,一定要为512的整数倍,block为一个512字节的数组

//****************从sd卡读数据块
void SD_Block_R(unsigned char* block, unsigned long address){
	unsigned int i;

	CS = 0;
	SD_Cmd(0x11, address, 0xff);//CMD11,数据块读写命令,

	while(SD_Response()!=0x00);//循环等待命令回应0x00

	while(SPI_R() != 0xfe); //0xfe为块读出的头, 后面紧跟512字节的数据块+2字节的CRC

	for(i=0; i<len ; i++){
		block[i] = SPI_R();//读数据
	};

	SPI_R();
	SPI_R();//两个字节的CRC。舍弃

	CS =1;
	SPI_R();//8个空脉冲
}

附:测试程序(程序从SD卡512000处写入512字节的数据,并读出)

/*********************************************************************************************/


#include <STC12C5A60S2.H> //单片机头文件

sbit CLK = P3^4;//同步时钟
sbit DI = P3^5;//Cmd/DataIn
sbit DO = P3^6;//DataOut
sbit CS = P3^7;//片选

unsigned int const len = 512;//扇区大小

void DELAY_MS (unsigned int a){
	unsigned int i;
	while( --a != 0){
		for(i = 0; i < 600; i++);
	}
}



//***********模拟spi写函数
void SPI_W(unsigned char Data){
	unsigned char i;
	for(i = 0; i<8; i++){
		Data <<= 1;
		CLK = 0;
		DI = CY;
		CLK = 1;
	};
	DI = 1;
}

//***********模拟spi读函数
unsigned char SPI_R(){
	unsigned char Data,i;
	DO = 1;//设置DO接口为输入状态
	for(i = 0; i<8; i++){
		Data <<= 1;
		CLK = 0;
		CLK = 1;
		Data |= DO;
	};
	return Data;
}


//**************读sd卡回应
unsigned char SD_Response(){
	unsigned char i,Response;
	for(i = 0; i<10; i++){
		Response = SPI_R();
		if(Response == 0x00)
			break;
		if(Response == 0x01)
			break;
	};
	return Response;
}


//***************向SD发命令
void SD_Cmd(unsigned char Cmd, unsigned long Argument, unsigned char CRC){
	unsigned char arg[4];
	arg[0] = (unsigned char)Argument;
	arg[1] = (unsigned char)(Argument >> 8);
	arg[2] = (unsigned char)(Argument >> 16);
	arg[3] = (unsigned char)(Argument >> 24);

	SPI_W(Cmd | 0x40);
	SPI_W(arg[3]);
	SPI_W(arg[2]);
	SPI_W(arg[1]);
	SPI_W(arg[0]);
	SPI_W(CRC);
}



//*************SD卡初始化
unsigned char SD_Init(){
	unsigned int delay = 0;
	unsigned char i;
	unsigned char Response = 0xff;
	
	CS = 1;
	for(i = 0; i<10; i++){
		SPI_W(0xff);//上电后给74个以上的时间脉冲
	};

	CS = 0;
	SD_Cmd(0x00, 0, 0x95);//命令CMD0,复位SD卡

	//等待复位成功
	i = 0;
	while(SD_Response() != 0x01){//等待SD卡回应信号
		i++;
		if(i > 100){
			return 0;//失败返回0
		};
	};

	CS = 1;
	SPI_W(0xff);//关片选后写8个空脉冲,SD卡复位完毕

	//设置SPI
	i = 0;
	CS = 0;
	while(Response != 0x00){//循环等待成功回应,若成功,回应信号为0x00
		SD_Cmd(0x01, 0, 0xff);//CMD1,将SD卡设置为SPI模式,无需CRC校验,填入0xff
		Response = SD_Response();
		if(i > 100){
			return 0;//尝试100次,失败返回0
		};
	};
	CS = 1;

	SPI_W(0xff);//给8个空脉冲
	return 1;
}


//***************SD卡写入数据块
unsigned char SD_Block_W(unsigned char* block, unsigned long address){
	unsigned int i;
	unsigned char Response_Write;
	CS =0;
	SD_Cmd(0x18, address, 0xff);//CMD18,块写入命令
	while(SD_Response() != 0x00);//循环等待命令回应0x00
	for(i = 0; i<10; i++){
		SPI_W(0xff);//写入一定量空脉冲
	};

	SPI_W(0xfe);//0xfe为块头部,后面跟512b字节,+2bCRC(0xff,0xff)

	for(i=0; i<len; i++){
		SPI_W(block[i]);//写入512b字节
	};

	SPI_W(0xff);
	SPI_W(0xff);

	Response_Write = SPI_R()&0x0f;//写入CRC码后SD卡会回应一个xxx0,1001
	while(SPI_R() == 0);//等待SD卡回应

	CS = 1;
	SPI_W(0xff);//写入8个空脉冲

	if(Response_Write == 0x05){
		return 1;
	}else{
		return 0;
	};
}

//****************从sd卡读数据块
void SD_Block_R(unsigned char* block, unsigned long address){
	unsigned int i;

	CS = 0;
	SD_Cmd(0x11, address, 0xff);//CMD11,数据块读写命令,

	while(SD_Response()!=0x00);//循环等待命令回应0x00

	while(SPI_R() != 0xfe); //0xfe为块读出的头, 后面紧跟512字节的数据块+2字节的CRC

	for(i=0; i<len ; i++){
		block[i] = SPI_R();//读数据
	};

	SPI_R();
	SPI_R();//两个字节的CRC。舍弃

	CS =1;
	SPI_R();//8个空脉冲
}



void main (void){
	unsigned char xdata block[len];
	int i;
	//初始化SD卡
	SD_Init();
	for(i=0;i<512;i++){
		block[i]=0xaa;
	};
	//从512000处写sd卡
	SD_Block_W(block, len*1000);
	//从512000处读sd卡
	SD_Block_R(block, len*1000);
	
}





2012-11-08 11:44:13 lynnlycs 阅读数 811
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3411 人正在学习 去看看 朱有鹏

1. 单片机spi驱动SD卡【SD卡相关资料】

   SD卡在现在的日常生活与工作中使用非常广泛,时下已经成为最为通用的数据存储卡。在诸如MP3、数码相机等设备上也都采用SD卡作为其存储设备。SD卡之所以得到如此广泛的使用,是因为它价格低廉、存储容量大、使用方便、通用性与安全性强等优点。既然它有着这么多优点,那么如果将它加入到单片机应用开发系统中来,将使系统变得更加出色。这就要求对SD卡的硬件与读写时序进行研究。对于SD卡的硬件结构,在官方的文档上有很详细的介绍,如SD卡内的存储器结构、存储单元组织方式等内容。要实现对它的读写,最核心的是它的时序,笔者在经过了实际的测试后,使用51单片机成功实现了对SD卡的扇区读写,并对其读写速度进行了评估。下面先来讲解SD卡的读写时序。

1       SD卡的引脚定义:

          SD卡引脚功能详述:

引脚

编号

SD模式

        SPI模式

名称

类型

描述

名称

类型

描述

1

CD/DAT3

IOPP

卡检测/

数据线3

#CS

I

片选

2

CMD

PP

命令/

回应

DI

I

数据输入

3

VSS1

S

电源地

VSS

S

电源地

4

VDD

S

电源

VDD

S

电源

5

CLK

I

时钟

SCLK

I

时钟

6

VSS2

S

电源地

VSS2

S

电源地

7

DAT0

IOPP

数据线0

DO

OPP

数据输出

8

DAT1

IOPP

数据线1

RSV

 

 

9

DAT2

IOPP

数据线2

RSV

 

 

       注:S:电源供给  I:输入 O:采用推拉驱动的输出          PP:采用推拉驱动的输入输出

SD卡支持两种总线方式:SD方式与SPI方式。其中SD方式采用6线制,使用CLKCMDDAT0~DAT3进行数据通信。而SPI方式采用4线制,使用CSCLKDataInDataOut进行数据通信。SD方式时的数据传输速度与SPI方式要快,采用单片机对SD卡进行读写时一般都采用SPI模式。采用不同的初始化方式可以使SD卡工作于SD方式或SPI方式。这里只对其SPI方式进行介绍。

2       SPI方式驱动SD卡的方法

     SD卡的SPI通信接口使其可以通过SPI通道进行数据读写。从应用的角度来看,采用SPI接口的好处在于,很多单片机内部自带SPI控制器,不光给开发上带来方便,同时也见降低了开发成本。然而,它也有不好的地方,如失去了SD卡的性能优势,要解决这一问题,就要用SD方式,因为它提供更大的总线数据带宽。SPI接口的选用是在上电初始时向其写入第一个命令时进行的。以下介绍SD卡的驱动方法,只实现简单的扇区读写。

1  命令与数据传输

1.       命令传输

SD卡自身有完备的命令系统,以实现各项操作。命令格式如下:

      命令的传输过程采用发送应答机制,过程如下:

每一个命令都有自己命令应答格式。在SPI模式中定义了三种应答格式,如下表所示:

字节

含义

 

 

 

1

7

开始位,始终为0

6

参数错误

5

地址错误

4

擦除序列错误

3

CRC错误

2

非法命令

1

擦除复位

0

闲置状态

字节

含义

 

 

 

1

7

开始位,始终为0

6

参数错误

5

地址错误

4

擦除序列错误

3

CRC错误

2

非法命令

1

擦除复位

0

闲置状态

 

 

 

2

7

溢出,CSD覆盖

6

擦除参数

5

写保护非法

4

ECC失败

3

卡控制器错误

2

未知错误

1

写保护擦除跳过,锁/解锁失败

0

锁卡

 

字节

含义

 

 

 

1

7

开始位,始终为0

6

参数错误

5

地址错误

4

擦除序列错误

3

CRC错误

2

非法命令

1

擦除复位

0

闲置状态

25

全部

操作条件寄存器,高位在前

          写命令的例程:

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

  向SD卡中写入命令,并返回回应的第二个字节

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

unsigned char Write_Command_SD(unsigned char *CMD)

{

   unsigned char tmp;

   unsigned char retry=0;

   unsigned char i;

 

   //禁止SD卡片选

   SPI_CS=1;

   //发送8个时钟信号

   Write_Byte_SD(0xFF);

   //使能SD卡片选

   SPI_CS=0;

 

   //SD卡发送6字节命令

   for (i=0;i<0x06;i++)

   {

      Write_Byte_SD(*CMD++);

   }

  

   //获得16位的回应

   Read_Byte_SD(); //read the first byte,ignore it.

   do

   {  //读取后8

      tmp = Read_Byte_SD();

      retry++;

   }

   while((tmp==0xff)&&(retry<100));

   return(tmp);

}

 

2  初始化

SD卡的初始化是非常重要的,只有进行了正确的初始化,才能进行后面的各项操作。在初始化过程中,SPI的时钟不能太快,否则会造初始化失败。在初始化成功后,应尽量提高SPI的速率。在刚开始要先发送至少74个时钟信号,这是必须的。在很多读者的实验中,很多是因为疏忽了这一点,而使初始化不成功。随后就是写入两个命令CMD0CMD1,使SD卡进入SPI模式

           初始化时序图:

           初始化例程:

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

    初始化SD卡到SPI模式

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

unsigned char SD_Init()

   unsigned char retry,temp;

   unsigned char i;

   unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};

   SD_Port_Init(); //初始化驱动端口

  

   Init_Flag=1; //将初始化标志置1

 

   for (i=0;i<0x0f;i++)

   {

      Write_Byte_SD(0xff); //发送至少74个时钟信号

   }

   //SD卡发送CMD0

   retry=0;

   do

   { //为了能够成功写入CMD0,在这里写200

     temp=Write_Command_SD(CMD);

     retry++;

     if(retry==200)

     { //超过200

       return(INIT_CMD0_ERROR);//CMD0 Error!

     }

   }

   while(temp!=1);  //回应01h,停止写入

  

   //发送CMD1SD

   CMD[0] = 0x41; //CMD1

   CMD[5] = 0xFF;

   retry=0;

   do

   { //为了能成功写入CMD1,100

     temp=Write_Command_SD(CMD);

     retry++;

     if(retry==100)

     { //超过100

       return(INIT_CMD1_ERROR);//CMD1 Error!

     }

   }

   while(temp!=0);//回应00h停止写入

  

   Init_Flag=0; //初始化完毕,初始化标志清零

  

   SPI_CS=1;  //片选无效

   return(0); //初始化成功

}

3  读取CID

CID寄存器存储了SD卡的标识码。每一个卡都有唯一的标识码。

CID寄存器长度为128位。它的寄存器结构如下:

名称

数据宽度

CID划分

生产标识号

MID

8

[127:120]

OEM/应用标识

OID

16

[119:104]

产品名称

PNM

40

[103:64]

产品版本

PRV

8

[63:56]

产品序列号

PSN

32

[55:24]

保留

4

[23:20]

生产日期

MDT

12

[19:8]

CRC7校验合

CRC

7

[7:1]

未使用,始终为1

1

[0:0]

它的读取时序如下:

        与此时序相对应的程序如下:

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

    读取SD卡的CID寄存器   16字节   成功返回0

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

unsigned char Read_CID_SD(unsigned char *Buffer)

{

   //读取CID寄存器的命令

   unsigned char CMD[] = {0x4A,0x00,0x00,0x00,0x00,0xFF};

   unsigned char temp;

   temp=SD_Read_Block(CMD,Buffer,16); //read 16 bytes

   return(temp);

}

       4)读取CSD

              CSDCard-Specific Data)寄存器提供了读写SD卡的一些信息。其中的一些单元可以由用户重新编程。具体的CSD结构如下:

名称

数据宽度

单元类型

CSD划分

CSD结构

CSD_STRUCTURE

2

R

[127:126]

保留

-

6

R

[125:120]

数据读取时间1

TAAC

8

R

[119:112]

数据在CLK周期内读取时间2(NSAC*100)

NSAC

8

R

[111:104]

最大数据传输率

TRAN_SPEED

8

R

[103:96]

卡命令集合

CCC

12

R

[95:84]

最大读取数据块长

READ_BL_LEN

4

R

[83:80]

允许读的部分块

READ_BL_PARTIAL

1

R

[79:79]

非线写块

WRITE_BLK_MISALIGN

1

R

[78:78]

非线读块

READ_BLK_MISALIGN

1

R

[77:77]

DSR条件

DSR_IMP

1

R

[76:76]

保留

-

2

R

[75:74]

设备容量

C_SIZE

12

R

[73:62]

最大读取电流@VDD min

VDD_R_CURR_MIN

3

R

[61:59]

最大读取电流@VDDmax

VDD_R_CURR_MAX

3

R

[58:56]

最大写电流@VDD min

VDD_W_CURR_MIN

3

R

[55:53]

最大写电流@VDD max

VDD_W_CURR_MAX

3

R

[52:50]

设备容量乘子

C_SIZE_MULT

3

R

[49:47]

擦除单块使能

ERASE_BLK_EN

1

R

[46:46]

擦除扇区大小

SECTOR_SIZE

7

R

[45:39]

写保护群大小

WP_GRP_SIZE

7

R

[38:32]

写保护群使能

WP_GRP_ENABLE

1

R

[31:31]

保留

-

2

R

[30:29]

写速度因子

R2W_FACTOR

3

R

[28:26]

最大写数据块长度

WRITE_BL_LEN

4

R

[25:22]

允许写的部分部

WRITE_BL_PARTIAL

1

R

[21:21]

保留

-

5

R

[20:16]

文件系统群

FILE_OFRMAT_GRP

1

R/W

[15:15]

拷贝标志

COPY

1

R/W

[14:14]

永久写保护

PERM_WRITE_PROTECT

1

R/W

[13:13]

暂时写保护

TMP_WRITE_PROTECT

1

R/W

[12:12]

文件系统

FIL_FORMAT

2

R/W

[11:10]

保留

-

2

R/W

[9:8]

CRC

CRC

7

R/W

[7:1]

未用,始终为1

-

1

 

[0:0]

           读取CSD 的时序:

           相应的程序例程如下:

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

    读SD卡的CSD寄存器   共16字节    返回0说明读取成功

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

unsigned char Read_CSD_SD(unsigned char *Buffer)

{  

   //读取CSD寄存器的命令

   unsigned char CMD[] = {0x49,0x00,0x00,0x00,0x00,0xFF};

   unsigned char temp;

   temp=SD_Read_Block(CMD,Buffer,16); //read 16 bytes

   return(temp);

}


4  读取SD卡信息

综合上面对CIDCSD寄存器的读取,可以知道很多关于SD卡的信息,以下程序可以获取这些信息。如下:

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

//返回

// SD卡的容量,单位为M

// sector count and multiplier MB are in

u08 == C_SIZE / (2^(9-C_SIZE_MULT))

// SD卡的名称

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

void SD_get_volume_info()

{  

    unsigned char i;

    unsigned char c_temp[5];

    VOLUME_INFO_TYPE SD_volume_Info,*vinf;

    vinf=&SD_volume_Info; //Init the pointoer;

/读取CSD寄存器

    Read_CSD_SD(sectorBuffer.dat);

//获取总扇区数

vinf->sector_count = sectorBuffer.dat[6] & 0x03;

vinf->sector_count <<= 8;

vinf->sector_count += sectorBuffer.dat[7];

vinf->sector_count <<= 2;

vinf->sector_count += (sectorBuffer.dat[8] & 0xc0) >> 6;

// 获取multiplier

vinf->sector_multiply = sectorBuffer.dat[9] & 0x03;

vinf->sector_multiply <<= 1;

vinf->sector_multiply += (sectorBuffer.dat[10] & 0x80) >> 7;

//获取SD卡的容量

vinf->size_MB = vinf->sector_count >> (9-vinf->sector_multiply);

// get the name of the card

Read_CID_SD(sectorBuffer.dat);

vinf->name[0] = sectorBuffer.dat[3];

vinf->name[1] = sectorBuffer.dat[4];

vinf->name[2] = sectorBuffer.dat[5];

vinf->name[3] = sectorBuffer.dat[6];

vinf->name[4] = sectorBuffer.dat[7];

vinf->name[5] = 0x00; //end flag  

}

         以上程序将信息装载到一个结构体中,这个结构体的定义如下:

typedef struct SD_VOLUME_INFO

{ //SD/SD Card info

  unsigned int  size_MB;

  unsigned char sector_multiply;

  unsigned int  sector_count;

  unsigned char name[6];

} VOLUME_INFO_TYPE;

5  扇区读

扇区读是对SD卡驱动的目的之一。SD卡的每一个扇区中有512个字节,一次扇区读操作将把某一个扇区内的512个字节全部读出。过程很简单,先写入命令,在得到相应的回应后,开始数据读取。

扇区读的时序:

 

             扇区读的程序例程:

unsigned char SD_Read_Sector(unsigned long sector,unsigned char *buffer)

   unsigned char retry;

   //命令16

   unsigned char CMD[] = {0x51,0x00,0x00,0x00,0x00,0xFF};

   unsigned char temp;

  

   //地址变换   由逻辑块地址转为字节地址

   sector = sector << 9; //sector = sector * 512

 

   CMD[1] = ((sector & 0xFF000000) >>24 );

   CMD[2] = ((sector & 0x00FF0000) >>16 );

   CMD[3] = ((sector & 0x0000FF00) >>8 );

 

   //将命令16写入SD

   retry=0;

   do

   {  //为了保证写入命令  一共写100

      temp=Write_Command_MMC(CMD);

      retry++;

      if(retry==100)

      {

        return(READ_BLOCK_ERROR); //block write Error!

      }

   }

   while(temp!=0);

          

   //Read Start Byte form MMC/SD-Card (FEh/Start Byte)

   //Now data is ready,you can read it out.

   while (Read_Byte_MMC() != 0xfe);

   readPos=0;

  SD_get_data(512,buffer) ;  //512字节被读出到buffer

 return 0;

}

其中SD_get_data函数如下:

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

    获取数据到buffer

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

void SD_get_data(unsigned int Bytes,unsigned char *buffer)

{

   unsigned int j;

   for (j=0;j<Bytes;j++)

      *buffer++ = Read_Byte_SD();

}

6  扇区写

扇区写是SD卡驱动的另一目的。每次扇区写操作将向SD卡的某个扇区中写入512个字节。过程与扇区读相似,只是数据的方向相反与写入命令不同而已。

    扇区写的时序:

 

 

 

扇区写的程序例程:

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

    写512个字节到SD卡的某一个扇区中去   返回0说明写入成功

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

unsigned char SD_write_sector(unsigned long addr,unsigned char *Buffer)

   unsigned char tmp,retry;

   unsigned int i;

   //, 命令24

   unsigned char CMD[] = {0x58,0x00,0x00,0x00,0x00,0xFF};

   addr = addr << 9; //addr = addr * 512

 

   CMD[1] = ((addr & 0xFF000000) >>24 );

   CMD[2] = ((addr & 0x00FF0000) >>16 );

   CMD[3] = ((addr & 0x0000FF00) >>8 );

 

   //写命令24SD卡中去

   retry=0;

   do

   {  //为了可靠写入,写100

      tmp=Write_Command_SD(CMD);

      retry++;

      if(retry==100)

      {

        return(tmp); //send commamd Error!

      }

   }

   while(tmp!=0);

  

 

   //在写之前先产生100个时钟信号

   for (i=0;i<100;i++)

   {

      Read_Byte_SD();

   }

 

   //写入开始字节

   Write_Byte_MMC(0xFE);  

 

   //现在可以写入512个字节

   for (i=0;i<512;i++)

   {

      Write_Byte_MMC(*Buffer++);

   }

 

   //CRC-Byte

   Write_Byte_MMC(0xFF); //Dummy CRC

   Write_Byte_MMC(0xFF); //CRC Code

  

   

   tmp=Read_Byte_MMC();   // read response

   if((tmp & 0x1F)!=0x05) // 写入的512个字节是未被接受

   {

     SPI_CS=1;

     return(WRITE_BLOCK_ERROR); //Error!

   }

   //等到SD卡不忙为止

//因为数据被接受后,SD卡在向储存阵列中编程数据

   while (Read_Byte_MMC()!=0xff){};

 

   //禁止SD

   SPI_CS=1;

   return(0);//写入成功

}

    此上内容在笔者的实验中都已调试通过。单片机采用STC89LE单片机(SD卡的初始化电压为2.0V~3.6V,操作电压为3.1V~3.5V,因此不能用5V单片机,或进行分压处理),工作于22.1184M的时钟下,由于所采用的单片机中没硬件SPI,采用软件模拟SPI,因此读写速率都较慢。如果要半SD卡应用于音频、视频等要求高速场合,则需要选用有硬件SPI的控制器,或使用SD模式,当然这就需要各位读者对SD模式加以研究,有了SPI模式的基础,SD模式应该不是什么难事。

摘自:

http://blog.csdn.net/topchao/article/details/4218630



2018-08-19 01:03:17 HeGuang68207 阅读数 1846
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3411 人正在学习 去看看 朱有鹏

SD卡(Secure Digital Memory Card):

又叫安全数码卡,是一种基于半导体闪存工艺的存储卡,被广泛应用于便携式电子设备。
SD卡已成为目前消费数码设备中应用最广泛的一种存储卡,具有大容量、高性能、安全等多种特点。

今天小楊就来试验一下通过单片机读写SD卡。
实验材料
1、普通PC一台;
2、SD/TF卡至少一张(推荐2GB以内);
3、禾灮Young_SD读卡模块一块,配原理图;
4、普通读卡器一个;
5、禾灮Young_AVR智能机器人控制板一块(兼容Arduino代码)(附Atmel官方MCU说明书一份)。
5、杜邦线若干。

读卡模块原理图

当然了,发烟测试第一步,通过最简单的代码实现功能:

Arduino代码:

/*
***此例子展示记录串口输入数据到SD卡
* SD卡与控制板使用SPI总线连接
** MOSI - pin 11
** MISO - pin 12
** CLK  - pin 13
** CS   - pin 4
*/

#include <SD.h>

const int chipSelect = 4;  //设定CS引脚为D4,这里也沿用官方默认设置

void setup(){
    Serial.begin(9600);  //设置串口通信波特率为9600
    Serial.print("Initializing SD card...");  //串口输出数据Initializing SD card...
    if (!SD.begin(chipSelect)) {  //如果从CS口与SD卡通信失败,串口输出信息Card failed, or not present
        Serial.println("Card failed, or not present");
        return;
    }
    Serial.println("card initialized.");  //与SD卡通信成功,串口输出信息card initialized.
}

void loop(){
    String dataString = Serial..readStringUntil("\n");

    // 打开文件,注意在同一时间只能有一个文件被打开
    // 如果你要打开另一个文件,就需要先关闭前一个
    File dataFile = SD.open("datalog.txt", FILE_WRITE);  

    // 打开datalog.txt文件,读写状态,位置在文件末尾。
    if (dataFile) {
        dataFile.println(dataString);
        dataFile.close();
        // 数组dataString输出到串口
        // Serial.println(dataString);
    }else {  // 如果无法打开文件,串口输出错误信息error opening datalog.txt
        Serial.println("error opening datalog.txt");
    } 
}

关闭开发板电源后把SD卡取出并接入电脑。可以看到SD卡中有一个datalog.txt文件,打开后有可以看到,此文件中的信息就是记录下的串口输入数据。

/*
***这个例子展示从SD卡中读取一个文件,并且把数据通过串口发送
*/

#include <SD.h>

const int chipSelect = 4;  //设定CS接口

void setup(){
  Serial.begin(9600);  //设置串口通信波特率为9600
  Serial.print("Initializing SD card...");  //串口输出数据Initializing SD card...

  if (!SD.begin(chipSelect)) {  //如果从CS口与SD卡通信失败,串口输出信息Card failed, or not present
    Serial.println("Card failed, or not present");
    // don't do anything more:
    return;
  }
  Serial.println("card initialized.");  //与SD卡通信成功,串口输出信息card initialized.

  File dataFile = SD.open("datalog.txt");  //打开datalog.txt文件

  if (dataFile) {
    while (dataFile.available()) {  //检查是否dataFile是否有数据
      Serial.write(dataFile.read());  //如果有数据则把数据发送到串口
    }
    dataFile.close();  //关闭dataFile
  }else {
    Serial.println("error opening datalog.txt");  //如果文件无法打开串口发送信息error opening datalog.txt
  } 
}

void loop(){
}

可以看到,datalog.txt文件中的数据都通过串口发送回了电脑。

/*
***此例子展示如何在SD卡中创建于删除文件
*/
#include <SD.h>
File myFile;
void setup(){
  Serial.begin(9600);  //设置串口通信波特率为9600
  Serial.print("Initializing SD card...");  //串口输出数据Initializing SD card...

  if (!SD.begin(4)) {  //如果从CS口与SD卡通信失败,串口输出信息initialization failed!
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");  //CS口与SD卡通信成功,串口输出信息initialization done.

  if (SD.exists("example.txt")) {  //检查example.txt文件是否存在
    Serial.println("example.txt exists.");  //如果存在输出信息example.txt exists.至串口
  }else {
    Serial.println("example.txt doesn't exist.");  //不存在输出信息example.txt doesn't exist.至串口
  }
  Serial.println("Creating example.txt...");
  myFile = SD.open("example.txt", FILE_WRITE);  //打开example.txt,如果没有自动创建,写入状态
  myFile.close();  //关闭文件
  if (SD.exists("example.txt")) {
    Serial.println("example.txt exists.");
  }else {
    Serial.println("example.txt doesn't exist.");  
  }
  Serial.println("Removing example.txt...");
  SD.remove("example.txt");  //删除文件example.txt
  if (SD.exists("example.txt")){ 
    Serial.println("example.txt exists.");
  }else {
    Serial.println("example.txt doesn't exist.");  
  }
}

void loop(){
}
串口监视器显示文件创建于删除的过程。
#include <SD.h>

File myFile;

void setup(){
  Serial.begin(9600);
  Serial.print("Initializing SD card...");

  if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");
  myFile = SD.open("test.txt", FILE_WRITE);

  if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("testing 1, 2, 3.");
    myFile.close();
    Serial.println("done.");
  } else {
    Serial.println("error opening test.txt");
  }

  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("test.txt:");    
    while (myFile.available()) {
            Serial.write(myFile.read());
    }
    myFile.close();
  } else {
    Serial.println("error opening test.txt");
  }
}

void loop(){
}

感谢一直关注着禾灮成长进步的朋友们。你们的信任、支持和鼓励,鞭策着我们一路走到了今天。

感谢所有的合作伙伴,我们相互促进,共同见证了彼此的成长。

感谢所有曾经在禾灮彼此倚靠、相互鼓励、携手同心、砥砺同行的兄弟姐妹。这里承载了我们的青春与热血。

            禾灮,感谢有你。

未来,我们将一如既往,砥砺前行。

                                    禾灮·小楊
                                   2018.08.16
2019-10-13 21:22:44 qq_42580947 阅读数 419
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3411 人正在学习 去看看 朱有鹏

1. MCU与MPU的区别

首先我们先聊一下MCU与MPU之间的区别然后在去关心两者的驱动的不同。MCU(微控制器)就是我们经常所见到的单片机,包括51,32,430等。MPU(微处理器)就是比较高端的ARM,比如ARM9, ARM11, ARM Cortex A系列等等。MCU与MPU的最重要的区别是:MPU和MCU的区别是前者多了两个部件:Cache(缓存)和MMU(内存管理单元)。加入缓存是因为处理器速度比内存速度大得多,所以引入了缓存。
在ARM领域, Linux编程的时候,就会看到虚拟地址。单片机中所用的地址都是物理地址,但是ARM里面启动MMU之后,我们看到的地址都是虚拟地址,经过MMU以后才是具体的物理地址。

2. 单片机驱动与Linux驱动的区别

① 单片机驱动很简单,直接操作物理地址的寄存器就可以了,代码量少;Linux驱动因为引入了虚拟地址与MMU,所以需要操作虚拟地址,经过MMU转化为实际物理地址才可以对寄存器进行操作,而且Linux代码量非常大(现对于单片机来讲);
② Linux驱动中,设备和驱动是分离的,而且驱动中也是分层的;
③ Linux内核中提供了大量的驱动接口,这对Linux驱动的开发带来的巨大的便利,这是单片机驱动中所没有的。

SD卡驱动

阅读数 61

AVR单片机驱动LCD1602

阅读数 1038

AVR单片机驱动LCD1602

博文 来自: IoT_Peng
没有更多推荐了,返回首页