这些小活动你都参加了吗?快来围观一下吧!>>
电子产品世界 » 论坛首页 » DIY与开源设计 » 电子DIY » (NRF24L01驱动成功)hanshuyujifen2的 ARM DIY进程贴

共119条 9/12 |‹ 7 8 9 10 11 12 跳转至
高工
2012-05-15 23:12:32     打赏
81楼
只有3分?
SD卡读写数据成功。

配合上面给出的SD卡驱动函数。可以正常读出SD卡中数据。
我读出的是SD卡的00块数据,通过串口发送电脑显示。
然后将读出的数据全部改成0写入0x00块。再读出,发串口显示。
初始化代码:
void SDCard_Init(void)
{
    SD_Error Status = SD_OK;
    SD_CardInfo SDCardInfo;
    /*-------------------------- SD Init ----------------------------- */
    Status = SD_Init();

    if (Status == SD_OK)
    {
        /*----------------- Read CSD/CID MSD registers ------------------*/
        Status = SD_GetCardInfo(&SDCardInfo);
    }

    if (Status == SD_OK)
    {
        /*----------------- Select Card --------------------------------*/
        Status = SD_SelectDeselect((u32) (SDCardInfo.RCA << 16));
    }

    if (Status == SD_OK)
    {
        //Status = SD_EnableWideBusOperation(SDIO_BusWide_4b);
    }

    /* Set Device Transfer Mode to DMA */
    if (Status == SD_OK)
    { 
        //    Status = SD_SetDeviceMode(SD_DMA_MODE);//oet
        Status = SD_SetDeviceMode(SD_POLLING_MODE);
        //Status = SD_SetDeviceMode(SD_INTERRUPT_MODE);
    }

}

使用库函数读写BLOCK代码:
    //先读出来显示一下
    SD_ReadBlock(0x00, (u32 *)(&buf[0]), 512);
    for(i=0;i<512;i++)
    {
        printf("0X%X\t",buf[i]);
    }   
    //修改block中数据,写入。0x01,0x02,0x..,0x..,0x03.后边数据不变.
    printf("\r\n\r\n");
    buf[0] = 1;
    buf[1] = 2;
    buf[4] = 3;
    SD_WriteBlock(0x00, (u32 *)(&buf[0]), 512);
    //SD_ReadBlock(0x00, (u32 *)(&buf[0]), 512);
       
    for(i=0;i<512;i++)
    {
        printf("0X%X\t",buf[i]);
    }   
上图:
SDIO读取00块数据


SDIO读出数据与WinHex读出数据的对比,原图可放大查看详细信息:


SDIO 写入数据对比

高工
2012-05-15 23:15:04     打赏
82楼
图片调小之后完全看不清楚了。
详细可查看原图
明天准备FATFS  再赚10分

高工
2012-05-16 12:06:58     打赏
83楼
你是说3.5库里边带的那个spi驱动sd卡吧?spi和sdio是不一样的。我已经给出了sdio驱动sd卡的程序了

高工
2012-05-16 22:45:38     打赏
84楼
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;
            }
        }
    }

最后上图:

高工
2012-05-18 09:02:38     打赏
85楼
我已失去七年了。。。。。。

高工
2012-05-18 09:10:58     打赏
86楼
这话说的酸酸的。。。。。。

高工
2012-05-18 12:18:35     打赏
87楼
你看看csd的说明。这个东西我没研究。读出block之后,直接交给fatFS了。一个小日本写的程序

高工
2012-05-19 22:46:59     打赏
88楼
试验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 差不多





高工
2012-05-20 21:14:14     打赏
89楼
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当作个缓冲也不错哦。

高工
2012-05-22 21:42:53     打赏
90楼

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

共119条 9/12 |‹ 7 8 9 10 11 12 跳转至

回复

匿名不能发帖!请先 [ 登陆 注册 ]