EEPW论坛

图片调小之后完全看不清楚了。
详细可查看原图
明天准备FATFS  再赚10分

你是说3.5库里边带的那个spi驱动sd卡吧？spi和sdio是不一样的。我已经给出了sdio驱动sd卡的程序了

FATFS移植以前琢磨过，那是用SPI读写SD卡。所以今天相对快点

FATFS是一个小日本写的文件系统程序。用的比较多。

移植需要提供哦你几个接口程序：SD卡初始化，SD卡读写Block
就这么多，其他fatFS自己搞定。

下载来代码后，需要新建一个文件：diskio.c。这是接口文件
需要写的函数原型已经在diskio.h里边定义了。你只需要根据需要改写就行了，并不一定要全部写出来。
下面是我的diskio.c里边写的几个函数：
/* 初始化驱动器 ，不需要  站自己写SDCard_Init()实现了这个功能*/

DSTATUS disk_initialize (
    BYTE drv                /* Physical drive nmuber (0..) */
)
{
    return 0;
}

/* 获取磁盘状态   不知道干啥的  没写*/

DSTATUS disk_status (
    BYTE drv        /* Physical drive nmuber (0..) */
)
{   
    return 0;
}
/* 读块，单块或多块  这个是核心  必须写完美*/

DRESULT disk_read (
    BYTE drv,        /* Physical drive nmuber (0..) */
    BYTE *buff,        /* Data buffer to store read data */
    DWORD sector,    /* Sector address (LBA) */
    BYTE count        /* Number of sectors to read (1..255) */
)
{
  //memset(buff2, 0, sizeof(buff2));
    if(count==1)
        {
          SD_ReadBlock(sector << 9 ,(u32 *)(&buff[0]),SECTOR_SIZE);
          //memcpy(buff,buff2,SECTOR_SIZE);
    }
    else
        {
          SD_ReadMultiBlocks(sector << 9 ,(u32 *)(&buff[0]),SECTOR_SIZE,count);
          //memcpy(buff,buff2,SECTOR_SIZE * count);
    }

    return RES_OK;
}

//往SD卡写数据  如果你对SD卡的操作是只读的，这个省略
DRESULT disk_write (
    BYTE drv,            /* Physical drive nmuber (0..) */
    const BYTE *buff,    /* Data to be written */
    DWORD sector,        /* Sector address (LBA) */
    BYTE count            /* Number of sectors to write (1..255) */
)
{
  //memset(buff2, 0, sizeof(buff2));
    if(count==1)
        {
          //memcpy(buff2,buff,SECTOR_SIZE);
          SD_WriteBlock(sector << 9 ,(u32 *)(&buff[0]),SECTOR_SIZE);
    }
    else
        {
          //memcpy(buff2,buff,SECTOR_SIZE * count);
          SD_WriteMultiBlocks(sector << 9 ,(u32 *)(&buff[0]),SECTOR_SIZE,count);
    }
       
  return RES_OK;
}

//不知道干啥的函数
DRESULT disk_ioctl (
    BYTE drv,        /* Physical drive nmuber (0..) */
    BYTE ctrl,        /* Control code */
    void *buff        /* Buffer to send/receive control data */
)
{

    return RES_OK;
}

//没搞定RTC，凑合下弄0代替
DWORD get_fattime(void){
    return 0;
}


在主函数中调用：
/*以上为读写SD卡测试程序*/
    /*一下为fatFS测试程序*/
    disk_initialize(0);
    f_mount(0, &fs);
    //列出根目录下文件
    if (f_opendir(&dirs, "") == FR_OK)
    {
        printf("找到根目录\r\n");
        while (f_readdir(&dirs, &finfo) == FR_OK)        //目录下是否有文件
        {
            if(!finfo.fname[0]) break;
            if (finfo.fattrib & AM_ARC)    //文件属性为存档。
            {   
                printf("找到文件：%s\r\n",finfo.fname);
                printf("文件：[%s]的内容如下\r\n",finfo.fname);
                    //打开文件，发串口
                //打开文件  只读方式
                f_open(&fsrc, finfo.fname, FA_OPEN_EXISTING | FA_READ);
                //读取文件内容
                f_read(&fsrc,readBuf,READBUF_SIZE,&br);
           
                //串口显示
                printf("%s\r\n",readBuf);
                //打印的东西太多了  只打印第一个吧
                break;
            }
        }
    }

最后上图：

我已失去七年了。。。。。。

这话说的酸酸的。。。。。。

你看看csd的说明。这个东西我没研究。读出block之后，直接交给fatFS了。一个小日本写的程序

试验FSTFS

先定义两个变量
static FATFS fs;  //文件系统
static FIL fsrc;  //文件

    FRESULT res;  //操作返回结果
    FILINFO finfo; //文件
    DIR dirs;      //目录

挂接驱动器
    disk_initialize(0);
    f_mount(0, &fs);
