你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

chrome
chrome firefox
firefox safari
safari ie
ie8及以上

陈酿！四年陈的STM32F103外设测试代码！希望对你有帮助~~~ 精华  

[复制链接]
Dylan疾风闪电 发布时间：2016-1-7 14:26
阅读主题, 点击返回1楼
赞 收藏 22 评论60 发布时间：2016-1-7 14:26
60个回答
Dylan疾风闪电 回答时间：2016-1-7 15:13:12
  1. /**
  2.   ******************************************************************************
  3.   * @file /FLASH_Program.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-17
  7.   * @brief    FLASH：擦写数据到FLASH地址
  8.   ******************************************************************************
  9.   *用途：将某些掉电保持的数据存入FLASH，供下次上电检测
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()
  13.   
  14.   //2.Watch中观察
  15.   FLASH地址0x08008000~0x0800C000中的数据：
  16.     从0xFFFFFFFF修改为Data = 0x15041979;
  17.   */

  19. #ifndef __FLASH_PROGRAM_H
  20. #define __FLASH_PROGRAM_H
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "std32periph.h"

  24. /* Private typedef -----------------------------------------------------------*/
  25. typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
  26. /* Private define ------------------------------------------------------------*/
  27. #define FLASH_PAGE_SIZE     ((u16)0x800)
  28. #define StartAddr           ((u32)0x08008000)
  29. #define EndAddr             ((u32)0x0800C000)
  30. /* Private macro -------------------------------------------------------------*/
  31. /* Private variables ---------------------------------------------------------*/
  32. /* Private functions ---------------------------------------------------------*/

  34. void fmain(void)
  35. {
  36.   u32 EraseCounter = 0x00, Address = 0x00;
  37.   vu32 NbrOfPage = (EndAddr - StartAddr) / FLASH_PAGE_SIZE;
  38.   u32 Data = 0x15041979;
  39.   /*  typedef enum{FLASH_BUSY = 1,  FLASH_ERROR_PG,  FLASH_ERROR_WRP,  FLASH_COMPLETE,  FLASH_TIMEOUT}FLASH_Status;  */
  40.   volatile FLASH_Status FLASHStatus = FLASH_COMPLETE;
  41.   volatile TestStatus MemoryProgramStatus = PASSED;
  42.   
  43.   
  44.   RCC_HSEConf(9);//72M

  46.   
  47.   FLASH_Unlock();
  48.   /* Clear All pending flags */
  49.   FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);       

  51.   /* Erase the FLASH pages */
  52.   for(EraseCounter = 0; (EraseCounter < NbrOfPage) && (FLASHStatus == FLASH_COMPLETE); EraseCounter++)
  53.   {
  54.     FLASHStatus = FLASH_ErasePage(StartAddr + (FLASH_PAGE_SIZE * EraseCounter));
  55.   }
  56.   
  57.   /*  FLASH Word program of data 0x15041979 at addresses defined by StartAddr and EndAddr*/
  58.   Address = StartAddr;
  59.   while((Address < EndAddr) && (FLASHStatus == FLASH_COMPLETE))
  60.   {
  61.     FLASHStatus = FLASH_ProgramWord(Address, Data);
  62.     Address = Address + 4;
  63.   }
  64.   
  65.   /* Check the corectness of written data */
  66.   Address = StartAddr;
  67.   while((Address < EndAddr) && (MemoryProgramStatus != FAILED))
  68.   {
  69.     if((*(vu32*) Address) != Data)
  70.     {
  71.       MemoryProgramStatus = FAILED;
  72.     }
  73.     Address += 4;
  74.   }
  75. }

  77. #endif
  78. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:13:27
  1. /**
  2.   ******************************************************************************
  3.   * @file /FLASH_WriteProtection.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-17
  7.   * @brief    FLASH：写保护(写保护部分存在问题，无法设置保护)
  8.   ******************************************************************************
  9.   *用途：将某些掉电保持的数据存入FLASH，供下次上电检测
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()
  13.   
  14.   //2.Watch中观察
  15.   FLASH地址0x08006000~0x08008000中的数据：
  16.     从0xFFFFFFFF修改为 0x17531753;
  17.   */

  19. #ifndef __FLASH_WRITEPROTECTION_H
  20. #define __FLASH_WRITEPROTECTION_H
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "std32periph.h"

  24. /* Private typedef -----------------------------------------------------------*/
  25. typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
  26. /* Private define ------------------------------------------------------------*/
  27. #define FLASH_PAGE_SIZE     ((u16)0x800)
  28. #define StartAddr           ((u32)0x08006000)
  29. #define EndAddr             ((u32)0x08008000)
  30. /* Uncomment this line to Enable Write Protection */
  31. //#define WriteProtection_Enable
  32. /* Uncomment this line to Disable Write Protection */
  33. #define WriteProtection_Disable
  34. /* Private macro -------------------------------------------------------------*/
  35. /* Private variables ---------------------------------------------------------*/
  36. /* Private functions ---------------------------------------------------------*/

  38. void fmain(void)
  39. {
  40.   u32 EraseCounter = 0, Address;
  41.   u16 Data = 0x1753;
  42.   vu32 WRPR_Value = 0xFFFFFFFF, ProtectedPages = 0x0;
  43.   vu8 NbrOfPage = (EndAddr - StartAddr) / FLASH_PAGE_SIZE;
  44.   /*  typedef enum{FLASH_BUSY = 1,  FLASH_ERROR_PG,  FLASH_ERROR_WRP,  FLASH_COMPLETE,  FLASH_TIMEOUT}FLASH_Status;  */
  45.   volatile FLASH_Status FLASHStatus = FLASH_COMPLETE;
  46.   volatile TestStatus MemoryProgramStatus = PASSED;  
  47.   
  48.   
  49.   RCC_HSEConf(9);//72M

  51.   
  52.   //CR_LOCK位=1执行解锁序列
  53.   FLASH->KEYR = 0x45670123;
  54.   FLASH->KEYR = 0xCDEF89AB;
  55.   
  56.   FLASH->SR = 0x35;//写1清除SR寄存器所有状态

  58.   //获取信息最后8页的写保护状态，判断是否写保护
  59.   ProtectedPages = (FLASH->WRPR) & 0x000000C0;

  61. #ifdef WriteProtection_Disable
  62.   if (ProtectedPages == 0x00)
  63.   {/* Pages are write protected */
  64.     FLASHStatus = FLASH_EraseOptionBytes();//Erases the FLASH option bytes.
  65.     /* ---------------------------------------------------------------------------------------
  66.     要将访问钥匙 0x05FA0000 与我们的操作 SYSRESETREQ[2]=1 相或,一起写入 SCB->AIRCR,才被CM3接受
  67.     //NVIC_GenerateSystemReset();
  68.     --------------------------------------------------------------------------------------- */
  69.     SCB->AIRCR = (u32)0x05FA0000 | (u32)0x04;//先键入钥匙(u32)0x05FA0000,然后产生一个系统复位
  70.   }
  71. #elif defined WriteProtection_Enable
  72.   if (ProtectedPages != 0x00)
  73.   {/* Pages not write protected */
  74.     /* Enable the pages write protection */
  75.     FLASHStatus = FLASH_EnableWriteProtection(0x000000C0);
  76.    
  77.     /* ---------------------------------------------------------------------------------------
  78.     要将访问钥匙 0x05FA0000 与我们的操作 SYSRESETREQ[2]=1 相或,一起写入 SCB->AIRCR,才被CM3接受
  79.     //NVIC_GenerateSystemReset();
  80.     --------------------------------------------------------------------------------------- */
  81.     SCB->AIRCR = (u32)0x05FA0000 | (u32)0x04;//先键入钥匙(u32)0x05FA0000,然后产生一个系统复位
  82.   }
  83. #endif
  84.   
  85.   /* If Pages are not write protected, perform erase and program operations
  86.      Else nothing */
  87.   if (ProtectedPages != 0x00)
  88.   {
  89.     FLASH->SR = 0x35;//写1清除SR寄存器所有状态

  91.     //擦除指定FLASH页
  92.     for(EraseCounter = 0; (EraseCounter < NbrOfPage) && (FLASHStatus == FLASH_COMPLETE); EraseCounter++)
  93.     {
  94.       FLASHStatus = FLASH_ErasePage(StartAddr + (FLASH_PAGE_SIZE * EraseCounter));
  95.     }
  96.   
  97.     //将数据0x1753 写入指定FLASH地址
  98.     Address = StartAddr;
  99.     while((Address < EndAddr) && (FLASHStatus == FLASH_COMPLETE))
  100.     {
  101.       FLASHStatus = FLASH_ProgramHalfWord(Address, Data);
  102.       Address = Address + 2;
  103.     }

  105.     //检测写入的数据
  106.     Address = StartAddr;
  107.     while((Address < EndAddr) && (MemoryProgramStatus != FAILED))
  108.     {
  109.       if((*(vu16*) Address) != Data)
  110.       {
  111.         MemoryProgramStatus = FAILED;
  112.       }
  113.       Address += 2;
  114.     }
  115.   }
  116. }



  120. #endif
  121. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:13:42
  1. /**
  2.   ******************************************************************************
  3.   * @file /FSMC_NAND.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-17
  7.   * @brief    FSMC：(未研究)
  8.   use the FSMC firmware library and an associate driver to perform erase/read/write operations
  9.   on the NAND512W3A2CN6E memory mounted on STM3210E-LK board.
  10.   ******************************************************************************
  11.   *用途：将某些掉电保持的数据存入FLASH，供下次上电检测
  12.   */
  13.   /*实例应用步骤：
  14.   //1."main.cpp"调用fmain()
  15.   
  16.   //2.Watch中观察
  17.   LED
  18.   TxBuffer,RxBuffer
  19.   */

  21. #ifndef __FSMC_NAND_H
  22. #define __FSMC_NAND_H
  23. /* Includes ------------------------------------------------------------------*/
  24. #include "std32periph.h"

  26. /* Private typedef -----------------------------------------------------------*/
  27. typedef struct
  28. {
  29.   u8 Maker_ID;
  30.   u8 Device_ID;
  31.   u8 Third_ID;
  32.   u8 Fourth_ID;
  33. }NAND_IDTypeDef;

  35. typedef struct
  36. {
  37.   u16 Block;
  38.   u16 Page;
  39. } NAND_ADDRESS;
  40. /* Private define ------------------------------------------------------------*/
  41. #define BUFFER_SIZE         0x80//0x1000
  42. #define NAND_HY_ManufactureCode 0xAD
  43. #define NAND_HY_DeviceCode      0xF1
  44. #define NAND_HY_3rdCode         0x80
  45. #define NAND_HY_4thCode         0x1D

  47. #define FSMC_Bank_NAND     FSMC_Bank2_NAND
  48. #define Bank_NAND_ADDR     Bank2_NAND_ADDR
  49. #define Bank2_NAND_ADDR    ((u32)0x70000000)

  51. /* Private macro -------------------------------------------------------------*/
  52. /*row address is in the unit of page
  53. for HY nand data sheet --> address sequence --> A0~A11 as tail --> discard 1st & 2nd address cycle*/
  54. #define ROW_ADDRESS (Address.Page + Address.Block * NAND_BLOCK_SIZE)

  56. /* NAND Area definition  for STM3210E-LK Board  */
  57. #define CMD_AREA                   (u32)(1<<16)  /* A16 = CLE  high */
  58. #define ADDR_AREA                  (u32)(1<<17)  /* A17 = ALE high */

  60. #define DATA_AREA                  ((u32)0x00000000)

  62. /* FSMC NAND memory command */
  63. #define        NAND_CMD_AREA_A            ((u8)0x00)
  64. //#define        NAND_CMD_AREA_B            ((u8)0x01)
  65. //#define NAND_CMD_AREA_C            ((u8)0x50)
  66. #define NAND_CMD_AREA_TRUE1        ((u8)0x30)

  68. #define NAND_CMD_WRITE0            ((u8)0x80)
  69. #define NAND_CMD_WRITE_TRUE1       ((u8)0x10)
  70.        
  71. #define NAND_CMD_ERASE0            ((u8)0x60)
  72. #define NAND_CMD_ERASE1            ((u8)0xD0)  

  74. #define NAND_CMD_READID            ((u8)0x90)       
  75. #define NAND_CMD_STATUS            ((u8)0x70)
  76. #define NAND_CMD_LOCK_STATUS       ((u8)0x7A)
  77. #define NAND_CMD_RESET             ((u8)0xFF)

  79. /* NAND memory status */
  80. #define NAND_VALID_ADDRESS         ((u32)0x00000100)
  81. #define NAND_INVALID_ADDRESS       ((u32)0x00000200)
  82. #define NAND_TIMEOUT_ERROR         ((u32)0x00000400)
  83. #define NAND_BUSY                  ((u32)0x00000000)
  84. #define NAND_ERROR                 ((u32)0x00000001) // bit0
  85. #define NAND_READY                 ((u32)0x00000040) // bit6

  87. /* FSMC NAND memory parameters */
  88. #define NAND_PAGE_SIZE             ((u16)0x0800) /* 2k bytes per page without Spare Area */
  89. #define NAND_BLOCK_SIZE            ((u16)0x0040) /* 64 pages per block */
  90. #define NAND_SPARE_AREA_SIZE       ((u16)0x0040) /* last 64 bytes as spare area */
  91. #define NAND_MAX_BLOCK             ((u16)0x0400) /* max 1024 block */

  93. /* FSMC NAND memory address computation */
  94. #define ADDR_1st_CYCLE(ADDR)       (u8)((ADDR)& 0xFF)               /* 1st addressing cycle */
  95. #define ADDR_2nd_CYCLE(ADDR)       (u8)(((ADDR)& 0xFF00) >> 8)      /* 2nd addressing cycle */
  96. #define ADDR_3rd_CYCLE(ADDR)       (u8)(((ADDR)& 0xFF0000) >> 16)   /* 3rd addressing cycle */
  97. #define ADDR_4th_CYCLE(ADDR)       (u8)(((ADDR)& 0xFF000000) >> 24) /* 4th addressing cycle */
  98. /* Private macro -------------------------------------------------------------*/
  99. /* Private variables ---------------------------------------------------------*/
  100. u8 page_data[NAND_PAGE_SIZE]; /*for temparoily hold the page data*/
  101. u8 page_data_tmp; /* store 1st 2k main array data(flush) */

  103. NAND_IDTypeDef NAND_ID;
  104. NAND_ADDRESS WriteReadAddr;
  105. u8 TxBuffer[BUFFER_SIZE], RxBuffer[BUFFER_SIZE];
  106. vu32 PageNumber = 2, WriteReadStatus = 0, status= 0;
  107. u32 j = 0;
  108. /* Private functions ---------------------------------------------------------*/
  109. void FSMC_NAND_Init(void);
  110. void FSMC_NAND_ReadID(NAND_IDTypeDef* NAND_ID);
  111. u32 FSMC_NAND_ProgramPage(u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToWrite);
  112. u32 FSMC_NAND_ReadPage (u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToRead);
  113. u32 FSMC_NAND_WriteSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaTowrite);
  114. u32 FSMC_NAND_ReadSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaToRead);
  115. u32 FSMC_NAND_EraseBlock(NAND_ADDRESS Address);
  116. u32 FSMC_NAND_Reset(void);
  117. u32 FSMC_NAND_GetStatus(void);
  118. u32 FSMC_NAND_ReadStatus(void);
  119. u32 FSMC_NAND_AddressIncrement(NAND_ADDRESS* Address);

  121. void FSMC_NAND_Init(void)
  122. {
  123.   GPIO_InitTypeDef GPIO_InitStructure;
  124.   FSMC_NANDInitTypeDef FSMC_NANDInitStructure;
  125.   FSMC_NAND_PCCARDTimingInitTypeDef  p;
  126.   
  127.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE |
  128.                          RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOG, ENABLE);
  129.   
  130. /*-- GPIO Configuration ------------------------------------------------------*/
  131. /* CLE, ALE, D0->D3, NOE, NWE and NCE2  NAND pin configuration  */
  132.   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15 |  
  133.                                  GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 |
  134.                                  GPIO_Pin_7;                                 
  135.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  136.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  138.   GPIO_Init(GPIOD, &GPIO_InitStructure);

  140. /* D4->D7 NAND pin configuration  */  
  141.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10;

  143.   GPIO_Init(GPIOE, &GPIO_InitStructure);


  146. /* NWAIT NAND pin configuration */
  147.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;                                                            
  148.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  149.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

  151.   GPIO_Init(GPIOD, &GPIO_InitStructure);

  153. /* INT2 NAND pin configuration */  
  154.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;                                                            
  155.   GPIO_Init(GPIOG, &GPIO_InitStructure);

  157.   /*-- FSMC Configuration ------------------------------------------------------*/
  158.   p.FSMC_SetupTime = 0x1;
  159.   p.FSMC_WaitSetupTime = 0x3;
  160.   p.FSMC_HoldSetupTime = 0x2;
  161.   p.FSMC_HiZSetupTime = 0x1;

  163.   FSMC_NANDInitStructure.FSMC_Bank = FSMC_Bank2_NAND;
  164.   FSMC_NANDInitStructure.FSMC_Waitfeature = FSMC_Waitfeature_Enable;
  165.   FSMC_NANDInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_8b;
  166.   FSMC_NANDInitStructure.FSMC_ECC = FSMC_ECC_Enable;
  167.   FSMC_NANDInitStructure.FSMC_ECCPageSize = FSMC_ECCPageSize_512Bytes;
  168.   //FSMC_NANDInitStructure.FSMC_AddressLowMapping = FSMC_AddressLowMapping_Direct;
  169.   FSMC_NANDInitStructure.FSMC_TCLRSetupTime = 0x00;
  170.   FSMC_NANDInitStructure.FSMC_TARSetupTime = 0x00;
  171.   FSMC_NANDInitStructure.FSMC_CommonSpaceTimingStruct = &p;
  172.   FSMC_NANDInitStructure.FSMC_AttributeSpaceTimingStruct = &p;
  173.   FSMC_NANDInit(&FSMC_NANDInitStructure);

  175.   /* FSMC NAND Bank Cmd Test */
  176.   FSMC_NANDCmd(FSMC_Bank2_NAND, ENABLE);
  177. }

  179. void FSMC_NAND_ReadID(NAND_IDTypeDef* NAND_ID)
  180. {
  181.   u32 data = 0;

  183.   /* writing 90h to the command register, followed by an address input of 00h*/        
  184.   *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = 0x90;
  185.   *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;

  187.    /* Four read cycles sequentially output the 1st cycle (ADh), and 2nd cycle (the device code) and
  188.       3rd cycle ID, 4th cycle ID */       
  189.    data = *(vu32 *)(Bank_NAND_ADDR | DATA_AREA);

  191.    NAND_ID->Maker_ID   = ADDR_1st_CYCLE (data);
  192.    NAND_ID->Device_ID  = ADDR_2nd_CYCLE (data);
  193.    NAND_ID->Third_ID   = ADDR_3rd_CYCLE (data);
  194.    NAND_ID->Fourth_ID  = ADDR_4th_CYCLE (data);  
  195. }

  197. u32 FSMC_NAND_ProgramPage(u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToWrite)
  198. {
  199.   u32 index = 0x00, numpagewritten = 0x00, addressstatus = NAND_VALID_ADDRESS;
  200.   u32 status = NAND_READY, size = 0x00;

  202.   while((NumPageToWrite != 0x00) && (addressstatus == NAND_VALID_ADDRESS) && (status == NAND_READY))
  203.   {
  204.     /* begins by inputting the Serial Data Input command (80h)*/
  205.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE0;
  206.     /* followed by the four cycle address inputs */
  207.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;  
  208.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;  
  209.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);  
  210.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);  

  212.     /* Calculate number of write operatin (the size of main array to be programed)*/
  213.     size = NAND_PAGE_SIZE + (NAND_PAGE_SIZE * numpagewritten);

  215.     /* then serial data and tADL of min=100ns should be guaranteed */
  216.     /* tADL is the time from the WE rising edge of final address cycle
  217.     to the WE rising of first data cycle. */
  218.     for(; index < size; index++)
  219.     {
  220.       *(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = pBuffer[index];
  221.     }
  222.    
  223.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE_TRUE1;

  225.     /* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
  226.     while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
  227.    
  228.     /* Check status for successful operation */
  229.     status = FSMC_NAND_GetStatus();
  230.    
  231.     if(status == NAND_READY)
  232.     {
  233.       numpagewritten++;

  235.       NumPageToWrite--;

  237.       /* Calculate Next small page Address */
  238.       addressstatus = FSMC_NAND_AddressIncrement(&Address);   
  239.     }   
  240.   }
  241.   
  242.   return (status | addressstatus);
  243. }

  245. u32 FSMC_NAND_ReadPage(u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToRead)
  246. {
  247.   u32 index = 0x00, numpageread = 0x00, addressstatus = NAND_VALID_ADDRESS;
  248.   u32 status = NAND_READY, size = 0x00;

  250.   while((NumPageToRead != 0x0) && (addressstatus == NAND_VALID_ADDRESS))
  251.   {          
  252.     /* Page Read command and page address */
  253.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_A;
  254.    
  255.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
  256.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
  257.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
  258.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
  259.    
  260.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_TRUE1;

  262.     /* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
  263.     while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
  264.    
  265.     /* Calculate the size */
  266.     size = NAND_PAGE_SIZE + (NAND_PAGE_SIZE * numpageread);
  267.    
  268.     /* Get Data into Buffer */   
  269.     for(; index < size; index++)
  270.     {
  271.       pBuffer[index]= *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
  272.     }

  274.     numpageread++;
  275.    
  276.     NumPageToRead--;

  278.     /* Calculate page address */                                    
  279.     addressstatus = FSMC_NAND_AddressIncrement(&Address);
  280.   }

  282.   status = FSMC_NAND_GetStatus();
  283.   
  284.   return (status | addressstatus);
  285. }

  287. u32 FSMC_NAND_WriteSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaTowrite)
  288. {
  289.   u32 index = 0x00, numsparesreawritten = 0x00, addressstatus = NAND_VALID_ADDRESS;
  290.   u32 status = NAND_READY, size = 0x00;


  293.   while((NumSpareAreaTowrite != 0x00) && (addressstatus == NAND_VALID_ADDRESS) && (status == NAND_READY))
  294.   {   
  295.     /* read out main array data into page_data[] firstly */
  296.     FSMC_NAND_ReadPage(page_data, Address, 1);
  297.    
  298.    
  299.     /* Page write Spare area command and address */
  300.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE0;

  302.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
  303.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
  304.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
  305.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);

  307.     /* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
  308.     while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );

  310.     /* total number of write operation */
  311.     size = (NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) + ((NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) * numsparesreawritten);

  313.     /* Write the data */
  314.     for(; index < size; index++)
  315.     {
  316.       if (index < size - NAND_SPARE_AREA_SIZE)
  317.         *(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = page_data[index - (NAND_PAGE_SIZE + NAND_SPARE_AREA_SIZE)*numsparesreawritten];
  318.       else
  319.         *(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = pBuffer[index - NAND_PAGE_SIZE * (numsparesreawritten+1)];
  320.     }
  321.    
  322.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE_TRUE1;

  324.     /* Check status for successful operation */
  325.     status = FSMC_NAND_GetStatus();

  327.     if(status == NAND_READY)
  328.     {
  329.       numsparesreawritten++;      

  331.       NumSpareAreaTowrite--;  
  332.    
  333.       /* Calculate Next page Address */
  334.       addressstatus = FSMC_NAND_AddressIncrement(&Address);
  335.     }      
  336.   }
  337.   
  338.   return (status | addressstatus);
  339. }

  341. u32 FSMC_NAND_ReadSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaToRead)
  342. {
  343.   u32 numsparearearead = 0x00, index = 0x00, addressstatus = NAND_VALID_ADDRESS;
  344.   u32 status = NAND_READY, size = 0x00;

  346.   while((NumSpareAreaToRead != 0x0) && (addressstatus == NAND_VALID_ADDRESS))
  347.   {     
  348.     /* Page Read command and page address */     
  349.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_A; // no area B/C for HY

  351.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
  352.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;     
  353.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);     
  354.     *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);   

  356.     *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_TRUE1;

  358.     /* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
  359.     while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
  360.    
  361.     /* total number of write operation */
  362.     size = (NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) +  ((NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) * numsparearearead);//
  363.        
  364.     /* Get page data into temp-space and get spare data into Buffer */
  365.     for ( ;index < size; index++)
  366.     {
  367.       if (index < size - NAND_SPARE_AREA_SIZE)
  368.         page_data_tmp = *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
  369.       else
  370.         pBuffer[index - NAND_PAGE_SIZE * (numsparearearead+1)] = *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
  371.     }
  372.    
  373.     numsparearearead++;
  374.    
  375.     NumSpareAreaToRead--;

  377.     /* Calculate page address */                                    
  378.     addressstatus = FSMC_NAND_AddressIncrement(&Address);
  379.   }

  381.   status = FSMC_NAND_GetStatus();

  383.   return (status | addressstatus);
  384. }

  386. u32 FSMC_NAND_EraseBlock(NAND_ADDRESS Address)
  387. {
  388.   *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_ERASE0;

  390.   *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
  391.   *(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
  392.                
  393.   *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_ERASE1;

  395.   /* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
  396.   while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
  397.    
  398.   return (FSMC_NAND_GetStatus());
  399. }

  401. u32 FSMC_NAND_Reset(void)
  402. {
  403.   *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_RESET;

  405.   return (NAND_READY);
  406. }

  408. u32 FSMC_NAND_GetStatus(void)
  409. {
  410.   u32 timeout = 0x1000000, status = NAND_READY;

  412.   status = FSMC_NAND_ReadStatus();

  414.   /* Wait for a NAND operation to complete or a TIMEOUT to occur */
  415.   while ((status != NAND_READY) &&( timeout != 0x00))
  416.   {
  417.      status = FSMC_NAND_ReadStatus();
  418.      timeout --;      
  419.   }

  421.   if(timeout == 0x00)
  422.   {         
  423.     status =  NAND_TIMEOUT_ERROR;      
  424.   }

  426.   /* Return the operation status */
  427.   return (status);      
  428. }

  430. u32 FSMC_NAND_ReadStatus(void)
  431. {
  432.   u32 data = 0x00, status = NAND_BUSY;

  434.   /* Read status operation ------------------------------------ */
  435.   *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_STATUS;
  436.   data = *(vu8 *)(Bank_NAND_ADDR);

  438.   if((data & NAND_ERROR) == NAND_ERROR)
  439.   {
  440.     status = NAND_ERROR;
  441.   }
  442.   else if((data & NAND_READY) == NAND_READY)
  443.   {
  444.     status = NAND_READY;
  445.   }
  446.   else
  447.   {
  448.     status = NAND_BUSY;
  449.   }
  450.   
  451.   return (status);
  452. }

  454. u32 FSMC_NAND_AddressIncrement(NAND_ADDRESS* Address)
  455. {
  456.   u32 status = NAND_VALID_ADDRESS;

  458.   Address->Page++;

  460.   if(Address->Page == NAND_BLOCK_SIZE)
  461.   {
  462.     Address->Page = 0;
  463.     Address->Block++;
  464.    
  465.     if(Address->Block == NAND_MAX_BLOCK)
  466.     {
  467.       status = NAND_INVALID_ADDRESS;
  468.     }
  469.   }
  470.   
  471.   return (status);
  472. }


  475. void Fill_Buffer(u8 *pBuffer, u16 BufferLenght, u32 Offset)
  476. {
  477.   u16 IndexTmp = 0;

  479.   /* Put in global buffer same values */
  480.   for (IndexTmp = 0; IndexTmp < BufferLenght; IndexTmp++ )
  481.   {
  482.     pBuffer[IndexTmp] = IndexTmp + Offset;
  483.   }
  484. }

  486. void fmain(void)
  487. {
  488.   RCC_HSEConf(9);//72M

  490.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF, ENABLE);
  491.   
  492.   /* Configure PF.06, PF.07 and PF.08 as Output push-pull */
  493.   GPIO_InitTypeDef GPIO_InitStructure;
  494.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8;
  495.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  496.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  497.   GPIO_Init(GPIOF, &GPIO_InitStructure);

  499.   /* Enable the FSMC Clock */
  500.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
  501.   
  502.   /* FSMC Initialization */
  503.   FSMC_NAND_Init();

  505.   /* NAND read ID command */
  506.   FSMC_NAND_ReadID(&NAND_ID);

  508.   /* Verify the NAND ID */
  509.   if((NAND_ID.Maker_ID == NAND_HY_ManufactureCode) && (NAND_ID.Device_ID == NAND_HY_DeviceCode))
  510.   {

  512.     /* NAND memory address to write to */
  513.     WriteReadAddr.Block = 0x00;
  514.     WriteReadAddr.Page = 0x00;

  516.     /* Erase the NAND first Block */
  517.     status = FSMC_NAND_EraseBlock(WriteReadAddr);

  519.     /* Write data to FSMC NAND memory */
  520.     /* Fill the buffer to send */
  521.     Fill_Buffer(TxBuffer, BUFFER_SIZE , 0x66);

  523.     status = FSMC_NAND_WriteSpareArea(TxBuffer, WriteReadAddr, PageNumber);

  525.     /* Read back the written data */
  526.     status = FSMC_NAND_ReadSpareArea(RxBuffer, WriteReadAddr, PageNumber);
  527.    
  528.     /* Verify the written data */
  529.     for(j = 0; j < BUFFER_SIZE; j++)
  530.     {
  531.       if(TxBuffer[j] != RxBuffer[j])
  532.       {     
  533.         WriteReadStatus++;
  534.       }
  535.     }

  537.     if (WriteReadStatus == 0)
  538.     {
  539.       GPIO_SetBits(GPIOF, GPIO_Pin_6);//执行结果
  540.     }
  541.     else
  542.     {
  543.       GPIO_SetBits(GPIOF, GPIO_Pin_7);     
  544.     }
  545.   }
  546.   else
  547.   {
  548.     GPIO_SetBits(GPIOF, GPIO_Pin_8);  
  549.   }
  550. }

  552. #endif
  553. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:14:08
  1. /**
  2.   ******************************************************************************
  3.   * @file /I2C_M24C02EEPROM.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-17
  7.   * @brief    I2C：(ST的I2C问题很多，建议不用，选择IO口模拟)--测试不通过，待调整《申明：这里只是老的资料，描述也是以前的。故对存在问题的代码也不进行优化！》
  8.   ******************************************************************************
  9.   *用途：
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()
  13.   
  14.   //2.Watch中观察
  15.   Tx1_Buffer == Rx1_Buffer
  16.   Tx2_Buffer == Rx2_Buffer
  17.   TransferStatus1,TransferStatus2
  18.   */

  20. #ifndef __I2C_M24C02EEPROM_H
  21. #define __I2C_M24C02EEPROM_H
  22. /* Includes ------------------------------------------------------------------*/
  23. #include "std32periph.h"

  25. /* Private typedef -----------------------------------------------------------*/
  26. typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
  27. typedef struct
  28. {
  29.   u8  *Tx,*Rx;
  30.   u16 Address,count,Max;
  31. }I2CTYPE;
  32. /* Private define ------------------------------------------------------------*/
  33. #define EEPROM_WriteAddress1    0x05
  34. #define EEPROM_ReadAddress1     0x05
  35. #define BufferSize1             (countof(Tx1_Buffer)-1)
  36. #define BufferSize2             (countof(Tx2_Buffer)-1)
  37. #define EEPROM_WriteAddress2    (EEPROM_WriteAddress1 + BufferSize1)
  38. #define EEPROM_ReadAddress2     (EEPROM_ReadAddress1 + BufferSize1)

  40. #define I2C_Speed               400000
  41. #define I2C1_SLAVE_ADDRESS7     0xA0
  42. #define I2C_PageSize            8 /* page size of the I2C M24C02 EEPROM */
  43.                                  /*  implemented on the STM3210E-LK board*/
  44. /* Private macro -------------------------------------------------------------*/
  45. #define countof(a) (sizeof(a) / sizeof(*(a)))
  46. /* Private variables ---------------------------------------------------------*/
  47. u8 Tx1_Buffer[] = "LLKKMMJJ";//"/* STM32F10x I2C Firmware ";
  48. u8 Tx2_Buffer[] = "Library Example */";
  49. u8 Rx1_Buffer[BufferSize1], Rx2_Buffer[BufferSize2];
  50. volatile TestStatus TransferStatus1 = FAILED, TransferStatus2 = FAILED;
  51. const u16 EEPROM_ADDRESS = 0xA0;//#define EEPROM_Block0_ADDRESS   0xA0   /* A1 = 0  A2 = 0 A3 = 0*/

  53. I2CTYPE msgI2C;
  54. bool status = false;
  55. /* Private functions ---------------------------------------------------------*/


  58. bool I2C_Event(I2CTYPE &msg)
  59. {
  60.   //#define  I2CMode_Slave
  61.   //Read SR1 and SR2,then save as I2CdwSR
  62.   u32 SR32 = I2C1->SR1 & 0x4FF;
  63.   SR32 |= (I2C1->SR2 & 0x7)<<16;
  64.   
  65.   switch (SR32)
  66.   {
  67. #ifdef  I2CMode_Slave
  68.   //Slave Mode处理事件的优先级 EV2=EV3 > EV4=EV3_2 > EV1=EV3_1
  69.   case  0x00020040://I2C_SR_EV2:           // BUSY and RXNE flags
  70.     msg.Rx[msg.count++] = I2C1->DR;
  71.     break;
  72.   case  0x00060080://I2C_ST_EV3:           // TRA, BUSY and TXE flags
  73.   case  0x00060084://I2C_ST_EV3_1:         // TRA, BUSY, TXE and BTF flags
  74.     I2C1->DR = msg.Tx[msg.count++];
  75.     break;
  76.    
  77.   case  0x00000010://I2C_SR_EV4:           // STOPF flag
  78.     I2C1->CR1 |= 0x0001;
  79.     break;
  80.   case  0x00000400://I2C_ST_EV3_2:         // AF flag
  81.     I2C1->SR1 &= 0xFBFF;
  82.     break;
  83.    
  84.   case  0x00060082://I2C_ST_EV1:           // TRA, BUSY, TXE and ADDR flags
  85.     msg.count = 0;
  86.     break;
  87.   case  0x00020002://I2C_SR_EV1:           // BUSY and ADDR flags
  88.     msg.count = 0;
  89.     break;
  90.    
  91. #else
  92.   //Master Mode处理事件的优先级 EV8=EV6_1=EV7_1 > EV7= > EV5=EV6=EV8_1=EV8_2
  93.   case  0x00070080://I2C_MT_EV8:           // TRA, BUSY, MSL, TXE flags
  94.     if (msg.count < msg.Max)
  95.     {
  96.       I2C1->DR = msg.Tx[msg.count++];
  97.     }
  98.     else
  99.     {
  100.       I2C1->CR2 &= 0xF9FF;
  101.       I2C1->CR1 |= 0x0200;//STOP
  102.     }
  103.     break;
  104.   case  0x00030002://I2C_MR_EV6(EV6_1):    // BUSY, MSL and ADDR flags
  105.     msg.count = 0;
  106.     if (msg.Max == 1)//只接收1个字节的情况
  107.     {
  108.       I2C1->CR1 &= 0xFBFF;//ACK=0
  109.       I2C1->CR1 |= 0x0200;//STOP
  110.     }
  111.     break;
  112.   case  0x00030040://I2C_MR_EV7:(EV7_1):    // BUSY, MSL and RXNE flags
  113.     msg.Rx[msg.count++] = I2C1->DR;
  114.     if (msg.count == (msg.Max-1))
  115.     {
  116.       I2C1->CR1 &= 0xFBFF;//ACK=0
  117.       I2C1->CR1 |= 0x0200;//STOP
  118.     }
  119.     break;
  120.    
  121.   case  0x00030001://I2C_MTR_EV5:          // BUSY, MSL and SB flag
  122.     I2C1->DR = msg.Address;
  123.     break;
  124.   case  0x00070082://I2C_MT_EV6:           // BUSY, MSL, ADDR, TXE and TRA flags
  125.     msg.count = 0;
  126.     break;
  127.   case  0x00070084://I2C_MT_EV8_2:         // TRA, BUSY, MSL, TXE and BTF flags
  128.     I2C1->CR1 |= 0x0200;//STOP
  129.     break;
  130. #endif
  131.   default:
  132.     return false;//异常状态
  133.   }
  134.   return true;
  135. }

  137. void I2C_EE_WaitEepromStandbyState(void)      
  138. {
  139.   vu16 SR1_Tmp = 0;

  141.   do
  142.   {
  143.     /* Send START condition */
  144.     I2C_GenerateSTART(I2C1, ENABLE);
  145.     /* Read I2C1 SR1 register */
  146.     SR1_Tmp = I2C1->SR1;
  147.     I2C1->DR = EEPROM_ADDRESS & 0xFE;/* Send EEPROM address for write */
  148.   }while(!(I2C1->SR1 & 0x0002));
  149.   
  150.   
  151.   if(I2C_GetFlagStatus(I2C1, I2C_FLAG_AF))
  152.   {
  153.     /* Clear AF flag */
  154.     I2C_ClearFlag(I2C1, I2C_FLAG_AF);
  155.   }
  156.   
  157.   /* STOP condition */   
  158.   I2C_GenerateSTOP(I2C1, ENABLE);
  159.   
  160.   /* While the stop bit is set */  
  161.   while (I2C1->CR1 & 0x200);
  162. }

  164. bool I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite)
  165. {
  166.   u16 Timeout = 0x2000;
  167.   
  168.   while((I2C1->SR2 & 0x2) && Timeout)// While the bus is busy
  169.     Timeout--;
  170.   if (Timeout==0)
  171.     return false;
  172.   
  173.   msgI2C.Address = EEPROM_ADDRESS & 0xFE;
  174.   msgI2C.Tx = &WriteAddr;
  175.   
  176.   I2C1->CR1 |= 0x0100;// Send START condition
  177.   
  178.   //EV5
  179.   Timeout = 0x2000;
  180.   while(!I2C_Event(msgI2C) && Timeout)
  181.   {
  182.     Timeout--;
  183.   }
  184.   if (Timeout==0)
  185.     return false;

  187.   msgI2C.Tx = pBuffer;
  188.   msgI2C.Max = NumByteToWrite;
  189.   //EV6
  190.   Timeout = 0x2000;
  191.   while(!I2C_Event(msgI2C) && Timeout)
  192.   {
  193.     Timeout--;
  194.   }
  195.   if (Timeout==0)
  196.     return false;
  197.   
  198.   //EV8
  199.   Timeout = 0x2000;
  200.   while(!I2C_Event(msgI2C) && Timeout)
  201.   {
  202.     Timeout--;
  203.   }
  204.   if (Timeout==0)
  205.     return false;
  206.   
  207.   /* While there is data to be written */
  208.   while(NumByteToWrite--)  
  209.   {
  210.     //EV8
  211.     Timeout = 0x2000;
  212.     while(!I2C_Event(msgI2C) && Timeout)
  213.     {
  214.       Timeout--;
  215.     }
  216.     if (Timeout==0)
  217.       return false;
  218.   }

  220.   I2C1->CR1 |= 0x0200;/* Send STOP condition */
  221.   
  222.   return true;
  223. }

  225. void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite)
  226. {
  227.   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;

  229.   Addr = WriteAddr % I2C_PageSize;
  230.   count = I2C_PageSize - Addr;
  231.   NumOfPage =  NumByteToWrite / I2C_PageSize;
  232.   NumOfSingle = NumByteToWrite % I2C_PageSize;

  234.   /* If WriteAddr is I2C_PageSize aligned  */
  235.   if(Addr == 0)
  236.   {
  237.     /* If NumByteToWrite < I2C_PageSize */
  238.     if(NumOfPage == 0)
  239.     {
  240.       status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  241.       I2C_EE_WaitEepromStandbyState();
  242.     }
  243.     /* If NumByteToWrite > I2C_PageSize */
  244.     else  
  245.     {
  246.       while(NumOfPage--)
  247.       {
  248.         status = I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
  249.             I2C_EE_WaitEepromStandbyState();
  250.         WriteAddr +=  I2C_PageSize;
  251.         pBuffer += I2C_PageSize;
  252.       }

  254.       if(NumOfSingle!=0)
  255.       {
  256.         status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  257.         I2C_EE_WaitEepromStandbyState();
  258.       }
  259.     }
  260.   }
  261.   /* If WriteAddr is not I2C_PageSize aligned  */
  262.   else
  263.   {
  264.     /* If NumByteToWrite < I2C_PageSize */
  265.     if(NumOfPage== 0)
  266.     {
  267.       status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  268.       I2C_EE_WaitEepromStandbyState();
  269.     }
  270.     /* If NumByteToWrite > I2C_PageSize */
  271.     else
  272.     {
  273.       NumByteToWrite -= count;
  274.       NumOfPage =  NumByteToWrite / I2C_PageSize;
  275.       NumOfSingle = NumByteToWrite % I2C_PageSize;       
  276.       
  277.       if(count != 0)
  278.       {  
  279.         status = I2C_EE_PageWrite(pBuffer, WriteAddr, count);
  280.         I2C_EE_WaitEepromStandbyState();
  281.         WriteAddr += count;
  282.         pBuffer += count;
  283.       }
  284.       
  285.       while(NumOfPage--)
  286.       {
  287.         status = I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
  288.         I2C_EE_WaitEepromStandbyState();
  289.         WriteAddr +=  I2C_PageSize;
  290.         pBuffer += I2C_PageSize;  
  291.       }
  292.       if(NumOfSingle != 0)
  293.       {
  294.         status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  295.         I2C_EE_WaitEepromStandbyState();
  296.       }
  297.     }
  298.   }  
  299. }

  301. bool I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
  302. {
  303.   u16 Timeout = 0x2000;
  304.   
  305.   while((I2C1->SR2 & 0x2) && Timeout)// While the bus is busy
  306.     Timeout--;
  307.   if (Timeout==0)
  308.     return false;
  309.   
  310.   msgI2C.Address = EEPROM_ADDRESS & 0xFE;/* Send EEPROM address for write */
  311.   msgI2C.Tx = &ReadAddr;/* Send the EEPROM's internal address to write to */
  312.   msgI2C.Max = 1;
  313.   
  314.   I2C1->CR1 |= 0x0100;// Send START condition
  315.   
  316.   //EV5
  317.   Timeout = 0x2000;
  318.   while(!I2C_Event(msgI2C) && Timeout)
  319.   {
  320.     Timeout--;
  321.   }
  322.   if (Timeout==0)
  323.     return false;

  325.   //EV6
  326.   Timeout = 0x2000;
  327.   while(!I2C_Event(msgI2C) && Timeout)
  328.   {
  329.     Timeout--;
  330.   }
  331.   if (Timeout==0)
  332.     return false;
  333.   
  334.   I2C_Cmd(I2C1, ENABLE);/* Clear EV6 by setting again the PE bit */

  336.   //EV8
  337.   Timeout = 0x2000;
  338.   while(!I2C_Event(msgI2C) && Timeout)
  339.   {
  340.     Timeout--;
  341.   }
  342.   if (Timeout==0)
  343.     return false;
  344.   
  345.   
  346.   msgI2C.Address = EEPROM_ADDRESS | 0x01;/* Send EEPROM address for read */
  347.   msgI2C.Tx = pBuffer;
  348.   msgI2C.Max = NumByteToRead;
  349.   I2C1->CR1 |= 0x0100;/* Send STRAT condition a second time */  
  350.   
  351.   //EV5
  352.   Timeout = 0x2000;
  353.   while(!I2C_Event(msgI2C) && Timeout)
  354.   {
  355.     Timeout--;
  356.   }
  357.   if (Timeout==0)
  358.     return false;
  359.   
  360.   //EV6
  361.   Timeout = 0x2000;
  362.   while(!I2C_Event(msgI2C) && Timeout)
  363.   {
  364.     Timeout--;
  365.   }
  366.   if (Timeout==0)
  367.     return false;
  368.   
  369.   /* While there is data to be read */
  370.   while(NumByteToRead)  
  371.   {
  372.     //EV7
  373.     Timeout = 0x2000;
  374.     while(!I2C_Event(msgI2C) && Timeout)
  375.     {
  376.       Timeout--;
  377.     }
  378.     if (Timeout==0)
  379.       return false;

  381.     NumByteToRead--;
  382.   }

  384.   /* Enable Acknowledgement to be ready for another reception */
  385.   I2C_AcknowledgeConfig(I2C1, ENABLE);
  386.   
  387.   return true;
  388. }


  391. TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength)
  392. {
  393.   while(BufferLength--)
  394.   {
  395.     if(*pBuffer1 != *pBuffer2)
  396.     {
  397.       return FAILED;
  398.     }
  399.    
  400.     pBuffer1++;
  401.     pBuffer2++;
  402.   }

  404.   return PASSED;  
  405. }

  407. void fmain(void)
  408. {
  409.   RCC_HSEConf(9);//72M

  411.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  412.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
  413.   //复位I2C
  414.   RCC_APB2PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
  415.   
  416.   
  417.   /* Initialize the I2C EEPROM driver ----------------------------------------*/
  418.   /* Configure I2C1 pins: SCL and SDA */
  419.   GPIO_InitTypeDef  GPIO_InitStructure;
  420.   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
  421.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  422.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
  423.   GPIO_Init(GPIOB, &GPIO_InitStructure);
  424.   /* I2C configuration */
  425.   I2C_InitTypeDef  I2C_InitStructure;
  426.   I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  427.   I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
  428.   I2C_InitStructure.I2C_OwnAddress1 = I2C1_SLAVE_ADDRESS7;
  429.   I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
  430.   I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  431.   I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
  432.   /* I2C Peripheral Enable */
  433.   I2C_Cmd(I2C1, ENABLE);
  434.   /* Apply I2C configuration after enabling it -----注意点：先使能后初始化*/
  435.   I2C_Init(I2C1, &I2C_InitStructure);


  438.   /* First write in the memory followed by a read of the written data --------*/
  439.   /* Write on I2C EEPROM from EEPROM_WriteAddress1 */
  440.   I2C_EE_BufferWrite(Tx1_Buffer, EEPROM_WriteAddress1, BufferSize1);

  442.   status = false;
  443.   /* Read from I2C EEPROM from EEPROM_ReadAddress1 */
  444.   status = I2C_EE_BufferRead(Rx1_Buffer, EEPROM_ReadAddress1, BufferSize1);

  446.   TransferStatus1 = Buffercmp(Tx1_Buffer, Rx1_Buffer, BufferSize1);

  448.   /* Wait for EEPROM standby state */
  449.   I2C_EE_WaitEepromStandbyState();

  451.   /* Second write in the memory followed by a read of the written data -------*/
  452.   /* Write on I2C EEPROM from EEPROM_WriteAddress2 */
  453.   I2C_EE_BufferWrite(Tx2_Buffer, EEPROM_WriteAddress2, BufferSize2);

  455.   /* Read from I2C EEPROM from EEPROM_ReadAddress2 */
  456.   I2C_EE_BufferRead(Rx2_Buffer, EEPROM_ReadAddress2, BufferSize2);

  458.   TransferStatus2 = Buffercmp(Tx2_Buffer, Rx2_Buffer, BufferSize2);
  459. }

  461. #endif
  462. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:14:29
  1. /**
  2.   ******************************************************************************
  3.   * @file /IWDG_Example.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-18
  7.   * @brief    IWDG：The IWDG timeout is set to 280 ms,Systick Interrupt is 250ms
  8.   黄灯闪烁，表示每250ms喂狗一次
  9.   亮绿灯，表示系统已经由IWDG复位，resumed from IWDG reset
  10.   按下Keyer4 进入EXTI中断，关闭Systick，使IWDG不能喂狗，系统复位
  11.   ******************************************************************************
  12.   *用途：可用来检测和解决由软件错误引起的故障；当计数器超时时，产生系统复位。
  13.   */
  14.   /*实例应用步骤：
  15.   //1."main.cpp"调用fmain()
  16.   
  17.   //2."stm32f10x_it.cpp"拷贝
  18.   #define __IWDG_Example
  19.   extern void IWDG_Feed();
  20.   void SysTick_Handler(void)
  21.   {
  22.   #if defined __IWDG_Example
  23.     IWDG_Feed();
  24.    
  25.     GPIO_WriteBit(GPIOF, GPIO_Pin_7, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_7)));
  26.   #endif
  27.   }

  29.   void EXTI15_10_IRQHandler(void)
  30.   {
  31.     if(EXTI_GetITStatus(EXTI_Line10) != RESET)
  32.     {
  33.       #if defined __IWDG_Example
  34.         GPIO_ResetBits(GPIOF, GPIO_Pin_7);
  35.         SysTick->CTRL = 0x00000;//复位,关闭计数器
  36.       #endif
  37.       EXTI_ClearITPendingBit(EXTI_Line10);
  38.     }
  39.   }
  40.   
  41.   //3."stm32f10x_it.h"声明
  42.   void EXTI15_10_IRQHandler(void);

  44.   //4.Watch中观察
  45.   LED
  46.   */

  48. #ifndef __IWDG_EXAMPLE_H
  49. #define __IWDG_EXAMPLE_H
  50. /* Includes ------------------------------------------------------------------*/
  51. #include "std32periph.h"

  53. /* Private typedef -----------------------------------------------------------*/
  54. /* Private define ------------------------------------------------------------*/
  55.   #define GPIO_LED          GPIOF
  56.   #define RCC_LED           RCC_APB2Periph_GPIOF
  57. /* Private macro -------------------------------------------------------------*/
  58. /* Private variables ---------------------------------------------------------*/
  59. /* Private functions ---------------------------------------------------------*/

  61. void IWDG_Init(u8 prer, u16 rlr)
  62. {
  63.   IWDG->KR=0X5555;//使能对IWDG->PR和IWDG->RLR的写
  64.   IWDG->PR=prer; //LSI/32=40Khz/4*2^pre
  65.   IWDG->RLR=rlr; //从加载寄存器 IWDG->RLR
  66.   IWDG->KR=0XAAAA;//reload
  67.   IWDG->KR=0XCCCC;//使能看门狗
  68. }

  70. void IWDG_Feed(void)
  71. {
  72.   IWDG->KR=0XAAAA;//reload
  73. }

  75. void fmain(void)
  76. {
  77.   RCC_HSEConf(9);//72M

  79.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_LED | RCC_APB2Periph_AFIO, ENABLE);

  81.   
  82.   GPIO_InitTypeDef GPIO_InitStructure;
  83.   /* Configure GPIO_LED pin 6 and pin 7 as Output push-pull */
  84.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  85.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  86.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  87.   GPIO_Init(GPIO_LED, &GPIO_InitStructure);
  88.   /* Configure Key Button GPIO Pin as input pull-up (Key Button EXTI Line) */
  89.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  90.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  91.   GPIO_Init(GPIOB, &GPIO_InitStructure);
  92.   
  93.   
  94.   /* Check if the system has resumed from IWDG reset */
  95.   if (RCC_GetFlagStatus(RCC_FLAG_IWDGRST) != RESET)
  96.   {/* IWDGRST flag set */
  97.     /* Set GPIO_LED pin 6 */
  98.     GPIO_SetBits(GPIO_LED, GPIO_Pin_6);

  100.     /* Clear reset flags */
  101.     RCC_ClearFlag();
  102.   }
  103.   else
  104.   {/* IWDGRST flag is not set */
  105.     /* Reset GPIO_LED pin 6 */
  106.     GPIO_ResetBits(GPIO_LED, GPIO_Pin_6);
  107.   }

  109.   /* Configure Key Button EXTI Line to generate an interrupt on falling edge */
  110.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource10);
  111.   /* Configure Key Button EXTI Line to generate an interrupt on falling edge */
  112.   EXTI_InitTypeDef EXTI_InitStructure;
  113.   EXTI_ClearITPendingBit(EXTI_Line10);
  114.   EXTI_InitStructure.EXTI_Line = EXTI_Line10;
  115.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  116.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
  117.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  118.   EXTI_Init(&EXTI_InitStructure);

  120.   /* NVIC configuration */
  121.   NVIC_GroupSet(NVIC_PriorityGroup_0, EXTI15_10_IRQn, 0);
  122.   NVIC_GroupSet(NVIC_PriorityGroup_0, SysTick_IRQn, 1);

  124.   /* Configure SysTick to generate an interrupt each 250ms */
  125.   SysTick->LOAD = 250000*9;
  126.   SysTick->VAL = 0x00;//清空计数器
  127.   /* ---------------------------------------------------------------------
  128.   SysTick 控制与状态寄存器的位
  129.   SysTick->CTRL: CountFlag【16】,CLKSource【2】,TickINT【1】,ENABLE【0】
  130.   --------------------------------------------------------------------- */
  131.   //CLKSource【2】=0  使用外部时钟源HCLK(1:内核时钟HCLK/8)
  132.   //  TickINT【1】=0  向下计数至0，不会挂起Systick(1:至0会挂起Systick)
  133.   //   ENABLE【0】=0  禁止计数器（1:使能，至0将CountFlag置1）
  134.   SysTick->CTRL = 0x00003;

  136.   
  137.   /* IWDG timeout equal to 280 ms (40KHz/32=1.25KHz T=[349+1]/1.25=280ms) */
  138.   IWDG_Init(0x3, 349);
  139. }

  141. #endif
  142. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:14:43
  1. /**
  2.   ******************************************************************************
  3.   * @file /NVIC_CM3LPModes.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-19
  7.   * @brief    NVIC：低功耗
  8.   WFE事件  新来的中断、之前悬起的中断等(比较容易唤醒)
  9.   WFI中断  
  10.   ******************************************************************************
  11.   *用途：
  12.   1.睡眠模式
  13.     进入：
  14.       SLEEP-NOW模式：立即进入睡眠模式
  15.         SLEEPDEEP = 0 , SLEEPONEXIT = 0
  16.       SLEEP-ON-EXIT模式：从*****最低优先级*****的中断中退出时，进入睡眠模式(没有成功)
  17.         SLEEPDEEP = 0 , SLEEPONEXIT = 1
  18.       然后执行WFI(等待中断)或WFE(等待事件)指令
  19.     唤醒：WFI(任意中断可唤醒)或WFE(唤醒事件)
  20.     唤醒延时：无

  22.   2.停机模式
  23.     进入：
  24.       设置CM3中的SLEEPDEEP位 , PWR_CR中清除PDDS位 , 设置LPDS位
  25.       然后执行WFI(等待中断)或WFE(等待事件)指令
  26.     唤醒：任意外部中断可唤醒
  27.     唤醒延时：HSI RC唤醒时间 + 电压调节器从低功耗唤醒的时间

  29.   3.待机模式：可实现系统的最低功耗
  30.     进入：
  31.       设置CM3系中的SLEEPDEEP位 , PWR_CR中设置PDDS位 , CWUF位
  32.       然后执行WFI(等待中断)或WFE(等待事件)指令
  33.     唤醒：WKUP引脚的上升沿、RTC闹钟事件、NRST引脚上的外部复位、IWDG复位
  34.     唤醒延时：复位阶段时电压调节器的启动

  36.   SCB->SCR[4:0] == SEVONPEND,0,SLEEPDEEP,SLEEPONEXIT,0
  37.   */
  38.   /*实例应用步骤：
  39.   //1."main.cpp"调用fmain()
  40.   
  41.   //2."stm32f10x_it.cpp"拷贝
  42.   //#define __NVIC_CM3LPModes
  43.   #if defined __NVIC_CM3LPModes
  44.     extern u8 LowPowerMode;
  45.   #endif
  46.   void EXTI15_10_IRQHandler(void)
  47.   {
  48.     if(EXTI_GetITStatus(EXTI_Line11) != RESET)
  49.     {
  50.       #if defined __NVIC_CM3LPModes
  51.         LowPowerMode = 1;
  52.       #endif
  53.       EXTI_ClearITPendingBit(EXTI_Line11);
  54.     }
  55.   }
  56.   void EXTI0_IRQHandler(void)
  57.   {
  58.     #if defined __NVIC_CM3LPModes
  59.       GPIO_WriteBit(GPIOF, GPIO_Pin_8, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_8)));
  60.     #endif
  61.     EXTI_ClearITPendingBit(EXTI_Line0);
  62.   }
  63.   
  64.   //3."stm32f10x_it.h"声明
  65.   void EXTI15_10_IRQHandler(void);
  66.   void EXTI0_IRQHandler(void);
  67.   
  68.   //4.Watch中观察
  69.   无动作------蓝灯闪烁    主程序正常运行中
  70.   SleepNow,SleepOnExti,
  71.   按下Sel-----绿灯翻转    进入指定模式
  72.   按下Key1----红灯翻转    唤醒
  73.   Stopping,
  74.   按下Sel-----绿灯翻转    进入指定模式
  75.   按下Key1----红灯翻转    唤醒，时钟变慢(开启或处于低功耗模式(PWR_CR)的设定)
  76.   Standby
  77.   按下Sel-----灯全灭      进入指定模式
  78.   按下Key1----红灯翻转    唤醒
  79.   */

  81. #ifndef __NVIC_CM3LPMODES_H
  82. #define __NVIC_CM3LPMODES_H
  83. /* Includes ------------------------------------------------------------------*/
  84. #include "std32periph.h"

  86. /* Private typedef -----------------------------------------------------------*/
  87. typedef enum
  88. {
  89.   Normal = 0,
  90.   SleepNow = 1,
  91.   SleepOnExti = 2,
  92.   Stopping = 3,
  93.   Standby = 4
  94. }RunMode;
  95. /* Private define ------------------------------------------------------------*/
  96.   #define GPIO_LED      GPIOF   
  97.   #define RCC_LED       RCC_APB2Periph_GPIOF
  98.   #define RCC_EXTI      RCC_APB2Periph_GPIOB
  99. /* Private macro -------------------------------------------------------------*/
  100. /* Private variables ---------------------------------------------------------*/
  101. EXTI_InitTypeDef EXTI_InitStructure;
  102. RunMode rm;
  103. u8 LowPowerMode;
  104. /* Private functions ---------------------------------------------------------*/

  106. void Delay(vu32 nCount)
  107. {
  108.   for(; nCount != 0; nCount--);
  109. }

  111. void fmain(void)
  112. {
  113.   RCC_HSEConf(9);//72M
  114.   
  115.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_LED | RCC_EXTI | RCC_APB2Periph_AFIO, ENABLE);

  117.   //GPIO_LED
  118.   GPIO_InitTypeDef GPIO_InitStructure;
  119.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_8 | GPIO_Pin_9;
  120.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  121.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  122.   GPIO_Init(GPIO_LED, &GPIO_InitStructure);
  123.   //GPIO_WakeUp
  124.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  125.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  126.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  127.   //GPIO_EXTI
  128.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  129.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  130.   GPIO_Init(GPIOB, &GPIO_InitStructure);

  132.   // Connect EXTI Line0 to PA.00
  133.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);
  134.   EXTI_InitStructure.EXTI_Line = EXTI_Line0;
  135.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  136.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
  137.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  138.   EXTI_Init(&EXTI_InitStructure);
  139.   // Connect EXTI Line11 to PB.11
  140.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource11);  
  141.   EXTI_InitStructure.EXTI_Line = EXTI_Line11;
  142.   EXTI_Init(&EXTI_InitStructure);
  143.   
  144.   NVIC_GroupSet(NVIC_PriorityGroup_0, EXTI15_10_IRQn, 1);
  145.   NVIC_GroupSet(NVIC_PriorityGroup_0, EXTI0_IRQn, 0);
  146.   
  147.   GPIO_ResetBits(GPIO_LED, GPIO_Pin_6);
  148.   rm = SleepNow;//Normal, SleepNow, SleepOnExti(没有成功), Stopping, Standby
  149.   while (1)
  150.   {
  151.     if(LowPowerMode == 1)
  152.     {
  153.       LowPowerMode = 0;
  154.       GPIO_WriteBit(GPIO_LED, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_6)));
  155.       
  156.       //SCB->SCR[4:0] == SEVONPEND,0,SLEEPDEEP,SLEEPONEXIT,0
  157.       switch(rm)
  158.       {
  159.       case SleepNow:
  160.         SCB->SCR &= 0xFFFFFFF0;//SLEEPDEEP = 0 , SLEEPONEXIT = 0
  161.         __WFE();
  162.         break;
  163.       case SleepOnExti:
  164.         SCB->SCR &= 0xFFFFFFF2;//SLEEPDEEP = 0 , SLEEPONEXIT = 1
  165.         SCB->SCR |= 0x00000002;
  166.         __WFE();
  167.         break;
  168.       case Stopping:
  169.         RCC->APB1ENR |= 0x10000000;//PWREN：电源接口时钟使能
  170.         SCB->SCR |= 0x00000004;//SLEEPDEEP = 1
  171.         PWR->CR &= 0x1FD;//PWR_CR中清除PDDS位 , 设置LPDS位
  172.         PWR->CR |= 0x001;
  173.         __WFE();
  174.         break;
  175.       case Standby:
  176.         RCC->APB1ENR |= 0x10000000;//PWREN：电源接口时钟使能
  177.         PWR->CSR |= 0x100;//PWR_CSR中设置EWUP位(WakeUp引脚PA0)
  178.         SCB->SCR |= 0x00000004;//SLEEPDEEP = 1
  179.         PWR->CR |= 0x006;//PWR_CR中设置PDDS位 , CWUF位
  180.         __WFE();
  181.         break;
  182.       default:
  183.         break;
  184.       }
  185.     }

  187.     Delay(0xFFFFF);
  188.     GPIO_WriteBit(GPIO_LED, GPIO_Pin_9, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_9)));
  189.   }
  190. }

  192. #endif
  193. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:19:03
  1. /**
  2.   ******************************************************************************
  3.   * @file /PWR_STANDBY.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-19
  7.   * @brief    PWR：待机模式
  8.   WFE事件  新来的中断、之前悬起的中断等(比较容易唤醒)
  9.   WFI中断  
  10.   ******************************************************************************
  11.   *用途：
  12.   3.待机模式：可实现系统的最低功耗
  13.     进入：
  14.       设置CM3系中的SLEEPDEEP位 , PWR_CR中设置PDDS位 , CWUF位
  15.       然后执行WFI(等待中断)或WFE(等待事件)指令
  16.     唤醒：WKUP引脚的上升沿、RTC闹钟事件、NRST引脚上的外部复位、IWDG复位
  17.     唤醒延时：复位阶段时电压调节器的启动

  19.   SCB->SCR[4:0] == SEVONPEND,0,SLEEPDEEP,SLEEPONEXIT,0
  20.   */
  21.   /*实例应用步骤：
  22.   //1."main.cpp"调用fmain()
  23.   
  24.   //2."stm32f10x_it.cpp"拷贝
  25.   void SysTick_Handler(void)
  26.   {
  27.     #if defined __PWR_STANDBY
  28.       GPIO_WriteBit(GPIOF, GPIO_Pin_6, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_6)));
  29.     #endif
  30.   }
  31.   void EXTI15_10_IRQHandler(void)
  32.   {
  33.     if(EXTI_GetITStatus(EXTI_Line11) != RESET)
  34.     {
  35.       #if defined __PWR_STANDBY
  36.         GPIO_SetBits(GPIOF, GPIO_Pin_6);
  37.         RTC_ClearFlag(RTC_FLAG_SEC);
  38.         while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);// Wait till RTC Second event occurs
  39.         RTC_SetAlarm(RTC_GetCounter()+ 3);// Set the RTC Alarm after 3s
  40.         RTC_WaitForLastTask();
  41.         //PWR_EnterSTANDBYMode();
  42.         SCB->SCR |= 0x00000004;//SLEEPDEEP = 1
  43.         PWR->CR |= 0x006;//PWR_CR中设置PDDS位 , CWUF位
  44.         __WFE();
  45.       #endif
  46.       EXTI_ClearITPendingBit(EXTI_Line11);
  47.     }
  48.   }
  49.   
  50.   //3."stm32f10x_it.h"声明
  51.   #define __PWR_STANDBY
  52.   void EXTI15_10_IRQHandler(void);
  53.   void SysTick_Handler(void);
  54.   
  55.   //4.Watch中观察
  56.   LED绿灯闪烁
  57.   按下Sel后进入待机模式，3s后RTC闹钟唤醒，黄灯点亮
  58.   */

  60. #ifndef __PWR_STANDBY_H
  61. #define __PWR_STANDBY_H
  62. /* Includes ------------------------------------------------------------------*/
  63. #include "std32periph.h"

  65. /* Private typedef -----------------------------------------------------------*/
  66. /* Private define ------------------------------------------------------------*/
  67.   #define GPIO_LED      GPIOF   
  68.   #define RCC_LED       RCC_APB2Periph_GPIOF
  69.   #define RCC_EXTI      RCC_APB2Periph_GPIOB
  70. /* Private macro -------------------------------------------------------------*/
  71. /* Private variables ---------------------------------------------------------*/
  72. /* Private functions ---------------------------------------------------------*/

  74. void RTC_Configuration(void)
  75. {
  76.   if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET)/* System resumed from STANDBY mode */
  77.   {
  78.    
  79.     GPIO_SetBits(GPIO_LED, GPIO_Pin_7);

  81.     /* Clear StandBy flag */
  82.     PWR_ClearFlag(PWR_FLAG_SB);

  84.     RTC_WaitForSynchro();
  85.   }
  86.   else
  87.   {
  88.     /* StandBy flag is not set */
  89.     /* RTC clock source configuration ----------------------------------------*/
  90.     BKP_DeInit();
  91.   
  92.     RCC_LSEConfig(RCC_LSE_ON);
  93.     while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
  94.     {
  95.     }

  97.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
  98.     RCC_RTCCLKCmd(ENABLE);

  100.     /* RTC configuration -----------------------------------------------------*/
  101.     RTC_WaitForSynchro();
  102.     /* Set the RTC time base to 1s */
  103.     RTC_SetPrescaler(32767);  
  104.     RTC_WaitForLastTask();
  105.   }
  106. }

  108. void fmain(void)
  109. {
  110.   RCC_HSEConf(9);//72M
  111.   
  112.   RCC_APB2PeriphClockCmd(RCC_EXTI | RCC_LED | RCC_APB2Periph_AFIO, ENABLE);
  113.   
  114.   GPIO_InitTypeDef GPIO_InitStructure;
  115.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  116.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  117.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  118.   GPIO_Init(GPIO_LED, &GPIO_InitStructure);

  120.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  121.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  122.   GPIO_Init(GPIOB, &GPIO_InitStructure);  

  124.   GPIO_SetBits(GPIO_LED, GPIO_Pin_6);
  125.   
  126.   
  127.   /* Enable PWR and BKP clock */
  128.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
  129.   /* Enable WKUP pin */
  130.   PWR_WakeUpPinCmd(ENABLE);
  131.   /* Allow access to BKP Domain */
  132.   PWR_BackupAccessCmd(ENABLE);

  134.   /* Configure RTC clock source and prescaler */
  135.   RTC_Configuration();

  137.   /* Configure EXTI Line to generate an interrupt on falling edge */
  138.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource11);
  139.   EXTI_InitTypeDef EXTI_InitStructure;
  140.   EXTI_InitStructure.EXTI_Line = EXTI_Line11;
  141.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  142.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
  143.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  144.   EXTI_Init(&EXTI_InitStructure);  

  146.   NVIC_GroupSet(NVIC_PriorityGroup_0, EXTI15_10_IRQn, 1);

  148.   /* Configure SysTick to generate an interrupt each 250ms */
  149.   SysTick->LOAD = 250000*9;
  150.   SysTick->VAL = 0x00;//清空计数器
  151.   /* ---------------------------------------------------------------------
  152.   SysTick 控制与状态寄存器的位
  153.   SysTick->CTRL: CountFlag【16】,CLKSource【2】,TickINT【1】,ENABLE【0】
  154.   --------------------------------------------------------------------- */
  155.   //CLKSource【2】=0  使用外部时钟源HCLK(1:内核时钟HCLK/8)
  156.   //  TickINT【1】=0  向下计数至0，不会挂起Systick(1:至0会挂起Systick)
  157.   //   ENABLE【0】=0  禁止计数器（1:使能，至0将CountFlag置1）
  158.   SysTick->CTRL = 0x00003;
  159. }

  161. #endif
  162. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:19:19
  1. /**
  2.   ******************************************************************************
  3.   * @file /PWR_STOP.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-19
  7.   * @brief    PWR：停机模式
  8.   WFE事件  新来的中断、之前悬起的中断等(比较容易唤醒)
  9.   WFI中断  
  10.   ******************************************************************************
  11.   *用途：
  12.   2.停机模式
  13.     进入：
  14.       设置CM3中的SLEEPDEEP位 , PWR_CR中清除PDDS位 , 设置LPDS位
  15.       然后执行WFI(等待中断)或WFE(等待事件)指令
  16.     唤醒：任意外部中断可唤醒
  17.     唤醒延时：HSI RC唤醒时间 + 电压调节器从低功耗唤醒的时间

  19.   SCB->SCR[4:0] == SEVONPEND,0,SLEEPDEEP,SLEEPONEXIT,0
  20.   */
  21.   /*实例应用步骤：
  22.   //1."main.cpp"调用fmain()
  23.   
  24.   //2."stm32f10x_it.cpp"拷贝
  25.   #ifdef  __PWR_STOP
  26.   void RTCAlarm_IRQHandler(void)
  27.   {
  28.     if(RTC_GetITStatus(RTC_IT_ALR) != RESET)
  29.     {
  30.       GPIO_WriteBit(GPIOF, GPIO_Pin_8, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOF, GPIO_Pin_8)));
  31.   
  32.       EXTI_ClearITPendingBit(EXTI_Line17);
  33.   
  34.       if(PWR_GetFlagStatus(PWR_FLAG_WU) != RESET)
  35.       {
  36.         PWR_ClearFlag(PWR_FLAG_WU);
  37.       }
  38.   
  39.       RTC_WaitForLastTask();   
  40.   
  41.       RTC_ClearITPendingBit(RTC_IT_ALR);
  42.   
  43.       RTC_WaitForLastTask();
  44.     }
  45.   }
  46.   #endif
  47.   
  48.   //3."stm32f10x_it.h"声明
  49.   #define __PWR_STOP
  50.   void RTCAlarm_IRQHandler(void);
  51.   
  52.   //4.Watch中观察
  53.   LED绿灯变化
  54.   进入停机模式，3s后RTC闹钟唤醒，红灯点亮，循环
  55.   */

  57. #ifndef __PWR_STOP_H
  58. #define __PWR_STOP_H
  59. /* Includes ------------------------------------------------------------------*/
  60. #include "std32periph.h"

  62. /* Private typedef -----------------------------------------------------------*/
  63. /* Private define ------------------------------------------------------------*/
  64.   #define GPIO_LED      GPIOF   
  65.   #define RCC_LED       RCC_APB2Periph_GPIOF
  66. /* Private macro -------------------------------------------------------------*/
  67. /* Private variables ---------------------------------------------------------*/
  68. /* Private functions ---------------------------------------------------------*/

  70. void SYSCLKConfig_STOP(void)
  71. {
  72.   /* Enable HSE */
  73.   RCC_HSEConfig(RCC_HSE_ON);

  75.   /* Wait till HSE is ready */
  76.   ErrorStatus HSEStartUpStatus;
  77.   HSEStartUpStatus = RCC_WaitForHSEStartUp();

  79.   if(HSEStartUpStatus == SUCCESS)
  80.   {
  81.     /* Enable PLL */
  82.     RCC_PLLCmd(ENABLE);

  84.     /* Wait till PLL is ready */
  85.     while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
  86.     {
  87.     }

  89.     /* Select PLL as system clock source */
  90.     RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

  92.     /* Wait till PLL is used as system clock source */
  93.     while(RCC_GetSYSCLKSource() != 0x08)
  94.     {
  95.     }
  96.   }
  97. }

  99. void RTC_Configuration(void)
  100. {
  101.   /* RTC clock source configuration ------------------------------------------*/
  102.   /* Reset Backup Domain */
  103.   BKP_DeInit();
  104.   
  105.   /* Enable the LSE OSC */
  106.   RCC_LSEConfig(RCC_LSE_ON);
  107.   /* Wait till LSE is ready */
  108.   while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
  109.   {
  110.   }

  112.   /* Select the RTC Clock Source */
  113.   RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);

  115.   /* Enable the RTC Clock */
  116.   RCC_RTCCLKCmd(ENABLE);

  118.   /* RTC configuration -------------------------------------------------------*/
  119.   /* Wait for RTC APB registers synchronisation */
  120.   RTC_WaitForSynchro();

  122.   /* Set the RTC time base to 1s */
  123.   RTC_SetPrescaler(32767);  
  124.   /* Wait until last write operation on RTC registers has finished */
  125.   RTC_WaitForLastTask();

  127.   /* Enable the RTC Alarm interrupt */
  128.   RTC_ITConfig(RTC_IT_ALR, ENABLE);
  129.   /* Wait until last write operation on RTC registers has finished */
  130.   RTC_WaitForLastTask();
  131. }


  134. void fmain(void)
  135. {
  136.   RCC_HSEConf(9);//72M
  137.   
  138.   RCC_APB2PeriphClockCmd(RCC_LED | RCC_APB2Periph_AFIO, ENABLE);
  139.   
  140.   GPIO_InitTypeDef GPIO_InitStructure;
  141.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_8;
  142.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  143.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  144.   GPIO_Init(GPIO_LED, &GPIO_InitStructure);


  147.   /* Configure EXTI Line17(RTC Alarm) to generate an interrupt on rising edge */
  148.   EXTI_ClearITPendingBit(EXTI_Line17);
  149.   EXTI_InitTypeDef EXTI_InitStructure;
  150.   EXTI_InitStructure.EXTI_Line = EXTI_Line17;
  151.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  152.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  153.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  154.   EXTI_Init(&EXTI_InitStructure);

  156.   
  157.   /* Enable PWR and BKP clock */
  158.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
  159.   /* Allow access to BKP Domain */
  160.   PWR_BackupAccessCmd(ENABLE);
  161.   /* Configure RTC clock source and prescaler */
  162.   RTC_Configuration();


  165.   NVIC_GroupSet(NVIC_PriorityGroup_0, RTCAlarm_IRQn, 0);

  167.   GPIO_SetBits(GPIO_LED, GPIO_Pin_6);
  168.   
  169.   while (1)
  170.   {
  171.     /* Insert 1.5 second delay */
  172.     Delay_us(1.5e6, 72);

  174.    
  175.     RTC_ClearFlag(RTC_FLAG_SEC);
  176.     while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

  178.     RTC_SetAlarm(RTC_GetCounter()+ 3);
  179.     RTC_WaitForLastTask();


  182.     GPIO_ResetBits(GPIO_LED, GPIO_Pin_6);


  185.     //PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
  186.     RCC->APB1ENR |= 0x10000000;//PWREN：电源接口时钟使能
  187.     SCB->SCR |= 0x00000004;//SLEEPDEEP = 1
  188.     PWR->CR &= 0x1FD;//PWR_CR中清除PDDS位 , 设置LPDS位
  189.     PWR->CR |= 0x001;
  190.     __WFI();
  191.    

  193.     GPIO_SetBits(GPIO_LED, GPIO_Pin_6);

  195.     SYSCLKConfig_STOP();
  196.   }
  197. }

  199. #endif
  200. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:19:38
  1. /**
  2.   ******************************************************************************
  3.   * @file /SPI_Example.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-5-16
  7.   * @brief    SPI：
  8.   ******************************************************************************
  9.   *用途：
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()

  14.   //2.Watch中观察
  15.   Tx_Buffer:Rx_Buffer
  16.   */

  18. #ifndef __SPI_EXAMPLE_H
  19. #define __SPI_EXAMPLE_H
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "std32periph.h"

  23. /* Private typedef -----------------------------------------------------------*/
  24. typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
  25. /* Private define ------------------------------------------------------------*/
  26.   #define GPIO_CS           GPIOB
  27.   #define RCC_CS            RCC_APB2Periph_GPIOB
  28.   #define Pin_CS            GPIO_Pin_2
  29.   #define SPI_FLASH_CS_LOW()       GPIO_ResetBits(GPIO_CS, Pin_CS)
  30.   #define SPI_FLASH_CS_HIGH()      GPIO_SetBits(GPIO_CS, Pin_CS)

  32.   #define  FLASH_WriteAddress     0x700000
  33.   #define  FLASH_ReadAddress      FLASH_WriteAddress
  34.   #define  FLASH_SectorToErase    FLASH_WriteAddress
  35.   #define  M25P64_FLASH_ID        0x202017
  36.   #define  BufferSize (countof(Tx_Buffer)-1)

  38.   #define SPI_FLASH_PageSize    0x100
  39.   #define WRITE      0x02  /* Write to Memory instruction */
  40.   #define WRSR       0x01  /* Write Status Register instruction */
  41.   #define WREN       0x06  /* Write enable instruction */
  42.   #define READ       0x03  /* Read from Memory instruction */
  43.   #define RDSR       0x05  /* Read Status Register instruction  */
  44.   #define RDID       0x9F  /* Read identification */
  45.   #define SE         0xD8  /* Sector Erase instruction */
  46.   #define BE         0xC7  /* Bulk Erase instruction */
  47.   #define WIP_Flag   0x01  /* Write In Progress (WIP) flag */
  48.   #define Dummy_Byte 0xA5
  49. /* Private macro -------------------------------------------------------------*/
  50.   #define countof(a) (sizeof(a) / sizeof(*(a)))  
  51. /* Private variables ---------------------------------------------------------*/
  52.   u8 Tx_Buffer[] = "STM32F10x SPI Firmware Library Example: communication with an M25P64 SPI FLASH";
  53.   u8 Index, Rx_Buffer[BufferSize];
  54.   volatile TestStatus TransferStatus1 = FAILED, TransferStatus2 = PASSED;
  55.   vu32 FLASH_ID = 0;
  56. /* Private functions ---------------------------------------------------------*/
  57.   TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength);
  58.   /*----- High layer function -----*/
  59.   void SPI_FLASH_Init(void);
  60.   void SPI_FLASH_SectorErase(u32 SectorAddr);
  61.   void SPI_FLASH_BulkErase(void);
  62.   void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
  63.   void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
  64.   void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
  65.   u32 SPI_FLASH_ReadID(void);
  66.   void SPI_FLASH_StartReadSequence(u32 ReadAddr);
  67.   /*----- Low layer function -----*/
  68.   u8 SPI_FLASH_ReadByte(void);
  69.   u8 SPI_FLASH_SendByte(u8 byte);
  70.   u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
  71.   void SPI_FLASH_WriteEnable(void);
  72.   void SPI_FLASH_WaitForWriteEnd(void);

  74.   
  75. void fmain(void)
  76. {
  77.   RCC_HSEConf(9);//72M
  78.   
  79.   /* Initialize the SPI FLASH driver */
  80.   SPI_FLASH_Init();

  82.     /* Perform a write in the Flash followed by a read of the written data */
  83.   /* Erase SPI FLASH Sector to write on */
  84.   SPI_FLASH_SectorErase(FLASH_SectorToErase);

  86.   /* Write Tx_Buffer data to SPI FLASH memory */
  87.   SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);

  89.   /* Read data from SPI FLASH memory */
  90.   SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);

  92.   /* Check the corectness of written dada */
  93.   TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
  94.   /* TransferStatus1 = PASSED, if the transmitted and received data by SPI1
  95.      are the same */
  96.   /* TransferStatus1 = FAILED, if the transmitted and received data by SPI1
  97.      are different */

  99.   /* Perform an erase in the Flash followed by a read of the written data */
  100.   /* Erase SPI FLASH Sector to write on */
  101.   SPI_FLASH_SectorErase(FLASH_SectorToErase);

  103.   /* Read data from SPI FLASH memory */
  104.   SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);

  106.   /* Check the corectness of erasing operation dada */
  107.   for (Index = 0; Index < BufferSize; Index++)
  108.   {
  109.     if (Rx_Buffer[Index] != 0xFF)
  110.     {
  111.       TransferStatus2 = FAILED;
  112.     }
  113.   }
  114.   /* TransferStatus2 = PASSED, if the specified sector part is erased */
  115.   /* TransferStatus2 = FAILED, if the specified sector part is not well erased  */
  116. }

  118. void SPI_FLASH_Init(void)
  119. {
  120.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_GPIOA |
  121.                          RCC_CS, ENABLE);

  123.   GPIO_InitTypeDef GPIO_InitStructure;
  124.   /* Configure SPI1 pins: SCK, MISO and MOSI */
  125.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
  126.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  127.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  128.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  129.   /* Configure I/O for Flash Chip select */
  130.   GPIO_InitStructure.GPIO_Pin = Pin_CS;
  131.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  132.   GPIO_Init(GPIO_CS, &GPIO_InitStructure);
  133.   /* Deselect the FLASH: Chip Select high */
  134.   SPI_FLASH_CS_HIGH();

  136.   /* SPI1 configuration */
  137.   SPI_InitTypeDef  SPI_InitStructure;
  138.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  139.   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  140.   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  141.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  142.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  143.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  144.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  145.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  146.   SPI_InitStructure.SPI_CRCPolynomial = 7;
  147.   SPI_Init(SPI1, &SPI_InitStructure);
  148.   /* Enable SPI1  */
  149.   SPI_Cmd(SPI1, ENABLE);
  150. }

  152. void SPI_FLASH_SectorErase(u32 SectorAddr)
  153. {
  154.   /* Send write enable instruction */
  155.   SPI_FLASH_WriteEnable();

  157.   /* Sector Erase */
  158.   /* Select the FLASH: Chip Select low */
  159.   SPI_FLASH_CS_LOW();
  160.   /* Send Sector Erase instruction */
  161.   SPI_FLASH_SendByte(SE);
  162.   /* Send SectorAddr high nibble address byte */
  163.   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  164.   /* Send SectorAddr medium nibble address byte */
  165.   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  166.   /* Send SectorAddr low nibble address byte */
  167.   SPI_FLASH_SendByte(SectorAddr & 0xFF);
  168.   /* Deselect the FLASH: Chip Select high */
  169.   SPI_FLASH_CS_HIGH();

  171.   /* Wait the end of Flash writing */
  172.   SPI_FLASH_WaitForWriteEnd();
  173. }

  175. void SPI_FLASH_BulkErase(void)
  176. {
  177.   /* Send write enable instruction */
  178.   SPI_FLASH_WriteEnable();

  180.   /* Bulk Erase */
  181.   /* Select the FLASH: Chip Select low */
  182.   SPI_FLASH_CS_LOW();
  183.   /* Send Bulk Erase instruction  */
  184.   SPI_FLASH_SendByte(BE);
  185.   /* Deselect the FLASH: Chip Select high */
  186.   SPI_FLASH_CS_HIGH();

  188.   /* Wait the end of Flash writing */
  189.   SPI_FLASH_WaitForWriteEnd();
  190. }

  192. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
  193. {
  194.   /* Enable the write access to the FLASH */
  195.   SPI_FLASH_WriteEnable();

  197.   /* Select the FLASH: Chip Select low */
  198.   SPI_FLASH_CS_LOW();
  199.   /* Send "Write to Memory " instruction */
  200.   SPI_FLASH_SendByte(WRITE);
  201.   /* Send WriteAddr high nibble address byte to write to */
  202.   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  203.   /* Send WriteAddr medium nibble address byte to write to */
  204.   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  205.   /* Send WriteAddr low nibble address byte to write to */
  206.   SPI_FLASH_SendByte(WriteAddr & 0xFF);

  208.   /* while there is data to be written on the FLASH */
  209.   while (NumByteToWrite--)
  210.   {
  211.     /* Send the current byte */
  212.     SPI_FLASH_SendByte(*pBuffer);
  213.     /* Point on the next byte to be written */
  214.     pBuffer++;
  215.   }

  217.   /* Deselect the FLASH: Chip Select high */
  218.   SPI_FLASH_CS_HIGH();

  220.   /* Wait the end of Flash writing */
  221.   SPI_FLASH_WaitForWriteEnd();
  222. }

  224. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
  225. {
  226.   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;

  228.   Addr = WriteAddr % SPI_FLASH_PageSize;
  229.   count = SPI_FLASH_PageSize - Addr;
  230.   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  231.   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

  233.   if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned  */
  234.   {
  235.     if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
  236.     {
  237.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  238.     }
  239.     else /* NumByteToWrite > SPI_FLASH_PageSize */
  240.     {
  241.       while (NumOfPage--)
  242.       {
  243.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  244.         WriteAddr +=  SPI_FLASH_PageSize;
  245.         pBuffer += SPI_FLASH_PageSize;
  246.       }

  248.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  249.     }
  250.   }
  251.   else /* WriteAddr is not SPI_FLASH_PageSize aligned  */
  252.   {
  253.     if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
  254.     {
  255.       if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
  256.       {
  257.         temp = NumOfSingle - count;

  259.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  260.         WriteAddr +=  count;
  261.         pBuffer += count;

  263.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
  264.       }
  265.       else
  266.       {
  267.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  268.       }
  269.     }
  270.     else /* NumByteToWrite > SPI_FLASH_PageSize */
  271.     {
  272.       NumByteToWrite -= count;
  273.       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  274.       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

  276.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  277.       WriteAddr +=  count;
  278.       pBuffer += count;

  280.       while (NumOfPage--)
  281.       {
  282.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  283.         WriteAddr +=  SPI_FLASH_PageSize;
  284.         pBuffer += SPI_FLASH_PageSize;
  285.       }

  287.       if (NumOfSingle != 0)
  288.       {
  289.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  290.       }
  291.     }
  292.   }
  293. }

  295. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
  296. {
  297.   /* Select the FLASH: Chip Select low */
  298.   SPI_FLASH_CS_LOW();

  300.   /* Send "Read from Memory " instruction */
  301.   SPI_FLASH_SendByte(READ);

  303.   /* Send ReadAddr high nibble address byte to read from */
  304.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  305.   /* Send ReadAddr medium nibble address byte to read from */
  306.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  307.   /* Send ReadAddr low nibble address byte to read from */
  308.   SPI_FLASH_SendByte(ReadAddr & 0xFF);

  310.   while (NumByteToRead--) /* while there is data to be read */
  311.   {
  312.     /* Read a byte from the FLASH */
  313.     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
  314.     /* Point to the next location where the byte read will be saved */
  315.     pBuffer++;
  316.   }

  318.   /* Deselect the FLASH: Chip Select high */
  319.   SPI_FLASH_CS_HIGH();
  320. }

  322. u32 SPI_FLASH_ReadID(void)
  323. {
  324.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;

  326.   /* Select the FLASH: Chip Select low */
  327.   SPI_FLASH_CS_LOW();

  329.   /* Send "RDID " instruction */
  330.   SPI_FLASH_SendByte(0x9F);

  332.   /* Read a byte from the FLASH */
  333.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);

  335.   /* Read a byte from the FLASH */
  336.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);

  338.   /* Read a byte from the FLASH */
  339.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);

  341.   /* Deselect the FLASH: Chip Select high */
  342.   SPI_FLASH_CS_HIGH();

  344.   Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;

  346.   return Temp;
  347. }

  349. void SPI_FLASH_StartReadSequence(u32 ReadAddr)
  350. {
  351.   /* Select the FLASH: Chip Select low */
  352.   SPI_FLASH_CS_LOW();

  354.   /* Send "Read from Memory " instruction */
  355.   SPI_FLASH_SendByte(READ);

  357.   /* Send the 24-bit address of the address to read from -----------------------*/
  358.   /* Send ReadAddr high nibble address byte */
  359.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  360.   /* Send ReadAddr medium nibble address byte */
  361.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  362.   /* Send ReadAddr low nibble address byte */
  363.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  364. }

  366. u8 SPI_FLASH_ReadByte(void)
  367. {
  368.   return (SPI_FLASH_SendByte(Dummy_Byte));
  369. }

  371. u8 SPI_FLASH_SendByte(u8 byte)
  372. {
  373.   /* Loop while DR register in not emplty */
  374.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);

  376.   /* Send byte through the SPI1 peripheral */
  377.   SPI_I2S_SendData(SPI1, byte);

  379.   /* Wait to receive a byte */
  380.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  382.   /* Return the byte read from the SPI bus */
  383.   return SPI_I2S_ReceiveData(SPI1);
  384. }

  386. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
  387. {
  388.   /* Loop while DR register in not emplty */
  389.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);

  391.   /* Send Half Word through the SPI1 peripheral */
  392.   SPI_I2S_SendData(SPI1, HalfWord);

  394.   /* Wait to receive a Half Word */
  395.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  397.   /* Return the Half Word read from the SPI bus */
  398.   return SPI_I2S_ReceiveData(SPI1);
  399. }

  401. void SPI_FLASH_WriteEnable(void)
  402. {
  403.   /* Select the FLASH: Chip Select low */
  404.   SPI_FLASH_CS_LOW();

  406.   /* Send "Write Enable" instruction */
  407.   SPI_FLASH_SendByte(WREN);

  409.   /* Deselect the FLASH: Chip Select high */
  410.   SPI_FLASH_CS_HIGH();
  411. }

  413. void SPI_FLASH_WaitForWriteEnd(void)
  414. {
  415.   u8 FLASH_Status = 0;

  417.   /* Select the FLASH: Chip Select low */
  418.   SPI_FLASH_CS_LOW();

  420.   /* Send "Read Status Register" instruction */
  421.   SPI_FLASH_SendByte(RDSR);

  423.   /* Loop as long as the memory is busy with a write cycle */
  424.   do
  425.   {
  426.     /* Send a dummy byte to generate the clock needed by the FLASH
  427.     and put the value of the status register in FLASH_Status variable */
  428.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);

  430.   }
  431.   while ((FLASH_Status & WIP_Flag) == SET); /* Write in progress */

  433.   /* Deselect the FLASH: Chip Select high */
  434.   SPI_FLASH_CS_HIGH();
  435. }

  437. TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength)
  438. {
  439.   while (BufferLength--)
  440.   {
  441.     if (*pBuffer1 != *pBuffer2)
  442.     {
  443.       return FAILED;
  444.     }

  446.     pBuffer1++;
  447.     pBuffer2++;
  448.   }

  450.   return PASSED;
  451. }

  453. #endif
  454. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
wolfgang2015 回答时间：2016-1-7 15:25:19
Dylan疾风闪电 发表于 2016-1-7 15:12

@file /EXTI_Example.h

检测下降沿触发中断，不过似乎没有处理按键抖动的问题，会出现释放按键后，有闪亮的情况.....
赞 评论

所属标签

STM32团队

STM32团队

意法半导体微控制器和微处理器拥有广泛的产品线，包含低成本的8位单片机和基于ARM® Cortex®-M0、M0+、M3、M4、M33、M7及A7内核并具备丰富外设选择的32位微控制器及微处理器

最新内容

相似技术帖

官网相关资源

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
微信公众号二维码 微信公众号
手机版二维码 手机版