EEPW论坛

试验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当作个缓冲也不错哦。

5分给你！！做的不赖啊

做得真棒~~~
就参考楼主的帖子继续实验了

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) /*!< 软件触发 */

SPI初始化和数据传输

LCD的触摸功能是SPI控制的，为了适应LCD的触摸功能，得先搞下SPI。

SPI总线在发送数据的时候，同时也在接收数据。因此将SPI总线的MISO和MOSI两个线连接起来就能看到发送出去的数据。
SPI1对应的GPIO引脚为PA5->SPI1_CLK   PA6->SPI1_MISO PA7->SPI1_MOSI。在板子上分别是SW2、SW3、SW4。因此将SW3、SW4插针链接。SCK不用管。

俺使用了库函数来玩SPI，代码如下：
//SPI初始化
void SPI1_Init(void)
{     
    SPI_InitTypeDef  SPI_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(    RCC_APB2Periph_GPIOA|RCC_APB2Periph_SPI1, ENABLE );   
      
    /* Configure SPI1 pins: SCK, MISO and MOSI */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;      //分别对应SPI1_CLK、SPI1_MISO、SPI1_MOSI
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //复用推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
   
    /* SPI1 configuration */
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;        //设置SPI工作模式:设置为主SPI
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;        //设置SPI的数据大小:SPI发送接收8位帧结构
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;        //选择了串行时钟的稳态:时钟悬空高
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;    //数据捕获于第二个时钟沿
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;        //定义波特率预分频的值:波特率预分频值为256
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;    //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    SPI_InitStructure.SPI_CRCPolynomial = 7;    //CRC值计算的多项式
    SPI_Init(SPI1, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
   
    /* Enable SPI1  */
    SPI_Cmd(SPI1, ENABLE); //使能SPI外设
             
} 
//发送/接收数据
u8 SPI1_ReadWriteByte(u8 TxData)
{       
    u8 retry=0;                 
    //while((SPI1->SR&1<<1)==0)//等待发送区空   
    /* Loop while DR register in not emplty */
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    {
        retry++;
        if(retry>200)return 0;
    }             
    /* Send byte through the SPI1 peripheral */
    SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    retry=0;

    /* Wait to receive a byte */
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET); //检查指定的SPI标志位设置与否:接受缓存非空标志位
    {
        retry++;
        if(retry>200)return 0;
    }                                 
    /* Return the byte read from the SPI bus */
    return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                   
}


主函数中调用：
    SPI1_Init();
    for(i=0;i<100;i++)
    {
        printf("SPI接收到数据：%d\r\n",SPI1_ReadWriteByte(i));
    }

串口显示图片如下：

看到强大的LZ，自己真的太慢了~

连上三天晚班。昨天弄触摸屏没搞定

有两个问题：1、EEPROM读写一直处于死锁状态~LZ是怎么解决的？
2、LZ是怎么学习STM32的！感觉没接触到一块全新的知识，自己就要用好长的时间去理清，而且还不一定可以完全搞明白~希望LZ给点建议