打开文件
    f_open(&fsrc, finfo.fname, FA_OPEN_EXISTING | FA_READ | FA_WRITE);   //打开以存在文件，可读写
    f_lseek(&fsrc, f_size(&fsrc));      //将文件指针移到文件末尾   
    f_puts("abcdefg",&fsrc);
    f_puts("gfedcba",&fsrc);        //写入文件后，自动移动文件指针到写入位置，不需要在移动指针
    f_sync(&fsrc);    //将缓存中的文件内容写入磁盘
    f_lseek(&fsrc, 0);  //移动文件指针以便读取文件
    f_read(&fsrc,readBuf,READBUF_SIZE-1,&br);   //自动移动文件指针
    while(!f_eof(&fsrc))  //检查是否读到了文件末尾
    {
        f_read(&fsrc,readBuf,READBUF_SIZE-1,&br);   //读取文件到缓存
        printf("%s",readBuf);    //串口输出
    }

最后试试f_printf().
    f_printf(&fsrc,"\r\n");
    f_printf(&fsrc,"\t%d\r\n",i); 
结果跟printf 差不多

FSMCS RAM读写，跟LCD操作相似。
SRAM初始化之后，直接写数据在一个SRAM范围内的地址就行了，操作相对方便。
LCD相当于在一个固定的SRAM地址读写数据。

根据电路，SRAM使用了FSMC Bank1的SRAM3块。SRAM的基地址是0x68000000，因此定义：
#define Bank1_SRAM3_ADDR    ((uint32_t)0x68000000)

下面是我的SRAM初始化程序和读写函数：
void My_SRAM_Init(void)
{
  FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
  FSMC_NORSRAMTimingInitTypeDef  p;
  GPIO_InitTypeDef GPIO_InitStructure;
 
  //时钟使能
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOG | RCC_APB2Periph_GPIOE |
                         RCC_APB2Periph_GPIOF, ENABLE);
 
/*-- GPIO 设置 ------------------------------------------------------*/
  /*!< 数据线配置 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_8 | GPIO_Pin_9 |
                                GPIO_Pin_10 | GPIO_Pin_14 | GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 |
                                GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 |
                                GPIO_Pin_15;
  GPIO_Init(GPIOE, &GPIO_InitStructure);
 
  /*!< 地址线配置 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 |
                                GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_12 | GPIO_Pin_13 |
                                GPIO_Pin_14 | GPIO_Pin_15;
  GPIO_Init(GPIOF, &GPIO_InitStructure);
 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 |
                                GPIO_Pin_4 | GPIO_Pin_5;
  GPIO_Init(GPIOG, &GPIO_InitStructure);
 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
  
  /*!< NOE 和 NWE 配置 */ 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 |GPIO_Pin_5;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
 
  /*!< NE3 配置 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_Init(GPIOG, &GPIO_InitStructure);
 
  /*!< NBL0, NBL1 配置 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
  GPIO_Init(GPIOE, &GPIO_InitStructure);
 
/*-- FSMC 设置 ------------------------------------------------------*/
  p.FSMC_AddressSetupTime = 0;       //地址建立时间SRAM读写比LCD块，我的LCD这里是2
  p.FSMC_AddressHoldTime = 0;       //地址保持时间
  p.FSMC_DataSetupTime = 3;           //数据建立时间
  p.FSMC_BusTurnAroundDuration = 0;
  p.FSMC_CLKDivision = 0;
  p.FSMC_DataLatency = 0;
  p.FSMC_AccessMode = FSMC_AccessMode_A;

  FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;      //选择Bank
  FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;//FSMC_DataAddressMux_Disable;
  FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
  FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
  FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
  FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
  FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
  FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
  FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
  FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
  FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
  FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
  FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
  FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
  FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;

  FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);

  /*!< 使能该bank   Enable FSMC Bank1_SRAM Bank */
  FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE); 
}

将缓存数据写入SRAM
void My_SRAM_WriteBuffer(uint16_t* pBuffer, uint32_t WriteAddr, uint32_t NumHalfwordToWrite)
{
  for(; NumHalfwordToWrite != 0; NumHalfwordToWrite--) /*!< while there is data to write */
  {
    /*!< Transfer data to the memory */
    *(uint16_t *) (Bank1_SRAM3_ADDR + WriteAddr) = *pBuffer++;
   
    /*!< Increment the address*/ 
    WriteAddr += 2;
  }  
}

读出SRAM中的数据到SRAM
void My_SRAM_ReadBuffer(uint16_t* pBuffer, uint32_t ReadAddr, uint32_t NumHalfwordToRead)
{
  for(; NumHalfwordToRead != 0; NumHalfwordToRead--) /*!< while there is data to read */
  {
    /*!< Read a half-word from the memory */
    *pBuffer++ = *(__IO uint16_t*) (Bank1_SRAM3_ADDR + ReadAddr);

    /*!< Increment the address*/ 
    ReadAddr += 2;
  } 
}

填充缓冲：
void Fill_Buffer(uint16_t *pBuffer, uint16_t BufferLenght, uint32_t Offset)
{
  uint16_t IndexTmp = 0;

  /* Put in global buffer same values */
  for (IndexTmp = 0; IndexTmp < BufferLenght; IndexTmp++ )
  {
    pBuffer[IndexTmp] = IndexTmp + Offset;
  }
}

主函数中调用：
    for(i=0;i<BUFFER_SIZE;i++) //显示RxBuffer内容，以便对比
       {
           printf("%X\t",RdBuffer[i]);   
       }
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE); //前次忘记FSMC开时钟了，所以读不出来
    My_SRAM_Init();    //初始化FSMC SRAM
    Fill_Buffer(WrBuffer, BUFFER_SIZE, 0);  //向写入数据的缓冲中写内容
   
    My_SRAM_WriteBuffer(WrBuffer, WRITE_READ_ADDR, BUFFER_SIZE);   //将缓冲中的内容写入SRAM
    My_SRAM_ReadBuffer(RdBuffer, WRITE_READ_ADDR, BUFFER_SIZE);    //读出

       for(i=0;i<BUFFER_SIZE;i++)       //显示内容
       {
           printf("%X\t",RdBuffer[i]);   
       }

最后  上图：



读SD卡数据到SRAM中，将SRAM当作个缓冲也不错哦。

DAC 看起来挺麻烦的，用起来还是很简单的。
只要设置几个东西就能输出。或许是我使用了软件触发的缘故吧.DMA DAC定时器我都没用到
片子上的DAC可以用来产生几种波形，或者直接输出给定的值。
今天分别测试下DAC输出噪声波形、三角波和DR中的数值。使用软件触发模式
没有示波器，用三用表测。
测量方法是这样的：在每次触发之后设置断点，让程序停在那里。然后三用表测。

DAC初始化代码如下：
//初始化
void My_DAC_Init()
{
    GPIO_InitTypeDef GPIO_InitStructure;
    //时钟使能
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);     
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
    //GPIO设置
   
    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;       //必须是模拟输出模式
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    //DAC初始化
    DAC_InitStructure.DAC_Trigger = DAC_Trigger_Software;                   //软件触发
      //DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_Noise;       //产生噪音波形。对于DAC_CR的Bit[6:7]
    //DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_Triangle;        //三角波
    DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;            //不使用波形输出功能(输出DAC_DR中定义的值)
      DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_LFSRUnmask_Bits8_0;
      DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
      DAC_Init(DAC_Channel_1, &DAC_InitStructure);
    DAC_Cmd(DAC_Channel_1, ENABLE);

    DAC_SetChannel1Data(DAC_Align_12b_L, 0x0000);
       
}

产生波形输出时，在主函数中调用：
    My_DAC_Init();
    while(1)
    {
        DAC_SoftwareTriggerCmd(DAC_Channel_1, ENABLE);
        //delay_ms(1000);
    }
产生指定值输出时候的调用：
    while(1)
    {
        for(i = 0;i<100;i++)
        {
            DAC_SetChannel1Data(DAC_Align_12b_L, i*300);
            DAC_SoftwareTriggerCmd(DAC_Channel_1, ENABLE);
            printf("当前DAC输出值为：%d\t\r\n",DAC_GetDataOutputValue(DAC_Channel_1)); //串口打印当前DAC输出的值
        }
       
        //delay_ms(1000);
    }

两只手，一手一个三用表表笔，没第三只手照相了。。。
等回去用示波器补图。
做了个串口输出的图供欣赏：


DAC的几个触发模式，先了解一下。
#define DAC_Trigger_None                   ((uint32_t)0x00000000) /*!< 只要数据准备完成就输出 */
#define DAC_Trigger_T6_TRGO                ((uint32_t)0x00000004) /*!< TIM6 触发 */
#define DAC_Trigger_T8_TRGO                ((uint32_t)0x0000000C) /*!< TIM8 触发*/
#define DAC_Trigger_T3_TRGO                ((uint32_t)0x0000000C) /*!< TIM8 触发 */
#define DAC_Trigger_T7_TRGO                ((uint32_t)0x00000014) /*!< TIM7 触发 */
#define DAC_Trigger_T5_TRGO                ((uint32_t)0x0000001C) /*!< TIM5 触发 */
#define DAC_Trigger_T15_TRGO               ((uint32_t)0x0000001C) /*!< TIM15 触发*/
#define DAC_Trigger_T2_TRGO                ((uint32_t)0x00000024) /*!< TIM2   */
#define DAC_Trigger_T4_TRGO                ((uint32_t)0x0000002C) /*!< TIM4   */
#define DAC_Trigger_Ext_IT9                ((uint32_t)0x00000034) /*!< 外部中断线9 触发 */
#define DAC_Trigger_Software               ((uint32_t)0x0000003C) /*!< 软件触发 */